Comme une sorte de partie 2 à Hello, World! (Un caractère sur deux) , écrivez un programme tel que ces trois programmes affichent "Bonjour, le monde!": Le programme entier, les 1er, 3e, 5e, etc. caractères de votre programme et les 2e, 4e, 6e, etc.

Si votre programme est:

abc
def

Il devrait afficher "Bonjour, monde!", Mais

acdf

Et

b
e

Pas de solutions avec le "Bonjour, monde!" Intégré.

code machine x86, 378 octets

PROG.COM Téléchargez et exécutez-le dans l' émulateur MS-DOS , DOSBox par exemple.

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

Vous pouvez également télécharger LEFT.COM et RIGHT.COM

Comment ça marche et comment courir

Voir la réponse à la première partie

la magie

Si vous souhaitez exécuter la commande opcode 0xAB avec un paramètre 0xCD , vous écrivez

Générateur

Exécutez le code, obtenez hex. Convertir en binaire

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 octets

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

Chaque personnage étrange

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

Chaque personnage pair

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

Essayez-le en ligne!

Cela pourrait probablement être beaucoup plus court, mais je suis heureux d'avoir réussi à le faire fonctionner en Python. Similaire à la réponse de vroomfondel dans la première partie.

Réponse ennuyeuse de 93 octets

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

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

Chaque personnage étrange

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

Chaque personnage pair

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

Essayez-le en ligne!

> <> , 45 octets

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

Ou même des personnages:

 "!dlroW olleH"!">o<  

Ou juste des caractères étranges:

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

Essayez - les en ligne: originaux , Evens , cote .

La version originale pousse " !!ddllrrooWW oolllleeHH" vers la pile, puis le poisson rebondit entre >~o <, ce qui supprime une lettre, imprime deux, supprime deux, imprime deux, supprime deux, etc. Les deux demi-programmes sont des programmes d'impression de chaîne assez standard. La partie délicate consistait à combiner "et !à basculer correctement dans le mode chaîne dans les trois programmes.

Befunge-98 , 43 octets

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

Essayez-le en ligne!

Seuls les étranges:

10x"!dlroW ,olleH"ck,@

Essayez-le en ligne!

Seuls les pairs:

2 "!dlroW ,olleH"ck,@

Essayez-le en ligne!

Explication

Le programme complet:

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.

Dans le programme étrange, le 2est parti, de sorte que 10xcela ne fait vraiment rien du tout (il définit le delta (1,0)auquel est par défaut de toute façon). Le reste du programme est alors le même.

Dans le programme pair, nous poussons juste 2le début que nous pouvons ignorer complètement. Le reste du programme est le même qu'avant.

Gammaplex , 46 octets

//

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

Vois ici.

Interprète. Il peut avoir besoin de quelques modifications pour fonctionner dans les compilateurs modernes.

Mathematica, 65 octets

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

Il lance des avertissements, des impressions Hello, World!et des retours Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Lorsqu'il est exécuté en tant que programme (pas dans le REPL), la valeur de retour ne sera pas imprimée.

Après avoir supprimé les caractères pairs:

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

Il imprime Hello, World!et revient "el,Wrd" Null Pit.

Après avoir supprimé les caractères impairs:

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

Il imprime Hello, World!et revient Null ol! rn[Hlo].

code machine x86, 73 octets

Inspiré par la solution de Евгений Новиков , je pensais que cela devrait être faisable avec moins de trucs, c'est-à-dire en sautant simplement sur des codes autrement "disjoints" pour les trois variantes. J'essaie toujours avec une variante intelligente qui utilise lodsb; lodsbcomme point central (donc une seule constante de chaîne est nécessaire pour toutes les 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 je me souviens bien de mon enfance, le petit modèle de COM commence par DS=CS=SSet le code est chargé à partir de CS:0100h. Je ne suppose pas qu'il est garanti que le code est chargé dans un bloc de mémoire mis à zéro (s'il était garanti, je pourrais laisser tomber deux octets).

Le démontage du code long doit être

  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"

Démontage de code impair

  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"

Démontage du code pair:

  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"

Rétine , 48 octets

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

Essayez-le en ligne!

Positions impaires:

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

Essayez-le en ligne!

Positions paires:

 `
Hello, World!$&
.\t
1

Essayez-le en ligne!

Explication

Le programme complet:

G |`

Cela ne fait rien du tout. Ce |n'est pas une option de configuration existante. Le Gfait cette une étape grep, mais il n'y a vraiment rien à l'expression rationnelle et rassemblés de vide est tout, donc cela ne fait rien. Le but de cette étape est d'avoir deux sauts de ligne devant le principal "Hello, World!" ligne de sorte que l'un d'eux survit toujours à la réduction. La raison pour laquelle il s'agit d'un cerf grep est que nous devons compenser la parité des lignes, et les étapes grep ne nécessitent qu'une seule ligne.

HHeelllloo,,  WWoorrlldd!!

Cela transforme la chaîne de travail (vide) en sortie requise avec chaque caractère doublé.

$_&

Cela ne fait rien. Le regex essaie de faire correspondre a _et a &après la fin de la chaîne, ce qui est bien sûr impossible. Nous aurons cependant besoin de ces caractères dans la version réduite, encore une fois pour faire face aux sauts de ligne disparus.

