Como gran fanático de la serie Lost TV , siempre me intrigó la secuencia de números que aparece repetidamente en los episodios. Estos números son:

$4, 8, 15, 16, 23, 42$ ( A104101 )

Usando cualquier lenguaje de programación, escriba un código que genere estos números.

Puntuación:

• La respuesta más corta gana

• La salida no debe contener ningún otro número o letra. Puede usar cualquier otro carácter como separador, o incluso ningún separador.

• No puede separar dígitos del mismo número. es una respuesta válida, pero no lo es.$48\_15162342$$481\_5162342$

• Debes respetar el orden.

• Si su código no contiene ninguno de los números de la secuencia, reduzca su puntaje en un 30%. Esta regla le permite ingresar los dígitos por separado. P.ej:

  abcde1fg5h
  

  Es un candidato válido porque la respuesta no contiene el número , solo sus dígitos. Sin embargo, cualquier u 8 invalidará el bono.$15$$4$$8$

• Si el código no contiene ningún dígito, reduzca su puntaje en un 50%. Otros personajes como $¹$ , $²$ o $³$ siguen siendo válidos para este bono.

Perdido , 29 27/2 = 13.5 bytes

%?\>>>>>>>>>>
>>\"*"@"

Pruébalo en línea! o verificar que es determinista

Parecía el lenguaje correcto para usar.

Explicación:

Lost es un lenguaje 2D donde el puntero comienza en cualquier lugar , yendo en cualquier dirección. Esto generalmente lleva a una doble verificación de que el puntero no haya ingresado a una sección antes.

...>>>>>>>>>>  These arrows filter all pointers that appear on the top line
.............  Or going vertically


%............  This flips the flag so that the program can end
.............  This stops premature termination

.?\..........  Clear the stack by skipping if a value popped from the stack is positive
.............  When the stack is empty, the \ directs the pointer down

.............  The \ directs the pointer right
..\"*"..  The string literal pushes all the Lost values to the stack

..\..........  The @ terminates the program if the % flag is switched
>>\........@.  Otherwise it clears the stack and repeats

.............  The quote here is to prevent the pointer getting stuck
............"  This happens when the pointer starts between the other quotes

Jalea , 7/2 = 3.5 bytes

“ƲÞIȥ’Ḥ

Imprime los números sin separador, es decir, el entero .$4815162342$

Pruébalo en línea!

Cómo funciona

“ƲÞIȥ’es biyectivo base-250 entero literal.
Ʋ, Þ, I, Y ȥtener (1-base) índices , , , y en la página de códigos de jalea, de manera que codifican el número entero .$154$$21$$74$$171$$250^3\cdot154+250^2\cdot21+250\cdot74+171=2407581171$

Finalmente, Ḥ(unhalve) dobla el número entero, produciendo $2\cdot2407581171=4815162342$ .

Es necesario duplicar, porque codificar la salida conduce directamente a “¡9)Ƙ[’, que contiene un dígito.

Neim , 6 5 bytes, 3 2.5 puntos

Jσς§A

Explicación:

J     Push 48
 σ    Push 15
  ς   Push 16
   §  Push 23
    A Push 42
      Implicitly join the contents 
      of the stack together and print

Pruébalo en línea!

05AB1E , puntaje: 10 9 7 bytes / 2 = 3.5

•‘o]Ê•·

Pruébalo en línea.

O alternativa de 7 bytes :

•’µ[%•R

Pruébalo en línea.

Ambos emitiendo el entero 4815162342.

Explicación:

•‘o]Ê•     # Compressed integer 2407581171
      ·    # Doubled

