hello world 문자열 ( "Hello world", "Hello, World"등) 및 소스 코드를 출력하는 프로그램을 작성하십시오. 출력은 stdout 또는 이와 동등한 것으로 작성됩니다. Hello world string은 소스 코드에 포함되어 있습니다.

예를 들어에 대한 출력은

(some source code here)hello world(some source code here)

출력을 다시 컴파일하거나 해석 할 때 비슷한 출력을 작성해야하지만 hello world 문자열은 다른 문장 부호 또는 대문자를 사용해야합니다. 예를 들어 앞의 예는 다음과 같은 출력을 만들 수 있습니다.

(some source code here)hello, wORld(some source code here)

이 예제에서 각 "(일부 소스 코드)"는 각 실행 후 변경되거나 동일 할 수 있습니다.

출력에는 유효한 hello world 문자열이 정확히 한 번만 포함되어야합니다. 유효하지 않은 hello world 문자열을 포함 할 수 있습니다. 소스 코드는 많은 양의 주석을 포함 할 수 있으며 hello world 문자열은 주석에 포함될 수 있습니다. 첫 번째 프로그램은 0 개 또는 1 개의 유효한 hello world 문자열을 가질 수 있지만 더 이상은 없습니다.

다음 문장 부호가 유효합니다.

hello, world
hello world
helloworld

모든 대문자를 사용할 수 있습니다. 예를 들어, 다음은 유효한 hello world 문자열입니다.

Hello, world
hellO WORld
HELLoworlD

이 문자열은 유효하지 않습니다 :

Hello     world
Hello(newline)world
Hello,world
Hello, Steve

다음 조건 중 하나가 충족되면 프로그램이 실패합니다.

• 초기 실행 중에 출력 된 hello world 문자열을 출력합니다.
• 출력이 더 이상 동일한 언어로 유효한 소스 코드가 아니거나
• 출력에는 정확히 하나의 유효한 hello world 문자열이 포함되지 않습니다.

최소 두 번의 첫 실행이 성공하지 않으면 귀하의 프로그램이이 콘테스트에 유효하지 않습니다. 이것은 세 번째 출력이 유효하지 않다는 것을 의미합니다. 프로그램의 출력은 무작위가 아닐 수 있습니다. 첫 번째 실행은 항상 동일한 두 번째 출력을 작성하고 두 번째 실행은 항상 동일한 세 번째 출력을 작성해야합니다.

점수는 초기 프로그램의 소스 코드에서 바이트 수로 계산됩니다. 최저 점수가 이깁니다.

다음 보너스가 적용됩니다 (최대 -60 %).

• -5 % * (N-2). 여기서 N은 프로그램이 유효하지 않은 출력을 생성 한 이후의 실행 색인입니다. 이 보너스 한도는 -50 %입니다. 프로그램이 12 회 이상 성공하면 최대 보너스를받습니다.
• 출력 (첫 번째 소스 코드 포함)에 3 가지 유효한 구두점 대안이 모두 포함 된 경우 -10 %

제출물에는 첫 번째 소스 코드가 포함되어야하며 성공적인 실행 결과도 포함되어야합니다. 프로그램이 12 회 이상 성공하면 12 회 실행에 대한 출력을 추가하십시오.

예

다음 줄은 첫 번째 소스 코드입니다. 우리가 그것을 실행할 때, 그것은 첫 번째 실행입니다.

hello world(some source code here)

다음 줄은 첫 번째 소스 코드 코드의 출력입니다. 첫 번째 출력입니다.

hello, world(some source code here) 

다음 줄은 두 번째 실행의 출력입니다. 두 번째 출력입니다.

helloworld(some source code here)

첫 번째 출력을 실행했을 때이 프로그램은 -10 % 보너스를받을 수있게되었습니다. 즉, 문장 부호가 서로 다른 두 개의 출력과 하나의 원본 코드가 있습니다. 또한 두 번째 결과물이 유효하기 때문에이 프로그램은이 콘테스트에 참가할 수 있습니다.

다음 줄은 세 번째 실행의 출력입니다. 세 번째 출력입니다.

Helloworld(some source code here)

