オレオレエレレオー

「oreo」という単語に類似した入力文字列を指定し、入力文字列と同じ幅のCookieのASCII表現を指定します（Cookieの安定性を確保するため）。

ルール

• 入力は小文字で、文字列「o」と「re」の任意の組み合わせを含み、それらの文字列のみを含む空白のない空ではない文字列です。
• 文字列「o」は固体Cookieを表し、文字列「re」はフィリングを表します。
• 出力は、入力文字列と同じ幅のスタックCookieである必要があります。
• 出力は文字列の配列ではない可能性があります
• Cookieは、各側に1文字ずつ、詰め物と重なる必要があります
• 出力に使用される文字は、以下の出力（█および░）と一致する必要はありません。Cookieの2つの部分で異なる非空白文字である必要があります。
• 塗りつぶしの左側の空白スペースは必須であり、後続の空白はオプションです

例

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

これはコードゴルフなので、最短の回答が勝ち、幸運を祈ります:)

ゼリー、 16 14  13 バイト

-1 Erik the Outgolferに感謝

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

使用するrC言語のためのrEAMとoCのためにookie。

オンラインでお試しください！

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

Canvas、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＃Interactive Compiler）、95バイト

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

オンラインでお試しください！

Aggregateを使用した代替、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バイト

長い間答えを投稿していないように感じます。さて、ここにいます。また、Retinaは大きく変わっており、私は今それを嫌いに感じています。

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

o|r
$&¶
_$

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

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

m`^r
 

オンラインでお試しください！

網膜、21バイト

r

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

オンラインでお試しください！説明：

r

rsを削除します。

L$`.
$.+*$&

元の入力の長さまで繰り返される独自の行に各文字をリストします。

\bee
 

ee各行の最初の2つをスペースに置き換えます。

C（GCC） 、135の 113 109 104バイト

• 保存された二十から二二十から七バイトにおかげ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));}

オンラインでお試しください！

JavaScript ES6、103バイト

103バイトの置換を使用：

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

オンラインでお試しください！

分割およびマップ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)

オンラインでお試しください！

Perl 5、47 -pバイト

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

オンラインでお試しください！

Python 3、77バイト

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

オンラインでお試しください！

Mathematica、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"})&

Perl 6、37バイト

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

オンラインでお試しください！

文字列を受け取ってオレオを出力する匿名のコードブロックでo、Cookieおよび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

Java 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

上記のソリューションでは、置換を使用します。以下は、代わりに入力の文字にマップします。

Java 11、113 112バイト

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

オンラインでお試しください！（再帰的）

JavaScript、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それが右に移動する場合-、入力文字列の長さより2少ないsの行を印刷してから、下に移動して左に移動します。

Bash、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＃Interactive Compiler）、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

ここで試してみてください！これは文字列置換を使用します。

私は本当にPythonが好きです（元のテストスクリプトを書いたものです）ので、楽しみのためにpythエントリを行うと思いました:)

ルビー、62 60バイト

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

オンラインでお試しください！

Oクッキー、*フィリングに使用します。

-1 @manatworkが愚かな間違いを指摘し、別の-1が空白に関する規則を緩和したために感謝します。

C＃（.NET Core）、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;};

オンラインでお試しください！

Clojure、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関数から最初の2つの引数を渡すために使用されるレジスタです）。便宜上、これのためにC ++ラッパーを作成しました。これは、優れた入力サニタイズを実行し、出力を出力します。そのコードはここにあります。これは、この関数用に作成した元のnasm構文アセンブリも示しています（最初に動作させたゴルフバージョンではありません）。

注意すべき点は、このコードは呼び出し先の保存されたレジスタを尊重しないことです。つまり、この関数を呼び出した後にしばらく実行すると、C ++コードがクラッシュする可能性があります。私のマシンではそうではありませんが、それはかなり驚くべきことです。また、出力文字列を区切るためにnullバイトを追加せず、代わりに出力文字列に割り当てられたスペースにバイトが事前に入力されています。（これが許可されない場合、3バイトのコストでヌルターミネータを追加できます）。

このコードのロジックは、基本的に文字列の長さをカウントし、入力文字列に見られる「o」および「r」文字ごとにこの長さの行を構築し、次に「e」文字ごとに構築して、最初の前の行の最後の文字とスペース文字。

C ++とnasmのソースコードを組み合わせてコンパイルして実行するためのオンラインの場所はどこにも見つからないので、これを機能させるための小さなラッパーコードを書くかもしれません。そうでなければ、コマンドで指定したリンクのmakefileでこれをコンパイルして実行できるはずです。

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

アセンブリをgccで受け入れられる形式にフォーマットできたので、オンラインで試してみてください！