Oreoorererereoo

Étant donné une chaîne d'entrée similaire au mot "oreo", donnez une représentation ASCII du cookie aussi large que la chaîne d'entrée (pour assurer la stabilité du cookie).

Règles

• L'entrée est en minuscule, une chaîne non vide, sans espace, qui ne contient aucune combinaison des chaînes "o" et "re", et ne contient que ces chaînes.
• La chaîne "o" représente le cookie solide, tandis que la chaîne "re" représente le remplissage.
• La sortie doit être un cookie empilé aussi large que la chaîne d'entrée.
• La sortie ne peut pas être un tableau de chaînes
• Le cookie doit chevaucher le remplissage d'un caractère de chaque côté
• Les caractères utilisés pour la sortie ne doivent pas nécessairement correspondre à la sortie ci-dessous (et), ils doivent simplement être différents caractères non-blancs pour les deux parties du cookie.
• Le remplissage d'espaces sur le côté gauche du remplissage est requis et tout espace de fin est facultatif.

Exemples

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Puisqu'il s'agit de code golf, la réponse la plus courte l'emporte, bonne chance :)

Jelly ,  16 14  13 bytes

-1 Merci à Erik l'Outgoler

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

Utilisations 1pour la crème et 0pour le biscuit.

Essayez-le en ligne!

Comment?

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

Précédent 16 byter:

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

Utilisations rpour le c ream et opour le c ookie.

Essayez-le en ligne!

Pepe , 364 octets

Malheureusement, l'interprète en ligne ne s'occupe pas de la compression des commentaires, donc tous les ocaractères seront remplacés par un espace. Ni les espaces ni les osont nécessaires, donc cela pourrait être 295 octets, mais j'aime mieux ça:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Essayez-le en ligne!

Ungolfed

Il y a peut-être quelques possibilités de golf avec drapeaux que j'ai ratées, mais j'ai terminé pour le moment:

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

Toile , 19 18 17 octets

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

Essayez-le ici!

Utilise le code fastidieux de ：r≠＊┤］pour supprimer rs de l'entrée.

Japt -R , 16 15 octets

re ¬£çX sX²èrÃû

L'essayer

                    :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

Des alternatives

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

C # (compilateur interactif Visual C #) , 95 octets

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

Essayez-le en ligne!

Alternative utilisant Agrégat, 108 octets

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

Essayez-le en ligne!

R , 106 octets

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

Essayez-le en ligne!

• -12 octets grâce à @Giuseppe

Version précédente avec explication:

R , 118 octets

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

Essayez-le en ligne!

• -1 octet grâce à @ Giuseppe

Code déroulé et explication:

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 octets

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

-1 octet grâce à @Emigna

Utilisations opour le cookie et rpour le remplissage.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

J'ai l'impression de ne pas avoir posté de réponse depuis très longtemps. Eh bien, je suis là. De plus, Retina a beaucoup changé et je sens que je suis nul à ça maintenant.

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

o|r
$&¶
_$

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

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

m`^r
 

Essayez-le en ligne!

Retina , 21 octets

r

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

Essayez-le en ligne! Explication:

r

Supprimer le rs.

L$`.
$.+*$&

Listez chaque lettre sur sa propre ligne répétée à la longueur de l'entrée d'origine.

\bee
 

Remplacez les deux premiers ees sur chaque ligne par un espace.

C (gcc) , 135 113 109 104 octets

• A sauvé vingt-deux vingt-sept octets grâce à NieDzejkob .
• Sauvegardé quatre octets grâce à 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));}

Essayez-le en ligne!

JavaScript ES6, 103 octets

Utiliser replace 103 octets:

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

Essayez-le en ligne!

Utiliser split et mapper 116 octets:

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

Essayez-le en ligne!

Perl 5 -p , 47 octets

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

Essayez-le en ligne!

Python 3 , 77 octets

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

Essayez-le en ligne!

Mathematica, 111 91 octets

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

Essayez-le en ligne!

Cela a été majorly raccourci grâce à Misha de modifications .

Mon code d'origine:

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

Ce code n’est pas très sophistiqué, mais il semble trop coûteux de se détourner des chaînes, puis de revenir en arrière ou de faire autre chose de malin.

En particulier, avec seulement 3 à 4 commandes nommées String, mon approche originale ne pouvait pas du tout économiser d'octets en essayant d'abstraire cela. Par exemple, 129 octets sont les suivants:

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

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

Essayez-le en ligne!

Bloc de code anonyme qui prend une chaîne et imprime l'oreo, avec ocomme cookie et rcomme crème.

Explication:

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

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

Utilisations =pour le cookie et ~pour le remplissage.

Essayez-le en ligne.

Explication:

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 solution ci-dessus utilise un remplacement. Les éléments suivants mappent sur les caractères de l'entrée:

Java 11, 113 112 octets

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

-1 octet grâce à @Neil .

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

AIE. Les noms de fonctions waaaay_too_long de PHP frappent encore!

Sortie:

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

Merci à @gwaugh -9 octets
Merci à @manatwork -2 octets

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

Essayez-le en ligne!

Essayez-le en ligne! (87 octets)