다음 줄은 네 번째 실행 결과입니다. 네 번째 출력입니다.

hellworld(some source code here)

이 출력은 유효하지 않습니다. 이 프로그램은 유효한 -5 % * (4-2) 보너스와 문장 부호에서 -10 % 보너스를받을 수 있습니다. 이것은 총 -20 %입니다. 첫 번째 소스 코드 ( "hello world (여기 소스 코드)")의 길이는 34 바이트이므로 최종 점수는 27.2입니다.

Pyth, 17 바이트

다른 Pyth 솔루션 :

"r\"helloworld\"1

산출:

r"helloworld"1

두 번째 출력 :

HELLOWORLD

수학, 214-50 % = 107 바이트

(a = Characters[StringJoin["helloworl", "d"]]; b = Apply[StringJoin, Tuples[Transpose[{a, ToUpperCase[a]}]], {1}]; StringReplacePart[ToString[#0, InputForm], b[[FirstPosition[b, "helloworld"] + 1]], {180, 189}]) & 

여기에서 문자열 수를 최적화하기로 결정했습니다. 이것은 대문자와 소문자의 모든 조합을 거치지 않고 1024 개의 프로그램에서 실행됩니다. 실행은 여기에서 볼 수 있습니다 .

Vitsy, 33-33 * .05 * (11-2) = 18.15 바이트

응! 이길! 당신은 아마 할 것입니다. :씨

첫 번째 출력 :

'0DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworld
'문자열로 캡처 시작
 0DV 0을 스택으로 밀고이를 최종 변수로 설정합니다.
    \ 다음 항목을 여러 번 반복하십시오. (출력에서 1, 2, 3 ...)
     {스택을 왼쪽으로 돌립니다.
      25 ^ 32를 스택으로 밉니다.
         -상단 항목을 빼면 소문자가 대문자가됩니다.
          V \ 다음 항목 최종 변수 시간을 수행하십시오.
            } 스택을 오른쪽으로 돌립니다.
             } 그리고 다시...
              1+를 추가하십시오. 이것은이 코드에서 0을 1, 2로 만듭니다 ...
                r 스택을 뒤집습니다.
                 d3 * 캐릭터를 얻는다
                    Z 스택의 모든 항목을 출력합니다.
                     ; 실행을 종료합니다.
                      helloworld 조작 할 문자열입니다.

두 번째 출력 :

'1DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworlD

세 번째 출력 :

'2DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloworLD

네 번째 출력 :

'3DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowoRLD

다섯 번째 출력 :

'4DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellowORLD

여섯 번째 출력 :

'5DV \ {25 ^ -V \}} 1+ {rd3 * Z; helloWORLD

일곱 번째 출력 :

'6DV \ {25 ^ -V \}} 1+ {rd3 * Z; hellOWORLD

여덟 번째 출력 :

'7DV \ {25 ^ -V \}} 1+ {rd3 * Z; helLOWORLD

아홉 번째 출력 :

'8DV \ {25 ^ -V \}} 1+ {rd3 * Z; heLLOWORLD

열 번째 출력 :

'9DV \ {25 ^ -V \}} 1+ {rd3 * Z; hELLOWORLD

열한 번째 출력 :

': DV \ {25 ^ -V \}} 1+ {rd3 * Z; HELLOWORLD

오류가 발생하므로 마지막 출력입니다.

CJam, N = 3 (4), 28 바이트 - 10 % - 10 % = 22.4

{`_E=-"_~Hello!, World"2<}_~

이것은 다음 체인을 시작합니다 :

{`_E=-"_~Hello, World"2<}_~
{`_E=-"_~Hello World"2<}_~
{`_E=-"_~HelloWorld"2<}_~
{`_E=-"_~Helloorld"2<}_~

마지막 것은 더 이상 유효한 "Hello, World"를 포함하지 않습니다.

여기에서 테스트하십시오.

설명

{`     e# Quine framework. Leaves a string representation of the block on the stack.
  _E=  e# Make a copy and get the 14th element, which is the character of the first 'o'.
  -    e# Remove that character from the string.
  "_~Hello!, World" e# Push this string, so the "Hello, World!" is part of the code.
  2<   e# Truncate to just "_~" to get the output right.  
}_~

초기 프로그램에는 유효한 "Hello, World"가 포함되어 있지 않지만 한 번 더 반복 할 수 있습니다.

CJam 69 60-50 % = 30

저는 아직 초보자입니다. CJam에서 골프를 치는 방법을 알려주십시오.

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~

99 개의 반복에 유효하므로 각 반복을 인쇄하는 것이 지루합니다.

hello 단어의 대문자를 열거하여 작동합니다. tedium은 "hello world"와 카운터를 모두 업데이트해야하므로 문자열을 여러 부분으로 나누는 것입니다.

설명

{`_40>\40<_38>~)`2Te[\25<"helloworld"00YbATe[.{{el}{eu}?}`+]W%"_~"}_~
{`                                                                      e# standard quine framework. Thanks for Dennis.
  _40>                                                                  e# get the Yb11..
      \40<                                                              e# get those that not included in top
          _38>~)`2Te[                                                   e# get the accumulator and increment it
                     \25<                                               e# get those before "hello world"
                         "helloworld"                                   e# the Hello World
                                     00                                 e# accumulator
                                        YbATe[                          e# convert to binary and align right.
                                              .{{el}{eu}?}              e# Uppercase if the corresponding bit is 0
                                                          `             e# add quote
                                                           +]W%         e# reorder stack
"_~"}_~

참고 : Mathematica 답변을 읽지 못했습니다. 미안합니다. 원래라고 생각합니다.

재정렬과 다른 대문자로 9 바이트를 잃습니다.

{`_6<\"helloworld"01YbW%.{{eu}{el}?}`\I>_2<~)`2Te[\2>"_~"}_~
{`                                                   "_~"}_~ e# Standard quine framework
  _6<\                                                       e# Get "{~_6<\"
      "helloworld"                                            e# The helloworld
                  01                                          e# The accumulator
                    Yb                                        e# Convert to base 2
                      W%                                      e# Reverse the binary
                        .{{eu}{el}?}                          e# Convert to uppercase while the corresponding bit is 1.
                                    `                         e# Add quote
                                     _2<                      e# Get accumulator
                                        ~)`2Te[               e# Increment the accumulator
                                               \2>            e# get the rest

CJam 73-60 % = 29.2

이번에는 구두점도 열거합니다.

{`:Z6<"HELLOWORLD"0:AYbW%.{{eu}{el}?}`", ":B-_6<BA3%>@6>A)ZW%52<W%"_~"}_~
{`:Z                                                              "_~"}_~ e# Standard Quine Framework
    6<                                                                    e# take the first 6 character
      "HELLOWORLD"                                                        e# Hello, world
                  0:A                                                     e# Accumulator
                     YbW%.{{eu}{el}?}`                                    e# See above
                                      ", ":B                              e# Punctuation
                                            -                             e# Delete punctuation
                                             _6<                          e# "hello
                                                BA3%>                     e# punctuation
                                                     @6>                  e# world"
                                                        A)                e# incremented accumulator
                                                          ZW%52<W%        e# Remaining part

GolfScript, 35 바이트-50 % = 17.5

0"HelloWorld"{@@{^.32&\}%`@".~"}.~

반복하기 전에 처형 횟수를 과잉으로 결정했습니다. 이 프로그램은 출력을 GolfScript 인터프리터로 피드백 하여 첫 반복 전에 890 개의 Hello World 문자열을 생성 합니다. 간단한 샘플로 다음은 처음 15 개의 반복입니다.

0"HelloWorld"{@@{^.32&\}%`@".~"}.~
0"HeLlOWoRlD"{@@{^.32&\}%`@".~"}.~
0"HelLOWorLD"{@@{^.32&\}%`@".~"}.~
0"HeLLOWoRLD"{@@{^.32&\}%`@".~"}.~
0"HellowORLD"{@@{^.32&\}%`@".~"}.~
32"HeLlOworld"{@@{^.32&\}%`@".~"}.~
0"hELloWoRlD"{@@{^.32&\}%`@".~"}.~
32"helLowORld"{@@{^.32&\}%`@".~"}.~
0"HeLLoWORlD"{@@{^.32&\}%`@".~"}.~
32"HellOWORld"{@@{^.32&\}%`@".~"}.~
0"hElLOWORlD"{@@{^.32&\}%`@".~"}.~
32"heLLOWORld"{@@{^.32&\}%`@".~"}.~
32"HelloworLd"{@@{^.32&\}%`@".~"}.~
32"hElLoWoRLd"{@@{^.32&\}%`@".~"}.~
0"HEllOWorlD"{@@{^.32&\}%`@".~"}.~

작동 방식은 문자열을 반복하여 이전 문자 (대소 문자를 뒤집은 후)가 소문자 인 경우 각 문자의 대문자를 (ASCII 코드를 32로 XOR하여) 대문자로 뒤집는 것입니다. 시작 프로그램의 숫자가 0이 아닌 32 인 경우 첫 번째 문자는 대소 문자가 바뀝니다. 문자열의 마지막 문자가 소문자 일 때마다 다음 반복에 대한 출력 수가 32가되어 끝 부분에서 변경이 발생합니다. 다음 반복에서 처음으로 다시 전파 할 문자열입니다.

(이 특정 피드백 프로세스는 완전히 임시 방식으로 얻어졌습니다 . 원래 대문자와 소문자를 비트로 사용하여 간단한 이진 카운터를 실행하고 싶었지만 구현하는 데 너무 많은 바이트가 필요했기 때문에 더 짧은 것을 찾기 위해 조정을 시작했습니다. 대소 문자 충돌 만 사용하는 이론상 최대 값은 2 ¹⁰ = 1024이므로 890 회 반복주기를 얻는 것이 좋습니다.)

아아, 추가 반복에 대한 보너스는 -50 %로 제한됩니다. 상한선이 없으면이 프로그램은 무려 4440 %의 보너스를받습니다. ;-)

