오레오 레레 레루

단어 "oreo"와 유사한 입력 문자열이 주어지면 쿠키 안정성을 보장하기 위해 입력 문자열만큼 넓은 쿠키의 ASCII 표현을 제공하십시오.

규칙

• 입력은 소문자이며, 문자열 "o"와 "re"의 조합을 포함하고 공백 만 포함하고 공백이없는 문자열입니다.
• 문자열 "o"는 솔리드 쿠키를 나타내고 문자열 "re"는 채우기를 나타냅니다.
• 출력은 입력 문자열만큼 넓은 스택 쿠키 여야합니다.
• 출력은 문자열 배열이 아닐 수 있습니다
• 쿠키는 각면에서 한 문자 씩 채우기와 겹쳐 야합니다.
• 출력에 사용 된 문자는 아래 출력 (█ 및 ░)과 일치하지 않아도되며 쿠키의 두 부분에 대해 공백이 아닌 다른 문자 여야합니다.
• 채우기 왼쪽에 공백이 필요하며 후행 공백은 선택 사항입니다.

예

Input: oreo
Output:
████
 ░░ 
████

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

Input: oreoorererereoo
Output:
███████████████
 ░░░░░░░░░░░░░ 
███████████████
███████████████
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
███████████████
███████████████

이것이 코드 골프이기 때문에 가장 짧은 답변이 승리합니다. :)

젤리 ,  16 14  13 바이트

-1 Outgolfer Erik에게 감사합니다

OḂƇẒṁ€aØ.¦€⁶Y

사용 1크림과 0쿠키를 위해.

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

어떻게?

OḂƇẒṁ€aØ.¦€⁶Y - Main Link: list of characters, V    e.g. 'orereo'
O             - ordinal (vectorises)                     [111,114,101,114,101,111]
  Ƈ           - filter keep those for which:
 Ḃ            -   modulo 2                               [111,    101,    101,111]
   Ẓ          - is prime? (vectorises)                   [  0,      1,      1,  0]
    ṁ€        - mould each like V                        [[0,0,0,0,0,0],[1,1,1,1,1,1],[1,1,1,1,1,1],[0,0,0,0,0,0]]
          €   - for each:
         ¦    -   sparse application...
       Ø.     -   ...to indices: literal [0,1] (0 is the rightmost index, 1 is the leftmost)
      a       -   ...apply: logical AND with:
           ⁶  -               space character           [[0,0,0,0,0,0],[' ',1,1,1,1,' '],[' ',1,1,1,1,' '],[0,0,0,0,0,0]]
            Y - join with newline characters            [0,0,0,0,0,0,'\n',' ',1,1,1,1,' ','\n',' ',1,1,1,1,' ','\n',0,0,0,0,0,0]
              - implicit print                       ...smashes everything together:
              -                                         000000
              -                                          1111 
              -                                          1111 
              -                                         000000

이전 16 개월 :

ḟ”eẋ€Ly@Ø.¦€⁾r Y

사용 r은 C에 대한 rEAM과 o는 C에 대한 ookie.

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

페페 , 364 바이트

불행히도 온라인 인터프리터는 주석 압축을 처리하지 않으므로 모든 o문자가 공백으로 바뀝니다. 공백이나 o가 필요 하지 않으므로 295 바이트가 될 수 있지만 더 좋아합니다.

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

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

언 골프

내가 놓친 플래그가 있는 골프 기회가있을 수 있지만 지금은 끝났습니다.

# "function" for 'e'
rEeEEeeEeE rrEE
  re          # remove duplicated argument
  reeeEeeeee  # print space
  rEEEEe      # decrement counter twice
REe re

# "function" for 'o'
rEeEEeEEEE rrEE
  re      # remove duplicated argument
  rEEEEE  # increment counter
REe re

# "function for 'r'
rEeEEEeeEe rrEE
  re Re              # remove duplicated argument & char
  RE REEEe REEEEE    # push 1
  re rE rEEEe rEEEEE # replace 1
  reE                # goto 1
