Como parte da parte 2 do Hello, World! (Todos os outros caracteres) , escreva um programa para que todos esses três programas imprimam "Olá, Mundo!": O programa inteiro, o 1º, o 3º, o 5º, etc. caracteres do seu programa e os 2º, 4º, 6º, etc.

Se o seu programa é:

abc
def

Ele deve exibir "Olá, mundo!", Mas também deve

acdf

E

b
e

Nenhuma solução com o "Olá, mundo!" Incorporado.

código de máquina x86, 378 bytes

PROG.COM Baixe e execute-o no emulador do MS-DOS , DOSBox , por exemplo.

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

Além disso, você pode baixar o LEFT.COM e o RIGHT.COM

Como funciona e como executar

Veja a resposta da parte um

Magia

Se você deseja executar o comando 0xAB opcode com um parâmetro 0xCD , você escreve

Gerador

Executar código, obter hexadecimal. Converter em binário

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

Todo personagem estranho

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

Todo personagem par

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

Experimente online!

Provavelmente isso poderia ficar muito mais curto, mas estou feliz por conseguir fazê-lo funcionar em Python. Semelhante à resposta de vroomfondel na primeira parte.

Resposta chata de 93 bytes

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

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

Todo personagem estranho

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

Todo personagem par

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

Experimente online!

> <> , 45 bytes

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

Ou apenas caracteres:

 "!dlroW olleH"!">o<  

Ou apenas caracteres estranhos:

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

Experimente-os online: originais , pares , probabilidades .

A versão original empurra " !!ddllrrooWW oolllleeHH" para a pilha e o peixe salta entre >~o <, o que exclui uma letra, imprime duas, exclui duas, imprime duas, exclui duas, etc. Os dois semi-programas são programas de impressão de seqüência bastante padrão. A parte complicada foi combinar "e !ativar e desativar o modo de string nos três programas corretamente.

Befunge-98 , 43 bytes

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

Experimente online!

Apenas os estranhos:

10x"!dlroW ,olleH"ck,@

Experimente online!

Somente os pares:

2 "!dlroW ,olleH"ck,@

Experimente online!

Explicação

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

No programa ímpar, ele 2desapareceu, de modo que 10xrealmente não faz nada (ele define o delta como (1,0)o padrão de qualquer maneira). O restante do programa é o mesmo.

No programa par, apenas pressionamos 2o princípio que podemos ignorar completamente. O restante do programa é o mesmo de antes.

Gammaplex , 46 bytes

//

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

Veja aqui.

Intérprete. Pode ser necessário fazer algumas alterações para funcionar em compiladores modernos.

Mathematica, 65 bytes

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

Emite alguns avisos, impressões Hello, World!e devoluções Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Quando executado como um programa (não no REPL), o valor de retorno não será impresso.

Depois de remover os caracteres pares:

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

Imprime Hello, World!e retorna "el,Wrd" Null Pit.

Depois de remover os caracteres ímpares:

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

Imprime Hello, World!e retorna Null ol! rn[Hlo].

código de máquina x86, 73 bytes

