Fizz Buzz在列中具有唯一字符

21

受数字在他们的车道和1，2，Fizz，4，Buzz中的启发

介绍

您的任务是完全生成以下输出：

1
2
Fizz
4
  Buzz
    Fizz
7
8
      Fizz
        Buzz
 11
          Fizz
   13
    14
            FizzBuzz
     16
      17
              Fizz
       19
                  Buzz
                    Fizz
 22
    23
                      Fizz
                        Buzz
   26
                          Fizz
     28
      29
                            FizzBuzz
       31
      32
                              Fizz
34
                                  Buzz
                                    Fizz
 37
  38
                                      Fizz
                                        Buzz
        41
                                          Fizz
  43
   44
                                            FizzBuzz
      46
       47
                                              Fizz
         49
                                                  Buzz

挑战

此挑战基于Fizz Buzz挑战，下面是一个回顾：输出1到100（含）之间的数字，每个数字在各自的行上显示，但是如果数字是3的倍数，则应输出“ Fizz”而不是原始数字，如果数字是5的倍数，则应输出“ Buzz”而不是原始数字。如果数字是15的倍数，则应输出“ FizzBu​​zz”而不是原始数字。

但是，除了上述要求之外，还应该使用空格缩进每一行，以使每一列仅包含唯一字符（不包括空格和换行符）。每行之前的空格是使所有行（包括每行）在每一列中具有唯一字符之前显示的最低要求。

例如，1,2,Fizz,4不需要任何压痕，因为他们已经在每列的唯一字符（第1列：12F4，列2： i，栏3：z，column4： z），但加入的时候Buzz，我们需要缩进两个空格，否则，我们将有两个z的在第三列和第四列中。由于两个空格足以实现目标，因此您不应将其缩进三个空格。7并且8不需要任何缩进，但是在输出时，11我们需要缩进一个空格，因为第一列已经有一个1。13然后需要缩进三个空格，因为现在第一，第二和第三列都有一个1。其余行的缩进遵循相同的规则。

为了简化挑战，上限已更改为50。

眼镜

  • 您可以编写程序或函数。他们都不应该接受任何非空输入。输入空输入即可。

  • 由于这是KC挑战，因此您需要按照“简介”部分中指定的方式生成输出。一条尾随的换行符就可以了。没有标题换行符或多余的标题空间。每行没有多余的尾随空格。

  • 只要STDOUT符合规范，您的程序就可以错误退出或具有非空的STDERR输出。

  • 这是语言内代码高尔夫球，具有最低字节数的程序以其语言获胜。

  • 默认漏洞适用。

code-golf  kolmogorov-complexity 
— 周卫军
source
2
给定的输出与规范不完全匹配，例如第
— 12、20、35
1
但是前两行的第二个字符是回车符。
— 累积
我已经排除了空格，现在我也应该排除换行符。
— 周

Answers:

9

Python 2，127个字节

i=0;exec"print ord('<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn'[i])%60*' '+(i%3/2*'Fizz'+i%5/4*'Buzz'or`-~i`);i+=1;"*50

在线尝试！

一个五十字节的查找表对代码大小的损害似乎小于跟踪每一列中出现了哪些字符所必需的逻辑。

— 林恩
source
1
如果要求我们最多打印100张，那么逻辑会更好
— 。–
5

Python 2中，167个 166 163 161 157字节

a=eval(`[{0}]*99`);i=0
exec"f=i%3/2*'Fizz'+i%5/4*'Buzz'or`i+1`;i+=1;g=0\nwhile any(b>{c}for b,c in zip(a[g:],f)):g+=1\nmap(set.add,a[g:],f);print' '*g+f;"*50

在线尝试！

编辑：

  • while短于for..range()1个字节。
  • 感谢@ovs削减了3个字节。我总是忘记exec...
  • 改编i%3/2自Lynn的答案的技巧（-2个字节）。
  • @Lynn建议a=map(set,[[]]*99)，但我发现了使用eval和repr具有相同字节（-4字节）的另一种方法。

使用一组列表来跟踪用于每一列的字符，并为成员资格设置不等式。其余遵循给出的确切规格。

— 起泡器
source
4

C（GCC） ，145个 144字节（143十六进制）

i;main(){for(;i++<50;printf("%*s%s%.d\n","000402800:81>34@56B7BH14JH3N56P76R0RX12ZX8^23`67b9b"[i]-48,i%3?"":"Fizz",i%5?"":"Buzz",i%3*i%5?i:0));}

在线尝试！