Essayez-le en ligne (soumission originale de 97 octets)!

PHP , 135 octets

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

Essayez-le en ligne! (récursif)

JavaScript, 72 65 64 octets

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

Essayez-le en ligne

Powershell, 71 69 66 octets

-2 octets merci @Veskah

-3 octets merci @AdmBorkBork

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

Script de test moins joué:

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

Sortie:

True
True
True
True
True

Charbon de bois , 19 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

Ｆθ

Boucle à travers les caractères de la chaîne d'entrée.

≡ι

Allumez chaque personnage.

o⟦⭆θ#⟧

S'il s'agit d'un, oimprimez la chaîne d'entrée remplacée par #s sur sa propre ligne.

e«→Ｐ⁻Ｌθ²↙

S'il s'agit d'un edéplacement vers la droite, imprimez une ligne de -s de deux fois moins que la longueur de la chaîne d'entrée, puis déplacez-vous vers le bas et la gauche.

Bash, 87 octets

Sans sed:

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

Merci à @manatwork.

Avec sed(90 octets):

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

C # (compilateur interactif Visual C #) , 71 octets

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

Essayez-le en ligne!

Emprunté quelques idées sur la réponse de Incarnation of Ignorance à coup sûr.

-6 octets grâce à @ASCIIOnly!

Le concept général consiste à calculer un agrégat de chaîne sur les caractères en entrée en respectant les règles suivantes:

• Si un rest rencontré, ajoutez un caractère d' espacement unique pour l'indentation. Nous savons que le prochain personnage sera une .
• Si un oou un eest rencontré, générez une chaîne en répétant le caractère actuel un nombre spécifique de fois et en l'ajoutant à une nouvelle ligne ou à un remplissage et à une nouvelle ligne.
• Le nombre de répétitions est déterminé par la longueur de la chaîne d'entrée et par le retrait ou non de la ligne actuelle.
• La PadLeftfonction est utilisée pour générer la chaîne de caractères répétitive.

Le résultat est la concaténation de toutes ces chaînes.

Pyth , 28 octets

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

Essayez-le ici! Celui-ci utilise une boucle.

Pyth, 30 octets

(Comme chaîne remplace)

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

Essayez-le ici! Celui-ci utilise le remplacement de chaîne.

J'aime beaucoup le python (c'est ce que j'ai écrit dans mes scripts de test originaux), alors j'ai pensé faire une entrée pyth pour le plaisir :)

Ruby , 62 60 octets

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

Essayez-le en ligne!

Utilisations Opour le cookie, *pour le remplissage.

-1 grâce à @manatwork signalant une erreur stupide et une autre -1 en raison d'un assouplissement des règles concernant les espaces.

C # (.NET Core) , 143 octets

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

Essayez-le en ligne!

Clojure , 137 octets

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

Je n'utilise pas les beaux personnages de l'imprimé dans la version avec golf car ceux-ci sont chers. Retourne une chaîne à imprimer.

Essayez-le en ligne!

Voir ci-dessous pour l'explication.

Pré-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 octets

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

Essayez-le en ligne!

• +1 octet: espaces de fin ajoutés

Python 2 , 77 76 72 octets

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

Essayez-le en ligne!

La partie extérieure du cookie est "o" et le remplissage est "r".

Code machine x86-64 (Linux), 97 octets

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

Cette fonction x86-64 prend le pointeur sur la chaîne d'entrée en rsi et construit la sortie à partir du pointeur dans rdi (ce sont les registres utilisés pour passer les deux premiers arguments d'une fonction C sous Linux). Pour plus de commodité, j'ai écrit un wrapper C ++ à cet effet, qui désinfecte également les entrées et les imprime. Ce code peut être localisé ici . Cela montre également l’assemblage de syntaxe nasm original que j’ai écrit pour cette fonction (ainsi que la version non golfée que j’ai travaillée en premier).

Il convient de noter que ce code ne respecte aucun des registres sauvegardés appelés, ce qui signifie que le code C ++ risque de planter s'il est exécuté pendant un certain temps après avoir appelé cette fonction. Sur ma machine, ce n'est pas le cas, mais c'est plutôt surprenant. Je n'ajoute pas non plus d'octet nul pour délimiter la chaîne de sortie, mais l'espace alloué à la chaîne de sortie est prérempli d'octets. (Si cela n'est pas autorisé, je peux ajouter le terminateur nul au coût de 3 octets).

La logique de ce code consiste essentiellement à compter la longueur de la chaîne, puis à construire une ligne de cette longueur pour chaque caractère "o" et "r" de la chaîne d'entrée, puis pour tout caractère "e", en remplaçant le premier. et les derniers caractères de la ligne précédente avec des espaces.

Je ne trouve aucun endroit en ligne pour compiler et exécuter un mélange de code source C ++ et nasm. Il est donc possible que j'écrive un petit code wrapper afin de prouver que cela fonctionne. Sinon, vous devriez pouvoir compiler et exécuter ceci avec le makefile dans le lien que j'ai donné avec la commande:

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

J'ai été capable de formater l'ensemble en un format acceptable par gcc, essayez-le en ligne!