Scrivi un programma che non accetta input e stampa Hello, World!su stdout o l'alternativa più vicina alla tua lingua. Il problema è che ogni riga del programma deve contenere solo caratteri ASCII stampabili e deve essere in ordine lessicografico, ovvero ordinata.

Ecco tutti i 95 caratteri ASCII stampabili in ordine:

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

Quindi, ad esempio, la riga non !!A0~sarebbe valida perché Ae 0sono fuori servizio. La linea !!0A~sarebbe valida.

Ogni riga nel tuo programma può essere di qualsiasi lunghezza e può esserci un numero qualsiasi di righe. Le righe vuote sono considerate ordinate. Ognuna delle nuove righe del programma deve essere la stessa (nessuna miscelazione \ne \r\n). Le schede e altri caratteri ASCII non stampabili sono vietati.

A grande richiesta , le condizioni di vittoria sono state cambiate: vince
l'invio con il minor numero di righe . Tiebreaker passa al programma più breve (le nuove righe contano come singoli caratteri).

Hello, World!Dovrebbero essere prodotti solo e una nuova riga finale facoltativa. Si noti che HQ9 + non è valido poiché emette hello, world. Posso vietare lingue simili a HQ9 + che hanno un carattere "Ciao, mondo!" comandi a causa della loro banalità.

Suggerimento:

Questo è sicuramente possibile in unario e Lenguage , anche se non molto conciso.

Headsecks , 1 riga, 366 byte

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

Headsecks è una banale sostituzione di Brainfuck in cui l'unica cosa che conta è il punto di codice modulo 8. L'equivalente Brainfuck è semplicemente

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

Fortunatamente questo approccio ingenuo appena si inserisce. C'è qualche potenziale per giocare a golf in byte, ma potrebbe essere difficile.

Testato usando questo interprete Python .

Generazione di codice

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 righe, 22 byte

/
//Hello
,
 Wor
l
d
!

Una rara possibilità che /// sia competitivo (purché nessuno inizi con Unary e Lenguage ...).

Il codice incontra prima un /, e analizza il

/
//

come istruzione sostitutiva che rimuove tutte le nuove righe dal resto del programma. Successivamente, il programma legge semplicemente

Hello, World!

che viene stampato alla lettera in quanto non contiene ulteriori barre.

JavaScript (67 66 62 linee, 227 269 ​​byte)

(Nota: testato solo su Firefox 36 e Safari 8, contiene funzioni ES6 minori (la Setclasse))

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]
+
"\
!')\
")
()

Il codice sopra sostanzialmente fa:

alert("Hello, World!")

Ovviamente alertnon è ordinato. Quindi, invece, dobbiamo generare l'istruzione come stringa e "valutarla":

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

Come generare la stringa? ES5 supporta la continuazione della linea in questo modo

"AL\
ERT" === "ALERT"

Ma il codice carattere \appare prima di tutte le lettere minuscole, quindi dobbiamo generare le lettere minuscole usando altri metodi.

Prendiamo in prestito un'idea di JSFuck qui. Le lettere minuscole coinvolte nelle dichiarazioni di allarme sono:

t e r a o l d

tutti questi possono essere estratti da caratteri di oggetti standard, che possono essere espressi in termini di una sequenza ordinata:

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

Come valutiamo la stringa? Sicuramente non possiamo usare in eval(s)quanto non è ordinato. In alternativa, potremmo usare Function(s)(), ma non possiamo usare in Functionquanto non è ordinato neanche. Tuttavia, Functionè il costruttore di tutte le funzioni, il che significa Set.constructor === Function.

L'aggiunta dell'identificatore constructorfa diventare l'elenco delle lettere minuscole:

t e r a o l d c u n s

che per fortuna potrebbe ancora essere generato da "truefalseundefinedfunction":

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

Dopo la preimpostazione, il codice sopra dovrebbe essere simile a:

// 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

