Se você gosta disso, considere participar de:

• O jogo oficial do ano de 2016 da Dyalog APL

• O Dyalog APL 2017 Code Golf Challenge mensal

Faça 12 trechos / expressões , no mesmo idioma, que resultem nos números de 0 a 10 e 42, respectivamente, mas sem gravar dados numéricos, de seqüência de caracteres ou caracteres literais.

Dados incorporados , como PI()e ALPHABET(), são bons, assim como, por exemplo, as constantes U, X, Y, Z e A de CJam, e as combinações BLEND, CHORD, CENTER, BREAK e LINES do Processing.

Todo snippet deve ser capaz de se manter por conta própria, ou seja, eles podem não ser interdependentes. No entanto, dentro de um único trecho, você pode atribuir uma variável e usá-la livremente, desde que se refira diretamente a ela pelo nome, e não por meio de uma string que contenha seu nome.

Todos os trechos devem ser válidos no computador do remetente no momento do envio (conforme relatado pelo SE), mas não podem depender de condições locais incomuns, como número de arquivos em um diretório, data ou hora exata ou entrada específica do usuário .

Exemplos de trechos válidos

3: INT(LOG10(YEAR(TODAY()))) porque permanece verdadeiro no futuro previsível
4: CUBICROOT(LEN(CHARACTERSET())) porque um conjunto de caracteres de 256 letras é muito comum
8: SQRT(SYSTEMTYPE()) porque sistemas de 64 bits são muito comuns

Exemplos de trechos inválidos

5: LEN(USERNAME()) porque a maioria das pessoas não usa "Admin" como login :-)
9: LOG10(SYSTEMMEMORY()) porque funciona apenas em sistemas com exatamente 1 GB de memória
42: CODE("*") porque contém um literal de cadeia / caractere

O resultado de cada snippet deve resultar em um número real (valor, int, float etc.) que pode ser usado para cálculos adicionais usando o mesmo idioma do snippet, ou seja, não uma sequência de texto representando esse número.

Somente idiomas baseados em caracteres são permitidos.

A pontuação é a contagem total de bytes de todos os 12 snippets combinados. As novas linhas que separam os trechos não são contadas.

Observe que as regras acima podem impedir a participação de alguns idiomas, mesmo que eles estejam completos no Turing.

Perguntas frequentes

P Os programas podem aceitar qualquer entrada?
R Sim, mas você pode não apenas solicitar entrada e inserir o número relevante.

P Os dígitos físicos (não dados) são permitidos?
A Sim, por exemplo LOG10().

P Os símbolos no Ruby contam como literais?
R Sim.

P A pontuação inclui novas linhas entre cada snippet?
A No.

P O TI-BASIC "baseado em caracteres" é suficiente para ser válido?
R Sim.

P Falso e verdadeiro contam como literais numéricos?
R Não, eles são aceitáveis.

P Podemos usar um literal numérico para chamar uma função se essa for a única maneira e o número não influenciar a saída da função?
R Sim, se essa for a maneira normal de escrever código no seu idioma.

P Minha linguagem assume que existe um [algo] no início de cada programa / expressão. Devo incluí-lo ou meus trechos devem funcionar se colocados no meio de um programa / expressão?
R Eles devem apenas trabalhar no meio de um programa / expressão.

P E os literais regex?
A Proibida, com exceção de línguas que apenas fazer expressões regulares.

P É aceitável um pedaço de código que possa imprimir todos os números especificados?
R Não, eles precisam ser separados e independentes entre si.

P Posso assumir um padrão semelhante int main() {}...ou equivalente?
R Sim.

P Quais tipos de dados de saída são permitidos?
A Qualquer tipo de dados numérico, como int, float, etc.

P Preciso imprimir o resultado de cada snippet?
R Não, disponibilizar o resultado para uso posterior é suficiente.

P São permitidas variáveis ​​predefinidas?
R Sim, e eles são redefinidos (se alterados) para cada trecho.

Q π e e são considerados literais numéricos?
R Não, você pode usá-los.

P Posso retornar 4 e 2 em células diferentes para 42?
R Não, eles devem estar conectados como um número.

P Bytes ou caracteres?
A Bytes, mas você pode escolher qualquer página de código desejada.

