Come una specie di parte 2 di Hello, World! (Ogni altro personaggio) , scrivi un programma tale tutti e tre questi programmi stampino "Hello, World!": L'intero programma, il 1o, 3o, 5o, ecc. Caratteri del tuo programma e il 2o, 4o, 6o, eccetera.

Se il tuo programma è:

abc
def

Dovrebbe essere visualizzato "Hello, World!", Ma così dovrebbe essere

acdf

E

b
e

Nessuna soluzione con "Hello, World!" Incorporato.

codice macchina x86, 378 byte

PROG.COM Scarica ed eseguilo nell'emulatore MS-DOS , ad esempio DOSBox .

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

Inoltre è possibile scaricare LEFT.COM e RIGHT.COM

Come funziona e come eseguire

Vedi la risposta alla prima parte

Magia

Se si desidera eseguire il comando 0xAB opcode con un parametro 0xCD , si scrive

Generatore

Esegui il codice, ottieni esadecimale. Converti in 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 byte

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

Ogni personaggio strano

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

Ogni personaggio pari

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

Provalo online!

Questo potrebbe probabilmente essere molto più breve, ma sono felice di essere riuscito a farlo funzionare in Python. Simile alla risposta di vroomfondel nella prima parte.

Risposta noiosa a 93 byte

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

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

Ogni personaggio strano

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

Ogni personaggio pari

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

Provalo online!

> <> , 45 byte

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

O anche solo personaggi:

 "!dlroW olleH"!">o<  

O solo personaggi strani:

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

Prova on-line: originali , livella , probabilità .

La versione originale spinge " !!ddllrrooWW oolllleeHH" nella pila, quindi il pesce rimbalza tra di loro >~o <, eliminando una lettera, stampandone due, eliminandone due, stampandone due, eliminandone due, ecc. I due semiprocessi sono programmi di stampa di stringhe abbastanza standard. La parte difficile era combinare "e !attivare e disattivare correttamente la modalità stringa in tutti e tre i programmi.

Befunge-98 , 43 byte

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

Provalo online!

Solo quelli dispari:

10x"!dlroW ,olleH"ck,@

Provalo online!

Solo quelli pari:

2 "!dlroW ,olleH"ck,@

Provalo online!

Spiegazione

Il programma 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.

Nel programma dispari, 2è sparito, quindi 10xnon fa assolutamente nulla (imposta comunque il delta su (1,0)cui è predefinito). Il resto del programma è quindi lo stesso.

Nel programma pari, spingiamo 2all'inizio all'inizio, che possiamo ignorare del tutto. Il resto del programma è lo stesso di prima.

Gammaplex , 46 byte

//

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

Vedere qui.

Interprete. Potrebbe essere necessario apportare alcune modifiche per funzionare nei compilatori moderni.

Mathematica, 65 byte

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

Genera alcuni avvisi, stampe Hello, World!e ritorni Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Quando eseguito come programma (non nel REPL), il valore restituito non verrà stampato.

Dopo aver rimosso i caratteri pari:

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

Stampa Hello, World!e ritorna"el,Wrd" Null Pit.

Dopo aver rimosso i caratteri dispari:

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

Stampa Hello, World!e ritorna Null ol! rn[Hlo].

codice macchina x86, 73 byte

Ispirato dalla soluzione di Евгений Новиков , ho pensato che potesse essere fattibile con meno trucchi, vale a dire, saltando semplicemente su codici altrimenti "disgiunti" per tutte e tre le varianti. Sto ancora provando con una variante intelligente che utilizza lodsb; lodsbcome punto centrale (quindi è necessaria una sola costante di stringa per tutte le varianti)

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 ricordo bene dai miei giorni d'infanzia, il piccolo modello di COM inizia con DS=CS=SSe il codice viene caricato a partire daCS:0100h . Non presumo sia garantito che il codice sia caricato in un blocco di memoria azzerato (se fosse garantito, potrei perdere due byte).

Lo smontaggio del codice lungo dovrebbe essere

  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"

Smontaggio del codice dispari

  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"

Smontaggio del codice pari:

  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 byte

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

Provalo online!

Posizioni dispari:

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

Provalo online!

Posizioni pari:

 `
Hello, World!$&
.\t
1

Provalo online!

Spiegazione

Il programma completo:

G |`

Questo non fa assolutamente nulla. Non |è un'opzione di configurazione esistente. Questo lo Grende un palcoscenico grep, ma non c'è davvero nulla da fare e il regex è vuoto, quindi questo non fa nulla. Lo scopo di questa fase è di avere due avanzamenti di riga davanti al principale "Ciao, mondo!" linea in modo che uno di loro sopravviva sempre alla riduzione. La ragione per rendere questo un cervo grep è che dobbiamo compensare la parità delle linee, e le fasi grep richiedono solo una singola linea.

HHeelllloo,,  WWoorrlldd!!

Questo trasforma la stringa di lavoro (vuota) nell'output richiesto con ogni carattere raddoppiato.

$_&