REe re

# Main

REEe REEEEeEee                # read input & reverse
REEEe REeeE REEEe REEEEEEE    # push length-1 & move to r

rEEEeE rEEEe # dummy loop-var (fucking do-whiles...)
RE REEEe REEEEE REE  # while [label-1]

  # Call the right procedure depending on current character,
  # sets stacks up as follows:
  #   R [ .... *currentChar ]
  #   r [ (N-1) *count ]
  Re re          # pop 1 & loop-counter
  rEEEeE         # duplicate counter
  REEEEEEe rEEEe # copy current char to other stack
  ReE            # jeq to 'o'-label or 'e'-label

  # Output currentChar count times:
  RE REEEe REE # while [label-0]:
    Re         #   pop 0
    rReEe      #   print character
    RE REEEe   #   push 0
    rEEEEe     #   decrement counter
  Ree

  REEEe REeeE REEEe REEEEEEE  # push length-1 & move to r
  re Re Re                    # pop 0, counter and 9((((currentChar
  RE REEEe REEEEE             # push 1
  reeeeeEeEe                  # print new-line

Ree

캔버스 , 19 18 17 바이트

e ∙╋
：r≠＊┤］；Ｌ×⁸↔⁸

여기 사용해보십시오!

입력에서 s ：r≠＊┤］를 제거하기 위해 성가신 긴 코드를 사용합니다 r.

Japt -R , 16 15 바이트

re ¬£çX sX²èrÃû

시도 해봐

                    :Implicit input of string U
re                  :Remove all "e"s
   ¬                :Split to array of characters
    £               :Map each X
     çX             :  Repeat X to the length of U
        s           :  Slice from index
         X²         :   Duplicate X
           èr       :   Count the occurrences of "r"
             Ã      :End map
              û     :Centre pad each element with spaces to the length of the longest
                    :Implicitly join with newlines and output

대안

re ¬ËpUÊaD²èrÃû
re ¬£îX rr²i^Ãû

C # (Visual C # 대화식 컴파일러) , 95 바이트

n=>n.Replace("o",new String('-',n.Length)+"\n").Replace("re"," ".PadRight(n.Length-1,'|')+"\n")

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

집계, 108 바이트를 사용한 대안

n=>n.Aggregate("",(d,c)=>d+(c<102?"":c<112?new String('-',n.Length)+"\n":" ".PadRight(n.Length-1,'|')+"\n"))

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

R , 106 바이트

function(s,N=nchar(s)){m=rep(el(strsplit(gsub('re',0,s),'')),e=N)
m[m<1&seq(m)%%N<2]=' '
write(m,1,N,,"")}

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

• @Giuseppe 덕분에 -12 바이트

설명이있는 이전 버전 :

R , 118 바이트

function(s,N=nchar(s)){m=t(replicate(N,el(strsplit(gsub('re',0,s),''))))
m[m<1&row(m)%in%c(1,N)]=' '
write(m,1,N,,'')}

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

• @Giuseppe 덕분에 -1 바이트

풀린 코드 및 설명 :

function(s){                       # s is the input string, e.g. 'oreo'

  N = nchar(s)                     # store the length of s into N, e.g. 4

  s1 = gsub('re',0,s)              # replace 're' with '0' and store in s1, e.g. 'o0o'

  v = el(strsplit(s1,''))          # split s1 into a vector v of single characters
                                   # e.g. 'o','0','o'

  m = replicate(N,v)               # evaluate N times the vector v and arrange 
                                   # the result into a matrix m (nchar(s1) x N)
                                   # e.g. 
                                   # 'o' 'o' 'o' 'o' 
                                   # '0' '0' '0' '0' 
                                   # 'o' 'o' 'o' 'o' 


  m = t(m)                         # transpose the matrix

  m[m<1 & row(m)%in%c(1,N)] = ' '  # substitute the zeros (i.e. where < 1) 
                                   # on the 1st and last row of the matrix with ' ' (space)
                                   # e.g. 
                                   # 'o' ' ' 'o' 
                                   # 'o' '0' 'o' 
                                   # 'o' '0' 'o' 
                                   # 'o' ' ' 'o'

  write(m,1,N,,'')                 # write the matrix to stdout (write function transposes it)
                                   # e.g.
                                   # oooo
                                   #  00 
                                   # oooo
}

