Codegolf Rainbow: dessiner en noir et blanc

12

Introduction:

entrez la description de l'image ici(Source: Wikipedia )
Quand on regarde un arc-en-ciel, il aura toujours les couleurs de haut en bas:
rouge; Orange; Jaune; vert; bleu; indigo; violet

Si nous regardons ces anneaux individuels, l'anneau rouge est bien sûr plus grand que l'anneau violet.
De plus, il est également possible d'avoir deux voire trois arc-en-ciel en même temps.

Tout cela combiné ci-dessus sera utilisé dans ce défi:

Défi:

Étant donné un nombre entier n, sortez autant d'anneaux des (éventuellement plus d'un) 'arcs-en-ciel', où nous utiliserons les lettres vibgyorpour les couleurs.

Voir les cas de test ci-dessous pour voir comment ils sont construits vers le haut n=1et comment l'espacement doit être géré (en n=8). Comme vous pouvez le voir, un espace est ajouté entre deux arcs-en-ciel, y compris l'espacement en haut, avant d'ajouter l'anneau de l'arc-en-ciel suivant en ligne.

Règles du défi:

  • Vous êtes autorisé à utiliser des capitaux VIBGYORau lieu de minuscules
  • Il devrait y avoir un espace entre les arcs-en-ciel individuels
  • N'importe quelle quantité d'espaces / de nouvelles lignes de début et / ou de fin est autorisée, tant que l'arc-en-ciel réel (où qu'il soit placé sur l'écran) est correct
  • L'entrée sera toujours un entier positif ( >= 1). Le comportement quand n=0est donc indéfini, et le programme / fonction peut faire ce qu'il veut (rien sortir; sortir l'arc-en-ciel de n=1; sortie aléatoire; échouer avec une erreur; etc.)
  • Vous êtes autorisé à sortir une liste / tableau de chaînes ou un tableau 2D / liste de caractères si vous le souhaitez (vous pouvez ajouter le code de jolie impression réel dans le pied de page TIO).
  • Ignorez le fait que les sorties ressemblent plus à des temples mayas qu'à des arcs-en-ciel. XD

Règles générales:

  • C'est le , donc la réponse la plus courte en octets l'emporte.
    Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
  • Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
  • Les failles par défaut sont interdites.
  • Si possible, veuillez ajouter un lien avec un test pour votre code.
  • De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test (premier n=1à n=10, et n=25):

1:
 vvv
v   v

2:
  iii
 ivvvi
iv   vi

3:
   bbb
  biiib
 bivvvib
biv   vib

4:
    ggg
   gbbbg
  gbiiibg
 gbivvvibg
gbiv   vibg

5:
     yyy
    ygggy
   ygbbbgy
  ygbiiibgy
 ygbivvvibgy
ygbiv   vibgy

6:
      ooo
     oyyyo
    oygggyo
   oygbbbgyo
  oygbiiibgyo
 oygbivvvibgyo
oygbiv   vibgyo

7:
       rrr
      rooor
     royyyor
    roygggyor
   roygbbbgyor
  roygbiiibgyor
 roygbivvvibgyor
roygbiv   vibgyor

8:
         vvv
        v   v
       v rrr v
      v rooor v
     v royyyor v
    v roygggyor v
   v roygbbbgyor v
  v roygbiiibgyor v
 v roygbivvvibgyor v
v roygbiv   vibgyor v

9:
          iii
         ivvvi
        iv   vi
       iv rrr vi
      iv rooor vi
     iv royyyor vi
    iv roygggyor vi
   iv roygbbbgyor vi
  iv roygbiiibgyor vi
 iv roygbivvvibgyor vi
iv roygbiv   vibgyor vi

10:
           bbb
          biiib
         bivvvib
        biv   vib
       biv rrr vib
      biv rooor vib
     biv royyyor vib
    biv roygggyor vib
   biv roygbbbgyor vib
  biv roygbiiibgyor vib
 biv roygbivvvibgyor vib
biv roygbiv   vibgyor vib

25:
                            ggg
                           gbbbg
                          gbiiibg
                         gbivvvibg
                        gbiv   vibg
                       gbiv rrr vibg
                      gbiv rooor vibg
                     gbiv royyyor vibg
                    gbiv roygggyor vibg
                   gbiv roygbbbgyor vibg
                  gbiv roygbiiibgyor vibg
                 gbiv roygbivvvibgyor vibg
                gbiv roygbiv   vibgyor vibg
               gbiv roygbiv rrr vibgyor vibg
              gbiv roygbiv rooor vibgyor vibg
             gbiv roygbiv royyyor vibgyor vibg
            gbiv roygbiv roygggyor vibgyor vibg
           gbiv roygbiv roygbbbgyor vibgyor vibg
          gbiv roygbiv roygbiiibgyor vibgyor vibg
         gbiv roygbiv roygbivvvibgyor vibgyor vibg
        gbiv roygbiv roygbiv   vibgyor vibgyor vibg
       gbiv roygbiv roygbiv rrr vibgyor vibgyor vibg
      gbiv roygbiv roygbiv rooor vibgyor vibgyor vibg
     gbiv roygbiv roygbiv royyyor vibgyor vibgyor vibg
    gbiv roygbiv roygbiv roygggyor vibgyor vibgyor vibg
   gbiv roygbiv roygbiv roygbbbgyor vibgyor vibgyor vibg
  gbiv roygbiv roygbiv roygbiiibgyor vibgyor vibgyor vibg
 gbiv roygbiv roygbiv roygbivvvibgyor vibgyor vibgyor vibg
gbiv roygbiv roygbiv roygbiv   vibgyor vibgyor vibgyor vibg
Kevin Cruijssen
la source
3
Peut-être que vous le savez et que c'est par conception (je sais que les arcs-en-ciel ne sont pas non plus des losanges ou des ascii, et les positions des ordres supérieurs deviennent plus compliquées), mais les couleurs ne sont-elles pas inversées dans le 2e arc-en-ciel?
Chris M
1
@ChrisM Ah, vous avez en effet raison. Avec deux arcs-en - ciel, le second est en effet inversé , mais avec trois seuls l'extérieur est inversé , et avec quatre les deux extérieurs sont inversés. Ah bien, un peu trop tard pour le changer maintenant. Peut-être que je penserai à un troisième défi lié à cela plus tard. :)
Kevin Cruijssen
Oh cool, gentil: ¬)
Chris M

