Si te gusta esto, considera participar en:

• El juego oficial Dyalog APL 2016 Year

• El desafío mensual de golf de código Dyalog APL 2017

Haga 12 fragmentos / expresiones , en el mismo idioma, que den como resultado los números del 0 al 10 y 42 respectivamente, pero sin escribir ningún dato numérico literal, cadena o carácter.

Los datos incorporados , como PI()y ALPHABET(), están bien, y también lo están, por ejemplo, las constantes U, X, Y, Z y A de CJam, y las MEZCLAS, ACORDES, CENTROS, INTERRUPCIONES y LÍNEAS de Processing.

Cada fragmento debe poder sostenerse por sí mismo, es decir, puede que no sean interdependientes. Sin embargo, dentro de un solo fragmento, puede asignar una variable y usarla libremente, siempre que se refiera directamente a ella por nombre y no a través de una cadena que contenga su nombre.

Todos los fragmentos deben ser válidos en la computadora del remitente en el momento del envío (según lo informado por SE), pero no pueden depender de condiciones locales inusuales como el número de archivos en un directorio, la fecha u hora exacta o la entrada específica del usuario .

Ejemplos de fragmentos válidos

3: INT(LOG10(YEAR(TODAY()))) porque sigue siendo cierto en el futuro previsible
4: CUBICROOT(LEN(CHARACTERSET())) porque un juego de caracteres de 256 letras es muy común
8: SQRT(SYSTEMTYPE()) porque los sistemas de 64 bits son muy comunes

Ejemplos de fragmentos inválidos

5: LEN(USERNAME()) porque la mayoría de las personas no usan "Admin" como inicio de sesión :-)
9: LOG10(SYSTEMMEMORY()) porque solo funciona en sistemas con exactamente 1 GB de memoria
42: CODE("*") porque contiene una cadena / carácter literal

El resultado de cada fragmento debe dar como resultado un número real (valor, int, flotante, etc.) que se pueda usar para cálculos adicionales utilizando el mismo idioma que el fragmento, es decir, no una cadena de texto que represente ese número.

Solo se permiten idiomas basados ​​en caracteres.

La puntuación es el recuento total de bytes de los 12 fragmentos combinados. Las nuevas líneas que separan los fragmentos no se cuentan.

Tenga en cuenta que las reglas anteriores pueden evitar que algunos idiomas participen, incluso si están completos en Turing.

Preguntas más frecuentes

P ¿Pueden los programas aceptar alguna entrada?
A Sí, pero puede que no solo solicite información e ingrese el número relevante.

P ¿Están permitidos los dígitos físicos (sin datos)?
Un sí, por ejemplo LOG10().

P ¿Los símbolos en Ruby cuentan como literales?
Un sí.

P ¿La puntuación incluye nuevas líneas entre cada fragmento?
Un no

P ¿TI-BASIC está "suficientemente basado en caracteres" para ser válido?
Un sí.

P ¿Cuentan falso y verdadero como literales numéricos?
A No, son aceptables.

P ¿Podemos usar un número literal para llamar a una función si esa es la única forma y el número no influye en la salida de la función?
A Sí, si esa es la forma normal de escribir código en su idioma.

P Mi lenguaje supone que hay un [algo] al comienzo de cada programa / expresión. ¿Debo incluirlo o mis fragmentos deberían funcionar si se colocan en el medio de un programa / expresión?
A Deberían funcionar en el medio de un programa / expresión.

P ¿Qué pasa con los literales regex?
Una prohibido, excepto para los idiomas que sólo hacen expresiones regulares.

P ¿Es aceptable una pieza de código que pueda imprimir todos los números especificados?
R No, tienen que estar separados y ser independientes entre sí.

P ¿ Puedo suponer una placa repetitiva como int main() {}...o equivalente?
Un sí.

P ¿Qué tipos de datos de salida están permitidos?
A Cualquier tipo de datos numéricos, como int, float, etc.

P ¿Necesito imprimir el resultado de cada fragmento?
R No, hacer que el resultado esté disponible para su uso posterior es suficiente.

P ¿Se permiten variables preestablecidas?
A Sí, y se restablecen (si se cambia) para cada fragmento.

