Hello World 0,0!


78

Dilbert luar biasa
sumber: Dilbert, 8 September 1992

Saya berharap untuk menambahkan sentuhan baru pada lagu klasik "Hello World!" program.

Kode program yang dihasilkan Hello World!tanpa:

  • String / Karakter literal
  • Bilangan (basis apa saja)
  • Fungsi pra-dibangun yang mengembalikan "Hello World!"
  • Literal RegEx

Dengan pengecualian "O" dan 0.

† "O" dikapitalisasi, "o" tidak dapat diterima.


4
Tolong, salah satu dari [kode-golf] dan [kode-tantangan], bukan keduanya. Maksud dari tag ini untuk membantu orang menemukan pertanyaan dengan aturan yang ingin mereka gunakan. Pada dasarnya setiap pertanyaan di situs ini harus berupa permainan atau sejenisnya.
dmckee

4
-1 Kami sudah mengaburkan Hello World , dan saya pikir tantangan ini terlalu mirip. Saya akan memberikan suara "sedekat duplikat", jika saya bukan mod.
Chris Jester-Young

2
@zzzzBov: Saya rasa itu tidak cukup berbeda untuk menjamin pertanyaan lain dalam tema "hello world"; tema yang berbeda akan lebih baik. Tapi, itu hanya pendapat saya.
Chris Jester-Young

1
Saya pikir ini adalah kode golf yang bagus - dan lebih baik dari yang sebelumnya.
MtnViewMark

2
Beberapa orang tampaknya berasumsi bahwa itu "O"*berarti mereka dapat memiliki string literal dengan sejumlah O, termasuk nol. Saya kira itu bukan niatnya. Mohon klarifikasi.
Timwi

Jawaban:


83

Windows PowerShell, terlalu banyak

Ya, memang, pada hari kami harus menulis »Halo dunia« menggunakan (hampir secara eksklusif) nol ...

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

Pada catatan yang lebih serius:

Windows PowerShell, 25

Write-Host Hello World!

Tidak ada string literal. Di Hello World!sana kebetulan diurai sebagai string karena PowerShell berada dalam mode parsing argumen di sana.


2
Bagaimana itu nyata ?? O_o
Josh

1
Saya mencari di internet untuk beberapa contoh atau sejarah ini. Ini sangat aneh. Bisakah Anda memberikan tautan?
Caleb Jares

1
"Kembali pada hari". :) Anda kaum milenium membuat saya bingung crack

Oh Unary. Saya mengerti.
Matius Roh

86

C, 327 karakter

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Anehnya, ia tidak kehilangan kecantikannya setelah preprocessing:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}

2
Luar biasa. Kehilangan !,
Mark Reed

1
Ini seni asli!
Askaga

Saya merasa seperti tubuh dapat dipersingkat dengan lebih banyak preprosesor. Tidak yakin apakah kode secara keseluruhan akan diuntungkan.
Zwei

@ Zwei, Pasti mungkin untuk mempersingkatnya. Saya tidak berusaha menemukan set makro yang optimal.
ugoren

Mengapa Anda tidak memasukkan parens di #Define CLANG? akan menghemat beberapa byte, bukan? Sunting: Nevermind, baru saja mencoba dan sekarang saya mengerti mengapa itu tidak berhasil ahaha
Albert Renshaw

52

BrainFuck, 102 111 karakter

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

Memenuhi semua aturan.

Penghargaan untuk Daniel Cristofani .


1
Saya tidak bisa memutuskan apakah aturannya juga harus menyatakan 0 and/or "O" must be used. Ini agak kejam bagi BrainFuck dan skrip golf, tetapi mereka sebenarnya tidak mengalami kesulitan dengan tantangan ini.
zzzzBov

34
@zzzzBov: Jika harus digunakan, maka kode Brainfuck hanya akan memasukkannya. Mereka tidak mempengaruhi program sama sekali.
Joey

38

C, 182 byte

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}

1
+1, Lol, Anda masih menggunakan trik operator tempel token! Sobat yang baik :-)
Quixotic

35

Program C - 45

(curang)

Selain itu, ini tidak menggunakan string literal atau regex literal. Itu mengambil keuntungan dari fitur pengerasan dari preprocessor C. s(x)adalah makro yang mengubah argumennya menjadi string.

#define s(x)#x
main(){puts(s(Hello World!));}

