Aux fins du défi actuel de "tracer" un mot, il faut l'entourer successivement de ses propres lettres, en commençant par la dernière, et enfin remplacer le mot d'origine au centre par des espaces:

       oooooo 
       onnnno 
on ->  on  no 
       onnnno
       oooooo

Tâche:

À partir d'une liste de mots, composée uniquement de lettres anglaises minuscules et / ou majuscules, décrivez chaque mot et affichez tous les blocs résultants côte à côte horizontalement, séparés par une colonne d'espace unique, alignés verticalement au centre des blocs.

Vous pouvez écrire un programme complet ou une fonction.

Contribution:

Une liste de mots, ou si vous préférez - une chaîne délimitée par des espaces ou d'autres symboles

Production:

La représentation ASCII des blocs pour les mots soulignés. Les espaces blancs avant / arrière sont autorisés.

Cas de test:

Input 1: ["code", "golf"] (or "code golf")
Output 1:

    cccccccccccc gggggggggggg
    cooooooooooc goooooooooog
    coddddddddoc gollllllllog
    codeeeeeedoc golfffffflog
    code    edoc golf    flog
    codeeeeeedoc golfffffflog
    coddddddddoc gollllllllog
    cooooooooooc goooooooooog
    cccccccccccc gggggggggggg

Input 2: ["I", "am", "just", "a", "man"]  (or "I am just a man")
Output 2: 

           jjjjjjjjjjjj
           juuuuuuuuuuj     mmmmmmmmm
    aaaaaa jussssssssuj     maaaaaaam
III ammmma justtttttsuj aaa mannnnnam
I I am  ma just    tsuj a a man   nam  
III ammmma justtttttsuj aaa mannnnnam
    aaaaaa jussssssssuj     maaaaaaam 
           juuuuuuuuuuj     mmmmmmmmm 
           jjjjjjjjjjjj

Critères gagnants:

Le code le plus court en octets dans chaque langue gagne. J'apprécierai grandement si vous commentez / expliquez votre code et votre approche.

code-golf ascii-art Galen Ivanov
la source

Pouvons-nous supposer qu'il y a au moins un mot?

PurkkaKoodari

@ Pietu1998 Oui, il y aura toujours au moins un mot

Galen Ivanov

1

@Kevin Cruijssen Transpose?

Galen Ivanov

7

Toile , 22 20 octets

ｌ ＊；±２１＊｛；ｌ└＊ｅ⟳｝ ］ｒ⤢

Essayez-le ici!

Explication:

{                 ]    map over the inputs
 l *                     array of length spaces - the canvas of the current word
    ;                    get the word back on top
     ±                   reverse it
      21*                repeat each character twice
         {      }        for each character
          ;l└              push the height of the item below (the canvas)
             *             repeat the character that many times vertically
              e            and encase the canvas in that char column
               ⟳           and rotate it clockwise for encasing the next time
                 ∙      push another space as the separator of words
                   r   center the words
                    ⤢  and transpose the final output (as everything was built vertically)

dzaima
la source

5

Fusain , 35 octets

ＦＡ«≔ＬιθＭθ↑Ｆθ«Ｂ⁻×³θ⊗κ⊕⊗⁻θκ§ικ↘»Ｍ⊕⊗θ→

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

ＦＡ«

Faites une boucle sur la liste d'entrée.

≔Ｌιθ

Obtenez la longueur du mot actuel.

Ｍθ↑

Déplacez-vous dans le coin supérieur gauche du contour résultant.

Ｆθ«

Boucle une fois pour chaque personnage.

Ｂ⁻×³θ⊗κ⊕⊗⁻θκ§ικ

Dessinez une boîte de la hauteur, de la largeur et du caractère appropriés.

↘»

Déplacez-vous dans le coin supérieur gauche de la case suivante.

Ｍ⊕⊗θ→

Passez au contour suivant.

Neil
la source

4

Haskell , ^{188 183 174 174 171} 167 octets

-9 -13 octets grâce à Laikoni .