Pyth, 18 바이트

"-\"hello world\"d

다음을 반환합니다 :

-"hello world"d

차례로 인쇄합니다.

helloworld

세 가지 맞춤법을 모두 수행하는 솔루션이 있었지만 보너스로 더 길었습니다.

심플 렉스 , 21 바이트

이것이 Simplex의 탄생 입니다. 나는 이것으로 더 멀리 갈 수 있습니다.

(Ctrl + Enter를 계속 누르고 있습니다. 죄송합니다. 태블릿 키보드에서 탓합니다.)

시도 3, v.0.8 +, 31-5 % = 29.45 바이트 (UTF-8 메타 크)

중간에있는 감정 표현은 나 자신을 표현합니다. 일종의. 또 왜 이러니? ._.

"\"f[helloworld]-:D-``\"§R'Hg"g
"                            "  ~~ write that string
 \"f[helloworld]-:D-``\"§R'Hg   ~~ escaped quotes
                              g ~~ output that string

두 번째 출력 :

"f[helloworld]-:D-``"§R'Hg
"                   "      ~~ write that string
 f[helloworld]-:D-``       ~~ string to be written
                     §R    ~~ go to second cell
                       'H  ~~ set it to H charcode
                         g ~~ output that string

세 번째 출력 :

f[Helloworld]-:D-``
f                   ~~ turns off safety mode (heck yeah error suppression!)
 [          ]-      ~~ write inside to outer program
  H                 ~~ sort strip
   e                ~~ write e = 2.718281828459045... to the strip
    ll              ~~ writes 1 twice to the cell
      o             ~~ outputs 1
       wo           ~~ apply o backwards through the strip (outputs 1)
         r          ~~ error! tries to access register for modification. nope!
          l         ~~ write 1 to to the current cell
           d        ~~ reverse the strip (NOP)
              :     ~~ removes last char of outer program
               D    ~~ double the current byte (2)
                -   ~~ writes previous char to outer program
                 `` ~~ suppress outer program evaluation and instead output it

