Votre pyramide

La pyramide que je veux que vous construisiez est entièrement constituée de cubes. Il a 24 couches, et la N ^ème couche du haut contient N ² cubes disposés dans un carré N par N. La pyramide ressemble à ceci:

Pour construire la pyramide, vous aurez besoin d'une réserve de cubes. On vous donne 4900 cubes disposés dans un carré de 70 par 70 qui ressemble à ceci:

(D'accord, j'avoue que l'image du carré est totalement inutile.)

Puisque 1 ² + 2 ² + 3 ² + ... + 24 ² = 70 ² , vous avez exactement le bon nombre de cubes pour construire la pyramide. Tout ce que vous avez à faire est de me dire où chaque cube doit aller.

Ta tâche

Vous devez choisir une bijection arbitraire entre les cubes du carré et les cubes de la pyramide. (Ce serait bien si votre réponse disait laquelle des 4900! Différentes bijections vous utilisez.)

Ensuite, écrivez une fonction ou un programme qui effectue les opérations suivantes:

• Étant donné l'emplacement d'un cube dans le carré 70 par 70 (sous la forme d'une paire de coordonnées (X,Y)),
• Afficher son emplacement dans la pyramide (sous la forme d'un triple de coordonnées (A,B,C)).

Les coordonnées d'entrée et de sortie peuvent toutes être indexées 0 ou indexées 1. En supposant 1 indexé, votre entrée (X,Y)sera une paire d'entiers entre 1 et 70. Votre sortie (A,B,C)sera un triple d'entiers; Adevrait être le calque compté à partir du haut (entre 1 et 24) et (B,C)devrait être les coordonnées de ce cube au sein de ce calque (entre 1 et A).

Par exemple:

• le cube supérieur de la pyramide a des coordonnées (1,1,1).
• Les quatre coins de la base de la pyramide ont des coordonnées (24,1,1), (24,1,24), (24,24,1)et (24,24,24).
• Si vous décidez de placer les coins du carré aux coins de la pyramide, (70,1)vous pouvez donner la sortie en entrée (24,24,1).

Vous pouvez supposer que vous ne recevrez que des coordonnées valides (X,Y)en entrée. La correction est entièrement déterminée par la règle suivante: deux entrées valides différentes doivent toujours donner deux entrées valides différentes.

C'est le code-golf : le code le plus court l'emporte.

Gelée , 15 14 octets

24p;€$€Ẏ
ḅ70ị¢

Essayez-le en ligne!

C'est assez simple: nous construisons la liste des coordonnées des cubes dans la pyramide comme une liste réelle. Ensuite, tout ce que nous devons faire est de bijecter les coordonnées d'entrée dans le carré dans un index dans la liste, ce qui est trivial à faire via la conversion de base.

Cette soumission fonctionne soit comme un programme complet (en prenant les coordonnées comme [x, y]via le premier argument de ligne de commande et en sortant sur la sortie standard), soit comme une fonction, implicitement nommée 2Ŀ.

Explication

Construire la liste

Nous commençons par le nombre 24, qui est interprété comme une plage de 1 à 24 inclus (parce que nous essayons de l'utiliser comme s'il s'agissait d'une liste). Ensuite, nous itérons dessus; c'est ce que fait le dernier €programme. Pour chaque élément n de la liste:

• Nous construisons la liste des paires x , y où chaque élément vient de 1 .. n ; pconstruit une liste de paires à partir de deux ensembles d'éléments, et comme une seule valeur est disponible ici ( n ), elle est implicitement utilisée pour les deux ensembles, qui deviennent donc tous deux une liste à partir de 1 .. n .
• Nous ajoutons n (encore une fois, la seule valeur dont nous disposons) à chaque élément de la liste ( ;€).
• Afin que la seconde €applique ces deux opérations à chaque n (c'est-à-dire pour créer une boucle contenant deux instructions), nous utilisons $pour regrouper les deux instructions en une seule.

Enfin, nous utilisons Ẏpour aplatir la liste d'une étape, afin d'obtenir une liste qui contient simplement toutes les coordonnées dans l'ordre. Cela commence comme ceci:

[1, 1, 1], [1, 1, 2], [1, 2, 2], [2, 1, 2], [2, 2, 2], [1, 1, 3], [1 , 2, 3], [1, 3, 3], [2, 1, 3], [2, 2, 3], [2, 3, 3], [3, 1, 3], [3, 2 , 3], [3, 3, 3], [1, 1, 4], [1, 2, 4], [1, 3, 4], [1, 4, 4], [2, 1, 4 ], [2, 2, 4], [2, 3, 4], [2, 4, 4], [3, 1, 4], [3, 2, 4], [3, 3, 4], [3, 4, 4], [4, 1, 4], [4, 2, 4], [4, 3, 4], [4, 4, 4],…

et se termine par [24, 24, 24].

Indexation de la liste

Nous commençons par convertir les coordonnées d'entrée en nombre en les interprétant comme un entier de base 70: ḅ70. Cela nous donne une valeur comprise entre 71 et 4970 inclus; toutes ces valeurs sont uniques mod 4900. ịindexe dans la liste modulo la longueur de la liste, [1, 1]nous donnera donc le 71e élément, [1, 2]le 72e élément, jusqu'à [70, 70]ce qui nous donne le 70e élément (c'est-à-dire l'élément avant la réponse pour [1, 1]). Enfin, nous avons juste besoin d'un ¢pour nous dire quelle liste indexer (dans ce cas, c'est la liste spécifiée par la ligne précédente; c'est ce qui ¢fait, exécutez la ligne précédente sans arguments).

PHP, 75 82 78 octets

0 indexé :

réglez P = X * 70 + Y puis réduisez P de A ² tout en descendant vers le bon calque. A-1; PENNSYLVANIE; P% A - terminé.

(inversé: lors de l'incrémentation de A vers le bon calque: P = P + A ² puis P = P + A * B + C -> X = P / 70, Y = P% 70)

for($p=$argv[1]*70+$argv[2];$p>=++$a**2;$p-=$a**2);echo$a-1,_,$p/$a|0,_,$p%$a;

Courir avec php -nr '<code>' <X> <Y>; imprime A_B_C.

1 indexé, 82 octets :

for($p=$argv[1]*70+$argv[2]-71;$p>++$a**2;$p-=$a**2);echo$a,_,$p/$a+1|0,_,$p%$a+1;

Python, 80 73 72 octets

Première soumission, ne soyez pas trop sévère q:

0 indexé

lambda x,y:[(a-1,b//a,b%a)for a in range(25)for b in range(a*a)][70*x+y]

Crée une liste de longueur 4900 avec toutes les coordonnées pyramidales et renvoie une entrée de liste différente pour chaque entrée.

Essayez-le en ligne!

Python 2 , 64 octets

x,y=input()
n=-70*x-y
i=1
while n<0:i+=1;n+=i*i
print~-i,n/i,n%i

Essayez-le en ligne!

C 89 , 87 , 82 , 71 octets

A pris la solution Python de xnor et supprimé le saut de ligne

p(x,y){for(x=-70*y-x,y=1;x<0;x+=++y*y);printf("%d %d %d",~-y,x/y,x%y);}

0 indexé

z;p(x,y){for(x+=y*70+1,y=z=0;z<x;z+=++y*y);z-=x;printf("%d %d %d\n",y-1,z/y,z%y);}

1 indexé

z;p(x,y){for(x+=~-y*70,y=z=1;z<x;z+=++y*y);z-=x-y;printf("%d %d %d\n",y,z/y,z%y+1);}

Lot, 103 octets

@set/an=%1*70+%2,i=0
:l
@set/an-=i*i,j=i,i+=1,k=n%%i,l=n/i
@if %l% geq %i% goto l
@echo %j% %k% %l%

0 indexé. Fonctionne à travers chaque couche en partant du haut.

J, 37 octets

-4 octets grâce à FrownyFrog

(a:-.~,(<:,&.>{@;~&i.)"0 i.25){~70&#.

Traduction assez simple de la méthode Jelly en J. Utilise l'indexation 0. Le sommet de la pyramide est le premier. Le coin inférieur droit de la base est le dernier.

La majorité du code est passe-partout pour produire la liste triplement indexée comme constante. Trouver l'élément correct dans cette liste sur la base de l'entrée de 2 éléments est simplement une question de traduction à partir de la base 70 avec70&#.

Essayez-le en ligne!

Husk , 13 octets

!foEG▲π3Π4B70

Essayez-le en ligne! Les indices commencent à 1.

Explication

Comme certaines autres réponses, je construis la liste complète des coordonnées de la pyramide et l'indexe simplement. Pour ce faire, je répertorie tous les triplets [A,B,C]dont les nombres sont compris entre 1 et 24 (exprimés en 4! Pour enregistrer un octet) et en conservant ceux pour lesquels A >= max(B,C).

!foEG▲π3Π4B70  Implicit input: a list of two numbers.
          B70  Interpret in base 70.
!              Modular index into the following list:
        Π4      Factorial of 4: 24
      π3        Take range and 3-fold Cartesian power: [[1,1,1],[1,1,2],..,[24,24,24]]
 f              Filter by
  oE            all values are equal
    G▲          in cumulative reduce by maximum.