Escriba un programa que imprima "¡Hola, mundo!". Pero también, si toma solo los caracteres primero, tercero, quinto, etc. de su programa, el programa resultante aún debería imprimir "¡Hola, Mundo!".

Si su programa es:

abc
def

Debería mostrar "¡Hola, mundo!", Pero también debería

acdf

No hay soluciones con menos de 2 caracteres.

Python 3 , 61 bytes

rant="partisn't"
print(("HHeelllloo,,  WWoorrlldd!!"""[::2]))

Pruébalo en línea!

Abusar del hecho de que printes una función en Python 3 :)

La solución menos partidista que encontrarás aquí en PPCG.

Se convierte

rn=print
rn("Hello, World!"[:])

Cardenal , 29 bytes

%
"
H
e
l
l
o
,
 
W
o
r
l
d
!

Pruébalo en línea!

Al eliminar todos los demás caracteres, se eliminan todos los avances de línea, lo que aún da como resultado Hello, World!:

%"Hello, World!

Pruébalo en línea!

La razón por la que esto funciona es que %crea cuatro punteros de instrucción, que se mueven en cada una de las cuatro direcciones cardinales. Las IP que dejan el código fuente simplemente se eliminan. Entonces, en el primer caso, solo queda la IP hacia el sur y en el segundo caso, solo queda la IP hacia el este, todos los demás simplemente se descartan. En cualquier caso, el programa ejecutado es justo "Hello, World!. Los "conmuta a modo de cadena en la que cada célula está simplemente en la salida estándar. No necesitamos terminar la cadena, porque dejar el código fuente aún termina el programa.

