Oreoorererereoo

Geben Sie bei einer Eingabezeichenfolge, die dem Wort "oreo" ähnelt, eine ASCII-Darstellung des Cookies an, die so breit ist wie die Eingabezeichenfolge (um die Stabilität des Cookies zu gewährleisten).

Regeln

• Die Eingabe erfolgt in Kleinbuchstaben. Dabei handelt es sich um eine nicht leere Zeichenfolge ohne Leerzeichen, die eine beliebige Kombination der Zeichenfolgen "o" und "re" enthält und nur diese Zeichenfolgen enthält.
• Die Zeichenfolge "o" steht für das feste Cookie, während die Zeichenfolge "re" die Füllung darstellt.
• Die Ausgabe muss ein gestapeltes Cookie sein, das so breit wie die Eingabezeichenfolge ist.
• Die Ausgabe ist möglicherweise kein Array von Zeichenfolgen
• Der Cookie muss die Füllung auf jeder Seite um ein Zeichen überlappen
• Die Zeichen, die für die Ausgabe verwendet werden, müssen nicht mit der Ausgabe unten (█ und ░) übereinstimmen, sondern müssen für die beiden Teile des Cookies unterschiedliche Nicht-Leerzeichen-Zeichen sein
• Das Leerzeichen auf der linken Seite der Füllung muss ausgefüllt werden. Nachgestellte Leerzeichen sind optional

Beispiele

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Da dies Codegolf ist, gewinnt die kürzeste Antwort, viel Glück :)

Jelly ,  16 14  13 Bytes

-1 Danke an Erik den Outgolfer

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

Verwendet 1für die Sahne und 0für den Keks.

Probieren Sie es online!

Wie?

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

Vorherige 16 Byter:

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

Verwendet rfür die C ream und ofür die C oOkie.

Probieren Sie es online!

Pepe , 364 Bytes

Leider kümmert sich der Online-Interpreter nicht um das Komprimieren von Kommentaren, daher werden alle oZeichen durch ein Leerzeichen ersetzt. Weder die Leerzeichen noch die osind notwendig, daher könnten dies 295 Bytes sein, aber es gefällt mir besser so:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Probieren Sie es online!

Ungolfed

Möglicherweise gibt es einige Golfmöglichkeiten mit Flaggen, die ich verpasst habe, aber jetzt bin ich fertig:

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

Canvas , 19 18 17 Bytes

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

Probieren Sie es hier aus!

Benutzt den ärgerlich langen Code von ：r≠＊┤］, um rs aus der Eingabe zu entfernen .

Japt -R , 16 15 Bytes

re ¬£çX sX²èrÃû

Versuch es

                    :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

Alternativen

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

C # (Visual C # Interactive Compiler) , 95 Byte

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

Probieren Sie es online!

Alternative mit Aggregat, 108 Bytes

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

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

Probieren Sie es online!

• -12 Bytes dank @ Giuseppe

Vorherige Version mit Erläuterung:

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

Probieren Sie es online!

• -1 Byte dank @Giuseppe

Abgerollter Code und Erklärung:

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 danke an @Emigna

Verwendet ofür den Cookie undr zum Füllen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Netzhaut , 74 73 Bytes

Ich habe das Gefühl, seit langer Zeit keine Antwort mehr gepostet zu haben. Also, hier bin ich. Außerdem hat sich Retina sehr verändert und ich habe das Gefühl, dass ich jetzt daran lutsche.

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

o|r
$&¶
_$

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

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

m`^r
 

Probieren Sie es online!

Netzhaut , 21 Bytes

r

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

Probieren Sie es online! Erläuterung:

r

Löschen Sie das rs.

L$`.
$.+*$&

Listen Sie jeden Buchstaben in einer eigenen Zeile auf, die sich bis zur Länge der ursprünglichen Eingabe wiederholt.

\bee
 

Ersetzen Sie die ersten zwei ees in jeder Zeile durch ein Leerzeichen.

