Oreoorererereoo


60

Oreoorererereoo

Étant donné une chaîne d'entrée similaire au mot "oreo", donnez une représentation ASCII du cookie aussi large que la chaîne d'entrée (pour assurer la stabilité du cookie).

Règles

  • L'entrée est en minuscule, une chaîne non vide, sans espace, qui ne contient aucune combinaison des chaînes "o" et "re", et ne contient que ces chaînes.
  • La chaîne "o" représente le cookie solide, tandis que la chaîne "re" représente le remplissage.
  • La sortie doit être un cookie empilé aussi large que la chaîne d'entrée.
  • La sortie ne peut pas être un tableau de chaînes
  • Le cookie doit chevaucher le remplissage d'un caractère de chaque côté
  • Les caractères utilisés pour la sortie ne doivent pas nécessairement correspondre à la sortie ci-dessous (et), ils doivent simplement être différents caractères non-blancs pour les deux parties du cookie.
  • Le remplissage d'espaces sur le côté gauche du remplissage est requis et tout espace de fin est facultatif.

Exemples

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Puisqu'il s'agit de code golf, la réponse la plus courte l'emporte, bonne chance :)


3
"Le remplissage des espaces de chaque côté du remplissage est requis". Cela signifie-t-il réellement qu'il doit y avoir un caractère d'espace à la fin de chaque ligne de remplissage? Si oui, pourquoi? Tant que cela fonctionne visuellement, qu'est-ce que cette exigence ajoute au défi?
ElPedro

@ ElPedro Bon point, j'ai modifié les règles et @Dennis j'ai modifié les règles afin que les commentaires soient corrects à nettoyer
GammaGames

@ JonathanAllan Depuis qu'il est imprimé "ascii-art", j'ai supprimé cette règle, il semble que j'ai oublié de mettre à jour la question. Devrait être mis à jour maintenant.
GammaGames

Super merci!
Jonathan Allan

@ GammaGames, si les espaces à droite ne sont plus nécessaires, je suppose que la sortie pour le scénario de test redevrait maintenant être acceptable 1 or 2 spaces, pas nécessairement 2?
Kirill L.

Réponses:


15

Jelly ,  16 14  13 bytes

-1 Merci à Erik l'Outgoler

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

Utilisations 1pour la crème et 0pour le biscuit.

Essayez-le en ligne!

Comment?

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

Précédent 16 byter:

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

Utilisations rpour le c ream et opour le c ookie.

Essayez-le en ligne!


J'espérais une entrée de Jelly, une langue si intéressante!
GammaGames

19

Pepe , 364 octets

Malheureusement, l'interprète en ligne ne s'occupe pas de la compression des commentaires, donc tous les ocaractères seront remplacés par un espace. Ni les espaces ni les osont nécessaires, donc cela pourrait être 295 octets, mais j'aime mieux ça:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Essayez-le en ligne!

Ungolfed

Il y a peut-être quelques possibilités de golf avec drapeaux que j'ai ratées, mais j'ai terminé pour le moment:

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



7

Japt -R , 16 15 octets

re ¬£çX sX²èrÃû

L'essayer

                    :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

Des alternatives

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

6

C # (compilateur interactif Visual C #) , 95 octets

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

Essayez-le en ligne!

Alternative utilisant Agrégat, 108 octets

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

Essayez-le en ligne!


1
maintenant, il coupe les espaces de fuite ..
dzaima

Il y a eu suffisamment de commentaires pour supprimer la règle de fin de ligne récente. N'hésitez pas à mettre à jour votre entrée.
GammaGames

Votre remplacement ne fonctionne pas lorsque l'entrée est o, car le n.Length-2résultat en sera -1.
Kevin Cruijssen

L' n.Length-2est est pour quand l'entrée a re.
Incarnation de l'Ignorance

6

R , 106 octets

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

Essayez-le en ligne!

  • -12 octets grâce à @Giuseppe

Version précédente avec explication:

R , 118 octets

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

Essayez-le en ligne!

  • -1 octet grâce à @ Giuseppe

Code déroulé et explication:

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
}


aaand 104 octets renvoyant une liste de lignes, ce qui n’est pas acceptable ici, mais c’est une idée intéressante (essentiellement ma soumission SNOBOL traduite en R)
Giuseppe

6

05AB1E , 18 17 16 octets

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

-1 octet grâce à @Emigna

Utilisations opour le cookie et rpour le remplissage.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Solution créative, mais cela ne résout pas entièrement le problème: oro donnerait une mauvaise réponse
Mark Smit

