Prenez les nombres 0, 1, 2, 3, 4, ...et disposez-les dans une spirale dans le sens des aiguilles d'une montre, en commençant vers le bas, en écrivant chaque chiffre dans son propre carré séparé.

Puis, étant donné l'un des quatre caractères ASCII distincts et cohérents (votre choix) représentant un axe et un entier d'entrée n, sortez les premiers ntermes de la séquence décrite en sélectionnant des carrés le long de l'axe correspondant.

Par exemple, ci-dessous se trouve la spirale arrangée jusqu'à mi-parcours 29. Supposons que nous utilisons u / d / l / rpour nos quatre caractères, représentant up / down / left / right. Puis, uen entrée, nous sortons 0, 5, 1, 4 ...(l'axe y positif) jusqu'au ne terme. Si on nous donnait plutôt lcomme entrée, ce serait 0, 3, 1, 1 ...jusqu'au nterme.

  2---3---2---4---2---5---2
  |                       |
  2   1---3---1---4---1   6
  |   |               |   |
  2   2   4---5---6   5   2
  |   |   |       |   |   |
  1   1   3   0   7   1   7
  |   |   |   |   |   |   |
  2   1   2---1   8   6   2
  |   |           |   |   |
  0   1---0---1---9   1   8
  |                   |   |
  2---9---1---8---1---7   2

Ce sont des séquences sur OEIS:

• http://oeis.org/A033953 pour l'axe x positif
• http://oeis.org/A033988 pour l'axe y positif
• http://oeis.org/A033989 pour l'axe x négatif
• http://oeis.org/A033990 pour l'axe y négatif

Exemples

d 19
[0, 1, 1, 8, 3, 7, 6, 2, 1, 5, 1, 1, 6, 2, 2, 1, 3, 4, 0]

r 72
[0, 7, 1, 7, 4, 2, 8, 1, 1, 3, 1, 2, 0, 2, 3, 1, 3, 4, 6, 5, 5, 5, 7, 7, 8, 8, 9, 6, 8, 1, 1, 1, 2, 3, 1, 8, 0, 6, 1, 7, 0, 9, 2, 8, 4, 3, 2, 1, 1, 7, 2, 6, 2, 1, 3, 3, 5, 5, 3, 2, 2, 0, 4, 3, 2, 5, 4, 6, 5, 0, 5, 1]

u 1
[0]

Règles

• Le cas échéant, vous pouvez supposer que l'entrée / sortie s'adaptera au type Integer natif de votre langue.
• Si vous utilisez des entiers pour représenter les quatre axes, vous pouvez utiliser des entiers négatifs sans enfreindre les règles.
• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Python 2 , 94 89 84 83 74 72 70 octets

J'ai utilisé WolframAlpha et déterminé qu'une limite supérieure de 5 ⁿ > 4n ² + 3n semble être suffisante. Il peut être changé à 9 ⁿ sans frais. Pour essayer des entrées plus grandes, utilisez 9*n*nau lieu de 5**npour éviter de manquer de mémoire.

lambda d,n:["".join(map(str,range(5**n)))[x*(4*x+d)]for x in range(n)]

Essayez-le en ligne!

Les entrées pour les directions sont:

• 3: à droite
• -3: vers le bas
• -1: gauche
• 1: haut

Enregistré 14 octets grâce à Rod
Enregistré 2 octets grâce à Jonathan Allan

MATL , 32 octets

tE1YLtn:qVXzw)3Lt3$)iX!w:qyfYm+)

L' entrée est n, aoù areprésente l'axe de la manière suivante:

• 0: la gauche;
• 1: en haut;
• 2: droite;
• 3: vers le bas.

La sortie est une chaîne.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Gelée ,  19  18 octets

Utilise l' astuce 5 ⁿ de la réponse Python de mbomb007

4,0jḅɗ@€ị5*D€FʋṖ0;

Un lien dyadique prenant nà gauche et det entier de:[-3,-1,1,3]:[v,<,^,>]

Essayez-le en ligne!

Une alternative de 20 octets qui est à la fois beaucoup plus rapide et qui ne se trompe pas pour un si petit n est:

²×5D€ƲFị@4,0jḅɗ@€Ṗ0;

Essayez-le en ligne!

Comment?

4,0jḅɗ@€ị5*D€FʋṖ0; - Link: integer, n; integer, d
     ɗ@€           - last three links as a dyad with sw@pped arguments for €ach (of implicit range [1,n])
4,0                -   literal list [4,0]
   j               -   join with d = [4,d,0]
    ḅ              -   convert from base n = 4*n^2+d*n+0
        ị          - index into...
              ʋ    - last four links as a monad:
         5         -   five
          *        -   exponentiate = 5^n
           D€      -   decimal list of each (in implicit range [1,5^n])
            F      -   flatten into a single list of the digits
               Ṗ   - pop (drop the final element)
                0; - prepend a zero

fonctionnera pour n considérable (comme +1000)

JavaScript (Node.js) , 104 octets

f=(d,n)=>--n?[...f(d,n),C(n*(4*n+d))]:[0]
C=(n,N=i=0)=>n>N?C(n-N,(p=10**i)*9*++i):+((p+--n/i|0)+"")[n%i]

Essayez-le en ligne!

Explication

• 3: à droite
• -3: bas (-3 est légitime selon les commentaires)
• -1: gauche
• 1: jusqu'à (comme @ mbomb007)

C- nième chiffre de la constante de Champernowne

________________________________________________________

Méthode moins efficace (ne fonctionnera pas pour 1000+)

JavaScript (Node.js) , 81 octets

f=(d,n)=>eval(`for(r=[],s=i=I="";I<n;)(s+=i++)[u=I*(4*I+d)]&&r.push(s[I++,u]),r`)

Essayez-le en ligne!

Stax , 13 octets

â╞ê←τ"(]]⌐┘?N

Exécuter et déboguer

Il prend l'entrée avec la direction, suivie par le compte. Droite, en haut, à gauche, et vers le bas sont 1, 3, 5et 7respectivement. Il faut une minute pour exécuter les trois cas de test fournis.