Pengantar:

(Sumber: Wikipedia )
Ketika kita melihat pelangi ia akan selalu memiliki warna dari atas ke bawah:
Merah; jeruk; kuning; hijau; biru; nila; violet

Jika kita melihat masing-masing cincin, cincin merah tentu saja lebih besar dari cincin ungu.
Selain itu, juga dimungkinkan untuk memiliki dua atau bahkan tiga pelangi secara bersamaan.

Semua gabungan di atas akan digunakan dalam tantangan ini:

Tantangan:

Diberikan bilangan bulat n, mengeluarkan banyak cincin dari (mungkin lebih dari satu) 'pelangi', tempat kami akan menggunakan huruf vibgyoruntuk warna.

Lihat kotak uji di bawah ini untuk melihat bagaimana mereka dibangun ke atas n=1, dan bagaimana ruang harus ditangani (at n=8). Seperti yang Anda lihat, satu spasi ditambahkan di antara dua pelangi, termasuk spasi di bagian atas, sebelum kita menambahkan cincin pelangi berikutnya dalam barisan.

Aturan tantangan:

• Anda diizinkan menggunakan modal VIBGYORalih-alih huruf kecil
• Harus ada ruang di antara masing-masing pelangi
• Jumlah ruang terdepan dan / atau trailing / garis baru diperbolehkan, selama pelangi sebenarnya (di mana pun ditempatkan di layar) sudah benar
• Input akan selalu berupa bilangan bulat positif ( >= 1). Perilaku ketika n=0karenanya tidak terdefinisi, dan program / fungsi dapat melakukan apa pun yang diinginkannya (tidak menghasilkan apa-apa; mengeluarkan pelangi n=1; output acak; gagal dengan kesalahan; dll.)
• Anda diperbolehkan untuk mengeluarkan daftar / array string atau 2D array / daftar karakter jika Anda mau (Anda bisa menambahkan kode pencetakan cantik yang sebenarnya di footer TIO).
• Abaikan fakta bahwa output lebih mirip kuil Maya daripada pelangi .. xD

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Uji kasus (pertama n=1sampai n=10, dan 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 terima kasih kepada ElPedro.

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

Cobalah online!

JavaScript (ES6), 100 byte

Mengembalikan array string.

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)

Cobalah online!

05AB1E , 32 31 23 byte

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

Cobalah online!

-1 berkat Kevin Cruijssen dan -8 terima kasih kepada Adnan

Penjelasan (Contoh tumpukan dengan input 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.

Kanvas , 29 28 26 byte

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

Coba di sini!

Penjelasan:

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 setelah memperbaiki bahwa shouldold harus berputar jika panjang yang diinginkan lebih besar dari panjang input dan memperbaiki ／seperti waktu ke-10

Haskell , 114 110 101 byte

Terima kasih kepada [nimi] [1] untuk - 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)

Cobalah online!

Dyalog APL , 41 39 38 byte

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

Cobalah online!

Pendekatan serupa dengan yang lain: A←⌈⎕×8÷7menemukan ketinggian pelangi (juga lebar 'setengah baris' terpanjang di kiri / kanan tengah) dan menetapkannya Auntuk digunakan nanti, sementara ¨-⍳iterasi melalui nilai-nilai 1..A, meniadakan mereka untuk memilih di sisi yang benar ketika digunakan dengan ↑.

A⍴' vibgyor'menghasilkan 'setengah baris' dan ⍵↑memilih substring panjang yang benar. (⌽,⊃,A↑⊢)menghasilkan baris penuh secara terbalik (yang membutuhkan lebih sedikit karakter untuk dilakukan), dimulai dengan setengah baris terbalik ( ⌽), kemudian karakter tengah diambil dari awal string setengah baris ( ⊃) dan akhirnya versi empuk kanan setengah baris () A↑⊢). Final ⌽membalikkan baris menjadi orientasi yang benar dan ↑mengubah vektor baris menjadi array 2D.

Sunting: -2 terima kasih kepada dzaima

Sunting: -1 terima kasih kepada 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)

Cobalah online!

Arang , 30 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

↶

Ubah arah gambar ke atas.

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

Hitung ketinggian pelangi dan ulangi string literal sejauh itu.

θ⸿

Cetak garis tengah pelangi.

Ｅθ✂θκ

Cetak bagian kanan pelangi dengan mengambil irisan yang berurutan dan mencetak masing-masing pada "garis" sendiri.

‖Ｏ←

Refleksikan untuk melengkapi pelangi.

Jelly , 31 byte

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

Cobalah online!

Lihatlah suite tes!

ಠ_ಠ Ini terlalu rumit karena Jelly tidak memiliki fungsi terpusat ...

Jelly , 28 byte

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

Tautan monadik yang menerima bilangan bulat yang menghasilkan daftar daftar karakter.

Cobalah online! (footer bergabung dengan karakter baris baru)

Atau lihat test-suite .

Bagaimana?

: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

Cobalah online!

• -6 byte terima kasih kepada @JayCe

Haskell , 106 113 byte

Saya belum dapat mengomentari postingan lain (yaitu ini ) jadi saya harus memposting solusinya sebagai jawaban terpisah.

Golf jauhnya 7 byte demi ov

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

Cobalah online!

( Versi lama , 113 byte)

PowerShell , 108 98 89 85 byte

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

Cobalah online!

Yang ini terasa cukup baik-baik saja sekarang. Pembulatan Bankir masih iblis dan saya menemukan cara untuk membuat bergabung non-bodoh. Saya mencoba monyet dengan $ ofs untuk tidak terlalu sukses. Omong-omong, hasil tanpa bergabung terlihat cukup bagus, agak 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)

Cobalah online!

Diselamatkan:

• -1 byte, terima kasih kepada Jonathan Frech

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

Cobalah online!

Sedikit lebih mudah dibaca:

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

Cobalah online!

Mencetak ruang ekstra depan dan belakang untuk setiap kelipatan 7.

Penjelasan

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
}

Kredit

• -2 byte terima kasih kepada Kevin Cruijssen

Stax , 23 byte

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

Jalankan dan debug itu

Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

" 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

Jalankan yang ini