Geléia , 47 números inteiros, 519 bytes
e
BI$⁼#
⁾⁾⁾Ụ^/
ı***ıḞḞ
5
6
7
.::::
9
EȮ<
⁻GṘ
=`p`VV×`DQV
~A~A~A~A~A~A~A~A~A~A~A~A~A
⁷ṾṾṾw
⁴ḟ€⁴Ṁ
mmmmċ
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
ĖḌĖḌ
ṫṣȦJṫȦ⁸ȦJ
22
“@ṃ»
!ḤḤ!
³HH
ØaM
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
irið8c
⁶ḲĠṂ°İṂĊ
œṡ¹ẆẆTUṖṖṖṖP
ȷ½RṪ
LµdddddµFL
33
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
ẇɓæ«æ«æ«æ«æ«|æ«|
⁹ṚḢ²
‘‘‘0‘‘‘‘‘‘‘
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
-____---__________
”(O
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
⁽{ʂ%⁽{}
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
44
111111l11&K1111111Kl11&
,SS¶ỊỊ,ÇS¶ÇÑÇÇÇÑ
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn
Cada linha é um programa completo e separado.
Experimente online! (inclui suíte de testes e verificador de interseção)
Como funciona
Todo programa completo sem argumentos de linha de comando executa seu link principal (definido na última linha) niladicamente, ou seja, sem entrada. Se o primeiro link da cadeia for um nilad, ele será consumido, chamado, e o argumento do link principal e o valor de retorno serão configurados para o resultado; se o primeiro link da cadeia for uma mônada ou díade, ele não será consumido e o argumento implícito e o valor de retorno 0 serão usados. Nos dois casos, o restante da cadeia é executado monadicamente.
A geléia controla sua produção em vários casos. Notavelmente, uma matriz simples é impressa sem seus colchetes, portanto 42 e [42] e indistinguíveis após a impressão. Usaremos isso em várias ocasiões.
1 - 10
e
O átomo existe testa se o valor de retorno 0 pertence ao argumento 0 . Sim, eretorna 1 .
BI$⁼#
BI$é um link rápido, especificamente uma cadeia monádica formada pelo $agrupamento rápido do átomo binárioB e do átomo de incrementosI . Combinados, eles convertem um número inteiro na matriz de seus dígitos na base 2 e depois calculam as diferenças diretas dos dígitos resultantes. Se a matriz tiver apenas um elemento, não haverá diferenças Idiretas e retornará uma matriz vazia (falsy); se houver pelo menos dois dígitos, Iretornará uma matriz não vazia (verdade).
O quick #consome o link rápido anterior e o aplica a 0 , 1, 2,… até que sejam encontradas correspondências suficientes e retorna a matriz de correspondências. A quantidade requerida é calculada por ⁼, que compara o valor de retorno / argumento 0 a si mesmo, produzindo 1 . Assim, o programa inteiro retorna [2] , o primeiro número inteiro não negativo com dois dígitos na base 2.
⁾⁾⁾Ụ^/
⁾⁾⁾é uma string literal, especificamente a string ⁾⁾ . O grau até átomo Ụordena seus índices por seus valores correspondentes; como os dois caracteres são iguais, isso gera [1, 2] . A matriz resultante é reduzida com o XOR bit a bit ^/, para que o programa inteiro retorne 3 .
ı***ıḞḞ
ıinicializa argumento e retorna valor para a unidade imaginária i . *é a díade de exponenciação , cujo argumento correto é o padrão do argumento do link principal. Assim, ***ıcalcula ((i i ) i ) i ≈ 4,81 + 0i , o Ḟátomo ( piso para argumentos reais , parte real para argumentos complexos) calcula a parte real ( 4,81 ), depois os Ḟpisos, produzindo 4 .
5
6
7
Esses três programas consistem em um único literal e fazem exatamente o que você esperaria.
.::::
O literal .é uma abreviação de 0,5 e inicializa o argumento e o valor de retorno. O argumento da direita da díade da divisão inteira ( :) assume como padrão o argumento dos links principais, ::::calculando 0,5 / 0,5 / 0,5 / 0,5 / 0,5 , produzindo 8 .
9
Outro literal.
EȮ<
O átomo todo igualE retorna 1 se todos os elementos em seu argumento são iguais e 0 se não. Um argumento inteiro z é promovido para [z] , então Eretornará 1 para o argumento implícito 0 .
Agora, o átomo de saídaȮ imprime 1 em STDOUT. Em seguida, comparamos 1 com o argumento implícito 0 usando o menor que átomo <. O resultado é (1 <0) = 0 e é impresso implicitamente quando o programa termina.
11 - 20
⁻GṘ
O átomo da gradeG tenta criar uma tabela visualmente agradável a partir de seu argumento. Para um argumento inteiro simples (aqui: 0 ), ele simplesmente o agrupa em uma matriz. O átomo plano não igual⁻ compara o argumento implícito 0 com o resultado à direita ( [0] ), produzindo 1, pois seus argumentos não são iguais. O átomo de representaçãoṘ imprime 1 em STDOUT e retorna seu resultado. No final do programa, o valor final de retorno é impresso implicitamente; portanto, terminamos com uma saída 11 .
=`p`VV×`DQV
O eu rapidamente `transforma uma díade em uma mônada, chamando-a com argumentos idênticos de esquerda e direita. Primeiro, =`compara o argumento implícito 0 com ele mesmo, produzindo 1 .
O átomo do produto cartesianop espera listas como argumentos, portanto promove o número inteiro 1 no intervalo [1,…, 1] = [1] . p`toma o produto cartesiano de [1] e ele próprio, produzindo [[1, 1]] .
O átomo evalV transforma todas as matrizes planas (contendo apenas números e caracteres) em cadeias de caracteres e avalia as cadeias resultantes como programas niládicos de geléia. [[1, 1]] é primeiro transformado em [“11”] , depois Vavalia a corda, produzindo [11] . Mais uma vez, Vtransforma essa matriz em "11" e a avalia para produzir 11 .
Agora, ×`multiplica 11 com ele mesmo, produzindo 121 . O átomo decimal transforma 121 em [1, 2, 1] , o átomo exclusivoQ descarta o segundo 1 e V, mais uma vez, transforma uma lista de dígitos no número inteiro resultante da concatenação, retornando 12 .
~A~A~A~A~A~A~A~A~A~A~A~A~A
~é o átomo NÃO bit a bit . Com a aritmética do complemento de dois, ele mapeia um argumento z para ~ z = - (z + 1) . Aé o átomo de valor absoluto , por isso mapeia - (z + 1) = z + 1 . Com o valor de retorno inicial 0 , as treze cópias do ~Aretorno 13 .
⁷ṾṾṾw
A constante ⁷mantém o caractere de nova linha '\ n' e inicializa o argumento e o valor de retorno.
O átomo desigualṾ tenta criar uma representação de string de seu argumento z, de modo que um programa Jelly que consiste nesse código retorne z .
A primeira chamada devolve obedientemente a string "” \ n " , que é um caractere literal. A próxima chamada retorna "" "," \ n " - um par de caracteres literais. A terceira e última chamada retorna "" "," "," ,, "", "\ n" - um quintupleto de caracteres literais.
Finalmente, o átomo do índice da janelaw promove seu argumento correto '\ n' para a cadeia "\ n" e encontra o primeiro índice de uma substring começando com "\ n" . Isso retorna 14 .
⁴ḟ€⁴Ṁ
⁴é a constante 16 . O filtro de link rápidofalso each ( ḟ€) promove seu argumento esquerdo 16 no intervalo [1,…, 16] e , em seguida, itera sobre seus elementos.
Para cada elemento z , ḟ⁴é executado, primeiro promovendo z para [z] e removendo todas as ocorrências (se houver) de 16 . Isso gera a matriz [[1], [2],…, [14], [15], []] , onde a última matriz está vazia porque continha 16 .
Finalmente, o átomo máximoṀ seleciona [15] .
mmmmċ
O átomo modularm - chamado com argumentos x (matriz) e y (número inteiro) geralmente leva todos os | y | th elemento de x , começando com o primeiro se y> 0 , com o último se y <0 . No entanto, quando y = 0 , ele retorna x concatenado com seu reverso.
O argumento inteiro esquerdo 0 é promovido primeiro para [0] . A primeira cópia de mconcatena [0] consigo mesma, produzindo [0, 0] . As cópias restantes transformam esse resultado em [0, 0, 0, 0] , depois [0, 0, 0, 0, 0, 0, 0, 0] e, finalmente, [0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .
Por fim, o átomo de contagemċ conta o número de vezes que o argumento implícito 0 aparece na matriz resultante, retornando 16 .
ṭṭṭṭṭṭṭṭḍḄḄḄḄḄḄḄḄḄ
ṭé o átomo de aderência e acrescenta seu argumento esquerdo ao direito. Como ṭe a seguir ḍsão diádicos, todas as chamadas para ṭpassar o argumento implícito 0 como o argumento correto ṭ. A primeira chamada retorna [0, 0] , a segunda [0, [0, 0] e a oitava e última [0, [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .
ḍé o átomo de divisibilidade ; para argumentos x e y , ele retorna 1 é x é divisível por y , 0 se não. Ḅé um no-op para números inteiros, então ḍḄtesta 0 quanto à divisibilidade de cada número inteiro na matriz construída. 0 é divisível por si só, então obtemos [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]]]] .
Agora, o átomo não binárioḄ opera em matrizes planas. Para um par [a, b] , ele simplesmente retorna 2a + b . Como mencionado anteriormente, Ḅé um no-op para números inteiros: um argumento inteiro c é promovido para [c] e [c] em qualquer base é simplesmente c .
A primeira chamada para Ḅreduz [1, 1] para 3 , resultando em [1, [1, [1, [1, [1, [1, [1, 3]]]]]]]]] . A próxima chamada reduz [1, 3] para 5 , a próxima [1, 5] para 7 e assim sucessivamente até o nono Ḅretornar 17 .
+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ+Ṇ
Ṇé o átomo lógico NÃO plano e mapeia o argumento implícito de 0 a 1 . +é o átomo de adição; portanto, cada uma das dezoito cópias de +Ṇincremento do valor de retorno anterior (inicialmente 0 ). Todo o programa retorna 18 .
CNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNCNC
Cé o átomo do complemento e mapeia seu argumento z para 1-z . Né o átomo de negação e mapeia seu argumento z para -z . Juntos, CNmapeia z para - (1-z) = z-1 , para que as dezoito cópias transformem o argumento implícito 0 em -18 . Uma aplicação final de Crendimentos 1 - (-18) = 19.
ĖḌĖḌ
O enumerar átomo Ėenumera os itens em uma matriz, criando pares de valores de índice. O argumento implícito 0 é promovido para [0] , depois Ėproduz [[1, 0]] . O átomo não decimal converte uma matriz plana da base 10 em número inteiro, produzindo [10] neste caso particular.
A segunda chamada para Ėtransforma [10] em [[1, 10]] , que a segunda Ḍfinalmente transforma em [20] .
21 - 30
ṫṣȦJṫȦ⁸ȦJ
O átomo da caudaṫ (díade) seleciona o postfix de seu argumento esquerdo que inicia no índice (baseado em 1 e modular) especificado em seu argumento direito, promovendo um argumento inteiro esquerdo x a [x] . Quando chamado com os dois argumentos definidos como 0 , ṫretorna [0] .
O átomo any e allȦ retorna 1 se seu argumento é verdadeiro e não contém zeros em nenhuma profundidade, 0 caso contrário. Aqui, simplesmente a usamos como uma função de identidade para retornar o argumento implícito 0 . A divisão no átomo ṣparticiona seu argumento esquerdo [0] nas ocorrências de seu argumento direito 0 , então retorna [[], []] aqui.
O átomo de índicesJ descarta os elementos do valor de retorno e os substitui por seus índices, produzindo o intervalo [1, 2] nesse caso específico. Ȧe ṫambos funcionam como antes, então eles reduzem [1,2] para o postfix que inicia no último índice, produzindo [2] .
Nos links niládicos, a constante ⁸mantém [] . Este é um nilad incomparável, ou seja, não se encaixa na cadeia de forma alguma. Como resultado, o valor de retorno anterior ( [2] ) é impresso em STDOUT e, em seguida, substituído pelo valor da nilad ( [] ).
Como [] é falso, Ȧtransforma-o em 0 . O Játomo promove 0 a [0] e , em seguida, retorna a lista de seus índices ( [1] ), que é impressa implicitamente quando o programa termina.
22
Outro literal. Repdigits parecem ser o melhor lugar para usá-los.
“@ṃ»
Isso usa a compactação de string incorporada de Jelly. Os índices de @ e ṃ na página de código do Jelly são 64 e 220 e os literais de cadeias podem conter 250 caracteres diferentes, portanto, este primeiro calcula o número inteiro 250 × 65 + 220 = 16470 .
16470 é divisível por 3, portanto, o quociente 16470/3 = 5490 codifica um caractere ASCII imprimível ou um avanço de linha. Existem 96 deles e 5490 = 96 × 57 + 18 , o que significa que decodificamos o caractere ASCII imprimível no índice baseado em 0 18 , que é '2' .
Ficamos com 57 , que também é divisível por 3 , então o quociente 57/3 = 19 = 96 × 0 + 19 codifica o caractere ASCII imprimível no índice baseado em 0 18 , que é '3' .
Isso deixa 0 ; o processo de decodificação é interrompido. Os caracteres gerados são concatenados para formar "23"
!ḤḤ!
O átomo fatorial! transforma o argumento implícito 0 em 1 . Duas invocações do átomo nãohalveḤ transformam 1 em 2 , depois 2 em 4 . Finalmente, !calcula 4! = 24 .
³HH
Na ausência de argumentos da linha de comando, a constante ³contém 100 . Duas invocações das Hvoltas 100 para 50 , depois 50 para 25 .
ØaM
A constante Øacontém o alfabeto em minúsculas. O átomo máximoM produz todos os índices de itens máximos e, como z é a maior letra minúscula, o resultado é [26] .
;;;;;;;;;;;;;;;;;;;;;;;;;;;¬¬ḅ¬
Vinte e seis cópias do concatenate átomo de ;concatenar o valor de retorno inicial 0 e vinte e seis instâncias do argumento padrão 0 , a construção de um conjunto de 27 zeros.
¬é o átomo lógico do NOT , portanto ;¬acrescenta 1 à matriz de zeros. O próximo ¬nega todos os elementos da matriz, deixando-nos com uma matriz de 27 unidades e 1 zero.
ḅé o átomo unbase e converte uma matriz de dígitos do argumento esquerdo da base especificada em seu argumento direito em número inteiro. ḅ¬converte de unário para inteiro, então ele simplesmente executa uma soma. Para uma matriz de 27 unidades, isso retorna 27 .
irið8c
O índice de átomo ipromove seu argumento esquerdo 0 a [0] , depois encontra o índice de seu argumento direito 0 nessa matriz, produzindo 1 .
O átomo de alcancer constrói um alcance ascendente ou descendente, do argumento esquerdo para o direito. O argumento certo é o argumento implícito 0 , então isso gera [1, 0] . Uma segunda invocação de ilocaliza o índice de 0 em [1, 0] , produzindo 2 .
ðinicia uma nova cadeia diádica. Como a cadeia anterior era niládica, os argumentos esquerdo e direito dessa cadeia serão iguais ao valor de retorno da primeira cadeia ( 2 ). cno átomo de combinações . Com o argumento esquerdo 8 e o argumento direito 2 , ele conta todas as 2 combinações únicas e não ordenadas de um conjunto de 8 elementos, retornando 8C2 = 8! / (6! 2!) = 28 .
⁶ḲĠṂ°İṂĊ
A constante ⁶mantém um caractere de espaço e define o argumento e retorna o valor para '' . O átomo de palavrasḲ promove o caractere '' para a string singleton "" e o divide em espaços, produzindo [[], []] .
O átomo do grupoĠ agrupa todos os índices de elementos iguais. Como os dois elementos do último valor de retorno são iguais, ele retorna [[1, 2]] aqui. O átomo mínimo extrai um elemento mínimo (o único) dessa matriz, produzindo [1, 2] .
O átomo em graus° converte ambos os números inteiros de graus sexagesimais em radianos, produzindo 1 ° × 2π / 360 ° = π / 180 e 2 ° × 2π / 360 ° = π / 90 . O átomo inverso recebe os inversos multiplicativos, produzindo 180 / π ≈ 57,3 e 90 / π ≈ 28,6 .
Então, Ṃmais uma vez leva o mínimo, produzindo 28,6 . Finalmente, o átomo do tetoĊ transforma 28,6 em 29 .
œṡ¹ẆẆTUṖṖṖṖP
O átomo de identidade¹ retorna 0 para o argumento implícito 0 . A divisão em torno do átomo œṡpromove os dois argumentos (ambos 0 ) a [0] e depois divide [0] em torno de sub-matrizes contíguas iguais a [0] . Isso produz [[], []] .
O átomo da janela deslizanteẆ cria todos os sub-arranjos contíguos de seu argumento. A primeira instância transforma [[], []] em [[]], [[]], [[], []]] , a segunda instância transforma [[]], [[]], [[] , []] para
[[[]]], [[[]]], [[[], []]], [[]], [[]]], [[]], [ [], []]], [[[]], [[]], [[], []]]] .
O átomo da verdadeT lista todos os índices de elementos de verdade . Nenhuma das matrizes no primeiro nível está vazia, então isso gera [1, 2, 3, 4, 5, 6] . O átomo de reversãoU inverte essa matriz, produzindo [6, 5, 4, 3, 2, 1] .
Quatro cópias do átomo popṖ removem os últimos quatro elementos, deixando-nos com [6, 5] . Finalmente, o átomo do produtoP transforma esse array em 30 .
31 - 40
ȷ½RṪ
ȷé uma abreviação de 1 × 10 3 = 1000 . O átomo de raiz quadrada½ produz 31,6 , que o átomo do intervaloR transforma em [1,…, 31] . Finalmente, o átomo da caudaṪ extrai o último elemento, retornando 31 .
LµdddddµFL
O átomo de comprimentoL promove o argumento implícito de 0 a [0] e , em seguida, leva o comprimento para produzir 1 . µinicia uma nova cadeia monádica e o resultado 1 se torna seu argumento.
Para os argumentos x e y , o átomo divmodd produz [x / y, x% y] . Cada chamada terá y = 1 , portanto o resultado será sempre [x, 0] .
A primeira chamada começa com x = 1 , produzindo [1, 0] . dopera apenas em números inteiros; portanto, vetoriza nas chamadas subseqüentes. A segunda chamada produz [[1, 0], [0, 0]] , a terceira [[[1, 0], [0, 0]], [[0, 0], [0, 0]]] , e o quinto e último, uma matriz de profundidade 5 que contém um único e 31 zeros.
µmais uma vez inicia uma nova cadeia monádica e a matriz anterior se torna seu argumento. O átomo planoF desinesta esse arranjo, produzindo um arranjo plano de um único e 31 zeros. Finalmente, Lleva o comprimento do resultado, retornando 32 .
33
Outro repdigit, outro literal.
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWŒḊ
Cada instância do átomo de quebra transforma seu argumento z em [z] . Com o valor de retorno inicial de 0 , todas as 34 instâncias produzem juntas [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Finalmente, o átomo de profundidadeŒḊ calcula a profundidade máxima da matriz resultante, retornando 34 .
ẇɓæ«æ«æ«æ«æ«|æ«|
A janela existe atom ẇpromove ambos os seus argumentos (ambos padrão para 0 ) para [0] e , em seguida, testa se ** [0] ** ocorre como uma sub-matriz contígua de [0] . Sim, ẇretorna 1 .
ɓinicia uma nova cadeia diádica. Como a cadeia anterior era niládica, os argumentos esquerdo e direito dessa cadeia serão iguais ao valor de retorno da primeira cadeia ( 1 ). A cadeia faz uso de dois átomos diádicos diferentes: deslocamento de bits para a esquerda ( æ«) e OR de bit a bit ( |).
Uma cadeia diádica que começa com três ou mais díades inicialmente chama a primeira díade com os argumentos da cadeia. Aqui, isso fornece 1 << 1 = 2 . As seis díades subseqüentes são agrupadas em pares (os chamados garfos ), onde a díade mais à direita é chamada primeiro com os argumentos da cadeia, depois a mais à esquerda é chamada com os valores de retorno anteriores para ambos os lados.
Pois æ«æ«, obtemos 2 << (1 << 1) = 2 << 2 = 8 . Então, æ«æ«calcula 8 << (1 << 1) = 8 << 2 = 32 . Agora |æ«nos leva 32 | (1 << 1) = 32 | 2 = 34 .
Finalmente, o final |funciona como um gancho e é chamado com o valor de retorno anterior como argumento à esquerda e o argumento à direita da cadeia como argumento à direita. Isso retorna 34 | 1 = 35 .
⁹ṚḢ²
Na ausência de um segundo argumento, a constante ⁹contém 256 . O átomo reverso promove 256 à matriz [2, 5, 6] e a reverte para produzir [6, 5, 2] . Então, o átomo principalḢ extrai o primeiro elemento e o átomo quadrado² retorna ** 6² = 36 *.
‘‘‘0‘‘‘‘‘‘‘
O incremento átomo ‘incrementa o seu argumento por uma , assim ‘‘‘transformar o valor de retorno inicial 0 em 3 . O 0 a seguir é um nilad imperceptível, ou seja, não se encaixa na cadeia de forma alguma. Como resultado, o valor de retorno anterior ( 3 ) é impresso em STDOUT e, em seguida, substituído pelo valor da nilad ( 0 ).
As 7 cópias a seguir ‘transformam 0 em 7 , impressas implicitamente quando o programa termina.
’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’ạ
O decréscimo átomo ’diminui seu argumento por 1 , então trinta e oito cópias transformar o valor de retorno inicial 0 para -38 . O átomo de diferença absolutaạ calcula a diferença não assinada entre -38 e o argumento implícito 0 , retornando 38 .
-____---__________
-é uma abreviação de -1 e define o argumento do link e o valor de retorno como -1 . Cada _um é uma instância do átomo de subtração diádica , cujo argumento correto será padronizado como -1 se estiver ausente.
Primeiro, -____-calcula (-1) - (-1) - (-1) - (-1) - (-1) = 3 . O -1 a seguir é um nilad imperceptível; portanto, o valor de retorno anterior ( 3 ) é impresso em STDOUT e, em seguida, substituído pelo valor do nilad ( -1 ).
Em seguida, -_calcula (-1) - (-1) = 0 , onde o literal -define o argumento esquerdo de _e usa o valor de retorno como o direito. As nove cópias a seguir _subtraem o argumento padrão -1 do valor de retorno, produzindo 9 , que é impresso implicitamente quando o programa termina.
”(O
”(é um literal de caractere e o átomo ordinalO procura seu ponto de código Unicode, produzindo 40 .
41 - 47
⁵ḶxḶ⁵ị⁵ḶxḶḣṢ
Na ausência de um terceiro argumento de linha de comando, a constante ⁵mantém 10 . O átomo sem comprimentoḶ cria um intervalo baseado em 0, especificamente [0,…, 9] para o argumento 10 , para ambos os lados do átomo de repetição no lugarx . O último combina elementos do argumento esquerdo com repetições do argumento direito e repete cada um dos elementos o número correspondente de vezes. Com [0,…, 9] como argumento à esquerda e à direita, obtemos zero zeros, um, dois, etc.
O índice no átomo ịbusca o elemento do argumento correto no índice especificado no esquerdo. Com o argumento esquerdo 10 ( ⁵à esquerda) e o argumento direito [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (resultado anterior), isso dá 4 .
A corrente até esse ponto é seguida por um nilad inigualável ⁵; portanto, o valor de retorno anterior ( 4 ) é impresso em STDOUT, o valor de retorno é definido como 10 e o restante da cadeia é analisado como de costume.
Como antes, ⁵ḶxḶproduzirá a matriz [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] . Desta vez, chamamos o átomo classificadoṢ no argumento 10 , que promove 10 a [1, 0] , depois classifica-o para produzir [0, 1] . O átomo da cabeça diádica agora busca os prefixos dos comprimentos 0 e 1 do resultado para a esquerda, deixando-nos com [[], [1]] . Quando impresso, nada além de 1 permanecerá visível.
⁽{ʂ%⁽{}
⁽e seus dois caracteres a seguir constituem um literal numérico. Se j e k são seus pontos de código na página de códigos de Jelly e (j, k) <(124, 250) , obtemos o número inteiro 1001 + 250j + k . Os pontos de código de '{' , '}' e 'ʂ' são 123 , 125 e 167 ; portanto, o literal esquerdo é avaliado em 1001 + 250 × 123 + 167 (= 31918) , enquanto o direito é avaliado em 1001 + 250 × 123 + 125 (= 31876) .
Como o número inteiro esquerdo é menor que o dobro do número direito, o resultado é (… + 167)% (… + 125) = (… + 167) - (… + 125) = 167 - 125 = 42 .
ẊẠżv©żvżvżvọ®®Ạżvżvżvọ®
O átomo aleatórioẊ aleatoriamente a ordem dos elementos de seu argumento; um argumento numérico z é promovido para o intervalo [1,…, z] anteriormente. Para o argumento implícito 0 , esse intervalo está vazio e Ẋgera [] . O átomo allẠ retorna 1 se todos os elementos de seu argumento forem verdadeiros, 0 se não. Como uma matriz vazia não contém elementos falsos, Ạretorna 1 aqui.
O zip com átomo ż(uma díade) recebe os argumentos x e y e transpõe o par [x, y] . Para números inteiros x e y , isso simplesmente produz [[x, y]] ; portanto, esse particular ż, chamado com os argumentos 1 e 0 (o argumento implícito), retorna [[1, 0]] . O átomo de avaliação diádicav transforma todas as matrizes planas (contendo apenas números e caracteres) no argumento da esquerda em seqüências de caracteres e depois avalia as sequências resultantes como programas monádicos do Jelly com seu argumento correto como argumentos dos programas. Desde ["10"]consiste unicamente de literais, isso ignora o argumento correto ve resulta simplesmente em [10] .
A cópia é© anexada rapidamente ve copia seu resultado no registro. Ocorrências posteriores do átomo de recuperação® (um nilad) serão buscadas [10] no registro.
As próximas três cópias do żvtrabalho como antes, mapeando [10] para [[10, 0] para [100] para… para [10000] . O átomo da ordemọ testa quantas vezes seu argumento esquerdo é divisível pelo argumento direito; portanto, aqui, ele calcula a ordem de 10 (buscada com ®) em 10000 = 10 4 , produzindo [4] .
A seguir, ®é apresentado um nilad incomparável; portanto, o valor de retorno anterior ( [4] ) é impresso em STDOUT e, em seguida, substituído pelo valor do nilad ( 10 ). Nós aplicamos a Ạseguir, produzindo 1 . (Isso é necessário, pois uma nilada seguida por uma díade seria analisável neste momento.)
Como antes, żvżvżvacrescenta três zeros ao valor de retorno atual, transformando 1 em [1000] . Por fim, ọ®calcula a ordem de 10 em 1000 = 10 3 e 3 é impresso em STDOUT quando o programa termina.
44
Mais um repdigo, mais um literal.
111111l11&K1111111Kl11&
Em primeiro lugar, o literal 111111define o argumento e o valor de retorno inicial como 111111 . As outras execuções 1também são literais.
lé o átomo do logaritmo , que calcula o logaritmo do argumento esquerdo para a base especificada no direito. Quando chamado 111111 com o argumento certo 11 , obtemos o log 11 111111 ≈ 4.85 .
A palavra átomo Kune um argumento de lista em espaços, depois de promover um caractere numérico / z para [z] . Aqui, simplesmente o usamos para transformar o argumento do link 111111 em [111111] . (Não exigimos uma matriz aqui, mas ficamos sem átomos de identidade.) O átomo AND bit a bit& leva os valores de retorno para ambos os lados, os converte em número inteiro, se necessário, e calcula seu AND bit a bit. Nesse caso em particular, ele retorna [4,85 e 111111] = [4 e 111111] = [4] .
A seguir, 1111111é apresentado um nilad incomparável; portanto, o valor de retorno anterior ( [4] ) é impresso em STDOUT e, em seguida, substituído pelo valor do nilad ( 1111111 ). Kentão transforma esse número inteiro em [1111111] . (Mais uma vez, isso não é realmente necessário, mas um nilad seguido por uma díade seria analisável neste momento.)
Como antes, l11calcula o log 11 1111111 ≈ 5,81 , depois &retorna [5,81 e 111111] = [5 e 111111] = [5] .
,SS
ỊỊ,ÇS
ÇÑÇÇÇÑ
Este é o único programa que consiste em vários links definidos pelo usuário. O último link é o link principal e é executado quando o programa é iniciado, os demais são links auxiliares. O quick Çsempre se refere ao link acima do atual e o executa monadicamente. Da mesma forma, o quick Ñsempre se refere ao link abaixo do atual (quebra automática) e também o executa monadicamente.
A ligação superior consiste no par átomo ,- uma díade que transforma argumentos x e y para [x, y] - e a soma átomo S- um mônade que promove um argumento inteiro z para [z] e reduz um argumento de matriz por adição. Quando o link ,SSé chamado com um argumento inteiro n , ele calcula Σ [n, Σn] = Σ [n, n] = 2n .
O elo do meio consiste nos átomos acima, o rápido mencionado acima Çe o átomo insignificanteỊ - uma mônada que produz 1 para argumentos numéricos z com -1 ≤ z ≤ 1 , mas 0 para todos os outros. A aplicação de Ịduas vezes a um argumento inteiro n essencialmente o substitui por 1 , pois a saída do primeiro Ị(a entrada do segundo) é sempre insignificante. Esse resultado é então emparelhado com o valor de retorno de Ç(chamado com o argumento n ) e o par resultante é reduzido em S. No total, calculamosΣ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1 .
Com esses dois links auxiliares, o link principal agora pode construir qualquer número inteiro não negativo observando seus dígitos binários. Com um valor de retorno inicial de 0 , a cadeia ÇÑÇÇÇÑcalcula o resultado final ((((((0 × 2 + 1) × 2)) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 × 2 + 1) × 2 + 1) × 2 = 46 .
ÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆnÆn
O próximo átomo primo encontra o menor número primo positivo estritamente maior que seu argumento. Com o valor de retorno inicial 0 , quinze invocações de Æncálculo do décimo quinto número primo, que é 47 .