Oreoorererereoo

Dada uma sequência de entrada semelhante à palavra "oreo", forneça uma representação ASCII do cookie que seja tão larga quanto a sequência de entrada (para garantir a estabilidade do cookie).

Regras

• A entrada é minúscula, uma sequência não-vazia, sem espaço em branco, que contém qualquer combinação das sequências "o" e "re" e contém apenas essas sequências.
• A sequência "o" representa o cookie sólido, enquanto a sequência "re" representa o preenchimento.
• A saída deve ser um cookie empilhado que seja tão largo quanto a sequência de entrada.
• A saída pode não ser uma matriz de strings
• O cookie deve sobrepor o preenchimento por um caractere de cada lado
• Os caracteres usados ​​para a saída não precisam corresponder à saída abaixo (█ e ░), eles apenas precisam ser caracteres diferentes de espaço em branco diferentes para as duas partes do cookie
• É necessário o preenchimento de espaço em branco no lado esquerdo do preenchimento e qualquer espaço em branco à direita é opcional

Exemplos

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Como esse é o código de golfe, a resposta mais curta vence, boa sorte :)

Geléia ,  16 14  13 bytes

-1 Agradecimentos a Erik, o Outgolfer

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

Usa 1para o creme e 0para o biscoito.

Experimente online!

Quão?

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

Usa rpara a equipe re opara a equipe o.

Experimente online!

Pepe , 364 bytes

Infelizmente, o intérprete on-line não cuida da compactação de comentários, portanto, todos os ocaracteres serão substituídos por um espaço. Nem os espaços nem o osão necessários, portanto podem ser 295 bytes, mas eu gosto mais desta maneira:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Experimente online!

Ungolfed

Pode haver algumas oportunidades de golfe com bandeiras que eu perdi, mas acabei por enquanto:

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

Tela , 19 18 17 bytes

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

Experimente aqui!

Usa o código irritantemente longo de ：r≠＊┤］para remover rs da entrada.

Japonês -R , 16 15 bytes

re ¬£çX sX²èrÃû

Tente

                    :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 interativo do Visual C #) , 95 bytes

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

Experimente online!

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

Experimente online!

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

Experimente online!

• -12 bytes graças a @ Giuseppe

Versão anterior com explicação:

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

Experimente online!

• -1 byte graças a @ Giuseppe

Código desenrolado e explicação:

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 graças a @Emigna

Usa opara o cookie e rpara o recheio.

Experimente online ou verifique todos os casos de teste .

Explicação:

'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

Sinto que não publico uma resposta há muito tempo. Bem, aqui estou eu. Além disso, a Retina mudou muito e sinto que sou péssima agora.

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

o|r
$&¶
_$

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

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

m`^r
 

Experimente online!

Retina , 21 bytes

r

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

Experimente online! Explicação:

r

Exclua os rs.

L$`.
$.+*$&

Liste cada letra em sua própria linha repetida para o comprimento da entrada original.

\bee
 

Substitua os dois primeiros ees em cada linha por um espaço.

C (gcc) , 135 113 109 104 bytes

• Economizou vinte e dois vinte e sete bytes graças a NieDzejkob .
• Economizou quatro bytes graças ao 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));}

Experimente online!

JavaScript ES6, 103 bytes

Usando substituir 103 bytes:

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

Experimente online!

Usando divisão e mapear 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)

Experimente online!

Perl 5 -p , 47 bytes

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

Experimente online!

Python 3 , 77 bytes

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

Experimente online!

Mathematica, 111 91 bytes

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

Experimente Online!

Este foi majorly encurtado graças ao Misha 's edições .

Meu código original:

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

Esse código não é muito sofisticado, mas parece muito caro converter-se de strings e depois voltar ou fazer qualquer outra coisa inteligente.

Em particular, com apenas 3-4 comandos com o nome String, minha abordagem original não conseguiu salvar bytes tentando abstraí-lo. Por exemplo, o seguinte é 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)}

Experimente online!

Bloco de código anônimo que pega uma string e imprime o oreo, com oo cookie e ro creme.

Explicação:

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

Usa =para o cookie e ~para o recheio.

Experimente online.

Explicação:

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

A solução acima usa uma substituição. Os seguintes mapas mapeiam os caracteres da entrada:

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 graças a @Neil .

Experimente online.

Explicação:

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)."
"]);

Experimente online!

OUCH. Os nomes de funções waaaay_too_long do PHP atacam novamente!

Resultado:

$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

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

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

