Sin cadenas (o números) adjuntos

71

Si te gusta esto, considera participar en:


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).

Adán
fuente
Si 0-9 no son literales numéricos pero son variables pre-pobladas, ¿serían juego limpio?
Cyoce
@Cyoce ¿Entonces 10 es {1, 0} y no 2 × 5?
Adám
no, simplemente hay otra sintaxis para literales que no es base-10, por lo que 0-9 no son literales. Tienen el valor de 0-9, pero se consideran variables
Cyoce
@Cyoce Entonces está bien. ¿Qué idioma es ese?
Adám
pretzel (un idioma en el que estoy trabajando).
Cyoce

Respuestas:

15

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).

Monja permeable
fuente
Escurridizo, pero recibe mi voto positivo.
Adám
49

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).

Timwi
fuente
66
+1 para la función Ackermann .
intrepidcoder
44
Desearía poder votar más de una vez ...
ev3commander
26

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>

usuario81655
fuente
Prueba 4: - ~ Math.PI
edc65
@ edc65 ¡Gracias! Pensé que habría algo que podría hacer con PI. :)
user81655
Para 5, 6 también puede usar -~-~Math.PIy -~-~-~Math.PIguardar otro byte (dos veces).
Sjoerd Job Postmus
1
Ahorre uno en 42 con (escape+NaN).length. PS Hoy aprendí que JavaScript es muy raro ...
Mwr247
1
NaN
Iba
17

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+
gato
fuente
Dice "un fragmento o expresión" para que pueda eliminar todos los! 'S
ev3commander
3
@cat No puedo hablar por el interlocutor, pero creo que eso significa estar separados el uno del otro, sin definir una función en una y luego usarla en otra. Sin embargo, cada fragmento no necesita ser un programa completo, puede asumir el int main() {}...equivalente repetitivo que lo hará funcionar.
TessellatingHeckler
15

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!

Dennis
fuente
12

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

p1xel
fuente
1
@someonewithpc 4 y 2 es diferente de 42: el OP dice que el resultado de cada fragmento debe dar como resultado un número real 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 . Puede hacer cálculos en 42 directamente, pero no es lo mismo para 4 y 2 en celdas separadas.
p1xel
Oh ok Me había perdido eso ...
someonewithpc
12

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.

patata dulce
fuente
No creo que esto solicite programas completos, solo fragmentos.
Erik the Outgolfer
12

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!

Pomo de la puerta
fuente
3
Perl es extraño. zoitz.com/comics/perl_small.png
ldam
menospreciado porque "número máximo de descriptor de archivo sys, 2 en todos los sistemas sanos = 3" pero tengo más de 65 años
cat
(Estoy bromeando, por supuesto que voté)
gato
1
¿Alguna vez has leído los comentarios en una publicación de SE y piensas, "wow, qué idiota escribió eso"? Ese soy yo ahora mismo, conmigo mismo.
gato
!$[+ord$/ # -1 + 10No lo entiendo. En la línea 2 dices que !$[te da 1, no -1, por lo que este fragmento da 11.
Timwi
10

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.

David
fuente
Esa Yqfunción (y su implementación) fue una muy buena sugerencia tuya :-)
Luis Mendo
IK+funcionaría igual de bien para 7, pero es un poco aburrido: P
David
10

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.