@MarkSmit oron'est pas une entrée possible, car l'entrée ne contiendra que os et res. Quoi qu'il en soit, orosemble toujours sortir correctement en suivant la spécification, car il produitooo\n r\nooo . Quel est le problème à ce sujet?
Kevin Cruijssen

Ceci est invalide: "Le remplissage d'
espacement des

2*peut être ·et les espaces manquants peuvent être corrigés en changeant ».cà.c.B»
Emigna

@ Emigna Ah, je ne peux pas croire que je n'y ai pas pensé ·, merci! :) Et toujours agréable d'avoir les spécifications changeantes pendant le défi, soupir ..
Kevin Cruijssen

5

Retina , 74 73 octets

J'ai l'impression de ne pas avoir posté de réponse depuis très longtemps. Eh bien, je suis là. De plus, Retina a beaucoup changé et je sens que je suis nul à ça maintenant.

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

o|r
$&¶
_$

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

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

m`^r
 

Essayez-le en ligne!


1
Whoa, quelle langue à la folie. Je l'aime!
GammaGames

n'inclut pas les espaces en fin de
chemin

2
J'aime comment [or]signifie oou rau lieu de [ou ]. Me fait mal à la tête.
nedla2004

@dzaima La question ne précise pas que les espaces à la fin sont obligatoires. Un commentaire a demandé, mais aucune réponse n'a été donnée.
mbomb007

@ nedla2004 Cela m'a en fait aidé à trouver un moyen de sauvegarder un octet. Merci.
mbomb007

5

Retina , 21 octets

r

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

Essayez-le en ligne! Explication:

r

Supprimer le rs.

L$`.
$.+*$&

Listez chaque lettre sur sa propre ligne répétée à la longueur de l'entrée d'origine.

\bee
 

Remplacez les deux premiers ees sur chaque ligne par un espace.


Cela enfreint les règles: "Le remplissage en espaces blancs de chaque côté du remplissage est requis"
NieDzejkob

@NieDzejkob Désolé de laisser passer ça, devrait être corrigé maintenant.
Neil

Pour info, l'exigence d'espaces de fuite est levée.
Jacktose le

@Neil Vous devriez résoudre ce problème &amp;: P
le

5

C (gcc) , 135 113 109 104 octets

  • A sauvé vingt-deux vingt-sept octets grâce à NieDzejkob .
  • Sauvegardé quatre octets grâce à 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));}

Essayez-le en ligne!


-D$=putchar

131 octets si vous ajoutez une nouvelle ligne de fin, comme le permettent les règles.
NieDzejkob

127 octets si vous déplacez le e=oà la condition de la première boucle et supprimez le reste.
NieDzejkob

118 octets si vous choisissez le cookie et les caractères de remplissage avec soin.
NieDzejkob


4

JavaScript ES6, 103 octets

Utiliser replace 103 octets:

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

Essayez-le en ligne!

Utiliser split et mapper 116 octets:

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

Essayez-le en ligne!


1
JS, gentil! Vous m'avez rappelé que j'allais ajouter une règle pour ne pas avoir de retour à la ligne à la fin de la sortie, je l'ai ajoutée. Désolé pour ça!
GammaGames

3
il suffit de supprimer la fin de ligne finale, soit 12 octets
Date:

Il y a eu suffisamment de commentaires pour supprimer la règle de fin de ligne récente. N'hésitez pas à mettre à jour votre entrée.
GammaGames

3
Vous pouvez enregistrer un octet en utilisant un modèle de chaîne avec ${"|".repeat(s>1?s-2:0)}et ses espaces, au lieu de " "+"|".repeat(s>1?s-2:0).
Ismael Miguel

Si vous utilisez des pics pour la chaîne dans la première division, vous pouvez supprimer les parenthèses qui l'entourent.
skiilaa


4

Python 3 , 77 octets

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

Essayez-le en ligne!


Intelligent! J'avais bien l'intention que la sortie ne soit pas une impression d'espace pour le remplissage (c'est à peu près oreo ascii), j'ai donc modifié les règles en conséquence. Désolé pour ça! Et j'aime toujours une réponse en python :)
GammaGames

@JonathanFrech migth a également supprimé les commentaires, cette approche a été invalidée. Je travaillerai plus au golf demain.
Rɪᴋᴇʀ

Vous pouvez supprimer l’espace à +" \n"enregistrer un octet.
Kevin Cruijssen