3
Untuk gagasan yang sangat nyaman "leksikal" :) Tapi cheekiness FTW!
JB

24

Haskell - 143 karakter

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

oy, itu berbulu!

Tidak ada angka, tidak ada operasi numerik, variabel diubah namanya menjadi hiburan.

Beberapa eksposisi mungkin bagus:

  • o%y, o&y, Dan o!ymasing-masing berlaku fungsi ountuk ybeberapa kali: 3, 9, dan 29 kali masing-masing. 29?!?! Ya, 29!
  • rdan wmerupakan karakter berikutnya dan sebelumnya, yang bila diterapkan menggunakan fungsi tingkat tinggi di atas dapat dibuat untuk mendapatkan semua karakter yang dibutuhkan 'O'.

Urutan lompatan yang dibutuhkan adalah:

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '

  • Sunting: (134 -> 144) Lupa untuk mengeluarkan tanda seru, huh ....
  • Sunting: (144 -> 143) Menghapus yang tidak perlu $, diganti namanya #menjadi !untuk Hugs.

1
ya? oo ....
Joey Adams

Itu tidak bekerja. codepad.org/lyKyj1Ox
nyuszika7h

@ Nyuszika7H Itu karena layanan ini mengaktifkan beberapa opsi kompiler secara default. Itu harus dikompilasi dengan GHC biasa.
FUZxxl

@ Nyuszika7H Berhasil dengan GHC. Masalahnya adalah bahwa layanan tersebut menggunakan Hugs mulai tahun 2006. Tampaknya ada dua hal yang tidak dapat ditangani oleh Hugs: 1) Menggunakan '#' sebagai operator. Mengubah ke '!' membuatnya bekerja. 2) Definisi r=succdan w=predmenjalankan pertentangan tentang bagaimana Hugs mengimplementasikan pembatasan monomorfisme. Mengubah ke r x=succ xdan w x=pred xmembuatnya berfungsi (dengan biaya 4 karakter). Ini tampaknya menjadi masalah dalam Pelukan.
MtnViewMark

Apakah masih valid setelah edit @Community?
Hosch250

22

Unary , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 byte

Saya terkejut bahwa belum ada yang melakukan ini ...

Terlalu panjang untuk memposting di sini, tapi ini adalah 1137672766964589547169964037018563746793726105983919528073581559828 nol.

Atau, lebih mudah dibaca: ~ 10 67 nol.

Terima kasih kepada @dzaima karena telah menghemat 10 197 byte


2
Ketika saya membaca "Saya pernah menulis seluruh database hanya menggunakan nol", pikiran pertama saya adalah "dia pasti melakukannya di unary". 1 untuk menjadi satu-satunya jawaban untuk bekerja persis seperti yang dilakukan komik itu
Cyoce

21

Mathematica 12 karakter

Hanya simbol, tanpa string.

Hello World!   

Itu! adalah operator faktorial, tetapi karena simbol Hello and World tidak terdefinisi, mengembalikan input tidak berubah.

Jika kita memodifikasi program sedikit:

Hello=2;
World=3;
Hello World!  

Kemudian ia mencetak 12(2 * 3!)


16

perakitan i386 (Linux, sintaks gcc), 440 442 435

Hari ini adalah hari kebaktian saya, dan setelah itu saya akan merasa cukup untuk sementara waktu. Saya mengizinkan diri saya nomor 128, lihat program di bawah ini untuk pembahasan mengapa. Tidak ada yang luar biasa: Saya hanya menyandikan "Hello World!" sebagai opcodes perakitan di mana itu masuk akal tanpa konstanta numerik, dan diisi sisanya dengan aritmatika.

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

(berkumpul dengan gcc -nostartfiles hello.S -o hello, mungkin -m32tergantung pada lengkungan Anda)

Mengapa toleransi untuk 128? Saya perlu syscalls untuk benar-benar menunjukkan apa pun; Syscall Linux menggunakan INT 80h (128 desimal); satu-satunya format operan untuk INT adalah langsung, jadi tidak mungkin untuk memiliki selain konstanta (ke kode) di sana. Saya bisa (setelah saya sadar) mencoba untuk mengungkapkannya sebagai fungsi konstanta simbolik lain dalam kode, mungkin n , tapi itu menjadi sangat membosankan karena tidak banyak mendapatkan. Saya membaca batasan angka sebagai cara untuk mencegah pengkodean ASCII, dan itu jelas bukan yang saya lakukan di sini, jadi saya merasa cukup tidak bersalah untuk mengirimkan ini. (FWIW, saya juga mencoba kode modifikasi diri, tapi itu segfaulted) Sekarang tidak ada 128 yang tersisa juga. Kodenya murni!

  • Edit1 diformat ulang untuk menyimpan garis; menghapus angka 1 (tidak ada yang memperhatikan ?!)
  • Edit2 dikompresi movdengan makro CPP; menghilangkan sisa 128.

