Oreoorererereoo

60

Oreoorererereoo

Dada una cadena de entrada que es similar a la palabra "oreo", proporcione una representación ASCII de la cookie que sea tan ancha como la cadena de entrada (para garantizar la estabilidad de la cookie).

Reglas

  • La entrada es minúscula, una cadena no vacía sin espacios en blanco que contiene cualquier combinación de las cadenas "o" y "re", y que contiene solo esas cadenas.
  • La cadena "o" representa la cookie sólida, mientras que la cadena "re" representa el relleno.
  • La salida debe ser una cookie apilada que sea tan ancha como la cadena de entrada.
  • La salida puede no ser una matriz de cadenas
  • La cookie debe superponerse al relleno por un carácter en cada lado
  • Los caracteres utilizados para la salida no tienen que coincidir con la salida a continuación (█ y ░), solo tienen que ser diferentes caracteres que no sean espacios en blanco para las dos partes de la cookie
  • Se requiere el relleno de espacios en blanco en el lado izquierdo del relleno, y cualquier espacio en blanco final es opcional

Ejemplos

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Dado que este es el código de golf, la respuesta más corta gana, buena suerte :)

GammaGames
fuente
3
"Se requiere el relleno de espacios en blanco en cada lado del relleno". ¿Esto realmente significa que debe haber un carácter de espacio al final de cada línea de relleno? Si es así, ¿por qué? Mientras funcione visualmente, ¿qué agrega este requisito al desafío?
ElPedro
@ ElPedro Buen punto, modifiqué las reglas y @Dennis las edité para que los comentarios estén bien para limpiar
GammaGames
@JonathanAllan Dado que está imprimiendo "ascii-art", eliminé esa regla, parece que olvidé actualizar la pregunta. Debería actualizarse ahora.
GammaGames
¡Genial gracias!
Jonathan Allan
@GammaGames, si ya no se requieren espacios en blanco a la derecha, supongo que la salida para el caso de prueba redebería ser ahora aceptable 1 or 2 spaces, ¿no necesariamente 2?
Kirill L.

Respuestas:

15

Jalea ,  16 14  13 bytes

-1 Gracias a Erik the Outgolfer

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

Usos 1para la crema y 0para la galleta.

Pruébalo en línea!

¿Cómo?

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

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

Usos rpara el c ream y opara el c ookie.

Pruébalo en línea!

Jonathan Allan
fuente
Esperaba una entrada de Jelly, ¡un lenguaje tan interesante!
GammaGames
19

Pepe , 364 bytes

Desafortunadamente, el intérprete en línea no se encarga de comprimir los comentarios, por lo tanto, todos los ocaracteres serán reemplazados por un espacio ... Ni los espacios ni los oson necesarios, por lo que esto podría ser de 295 bytes, pero me gusta más de esta manera:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Pruébalo en línea!

Sin golf

Puede haber algunas oportunidades de golf con banderas que me perdí, pero ya he terminado:

# "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
ბიმო
fuente
1
Me mudé a esta conversación de chat para usted.
DJMcMayhem
9

Lienzo , 19 18 17 bytes

e ∙╋
:r≠*┤];L×⁸↔⁸

Pruébalo aquí!

Utiliza el código largamente molesto de :r≠*┤]eliminar rs de la entrada.

dzaima
fuente
¡Esa es una característica útil y un lenguaje genial!
GammaGames
7

Japt -R , 16 15 bytes

re ¬£çX sX²èrÃû

Intentalo

                    :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

Alternativas

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

C # (compilador interactivo de Visual C #) , 95 bytes

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

Pruébalo en línea!

Alternativa usando Agregado, 108 bytes

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

Pruébalo en línea!

Encarnación de la ignorancia
fuente
1
ahora recorta los espacios finales ..
dzaima
Hubo suficientes comentarios que eliminé la regla de nueva línea final. Siéntase libre de actualizar su entrada.
GammaGames
Su reemplazo no funciona cuando la entrada es o, ya que el n.Length-2resultado será -1.
Kevin Cruijssen
El n.Length-2es para cuando la entrada tiene re.
Encarnación de la ignorancia
6

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

Pruébalo en línea!

  • -12 bytes gracias a @Giuseppe

Versión anterior con explicación:

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

Pruébalo en línea!

  • -1 byte gracias a @Giuseppe

Código desenrollado y explicación:

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
}
digEmAll
fuente
106 bytes
Giuseppe
aa y 104 bytes que devuelven una lista de líneas, lo cual no es aceptable aquí, pero es una idea interesante (esencialmente mi envío SNOBOL traducido a R)
Giuseppe
6

