Este es un reenvío de Evolution of "Hello World!" , Escrito originalmente por el usuario Helka Homba

No debe cerrarse como duplicado, debido al meta consenso aquí .

El original se solicitó hace más de dos años y estuvo activo por última vez hace más de seis meses. Tengo permiso de Helka Homba para publicar esto aquí

Desde el original, se han inventado muchos idiomas, y muchas personas se han unido al sitio que nunca han tenido la oportunidad de responder el original, por lo que creo que este reenvío es aceptable.

El desafío es hacer un programa que se imprima 2^nen stdout, donde nestá el número de su programa. El problema es que su programa debe tener una distancia de Levenshtein de 10 o menos del programa en la respuesta presentada antes que la suya.

Cómo funcionará esto

A continuación, enviaré la primera respuesta con C #, que imprime 2 ^ (n = 1) = 2.

La siguiente persona que responda debe modificar el código con hasta 10 inserciones, eliminaciones o sustituciones de un solo carácter para que cuando se ejecute en el idioma de la nueva respuesta, se imprima 2^n(con nel número de respuesta). Por ejemplo, la respuesta número 25 (digamos que está en Pyth) imprimiría 2 ^ 25 o 33554432.

Esto continuará hasta que todos se atasquen porque no hay un nuevo idioma en el que se pueda ejecutar el programa de la última respuesta solo cambiando 10 caracteres. El objetivo común es ver cuánto tiempo podemos mantener esto, así que trate de no hacer ediciones de caracteres oscuras o injustificadas (sin embargo, esto no es un requisito).

Formateo

Por favor, formatee su publicación de esta manera:

#Answer N - [language]

    [code]

[notes, explanation, observations, whatever]

Donde N es el número de respuesta (aumenta gradualmente, N = 1, 2, 3, ...).

No tiene que decir qué caracteres exactos se cambiaron. Solo asegúrese de que la distancia de Levenshtein sea de 0 a 10.

Si su respuesta en un idioma o el código resultante es un desastre, no por favor, explique lo que hizo y por qué funciona, aunque esto no es necesario.

Reglas

La clave para entender sobre este desafío es que solo una persona puede responder a la vez y cada respuesta depende de la anterior .

Nunca debe haber dos respuestas con el mismo N. Si dos personas responden simultáneamente por un poco de N, el que respondió más tarde (incluso si es una diferencia de unos segundos) debería eliminar gentilmente su respuesta.

Además...

• Un usuario no puede enviar dos respuestas seguidas. (por ejemplo, desde que envié la respuesta 1 no puedo responder 2, pero podría responder 3.)
• Intente evitar publicar demasiadas respuestas en un corto período de tiempo.
• Cada respuesta debe estar en un lenguaje de programación diferente.
  • Puede usar diferentes versiones principales de un lenguaje, como Python 2/3
  • Los idiomas cuentan como distintos si tradicionalmente se llaman con dos nombres diferentes. (Puede haber algunas ambigüedades aquí, pero no dejes que eso arruine el concurso).
• No tiene que atenerse a ASCII, puede usar los caracteres que desee. La distancia de Levenshtein se medirá en caracteres unicode .
• La salida solo debe ser 2^ny no otros caracteres. (El espacio en blanco inicial / final está bien, al igual que la salida no soportable como >>>o ans=)
• Si su idioma no tiene stdout, use lo que se usa comúnmente para generar texto rápidamente (por ejemplo, console.logo alerten JavaScript).
• Cuando la potencia de dos que tiene que emitir es muy grande, puede asumir una memoria infinita, pero no un tamaño entero infinito. Tenga cuidado con los desbordamientos de enteros.
• Puede hacer uso de la notación científica o de cualquier idioma que sea la forma más natural de representar números. (Excepto para unario, NO envíe en unario)

Asegúrate de que tu respuesta sea válida. No queremos darnos cuenta de que hay una ruptura en la cadena de cinco respuestas. Las respuestas no válidas deben repararse rápidamente o eliminarse antes de que haya respuestas adicionales.

