Oreoorererereoo

"Oreo" kelimesine benzer bir giriş dizgesi verildiğinde, giriş dizesi kadar geniş bir çerezin ASCII gösterimini verin (çerezlerin stabilitesini sağlamak için).

kurallar

• Girdi, "o" ve "re" dizelerinin herhangi bir birleşimini içeren ve yalnızca bu dizeleri içeren beyaz boşluk içermeyen boş olmayan bir dizedir.
• "O" dizgisi katı çerezi temsil ederken, "re" dizgisi dolguyu temsil eder.
• Çıktı, giriş dizgisi kadar geniş bir yığılmış çerez olmalıdır.
• Çıktı bir dizi dizgi olmayabilir
• Çerez, her iki taraftaki dolguyu bir karakter ile üst üste getirmelidir
• Çıktı için kullanılan karakterlerin aşağıdaki çıktıyla eşleşmesi gerekmez (█ ve ░), çerezin iki kısmı için farklı boşluk olmayan karakterler olması gerekir
• Dolgunun sol tarafındaki boşluk doldurma gereklidir ve izleyen boşluklar isteğe bağlıdır

Örnekler

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Bu kod golf olduğundan, en kısa cevap kazanır, iyi şanslar :)

Jöle ,  16 14  13 bayt

-1 Outgolfer Erik'e teşekkürler

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

1Krema ve 0çerez için kullanır .

Çevrimiçi deneyin!

Nasıl?

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

Önceki 16 bayt:

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

Kullanımları rc için rrüyalarin ve oc için oOkie.

Çevrimiçi deneyin!

Pepe , 364 bayt

Maalesef, çevrimiçi tercüman yorumları sıkıştırmayla ilgilenmez, bu nedenle tüm okarakterler bir boşlukla değiştirilir. Ne boşluk ne ode gerekli değildir, bu yüzden bu 295 bayt olabilir, ama daha çok hoşuma gitti:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Çevrimiçi deneyin!

Ungolfed

Kaçırdığım bayraklarla bazı golf fırsatları olabilir , ama şimdilik bittim:

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

Tuval , 19 18 17 bayt

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

Burada dene!

S girişinden ：r≠＊┤］kaldırmak için can sıkıcı uzun kodunu kullanırr

Japt -R , 16 15 bayt

re ¬£çX sX²èrÃû

Dene

                    :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

Alternatifler

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

C # (Visual C # Etkileşimli Derleyici) , 95 bayt

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

Çevrimiçi deneyin!

Agrega kullanarak alternatif, 108 bayt

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

Çevrimiçi deneyin!

R , 106 bayt

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

Çevrimiçi deneyin!

• @Giuseppe sayesinde -12 bayt

Açıklama ile önceki sürüm:

R , 118 bayt

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

Çevrimiçi deneyin!

• @Giuseppe sayesinde -1 bayt

Kontrolsüz kod ve açıklama:

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 bayt

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

@Emigna sayesinde -1 bayt

oÇerez ve rdoldurma için kullanır .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Çok uzun zamandır bir cevap göndermemiş gibi hissediyorum. İşte buradayım. Ayrıca, Retina çok değişti ve şimdi emiyormuş gibi hissediyorum.

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

o|r
$&¶
_$

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

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

m`^r
 

Çevrimiçi deneyin!

Retina , 21 bayt

r

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

Çevrimiçi deneyin! Açıklama:

r

S silin r.

L$`.
$.+*$&

Her bir harfi, orijinal girişin uzunluğuna kadar tekrarlanan kendi satırında listeleyin.

\bee
 

eeHer satırdaki ilk iki s'yi bir boşlukla değiştirin.

C (gcc) , 135 113 109 104 bayt

• Kaydedilen yirmi-iki -e doğru yirmi-yedi bayt sayesinde NieDzejkob .
• Ceilingcat sayesinde dört byte kurtarıldı .

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

Çevrimiçi deneyin!

JavaScript ES6, 103 bayt

103 bayt yerine:

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

Çevrimiçi deneyin!

Bölünmüş ve eşleme 116 bayt kullanma:

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

Çevrimiçi deneyin!

Perl 5 -p , 47 bayt

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

Çevrimiçi deneyin!

Python 3 , 77 bayt

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

Çevrimiçi deneyin!

Mathematica, 111 91 bayt

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

Çevrimiçi Deneyin!

Bu Majorly sayesinde kısaltılmıştır Misha 'ın düzenlemeler .

Orijinal kodum:

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

Bu kod çok süslü değil ancak dizelerden uzaklaşmak ve sonra geri dönmek ya da zekice bir şey yapmak çok pahalı görünüyor.

Özellikle, String adını taşıyan yalnızca 3-4 komutla orijinal yaklaşımım, onu soyutlamaya çalışarak baytları hiçbir zaman kaydedemedi. Örneğin, aşağıdakiler 129 bayttır:

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

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

Çevrimiçi deneyin!

Bir dize alan ve oreoyu, oçerez ve rkrem olarak basan anonim kod bloğu .

Açıklama:

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

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

=Çerez ve ~doldurma için kullanır .

Çevrimiçi deneyin.

Açıklama:

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

Yukarıdaki çözüm bir yerine kullanır. Bunun yerine, girişin karakterleri üzerinden haritalanır:

Java 11, 113 112 bayt

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

@Neil sayesinde -1 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

OUCH. PHP'nin waaaay_too_long işlev isimleri tekrar grev!

Çıktı:

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

@Gwaugh -9 Bytes
sayesinde @manatwork -2 Bytes sayesinde

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

Çevrimiçi deneyin!

Çevrimiçi deneyin! (87 Bayt)

Çevrimiçi deneyin (orijinal 97 bayt gönderim)!