최종 출력 :

HelloworlD

시도 2, v.0.8 +, 21 바이트 (UTF-8, 생각합니다)

"\"helloworld\"§'Hg"g
"                  "  ~~ write that string
 \"helloworld\"§'Hg   ~~ escaped quotes
                    g ~~ output that string

산출:

"helloworld"§'Hg
"          "     ~~ write that string
 helloworld      ~~ string to be written
            §    ~~ go to first cell
             'H  ~~ set it to H charcode
               g ~~ output that string

최종 출력 :

helloworld

시도 1, v.0.7 + 28 26 바이트

이것이 첫 보너스에 해당되는지 확실하지 않습니다.

"BhelloworldB"t[s32S;]'gs;
"            "             ~~ write that string
 BhelloworldB              ~~ the string
              t[     ]     ~~ apply the inner from left to right
                s          ~~ output as character
                 32S       ~~ subtract 32 ("capitalize")
                    ;      ~~ add the current byte's char to the outer program
                      'g;s ~~ add g to the outer program

첫 번째 출력 :

"HELLOWORLD"g

외부 프로그램은 실행이 끝날 때 평가됩니다 (y를 위해 수행합니다. 외부 프로그램은 다음과 같습니다.

"HELLOWORLD"g
"          "  ~~ write that string
            g ~~ output that string as string characters

최종 출력 :

HELLOWORLD

루비, 81-50 % = 40.5

원본 코드 :

_='_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)';puts _%[_,'HELLOWORL'+?D]

연속 출력 :

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"HELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hELLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"heLLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helLOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellOWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloWORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowORLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"hellowoRLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworLD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworlD"]).sub(/[[:upper:]]/,&:swapcase)

