Napisz program, który nie pobiera danych wejściowych i drukuje Hello, World!na standardowe wyjście lub najbliższą alternatywę dla twojego języka. Problem polega na tym, że każda linia w twoim programie musi zawierać tylko drukowalne znaki ASCII i musi być uporządkowana leksykograficznie, inaczej sortowana.

Oto wszystkie 95 znaków ASCII do wydruku w kolejności:

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

Na przykład linia !!A0~byłaby nieprawidłowa, ponieważ Ai 0są w porządku. Linia !!0A~byłaby ważna.

Każda linia w twoim programie może mieć dowolną długość i może być dowolna liczba linii. Puste linie są uważane za posortowane. Każda nowa linia w twoim programie musi być taka sama (bez miksowania \ni \r\n). Zakładki i inne niedrukowalne znaki ASCII są zabronione.

Ze względu na popularny popyt warunki wygranej zostały zmienione:
Zgłoszenie z najmniejszą liczbą linii wygrywa. Tiebreaker przechodzi do najkrótszego programu (znaki nowej linii liczą się jako pojedyncze znaki).

Hello, World!Wyjściowy powinien być tylko opcjonalny znak nowej linii. Zauważ, że HQ9 + jest nieprawidłowy, ponieważ generuje dane wyjściowe hello, world. Mogę zabronić używania języków podobnych do HQ9 +, które mają jeden znak „Witaj, świecie!” polecenia ze względu na ich trywialność.

Wskazówka:

Jest to zdecydowanie możliwe w Unary i Lenguage , choć niezbyt zwięźle.

Zagłówki , 1 linia, 366 bajtów

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

Headsecks to trywialna zamiana Brainfuck, w której jedyną rzeczą, która się liczy, jest punkt kodowy modulo 8. Odpowiednikiem Brainfuck jest jedynie

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

Na szczęście to naiwne podejście po prostu pasuje. Istnieje pewien potencjał do gry w golfa w dół bajtów, ale może to być trudne.

Testowane przy użyciu tego interpretera języka Python .

Generowanie kodu

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 linii, 22 bajty

/
//Hello
,
 Wor
l
d
!

Rzadka szansa na współzawodnictwo /// (o ile nikt nie zaczyna od Unary i Lenguage ...).

Kod najpierw napotyka a /i analizuje

/
//

jako instrukcja zamiany, która usuwa wszystkie nowe wiersze z pozostałej części programu. Następnie program po prostu czyta

Hello, World!

który jest drukowany dosłownie, ponieważ nie zawiera żadnych dodatkowych ukośników.

JavaScript (67 66 62 linie, 227 269 ​​bajtów)

(Uwaga: testowane tylko na Firefox 36 i Safari 8, zawiera niewielkie funkcje ES6 ( Setklasa))

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

Powyższy kod zasadniczo wykonuje:

alert("Hello, World!")

Oczywiście alertnie jest posortowane. Zamiast tego musimy wygenerować instrukcję jako ciąg znaków i „ewaluować” ją:

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

Jak wygenerować ciąg? ES5 obsługuje kontynuację linii, dzięki czemu

"AL\
ERT" === "ALERT"

Ale kod znakowy \pojawia się przed wszystkimi małymi literami, więc musimy wygenerować małe litery za pomocą innych metod.

Pożyczamy tutaj pomysł na JSFuck . Małe litery użyte w oświadczeniach ostrzegawczych to:

t e r a o l d

wszystkie z nich można wyodrębnić ze znaków standardowych obiektów, które można wyrazić w postaci posortowanej sekwencji:

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

Jak oceniamy ciąg? Z pewnością nie możemy używać, eval(s)ponieważ nie jest posortowane. Alternatywnie możemy użyć Function(s)(), ale nie możemy użyć, Functionponieważ nie jest również posortowane. Jednak Functionjest konstruktor wszystkich funkcji, co oznacza Set.constructor === Function.

Dodanie identyfikatora constructorpowoduje, że lista małych liter staje się:

t e r a o l d c u n s

które na szczęście nadal mogą być generowane przez "truefalseundefinedfunction":

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

Po wstępnym sprawdzeniu powyższy kod powinien wyglądać następująco:

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

