Oreoorererereoo

Dada una cadena de entrada que es similar a la palabra "oreo", proporcione una representación ASCII de la cookie que sea tan ancha como la cadena de entrada (para garantizar la estabilidad de la cookie).

Reglas

• La entrada es minúscula, una cadena no vacía sin espacios en blanco que contiene cualquier combinación de las cadenas "o" y "re", y que contiene solo esas cadenas.
• La cadena "o" representa la cookie sólida, mientras que la cadena "re" representa el relleno.
• La salida debe ser una cookie apilada que sea tan ancha como la cadena de entrada.
• La salida puede no ser una matriz de cadenas
• La cookie debe superponerse al relleno por un carácter en cada lado
• Los caracteres utilizados para la salida no tienen que coincidir con la salida a continuación (█ y ░), solo tienen que ser diferentes caracteres que no sean espacios en blanco para las dos partes de la cookie
• Se requiere el relleno de espacios en blanco en el lado izquierdo del relleno, y cualquier espacio en blanco final es opcional

Ejemplos

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Dado que este es el código de golf, la respuesta más corta gana, buena suerte :)

Jalea ,  16 14  13 bytes

-1 Gracias a Erik the Outgolfer

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

Usos 1para la crema y 0para la galleta.

Pruébalo en línea!

¿Cómo?

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 byter anterior:

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

Usos rpara el c ream y opara el c ookie.

Pruébalo en línea!

Pepe , 364 bytes

Desafortunadamente, el intérprete en línea no se encarga de comprimir los comentarios, por lo tanto, todos los ocaracteres serán reemplazados por un espacio ... Ni los espacios ni los oson necesarios, por lo que esto podría ser de 295 bytes, pero me gusta más de esta manera:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Pruébalo en línea!

Sin golf

Puede haber algunas oportunidades de golf con banderas que me perdí, pero ya he terminado:

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

Lienzo , 19 18 17 bytes

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

Pruébalo aquí!

Utiliza el código largamente molesto de ：r≠＊┤］eliminar rs de la entrada.

Japt -R , 16 15 bytes

re ¬£çX sX²èrÃû

Intentalo

                    :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

Alternativas

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

C # (compilador interactivo de Visual C #) , 95 bytes

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

Pruébalo en línea!

Alternativa usando Agregado, 108 bytes

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

Pruébalo en línea!

R , 106 bytes

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

Pruébalo en línea!

• -12 bytes gracias a @Giuseppe

Versión anterior con explicación:

R , 118 bytes

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

Pruébalo en línea!

• -1 byte gracias a @Giuseppe

Código desenrollado y explicación:

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 bytes

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

-1 byte gracias a @Emigna

Usos opara la galleta y rpara el relleno.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

'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 bytes

Siento que no he publicado una respuesta en mucho tiempo. Pues aquí estoy. Además, Retina ha cambiado mucho, y siento que ahora soy un asco.

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

o|r
$&¶
_$

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

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

m`^r
 

Pruébalo en línea!

Retina , 21 bytes

r

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

Pruébalo en línea! Explicación:

r

Eliminar el rs.

L$`.
$.+*$&

Liste cada letra en su propia línea repetida a la longitud de la entrada original.

\bee
 

Reemplace los primeros dos ees en cada línea con un espacio.

C (gcc) , 135 113 109 104 bytes

• Guardado veintidós veintisiete bytes gracias a NieDzejkob .
• Guardado cuatro bytes gracias a ceilingcat .

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

Pruébalo en línea!

JavaScript ES6, 103 bytes

Usando reemplazar 103 bytes:

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

Pruébalo en línea!

Usando dividir y asignar 116 bytes:

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

Pruébalo en línea!

Perl 5 -p , 47 bytes

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

Pruébalo en línea!

Python 3 , 77 bytes

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

Pruébalo en línea!

Mathematica, 111 91 bytes

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

¡Pruébelo en línea!

Esto se acortó principalmente gracias a las ediciones de Misha .

Mi código original:

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

Este código no es muy sofisticado, pero parece demasiado caro para convertirlo en cadenas y luego volverlo a hacer o hacer cualquier otra cosa inteligente.

En particular, con solo 3-4 comandos que tienen el nombre de Cadena, mi enfoque original no pudo guardar bytes en absoluto al tratar de abstraerlo. Por ejemplo, el siguiente es 129 bytes:

(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 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una cadena e imprime el oreo, con ola galleta y rla crema.

Explicación:

{                                   }   # 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 bytes

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

Usos =para la galleta y ~para el relleno.

Pruébalo en línea.

Explicació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

La solución anterior utiliza un reemplazo. Los siguientes mapas sobre los caracteres de la entrada en su lugar:

Java 11, 113 112 bytes

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

-1 byte gracias a @Neil .

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

AY. ¡Los nombres de funciones waaaay_too_long de PHP vuelven a aparecer!

Salida:

$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 bytes

Gracias a @gwaugh -9 Bytes
Gracias a @manatwork -2 Bytes

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

Pruébalo en línea!

Pruébalo en línea! (87 bytes)

¡Pruébelo en línea (presentación original de 97 bytes)!

PHP , 135 bytes

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

Pruébalo en línea! (recursivo)

JavaScript, 72 65 64 bytes

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

Pruébalo en línea

Powershell, 71 69 66 bytes

-2 bytes gracias @Veskah

-3 bytes gracias @AdmBorkBork

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

Menos guión de prueba de golf:

$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
}

