Codegolf Rainbow：黑白画

12

介绍：

在此处输入图片说明（来源：Wikipedia）
当我们看着彩虹时，它将始终具有从上到下的颜色
。橙子; 黄色; 绿色; 蓝色; 靛青; 紫色

如果我们看这些单独的环，红色环当然要比紫色环大。
另外，也可以同时有两个甚至三个彩虹。

以上所有这些结合将用于此挑战：

挑战：

给定一个integer n，输出很多（可能不止一个）“彩虹”的圆环，在这里我们将使用字母vibgyor作为颜色。

请参阅下面的测试用例，以了解如何从向上构建它们n=1，以及如何处理间距（在处n=8）。如您所见，在我们在一行中添加下一个彩虹的环之前，在两个彩虹之间添加了一个空格，包括顶部的间距。

挑战规则：

  • 您可以使用大写VIBGYOR字母而不是小写字母
  • 各个彩虹之间应该有一个间隔
  • 只要实际的彩虹（放置在屏幕上的任何位置）正确，就可以使用任何数量的前导和/或尾随空格/换行符
  • 输入将始终为正整数（>= 1）。n=0因此，何时的行为是不确定的，并且程序/函数可以执行任何所需的操作（不输出任何内容；输出彩虹n=1；随机输出；由于错误而失败等）。
  • 如果需要，您可以输出字符串列表/数组或2D数组/字符列表（可以在TIO页脚中添加实际的漂亮打印代码）。
  • 忽略输出看起来更像玛雅神庙而不是彩虹的事实。xD

通用规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您使用非代码高尔夫球语言发布答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案，因此允许您使用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
code-golf  string  ascii-art  number 
— 凯文·克鲁伊森
source
3
也许您知道这一点，这是设计使然的（我知道彩虹也不是菱形或ascii，并且更高阶的位置会变得更加复杂），但是第二个彩虹中的颜色不是颠倒了吗？
— 克里斯M
1
@ChrisM啊，你确实是对的。有两个彩虹时，第二个确实颠倒了，但只有三个彩虹时，外面的颠倒了，而有四个彩虹的外面都颠倒了。嗯，现在更改它为时已晚。也许以后我会想到第三个相关的挑战。:)
— Kevin Cruijssen
1
— 凯文·克鲁伊森
哦，太好了！：¬）
— Chris M

Answers:

3

JavaScript（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)

在线尝试！

— Arnauld
source
3

05AB1E，32 31 23字节

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

在线尝试！

-1感谢Kevin Cruijssen，-8感谢Adnan

说明（带有输入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.
— 魔术章鱼缸
source
1
"vibgyor"可以打1个字节到.•2Bãθ(•。（在这里的 “ 如何压缩不属于字典的字符串？ ”部分中的解释。）此外，„vr…v r:ð«还可以使用'v„v .:。所以28个字节。不错的答案，但我+1。
— 凯文·克鲁伊森
2
@KevinCruijssen哦，我对字符串压缩一无所知-我只是想（通常超小型字符串就是这种情况）的3字节膨胀.••不会节省一个字节。图中的一次，我实在不检查是不是时间将节省字节的xD。好收获
— 魔术章鱼缸
3
— Adnan
1
@Adnan相当公平，但是缺少镜子却使它在我眼中成为了重要的重构（而且我怀疑我是否会独自到达那里：P）。
— 魔术章鱼缸
1
@Adnan也是个¬ý天才... 真是的...您的想法与众不同，太棒了。
— 魔术章鱼缸
3

画布，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"

如果所需长度大于输入长度并固定了第10次，则固定该mold后应循环25 24 22字节／

— 宰马
source
出于好奇，为什么v偏向（<）？如果v已经是Canvas中的保留关键字，那么为什么不使用它<作为反向关键字呢？
— 凯文·克鲁伊森
1
垂直使用字符然后旋转，并且Canvas足够聪明，<v
— 可以确定
好的，如果您v在这里使用过，然后将其逆时针旋转90度，它就会变成>。我知道了。：D
— 凯文·克鲁伊森
@KevinCruijssen那就会有其他后果太
— dzaima
啊，那边还有镜子吗？我看不懂Canvas tbh，所以我期待代码的解释。;）
— Kevin Cruijssen
3

Haskell中，114个 110 101字节

感谢[nimi] [1] -4 13个字节！

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)

在线尝试！

— ovs
source
3

Dyalog APL，41 39 38字节

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

在线尝试！

与其他方法相似的方法：A←⌈⎕×8÷7找到彩虹的高度（以及中心左​​侧/右侧最长的“半排”的宽度），并将其分配给A以后使用，同时¨-⍳迭代值1..A，与一起使用时，否定它们在正确的一侧进行选择↑。

A⍴' vibgyor'生成“半行”并⍵↑选择正确长度的子字符串。(⌽,⊃,A↑⊢)生成反向的完整行（只需花费较少的字符），从反向的半行（⌽）开始，然后从半行字符串（⊃）的开头获取中心字符，最后是半行的右填充版本（A↑⊢）。最终⌽将行反转为正确的方向，↑并将行向量转换为2D数组。

编辑： -2感谢dzaima

编辑： -1感谢ngn

— 捕鼠器
source
您可以替换⍕⍪为↑-允许输出2D字符数组
— dzaima
— dzaima
1+÷7->8÷7
— ngn
2

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

在线尝试！

— 竿
source
2

木炭，30字节

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

在线尝试！链接是详细版本的代码。说明：

↶

将绘图方向更改为向上。

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

计算彩虹的高度，然后将文字字符串重复到该长度。

θ⸿

打印彩虹的中心线。

Ｅθ✂θκ

拍摄连续的切片并将其打印在自己的“行”上，以打印彩虹的右半部分。

‖Ｏ←

反射以完成彩虹。

— 尼尔
source
2

果冻，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)
— 乔纳森·艾伦
source
2

Haskell，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字节）

— 马克斯·叶赫拉科夫
source
好答案。我不知道Haskell，但是代码似乎与其他Haskell答案有很大不同。PS：Haskell的其他答案实际上是@nimi的注释中的高尔夫球提示之后的110个字节。无论如何，这是一个不错的替代Haskell答案，所以我+1。
— 凯文·克鲁伊森
1
似乎列表理解是应对这一挑战的更好工具。通过减少功能总数，我能够使您的解决方案达到106字节。随时适应这些变化。
— ovs '18
2

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
— 维斯卡
source
[int] $ x + = $ x / 7吗？
— mazzy
@mazzy对于x = 25失败。您必须截断但强制转换为int轮
— Veskah '18
是。截断是
— 可行的
1
我知道@mazzy，我知道截断的唯一方法是[math] :: truncate（）或上面使用的正则表达式技巧。[int] $ x将数字四舍五入。如果您知道更好的方法，我会全力以赴。
— 维斯卡
1

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

在线尝试！

已保存：

  • -1字节，感谢乔纳森·弗雷希（Jonathan Frech）
— 场
source
为什么//在Python 2中？
— 乔纳森·弗雷希
@JonathanFrech因为我很笨：P
— TF
@dzaima，是的。应该立即修复
— TF
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 ]
    ]
]
— 加伦·伊万诺夫（Galen Ivanov）
source
1

Java（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
}

学分

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
通过更改,w=-~h*2+1,i=h+1为,i=h+1,w=i*2+1
— Kevin Cruijssen，
哇，我真的不应该在午夜之前打高尔夫球！谢谢你，@ KevinCruijssen！:)
— OlivierGrégoire18年
建议i-~i而不是i*2+1
— ceilingcat '19
1

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

运行这个

— 递归的
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.