Als eine Art Teil 2 zu Hallo, Welt! (Jedes andere Zeichen) , ein Programm schreiben , so dass alle drei dieser Programme drucken „Hallo, Welt!“: Das gesamte Programm, das 1., 3., 5. usw. Zeichen des Programms, und die 2., 4., 6., etc.

Wenn Ihr Programm ist:

abc
def

Es sollte "Hello, World!" Ausgeben, sollte es aber auch

acdf

Und

b
e

Keine Lösungen mit eingebauten "Hallo, Welt!" S.

x86-Maschinencode, 378 Byte

PROG.COM Downloaden Sie und führen Sie es in MS-DOS- Emulator, DOSBox beispielsweise aus.

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

Sie können auch LEFT.COM und herunterladen RIGHT.COM

Wie es funktioniert und wie man läuft

Siehe Antwort zu Teil eins

Zauber

Wenn Sie den Befehl 0xAB opcode mit einem Parameter 0xCD ausführen möchten , schreiben Sie

Generator

Code ausführen, Hex erhalten. In Binär umwandeln

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

Jeder seltsame Charakter

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

Jeder gerade Charakter

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

Probieren Sie es online!

Dies könnte wahrscheinlich viel kürzer werden, aber ich bin froh, dass ich es geschafft habe, es in Python zum Laufen zu bringen. Ähnlich wie die Antwort von vroomfondel im ersten Teil.

Langweilige 93-Byte-Antwort

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

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

Jeder seltsame Charakter

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

Jeder gerade Charakter

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

Probieren Sie es online!

> <> 45 Bytes

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

Oder einfach nur Zeichen:

 "!dlroW olleH"!">o<  

Oder nur ungerade Zeichen:

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

Probieren Sie sie online aus: originell , ausgeglichen , Gewinnchancen .

Die ursprüngliche Version drückt " !!ddllrrooWW oolllleeHH" auf den Stapel, dann springt der Fisch dazwischen >~o <, wodurch ein Buchstabe gelöscht, zwei gedruckt, zwei gelöscht, zwei gedruckt, zwei gelöscht usw. Die beiden Halbprogramme sind ziemlich normale Zeichenfolgendruckprogramme. Der knifflige Teil war, in allen drei Programmen den String-Modus korrekt zu kombinieren "und wieder !zu deaktivieren.

Befunge-98 , 43 Bytes

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

Probieren Sie es online!

Nur die ungeraden:

10x"!dlroW ,olleH"ck,@

Probieren Sie es online!

Nur die geraden:

2 "!dlroW ,olleH"ck,@

Probieren Sie es online!

Erläuterung

Das vollständige Programm:

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.

Im ungeraden Programm ist das 2weg, damit macht das 10xeigentlich gar nichts (es setzt das Delta auf (1,0)das es sowieso voreingestellt ist). Der Rest des Programms ist dann der gleiche.

Im geraden Programm drücken wir nur 2den Anfang, den wir völlig ignorieren können. Der Rest des Programms ist derselbe wie zuvor.

Gammaplex , 46 Bytes

//

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

Siehe hier.

Dolmetscher. Möglicherweise müssen einige Änderungen vorgenommen werden, um in modernen Compilern zu funktionieren.

Mathematica, 65 Bytes

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

Es gibt einige Warnungen aus, druckt Hello, World!und kehrt zurück Null PPrriinntt[["" HHeelllloo, Null, "" WWoorrlldd!!]]. Bei Ausführung als Programm (nicht in der REPL) wird der Rückgabewert nicht gedruckt.

Nach dem Entfernen der geraden Zeichen:

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

Es wird gedruckt Hello, World!und kehrt zurück"el,Wrd" Null Pit.

Nach dem Entfernen der ungeraden Zeichen:

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

Es wird gedruckt Hello, World!und kehrt zurück Null ol! rn[Hlo].

x86-Maschinencode, 73 Byte