C (gcc) , 135, 113, 109 104 Bytes

• Zweiundzwanzig siebenundzwanzig Bytes dank gespeichert NieDzejkob .
• Vier Bytes gespart dank 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));}

Probieren Sie es online!

JavaScript ES6, 103 Byte

Verwenden von Ersetzen 103 Bytes:

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

Probieren Sie es online!

Verwendung von split und map 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)

Probieren Sie es online!

Perl 5 -p , 47 Bytes

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

Probieren Sie es online!

Python 3 , 77 Bytes

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

Probieren Sie es online!

Mathematica, 111 91 Bytes

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

Probieren Sie es online!

Dies wurde majorly durch verkürzte Misha ‚s Bearbeitungen .

Mein ursprünglicher Code:

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

Dieser Code ist nicht besonders ausgefallen, aber es scheint zu teuer, ihn von Strings zu konvertieren und dann wieder zurück zu kehren oder andere clevere Dinge zu tun.

Insbesondere mit nur 3-4 Befehlen, die den Namen String haben, konnte mein ursprünglicher Ansatz überhaupt keine Bytes sparen, indem er versuchte, dies zu abstrahieren. Das Folgende ist zum Beispiel 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)}

Probieren Sie es online!

Anonymer Codeblock, der eine Zeichenfolge verwendet und das Oreo mit oals Cookie und rals Creme ausgibt.

Erläuterung:

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

Verwendet = für den Keks und~ zum Füllen.

Probieren Sie es online aus.

Erläuterung:

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

Die obige Lösung verwendet einen Ersatz. Die folgende Abbildung zeigt stattdessen die Zeichen der Eingabe:

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 dank @Neil .

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es online!

AUTSCH. Die waaaay_too_long-Funktionsnamen von PHP schlagen wieder zu!

Ausgabe:

$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

Dank an @gwaugh -9 Bytes
Dank an @manatwork -2 Bytes

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

Probieren Sie es online!

Probieren Sie es online! (87 Bytes)

Probieren Sie es online aus (Original 97 Bytes Submition)!

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

Probieren Sie es online! (rekursiv)

JavaScript, 72 65 64 Bytes

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

Probieren Sie es online aus

Powershell, 71 69 66 Bytes

-2 Bytes danke @Veskah

-3 Bytes danke @AdmBorkBork

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

Weniger Golf-Testskript:

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

Ausgabe:

True
True
True
True
True

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆθ

Durchlaufen Sie die Zeichen der Eingabezeichenfolge.

≡ι

Schalte jeden Charakter ein.

o⟦⭆θ#⟧

In diesem oFall wird die Eingabezeichenfolge #in einer eigenen Zeile durch s ersetzt.

e«→Ｐ⁻Ｌθ²↙

Wenn es sich um eine eBewegung nach rechts handelt, drucken Sie eine Zeile mit -s, die um zwei kürzer als die Länge der Eingabezeichenfolge ist, und bewegen Sie sich dann nach unten und links.

Bash, 87 Bytes

Ohne sed :

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

Vielen Dank an @manatwork.

Mit 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 # (Visual C # Interactive Compiler) , 71 Byte

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

Probieren Sie es online!

Ich habe mir mit Sicherheit einige Ideen aus der Antwort von Verkörperung der Ignoranz ausgeliehen .

-6 Bytes dank @ASCIIOnly!

Das Gesamtkonzept besteht darin, ein Zeichenfolgenaggregat über die Eingabezeichen nach diesen Regeln zu berechnen:

• Wenn ein rauftritt, fügen Sie ein einzelnes Leerzeichen zum Einrücken hinzu. Wir wissen, dass der nächste Charakter ein sein wird e.
• Wenn ein ooder eine wird, generieren Sie eine Zeichenfolge, indem Sie das aktuelle Zeichen eine bestimmte Anzahl von Malen wiederholen und es vor eine neue Zeile oder ein Auffüllen und eine neue Zeile setzen.
• Die Anzahl der Wiederholungen wird durch die Länge der Eingabezeichenfolge und durch den Einzug der aktuellen Zeile bestimmt.
• Das PadLeft Funktion dient zur Generierung der sich wiederholenden Zeichenkette.

