Giới thiệu:

(Nguồn: Wikipedia )
Khi chúng ta nhìn vào cầu vồng, nó sẽ luôn có các màu từ trên xuống dưới:
Đỏ; trái cam; màu vàng; màu xanh lá; màu xanh da trời; xanh đậm; màu tím

Nếu chúng ta nhìn vào những chiếc nhẫn riêng lẻ này, chiếc nhẫn màu đỏ dĩ nhiên lớn hơn chiếc nhẫn màu tím.
Ngoài ra, cũng có thể có hai hoặc thậm chí ba cầu vồng cùng một lúc.

Tất cả điều này kết hợp ở trên sẽ được sử dụng trong thử thách này:

Thử thách:

Cho một số nguyên n, xuất ra nhiều vòng của (có thể nhiều hơn một) 'cầu vồng', trong đó chúng ta sẽ sử dụng các chữ cái vibgyorcho màu sắc.

Xem các trường hợp thử nghiệm bên dưới để xem cách chúng được xây dựng từ trên xuống n=1và cách xử lý khoảng cách (at n=8). Như bạn có thể thấy, một khoảng trắng được thêm vào giữa hai cầu vồng, bao gồm khoảng cách ở trên cùng, trước khi chúng ta thêm vòng cầu vồng tiếp theo.

Quy tắc thử thách:

• Bạn được phép sử dụng vốn VIBGYORthay vì chữ thường
• Cần có một khoảng trống giữa các cầu vồng riêng lẻ
• Bất kỳ số lượng khoảng trắng hàng đầu và / hoặc dấu / dòng mới nào đều được phép, miễn là cầu vồng thực tế (bất cứ nơi nào nó được đặt trên màn hình) là chính xác
• Đầu vào sẽ luôn là một số nguyên dương ( >= 1). n=0Do đó, hành vi khi không được xác định và chương trình / hàm có thể làm bất cứ điều gì nó muốn (không xuất ra gì; xuất ra cầu vồng n=1; đầu ra ngẫu nhiên; không thành công, v.v.)
• Bạn được phép xuất một danh sách / mảng chuỗi hoặc mảng 2D / danh sách các ký tự nếu bạn muốn (bạn có thể thêm mã in ấn thực tế vào chân trang TIO).
• Bỏ qua thực tế là các đầu ra trông giống như các đền thờ của người Maya hơn là cầu vồng .. xD

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm (từ đầu n=1đến qua n=10và 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 nhờ ElPedro.

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

Hãy thử trực tuyến!

JavaScript (ES6), 100 byte

Trả về một chuỗi các chuỗi.

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)

Hãy thử trực tuyến!

05AB1E , 32 31 23 byte

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

Hãy thử trực tuyến!

-1 cảm ơn Kevin Cruijssen và -8 nhờ Adnan

Giải thích (Ví dụ ngăn xếp w / đầu vào của 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.

Canvas , 29 28 26 byte

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

Hãy thử nó ở đây!

Giải trình:

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 sau khi sửa lỗi đó sẽ quay vòng nếu độ dài mong muốn lớn hơn độ dài đầu vào và sửa ／trong khoảng thời gian thứ 10

Haskell , 114 110 101 byte

Cảm ơn [nimi] [1] cho - 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)

Hãy thử trực tuyến!

APL Dyalog , 41 39 38 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận tương tự với các cách khác: A←⌈⎕×8÷7tìm chiều cao của cầu vồng (cũng là chiều rộng của 'nửa hàng' dài nhất ở bên trái / phải của trung tâm) và gán nó Acho sử dụng sau này, trong khi ¨-⍳lặp qua các giá trị 1..A, phủ định chúng để chọn ở phía bên phải khi được sử dụng với ↑.

A⍴' vibgyor'tạo một 'nửa hàng' và ⍵↑chọn chuỗi con có độ dài chính xác. (⌽,⊃,A↑⊢)tạo ra hàng đầy đủ theo chiều ngược lại (cần ít ký tự hơn để làm), bắt đầu bằng một nửa hàng đảo ngược ( ⌽), sau đó ký tự trung tâm được lấy từ đầu chuỗi nửa hàng ( ⊃) và cuối cùng là phiên bản đệm bên phải của nửa hàng ( A↑⊢). Cuối cùng ⌽đảo ngược hàng thành hướng chính xác và ↑biến vectơ của các hàng thành một mảng 2D.

Chỉnh sửa: -2 nhờ dzaima

Chỉnh sửa: -1 nhờ 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)

Hãy thử trực tuyến!

Than , 30 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

↶

Thay đổi hướng vẽ lên trên.

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

Tính chiều cao của cầu vồng và lặp lại chuỗi ký tự theo chiều dài đó.

θ⸿

In dòng trung tâm của cầu vồng.

Ｅθ✂θκ

In nửa bên phải của cầu vồng bằng cách lấy các lát cắt liên tiếp và in từng lát trên "đường thẳng" của chính nó.

‖Ｏ←

Phản ánh để hoàn thành cầu vồng.

Thạch , 31 byte

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

Hãy thử trực tuyến!

Kiểm tra một bộ thử nghiệm!

_ಠ Điều này quá phức tạp vì Jelly không có chức năng tập trung ...

Thạch , 28 byte

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

Một liên kết đơn âm chấp nhận một số nguyên mang lại một danh sách các danh sách các ký tự.

Hãy thử trực tuyến!(chân trang tham gia với các ký tự dòng mới)

Hoặc xem bộ thử nghiệm .

Làm sao?

: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

Hãy thử trực tuyến!

• -6 byte nhờ @JayCe

Haskell , 106 113 byte

Tôi chưa thể nhận xét các bài đăng khác (cụ thể là bài này ) vì vậy tôi phải đăng giải pháp dưới dạng câu trả lời riêng.

Bỏ đi 7 byte bằng lò nướng

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

Hãy thử trực tuyến!

( Phiên bản cũ , 113 byte)

PowerShell , 108 98 89 85 byte

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

Hãy thử trực tuyến!

Điều này cảm thấy khá ổn bây giờ. Làm tròn ngân hàng vẫn là ma quỷ và tôi đã tìm ra cách để tham gia một cách không ngớ ngẩn. Tôi đã thử làm khỉ với $ ofs để không thành công lắm. Nói về, kết quả mà không tham gia trông khá tốt, một chút u uất:

         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)

Hãy thử trực tuyến!

Đã lưu:

• -1 byte, nhờ Jonathan Frech

Màu đỏ , 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]]]

Hãy thử trực tuyến!

Hơi dễ đọc hơn:

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

Hãy thử trực tuyến!

In một không gian hàng đầu và dấu phụ cho mỗi bội số của 7.

Giải trình

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
}

Tín dụng

• -2 byte nhờ Kevin Cruijssen

Stax , 23 byte

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

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

" 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

Chạy cái này