P ¿Se consideran π y e literales numéricos?
A No, puedes usarlos.

P ¿ Puedo devolver 4 y 2 en celdas diferentes para 42?
A No, deben estar conectados como un número.

Q Bytes o caracteres?
A Bytes, pero puede elegir cualquier página de códigos deseada.

P ¿Se pueden utilizar funciones constantes y variables preestablecidas como J's 9:, Actually 9y Pretzel's 9?
A Sí, si el vocabulario es finito (19 para J, 10 para Actually y Pretzel).

Hexagonía , 13 bytes.

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

Pruébalo en línea!

En Hexagony, 0through 9son funciones que multiplican la memoria actual por 10 y luego suman el número representado por el nombre de la función. Por lo tanto, el primer fragmento está vacío ya que los recuerdos comienzan como 0.

Por ejemplo, si la memoria actual es 65, ejecutar la función 3hará que la memoria actual 653.

(Para los votantes que votan a favor: denieguen todo lo que quieran; estoy listo).

Funciton , 1222 bytes

Además de los literales numéricos, hay dos formas en que puedo producir un valor (cualquier valor) en Funciton: expresiones stdin y lambda. Stdin es un cuadro único, mientras que una expresión lambda completa requiere más sintaxis, así que voy con stdin. Sin embargo, aunque stdin podría ser cualquier cosa, todo lo siguiente funciona independientemente de qué entrada se proporcione.

Todas las funciones de la biblioteca utilizadas aquí existían antes de que se publicara el desafío.

0 (40 bytes en UTF-16)

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

Esto usa la sintaxis en bruto para menor que. Un valor nunca es menor que sí mismo, por lo que el resultado es 0.

1 (52 bytes en UTF-16)

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

⌑devuelve una secuencia perezosa que contiene un único elemento y ɕcuenta el número de elementos. (¡La secuencia perezosa es lo suficientemente perezosa como para que este fragmento no evalúe el stdin en absoluto!)

2 (70 bytes en UTF-16)

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

= 2¹. ʂgenera todas las subsecuencias de una secuencia y, por lo tanto, convierte una secuencia de n elementos en uno con 2ⁿ.

3 (88 bytes en UTF-16)

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

= 2 + 1. ♯incrementa un valor en 1.

4 (88 bytes en UTF-16)

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

= 2².

5 (106 bytes en UTF-16)

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

= 4 + 1.

6 (106 bytes en UTF-16)

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

= 3 factorial.

7 (110 bytes en UTF-16)

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

= A (2, 2) (función de Ackermann).

8 (118 bytes en UTF-16)

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

= 2 << 2 (desplazamiento a la izquierda).

9 (128 bytes en UTF-16)

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

= 3 × 3.

10 (146 bytes en UTF-16)

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

= 5 + 5.

42 (170 bytes en UTF-16)

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

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 bytes

Con la ayuda de @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn y @ 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

Los primeros fragmentos empujan 0-10, y luego ZR+empuja y es .251725 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

¡Gracias a @ MartinBüttner por -1 byte!

Pruébalo en línea!

Brainfuck, 70 bytes

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

Cada línea debe ejecutarse individualmente.

Los primeros 10 se explican por sí mismos: incrementamos el valor de la celda a través de cada signo más.

El 42 es mucho más complejo. Se basa en el hecho de que el intérprete más loco utiliza celdas de 8 bits, lo que significa que todas las operaciones se realizan en el módulo 256. --Establece la celda # 0 a 254. Luego ingresamos un bucle que se ejecuta hasta que la celda # 0 es 0. Cada iteración agrega 1 a la celda # 1 y agrega 6 a la celda # 0. Este bucle se ejecuta 43 veces, por lo que la celda # 1 es 43. Finalmente, restamos 1 de la celda # 1 para que sea 42.

Obtuve los 42 más eficientes encontrados de http://esolangs.org/wiki/Brainfuck_constants

Oscuridad , 339303 bytes

Aquí es donde la oscuridad realmente brilla . ¿Consíguelo? : ~)!

Sin imprimir (reemplazó el espacio con \sen la primera línea ya que no se mostrará de otra manera):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Con impresión:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