No edite las respuestas a menos que sea absolutamente necesario.

Tanteo

Una vez que las cosas se calman, el usuario que envía la mayoría de las respuestas (válidas) gana. Los lazos van al usuario con los votos positivos más acumulativos.

Edítelos cuando publique una respuesta:

Tabla de clasificación

13 idiomas

Okx

8 idiomas

zepelín

4 idiomas

Pavel
Jonathan Allan
Kritixi Lithos
Riker

3 idiomas

boboquack

2 idiomas

comentarios
Conor O'Brien
Sandía Destructible
ovs
Tom Carpenter

1 idioma

ATaco
Blocks
Dennis
dzaima
Erik the Outgolfer
ETHproductions
ghosts_in_the_code
Leo
Lynn
Matheus Avellar
Nathaniel
Qwerp-Derp
R. Kap
Taylor Scott
nimi
Mistah Figgins
PidgeyUsedGust
steenbergh

Idiomas utilizados hasta ahora:

1. C # (Pavel)
2. /// (boboquack)
3. Retina (Dennis)
4. Jalea (Jonathon Allan)
5. Pyth (boboquack)
6. > <> (Sandía Destructible)
7. Minkolang (Kritixi Lithos)
8. Perl (Pavel)
9. Python (Qwerp-Derp)
10. dc (R. Kap)
11. Carbón (Jonathon Allan)
12. BrainFuck auto modificable (Leo)
13. SOGL (dzaima)
14. ShapeScript (Jonathon Allan)
15. Pyke (boboquack)
16. Rubí (Nathaniel)
17. 05AB1E (ovs)
18. STATA (marcas)
19. aC (Kritixi Lithos)
20. Japt (Okx)
21. 2sable (Kritixi Lithos)
22. Cheddar (Jonathon Allan)
23. Pilones (Okx)
24. Bash (zepelín)
25. Pushy (Okx)
26. CJam (Erik el Outgolfer)
27. MATL (Okx)
28. MATLAB (Tom Carpenter)
29. Octava (Kritixi Lithos)
30. R (ovs)
31. JavaScript ES7 (Tom Carpenter)
32. Convexo (Okx)
33. Mathematica (ghosts_in_the_code)
34. Pip (Okx)
35. Apilado (Conor O'Brien)
36. GolfScript (Okx)
37. En realidad (lynn)
38. RProgN (Okx)
39. Esquema (comentarios)
40. Elemento (Okx)
41. J (bloques)
42. Cubix (ETHproductions)
43. zsh (zepelín)
44. VBA (Taylor Scott)
45. Pescado (zepelín)
46. Reticular (Okx)
47. Perl 6 (Pavel)
48. RProgN2 (ATaco)
49. PHP (Matheus Avellar)
50. Jolf (Conor O'Brien)
51. Haskell (nimi)
52. Befunge-98 (Mistah Figgins)
53. Gnuplot (zepelín)
54. QBIC (steenbergh)
55. FOG (Riker)
56. Qwerty-RPN (Okx)
57. Korn Shell (ksh) (zepelín)
58. Julia (Riker)
59. Python 3 (Pavel)
60. Vimscript (Riker)
61. Dash (zepelín)
62. Vitsy (Okx)
63. csh (zepelín)
64. Ohm (Okx)
65. Bosh (zepelín)
66. es-shell (Riker)
67. Gol> <> (PidgeyUsedGust)

Esta pregunta funciona mejor cuando ordena por más antigua .

Answer 64, Ohm, distance 10

64º,;S)1'a"bc"<<x
2^63 
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
exit
 @n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:py print(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Added 64º,;S)1'a

Only the 64º, is actual code, the rest is just junk.

This program will print the correct output, but it will also ask for some STDIN after it has printed 2⁶⁴.

Answer 17: 05AB1E, Distance of 3

#"Ａ#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#β”6904”±r«"$2 
puts 16384 8*

Try it online!

Answer 24: Bash, distance 8

#23#2ej
printf $[2**24]
#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#ß”6904”±r«"$2 
#puts 16384 8*di 2^18o8*'

Try It Online !

Answer 51, Haskell, distance 10

--2@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024
print(2^51)--;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Remove 2 NL, replace ^ at the beginning with -, prepend another -, delete * within the print, replace 2nd * with ^, overwrite 49with 51, insert -- after the print.

Answer 67, Gol><>, distance 6

We van use the trampoline # to just append the code in reverse. By removing S)1'a the ; can be reused, needing only 6 characters to be added.

#64º,;n*:"C"
"bc"<<x
2^66
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
quit()
@n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:
py 
p
riker
i
n
t
(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#

Try it online!

I think keeping the # allows for some other languages to use it as a commented line.

Answer 4: Jelly distance 3

/class HelloWorld {static void Main() 0{
    System.Console.Write(2);
0}}//4|
8Ḥ

Try it online!

all insertions: 00Ḥ.

0{ and 0} are there to suppress parsing errors (pop from empty list due to the { and } being quicks that turn monads into dyads using the left and right argument respectively).

Ḥ "unhalves" 8 to make 16.

Answer 5: Pyth

32 "/class HelloWorld {static void Main() 0{
    System.Console.Write(2);
0}}//4|
8Ḥ

