소개:

(출처 : Wikipedia )
무지개를 보면 항상 위에서 아래로
색이 나타납니다. 주황색; 노랑; 초록; 푸른; 남빛; 제비꽃

이 개별 고리를 보면 빨간색 고리는 물론 보라색 고리보다 큽니다.
또한, 동시에 2 개 또는 3 개의 무지개를 가질 수도 있습니다.

이 모든 도전 과제는이 도전에 사용됩니다 :

도전:

integer가 주어지면 n(무엇보다 하나 이상의) '무지개'의 많은 고리가 출력되며, 여기서 문자 vibgyor를 색상으로 사용합니다 .

아래의 테스트 사례를 참조 n=1하여을 (를 n=8) 위쪽으로 구축 하는 방법과 간격을 처리하는 방법 ( )을 확인하십시오. 보시다시피, 다음 무지개의 고리를 줄에 추가하기 전에 상단의 간격을 포함하여 두 무지개 사이에 하나의 공간이 추가됩니다.

도전 규칙 :

• VIBGYOR소문자 대신 대문자를 사용할 수 있습니다
• 개별 무지개 사이에 공간이 있어야합니다
• 실제 레인보우 (화면에 배치 된 곳)가 올바른 한 모든 선행 및 / 또는 후행 공백 / 개행이 허용됩니다.
• 입력은 항상 양의 정수 ( >= 1)입니다. 따라서 동작 n=0이 정의되지 않은 경우 프로그램 / 함수는 원하는 것을 수행 할 수 있습니다 (아무것도 출력하지 않고 무지개 n=1출력; 임의 출력; 오류와 함께 실패 등).
• 원하는 경우 문자열 목록 / 배열 또는 2D 배열 / 문자 목록을 출력 할 수 있습니다 (TIO 바닥 글에 실제 예쁜 인쇄 코드를 추가 할 수 있음).
• 출력물이 무지개보다 마야 사원처럼 보인다는 사실을 무시하십시오. xD

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 케이스 (첫째 n=1을 통해 n=10, 그리고 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

파이썬 2 , 84 82 81 바이트

ElPedro 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 100 바이트

문자열 배열을 반환합니다.

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)

온라인으로 사용해보십시오!

05AB1E , 32 31 23 바이트

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

온라인으로 사용해보십시오!

Kevin Cruijssen 덕분에 -1, Adnan 덕분에 -8

설명 (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.

캔버스 , 29 28 26 바이트

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

여기 사용해보십시오!

설명:

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 바이트 그 후에 몰드를 고정 해 순환 원하는 길이 입력 길이보다 큰 고정 인 경우 ／10 시간 등에

하스켈 , 114 (110) 101 바이트

-4 13 바이트에 대해 [nimi] [1] 님 감사 합니다!

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)

온라인으로 사용해보십시오!

Dyalog APL , 41 39 38 바이트

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

온라인으로 사용해보십시오!

다른 사람에 대한 비슷한 접근 방식 : A←⌈⎕×8÷7무지개의 높이 (중앙의 왼쪽 / 오른쪽으로 가장 긴 '반 줄'의 너비) A를 찾아 나중에 사용 하기 위해 할당 ¨-⍳하고 값 1 을 반복합니다. 와 함께 사용할 때 올바른면을 선택하도록 부정합니다 ↑.

A⍴' vibgyor''반쪽 행'을 생성 ⍵↑하고 올바른 길이 하위 문자열을 선택합니다. (⌽,⊃,A↑⊢)반 줄 반 ( ⌽)부터 시작하여 반 줄 문자열 ( ⊃) 의 시작 부분에서 가져온 가운데 문자와 반 줄 의 오른쪽 패딩 된 버전 ( A↑⊢). 마지막 ⌽은 행을 올바른 방향으로 바꾸고 행 ↑벡터를 2D 배열로 바꿉니다 .

편집 : dzaima 덕분에 -2

편집 : ngn 덕분에 -1

파이썬 2 , 108 바이트

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)

온라인으로 사용해보십시오!

숯 , 30 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

↶

도면 방향을 위로 변경하십시오.

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

무지개의 높이를 계산하고 리터럴 문자열을 해당 길이로 반복하십시오.

θ⸿

무지개의 중심선을 인쇄하십시오.

Ｅθ✂θκ

연속적인 슬라이스를 가져 와서 각각의 "라인"으로 인쇄하여 무지개의 오른쪽 절반을 인쇄합니다.

‖Ｏ←

무지개를 완성하십시오.

젤리 , 31 바이트

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

온라인으로 사용해보십시오!

테스트 스위트를 확인하십시오!

elly_ ಠ 젤리에는 중앙 집중식 기능이 없기 때문에 지나치게 복잡합니다 ...

젤리 , 28 바이트

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

문자 목록을 생성하는 정수를 허용하는 모나드 링크.

온라인으로 사용해보십시오! 바닥 글은 개행 문자와 결합합니다.

또는 테스트 스위트를 참조하십시오 .

어떻게?

: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 바이트

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

온라인으로 사용해보십시오!

• @JayCe 덕분에 -6 바이트

하스켈 , 106113 바이트

다른 게시물 (즉, this )에 댓글을 달 수 없으므로 솔루션을 별도의 답변으로 게시해야합니다.

ovs에 의해 7 바이트 떨어져 골프

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

온라인으로 사용해보십시오!

( 이전 버전 , 113 바이트)

PowerShell , 108 98 89 85 바이트

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

온라인으로 사용해보십시오!

이것은 지금 꽤 기분이 좋습니다. 뱅커의 반올림은 여전히 ​​악마이며 벙어리가 아닌 조인 방법을 알아 냈습니다. 나는 많은 성공을 거두지 않기 위해 $ ofs로 원숭이를 시도했습니다. 말하자면 조인이없는 결과는 꽤 좋아 보입니다.

         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

파이썬 (2) , 132 (131) 바이트

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)

온라인으로 사용해보십시오!

저장 됨 :

• Jonathan Frech 덕분에 -1 바이트

빨강 , 153 바이트

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

온라인으로 사용해보십시오!

약간 더 읽기 쉽다 :

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

자바 (JDK 10) , 184 바이트

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

온라인으로 사용해보십시오!

7의 배수로 추가 선행 및 후행 공간을 인쇄합니다.

설명

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
}

크레딧

• Kevin Cruijssen 덕분에 -2 바이트

Stax , 23 바이트

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

실행 및 디버깅

포장을 풀고 포장을 풀고 주석을 달았습니다.

" 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

이것을 실행