Cada línea debe ejecutarse individualmente en este caso ya que el programa termina en la luz (un espacio). Sin embargo, es posible escribir esto en una o varias líneas en el mismo programa.

La oscuridad regular (█) incrementa un registro en 1, y la instrucción ■ (algún tipo de mini-oscuridad) genera el contenido del registro.

Perl 5, 86 75 71 66 bytes

Todos los ^Fs son caracteres de control literal (0x06 en ASCII) y, por lo tanto, un solo 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

¡Gracias a msh210 por guardar 11 bytes y Dom Hastings por 9 bytes!

MATL, 30 bytes

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

H, Iy Kson constantes predefinidas para 2, 3 y 4 (como pi). Oy lson funciones que devuelven una matriz de ceros ( O) o unos ( l), el tamaño predeterminado es 1x1. :hace un vector y lo ssuma, así que K:shace un vector del 1 al 4 y lo suma para obtener 10. Yqes la función n-ésima, así KYqes el 4º primo, 7.

Prólogo, 113 99 bytes

Fragmentos

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 las constantes matemáticas e y pi de diferentes maneras convertidas en int.

Editar: se guardaron 14 bytes utilizando flotantes para 0-2.

PHP, 157 145 91 bytes

Publicando por primera vez en Code Golf, pensé que le daría una oportunidad. Eventualmente mejoraré: P Si ves algún lugar obvio (para ti) donde pueda guardar personajes, avísame.

EDITAR: Me di cuenta de que no necesitaba los puntos y comas, ya que estos son solo fragmentos.

EDIT2: ¡Gracias a Blackhole por muchas sugerencias!

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

Mi primera presentación, ¡espero haberlo hecho todo bien! Según el tiempo que pasé en esto, creo que seguramente hay uno mejor para algunos de ellos.

# 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

Muchas gracias a FryAmTheEggman!

C #, sin 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

Esto es mucho más aburrido de lo que inicialmente pensé que iba a ser. Tenía ideas muy variadas, como new[]{true}.Lengthy true.GetHashCode()y typeof(int).Name.Lengthy uint.MinValueetc., pero las new int()superaba a todas.

PowerShell, 147 bytes

Estos se utilizan +para convertir cosas implícitamente en enteros. Los números posteriores usan Enums de las bases de .Net Framework de PowerShell que tienen los valores correctos.

+$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 en JavaScript, C # y las respuestas de PHP estarían - -bnot - -bnot - -bnoten PowerShell.

• x^yla exponenciación utilizada en las respuestas de Perl, o x**yen Python o JavaScript ES7, sería[Math]::Pow($x,$y)

• las constantes e y Pi son las de carácter pesado [Math]::Ey[Math]::PI

DC , 35 bytes

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