05AB1E , 18 17 16 바이트

'eKεD'rQ2*Igα×}.c

@Emigna 덕분에 -1 바이트

사용 o쿠키과 r충만.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

'eK                 '# Remove all "e" from the (implicit) input
                     #  i.e. "orereo" → "orro"
   ε         }       # Map all characters to:
    D                #  Duplicate the current character
     'rQ            '#  Check if it's an "r" (1 if truthy; 0 if falsey)
                     #   i.e. "r" → 1
                     #   i.e. "o" → 0
        ·            #  Double that
                     #   i.e. 1 → 2
                     #   i.e. 0 → 0
         Ig          #  Take the length of the input
                     #   i.e. "orereo" → 6
           α         #  Take the absolute difference between the two
                     #   i.e. 2 and 6 → 4
                     #   i.e. 0 and 6 → 6
            ×        #  Repeat the duplicated character that many times
                     #   i.e. "r" and 4 → "rrrr"
                     #   i.e. "o" and 6 → "oooooo"
              .c     # Then centralize it, which also imlicitly joins by newlines
                     # (and the result is output implicitly)
                     #  i.e. ["oooooo","rrrr","rrrr","oooooo"]
                     #   → "oooooo\n rrrr\n rrrr\noooooo"

망막 , 74 73 바이트

답변을 오랫동안 게시하지 않은 것 같습니다. 글쎄요, 여기 있습니다. 또한, 레티 나는 많이 바뀌었고, 나는 지금 그것을 빨아 먹는 것처럼 느낍니다.

.+
$0$.0
(\d+)
*
e

o|r
$&¶
_$

