Scrivi un programma che stampa "Hello, World!". Ma anche se prendi solo il primo, il terzo, il quinto, ecc. Caratteri del tuo programma, il programma risultante dovrebbe comunque stampare "Hello, World!".

Se il tuo programma è:

abc
def

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

acdf

Nessuna soluzione con meno di 2 caratteri.

Python 3 , 61 byte

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

Provalo online!

Abusare del fatto che printè una funzione in Python 3 :)

La soluzione meno partigiana che troverai qui su PPCG.

diventa

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

Cardinale , 29 byte

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

Provalo online!

La rimozione di ogni altro carattere rimuove tutti gli avanzamenti di riga, il che comporta comunque Hello, World!:

%"Hello, World!

Provalo online!

La ragione per cui funziona è che %crea quattro puntatori di istruzioni, che si muovono in ciascuna delle quattro direzioni cardinali. Gli IP che lasciano il codice sorgente vengono semplicemente rimossi. Quindi, nel primo caso, rimane solo l'IP in direzione sud e nel secondo caso, rimane solo l'IP in direzione est, tutti gli altri vengono semplicemente eliminati. In entrambi i casi, il programma eseguito è quindi giusto "Hello, World!. Le "commuta alla modalità stringa dove ciascuna cella viene semplicemente stampato a STDOUT. Non abbiamo bisogno di terminare la stringa, perché lasciare il codice sorgente termina ancora il programma.

Si noti che la stessa idea funziona in cera d' api , usando *invece di %e `invece di "(questo perché la cera d'api è stata ampiamente ispirata dal cardinale ma usa una griglia esagonale).

Provalo online! (verticale) | | Provalo online! (orizzontale)

C, 125 byte

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

Provalo online!

Con caratteri pari rimossi:

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

Provalo online!

In realtà , 2 byte

HH

Spiegazione:

H, come ci si potrebbe aspettare, spinge Hello, World!in pila.

Il programma principale ( HH) incontrerà il primo He passerà Hello, World!allo stack. Nel secondo H, tuttavia, proverà a utilizzare due argomenti (poiché lo stack deve essere vuoto per inviare Hello, World!) e fallire. Tuttavia, questo errore verrà ignorato e quindi Hello, World!verrà stampato in modo implicito.

Il secondo programma ( H) verrà premuto Hello, World!una volta e verrà stampato in modo implicito.

Questo è simile alla risposta a 2 byte di Fatalize, ma in realtà non "imbroglia".

Provalo online!

Lua , 89 byte

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

Provalo online! Come mostra l'evidenziazione della sintassi, si tratta di un massiccio abuso di commenti.

Alternato:

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

Provalo online!

E per comodità, un programma per convertire un programma in qualsiasi altra forma di carattere: provalo online!

Retina , 39 byte

HHeelllloo,,  WWoorrlldd!!


(.).x?
$1

Provalo online!

Prendere ogni altro personaggio dà:

Hello, World!
()x
1

Provalo online!

Il primo programma crea una stringa con il saluto duplicato. Quindi sostituisce ogni coppia di caratteri con il primo carattere. C'è anche una fase vuota che sostituisce tutte le stringhe vuote con stringhe vuote in mezzo, ma che non fa nulla. Il secondo programma non corrisponde alla lettera "x", quindi non sostituisce nulla dopo aver creato il messaggio di saluto.

Forse in modo più divertente, se la terza fase è cambiata leggermente, la prima serie di personaggi non deve essere lo stesso messaggio. Ciò potrebbe portare a molte soluzioni di lunghezza identica come quelle piene e dimezzate .

Carbone , 25 byte

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

Provalo online!

Se rimuovi i caratteri pari, rimuovi semplicemente i comandi freccia che indicano la direzione del testo successivo e che lascia il seguente codice:

Hello, World!

Provalo online!

Questo stampa anche il saluto.

Haskell , 85 byte

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

Provalo online!