P Podem ser usadas funções constantes e variáveis ​​predefinidas como J 9:, Actually 9e Pretzel 9?
R Sim, se o vocabulário for finito (19 para J, 10 para Actually e Pretzel).

Hexagonia , 13 bytes

1 1
2
3
4
5
6
7
8
9
10
42.

Experimente online!

No Hexagony, 0through 9são funções que multiplicam a memória atual por 10 e adicionam o número representado pelo nome da função. Portanto, o primeiro trecho está vazio quando as memórias começam como 0.

Por exemplo, se a memória atual estiver 65, a execução da função 3criará a memória atual 653.

(Para os que votam para baixo: votem para baixo quanto quiserem; eu estou pronto.)

Função , 1222 bytes

Além dos literais numéricos, há duas maneiras de produzir um valor (qualquer valor) no Funciton: expressões stdin e lambda. Stdin é uma caixa única, enquanto uma expressão lambda completa requer mais sintaxe, então eu vou com stdin. No entanto, embora stdin possa ser qualquer coisa, todos os trabalhos a seguir, independentemente de qual entrada é fornecida.

Todas as funções de biblioteca usadas aqui existiam antes do lançamento do desafio.

0 (40 bytes em UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

Isso usa a sintaxe bruta por menos que. Um valor nunca é menor que ele próprio, portanto, o resultado disso é 0.

1 (52 bytes em UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

⌑retorna uma sequência lenta que contém um único elemento e ɕconta o número de elementos. (A sequência lenta é preguiçosa o suficiente para que esse trecho não avalie realmente o stdin!)

2 (70 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂgera todas as subsequências de uma sequência e, assim, transforma uma sequência de n elementos em um com 2ⁿ.

3 (88 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. ♯incrementa um valor em 1.

4 (88 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 bytes em UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 fatorial.

7 (110 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (função Ackermann).

8 (118 bytes em UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (shift-esquerda).

9 (128 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 bytes em UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 bytes em UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 bytes

Com a ajuda de @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn e @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

Mouse-2002 , 27 26 17 14 bytes

Os primeiros trechos pressionam 0-10 e ZR+empurram 25então 17e 25 17 + 42 =é 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam, 27 24 bytes

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Obrigado a @ MartinBüttner por -1 byte!

Experimente online!

Brainfuck, 70 bytes

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

Cada linha deve ser executada individualmente.

Os 10 primeiros são auto-explicativos: incrementamos o valor da célula via cada mais.

O 42 é muito mais complexo. Ele se baseia no fato de que o intérprete mais covarde usa células de 8 bits, o que significa que todas as operações nele são realizadas no módulo 256. --Define a célula # 0 a 254. Em seguida, inserimos um loop que é executado até a célula # 0 ser 0. Cada iteração adiciona 1 à célula nº 1 e adiciona 6 à célula nº 0. Esses loops são executados 43 vezes, então a célula 1 é 43. Finalmente, subtraímos 1 da célula 1 para torná-la 42.

Eu consegui os 42 mais eficientes já encontrados em http://esolangs.org/wiki/Brainfuck_constants

Escuridão , 339 303 bytes

É aqui que a escuridão realmente brilha . Pegue? : ~)!

Sem impressão (substituiu o espaço \sna primeira linha, pois não será exibido de outra forma):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

Com impressão:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

Cada linha deve ser executada individualmente neste caso, pois o programa termina na luz (um espaço). No entanto, é possível escrever isso em uma ou várias linhas no mesmo programa.

A escuridão regular (█) incrementa um registro em 1, e a instrução ■ (algum tipo de mini-escuridão) gera o conteúdo do registro.

Perl 5, 86 75 71 66 bytes

Todos os ^Fs são caracteres de controle literais (0x06 em ASCII) e, portanto, um único byte.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Obrigado ao msh210 por salvar 11 bytes e ao Dom Hastings por 9 bytes!

MATL, 30 bytes

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, I, E Ksão constantes predefinidas para 2, 3, e 4 (como pi). Oe lsão funções que retornam uma matriz de zeros ( O) ou uns ( l), o tamanho padrão é 1x1. :faz um vetor e o ssoma, então K:sfaz um vetor de 1 a 4 e o soma para obter 10. Yqé a n-ésima função primária, assim KYqcomo o quarto primo, 7.

Prolog, 113 99 bytes

Trechos:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Combina as constantes matemáticas e e pi de diferentes maneiras convertidas em int.

Editar: salvou 14 bytes utilizando flutuadores para 0-2.

PHP, 157 145 91 bytes

A primeira vez que publiquei no Code Golf, achei que eu tentaria. Eu melhorarei eventualmente: P Se você encontrar algum ponto óbvio (para você) onde eu possa salvar personagens, me avise.

Edição: Percebi que não precisava de ponto e vírgula, uma vez que estes são apenas trechos.

EDIT2: Obrigado ao Blackhole por muitas sugestões!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

Python 2, 191 159 158 157 156 149 146 bytes

Minha primeira submissão, espero ter acertado tudo! Com base no tempo que gastei nisso, acho que certamente há um melhor para alguns deles.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Muito obrigado a FryAmTheEggman!

C #, sem usos, 234 bytes

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Isso é muito mais chato do que eu pensava inicialmente. Eu tinha idéias bastante variadas, como new[]{true}.Lengthe true.GetHashCode()e typeof(int).Name.Lengthe uint.MinValueetc., mas new int()venci todas elas.

PowerShell, 147 bytes

Eles são usados +para converter implicitamente coisas em números inteiros. Os números posteriores usam Enums dos limites do .NET Framework do PowerShell, que possuem os valores corretos.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

• -~-~-~usado em JavaScript, as respostas C # e PHP estariam - -bnot - -bnot - -bnotno PowerShell.

• x^yexponenciação usada em respostas Perl, ou x**yem Python ou JavaScript ES7, seria[Math]::Pow($x,$y)

• constantes e e Pi são os caracteres pesados [Math]::Ee[Math]::PI

DC , 35 bytes

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Para testar os trechos, anexe a fpara imprimir a pilha e passe essa sequência para dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 bytes

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

No TI-BASIC, todas as variáveis ​​de uma letra não inicializadas começam em 0 e Xmax(o limite direito da tela da tela do gráfico) começa em 10.

A constante matemática πé de um byte , mas etem dois bytes.

Python 2, 306 275 274 bytes

Eu usei o fato de que para qualquer x (número inteiro e não 0) a expressão x/xé igual a 1 e brincamos com algumas operações bit a bit.

Ajustei os trechos de forma que eles ainda atendam aos requisitos (graças a @nimi isso me salvou em 24 bytes), mas você deve testá-los manualmente. Aqui está o código e a contagem de bytes individuais:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

Math ++, total de 92 bytes

0 (1 bytes): a

1 (2 bytes):!a

2 (3 bytes):_$e

3 (4 bytes): _$pi

4 (7 bytes): _$e+_$e

5 (8 bytes): _($e+$e)

6 (9 bytes): _$pi+_$pi

7 (8 bytes): _($e*$e)

8 (9 bytes): _($e*$pi)

9 (10 bytes): _($pi*$pi)

10 (12 bytes): _$e*_($e+$e)

42 (19 bytes): _($pi+$pi)*_($e*$e)

Javascript (navegador Env), 155 136 130 bytes

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Graças a:
@Ismael Miguel : 155 -> 136 -> 130 bytes

Sério, 39 33 bytes

Coisas entre parênteses são explicações:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps de programas:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Graças à quintopia por 6 bytes!

dc, 42 bytes

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Resultados

0
1
2
3
4
5
6
7
8
9
10
42

Não há muitas maneiras de gerar novos números com dc. Eu uso O: base de saída, inicialmente 10; K: precisão, inicialmente 0; zprofundidade da pilha, inicialmente 0; Zdígitos significativos do operando. Nós os combinamos com os operadores aritméticos usuais.

Programa de teste

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

Mathematica, 101 bytes

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Tenho certeza de que alguns deles são abaixo do ideal. Esses colchetes são realmente caros.

Para consistência, os dois primeiros também poderia ser E-Ee E/Eé claro, mas eu pensei que é muito bacana para chegar 0e 1partir de um cálculo com variáveis indefinidas.

Japonês , 34 33 30 bytes

1 byte salvo graças a @ThomasKwa

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Aqui está o que cada um dos diferentes caracteres significa:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Marbelous , 98 bytes

Não é muito empolgante, depende dos ?ndispositivos que transformam qualquer mármore em um valor aleatório no intervalo 0..n (inclusive), um efeito colateral disso é que ?0transforma qualquer mármore em um 0, independentemente da entrada. Eu acho que o uso de literais é permitido porque o valor não afeta o resultado e não há outra maneira de chamar uma função uma vez no Marbelous.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

> <> , 86 bytes

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;oullll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;oullllll+n;
• 10: llll+:+n;oulll:l+*n;
• 42: llll*ll+*n;

Depende do tamanho da pilha para obter seus literais.

Fórmulas do MS Excel, 163 151 150 143 bytes

Não é exatamente uma linguagem de programação, mas aqui vai ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()é usado na maioria dos casos, pois é a maneira mais curta (que eu conheço) de introduzir um valor numérico sem usar um número ou string literal. Nconverte várias coisas (incluindo booleanos) em números e Tconverte várias coisas em texto. TYPEretorna 2 para um argumento de texto e 4 para um argumento booleano. TRUNCdescarta a parte fracionária (ou seja, arredonda números positivos para baixo), EVENarredonda para o próximo número par e ODDarredonda para o próximo número ímpar. CODE(-PI())é o código ASCII do primeiro caractere da conversão para o texto de -π, ou seja, 45 (para "-").

EDIT: Removidos sinais de igual da contagem de bytes (-12!) - como apontado por Nᴮᶻ nos comentários, eles não devem ser incluídos.

EDIT 2: Supondo que o restante da planilha esteja vazio, é possível usar uma referência a uma célula vazia como zero (novamente, sugerido por Nᴮᶻ), desde que inclua um sinal de menos (ou use-o em outra expressão numérica) para resolver digite ambiguidade.

DUP , 68 bytes

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Existem muitas maneiras de fazer isso, mas estou abusando da pilha de retorno dessa.

Explicação

Para entender isso completamente, você precisa entender o comportamento do DUP em relação às lambdas. Em vez de enviar o próprio lambda para a pilha, ele realmente envia o IP atual para a pilha quando o lambda é detectado. Isso pode explicar os três primeiros trechos, que envolvem lambdas.

Os próximos trechos usam a pilha de retorno. Quando !é executado, o IP atual é enviado para a pilha de retorno e a parte superior da pilha é definida como o novo IP para iniciar a execução do lambda. )aparece um número da pilha de retorno na pilha de dados.

Isso é o suficiente para explicar o restante dos trechos. Se você ainda não o recebeu, lembre-se de que o Stepbotão é bastante útil!

05AB1E, 40 38 24 bytes

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• Push counter_variable
• Push 1
• Push 2
• Pressione 1 + 2
• Pressione 2 * 2
• Push 10/2
• Empurre (10/2) +1
• Empurre (10/2) +2
• Push 10-2
• Push 10-1
• Push 10
• Pressione 32, 10, adicione

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

Cada linha é um trecho diferente.

Os números no programa não contam como literais numéricos, pois são usados ​​apenas como comandos.

O último pode definitivamente ser jogado mais.

Edição: Eu tenho o intérprete trabalhando e todos os trechos funcionam. Se você quiser testar se, adicione 0f0fno final do snippet para que o programa seja encerrado.

Pyth, 35 34 33 bytes

-1 byte por @Mimarik

Existem várias possibilidades para alguns programas.

0, 1 byte

Z

1, 2 bytes

hZ
!Z

2, 3 bytes

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 bytes

l`d

4, 3 bytes

l`b
eCN

5, 4 bytes

hl`b
telG

6, 3 bytes

elG

7,4 bytes

tttT
helG

8, 3 bytes

ttT

9, 2 bytes

tT

10, 1 byte

T

42, 4 bytes

yhyT

Tudo isso envolve duplo básico (y comandos ), +1 ( h) e -1 ( t) ou l(comprimento de uma string). A variável Z é inicializada em zero.

Para 5, bé inicializado com um caractere de nova linha. Backtick fornece "\n"(incluindo as aspas, e o comprimento dessa sequência é 4.

Experimente aqui !