Das Ergebnis ist die Verkettung all dieser Zeichenfolgen.

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

Probieren Sie es hier aus!Dieser verwendet eine Schleife.

Pyth, 30 Bytes

(Als String ersetzen)

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

Probieren Sie es hier aus!Dieser verwendet String-Ersetzung.

Ich mag Python wirklich (es ist das, in dem ich meine ursprünglichen Testskripte geschrieben habe), also dachte ich, ich würde zum Spaß einen Pyth-Eintrag machen :)

Ruby , 62 60 Bytes

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

Probieren Sie es online!

Verwendet Ofür den Keks, *zum Füllen.

-1 dank @manatwork, das auf einen dummen Fehler hinweist, und -1 wegen der Lockerung der Regeln für Leerzeichen.

C # (.NET Core) , 143 Byte

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

Probieren Sie es 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)))))

Ich verwende die netten Zeichen im Ausdruck in der Golfversion nicht, da diese teuer sind. Gibt eine zu druckende Zeichenfolge zurück.

Probieren Sie es online!

Erklärungen finden Sie weiter unten.

Vorgolfen:

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

Probieren Sie es online!

• +1 Byte: Leerzeichen am Ende hinzugefügt

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)

Probieren Sie es online!

Der äußere Teil des Cookies ist "o" und die Füllung ist "r".

x86-64-Computercode (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

Diese x86-64-Funktion nimmt den Zeiger auf die Eingabezeichenfolge in rsi auf und erstellt die Ausgabe ab dem Zeiger in rdi (dies sind die Register, mit denen die ersten beiden Argumente einer C-Funktion unter Linux übergeben werden). Der Einfachheit halber habe ich dafür einen C ++ - Wrapper geschrieben, der auch die Eingabe bereinigt und die Ausgabe druckt. Dieser Code kann hier gefunden werden . Dies zeigt auch die ursprüngliche nasm-Syntax-Assembly, die ich für diese Funktion geschrieben habe (sowie die nicht golfene Version, mit der ich zuerst gearbeitet habe).

Ein paar Dinge, die beachtet werden müssen, sind, dass dieser Code keine von Angerufenen gespeicherten Register berücksichtigt, was bedeutet, dass der C ++ - Code wahrscheinlich abstürzt, wenn er nach dem Aufrufen dieser Funktion für eine Weile ausgeführt wird. Auf meinem Rechner ist das nicht der Fall, aber das ist ziemlich überraschend. Ich füge auch kein Null-Byte hinzu, um die Ausgabezeichenfolge zu begrenzen, und stattdessen wird der für die Ausgabezeichenfolge zugewiesene Speicherplatz mit Bytes vorab gefüllt. (Wenn dies nicht erlaubt ist, kann ich das Null-Abschlusszeichen zu einem Preis von 3 Bytes hinzufügen).

Die Logik für diesen Code besteht im Wesentlichen darin, die Länge der Zeichenfolge zu zählen, dann für jedes in der Eingabezeichenfolge angezeigte 'o' und 'r' Zeichen eine Zeile dieser Länge zu erstellen und dann für jedes angezeigte 'e' Zeichen das erste zu ersetzen und letzte Zeichen in der vorherigen Zeile mit Leerzeichen.

Ich kann nirgendwo online finden, um eine Mischung aus C ++ - und nasm-Quellcode zu kompilieren und auszuführen, daher könnte ich einen kleinen Wrapper-Code schreiben, um zu beweisen, dass dies funktioniert. Andernfalls sollten Sie in der Lage sein, dies mit dem Makefile in dem Link zu kompilieren und auszuführen, den ich mit dem Befehl gab:

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

Ich konnte die Assembly so formatieren, dass sie von gcc akzeptiert wird sie sie also online aus!