_="_=%p;puts (_%%[_,%p]).sub(/[[:upper:]]/,&:swapcase)";puts (_%[_,"helloworld"]).sub(/[[:upper:]]/,&:swapcase)

나는 이것이 전체 50 %로 간주한다고 생각합니까? 하나씩 끊어 질 수 있습니다. 또한 루비에는 더 나은 채점 비 보너스 솔루션이있을 것입니다.

원래 코드에는 "helloworld"가 포함되어 있지 않지만 소스 코드의 첫 번째 대문자를 소문자 버전으로 바꾸는 quine을 작성합니다. 따라서 quine을 연속해서 실행할 때마다 대문자가 1 줄어 듭니다.

여기서의 트릭은 형식화 문자열을 사용하여 quining을위한 문자열 자체와 Hello World 문자열을 모두 보간하여 한 번만 표시되도록하는 것입니다.

PHP, 297-40 % = 178.2 바이트

실제로 경쟁적이지는 않지만 글쓰기가 재미있었습니다.

<?ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(0,0+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[0]=$h[0]^' ';return "<"."?".$s."?".">".$s.$h;});

이 quine의 변형입니다.

<?
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });?>
ob_start(function($b){ return "<"."?\n$b?".">\n$b"; });

그러나 또한 출력을 대체하는이 "Helloworld"추가 0로 0+1(다음 반복에서 1와 1+1등 등). substr새로운 "helloworld"가 추가되기 전에 기존 "helloworld"출력을 사용하여 제거됩니다.

다른 출력을 얻기 위해 "helloworld"문자 하나가 대문자로 표시됩니다 (증가 숫자로 결정됨). 이것은 관련 코드입니다.

$h=hello.world;$h[0]=$h[0]^' '

여기서는 숫자 교체를 위해 숫자를 사용하지 않는 것이 문제였습니다.

str_replace(0,0+(int)true,$s)

당신은 이미 그것이 +1로 실현되었음을 알 수 있습니다 +(int)true.

하위 문자열 인수의 경우 0, 146다음이 필요했습니다 .

!i, ord(I)+ord(I)

비어 있지 않은 문자열 "i"는 강제 true되고 무효화됩니다. false유효한 정수 인수이며처럼 취급 0됩니다. ord(I)"I"의 ASCII 값 : 73

출력 (1 차 반복) :

<?ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(1,1+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[1]=$h[1]^' ';return "<"."?".$s."?".">".$s.$h;});Helloworld

출력 (2 차 반복) :

