Introdução:

(Fonte: Wikipedia )
Quando olhamos para um arco-íris, ele sempre terá as cores de cima para baixo:
vermelho; laranja; amarelo; verde; azul; índigo; tolet

Se olharmos para esses anéis individuais, é claro que o anel vermelho é maior que o anel violeta.
Além disso, também é possível ter dois ou até três arco-íris ao mesmo tempo.

Tudo isso combinado acima será usado neste desafio:

Desafio:

Dado um número inteiro n, produza muitos anéis dos (possivelmente mais de um) 'arco-íris', onde usaremos as letras vibgyorpara as cores.

Veja os casos de teste abaixo para ver como eles são criados a partir de cima n=1e como o espaçamento deve ser tratado (em n=8). Como você pode ver, um espaço é adicionado entre dois arco-íris, incluindo o espaçamento na parte superior, antes de adicionarmos o anel do próximo arco-íris na linha.

Regras do desafio:

• Você tem permissão para usar capital em VIBGYORvez de letras minúsculas
• Deve haver um espaço entre os arco-íris individuais
• Qualquer quantidade de espaços à esquerda e / ou à direita / novas linhas é permitida, desde que o arco-íris real (onde quer que seja colocado na tela) esteja correto
• A entrada sempre será um número inteiro positivo ( >= 1). O comportamento quando n=0é, portanto, indefinido, e o programa / função pode fazer o que quiser (não produzindo nada; produzindo o arco-íris de n=1; produção aleatória; falha com erro; etc.)
• Você pode gerar uma lista / matriz de seqüências de caracteres ou uma matriz / lista 2D de caracteres, se desejar (você pode adicionar o código de impressão bonita no rodapé do TIO).
• Ignore o fato de que as saídas parecem mais templos maias do que arco-íris. XD

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste (primeiro n=1a n=10e 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 graças ao ElPedro.

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

Experimente online!

JavaScript (ES6), 100 bytes

Retorna uma matriz de strings.

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)

Experimente online!

05AB1E , 32 31 23 bytes

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

Experimente online!

-1 graças a Kevin Cruijssen e -8 graças a Adnan

Explicação (Exemplo de pilha com entrada 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.

Tela , 29 28 26 bytes

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

Experimente aqui!

Explicação:

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 após a fixação do campo de ciclo, se o comprimento desejado for maior que o comprimento das entradas e a fixação ／pela 10ª vez

Haskell , 114 110 101 bytes

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

Experimente online!

Dyalog APL , 41 39 38 bytes

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

Experimente online!

Uma abordagem semelhante a outras pessoas: A←⌈⎕×8÷7encontra a altura do arco-íris (também a largura da 'meia linha' mais longa à esquerda / direita do centro) e a atribui Apara uso posterior, enquanto ¨-⍳itera os valores 1..A, negando-os a selecionar no lado correto quando usados ​​com ↑.

A⍴' vibgyor'gera uma 'meia linha' e ⍵↑seleciona a substring de comprimento correto. (⌽,⊃,A↑⊢)gera a linha completa no sentido inverso (o que leva menos caracteres para fazer), começando com uma meia linha invertida ( ⌽), depois o caractere central retirado do início da cadeia de meia linha ( ⊃) e, finalmente, uma versão acolchoada à direita da meia linha ( A↑⊢) O final ⌽reverte a linha para a orientação correta e ↑transforma o vetor de linhas em uma matriz 2D.

Edit: -2 graças a dzaima

Edit: -1 graças 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)

Experimente online!

Carvão , 30 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

↶

Mude a direção do desenho para cima.

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

Calcule a altura do arco-íris e repita a string literal para esse comprimento.

θ⸿

Imprima a linha central do arco-íris.

Ｅθ✂θκ

Imprima a metade direita do arco-íris, obtendo fatias sucessivas e imprimindo cada uma em sua própria "linha".

‖Ｏ←

Reflita para completar o arco-íris.

Gelatina , 31 bytes

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

Experimente online!

Confira uma suíte de testes!

ಠ_ಠ Este é excessivamente complicado, porque Jelly não tem uma função centralizar ...

Gelatina , 28 bytes

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

Um link monádico que aceita um número inteiro que gera uma lista de listas de caracteres.

Experimente online! (rodapé se junta a caracteres de nova linha)

Ou veja a suíte de testes .

Quão?

: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

Experimente online!

• -6 bytes graças a @JayCe

Haskell , 106 113 bytes

Ainda não posso comentar outras postagens (ou seja, essa ), então tenho que postar a solução como uma resposta separada.

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

Experimente online!

( Versão antiga , 113 bytes)

PowerShell , 108 98 89 85 bytes

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

Experimente online!

Este parece bem agora. O arredondamento dos banqueiros ainda é o diabo e eu descobri como fazer uma união não burra. Eu tentei monkeying com $ ofs sem muito sucesso. Falando nisso, os resultados sem junções parecem muito bons, um pouco 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)

Experimente online!

Salvou:

• -1 byte, graças a Jonathan Frech

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

Experimente online!

Um pouco mais legível:

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

Experimente online!

Imprime um espaço extra inicial e final para cada múltiplo de 7.

Explicação

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 graças a Kevin Cruijssen

Stax , 23 bytes

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

" 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

Execute este