Réponses:

3

JavaScript (ES6), 100 octets

Renvoie un tableau de chaînes.

f=(n,a=[i='   '])=>++i<n+n/7?f(n,[c=' vibgyor'[i&7],...a].map(s=>c+s+c)):a.map(s=>' '.repeat(--i)+s)

Essayez-le en ligne!

Arnauld
la source
3

05AB1E , 32 31 23 octets

.•VvÈ©•¹∍¬„ v:Rηε¬ý}.c

Essayez-le en ligne!

-1 merci à Kevin Cruijssen et -8 merci à Adnan


Explication (exemple de pile avec entrée de 3):

.•VvÈ©•                  # Push 'aibgyor'           | ['aibgyor']
       ¹∍                # Extend to input length.  | ['aib']
         ¬               # Push head.               | ['aib','a']
          „ v:           # Replace with ' v'.       | [' vib']
              R          # Reverse.                 | ['biv ']
               η         # Prefixes.                | ['b', 'bi', 'biv', 'biv ']
                ε   }    # For each....             | []
                 ¬ý     # Bifurcate, join by head. | ['b','b']       ->    ['bbb']
                                                    | ['bi','ib']     ->   ['biiib']
                                                    | ['biv','vib']   ->  ['bivvvib']
                                                    | ['biv ',' vib'] -> ['biv   vib']
                     .c # Center the result.        | Expected output.