Emigna
fuente
1
algo mal con e / e = 1?
Level River St
@steveverrill: se convertirá en flotante (1.0). Interpreté la descripción del desafío en el sentido de que los números deberían ser enteros. La mayoría de estos, si no todos, podrían acortarse de otra manera.
Emigna
1
@steveverrill Los flotadores están bien. Solo necesitamos el valor correcto .
Adám
9

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
orp
fuente
55
PHP tiene muchas extensiones y, por lo tanto, muchas constantes predefinidas mucho mejores que las matemáticas para este desafío;). LC_ALLpara 0 (-1 byte), DNS_Apara 1 (-3 bytes), LOCK_NBpara 4 (-3 bytes), LC_TIMEpara 5 (-7 bytes), LOG_INFOpara 6 (-8 bytes), INI_ALLpara 7 (-5 bytes), ...
Blackhole
55
IMG_WBMPPara 8 (-4 bytes), SQL_DATEpara 9 (-9 bytes), SQL_TIMEpara 10 (-3 bytes) y LOG_INFO*INI_ALLpara 42 (-11 bytes). ¡De ahí un total de 51 bytes guardados! Estas constantes son válidas al menos en PHP 5.6.1 en Windows.
Blackhole
@Blackhole no es LC_ALLuna cosa dependiente de la localidad?
gato
@cat De hecho, es una constante utilizada setlocale()para cambiar todas las categorías de configuraciones regionales. Pero el valor de la constante en sí es, por supuesto, independiente de la configuración regional :).
Blackhole
@ Blackhole ah, ya veo!
gato
9

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!

Joachim Jablon
fuente
Bienvenido a PPCG :) No estoy 100% seguro de este desafío, pero creo que usarlo Truecomo modismo para 1 debería ser aceptable, ya que no sé cuándo no son equivalentes como fragmentos.
FryAmTheEggman
Oh tienes razon! No lo uso para el 1 en sí, porque ¡ True is not 1pero para todos los cálculos basados ​​en 1, ayuda! Editando ahora.
Joachim Jablon
1
Utilizar #8 len(`id(id)`). Entonces 8, 9 y 10 serán más cortos. Además, quizás agregue un hipervínculo para Probar en línea .
mbomb007
Puede obtener 9 con len(`{()}`)11 bytes, y eso le da 7 a 10 más corto.
xnor
9

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.

Timwi
fuente
¿Le permitirían las reglas hacer algo así var a = new int();y luego usarlo aen cada fragmento?
señora
@LoganDam: Me parece más interesante si cada expresión tiene que ser independiente. Por eso también no utilicé ninguna usingdeclaración.
Timwi
Whoa para qué son esos 10/09/42: Oo
ev3commander
@ ev3commander: son simplemente los valores de enumeración más cortos definidos en mscorlib que tienen el valor entero necesario. Para ConsoleKey.Tab, el valor 9 no es sorprendente (9 también es el ASCII del carácter de tabulación). Los otros son probablemente arbitrarios.
Timwi
El más corto para 8:int a=-~-~new int();a<<a
LegionMammal978
9

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

TessellatingHeckler
fuente
x^yes xor en JavaScript. JavaScript (ES7) tiene **para exponentes. Fuente
mbomb007
@ mbomb007 Ah, gracias. He actualizado mi nota al respecto.
TessellatingHeckler
@ mbomb007 Sigo pensando que es un poco tonto
SuperJedi224
@ SuperJedi224 ¿Por qué? Así es como lo hace Python. Y xor es un operador importante.
mbomb007
8

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
yeti
fuente
Creo que Ey Faquí hay dígitos (incluso cuando son mayores que la raíz de entrada). La evidencia de esto es que se combinan como dígitos; por ejemplo F0-> 150. Puede ver el mismo comportamiento con los dígitos decimales una vez que cambie la raíz de entrada y salida.
Toby Speight
Hay muchas otras respuestas usando cosas similares ... ¿por qué debería ser el único en el que esto no está bien?
yeti
No debería, si hay otras soluciones que usan dígitos, entonces tampoco son respuestas válidas.
Toby Speight
1
¡Ya no me importa! Codegolf incluso acepta un programa de conjunto gráfico mandelbrot como solución a la tarea de escribir un programa mandelbrot de arte ascii ... codegolf necesita un gran reinicio y, cuando se reinicia, puede que me interesen o no las reglas nuevamente ...: -Þ
yeti
7

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.

lirtosiast
fuente
¿No se considera π datos numéricos?
vsz
@vsz quizás, pero no es un número literal. La operación incluso lo dice.
SuperJedi224
@NBZ muy buen punto. Culpa mía.
GamrCorps
6

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
ბიმო
fuente
Puede guardar bytes coni=id(id);r=~i/i
Cyoce
6

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)

