Giriş Hello, World!yapamayan ve stdout'a veya dilinizin en yakın alternatifi olan bir program yazın . Yakalama, programınızdaki her satırın yalnızca yazdırılabilir ASCII karakterleri içermesi ve sıralı, sıralı bir sıralama şeklinde olması gerektiğidir.

Sırayla, yazdırılabilir 95 ASCII karakterinin tümü:

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

Bu nedenle, örneğin, satır !!A0~geçersiz olur Ave 0sıra dışıdır. Satır !!0A~geçerli olur.

Programınızdaki her satır herhangi bir uzunlukta olabilir ve herhangi bir sayıda satır olabilir. Boş satırlar sıralanmış olarak kabul edilir. Programınızdaki yeni satırların her biri aynı olmalıdır (karıştırma \nve karıştırma \r\n). Sekmeler ve yazdırılamayan diğer ASCII karakterleri yasaktır.

Nedeniyle için yoğun talep , kazanma koşulu etrafında geçildi:
en az olan teslim hatları kazanır. Tiebreaker en kısa programa gider (yeni satırlar tek karakter olarak sayılır).

Yalnızca Hello, World!ve isteğe bağlı bir izleyen satırsonu çıkarılmalıdır. HQ9 + ' ın çıkıştan bu yana geçersiz olduğunu unutmayın hello, world. HQ9 + 'ya benzer bir karaktere sahip olan "Merhaba, Dünya!" Karakterlerini yasaklayabilirim. önemsizlikleri nedeniyle komutlar.

İpucu:

Bu kesinlikle mümkün tekli ve yüksek oranlarda konuşma olmasa çok kısaca.

Headsecks , 1 satır, 366 bayt

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

Headsecks, önem taşıyan tek şeyin modulo 8 kod noktası olduğu önemsiz bir Brainfuck ikamesidir. Eşdeğer Brainfuck sadece

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

Neyse ki bu saf yaklaşım sadece uyuyor. Baytlarda golf oynamak için bazı potansiyeller var ama zor olabilir.

Bu Python yorumlayıcısı kullanılarak test edilmiştir .

Kod oluşturma

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 satır, 22 bayt

/
//Hello
,
 Wor
l
d
!

/// rekabet edebilmek için nadir bir şans (hiç kimse Unary ve Lenguage ile başlamadığı sürece ...).

Kod önce a ile karşılaşır /ve ayrıştırır.

/
//

Programın geri kalanından tüm yeni satırları kaldıran bir değiştirme talimatı olarak. Daha sonra, program sadece okur

Hello, World!

daha fazla eğik çizgi içermediğinden sözlü basılmıştır.

JavaScript (67 66 62 satır, 227 269 ​​bayt)

