Oreoorererereoo

Враховуючи вхідний рядок, схожий на слово "oreo", наведіть ASCII подання файлу cookie, яке буде таким же широким, як рядок введення (щоб забезпечити стабільність файлу cookie).

Правила

• Вхід - це малий регістр, не порожній рядок без пробілу, що містить будь-яку комбінацію рядків "o" і "re", і містить лише ці рядки.
• Рядок "o" являє собою суцільне cookie, тоді як рядок "re" являє собою заповнення.
• Вихід повинен бути складеним файлом cookie, шириною як рядок введення.
• Вихід може бути не масивом рядків
• Файл 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для c ream та oc 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≠＊┤］；Ｌ×⁸↔⁸

Спробуйте тут!

Використовує дратівливий довгий код ：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 # Interactive Compiler) , 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,,"")}

Спробуйте в Інтернеті!

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

Сітківка , 74 73 байт

Мені здається, я не надто довго розміщував відповідь. Ну ось я. Також Ретина дуже сильно змінилася, і я відчуваю, що зараз я смоктала за це.

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

o|r
$&¶
_$

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

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

m`^r
 

Спробуйте в Інтернеті!

Сітківка , 21 байт

r

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

Спробуйте в Інтернеті! Пояснення:

r

Видаліть rs.

L$`.
$.+*$&

Перелічіть кожну букву в своєму власному рядку, повтореному на довжину початкового вводу.

\bee
 

Замініть перші два ee s у кожному рядку пробілом.

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)

Спробуйте в Інтернеті!

Використовуючи розділення та відображення 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")

Спробуйте в Інтернеті!

Математика, 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)}

Спробуйте в Інтернеті!

Блок анонімного коду, який займає рядок і друкує орео, з 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

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 # Interactive Compiler) , 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 (саме про це я писав свої оригінальні тестові сценарії), тож я подумав, що буду робити піт для розваги :)

Рубі , 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)

Спробуйте в Інтернеті!

Зовнішня частина файлу 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 ++ для цього, яка також робить гарну санітарію введення та друкує вихід. Цей код можна знайти тут . Це також показує оригінальну збірку синтаксису насма, яку я написав для цієї функції (а також версію, що не використовується для гольфу, я працював першим).

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

Логіка цього коду, по суті, підраховує довжину рядка, потім будує рядок такої довжини для кожного символу 'o' та 'r', що бачиться у вхідному рядку, а потім для будь-якого баченого символу 'e', ​​замінюючи перший та останні символи попереднього рядка з пробілами.

Я не можу ніде знайти в Інтернеті, щоб компілювати та запускати суміш C ++ та насмісного вихідного коду, тому я можу написати невеликий код для обгортки для цього, щоб довести, що він працює. В іншому випадку ви повинні мати можливість скласти та запустити це за допомогою makefile у посиланні, яке я дав за допомогою команди:

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

Я зміг відформатувати збірку на щось прийнятне для gcc, тому спробуйте це в Інтернеті!