Aggiornamento: Rinominato E, L, O, R, Ta vari ripetizione $per ridurre le 4 linee.

Insonnia , 4 linee, 59 byte

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Questo programma viene generato ottimizzando il conteggio delle righe.

10 linee, 43 byte

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

Questo programma sopra è generato ottimizzando il conteggio dei byte.

Cygwin bash, 16 linee, 60 byte

Questo funziona solo a causa del nome del file senza distinzione tra maiuscole e minuscole su Windows e del fatto che Cygwin cerca le utilità senza distinzione tra maiuscole e minuscole anche se non lo si imposta per riconoscere il percorso senza distinzione tra maiuscole e minuscole.

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

Prendi nota di ciò ECHOalla fine.

> <> , 6 righe, 111 byte

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

Ho problemi a giocare a golf con una linea in più, ma in ogni caso sono felice di aver battuto il metodo a 7 linee.

Spiegazione

> <> è un linguaggio 2D basato su stack in cui le istruzioni sono caratteri singoli e il flusso del programma può essere su, giù, sinistra o destra. L' "istruzione attiva o disattiva l'analisi delle stringhe, spingendo i caratteri fino a quando non "viene raggiunta una chiusura , ma a causa della natura di> <> non esiste una cosa come "analisi di stringhe a più righe" come con le stringhe di CJam o le stringhe a tre punte di Python. Questo si è rivelato un grosso problema perché non è permesso iniziare e terminare una riga con a "e avere altri caratteri tra (es. "some chars")!

Nota che /e \rifletti il ​​flusso del programma, quindi eseguiamo effettivamente la prima riga e poi tutte le righe in ordine inverso, e la maggior parte delle righe vengono effettivamente eseguite al contrario!