Prints the numeric literal 32, then the space between the 2 and the " suppresses printing of the (auto-completed) string literal.

+4 characters - 32 "

Try it on herokuapp

Answer 6 - ><>

32""/class HelloWorld {static void Main() 0{;n***~
    System.Console.Write(2);
0}}//4|
8Ḥ

replaced a space with ", the code pushes 3, 2, 4, then reverses, pushes 4,2,3, then pops 3 off the stack, and multiplies 2, 4, 4, 2, for 64, outputs it and halts

Try it online

maybe use https://www.fishlanguage.com/playground

Answer 3: Retina, distance 3

/class HelloWorld {static void Main() {
    System.Console.Write(2);
}}//4|
8

Appended |\n8 (distance 3).

Try it online!

Answer 20: Japt, distance 8

2**20$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#ß”6904”±r«"$2 
#puts 16384 8*di 2^18*/

Try it online!

Modifications:

Changed 2^19 to 2**20 at the start of the program, to calculate the power (4)

Replaced # with $ on the first line so that everything past it is interpreted as JS (1)

On the last line, removed the / and added a */ at the end of the program, so the comment takes up the whole program (3)

Answer 27: MATL, distance 4

27W%2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'

Try it online!

Added 27W%

Explanation:

  W   2 to the power of
27    27
   %  Start of single line comment

Answer 50: Jolf, distance 10

^2@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**49);#0}}//4|
#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Try it here!