Experimente online!

Experimente online! (87 bytes)

Experimente online (envio 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):"";}

Experimente online! (recursivo)

JavaScript, 72 65 64 bytes

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

Experimente online

Powershell, 71 69 66 bytes

-2 bytes obrigado @Veskah

-3 bytes obrigado @AdmBorkBork

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

Script de teste com menos golfe:

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

Resultado:

True
True
True
True
True

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆθ

Faça um loop pelos caracteres da sequência de entrada.

≡ι

Ligue cada personagem.

o⟦⭆θ#⟧

Se for um o, imprima a sequência de entrada substituída por #s em sua própria linha.

e«→Ｐ⁻Ｌθ²↙

Se for um emovimento para a direita, imprima uma linha de -s que seja dois a menos que o comprimento da sequência de entrada e, em seguida, mova para baixo e para a esquerda.

Bash, 87 bytes

Sem sed:

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

Graças a @manatwork.

Com 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 interativo do Visual C #) , 71 bytes

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

Experimente online!

Emprestou algumas idéias da resposta da Modalidade de Ignorância, com certeza.

-6 bytes graças a @ASCIIOnly!

O conceito geral é calcular uma cadeia de caracteres agregada sobre os caracteres de entrada seguindo estas regras:

• Se um rfor encontrado, adicione um caractere de espaço único para indentação. Sabemos que o próximo personagem será um e.
• Se um oou um efor encontrado, gere uma sequência repetindo o caractere atual um número específico de vezes e acrescentando-o a uma nova linha ou a um preenchimento e a uma nova linha.
• O número de vezes a repetir é determinado pelo comprimento da sequência de entrada e se a linha atual é recuada.
• A PadLeftfunção é usada para gerar a sequência de caracteres repetidos.

O resultado é a concatenação de todas essas seqüências.

Pitão , 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 " "

Experimente aqui! Este usa um loop.

Pitão, 30 bytes

(Como string substituir)

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

Experimente aqui! Este usa substituição de string.

Eu realmente gosto de python (foi no que escrevi meus scripts de teste originais), então pensei em fazer uma entrada pyth por diversão :)

Ruby , 62 60 bytes

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

Experimente online!

Usa Opara o cookie, *para o recheio.

-1 graças a @manatwork apontando um erro bobo e outro -1 devido ao relaxamento das regras sobre espaços em branco.

C # (.NET Core) , 143 bytes

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

Experimente online!

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

Não estou usando os bons caracteres impressos na versão golfada, pois são caros. Retorna uma string a ser impressa.

Experimente online!

Veja abaixo a explicação.

Pré-golfe:

; 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

Dardo , 120 106 107 bytes

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

Experimente online!

• +1 byte: espaço em branco à direita adicionado

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)

Experimente online!

A parte externa do cookie é 'o' e o recheio é '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

Essa função x86-64 pega o ponteiro para a string de entrada em rsi e constrói a saída iniciando no ponteiro em rdi (esses são os registradores usados ​​para passar os dois primeiros argumentos de uma função C no Linux). Por conveniência, escrevi um wrapper C ++ para isso, que também faz uma boa limpeza de entrada e imprime a saída. Esse código pode ser localizado aqui . Isso também mostra o conjunto de sintaxe nasm original que escrevi para esta função (bem como a versão sem golf que trabalhei primeiro).

Algumas coisas a serem observadas é que esse código não respeita nenhum registro salvo de callee, o que significa que o código C ++ provavelmente falhará se for executado por um tempo depois de chamar esta função. Na minha máquina, não, mas isso é bastante surpreendente. Também não adiciono um byte nulo para delimitar a sequência de saída e, em vez disso, o espaço alocado para a sequência de saída é preenchido com bytes. (Se isso não for permitido, posso adicionar o terminador nulo a um custo de 3 bytes).

A lógica para esse código é essencialmente contar o comprimento da sequência, construindo uma linha desse comprimento para cada caractere 'o' e 'r' visto na sequência de entrada e, em seguida, para qualquer caractere 'e' visto, substituindo o primeiro e últimos caracteres na linha anterior com caracteres de espaço.

Não consigo encontrar nenhum lugar on-line para compilar e executar uma mistura de código-fonte C ++ e nasm, portanto, devo escrever um pequeno código de invólucro para isso para provar que funciona. Caso contrário, você poderá compilar e executar isso com o makefile no link que forneci com o comando:

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

Consegui formatar o assembly para algo aceitável pelo gcc, então tente online!