Tenga en cuenta que la misma idea funciona en Beeswax , usando en *lugar de %y en `lugar de "(esto se debe a que Beeswax se inspiró en gran medida en Cardinal pero usa una cuadrícula hexagonal).

Pruébalo en línea! (vertical) | El | Pruébalo en línea! (horizontal)

C, 125 bytes

xpxuxtxs( ) { }xuxs ( ) { } main( ) {puts ( "Hello, World!" ) ; } mxaxixn ( ) {xpxuxtxs ( " H e l l o ,   W o r l d ! " ) ; }

Pruébalo en línea!

Con incluso caracteres eliminados:

xxxx(){}us(){}mi(){us("el,Wrd");}main(){puts("Hello, World!");}

Pruébalo en línea!

En realidad , 2 bytes

HH

Explicación:

H, como es de esperar, empuja Hello, World!a la pila.

El programa principal ( HH) encontrará el primero Hy lo empujará Hello, World!a la pila. En el segundo H, sin embargo, intentará usar dos argumentos (ya que la pila debe estar vacía para empujar Hello, World!) y fallará. Sin embargo, este error será ignorado y luego Hello, World!se imprimirá implícitamente.

El segundo programa ( H) se presionará Hello, World!una vez, y eso se imprimirá implícitamente.

Esto es similar a la respuesta de 2 bytes de Fatalize, pero esto realmente no "engaña".

Pruébalo en línea!

Lua , 89 bytes

--- [ [
print("Hello, World!")
--[[ ] ]
pCrAiLnCtU(L"AHTeOlRlFoE,L IWNoEr:lDd !:"D)
---]]

Pruébalo en línea! Como muestra el resaltado de sintaxis, este es un abuso masivo de comentarios.

Alterno:

--[[pit"el,Wrd"
-[]]print("Hello, World!")--]

Pruébalo en línea!

Y para mayor comodidad, un programa para convertir un programa en cualquier otra forma de personaje: ¡ Pruébelo en línea!

Retina , 39 bytes

HHeelllloo,,  WWoorrlldd!!


(.).x?
$1

Pruébalo en línea!

Tomar cada otro personaje da:

Hello, World!
()x
1

Pruébalo en línea!

El primer programa crea una cadena con el saludo duplicado. Luego reemplaza cada par de caracteres con el primer carácter. También hay una etapa vacía que reemplaza todas las cadenas vacías con cadenas vacías en el medio, pero eso no hace nada. El segundo programa no coincide con la letra "x", por lo que no reemplaza nada después de crear el saludo.

Quizás de manera más divertida, si la tercera etapa se cambia ligeramente, el primer conjunto de caracteres no tiene que ser el mismo mensaje. Esto podría conducir a muchas soluciones de longitud idéntica, como la completa y la mitad .

Carbón de leña , 25 bytes

H→e→l→l→o→,→ →W→o→r→l→d→!

Pruébalo en línea!

Si elimina los caracteres pares, simplemente elimina los comandos de flecha que indican la dirección del siguiente texto, y eso deja el siguiente código:

Hello, World!

Pruébalo en línea!

Eso también imprime el saludo.

Haskell , 85 bytes

{--}main=putStr"Hello, World!"--} m a i n = p u t S t r " H e l l o ,   W o r l d ! "

Pruébalo en línea!

Cada segundo personaje eliminado:

{-mi=uSrHlo ol!-}main=putStr"Hello, World!"

Pruébalo en línea!

Esto explota los dos formatos de comentarios en Haskell: {- -}para comentarios en línea o multilínea y --para comentar el resto de la línea.

Javascript, 67 bytes

/**/alert`Hello, World`// * / a l e r t ` H e l l o ,   W o r l d `

Cada segunda letra eliminada:

/*aetHlo ol`/*/alert`Hello, World`

Al igual que la respuesta de Hasikell de Laikoni, esto explota los comentarios.

Brachylog , 4 bytes

Ḥ~wḤ

Pruébalo en línea!

Explicación

~wescribe su variable derecha en STDOUTe ignora su argumento izquierdo. Ḥes "Hello, World!", así que esto imprime Hello, World!.

Si solo tomamos los caracteres primero y tercero, obtenemos Ḥw. En ese caso wescribe su variable izquierda e ignora su variable derecha, por lo que también imprime Hello, World!.

2 bytes

ḤḤ

Pruébalo en línea!

Esto es técnicamente una respuesta válida, pero unifica la variable de salida del programa en lugar de imprimir STDOUT, por lo que supongo que el programa de 4 bytes está más en el espíritu del desafío.

Haskell, 102 bytes

El programa completo:

main= putStr"Hello, World!";;
putSt   x ="p u t S t r  \" H e l l o ,   W o r l d !\"";
mmaaiin = main

y con cualquier otro personaje eliminado:

mi=ptt"el,Wrd";ptt x=putStr "Hello, World!";main=mi

código de máquina x86, 162 bytes

PROG.COM Descargue y ejecútelo en el emulador de MS-DOS , DOSBox , por ejemplo.

90 B3 B4 B4 02 90 90 B3 B2 B2 48 90 90 B3 CD CD 21 90 90 B3 B2 B2 65 90 
90 B3 CD CD 21 90 90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 2C 90 90 B3 CD CD 21 90 
90 B3 B2 B2 20 90 90 B3 CD CD 21 90 90 B3 B2 B2 77 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 72 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 B2 B2 64 90 90 B3 CD CD 21 90 
90 B3 B2 B2 21 90 90 B3 CD CD 21 90 90 B3 CD CD 20 90

después de la extracción MINI.COM Descargar

90 B4 02 90 B2 48 90 CD 21 90 B2 65 90 CD 21 90 B2 6C 90 CD 21 90 CD 21 
90 B2 6F 90 CD 21 90 B2 2C 90 CD 21 90 B2 20 90 CD 21 90 B2 77 90 CD 21 
90 B2 6F 90 CD 21 90 B2 72 90 CD 21 90 B2 6C 90 CD 21 90 B2 64 90 CD 21 
90 B2 21 90 CD 21 90 CD 20

¿Como correr?

Instale DOSBox, para Ubuntu / Debian

sudo apt install dosbox

Ejecutarlo

dosbox

En DOSBOX

mount c /home/user/path/to/your/directory
c:
PROG.COM
MINI.COM

¿Cómo funciona?

Los códigos de operación de la máquina representan instrucciones en lenguaje ensamblador .

En MS-DOS para imprimir caracteres , establecerá registros y hará interrupciones. El registro AH será 0x02, el registro DL contiene su char. El vector de interrupción es 0x21.

mov ah,0x2  ;AH register to 0x2 (B4 02)
mov dl,0x48 ;DL register to "H" (B2 48)
int 0x21    ;0x21 interrupt     (CD 21)

El pequeño modelo de archivo COM de MS-DOS es una buena elección, porque no tiene encabezados . Está limitado por 64K, pero en nuestro caso no importa.

Para detener el programa, use la interrupción 0x20

int 0x20    ;0x20 interrupt     (CD 20)

magia

Si desea ejecutar el comando 0xAB opcode con un parámetro 0xCD , escriba

AB CD

En PROG.COM

90 B3 AB AB CD 90
nop         ; No operation (90)
mov bl,0xb4 ; BL register to AB (B3 AB)
AB CD command (AB CD)
nop         ; No operation (90)

En MINI.COM

90 AB CD
nop         ; No operation (90)
AB CD command (AB CD)

Es códigos de máquina iguales , si no usa el registro BL .

Generador

Convertir archivo de texto con hexadecimal a binario hexadecimal

cat hex_file | xxd -r -p > exec.com

function byte2hex(byte){
	var ret=byte.toString(16).toUpperCase();
	return ret.length==1 ? "0"+ret : ret;
}

function str2hex(str){
	var ret = [];
	for(var i=0;i<str.length;i++){
		ret.push(byte2hex(str.charCodeAt(i)));
	}
	return ret;
}

function genCode(hexArr){
	var ret = [["B4","02"]];
	for(var i=0;i<hexArr.length;i++){
		if(hexArr[i]!=hexArr[i-1]){
			ret.push(["B2",hexArr[i]]);
		}
		ret.push(["CD","21"]);
	}
	ret.push(["CD","20"]);

	return ret;
}


function magicCode(str){
	var ret=[""];
	var code=genCode(str2hex(str));

	for(var i=0;i<code.length;i++){
		ret.push("90 B3 "+code[i][0]+" "+code[i][0]+" "+code[i][1]+" 90");
		if(i%4==3){ret.push("\n");}
	}
	return ret.join(" ");
}

function magicCodeMinified(str){
	var ret=[""];
	var code=genCode(str2hex(str));

	for(var i=0;i<code.length;i++){
		ret.push("90 "+code[i][0]+" "+code[i][1]);
		if(i%8==7){ret.push("\n");}
	}
	return ret.join(" ");
}

var str=prompt("string","Hello, world!");
var out="PROG.COM\n" + magicCode(str)+"\n\nMINI.COM\n"+magicCodeMinified(str);

document.write(out.replace("\n","<br>"));
alert(out);

Pyth , 31 bytes

p% 2"HHeelllloo,,  WWoorrlldd!!

Pruébalo en línea!

Se convierte

p "Hello, World!

Gracias a @CalculatorFeline por señalar un error y eliminar un byte.

V , 32 bytes

i;H;e;l;l;o;,; ;w;o;r;l;d;!;<esc>;Ó;

Tenga en cuenta que <esc>es un solo carácter, por ejemplo0x1b

Pruébalo en línea!

Eliminar cualquier otro personaje da:

iHello, world!<esc>Ó

Pruébalo en línea!

05AB1E , 29 bytes

”™ ,ï‚‚ï ! ”# ¦2 ä ø¨øJð ý

Pruébalo en línea!

Explicación

”™ ,ï‚‚ï ! ”                # push the string "Weekly Hello , Changed World ! "
               #               # split on spaces
                               # RESULT: ['Weekly','Hello',',','Changed','World','!','']
                ¦              # remove the first element (Weekly)
                 2ä            # split in 2 parts
                               # RESULT: [['Hello', ',', 'Changed'], ['World', '!', '']]
                   ø           # zip
                               # RESULT: [['Hello', 'World'], [',', '!'], ['Changed', '']]
                    ¨          # remove the last element
                     ø         # zip
                               # RESULT: [['Hello', ','], ['World', '!']]
                      J        # join each inner list
                       ðý      # join on space

Después de eliminar cualquier otro personaje, nos queda el código

”Ÿ™,‚ï!” 2äøøðý

Pruébalo en línea!

Explicación

”Ÿ™,‚ï!”       # push the string "Hello, World!"
        2ä     # split in 2 parts
               # RESULT: ['Hello, ', 'World!']
          ø    # zip, as the string has an odd length the space is lost
               # RESULT: ['HW', 'eo', 'lr', 'll', 'od', ',!']
           ø   # zip again
               # RESULT: ['Hello,', 'World!']
            ðý # join on space

Mathematica, 62 bytes

P0r0i0n0t0@0"0H0e0l0l0o0,0 0W0o0r0l0d0!0"Print@"Hello, World!"

Regresa "0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0]e imprime Hello, World!como un efecto secundario. Cuando se ejecuta como un programa (no en REPL), el valor de retorno no se imprimirá.

Después de eliminar cualquier otro personaje:

Print@"Hello, World!"rn@Hlo ol!

Regresa Null ol! rn[Hlo]e imprime Hello, World!.

Jalea , 26 25 bytes

““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »

Pruébalo en línea!

Después de eliminar cada segundo carácter, nos queda el siguiente código.

“3a;»“3ḅaė;œ»

Pruébalo en línea!

Cómo funciona

““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »  Main link.

““3ḅaė;œ»                  Index into Jelly's dictionary to yield
                           ["", "Hello, World!"]. 
          “ 3 ḅ a ė ; œ »  Index into Jelly's dictionary to yield.
                          " FullERebitingBEfluffiest adoptable".
         ḷ                 Take the left result.

“3a;»“3ḅaė;œ»  Main link.

“3a;»          Index into Jelly's dicrionary to yield " N-".
               Set the argument and the return value to the result.
     “3ḅaė;œ»  Index into Jelly's dicrionary to yield "Hello, World!".
               Set the return value to the result.

Cubic v2.1 , 222 bytes

+0503 @@6 :22 //1 +050501 @@6 :55 +0502 @@6@6 :33 //1 +050502 @@6 :55 +03 //1 +04 @@6 :55 //1 +03 @@6 :55 +01 //1 +0504 @@6 :33 //1 +050502 @@6 :55 +01 //1 +050502 @@6 :55 +0502 @@6 :11 //1 +050501 @@6 :55 +01 //1 +03 @@6

Pruébalo en línea!

Cada otra carta:

+53@6:2/1+551@6:5+52@66:3/1+552@6:5+3/1+4@6:5/1+3@6:5+1/1+54@6:3/1+552@6:5+1/1+552@6:5+52@6:1/1+551@6:5+1/1+3@6

Pruébalo en línea!

CJam , 32 bytes

"HHeelllloo,,  WWoorrlldd!! "2 %

Pruébalo en línea!

Tomar cada otro personaje da:

"Hello, World!" 

Pruébalo en línea!

Ayuda, WarDoq! , 2 bytes

Hi

Pruébalo en línea!

Himpresiones Hello, World!, ies un no-op.

_{Ayuda, WarDoq! puede agregar dos números y probar primos, por lo que se considera un lenguaje de programación válido según esta meta publicación .}

/// , 25 bytes

H\e\l\l\o\,\ \W\o\r\l\d\!

Pruébalo en línea!

Con cada otro personaje eliminado:

Hello, World!

PHP, 53 bytes

#
echo date(
$e_c_h_o='\H\e\l\l\o\,\ \W\o\r\l\d\!
');

Con cada otro personaje eliminado:

#eh ae
echo'Hello, World!';

Octava, 49 45 bytes

Guardado 4 bytes ya que Octave no requiere corchetes para indexar.

'HHeelllloo,,  WWoorrlldd!! ' (1:2 : 3 ^ 3)''

Pruébalo en línea!

Y el reducido:

'Hello, World!'(:    )'

Pruébalo en línea!

Explicación:

El código inicial tiene las letras en la cadena duplicadas, de modo que nos quedamos Hello, World!cuando se elimina cada segundo. Se agregan algunos espacios para garantizar que se mantengan los corchetes y los apóstrofes.

La indexación es realmente 1:2:end. Hay 27 caracteres, y no podemos utilizar endo 27ya que debemos eliminar un carácter, por lo que van con 3 ^ 3su lugar. Cuando eliminamos cada tercer carácter, la indexación se convierte (:)(y algunos espacios adicionales).

(:)significa "aplanar y convertir en un vector vertical" . Entonces, necesitamos transponerlo, usando '. No necesitamos transponer la cadena en el código original, pero la doble transposición funciona, por lo que la primera cadena se transpone dos veces usando '', y la segunda se transpone solo una vez.

APL (Dyalog) , 35 34 bytes

-1 gracias a Martin Ender.

'0H0e0l0l0o0,0 0W0o0r0l0d0!0'~ ⍕ 0

Pruébalo en línea!

'0H0e0l0l0o0,0 0W0o0r0l0d0!0' el mensaje con ceros como caracteres de relleno extraíbles

~ excepto

⍕ formateado (stringified)

0 Número cero

Dejando solo los caracteres impares, esto se convierte 'Hello, World!' .

T-SQL, 75 bytes

---
PRINT 'Hello, World!'
/*
-P-R-I-N-T-'-H-e-l-l-o-,- -W-o-r-l-d-!-'
---*/

