Prendi i numeri 0, 1, 2, 3, 4, ...e disponili in una spirale in senso orario, iniziando verso il basso, scrivendo ogni cifra nel suo quadrato separato.

Quindi, dato uno dei quattro caratteri ASCII distinti e coerenti (a scelta) che rappresentano un asse e un intero di input n, emettono i primi ntermini della sequenza descritta selezionando i quadrati lungo l'asse corrispondente.

Ad esempio, di seguito è riportata la spirale sistemata fino a metà 29. Supponiamo di usare u / d / l / rper i nostri quattro personaggi, che rappresentano up / down / left / right. Quindi, dato ucome input, produciamo 0, 5, 1, 4 ...(l'asse y positivo) fino al nth termine. Se invece ci venisse dato lcome input, allora sarebbe 0, 3, 1, 1 ...fino al nterzo termine.

  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

Queste sono sequenze su OEIS:

• http://oeis.org/A033953 per l'asse x positivo
• http://oeis.org/A033988 per l'asse y positivo
• http://oeis.org/A033989 per l'asse x negativo
• http://oeis.org/A033990 per l'asse y negativo

Esempi

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]

Regole

• Se applicabile, puoi supporre che l'input / output si adatti al tipo intero nativo della tua lingua.
• Se si utilizzano numeri interi per rappresentare i quattro assi, è possibile utilizzare numeri interi negativi senza infrangere le regole.
• L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Python 2 , 94 89 84 83 74 72 70 byte

Ho usato WolframAlpha e ho stabilito che un limite superiore di 5 ⁿ > 4n ² + 3n sembra essere sufficiente. Può essere modificato in 9 ⁿ senza alcun costo. Per provare input più grandi, utilizzare 9*n*ninvece di 5**nper evitare l'esaurimento della memoria.

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

Provalo online!

Gli input per le direzioni sono:

• 3: giusto
• -3: giù
• -1 a Sinistra
• 1: su

Salvato 14 byte grazie a Rod
Salvato 2 byte grazie a Jonathan Allan

MATL , 32 byte

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

Input è n, adove arappresenta l'asse come segue:

• 0: sinistra;
• 1: su;
• 2: giusto;
• 3: giù.

L'output è una stringa.

Provalo online! Oppure verifica tutti i casi di test .

Gelatina ,  19  18 byte

Usa il trucco 5 ⁿ dalla risposta Python di mbomb007

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

Un collegamento diadico che prende na sinistra de intero da:[-3,-1,1,3]:[v,<,^,>]

Provalo online!

Un'alternativa di 20 byte che è sia molto più veloce che non segfault per una così piccola n è:

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

Provalo online!

Come?

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

funzionerà per n considerevole (come +1000)

JavaScript (Node.js) , 104 byte

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]

Provalo online!

Spiegazione

• 3: giusto
• -3: giù (-3 è legittimo secondo i commenti)
• -1 a Sinistra
• 1: su (come @ mbomb007)

C-ennesima cifra della costante di Champernowne

________________________________________________________

Metodo meno efficiente (non funzionerà per oltre 1000)

JavaScript (Node.js) , 81 byte

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

Provalo online!

Stax , 13 byte

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

Esegui ed esegui il debug

Prende l'input con la direzione, seguito dal conteggio. Destra, in alto, a sinistra, e in basso sono 1, 3, 5, e 7, rispettivamente. Ci vogliono un minuto intero per eseguire i tre casi di test forniti.