+(/_/&`o¶
oo¶
_$

)/_/&`r¶
rr¶
¶$

m`^r
 

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

망막 , 21 바이트

r

L$`.
$.+*$&
\bee
 

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

r

rs를 삭제하십시오 .

L$`.
$.+*$&

원래 문자의 길이만큼 반복하여 각 문자를 한 줄에 나열하십시오.

\bee
 

ee각 줄 의 처음 두 개를 공백으로 바꿉니다 .

C (GCC) , 135 (113) 109 104 바이트

• 저장된 20-2 개의 에 20-7 개의 바이트 감사 NieDzejkob .
• ceilingcat 덕분에 4 바이트를 절약했습니다 .

#define $ putchar(33
O(char*r){for(char*e,*o=r,x;*r;$-23))for(x=*r++>111,e=x?$-1),r++,o+2:o;*e++;$+x));}

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

자바 스크립트 ES6, 103 바이트

103 바이트 대체 사용 :

x=>x.replace(/o/g,"-".repeat(s=x.length)+`
`).replace(/re/g," "+"|".repeat(s>1?s-2:0)+` 
`).slice(0,-1)

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

split 및 map 116 바이트 사용 :

x=>x.split("re").map(y=>("-"[h='repeat'](r=x.length)+`
`)[h](y.length)).join(" "+"|"[h](r>1?r-2:0)+` 
`).slice(0,-1)

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

펄 5 -p , 47 바이트

s|o|X x($i=y///c).$/|ge;s|re|$".O x($i-2).$/|ge

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

파이썬 3 , 77 바이트

lambda x:x.replace("o","-"*len(x)+"\n").replace("re"," "+'.'*(len(x)-2)+"\n")

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

수학, 111 91 바이트

#~StringReplace~{"o"->"O"~Table~(n=StringLength@#)<>"\n","re"->" "<>Table["R",n-2]<>" \n"}&

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

이것은 Misha 의 편집 덕분에 크게 단축되었습니다 .

내 원래 코드 :

(z=StringRepeat;n=StringLength@#;#~StringReplace~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&

이 코드는 그리 훌륭하지는 않지만 문자열에서 변환 한 다음 되돌아 가거나 영리한 것을하기에는 너무 비싸 보입니다.

특히 이름이 String 인 3-4 개의 명령 만 있으면 원래의 접근 방식으로 추상화하지 않아 바이트를 절약 할 수 없었습니다. 예를 들어, 다음은 129 바이트입니다.

(w=Symbol["String"<>#]&;z=w@"Repeat";n=w["Length"]@#;#~w@"Replace"~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&

펄 6 , 37 바이트

{m:g/o|r/>>.&({S/rr/ /.say}o*x.comb)}

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

o쿠키를 사용 하여 문자열을 가져와 오레오를 인쇄하는 익명 코드 블록r 크림으로 .

설명:

{                                   }   # Anonymous code block
 m:g/o|r/                               # Select all o s and r s
         >>.&(                     )    # Map each letter to
                            *x.comb     # The letter padded to the width
               S/rr/ /                  # Substitute a leading rr with a space
                      .say              # And print with a newline

자바 11, 110 바이트

s->{int l=s.length();return s.replace("re"," "+"~".repeat(l-(l<2?1:2))+"\n").replace("o","=".repeat(l)+"\n");}

사용 =쿠키과 ~충만.

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

설명:

s->{                       // Method with String as both parameter and return-type
  int l=s.length();        //  Get the length of the input
  return s                 //  Return the input
          .replace("re",   //  After we've replaced all "re" with:
            " "            //   A space
            +"~".repeat(l-(l<2?1:2))
                           //   Appended with length-2 amount of "~"
                           //   (or length-1 if the input-length was 1)
            +"\n")         //   Appended with a newline
          .replace("o",    //  And we've also replaced all "o" with:
            "=".repeat(l)  //   Length amount of "="
            +"\n");}       //   Appended with a newline

위의 솔루션은 교체를 사용합니다. 다음은 대신 입력 문자를 매핑합니다.

자바 11, 113112 바이트

s->s.chars().forEach(c->{if(c>101)System.out.println((c>111?" ":"")+(""+(char)c).repeat(s.length()-2*(~c&1)));})

@Neil 덕분에 -1 바이트 .

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

설명:

s->                           // Method with String parameter and no return-type
  s.chars().forEach(c->{      //  Loop over the characters as codepoint-integers
    if(c>101)                 //   If it's not an 'e':
      System.out.println(     //    Print with trailing newline:
       (c>111?                //     If it's an 'r'
         " "                  //      Start with a space
        :                     //     Else (it's an 'o' instead)
         "")                  //      Start with an empty string
       +(""+(char)c).repeat(  //     And append the character itself
          .repeat(            //     Repeated the following amount of times:
           s.length()         //      The input-length
           -2*(~c&1)));})     //      Minus 2 if it's an "r", or 0 if it's an "o"

PHP ,100 99 93 바이트

$l=strlen($i=$argv[1]);$r=str_repeat;echo strtr($i,[o=>$r(X,$l)."
",re=>' '.$r(o,$l-2)."
"]);

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

아야. PHP의 waaaay_too_long 함수 이름이 다시 나타납니다!

산출:

$php oreo.php oreo
XXXX
 oo
XXXX

$php oreo.php o
X

$php oreo.php rere
 oo
 oo

$ php oreo.php oreoorererereoo
XXXXXXXXXXXXXXX
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX

PHP , 96 87 85 바이트

@gwaugh 덕분에 -9 바이트 @manatwork
덕분에 -2 바이트

<?=strtr($i=$argv[1],[o=>($r=str_repeat)(X,$l=strlen($i))."
",re=>" {$r(o,$l-2)}
"]);

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

온라인으로 사용해보십시오! (87 바이트)

온라인으로 사용해보십시오 (원본 97 바이트 제출)!

PHP , 135 바이트

function f($w,$x=0){$f=str_repeat;echo($x<($l=strlen($w)))?($w[$x]=='o')?$f(█,$l)."
".f($w,$x+1):" ".$f(░,$l-2)."
".f($w,$x+2):"";}

온라인으로 사용해보십시오! (재귀)

자바 스크립트, 72 65 64 바이트

s=>s.replace(/.e?/g,([x,y])=>(y?`
 `:`
`).padEnd(s.length+!y,x))

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

Powershell, 71 69 66 바이트

-2 바이트 덕분에 @Veskah

-3 바이트 덕분에 @AdmBorkBork

$l=$args|% le*
switch($args|% t*y){'o'{'#'*$l}'r'{" "+'%'*($l-2)}}

덜 골프 테스트 스크립트 :

$f = {

$l=$args|% length
switch($args|% t*y){
    'o'{'#'*$l}
    'r'{" "+'%'*($l-2)}
}

}

@(

,(
'oreo',
'####',
' %%',
'####'
)
,(
'o',
'#'
)
,(
're',
' '
)
,(
'rere',
' %%',
' %%'
)
,(
'oreoorererereoo',
'###############',
' %%%%%%%%%%%%%',
'###############',
'###############',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
'###############',
'###############'
)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    # $result # uncomment this line to display a result
}

산출:

True
True
True
True
True

숯 , 19 바이트

Ｆθ≡ιo⟦⭆θ#⟧e«→Ｐ⁻Ｌθ²↙

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆθ

입력 문자열의 문자를 반복합니다.

≡ι

각 문자를 켭니다.

o⟦⭆θ#⟧

그렇다면 o입력 #줄을 자신의 줄에 s 로 바꾸십시오 .

e«→Ｐ⁻Ｌθ²↙

그것이이 있다면 e다음 오른쪽으로 이동, 라인 인쇄 -한 후, 입력 문자열의 길이보다 두 이하의의를 아래로 이동하고 떠났다.

배쉬, 87 바이트

없이 sed:

f(){ printf %$1s|tr \  $2;}
c=${1//o/`f ${#1} B`
}
echo "${c//re/ `f $[${#1}-2] F` 
}"