Ogni secondo carattere rimosso:

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

Provalo online!

Questo sfrutta i due formati di commento in Haskell: {- -}per commenti in linea o multilinea e --per commentare il resto della linea.

Javascript, 67 byte

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

Ogni seconda lettera rimossa:

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

Proprio come la risposta di Laikoni Haskell, questo sfrutta i commenti.

Brachylog , 4 byte

Ḥ~wḤ

Provalo online!

Spiegazione

~wscrive la sua variabile destra in STDOUTe ignora l'argomento sinistro. Ḥè "Hello, World!", quindi questo stampa Hello, World!.

Se prendiamo solo il primo e il terzo carattere, otteniamo Ḥw. In tal caso wscrive la sua variabile sinistra e ignora la sua variabile destra, quindi stampa anche Hello, World!.

2 byte

ḤḤ

Provalo online!

Questa è tecnicamente una risposta valida, ma unifica la variabile di output del programma invece di stamparla STDOUT, quindi immagino che il programma a 4 byte sia più nello spirito della sfida.

Haskell, 102 byte

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

e con ogni altro personaggio rimosso:

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

codice macchina x86, 162 byte

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

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

dopo la rimozione Download MINI.COM

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

Come correre?

Installa DOSBox, per Ubuntu / Debian

sudo apt install dosbox

Eseguirlo

dosbox

In DOSBOX

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

Come funziona?

I codici di funzionamento della macchina rappresentano le istruzioni del linguaggio di assemblaggio .

In MS-DOS per stampare il carattere imposterai i registri e farai l'interruzione. Il registro AH sarà 0x02, il registro DL contiene il tuo carattere. Il vettore di interruzione è 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)

Il modello minuscolo di file COM MS-DOS è una buona scelta, perché non ha intestazioni . È limitato a 64 KB, ma nel nostro caso non importa.

Per interrompere il programma utilizzare l'interruzione 0x20

int 0x20    ;0x20 interrupt     (CD 20)

Magia

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

AB CD

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

In MINI.COM

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

Sono uguali codici macchina, se non si utilizza il registro BL .

Generatore

Converti file di testo con esadecimale in binario esadecimale

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 byte

p% 2"HHeelllloo,,  WWoorrlldd!!

Provalo online!

diventa

p "Hello, World!

Grazie a @CalculatorFeline per aver segnalato un errore e aver rimosso un byte.

V , 32 byte

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

Si noti che <esc>è un singolo carattere, ad es0x1b

Provalo online!

Rimuovere ogni altro personaggio dà:

iHello, world!<esc>Ó

Provalo online!

05AB1E , 29 byte

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

Provalo online!

Spiegazione

”™ ,ï‚‚ï ! ”                # 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

Dopo aver rimosso tutti gli altri caratteri ci resta il codice

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

Provalo online!

Spiegazione

”Ÿ™,‚ï!”       # 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 byte

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

Torna "0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0]e stampa Hello, World!come effetto collaterale. Quando eseguito come programma (non nel REPL), il valore restituito non verrà stampato.

Dopo aver rimosso tutti gli altri personaggi:

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

Torna Null ol! rn[Hlo]e stampa Hello, World!.

Gelatina , 26 25 byte

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

Provalo online!

Dopo aver rimosso ogni secondo carattere, ci rimane il seguente codice.

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

Provalo online!

Come funziona

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

Cubicamente v2.1 , 222 byte

+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

Provalo online!

Ogni altra lettera:

+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

Provalo online!

CJam , 32 byte

"HHeelllloo,,  WWoorrlldd!! "2 %

Provalo online!

Prendere ogni altro personaggio dà:

"Hello, World!" 

Provalo online!

Aiuto, WarDoq! , 2 byte

Hi

Provalo online!

Hstampe Hello, World!, iè una no-op.

_{Aiuto, WarDoq! può aggiungere due numeri e testare i numeri primi, quindi è considerato un linguaggio di programmazione valido per questo meta post .}