05AB1E , 18 17 16 bytes

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

-1 byte gracias a @Emigna

Usos opara la galleta y rpara el relleno.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

'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"
Kevin Cruijssen
fuente
Solución creativa, pero no resuelve el problema por completo: oro daría una respuesta incorrecta
Mark Smit
@ MarkSmit orono es una entrada posible, ya que la entrada solo contendrá osy res. De todos modos, orotodavía parece salir correctamente siguiendo la especificación, ya queooo\n r\nooo sale . ¿Qué tiene de malo?
Kevin Cruijssen
Esto no es válido: "Se requiere el relleno de espacios en blanco en cada lado del relleno"
NieDzejkob
2*puede ser ·y el espacio en blanco que falta puede ».c.c.B»
repararse
@Emigna Ah, no puedo creer que no haya pensado ·, ¡gracias! :) Y siempre es bueno tener especificaciones cambiantes durante el desafío, suspiro ..
Kevin Cruijssen
5

Retina , 74 73 bytes

Siento que no he publicado una respuesta en mucho tiempo. Pues aquí estoy. Además, Retina ha cambiado mucho, y siento que ahora soy un asco.

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

o|r
$&¶
_$

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

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

m`^r
 

Pruébalo en línea!

mbomb007
fuente
1
Whoa, qué lenguaje tan loco. ¡Me gusta!
GammaGames
no incluye espacios en blanco al final ..
dzaima
2
Me gusta cómo [or]significa oo en rlugar de [o ]. Me duele la cabeza.
nedla2004
@dzaima La pregunta no especifica que se requieren espacios en blanco al final. Un comentario preguntó, pero no se dio respuesta.
mbomb007
@ nedla2004 Eso realmente me ayudó a notar una forma de guardar un byte. Gracias.
mbomb007
5

Retina , 21 bytes

r

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

Pruébalo en línea! Explicación:

r

Eliminar el rs.

L$`.
$.+*$&

Liste cada letra en su propia línea repetida a la longitud de la entrada original.

\bee
 

Reemplace los primeros dos ees en cada línea con un espacio.

Neil
fuente
Esto rompe las reglas: "Se requiere el relleno de espacios en blanco en cada lado del relleno"
NieDzejkob
@NieDzejkob Perdón por pasar por alto eso, debería arreglarse ahora.
Neil
Para su información, se eliminó el requisito de espacio en blanco al final.
Jacktose
@Neil Deberías arreglar eso &amp;: P
Solo ASCII
5

C (gcc) , 135 113 109 104 bytes

  • Guardado veintidós veintisiete bytes gracias a NieDzejkob .
  • Guardado cuatro bytes gracias a 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));}

Pruébalo en línea!

Jonathan Frech
fuente
-D$=putchar
131 bytes si agrega una nueva línea final según lo permitido por las reglas.
NieDzejkob
127 bytes si mueve el e=oa la condición del primer bucle for y luego elimina el resto.
NieDzejkob
118 bytes si elige la cookie y los caracteres de relleno con cuidado.
NieDzejkob
113 bytes
NieDzejkob
4

JavaScript ES6, 103 bytes

Usando reemplazar 103 bytes:

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

Pruébalo en línea!

Usando dividir y asignar 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)

Pruébalo en línea!

fəˈnɛtɪk
fuente
1
JS, bien! Me recordó que iba a agregar una regla sobre no tener retornos de línea al final de la salida, la agregué. ¡Lo siento por eso!
GammaGames
3
simplemente eliminar la nueva línea final es de 12 bytes
fəˈnɛtɪk
Hubo suficientes comentarios que eliminé la regla de nueva línea final. Siéntase libre de actualizar su entrada.
GammaGames
3
Puede guardar un byte usando una cadena de plantilla con ${"|".repeat(s>1?s-2:0)}y sus espacios en blanco, en lugar de usar " "+"|".repeat(s>1?s-2:0).
Ismael Miguel
Si usa los backticks para la cadena en la primera división, puede eliminar los paréntesis a su alrededor.
skiilaa
4

Perl 5 -p , 47 bytes

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

Pruébalo en línea!

Xcali
fuente
Esto rompe las reglas: "Se requiere el relleno de espacios en blanco en cada lado del relleno"
NieDzejkob
con algunas variaciones tio.run/##K0gtyjH9/…
Nahuel Fouilleul
4

Python 3 , 77 bytes

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

Pruébalo en línea!