Inspirado pela solução de Евгений Новиков , achei que deveria ser possível com menos truques, ou seja, apenas pulando para códigos "disjuntos" para as três variantes. Ainda estou tentando com uma variante inteligente que use lodsb; lodsbcomo ponto central (portanto, apenas uma constante de cadeia é necessária para todas as 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

Se bem me lembro dos dias da minha infância, o pequeno modelo do COM começa DS=CS=SSe o código é carregado a partir de CS:0100h. Não presumo que seja garantido que o código seja carregado em um bloco de memória zerado (se fosse garantido, eu poderia eliminar dois bytes).

A desmontagem do código longo deve 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"

Desmontagem do código ímpar

  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"

Desmontagem do 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

Experimente online!

Posições ímpares:

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

Experimente online!

Posições pares:

 `
Hello, World!$&
.\t
1

Experimente online!

Explicação

O programa completo:

G |`

Isso não faz nada. A |opção não é uma configuração existente. O Gtorna esta uma fase grep, mas não há realmente nada a ser grepped ea regex é esvaziar qualquer, então isso não faz nada. O objetivo desse estágio é ter dois feeds de linha na frente do "Olá, mundo!" linha para que um deles sempre sobreviva à redução. A razão para fazer disso um grep stag é que precisamos compensar a paridade das linhas, e os estágios grep requerem apenas uma única linha.

HHeelllloo,,  WWoorrlldd!!

Isso transforma a sequência de trabalho (vazia) na saída necessária, com cada caractere dobrado.

$_&

Isso não faz nada. As tentativas de regex para corresponder a um _e um &após o final da cadeia que é obviamente impossível. No entanto, precisaremos desses caracteres na versão reduzida, novamente para lidar com os desaparecimentos de linha.

(.)\1t?
$1

Finalmente, removemos os caracteres duplicados substituindo (.)\1por $1. O t?nunca é usado, mas será novamente necessário nas versões reduzidas.

O programa ímpar:

G|
Hello, World!

O Gnão pode corresponder à entrada vazia, mas é por isso que temos |que permitir uma correspondência vazia alternativa. Isso transforma a cadeia de trabalho vazia na saída desejada.

_
()1?$

Isso substitui os sublinhados por ()1?$, mas não há sublinhados na sequência, portanto, isso não faz nada.

O programa par:

 `
Hello, World!$&

O `just denota uma string de configuração vazia, então usamos novamente o regex vazio para substituir a string de trabalho pela saída. Desta vez, também inserimos, $&mas essa é a correspondência em si, que está vazia, é claro, para que não faça nada.

.\t
1

Isso substituiria qualquer caractere seguido por uma guia por a 1, mas não temos nenhuma guia , portanto, isso também é um não-op.

Lua , 106 bytes

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

Experimente online!

Alternativa 1:

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

Experimente online!

Alternativa 2:

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

Experimente online!

Script do alternador: Experimente online!

CJam , 44 bytes

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

Experimente online!

PHP, 70 bytes

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

Caracteres ímpares:

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

Caracteres pares:

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

Haskell , 92 bytes

{---- }

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

Experimente online! Parece que o abuso de comentários é exagerado para o realce da sintaxe. {- ... -}é um comentário embutido ou de várias linhas, enquanto --inicia um comentário de linha.

Caracteres ímpares:

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

Experimente online!

Caracteres pares:

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

Experimente online!

Zsh , 54 bytes

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

Experimente online!

O programa principal executa a primeira instrução com sucesso, portanto, a instrução após o booleano ||é ignorada.

Para ímpar / par, <<<Hello\ world!torna-se um não terminado <<heredocou um <filefornecido no stdin. De qualquer forma, o ||torna - se |, e, portanto, o que for gerado pelo primeiro comando é canalizado e ignorado echo.

LOGO , 71 bytes

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

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

(o programa tem uma nova linha à direita)

Duas versões removidas:

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

e

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

(o programa tem uma nova linha à direita)

Para uma explicação sobre o que pre erfazer, consulte este post . Nesse caso, eré alimentado com uma palavra para determinar o nome do procedimento.

O \caractere de escape é no Logo, que escapará da nova linha após o final do comentário, portanto faça da segunda linha ( rHlo ol!e |) do segundo programa removido um comentário.

Javascript, 68 bytes

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

Personagens Estranhos:

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

Personagens pares:

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

Versão modificada da minha resposta na outra.

Perl 5 , 61 bytes

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

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

Experimente online!

Every Byte Estranho

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

Experimente online!

Every Even Byte

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

Experimente online!

BotEngine , 180 178 bytes

Com base na minha resposta a esta pergunta.

 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 ímpares (observe os vários espaços à direita na última linha):

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

Caracteres 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  

Encantos Rúnicos , 52 bytes

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

Experimente online!

Rúnico geralmente não é muito bom em lidar com radiação, pois remover caracteres de controle de fluxo aleatoriamente torna a execução do rastreamento uma dor enorme, mas radiação previsível como todos os outros caracteres? Fácil, apenas codificamos dois programas que são revertidos e intercalados e, em seguida, aderimos a uma terceira cópia para a execução e controle da base, que é executado com um único caractere. No programa 2, a terceira cópia é lixo que nunca é visto e, no programa 3, retém as aspas, permitindo que seja estourada sem imprimi-la.

O programa 1 executa apenas esta parte:

 L                                  @"!dlroW ,olleH"

O programa 2 executa apenas esta parte:

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

Como isso:

  "Hello, World!" @!lo olH

Experimente online!

O programa 3 executa apenas esta parte:

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

Como isso:

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

Experimente online!

A "drW,le"parte é executada, mas a ~sai imediatamente da pilha, preservando a saída desejada.

Ingenuamente, parece que uma conversão da resposta> <> resultaria em um programa mais curto, pesando 45 bytes:

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

No entanto, o Runic tem uma limitação que> <> não possui: um tamanho máximo de pilha de 10 + mana de IP (que é inicialmente 10). E !!ddllrrooWW oolllleeHHcontém 24 caracteres, fazendo com que o IP esvazie a mana até expirar pouco antes de executar o Rcomando, resultando em nenhuma saída para o programa base.

Experimente online!