Prepended ^2@2( (+5)

Removed ± and ß from #ß6904±r (+2)

Removed ó from óout (+1)

Removed <? from <?#"#28@P2* (+2)

Total: 10. Remove all the non-ASCII characters!

Explanation

( stops parsing, so the code looks like:

^2@2
^      exponentiate
 2     two
  @2   to the 50 (char code of 2)

Answer 52. Befunge-98, distance 8 + 2

Thanks to @DestructibleWatermelon for golfing a byte!

--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024
print(2^51)--;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Try it Online!

Added '3k before the 2, and '2k*. between the 2 and @.

-- does nothing,
'3k2 puts 52 2s onto the stack, and
'2k*.@ multiplies them together, prints the number, and exits

Also, I added a d" after printf("% to make other people's lives easier, as I had 2 extra characters. It doesn't affect the Befunge-98 program.

Answer 42: Cubix, distance 8

2^41 NB.`(expt 2 39); ^ exit @ⁿ.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*

Try it online!

The lert(2**31 in the middle was changed to 44******O@.

Answer 60, Vimscript, distance 10

"bc<<<2^57 #x??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:py print(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Changed the 2 # on the start of the middle two lines to ", added a " in front of the first line, and :py<space> in front of the last line.

For clarification:

" is a line comment in vimscript (at least at the start of a line), and doesn't need to be matched.

Vim can run python code, so this is really equivalent to asking python for the answer.

Answer 8: Perl

#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
print(256);
#0}}//4|
#8Ḥ

Exactly distance of 10: +4 # for comments, +1 newline after System.Console., +3 for transforming write into print, +2 for turning 2 into 256.

I wasn't going to participate, but I wanted to make sure some regular langs were added before anything got too insane.

Try it online!

Answer 49: PHP, distance 6

<?#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**49);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Added <? and ?> to open and close PHP tags, respectively.

Replaced 48 with 49.

# starts a comment on PHP, so nothing is considered except for

<? print(2**49); ?>

Here's a screenshot of proper syntax highlihgting and output to help visualize:

Answer 2: ///

/class HelloWorld {static void Main() {
    System.Console.Write(2);
}}//4

+4 chars - ///4

Try it online!

Answer 7: Minkolang, Distance: 4

327;N.""/class HelloWorld {static void Main() 0{;n***~
    System.Console.Write(2);
0}}//4|
8Ḥ

Try it online!

I added 7;N. to the program. Basically 3, 2 and 7 are pushed to the stack and then 2 is raised to the seventh power using ;. This is then outputted as a Number and then the program stops on the .

Answer 11: Charcoal, distance 5

Ａ#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
1024p#rint(512);
#0}}//4|
β2048

Try It Online!

The uppercase Greek letters Ａ and β are variables which are assigned the ASCII characters following. The final value is implicitly printed.

Answer 10: dc, Distance of 5

#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
1024p#rint(512);
#0}}//4|
#8

Here is a valid dc program which outputs 1024.

Try it online!

Answer 12: Self-modifying Brainfuck

Ａ#327;N<.""/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
1024p#rint(512);
#0}}//4|
#β6904

Try it online!

SMBF is just like brainfuck, except the source code is available on the tape to the left of the starting position. Here we have the number to print in reverse at the end of the code, and we do <. four times to print all four digits.

I added a < before each . in the code (there were 3 of them), an extra <., and modified the final number. Distance should be 8.

Answer 29: Octave, Distance: 1

disp(2^29)%2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'

Try it online!

All I had to do was to change the 28 to 29

Answer 31: JavaScript ES7, Distance 7

alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'

ES7 supports the ** operator for power.

You can try online here.

Answer 33: Mathematica, distance 9

2^33 (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'*)

Explanation

Puts everything inside comments and outputs 2^33

Please verify that this answer is valid before putting your own because I am new at this and don't want to end up breaking the chain.

Answer 37: Actually, distance 7

2:37@ⁿ.óout (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*

Replaced   36?# with :37@ⁿ.ó.

Try it online!

Answer 38: RProgN, distance 10

2 38 ^ exit @ⁿ.óout (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*

Try it online!

Replaced 2:37 with 2 38 ^ exit (10) (note the trailing space)

Explanation:

2            2
     ^       to the power of
  38         38
       exit  Stop the prgram

Answer 47: Perl 6, distance 10

#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**47);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*

Perl 6 is considered distinct from Perl. I tried to set up C down the road by adding "% after printf, hopefully someone uses that.

Try it online!

Answer 48: RProgN2, distance 9

"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**47);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^

Added a " to the start which stopped everything from breaking, the [[[ at the end clears the memory, and 268*^ calculates the new answer. Implicitly printed.

Try it online!

Answer 66, es (shell) + bc, distance 8

#64º,;S)1'a
"bc"<<x
2^66
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
quit()
@n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:
py 
p
riker
i
n
t
(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>

Changed exit to quit(), and added iker after the first r. I couldn't resist and I wanted to add 4 more characters.