Rɪᴋᴇʀ
fuente
¡Inteligente! Tenía la intención de que la salida no imprimiera espacios en blanco para el relleno (es casi oreo ascii), por lo que he editado las reglas en consecuencia. ¡Lo siento por eso! Y siempre me encanta una respuesta de Python :)
GammaGames
@JonathanFrech migth también eliminó los comentarios, ese enfoque fue invalidado. Trabajaré más en golf mañana.
Rɪᴋᴇʀ
Puede eliminar el espacio en +" \n"para guardar un byte.
Kevin Cruijssen
@KevinCruijssen puedo? El programa de entrada dice que toda la cookie debe ser tan ancha como la entrada.
Rɪᴋᴇʀ
2
Interpreté que significa que un espacio final es lo mismo (visualmente) que ningún espacio. Esa es la belleza de las respuestas a los desafíos de arte ascii. Si se ven bien, tienen razón :-)
ElPedro
4

Mathematica, 111 91 bytes

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

¡Pruébelo en línea!

Esto se acortó principalmente gracias a las ediciones de Misha .


Mi código original:

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

Este código no es muy sofisticado, pero parece demasiado caro para convertirlo en cadenas y luego volverlo a hacer o hacer cualquier otra cosa inteligente.

En particular, con solo 3-4 comandos que tienen el nombre de Cadena, mi enfoque original no pudo guardar bytes en absoluto al tratar de abstraerlo. Por ejemplo, el siguiente es 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"})&
Marcas.
fuente
1
Algunas mejoras: StringRepeatpuede ser Tableporque <>convertirá la lista en una cadena más tarde; el Ifes innecesaria, ya que se toma la rerama sólo cuando nes al menos 2; podemos ahorrar en paréntesis definiendo nsolo cuando lo usamos. Pruébalo en línea!
Misha Lavrov
@MishaLavrov Se Ifagregó porque StringRepeatarrojaría un error en el caso de "re"; no le permite repetir una cadena 0 veces. Tableno tiene esa limitación, ¡así que es un gran ahorro!
Mark S.
4

Perl 6 , 37 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una cadena e imprime el oreo, con ola galleta y rla crema.

Explicación:

{                                   }   # 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
Jo King
fuente
No me di cuenta de que opodría usarse en lugar de . Muy bien golfizado.
primo
4

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

Usos =para la galleta y ~para el relleno.

Pruébalo en línea.

Explicación:

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 solución anterior utiliza un reemplazo. Los siguientes mapas sobre los caracteres de la entrada en su lugar:

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 gracias a @Neil .

Pruébalo en línea.

Explicación:

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"
Kevin Cruijssen
fuente
1
Puedes usar ~c&1?
Neil
@Neil sí puedo, gracias.
Kevin Cruijssen
Esto no es válido: "Se requiere el relleno de espacios en blanco en cada lado del relleno"
NieDzejkob
@NieDzejkob Corregido ... Siempre es bueno tener especificaciones cambiantes durante el desafío, suspiro ...
Kevin Cruijssen
@KevinCruijssen ya no: P
Solo ASCII
4

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

Pruébalo en línea!

AY. ¡Los nombres de funciones waaaay_too_long de PHP vuelven a aparecer!

Salida:

$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
640 KB
fuente
Las líneas de crema no son válidas necesitan un espacio final
solo ASCII el
Se corrigió el espacio final. ¡Gracias!
640 KB
1
¡Oh muchacho, PHP! Además, cualquier espacio en blanco final ahora es opcional, había suficientes personas que señalaron que, dado que está imprimiendo ascii, realmente no debería ser necesario.
GammaGames
4

PHP , 96 87 85 bytes

Gracias a @gwaugh -9 Bytes
Gracias a @manatwork -2 Bytes

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

Pruébalo en línea!

Pruébalo en línea! (87 bytes)

¡Pruébelo en línea (presentación original de 97 bytes)!


Y una función recursiva

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

Pruébalo en línea! (recursivo)

Francisco Hahn
fuente
1
Al combinar lo mejor de nuestras dos presentaciones, pude reducirlo a 87 bytes TIO . ¿Sería un juego para entrar en esto como una presentación colaborativa? :)
640KB
1
Creo que podemos eliminar 1 byte más usando el comando short_tag_open, y en lugar de <?=eso podemos usar <?, ¿o me equivoco?
Francisco Hahn
1
2 caracteres más cortos con interpolación de cadenas: ' '.$r(o,$l-2)."␤"" {$r(o,$l-2)}␤".
manatwork
Gracias @manatwork a veces se me olvidó que los php vars se evalúan en una cadena si se declara la cadena completa en ""lugar de''
Francisco Hahn
1
Esto puede ser 3 bytes más corto usando $argn: ¡ Pruébelo en línea!
Noche2
4