0000h: 69 3B 6D 61 69 6E 28 29 7B 66 6F 72 28 3B 69 2B ; i;main(){for(;i+
0010h: 2B 3C 35 30 3B 70 72 69 6E 74 66 28 22 25 2A 73 ; +<50;printf("%*s
0020h: 25 73 25 2E 64 5C 6E 22 2C 22 FE FE FE 02 FE 00 ; %s%.d\n","......
0030h: 06 FE FE 08 06 FF 0C 01 02 0E 03 04 10 05 10 16 ; ................
0040h: FF 02 18 16 01 1C 03 04 1E 05 04 20 FE 20 26 FF ; ........... . &.
0050h: 63 28 26 06 2C 00 01 2E 04 05 30 07 30 22 5B 69 ; c(&.,.....0.0"[i
0060h: 5D 2B 32 2C 69 25 33 3F 22 22 3A 22 46 69 7A 7A ; ]+2,i%3?"":"Fizz
0070h: 22 2C 69 25 35 3F 22 22 3A 22 42 75 7A 7A 22 2C ; ",i%5?"":"Buzz",
0080h: 69 25 33 2A 69 25 35 3F 69 3A 30 29 29 3B 7D    ; i%3*i%5?i:0));}
— 平方米
source
3

红宝石，129字节

puts (1..50).map{|n|" "*(".<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn"[n].ord%60)+("FizzBuzz
"[i=n**4%-15,i+13]||n.to_s)}

在线尝试！

对于查找表方法和fizzbuzz算法，这里要归功于Lynn 。

FizzBu​​zz算法非常有趣，它基于一个惊人的巧合，即所有小于15的正非整数（不包括3和5）当加到4的幂时，都比15的倍数大1。事实：

 n     n**4  n**4%15  n**4%-15
 1        1     1       -14
 2       16     1       -14
 3       81     6        -9
 4      256     1       -14
 5      625    10        -5
 6     1296     6        -9
 7     2401     1       -14
 8     4096     1       -14
 9     6561     6        -9
10    10000    10        -5
11    14641     1       -14
12    20736     6        -9
13    28561     1       -14
14    38416     1       -14
15    50625     0         0

值3**4%15和5**4%15恰好相距4：字符串“ Fizz”的长度。我们可以利用它们从至少9个字符的字符串末尾开始索引来利用这一点。3的倍数将从字符串的开头开始索引，而5的倍数将从字符串的最后5个字符开始索引。每隔一个数字将尝试从字符串开头之前开始进行索引，然后失败，返回nil。然后15，当然是从第0个字符开始的索引。“ FizzBu​​zz”只有8个字符的事实是一个小障碍。我们使用换行符将其填充，稍后将被忽略puts。

查找表可能会通过一种更具过程性的方法而超出实际需求，但我的尝试是在190个字节附近。

— benj2240
source
2
有趣。应当注意的是，当所有数字均以15模1取15的四次幂时，它们互质为15的事实可以从费马小定理得出。
— 周
2

[JavaScript（Node.js）REPL]，144字节

(f=(i,s=[['Fizz'][i%3]]+[['Buzz'][i%5]]||i+[],b=i>1?f(i-1):[])=>[...s].some((p,j)=>b.some(w=>w[j]==p&0!=p))?f(i,' '+s):b.push(s)&&b)(50).join`

`

在线尝试！

警告程序本身运行时间过长

JavaScript（Node.js），132字节，由Arnauld

f=(a=n=[],s=`${b=++n%5?'':'Buzz',n%3?b||n:'Fizz'+b}
`)=>n>50?'':a.some(x=>[...x].some((c,i)=>c!=0&c==s[i]))?f(a,' '+s):s+f([s,...a])

在线尝试！

— 平方米
source
您的答案似乎与TIO链接不同
— Jo King
@JoKing TIO输出数组，我不知道是否允许
— l4m2，18年
1

Haskell中，190个187 186 178 176字节

unlines$foldl(\a x->a++[[z|z<-iterate(' ':)x,all(\m->null[p|(p,q)<-m`zip`z,p==q&&p>' '])a]!!0])[]$h<$>[1..50]
a%b=a`mod`b<1
h n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz"|1<2=show n

在线尝试！

稍易读（并带有注释）的版本：

-- check if a is evenly divisible by b
a%b=a`mod`b<1
-- produce correct FizzBuzz output for a number
h n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz"|1<2=show n
-- test if all chars distinct between two strings
x#y=null[a|(a,b)<-x`zip`y,a==b&&a>' ']
-- given a new string and all previous strings
-- shift the new string to the right until all
-- chars are distinct
x!y=[z|z<-iterate(' ':)y,all(z#)x]!!0
g=h<$>[1..50]
f'=foldl step[]g
  where step acc x = acc++[acc!x]

编辑：我最终在高尔夫版本中内联了一些功能以节省更多字节。

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source
@Laikoni对。固定。
— 克里斯蒂安·卢帕斯库
1

Jstx，122 字节

◄50-☺6*ø($♥:ø↕♂Fizz♀☺(◙$♣:ø↕♂Buzz♀6☺(◙"ø↕$6◙♂<<<<>@<<BD=F?@HABJCNP=@RT?VABXCBZ<^`=>bdDf>?hBCjEn'[i])%60*♀&P◄59▼ö,► 7.☻a0.2

在线尝试！

— 量子64
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.