<?ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});?>ob_start(function($s){$s=substr(str_replace(2,2+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[2]=$h[2]^' ';return "<"."?".$s."?".">".$s.$h;});hElloworld

출력 (10 번째 반복) :

이것은 마지막으로 유효한 출력이지만 더 이상 유효한 프로그램이 아닙니다.

<?ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$h?>ob_start(function($s){$s=substr(str_replace(10,10+(int)true,$s),!i,ord(I)+ord(I));$h=hello.world;$h[10]=$h[10]^' ';return "<"."?".$s."?".">".$s.$hhelloworlD

"Hello world"문자열을 찾으려면 오른쪽으로 스크롤하십시오!

핍, 48-50 % = 24

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<0.h@>0R0o+0"

다음과 같이 진화합니다.

V Y"`V Y`.RPyRh:ST`helloworld`UCh@<1.h@>1R1o+1"
V Y"`V Y`.RPyRh:ST`Helloworld`UCh@<2.h@>2R2o+2"
V Y"`V Y`.RPyRh:ST`HElloworld`UCh@<3.h@>3R3o+3"
V Y"`V Y`.RPyRh:ST`HELloworld`UCh@<4.h@>4R4o+4"
V Y"`V Y`.RPyRh:ST`HELLoworld`UCh@<5.h@>5R5o+5"
V Y"`V Y`.RPyRh:ST`HELLOworld`UCh@<6.h@>6R6o+6"
V Y"`V Y`.RPyRh:ST`HELLOWorld`UCh@<7.h@>7R7o+7"
V Y"`V Y`.RPyRh:ST`HELLOWOrld`UCh@<8.h@>8R8o+8"
V Y"`V Y`.RPyRh:ST`HELLOWORld`UCh@<9.h@>9R9o+9"
V Y"`V Y`.RPyRh:ST`HELLOWORLd`UCh@<10.h@>10R10o+10"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<11.h@>11R11o+11"
V Y"`V Y`.RPyRh:ST`HELLOWORLD`UCh@<12.h@>12R12o+12"

가 HELLOWORLD변경되지 않았기 때문에 마지막 출력이 유효하지 않습니다. (보너스를 제대로하지 않으면 저를 정정하십시오.)

이 질문 덕분에 방금 새로운 quine 기술을 발견했습니다! 기본 quine은 V Y"`V Y`.RPy"다음과 같습니다.

  Y"         "  Yank that string into the variable y
V               Evaluate it as a Pip expression:
          RPy   y wrapped in double quotes (repr)
    `V Y`.      Prepend that regex pattern
                When this is evaluated, it returns a pattern object, which is
                auto-printed--conveniently, without the `` delimiters

추가 코드는 y다음과 같이 문자열을 수정 하기 전에 에서 문자열을 수정합니다 .

• 현재 helloworld를 가장 왼쪽 0문자가 대문자로 바꾸십시오.
• 모든 발생을 0로 대체하십시오 o+0(여기서 o1은 내장 변수 임).

다음에 코드의 숫자 주위는 1대신에 0등이 있습니다.

자바 스크립트, 52 바이트

function(){return '("hello world").replace(" ","")'}

테스트

=>

<='("hello world").replace(" ","")'

=> eval('("hello world").replace(" ","")')

<= 'helloworld'

///, 23 바이트-10 % = 20.7?

/,//\/ \/\/hello, world

온라인으로 사용해보십시오!

첫 번째 출력 :

/ //hello world

두 번째 출력 :

helloworld

BBC 기본, 56 바이트

게임이 얼마나 늦었는지 깨닫기 전에 이것에 균열이 생겼습니다. 가치있는 것을 위해 여기 내 버전과 StackExchange 코드 골프에 대한 첫 번째 시도가 있습니다.

여기, V. 는 다음 쉼표로 구분 된 목록에서 ASCII 코드로 제공되는 문자를 에코하고 P. 는 인쇄의 약어입니다. 백 스페이스 문자를 사용하여 기존 'helloworld'문자열을 덮어 씁니다.

입력 코드 :

V.80,46,34:P."helloworld";:V.8,68,34,59:P.":V.8,8,76,68"

첫 번째 출력 :

P."helloworlD";:V.8,8,76,68

두 번째 출력 :

helloworLD

https://bbc.godbolt.org/ 에서 온라인으로 테스트 할 수 있습니다.