谢尔宾斯基层

19

首先，/\您可以通过在下面添加一条线来创建类似于Sierpinski三角形的图案，从而...

  1. 任何松散的分支/或\再次分裂为两个分支：/\。
  2. 分支的任何碰撞都将\/死，其下无任何东西（只有空格）。

重复这些规则将产生

     /\
    /\/\
   /\  /\
  /\/\/\/\
 /\      /\
/\/\    /\/\
etc...

（ViHart的启发）

编写一个程序或函数，该程序或函数接受一个正整数N，并将此模式的前N行打印到stdout，且前导或尾随空格不超过所需数量。

例如，如果输入是1输出，则必须为

/\

如果输入是2输出，则必须为

 /\
/\/\

如果输入是8输出，则必须为

       /\
      /\/\
     /\  /\
    /\/\/\/\
   /\      /\
  /\/\    /\/\
 /\  /\  /\  /\
/\/\/\/\/\/\/\/\

等等。

字节最少的代码获胜。

code-golf  fractal  code-golf  math  polynomials  abstract-algebra  code-golf  geometry  3d  popularity-contest  string  code-golf  math  3d  code-golf  javascript  browser  code-golf  random  array-manipulation  code-golf  restricted-source  javascript  set-theory  code-golf  graph-theory  path-finding  decision-problem  code-golf  code-golf  primes  c  code-golf  graphical-output  fractal  fastest-code  simulation  code-golf  sequence  code-golf  graphical-output  code-golf  code-golf  math  binary  rational-numbers  code-golf  number  fibonacci  popularity-contest  code-golf  number  code-golf  game 
— 卡尔文的爱好
source
1
您能否将其设置为“最少字节数”以避免代码压缩的恶作剧？
— xnor
@xnor已更改。
— 卡尔文的爱好2014年
我实际上是要发布此。卑鄙的 ：/
— Kaz Wolfe 2014年
APL的答案在哪里？
— 2014年

Answers:

9

GolfScript（42个字节）

~,-1%1\{' '*\.2base{'  /\\'2/=}%n@.2*^}/;;

在线演示

这利用了Pascal三角形和Sierpinski三角形之间的众所周知的关系。

— 彼得·泰勒
source
6

CJam，48 46字节