@KevinCruijssen puis-je? Le programme d'entrée dit que le cookie entier doit être aussi large que l'entrée.
Rɪᴋᴇʀ

2
J'ai interprété cela comme signifiant qu'un espace de fuite est identique (visuellement) à l'absence d'espace. C’est la beauté des réponses aux défis de l’art ascii. S'ils ont l'air correct, ils ont raison :-)
ElPedro

4

Mathematica, 111 91 octets

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

Essayez-le en ligne!

Cela a été majorly raccourci grâce à Misha de modifications .


Mon code d'origine:

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

Ce code n’est pas très sophistiqué, mais il semble trop coûteux de se détourner des chaînes, puis de revenir en arrière ou de faire autre chose de malin.

En particulier, avec seulement 3 à 4 commandes nommées String, mon approche originale ne pouvait pas du tout économiser d'octets en essayant d'abstraire cela. Par exemple, 129 octets sont les suivants:

(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"})&

1
Quelques améliorations: StringRepeatpeut être Tablepuisque <>convertira la liste en chaîne plus tard; la Ifest inutile puisque nous ne prenons la rebranche que lorsque nest au moins 2; nous pouvons économiser sur les parenthèses en définissant nseulement quand nous l'utilisons. Essayez-le en ligne!
Misha Lavrov

@MishaLavrov The a Ifété ajouté car cela StringRepeatprovoquerait une erreur dans le cas de "re"; cela ne vous permet pas de répéter une chaîne 0 fois. Tablen'a pas une telle limitation, donc c'est un gros gain!
Mark S.

4

Perl 6 , 37 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend une chaîne et imprime l'oreo, avec ocomme cookie et rcomme crème.

Explication:

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

Je ne savais pas que je opouvais utiliser à la place de . Très bien joué au golf.
Primo

4

Java 11, 110 octets

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

Utilisations =pour le cookie et ~pour le remplissage.

Essayez-le en ligne.

Explication:

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 solution ci-dessus utilise un remplacement. Les éléments suivants mappent sur les caractères de l'entrée:

Java 11, 113 112 octets

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

-1 octet grâce à @Neil .

Essayez-le en ligne.

Explication:

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"

1
Pouvez-vous utiliser ~c&1?
Neil

@ Neil je peux en effet, merci.
Kevin Cruijssen le

Ceci est invalide: "Le remplissage d'
espacement des

@NieDzejkob fixe .. Toujours agréable d'avoir des spécifications changeantes pendant le défi, soupire ..
Kevin Cruijssen

@KevinCruijssen plus maintenant: P
ASCII seulement

4

PHP ,100 99 93 octets

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

Essayez-le en ligne!

AIE. Les noms de fonctions waaaay_too_long de PHP frappent encore!

Sortie:

$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

Les lignes de crème non valides nécessitent un espace de fuite
ASCII uniquement

Correction de l'espace de fuite. Merci!
640KB

1
Oh mon Dieu, PHP! De plus, tout espace blanc de fin est maintenant facultatif, il y avait suffisamment de personnes qui ont fait remarquer que, puisque l'impression est en ascii, cela ne devrait pas vraiment être nécessaire.
GammaGames

4

PHP , 96 87 85 octets

Merci à @gwaugh -9 octets
Merci à @manatwork -2 octets

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

Essayez-le en ligne!

Essayez-le en ligne! (87 octets)

Essayez-le en ligne (soumission originale de 97 octets)!


Et une fonction récursive

PHP , 135 octets

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

Essayez-le en ligne! (récursif)


1
en combinant le meilleur de nos deux soumissions, j'ai pu réduire le nombre d' octets à 87 octets . Seriez-vous prêt à accepter cette proposition en tant que soumission collaborative? :)
640Ko

1
Je pense que nous pouvons supprimer 1 octet supplémentaire en utilisant la commande short_tag_open, et au lieu de, <?=nous pouvons utiliser <?, ou est-ce que je me trompe?
Francisco Hahn

1
2 caractères plus courts avec interpolation de chaîne: ' '.$r(o,$l-2)."␤"" {$r(o,$l-2)}␤".
Manatwork le

Merci @manatwork parfois j'ai oublié php vars sont évalués dans une chaîne si la chaîne entière est déclarée avec ""istead de''
Francisco Hahn

1
Cela peut être plus court de 3 octets avec $argn: Essayez-le en ligne!
Nuit2


4

Powershell, 71 69 66 octets

-2 octets merci @Veskah

-3 octets merci @AdmBorkBork

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

Script de test moins joué:

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

Sortie:

True
True
True
True
True

1
On dirait que vous n'avez pas besoin de parens autour des $args 69 octets
Veskah

1
La longueur de [string[]]est un [int[]]... La valeur [int[]]est [int]si le tableau ne contient qu'un seul élément. Génial! Merci!
mazzy

1
Le PO a mis à jour le défi afin que vous n'ayez plus besoin d'espaces de fin. Cela signifie que vous rpouvez être à la " "+'%'*($l-2)place pour -3 octets.
AdmBorkBork

3

Charbon de bois , 19 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

Fθ

Boucle à travers les caractères de la chaîne d'entrée.

≡ι

Allumez chaque personnage.

o⟦⭆θ#⟧

S'il s'agit d'un, oimprimez la chaîne d'entrée remplacée par #s sur sa propre ligne.

e«→P⁻Lθ²↙

S'il s'agit d'un edéplacement vers la droite, imprimez une ligne de -s de deux fois moins que la longueur de la chaîne d'entrée, puis déplacez-vous vers le bas et la gauche.


3

Bash, 87 octets

Sans sed:

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

Merci à @manatwork.

Avec sed(90 octets):

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

Pourriez-vous nous montrer un exemple d'utilisation? Je suis un peu confus par votre fonction qui attend 2 paramètres.
Manatwork

Vous écrivez cela dans un script appelé test.sh. Ensuite, vous appelez test.sh de la ligne de commande comme suit: bash test.sh oreoorererereoo. fest nécessaire pour répéter le $2 $1nombre de caractères
Vert

Oops. J'ai complètement mal compris la fonction f. Quelques modifications mineures supplémentaires pourraient y être apportées: Essayez-le en ligne!
Manatwork



3

C # (compilateur interactif Visual C #) , 71 octets

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

Essayez-le en ligne!

Emprunté quelques idées sur la réponse de Incarnation of Ignorance à coup sûr.

-6 octets grâce à @ASCIIOnly!

Le concept général consiste à calculer un agrégat de chaîne sur les caractères en entrée en respectant les règles suivantes:

  • Si un rest rencontré, ajoutez un caractère d' espacement unique pour l'indentation. Nous savons que le prochain personnage sera une .
  • Si un oou un eest rencontré, générez une chaîne en répétant le caractère actuel un nombre spécifique de fois et en l'ajoutant à une nouvelle ligne ou à un remplissage et à une nouvelle ligne.
  • Le nombre de répétitions est déterminé par la longueur de la chaîne d'entrée et par le retrait ou non de la ligne actuelle.
  • La PadLeftfonction est utilisée pour générer la chaîne de caractères répétitive.

Le résultat est la concaténation de toutes ces chaînes.



@ASCIIOnly - Merci :)
dana

> Le remplissage par des espaces est obligatoire de chaque côté du remplissage
ASCII uniquement


Je n'ai pas remarqué cela :) Bien que, en examinant les réponses postées, environ la moitié l'ait mal fait aussi. Bonne prise quand même!
Dana

3

Pyth , 28 octets

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

Essayez-le ici! Celui-ci utilise une boucle.

Pyth, 30 octets

(Comme chaîne remplace)

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

Essayez-le ici! Celui-ci utilise le remplacement de chaîne.

J'aime beaucoup le python (c'est ce que j'ai écrit dans mes scripts de test originaux), alors j'ai pensé faire une entrée pyth pour le plaisir :)


1
N'est-ce pas 37 octets? Je pensais que Pyth utilisait le code ASCII par défaut comme page de code, tout comme Python, si je me souviens bien. Ainsi, même si votre code est composé de 33 caractères, les deux et trois octets chacun. Ou est-ce que je manque quelque chose ici?
Kevin Cruijssen le

Bon appel, je ne m'en étais pas rendu compte (je ne pouvais pas utiliser pyth sur tio.run, j'ai donc utilisé le compteur de longueur sur la page herokuapp). Dans la boucle for, je pourrais simplement remplacer le caractère par N, même en sauvegardant quelques octets!
GammaGames

Pensé que quelque chose comme ça s'est passé. :) J'ai déjà eu le même problème avec une de mes réponses 05AB1E qui utilisait des caractères en dehors de sa page de code. Malheureusement, TIO affiche les caractères et octets les mêmes pour la plupart des langues de golf. Pour Java ou Python, TIO indiquera correctement 33 chars, 37 bytes, mais pas dans les langues de golf sur TIO. Mais dans vos solutions, le simple fait de changer ces personnages corrige effectivement le problème. Ce n'est donc pas un si gros problème ici.
Kevin Cruijssen le