Questo non fa niente. Il regex cerca di abbinare a _e a &dopo la fine della stringa, il che è ovviamente impossibile. Tuttavia, avremo bisogno di quei personaggi nella versione ridotta, ancora una volta per far fronte alle alimentazioni di linea che svaniscono.

(.)\1t?
$1

Infine, rimuoviamo i caratteri duplicati sostituendoli (.)\1con $1. Ilt? viene mai utilizzato, ma sarà nuovamente necessario nelle versioni ridotte.

Il programma dispari:

G|
Hello, World!

Non Gpuò corrispondere all'input vuoto, ma è per questo che dobbiamo |consentire una corrispondenza vuota alternativa. Ciò trasforma la stringa di lavoro vuota nell'output desiderato.

_
()1?$

Questo sostituisce i trattini bassi con ()1?$ , ma non ci sono trattini bassi nella stringa, quindi non fa nulla.

Il programma pari:

 `
Hello, World!$&

Il `solo denota una stringa di configurazione vuoto, quindi usiamo di nuovo la regex vuota per sostituire la stringa di lavoro con l'uscita. Questa volta inseriamo anche, $&ma questa è la corrispondenza stessa, che è vuota, ovviamente, quindi non fa nulla.

.\t
1

Ciò sostituirà qualsiasi carattere seguito da una scheda con un 1, ma non abbiamo alcuna scheda , quindi anche questa è una no-op.

Lua , 106 byte

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

Provalo online!

Alternativo 1:

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

Provalo online!

Alternativo n. 2:

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

Provalo online!

Script dell'alternatore: provalo online!

CJam , 44 byte

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

Provalo online!

PHP, 70 byte

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

Personaggi strani:

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

Personaggi pari:

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

Haskell , 92 byte

{---- }

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

Provalo online! Sembra che l'abuso dei commenti sia troppo difficile da gestire per l'evidenziazione della sintassi. {- ... -}è un commento in linea o multilinea, mentre-- inizia un commento di linea.

Personaggi strani:

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

Provalo online!

Personaggi pari:

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

Provalo online!

Zsh , 54 byte

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

Provalo online!

Il programma principale esegue correttamente la prima istruzione, quindi l'istruzione dopo il booleano ||viene ignorata.

Per pari / dispari, <<<Hello\ world!diventa o non terminato <<heredoco <filefornito su stdin. In entrambi i casi, ||diventa diventa |, e quindi tutto ciò che viene emesso dal primo comando viene convogliato e ignorato da echo.

LOGO , 71 byte

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

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

(il programma ha una nuova riga finale)

Due versioni rimosse:

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

e

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

(il programma ha una nuova riga finale)

Per una spiegazione su cosa pre come erfare, consulta questo post . In questo caso,er viene feed con una parola determinare il nome della procedura.

Il \carattere di escape in Logo, che sfuggirà alla nuova riga dopo la fine del commento, rende quindi la seconda riga ( rHlo ol!e |) del secondo programma rimosso un commento.

Javascript, 68 byte

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

Personaggi dispari:

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

Personaggi pari:

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

Versione modificata della mia risposta sull'altra.

Perl 5 , 61 byte

60 byte codice + 1 per -p.

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

Provalo online!

Ogni byte dispari

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

Provalo online!

Ogni byte pari

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

Provalo online!

BotEngine , 180 178 byte

Sulla base della mia risposta a questa domanda.

 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

Caratteri dispari (notare gli spazi finali multipli sull'ultima riga):

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

Personaggi pari:

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

Incantesimi runici , 52 byte

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

Provalo online!

Runic di solito non è molto bravo a gestire le radiazioni poiché avere caratteri di controllo del flusso rimossi a caso rende l'esecuzione della traccia un dolore enorme, ma radiazioni prevedibili come ogni altro personaggio? Semplicemente, abbiamo semplicemente codificato due programmi che sono invertiti l'uno dall'altro e interlacciati, quindi puntiamo su una terza copia per l'esecuzione e il controllo di base quale viene eseguita con un singolo carattere. Nel programma 2, la terza copia è immondizia che non si è mai vista, e nel programma 3 mantiene le virgolette, consentendole di essere saltate senza stamparlo.

Il programma 1 esegue solo questa parte:

 L                                  @"!dlroW ,olleH"

Il programma 2 esegue solo questa parte:

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

Come questo:

  "Hello, World!" @!lo olH

Provalo online!

Il Programma 3 esegue solo questa parte:

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

Come questo:

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

Provalo online!

La "drW,le"porzione viene eseguita, ma la ~espelle immediatamente dallo stack, preservando l'output desiderato.

Ingenuamente sembrerebbe che una conversione della risposta> <> comporterebbe un programma più breve, del peso di 45 byte:

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

Tuttavia, Runic ha una limitazione che> <> non ha: una dimensione massima dello stack di 10 + mana IP (che inizialmente è 10). E !!ddllrrooWW oolllleeHHcontiene 24 caratteri, causando il sanguinamento del mana dell'IP fino a quando non scade appena prima di eseguire il Rcomando, senza produrre output per il programma di base.

Provalo online!