SuperJedi224
fuente
5

Javascript (Browser Env), 155 136 130 bytes

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

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

usandfriends
fuente
1
Puedes usar -~[]+[]+-[]para producir 10. Devolverá una cadena, pero aún se puede usar como un número. Además, puede usar -~(top+top.s).lengthpara calcular 42(-8 bytes) y eliminar su dependencia de Google Chrome. Para guardar más 3 bytes, use (P=Math.PI)*P>>+[]para calcular 9.
Ismael Miguel
1
Lo siento, olvidé algunos bytes que puedes afeitar. Puedes usar ~(~[]+[]+-[])para generar 9. Eso debería reducir algunos bytes más.
Ismael Miguel
curiosamente, +[12]da 12y +[1, 2]da NaN. Odio a JS
gato el
2
@cat Es por el extraño sistema de transmisión de JavaScript. Las matrices se convierten en cadenas como [1,2,3]=> "1,2,3"y las cadenas se convierten en números como "12"=> 12pero si hay caracteres que no son números en la cadena, la conversión vuelve NaN. +[1,2]se "1,2"convierte en una cadena y luego en un número, pero la cadena contiene una coma, por lo que se convierte NaN.
user81655
@ user81655 eso. es. HORRIBLE.
gato
5

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!

Mego
fuente
1
¿Supongo que en serio usa una página de códigos de 256 caracteres que incluye caracteres pseudo gráficos?
Adám
2
@NBZ CP437
Mego
Puede guardar un byte en 6 con Hl▓
quintopia
La misma idea con ú ahorra un byte el 9
quintopia
HlPDahorra 2 bytes en 42, y QlPguarda un byte en 7, y Qlªguarda un byte en 9, y Ql╙guarda un byte en 8. Creo que eso se reduce seriamente a 33 bytes, relacionando a Pyth.
quintopia
5

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[@]}"
Toby Speight
fuente
4

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.

Martin Ender
fuente
@NBZ Lo siento, me olvidé 0. Si aobtiene el valor 0después, eso no es un problema, siempre que no se use cuando a/ase evalúa.
Martin Ender
@NBZ El recuento de bytes es simplemente el recuento de bytes UTF-8.
Martin Ender
4

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
°    ++
´    --
ETHproducciones
fuente
¿Japt toma números hexadecimales por defecto? Si es así, entonces A a F serían literales numéricos ...
Adám
@NBZ A-Ison variables que, por defecto, se asignan a varios números, como se muestra arriba. A-Fson asignados a 10-15. ¿Esto invalida esas variables?
ETHproductions
No. Me preguntaba si, digamos, 12AB3 era válido. Ahora sé que no lo es. No hay literales aquí, sigue adelante. :-)
Adám
4

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
overactor
fuente
Seguro que parece que 0 ... L son literales numéricos.
Adám
2
@NBZ No lo son, no puedes usarlos de forma independiente. +0 a + Z son como funciones integradas. Es aburrido pero válido.
overactor
4

> <> , 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.

