Pepe, 364 bytes

Unfortunately the online interpreter does not take care of compressing comments, hence all o characters will be replaced by a space.. Neither the spaces nor the o are necessary, so this could be 295 bytes, but I like it more this way:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Try it online!

Ungolfed

There might be some golfing oppurtunities with flags which I missed, but I'm done for now:

# "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≠＊┤］；Ｌ×⁸↔⁸

Try it here!

Uses the annoyingly long code of ：r≠＊┤］ to remove rs from the input..

Japt -R, 16 15 bytes

re ¬£çX sX²èrÃû

Try it

                    :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

Alternatives

re ¬ËpUÊaD²èrÃû

re ¬£îX rr²i^Ãû

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

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

Try it online!

Alternative using Aggregate, 108 bytes

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

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

Try it online!

• -12 bytes thanks to @Giuseppe

Previous version with explanation :

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

Try it online!

• -1 byte thanks to @Giuseppe

Unrolled code and explanation :

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 thanks to @Emigna

Uses o for the cookie and r for the filling.

Try it online or verify all test cases.

Explanation:

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

                     #   → "oooooon rrrrn rrrrnoooooo"

Retina, 74 73 bytes

I feel like I haven't posted an answer in a very long time. Well, here I am. Also, Retina has changed a lot, and I feel like I suck at it now.

.+

$0$.0

(d+)

*

e



o|r

$&¶

_$



+(/_/&`o¶

oo¶

_$



)/_/&`r¶

rr¶

¶$



m`^r

 

Try it online!

Retina, 21 bytes

r



L$`.

$.+*$&

bee

 

Try it online! Explanation:

r

Delete the rs.

L$`.

$.+*$&

List each letter on its own line repeated to the length of the original input.

bee

 

Replace the first two ees on each line with a space.

JavaScript ES6, 103 bytes

Using replace 103 bytes:

x=>x.replace(/o/g,"-".repeat(s=x.length)+`

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

`).slice(0,-1)

Try it online!

Using split and 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)

Try it online!

Python 3, 77 bytes

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

Try it online!

Powershell, 71 69 bytes

-2 bytes thanks @Veskah

$l=$args|% le*

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

Less golfed test script:

$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

}

Output:

True

True

True

True

True

Mathematica, 111 91 bytes

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

Try It Online!

This was majorly shortened thanks to Misha's edits.

My original code:

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

This code is not very fancy but it seems too expensive to convert away from strings and then back or to do anything else clever.

In particular, with only 3-4 commands that have the name String, my original approach couldn't save bytes at all by trying to abstract that away. For example, the following is 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"})&

C (gcc), 135 113 109 104 bytes

• Saved twenty-two twenty-seven bytes thanks to NieDzejkob.


• Saved four bytes thanks to 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));}

Try it online!

Charcoal, 19 bytes

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

Try it online! Link is to verbose version of code. Explanation:

Ｆθ

Loop through the characters of the input string.

≡ι

Switch on each character.

o⟦⭆θ#⟧

If it's an o then print the input string replaced with #s on its own line.

e«→Ｐ⁻Ｌθ²↙

If it's an e then move right, print a line of -s that's two less than the length of the input string, then move down and left.

Perl 5 -p, 47 bytes

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

Try it online!

Bash, 87 bytes

Without sed:

f(){ printf %$1s|tr   $2;}

c=${1//o/`f ${#1} B`

}

echo "${c//re/ `f $[${#1}-2] F` 

}"

Thanks to @manatwork.

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

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

Try it online!

Borrowed some ideas from on Embodiment of Ignorance's answer for sure.

-6 bytes thanks to @ASCIIOnly!

The overall concept is to compute a string aggregate over the input characters following these rules:

• If an r is encountered, append a single space character for indentation. We know the next character will be an e.


• If an o or an e is encountered, generate a string by repeating the current character a specific number of times and prepending it to a newline or some padding and a newline.


• The number of times to repeat is determined by length of input string and whether the current line is indented.


• The PadLeft function is used to generate the repeating character string.

The result is the concatenation of all of these strings.

Perl 6, 37 bytes

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

Try it online!

Anonymous code block that takes a string and prints the oreo, with o as the cookie and r as the cream.

Explanation:

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

Uses = for the cookie and ~ for the filling.

Try it online.

Explanation:

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

The above solution uses a replace. The following maps over the characters of the input instead:

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 thanks to @Neil.

Try it online.

Explanation:

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

"]);

Try it online!

OUCH. PHP's waaaay_too_long function names strike again!

Output:

$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

Thanks to @gwaugh -9 Bytes

Thanks to @manatwork -2 Bytes

<?=strtr($i=$argv[1],[o=>($r=str_repeat)(X,$l=strlen($i))."

",re=>" {$r(o,$l-2)}

"]);

Try it online!

Try it online! (87 Bytes)

Try it online (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):"";}

Try it online! (recursive)

JavaScript, 72 65 64 bytes

s=>s.replace(/.e?/g,([x,y])=>(y?`

 `:`

`).padEnd(s.length+!y,x))

Try it online

C# (.NET Core), 143 bytes

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

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

I'm not using the nice characters in the printout in the golfed version since those are expensive. Returns a string to be printed.

Try it online!

See below for explanation.

Pre-golfed:

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

Try it online!

• +1 byte : Added trailing whitespace

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)

Try it online!

The outer part of the cookie is 'o' and the filling is 'r'.