출처 : Dilbert, 1992 년 9 월 8 일

고전적인 "Hello World!"에 새로운 변화를주기를 바라고 있습니다. 프로그램.

다음 Hello World!없이 출력되는 프로그램을 코딩하십시오 .

• 문자열 / 문자 리터럴
• 숫자 (모든 기준)
• "Hello World!"를 반환하는 미리 작성된 함수
• 정규식 리터럴

"O" ^† 및 0을 제외 하고.

† "O"는 대문자이며 "o"는 사용할 수 없습니다.

Windows PowerShell, 너무 많은

예, 실제로, 우리는 (거의 독점적으로) 0을 사용하여»Hello world«를 작성해야했습니다 ...

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

더 심각한 참고 사항 :

윈도우 PowerShell, 25

Write-Host Hello World!

문자열 리터럴이 없습니다. 는 Hello World!거기에 단지 할 일이 구문 분석 PowerShell을 이후 문자열이 인수 구문 분석 모드에서와 같이.

C, 327 자

#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))))))))
    ))))))))))))))))))))))))))))))))))))));
}

이상하게도 사전 처리 후 아름다움을 잃지 않습니다.

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

BrainFuck, 102 111 자

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

모든 규칙을 준수합니다.

신용은 다니엘 크리스토 파니 에게 간다 .

C, 182 바이트

#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);}

C 프로그램-45

(속임수)

사 전적으로 이것은 문자열 리터럴이나 정규 표현식 리터럴을 사용하지 않습니다. C 프리 프로세서 의 스트링 화 기능을 활용합니다. s(x)인수를 문자열로 바꾸는 매크로입니다.

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

하스켈-143 자

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]

오, 그거 멍청 아!

숫자, 숫자 연산, 놀이로 이름이 바뀐 변수가 없습니다.

일부 박람회는 좋을 수도 있습니다.

• o%y, o&y및 o!y각각은 함수 o를 각각 y3, 9 및 29 회 여러 번 적용합니다 . 29?!?! 예, 29!
• r및 w사용하여 적용 할 때 위의 고차 기능에서 필요로하는 모든 문자를 얻을 할 수 다음 및 이전의 문자이다 'O'.

필요한 점프 순서는 다음과 같습니다.

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

• 편집 : (134-> 144) 느낌표를 출력하는 것을 잊었습니다.
• 편집 : (144-> 143) 불필요한을 제거하고 포옹으로 $이름 #을 바꿨 습니다 !.

단항 , 10 ¹⁹⁷ 1137672766964589547169964037018563746793726105983919528073581559828 바이트

아직 아무도이 일을하지 않은 것에 놀랐습니다 ...

여기에 게시하기에는 너무 길지만 1137672766964589547169964037018563746793726105983919528073581559828은 0입니다.

또는 더 쉽게 읽을 수 있습니다 : ~ 10 ⁶⁷ 0.

10 ¹⁹⁷ 바이트 를 절약 한 @dzaima에게 감사 합니다

매스 매 티카 12 자

문자열 만없는 기호 만.

Hello World!   

! 는 계승 연산자이지만 Hello 및 World 기호가 정의되지 않았으므로 입력을 변경하지 않고 반환합니다.

프로그램을 약간 수정하면 :

Hello=2;
World=3;
Hello World!  

그런 다음 12(2 * 3!)을 인쇄합니다 .

i386 어셈블리 (Linux, gcc 구문), 440 442 435

오늘은 제 집회 일이었고 그 후로 얼마 동안은 충분했을 것입니다. 나는 128 번을 허용했다. 이유에 대한 논의는 아래 프로그램을 참조하십시오. 특별한 것은 없습니다 : "Hello World!" 숫자 상수없이 의미가 있고 나머지는 산술로 채워진 어셈블리 opcode로.

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

( 아치에 따라으로 조립 gcc -nostartfiles hello.S -o hello가능 -m32)

128의 허용 오차를 사용해야하는 이유는 무엇입니까? 실제로 아무것도 표시하려면 syscall이 필요합니다. Linux syscall은 INT 80h (십진수 128)입니다. INT의 유일한 피연산자 형식은 즉각적이므로 코드에 상수 이외의 것을 가질 수 없습니다. 나는 수 (나는 술을 마시지 얻을 후) 코드, 가능성이있는 다른 기호 상수의 함수로 표현하려고 N ,하지만 점점 매우 별로 이익을 위해 지루한. ASCII 코딩을 방지하는 방법으로 숫자에 대한 제약 조건을 읽었으며 이것이 내가하고있는 일이 아니므로이를 제출할만큼 결백하다고 느낍니다. (FWIW, 나는 또한 자체 수정 코드를 시도했지만 그 segfaulted) 이제 128도 남지 않았습니다. 코드는 순수합니다!

• Edit1은 줄을 저장하기 위해 다시 포맷되었습니다. 숫자 1을 제거했습니다 (아무도 눈치 채지 못했습니까?!)
• movCPP 매크로로 압축 된 Edit2 ; 나머지 128을 제거했습니다.

자바 스크립트-305

조금 길지만 사용 된 방법이 마음에 듭니다.

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

C # (131 자)

141 자 142 자

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);}}

읽을 수있는 :

