Oreoorereroo

Đưa ra một chuỗi đầu vào tương tự như từ "oreo", hãy đưa ra một đại diện ASCII của cookie rộng bằng chuỗi đầu vào (để đảm bảo tính ổn định của cookie).

Quy tắc

• Đầu vào là chữ thường, một chuỗi không trống không có khoảng trắng chứa bất kỳ sự kết hợp nào của chuỗi "o" và "re" và chỉ chứa các chuỗi đó.
• Chuỗi "o" đại diện cho cookie rắn, trong khi chuỗi "re" đại diện cho điền.
• Đầu ra phải là một cookie xếp chồng rộng bằng chuỗi đầu vào.
• Đầu ra có thể không phải là một chuỗi các chuỗi
• Cookie phải chồng lấp điền vào bởi một ký tự ở mỗi bên
• Các ký tự được sử dụng cho đầu ra không phải khớp với đầu ra bên dưới (và), chúng chỉ phải là các ký tự không phải khoảng trắng khác nhau cho hai phần của cookie
• Việc đệm khoảng trắng ở phía bên trái của điền là bắt buộc và bất kỳ khoảng trắng theo sau nào là tùy chọn

Ví dụ

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Vì đây là mã golf, câu trả lời ngắn nhất sẽ thắng, chúc may mắn :)

Thạch ,  16 14  13 byte

-1 Cảm ơn Erik, Outgolfer

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

Sử dụng 1cho kem và 0cho cookie.

Hãy thử trực tuyến!

Làm sao?

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 trước:

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

Sử dụng rcho c ream và ocho c ookie.

Hãy thử trực tuyến!

Pepe , 364 byte

Thật không may, trình thông dịch trực tuyến không quan tâm đến việc nén các bình luận, do đó tất cả các oký tự sẽ được thay thế bằng một khoảng trắng .. Cả các khoảng trắng và không ocần thiết, vì vậy đây có thể là 295 byte, nhưng tôi thích nó hơn theo cách này:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Hãy thử trực tuyến!

Ung dung

Có thể có một số cơ hội chơi golf với cờ mà tôi đã bỏ lỡ, nhưng tôi đã hoàn thành:

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

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

Hãy thử nó ở đây!

Sử dụng mã dài khó chịu ：r≠＊┤］để loại bỏ rs khỏi đầu vào ..

Japt -R , 16 15 byte

re ¬£çX sX²èrÃû

Thử nó

                    :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

Lựa chọn thay thế

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

C # (Trình biên dịch tương tác Visual C #) , 95 byte

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

Hãy thử trực tuyến!

Thay thế bằng cách sử dụng Tổng hợp, 108 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

• -12 byte nhờ @Giuseppe

Phiên bản trước với lời giải thích:

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

Hãy thử trực tuyến!

• -1 byte nhờ @Giuseppe

Mã không được kiểm soát và giải thích:

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 nhờ @Emigna

Sử dụng ocho cookie và rcho điền.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Võng mạc , 74 73 byte

Tôi cảm thấy như mình đã không đăng một câu trả lời trong một thời gian rất dài. Vâng, tôi đây. Ngoài ra, Retina đã thay đổi rất nhiều, và tôi cảm thấy như bây giờ tôi rất thích nó.

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

o|r
$&¶
_$

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

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

m`^r
 

Hãy thử trực tuyến!

Võng mạc , 21 byte

r

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

Hãy thử trực tuyến! Giải trình:

r

Xóa rs.

L$`.
$.+*$&

Liệt kê mỗi chữ cái trên dòng riêng được lặp lại theo chiều dài của đầu vào ban đầu.

\bee
 

Thay thế hai ees đầu tiên trên mỗi dòng bằng một khoảng trắng.

C (gcc) , 135 113 109 104 byte

• Đã lưu hai mươi hai hai mươi bảy byte nhờ NieDzejkob .
• Lưu bốn byte nhờ trần .

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

Hãy thử trực tuyến!

JavaScript ES6, 103 byte

Sử dụng thay thế 103 byte:

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

Hãy thử trực tuyến!

Sử dụng phân tách và ánh xạ 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)

Hãy thử trực tuyến!

Perl 5 -p , 47 byte

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

Hãy thử trực tuyến!

Python 3 , 77 byte

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

Hãy thử trực tuyến!

Toán học, 111 91 byte

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

Dùng thử trực tuyến!

Điều này đã được rút ngắn đáng kể nhờ các chỉnh sửa của Misha .

Mã ban đầu của tôi:

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

Mã này không được ưa thích lắm nhưng có vẻ quá tốn kém để chuyển đổi khỏi chuỗi và sau đó quay lại hoặc làm bất cứ điều gì khác thông minh.

Đặc biệt, chỉ với 3-4 lệnh có tên String, cách tiếp cận ban đầu của tôi không thể lưu byte bằng cách cố gắng trừu tượng hóa nó. Ví dụ: sau đây là 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)}

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một chuỗi và in oreo, với ocookie và rdưới dạng kem.

Giải trình:

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

Sử dụng =cho cookie và ~cho điền.

Hãy thử trực tuyến.

Giải trình:

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

Các giải pháp trên sử dụng một thay thế. Thay vào đó, ánh xạ qua các ký tự của đầu vào:

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 nhờ @Neil .

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử trực tuyến!

NGOÀI. Tên hàm waaaay_too_long của PHP lại tấn công!

Đầu ra:

$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

Cảm ơn @gwaugh -9 Byte
Cảm ơn @manatwork -2 Byte

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

Hãy thử trực tuyến!

Hãy thử trực tuyến! (87 byte)

Hãy thử trực tuyến (đệ trình 97 byte gốc)!

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