@KevinCruijssen Attendez, 05AB1E n'utilise pas de SBCS réel?
ASCII uniquement le

1
Si cela vous intéresse, cela semble fonctionner sans effort sur TIO pour moi.
NieDzejkob

3

Ruby , 62 60 octets

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

Essayez-le en ligne!

Utilisations Opour le cookie, *pour le remplissage.

-1 grâce à @manatwork signalant une erreur stupide et une autre -1 en raison d'un assouplissement des règles concernant les espaces.


Pas besoin de parenthèses autour .gsubdes paramètres.
Manatwork le


2

Clojure , 137 octets

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

Je n'utilise pas les beaux personnages de l'imprimé dans la version avec golf car ceux-ci sont chers. Retourne une chaîne à imprimer.

Essayez-le en ligne!

Voir ci-dessous pour l'explication.

Pré-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

2

Dart , 120 106 107 octets

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

Essayez-le en ligne!

  • +1 octet: espaces de fin ajoutés

Ceci est invalide: "Le remplissage d'
espacement des

Oh, ce n'est pas grave alors, je vais corriger ça bientôt. Merci pour l'info, ça m'a manqué
Elcan

2

Python 2 , 77 76 72 octets

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

Essayez-le en ligne!

La partie extérieure du cookie est "o" et le remplissage est "r".


68 octets . Bien que je doute que vous puissiez vraiment omettre les espaces de fin, la spécification dit "Le remplissage d'espacement des blancs de chaque côté du remplissage est requis" ...
Erik the Outgolfer Le

Merci @EriktheOutgolfer. Je pensais qu'un lambda serait plus court! Devinez dans ce cas pas. Avait manqué l'exigence concernant l'espace de fuite obligatoire sur le remplissage. Vraiment, je ne vois pas l’intérêt d’un défi artistique en ASCII, mais si c’est ce que l’OP exige, alors je suppose que ma réponse est invalide de toute façon.
ElPedro

Maintenant corrigé ...
ElPedro

Pourquoi ramener à 76? Juste mis +' 'après (l-2). En outre, vous avez une faute de frappe, *' 'doit être +' '.
Erik the Outgolfer

C'est ce que j'ai fait avec ma solution actuelle. Je regarderai de plus près vos allusions demain (plus tard aujourd'hui). Il est tard et j'ai pelleté de la neige toute la journée, donc trop fatigué pour le golf. Merci pour les conseils cependant :)
ElPedro

2

Code machine x86-64 (Linux), 97 octets

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

Cette fonction x86-64 prend le pointeur sur la chaîne d'entrée en rsi et construit la sortie à partir du pointeur dans rdi (ce sont les registres utilisés pour passer les deux premiers arguments d'une fonction C sous Linux). Pour plus de commodité, j'ai écrit un wrapper C ++ à cet effet, qui désinfecte également les entrées et les imprime. Ce code peut être localisé ici . Cela montre également l’assemblage de syntaxe nasm original que j’ai écrit pour cette fonction (ainsi que la version non golfée que j’ai travaillée en premier).

Il convient de noter que ce code ne respecte aucun des registres sauvegardés appelés, ce qui signifie que le code C ++ risque de planter s'il est exécuté pendant un certain temps après avoir appelé cette fonction. Sur ma machine, ce n'est pas le cas, mais c'est plutôt surprenant. Je n'ajoute pas non plus d'octet nul pour délimiter la chaîne de sortie, mais l'espace alloué à la chaîne de sortie est prérempli d'octets. (Si cela n'est pas autorisé, je peux ajouter le terminateur nul au coût de 3 octets).

La logique de ce code consiste essentiellement à compter la longueur de la chaîne, puis à construire une ligne de cette longueur pour chaque caractère "o" et "r" de la chaîne d'entrée, puis pour tout caractère "e", en remplaçant le premier. et les derniers caractères de la ligne précédente avec des espaces.

Je ne trouve aucun endroit en ligne pour compiler et exécuter un mélange de code source C ++ et nasm. Il est donc possible que j'écrive un petit code wrapper afin de prouver que cela fonctionne. Sinon, vous devriez pouvoir compiler et exécuter ceci avec le makefile dans le lien que j'ai donné avec la commande:

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

J'ai été capable de formater l'ensemble en un format acceptable par gcc, essayez-le en ligne!


1
Oh mon Dieu, maintenant c'est une entrée!
GammaGames
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.