21

使用任何编程语言以这种方式显示1到99（包括两者）之间的数字，以便：

数字用单个空格隔开，
如果数字可被3整除，则应在括号中，
如果数字可被4整除，则应放在方括号中，
如果数字可被3和4整除，则应同时在括号和方括号中（方括号更靠近数字）。

您的程序应准确显示：

1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)

code-golf kolmogorov-complexity

— 莫尼利卡
source

6

05AB1E，23个字节

-1字节感谢Kevin Cruijssen

тGND4Öi…[ÿ]}N3Öi…(ÿ)]ðý

在线尝试！

— 奥克斯
source

1

通过更改}?ð?为-1字节]ðý（关闭if和loop，并用空格连接整个堆栈）

— Kevin Cruijssen

@KevinCruijssen谢谢，这正是我想要的！

— Okx

-1通过使用Å€

— Grimmy

6

Python 2中，68个 65 60字节

i=0
exec"i+=1;print'('[i%3:]+`[i][i%4:]or i`+')'[i%3:],;"*99

在线尝试！

— ovs
source

1

我是对的：) +1

— ElPedro '18

5

R，61字节

"+"=c
r=""+""
cat(paste0(r+"(",r+""+"[",1:99,r+""+"]",r+")"))

在线尝试！

— 多伊
source

2

辉煌的混叠！

— 朱塞佩

这怎么工作？棒极了！+1给你我的朋友

— Sumner18 '18

4

果冻，21 20字节

³Ṗµ3,4ṚƬḍ×“([“])”j)K

在线尝试！

怎么运行的

³Ṗµ3,4ṚƬḍ×“([“])”j)K  Main link. No arguments.

³                     Set the return value to 100.
 Ṗ                    Pop; yield [1, ..., 99].
  µ               )   Map the chain in between over [1, ..., 9]; for each integer k:
   3,4                    Set the return value to [3, 4].
      ṚƬ                  Reverse until a loop is reached. Yields [[3, 4], [4, 3]].
        ḍ                 Test k for divisibility by [[3, 4], [4, 3]], yielding a
                          matrix of Booleans.
         ×“([“])”         Repeat the characters of [['(', '['], [']', ')']] as many
                          times as the Booleans indicate.
                 j        Join the resulting pair of strings, separated by k.
                   K  Join the resulting array of strings, separated by spaces.

— 丹尼斯
source

3

D，110字节