Inspiriert von der Lösung von Евгений Новиков , dachte ich, dass es mit weniger Tricks machbar sein sollte, dh nur herumzuspringen, um ansonsten "disjunkte" Codes für alle drei Varianten zu erhalten. Ich versuche es immer noch mit einer intelligenten Variante, die lodsb; lodsbals Mittelpunkt dient (daher wird für alle Varianten nur eine String-Konstante benötigt).

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

Wenn ich mich richtig an meine Kindheitstage erinnere, beginnt das winzige COM-Modell mit DS=CS=SSund der Code wird ab geladenCS:0100h . Ich gehe nicht davon aus, dass garantiert wird, dass der Code in einen Speicherblock mit Nullen geladen wird (wenn dies garantiert wäre, könnte ich zwei Bytes löschen).

Demontage des Langcodes sollte sein

  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"

Zerlegung eines ungeraden Codes

  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"

Zerlegung von geradem Code:

  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"

Netzhaut , 48 Bytes

G |`

HHeelllloo,,  WWoorrlldd!!
$_&

(.)\1t?
$1

Probieren Sie es online!

Ungerade Positionen:

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

Probieren Sie es online!

Gerade Positionen:

 `
Hello, World!$&
.\t
1

Probieren Sie es online!

Erläuterung

Das vollständige Programm:

G |`

Das macht überhaupt nichts. Dies |ist keine vorhandene Konfigurationsoption. Das Gmacht dies zu einer Grep-Bühne, aber es gibt wirklich nichts zu begreifen und die Regex ist leer, also macht das nichts. Der Zweck dieser Stufe ist es, zwei Zeilenvorschübe vor dem Hauptmenü "Hallo, Welt!" Zu haben. Linie, so dass einer von ihnen immer die Reduktion überlebt. Der Grund für die Erstellung eines Grep-Stags besteht darin, dass die Parität der Zeilen ausgeglichen werden muss und Grep-Stufen nur eine einzelne Zeile erfordern.

HHeelllloo,,  WWoorrlldd!!

Dies verwandelt die (leere) Arbeitszeichenfolge in die erforderliche Ausgabe, wobei jedes Zeichen verdoppelt wird.

$_&

Das macht nichts. Die Regex versucht, nach dem Ende der Zeichenkette ein _und ein zu finden, &was natürlich unmöglich ist. Wir werden diese Zeichen jedoch in der reduzierten Version benötigen, um verschwindende Zeilenvorschübe zu beheben.

(.)\1t?
$1

Zum Schluss entfernen wir die doppelten Zeichen durch Ersetzen (.)\1durch $1. Das t?wird nie verwendet, wird aber in den reduzierten Versionen wieder benötigt.

Das ungerade Programm:

G|
Hello, World!

Der Gkann nicht mit der Leereingabe übereinstimmen, aber aus diesem Grund müssen wir |eine alternative Leereingabe zulassen. Dies macht den leeren Arbeitsstring zur gewünschten Ausgabe.

_
()1?$

Dies ersetzt Unterstriche durch ()1?$, es gibt jedoch keine Unterstriche in der Zeichenfolge, sodass dies nichts bewirkt.

Das gerade Programm:

 `
Hello, World!$&

