Desafio:

Sua tarefa é escrever o maior número possível de programas / funções / trechos, onde cada um gera / imprime / retorna um número inteiro. O primeiro programa deve gerar o número inteiro 1, o segundo 2e assim por diante.

Você não pode reutilizar nenhum caractere entre os programas. Portanto, se o primeiro programa for x==x:, você não poderá usar os caracteres xe =novamente em nenhum dos outros programas. Nota: É permitido usar o mesmo caractere várias vezes em um programa.

Pontuação:

O vencedor será a finalização que contar mais. Caso haja empate, o vencedor será o envio que utilizou o menor número de bytes no total.

Regras:

• Você pode usar apenas um idioma para todos os números inteiros
• Snippets são permitidos!
• Para mantê-lo justo, todos os caracteres devem ser codificados usando um único byte no idioma que você escolher.
• A saída deve estar em decimal. Você não pode imprimi-lo com notação científica ou algum outro formato alternativo. A saída de flutuadores está OK, desde que todos os dígitos mostrados atrás do ponto decimal sejam 0. Então, 4.000é aceito. Imprecisões devido ao FPA são aceitas, desde que não sejam mostradas na saída.
• ans =, espaços à esquerda e à direita e novas linhas etc. são permitidos.
• Você pode desconsiderar STDERR, desde que a saída correta seja retornada para STDOUT
• Você pode optar por enviar o número inteiro para STDERR, mas apenas se STDOUT estiver vazio.
• Os idiomas independentes de símbolos (como o Lenguage ) não são permitidos
• As letras diferenciam maiúsculas de minúsculas a != A.
• Os programas devem ser independentes
• Espaço em branco não pode ser reutilizado
• Você deve usar dígitos ASCII na saída

As explicações são incentivadas!

JavaScript (ES7), pontuação 17, 176 bytes

Eles disseram que não podia ser feito, então eu fiz: D (graças a muita ajuda do @FullDecent)

""**""
~(~/~//~/~/)/~/~/
3
4
!NaN- -!NaN- -!NaN- -!NaN- -!NaN
6
7
8
9
++[[]][+[]]+[+[]]
11
'lengthlength'.length
222>>2>>2
`${``^``}xE`^``
0XF
C=CSS==CSS;C<<C<<C<<C<<C
555555555555555555555%55

Caracteres não utilizados:

#&,:?@ABDGHIJKLMOPQRTUVWYZ\_bcdfijkmopqrsuvwyz|

Eu não acho que 18 seja possível, mas eu disse a mesma coisa sobre 17 ...

Explicação

JavaScript é uma linguagem de tipo muito fraco; se você tentar executar uma operação matemática em um valor não numérico, o JS fará o possível para convertê-lo em um número primeiro. Isso permite muitas soluções interessantes. Tentei evitar o máximo possível de dígitos, para que possam ser usados ​​posteriormente.

1. **é o operador de exponenciação no ES7. A cadeia vazia, quando coagida a um número 0, torna-se , portanto 0 ** 0, calcula o que está de 1acordo com o JavaScript.
2. Um pouco ridículo, mas funciona. /~/é um literal de regex e ~/~/retorna -1, então é ~(-1 / -1) / -1= ~(1) / -1= -2 / -1= 2. (créditos para @ GOTO0 pela ideia)
3. Simplesmente 3.
4. Agora simplesmente 4.
5. NaNFalsas é, assim !NaNseja true, o que é equivalente a 1. A expressão torna-se assim 1 - -1 - -1 - -1 - -1= 1 + 1 + 1 + 1 + 1= 5.
6. Simplesmente 6.
7. Simplesmente 7.
8. Simplesmente 8.
9. Simplesmente 9.
10. Isso usa um pouco de magia JSF *** . +[]é 0, então [[]][+[]]retorna o primeiro elemento de [[]](ou seja, []) e o ++incrementa para 1. Em seguida, +[+[]]adiciona a matriz [0], que é coagida a uma sequência e cria "10".
11. Simplesmente 11. Eu tinha usado originalmente 11&1111para 3 e 33/311, até que percebi novamente como sou burra ...
12. Essa estratégia funcionaria em qualquer número: crie uma sequência de comprimento 12e uso .length.
13. Eu apenas brinquei com 2s e >s por um tempo para conseguir este. Tive sorte novamente: 222 >> 2é 55e 55 >> 2é 13.
14. Este é um pouco complicado. A idéia básica é criar 14em hex ( 0xE), mas precisamos do dígito em 0outro lugar. Então, em vez disso, acrescentamos o resultado de ``^``à string xE; a cadeia vazia forçada a um número é 0, então isso retorna 0 ^ 0= 0. Em seguida, o resultado é XORed com a sequência vazia, que converte os dois valores em números; "0xE" ^ ""é 14.
15. Agora isso é bem fácil: 0XFé um literal hexadecimal com um valor de 15.
16. O mais complicado de todos? Primeiro, definimos a variável Ccomo CSS == CSS(ou seja, true). Depois, pegamos o resultado e executamos << Cquatro vezes, o que basicamente se multiplica 1por 2 ** 4.
17. O JavaScript começa a perder a precisão inteira em 2 ⁵³ , o que permite 555...555%55retornar um número que não é 0ou 5. Por acaso tive muita sorte enquanto brincava por aqui.

Estratégias que funcionariam em muitos números:

• -!NaNfuncionaria em qualquer número (atualmente 5), embora ele fique grande muito rápido.
• ~/~/funcionaria em qualquer número (atualmente 2), embora fique muito grande muito rápido.
• +[]funcionaria em qualquer número (atualmente 10), embora seja muito mais fácil em 10ou 11.
• .length funcionaria em qualquer número.
• `${-``}xE`-`` funcionaria em praticamente qualquer número, se você fizer certo.
• C<<Cfuncionaria com qualquer potência de duas (atualmente 16) ou int, se você incluísse |.

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 ⁱ ) ⁱ ) ⁱ ≈ 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 ³ = 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 ⁴ , 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 ³ 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 ₁₁ 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 ₁₁ 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 .

brainfuck , score 2, 255 144 10 bytes

... Sim, não é a melhor ideia, já que tenho apenas 8 caracteres (tarpits que vão tarpit) para trabalhar, mas vamos ver o quanto é possível. Eu acho que isso é tudo que é possível. : P Esta resposta demonstra seis dos oito caracteres que o brainfuck usa, sendo os outros dois ,, o que é entrada e o .que é saída.

+
>--[<->-]

Visualize online!

Explicação

Cada número é criado e armazenado na célula inicial da fita. Depende muito das células de quebra automática, que não são implementadas em alguns intérpretes.

1 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

+  increment the current cell