6
Beginilah cara pria sejati memprogram.
Nit

14

Javascript - 305

Agak panjang tapi saya suka metode yang digunakan.

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))

Saya suka itu. Akan lebih baik dengan parameter fungsi sebagai OO, OOO, tapi tentu saja itu akan membuatnya lagi.
zzzzBov

Sangat bagus. Apakah 'String baru ()' harus ada di sana pada akhirnya? Tampaknya bekerja tanpa itu.
Stephen Perelson

3
Ah, tidak. Terkadang saya lupa betapa lemahnya mengetik Javascript.
david4dev

Anda tidak perlu meninggalkan 0 bit ('0+'), dan spasi dan tanda seru memiliki dua 0 bit tersisa. Total pengurangan 28 karakter.
Stephen Perelson

10

C # (131 karakter)

141 chars 142 chars

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

Dapat dibaca:

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}

2
ini bengkok dan bagus. Aku menyukainya.
jcolebrand

+1 cara yang bagus untuk menghasilkan angka-angka tertentu. Harus ingat itu!
Igby Largeman

Program LINQPad, 102 karakter:enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
Cœur

.ToString()-> +""menyimpan beberapa cahrs
Firo

2
@ Firo: ... dan melanggar aturan. (Tidak ada literal string yang diizinkan.)
Timwi

8

JavaScript, 88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

Terima kasih banyak kepada @Timwi atas sarannya

operator ternary dihapus:

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
aliasString.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117
Beralih jika-lain ke operator ternary

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
Saya menjaga orang-orang yang "O"adil untuk memiliki "O" dalam program.

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)

@ Joey, itu intinya.
zzzzBov

@ Joey, saya membaca meta codegolf bahwa seseorang harus menghindari menjawab pertanyaan mereka sendiri untuk beberapa waktu untuk mendorong orang lain untuk mencoba berbagai pendekatan yang berbeda. Rencana saya adalah menghapus komentar dalam satu atau dua hari.
zzzzBov

@ Joey, tidak bekerja pada mesin saya sendiri pada saat itu, dan saya tidak merasa ingin mengirim sendiri jawaban kepada saya ketika saya bisa mempostingnya dalam komentar.
zzzzBov

@ Joey: "Hanya ada lima dari mereka" salah. Siapa pun dapat menyarankan suntingan. Cukup klik pada "edit" antara "tautan" dan "bendera" dan Anda dapat melihat kodenya.
John

@zzz: "itulah intinya" Siapa pun masih bisa melihatnya. Siapa pun dapat menyarankan suntingan dengan mengklik "edit" di antara "tautan" dan "bendera", yang akan memunculkan dialog edit, mengungkapkan kode Anda.
John

7

GolfScript, 63 karakter

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

Apa, belum ada entri GolfScript?

Yang ini menggunakan literal numerik tunggal 0dan variabel bernama O(yang digunakan untuk menyimpan nomor 3). Yang lainnya adalah manipulasi aritmatika dan stack. String Hello World!dibangun dari kode ASCII-nya, karakter demi karakter.

Begini cara kerjanya:

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string

7

Brainfuck, 111 byte

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

Algoritma menjelaskan

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

Versi lebih lama tanpa loop, 389 byte:

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

Ini adalah puzzle kode-golf, intinya adalah membuat program sesingkat mungkin. Bagian dari itu melibatkan memposting panjang kode Anda.
zzzzBov

5

Lua 144 97 86 karakter

Pendekatan yang berbeda, berdasarkan pada fakta bahwa kunci tabel juga adalah string, dan fakta bahwa #Hello == #World == 32 == string.byte '\ n'

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

145 solusi char

  • tidak ada string kecuali "O" atau 0
  • tidak ada Regex
  • tidak ada fungsi yang dibangun sebelumnya