Hãy thử trực tuyến! (đệ quy)

JavaScript, 72 65 64 byte

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

Dùng thử trực tuyến

Powershell, 71 69 66 byte

-2 byte cảm ơn @Veskah

-3 byte cảm ơn @AdmBorkBork

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

Kịch bản kiểm tra ít chơi gôn hơn:

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

Đầu ra:

True
True
True
True
True

Than , 19 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆθ

Lặp qua các ký tự của chuỗi đầu vào.

≡ι

Bật từng nhân vật.

o⟦⭆θ#⟧

Nếu đó là một chuỗi othì in chuỗi đầu vào được thay thế bằng #s trên dòng riêng của nó.

e«→Ｐ⁻Ｌθ²↙

Nếu đó là edi chuyển sang phải, hãy in một dòng -nhỏ hơn hai chiều dài của chuỗi đầu vào, sau đó di chuyển xuống và sang trái.

Bash, 87 byte

Không có sed:

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

Cảm ơn @manatwork.

Với 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 # (Trình biên dịch tương tác Visual C #) , 71 byte

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

Hãy thử trực tuyến!

Mượn một số ý tưởng từ câu trả lời của Embodiment of Ignorance .

-6 byte nhờ @ASCIIOnly!

Khái niệm tổng thể là tính toán một chuỗi tổng hợp trên các ký tự đầu vào theo các quy tắc sau:

• Nếu rgặp phải, nối thêm một ký tự khoảng trắng để thụt lề. Chúng tôi biết nhân vật tiếp theo sẽ là một e.
• Nếu gặp phải một ohoặc emột chuỗi, hãy tạo một chuỗi bằng cách lặp lại ký tự hiện tại một số lần cụ thể và thêm nó vào một dòng mới hoặc một số phần đệm và một dòng mới.
• Số lần lặp lại được xác định theo độ dài của chuỗi đầu vào và liệu dòng hiện tại có được thụt lề hay không.
• Các PadLeftchức năng được sử dụng để tạo ra các chuỗi ký tự lặp lại.

Kết quả là sự kết hợp của tất cả các chuỗi này.

Bình thường , 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 " "

Hãy thử nó ở đây! Cái này sử dụng một vòng lặp.

Bình thường, 30 byte

(Như chuỗi thay thế)

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

Hãy thử nó ở đây! Cái này sử dụng thay thế chuỗi.

Tôi thực sự thích python (đó là những gì tôi đã viết kịch bản thử nghiệm ban đầu của mình), vì vậy tôi nghĩ rằng tôi sẽ làm một mục thứ ba cho vui :)

Ruby , 62 60 byte

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

Hãy thử trực tuyến!

Sử dụng Ocho cookie, *để điền.

-1 nhờ @manatwork chỉ ra một lỗi ngớ ngẩn và -1 khác do nới lỏng các quy tắc về khoảng trắng.

C # (.NET Core) , 143 byte

Không có 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;};

Hãy thử trực tuyến!

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

Tôi không sử dụng các ký tự đẹp trong bản in trong phiên bản golf vì chúng đắt tiền. Trả về một chuỗi được in.

Hãy thử trực tuyến!

Xem bên dưới để giải thích.

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

Phi tiêu , 120 106 107 byte

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

Hãy thử trực tuyến!

• +1 byte: Đã thêm khoảng trắng theo sau

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)

Hãy thử trực tuyến!

Phần bên ngoài của cookie là 'o' và phần điền là 'r'.

mã máy 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

Hàm x86-64 này đưa con trỏ đến chuỗi đầu vào trong rsi và xây dựng đầu ra bắt đầu từ con trỏ trong rdi (đây là các thanh ghi được sử dụng để truyền hai đối số đầu tiên từ hàm C trên Linux). Để thuận tiện, tôi đã viết một trình bao bọc C ++ cho việc này cũng giúp khử trùng đầu vào tốt và in đầu ra. Mã đó có thể được đặt ở đây . Điều này cũng cho thấy tập hợp cú pháp ban đầu mà tôi đã viết cho chức năng này (cũng như phiên bản không chơi gôn mà tôi đã làm việc trước tiên).

Một vài điều cần lưu ý là mã này không tôn trọng bất kỳ thanh ghi lưu nào của callee, điều đó có nghĩa là mã C ++ có thể sẽ bị sập nếu chạy một lúc sau khi gọi hàm này. Trên máy của tôi thì không, nhưng điều đó khá đáng ngạc nhiên. Tôi cũng không thêm một byte null để phân định chuỗi đầu ra và thay vào đó, không gian được phân bổ cho chuỗi đầu ra được điền sẵn các byte. (Nếu điều này không được phép, tôi có thể thêm bộ kết thúc null với chi phí 3 byte).

Logic cho mã này về cơ bản là đếm độ dài của chuỗi, sau đó xây dựng một dòng có độ dài này cho mỗi ký tự 'o' và 'r' được thấy trong chuỗi đầu vào, sau đó cho bất kỳ ký tự 'e' nào được nhìn thấy, thay thế ký tự đầu tiên và các ký tự cuối cùng trên dòng trước với các ký tự khoảng trắng.

Tôi không thể tìm thấy bất cứ nơi nào trực tuyến để biên dịch và chạy hỗn hợp mã nguồn C ++ và mã nguồn, vì vậy tôi có thể viết một số mã trình bao bọc nhỏ để làm điều này để chứng minh rằng nó hoạt động. Nếu không, bạn sẽ có thể biên dịch và chạy nó với makefile trong liên kết tôi đã đưa ra bằng lệnh:

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

Tôi đã có thể định dạng lắp ráp thành một cái gì đó được chấp nhận bởi gcc, vì vậy hãy thử trực tuyến!