JavaScript, 72 65 64 bytes

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

Pruébalo en línea

Lanudo
fuente
4

Powershell, 71 69 66 bytes

-2 bytes gracias @Veskah

-3 bytes gracias @AdmBorkBork

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

Menos guión de prueba de golf:

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

Salida:

True
True
True
True
True
mazzy
fuente
1
Parece que no necesita parens alrededor de los $args 69 bytes
Veskah
1
La longitud de [string[]]es un [int[]]... El [int[]]es [int]si la matriz contiene un solo elemento. ¡Excelente! ¡Gracias!
mazzy
1
El OP actualizó el desafío para que ya no necesite espacios finales. Esto significa que rpuede ser " "+'%'*($l-2)en su lugar para -3 bytes.
AdmBorkBork
3

Carbón de leña , 19 bytes

Fθ≡ιo⟦⭆θ#⟧e«→P⁻Lθ²↙

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Fθ

Recorre los caracteres de la cadena de entrada.

≡ι

Enciende cada personaje.

o⟦⭆θ#⟧

Si es un o, imprima la cadena de entrada reemplazada por #s en su propia línea.

e«→P⁻Lθ²↙

Si es un emovimiento hacia la derecha, imprima una línea de -s que sea dos menos que la longitud de la cadena de entrada, luego muévase hacia abajo y hacia la izquierda.

Neil
fuente
3

Bash, 87 bytes

Sin sed:

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

Gracias a @manatwork.

Con 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"
Verde
fuente
¿Podría mostrarnos alguna muestra de uso? Estoy un poco confundido por su función esperando 2 parámetros.
manatwork
Escribes eso en un guión llamado test.sh. A continuación, se llama a test.sh desde la línea de comandos de la siguiente manera: bash test.sh oreoorererereoo. fes necesario para repetir el $2 $1número de caracteres varias veces
Verde
Ups Entendí completamente mal la función f. Se podrían hacer algunos cambios menores allí: ¡ Pruébelo en línea!
manatwork
1
75 bytes.
Dennis
1
60 bytes
Nahuel Fouilleul
3

C # (compilador interactivo de Visual C #) , 71 bytes

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

Pruébalo en línea!

Tomó prestadas algunas ideas de la respuesta de Encarnación de la Ignorancia con seguridad.

-6 bytes gracias a @ASCIIOnly!

El concepto general es calcular un agregado de cadena sobre los caracteres de entrada siguiendo estas reglas:

  • Si rse encuentra un, agregue un solo carácter de espacio para la sangría. Sabemos que el próximo personaje será un e.
  • Si se encuentra una oo una e, genere una cadena repitiendo el carácter actual un número específico de veces y preponiéndola a una nueva línea o algún relleno y una nueva línea.
  • El número de veces para repetir está determinado por la longitud de la cadena de entrada y si la línea actual está sangrada.
  • La PadLeftfunción se utiliza para generar la cadena de caracteres repetitiva.

El resultado es la concatenación de todas estas cadenas.

dana
fuente
1
71
Solo ASCII
@ASCIIOnly - Gracias :)
dana
> Se requiere el relleno de espacios en blanco en cada lado del relleno
solo ASCII el
1
85?
Solo ASCII
No me di cuenta de eso :) Aunque, al revisar las respuestas publicadas, aproximadamente 1/2 también lo ha hecho incorrectamente. Buena captura sin embargo!
dana
3

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

Pruébalo aquí! Este usa un bucle.

Pyth, 30 bytes

(Como reemplazo de cadena)

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

Pruébalo aquí! Este usa reemplazo de cadena.

Realmente me gusta Python (es en lo que escribí mis scripts de prueba originales), así que pensé en hacer una entrada de Pyth por diversión :)

GammaGames
fuente
1
¿No son estos 37 bytes? Pensé que Pyth usa ASCII predeterminado como su página de códigos al igual que Python, si no recuerdo mal. Así que a pesar de que su código es de 33 caracteres, tanto y son tres bytes cada uno. ¿O me estoy perdiendo algo aquí?
Kevin Cruijssen
Buena decisión, no me di cuenta de eso (no pude hacer que Pyth funcionara en tio.run, así que usé el contador de longitud en la página de herokuapp). En el bucle for, podría reemplazar el carácter con N, ¡incluso ahorrando algunos bytes!
GammaGames
Pensé que algo así sucedió. :) Una vez tuve el mismo problema con una respuesta 05AB1E que usaba caracteres fuera de su página de códigos. Desafortunadamente, TIO muestra los caracteres y bytes de la misma manera para la mayoría de los idiomas de golf. Para Java o Python, TIO indicará correctamente 33 chars, 37 bytes, pero no en idiomas de golf en TIO. Pero en sus soluciones, solo cambiar esos caracteres realmente soluciona el problema, por lo que no es un gran problema aquí.
Kevin Cruijssen
@KevinCruijssen Espera, 05AB1E no usa un SBCS real?
Solo ASCII
1
Si estás interesado, parece que funciona sin esfuerzo en TIO para mí.
NieDzejkob
3

