Escreva um programa que imprima "Olá, mundo!". Mas também, se você usar apenas o primeiro, o terceiro, o quinto, etc. caracteres do seu programa, o programa resultante ainda deverá imprimir "Olá, Mundo!".

Se o seu programa é:

abc
def

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

acdf

Nenhuma solução com menos de 2 caracteres.

Python 3 , 61 bytes

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

Experimente online!

Abusando do fato de que printé uma função no Python 3 :)

A solução menos partidária que você encontrará aqui no PPCG.

Torna-se

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

Cardinal , 29 bytes

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

Experimente online!

A remoção de todos os outros caracteres remove todos os feeds de linha, o que ainda resulta em Hello, World!:

%"Hello, World!

Experimente online!

A razão pela qual isso funciona é que % cria quatro ponteiros de instruções, movendo-se em cada uma das quatro direções cardeais. IPs que deixam o código fonte são simplesmente removidos. Portanto, no primeiro caso, apenas o IP do sul permanece e, no segundo caso, apenas o PI do leste permanece, todos os outros são simplesmente descartados. Em ambos os casos, o programa executado é justo "Hello, World!. o" alterna para o modo de corda, em que cada célula é simplesmente mostrados na saída padrão. Não precisamos finalizar a string, porque deixar o código fonte ainda encerra o programa.