Salida:

True
True
True
True
True

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆθ

Recorre los caracteres de la cadena de entrada.

≡ι

Enciende cada personaje.

o⟦⭆θ#⟧

Si es un o, imprima la cadena de entrada reemplazada por #s en su propia línea.

e«→Ｐ⁻Ｌθ²↙

Si es un emovimiento hacia la derecha, imprima una línea de -s que sea dos menos que la longitud de la cadena de entrada, luego muévase hacia abajo y hacia la izquierda.

Bash, 87 bytes

Sin sed:

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

Gracias a @manatwork.

Con sed(90 bytes):

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

C # (compilador interactivo de Visual C #) , 71 bytes

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

Pruébalo en línea!

Tomó prestadas algunas ideas de la respuesta de Encarnación de la Ignorancia con seguridad.

-6 bytes gracias a @ASCIIOnly!

El concepto general es calcular un agregado de cadena sobre los caracteres de entrada siguiendo estas reglas:

• Si rse encuentra un, agregue un solo carácter de espacio para la sangría. Sabemos que el próximo personaje será un e.
• Si se encuentra una oo una e, genere una cadena repitiendo el carácter actual un número específico de veces y preponiéndola a una nueva línea o algún relleno y una nueva línea.
• El número de veces para repetir está determinado por la longitud de la cadena de entrada y si la línea actual está sangrada.
• La PadLeftfunción se utiliza para generar la cadena de caracteres repetitiva.

El resultado es la concatenación de todas estas cadenas.

Pyth , 28 bytes

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

Pruébalo aquí! Este usa un bucle.

Pyth, 30 bytes

(Como reemplazo de cadena)

::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

Pruébalo aquí! Este usa reemplazo de cadena.

Realmente me gusta Python (es en lo que escribí mis scripts de prueba originales), así que pensé en hacer una entrada de Pyth por diversión :)

Ruby , 62 60 bytes

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

Pruébalo en línea!

Usos Opara la galleta, *para el relleno.

-1 gracias a @manatwork señalando un error tonto y otro -1 debido a la relajación de las reglas sobre espacios en blanco.

C # (.NET Core) , 143 bytes

Sin 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;};

Pruébalo en línea!

Clojure , 137 bytes

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

No estoy usando los simpáticos personajes en la impresión en la versión de golf ya que son caros. Devuelve una cadena para imprimir.

Pruébalo en línea!

Vea a continuación la explicación.

Pre-golf:

; 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

Dart , 120 106 107 bytes

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

Pruébalo en línea!

• +1 byte: espacio en blanco final agregado

Python 2 , 77 76 72 bytes

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

Pruébalo en línea!

La parte externa de la cookie es 'o' y el relleno es 'r'.

Código de máquina x86-64 (Linux), 97 bytes

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

Esta función x86-64 toma el puntero a la cadena de entrada en rsi y construye la salida comenzando en el puntero en rdi (estos son los registros utilizados para pasar los dos primeros argumentos de una función C en Linux). Para mayor comodidad, he escrito un contenedor de C ++ para esto que también hace una buena desinfección de entrada e imprime la salida. Ese código se puede encontrar aquí . Esto también muestra el ensamblaje de sintaxis nasm original que escribí para esta función (así como la versión sin golf en la que trabajé primero).

Algunas cosas a tener en cuenta es que este código no respeta ningún registro guardado de la persona que llama, lo que significa que el código C ++ probablemente se bloqueará si se ejecuta durante un tiempo después de llamar a esta función. En mi máquina no, pero eso es bastante sorprendente. Tampoco agrego un byte nulo para delimitar la cadena de salida, y en su lugar, el espacio asignado para la cadena de salida se llena previamente con bytes. (Si esto no está permitido, puedo agregar el terminador nulo a un costo de 3 bytes).

La lógica de este código es esencialmente contar la longitud de la cadena, luego construir una línea de esta longitud para cada carácter 'o' y 'r' visto en la cadena de entrada, y luego para cualquier carácter 'e' visto, reemplazando el primero y últimos caracteres en la línea anterior con caracteres de espacio.

No puedo encontrar ningún lugar en línea para compilar y ejecutar una combinación de código fuente C ++ y nasm, por lo que podría escribir un pequeño código de envoltura para que esto demuestre que funciona. De lo contrario, debería poder compilar y ejecutar esto con el archivo MAKE en el enlace que le di con el comando:

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

Pude formatear el ensamblaje a algo aceptable por gcc, ¡así que pruébelo en línea!