Como una especie de parte 2 para Hello, World! (Todos los demás caracteres) , escriba un programa de manera que los tres programas impriman "¡Hola, mundo!": El programa completo, los caracteres primero, tercero, quinto, etc. de su programa, y el segundo, cuarto, sexto, etc.

Si su programa es:

abc
def

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

acdf

Y

b
e

No hay soluciones con "Hola, mundo" incorporado.

código de máquina x86, 378 bytes

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

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

También puede descargar LEFT.COM y RIGHT.COM

Cómo funciona y cómo correr

Ver respuesta a la primera parte

magia

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

Generador

Ejecute el código, obtenga hexadecimal. Convertir a binario

cat prog.hex | xxd -r -p > PROG.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 format(arr){
	var ret=[],tmp=[];
	for(var i=0;i<arr.length;i++){
		tmp.push(arr[i]);
		if(i%16==15 || i==arr.length-1){ret.push(tmp.join(" "));tmp=[];}
	}
	return ret.join("\n");
}

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

	for(var i=0;i<code.length;i++){
		var ab=code[i][0],cd=code[i][1],tmp;
		tmp=["B3",ab,"B3",cd,"90","B3","B3",ab,cd,"B3",ab,"B3",cd,"90"];
		for(var j=0;j<tmp.length;j++){
			if((mode&1 && j%2==0) || (mode&2 && j%2==1)){ret.push(tmp[j])}
		}
		
	}
	return ret;
}

const LEFT=1,RIGHT=2,ALL=3;

var str=prompt("string","Hello, world!");

var out = ["PROG.COM\n",format(magicCode(str,ALL)),"\n\nLEFT.COM\n",format(magicCode(str,LEFT)),"\n\nRIGHT.COM\n",format(magicCode(str,RIGHT))].join("\n");

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

Python 3 , 115 bytes

print=="partisn't";
"ran" >="partisn't" ;
print((""" "HHeelllloo,,  wwoorrlldd!! """[" ) #2">"1":: 3- 1] [ 1:-1 ]))

Cada personaje extraño

pit=print;"a">"ats'";pit(" Hello, world! "[  2>1: -1  :1])

Cada personaje par

rn="ats'"
rn =print 
rn("""Hello, world!""")#""":3 ][1- )

Pruébalo en línea!

Esto probablemente podría ser mucho más corto, pero estoy feliz de que logré que funcione en Python. Similar a la respuesta de vroomfondel en la primera parte.

Aburrido respuesta de 93 bytes

""""""
print("Hello, world!")
""""""#
""""

pprriinntt((""HHeelllloo,,  wwoorrlldd!!""))
#"""

Cada personaje extraño

"""pit"el,wrd"
"""
""
print("Hello, world!")#"

Cada personaje par

"""
rn(Hlo ol!)"""#""
print("Hello, world!")
""

Pruébalo en línea!

> <> , 45 bytes