PHP , 135 bayt

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

Çevrimiçi deneyin! (Yinelemeli)

JavaScript, 72 65 64 bayt

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

Çevrimiçi deneyin

Powershell, 71 69 66 bayt

-2 bayt teşekkürler @Veskah

-3 bayt teşekkürler @AdmBorkBork

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

Daha az golf test testi senaryosu:

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

Çıktı:

True
True
True
True
True

Kömür , 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｆθ

Giriş dizesinin karakterleri arasında dolaşın.

≡ι

Her karakteri aç.

o⟦⭆θ#⟧

Eğer öyleyse o, #s ile değiştirilen giriş dizesini kendi satırında yazdır .

e«→Ｐ⁻Ｌθ²↙

eSonra bir sağa hareket ederse -, giriş dizesinin uzunluğundan iki kat daha az bir s satırı yazdırın , sonra aşağı ve sola hareket ettirin.

Bash, 87 bayt

Olmadan sed:

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

@ Manatwork sayesinde.

İle sed(90 bayt):

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 # Etkileşimli Derleyici) , 71 bayt

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

Çevrimiçi deneyin!

Ignorance'ın cevabını somutlaştırma konusundaki fikirlerinden kesin olarak ödünç alınmış .

@ASCIIOnly sayesinde -6 bayt!

Genel kavram, bu kurallara uyarak giriş karakterleri üzerinde bir dize toplamı hesaplamaktır:

• Bir rkarşılaşırsanız, girinti için tek bir boşluk karakteri ekleyin . Bir sonraki karakterin olacağını biliyoruz e.
• Eğer bir oveya bir eile karşılaşılırsa, mevcut karakteri belirli sayıda tekrarlayarak ve onu yeni bir satıra veya bir takım dolguyu ve yeni bir satıra hazırlayarak bir dize oluşturun.
• Yinelenecek zaman sayısı, girdi dizesinin uzunluğuna ve geçerli satırın girintili olup olmadığına göre belirlenir.
• PadLeftFonksiyonu yinelenen karakter dize oluşturmak için kullanılır.

Sonuç, tüm bu dizelerin birleştirilmesidir.

Pyth , 28 bayt

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

Burada dene! Bu bir döngü kullanır.

Pyth, 30 bayt

(Dize değiştirilirken)

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

Burada dene! Bu dize değiştirme kullanır.

Python'u gerçekten seviyorum (orijinal test senaryolarımı yazdım), bu yüzden eğlenmek için bir pyth girişi yapacağımı düşündüm :)

Ruby , 62 60 bayt

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

Çevrimiçi deneyin!

OÇerez *için, doldurma için kullanır .

@ Manatwork ile aptalca bir hataya işaret eden -1 ve boşluklarla ilgili kuralların gevşetilmesi nedeniyle -1.

C # (.NET Core) , 143 bayt

LINQ olmadan.

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

Çevrimiçi deneyin!

Clojure , 137 bayt

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

Çıktıdaki hoş karakterleri golf sürümlerinde kullanmıyorum, çünkü bunlar pahalı. Yazdırılacak bir dize döndürür.

Çevrimiçi deneyin!

Açıklama için aşağıya bakınız.

Ön 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 bayt

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

Çevrimiçi deneyin!

• +1 bayt: Eklenen sondaki boşluk

Python 2 , 77 76 72 bayt

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

Çevrimiçi deneyin!

Çerezin dış kısmı 'o' ve doldurma 'r'.

x86-64 makine kodu (Linux), 97 bayt

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

Bu x86-64 işlevi, göstergede rsi içindeki girdi dizgisini alır ve göstergeden başlayan çıktıyı rdi olarak oluşturur (bunlar ilk iki argümanı Linux'taki bir C işlevinden geçirmek için kullanılan kayıtlardır). Kolaylık sağlamak için, bunun için hoş bir giriş temizliği de sağlayan ve çıktıyı basan bir C ++ sargısı yazdım. Bu kod burada bulunabilir . Bu aynı zamanda, bu işlev için yazdığım orijinal nasm sözdizimi derlemesini (ilk önce çalıştığım golf oynamayan versiyonun yanı sıra) gösterir.

Unutulmaması gereken birkaç nokta, bu kodun, kaydedilmiş kayıtların kaydedilmediklerine saygı göstermemesidir; bu, C ++ kodunun, bu işlevi çağırdıktan sonra bir süre çalıştırılırsa muhtemelen çökeceği anlamına gelir. Makinemde değil, ama bu oldukça şaşırtıcı. Ayrıca çıktı dizesini sınırlandırmak için boş bir bayt eklemem, bunun yerine çıktı dizesi için ayrılan alan baytlarla önceden doldurulur. (Eğer buna izin verilmezse, boş sonlandırıcıyı 3 byte ekleyebilirim).

Bu kodun mantığı, esas olarak dizenin uzunluğunu saymaktır, daha sonra bu dizginin giriş dizisinde görülen her 'o' ve 'r' karakterleri için bir çizgi oluşturması ve daha sonra, herhangi bir 'e' karakteri için, ilk yerine ve önceki satırdaki son karakterlerle boşluk karakterleri.

C ++ ve nasm kaynak kodunun bir karışımını derleyip çalıştıracak çevrimiçi bir şey bulamıyorum, bu yüzden bunun işe yaradığını ispatlamak için bazı küçük sarmalayıcı kodları yazabilirim. Aksi halde, bu komutu komutla verdiğim bağlantıdaki makefile ile derleyebilmeli ve çalıştırabilmelisiniz:

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

Düzeneği gcc tarafından kabul edilebilir bir şeye biçimlendirebildim, bu yüzden çevrimiçi deneyin!