Urne de poulpe magique
la source
1
"vibgyor"peut être joué au golf de 1 octet à .•2Bãθ(•. ( Voici l'explication à ce sujet dans la section " Comment compresser des chaînes ne faisant pas partie du dictionnaire? ".) En outre, „vr…v r:ð«peut être joué au 'v„v .:. Donc 28 octets . Belle réponse cependant, +1 de ma part.
Kevin Cruijssen
2
@KevinCruijssen oh je sais tout sur la compression de chaînes - je viens de penser (comme c'est généralement le cas avec de très petites chaînes) que le gonflement de 3 octets .••ne sauverait pas un octet. Chiffres la seule fois où je ne vérifie pas réellement, c'est le temps qu'il sauverait les octets xD. Good catch
Magic Octopus Urn
1
@Adnan assez juste, le manque de miroir en fait cependant un refactor important à mes yeux (cela et je doute que j'y serais arrivé par moi-même: P).
Urne de poulpe magique
1
@Adnan ¬ýest aussi un génie ... Jeez ... Vous pensez différemment et c'est génial.
Magic Octopus Urn
3

Toile , 29 28 26 octets

7÷U+{ <ibgyor@¹×/n}⇵K2*∔─↶

Essayez-le ici!

Explication:

7÷U+                          ceil(input/7) + input
    {             }         for n in 1..the above
      <ibgyor@                in the string " <ibgyor", pick the nth character
              ¹×              repeat n times
                /             create a diagonal of that
                 n            and overlap the top 2 stack items (the 1st time around this does nothing, leaving an item for the next iterations)
                   ⇵        reverse the result vertically
                    K       take off the last line (e.g. " <ibgyor <ib")
                     2*     repeat that vertically twice
                       ∔    and append that back to the diagonals
                        ─   palindromize vertically
                         ↶  and rotate 90° anti-clockwise. This rotates "<" to "v"

25 24 22 octets après la correction que l'ancien devrait tourner si la longueur souhaitée est plus grande que la longueur des entrées et fixation pour la 10e fois

dzaima
la source
Par curiosité, pourquoi le vcôté ( <)? Est-ce vdéjà un mot-clé réservé dans Canvas, si oui, pourquoi ne pas utiliser <comme mot-clé inversé à la place?
Kevin Cruijssen
1
les caractères sont utilisés verticalement puis tournés, et Canvas est assez intelligent pour comprendre que la <rotation de 90 ° dans le sens inverse des aiguilles d'une montre est égale à v: P Tous les ASCII font partie des chaînes dans Canvas btw
dzaima
Ah ok, donc si vous l'auriez utilisé vici, et ensuite vous le faites pivoter de 90 degrés dans le sens antihoraire, cela devient à la >place. Je vois. : D
Kevin Cruijssen
@KevinCruijssen Cela aurait d' autres conséquences aussi
dzaima
Ah, tu as aussi un miroir quelque part? Je ne peux pas lire Canvas tbh, donc j'attends avec impatience l'explication du code. ;)
Kevin Cruijssen
3

Haskell , 114 110 101 octets

Merci à [nimi] [1] pour - 4 13 octets!

f n=""#(n+1+div n 7)
w#0=[]
w#n|x<-cycle"r vibgyo"!!n=((' '<$[2..n])++reverse w++x:x:x:w):(x:w)#(n-1)

Essayez-le en ligne!

ovs
la source
3

Dyalog APL , 41 39 38 octets

↑{⌽(⌽,⊃,A↑⊢)⍵↑A' vibgyor'}¨-⍳A←⌈⎕×8÷7

Essayez-le en ligne!

Une approche similaire à d'autres: A←⌈⎕×8÷7trouve la hauteur de l'arc-en-ciel (également la largeur de la `` demi-rangée '' la plus longue à gauche / droite du centre) et l'affecte à Apour une utilisation ultérieure, tout en ¨-⍳parcourant les valeurs 1..A, les nier pour sélectionner du bon côté lorsqu'il est utilisé avec .

A⍴' vibgyor'génère une «demi-ligne» et ⍵↑sélectionne la sous-chaîne de longueur correcte. (⌽,⊃,A↑⊢)génère la ligne complète à l'envers (ce qui prend moins de caractères à faire), en commençant par une demi-ligne inversée ( ), puis le caractère central tiré du début de la chaîne de demi-ligne ( ) et enfin une version rembourrée à droite de la demi-ligne ( A↑⊢). La finale inverse la ligne dans la bonne orientation et transforme le vecteur de lignes en un tableau 2D.

Edit: -2 grâce à dzaima

Edit: -1 grâce à ngn

souricière
la source
Vous pouvez remplacer ⍕⍪par - la sortie d'un tableau 2D de caractères est autorisée
dzaima
39 octets
dzaima
1+÷7->8÷7
ngn
2

Fusain , 30 octets

↶≔… vibgyor⁺²÷×⁸⊖N⁷θθ⸿Eθ✂θκ‖O←

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

Changez la direction du dessin vers le haut.

≔… vibgyor⁺²÷×⁸⊖N⁷θ

Calculez la hauteur de l'arc-en-ciel et répétez la chaîne littérale à cette longueur.

θ⸿

Imprimez la ligne centrale de l'arc-en-ciel.

Eθ✂θκ

Imprimez la moitié droite de l'arc-en-ciel en prenant des tranches successives et en les imprimant chacune sur sa propre "ligne".

‖O←

Réfléchissez pour compléter l'arc-en-ciel.

Neil
la source
2

Gelée , 28 octets

:7+‘“ vibgyor”ṁµṫJZz⁶U;"⁸ŒBṚ

Un lien monadique acceptant un entier qui donne une liste de listes de caractères.

Essayez-le en ligne! (le pied de page rejoint les caractères de nouvelle ligne)

Ou consultez la suite de tests .

Comment?

:7+‘“ vibgyor”ṁµṫJZz⁶U;"⁸ŒBṚ - Link: integer
:7                           - integer divide by seven (number of full rainbows)
   ‘                         - increment (the input integer)
  +                          - add (gets the number bands)
    “ vibgyor”               - list of characters = " vibgyor"
              ṁ              - mould like the result above (as a range)
               µ             - start a new monadic chain
                 J           - range of length
                ṫ            - tail (vectorises) (gets the suffixes)
                  Z          - transpose
                   z⁶        - transpose with filler space character
                             -   (together these pad with spaces to the right)
                     U       - reverse each
                             -   (now we have the left side of the rainbow upside down)
                        ⁸    - chain's left argument, as right argument of...
                       "     -   zip with:
                      ;      -     concatenation
                             -   (adds the central character)
                         ŒB  - bounce (vectorises at depth 1)
                             -   (reflects each row like [1,2,3,4] -> [1,2,3,4,3,2,1])
                           Ṛ - reverse (turn the rainbow up the right way)
Jonathan Allan
la source
2

Haskell , 106 113 octets

Je ne peux pas encore commenter d'autres messages (à savoir celui-ci ), je dois donc publier la solution en tant que réponse distincte.

Golfé loin 7 octets par ovs

p x=reverse x++x!!0:x
u m|n<-m+div(m-1)7=[(' '<$[z..n])++p(drop(n-z)$take(n+1)$cycle" vibgyor")|z<-[0..n]]

Essayez-le en ligne!

( Ancienne version , 113 octets)

Max Yekhlakov
la source
Bonne réponse. Je ne connais pas Haskell, mais le code semble assez différent de l'autre réponse Haskell. PS: Cette autre réponse Haskell est en fait 110 octets après les conseils de golf dans le commentaire de @ nimi . Quoi qu'il en soit, c'est une bonne réponse alternative à Haskell, donc +1 de ma part.
Kevin Cruijssen
1
Il semble que la compréhension des listes soit le meilleur outil pour relever ce défi. J'ai pu faire jouer votre solution à 106 octets en réduisant le nombre total de fonctions. N'hésitez pas à adapter ces changements.
ovs
2

PowerShell , 108 98 89 85 octets

param($x)($x+=$x/7-replace'\..*')..0|%{' '*$_+-join(" vibgyor"*$x)[$x..$_+$_+$_..$x]}

Essayez-le en ligne!

Celui-ci se sent bien maintenant. L'arrondi de banquier est toujours le diable et j'ai compris comment faire une jointure non stupide. J'ai essayé le singe avec $ ofs sans grand succès. En parlant de ça, les résultats sans jointures sont plutôt bons, un peu melty:

         vvv
        v     v
       v   rrr   v
      v   r ooo r   v
     v   r o yyy o r   v
    v   r o y ggg y o r   v
   v   r o y g bbb g y o r   v
  v   r o y g b iii b g y o r   v
 v   r o y g b i vvv i b g y o r   v
v   r o y g b i v     v i b g y o r   v
Veskah
la source
[int] $ x + = $ x / 7?
mazzy
@mazzy Cela échoue pour x = 25. Vous devez tronquer mais passer aux tours int.
Veskah
Oui. Et tronquer est des œuvres
mazzy
1
@mazzy Je sais, la seule façon que je connais de tronquer est soit [math] :: truncate () soit l'astuce regex utilisée ci-dessus. [int] $ x arrondit le nombre. Si vous connaissez une meilleure façon, je suis tout ouïe.
Veskah
1

Python 2 , 132 131 octets

def f(n):
 t=n+n/7;s=('vibgyor '*n)[:t];r=[s[~i:]+t*' 'for i in range(t)]
 for l in zip(*r+3*[' '+s]+r[::-1])[::-1]:print''.join(l)

Essayez-le en ligne!


Enregistré:

  • -1 octet, merci à Jonathan Frech
TFeld
la source
Pourquoi //en Python 2?
Jonathan Frech
@JonathanFrech Parce que je suis stupide: P
TFeld
@dzaima, ouais. Devrait être corrigé maintenant
TFeld
1

Rouge , 153 octets

func[n][r: take/last/part append/dup copy"""roygbiv "n l: 9 * n + 8 / 8
repeat i l[print rejoin[t: pad/left take/part copy r i l last t reverse copy t]]]

Essayez-le en ligne!

Un peu plus lisible:

f: func[ n ] [
    r: copy ""
    append/dup r "roygbiv " n
    r: take/last/part r l: 9 * n + 8 / 8
    repeat i l [
        print rejoin [ t: pad/left take/part copy r i l
                       last t 
                       reverse copy t ]
    ]
]
Galen Ivanov
la source
1

Java (JDK 10) , 184 octets

n->{int h=n+n/7,i=h+1,w=i*2+1,j,k=0;var o=new char[i][w];for(;i-->0;o[i][w/2]=o[i][w/2+1])for(j=w/2;j-->0;)o[i][j]=o[i][w+~j]=i<h?j<1?32:o[i+1][j-1]:" vibgyor".charAt(k++%8);return o;}

Essayez-le en ligne!

Imprime un espace de début et de fin supplémentaire pour chaque multiple de 7.

Explication

n->{                             // IntFunction
 int h=n+n/7,                    //  Declare that height = n + n/7
     i=h+1,                      //          that index  = h + 1
     w=i*2+1,                    //          that width  = (h+1)*2+1
     j,                          //          j
     k=0;                        //          that k      = 0
 var o=new char[i][w];           //  Declare a 2D char array
 for(;                           //  Loop
   i-->0;                        //    Until i is 0
   o[i][w/2]=o[i][w/2+1]         //    After each run, copy the middle letter.
 )
  for(j=w/2;                     //   Loop on j = w/2
   j-->0;                        //     Until j = 0
  )                              //
   o[i][j]                       //    copy letters to the left side,
    =o[i][w+~j]                  //      and the right side
    =i<h                         //      if it's not the last line
     ?j<1                        //        if it's the first (and last) character
      ?32                        //          set it to a space.
      :o[i+1][j-1]               //          else set it to the previous character on the next line.
     :" vibgyor".charAt(k++%8);  //      else assign the next letter.
 return o;                       //  return everything
}

Crédits

Olivier Grégoire
la source
Vous pouvez enregistrer 2 octets en changeant ,w=-~h*2+1,i=h+1à,i=h+1,w=i*2+1
Kevin Cruijssen
Wow, je ne devrais vraiment pas jouer au golf à minuit! Merci pour cela, @KevinCruijssen! :)
Olivier Grégoire
Suggérer à la i-~iplace dei*2+1
plafondcat
1

Stax , 23 octets

⌡G'5h!M╩EV[Ez ▼>≈<S⌡⌡0`

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

" vibgyor"  string literal
,8*7/^      input * 8 / 7 + 1
:m          repeat literal to that length
|]          get all prefixes
Mr          rectangularize, transpose array of arrays, then reverse
            this is the same as rotating counter-clockwise
m           map over each row with the rest of the program, then implicitly output
            the stack starts with just the row itself
  _h        push the first character of the row
  _r        push the reversed row
  L         wrap the entire stack in a single array

Exécutez celui-ci

récursif
la source