Ruby , 62 60 bytes

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

Pruébalo en línea!

Usos Opara la galleta, *para el relleno.

-1 gracias a @manatwork señalando un error tonto y otro -1 debido a la relajación de las reglas sobre espacios en blanco.

Kirill L.
fuente
No hay necesidad de paréntesis alrededor .gsubde los parámetros.
manatwork
2

C # (.NET Core) , 143 bytes

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

Pruébalo en línea!

Destroigo
fuente
2

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

No estoy usando los simpáticos personajes en la impresión en la versión de golf ya que son caros. Devuelve una cadena para imprimir.

Pruébalo en línea!

Vea a continuación la explicación.

Pre-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
Carcigenicate
fuente
2

Dart , 120 106 107 bytes

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

Pruébalo en línea!

  • +1 byte: espacio en blanco final agregado
Elcan
fuente
Esto no es válido: "Se requiere el relleno de espacios en blanco en cada lado del relleno"
NieDzejkob
Oh, no importa entonces, lo corregiré pronto. Gracias por la información, me la perdí
Elcan
2

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)

Pruébalo en línea!

La parte externa de la cookie es 'o' y el relleno es 'r'.

ElPedro
fuente
68 bytes . Aunque dudo si realmente puede omitir los espacios finales, la especificación dice "Se requiere el relleno de espacios en blanco en cada lado del relleno" ...
Erik the Outgolfer
Gracias @EriktheOutgolfer. ¡Pensé que una lambda sería más corta! Supongo que en este caso no. Había perdido el requisito sobre el espacio final obligatorio en el relleno. Realmente no puedo ver el punto con un desafío de arte ascii, pero si eso es lo que requiere OP, entonces supongo que mi respuesta no es válida de todos modos.
ElPedro
Ahora corregido ...
ElPedro
¿Por qué devolverlo a 76? Solo ponlo +' 'después (l-2). Además, tiene un error tipográfico, *' 'debe ser +' '.
Erik el Outgolfer
Eso es lo que hice con mi solución actual. Echaré un vistazo más de cerca a tus pistas mañana (más tarde hoy). Es tarde aquí y he estado palear nieve todo el día, muy cansado para jugar al golf. Aunque gracias por los consejos :)
ElPedro
2

Código de máquina x86-64 (Linux), 97 bytes

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

Esta función x86-64 toma el puntero a la cadena de entrada en rsi y construye la salida comenzando en el puntero en rdi (estos son los registros utilizados para pasar los dos primeros argumentos de una función C en Linux). Para mayor comodidad, he escrito un contenedor de C ++ para esto que también hace una buena desinfección de entrada e imprime la salida. Ese código se puede encontrar aquí . Esto también muestra el ensamblaje de sintaxis nasm original que escribí para esta función (así como la versión sin golf en la que trabajé primero).

Algunas cosas a tener en cuenta es que este código no respeta ningún registro guardado de la persona que llama, lo que significa que el código C ++ probablemente se bloqueará si se ejecuta durante un tiempo después de llamar a esta función. En mi máquina no, pero eso es bastante sorprendente. Tampoco agrego un byte nulo para delimitar la cadena de salida, y en su lugar, el espacio asignado para la cadena de salida se llena previamente con bytes. (Si esto no está permitido, puedo agregar el terminador nulo a un costo de 3 bytes).

La lógica de este código es esencialmente contar la longitud de la cadena, luego construir una línea de esta longitud para cada carácter 'o' y 'r' visto en la cadena de entrada, y luego para cualquier carácter 'e' visto, reemplazando el primero y últimos caracteres en la línea anterior con caracteres de espacio.

No puedo encontrar ningún lugar en línea para compilar y ejecutar una combinación de código fuente C ++ y nasm, por lo que podría escribir un pequeño código de envoltura para que esto demuestre que funciona. De lo contrario, debería poder compilar y ejecutar esto con el archivo MAKE en el enlace que le di con el comando:

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

Pude formatear el ensamblaje a algo aceptable por gcc, ¡así que pruébelo en línea!

davey
fuente
1
¡Oh, esto es una entrada!
GammaGames