@manatwork에게 감사합니다.

와 sed(90 바이트) :

f(){ printf %$1s|tr \  $2;}
echo $1|sed "s/o/`f ${#1} B`\n/g;s/re/ `f $[${#1}-2] F` \n/g"

C # (Visual C # 대화식 컴파일러) , 71 바이트

s=>s.Aggregate("",(a,c)=>a+(c>111?" ":"\n".PadLeft(s.Length+c/5-21,c)))

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

무지의 구체화에 대한 아이디어로부터 확실한 아이디어를 얻었습니다 .

@ASCIIOnly 덕분에 -6 바이트!

전반적인 개념은 다음 규칙에 따라 입력 문자에 대한 문자열 집계를 계산하는 것입니다.

• 가 있으면 들여 쓰기를위한 r공백 문자 하나를 추가하십시오 . 우리는 다음 캐릭터가 될 것임을 알고 있습니다 e.
• 경우 o또는이 e발생, 현재의 문자를 특정 횟수를 반복하고 줄 바꿈 또는 일부 패딩과 줄 바꿈에 붙이는하여 문자열을 생성합니다.
• 반복 횟수는 입력 문자열의 길이와 현재 행의 들여 쓰기 여부에 따라 결정됩니다.
• 그만큼 PadLeft 함수는 반복되는 문자열을 생성하는 데 사용됩니다.

결과적으로 이러한 모든 문자열이 연결됩니다.

Pyth , 28 바이트

