Introducción:

(Fuente: Wikipedia )
Cuando miramos un arco iris siempre tendrá los colores de arriba a abajo:
rojo; naranja; amarillo; verde; azul; índigo; Violeta

Si observamos estos anillos individuales, el anillo rojo es, por supuesto, más grande que el anillo violeta.
Además, también es posible tener dos o incluso tres arcoíris al mismo tiempo.

Todo lo anterior combinado se usará en este desafío:

Desafío:

Dado un número entero n, genera muchos anillos de (posiblemente más de uno) 'arco iris', donde usaremos las letras vibgyorpara los colores.

Vea los casos de prueba a continuación para ver cómo se construyen hacia arriba n=1y cómo se debe manejar el espacio (en n=8). Como puede ver, se agrega un espacio entre dos arcoíris, incluido el espacio en la parte superior, antes de agregar el anillo del siguiente arcoíris en línea.

Reglas de desafío:

• Se le permite usar capital en VIBGYORlugar de minúsculas
• Debería haber un espacio entre los arcoíris individuales
• Se permite cualquier cantidad de espacios iniciales y / o finales / nuevas líneas, siempre que el arcoíris real (donde sea que se coloque en la pantalla) sea correcto
• La entrada siempre será un entero positivo ( >= 1). El comportamiento, n=0por lo tanto, no está definido, y el programa / función puede hacer lo que quiera (no generar nada; generar el arco iris de n=1; salida aleatoria; fallar con un error; etc.)
• Si lo desea, puede generar una lista / matriz de cadenas o una matriz / lista de caracteres 2D (puede agregar el código de impresión bonita en el pie de página de TIO).
• Ignora el hecho de que las salidas se parecen más a los templos mayas que a los arcoiris. XD

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba (primero a n=1través n=10y 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

Python 2 , 84 82 81 bytes

-2 bytes gracias a ElPedro.

n=input();n+=n/7;w=''
while-~n:w+=" vibgyor"[n%8];print' '*n+w+w[-1]+w[::-1];n-=1

Pruébalo en línea!

JavaScript (ES6), 100 bytes

Devuelve una matriz de cadenas.

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)

Pruébalo en línea!

05AB1E , 32 31 23 bytes

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

Pruébalo en línea!

-1 gracias a Kevin Cruijssen y -8 gracias a Adnan

Explicación (Ejemplo de pila con entrada 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.

Lienzo , 29 28 26 bytes

７÷Ｕ＋｛ <ibgyor＠¹×／ｎ｝⇵Ｋ２＊∔─↶

Pruébalo aquí!

Explicación:

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 bytes después de arreglar ese shouldold debería ciclar si la longitud deseada es mayor que la longitud de las entradas y arreglar ／por décima vez

Haskell , 114 110 101 bytes

Gracias a [nimi] [1] por - 4 13 bytes!

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)

Pruébalo en línea!

Dyalog APL , 41 39 38 bytes

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

Pruébalo en línea!

Un enfoque similar a los demás: A←⌈⎕×8÷7encuentra la altura del arco iris (también el ancho de la 'media fila' más larga a la izquierda / derecha del centro) y lo asigna Apara su uso posterior, mientras ¨-⍳itera a través de los valores 1..A, negándolos a seleccionar en el lado correcto cuando se usa con ↑.

A⍴' vibgyor'genera una 'media fila' y ⍵↑selecciona la subcadena de longitud correcta. (⌽,⊃,A↑⊢)genera la fila completa en reversa (que requiere menos caracteres), comenzando con una media fila invertida ( ⌽), luego el carácter central tomado del comienzo de la cadena de media fila ( ⊃) y finalmente una versión con relleno derecho de la media fila ( A↑⊢) El final ⌽invierte la fila en la orientación correcta y ↑convierte el vector de filas en una matriz 2D.

Editar: -2 gracias a dzaima

Editar: -1 gracias a ngn

Python 2 , 108 bytes

n=input()-1
n+=n/7+2
o=[]
for s in(' vibgyor'*n)[:n]:o=[s+l+s for l in[s]+o]
for l in o:print l.center(n-~n)

Pruébalo en línea!

Carbón , 30 bytes

↶≔… vibgyor⁺²÷×⁸⊖Ｎ⁷θθ⸿Ｅθ✂θκ‖Ｏ←

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

↶

Cambia la dirección del dibujo hacia arriba.

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

Calcule la altura del arcoíris y repita la cadena literal a esa longitud.

θ⸿

Imprime la línea central del arcoíris.

Ｅθ✂θκ

Imprima la mitad derecha del arco iris tomando rebanadas sucesivas e imprimiendo cada una en su propia "línea".

‖Ｏ←

Reflexiona para completar el arcoiris.

Jalea , 31 bytes

:7+‘µ“ vibgyor”ṁṚ,Ṛjṛ/ƲƤṭ"ḶṚ⁶ẋƲ

Pruébalo en línea!

¡Mira un paquete de prueba!

ಠ_ಠ Esto es demasiado complicado porque Jelly no tiene una función centralizada ...

Jalea , 28 bytes

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

Un enlace monádico que acepta un número entero que produce una lista de listas de caracteres.

Pruébalo en línea! (el pie de página se une con los caracteres de nueva línea)

O vea el conjunto de pruebas .

¿Cómo?

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

R , 130 bytes

function(n,k=n%/%7*8+1+n%%7,a=el(strsplit(' vibgyor'/k,'')))for(i in k:1)cat(d<-' '/(i-1),a[c(k:i,i,i:k)],d,sep='','
')
"/"=strrep

Pruébalo en línea!

• -6 bytes gracias a @JayCe

Haskell , 106113 bytes

Todavía no puedo comentar otras publicaciones (es decir, esto ), así que tengo que publicar la solución como una respuesta separada.

Golfed lejos 7 bytes por 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]]

Pruébalo en línea!

( Versión anterior , 113 bytes)

PowerShell , 108 98 89 85 bytes

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

Pruébalo en línea!

Este se siente bastante bien ahora. El redondeo de los banqueros sigue siendo el demonio y descubrí cómo hacer una unión no tonta. Traté de hacer monos con $ ofs sin mucho éxito. Hablando de eso, los resultados sin combinaciones se ven bastante bien, un poco 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

Python 2 , 132 131 bytes

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)

Pruébalo en línea!

Salvado:

• -1 byte, gracias a Jonathan Frech

Rojo , 153 bytes

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

Pruébalo en línea!

Ligeramente más legible:

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

Java (JDK 10) , 184 bytes

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

Pruébalo en línea!

Imprime un espacio inicial y final adicional para cada múltiplo de 7.

Explicación

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

• -2 bytes gracias a Kevin Cruijssen

Stax , 23 bytes

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

" 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

Ejecute este