(Not: Yalnızca Firefox 36 ve Safari 8'de test edilmiştir, küçük ES6 özellikleri içerir ( Setsınıf))

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

Yukarıdaki kod temelde şunları yapar:

alert("Hello, World!")

Açıkçası alertsıralanmamış. Bunun yerine, ifadeyi bir dizge olarak oluşturmamız ve “değerlendirmemiz” gerekir:

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

Dize nasıl oluşturulur? ES5, satırın devamını destekler;

"AL\
ERT" === "ALERT"

Ancak karakter kodu tüm küçük harflerden önce\ görünür , bu nedenle diğer yöntemleri kullanarak küçük harfleri oluşturmamız gerekir.

Burada bazı JSFuck fikirlerini ödünç alıyoruz . Uyarı ifadelerinde yer alan küçük harfler:

t e r a o l d

Bunların tümü, bazı sıralama dizileriyle ifade edilebilen standart nesnelerin karakterlerinden elde edilebilir:

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

Dizeyi nasıl değerlendiriyoruz? Tabii eval(s)sıralanmadığı için kullanamayız. Alternatif olarak kullanabiliriz Function(s)(), ancak Functionsıralanmadığı için kullanamayız. Ancak, Functiontüm işlevlerin yapıcısı, yani Set.constructor === Function.

Tanımlayıcı eklemek, constructorküçük harflerin listesini olur:

t e r a o l d c u n s

Neyse ki hala tarafından üretilebilir "truefalseundefinedfunction":

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

Güzelleştirmeden sonra, yukarıdaki kod şöyle okunmalıdır:

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

Güncelleme: Yeniden adlandırılmış E, L, O, R, Tçeşitli tekrarına $4 satır azaltmak için.

Uykusuzluk , 4 satır, 59 bayt

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Bu program satır sayımı için optimize edilerek oluşturulmuştur.

10 satır, 43 bayt

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

Bu yukarıdaki program bayt sayımı için optimize edilerek üretilmiştir.

Cygwin bash, 16 satır, 60 bayt

Bu, yalnızca Windows'ta büyük / küçük harfe duyarlı olmayan dosya adı ve Cygwin'in yardımcı programları büyük / küçük harfe duyarsız bulması nedeniyle çalışır.

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

ECHOSonunda bunu not al .

> <> , 6 satır, 111 bayt

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

Ekstra bir hatla golf oynamakta zorlanıyorum, ancak her durumda 7 hatlı yöntemi yendiğim için mutluyum.

açıklama

> <> talimatların tek karakter olduğu ve program akışının yukarı, aşağı, sola veya sağa gelebileceği yığın tabanlı bir 2D dilidir. "Talimat bir kapanış kadar karakter iterek dize ayrıştırma değiştirir "karşılanmaktadır, fakat doğası> <> CJam en dizeleri veya Python'un üçlü tırnakla gibi "çok hatlı dize ayrıştırma" diye bir şey yoktur. Bu büyük bir sorun olarak ortaya çıktı çünkü a ile bir çizginin başlaması ve bitmesi "ve (örn. "some chars") Arasında başka karakterlerin bulunmasına izin verilmiyor!

Buna dikkat edin /ve \program akışını yansıtın, bu yüzden ilk satırın ardından tüm satırları ters sırada uygularız ve çoğu satır gerçekte geriye doğru yürütülür!

[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

Bir yandan notta, işte <>> en az bayt (23 satır, 47 bayt):

v
"
!
d
l
r
o
W

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

CJam, 5 4 satır, 162 bayt

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

Uykusuzluk ile aynı sayıda çizgi! (ama çok daha fazla bayt)

Çevrimiçi deneyin .

açıklama

"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 daha sonra yığını otomatik olarak yazdırır.

Bana işe Scyaradığını hatırlattığımız için @Optimizer sayesinde , aksi takdirde SX|başarısız olur (bir set veya bunun yerine, boşluk ve 1'den oluşan diziyi verir).

> <> (Balık) , 5 satır, birçok bayt

Kod son derece uzun, söylediğimde [6535529689086686142930090 '+' signs]ve [6535529689086686142930090 'd' characters]kodun ilk satırında, 6535529689086686142930090arka arkaya kelimenin tam anlamıyla artı işaretler var demek istiyorum !

(Ve aşağıdaki satırlar için gerekli önek boşluklarını ekleyin.)

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

Yalnızca baskı yapan daha kısa bir test edilebilir alternatif Hi:

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

Yöntem:

• İlk satırda base128'deki dizgeyi temsil eden büyük bir sayı yarattık.
• Satırların geri kalanında (aşağıdan yukarıya doğru) her döngüde tamsayı değeri 0 olana kadar aşağıdaki karakteri yazdırırız.
• Döngü kodudur :1(?;:882**%:o-288**,.

(Bu yöntemle isteğe bağlı 2+ karakter uzun dize yazdırabiliriz.)

PHP (7/17 satır, 36/59 bayt):

Geçersiz cevap miktarı nedeniyle bu cevabı tekrar yazdım.

Tarayıcı sürümü? Gone.

Fakat her ikisi de PHP'de bitsel xor( ^) dizgelere dayanan 2 çözümüm var .

Bu son derece güçlü bir çözüm! Bazen bol miktarda bayt tasarrufu sağlar.

İlk önce en kısa cevap:

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

Biliyorum, berbat görünüyor, ama işe yarıyor!

Bir sonraki yeni satırlara bağlıdır.

Evet, yeni satırları kullanıyor ( \n/ UNIX stili gerekli)!

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

Bunun için yeni hatların çalışması gerekiyor.

Mükemmel değil ama işe yarıyor!

Her iki cevaplar dayandığını MartinBüttner @ 'in çözümü :

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

Tüm hatalarımı tespit etmek ve önerileri için @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner ve @skagedal'a özel bir teşekkür .

Pyth, 7 satır, 23 bayt

-
"Hello
,
 Wor
l
d
!"b

Oldukça basit, sadece çok satırlı bir dize kullanın ve yeni satırları kaldırın.

Burada dene.

İleri, 41 satır, 143 bayt

Çevrimiçi deneyin.

Bununla çok gurur duyuyorum. Google'ın büyük / küçük harfe duyarlı olmayan dilleri aramasını sağladığımı öğrendikten sonra çok hızlı bir şekilde çırptım ve Forth'u dürüstçe tanıyorum. Hem bayt hem de satır olarak neredeyse kesinlikle kısaltılabilir. Öneriler takdir edilmektedir. : D

Bu program aslında her ASCII karakterinin ondalık değerini iterek her birini yazdırır. Yazarken optimize etmeye çalıştım, bu yüzden istediğimden daha az okunabilir.

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

Mermer, 9 satır, 94 bayt

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

Burada çevrimiçi sınayın. Using spaces for blank cellskontrol edilmeli.

Kaynağın görsel temsili:

Açıklama: Bu programdaki her onaltılık değer, her "tik" de aşağı doğru hareket eder (açık değilse \\, bu durumda sağa doğru hareket eder). ++değeri artıracak, azaltacak --, ~~bitsel olarak uygulayamayacaksınız, vb. alttan düşen değerler ASCII karakteri olarak yazdırılır.

Örneğin: 33Üst köşede olur (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 satır

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

Rebol - 15 satır (51 bayt)

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

Rebol'a içinde Sözcükler harf duyarsız (örn. PRINT, PrintVe printhepsi aynı işlevi çağırır).

Yukarıdaki kod toplandı:

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

NB. spboşluk char döndürür !

Unary , 1 satır, çok fazla bayt

Bu programdaki her karakter 0. Kaynak buraya koymak için çok uzun, ancak bu çok sayıda sıfırdan oluşan bir dizgeden oluşuyor:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Bu, bu ikili sayının ondalık gösterimidir:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Bu BrainF *** programından oluşturulmuş olan:

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

Nasıl ürettiğimi görün: http://ideone.com/lMT40p

Toplu İş - 39 Satır (202 bayt)

Düğmeyi cmdkullanarak bir çağrının içindeki kodu çalıştırarak geciktirilmiş genişlemeyi etkinleştirerek boyutu azaltmak istedim /v on, ancak tüm atmaları geçemedi.

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

Newlines olmadan (ve newlines'tan kaçmak için karatlar):

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

Ruby, 19 satır, 95 bayt

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

Muhtemelen Ruby I için ikinci en zor kod kısıtlama ucube sonra, bu sitede gördüğüm burada .

Açıklama için düzenle: Sıralanan tek Ruby çıktı <<yöntemi, STDOUT'daki yöntemdir. Ne yazık ki, STDOUT için sabit $>, >çoğu sembolden daha ASCII'dir ve daha yüksektir, bu nedenle üzerinde bir yöntem çağırmak gerçekten mümkün değildir. Daha izlenebilir bir değişken ismine almak için çok satırlı bir atama deyimine ihtiyacımız var, $;(noktalı virgül hala oldukça yüksek, ancak bu formun değişkenleri atanamazlar veya sadece dizgiler olabilir).

Semboller ( :Wor, vb.) Değişmezi yapmanın en kolay yoludur ve bir dizgiden yeni satırları çıkarmanın bir yolunu göremiyorum, bu yüzden birden çok yazdırma deyimine ihtiyacım var. Boşluk ve noktalama işaretleri bir kelimenin tam anlamıyla sembolize edilemez, ancak neyse ki chrsayılardaki yöntem yasaldır, bu yüzden ASCII değerinden bir karakter alabilirim. ::arama yöntemlerinin alternatif bir yoludur. Uzay çok zor çünkü yazamıyorum 32, bu yüzden 1'den 33'ü çıkarıp değişkene atayım.

Retina, 12 satır, 29 bayt (rakipsiz)

Dil zorluktan daha yeni.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Çevrimiçi deneyin