li(_S*"/\\":T+\{_N@S+TW%/S2**" /"/"\ "f/:+T*}*

基于问题1和2的简单递归方法。

在线尝试。

怎么运行的

li(         " L := int(input()) - 1            ";
_S*         " A := L * ' '                     ";
"/\\":T+    " A += (T := '/\')                 ";
\{          " do L times:                      ";
  _N        "   push A, '\n'                   ";
  @S+       "   A += ' '                       ";
  TW%/      "   B := A.split(reverse(T))       ";
  S2**      "   A := '  '.join(B)              ";
  " /"/     "   B := A.split(' /')             ";
  "\ "f/    "   C := { X.split('\ ') : X ∊ B } ";
  :+T*      "   A := T.join(sum(C, []))        ";
}*          "                                  ";

CJam，51个字节

li__2mL,1a\{2_@##)1$f*+}/<f{2b_"  /\\"2/f=@@,-S*\N}

我更喜欢这种方法，但是它不能与递归方法竞争。即使消除了2mL（这至少导致O（2 n）执行时间），我仍然有48个字节...

这种方法将/\s 编码为1，并将它们之间的双倍空格编码为0。考虑到结果数组的二进制数，我们看到第n行的配置对应于大于1 的第n个整数，该整数可以表示为不同费马数的乘积（形式为2 2 k +1的整数）。

怎么运行的

li__2mL,1a         " push L := int(input()), L, R := range(log(L)/log(2)), A := [1] ";
\{2_@##)1$f*+}/    " for I in R: A += { a × 2**(2**I) : a ∊ A }                     ";
<                  " A := A[:L]                                                     ";
f{                 " for I in R: push L, I                                          ";
  2b_"  /\\"2/     "   push (B := base(I, 2)), B, S := [ '  ' '/\' ]                ";
  f=               "   for J in I: J := S[J]                                        ";
  @@,-S*\N         "   push (L - len(B)) * ' ', J, '\n'                             ";
}                  "                                                                ";
— 丹尼斯
source
5

蟒2 - 140 139 127 122 121 118 116

N=input()
b,V,m,n=' V/\\'
s=b*~-N+m+n
R=str.replace
while N:print s;N-=1;s=R(R(R(R(s+b,b+m,V),n+b,V),n+m,b+b),V,m+n)

基于临时字符串替换（/programming//a/8687380/3419103）：

  1. / > V
  2. \ > V
  3. \/> __（2个空格）
  4. V > /\
— 法尔科
source
b*(N-1)+m+n可能是b*~-N+m+n
— FryAmTheEggman 2014年
@FryAmTheEggman：太棒了！现在我明白了，JavaScript！;）
— Falko 2014年
4

Javascript-117字节

缩小：

T=n=>{S=' '.repeat(n-1);a='/\\';for(t=s=S+a+S;--n;t+='\n'+s)s=s.replace(/\\\//g,'  ').replace(/ \/|\\ /g,a);return t}

展开：

T = n => {
    S = ' '.repeat( n-1 );
    a = '/\\';
    for( t = s = S + a + S; --n; t += '\n' + s )
        s = s.replace( /\\\//g, '  ' ).replace( / \/|\\ /g, a );

    return t;
}

样本输出（用于n = 20）：

                   /\                   
                  /\/\                  
                 /\  /\                 
                /\/\/\/\                
               /\      /\               
              /\/\    /\/\              
             /\  /\  /\  /\             
            /\/\/\/\/\/\/\/\            
           /\              /\           
          /\/\            /\/\          
         /\  /\          /\  /\         
        /\/\/\/\        /\/\/\/\        
       /\      /\      /\      /\       
      /\/\    /\/\    /\/\    /\/\      
     /\  /\  /\  /\  /\  /\  /\  /\     
    /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\    
   /\                              /\   
  /\/\                            /\/\  
 /\  /\                          /\  /\ 
/\/\/\/\                        /\/\/\/\

现在，如果repeatand replace函数的名称没有那么长。：P

— 首席技术官
source
3

Pyth，45个字节

K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"

运行示例

$ pyth -c 'K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"' <<< 16
               /\
              /\/\
             /\  /\
            /\/\/\/\
           /\      /\
          /\/\    /\/\
         /\  /\  /\  /\
        /\/\/\/\/\/\/\/\
       /\              /\
      /\/\            /\/\
     /\  /\          /\  /\
    /\/\/\/\        /\/\/\/\
   /\      /\      /\      /\
  /\/\    /\/\    /\/\    /\/\
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

怎么运行的

                            # Q = eval(input())
K"/\\"                      # K = "/\\"
      Jt+*QdK               # J = (Q * " " + K)[1:]
             VQ             # for N in range(Q):
               pbJ          #     print(J, end="\n")
                            #
=JjK                        #     J = K.join(
    sm                      #         sum(list(map(lambda d:
      cd"\ "                #             d.split("\ "),
            c               #                                                .split(    )
             j*2d           #              " ".join(                        )
                 c   _K     #                                .split(K[::-1])
                  +Jd       #                       (J + " ")
                       " /" #                                                       " /"
                            #     ))))
— 丹尼斯
source
3

红宝石，90岁

f=->n{a=["/\\".center(2*n)]
2.upto(n){a<<a[-1].gsub("\\/","  ").gsub(/ \/|\\ /,"/\\")}
puts a}

说明

  • 输入作为lambda的参数。预计将是一个Integer。
  • 使用String#center创建String "/\"与n - 2每一侧的空间，并把它变成一个Array（a）。
  • 添加到a的最后一个元素中a，每次"\/"替换为" "，每次替换为" /"或" \"替换为"/\"。
  • 用于puts在每个a行上打印每个元素。
— 英国茶
source
3

Haskell中，128 112

g n=unlines$take n$i t([1..n]>>" ")%(i(\l->l++l%i(t.t)(t l>>"  ")%l)["/\\"]!!n)
t=tail
(%)=zipWith(++)
i=iterate
— 骄傲的哈斯克勒
source
如果我import Data.Listunlines
— 算出
@Flonk unlines在前奏中。
— 骄傲的haskeller
糟糕，也许我应该在评论之前先查一下。我的错！
— Flonk
2

的JavaScript（E6）107 106

编辑：固定字节数，进行递归。

与其他JS答案没有太大不同……至少此代码可按要求“打印”模式。核心是在每一行中将'/''\'替换为'/ \'，其余的全部替换为''。

F=(n,o=t='/\\',b=' ')=>
  n--&&
    console.log(b.repeat(n)+o)|
    F(n,(b+o+b).replace(/../g,s=>s==b+b|s=='\\/'?b+b:t))

在FireFox / FireBug控制台中测试

F(15)

输出量

                  /\
                 /\/\
                /\  /\
               /\/\/\/\
              /\      /\
             /\/\    /\/\
            /\  /\  /\  /\
           /\/\/\/\/\/\/\/\
          /\              /\
         /\/\            /\/\
        /\  /\          /\  /\
       /\/\/\/\        /\/\/\/\
      /\      /\      /\      /\
     /\/\    /\/\    /\/\    /\/\
    /\  /\  /\  /\  /\  /\  /\  /\
— edc65
source
2

Perl 5-56个字节

\ 0可以替换为实际的空字节字符

#!/usr/bin/perl -l
$p="/\\";$_=$"x~$_.$p,y/\0/ /,print,$p^="\0\0$p"for-<>..-1

它使用以下事实：如果忽略前导空格并将'/ \'表示为1并将''表示为0，则给定行中的模式f（n）= f（n-1）^（f（n-1）< <1）。但是，由于perl的按位字符串操作，上面代码中的计算是在接近预期输出的字符串上执行的（没有前导空格，其他空格替换为空字节）。

$p="/\\";          # initialize
  $_=$"x~$_.$p,    # loop start, add spaces
  y/\0/ /,         # replace nulls with spaces
  print,           # output
  $p^="\0\0$p"     # calculate next string
for-<>..-1         # loop from -n to -1
— 坚果
source
1

Python 2，84个字节

n=i=input()
while i:print' '*i+''.join("/ \ "[j&i+1>0::2]for j in range(n-i+1));i-=1
— 异或
source
0

JavaScript和lambda表达式，141 128

141

f=n=>{for(a="25",q=0;++q<n;a=a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25));return a[r](/./g,x=>"  /  \\"[x])}

128

f=n=>(t=a=>--n?t(a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25)):a)("25")[r](/./g,x=>"  /  \\"[x])

可以在Firefox（n = 16）上进行测试：

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
— Qwertiy
source
0

Python 2，97个字节

i=input()
x=1
while i:i-=1;print " "*i+bin(x)[2:].replace("0","  ").replace("1", "/\\");x^=2*x
— 波什尼克
source
欢迎来到编程难题和代码高尔夫球！好的答案：D
— 猫
0

Mathematica，86个字节

Column[Row/@Mod[Table[Binomial[n,k],{n,0,#-1},{k,0,n}],2]/.{1->"/\\",0->"  "},Center]&
— J42161217
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.