Aktualizacja: Zmiana nazwy E, L, O, R, Tdo różnych powtórzeniu $zredukować 4 linie.

Bezsenność , 4 linie, 59 bajtów

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Ten program jest generowany przez optymalizację pod kątem liczby linii.

10 linii, 43 bajty

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

Powyższy program jest generowany przez optymalizację liczby bajtów.

Cygwin bash, 16 linii, 60 bajtów

Działa to tylko z powodu nazwy pliku bez rozróżniania wielkości liter w systemie Windows oraz faktu, że Cygwin wyszukuje narzędzia bez rozróżniania wielkości liter, nawet jeśli nie ustawisz rozpoznawania ścieżki bez rozróżniania wielkości liter.

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

Zwróć na to uwagę ECHOna końcu.

> <> , 6 linii, 111 bajtów

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

Mam problem z graniem w dodatkową linię, ale w każdym razie cieszę się, że pokonałem metodę 7-liniową.

Wyjaśnienie

> <> to oparty na stosie język 2D, w którym instrukcje są pojedynczymi znakami, a przepływ programu może być w górę, w dół, w lewo lub w prawo. "Instrukcja przełącza ciąg parsowania, pchanie znaki aż do zamknięcia "jest spełniony, ale ze względu na charakter> <> nie ma czegoś takiego jak „multi-line ciąg parsowania” jak z ciągów CJam lub potrójnymi cudzysłowami Pythona. Okazało się to być poważnym problemem, ponieważ rozpoczynanie i kończenie linii za pomocą "a posiadanie innych znaków między (np. "some chars") Jest niedozwolone!

Należy pamiętać, że /i \odzwierciedla przebiegu programu, więc faktycznie wykonać pierwszą linię następnie wszystkie linie w odwrotnej kolejności, a większość linii są faktycznie wykonywane w kierunku do tyłu!