•’µ[%•     # Compressed integer 2432615184
      R    # Reversed

Vea esta sugerencia mía 05AB1E (sección ¿Cómo comprimir enteros grandes? ) Para comprender por qué •‘o]Ê•es 2407581171y •’µ[%•es 2432615184.

Antigua respuesta de 9 bytes que genera la lista [4,8,15,16,23,42]:

•ΓƒÇ²•т;в

-1 byte (y por lo tanto -0.5 puntaje) gracias a @Emigna .

Más largo que la otra respuesta 05AB1E , pero esto genera la lista en [4,8,15,16,23,42]lugar del entero 4815162342.

Pruébalo en línea.

Explicación:

•ΓƒÇ²•       # Compressed integer 1301916192
      т;     # Integer 50 (100 halved)
        в    # Convert the first integer to Base-50 (arbitrary): [4,8,15,16,23,42]

Vea esta sugerencia mía 05AB1E (secciones ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender por qué •ΓƒÇ²•es 1301916192y •ΓƒÇ²•50вes [4,8,15,16,23,42].

JavaScript (ES7), 34/2 = 17 bytes

_=>eval(atob`NjUwNTgxMDErNDEqKjY`)

Pruébalo en línea!

Esto decodifica y evalúa la expresión "65058101+41**6", que no contiene ningún dígito una vez codificado en base-64.

JavaScript (ES6), 13 bytes

Aburrida solución obvia.

_=>4815162342

Pruébalo en línea!

Python 3 , 25 bytes, 12.5 puntos

print(*map(ord,'ዏٗ*'))

Pruébalo en línea!

𩦦 （髒, ⿰ 馬 葬）, 𧨦 （謚, ⿰ 言 ⿱⿵ 八一 皿） cuestan 4 bytes, pero U + 0657 solo cuesta 2 bytes ...

Python 3 , 29 bytes, 14.5 puntos

print(ord('𩦦')*ord('湡'))

Pruébalo en línea!

𩦦 （⿰ 馬 葬） es un carácter variante de 髒 que significa "sucio". 湡 es el nombre de un río. Y no tienen nada que ver con esta pregunta, como lo sabía.

Brain-Flak , 52/2 == 26 bytes

(((((((((()()()())){})){}[()])())[]()()())){}[[]]())

Pruébalo en línea!

Java 8, puntuación: 12 11,9 (70% de 17 bytes)

v->767*6277917L+3

-0.1 puntaje gracias a @RickHitchcock .

Pruébalo en línea.

Explicación:

v->               // Method with empty unused parameter and long return-type
  767             //  767
     *6277917L    //  multiplied by 6277917 (as long)
              +3  //  And then 3 is added

Antigua respuesta con una puntuación de: 12 (50% de 24 bytes):

v->(long)''*'Ⓥ'*'䧶'

Contiene un carácter no imprimible 0x1B.

Pruébalo en línea.

Explicación:

v->                   // Method with empty unused parameter and long return-type
  (long)              //  Cast the character (and therefore the result) to a long
        ''            //  27
           *'Ⓥ'       //  Multiplied by 9419
                *'䧶'  //  Multiplied by 18934

En Java, los caracteres se pueden autoboxear a enteros que tienen su valor unicode. Desafortunadamente, el máximo unicode admitido para caracteres es 65,535, por lo que no puedo usar solo dos caracteres para multiplicar (ya que los dos números más grandes que dividen el esperado 4,815,162,342son 56,802y 84,771, donde 84,771desafortunadamente excede el máximo 65,535.
Además, ya que el tamaño máximo de un intes 32 ² -1 ( 2,147,483,647) y el resultado 4,815,162,342es mayor que eso , se requiere una conversión explícita a long, que puede contener hasta 64 ² -1 ( 9,223,372,036,854,775,807).

La respuesta aburrida habría sido de 14 bytes sin ninguna bonificación:

v->4815162341L

Pruébalo en línea.

R, 18x0.7 = puntaje 12.6

cat(9*2*267509019)

Bastante autoexplicativo, solo hace algo de aritmética evitando los números en cuestión.

7 , 10 bytes, 27 caracteres

115160723426754314105574033

Pruébalo en línea!

La representación empaquetada de este programa en el disco es ( xxdformato):

00000000: 269c 3a71 6f63 308b 7c0d                 &.:qoc0.|.

Explicación

Hemos visto esta secuencia de números antes, en Automate Saving the World , que consistía en imprimir los números a intervalos regulares, haciéndolo interesante al requerir el uso de un lenguaje muy antiguo. Sin embargo, muchos idiomas más nuevos pueden tener sus propios giros que hacen que este desafío sea interesante. _{(Sí, este párrafo, y de hecho la razón por la que comencé a escribir esta respuesta, es efectivamente solo una forma de mostrar todos los desafíos relacionados en la barra lateral; normalmente las personas lo hacen usando comentarios, pero no tengo suficiente representante .)}

Lo primero que debe tener en cuenta es que 7 está hecho completamente de dígitos, por lo que es poco probable que las bonificaciones funcionen aquí (aunque si ve el programa como una secuencia de octetos, ninguno de ellos corresponde a representaciones ASCII de ninguno de los números originales , para que puedas reclamar la bonificación en ese sentido). Lo siguiente a tener en cuenta es que 7 tiene comandos para recrear la secuencia de comandos que probablemente haya producido una pieza específica de datos; Entonces, ¿podríamos interpretar los números perdidos 4815162342como una sección de un programa 7 en sí?

La respuesta es "no del todo". La parte más problemática es ese segundo número 8,. 7 programas están escritos en octal; no hay un número como 8. Por lo tanto, el comienzo de la cadena tendrá que imprimirse de manera diferente.

Por lo tanto, la base del programa se basa en el programa 7 "Hola mundo":

5431410557403
543141055          string literal
         7         separate data from code
          4        rearrange stack: {program's source}, empty element, {literal}
           0       escape {the literal}, appending it to {the empty element}
            3      output {the escaped literal}, pop {the program's source}

con el literal escapado en un lenguaje de dominio específico que se interpreta de la siguiente manera:

5                  output format: US-TTY using pairs of digits in the string
 43                select character set: digits and common symbols
   14              "4"
     10            "8"
       55          forget the set output format

Después de esto viene un extra 3, que genera el elemento de pila restante (y sale debido a la pila restante insuficiente). Ese elemento se especifica al inicio del programa, y ​​para evitar lo inigualable 6(que funciona un poco como un corchete de cierre), lo generamos usando código, en lugar de escribirlo directamente como datos. (Tenga en cuenta que hay dos 7caracteres implícitos al inicio del programa, que es relevante aquí):

{77}115160723426
 7                 empty stack element
  7 11516          append "1151"
         0         append "6"
          723246   append "2324"

Eso produce el siguiente literal:

115162324
1                  set output format: literally as octal
 15162324          "15162324"

que se imprime

05AB1E , 6 * 0.7 = 4.2 bytes

•1Z&ð“

Pruébalo en línea!

Imprime el número sin comprimir desde base-255

Fuente de ensamblaje MASM 8088, (93 bytes - 50%) = 46.5 bytes

Sin usar números o la secuencia en la fuente:

MOV AH,'P'-'G'
LEA DX,L
INT '!'
RET
T EQU '-'-'+'
L DW 'ph'/T,'jb'/T,'lb'/T,'fd'/T,'dh'/T,'$'

Salida:

A>LOST.COM
4815162342

Carbón , 13 bytes / 2 = 6.5

ＩＥTPIHA.⁻⁸⁸℅ι

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona restando los códigos ASCII de la cadena TPIHA.de 88 y convirtiendo a cadena.

Aheui (esótopo) , 45 bytes (15 caracteres) * 0.5 = 22.5 puntos

반밤밪박밭빠따받발따밣뱣히망어

Pruébalo en línea!

Explicación:

Mira esto también; Referencia de Aheui ( inglés )

Aheui program starts with default stack '아'(or none)

반: push 2, move cursor right by 1(→).
밤: push 4, →
밪: push 3, →
박: push 2, →
밭: push 4, →
빠: dup, →
따: pop 2, push mul result(16).
받: push 3, →
발: push 5, →
따: pop 2, push mul result(15).
밣: push 8, →
뱣: push 4, move cursor right by 2(→→).
히: end.
망: pop 1, print, → (if stack is empty, move cursor left by 1.)
어: move cursor left by 1(←).

Tenga en cuenta que ㅁ (instrucción de impresión) mueve el cursor en dirección inversa si la pila (o la cola) está vacía.

Perl 5 , 16 bytes - 30% = 11.2

say 0x5FAB2EA2*3

Pruébalo en línea!

PowerShell , 12 bytes * 0.7 = 8.4

0x5FAB2EA2*3

Pruébalo en línea!

"Puerto" de la respuesta de Xcali para tener una mejor respuesta Powershell.

naz , 46 bytes, puntaje 32.2

2a2a1o2m1o7s1o5m1o2s2s1o6m1o2s2s1o1a1o1a1o2s1o

Simplemente genera cada dígito en 4815162342uno a la vez.

JavaScript, 143 bytes (no estoy seguro de cómo calificar)

(g=`${2*2}`)=>g.repeat(6).replace(/(.)/g,(m,p,i,k='')=>
  (k=m*[g-3,g-2,g,g,+g+2,g*3-1][i]
  ,RegExp(`${g-2}|${g}`).test(i)?k-1:i==+g+1?k-(g/2):k))

Pruébalo en línea!

Comience con seis 4, multiplique, sume, reste por, a, de 4para derivar la salida.

PHP, 35/2 = 17.5

<?=zzzzzzzzzzzzzzz^NVBVKOVKLVHIVNH;

Un enfoque digital: 40 * .7 = 28

<?=2+2,_,5+3,_,17-2,_,17-1,_,17+6,_,7*6;

sin dígitos, sin cadenas: 68/2 = 34

<?=$p++,!$p++,$p+=$p,_,$p+=$p,_,~-$q=$p+$p,_,$q,_,--$p+$q,_,$p*~-$p;

Pruébalos en línea .

JavaScript (SpiderMonkey), 67 bytes / 2 = 33.5 60 bytes / 2 = 30 58 bytes / 2 = 29 48 bytes / 2 = 24

-7 bytes / 3.5 , -2 bytes / 1 cortesía de @JoKing, -10 bytes / 5 cortesía de @tsh

print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Pruébalo en línea!

APL (Dyalog Unicode), 18/2 = 9 bytes

×/⎕UCS'𩦦湡'

Simplemente aburrida multiplicación de personajes viejos.

Pruébalo en línea!

JavaScript (ES6), 16 * 0.7 = 11.2 bytes

_=>767*6277917+3

Emite los dígitos sin delimitadores.

¡Pruébelo en línea!

Espacio en blanco , puntuación: 49 41 bytes / 2 = 20.5

[S S S T    S S S T T   T   T   T   S S S S S S S T T   S S S T S T T   T   T   T   S S T   T   S N
_Push_4815162342][T N
S T _Print_number]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Pseudocódigo:

Integer i = 4815162342
Print i as number to STDOUT

Explicación:

En el espacio en blanco, se empuja un número de la siguiente manera:

• S: Habilitar manipulación de pila
• S: Número de inserción
• S/ T: Positivo / negativo respectivamente
• Algunos T/ Sseguido de un solo N: Decimal como binario, donde Tes 1 y Ses 0

Después de eso, simplemente se imprime con TNST:

• TN: Habilitar E / S
• S: Salida de la parte superior de la pila
• T: Como número

F #, 45 bytes = 22.5 puntos

Solo un forciclo común que imprime los dígitos:

for c in"DHOPWj"do printf"%d"(int c-int '@')

Lo anterior es un programa completo que se puede compilar en un ejecutable.

En un REPL (bucle read-eval-print), por ejemplo, FSI (F # Interactive), la siguiente versión más corta funcionará, ya que REPL generará una representación de la expresión evaluada; tiene 35 bytes = 17.5 puntos:

[for c in"DHOPWj"->int c-int '@'];;

Pyke , 3 puntos

77 91 f8 86 98 06

Pruébalo aquí!

El primer byte señala que se lea en la base 128 hasta que se establezca un byte sin el bit alto.

Finalmente, 32 se resta del resultado (por razones históricas).

Esto permite la generación de grandes números en muy pequeñas cantidades de espacio.

MathGolf , 7 bytes * 0.5 = 3.5

ÿ≤┼ÇÅ$∞

Pruébalo en línea!

Explicación

Tenga en cuenta que este código aún no funciona en TIO. Recientemente he realizado algunos cambios en MathGolf, incluida la adición del $operador. Una vez que se extrae a TIO, puede ejecutarlo allí, luego haré una actualización de esta respuesta. Funciona perfectamente en la terminal

ÿ≤┼ÇÅ     Push "≤┼ÇÅ"
     $    pop(a), push ord(a) (pushes 2407581171)
      ∞   pop a, push 2*a

Utilizo el hecho de que MathGolf tiene literales de 1 byte para crear cadenas de hasta 4. Si hubiera querido convertir el número entero de una cadena de base 256, habría necesitado usar dos ", y la cadena habría sido 5 caracteres. De esta manera, ahorro 2 bytes, pero pierdo un byte al tener el operador de duplicación al final.

Python 3 34 Puntos

b=len("  ");c=b*b;d=c*b;e=d*b;g=e+d-b//b;print(c,d,e-b//b,e,g,g*b-c)

Python 3 , 44 38 19 18.5 bytes

-6 bytes gracias a @Jo King
-50% bytes gracias a @ouflak por señalar el bono del 50%
-1 byte gracias a @Dennis

for i in'밗ɯ*':print(ord(i),end='')

Pruébalo en línea!

Japt, 10 9 bytes / 2 = 4.5

"0¢*"mc

Pruébalo

Befunge-98 (FBBI) , 15 bytes / 2 = 7.5 puntos

"*H/!k-"*.*+..@

Pruébalo en línea!

Explicación:

Primero empuje los valores ASCII de los caracteres '* + H /! K- (42, 72, 47, 33, 107, 45) en este orden a la pila. Luego computa$4815 = 45 \cdot 107$ y $1623 = 33\cdot 47+72$y salida.