(.)\1t?
$1

Enfin, nous supprimons les caractères en double en les remplaçant (.)\1par $1. Le t?n'est jamais utilisé mais sera de nouveau nécessaire dans les versions réduites.

Le programme étrange:

G|
Hello, World!

Le Gne peut pas correspondre à l'entrée vide, mais c'est pourquoi nous devons |autoriser une autre correspondance vide. Cela transforme la chaîne de travail vide en sortie souhaitée.

_
()1?$

Cela remplace les traits de soulignement par ()1?$, mais il n'y a aucun trait de soulignement dans la chaîne, donc cela ne fait rien.

Le programme pair:

 `
Hello, World!$&

Le `dénote juste une chaîne de configuration vide, nous utilisons donc à nouveau l'expression régulière vide pour remplacer la chaîne de travail par la sortie. Cette fois, nous insérons également $&mais c'est le match lui-même, qui est vide, bien sûr, donc il ne fait rien.

.\t
1

Cela remplacerait tout caractère suivi d'un onglet par un 1, mais nous n'avons aucun onglet, il s'agit donc également d'un no-op.

Lua , 106 octets

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

Essayez-le en ligne!

Suppléant 1:

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

Essayez-le en ligne!

Alternative # 2:

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

Essayez-le en ligne!

Script alternateur: essayez-le en ligne!

CJam , 44 octets

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

Essayez-le en ligne!

PHP, 70 octets

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

Caractères étranges:

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

Caractères pairs:

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

Haskell , 92 octets

{---- }

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

Essayez-le en ligne! Il semble que l'abus de commentaire soit trop pour la mise en évidence de la syntaxe. {- ... -}est un commentaire en ligne ou sur plusieurs lignes, alors qu'il --démarre un commentaire en ligne.

Caractères étranges:

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

Essayez-le en ligne!

Caractères pairs:

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

Essayez-le en ligne!

Zsh , 54 octets

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

Essayez-le en ligne!

Le programme principal exécute la première instruction avec succès, donc l'instruction après le booléen || est ignorée.

Pour impair / pair, le <<<Hello\ world!devient soit un non terminé <<heredocou un <filefourni sur stdin. Dans tous les cas, le ||devient |, et donc tout ce qui est sorti par la première commande est canalisé et ignoré par echo.

LOGO , 71 octets

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

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

(le programme a une nouvelle ligne de fin)

Deux versions supprimées:

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

et

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

(le programme a une nouvelle ligne de fin)

Pour une explication quoi pret erfaire, voir ce post . Dans ce cas,er est alimenté avec un mot pour déterminer le nom de la procédure.

Le \caractère d'échappement est dans Logo, qui échappera à la nouvelle ligne après la fin du commentaire, donc faites de la deuxième ligne ( rHlo ol!e |) du deuxième programme supprimé un commentaire.

Javascript, 68 octets

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

Caractères étranges:

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

Caractères pairs:

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

Version modifiée de ma réponse sur l'autre.

Perl 5 , 61 octets

Code de 60 octets + 1 pour -p.

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

Essayez-le en ligne!

Chaque octet impair

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

Essayez-le en ligne!

Chaque octet pair

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

Essayez-le en ligne!

BotEngine , 180 178 octets

Basé sur ma réponse à cette question.

 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

Caractères impairs (notez les multiples espaces de fin sur la dernière ligne):

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

Caractères pairs:

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

Enchantements runiques , 52 octets

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

Essayez-le en ligne!

Runic n'est généralement pas très doué pour gérer les radiations, car le fait de retirer les caractères de contrôle de flux au hasard rend l'exécution du traçage très difficile, mais les radiations prévisibles comme tous les autres personnages? Facile, nous encodons simplement deux programmes qui sont inversés l'un de l'autre et entrelacés, puis clouons sur une troisième copie pour l'exécution de base et contrôlons laquelle est exécutée avec un seul caractère. Dans le programme 2, la troisième copie est une ordure qui n'a jamais été vue, et dans le programme 3, elle conserve les guillemets, ce qui lui permet d'être sauté sans l'imprimer.

Le programme 1 exécute uniquement cette partie:

 L                                  @"!dlroW ,olleH"

Le programme 2 exécute uniquement cette partie:

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

Comme ça:

  "Hello, World!" @!lo olH

Essayez-le en ligne!

Le programme 3 exécute uniquement cette partie:

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

Comme ça:

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

Essayez-le en ligne!

La "drW,le"portion est exécutée, mais le~ sort immédiatement de la pile, préservant la sortie souhaitée.

Naïvement, il semblerait qu'une conversion de la réponse> <> entraînerait un programme plus court, pesant 45 octets:

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

Cependant, Runic a une limitation que> <> n'a pas: une taille de pile maximale de 10 + mana IP (qui est initialement 10). Et !!ddllrrooWW oolllleeHHcontient 24 caractères, provoquant une perte de mana de l'IP jusqu'à son expiration juste avant l'exécution de la Rcommande, ce qui n'entraîne aucune sortie pour le programme de base.

Essayez-le en ligne!