[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

Na marginesie, oto zabawna próba>> <> najmniej bajtów (23 wiersze, 47 bajtów):

v
"
!
d
l
r
o
W

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

CJam, 5 4 wiersze, 162 bajty

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

Taka sama liczba linii jak bezsenność! (ale o wiele więcej bajtów)

Wypróbuj online .

Wyjaśnienie

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

Następnie CJam automatycznie drukuje stos.

Dzięki @Optimizer za przypomnienie mi, że Scdziała, bo inaczej się SX|nie powiedzie (robi setwise lub zamiast tego, dając tablicę składającą się ze spacji i 1).

> <> (Ryba) , 5 linii, wiele bajtów

Kod jest bardzo długi, kiedy mówię, [6535529689086686142930090 '+' signs]aw [6535529689086686142930090 'd' characters]pierwszym wierszu kodu mam na myśli dosłownie 6535529689086686142930090znaki plus w rzędzie!

(I w poniższych wierszach dodaj niezbędne spacje przedrostkowe.)

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

Krótsza, testowalna alternatywa, która drukuje tylko Hi:

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

Metoda:

• W pierwszym wierszu tworzymy ogromną liczbę reprezentującą ciąg znaków w base128.
• W pozostałych wierszach (od dołu do góry) wypisujemy następujący znak w każdej pętli, dopóki wartość liczby całkowitej nie osiągnie 0.
• Kod pętli to :1(?;:882**%:o-288**,.

(Za pomocą tej metody możemy wydrukować dowolny ciąg znaków o długości 2+).

PHP (7/17 wierszy, 36/59 bajtów):

Ze względu na liczbę nieprawidłowych odpowiedzi przepisałem tę odpowiedź.

Wersja przeglądarki? Odszedł.

Ale mam 2 rozwiązania, oba oparte na bitowym xor( ^) ciągach w PHP.

To niezwykle potężne rozwiązanie! Czasami pozwala zaoszczędzić dużo bajtów.

Po pierwsze, najkrótsza odpowiedź:

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

Wiem, wygląda okropnie, ale działa!

Następny zależy od nowego wiersza.

Tak, używa znaku nowej linii ( \nwymagany jest styl / UNIX)!

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

Nowe wiersze na tym są wymagane do działania.

To nie jest idealne, ale działa!

Obie odpowiedzi były oparte na @ MartinBüttner „s rozwiązania :

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

Specjalne podziękowania dla @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner i @skagedal za wykrycie wszystkich moich błędów i za ich sugestie.

Pyth, 7 linii, 23 bajty

-
"Hello
,
 Wor
l
d
!"b

Całkiem proste, wystarczy użyć ciągu wielowierszowego i usunąć znaki nowej linii.

Wypróbuj tutaj.

Dalej, 41 linii, 143 bajty

Wypróbuj online.

Jestem z tego bardzo dumny. Wyciągnąłem to dość szybko, gdy znalazłem, że mogę to zrobić, ponieważ Google szukało języków bez rozróżniania wielkości liter i już znam Fortha przyzwoicie. Niemal na pewno można go skrócić, zarówno bajtów, jak i linii. Sugestie są mile widziane. :RE

Ten program zasadniczo wypycha wartość dziesiętną każdego znaku ASCII, a następnie drukuje każdy. Podczas pisania próbowałem zoptymalizować, dlatego jest mniej czytelny, niż bym chciał.

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

Cudowny, 9 linii, 94 bajty

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

Sprawdź to online tutaj. Using spaces for blank cellsmusi zostać sprawdzone.

Wizualna reprezentacja źródła:

Objaśnienie: Każda wartość szesnastkowa w tym programie przesuwa się w dół o każdy „tik” (chyba że jest włączony \\, w takim przypadku przesuwa się w prawo). ++zwiększy wartość, --zmniejszy, nie ~~zastosuje bitów itp. Wartości, które spadają z dołu są drukowane jako znak ASCII.

Na przykład: W 33górnym rogu pojawi się (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 linii

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

Rebol - 15 linii (51 bajtów)

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

Słowa REBOL-są niewłaściwe (np. PRINT, PrintA printto wszystko wywołać tę samą funkcję).

Powyższy kod posprzątał:

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

NB. spzwraca znak spacji !

Unary , 1 linia, dużo bajtów

Każda postać w tym programie jest 0. Źródło jest za długie, aby je tutaj wstawić, ale składa się z ciągu wielu zer:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

To jest reprezentacja dziesiętna dla tej liczby binarnej:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Który został stworzony z tego programu BrainF ***:

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

Zobacz, jak to wygenerowałem: http://ideone.com/lMT40p

Partia - 39 linii (202 bajty)

Chciałem zmniejszyć rozmiar, umożliwiając opóźnioną ekspansję, uruchamiając kod w cmdwywołaniu za pomocą /v onprzełącznika, ale nie mogłem ominąć wszystkich karatów.

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

Bez nowych linii (i karatów, aby uciec przed nowymi liniami):

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

Ruby, 19 linii, 95 bajtów

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

Prawdopodobnie drugie najtrudniejsze ograniczenie kodu dla Ruby, jakie widziałem na tej stronie, po potworności tutaj .

Edycja dla wyjaśnienia: Jedyną posortowaną metodą wyjściową Ruby jest <<metoda STDOUT. Niestety, stała dla STDOUT jest $>i >jest wyższa niż ASCII niż większość symboli, więc tak naprawdę nie można wywołać dla niej metody. Potrzebujemy wieloliniowej instrukcji przypisania, aby przekształcić ją w bardziej zrozumiałą nazwę zmiennej $;(średnik jest wciąż dość wysoki, ale większość zmiennych tej postaci jest albo nieprzypisywalna, albo może być tylko ciągiem znaków).

Symbole ( :Woritp.) To najłatwiejszy sposób na dosłowność i nie widzę sposobu na usunięcie znaków nowej linii z łańcucha, więc potrzebuję wielu instrukcji drukowania. Spacja i interpunkcja nie mogą być literałami symboli, ale na szczęście chrmetoda na liczbach jest legalna, więc mogę uzyskać znak z jego wartości ASCII. ::jest alternatywnym sposobem wywoływania metod. Spacja jest trudna, ponieważ nie mogę pisać 32, więc odejmuję 1 od 33 i przypisuję ją do zmiennej.

Siatkówka, 12 linii, 29 bajtów (niekonkurujące)

Język jest nowszy niż wyzwanie.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Wypróbuj online