[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

In una nota a margine, ecco un divertente tentativo di un> <> minimo byte (23 righe, 47 byte):

v
"
!
d
l
r
o
W

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

CJam, 5 4 righe, 162 byte

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

Stesso numero di linee di Insomnia! (ma molti più byte)

Provalo online .

Spiegazione

"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 stampa automaticamente la pila in seguito.

Grazie a @Optimizer per avermi ricordato che Scfunziona, perché altrimenti SX|fallisce (fa una setwise o invece, dando l'array costituito da uno spazio e 1).

> <> (Fish) , 5 righe, molti byte

Il codice è estremamente lungo, quando dico [6535529689086686142930090 '+' signs]e [6535529689086686142930090 'd' characters]nella prima riga del codice, intendo che ci sono letteralmente 6535529689086686142930090più segni in una riga!

(E per le seguenti righe aggiungere gli spazi prefisso necessari.)

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

Un'alternativa più breve verificabile che stampa solo Hi:

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

Metodo:

• Nella prima riga creiamo un numero enorme che rappresenta la stringa in base128.
• Nel resto delle righe (andando dal basso verso l'alto) stampiamo il seguente carattere in ogni ciclo fino a quando il valore dell'intero non raggiunge 0.
• Il codice di looping è :1(?;:882**%:o-288**,.

(Con questo metodo possiamo stampare stringhe arbitrarie di 2+ caratteri.)

PHP (7/17 righe, 36/59 byte):

A causa della quantità di risposte non valide, ho riscritto questa risposta.

La versione del browser? Andato.

Ma ho 2 soluzioni, entrambe basate su bitwise xor( ^) di stringhe in PHP.

Questa è una soluzione estremamente potente! A volte, consente di risparmiare molti byte.

Innanzitutto, la risposta più breve:

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

Lo so, sembra orribile, ma funziona!

Il prossimo dipende dalle nuove righe.

Sì, utilizza newline ( \nè richiesto lo stile / UNIX)!

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

Le newline su questo sono necessarie per funzionare.

Non è perfetto, ma funziona!

Entrambe le risposte sono basate su @ MartinBüttner 's soluzione :

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

Un ringraziamento speciale a @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner e @skagedal per aver rilevato tutti i miei errori e per i loro suggerimenti.

Pyth, 7 linee, 23 byte

-
"Hello
,
 Wor
l
d
!"b

Abbastanza semplice, basta usare una stringa multilinea e rimuovere le nuove righe.

Provalo qui.

Avanti, 41 linee, 143 byte

Provalo online.

Ne sono molto orgoglioso. L'ho tirato fuori abbastanza rapidamente una volta scoperto che potevo farlo, avendo Google cercato lingue senza distinzione tra maiuscole e minuscole, e conosco già Forth decentemente. Può quasi sicuramente essere abbreviato, sia byte che righe. I suggerimenti sono apprezzati. : D

Questo programma spinge essenzialmente il valore decimale di ciascun carattere ASCII, quindi stampa ciascuno di essi. Ho provato a ottimizzare mentre l'ho scritto, quindi è meno leggibile di quanto mi piacerebbe.

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 righe, 94 byte

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

Provalo online qui. Using spaces for blank cellsdeve essere controllato.

Rappresentazione visiva della fonte:

Spiegazione: Ogni valore esadecimale in questo programma si sposta verso il basso di ogni "segno di spunta" (a meno che non sia attivo \\, nel qual caso si sposta a destra). ++incrementerà il valore, --decrementerà, ~~applicherà un non bit a bit, ecc. I valori che cadono dal fondo vengono stampati come caratteri ASCII.

Ad esempio: L' 33angolo in alto diventa (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 righe

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

Rebol - 15 linee (51 byte)

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

Parole Rebol sono case-insensitive (ad es. PRINT, PrintE printsarebbero tutti chiamare la stessa funzione).

Il codice sopra riordinato:

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

NB. sprestituisce il carattere spaziale !

Unario , 1 riga, molti byte

Ogni personaggio di questo programma è 0 . La fonte è troppo lunga per essere inserita qui, ma è composta da una stringa di tanti zeri:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Questa è la rappresentazione decimale per questo numero binario:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Che è stato creato da questo programma BrainF ***:

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

Guarda come l'ho generato: http://ideone.com/lMT40p

Lotto - 39 righe (202 byte)

Volevo ridurre le dimensioni abilitando l'espansione ritardata eseguendo il codice all'interno di una cmdchiamata utilizzando l' /v oninterruttore, ma non sono riuscito a superare tutti i carati.

@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^
!^^^
!

Senza le nuove linee (e carati per sfuggire alle nuove linee):

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

Rubino, 19 righe, 95 byte

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

Forse la seconda restrizione di codice più difficile per Ruby che ho visto su questo sito, dopo la mostruosità qui .

Modifica per spiegazione: l'unico metodo di output di Ruby che è stato ordinato è il <<metodo su STDOUT. Sfortunatamente, la costante per STDOUT è $>, ed >è ASCII superiore rispetto alla maggior parte dei simboli, quindi non è davvero possibile chiamare un metodo su di esso. Abbiamo bisogno di un'istruzione di assegnazione su più righe per inserirla in un nome di variabile più tracciabile,$; (il punto e virgola è ancora piuttosto elevato, ma la maggior parte delle variabili di questo modulo sono non assegnabili o possono essere solo stringhe).

I simboli ( :Wor, ecc.) Sono il modo più semplice per eseguire un valore letterale e non vedo un modo per rimuovere le righe da una stringa, quindi ho bisogno di più istruzioni di stampa. Lo spazio e la punteggiatura non possono andare in un simbolo letterale, ma per fortuna il chrmetodo sui numeri è legale, quindi posso ottenere un carattere dal suo valore ASCII. ::è un modo alternativo di chiamare metodi. Lo spazio è complicato perché non riesco a scrivere 32, quindi sottraggo 1 da 33 e lo assegno a una variabile.

Retina, 12 linee, 29 byte (non concorrenti)

La lingua è più recente della sfida.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Provalo online