[ 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

2 :

[ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-- decrement the current cell twice

[ 0 |254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[  while the current cell is not 0
<  move to the previous cell
-  decrement the current cell

[255|254| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

>  move to the next cell
-  decrement the current cell

[255|253| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

]  repeat while the current cell is not 0

...

[ 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

[ 2 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
  ^

[ 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 ]
      ^

Neim , pontuação 38, 327 bytes

1: 𝔼
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: β
11: γ
12: δ
13: ε
14: ζ
15: η
16: θ
17: ι
18: κ
19: λ
20: μ
21: ν
22: ξ
23: π
24: ρ
25: σ
26: ς
27: τ
28: υ
29: φ
30: χ
31: ψ
32: ω
33: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
34: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<𝐀
35: 𝐓0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻0𝐓𝔻
36: ℂ𝐋𝐠𝐋𝐠𝐋𝐠𝐋𝐝𝐬𝕏𝐬
37: α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊α𝕊
38: 𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝔸𝐥

Explicação:

• Para 1, usamos o token 'check for igualdade', aqui explorando que quando Neim tenta exibir entradas vazias, obtém 0. Como 0 e 0 são equivalentes, isso empurra 1, que é impresso implicitamente
• De 2 a 9, usamos apenas literais numéricos.
• De 10 a 32, Neim realmente tem constantes de um byte para todas elas (sim, é uma loucura).
• Para 33, usamos apenas o comando increment. No primeiro byte, o Neim tenta exibir algo para incrementá-lo, mas, como a entrada está vazia, o padrão é popping 0.
• Para 34, usamos a mesma abordagem, mas diminuindo e assumindo o valor absoluto.
• Para 35, estamos explorando o fato de que zero fatorial é um, e usamos isso duplicando o fator e adicionando repetidamente
• Para 36, ​​usamos ℂ0 e 0 para verificar a co-primalidade, quais são. Isso empurra 1. Em seguida, obtemos o primeiro uso primo 𝐋, o que resulta em uma lista de singleton contendo apenas 2. Em seguida, obtemos o maior elemento ( 𝐠), que empurra 2 como um número. Então repetimos esse processo até chegarmos à lista [2 3 5 7 11]. Depois disso, usamos o 𝐝cálculo dos deltas, resultando na lista [1 2 2 4]. Em seguida, usamos 𝐬a soma - que é 9 - e calculamos o intervalo exclusivo de 0 a 9, resultando em [0 1 2 3 4 5 6 7 8]. Finalmente, 𝐬é usado novamente para obter 37.
• Para 37, αé uma constante que representa uma negativa, e repetidamente a pressionamos e subtraímos (novamente explorando o fato de que, quando tentamos abrir a entrada vazia, 0 é pressionado)
• Para 38, mais uma vez usando o 0 padrão para entrada vazia, continuamos anexando 0 a si próprio, criando uma lista longa e calculando o comprimento.

Pode ser experimentado aqui

Python 2, 15

Aqui está um começo, procurando mais

Graças a leo cuja dica me ajudou a chegar a 15

[[[]]>[]][[]>[]]>>[[]>[]][[]>[]]

---

2

---

import math
print'%i'%math.pi

---

((()<())<())<<((()<())<())<<((()<())<())

---

5

---

6

---

7

---

8

---

9

---

11^1 

---

33/3

---

4--4--4

---

__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__+__debug__

---

q=""=="";qq=q=="";qqq=~q*~q*~q;~qqq*~q*~qq

---

0xF

Japt , 448 bytes, pontuação 42

Uma grande colaboração entre Shaggy , ETHproductions e Oliver .

v
y
Íà
Qiiii)iiii)âQ
ÂHq
LÁL
´Vn´VnVnVn
8
9
A
B
C
D
E
F
G
J-----J---J---J---J
[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x
;Iìw
~~½e½e½e½e~½e½
++T+++T+++T+++T+++T+++T
22
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
4á
5²
°UU°°°U°°U°°U°°U°°U
»³³
7/¼
$'_____________________________b'$bb
ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa
Sc
33
Mg011
##
6p
Rí í í í í è.
`¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥`l
¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o
º¤¤*º¤*º¤
(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å
Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

Estes caracteres (úteis) são deixados:

!%&,:=>?@OPWX\dfhjkrstuz{}¡¢£¦§©ª«¬®¯¸ÀÃÆÇÈÐßãäåæçéêëîïñóôõö×øÿ

---

Explicações

Algumas coisas a saber sobre Japt antes de começarmos, das quais fiz uso frequente. Primeiramente, o Japt possui 6 variáveis ​​reservadas para entrada, sendo essas as maiúsculas U-Z. Se nenhuma entrada for passada por essas variáveis, todas elas serão padrão 0. A segunda coisa é abordada nesta dica .

Clique em qualquer trecho para experimentá-lo no intérprete online .

---

v

Quando aplicado a um número, o vmétodo usa um número inteiro n como argumento e retorna 1 se o número for divisível por n , 0 se não. Se n não for fornecido, o padrão será 2 . 0 (o valor padrão para U) é divisível por 2 , então isso nos dá nosso 1 .

---

y

Muito parecido com o primeiro. Quando aplicado a um número, o ymétodo pega um número inteiro n como argumento e retorna o GCD dos dois números. Se n não for fornecido, o padrão será 2 . Como 0 é divisível por 2 , o MDC (0, 2) nos dá nossos 2 .

---

Íà

Íé o atalho para n(2)ou 2- this. Porque não temos entrada, nós padrão thispara 0, o que resulta em 2-0 = 2.

àretorna o número de combinações de [1...this], que retorna 3

---

Qiiii)iiii)âQ

Qo padrão é aspas simples. iem uma string insere outra string no começo; conforme explicado em # 3 , cada um iiii)é equivalente a .i("i".i("i"))JS, inserindo duas cópias ino início da sequência. Faça isso duas vezes e você terá a string iiii". âQentão simula .search(Q), fornecendo o índice do primeiro "na sequência, que é 4 .

---

ÂHq

Hé a constante para 32 . Quando aplicado a um número do qmétodo, que leva inteiro n como um argumento, retorna o n ^th raiz desse número. Se n não é fornecido o valor padrão é 2 assim Hqnos dá a raiz quadrada de 32, que é de aproximadamente 5,6568 . Âé o atalho para ~~, que pavimenta o resultado, fornecendo 5 .

---

LÁL

Lé predefinido para 100 e Áé o atalho para >>>(deslocamento à direita bit a bit de preenchimento zero). 100>>>100é o mesmo que 100>>>4(o operando direito envolve o mod 32), que é 6 .

---

´Vn´VnVnVn

Como observado anteriormente, o Vpadrão é 0 . ´é o atalho para o --operador, portanto, o código é equivalente ao seguinte JS:

(--V).n((--V).n(V.n(V.n())))

X.n(Y)é equivalente a Y - X ou -X + Y ; o primeiro --Vretorna -1 e o segundo -2 , então isso é equivalente a - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . Simplificando, obtemos 1 + 2 + 2 + 2 = 7 .

---

8
9

Literalmente, 8 e 9 .

---

A
B
C
D
E
F
G

Estas são as constantes para 10 - 16 , inclusive.

---

J-----J---J---J---J

Jestá predefinido para -1 . O interpretador Japt de alguma forma consegue analisar isso corretamente, como (J--) - (--J) - (--J) - (--J) - (--J). Fazendo um pouco mais de matemática, descobrimos que isso é equivalente a (-1) - (-3) - (-4) - (-5) - (-6) ou -1 + 3 + 4 + 5 + 6 = 17 .

---

[¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾]x

¾é, como você pode imaginar, um atalho para .75. Colocamos 24 cópias de 0,75 em uma matriz e depois somamos x, dando 0,75 * 24 = 18 .

---

;Iìw

Eu acho que este é o meu favorito. ;no início do programa altera os valores de algumas das constantes japt; sem ele Ié 64 , mas com ele Ié 91 . ìwconverte-o em uma lista de dígitos e é executado wna lista, revertendo a matriz e depois volta a ser um número para obter 19 .

---

~~½e½e½e½e~½e½

½é um atalho para .5. eem um número x recebe um argumento y e retorna x * 10 ^y . Portanto, a cadeia de cálculos que acontece é:

           ½e½     1.5811  (.5 * sqrt(10))
          ~       -2
        ½e         0.005  (.5 * (10 ** -2))
      ½e           0.5058
    ½e             1.6024
  ½e              20.0138

E a final ~~serve como base para um número inteiro, produzindo o resultado de 20 .

---

++T+++T+++T+++T+++T+++T

Testá predefinido para 0 . ++é o operador de incremento em JS e também em Japt; T+++Té analisado como (T++) + T, mas ++T+++Té analisado como (++T) + (++T), portanto, isso é equivalente ao código JS

(++T) + (++T) + (++T) + (++T) + (++T) + (++T)

O resultado é 1 + 2 + 3 + 4 + 5 + 6 , que soma 21 .

---

22

Um literal 22 .

---

ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ

Äé um atalho para +1, então isso simplesmente soma 23 1 s.

---

4á

Isso encontra o número de permutações de [1, 2, 3, 4], que é 4! = 24 .

---

5²

²é um atalho para p2, que eleva um número à potência de dois. 5 ** 2 é 25 .

---

°UU°°°U°°U°°U°°U°°U

°é um atalho para o ++operador ou, se não puder ser analisado como tal + +,. Como observado anteriormente, quando não há entrada, o Upadrão é 0 . Portanto, o código é equivalente a (++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U), que é muito semelhante ao # 17 : Uprimeiro é incrementado 1, depois repetidamente incrementado e adicionado, de modo que o resultado final seja 1 + 3 + 4 + 5 + 6 + 7 = 26 .

---

»³³

³é o atalho para o pmétodo com um argumento 3 . No entanto, se uma letra minúscula aparecer diretamente após um parêntese esquerdo ( »é o atalho para ((), ela se tornará uma sequência. Isso permite que ele seja passado para um método e chamado como uma função (ou seja, m³seria mapeado por .p(3)). Nesse caso, no entanto, ("p",3)retorna nosso 3, então aumentamos o poder de 3( pé o método de poder quando aplicado a um número), o que nos dá 27 .

---

7/¼

¼, como você provavelmente já sabe, é um atalho para .25, portanto, calcula 7 / 0,25 = 28 .

---

$'_____________________________b'$bb

Tudo o que $estiver envolto em símbolos é tratado como JavaScript puro, por isso temos uma sequência de 29 sublinhados seguida por a b. (Sem o $, 'seria uma cadeia de caracteres únicos.) O bmétodo, quando aplicado a uma cadeia, retorna o primeiro índice de seu argumento nessa cadeia. Conforme explicado no item 3 , o último bé convertido em uma sequência, então estamos pegando o primeiro índice de bnossa sequência, que é 29 .

---

ZµÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉ

µé um atalho para -=e Épara -1. O efeito está subtraindo 30 cópias de -1 de 0 , o que dá 30 .

---

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"aa

Muito parecido com # 29. O amétodo, quando aplicado a uma string, retorna o último índice de seu argumento nessa string. Usando a indexação 0, o último índice de auma sequência de 32 as é 31 .

---

Sc

Sé predefinido para um único espaço e, cem uma sequência de caracteres únicos, retorna seu código de caracteres, fornecendo 32 .

---

33

Literal 33 .

---

Mg011

MgNretorna o número enésimo de Fibonacci. 011é 9 em octal; o 9º número de Fibonacci é 34 .

---

##

#retorna o código de caractere do próximo caractere. O código de caractere por #si só passa a ser 35 , tornando nosso trabalho aqui especialmente fácil.

---

6p

pé exponenciação e, sem um segundo argumento, o padrão é 2 ; portanto, isso imprime 6 ** 2 = 36 .

---

Rí í í í í è.

Este é um pouco complicado. Ro padrão é um único caractere de nova linha (que é uma nova linha se torna importante posteriormente). íem uma string, sem argumentos, pega cada caractere e anexa seu índice: uma transformação bastante inútil, mas o resultado através de 5 iterações é o seguinte: (usando em Rvez de uma nova linha literal)

R
R0
R001
R0010213
R001021304251637
R0010213042516370849210511112613314715

Interessante como cada entrada é simplesmente um prefixo da próxima ... Mas, de qualquer maneira, a última parte è., conta quantas correspondências de /./gsão encontradas no resultado. Existem 38 caracteres na string; no entanto, como /./gcorresponde apenas a caracteres que não são de nova linha, o resultado é 37 .

---

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥l

Os backticks marcam uma string compactada e ¥descompactam para ll. lem uma string fornece length; portanto, após a descompressão, isso fornece 38 .

---

¨N|N¹òò¹m···m|¹mò¹m···m|¹mò¹m···m|¹o

Oooh garoto, esse aqui é doozy. Primeiro, geramos truecom ¨N( ¨significa >=e Nsem entradas é a matriz vazia), depois convertemos isso em 1com |N. A partir daí, fica muito louco:

ò    Inclusive range [0..1],            [0, 1]
 ò   making each an inclusive range.    [[0], [0, 1]]
m·   Join each on newlines.             ["0", "0\n1"]
·    Join on newlines.                  "0\n0\n1"
·    Split on newlines.                 ["0", "0", "1"]
m    Map each item X and index Y to     
 |     X | Y.                           ["0" | 0, "0" | 1, "1" | 2] -> [0, 1, 3]
m    Map each by 
 ò     inclusive range.                 [[0], [0, 1], [0, 1, 2, 3]]
m··· Same as before.                    ["0", "0", "1", "0", "1", "2", "3"]
m|   Bitwise OR thing again.            [0, 1, 3, 3, 5, 7, 7]
mò   Map each by inclusive range.       [[0], [0, 1], ..., [0, 1, 2, 3, 4, 5, 6, 7]]
m··· Same as before.                    ["0", "0", ..., "5", "6", "7"]
m|   Bitwise OR again.                  ["0"|0, "0"|1, ..., "5"|30, "6"|31, "7"|32]
                                        -> [0, 1, ..., 31, 31, 39]

(Os ¹são apenas substitutos para parênteses próximos e foram omitidos.) A final oaparece e retorna o item final na matriz, dando 39 .

---

º¤¤*º¤

Principalmente o mesmo truque do # 3 . ¤é o atalho para o smétodo com um argumento 2 . Nesse caso, no entanto, o código transpilado é (("s", 2).s(2) * (("s", 2) * (("s", 2)))), ou simplificado (2).s(2) * (2 * 2). .s(2)retorna o número como uma string de base 2, que fornece "10"; * (2 * 2)implicitamente converte isso em um número e multiplica por 4 , resultando em 40 .

---

(Å<<(Å<<(Å<<(Å<<(Å<<(Å^(Å<<(Å<<(Å<<(Å^(Å

Semelhante ao anterior. Åé o atalho para o smétodo com um argumento 1 . Nesse caso, no entanto, cada um (Åtranspila para ("s", 1), o que apenas retorna 1 . 1<<1<<1<<1<<1<<1é 32 e 1<<1<<1<<1é 8 ; estes são XORed junto com 1para obter 41 .

---

Y±Y¶YY±YY±Y±Y¶YY±YY±Y±Y¶YY±Y

±é um atalho para +=e ¶para ===. Isso significa que o código é realmente

Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y,Y+=Y+=Y===Y,Y+=Y

Y===Y é sempre verdade, para que possamos simplificar isso:

Y+=1,Y+=Y,Y+=Y+=1,Y+=Y,Y+=Y+=1,Y+=Y

0 + 1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ; 21 + 21 = 42 .

PHP, pontuação 17, 130 bytes

caracteres usados ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx

Z==Z
FTP_MOREDATA
';'&w
![]<<![]<<![]
5
6
"#"|"$"|"1"
8
SIGKILL
333333>>3>>3>>3>>3>>3
99/9
22-2-2-2-2-2
strspn(XXXXXXXXXXXXXX,X)
7+7
0xf
4*4
ha^YV

1 Constante booleana Z (não definida) igual constante Z

2 FTP_MOREDATA é uma constante no PHP com o valor 2

3 bit a bit e caracteres; e W

4 bit a bit Shift esquerdo e lógico não convertido em array vazio para boolean true com é convertido em número inteiro 1 através do operador shift left

7 bit a bit Ou caracteres # e $ e 1

9 SIGKILL é uma constante em PHP com o valor 9

10 bit a bit Shift para a direita, cada etapa é uma divisão inteira com 8, portanto temos as etapas 333333, 41666, 5208, 658, 651, 81, 10

13 caracteres char X na string X ... desde o início

15 valor hexadecimal f = 15

17 Xor bit a bit com as cadeias ha e YV

Todos os snippets são itens em uma matriz

Experimente online!

PHP, pontuação 16, 94 bytes

caracteres usados AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789

Z==Z
":"&"w"    
M_PI|[]
TRUE<<TRUE<<TRUE
5
6
A^v    
8
9
!$s.strlen($s)    
77/7
3+3+3+3
111>>1>>1>>1    
22-2-2-2-2
0xf
4*4

1 Constante booleana Z (não definida) igual constante Z

2 bit a bit e caracteres: ew

3 Pi convertido para valor inteiro por meio de matriz vazia convertida em zero

7 xor char a bit A e v

10 variável $ s não configurada! $ S = uma concat com comprimento de string da variável $ s

13 111/2 = 55/2 = 27/2 = 13 Divisão inteira bit a bit

15 valor hexadecimal f = 15

Todos os snippets são itens em uma matriz

Experimente online!

PHP, pontuação 14, 84 bytes

caracteres usados $!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx

Z==Z
2
M_PI^[]
4
5
6
ERA%11
8
9
!$s.strlen($s)
77/7
3+3+3+3
0xd    
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-NULL

1 Constante booleana Z (não definida) igual constante Z

3 Pi convertido para valor inteiro por meio de matriz vazia convertida em zero

7 ERA é uma constante com o valor 131116 mod 11 = 7

10 variável $ s não configurada! $ S = uma concat com o comprimento da string da variável $ s é zero

13 valor hexadecimal d = 13 14 bit a bit não e sinal de menos aumenta NULL para 14

Todos os snippets são itens em uma matriz

Experimente online!

R, pontuação 13 14

F^F                       # F==0 in R
q=""=="";q--q             # ""=="" is TRUE, TRUE == 1 (Thanks WheatWizard)
3
4
5
6
7
8
9
1e1                       # scientific notation for 10
22/2
T+T+T+T+T+T+T+T+T+T+T+T   # T == 1
0xD                       
sum(mtcars$vs)            # mtcars is a built-in dataset, summing the $vs column gives 14

Obteve um extra graças ao user2390246.

Caracteres utilizados:

0123456789acemqrstuvxDFT^=";-/+()$

MATL , pontuação 21 22 23 números (273 bytes)

Agradecemos a J Doe por estender de 22 para 23 números!

0~
'bd'd
{P}gk
HH^
5
6
7
8
9
3 3.333333333333333*
11
IEE
[B]Yq
llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx
KUKUa-
4W
FFFFFFFFFFFFFFFFFn
TTTTTTTTTTTTTTTTTTs
rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz
OOOOOOOOOOOOOOOOOOOOvZyX>
JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/
22
`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Experimente online! Cada trecho no link é finalizado porD(exibição) ou]D(loop fechado explicitamente e exibição) para limpar a pilha e, assim, isolar-se do próximo trecho.

Explicação

0~

Empurre 0. Negar. Dá true, que é exibido como 1.

'bd'd

Empurre a corda 'bd'. Diferença consecutiva entre os pontos de código dos caracteres.

{P}gk

Empurre a matriz de células que contém o número pi. Converta em matriz numérica (ou seja, em um único número). Arredondar para baixo.

HH^

Empurre 2duas vezes. Poder.

5

Literal numérico.

6

Literal numérico.

7

Literal numérico.

8

Literal numérico.

9

Literal numérico.

3 3.333333333333333*

Empurre 3. Empurre 3.333333333333333. Multiplicar. Devido à precisão do ponto flutuante, isso fornece 10.

11

Literal numérico.

IEE

Empurre 3. Multiplique 2duas vezes.

[B]Yq

Empurre [6](que é o mesmo que 6). Calcular o n- ésimo primo.

llllllllllllllNwxwxwxwxwxwxwxwxwxwxwxwxwxwx

Empurre 114 vezes. Número de elementos na pilha. Limpe o restante da pilha.

KUKUa-

Empurre 4. Quadrado. Faça o mesmo. Qualquer: dá 1. Subtrair.

4W

Empurre 4. 2elevado a isso.

FFFFFFFFFFFFFFFFFn

Empurre a matriz [false false ... false](17 vezes). Número de elementos na matriz.

TTTTTTTTTTTTTTTTTTs

Empurre a matriz [true true ... true](18 vezes). Soma da matriz.

rrrrrrrrrrrrrrrrrrrhhhhhhhhhhhhhhhhhhz

Pressione 19 números aleatórios retirados do intervalo (0,1). Concatene horizontalmente 18 vezes. Número de elementos diferentes de zero na matriz.

OOOOOOOOOOOOOOOOOOOOvZyX>

Empurre 020 vezes. Concatene o conteúdo da pilha verticalmente (fornece um vetor de coluna). Tamanho: fornece a matriz [20 1]. Máximo de matriz.

JJJJJJJJJJJJJJJJJJJJJ++++++++++++++++++++J/

Empurre 1j(unidade imaginária) 21 vezes. Adicione 20 vezes. Divida por 1j.

22

Literal numérico

`@QQQQQQQQQQQQQQQQQQQQQQ@@<

Faça ... while loop ( `) com final implícito. Na primeira iteração, ele empurra o índice de iteração ( @) e o incrementa ( Q) 22 vezes, o que gera 23. A condição do loop ( @@<) é falsa; portanto, o loop é encerrado.

Algumas idéias para melhorias adicionais

• (espaço) no snippet 10 pode ser substituído por |
• X>no snippet 20 pode ser substituído por p, liberando assim o prefixo X.
• Atualmente não utilizadas e potencialmente útil: :,A

Vim 8 no Windows, pontuação 13, 104 bytes

1
2
3
4
5
6
7
^R=&ts^@
9
8^O^A^O^A
0^[^X^X^X^X^X^X^X^X^X^X^X0x
:h<CR>wwwwwwwwwwwy$:q<CR>p
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD

^{keystroke}representa <C-{keystroke}>, assim ^Xé <C-x>, exceto o ^@que é <C-j>. Ainda estou tentando adicionar mais números a esta lista e <CR>representa um avanço de linha.

Nota: para executar esses comandos, inicie o vim usando -u NONE -U NONE. Isso é para garantir que suas configurações não interfiram no código.

Os fragmentos 1 a 10 iniciam no modo de inserção. Enquanto os trechos 12 e 13 começam no modo normal.

Explicações

O snippet 8 é :^R=&ts^@. Tenho que agradecer @ L3viathan para chegar com isso e @ nmjcman101 por sugerir ^@como um substituto para o avanço de linha e @ ØrjanJohansen para encurtar &tabstopa &ts. &tsavalia o tamanho da guia, que é por padrão 8 e esse valor é inserido no editor.

O snippet 10 é 8^O^A^O^A. Inserimos um 8 e, em seguida, incrementamos duas vezes para obter 10.

O fragmento 11 é 0^[^X^X^X^X^X^X^X^X^X^X^X0x. Escrevemos um 0 e diminuímos 11 vezes para obter -11. Em seguida, removemos o sinal de menos para obter 11.

O fragmento 12 é :h<CR>wwwwwwwwwwwy$:q<CR>p. Isso abre o menu de ajuda do Vim 8, que contém as seguintes informações:

*help.txt*  For Vim version 8.0.  Last change: 2016 Sep 12

E a sequência de ws passa para o 12, momento em que y$copia o número. Em seguida, é colado no editor usando p.

O snippet 13 grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llDagradece a @DJMcMayhem por ter vindo com ele. Isso funciona apenas no Windows. O trecho procura no menu de ajuda por comandos que começam com g. Em seguida, ele desce usando jpara chegar a esta linha:

|g?|        g?      2  Rot13 encoding operator

após o que ele copia e cola no buffer. Depois disso, tudo, exceto os 13, é removido do buffer.

Mathematica, pontuação 13

x~D~x
⌊E⌋
3
⌈Pi⌉
5
6
LucasL@4
8
9
0!+0!+0!+0!+0!+0!+0!+0!+0!+0!
77/7
Tr[{11,1}]
-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I-I*I

05AB1E , pontuação 18, 67 bytes

X     Variable is initialized to 1
Y     Variable is initialized to 2
2>     2 + 1
4
5
6
7
8
9
T     Constant 10
3b     3 in binary
•C     Ascii code of 'C'
11Ì     11 in hex
A'ok     Index of 'o' in the alphabet
žz¨¤x+     Middle character of '256' times 2, plus itself
¾<<<<n     Variable initialized to 0, 4 times -1, squared
‘c‘‘c‘QDJH     'c' equals itself (true = 1), duplicated, converted from hex to dec
тD÷·±D*·     Constant 100, divided by itself, * 2, bitwise not, times itself, * 2
"d"aÐÐÐÐÐÐÐÐÐ)O     "d" is_alpha (true = 1), triplicated 9 times, total sum

Experimente online!

PingPong , pontuação 127

No PingPong, cada caractere tem seu próprio valor numérico distinto, tornando a contagem até 127 uma tarefa trivial. A linguagem funciona lendo o valor de cada caractere e empurrando-o para o topo de uma pilha, onde todas as operações são executadas. Teoricamente, o PingPong pode ultrapassar 127, mas seria necessário passar um bloco de caracteres que simplesmente aparecem como espaços em um editor de texto, então eu os deixei de fora da minha solução.

1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: A
11: B
12: C
13: D
14: E
15: F
16: G
17: H
18: I
19: J
20: K
21: L
22: M
23: N
24: O
25: P
26: Q
27: R
28: S
29: T
30: U
31: V
32: W
33: X
34: Y
35: Z
36: a
37: b
38: c
39: d
40: e
41: f
42: g
43: h
44: i
45: j
46: k
47: l
48: m
49: n
50: o
51: p
52: q
53: r
54: s
55: t
56: u
57: v
58: w
59: x
60: y
61: z
62: ©
63: ®
64: À
65: Á
66: Â
67: Ã
68: Ä
69: Å
70: Æ
71: Ç
72: È
73: É
74: Ê
75: Ë
76: Ì
77: Í
78: Î
79: Ï
80: Ð
81: Ñ
82: Ò
83: Ó
84: Ô
85: Õ
86: Ö
87: ×
88: Ø
89: Ù
90: Ú
91: Û
92: Ü
93: Ý
94: Þ
95: ß
96: à
97: á
98: â
99: ã
100: ä
101: å
102: æ
103: ç
104: è
105: é
106: ê
107: ë
108: ì
109: í
110: î
111: ï
112: ð
113: ñ
114: ò
115: ó
116: ô
117: õ
118: ö
119: ÷
120: ø
121: ù
122: ú
123: û
124: ü
125: ý
126: þ
127: ÿ

Oitava, Pontuação 14, 74 bytes

Tenho certeza de que estou perto do limite agora.

1:  ~0                        % Not 0 == 1
2:  "H"/"$"                   % "H" = 72, "$" = 36. H/$ = 2
3:  3                         % Literal
4:  4                         % Literal
5:  5                         % Literal
6:  6                         % Literal
7:  7                         % Literal
8:  8                         % Literal
9:  9                         % Literal
10: ceil(pi*pi)               % pi*pi = 9.87. ceil(9.87) = 10
11: 11                        % Literal
12: 2+2+2+2+2+2               % Well, not much to say
13: ['','RT'-'!']             % 'RT' = [82,84]. Subtract '!' (33) to get ['',49,51]=13
14: nnz...                    % Number of non-zero elements in the string...
    nnnnnnnnnnnnnn            % on this line. (This is an awesome trick by the way!)

Teve de remover strchruma vez que já tem cem número 10. Eu ainda tenho j, ^, =, !, espaço e guia horizontal (ASCII-9) para a esquerda, por isso pode ser possível espremer mais um em.

A guia horizontal pode ser usada como um espaço, portanto, o truque usado com strchre nnzpode ser usado mais uma vez. As únicas letras minúsculas restantes são abdfgjkmoquvwxy. Não há muitas funções que possam ser feitas com essas funções. modpoderia funcionar, mas não pode receber entrada de string.

É fácil usar os caracteres restantes para obter 1, mas não sei como conseguir mais nada.

Teste tudo .

Possivelmente útil: fun aé o mesmo que fun('a'), fun a bé o mesmo fun('a','b')e assim por diante. Isso pode ser usado em vários lugares:

gt t g    % Equivalent to 't'>'g'. Returns 1. Uses space (available)
or o r    % Equivalent to 'o' | 'r'. Returns 1. 

Usar isso 0disponibilizará, mas ainda não consigo ver como torná-lo útil.

e (2.71828...)e jainda não são utilizados. Deve remover ceilpara usar eembora.

Alternativas (inspiração):

1:  ~0             % Not 0 = 1
2:  2              % Numeral
3:  3              % Numeral
4:  fix(i^i^i^i)   % Numeral
5:  5              % Numeral
6:  6              % Numeral
7:  7              % Numeral
8:  8              % Numeral
9:  9              % Numeral 
10: 1+1+1+1+1+1+1+1+1+1   % Well, not much to explain
11: ['','RR'-'!']  % RR are [82,82] in ASCII, subtract 33 (!) to get
                   % [49,49], and concatenate with the empty string to convert [49,49] to 11 
12: nnz nnnnnnnnnnnn   % Number of non-zero elements in the string containing 12 n
13: "4"/4          % "4" = 52. Divide it by 4 to get 13.

JavaScript (ES7), 16 números inteiros, 137 130 128 bytes

Tomei resposta @ETHproductions e correu com ela por um tempo; mudou tanto que estou postando separadamente. Idéias são bem vindas. :)

""**""
-~-~{}
3
C=CSS==CSS;C<<C<<C
5
6
7
8
9
++[[]][+[]]+[+[]]
11
4444444444444444444%44
222>>2>>2
`..............i`.indexOf`i`
0XF
atob('MTY')

Remanescente:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

Ou, se o snippet de 1 for substituído por !!/!//!!/!/:
$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz

---

JavaScript (ES7), 16 números inteiros, 127 bytes

Um byte mais curto. : P

""**""
-~-~{}
3
4
5
6
7
C=CSS==CSS;C<<C<<C<<C
9
++[[]][+[]]+[+[]]
11
`............i`.indexOf`i`
222>>2>>2
0XE
atob('MTU')
88888888888888888%88

Remanescente: $_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz

Dyalog APL, pontuação 15, 89 bytes

≡''
≢###
3
4
⍴⍬⍬⍬⍬⍬
6
⌈○2
8
9
1E1
⎕D⍳⊂⎕D











l:l
7--7-×7
(~0 0 0 0 0 0 0 0 0 0 0 0 0 0)⊥~0
5+5+5

_{As novas linhas anteriores l:lfazem parte de 12.}

_{Os espaços em 14 representam tabulações.}

> <> , pontuação 20, 93 90 74 65 bytes

(3 bytes salvos pelo Teal Pelican, muitos bytes salvos por Jo King!)

iii((
2
3
ll{lll{[
5
6
7
8
!   00=0g
a
b
c
d
e
f
44*
'RA'%
999-9--
"&F#",,
1::+:++:+:+

Experimente-os no parque infantil de peixes! Você pode fazer com que os trechos imprimam seus resultados adicionando n;ao final de cada um. Observe que o nono snippet contém uma guia que é consumida pela troca de pilhas.

Explicação:

• Em iii((, cada um itenta obter entrada, mas como não há, eles pressionam EOF = -1. Então (é a instrução menor que, e como -1não é menor que -1, empurra uma falsa 0; mas o segundo (pergunta se -1é menor que 0, o que é, então empurra uma verdade 1.
• 2e 3são óbvias.
• Pois ll{lll{[, o primeiro lempurra o comprimento da pilha, ou seja 0, o segundo empurra o novo comprimento, trazendo a pilha para 0, 1. O {gira a pilha para a esquerda, trocando o 1e 0. Mais três ls trazem a pilha para 1, 0, 2, 3, 4. Em seguida, {gira 1para a frente e [extrai a primeira 1coisa na pilha, que é 4.
• 5, 6, 7E 8são óbvias demais.
• Em !\t00=0g(onde \trepresenta uma guia), !pula a guia e 00=pressiona dois zeros e verifica se são iguais - eles são, então temos uma verdade 1. Depois de pressionar outro 0, o gpersonagem fica na posição 1,0do código, que é a guia do código de caractere 9.
• aatravés de fcada push 10para 15respectivamente (presumivelmente para tornar hexadecimal agradável).
• 44*empurra dois se 4multiplica-os juntos, por 16.
• 'RA'envia os códigos de caracteres de Re A(82 e 65 respectivamente) para a pilha e depois %calcula 82 mod 65 = 17.
• 999-9--avalia a 9 - ((9 - 9) - 9) = 18.
• "&F#"empurra os códigos de caracteres de &, Fe #, que são 38, 70e 35respectivamente. Então ,é a divisão, então chegamos 38 / (70 / 35) = 19.
• Por fim, 1::pressiona ae 1duplica duas vezes, +adiciona duas para obter 2; :+duplica o 2e adiciona a si próprio para obter 4; +adiciona o restante 1para obter 5; em seguida, :+:+duplica e adiciona duas vezes, resultando em 20.

Esta é a pontuação máxima possível com> <>. Qualquer trecho deve incluir uma instrução em algum lugar que se transforma uma pilha vazia em uma pilha não-vazia, e há apenas 18> <> instruções que podem fazer isso (ou seja i, le os dígitos 0–9e a–f), além de modo de string. (Todas as outras instruções não fazem nada em uma pilha vazia ><v^/\|_#x!{}rou tentam exibir algo e erros ?.+-*,%=():~$@[]on&gp.) A entrada no modo de seqüência de caracteres usa um "ou outro ', para que haja no máximo 18 + 2 = 20trechos possíveis.

---

Se você está mais confortável com unprintables do que eu sou, isso é possível em 53 bytes, graças a Jo King: 00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z", onde a X, Ye Zsão substituídos por caracteres com códigos 17, 19e 20respectivamente.

MathGolf , 48 51 53 inteiros, 324 bytes

î
ª∞~
c±b±+
φⁿ_¥-
5
6
7
○¢i♀/
d²
♂
A
B
C
D
E
☻
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
♥
U
V
W
X
Y
Z
♫¼¼¼¼
88888]Σ
41
╔½½½½½½½½½½½
π░3§3
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$
ÿ@@@@£9
))))))))))))))))))))))))))))))))))))))))))))))))))
►◄╠•╠
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h 
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((

+2 pontos (e -2 bytes distintos usados 40) graças a @maxb .

Cada linha é um programa separado.

Bytes usados ​​(92 bytes distintos): îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(

Explicação e links TIO:

MathGolf é uma nova linguagem de golfe especializada em desafios matemáticos de golfe. Ele possui um monte de componentes de byte único para números, tornando este um desafio perfeito para ele.

1) î: Pressione o valor indexado em 1 do loop, que é 1 por padrão: Experimente online.
2) ª∞~: Pressione [1]; dobrar ([2]); lista pop e coloque seu conteúdo na pilha: Experimente online.
3) c±b±+: Pressione -2; depois pop e pressione seu valor absoluto; empurre -1; depois pop e pressione seu valor absoluto; e adicione-os juntos Experimente online.
4) φⁿ_¥-: Empurre a proporção áurea (1,618033988749895); cubo-lo (4.23606797749979); duplicar a parte superior da pilha; tome o módulo 2 (0,23606797749979); subtraia-os um do outro: Experimente online.
5,6,7) Os próprios números: Experimente online.
8) ○¢i♀/: Pressione 2048; converter para uma cadeia hexadecimal (800); converter para inteiro; empurre 100; dividir: Experimente online.
9) d²: Pressione -3; quadrado: Experimente online. 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33, 34,35,36,37,38) Envie os builtins para os próprios números ( ♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ): experimente online.
39) ♫¼¼¼¼: Pressione 10000; número inteiro dividido por 4 quatro vezes: Experimente online.
40) 88888]Σ: Empurre 8 cinco vezes; envolva-os em uma lista; some essa lista: experimente online.
41) O número em si: Experimente online.
42) ╔½½½½½½½½½½½: Pressione 86400; inteiro dividido por 2 onze vezes: Experimente online.
43) π░3§3: Pressione PI (3.141592653589793); moldar a corda; pop e pressione seu terceiro caractere indexado em 0 (4); empurrão 3; produza a pilha inteira unida implicitamente: 44)Experimente online. : Pressione 2 duas vezes; tome o poder dos dois (4); faça isso novamente; produza a pilha inteira unida implicitamente: Experimente online. 45) : Pressione 2 * PI (6.283185307179586); estale e empurre a potência de 2 abaixo dela, a mais próxima (4); empurre o topo da pilha + 1 sem estourar (5); produza a pilha inteira unida implicitamente: Experimente online. 46) : Pressione 64; diminuir por 2 nove vezes: Experimente online. 47) : Pressione gamma (n + 1) (1 por padrão); incrementar em 2 vinte e três vezes: Experimente online. 48) : Empurre a corda
22#22#
τ╥└
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
'0$: Pressione o valor ordinal do caractere '0': experimente online.
49)ÿ@@@@£9"@@@@"; estale e empurre seu comprimento (4); empurrão 9; produza a pilha inteira unida implicitamente: Experimente online.
50) )))))))))))))))))))))))))))))))))))))))))))))))))): Incremento de 1 cinquenta vezes: Experimente online.
51) ►◄╠•╠: Empurre 1.000.000; Empurre 10.000.000; pop tanto e inteiro - divida-os um com o outro (10); push 512; pop tanto e inteiro-divida-os um com o outro: Experimente online.
52) "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h : Empurre a corda "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"; empurre seu comprimento (sem esticar a corda); remova tudo da pilha, exceto o último item: experimente online.
53) ♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((: Pressione 128; decrementado em 1 setenta e cinco vezes: Experimente online.

Tentará adicionar um pouco mais adiante. Ainda tenho algumas coisas úteis, incluindo módulo %e multiplicação *.

Java 8, 11 12 13, 39 bytes

Java possui apenas 10 símbolos para números (0-9) e todas as chamadas e constantes de métodos requerem um período, portanto, não tenho certeza se posso obter acima de 11 saídas

Aparentemente, os caracteres convertidos para números inteiros por padrão quando operações são aplicadas

+1 com a ajuda de @ OlivierGrégoire

i->-~i
2
3
4
5
6
7
8
9
'P'^'Z'
11
"::::::::::::"::length
0xD

Explicações:

i->-~i

número inteiro lambda que não recebe entrada e retorna 1. Quando um parâmetro não recebe entrada, o valor padrão é usado conforme o meta post acima, que para números inteiros é 0

2
3
4
5
6
7
8
9

inteiros literais

'P'^'Z'

XOR de dois caracteres para retornar 10

11

inteiro literal

":::::::::::"::length

expressão lambda que retorna o comprimento de uma sequência de 12 caracteres

0xD

Hexadecimal 13

Link TIO se você deseja verificar.

Gaia , pontuação 25, 203 bytes

§‼
..⌉+⌉
₵P~~
4
5
6
∂Ql
8
9
¶c
11
'¡ċ⌋u⌋
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
7:,Σ
Ø!))))))))))))))
øøw<øøw<«øøw<«øøw<«øøw<«
⟩‘
₸ḣ₸K$₸ḣ₸/S₸₸/=$
]]]]]]]]]]]]]]]]]]]n
⇑’e
0(((((((((((((((((((((_
22
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
3₈×
ℍḥḥ

Considero isso uma pontuação perfeita, já que nenhuma outra nilada pode ser usada, dadas as limitações do personagem.

Explicações

1 §‼

§é um caractere de espaço, ‼é coerente com booleano; portanto, o resultado é 1.

2) ..⌉+⌉

.é um atalho para 0.5, então é isso ceil(0.5+ceil(0.5)).

3) ₵P~~

₵P é pi, ~ é uma negação bit a bit. A negação bit a bit dupla é simplesmente truncamento.

4) 4

5) 5

6 6

7) ∂Ql

∂Qé uma lista que contém os nomes dos dias da semana e lé longa.

8) 8

9 9

10) ¶c

Ponto cde código do avanço de linha ¶.

11) 11

12) '¡ċ⌋u⌋

'¡  The string "¡"
ċ   Turn it into a list of code points: [161]
⌋   Minimum: 161
u⌋  Floored square root: 12

13) --⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻

-é uma abreviação de -1, ⁻é subtração. Portanto, isso é -1 - -1 - -1...tempo suficiente para fazer 13.

14) 7:,Σ

Empurre 7, duplique :, emparelhe ,os dois 7s em uma lista e some Σ.

15 Ø!))))))))))))))

Øé uma sequência vazia, assim Ø!como 1. Incremente )1 14 vezes.

16 øøw<øøw<«øøw<«øøw<«øøw<«

øø    Push two empty lists
w     Wrap one of them
<     [] < [[]]? (it is, so push 1)
øøw<  Do the same thing again to push another 1
«     Bitshift 1 left by 1
      Do that same thing again 3 more times to get 16

17 ⟩‘

Fechar uma string ‘faz com que seja um número base-250 literal. ⟩está no valor de byte 17 na página de códigos do Gaia.

18 ₸ḣ₸K$₸ḣ₸/S₸₸/=$

₸     10
ḣ     doubled
₸     10
K     20 choose 10 (184756)
$     Digit list
₸ḣ₸/  20/10 (2)
S     Split the digit list at index 2 ([[1 8][4 7 5 6]])
₸₸/   10/10 (1)
=     Get the first element of that split ([1 8])
$     Join together and print 18

19 ]]]]]]]]]]]]]]]]]]]n

Cada um ]envolve a pilha na lista. Faça isso 19 vezes e obtenha a profundidade nda lista.

20 ⇑’e

Fechar uma string ’faz dela uma lista de pontos de código da página de códigos. edespeja a lista na pilha.⇑tem um ponto de código 20 na página de códigos.

21 0(((((((((((((((((((((_

Decrescente (0 21 vezes e depois negue _.

22) 22

23 “B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B

Converta a string “B”da base 24, onde estão os dígitos de 0 a 23 ↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B. O resultado é 23.

24 3₈×

3 × 8.

25) ℍḥḥ

100 ℍpela metade ḥe novamente pela metade.

C, pontuação 13

Essas são apenas várias constantes inteiras.

0==0
__LINE__
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
'o'/'.' 
2*2*2*2-2-2
strlen("strlenstrlens")

1. 0==0avalia para 1
2. Assume que o código está na linha 2. __LINE__= 2
3. Constante inteira
4. Constante inteira
5. Constante inteira
6. Constante inteira
7. Constante inteira
8. Constante inteira
9. Constante inteira
10. 1+1+1...= 1*10= 10
11. 'o'é 111, '.'representa o ASCII 0x10 não imprimível. 111/10 = 11
12. (2<<2)= 8, 8*2= 16, 16-2-2= 12
13. comprimento da cadeia de "strlenstrlens"= 13

Ohm , pontuação 21 22, 160 bytes totais

╓S@Ri
ΓΓ-Γ-Γ-
αê⌠
¡¡¡¡¼
5
▀lll▀l
ÑÑÑÑÑÑÑÿWÿk
ü`½½
9
..≥°
$$J
3dd
7ƒ
2≡≡≡Σ
║F
4º
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
6DD++
8π
τ╛hτ*
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
1111 11v11%L1111 11v11%L

Experimente online!

Explicações

1 ╓S@Ri

Pressione os segundos da data / hora atual ( ╓S). Obtenha o intervalo inclusivo de 1 a segundos ( @), inverta-o ( R), obtenha o último elemento (i ), que é sempre 1.

2) ΓΓ-Γ-Γ-

Γ é -1, então isso é (-1) - (-1) - (-1) - (-1), que é 2.

3) αê⌠

αêé o número de Euler (2.71828 ...), ⌠é o teto. 3 é o resultado.

4) ¡¡¡¡¼

¡incrementa o contador, ¼empurra o contador.

5) 5

Apenas um literal.

6 ▀lll▀l

▀lll▀é uma literal de string compactada que é equivalente a "of >ic". lleva o comprimento, então o resultado é 6.

7) ÑÑÑÑÑÑÑÿWÿk

Primeiro, pressionamos 7 caracteres de nova linha ( Ñ) e depois uma string vazia ( ÿ). A pilha é agrupada em uma matriz ( W) e, em seguida, o índice da sequência vazia nessa matriz é encontrado.

8) ü`½½

üé um caractere de espaço. `pressiona seu valor ASCII (32) e, em seguida, é reduzido pela metade duas vezes ( ½½).

9 9

Apenas um literal.

10) ..≥°

..é um .caractere literal . Ele é incrementado ( ≥), que analisa a sequência como um número, padronizando para 0, pois não é um número válido, e a incrementa para 1. Em seguida, calculamos 10 ¹ ( °).

11) $$J

$ empurra o valor atual do registro, inicialmente 1. Então, pressione 1 duas vezes, junte a pilha e imprima.

12) 3dd

Pressione 3 e dobre duas vezes.

13) 7ƒ

Empurra o 7º número de Fibonacci.

14) 2≡≡≡Σ

Empurre 2, triplique três vezes, deixando 7 2 na pilha. Então pegue a soma da pilha ( Σ).

15 ║F

║é o delimitador para literais de números de base 220. Como isso está no final de uma linha, não precisa ser finalizado.

16 4º

Calcular 2 ⁴ .

17 0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~

òé negar bit a bit, ~é negar aritmético. Combinando esses operadores, podemos incrementar 0 17 vezes.

18 6DD++

Pressione 6, duplique duas vezes e calcule 6 + 6 + 6.

19 8π

Empurre o 8º número primo.

20 τ╛hτ*

Pressione 10 ( τ), obtenha o primeiro elemento ( h) de seus fatores primos ( ╛), multiplique por 10.

21 "≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A

Da mesma forma que os trechos anteriores, a string "≤"é analisada como 0. Nós a diminuímos 21 vezes e, em seguida, obtemos o valor absoluto.

22) 1111 11v11%L1111 11v11%L

Aqui calculamos 1111 div 11 mod 11, que é 2, depois imprimimos 2. Em seguida, faça-o novamente.

PowerShell, pontuação 12, 91 bytes. 14, 176 bytes

[byte]!![byte]                    # type gets cast to bool false, inverted, to int = 1
-   -$?-shl$?                   # -bool true is -1, shift left, negative. (Tab not space)
3
4
5
6
7
8
9
1+1+1+1+1+1+1+1+1+1
22/2                                           # use the 2
'uuuuuuuuuuuu'.LENGTH                          # string length
0xd
@{z=@{};Y=@{};YY=@{};w=@{};v=@{};U=@{};zz=@{};S=@{};r=@{};q=@{};p=@{};J=@{};K=@{};m=@{}}|% COU*             # count items in hashtable (space)

Editar:

• Agradecemos a Ørjan Johansen por sugerir o hexadecimal 0xd para 13 e a reorganização de 5 para liberar 1 + 1 + 1 + 1 .. como opção.
• Comprimento de matriz alterado para comprimento de string, [int] para [byte] e hashtable para usar hashtables como valores, liberando o (),""Pondering 15 com algo como, "ZZZZZZZZZZZZZZZA".InDeXof("A")mas não pode reutilizar o ponto ou o 'e' ..

O PowerShell não pode fazer variáveis ​​sem $, não pode fazer exponenciação, deslocamento de bits, Pi, ceil () etc. com símbolos básicos e, na maioria das vezes, digita coercian para / de bool e para / de números como seqüências de caracteres, portanto há relativamente pouco espaço para geração de números com baixa sintaxe.

TI-Basic (série 83), pontuação 21 22 23 24 25 (1003 bytes)

1:  A=A
2:  int(tan(tan(cos(cos(cos(B
3:  tanh⁻¹(√(√(√(√(√(√(√(√(√(√(C!°√(√(C!°
        √(√(√(√(√(√(C!°√(√(√(√(√(√(C!°√(
        C!°√(√(√(C!°√(C!°√(C!°√(√(√(√(√(
        √(C!°√(C!°√(C!°√(C!°
4:  4
5:  cosh(sinh⁻¹(cosh(sinh⁻¹(...sinh⁻¹(cosh(D    with 25 repetitions of cosh(
6:  6
7:  7
8:  8
9:  9
10: ₁₀^(₁₀^(E
11: 11
12: F nPr F/sin(tan⁻¹(...(sin(tan⁻¹(F nPr F     with 143 repetitions of sin(tan⁻¹(
13: det([[G≤G]...[G≤G]]ᵀ[[G≤G]...[G≤G           with 26 repetitions of G≤G
14: ln(tanh(not(H))...tanh(not(H)))
        ln(tanh(not(H)))^⁻not(H                 with 14+1 repetitions of tanh(not(H))
15: iPart(e^(e^(e^(I
16: sum(dim(identity(sum(dim(identity(sum(
        dim(identity(sum(dim(identity(J≥J
17: K nCr K+K nCr K+...+K nCr K                 with 17 repetitions of K nCr K
18: abs(i-i-...-i                               with 20 repetitions of i
19: rand→L:log(LL...LL→M:log(L→N:N⁻¹M           with 19 L's inside the log
20: mean(seq(OOO,O,O,sinh(sinh(cos⁻¹(O
21: ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(³√(ππ³√(π³
        √(π³√(ππ³√(π³√(ππ³√(ππ³√(ππ³√(π³√(
        π³√(³√(ππ³√(ππ
22: 22
23: 3(3(3×√(3(3(3×√(3(3×√(3(3(3×√(3×√(3×√(
        3(3×√(3(3×√(3(3(3×√(3(3×√(3×√(3(3(
        3×√(3(3×√(3×√(3×√(3(3(3×√(3(3×√(3(
        3(3×√(3×√(3(3(3×√3
24: Fix 0
    sin⁻¹(ᴇ0
    AnsAnsAnsAnsAnsAnsAns
25: 5*5

Consulte http://tibasicdev.wikidot.com/one-byte-tokens para obter uma lista de quais coisas o desafio faz e não permite aqui.

Todos esses podem ser programas completos, pois a última linha de um programa é impressa automaticamente. Mas (exceto 17, que tem várias linhas), eles também podem ser trechos na tela inicial.

Neste ponto, não vejo outra maneira de obter nenhum valor diferente de zero dos tokens restantes disponíveis. Se houver alguma melhoria a ser feita, será necessário primeiro tornar algumas das soluções acima mais conservadoras.

Explicações

• A=Aé um booleano 1 porque a variável Aé igual a si mesma.
• Bé 0 por padrão, tan(tan(cos(cos(cos(Bé cerca de 2,21, e então tomamos a palavra.
• C!°é de 1 grau em radianos, cerca de 0,017. Algum poder positivo disso é tanh (2), cerca de 0,964. Codificamos esse poder em binário usando multiplicação implícita e √(, em seguida, pegamos tanh⁻¹(.
• 4 é simples
• cosh(sinh⁻¹(X$\sqrt{1+X^2}$
• 6-9 são simples
• ₁₀^( é um byte embutido para potências de 10 e 10 ^ 10 ^ 0 = 10 ^ 1 = 10.
• 11 é 11.
• F nPr Fsin(tan⁻¹(X$\frac{1}{\sqrt{1+1/X^2}}$
• G≤Gé 1, assim [[G≤G]...[G≤G]]como um vetor de coluna 13x1. Levar consigo o produto de sua transposição fornece a matriz [[13]], cujo determinante é 13.
• not(H)é 1. tanh(not(H))é apenas um número diferente de 0 ou 1 e ln(XXX....X)ln(X)^⁻1será simplificado para o número de X's' no primeiro log, desde queX não seja 0 (para que o log exista) e não 1 (para que não dividamos por 0).
• e^(e^(e^(F avalia para cerca de 15.15, e depois tomamos a palavra.
• J≥Jé 1. identity(constrói uma matriz de identidade 1x1, dim(encontra suas dimensões de linha e coluna e as sum(adiciona para obter 2. Em seguida, fazemos isso novamente, adicionando as dimensões de uma matriz 2x2 para obter 4 e, novamente, adicionando as dimensões de uma matriz 4x4 para obter 8 e, novamente, adicionando as dimensões de uma matriz 8x8 para obter 16.
• K nCr K é o coeficiente binomial 0, escolha 0 ou 1. Somando 17 1, obtém-se 17.
• i-i-...-i simplifica para i18i, e tendo abs( dá 18.
• rand→Larmazena um número real aleatório em L, mas não nos importamos com o que é. Estamos computando log(L)⁻¹log(L^19), o que simplifica para 19.
• sinh(sinh(cos⁻¹(Ié um pouco acima de 4, seq(III,I,I,sinh(sinh(cos⁻¹(Ifornece a lista {0 1 8 27 64}cuja média aritmética é 20.
• Outra instância do truque usado para obter 3. Aqui, algum poder de πdeve dar 21; codificamos esse poder no ternário usando multiplicação implícita e ³√(.
• 22 é 22.
• Outra instância do truque usada para obter 3 e 21. Codificamos a potência de 3 que é igual a 23 no ternário, usando 3×√(como raiz de cubo e (para multiplicação.
• Fix 0é a configuração para exibir 0 dígitos após o decimal, arredondando todos os valores para números inteiros. sin⁻¹(ᴇ0avalia para π / 2, e π / 2 multiplicado por si só 7 vezes resulta em 23,59, que arredonda para 24.
• 5*5é 25. (Seria mais conservador usar 5para obter 5 e adaptar a solução usada lá para 25. Mas dessa maneira economiza muito espaço e *não é um caractere muito útil porque existe multiplicação implícita.)

SOGL , pontuação 16 18 20, 109 bytes, 47 caracteres usados

=                    push ""=""
ρ:¾/U                ceil(isPalindrome("")/(isPalindrome("")*(3/4))) -> ceil(1/(3/4)) -> ceil(4/3)
3                    push 3
MM¼÷                 100/(100*1/4)
æ⁄                   length of "aeiou"
6                    push 6
7                    push 7
Nτ                   log2(256)
9                    push 9
L                    push 10
⁹’                   byte with the 11th SOGL code point
Ιζrkk"⁸              `⁸`s UTF-8 codepoint to string, take off 1st 2 chars
'⁰                   messy compression
īuHHHHHHHHHHHHHH±    floor(0.1) `-1` 14 times, then change sign
aIIIIIIIIIIIIIII     A `+1` 15 times, A = 0
4²                   4^2
lllllllllllllllll”l  length of "lllllllllllllllll"
222222222++++++++    2+2+2+2+2+2+2+2+2
δ“○“-                429-420
Μ℮‘                  compressed string of "2ŗ" where ŗ defaults to 0

Braquilog , 16 inteiros, 86 bytes

1
2
3
4
5
6
7
8
9
ℕ<<<<<<<<<<
≜+₁₁
Ịbkkkkkkkị
Ḥl
ℤ₇×₂ṅ
"____**"pᶜ¹
⟦h>>>>>>>>>>>>>>>>ȧ

Experimente online! (A entrada controla qual programa é executado, de 1 a N)

Explicação

                       The output is...

1                      1
2                      2
3                      3
4                      4
5                      5
6                      6
7                      7
8                      8
9                      9
ℕ<<<<<<<<<<            Strictly bigger than ... strictly bigger than 0
≜+₁₁                   0 + 11
Ịbkkkkkkkị             "12" converted to an integer
Ḥl                     The length of "Hello, World!"
ℤ₇×₂ṅ                  -(-7 × 2)
"____**"pᶜ¹            The number of unique permutations of "____**"
⟦h>>>>>>>>>>>>>>>>ȧ    The absolute value of stricly less than ... stricly less than 0

Geléia , pontuação 22, 177 bytes

1: Ṇ  : logical NOT. When there is no input, 0 is assumed, so this returns NOT(0)=1
2: ~A~A  : ~ is bitwise NOT and A is absolute value, implicit 0 input
         : 0~ = -1;   0~A = 1;   0~A~ = -2;  0~A~A = 2.
3: 3  : literal 3
4: -ı-²²×-Ḟ:
   -ı-     : literal complex number -1-1j
   ²²×-    : square (2j), then square(-4), then multiply by (×) negative 1 (-) to get 4+0i
   Ḟ       : get the real component, which is 4
5: 5  : literal 5
6: 6  : literal 6
7: 7  : literal 7
8: 8  : literal 8
9: ØDṪ : tail(Ṫ) of list of digits (ØD) to return 9
10: ⁵  : literal 10
11: 11 : literal 11
12: CNCNCNCNCNCNCNCNCNCNCNC : again, 0 is taken as input because there is no input
                            : C is complement and N is negate
                            : so each NC returns 1-(-n)=n+1 and is equivalent to increment, returning 12
13: “>>>>>»L    : encodes "#GlomAbducens" with “>>>>>» then returns the length in characters (13) with L
14: ‘‘‘‘‘‘‘‘‘‘‘‘‘‘   : default input is 0 again, and each ‘ increments it to get 14
15: Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;Ị;ỊS : default input is 0 again.
                                   : each Ị returns abs(0)<1 = 1
                                   : these are concatenated together with ; then summed with S to get 15
16: ⁴  : builtin literal 16
17: ,,,,,,,,,,,,,,,,,ŒḂŒḊ : Each , is the pair dyad: x,y = [x,y] and x,[y,z] = [x,[y,z]]. 
                          : Thus each , increased the depth by 1, then ŒḊ returns the depth: 17
18: 9Ḥ : 9 doubled = 18
19: E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E : each E returns areallelementsidentical([0]) = 1
                                          : 19 of these are summed with +
20: 44440b44ạ/ : 44440 base 44 = [22,42,0].
               : ạ/ takes the absolute difference of terms: ||22-42|-0| = 20
21: ”TOHH : ”T is the character literal "T". OHH returns its ascii value 84 (O) halved twice (HH) = 21
22: literal 22

Tente tudo de uma vez ou Tente um de cada vez (o argumento é qual saída você deseja).

Caracteres não utilizados:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑÞßæçðȷñ÷øœþ !"#$%&'()*.:<=?@BFGIJKMPQRUVWXYZ[\]^_`acdefghijklmnopqrstuvwxyz{|}¶°¹³⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḲḶṂỌṚṢṬỤṾẈỴẒȦĊĖḞĠḢİĿṀṄȮṖṘṠẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«’

Reng, pontuação 40, 149 bytes

Experimente aqui!

1.  e
2.  2
3.  ::l
4.  4
5.  5
6.  i`i`i`i`i`i`+++++
7.  7
8.  8
9.  9
10. A
11. ÇÇÇǹ
12. C
13* [[[[[[[[[[[[[mn~
14. E
15. F
16. G
17. H
18. I
19. J
20. K
21. L
22. M
23. N
24. O
25. P
26. Q
27. R
28. S
29. T
30. U
31. V
32. W
33. X
34. Y
35. Z
36. 6²
37. "%"
38* &fæ¦
39. D3*
40. 11±$1±±±±±±±±$11±$1±±±±$±$

Todas as letras maiúsculas são números, então isso é legal. Todos, exceto dois, são trechos. Os dois que são programas:

13. [[[[[[[[[[[[[mn~
38. &fæ¦

O link fornecido permite ver a pilha durante a execução. Vou escrever uma explicação mais tarde.

CJam, pontuação 27, 168 bytes

3/1: X , Y,Z

As variáveis X, Ye Zsão inicializadas em 1, 2 e 3, respectivamente.

4: ",,,,",

Empurre a corda ,,,,e pegue o comprimento.

5-9: 5 , 6, 7, 8,9

Literais numéricos.

10-20 : A-K

Variáveis ​​pré-inicializadas.

21: U)))))))))))))))))))))

A variável Ué inicializada para 0. Empurre Ue aumente 22 vezes.

22: 22

Literal numérico.

23: ';(((((((((';((((((((

Empurre o personagem ;e diminua 9 vezes para obter 2, depois empurre ;novamente e diminua 8 vezes para obter 3.

24: 4m!

Tome o fatorial de 4.

25: TT=TT=+TT=TT=TT=TT=TT=++++

TT=empurra 1. Este código é equivalente a 1 1+1 1 1 1 1++++.

26: N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-

Nempurra uma string contendo uma nova linha. :iconverte-o em uma lista de códigos de caracteres, produzindo [10]. ~descompacta, dando 10.W-é o equivalente a adicionar um. Aumentar 10 dezesseis vezes dá 26.

27: LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#

Encontre o índice de 0 em uma lista em que 0 esteja no 27º índice.

Personagens ainda disponíveis: $%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}

Algumas notas para potencial expansão:

• Talvez eu precise alterar de 10 a 20 para usar as variáveis ​​para outra coisa. Se eu conseguir números maiores que 1, posso usar *(e possivelmente operadores bit a bit, mas acho que eles não ajudarão muito).

• Eu ainda tenho S, qualquer bem que me faça.

• Se eu mudar 26 para N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-, :estará disponível.

• Eu posso enviar algumas listas vazias e obter mais zeros com as variáveis ​​existentes. Também posso obter π, mas isso não parece muito útil, a menos que eu possa convertê-lo em um número inteiro de alguma forma, e m(para m[) ei já esteja sendo usado.

• Em termos de manipulação de array, eu posso:

  • Use um mapa com %ouf
  • Use uma dobra com *
  • Faça algumas operações rotineiras
  • Conversão de base (isso parece promissor, mas não sei como obteria o número de base)
  • Construa matrizes usando |:M1|2|3|

Haskell , pontuação 13, 86 bytes

pi/pi
sum[sum[]^sum[],sum[]^sum[]]
3
4
5
6
7
8
9
length"eeeeeeeeee"
11
2+2+2+2+2+2
0xD

Experimente online!

Agradeço a Ørjan Johansen por encontrar uma maneira de corrigir a sobreposição da minha carta, preservando a pontuação de treze. (Também por me esforçar para me notificar sobre isso enquanto essa resposta foi excluída.)

pi/pié 1.0.
sum[]avalia para 0, 0^0para 1e sum[1,1]para 2. 3para 9se decodificar.
length"eeeeeeeeee"produz o comprimento da string, que é 10.
2+2+2+2+2+2é 12.
0xDé hexadecimal para 13.