! """!!ddllrrooWW  oolllleeHH"!!"" >~o <> o <

O simplemente personajes:

 "!dlroW olleH"!">o<  

O simplemente caracteres extraños:

!""!dlroW olleH!" ~ >o<

Pruébelos en línea: originales , pares , probabilidades .

La versión original empuja " !!ddllrrooWW oolllleeHH" a la pila, luego el pez rebota entre ellos >~o <, lo que elimina una letra, imprime dos, elimina dos, imprime dos, elimina dos, etc. Los dos medios programas son programas de impresión de cadenas bastante estándar. La parte difícil era combinar "y !activar y desactivar el modo de cadena en los tres programas correctamente.

Befunge-98 , 43 bytes

120 x""!!ddllrrooWW  ,,oolllleeHH""cckk,,@@

Pruébalo en línea!

Solo los impares:

10x"!dlroW ,olleH"ck,@

Pruébalo en línea!

Solo los pares:

2 "!dlroW ,olleH"ck,@

Pruébalo en línea!

Explicación

El programa completo:

120               Push 1, push 2, push 0.
x                 Pop 0 (y) and 2 (x) and set the instruction pointer's movement
                  delta to (x,y). That is, run the remainder of the code
                  by skipping every other cell.
"!dlroW ,olleH"   Push the code points of the output.
ck,               Print 13 characters from the top of the stack.
@                 Terminate the program.

En el programa impar, 2se ha ido, por lo que 10xrealmente no hace nada en absoluto (de todos (1,0)modos establece el delta que es el predeterminado). El resto del programa es el mismo.

En el programa par, simplemente presionamos 2el principio que podemos ignorar por completo. El resto del programa es el mismo que antes.

Gammaplex , 46 bytes

//

EERRrrXXXX""HHeelllloo,,  WWoorrlldd!!""XX

Mira aquí.

Interprete. Es posible que necesite algunos cambios para funcionar en compiladores modernos.

Mathematica, 65 bytes

PPrriinntt[[""HHeelllloo,,  WWoorrlldd!!""]]Print@"Hello, World!"

Lanza algunas advertencias, impresiones Hello, World!y devoluciones Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Cuando se ejecuta como un programa (no en REPL), el valor de retorno no se imprimirá.

Después de eliminar los caracteres pares:

Print["Hello, World!"]Pit"el,Wrd"

Imprime Hello, World!y vuelve "el,Wrd" Null Pit.

Después de eliminar los caracteres impares:

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

Imprime Hello, World!y vuelve Null ol! rn[Hlo].

código de máquina x86, 73 bytes

Inspirado por la solución de Евгений Новиков , pensé que debería ser posible con menos trucos, es decir, simplemente saltar a los códigos "disjuntos" para las tres variantes. Todavía estoy intentando con una variante inteligente que se usa lodsb; lodsbcomo punto central (por lo que solo se necesita una constante de cadena para todas las variantes)

EB 14 00 00 8A 8A 17 16 01 01 B4 B4 09 09 CD CD
21 21 CD CD 20 20 8A 1f 01 B4 09 CD 21 CD 20 48
65 6c 6c 6f 2c 20 57 6f 72 6c 64 21 00 48 48 65
65 6c 6c 6c 6c 6f 6f 2c 2c 20 20 57 57 6f 6f 72
72 6c 6c 64 64 21 21 00 00

Si recuerdo correctamente de mis días de infancia, el pequeño modelo de COM comienza con DS=CS=SSy el código se carga a partir de CS:0100h. No asumo que está garantizado que el código se carga en un bloque de memoria a cero (si estuviera garantizado, podría soltar dos bytes).

El desmontaje del código largo debe ser

  JMP *+14h
  ; 20 irrelevant bytes
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
message:
  DB "Hello, World!\0"
  DB "HHeelllloo,,  WWoorrlldd!!\0\0"

Desmontaje de código impar

  JMP *+00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

Desmontaje de código par:

  ADC AL,00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

Retina , 48 bytes

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

Pruébalo en línea!

Posiciones impares:

G|
Hello, World!
_
()1?$

Pruébalo en línea!

Posiciones pares:

 `
Hello, World!$&
.\t
1

Pruébalo en línea!

Explicación

El programa completo:

G |`

Esto no hace nada en absoluto. La |no es una opción de configuración existente. Esto lo Gconvierte en una etapa de grep, pero realmente no hay nada que ser grepé y la expresión regular está vacía, por lo que esto no hace nada. El propósito de esta etapa es tener dos avances de línea frente al principal "¡Hola, mundo!" línea para que uno de ellos siempre sobreviva a la reducción. La razón para convertir esto en un ciervo grep es que necesitamos compensar la paridad de las líneas, y las etapas grep solo requieren una sola línea.

HHeelllloo,,  WWoorrlldd!!

Esto convierte la cadena de trabajo (vacía) en la salida requerida con cada carácter duplicado.

$_&

Esto no hace nada. Los intentos de expresiones regulares para que coincida con una _y &después del final de la cadena, que es, por supuesto, imposible. Sin embargo, necesitaremos esos caracteres en la versión reducida, nuevamente para lidiar con los avances de línea que desaparecen.

(.)\1t?
$1

Finalmente, eliminamos los caracteres duplicados reemplazándolos (.)\1con $1. El t?nunca se usa pero será necesario nuevamente en las versiones reducidas.

El programa extraño:

G|
Hello, World!

No Gpuede coincidir con la entrada vacía, pero es por eso que tenemos |que permitir una coincidencia vacía alternativa. Esto convierte la cadena de trabajo vacía en la salida deseada.

_
()1?$

Esto reemplaza los guiones bajos con ()1?$, pero no hay guiones bajos en la cadena, por lo que no hace nada.

El programa par:

 `
Hello, World!$&

El `solo denota una cadena de configuración vacía, por lo que nuevamente usamos la expresión regular vacía para reemplazar la cadena de trabajo con la salida. Esta vez también insertamos, $&pero esa es la coincidencia en sí, que está vacía, por supuesto, por lo que no hace nada.

.\t
1

Esto reemplazaría cualquier carácter seguido de una pestaña con un 1, pero no tenemos pestañas, por lo que esto también es un no-op.

Lua , 106 bytes

----[[[[
print("Hello, World!")
--[[
---- ] ]
---- ] ]
pprriinntt((""HHeelllloo,,  WWoorrlldd!!""))
----]]

Pruébalo en línea!

Alternativa 1:

--[[
rn(Hlo ol!)-[
--]]--  
print("Hello, World!")--]

Pruébalo en línea!

Alternativa # 2:

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

Pruébalo en línea!

Script del alternador: ¡ Pruébelo en línea!

CJam , 44 bytes

{{HHeelllloo,,  WWoorrlldd!!}}ss{{}}ss-X)%L-

Pruébalo en línea!

PHP, 70 bytes

"";echo'Hello, World!'.""//pprriinntt''HHeelllloo,,  WWoorrlldd!!''
;;

Caracteres impares:

";coHlo ol!."/print'Hello, World!';

Personajes pares:

"eh'el,Wrd'"/print'Hello, World!'
;

Haskell , 92 bytes

{---- }

mmaaiinn==ppuuttSSttrr""HHeelllloo,,  WWoorrlldd!!""----}main=putStr"Hello, World!"

Pruébalo en línea! Parece que el abuso de comentarios es demasiado para el manejo de resaltado de sintaxis. {- ... -}es un comentario en línea o de varias líneas, mientras que --comienza un comentario en línea.

Caracteres impares:

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

Pruébalo en línea!

Personajes pares:

-- 
main=putStr"Hello, World!"--}anptt"el,Wrd"

Pruébalo en línea!

Zsh , 54 bytes

<<<Hello\ world!||eecchhoo  HHeelllloo\\  wwoorrlldd!!

Pruébalo en línea!

El programa principal ejecuta la primera declaración con éxito, por lo que ||se ignora la declaración después del booleano .

Para impar / par, se <<<Hello\ world!convierte en un stdin no terminado <<heredoco <fileprovisto. De cualquier manera, se ||convierte en |, y así lo que sea que salga por el primer comando es canalizado e ignorado por echo.

LOGOTIPO , 71 bytes

;;\\
pr[Hello, World!]er "|

pprr[[HHeelllloo,,  WWoorrlldd!!]]
;;\\
|

(el programa tiene una nueva línea final)

Dos versiones eliminadas:

;\p[el,Wrd]r"
pr[Hello, World!]
;\|

y

;\
rHlo ol!e |
pr[Hello, World!];\

(el programa tiene una nueva línea final)

Para una explicación de qué pry erhacer, vea esta publicación . En este caso, erse alimenta con una palabra para determinar el nombre del procedimiento.

El \carácter de escape es en Logo, que escapará de la nueva línea después del final del comentario, por lo tanto, haga que la segunda línea ( rHlo ol!e |) del segundo programa eliminado sea un comentario.

Javascript, 68 bytes

//**
alert`Hello, World`//**//aalleerrtt``HHeelllloo,,  WWoorrlldd``

Caracteres impares:

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

Personajes pares:

/*
lr`el,Wrd/*/alert`Hello, World`

Versión modificada de mi respuesta en la otra.

Perl 5 , 61 bytes

Código de 60 bytes + 1 para -p.

$ _ =$ _ =q";HHeelllloo,,  WWoorrlldd!!";;;q##;s/;|.\K.//g##

Pruébalo en línea!

Cada byte impar

  $_="Hello, World!";q#s;.K/g#

Pruébalo en línea!

Cada byte par

$_=  q;Hello, World!;;#;/|\./#

Pruébalo en línea!

BotEngine , 180 178 bytes

Basado en mi respuesta a esta pregunta.

 vv 
 v < 
 eHH 
 eee 
 ell 
 ell 
 eoo 
 e,, 
 e   
 eWW 
 eoo 
 err 
 ell 
 edd 
 e!! 

>>P          e     e     e     e     e     e     e     e     e     e     e     e     e P

Caracteres impares (tenga en cuenta los múltiples espacios finales en la última línea):

 v
v<
eH
ee
el
el
eo
e,
e 
eW
eo
er
el
ed
e!
>P                                          

Personajes pares:

v     H  e  l  l  o  ,     W  o  r  l  d  ! 
>     e  e  e  e  e  e  e  e  e  e  e  e  eP  

Encantamientos rúnicos , 52 bytes

 L @""H!edlllroo,W  W,oorlllde!H"" ~@"!dlroW ,olleH"

Pruébalo en línea!

Runic generalmente no es muy bueno para lidiar con la radiación, ya que eliminar los caracteres de control de flujo al azar hace que la ejecución del rastreo sea un gran dolor, pero ¿radiación predecible como cualquier otro personaje? Fácil, simplemente codificamos dos programas que se invierten entre sí y se intercalan, luego agregamos una tercera copia para la ejecución base y controlamos cuál se ejecuta con un solo carácter. En el programa 2, la tercera copia es basura que nunca se ha visto, y en el programa 3 conserva las comillas, lo que permite que aparezca sin imprimirla.

El programa 1 solo ejecuta esta parte:

 L                                  @"!dlroW ,olleH"

El programa 2 solo ejecuta esta parte:

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

Me gusta esto:

  "Hello, World!" @!lo olH

Pruébalo en línea!

El programa 3 solo ejecuta esta parte:

 L @ " ! d l r o W   , o l l e H " ~ " d r W , l e "

Me gusta esto:

L@"!dlroW ,olleH"~"drW,le"

Pruébalo en línea!

La "drW,le"porción se ejecuta, pero ~inmediatamente la saca de la pila, conservando la salida deseada.

Ingenuamente parecería que una conversión de la respuesta> <> resultaría en un programa más corto, con un peso de 45 bytes:

! ```!!ddllrrooWW  oolllleeHH`!!`` R~$ LR $ L

Sin embargo, Runic tiene una limitación que> <> no tiene: un tamaño de pila máximo de 10 + maná de IP (que inicialmente es 10). Y !!ddllrrooWW oolllleeHHcontiene 24 caracteres, lo que hace que la IP sangre maná hasta que caduque justo antes de ejecutar el Rcomando, lo que no genera salida para el programa base.

Pruébalo en línea!