Các thách thức

Xây dựng một N-san Cantor Set .

Bộ ternary Cantor được tạo bằng cách xóa liên tục phần ba mở giữa của một tập hợp các phân đoạn dòng.

Chương trình nhận một tham số N(số nguyên) và sau đó in (trong bảng điều khiển hoặc cách tương tự) một Tập hợp các cấp độ N. Bản in chỉ có thể chứa các _ký tự dấu gạch dưới ( ) và dấu cách. Tham số có thể là dương hoặc âm và dấu hiệu cho biết hướng xây dựng Bộ Cantor: Nếu N > 0Bộ Cantor được xây dựng xuống và nếu N < 0Bộ Cantor được xây dựng lên. Nếu N = 0sau đó chương trình in một dòng duy nhất ( _).

Ví dụ:

N = 2

_________
___   ___
_ _   _ _

N = -2

_ _   _ _
___   ___
_________

N = 3

___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _

N = -3

_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

Tiêu chí chiến thắng

Vì nó là một thử thách golf mã, mã ngắn nhất sẽ thắng.

Đã chỉnh sửa: Sửa đổi 0 đầu vào theo đề xuất của ugoren.

GolfScript, 49 42 40 ký tự

~.abs.3\?'_'*\{.3%..,' '*\++}*](0>2*(%n*

Cảm ơn hammar cho 42-> 40.

Nỗ lực tốt nhất của tôi theo cách tiếp cận lý thuyết số nhiều hơn đáng buồn là lâu hơn nhiều:

~.abs:^3\?,{3^)?+3base(;1+1?.'_'*^@-)' '*+}%zip\0>2*(%n*

hoặc là

~.abs 3\?:^,{6^*+3base.1+1?.('_'*@,@-' '*+}%zip\0>2*(%n*

và tôi nghi ngờ rằng độ dài basevà zipsẽ khiến nó không thể bắt kịp.

Python, 116 113 104 103 ký tự

n=input()
d=n>0 or-1
for i in range(n*d+1)[::d]:
 s='_'*3**i
 while i<n*d:s+=len(s)*' '+s;i+=1
 print s

Thuật toán cũ đứng đầu với 113 ký tự

r=input()
u='_'
l=[u]
for _ in abs(r)*u:o=len(l[0]);l=[s+o*' '+s for s in l]+[u*o*3]
print'\n'.join(l[::r>0 or-1])

Hồng ngọc (97)

Dựa trên phiên bản trăn của Steven Rumbalski:

n,r=$*[0].to_i,[?_]
n.abs.times{z=r[0].size;r=r.map{|s|s+' '*z+s}+[?_*z*3]}
puts n<0?r:r.reverse

Những lần thử trước, cả hai cùng chiều dài (112)

Xây dựng các dòng từ các bộ phận:

c=->x,n{n<1??_*x :(z=c[s=x/3,n-1])+' '*s+z}
r=(0..m=(n=$*[0].to_i).abs).map{|i|c[3**m,i]}
puts n<0?r.reverse: r

Bắt đầu với một dòng, tạo lỗ hổng trong nó:

r=[?_*3**a=(n=$*[0].to_i).abs]
a.times{|c|r<<r[-1].gsub((x=?_*o=3**(a-c-1))*3,x+' '*o+x)}
puts n<0?r.reverse: r

Perl, 93 ký tự

@x=($t=$x=_ x 3**($a=abs($n=<>)),map$x.=$"x($x=~s/(.)../$1/g).$x,1..$a);say for$n<0?sort@x:@x

Tôi nghĩ tôi sẽ thử xem giải pháp GolfScript của Peter Taylor sẽ chuyển đến Perl tốt như thế nào . Các tính năng đáng chú ý bao gồm việc sử dụng sortthay vì reverseđể lưu ba ký tự, sử dụng thực tế là một không gian sắp xếp trước đó _.

Lisp thông thường, 217 210 ký tự

(defun m(x)(flet((c(n v)(if(= n 0)`((,v))(cons(substitute v nil(make-list(expt 3 n)))(mapcar #'append(c(1- n)v)(c(1- n)" ")(c(1- n)v))))))(format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

Mở rộng:

(defun m(x)
  (flet((c(n v)
    (if(= n 0)
       `((,v))
       (cons(substitute v nil(make-list(expt 3 n)))
            (mapcar #'append
                    (c(1- n)v)
                    (c(1- n)" ")
                    (c(1- n)v))))))
   (format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

Tôi hình dung nếu mã Lisp quản lý để đánh bại bất kỳ số đếm ban đầu nào cho ngôn ngữ khác (C, 219) Tôi đang làm tốt :)

C ( 163 161 ký tự)

i,l,N;f(n,m,s){if(n){s=--n<l?m:s;f(n,m,s);f(n,s,s);f(n,m,s);}else
putchar(m);}main(n,v)int**v;{for(i=N=abs(n=atoi(1[v]));i+1;i--)l=n<N?N-i:i,f(N,95,32),f(0,10);}

Mượn một vài mánh khóe từ câu trả lời của ugoren , nhưng logic cốt lõi thì hoàn toàn khác. Tôi không thể theo vòng lặp của anh ấy, vì vậy có thể lai và tiết kiệm thêm một vài thứ nữa.

C, 219 193 179 143 136 131 ký tự

Thực hiện theo các ý tưởng khác của Petyer Taylor, cộng với sự cải tiến của riêng tôi, đã tiết kiệm thêm 6 ý tưởng.
Tích hợp một số mẹo từ @PeterTaylor, cộng với sao chép chức năng chính của anh ấy, với những thay đổi nhỏ, giúp tiết kiệm một ký tự (sao chép công bằng? Vì cả hai chúng tôi sẽ không giành được cái này, tôi đoán nó không quá tệ).
Tôi đã nghĩ đến một sự cải thiện đáng kể trong cách thức đệ quy của tôi hoạt động, và sau khi thấy câu trả lời của Peter Taylor, tôi đã thực hiện nó để lấy lại vị trí dẫn đầu. Khi đọc câu trả lời của anh ấy một lần nữa, tôi thấy rằng tôi đã làm gần như chính xác những gì anh ấy đã làm. Vì vậy, điều này có vẻ như sự lai tạo mà ông đề xuất.
Cũng đơn giản hóa các vòng lặp trong main, giữ nguyên chiều dài.
Và lấy mẹo của Peter để in dòng mới, thay vì puts("")- lưu một ký tự.

Xóa intkhỏi khai báo biến - một cảnh báo, nhưng lưu 4 ký tự.
Thuật toán mới không tính toán trước 3 ^ x, nhưng sử dụng một vòng lặp duy nhất để in 3 ^ x ký tự.
Có thể lưu thêm một lần nữa bằng cách xác định int*v, nhưng sau đó 64 bit sẽ không hoạt động.
Số ký tự không bao gồm khoảng trắng (có thể được loại bỏ).

o,i,n;
p(c) {
    n-- ?
        p(c),p(o>n?c:32),p(c)
    :
        putchar(c);
    n++;
}
main(c,v)int**v; {
    for(n=abs(c=atoi(v[1]));i<=n;i++)o=c+n?n-i:i,p(95),puts("");
}

Thuật toán cũ hơn, ký tự 219:

p(l,o,i,m,c,j) {
    for(;i<(m=l);i++)
        for(j=0,c=95;m/o||!putchar(c);j++)
            i/m%3-1||(c=32),m/=3;
    puts("");
}
main(c,v,n,i,l,o)int**v;{
    (n=atoi(v[1]))<0?n=-n:(c=0);
    for(i=n,l=1;i;i--)l*=3;
    o=c?1:l;
    for (;i<=n;i++)p(l,o,0),c?o*=3:(o/=3);
}

J, 44 39 38 37 byte

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|

Sử dụng phép lặp để xây dựng bộ tiếp theo bắt đầu bằng 1 (đại diện _ ) ban đầu.

Sử dụng

   f =: ' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|
   f 0
_
   f 1
___
_ _
   f _1
_ _
___
   f 2
_________
___   ___
_ _   _ _
   f _2
_ _   _ _
___   ___
_________
   f 3
___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _
   f _3
_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

Giải trình

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|  Input: integer n
                                    |  Absolute value of n
                (,:1)                  The array [1]
                     1&(          )~   Repeat abs(n) times starting with x = [1]
                                 ]       Identity function, gets x
                            0&*          Multiply x by 0
                               ,.        Join the rows together
                         ]               Identity function, gets x
                          ,.             Join the rows together
                     1  ,                Prepend a row of 1's and return
      0&>                              Test if n is negative, 1 if true else 0
         _&(   )                       If n is negative
             |.                          Reverse the previous result
            ]                            Return that
                                       Else pass the previous result unmodified
' _'                                   The string ' _'
    {~                                 Select from the string using the result
                                       as indices and return

R , 141 139 137 byte

m=abs(n<-scan());write("if"(n<m,rev,c)(c(" ","_")[Reduce(`%x%`,rep(list(matrix(c(1,1,1,1,0,1),3)),m),t(1))[,1+2^m-2^(m:0)]+1]),1,3^m,,"")

Hãy thử trực tuyến!

-15 byte cũng nhờ sử dụng '('chức năng nhận dạng của Giuseppe ; writethay vì catin đầu ra; sử dụng thông minh%x% .

-2 byte nhờ Kirill L. bằng cách sử dụng cthay vì '('làm chức năng nhận dạng.

Con trăn, 177 164 ký tự

N=input()
n=abs(N)
c=lambda x:0if x<1 else x%3==1or c(x/3)
r=["".join([["_"," "][c(x/3**i)]for x in range(3**n)])for i in range(n+1)]
print"\n".join(r[::N>0 or-1])

Perl, 113 ký tự

$i=abs($I=<>);@w=$_='_'x3**$i;while($i--){$x=3**$i;s/(__){$x}/'_'x$x.' 'x$x/eg;push@w,$_}say for$I>0?reverse@w:@w

Mở rộng:

$i=abs($I=<>);
@w=$_='_'x3**$i;
while($i--){
    $x=3**$i;
    s/(__){$x}/'_'x$x.' 'x$x/eg;
    push@w,$_
}
say for$I>0?reverse@w:@w

JavaScript 121 byte

Hàm đệ quy bên trong, sau đó chăm sóc đầu ra ngược nếu cần

n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

Ít chơi gôn

n=>{
  var f = n => { // recursive function
    var t = n && f(n-1), r = t[0]
    return n 
      ? [r+r+r, ...t.map(x => x+t[n]+x)]
      : ['_',' ']
  };
  f = f(n < 0 ? -n : n);
  f.pop(); // last row is all blanks
  if (n<0) f.reverse();
  return f.join`\n`
}

Kiểm tra

var F=
n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

function go()
{
  var n=+I.value
  O.textContent = F(n)
}

go()

<input id=I type=number value=3 oninput='go()'>
<pre id=O></pre>

Hàng loạt, 265 262 242 236 235 byte

@echo off
set/pn=
set c=%n%,-1,0
if %n% lss 0 set c=0,1,%n:-=%
for /l %%i in (%c%)do call:l %%i
exit/b
:l
set s=_
for /l %%j in (1,1,%n:-=%)do call:m %1 %%j
echo %s%
:m
set t=%s%
if %1 lss +%2 set t=%s:_= %
set s=%s%%t%%s%

Chỉnh sửa: Đã lưu 12 19 byte nhờ @ l4m2. Đã lưu 8 byte bằng cách loại bỏ %a%biến không cần thiết .

JavaScript (Node.js) , 148 byte

n=>f=(L=n<0&&n,R=n>0&&n)=>[...Array(r=3**(n>0?n:-n))].map(_=>((j++).toString(3)+1).indexOf(1)>(L>0?L:-L)?'_':' ',j=r+r).join``+`
${L++<R?f(L,R):''}`

Hãy thử trực tuyến!

Con trăn 2 , 102 byte

lambda n:'\n'.join(eval("[i+' '*len(i)+i for i in"*abs(n)+"'_'"+"]+['___'*len(i)]"*abs(n))[::n<1or-1])

Hãy thử trực tuyến!

Prolog (SWI) , 265 232 213 byte

S-E-R:-between(S,E,R).
[]/R/R.
[H|T]/B/R:-T/[H,32,H|B]/R.
N+R:-(N>0->O is N-1,O+S,S/[]/R;R=`_`).
N*[H|T]:-1-N-_,writef("%n",[H]);N*T.
_*[]:-nl.
-N:-(0-N-J,K is N-J;N-0-I,J is -I,K is I-N),L is 3^K,J+R,L*R,1=0;1=1.

Hãy thử trực tuyến!

PowerShell , 111 byte

filter f{if($s=[math]::Sign($_)){($x=$_-$s|f|%{$_+' '*($l=$_|% Le*)+$_})|?{$s-1};'_'*3*$l;$x|?{$s+1}}else{'_'}}

Hãy thử trực tuyến!

Ít chơi gôn hơn:

filter f{
    if($sign=[math]::Sign($_)){
        $x=$_-$sign|f|%{
            $_+' '*($length=$_|% Length)+$_
        }
        $x|?{$sign-1}  # output $x if $_ is negative
        '_'*3*$length
        $x|?{$sign+1}  # output $x if $_ is positive
    }
    else{
        '_'
    }
}