Abuso de comentarios de una o varias líneas, inspirado en la versión LUA de CalculatorFeline .

Después de eliminar todos los caracteres pares, algunos de los cuales son saltos de línea:

--PIT'el,Wrd'/
PRINT'Hello, World!'--/

Javascript, 73 bytes

a ='a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/';eval(a.replace(/0/g,''))

Construye una cadena acon el contenido a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/, luego elimina todo lo que se 0debe dar alert`Hello, World!`//, que es eval'd.

Tomar cada otro personaje del programa da

a=alert`Hello, World!`//;vlarpae//,')

que alerta Hello, Worldusando la sintaxis de cadena de plantilla de la misma manera que lo que se evaluó en el programa completo, luego almacena el resultado de la llamada ae incluye el comentario perspicaz //;vlarpae//,').

> <> , 47 bytes

Original:

| v~" H e l l o ,   W o r l d ! "

~o<< ;!!!? l

Con cada segundo personaje eliminado:

|v"Hello, World!"
o<;!?l

Pruébelos en línea: original , modificado

El programa original empuja a los personajes de "¡Hola, mundo!" a la pila (en orden inverso) intercalados con espacios, luego imprime alternativamente un carácter y elimina uno hasta que la longitud de la pila es cero. El segundo programa hace lo mismo, excepto que las instrucciones de eliminación ~se han ido.

Si no le importa detenerse con un error, podemos sacar una hoja del libro Cardinal de Martin Ender : el código modificado es

\"!dlroW ,olleH"!#o#

y el original es el mismo pero con líneas nuevas insertadas entre todos los caracteres, para 39 bytes. Pruébelos en línea: original , modificado .

,,, 34 bytes

 2"Hteoltlaol,l yWhourmladn!! "⟛

Al eliminar los caracteres pares ...

 "Hello, World!"

Explicación

Con todos los personajes:

 2"..."⟛

               no-op
 2             push 2 to the stack
  "..."        push "Hteoltlaol,l yWhourmladn!! " to the stack
       ⟛      pop 2 and the string and push every 2nd character of the string
               implicit output

Sin los caracteres pares:

 "..."

               no-op
 "..."         push "Hello, World!" to the stack
               implicit output

Brainfuck, 155 bytes

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

Pruébalo en línea!

Cada segundo personaje eliminado:

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

Jalea , 32 bytes

 2“HHeelllloo,,  WWoorrlldd!! ”m

Pruébalo en línea!

-2 bytes gracias a la respuesta de @ totallyhuman

Ahora el mío es un tonto>. <

Vota ese también: D