introduction

Écrivez un programme pour sortir la spirale sortante du célèbre pangram suivant les règles données.

Défi

Un pangram est une phrase qui utilise au moins une fois chaque lettre d'un alphabet donné. L'un des pangrams les plus célèbres est celui qui est largement utilisé dans la visionneuse de polices Windows, à savoir " Le renard brun rapide saute par-dessus le chien paresseux ". Le défi est de produire une spirale basée sur ce texte.

Votre tâche génère ce texte exact:

heeeeellllllllllllazzzzzzzzzzz
hummmmmmmmmmmmmppppppppppppppy
hubrrrrrrrrrrrrrrrrrrooooooosy
hukyddddoooooooooooooooggggwsy
hukyveeeeerrrrrrrrrrrrrrrrtwsy
hukyvxjjjjjjjjjjuuuuuuuuuttwsy
hukyvxkbbrrrrrrrrrrrrrrrmttwsy
hukyvxkogggggggttttttttomttwsy
tukyvokoellllllllllllahomttwsy
tukyvokoeovvvvvvvvvvvzhomttwsy
tukyvocoeoummmmmmmmmezhomttwsy
tukyvocoeoufooooooopezhomttwsy
tukyvocohoufroooooxpezhomttwsy
tukyvoiohoufrquuuwxpezhomttwsy
tucyvoiohoufbqttiwxpezhomttwsy
tucyvoiohoufbeehiwxprzhomttwsy
tucyvoiohoufkccciwxprzeomttwsy
tjiyvoidhounnnnnnwxprzeomttwsy
tjiyvoidhojjjjjjjjxprzeomttwsy
tjiyvoidhssssssssssprzeopttwsy
tjiyvoidttttttttttttrzeopttwsy
tjiyvoiyyyyyyyyyyyyyyzqopttwoy
tjiyvouuuuuuuuuuuuuuuuqwpttwoy
tjiyvffffnnnnnnnnnnnnnnwpttwoy
tjiyossssssssssssssssssspthwoy
tjizzzzalllllllllllleeeeehhwoy
tjuuqqqqqqqqqqqqqqqqqeeeeehnod
txxxxxoooooooooooooooffffffnod
reeeeevvvvvvvvvvvvvvvvvvvvvvod
       gggggggoooooooooooooood

Voici comment il est généré,

• Il y avait un renard zélé qui aimait le pangram "Le renard brun rapide saute par-dessus le chien paresseux". Un jour, il était au centre d'une spirale extérieure et a décidé de sauter dedans et de peindre.
• Il aimerait parcourir le pangramme du début à la fin, et si une lettre est la nième lettre de l'alphabet, il aimerait la peindre n fois.
• Cependant, le renard n'était pas très bon pour faire des virages dans les coins, donc en atteignant chaque coin, il devait également s'arrêter et passer à la lettre suivante.
• Il a également décidé de répéter le pangram trois fois pour souligner qu'il est le renard brun rapide.
• Votre travail consiste à montrer à quoi ressemblerait la spirale après que le renard ait peint toutes ces lettres.

(Version simple sans narration)

• Le célèbre pangram "Le renard brun rapide saute par-dessus le chien paresseux" est répété trois fois, avec les espaces supprimés et toutes les lettres en minuscules, pour générer

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• La spirale part du centre et commence par la lettre "t", elle commence par aller à droite et va vers l'extérieur dans le sens des aiguilles d'une montre. Si le caractère actuel est la nième lettre de l'alphabet, il passe au caractère suivant chaque fois

  • la spirale atteint un coin, ou
  • les lettres actuelles sont imprimées exactement n fois.

Pour mieux l'illustrer, je vais expliquer comment la spirale liée aux trois premiers mots "thequickbrown" est générée.

 rooooo
 rquuuw
 bqttiw
 beehiw
 kccciw
nnnnnnw

Le renard part de "t", va à droite, atteint le 1er coin, le peint avec le "t" puis bascule sur "h" et descend, atteint le 2ème coin, bascule sur "e" et va à gauche, atteint le 3e coin, passe à "q" et monte, atteint le 4e coin, passe à "u" et va à droite, atteint un coin et passe à "i", descend, atteint un coin et passe à "c", va à gauche, peint avec succès 3 "c" avant d'atteindre le coin suivant , passe à "k" et continue à gauche , atteint un coin tout de suite, passe à "b" et monte, peint 2 "b" avant d'atteindre le coin suivant, passe à "r"et continue vers le haut , atteint un coin et passe à "o", va à droite, puis "w", en bas, "n", à gauche.

Spécifications

• Vous pouvez prendre une entrée facultative qui contient n'importe quelle forme standard de la chaîne

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• Votre sortie doit être formatée sous forme de chaîne et doit aller à STDOUT au lieu de fichiers ou STDERR, avec des retours à la ligne placés correctement. L'en-tête et la fin des lignes vides n'ont pas d'importance. Les espaces de titre et de fin dans chaque ligne sont autorisés, mais doivent être cohérents. Donc, si vous ajoutez 5 espaces avant une ligne du texte donné, vous devrez ajouter exactement 5 espaces avant chaque ligne pour que la spirale soit la même.

• C'est le code-golf , le plus petit nombre d'octets gagne.

• Comme d'habitude, les failles par défaut s'appliquent ici.

_{Les explications sont les bienvenues, mais pas nécessaires.}

_{Titre modifié pour en faire un pangramme par commentaire de caird coinheringaahing.}

