Oreoorererereoo

Data una stringa di input simile alla parola "oreo", fornire una rappresentazione ASCII del cookie ampia quanto la stringa di input (per garantire la stabilità del cookie).

Regole

• L'input è in minuscolo, una stringa non vuota senza spazi bianchi contenente una combinazione delle stringhe "o" e "re" e contenente solo quelle stringhe.
• La stringa "o" rappresenta il cookie solido, mentre la stringa "re" rappresenta il riempimento.
• L'output deve essere un cookie impilato largo quanto la stringa di input.
• L'output potrebbe non essere una matrice di stringhe
• Il cookie deve sovrapporsi al riempimento di un carattere su ciascun lato
• I caratteri utilizzati per l'output non devono corrispondere all'output di seguito (█ e ░), devono solo essere diversi caratteri non bianchi per le due parti del cookie
• L'imbottitura degli spazi bianchi sul lato sinistro del riempimento è obbligatoria e qualsiasi spazio bianco finale è facoltativo

Esempi

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Dato che si tratta di codice golf, vince la risposta più breve, buona fortuna :)

Gelatina ,  16 14  13 byte

-1 Grazie a Erik the Outgolfer

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

Utilizza 1per la crema e 0per il biscotto.

Provalo online!

Come?

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

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

Usi rper il rforno e oper il ocaffè.

Provalo online!

Pepe , 364 byte

Sfortunatamente l'interprete online non si occupa di comprimere i commenti, quindi tutti i opersonaggi saranno sostituiti da uno spazio. Né gli spazi né quelli osono necessari, quindi potrebbero essere 295 byte, ma mi piace di più in questo modo:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Provalo online!

Ungolfed

Potrebbero esserci delle opportunità da golf con le bandiere che mi mancavano, ma per ora ho finito:

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

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

Provalo qui!

Utilizza il codice fastidiosamente lungo di ：r≠＊┤］rimuovere rs dall'input.

Japt -R , 16 15 byte

re ¬£çX sX²èrÃû

Provalo

                    :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

alternative

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

C # (compilatore interattivo Visual C #) , 95 byte

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

Provalo online!

Alternativa che utilizza aggregato, 108 byte

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

Provalo online!

R , 106 byte

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

Provalo online!

• -12 byte grazie a @Giuseppe

Versione precedente con spiegazione:

R , 118 byte

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

Provalo online!

• -1 byte grazie a @Giuseppe

Codice non spiegato e spiegazione:

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 byte

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

-1 byte grazie a @Emigna

Utilizza oper il cookie e rper il riempimento.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Mi sento come se non avessi pubblicato una risposta da molto tempo. Bene, eccomi qui. Inoltre, Retina è cambiata molto, e mi sento come se fossi schifo adesso.

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

o|r
$&¶
_$

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

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

m`^r
 

Provalo online!

Retina , 21 byte

r

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

Provalo online! Spiegazione:

r

Elimina la rs.

L$`.
$.+*$&

Elencare ogni lettera sulla propria riga ripetuta per la lunghezza dell'input originale.

\bee
 

Sostituisci le prime due ees su ogni riga con uno spazio.

C (gcc) , 135 113 109 104 104 byte

• Risparmiato ventidue ventisette byte grazie a NieDzejkob .
• Risparmiato quattro byte grazie 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));}

Provalo online!

JavaScript ES6, 103 byte

Utilizzando sostituire 103 byte:

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

Provalo online!

Utilizzo della divisione e mappa 116 byte:

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

Provalo online!

Perl 5 -p , 47 byte

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

Provalo online!

Python 3 , 77 byte

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

Provalo online!

Mathematica, 111 91 byte

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

Provalo online!

Questo è stato majorly accorciata grazie a Misha 's modifiche .

Il mio codice originale:

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

Questo codice non è molto elaborato ma sembra troppo costoso per convertirsi da stringhe e poi tornare indietro o per fare qualcos'altro di intelligente.

In particolare, con solo 3-4 comandi che hanno il nome String, il mio approccio originale non è riuscito a salvare i byte cercando di sottrarlo. Ad esempio, quanto segue è 129 byte:

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

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

Provalo online!

Blocco di codice anonimo che prende una stringa e stampa il oreo, con ocome cookie e rcome crema.

Spiegazione:

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

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

Utilizza =per il cookie e ~per il riempimento.

Provalo online.

Spiegazione:

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 soluzione precedente utilizza un sostituto. Le seguenti mappe invece sui caratteri dell'input:

Java 11, 113 112 byte

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

-1 byte grazie a @Neil .

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

AHIA. I nomi delle funzioni waaaay_too_long di PHP colpiscono ancora!

Produzione:

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

Grazie a @gwaugh -9 byte
Grazie a @manatwork -2 byte

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

Provalo online!

Provalo online! (87 byte)