Apakah delta encoding dari byte, kemudian beberapa primenumber dll :)

Versi golf:

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

Berkomentar:

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

Sunting: Mengubah beberapa string O, dan menemukan beberapa optimalisasi yang lebih.


"O" * - Saya pikir * adalah untuk catatan kaki, bukan "sejumlah O
RomanSt

Ya, regexing adalah apa yang secara alami saya lakukan: hlm. Bisa menggantinya dengan biaya 5 atau 3 karakter tambahan untuk masing-masing solusi pertama dan kedua
jpjacobs

Tapi bagaimanapun, saya akan mengeditnya, terima kasih untuk kepala
jpjacobs

Halo dan World in table constructor masih berupa string literal - itu hanya gula sintaksis.
Oleg V. Volkov

5

Python ( 126 130)

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])

Secara literal ''tidak diizinkan.
RomanSt

1
@romkyns: Sangat benar, sudah diperbaiki.
Hoa Long Tam

5
Tidak diperbaiki (output salah). Anda mungkin memikirkan [:0].
WolframH

5

J, 250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

Saya terlalu banyak bersenang-senang dengan yang ini, dan saya belajar sedikit lebih banyak untuk boot. Juga, ooo ooo ooomungkin kode paling bodoh yang pernah saya tulis.


5

QR dengan halfblocks (169) 121 karakter

Dengan QR-Code dengan menggunakan karakter setengah blok UTF-8:

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

Sayangnya, ini tidak akan ditampilkan dengan baik di sana. Ada potongan kecil dengan style sheet yang sesuai, tapi .. Tidak! Bahasa yang disajikan di sini bukan HTML! Bahasa yang disajikan di sini adalah QR Code ! (HTML dan CSS digunakan di sini hanya untuk mengatasi bug presentasi!)

QR dengan halfblocks (169)

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

Idealnya, ini bisa terlihat seperti:

QR: Hello World!


Gunakan ponsel pintar Anda untuk melihat ini atau di zbarbawah linux. (sampel: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri

Bukankah Code golf!karakter literal?
ugoren

2
Saya sebenarnya berpikir jawaban ini, meskipun kreatif, tidak memenuhi syarat karena itu bukan program. QR adalah cara untuk menyandikan data, bukan bahasa pemrograman.
ugoren

1
Juga bagaimana dengan bahasa seperti postscript, svgatau bahasa presentasi lain yang sudah digunakan di sana !? Sebuah cara untuk encode adalah bahasa pula ... saya pikir!
F. Hauri

1
Saya menggunakan HTML (minus JS) sebagai contoh untuk apa yang bukan bahasa. Hal yang sama berlaku untuk QR. Lihat kriteria ini .
ugoren

4

Scala ( 357 423 361 karakter)

Bukan jawaban terpendek, sayangnya, tetapi berharap untuk mendapatkan nilai bonus untuk penggunaan 'O'dan'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

Sebelumnya:

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

Versi lama (ilegal):

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}

Saya percaya string kosong ( "") dan string / karakter literal yang berisi karakter nol ( '0') tidak diperbolehkan. Hanya string "O"(modal O) dan jumlahnya 0.
Timwi

Bersetubuh. Diperlukan beberapa pengeditan ...
Gareth

4

C (atau C ++) (segmen tubuh: 49) (curang)

saat kompilasi, kompilasi ke biner yang dipanggil Hello\ World\!, kode tersebut adalah:

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

The strrchrsegmen diperlukan untuk menghapus path lengkap di ajang nama program berlalu di berisi path lengkap, juga tidak ada argumen harus dilalui dalam ..

Baris kompilasi umum dapat: gcc -o Hello\ World\! foo.c


3

C ++, 141, 146

Pertama kali mencoba salah satunya, mungkin bisa sedikit ditingkatkan:

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

SUNTING:

