Introduzione:

(Fonte: Wikipedia )
Quando guardiamo un arcobaleno avrà sempre i colori dall'alto verso il basso:
rosso; arancia; giallo; verde; blu; indaco; viola

Se guardiamo questi singoli anelli, l'anello rosso è ovviamente più grande dell'anello viola.
Inoltre, è anche possibile avere due o anche tre arcobaleno contemporaneamente.

Tutto questo sopra combinato verrà utilizzato in questa sfida:

Sfida:

Dato un numero intero n, genera molti anelli dei "arcobaleni" (forse più di uno), dove useremo le lettere vibgyorper i colori.

Vedere i casi di test di seguito per vedere come sono costruiti verso l'alto n=1e come deve essere gestita la spaziatura (at n=8). Come puoi vedere, viene aggiunto uno spazio tra due arcobaleni, compresa la spaziatura nella parte superiore, prima di aggiungere l'anello del prossimo arcobaleno in linea.

Regole della sfida:

• È consentito utilizzare il capitale VIBGYORanziché il minuscolo
• Dovrebbe esserci uno spazio tra i singoli arcobaleni
• È consentita qualsiasi quantità di spazi / nuove linee iniziali e / o finali, purché l'arcobaleno reale (ovunque sia posizionato sullo schermo) sia corretto
• L'input sarà sempre un numero intero positivo ( >= 1). Il comportamento quando n=0è quindi indefinito e il programma / funzione può fare tutto ciò che vuole (emettere nulla; emettere l'arcobaleno di n=1; output casuale; fallire con un errore; ecc.)
• È possibile generare un elenco / array di stringhe o array / elenco di caratteri 2D se lo si desidera (è possibile aggiungere il codice di stampa piuttosto reale nel piè di pagina TIO).
• Ignora il fatto che le uscite assomigliano più ai templi Maya che agli arcobaleni .. xD

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi di test (dal primo n=1al n=10, e 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 byte

-2 byte grazie a ElPedro.

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

Provalo online!

JavaScript (ES6), 100 byte

Restituisce una matrice di stringhe.

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)

Provalo online!

05AB1E , 32 31 23 byte

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

Provalo online!

-1 grazie a Kevin Cruijssen e -8 grazie ad Adnan

Spiegazione (esempio di stack con input di 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 byte

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

Provalo qui!

Spiegazione:

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 byte dopo aver risolto che shouldvecchio dovrebbe scorrere se la lunghezza desiderata è maggiore della lunghezza degli ingressi e fissarsi ／per la decima volta

Haskell , 114 110 101 byte

Grazie a [nimi] [1] per - 4 13 byte!

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)

Provalo online!

Dyalog APL , 41 39 38 byte

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

Provalo online!

Un approccio simile agli altri: A←⌈⎕×8÷7trova l'altezza dell'arcobaleno (anche la larghezza della "mezza fila" più lunga a sinistra / a destra del centro) e lo assegna Aper un uso successivo, mentre ¨-⍳scorre i valori 1..A, negandoli per selezionare dal lato corretto se utilizzato con ↑.

A⍴' vibgyor'genera una 'mezza fila' e ⍵↑seleziona la sottostringa di lunghezza corretta. (⌽,⊃,A↑⊢)genera l'intera riga al contrario (che richiede meno caratteri da eseguire), iniziando con una mezza riga invertita ( ⌽), quindi il carattere centrale preso dall'inizio della stringa della mezza riga ( ⊃) e infine una versione imbottita a destra della mezza riga ( A↑⊢). Il finale ⌽inverte la riga nell'orientamento corretto e ↑trasforma il vettore di righe in un array 2D.

Modifica: -2 grazie a dzaima

Modifica: -1 grazie a ngn

Python 2 , 108 byte

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)

Provalo online!

Carbone , 30 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

↶

Cambia la direzione del disegno verso l'alto.

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

Calcola l'altezza dell'arcobaleno e ripeti la stringa letterale a quella lunghezza.

θ⸿

Stampa la linea centrale dell'arcobaleno.

Ｅθ✂θκ

Stampa la metà destra dell'arcobaleno prendendo sezioni successive e stampandole ognuna sulla propria "linea".

‖Ｏ←

Rifletti per completare l'arcobaleno.

Gelatina , 31 byte

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

Provalo online!

Dai un'occhiata a una suite di test!

ಠ_ಠ Questo è eccessivamente complicato perché Jelly non ha una funzione di centralizzazione ...

Gelatina , 28 byte

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

Un collegamento monadico che accetta un numero intero che produce un elenco di elenchi di caratteri.

Provalo online! (il piè di pagina si unisce ai caratteri di nuova riga)

Oppure vedi la suite di test .

Come?

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

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

Provalo online!

• -6 byte grazie a @JayCe

Haskell , 106 113 byte

Non posso ancora commentare altri post (vale a dire questo ), quindi devo pubblicare la soluzione come risposta separata.

Golfato via 7 byte da 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]]

Provalo online!

( Vecchia versione , 113 byte)

PowerShell , 108 98 89 85 byte

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

Provalo online!

Questo ora sembra abbastanza bene. L'arrotondamento del banco è ancora il diavolo e ho capito come fare un join non stupido. Ho provato a fare scimmie con $ ofs senza molto successo. A proposito, i risultati senza join sembrano abbastanza buoni, un po '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 byte

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)

Provalo online!

Salvato:

• -1 byte, grazie a Jonathan Frech

Rosso , 153 byte

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

Provalo online!

Leggermente più leggibile:

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 byte

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

Provalo online!

Stampa uno spazio iniziale e finale aggiuntivo per ogni multiplo di 7.

Spiegazione

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
}

Titoli di coda

• -2 byte grazie a Kevin Cruijssen

Stax , 23 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

" 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

Esegui questo