import std.stdio;void f(){for(int i;i<99;)write(++i%3?"":"(",i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

在线尝试！

从@HatsuPointerKun的C ++答案移植。

— 扎查里
source

3

木炭，30字节

⪫ＥＥＥ⁹⁹Ｉ⊕ι⎇﹪⊕κ⁴ι⪫[]ι⎇﹪⊕κ³ι⪫()ι

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

    ⁹⁹                          Literal 99
   Ｅ                            Map over implicit range
        ι                       Current value
       ⊕                        Incrementd
      Ｉ                         Cast to string
  Ｅ                             Map over list of strings
            κ                   Current index
           ⊕                    Incremented
             ⁴                  Literal 4
          ﹪                     Modulo
              ι                 Current value
                []              Literal string `[]`
                  ι             Current value
               ⪫                Join i.e wrap value in `[]`
         ⎇                      Ternary
 Ｅ                              Map over list of strings
                      κ         Current index
                     ⊕          Incremented
                       ³        Literal 3
                    ﹪           Modulo
                        ι       Current value
                          ()    Literal string `()`
                            ι   Current value
                         ⪫      Join i.e wrap value in `()`
                   ⎇            Ternary
                                Literal space
⪫                               Join list
                                Implicitly print

— 尼尔
source

3

J，54 53字节

@Jonah少了1个字节

(*stdout(3|.0=4 3 1 3 4&|,1=":)#3|.']) ([',":)@>i.100

在线尝试！

— 皱眉蛙
source

感谢您完成此操作。另外，为什么要在stdout这里做...我以前从未见过。@FrownyFrog

— 约拿（Jonah）

@Jonah我无法将其输出为完整的字符串，它被截断（...）stdout不会这样做，并且它也不打印换行符，因此我也可以分别打印每个数字。出于某种原因，尽管它使尾随的空格出现（有4个，并且故意有1个空格）

— FrownyFrog

这种方法真的很聪明，既可以轮换使用，也可以选择使用#。我引入了一个辅助动词来包围()和[]：g=. {.@[ , ":@] , {:@[。太详细了！

— 乔纳

还有一个问题：您使用LF而不是的任何原因_。后者似乎也起作用。

— 乔纳（Jonah）'18

3

C，C ++，136个 133 131 129 128 124字节

-5个字节，感谢Zacharý并受D语言的write（）函数启发（请参阅Zacharý答案）

-2个字节归功于mriklojn

由于mriklojn，C版本的-12个字节

--4个字节，感谢ceilingcat

#include<cstdio>
void f(){for(int i=0;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

C具体优化：115个字节

#include<stdio.h>
i;f(){for(;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

— HatsuPointerKun
source

MSVC可以让您执行此操作inf f()吗？对不起“回合删除我的意见，认为我有什么短（我没有）

— 扎卡里

@Zacharý不，我认为该函数太简单了，它会生成“ f必须返回一个int”。顺便说一句，您的解决方案缩短了3个字节（包括压缩与移动i的增量配对）

— HatsuPointerKun

1

ang，点点忘了那printf件事。那你不能使用C stdio吗？

— 扎卡里

2

您可以使用/利用的另一件事是，至少在gcc 5.3.1中，您不需要#include，并且还可以删除函数返回类型。此外，如果您int i在函数外部声明（在全局范围内），则其值默认为0，数据类型默认为int。这将导致您的循环从0开始，并且要解决此问题，您可以将增量移动到for循环的条件表达式中，使其看起来像是i;f(){for(;++i<=99;)

— mriklojn

1

建议")\0"+i%3而不是i%3?"":")"。另外，我认为您需要i=0在循环开始时添加。

— ceilingcat '18

3

Powershell，60个字节

"$(1..99|%{($_,"($_)","[$_]","([$_])")[!($_%3)+2*!($_%4)]})"

说明：

具有4个元素的数组： $_, "($_)", "[$_]", "([$_])"
和索引： [!($_%3)+2*!($_%4)]
对每个数字重复
将结果转换为字符串

少打高尔夫球的测试脚本：

$f = {

$r = 1..99|%{
    ($_, "($_)", "[$_]", "([$_])") [!($_%3)+2*!($_%4)]
}
"$($r)"

}

$expected = '1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)'
$result = &$f
$result-eq$expected
$result

输出：

True
1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)

— 疯狂的
source

3

MathGolf，41 40 34 29 字节

♀({îû)(î+╫îa_'(\')ßyΓî34α÷ä§

注意：它有一个尾随空格

只有我的第二个MathGolf答案..
-5个字节感谢@JoKing。

在线尝试。

说明：

♀(             # Push 99 (100 decreased by 1)
  {            # Start a loop, which implicitly loops down to (and excluding) 0
   û)(         #  Push string ")("
      î+       #  Append the 1-indexed index
        ╫      #  Rotate the string once towards the right
   îa          #  Push the 1-indexed index of the loop, wrap in a list
   _           #  Duplicate it
    '(        '#  Push string "("
      \        #  Swap the top two items of the stack
       ')     '#  Push string ")"
         ßy    #  Wrap all three into a list, and join them
   Γ           #  Wrap all four into a list
               #  (We now have a list [N, "(N)", "[N]", "([N])"], where N is the index)
   î           #  Push the 1-indexed index of the loop
    34         #  Push 3 and 4 to the stack
      α        #  Wrap all three into a list
       ÷       #  Check for each if the index is divisible by it
               #  (resulting in either [0,0], [0,1], [1,0], or [1,1]
        ä      #  Convert from binary to integer
               #  (resulting in either 0, 1, 2, or 3
         §     #  Push the string at that index from the array
               #  Push a space
               # (After the loop, output the entire stack joined together implicitly)

— 凯文·克鲁伊森
source

@JoKing谢谢！不知道q可以将其省略，并且它是在循环中隐式完成的。另外，也不知道内置了2/3/4字符串。不幸的是，旋转技巧不适用于包装好的数组。

— 凯文·克鲁伊森

好吧，更多的是，我在每次迭代时都将显式输出替换为程序末尾的隐式输出

— Jo King

@JoKing是的，但我不知道它会输出整个堆栈，而不是仅输出顶部。:)

— Kevin Cruijssen

我的解决方案接近40个字节，尽管我误读并认为应使用大括号而不是方括号。解决方案做得好！

— maxb

2

Haskell，77个字节

unwords[f"()"3$f"[]"4$show n|n<-[1..99],let f(x:r)m s|mod n m<1=x:s++r|1<3=s]

在线尝试！

我不知道是否show[n]可以用来缩短东西，至今无果。

— 莱科尼
source

2

Lua中，161个 123字节

b=""for i=1,99 do;c,d=i%3==0,i%4==0;b=b..(c and"("or"")..(d and"["or"")..i..(d and"]"or"")..(c and")"or"").." "end;print(b)

在线尝试！

取消高尔夫：

b = ""
for i = 1, 99 do
    c = 1 % 3 == 0
    d = 1 % 4 == 0
    a = ""
    if c then
        a = a .. "("
    end
    if d then
        a = a .. "["
    end
    a = a .. i
    if d then
        a = a .. "]"
    end
    if c then
        a = a .. ")"
    end
    b = b .. a .. " "
end
print(b)

— 戴维·惠特利
source

2

Python 2中，105个 97 88 86 85 84字节

x=1
while x<100:print((('%s','(%s)')[x%3<1],'[%s]')[x%4<1],'([%s])')[x%12<1]%x,;x+=1

在线尝试！

— 埃尔佩德罗
source

2

C（gcc），84个字节

main(i){while(99/i++)printf("%s%s%d%s%s ","("+i%3,"["+i%4,i-1,"]"+i%4,")"+i%3);}

每个“括号字符串”的开头都有一个空字节。

在线尝试！

— 丹尼斯
source

在“（”“ + i％3中，您如何知道i = 2的地址指向零字符值？对于{[，3}中的i [[+ i％4]，我也是如此？

— RosLuP

它可以与gcc一起使用，这已经足够好了，因为PPCG通过其实现定义了语言。

— 丹尼斯

我认为您不能说在gcc编译器的每个实现中都可以正确编译代码，也许只有一个可以在您的PC中运行（但可能不太行）

— RosLuP

@RosLuP GCC 做工作，在大多数计算机上以同样的方式，虽然，至少在用相同的架构什么

— ASCII-仅

@ASCII唯一可能，如果针对空间或速度进行了优化编译的结果是不同的...我不知道它是否超出标准...

— RosLuP

2

PowerShell，67 62字节

"$(1..99|%{'('*!($x=$_%3)+'['*!($y=$_%4)+$_+']'*!$y+')'*!$x})"

在线尝试！

基本上，FizzBuzz使用字符串乘法乘以布尔变量（隐式转换为1或0）。这些字符串留在管道上，并收集在引号内的脚本块中。由于$OutputFieldSeparator数组的默认值是空格，因此这隐式地为我们提供了以空格分隔的数组元素。

— AdmBorkBork
source

2

C＃，124个 117 123字节

-5个字节，感谢Kevin Cruijssen

x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}

测试：

Action<int> t = x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}
t.Invoke(0);
Console.ReadKey();

— HatsuPointerKun
source

我知道要进入C＃了。C＃是否允许整数作为三元运算符的左参数，还是必须为布尔值？

— 扎卡里

我对C＃不太了解，但是您可以使用它x而i不用担心它int 吗？（当然，您仍然需要设置它）。

— 扎卡里

@Zacharý不，它生成CS0029错误“无法将int隐式转换为boolean”。是的，我可以使用i的事实是，当我将其初始化为0时Invoke。但这是否意味着我必须在字节数中包含t（Action<int>）的声明和call（t.Invoke(0)）的声明？

— HatsuPointerKun

我问类似的东西 x=>{for(x=0;x++<99;)Console.Write((x%3==0?"(":"")+(x%4==0?"[":"")+x+(x%4==0?"]":"")+(x%3==0?")":"")+(x%99==0?"":" "));};是否行得通。

— 扎卡里

1

全部五个==0都可以<1。

— 凯文·克鲁伊森

2

红色，99 97字节

repeat n 99[a: b: c: d:""if n% 3 = 0[a:"("c:")"]if n% 4 = 0[b:"["d:"]"]prin rejoin[a b n d c" "]]

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

2

红宝石，72 66字节

p [*1..99].map{|x|a=x
a="[#{x}]"if x%4<1
a="(#{a})"if x%3<1
a}*' '

感谢@ jonathan-frech和@ conor-obrien进行的其他修饰。

— 会穿越
source

您好，欢迎来到PPCG！70个字节。

— 乔纳森·弗雷希

欢迎来到PPCG！这是@JonathanFrench建议的另外4个字节，为66个字节，因为a.join b数组a和字符串b等效于a*b

— Conor O'Brien

2

PowerShell，98 82 74 67 63 62字节

@Veskah高达-31个字节，仅@ASCII使得-5个字节

(1..99|%{(($a=($_,"[$_]")[!($_%4)]),"($a)")[!($_%3)]})-join' '

在线尝试！

我仍然不太确定我在这里做了什么。

— 加布里埃尔·米尔斯（Gabriel Mills）
source

只是快速打高尔夫70个字节。您不必将$ a强制转换为字符串，并且"$a"仍将替换为值。（注意：单引号不能代替$foo，只能是双引号）。另一个技巧是，如果只关心0或1，则可以使用布尔逻辑来保存字节

— Veskah

如果还使用列表索引，则为67个字节。

— Veskah

也67

— 仅限ASCII

63吗

— 仅ASCII码

62吗

— 仅使用ASCII

1

perl -E，60个字节

$,=$";say map$_%12?$_%3?$_%4?$_:"[$_]":"($_)":"([$_])",1..99

如果我们可以在数字之间使用换行符，则可以节省一些字节：在这种情况下，我们可以删除$,=$";，将其更改map为for循环，同时将其say移至循环中。

1

您是阿比盖尔吗？发明者/^1$|^(11+?)\1+$/？

— msh210 '18

1

哇。能有您在这里真是荣幸！

— msh210 '18

1

Perl 6的，51 48个字节

put {$_%3??$^a!!"($a)"}(++$_%4??$_!!"[$_]")xx 99

在线尝试！

— 恩韦恩霍夫
source

我要虐待列表和数组表示，等之间的区别这个，但我不知道如何摆脱周围的整个列表封闭括号...

— 乔金

@JoKing我也考虑过这个问题，但是我只想出了这个51-byter。

— nwellnhof '18

1

批处理，145字节

@set s=
@for /l %%i in (1,1,99)do @set/an=%%i,b=n%%4,p=n%%3&call:c
@echo%s%
:c
@if %b%==0 set n=[%n%]
@if %p%==0 set n=(%n%)
@set s=%s% %n%

该代码进入子例程，但此时字符串已被打印出来，因此该代码无害地执行。

— 尼尔
source

1

PHP 103

for(;$i<1e2;$i++)$a.=$i%12==0?"([$i]) ":($i%3==0?"($i) ":($i%4==0?"[$i] ":"$i "));echo substr($a,5,-1);

https://www.ideone.com/SBAuWp

— th3pirat3
source

1

干净，100字节

import StdEnv,Text

join" "[if(n/3*3<n)m("("+m+")")\\n<-[1..99],m<-[if(n/4*4<n)(""<+n)("["<+n<+"]")]]

在线尝试！

— 巨大
source

1

sfk，225字节

for n from 1 to 99 +calc -var #(n)/3+1/3 -dig=0 +calc -var #text*3-#(n) +setvar t +calc -var #(n)/4 -dig=0 +calc -var #text*4-#(n) +xed -var _0_#(t)\[#(n)\]_ _*_#(t)#(n)_ +xed _0*_([part2])_ _?*_[part2]_ +xed "_\n_ _" +endfor

在线尝试！

— 巨大
source

1

Bash，61个字节

-14个字节，感谢Dennis

seq 99|awk '{ORS=" ";x=$1%4?$1:"["$1"]";print$1%3?x:"("x")"}'

说明

很简单：

seq 产生1..99
我们将其awk与输入记录分隔符（ORS）设置为空格进行管道连接，以使输出为单行。
当数字可被4整除时，awk主体仅添加“ []”，然后可被3整除时在其上添加“（）”。

在线尝试！

— 约拿
source

1

JavaScript（Node.js），57字节

f=(n=99)=>n&&f(n-1)+(s=n%4?n:`[${n}]`,n%3?s:`(${s})`)+' '

在线尝试！

更改为社区CUZ，因为优化过分依赖它

— l4m2
source

您可以通过这样做来显着缩短${n%4?n:`[${n}]`}

— ETHproductions'Nov

66个字节（带有ETH的建议）

— Alion

59字节

— Arnauld

57字节

— Neil

1

PHP，65字节

while($i++<99)echo$i%4?$i%3?$i:"($i)":($i%3?"[$i]":"([$i])")," ";

要么

while($i++<99)echo"("[$i%3],"["[$i%4],$i,"]"[$i%4],")"[$i%3]," ";

（需要PHP 5.5或更高版本）

运行-nr或在线尝试它们。

— 提图斯
source

1

Python 2，78个字节

i=0
exec"i+=1;u=i%3/-2*(i%4/-3-1);print'([%0d])'[u:7-u:1+(i%3<1<=i%4)]%i,;"*99

在线尝试！

我设想了这种很酷的方法切片，'([%0d])'但是我无法再缩短表达式了。

— 林恩
source

1

Java 8，92 91字节

-1字节感谢@Dana

i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}

在线尝试！

替代解决方案，82字节（输出中带有尾随空格-不确定是否允许）：

i->{for(;i++<99;)out.printf((i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)+" ",i);}

说明：

for(;i++<99;)-for循环，其值从i（重新用作输入，在这种情况下为0）到99

out.printf(<part1>+<part2>,i); -在立即将字符串打印到标准输出之前，先格式化该字符串 i

其中<part1>是(i>1?" ":"")-打印空间之前打印的数量，除非该数为1，在这种情况下省略了空间

并且<part2>是(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)-如果i可被3和4整除，i则在其周围有方括号和圆形括号；否则i被3整除，i有圆括号；否则，如果i可以被4整除，则i带有方括号；否则，i没有括号。

— 非巴尔
source

通过将空间移到每个循环迭代的开始来节省一个字节(i>1:" ":"")

— dana

仅当我将结果反向打印时才有效（请参见this），但实际上将节省2个字节而不是1个字节

— 。– NotBaal

不幸的是，这与每个问题的预期输出不同，但是仍然感谢您的建议！

— NotBaal

1

“在线尝试”链接似乎已损坏。我在想i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}什么？

— dana

1

哦，您是对的，确实有效！感谢那！

— NotBaal

多重性测试

05AB1E，23个字节

Python 2中，68个 65 60字节

R，61字节

果冻，21 20字节

怎么运行的

D，110字节

木炭，30字节

J，54 53字节

C，C ++，136个 133 131 129 128 124字节

C具体优化：115个字节

Powershell，60个字节

MathGolf，41 40 34 29 字节

Haskell，77个字节

Lua中，161个 123字节

Python 2中，105个 97 88 86 85 84字节

C（gcc），84个字节

PowerShell，67 62字节

C＃，124个 117 123字节

红色，99 97字节

红宝石，72 66字节

PowerShell，98 82 74 67 63 62字节

perl -E，60个字节

Perl 6的，51 48个字节

批处理，145字节

PHP 103

干净，100字节

sfk，225字节

Bash，61个字节

说明

JavaScript（Node.js），57字节

PHP，65字节

Python 2，78个字节

Java 8，92 91字节