Para probar los fragmentos, agregue un fpara imprimir la pila y pasar esa cadena a 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(π

En TI-BASIC, todas las variables de una sola letra no inicializadas comienzan en 0 y Xmax(el límite de la ventana derecha de la pantalla del gráfico) comienza en 10.

La constante matemática πes un byte , pero etiene dos bytes.

Python 2, 306 275 274 bytes

Utilicé el hecho de que para cualquier x (entero y no 0) la expresión x/xes igual a 1 y jugué con algunas operaciones bit a bit.

Ajusté los fragmentos de modo que todavía cumplan con los requisitos (gracias @nimi, esto me ahorró 24 bytes), pero tienes que probarlos manualmente. Aquí está el código y el recuento de bytes individuales:

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 ++, 92 bytes en total

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 (Browser Env), 155 136 130 bytes

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

Gracias a:
@Ismael Miguel : 155 -> 136 -> 130 bytes

En serio, 39 33 bytes

Las cosas entre paréntesis son explicaciones:

 (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

¡Gracias a 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

No hay muchas maneras de generar nuevos números con CC. Yo uso O: base de salida, inicialmente 10; K: precisión, inicialmente 0; zprofundidad de la pila, inicialmente 0; Zdígitos significativos del operando. Combinamos estos con los operadores aritméticos habituales.

Programa de prueba

#!/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⌋

Estoy bastante seguro de que algunos de estos son subóptimos. Esos corchetes son realmente caros.

Por coherencia, los dos primeros también podrían serlo E-Ey, E/Epor supuesto, pero pensé que es bastante ingenioso obtener 0y 1de un cálculo con variables indefinidas.

Japt , 34 33 30 bytes

1 byte guardado gracias a @ThomasKwa

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

Esto es lo que significa cada uno de los diferentes caracteres:

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

Maravilloso , 98 bytes

No es terriblemente emocionante, se basa en los ?ndispositivos que convierten cualquier canica en un valor aleatorio en el rango 0..n (inclusive) un efecto secundario de esto es que ?0convierte cualquier canica en 0 independientemente de la entrada. Creo que el uso de literales está permitido porque el valor no afecta el resultado y no hay otra forma de llamar a una función una vez en 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;ollll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;ollllll+n;
• 10: llll+:+n;olll:l+*n;
• 42: llll*ll+*n;

Se basa en el tamaño de la pila para obtener sus literales.

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

No es exactamente un lenguaje de programación, pero aquí va ...

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()se usa en la mayoría de los casos, ya que es la forma más corta (que yo sepa) de introducir un valor numérico sin usar un número o un literal de cadena. Nconvierte varias cosas (incluidos booleanos) en números, y Tconvierte varias cosas en texto. TYPEdevuelve 2 para un argumento de texto y 4 para un argumento booleano. TRUNCdescarta la parte fraccionaria (es decir, redondea los números positivos hacia abajo), EVENredondea al siguiente número par y ODDredondea al siguiente número impar. CODE(-PI())es el código ASCII del primer carácter de la conversión a texto de -π, es decir, 45 (para "-").

EDITAR: Se eliminaron los signos de igual del recuento de bytes (-12!) - como lo señaló Nᴮᶻ en los comentarios, no se supone que estén incluidos.

EDITAR 2: suponiendo que el resto de la hoja de trabajo esté vacía, es posible usar una referencia a una celda vacía como cero (nuevamente, sugerido por Nᴮᶻ) siempre que incluyamos un signo menos (o lo usemos en otra expresión numérica) para resolver ambigüedad tipo.

DUP , 68 bytes

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

Try it here.

Hay MUCHAS formas de hacer esto, pero estoy abusando de la pila de retorno para esta.

Explicación

Para resolverlo completamente, debe comprender el comportamiento de DUP con respecto a las lambdas. En lugar de empujar el lambda a la pila, en realidad empuja la IP actual a la pila cuando se detecta el lambda. Eso puede explicar los primeros 3 fragmentos, que involucran lambdas.

Los siguientes fragmentos usan la pila de retorno. Cuando !se ejecuta, la IP actual se empuja a la pila de retorno, y la parte superior de la pila se establece como la nueva IP para iniciar la ejecución lambda. )saca un número de la pila de retorno a la pila de datos.

Eso es más que suficiente para explicar el resto de los fragmentos. Si aún no lo entiende, tenga en cuenta que el Stepbotón es bastante útil.

05AB1E, 40 38 24 bytes

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

• Push counter_variable
• Empuje 1
• Empuje 2
• Empuje 1 + 2
• Empuje 2 * 2
• Empuje 10/2
• Empujar (10/2) +1
• Empujar (10/2) +2
• Empuje 10-2
• Empuje 10-1
• Empuje 10
• Presione 32, 10, agregue

D1ffe7e45e , 112

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

Cada línea es un fragmento diferente.

Los números en el programa no cuentan como literales numéricos ya que solo se usan como comandos.

El último definitivamente se puede jugar más al golf.

EDITAR: Obtuve el intérprete funcionando y todos los fragmentos funcionan. Si desea probar si usted mismo, agregue 0f0fal final del fragmento para que el programa finalice.

Pyth, 35 34 33 bytes

-1 byte por @Mimarik

Hay varias posibilidades para algunos 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

Todos estos involucran comandos básicos double ( y), +1 ( h) y -1 ( t), o l(longitud de una cadena). La variable Z se inicializa a cero.

Para 5, bse inicializa a un carácter de nueva línea. Backtick da "\n"(incluidas las comillas, y la longitud de esa cadena es 4.

Pruébalos aquí !