Provalo online (invio originale di 97 byte)!

PHP , 135 byte

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

Provalo online! (ricorsivo)

JavaScript, 72 65 64 byte

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

Provalo online

Powershell, 71 69 66 byte

-2 byte grazie @Veskah

-3 byte grazie @AdmBorkBork

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

Script di test meno golfato:

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

Produzione:

True
True
True
True
True

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆθ

Passa attraverso i caratteri della stringa di input.

≡ι

Accendi ogni personaggio.

o⟦⭆θ#⟧

Se è un, oquindi stampare la stringa di input sostituita con #s sulla propria riga.

e«→Ｐ⁻Ｌθ²↙

Se è equindi spostati a destra, stampa una linea di -s che è due in meno della lunghezza della stringa di input, quindi scorri verso il basso e a sinistra.

Bash, 87 byte

Senza sed:

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

Grazie a @manatwork.

Con sed(90 byte):

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

C # (compilatore interattivo Visual C #) , 71 byte

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

Provalo online!

Ho preso in prestito alcune idee da su Incarnazione della risposta dell'ignoranza di sicuro.

-6 byte grazie a @ASCIIOnly!

Il concetto generale è di calcolare un aggregato di stringhe sui caratteri di input seguendo queste regole:

• Se rviene rilevato un carattere , aggiungere un singolo carattere spazio per il rientro. Sappiamo che il prossimo personaggio sarà un e.
• Se si incontra uno oo uno e, generare una stringa ripetendo il carattere corrente un numero specifico di volte e anteponendolo a una nuova riga o ad una spaziatura e a una nuova riga.
• Il numero di volte da ripetere è determinato dalla lunghezza della stringa di input e se la riga corrente è rientrata.
• La PadLeftfunzione viene utilizzata per generare la stringa di caratteri ripetuti.

Il risultato è la concatenazione di tutte queste stringhe.

Pyth , 28 byte

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

Provalo qui! Questo usa un loop.

Pyth, 30 byte

(Come stringa sostituita)

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

Provalo qui! Questo usa la sostituzione della stringa.

Mi piace molto Python (è quello in cui ho scritto i miei script di test originali), quindi ho pensato di fare una voce Pyth per divertimento :)

Rubino , 62 60 byte

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

Provalo online!

Utilizza Oper il cookie, *per il ripieno.

-1 grazie a @manatwork sottolineando un errore sciocco e un altro -1 a causa del rilassamento delle regole sugli spazi bianchi.

C # (.NET Core) , 143 byte

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

Provalo online!

Clojure , 137 byte

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

Non sto usando i simpatici personaggi nella stampa nella versione golfata poiché sono costosi. Restituisce una stringa da stampare.

Provalo online!

Vedi sotto per la spiegazione.

Pre-giocato a 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

Dardo , 120 106 107 byte

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

Provalo online!

• +1 byte: aggiunto spazio bianco finale

Python 2 , 77 76 72 byte

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

Provalo online!

La parte esterna del cookie è 'o' e il riempimento è 'r'.

codice macchina x86-64 (Linux), 97 byte

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

Questa funzione x86-64 accetta il puntatore alla stringa di input in rsi e crea l'output a partire dal puntatore in rdi (questi sono i registri utilizzati per passare i primi due argomenti da una funzione C su Linux). Per comodità, ho scritto un wrapper C ++ per questo che fa anche una buona sanificazione dell'input e stampa l'output. Quel codice può essere trovato qui . Questo mostra anche l'assemblaggio della sintassi nasm originale che ho scritto per questa funzione (così come la versione non golfata che ho iniziato a lavorare prima).

Alcune cose da notare è che questo codice non rispetta alcun registro salvato chiamato, il che significa che il codice C ++ probabilmente andrà in crash se eseguito per un po 'dopo aver chiamato questa funzione. Sulla mia macchina non funziona, ma è piuttosto sorprendente. Inoltre, non aggiungo un byte null per delimitare la stringa di output e invece lo spazio allocato per la stringa di output è precompilato con byte. (Se ciò non è consentito, posso aggiungere il terminatore null a un costo di 3 byte).

La logica di questo codice sta essenzialmente contando la lunghezza della stringa, quindi costruendo una linea di questa lunghezza per ogni carattere 'o' e 'r' visto nella stringa di input, e quindi per ogni carattere 'e' visto, sostituendo il primo e gli ultimi caratteri nella riga precedente con caratteri spaziali.

Non riesco a trovare da nessuna parte online per compilare ed eseguire un mix di codice sorgente C ++ e nasm, quindi potrei scrivere un piccolo codice wrapper per dimostrare che funziona. Altrimenti dovresti essere in grado di compilare ed eseguire questo con il makefile nel link che ho dato con il comando:

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

Sono stato in grado di formattare l'assembly su qualcosa di accettabile da gcc, quindi provalo online!