Das bedeutet `nur eine leere Konfigurationszeichenfolge, daher verwenden wir wieder die leere Regex, um die Arbeitszeichenfolge durch die Ausgabe zu ersetzen. Dieses Mal fügen wir auch ein, $&aber das ist das Match selbst, das natürlich leer ist, also macht es nichts.

.\t
1

Dies würde jedes Zeichen, auf das ein Tabulator folgt, durch ein ersetzen 1, aber wir haben keine Tabulatoren, daher ist dies auch ein No-Op.

Lua , 106 Bytes

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

Probieren Sie es online!

Alternative 1:

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

Probieren Sie es online!

Alternative 2:

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

Probieren Sie es online!

Drehbuch der Lichtmaschine: Probieren Sie es online aus!

CJam , 44 Bytes

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

Probieren Sie es online!

PHP, 70 Bytes

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

Ungerade Zeichen:

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

Gerade Zeichen:

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

Haskell , 92 Bytes

{---- }

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

Probieren Sie es online! Es sieht so aus, als wäre der Missbrauch von Kommentaren zu viel für die Syntaxhervorhebung. {- ... -}ist ein Inline- oder mehrzeiliger Kommentar, während --ein Zeilenkommentar beginnt.

Ungerade Zeichen:

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

Probieren Sie es online!

Gerade Zeichen:

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

Probieren Sie es online!

Zsh , 54 Bytes

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

Probieren Sie es online!

Das Hauptprogramm führt die erste Anweisung erfolgreich aus, sodass die Anweisung nach dem Booleschen Wert ||ignoriert wird.

Für ungerade / gerade wird das <<<Hello\ world!entweder ein nicht abgeschlossenes <<heredocoder ein <fileauf stdin bereitgestelltes. In beiden Fällen wird das ||zu |und alles, was vom ersten Befehl ausgegeben wird , wird weitergeleitet und von ignoriert echo.

LOGO , 71 Bytes

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

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

(Das Programm hat eine abschließende Newline)

Zwei entfernte Versionen:

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

und

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

(Das Programm hat eine abschließende Newline)

Für eine Erklärung was prunder tun, siehe diesen Beitrag . In diesem Fall erwird Feed mit einem Wort Prozedurnamen bestimmen.

Das \Escape-Zeichen in Logo, das die neue Zeile nach dem Ende des Kommentars verlässt, macht daher die zweite Zeile ( rHlo ol!e |) des zweiten entfernten Programms zu einem Kommentar.

Javascript, 68 Bytes

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

Sonderzeichen:

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

Sogar Charaktere:

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

Geänderte Version meiner Antwort auf die andere.

Perl 5 , 61 Bytes

60 Byte Code + 1 für -p.

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

Probieren Sie es online!

Jedes ungerade Byte

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

Probieren Sie es online!

Jedes gerade Byte

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

Probieren Sie es online!

BotEngine , 180 178 Bytes

Basierend auf meiner Antwort auf diese Frage.

 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

Ungerade Zeichen (beachten Sie die mehreren nachgestellten Leerzeichen in der letzten Zeile):

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

Gerade Zeichen:

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

Runenverzauberungen , 52 Bytes

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

Probieren Sie es online!

Runic ist normalerweise nicht sehr gut im Umgang mit Strahlung, da das zufällige Entfernen von Flusskontrollzeichen die Ausführung der Verfolgung zu einem großen Schmerz macht, aber vorhersagbare Strahlung wie jedes andere Zeichen? Ganz einfach, wir codieren einfach zwei Programme, die gegeneinander vertauscht und verschachtelt sind, und heften dann eine dritte Kopie für die Basisausführung auf und steuern, welche mit einem einzelnen Zeichen ausgeführt wird. In Programm 2 ist die dritte Kopie Müll, der nie gesehen wurde, und in Programm 3 werden die Anführungszeichen beibehalten, sodass sie ohne Drucken angezeigt werden können.

Programm 1 führt nur diesen Teil aus:

 L                                  @"!dlroW ,olleH"

Programm 2 führt nur diesen Teil aus:

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

So was:

  "Hello, World!" @!lo olH

Probieren Sie es online!

Programm 3 führt nur diesen Teil aus:

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

So was:

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

Probieren Sie es online!

Das "drW,le" Teil wird ausgeführt, wird jedoch ~sofort vom Stapel entfernt, wobei die gewünschte Ausgabe beibehalten wird.

Naiv scheint eine Konvertierung der Antwort> <> zu einem kürzeren Programm mit einem Gewicht von 45 Bytes zu führen:

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

Runic hat jedoch eine Einschränkung, die> <> nicht hat: eine maximale Stapelgröße von 10 + IPs Mana (die anfänglich 10 ist). Und !!ddllrrooWW oolllleeHHenthält 24 Zeichen, was dazu führt, dass die IP-Adresse bis zum Ablauf des Zeitraums, bevor der RBefehl ausgeführt wird, aus dem Mana ausblutet , was zu keiner Ausgabe für das Basisprogramm führt.

Probieren Sie es online!