Mencuri trik membagi dari pos lain, tidak percaya saya tidak memikirkan itu :(


1
Anda secara teknis seharusnya memasukkan seluruh program kerja dalam jumlah karakter, termasuk hal-hal seperti utama, semua perpustakaan yang disertakan std::, dll.
Wug

3

Haskell - 146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

Saya pikir pencocokan pola akan memberikan Haskell kaki besar, khususnya karena Anda dapat menginisialisasi kekuatan dua seperti:

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

Namun, seperti yang terlihat pada jawaban Haskell dari MtnViewMark (yang pantas mendapatkan banyak upvotes, dan jawaban lainnya), kompresi yang lebih baik dapat dicapai dengan menggunakan lebih dari sekadar +dan -.


3

Clojure - 46 karakter

(map print(butlast(rest(str'(Hello World!)))))

Catat itu Hellodan World!merupakan simbol, bukan literal apa pun.


3

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}

1
The 100melanggar aturan tentang angka. Silakan ganti dengan sesuatu yang lebih lucu.
Joey Adams

@ joey-adams Terima kasih telah menunjukkan. Mengubahnya.
fR0DDY

Line 7: error: ISO C++ forbids declaration of 'main' with no type
Nathan Osman

@ george-edison Dikoreksi. Meskipun bekerja tanpa intpada g ++
fR0DDY

3

PHP - 49 karakter

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

Changelog :

  • (73 -> 86) Lupa mengeluarkan tanda seru ... huh
  • (86 -> 57) Menggunakan variabel tunggal dengan penambahan
  • (57 -> 51) Diubah untuk menggunakan operator bitwise pada 0
  • (51 -> 49) Lebih banyak operator bitwise

1
Cukup yakin bahwa konstanta akan dihitung sebagai string literal karena konversi.
Kevin Brown

@ Bass5098 Terima kasih atas hasil edit Anda! Saya menyetujuinya.
nyuszika7h

@ Bass5098 tidak berfungsi, Anda harus memiliki karakter 32 dan 33, bukan 21 dan 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);berfungsi, tetapi 54 karakter.
zzzzBov

@zzzzBov Saya tidak tahu cara menghapus edit pada awalnya, dan lupa untuk mengembalikannya setelah disetujui.
Kevin Brown

wah, saya meninggalkan 1di sana. Di sana saya melanggar aturan saya sendiri ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);adalah apa yang seharusnya saya gunakan, masih 54 karakter.
zzzzBov

3

Python, 106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])

Gunakan '' (tanpa spasi sebelumnya) alih-alih str ()
aditsu

2
Juga, sangat bagus! :) Btw, tugas ganda tidak menyimpan karakter apa pun
aditsu

@ Aditsu: Saya tidak bisa, itu akan menjadi string literal. Terima kasih atas komentar anda :)
flornquake

Oh oops, entah bagaimana string kosong itu tidak terdaftar sebagai literal dalam pikiran saya
aditsu

3

Perl, 186 byte

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

Setiap karakter dicetak melalui nomor urutnya, yang merupakan panjang array. Konstruksi array dioptimalkan melalui representasi biner dari nomor karakter.

Tidak Terkumpul:

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1

Tampaknya vodoo biner saya menginspirasi Anda :) +1
masterX244

3

Java 389 karakter

melihat deklarasi yang tidak perlu

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

Riwayat ada dalam riwayat sunting sekarang versi ungolfed asli dapat dibaca:

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }

3

Perl 6 , 199 byte

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

(baris baru ditambahkan untuk mengurangi lebar, tetapi tidak perlu jadi tidak dihitung)


Hello World! dikodekan sebagai daftar daftar kekuatan 2 setiap huruf.

Tepat ada satu tempat di mana saya memiliki literal 0yang digunakan untuk apa pun selain a 0. Ini digunakan untuk membuat daftar satu elemen, yang segera diubah menjadi nomor 1dengan operator awalan numerik ( +[0]).

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})

3

JavaScript 662 karakter

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

Bagaimana dengan menyalahgunakan array literal hanya untuk memiliki basis unary. Program ini memiliki keuntungan karena tidak digunakan 0.


Meskipun ini mungkin valid, puzzle khusus ini adalah kode golf, yang berarti Anda harus membidik kode sesingkat mungkin. Pada 600+ karakter, Anda tidak berada di dekat <100 karakter yang sudah dimiliki solusi JS.
zzzzBov

1
@zzzzBov: Saya sebenarnya tidak mencoba untuk menang.
Konrad Borowski

1
Program ini memiliki keuntungan karena tidak digunakan 0. Bagaimana dengan O_O=0;?
Erik the Outgolfer

@EriktheGolfer: Diperbaiki, terima kasih. Saya gagal memperhatikan yang itu.
Konrad Borowski

O_O=[].lengthdapat ditulis sebagai O_O=falseyang mengurangi oleh 4.
Atmocreations
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.