FNzIqN"o"*lzN)IqN"r"+d*-lz2N
FNz                              For each value, N, in input
   IqN"o"                        if the character is "o"
         *lzN                    return the character times the length of the input
             )                   end if
              IqN"r"             if the character is "r"
FNzIqN"o"*lzN)IqN"r"+d*-lz2N
                        *-lz2N   return the character times length - 2
                    +d           padded on the left with " "

여기 사용해보십시오! 이것은 루프를 사용합니다.

Pyth, 30 바이트

(문자열 교체시)

::z"o"+*lz"="b"re"++d*-lz2"~"b
 :z"o"                           With the input, replace "o" with
       *lz"="                    "=" times the length of the input
      +      b                   and a newline added to the end
:             "re"               With the input, replace "re" with
                     *    "~"    "~" times
                      -lz2       the length of the input minus 2
                   +d            padded on the left with " "
                  +          b   and a newline added to the end

여기 사용해보십시오! 이것은 문자열 교체를 사용합니다.

나는 파이썬을 정말로 좋아합니다 (원래 테스트 스크립트를 작성했습니다). 나는 재미를 위해 pyth 항목을 할 것이라고 생각했습니다. :)

루비 , 62 60 바이트

->s{s.gsub /./,?r=>" #{(?**z=s.size)[0..-3]}
",?o=>?O*z+?\n}

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

사용 O, 쿠키에 대한 *충만.

공백에 대한 규칙이 완화되어 @manatwork가 바보 같은 실수를 지적하고 -1에 감사드립니다.

C # (. NET 코어) 143 바이트

LINQ없이.

p=>{var q="";foreach(char c in p){if(c!='e'){for(var j=0;j<p.Length;j++)q+=(j<1|j>p.Length-2)&c>'q'?" ":c<'p'?"█":"░";q+="\n";}}return q;};

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

클로저 , 137 바이트

(fn[f](let[w(count f)r #(apply str(repeat % %2))](clojure.string/join"\n"(replace{\o(r w \#)\e(str \ (r(- w 2)\-) \ )}(remove #{\r}f)))))

나는 골프 버전의 인쇄물에 멋진 문자를 사용하지 않고 있기 때문에 비용이 많이 듭니다. 인쇄 할 문자열을 반환합니다.

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

설명은 아래를 참조하십시오.

사전 골프 :

; Backslashes indicate a character literal
(defn oreo [format-str]
  (let [width (count format-str)

        ; A helper function since Clojure doesn't have built-in string multiplication
        str-repeat #(apply str (repeat % %2))

        ; Define the layers
        cookie (str-repeat width \█)
        cream (str \ (str-repeat (- width 2) \░) \ )]

    (->> format-str ; Take the input string,
         (remove #{\r}) ; remove r for simplcity,
         (replace {\o cookie, \e cream}) ; replace the remaining letters with the layers,
         (clojure.string/join "\n")))) ; and join the layers together with newlines

다트 , 120 (106) 107 바이트

f(s)=>s.replaceAll('o',''.padRight(s.length,'#')+'\n').replaceAll('re',' '.padRight(s.length-1,'-')+' \n');

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

• +1 바이트 : 후행 공백 추가

파이썬 2 , 77 76 72 바이트

lambda i:'\n'.join((x*len(i),' '+x*(len(i)-2))[x>'o']for x in i if'e'<x)

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

쿠키의 바깥 부분은 'o'이고 채우기는 'r'입니다.

x86-64 머신 코드 (Linux), 97 바이트

0000000000000000 <oreo_asm>:
   0:   56                      push   %rsi
   1:   57                      push   %rdi

0000000000000002 <len>:
   2:   48 ff c7                inc    %rdi
   5:   80 3f 00                cmpb   $0x0,(%rdi)
   8:   75 f8                   jne    2 <len>
   a:   49 89 fc                mov    %rdi,%r12
   d:   5f                      pop    %rdi
   e:   49 29 fc                sub    %rdi,%r12
  11:   4d 31 f6                xor    %r14,%r14
  14:   eb 18                   jmp    2e <outer_loop.skip>

0000000000000016 <extra>:
  16:   41 c6 01 20             movb   $0x20,(%r9)
  1a:   c6 03 20                movb   $0x20,(%rbx)
  1d:   49 ff ce                dec    %r14
  20:   eb 06                   jmp    28 <outer_loop>

0000000000000022 <newline>:
  22:   c6 06 0a                movb   $0xa,(%rsi)
  25:   48 ff c6                inc    %rsi

0000000000000028 <outer_loop>:
  28:   49 ff c6                inc    %r14
  2b:   48 ff c7                inc    %rdi

000000000000002e <outer_loop.skip>:
  2e:   44 8a 07                mov    (%rdi),%r8b
  31:   41 80 f8 65             cmp    $0x65,%r8b
  35:   74 df                   je     16 <extra>
  37:   45 84 c0                test   %r8b,%r8b
  3a:   74 23                   je     5f <done>
  3c:   48 89 f3                mov    %rsi,%rbx

000000000000003f <inner_loop>:
  3f:   44 88 06                mov    %r8b,(%rsi)
  42:   49 89 f1                mov    %rsi,%r9
  45:   48 ff c6                inc    %rsi
  48:   48 31 d2                xor    %rdx,%rdx
  4b:   48 89 f0                mov    %rsi,%rax
  4e:   48 2b 04 24             sub    (%rsp),%rax
  52:   4c 29 f0                sub    %r14,%rax
  55:   49 f7 f4                div    %r12
  58:   48 85 d2                test   %rdx,%rdx
  5b:   74 c5                   je     22 <newline>
  5d:   eb e0                   jmp    3f <inner_loop>

000000000000005f <done>:
  5f:   5e                      pop    %rsi
  60:   c3                      retq

이 x86-64 함수는 rsi의 입력 문자열에 대한 포인터를 가져와 rdi의 포인터에서 시작하여 출력을 빌드합니다 (Linux의 C 함수에서 처음 두 인수를 전달하는 데 사용되는 레지스터입니다). 편의상, 좋은 입력 삭제를 수행하고 출력을 인쇄하는 C ++ 래퍼를 작성했습니다. 그 코드는 여기 에 있습니다 . 이것은 또한이 함수를 위해 작성한 원래 nasm 구문 어셈블리와 내가 처음 작업 한 골프 이외의 버전을 보여줍니다.

이 코드는 수신자가 저장 한 레지스터를 존중하지 않으므로이 함수를 호출 한 후 잠시 동안 C ++ 코드를 실행하면 충돌이 발생할 수 있습니다. 내 컴퓨터에서는 그렇지 않지만 다소 놀랍습니다. 또한 출력 문자열을 구분하기 위해 null 바이트를 추가하지 않고 출력 문자열에 할당 된 공간이 바이트로 미리 채워져 있습니다. (이것이 허용되지 않으면 3 바이트의 비용으로 null 종결자를 추가 할 수 있습니다).

이 코드의 논리는 본질적으로 문자열의 길이를 계산 한 다음 입력 문자열에 표시되는 각 'o'및 'r'문자에 대해이 길이의 행을 작성하고 표시된 'e'문자에 대해 첫 번째 문자를 대체합니다. 공백 문자가있는 이전 행의 마지막 문자

C ++과 nasm 소스 코드를 혼합하여 컴파일하고 실행하기 위해 온라인 어디에서도 찾을 수 없으므로 작동하는 것으로 입증하기 위해 작은 래퍼 코드를 작성할 수 있습니다. 그렇지 않으면 명령으로 제공 한 링크의 makefile로 이것을 컴파일하고 실행할 수 있어야합니다.

$ make oreo ASM_FILE=oreo_golf.nasm
$ ./oreo oreoorererereoo --use_asm

gcc가 허용하는 형식으로 어셈블리를 포맷 할 수 있었으므로 온라인으로 시도하십시오!