Schreiben Sie ein Programm, das keine Eingaben macht und Hello, World!auf stdout oder die nächstgelegene Alternative Ihrer Sprache druckt . Der Haken ist, dass jede Zeile in Ihrem Programm nur druckbare ASCII-Zeichen enthalten darf und in lexikografischer Reihenfolge, auch bekannt als sortiert, sein muss.

Hier sind alle 95 druckbaren ASCII-Zeichen der Reihe nach aufgeführt:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

So wäre zum Beispiel die Zeile !!A0~ungültig, weil die Aund 0nicht in Ordnung sind. Die Zeile !!0A~wäre gültig.

Jede Zeile in Ihrem Programm kann beliebig lang sein und es kann eine beliebige Anzahl von Zeilen geben. Leerzeilen gelten als sortiert. Jede der Zeilenumbrüche in Ihrem Programm muss gleich sein (kein Mischen \nund \r\n). Tabulatoren und andere nicht druckbare ASCII-Zeichen sind verboten.

Aufgrund der großen Nachfrage wurde die Gewinnbedingung geändert:
Die Einsendung mit den wenigsten Zeilen gewinnt. Tiebreaker geht zum kürzesten Programm (Zeilenumbrüche zählen als Einzelzeichen).

Es sollte nur Hello, World!ein optionaler Zeilenumbruch ausgegeben werden. Beachten Sie, dass HQ9 + ungültig ist, da es ausgegeben wirdhello, world . Ich kann ähnliche Sprachen wie HQ9 + verbieten, die ein Zeichen "Hallo, Welt!" Haben. Befehle aufgrund ihrer Trivialität.

Hinweis:

Dies ist auf jeden Fall möglich , in Unary und Lenguage , wenn auch nicht sehr prägnant.