_{Le chien paresseux est trop paresseux pour apparaître dans l'histoire.}

_{Je vise à créer un défi de chaîne dans lequel la lettre à produire ne peut pas être calculée par de simples fonctions des coordonnées.}

Stax , 35 34 33 32 octets

é╛îá%ⁿ┌○iê}→Ug=╩◙╘Ç⌐)QX↑L╓₧╗▌╧▬q

Exécutez-le et déboguez-le en ligne

Stax est une langue sur laquelle je travaille depuis environ 6 mois. C'est le premier golf public avec. Nous allons passer aux choses sérieuses.

Stax est normalement écrit dans le jeu de caractères ASCII imprimable. Cette soumission de 34 octets est regroupée dans une variante du jeu de caractères CP437. La représentation ascii correspondante est

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr

Stax est un langage basé sur une pile, mais il a deux piles de données, "principale" et "entrée". La plupart des opérations utilisent la pile principale, mais l'entrée commence sur la pile d'entrée. Les instructions de stax sont principalement des séquences ascii à un ou deux caractères. La plupart d'entre eux sont surchargés, ce qui signifie que leur comportement est déterminé par les quelques premières valeurs de la ou des piles.

À un niveau élevé, ce programme crée une grille en ajoutant à plusieurs reprises des chaînes à la dernière ligne. Lorsque la dernière ligne se remplit, elle fait pivoter la grille dans le sens horaire. À la fin, il reflète la grille horizontalement. Plus en détail, le programme fonctionne comme ceci.

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr
't]                                         ["t"]
   ,                                        Pop from input, push to main ("thequick...")
    {                            F          For each character in input, execute block...
     ]_96-*                                 Produce string using character appropriate
                                                number of times (a=1, b=2, etc)
           ~                                Pop from main, push to input for use later
            cH                              Copy last row from grid.
              T                             Right-trim whitespace
               ,+                           Pop from input stack and append
                 nh%                        Get the width of the first row of the grid
                    ^                       Add 1
                     (                      Right-pad/truncate string to this length
                      X                     Store in the x register
                       Us&                  Overwrite last row of the grid with new value.
                          xH                Get the last element from x.
                                                Basically, the lower right corner.
                             {  }M         Conditionally execute block.  This will happen 
                                                when the bottom right corner isn't a space.
                              rM            Reverse and transpose (aka rotate clockwise)
                                  |<        Left-justify grid; give all rows equal size.
                                     m      For each row, execute the rest of the program
                                               and then print the result to output
                                      r     Reverse the row

Charbon de bois , 66 40 36 octets

≔²ηＦＳ«Ｆ¬η«¶↷⊞υη≔⊕÷Ｌυ²η¶»Ｆ⊕⌕βι¿η«≦⊖ηι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Modifier: 16 octets enregistrés en prenant le texte en entrée. Explication:

≔²η

Commencez avec 2 ts pour une raison quelconque.

ＦＳ«

Faites une boucle sur toutes les lettres du pangram.

Ｆ¬η«

Avons-nous atteint un coin encore?

¶

Descendez (ou quelle que soit la direction suivante) d'une ligne.

↷

Faites pivoter le sens d'impression de 90 ° dans le sens des aiguilles d'une montre.

⊞υη≔⊕÷Ｌυ²η

Calculez la longueur du côté suivant.

¶»

Terminez de fixer la position du curseur. (Le charbon de bois aurait préféré que le côté se termine juste avant le coin, de sorte que vous tourniez sur le coin lui-même.)

Ｆ⊕⌕βι

Boucle autant de fois que la position de la lettre actuelle dans l'alphabet.

¿η«

Si nous n'avons pas atteint le coin,

≦⊖ηι

Diminuez le nombre et imprimez la lettre actuelle.

Ruby , 217 212 209 208 octets

->s{s+=' '*8
x=0
a=[""]*30
i=14
a[i]=?t
l=->{a[i]=s[x]+a[i]}
r=->{a[i]+=s[x]}
(0..58).map{|g|c=0
(0..g/2).map{c>s[x].ord-97&&(x+=1;c=0)
c+=1
eval %w{r i+=1;r l i-=1;l}[g%4]+"[]"}
x+=1}
a[-1].slice!0
$><<a*$/}

Essayez-le en ligne!

Passe beaucoup de temps à gérer les pointeurs, il peut donc y avoir de la place pour plus de golf.

-5 octets: tripler le pangram avant de saisir. Merci à Weijun Zhou .

-3 octets: remplir la chaîne d'entrée et couper la dernière jambe, au lieu de générer la dernière jambe à partir de zéro.

-1 octets: utilisez &&au lieu d'un opérateur ternaire avec une valeur jetable.

Explication:

->s{
  s += " " * 8                             # These spaces will show on the bottom row
  x = 0                                    # x is a pointer into s
  a = [""] * 30                            # a is an array of row strings
  i = 14                                   # i is a pointer into a
  a[i] = ?t                                # "Starts with two t's for some reason"
  l = ->{ a[i] = s[x]+a[i] }               # lambda to prepend char x to row i
  r = ->{ a[i] += s[x] }                   # lambda to append char x to row i
  (0..57).map{|g|                          # There are 58 "legs" to the spiral
    c = 0                                  # c is the print count of s[x]
    (0..g/2).map{                          # Leg g has g/2+1 characters
      c > s[x].ord-97 && (x+=1;c=0)        # Possibly switch to next letter
      c += 1
      eval %w{r i+=1;r l i-=1;l}[g%4]+"[]" # Call the appropriate lambda
    }
    x += 1                                 # Definitely switch to next letter
  }
  a[-1].slice!0                            # Remove the first char from the bottom row
  $> << a*$/                               # Join with newlines and print
}