Sua pirâmide

A pirâmide que quero que você construa é feita inteiramente de cubos. Possui 24 camadas, e a N a ^ésima camada da parte superior contém cubos de N ² organizados em um quadrado N por N. A pirâmide é assim:

Para construir a pirâmide, você precisará de um suprimento de cubos. Você recebe 4900 cubos dispostos em um quadrado de 70 por 70, assim:

(Ok, admito que a imagem da praça é totalmente desnecessária.)

Como 1 ² + 2 ² + 3 ² + ... + 24 ² = 70 ² , você tem exatamente o número certo de cubos para construir a pirâmide. Tudo o que você precisa fazer é me dizer onde cada cubo deve ir.

Sua tarefa

Você deve escolher uma joia arbitrária entre os cubos no quadrado e os cubos na pirâmide. (Seria bom se a sua resposta dissesse qual das 4900 diferentes bijeções que você está usando.)

Em seguida, escreva uma função ou programa que faça o seguinte:

• Dada a localização de um cubo no quadrado 70 por 70 (como um par de coordenadas (X,Y)),
• Saída sua localização na pirâmide (como um triplo de coordenadas (A,B,C)).

As coordenadas de entrada e saída podem ser indexadas em 0 ou 1. Supondo que seja indexado 1, sua entrada (X,Y)será um par de números inteiros entre 1 e 70. Sua saída (A,B,C)será um triplo de números inteiros; Adeve ser a camada contando da parte superior (entre 1 e 24) e (B,C)as coordenadas desse cubo dentro dessa camada (entre 1 e A).

Por exemplo:

• o cubo superior da pirâmide tem coordenadas (1,1,1).
• Os quatro cantos da base da pirâmide têm coordenadas (24,1,1), (24,1,24), (24,24,1), e (24,24,24).
• Se você decidir colocar os cantos do quadrado nos cantos da pirâmide, na entrada (70,1)você poderá fornecer a saída (24,24,1).

Você pode supor que você receberá apenas coordenadas válidas (X,Y)como entrada. A correção é inteiramente determinada pela seguinte regra: duas entradas válidas diferentes sempre devem fornecer duas entradas válidas diferentes.

Este é o código-golfe : o código mais curto vence.

Geléia , 15 14 bytes

24p;€$€Ẏ
ḅ70ị¢

Experimente online!

Isso é bastante simples: construímos a lista de coordenadas de cubos dentro da pirâmide como uma lista real. Então, tudo o que precisamos fazer é conectar as coordenadas de entrada dentro do quadrado em um índice dentro da lista, o que é trivial através da conversão de base.

Essa submissão funciona como um programa completo (tomando as coordenadas como [x, y]através do primeiro argumento da linha de comando e gerando a saída padrão) ou como uma função, implicitamente nomeada 2Ŀ.

Explicação

Construindo a lista

Começamos com o número 24, que é interpretado como um intervalo de 1 a 24, inclusive (porque estamos tentando usá-lo como se fosse uma lista). Então iteramos sobre ele; é isso que o último €do programa faz. Para cada elemento n da lista:

• Construímos a lista de pares x , y onde cada elemento vem de 1 .. n ; pconstrói uma lista de pares com dois conjuntos de elementos e, como apenas um valor está disponível aqui ( n ), é implicitamente usado para os dois conjuntos, que, portanto, tornam-se uma lista de 1 .. n .
• Anexamos n (novamente, o único valor que temos disponível) a cada elemento da lista ( ;€).
• Para fazer com que a segunda €aplique essas duas operações a cada n (ou seja, para criar um loop contendo duas instruções), usamos $para agrupar as duas instruções em uma.

Finalmente, usamos Ẏpara achatar a lista em um estágio, a fim de obter uma lista que simplesmente contém todas as coordenadas em ordem. Começa assim:

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

Indexando a lista

Começamos convertendo as coordenadas de entrada em um número, interpretando-as como um número inteiro de base 70: ḅ70. Isso nos dá um valor no intervalo de 71 a 4970, inclusive; todos esses valores são únicos mod 4900. ịindexa no módulo da lista o comprimento da lista, portanto [1, 1], forneceremos o 71º elemento, [1, 2]o 72º elemento, até o [70, 70]qual nos dará o 70º elemento (isto é, o elemento antes da resposta para [1, 1]) Finalmente, precisamos apenas ¢de nos dizer qual lista indexar (nesse caso, é a lista especificada pela linha anterior; é isso que ¢acontece, execute a linha anterior sem argumentos).

PHP, 75 82 78 bytes

Indexado em 0 :

conjunto P = X + Y * 70, em seguida, reduzir P por A ² ao andar para baixo para a camada correcta. A-1; P / A; P% A - pronto.

(invertido: ao incrementar A para a camada correta: P = P + A2 ² e 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;

Corra com php -nr '<code>' <X> <Y>; imprime A_B_C.

1 indexado, 82 bytes :

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 bytes

Primeira submissão, não seja muito duro q:

Indexado a 0

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

Cria uma lista de comprimento 4900 com todas as coordenadas pyramind e retorna uma entrada de lista diferente para cada entrada.

Experimente online!

Python 2 , 64 bytes

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

Experimente online!

C 89 , 87 , 82 , 71 bytes

Tomou a solução Python do xnor e removeu a quebra de linha

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

Indexado a 0

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

Indexado 1

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

Lote, 103 bytes

@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%

Indexado a 0. Funciona através de cada camada, começando pelo topo.

J, 37 bytes

-4 bytes graças ao FrownyFrog

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

Tradução bastante direta do método Jelly em J. Usa 0 indexação. A praça da pirâmide superior é a primeira. O canto inferior direito da base é o último.

A maioria do código é padronizada para produzir a lista indexada tripla como uma constante. Encontrar o elemento correto nessa lista com base na entrada de 2 elementos é simplesmente uma questão de traduzir da base 70 com70&#.

Experimente online!

Casca , 13 bytes

!foEG▲π3Π4B70

Experimente online! Os índices começam em 1.

Explicação

Como algumas outras respostas, construo a lista completa de coordenadas da pirâmide e simplesmente a indexo. Eu faço isso listando todos os triplos em [A,B,C]que os números estão entre 1 e 24 (expressos em 4! Para salvar um byte) e mantendo aqueles para os quais 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.