Aaron
fuente
Probablemente pueda eliminar el nen cada uno porque las funciones en lenguajes basados ​​en la pila pueden dejar la salida en la pila por -11 bytes.
redstarcoder
@redstarcoder, incluso podría eliminar ;un total de 22 bytes y considerar el final de la función alcanzada al final de la línea, pero es un poco ambiguo ya ><>que no tiene funciones listas para usar .
Aaron
Técnicamente, si desea funciones ><>, sus funciones tienen que aceptar una posición de retorno (x & y) en la pila además de sus parámetros, asegúrese de que no estén en el camino al hacer los cálculos ( [es útil en ese contexto), luego salte a la posición de retorno después de haber terminado la ejecución. Había hecho un POC hace un tiempo, échale un vistazo si estás interesado
Aaron
De hecho, he visto tu publicación antes, ¡y buen trabajo! Hice una meta publicación sobre las ambigüedades de las funciones . Lo que digo es que esto normalmente está permitido, con el ;. La razón por la que digo dejar ;es porque de lo contrario no hay forma de denotar cuando la función termina sin a .. La mayoría de la gente parece considerar esto justo, pero podría tratar de escribir una meta publicación específica aquí si le preocupa.
redstarcoder
1
@redstarcoder gracias por la información! Siento que el sufijo de los ><>fragmentos .sería la mejor manera de apegarse a la definición de función como se describe en la respuesta más votada de la meta publicación, sin embargo, estoy de acuerdo en que ;es una buena alternativa que requiere menos explicación.
Aaron
4

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.

dnep
fuente
0=Z9
Adám
Eliminado el =s, gracias. Con respecto a su sugerencia, evité las referencias de celda a propósito, para asegurarme de que las fórmulas sean independientes del contenido de la tabla; si Z9contiene un texto, =Z9ya no devolverá cero. Decidí no asumir nada sobre la mesa.
dnep
de todos modos, me hiciste saquearlo de nuevo, y me di cuenta de que al menos podía guardar 1 byte usando a 0 la misma lógica que solía 1 ...
Dnep
Pero algunos idiomas tienen todas las variables establecidas en 0 si no están configuradas en otra cosa. En este contexto, vería Excel como un lenguaje con celdas de memoria (teóricamente infinitas) A1: ZZZ ..: 999 ... y sin distinción entre el código del programa y los datos (es decir, puede modificarse automáticamente). Dado que cada fragmento es independiente de los demás, supongo que está en A1, y el resto de la hoja está en blanco. (Para los programas, tendría una declaración completa en cada celda A1, A2, etc.)
Adám
Veo su punto ... pero hay un problema adicional con las referencias de celda: Z9en una hoja vacía hay un valor vacío que se convierte 0en muchos casos, pero que puede convertirse a ""(cadena vacía) si se usa en algunas expresiones, al igual que una variante no inicializada de VBA, por lo que no es estrictamente equivalente a 0. Por ejemplo, = 0&"a" se evalúa como "0a"pero se = Z9&"a"evalúa como "a". Sin embargo, esto se puede resolver agregando un unario -a la referencia (lo que obliga a que sea numérico, nuevamente, al igual que en VBA). Entonces -Z9 se puede usar como cero. Acabo de actualizar la respuesta. Gracias de nuevo.
dnep
4

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.

Mama Fun Roll
fuente
4

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
acrolito
fuente
1
es más limpio de pila que Yx, Xse puede usar en lugar de ºaquí (por defecto 1, ºsignifica len(stack)>1, por lo que no se predetermina a nada). Además, su bytecount es 24, no 35 (CP-1252, las líneas nuevas no cuentan si son fragmentos separados).
Erik the Outgolfer
Sé que aún no era posible en el momento en que publicó esto, pero 6 puede ser ₆tahora (presione 36, raíz cuadrada) para guardar un byte ( Pruébelo en línea ).
Kevin Cruijssen
3

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.

ASCIIThenANSI
fuente
66
Esos seguramente me parecen literales. Además, no publique código que no haya probado.
Mego
2
¿Puedes explicar cómo funcionan?
Adám
@NBZ D1ffe7e45e funciona en función de la diferencia entre dos números hexadecimales. Esa diferencia se interpreta en un comando. Por ejemplo, la diferencia entre 0 y 2 es 2, que se interpreta como el comando de incremento (como +en Brainf ** k). Pensé que, dado que se usan como comandos y no como literales numéricos, todavía contaba. Eliminaré la respuesta si no lo hace.
ASCIIThenANSI
@Mego Tengo el intérprete trabajando y mi código funciona. Vea el comentario anterior para saber por qué creo que no son literales.
ASCIIThenANSI
1
No creo que ninguno de estos sean literales. Sin embargo, no creo que deba imprimir los números, ya que el resultado de cada fragmento debe dar como resultado un número real que se pueda usar para cálculos adicionales .
Dennis
3

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í !

lirtosiast
fuente
El usuario Mimarik sugirió guardar un byte en 42 con yhyT. ( Rechacé la edición según meta.codegolf.stackexchange.com/questions/1615/… )
Martin Ender