La tua piramide

La piramide che voglio che tu costruisca è fatta interamente di cubi. Ha 24 strati e l' ^ennesimo strato dall'alto contiene N ² cubi disposti in un quadrato N per N. La piramide si presenta così:

Per costruire la piramide, avrai bisogno di una scorta di cubi. Ti vengono dati 4900 cubi disposti in un quadrato 70 per 70 che assomiglia a questo:

(Va bene, ammetto che l'immagine della piazza è del tutto inutile.)

Poiché 1 ² + 2 ² + 3 ² + ... + 24 ² = 70 ² , hai esattamente il numero giusto di cubi per costruire la piramide. Tutto quello che devi fare è dirmi dove dovrebbe andare ogni cubo.

Il tuo compito

Dovresti scegliere una biiezione arbitraria tra i cubi nel quadrato e quelli nella piramide. (Sarebbe bello se la tua risposta dicesse quale delle 4900! Diverse biiezioni stai usando.)

Quindi, scrivere una funzione o un programma che procede come segue:

• Data la posizione di un cubo nel quadrato 70 per 70 (come una coppia di coordinate (X,Y)),
• Stampa la sua posizione nella piramide (come tripla di coordinate (A,B,C)).

Le coordinate di input e output possono essere tutte indicizzate 0 o 1 indicizzate. Supponendo 1 indicizzato, l'input (X,Y)sarà una coppia di numeri interi compresi tra 1 e 70. L'output (A,B,C)sarà una tripla di numeri interi; Adovrebbe essere il conteggio dei layer dall'alto (tra 1 e 24) e (B,C)dovrebbero essere le coordinate di quel cubo all'interno di quel layer (tra 1 e A).

Per esempio:

• il cubo superiore della piramide ha coordinate (1,1,1).
• I quattro angoli della base della piramide hanno coordinate (24,1,1), (24,1,24), (24,24,1), e (24,24,24).
• Se decidi di posizionare gli angoli del quadrato agli angoli della piramide, allora sull'input (70,1)potresti dare l'output (24,24,1).

Puoi presumere che ti verranno fornite solo coordinate valide (X,Y)come input. La correttezza è interamente determinata dalla seguente regola: due diversi input validi dovrebbero sempre fornire due diversi output validi.

Questo è code-golf : vince il codice più corto.

Gelatina , 15 14 byte

24p;€$€Ẏ
ḅ70ị¢

Provalo online!

Questo è abbastanza semplice: costruiamo l'elenco delle coordinate dei cubi all'interno della piramide come un elenco reale. Quindi tutto ciò che dobbiamo fare è biettare le coordinate di input all'interno del quadrato in un indice all'interno dell'elenco, cosa banale da eseguire tramite la conversione di base.

Questa presentazione funziona sia come un programma completo (prendendo le coordinate come [x, y]tramite il primo argomento della riga di comando e producendo l'output standard), sia come una funzione, implicitamente denominata 2Ŀ.

Spiegazione

Costruire l'elenco

Iniziamo con il numero 24, che viene interpretato come un intervallo compreso tra 1 e 24 incluso (perché stiamo cercando di usarlo come se fosse un elenco). Quindi iteriamo su di esso; questo è quello che fa l'ultimo €programma. Per ogni elemento n dell'elenco:

• Costruiamo la lista di coppie x , y in cui ogni elemento proviene da 1 .. n ; pcostruisce un elenco di coppie dato due insiemi di elementi, e poiché qui è disponibile solo un valore ( n ), viene implicitamente usato per entrambi gli insiemi, che diventano quindi entrambi un elenco da 1 .. n .
• Aggiungiamo n (di nuovo, l'unico valore che abbiamo a disposizione) a ciascun elemento dell'elenco ( ;€).
• Per fare in modo che la seconda €applichi entrambe queste operazioni a ciascuna n (cioè per creare un ciclo contenente due istruzioni), usiamo $per raggruppare le due istruzioni in una sola.

Infine, usiamo Ẏper appiattire l'elenco di uno stadio, al fine di ottenere un elenco che contiene semplicemente tutte le coordinate in ordine. Inizia così:

[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], ...

e termina con [24, 24, 24].

Indicizzazione dell'elenco

Iniziamo convertendo le coordinate di input in un numero interpretandole come un intero di base 70: ḅ70. Questo ci dà un valore compreso tra 71 e 4970 inclusi; tutti questi valori sono univoci mod 4900. ịindicizza nella lista il modulo della lunghezza della lista, quindi [1, 1]ci darà il 71 ° elemento, [1, 2]il 72 ° elemento, fino a [70, 70]che ci dà il 70 ° elemento (cioè l'elemento prima della risposta per [1, 1]). Infine, abbiamo solo bisogno ¢di dirci quale elenco indicizzare (in questo caso, è l'elenco specificato dalla riga precedente; ecco cosa ¢fa, eseguire la riga precedente senza argomenti).

PHP, 75 82 78 byte

0 indicizzato :

impostare P = X * 70 + Y quindi ridurre P di A ² mentre si cammina verso il livello corretto. A-1; PAPÀ; P% A - fatto.

(invertito: durante l'incremento di A al livello corretto: P = P + A ² quindi 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;

Corri con php -nr '<code>' <X> <Y>; stampa A_B_C.

1 indice, 82 byte :

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 byte

Prima presentazione, non essere troppo duro q:

0-indicizzato

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

Crea un elenco di lunghezza 4900 con tutte le coordinate di pyramind e restituisce una voce di elenco diversa per ciascun input.

Provalo online!

Python 2 , 64 byte

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

Provalo online!

C 89 , 87 , 82 , 71 byte

Ha preso la soluzione Python di xnor e ha rimosso l'interruzione di linea

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-indicizzato

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-indicizzato

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);}

Lotto, 103 byte

@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-indicizzati. Funziona attraverso ogni livello a partire dall'alto.

J, 37 byte

-4 byte grazie a FrownyFrog

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

Traduzione abbastanza semplice del metodo Jelly in J. Usa 0 indicizzazione. Il primo quadrato piramidale è il primo. L'angolo in basso a destra della base è l'ultimo.

La maggior parte del codice è boilerplate per produrre l'elenco triplo indicizzato come costante. Trovare l'elemento corretto all'interno di quell'elenco basato sull'input di 2 elementi è semplicemente una questione di traduzione dalla base 70 con70&#.

Provalo online!

Buccia , 13 byte

!foEG▲π3Π4B70

Provalo online! Gli indici iniziano da 1.

Spiegazione

Come alcune altre risposte, costruisco l'elenco completo delle coordinate della piramide e semplicemente ci indice. Lo faccio elencando tutte le triple in [A,B,C]cui i numeri sono compresi tra 1 e 24 (espressi come 4! Per salvare un byte) e mantenendo quelli per i quali 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.