Quatre axes en spirale

9

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:

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.
code-golf number-theory grid AdmBorkBork
la source
Pouvons-nous prendre des entiers négatifs pour deux directions?
mbomb007
@ mbomb007 Bien sûr, ce serait OK.
AdmBorkBork
Cela ne semble pas très pratique, mais pouvons-nous retourner un entier qui a les chiffres requis sauf le zéro de tête (ce qui serait implicite de toute façon)?
Erik the Outgolfer
@AdmBorkBork Fondamentalement, je n'ai pas une telle solution en tête, juste pensé à demander. :)
Erik the Outgolfer
Un défi est jugé par la sortie. Donc, si le zéro n'est pas inclus, je pense que ce serait faux, car vous le compteriez mal si le zéro est exclu pour la sortie de chaîne. Python peut produire des entiers avec des zéros non significatifs, alors pourquoi pas d'autres langages.
mbomb007

Réponses:

5

Python 2 , 94 89 84 83 74 72 70 octets

J'ai utilisé WolframAlpha et déterminé qu'une limite supérieure de 5 n > 4n 2 + 3n semble être suffisante. Il peut être changé à 9 n 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

mbomb007
la source
1

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 .

Luis Mendo
la source
1

Gelée ,  19  18 octets

Utilise l' astuce 5 n 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
Jonathan Allan
la source
1

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!

DanielIndie
la source
0

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.

récursif
la source