Headsecks , 1 Zeile, 366 Bytes

                                                                        $(((((((((((((((((((((((((((((,000000044888<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIIIIIIIIIIIILPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPTXXXXXXXXXXXXXXXXXXXXXXXX\```diiiiiilqqqqqqqqtyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy|

Headsecks ist eine triviale Brainfuck-Substitution, bei der es nur auf den Codepunkt modulo 8 ankommt. Das äquivalente Brainfuck ist lediglich

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.

Zum Glück dieser naive Ansatz passt einfach . Es gibt ein gewisses Potenzial, Bytes abzubauen, aber es könnte schwierig sein.

Getestet mit diesem Python-Interpreter .

Code wird generiert

code = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------."
command_map = "+-<>.,[]"

last_point = 32
out = []

for char in code:
    curr_mod = command_map.index(char)
    last_mod = last_point % 8

    if curr_mod > last_mod:
        last_point += curr_mod - last_mod

    elif curr_mod < last_mod:
        last_point += (8 - last_mod) + curr_mod

    out.append(chr(last_point))

print("".join(out))

/// , 7 Zeilen, 22 Bytes

/
//Hello
,
 Wor
l
d
!

Eine seltene Chance für ///, wettbewerbsfähig zu sein (solange niemand mit Unary und Lenguage anfängt ...).

Der Code trifft zuerst auf a /und analysiert das

/
//

als Ersetzungsanweisung, die alle Zeilenumbrüche aus dem Rest des Programms entfernt. Danach liest das Programm nur noch

Hello, World!

die wörtlich gedruckt wird, da sie keine weiteren Schrägstriche enthält.

JavaScript (67 66 62 Zeilen, 227 269 ​​Bytes)

(Hinweis: Nur unter Firefox 36 und Safari 8 getestet, enthält kleinere ES6-Funktionen (die SetKlasse))

Z
=
!""+
(0[[]]
+
(
!!""+Set
));c
=Z[~
-22]
$=Z[
3]
$$=Z[
15]
$$$=Z[
24]
$$$$=Z[
1]
$$$$$=Z[
0]
Set
[c
+
$$$+Z[
5]
+Z[
16]
+
$$$$$+
$$$$+Z[
2]
+c
+
$$$$$+
$$$+
$$$$]
(Z[
14]
+
$$+
$+
$$$$+
$$$$$+
"(\
'H\
"+
$+
$$+
$$+
$$$+
",\
 W\
"+
$$$+
$$$$+
$$+Z[
6]
+
"\
!')\
")
()

Der obige Code bewirkt im Grunde:

alert("Hello, World!")

Offensichtlich alertist nicht sortiert. Stattdessen müssen wir die Anweisung als String generieren und "auswerten":

s = "alert('Hello, World!')";   // generate this using sorted code
eval(s)

Wie wird der String generiert? ES5 unterstützt die Fortsetzung von Zeilen

"AL\
ERT" === "ALERT"

Da der Zeichencode jedoch vor allen Kleinbuchstaben \angezeigt wird , müssen die Kleinbuchstaben mit anderen Methoden generiert werden.

Wir leihen uns hier eine Idee von JSFuck aus. Die in den Warnmeldungen enthaltenen Kleinbuchstaben sind:

t e r a o l d

All dies kann aus Zeichen von Standardobjekten extrahiert werden, die in einer bestimmten sortierten Reihenfolge ausgedrückt werden können:

t, e, r ← true      = !""
a, l    ← false     = !!""
o       ← function  = Set
d       ← undefined = 0[[]]

Wie bewerten wir den String? Sicher können wir nicht verwenden, eval(s)da es nicht sortiert ist. Alternativ könnten wir verwenden Function(s)(), aber wir können es nicht verwenden, Functionda es auch nicht sortiert ist. Ist Functionjedoch der Konstruktor aller Funktionen, was bedeutet Set.constructor === Function.

Durch Hinzufügen des Bezeichners constructorwird die Liste der Kleinbuchstaben zu:

t e r a o l d c u n s

was glücklicherweise noch generiert werden konnte von "truefalseundefinedfunction":

t, e, r, u ← true      = !""
a, l, s    ← false     = !!""
o, c, n    ← function  = Set
d          ← undefined = 0[[]]

Nach dem Prettifizieren sollte der obige Code wie folgt lauten:

// lines 1~8 defines our string containing all lowercase letters we want
Z = true + (undefined + (false + Set))
// Z = "trueundefinedfalsefunction Set() { [native code] }"

// lines 8~20 defines the variables `c`, `$` (e), `$$` (l), `$$$` (o), 
// `$$$$` (r), `$$$$$` (t)
// for the corresponding lowercase letters extracted from `Z`

// the rest calls:
Set["constructor"]("alert('Hello, World')")()
// lines 22~36 generates the "constructor" string
// lines 37~61 generates the "alert('Hello, World')" string

Update: Umbenannt E, L, O, R, , Tum verschiedene Wiederholungen von $4 Zeilen zu reduzieren.

Schlaflosigkeit , 4 Zeilen, 59 Bytes

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Dieses Programm wird durch Optimierung der Zeilenzahl generiert.

10 Zeilen, 43 Bytes

(u
pt
(dppty
p~
j
<Fptt{
(otz
?o
FLu
<?FFu~

Dieses obige Programm wird durch Optimieren der Bytezahl generiert.

Cygwin Bash, 16 Zeilen, 60 Bytes

Dies funktioniert nur aufgrund des Dateinamens, bei dem die Groß- und Kleinschreibung nicht berücksichtigt wird, und der Tatsache, dass Cygwin die Dienstprogramme ohne Berücksichtigung der Groß- und Kleinschreibung aufruft, auch wenn Sie nicht festlegen, dass der Pfad ohne Berücksichtigung der Groß- und Kleinschreibung erkannt wird.

A\
=Hello
A\
+=\
",
"Wor
A\
+=l
A\
+=d
A\
+=\
!
E\
CHO\
 $A

Beachten Sie dies ECHOam Ende.

> <> , 6 Zeilen, 111 Bytes

  """""""/;;Hello
        &\o
      &++\oooo~~
"++++++++\bbbdlr
    +++++\ccccccccfooo}
    $++66\cfffffooooopr

Ich habe Probleme, eine Extralinie auszuspielen, aber auf jeden Fall bin ich froh, die 7-Linien-Methode geschlagen zu haben.

Erläuterung

> <> ist eine stapelbasierte 2D-Sprache, in der Anweisungen einzelne Zeichen sind und der Programmfluss nach oben, unten, links oder rechts erfolgen kann. Der "Befehl schaltet das Parsen von Strings um und drückt Zeichen, bis ein Closing erreicht "ist. Aufgrund der Natur von> <> gibt es jedoch kein "mehrzeiliges Parsen von Strings" wie bei CJams Strings oder Pythons Strings mit dreifachen Anführungszeichen. Dies stellte sich als schwerwiegendes Problem heraus, da das Beginnen und Beenden einer Zeile mit einem "und andere Zeichen dazwischen (z. B. "some chars") nicht zulässig sind!

Beachten Sie dies /und \spiegeln Sie den Programmablauf wider. Wir führen die erste Zeile in umgekehrter Reihenfolge aus, und die meisten Zeilen werden tatsächlich rückwärts ausgeführt!

[Line 1]

""""""              Three empty strings, push nothing
"/;;Hello  "        Push "/;;Hello  ". Note the wrapping - ><> is toroidal!
""""""              Three empty strings, push nothing

[Line 6]
66++$               Turn the top " " into "," by adding 12, then swap top two
rp                  Reverse stack and pop top 3
ooooo               Print "Hello", stack is now " ,"
fffffc              Push some 15s and a 12

[Line 5]
+++++               Sum the 15s and 12 to give 87, or "W"
}ooo                Move "W" to the back and output ", W"
fcccccccc           Push a 15 and some 12s

[Line 4]
++++++++            Sum the 15 and 12s to give 111, or "o"
"rldbbb\++++++++"   Push chars to stack
r                   Reverse stack
ld                  Push length of stack and 13, not used
bbb                 Push three 11s

[Line 3]
++&                 Sum the 11s to give 33, or "!" and put in register
~~                  Pop top two
oooo                Print "orld"

[Line 2]
&                   Put "!" from register to stack
o                   Print "!"

[Line 1]
;                   Terminate

Nebenbei bemerkt, hier ist ein amüsanter Versuch mit einem Minimum an Bytes (23 Zeilen, 47 Bytes):

v
"
!
d
l
r
o
W

,
o
l
l
e
H
"
/<
l
?
!
;
o
\^

CJam, 5 4 Zeilen, 162 Bytes

"Hello
")))))))))))))))))))))))))))))))))))68S\cel
"Wor
")))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))@SX\c|

Gleiche Anzahl Leitungen wie Insomnia! (aber viel mehr Bytes)

Probieren Sie es online aus .

Erläuterung

"Hello\n"        Push "Hello" and a newline
)                Uncons the newline
)))...)))        Increment the newline into a ","
68S\             Push 68 and a space then swap, leaving 68 on top
c                Convert 68 into a char "D"
el               Lowercase "D" into "d"
"Wor\n"          Push "Wor" and a newline
)                Uncons the newline
)))...)))        Increment the newline into an "l"
@                Rotate top three elements, moving the "d" to the top
SX\              Push a space and 1 then swap, leaving the space on top
c                Convert the space (which is an array) into a char
|                Bitwise or the space (32) with 1 to give "!" (33)    

CJam druckt den Stapel anschließend automatisch aus.

Vielen Dank an @Optimizer, der mich daran erinnert hat, dass das Scfunktioniert, weil es sonst SX|fehlschlägt (es macht ein setwise oder gibt stattdessen das Array bestehend aus einem Leerzeichen und 1).

> <> (Fisch) , 5 Zeilen, viele Bytes

Der Code ist extrem lang, wenn ich sage [6535529689086686142930090 '+' signs]und [6535529689086686142930090 'd' characters]in der ersten Zeile des Codes, meine ich, dass es buchstäblich gibt6535529689086686142930090 Pluszeichen in einer Reihe gibt!

(Fügen Sie für die folgenden Zeilen die erforderlichen Präfix-Leerzeichen hinzu.)

'[6535529689086686142930090 '+' signs]^`[6535529689086686142930090 'd' characters]
                                   **,/288
                                     -/:o
                             %**288:;?\
                                   (1:\

Eine kürzere testbare Alternative, die nur druckt Hi:

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^`hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
                                                                                                                               **,/288
                                                                                                                                 -/:o
                                                                                                                         %**288:;?\
                                                                                                                               (1:\

Methode:

• In der ersten Zeile erstellen wir eine riesige Zahl, die den String in base128 darstellt.
• In den restlichen Zeilen (von unten nach oben) wird in jeder Schleife das folgende Zeichen gedruckt, bis der Wert der Ganzzahl 0 erreicht.
• Der Schleifencode ist :1(?;:882**%:o-288**,.

(Mit dieser Methode können beliebig lange Zeichenfolgen mit mehr als 2 Zeichen gedruckt werden.)

PHP (7/17 Zeilen, 36/59 Bytes):

Aufgrund der Anzahl ungültiger Antworten habe ich diese Antwort umgeschrieben.

Die Browserversion? Weg.

Aber ich habe 2 Lösungen, beide basierend auf bitwise xor( ^) von Strings in PHP.

Dies ist eine äußerst leistungsstarke Lösung! Manchmal können so viele Bytes gespart werden.

Erstens die kürzeste Antwort:

Echo
Hello
,AM^mm
,Wor
,OOO^
"#+n
";

Ich weiß, es sieht schrecklich aus, aber es funktioniert!

Der nächste hängt von Zeilenumbrüchen ab.

Ja, es werden Zeilenumbrüche verwendet ( \n/ UNIX-Stil ist erforderlich)!

Echo
Bo
.ff
.e
.
"&*]ex
fn
"^
"\n
\n
\n
\n
\n
\n
\n
",B^c
;

Die Zeilenumbrüche in diesem Fall müssen funktionieren.

Es ist nicht perfekt, aber es funktioniert!

Beide Antworten basierten auf der @ MartinBüttner - Lösung :

Echo
Hello
.
chr
(44
).
chr
(29
+3
).Wor
.l
.d
."!
";

Ein besonderer Dank geht an @ n̴̖̋h̴̖̋ã̷͉h̷̭̿d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner und @skagedal für die Aufdeckung all meiner Fehler und für ihre Vorschläge.

Pyth, 7 Zeilen, 23 Bytes

-
"Hello
,
 Wor
l
d
!"b

Ziemlich einfach, verwenden Sie einfach eine mehrzeilige Zeichenfolge und entfernen Sie die Zeilenumbrüche.

Probieren Sie es hier aus.

Viertens 41 Zeilen, 143 Bytes

Probieren Sie es online aus.

Darauf bin ich sehr stolz. Ich habe es ziemlich schnell rausgepeitscht, als ich herausgefunden habe, dass ich es schaffen kann, da Google nach Sprachen gesucht hat, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird, und ich kenne Forth bereits recht gut. Es kann fast definitiv verkürzt werden, sowohl Bytes als auch Zeilen. Vorschläge werden geschätzt. : D

Dieses Programm gibt im Wesentlichen den Dezimalwert jedes ASCII-Zeichens aus und druckt dann jedes einzelne aus. Ich habe versucht zu optimieren, während ich es geschrieben habe, daher ist es weniger lesbar als ich möchte.

33
99
1
+
DUp
8
+
2DUp
6
+
SWap
11
+
2OVer
SWap
8
9
*
EMit
1
+
EMit
DUp
DUp
EMit
EMit
3
+
EMit
29
3
2DUp
+
EMit
*
EMit
EMit
EMit
EMit
EMit
EMit

Marbelous, 9 Zeilen, 94 Bytes

3333
    @ADD
    358C
++--29\\
++--3555DE
<<<<<<>>~~
+++++446666D
++++++++../\
      ++------

Testen Sie es hier online. Using spaces for blank cellsmuss überprüft werden.

Visuelle Darstellung der Quelle:

Erläuterung: Jeder hexadezimale Wert in diesem Programm bewegt sich mit jedem "Häkchen" nach unten (es sei denn, er ist aktiviert \\, in diesem Fall bewegt er sich nach rechts). ++erhöht den Wert, --verringert,~~ wendet ein Bit nicht an usw. Werte, die nach unten fallen, werden als ASCII-Zeichen gedruckt.

Zum Beispiel: Das 33in der oberen Ecke wird (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 Zeilen

$_
=
'pr
int
"Hello
,
 Wor
l
d
!"';s
!
!!g
;s
!.
*
!$&
!eex

Rebol - 15 Zeilen (51 Bytes)

PRin
AJOin
[
'Hello
Sp 
+
12
Sp
'Wor
'l
'd
Sp
+
1
]

Worte in Rebol Groß- und Kleinschreibung (zB. PRINT, PrintUndprint würden die gleiche Funktion alle nennen).

Der obige Code wurde aufgeräumt:

prin ajoin [
    'Hello  sp + 12  sp  'Wor  'l  'd  sp + 1
]

NB. spgibt das Leerzeichen zurück !

Unär , 1 Zeile, viele Bytes

Jeder Charakter in diesem Programm ist 0. Die Quelle ist zu lang, um sie hier einzufügen, aber sie besteht aus einer Folge dieser vielen Nullen:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Dies ist die Dezimaldarstellung für diese Binärzahl:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Welche wurde aus diesem BrainF *** Programm erstellt:

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

Sehen Sie, wie ich es generiert habe: http://ideone.com/lMT40p

Stapelverarbeitung - 39 Zeilen (202 Byte)

Ich wollte die Größe reduzieren, indem ich die verzögerte Erweiterung aktivierte, indem ich den Code innerhalb eines cmdAnrufs über den /v onSchalter ausführte, konnte aber nicht alle Karat überwinden.

@S^
ET^
LO^
C^
AL^
 EN^
ABL^
E^
DEL^
AY^
E^
DEX^
P^
ANS^
IO^
N
@S^
ET^
 0=Hello
@S^
ET^
 1=^
,^
 Wor
@S^
ET^
 2=l
@S^
ET^
 3=d
@E^
CHO^
 !^
0^
!!1^
!!2^
!!3^
!^^^
!

Ohne die Zeilenumbrüche (und Karat, um Zeilenumbrüchen zu entgehen):

@SETLOCAL ENABLEDELAYEDEXPANSION
@SET 0=Hello
@SET 1=, Wor
@SET 2=l
@SET 3=d
@ECHO !0!!1!!2!!3!^^!

Ruby, 19 Zeilen, 95 Bytes

$;=
$>
$;<<
:Hello
$;<<
44::chr
$.=
33::
-1
$;<<
$.::chr
$;<<
:Wor
$;<<
:l
$;<<
:d
$;<<
33::chr

Möglicherweise die zweithärteste Code-Einschränkung für Ruby, die ich auf dieser Site gesehen habe, nach der Monstrosität hier .

Zur Erklärung bearbeiten: Die einzige Ruby-Ausgabemethode, die sortiert wird, ist die <<Methode in STDOUT. Leider ist die Konstante für STDOUT$> und> ist höher als die meisten ASCII - Symbole, es ist also nicht wirklich möglich , ein Verfahren auf sie zu nennen. Wir brauchen eine mehrzeilige Zuweisungsanweisung, um einen besser lesbaren Variablennamen zu erhalten.$; (Semikolon ist immer noch ziemlich hoch, aber die meisten Variablen dieser Form können entweder nicht zugewiesen werden oder können nur Zeichenfolgen sein).

Symbole (:Wor usw.) sind die einfachste Möglichkeit, ein Literal zu erstellen, und ich sehe keine Möglichkeit, Zeilenumbrüche aus einer Zeichenfolge zu entfernen. Daher benötige ich mehrere print-Anweisungen. Das Leerzeichen und die Interpunktion können nicht in ein Symbol-Literal aufgenommen werden, aber zum Glück ist die chrMethode für Zahlen zulässig, sodass ich ein Zeichen aus dem ASCII-Wert abrufen kann. ::ist eine alternative Methode zum Aufrufen von Methoden. Raum ist schwierig, weil ich nicht schreiben kann 32, also subtrahiere ich 1 von 33 und ordne es einer Variablen zu.

Netzhaut, 12 Zeilen, 29 Bytes (nicht konkurrierend)

Die Sprache ist neuer als die Herausforderung.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Probieren Sie es online aus