Oreoorererereoo

Учитывая, что входная строка похожа на слово «oreo», задайте ASCII-представление файла cookie, ширина которого равна входной строке (для обеспечения стабильности файла cookie).

правила

• Ввод нижнего регистра, непустая строка без пробелов, содержащая любую комбинацию строк «o» и «re», и содержащая только эти строки.
• Строка «o» представляет сплошное печенье, в то время как строка «re» представляет начинку.
• Выходными данными должен быть сложенный файл cookie, ширина которого равна ширине входной строки.
• Вывод не может быть массивом строк
• Печенье должно перекрывать заполнение одним символом с каждой стороны
• Символы, используемые для вывода, не должны совпадать с выводом ниже (█ и ░), они просто должны быть разными непробельными символами для двух частей файла cookie.
• Заполнение пробелов в левой части заливки обязательно, и любые пробелы в конце не обязательны

Примеры

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Так как это кодовый гольф, выигрывает самый короткий ответ, удачи :)

Желе ,  16 14  13 байт

-1 Спасибо Эрику Аутгольферу

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для rкамеры и oдля oОК.

Попробуйте онлайн!

Пепе , 364 байта

К сожалению, онлайн-интерпретатор не заботится о сжатии комментариев, поэтому все oсимволы будут заменены пробелом. Ни пробелы, ни символы не oнужны, поэтому это может быть 295 байт, но мне больше нравится этот способ:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Попробуйте онлайн!

Ungolfed

Могут быть некоторые возможности для игры в гольф с флагами, которые я пропустил, но я уже закончил:

# "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≠＊┤］；Ｌ×⁸↔⁸

Попробуй это здесь!

Использует раздражающе длинный код ：r≠＊┤］для удаления rs из ввода.

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

Попробуйте онлайн!

Альтернатива с использованием 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,,"")}

Попробуйте онлайн!

• -12 байт благодаря @Giuseppe

Предыдущая версия с объяснением:

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

Попробуйте онлайн!

• -1 байт благодаря @Giuseppe

Развернутый код и объяснение:

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

-1 байт благодаря @Emigna

Используется 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"

Retina , 74 73 байта

Я чувствую, что не отправил ответ в течение очень долгого времени. Ну вот и я. Кроме того, Retina сильно изменилась, и я чувствую, что сосу это сейчас.

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

o|r
$&¶
_$

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

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

m`^r
 

Попробуйте онлайн!

Сетчатка , 21 байт

r

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

Попробуйте онлайн! Объяснение:

r

Удалить rс.

L$`.
$.+*$&

Перечислите каждую букву в отдельной строке, повторяя длину исходного ввода.

\bee
 

Замените первые два ees в каждой строке пробелом.

C (gcc) , 135 113 109 104 байта

• Сохранено двадцать два двадцать семь байтов благодаря NieDzejkob .
• Сохранено четыре байта благодаря потолку .

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

Попробуйте онлайн!

Используя 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)

Попробуйте онлайн!

Perl 5 -p , 47 байт

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

Попробуйте онлайн!

Это главно укорачивается благодаря Мише «s правок .

Мой оригинальный код:

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

Этот код не очень сложный, но кажется слишком дорогим, чтобы преобразовать его из строки, а затем обратно или сделать что-нибудь еще более умное.

В частности, только с 3-4 командами, имеющими имя String, мой оригинальный подход вообще не мог сохранить байты, пытаясь абстрагироваться от этого. Например, следующее составляет 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)}

Попробуйте онлайн!

Блок анонимного кода, который принимает строку и печатает oreo, используя 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)));})

-1 байт благодаря @Neil .

Попробуйте онлайн.

Объяснение:

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движение затем вправо, выведите строку -s, которая на два меньше длины входной строки, затем двигайтесь вниз и влево.

Баш, 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)))

Попробуйте онлайн!

Заимствовал некоторые идеи от ответа «Реализации невежества» наверняка.

-6 байт благодаря @ASCIIOnly!

Общая концепция состоит в том, чтобы вычислить агрегат строки по входным символам, следуя этим правилам:

• Если 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)))))

Я не использую хороших персонажей в распечатке в гольф-версии, потому что они дорогие. Возвращает строку для печати.

Попробуйте онлайн!

Смотрите объяснение ниже.

Pre-golfed:

; 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 байт: добавлен завершающий пробел

Python 2 , 77 76 72 байта

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

Попробуйте онлайн!

Внешняя часть cookie - «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 (это регистры, используемые для передачи первых двух аргументов из функции C в Linux). Для удобства я написал оболочку C ++ для этого, которая также хорошо очищает ввод и печатает вывод. Этот код можно найти здесь . Это также показывает оригинальную синтаксическую сборку nasm, которую я написал для этой функции (а также версию без игры в гольф, которую я начал работать первым).

Следует отметить, что этот код не учитывает сохраненные регистры вызываемого абонента, а это означает, что код C ++, скорее всего, потерпит крах, если будет выполнен некоторое время после вызова этой функции. На моей машине это не так, но это довольно удивительно. Я также не добавляю нулевой байт для разделения выходной строки, а вместо этого пространство, выделенное для выходной строки, предварительно заполняется байтами. (Если это не разрешено, я могу добавить нулевой терминатор по стоимости 3 байта).

Логика для этого кода заключается в подсчете длины строки, затем построении строки этой длины для каждого символа «o» и «r», видимого во входной строке, а затем для любого символа «e», заменяющего первый и последние символы в предыдущей строке с пробелами.

Я не могу найти где-нибудь в Интернете, чтобы скомпилировать и запустить смесь исходного кода C ++ и nasm, поэтому я мог бы написать небольшой код-обертку для этого, чтобы доказать, что он работает. В противном случае вы сможете скомпилировать и запустить это с make-файлом по ссылке, которую я дал с командой:

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

Мне удалось отформатировать сборку до чего-то приемлемого для gcc, так что попробуйте это онлайн!