Observe que a mesma idéia funciona em cera de abelha , usando em *vez de% e em `vez de "(isso ocorre porque a cera de abelha foi amplamente inspirada pelo Cardinal, mas usa uma grade hexagonal).

Experimente online! (vertical) | | Experimente online! (horizontal)

C, 125 bytes

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

Experimente online!

Com caracteres pares removidos:

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

Experimente online!

Na verdade , 2 bytes

HH

Explicação:

H, como você pode esperar, empurra Hello, World! para a pilha.

O programa principal ( HH) encontrará o primeiro He empurrará Hello, World!para a pilha. No segundo H, no entanto, ele tentará usar dois argumentos (já que a pilha precisa estar vazia para pressionar Hello, World!) e falhará. No entanto, esse erro será ignorado e, em seguida,Hello, World! será impresso implicitamente.

O segundo programa ( H) pressionaráHello, World! enviado uma vez, e isso será impresso implicitamente.

Isso é semelhante à resposta de 2 bytes de Fatalize, mas isso realmente não "trapaceia".

Experimente online!

Lua , 89 bytes

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

Experimente online! Como mostra o realce da sintaxe, isso é um abuso massivo de comentários.

Alternar:

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

Experimente online!

E, por conveniência, um programa para converter um programa em qualquer outra forma de caractere: Experimente online!

Retina , 39 bytes

HHeelllloo,,  WWoorrlldd!!


(.).x?
$1

Experimente online!

Tomar todos os outros personagens dá:

Hello, World!
()x
1

Experimente online!

O primeiro programa cria uma string com a saudação duplicada. Em seguida, substitui cada par de caracteres pelo primeiro caractere. Há também um estágio vazio que substitui todas as cadeias vazias por cadeias vazias no meio, mas isso não faz nada. O segundo programa falha ao corresponder à letra "x", para que não substitua nada após a criação da saudação.

Talvez o mais divertido seja que, se o terceiro estágio for alterado ligeiramente, o primeiro conjunto de caracteres não precisará ser a mesma mensagem. Isso pode levar a muitas soluções de comprimento idêntico, como completas e reduzidas pela metade .

Carvão , 25 bytes

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

Experimente online!

Se você remover os caracteres pares, basta remover os comandos de seta que indicam a direção do próximo texto e que deixa o seguinte código:

Hello, World!

Experimente online!

Isso também imprime a saudação.

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 ! "

Experimente online!

Cada segundo caractere removido:

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

Experimente online!

Isso explora os dois formatos de comentários em Haskell: {- -}para comentários em linha ou multilinhas e --para comentar o restante da linha.

Javascript, 67 bytes

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

A cada segunda letra removida:

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

Assim como a resposta de Haskell, de Laikoni, isso explora comentários.

Braquilog , 4 bytes

Ḥ~wḤ

Experimente online!

Explicação

~wgrava sua variável direita em STDOUTe ignora seu argumento esquerdo. Ḥé "Hello, World!", então isso imprime Hello, World!.

Se pegarmos apenas o primeiro e o terceiro caracteres, receberemos Ḥw. Nesse caso, wescreve sua variável esquerda e ignora sua variável direita, para que também imprima Hello, World!.

2 bytes

ḤḤ

Experimente online!

Esta é tecnicamente uma resposta válida, mas unifica a variável de saída do programa em vez de imprimir para STDOUT, então acho que o programa de 4 bytes está mais dentro do espírito do desafio.

Haskell, 102 bytes

O 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

e com todos os outros caracteres removidos:

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

código de máquina x86, 162 bytes

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

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

após a remoção Download do 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

Como correr?

Instale o DOSBox, para Ubuntu / Debian

sudo apt install dosbox

Executá-lo

dosbox

No DOSBOX

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

Como isso funciona?

Os códigos de operação da máquina representam instruções da linguagem de montagem .

No MS-DOS para imprimir char, você definirá registros e fará interrupções. O registro AH será 0x02, o registro DL contém o seu caracter. O vetor de interrupção é 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)

O modelo minúsculo do arquivo COM do MS-DOS é uma boa escolha, porque não possui cabeçalhos . É limitado por 64K, mas, no nosso caso, não importa.

Para parar o programa, use a interrupção 0x20

int 0x20    ;0x20 interrupt     (CD 20)

Magia

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

AB CD

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

No MINI.COM

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

São códigos de máquina iguais , se você não usar o registro BL .

Gerador

Converter arquivo de texto com hexadecimal em hexadecimal binário

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

Pitão , 31 bytes

p% 2"HHeelllloo,,  WWoorrlldd!!

Experimente online!

Torna-se

p "Hello, World!

Agradecemos a @CalculatorFeline por apontar um erro e remover um byte.

V , 32 bytes

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

Observe que <esc>é um caractere único, por exemplo0x1b

Experimente online!

A remoção de todos os outros caracteres fornece:

iHello, world!<esc>Ó

Experimente online!

05AB1E , 29 bytes

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

Experimente online!

Explicação

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

Depois de remover todos os outros caracteres, ficamos com o código

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

Experimente online!

Explicação

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

Ele retorna "0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0]e imprimeHello, World! como efeito colateral. Quando executado como um programa (não no REPL), o valor de retorno não será impresso.

Depois de remover todos os outros caracteres:

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

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

Geléia , 26 25 bytes

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

Experimente online!

Depois de remover cada segundo caractere, ficamos com o código a seguir.

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

Experimente online!

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

Cubicamente 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

Experimente online!

Todas as outras letras:

+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

Experimente online!

CJam , 32 bytes

"HHeelllloo,,  WWoorrlldd!! "2 %

Experimente online!

Tomar todos os outros personagens dá:

"Hello, World!" 

Experimente online!

Ajuda, WarDoq! , 2 bytes

Hi

Experimente online!

Himprime Hello, World!, ié um no-op.

_{Ajuda, WarDoq! pode adicionar dois números e testar primos, por isso é considerada uma linguagem de programação válida para este meta post .}

/// , 25 bytes

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

Experimente online!

Com todos os outros caracteres removidos:

Hello, World!

PHP, 53 bytes

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

Com todos os outros caracteres removidos:

#eh ae
echo'Hello, World!';

Oitava, 49 45 bytes

Salva 4 bytes, pois o Octave não requer colchetes para fazer a indexação.

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

Experimente online!

E o reduzido:

'Hello, World!'(:    )'

Experimente online!

Explicação:

O código inicial tem as letras na string duplicadas, para que fiquemos com Hello, World! quando cada segundo é removido. Alguns espaços são adicionados para garantir que os colchetes e apóstrofos sejam mantidos.

A indexação é realmente 1:2:end. Existem 27 caracteres, e não podemos usar endou 27já que precisamos remover um caractere, então continuamos com 3 ^ 3ele. Quando removemos todos os terceiros caracteres, a indexação se torna (:)(e alguns espaços adicionais).

(:)significa "achatar e se transformar em um vetor vertical" . Então, precisamos transpor, usando '. Não precisamos transpor a string no código original, mas a dupla transposição funciona, então a primeira string é transposta duas vezes usando '', e a segunda é transposta apenas uma vez.

APL (Dyalog) , 35 34 bytes

-1 graças a Martin Ender.

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

Experimente online!

'0H0e0l0l0o0,0 0W0o0r0l0d0!0' a mensagem com zeros como caracteres de preenchimento removíveis

~ exceto

⍕ formatado (stringified)

0 número zero

Deixando apenas os caracteres estranhos, isso se torna '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 comentários de uma e várias linhas, inspirado na versão LUA da CalculatorFeline .

Após a remoção de todos os caracteres pares, alguns dos quais são quebras de linha:

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

Javascript, 73 bytes

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

Constrói uma string acom o conteúdo a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/e remove todos 0os itens a serem fornecidos alert`Hello, World!`//, que são eval'd.

Tomar todos os outros caracteres do programa fornece

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

que alerta Hello, Worldusando a sintaxe da seqüência de caracteres do modelo da mesma forma que foi avaliada no programa completo, armazena o resultado da chamada ae inclui um comentário perspicaz //;vlarpae//,').

> <> , 47 bytes

Original:

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

~o<< ;!!!? l

Com cada segundo caractere removido:

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

Experimente online: original , modificado

O programa original envia os caracteres de "Olá, mundo!" para a pilha (na ordem inversa) intercalada com espaços, imprime alternadamente um caractere e exclui um até que o comprimento da pilha seja zero. O segundo programa faz o mesmo, exceto as instruções de exclusão~ se foram.

Se você não se importa em parar com um erro, podemos tirar uma folha do livro do Cardinal de Martin Ender : o código modificado é

\"!dlroW ,olleH"!#o#

e o original é o mesmo, mas com novas linhas inseridas entre todos os caracteres, por 39 bytes. Experimente online: original , modificado .

,,,, 34 bytes

 2"Hteoltlaol,l yWhourmladn!! "⟛

Ao remover os caracteres pares ...

 "Hello, World!"

Explicação

Com todos os personagens:

 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

Sem os caracteres pares numerados:

 "..."

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

Brainfuck, 155 bytes

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

Experimente online!

Cada segundo caractere removido:

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

Geléia , 32 bytes

 2“HHeelllloo,,  WWoorrlldd!! ”m

Experimente online!

-2 bytes graças à resposta de totallyhuman

Agora o meu é um idiota>. <

Voto a favor desse também: D