/// , 25 byte

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

Provalo online!

Con ogni altro personaggio rimosso:

Hello, World!

PHP, 53 byte

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

Con ogni altro personaggio rimosso:

#eh ae
echo'Hello, World!';

Ottava, 49 45 byte

Salvato 4 byte poiché Octave non richiede parentesi per eseguire l'indicizzazione.

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

Provalo online!

E quello ridotto:

'Hello, World!'(:    )'

Provalo online!

Spiegazione:

Il codice iniziale ha le lettere nella stringa duplicate, in modo che restino Hello, World!quando viene rimosso ogni secondo. Alcuni spazi vengono aggiunti per garantire il mantenimento delle parentesi e degli apostrofi.

L'indicizzazione è davvero 1:2:end. Ci sono 27 caratteri e non possiamo usarli endo 27dato che dobbiamo rimuovere un personaggio, quindi andiamo 3 ^ 3invece con . Quando rimuoviamo ogni terzo carattere, l'indicizzazione diventa(:) (e alcuni spazi aggiuntivi).

(:)significa "appiattire e trasformarsi in un vettore verticale" . Quindi, dobbiamo trasporlo, usando '. Non è necessario trasporre la stringa nel codice originale, ma la doppia trasposizione funziona, quindi la prima stringa viene trasposta due volte usando ''e la seconda viene trasposta una sola volta.

APL (Dyalog) , 35 34 byte

-1 grazie a Martin Ender.

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

Provalo online!

'0H0e0l0l0o0,0 0W0o0r0l0d0!0' il messaggio con zeri come caratteri di riempimento rimovibili

~ tranne

⍕ formattato (rigoroso)

0 numero zero

Lasciando solo i caratteri dispari, questo diventa 'Hello, World!' .

T-SQL, 75 byte

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

Abuso di commenti su una o più righe, ispirato alla versione LUA di CalculatorFeline .

Dopo la rimozione di tutti i caratteri pari, alcuni dei quali sono interruzioni di riga:

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

Javascript, 73 byte

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

Costruisce una stringa acon il contenuto a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/, quindi rimuove tutto 0da dare alert`Hello, World!`//, che è eval'd.

Prendere ogni altro carattere del programma dà

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

che avvisa Hello, Worldusando la sintassi della stringa di modello allo stesso modo di ciò che è stato valutato nell'intero programma, quindi memorizza il risultato della chiamata ae include il commento approfondito //;vlarpae//,').

> <> , 47 byte

Originale:

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

~o<< ;!!!? l

Con ogni secondo carattere rimosso:

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

Provali online: originale , modificati

Il programma originale spinge i personaggi di "Hello, World!" alla pila (in ordine inverso) intervallata da spazi, quindi stampa alternativamente un carattere e ne elimina uno fino a quando la lunghezza della pila è zero. Il secondo programma fa lo stesso, tranne le istruzioni per l'eliminazione~ sono sparite.

Se non ti dispiace fermarti con un errore, possiamo prendere una foglia dal libro cardinale di Martin Ender : il codice modificato è

\"!dlroW ,olleH"!#o#

e l'originale è lo stesso ma con le nuove righe inserite tra tutti i caratteri, per 39 byte. Provali online: originali , modificati .

,,, 34 byte

 2"Hteoltlaol,l yWhourmladn!! "⟛

Alla rimozione dei caratteri pari ...

 "Hello, World!"

Spiegazione

Con tutti i personaggi:

 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

Senza i caratteri pari:

 "..."

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

Brainfuck, 155 byte

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

Provalo online!

Ogni secondo carattere rimosso:

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

Gelatina , 32 byte

 2“HHeelllloo,,  WWoorrlldd!! ”m

Provalo online!

-2 byte grazie alla risposta di @humanhuman

Ora il mio è un duplicato>. <

Valorizza anche quello: D