// 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);
    }
}

자바 스크립트, 88

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

99

제안에 대한 @Timwi에게 많은 감사

삼항 연산자 제거 :

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

별명 103String.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
if-else를 3 진 연산자로 전환

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 프로그램에 "O"를
유지 "O"하려고합니다.

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)

GolfScript, 63 자

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

아직 GolfScript 항목이 없습니까?

이것은 하나의 숫자 리터럴 0과 변수를 O사용합니다 (이는 숫자를 저장하는 데 사용됩니다 3). 다른 모든 것은 산술 및 스택 조작입니다. 문자열 Hello World!은 문자별로 ASCII 코드로 구성됩니다.

작동 방식은 다음과 같습니다.

[             # 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

Brainfuck, 111 바이트

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

알고리즘 설명

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!'

루프없는 긴 버전, 389 바이트 :

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

루아 144 97 86 자

테이블 키도 문자열이라는 사실과 #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 자 솔루션

• "O"또는 0을 제외한 문자열 없음
• 정규식 없음
• 사전 구축 된 기능 없음

바이트의 델타 인코딩, 소수 등 등 :)

골프 버전 :

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

댓글 :

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

편집 : 여러 O 문자열을 변경하고 더 많은 최적화가 발견되었습니다.

파이썬 ( 126130 )

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

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

나는 이것으로 너무 재미 있었고 부팅 할 J를 조금 더 배웠다. 또한 ooo ooo ooo내가 작성한 가장 바보 같은 코드 일 수도 있습니다.

하프 블록이있는 QR (169) 121 자

UTF-8 하프 블록 문자를 사용하여 QR 코드 사용 :

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

불행히도, 이것은 훌륭하게 렌더링되지 않습니다. 적절한 스타일 시트가 포함 된 작은 스 니펫이 있지만 .. 아니요! 여기에 제시된 언어는 HTML 이 아닙니다 ! 여기에 제시된 언어는 QR 코드입니다 ! (HTML 및 CSS는 여기에서 프리젠 테이션 버그를 해결하기 위해서만 사용됩니다!)

 body {
    font-family: monospace;
    line-height:97%;
 }

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

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

아이디어는 다음과 같습니다.

스칼라 ( 357 개 423 361 문자)

아니 짧은 대답은 불행하게도하지만, 가장 사용하기위한 보너스 점수를 얻을 수 있었으면 'O'하고'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)}

이전 :

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

이전 (불법) 버전 :

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

C (또는 C ++) (본문 세그먼트 : 49) (속임수)

컴파일 할 때 이진으로 컴파일 Hello\ World\!하면 코드는 다음과 같습니다.

#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);
}

strrchr세그먼트는 전달 된 프로그램 이름은 전체 경로도 포함하는 경우에 전체 경로를 제거하는 데 필요한 인수가 전달되지해야합니다 ..

일반적인 컴파일 라인은 다음과 같습니다. gcc -o Hello\ World\! foo.c

C ++, 141, 146

이 중 하나를 처음 시도하면 아마 약간 개선 될 수 있습니다.

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;

편집하다:

다른 게시물에서 나누는 속임수를 훔쳤습니다.

하스켈-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

나는 패턴 매칭이 Haskell에게 큰 다리를 줄 것이라고 생각했습니다. 특히 2의 거듭 제곱을 초기화 할 수 있기 때문입니다.

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

에서 볼 그러나 MtnViewMark의 하스켈 응답 (그런데, 많은 많은 upvotes을받을 권리)과 다른 답변, 더 나은 압축은보다 사용에 의해 달성 될 수있다 +및 -.

클로저-46 자

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

그 참고 Hello하고 World!, 어떤 종류의 리터럴 상징이 아니다.

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);
}

PHP – 49 자

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

변경 내역 :

• (73-> 86) 느낌표 출력을 잊었습니다 ... 한숨
• (86-> 57) 증가와 함께 단일 변수를 사용합니다
• (57-> 51) 0에서 비트 연산자를 사용하도록 변경되었습니다.
• (51-> 49) 더 비트 연산자

파이썬, 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,_])

펄, 186 바이트

@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]

각 문자는 배열의 길이 인 서수를 통해 인쇄됩니다. 배열의 구성은 문자 번호의 이진 표현을 통해 최적화됩니다.

언 골프 드 :

@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

자바 389 자

불필요한 선언을 발견했다

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),_});}}

히스토리는 편집 히스토리에 있으며 이제 원본 언 골프 버전을 읽을 수 있습니다.

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

펄 6 , 199 바이트

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**@_})

(줄 바꾸기는 너비를 줄이기 위해 추가되지만 필요하지 않으므로 계산되지 않습니다)

Hello World! 각 문자의 2의 거듭 제곱 목록으로 인코딩됩니다.

내가 0아닌 다른 용도로 사용되는 리터럴이있는 곳이 정확히 하나 있습니다 0. 단일 요소 목록을 작성하는 데 사용되며 1숫자 접 두부 연산자 ( +[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**@_})

자바 스크립트 662 자

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

단항 기지를 갖기 위해 배열 리터럴을 남용하는 것은 어떻습니까? 이 프로그램은를 사용하지 않는 이점이 있습니다 0.