e=[]:e
c#a=k c<$>k(c<$a!!0)a
k c s=c:s++[c]
f w=foldr(#)[p w]w
p=(' '<$)
s w=unlines.map unwords.foldr(zipWith(:))e$until(\a->all((p a>=).p)$f<$>w)(k=<<p.head)<$>f<$>w

Essayez-le en ligne!

ovs
la source

\a->and[p a>=p x|x<-f<$>w]peut être \a->all((p a>=).p)$f<$>wet k c=(++[c]).(c:)peut être k c s=c:s++[c].

Laikoni

3

Pyth, 34 33 octets

Jsm+;uCjR*2HG_.iddm\ dQjCm.[lJd;J

Essayez-le en ligne.

Vide tout un tas d'espaces supplémentaires, mais cela est permis par le défi.

Explication

m… QFait ce qui suit pour chaque mot dde l'entrée Q:
- m\ dmappe le mot avec x => " ", créant essentiellement la liste [" ", ..., " "]avec autant d'éléments que le mot a de lettres.
- .iddentrelace le mot avec lui-même, répétant les lettres du mot deux fois. _inverse cette chaîne. worddevient ddrrooww.
- ucommence par G= le tableau d'espaces et applique ce qui suit à chaque lettre de la chaîne entrelacée dans H:
  - *2H répète le caractère deux fois.
  - jR… GPlace chaque chaîneG entre la paire de caractères.
  - Céchange des lignes et des colonnes. Lorsque ces trois étapes sont effectuées deux fois avec le même caractère dans H, cela décrit les lignes Gavec ce caractère.
- Nous avons maintenant les colonnes pour le mot décrit d. +;ajoute une colonne d'espace.
saplatit le tableau de colonnes pour chaque mot et l' Jenregistre dans la variableJ .
m…J Fait ce qui suit pour chaque colonne de la sortie:
- .[lJd;remplit les deux côtés de la colonne avec des espaces de sorte que la longueur de la colonne soit égale au nombre de colonnes. Il s'agit toujours d'un remplissage suffisant pour aligner verticalement les colonnes.
Ctransforme les colonnes en lignes et jjoint les lignes avec des retours à la ligne.

Solution alternative, 33 octets

j.tsm.[L\ l+dsQ+;uCjR*2HG_.iddm\

Essayez-le en ligne.

Notez qu'il y a un espace de fin. Généralement le même algorithme, sauf uniquement les colonnes de tampons en haut, puis transposées avec un remplissage d'espace.

PurkkaKoodari
la source

3

R , 189 octets

function(x,S=32,`+`=rbind,`*`=cbind)cat(intToUtf8(Reduce(`+`,Map(function(s,K=utf8ToInt(s),o=S-!K){for(i in rev(K))o=i+i*o*i+i
for(j in(0:(max(nchar(x))-nchar(s)))[-1])o=S*o*S
o+S},x))+10))

Essayez-le en ligne!

Une collaboration entre digEmAll et moi dans le chat .

function(x){
 S <- 32			# space
 `+` <- rbind			# alias for rbind
 `*` <- cbind			# alias for cbind
 outlineWord <- function(s){	# function to construct the outline for each word
  chars <- utf8ToInt(s)		# convert to code points
  output <- S - !chars		# replace each char with 32 (space)
  for(i in rev(chars))
   o <- i + i * o * i + i	# o <- rbind(i,cbind(i,o,i),i)
  for(j in(0:(max(nchar(x))-nchar(s)))[-1])
   o <- S * o * S		# pad with spaces
   o + S}			# return with an additional row of spaces between words
 outlines <- Map(outlineWord,x)	# apply outlineWord to each element of x
 outlines <- Reduce(`+`,outlines)# reduce by rbind
 outlines <- outlines+10	# add row of newlines
 cat(intToUtf8(outlines))	# convert back to strings and print
}

Giuseppe
la source

187 avec un alias évident

J.Doe

@ J.Doe c'est le wiki de la communauté alors n'hésitez pas à le modifier dans :-)

Giuseppe

1

APL (Dyalog Classic) , 57 51 50 octets

{⍉⊃⍪/,/((⊢-⌈/)≢¨⍵)⌽↑{⍪¨↓0 1↓⍕,∘⍉∘⌽⍣4/⍵,⊂⍉⍪¯1/⍵}¨⍵}

Essayez-le en ligne!

ngn
la source

1

Stax , 26 25 octets

¢π‼○MªΘ└ƒ∩┘?◙↕)fY╨nu⌂E┴6X

Exécuter et déboguer

récursif
la source

1

05AB1E , 46 octets

εg©;ò<Uyηε¤®∍«®>∍}yð«©ª®Xиª˜».º.∊}¶«».C.B€SζJ»

Pas trop content, mais je suis content que ça marche.

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

Explication:

ε                             # Map `y` over the (implicit) input-list
 g                            #  Take the length of the current item
  ©                           #  Store it in the register (without popping)
   ;                          #  Halve it
    ò                         #  Ceil and cast to integer at the same time
     <                        #  Decrease it by 1
      U                       #  Pop and store it in variable `X`
 yη                           #  Take the prefixes of the current string `y`
   ε       }                  #  Map over these prefixes:
    ¤                         #   Take the last character of the string
     ®×                       #   Increase it to a size equal to the length from the register
       «                      #   Append it to the current prefix
        ®>                    #   Take the length from the register, and add 1
          ∍                   #   Shorten the string to that size
 y                            #  Push the string `y` again
  ð«                          #  Append a space
    ©                         #  Store it in the register (without popping)
     ª                        #  Append it at the end of the list of modified prefixes
      ®                       #  Push the string with space from the register again
       Xи                     #  Repeat it `X` amount of times
         ª                    #  Append them to the list
          ˜                   #  Flatten to remove the empty appended list if `X` was 0
           »                  #  Join by newlines
            .º.∊              #  Intersect mirror both horizontally and vertically
                }             # Close outer map
                 ¶«           # Append a newline after each (for the space delimiters)
                   »          # Join everything by newlines
                    .C        # Centralize it horizontally
                              # (too bad a centralize vertically isn't available..)
                      .B      # Split on newlines again
                        €S    # Convert each line to a list of characters
                          ζ   # Zip, swapping rows/columns (with space filler by default)
                           J  # Join the loose characters of every line to a string again
                            » # Join the lines by newlines (and output implicitly)

Kevin Cruijssen
la source

Décrire les mots avec leurs lettres

Tâche:

Contribution:

Production:

Cas de test:

Critères gagnants:

Réponses:

Toile , 22 20 octets

Fusain , 35 octets

Haskell , ^{188 183 174 174 171} 167 octets

Pyth, 34 33 octets

Explication

Solution alternative, 33 octets

R , 189 octets

APL (Dyalog Classic) , 57 51 50 octets

Stax , 26 25 octets

05AB1E , 46 octets

Décrire les mots avec leurs lettres

Tâche:

Contribution:

Production:

Cas de test:

Critères gagnants:

Réponses:

Toile , 22 20 octets

Fusain , 35 octets

Haskell , 188 183 174 174 171 167 octets

Pyth, 34 33 octets

Explication

Solution alternative, 33 octets

R , 189 octets

APL (Dyalog Classic) , 57 51 50 octets

Stax , 26 25 octets

05AB1E , 46 octets

Haskell , ^{188 183 174 174 171} 167 octets