Viết chương trình lấy số nguyên N qua stdin hoặc dòng lệnh.

Nếu N bằng 0, chữ cái đơn Ophải được in ra thiết bị xuất chuẩn.

Nếu N dương tính , chuỗi xoắn kép nghệ thuật ASCII nằm ngang này , được vẽ N phân đoạn rộng, phải được in.

Nếu N là 1, đầu ra là:

 /\
O  O
 \/

Nếu N là 2, đầu ra là:

 /\ /\
O  /  O
 \/ \/

Nếu N là 3, đầu ra là:

 /\ /\ /\
O  /  /  O
 \/ \/ \/

Nếu N là 4, đầu ra là:

 /\ /\ /\ /\
O  /  /  /  O
 \/ \/ \/ \/

Mẫu tiếp tục theo cùng một cách chính xác cho N. lớn hơn Lưu ý rằng dấu gạch chéo ( /) phải được sử dụng ở tất cả các vị trí của các chuỗi xoắn ốc, ngoại trừ các Ođầu.

Nếu N âm tính , chuỗi xoắn kép nghệ thuật ASCII dọc này , được vẽ các đoạn -N cao, phải được in.

Nếu N là -1, đầu ra là:

 O
/ \
\ /
 O

Nếu N là -2, đầu ra là:

 O
/ \
\ /
 \
/ \
\ /
 O

Nếu N là -3, đầu ra là:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

Nếu N là -4, đầu ra là:

 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O

Mẫu tiếp tục theo cùng một cách chính xác cho N. nhỏ hơn Lưu ý rằng các dấu gạch chéo ngược ( \) phải được sử dụng ở tất cả các vị trí của các chuỗi xoắn ốc, ngoại trừ các Ođầu.

Chi tiết

• Thay vì một chương trình, bạn có thể viết một hàm lấy N làm số nguyên và in kết quả bình thường hoặc trả về dưới dạng chuỗi.
• Đầu ra cho bất kỳ N có thể tùy ý chứa một dòng mới.
• Bất kỳ dòng đầu ra cho bất kỳ N có thể tùy chọn chứa 4 hoặc ít hơn dấu cách.
• Không bao giờ nên có bất kỳ không gian hàng đầu nào không phải là một phần của mẫu được chỉ định.
• Mã ngắn nhất tính bằng byte thắng.

CJam, 56 55 53 52 50 byte

S'O:Ori:X0>"\/"=" / \\\ / "+Xz*1>O]s3/X"z"<~N*X\O?

Nhìn kích thước đó! Thủ phạm chính là N = 0trường hợp đặc biệt và \thay vì /trong vòng xoắn dọc.

Đây là cách nó làm việc:

S'O:O                                  e# Put a space on stack. Now put char O on stack
                                       e# and assign it to variable O. This is not really
                                       e# helping in golfing as using 'O everywhere is
                                       e# same number of bytes
     ri:X                              e# Read input as in integer and store it in X
         0>"\/"=                       e# If X is greater than 0, choose /, otherwise \
                " / \\\ / "            e# Put this string on stack
                           +           e# Append to chosen \ or /
                            Xz*        e# Repeat it abs(X) times
1>                                     e# Remove the first character from repeated string
  O]                                   e# Put char O on stack, wrap everything in an array
                                       e# and convert it to string.
    3/                                 e# Split the string into parts of length 3
      X"z"<~                           e# If X is positive, transpose the array to get a
                                       e# horizontal helix, otherwise it would be vertical
            N*                         e# Join the parts with newline
              X\O?                     e# If X was 0, then pick char O instead of this
                                       e# final joined string.

Mã được chia thành ba phần:

• Phần X0>"\/"=" / \\\ / "+cung cấp một trong hai "/ / \\\ / "hoặc "\ / \\\ / "rất quan trọng vì chuỗi xoắn đơn giản được tạo thành từ xen kẽ "/ \"và được "\ /"nối bởi một trong hai " / "hoặc " \ ". Chẳng hạn, nếu bạn coi đầu vào là 2, thì chuỗi lặp lại cuối cùng của bạn sẽ là "/ / \\ / / / \\ / "(không thoát). Điều này rõ ràng có thêm /ở đầu và một không gian thêm ở cuối.
• Phần thứ hai là sửa chuỗi trên với những điều bổ sung và phân chia. Đối với một đầu vào 2, chuỗi cuối cùng mong muốn không có dòng mới " O / \\\ / / / \\\ / O", nhưng sau điểm trên, chúng ta chỉ có "/ / \\\ / / / \\\ / ". Vì vậy, chúng tôi loại bỏ ký tự đầu tiên, thêm một khoảng trắng và 'Oở đầu và một ký tự khác 'Oở cuối. Sau đó, chúng tôi cuối cùng đã chia nó thành 3 phần
• Cuối cùng, chúng tôi quyết định có chuyển đổi chuỗi phân tách này cho chuỗi xoắn dọc hay không; Tham gia các phần theo dòng mới; Và chọn giữa ký tự này và một ký tự đơn 'O(cho trường hợp 0 ​​đầu vào)

Dùng thử trực tuyến tại đây

JavaScript (ES6), 126 132 133

A=n=>(F=(f,j='')=>f+(j+f).repeat(n-1),n>0?F(' /\\')+`
o${F('  ','/')}o
`+F(' \\/'):(n=-n)?` o${F(`
/ \\
\\ /
`,' \\')} o`:'o') 

// Test
for(i=0;i<10;i++)
  P.innerHTML = P.innerHTML + A(i)+'\n\n\n',
  N.innerHTML = N.innerHTML + A(-i)+'\n\n\n'

pre { 
  font-size: 10px;
  line-height: 9px;
}

<table>
<tr><th>Positive</th><th>Negative</th></tr>
<tr><td valign=top><pre id=P></pre></td><td><pre id=N></pre></td></tr>
</table>

Sử dụng chuỗi templated, dòng mới đếm.

Dễ đọc hơn

A=n=>(
  F=(f,j='')=>f+(j+f).repeat(n-1),
  n > 0 ? F(' /\\') + '\no' + F('  ','/') + 'o\n'+F(' \\/')
  : (n=-n) ? ' o' + F('\n/ \\\n\\ /\n',' \\')'+' o':'o'
)  

Bình thường, 52 byte

M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)?jb?gQ\/>Q0msdCg_Q\\Q\O

Trình diễn, thuyết trình.

Giải trình:

Phần đầu tiên M[Jj"/\\"*hGdjP*G+*2dH*2\O_J), định nghĩa một hàm, gcó hai đầu vào. Đầu vào đầu tiên G, là số lần lặp lại để sử dụng. Đây là giá trị tuyệt đối của đầu vào. Đầu vào thứ hai H, là ký tự đặt ở trung tâm của các hình xoắn ốc.

Hàm trả về danh sách 3 phần tử, bao gồm 3 dòng của xoắn ốc dương và 3 cột của xoắn ốc âm.

Phần tử đầu tiên được xác định bởi Jj"/\\"*hGd. *hGdlà chuỗi G+1không gian. j"/\\"*hGdtham gia chuỗi đó với "/\"tư cách là đồng hồ đo. Lúc Jđầu lưu giá trị kết quả để sử dụng trong tương lai.

Yếu tố thứ hai là jP*G+*2dH*2\O. Chúng tôi bắt đầu với +*2dH. Đây là hai khoảng trắng theo sau là ký tự đầu vào. Sau đó, chúng tôi lặp lại chuỗi Glần đó với *G. Sau đó, chúng tôi loại bỏ nhân vật cuối cùng của nó với P. Cuối cùng, chúng tôi bao quanh chuỗi này với hai Oký tự, với j ... *2\O.

Phần tử thứ ba được tạo ra với _J. Điều này chỉ đơn giản là đảo ngược của dòng đầu tiên.

Phần sau, ?jb?gQ\/>Q0msdCg_Q\\Q\Ochọn giữa ba vị trí khác nhau, dương, âm và bằng không. Các điều kiện if-then đầu tiên trên Q, đầu vào. Các điều kiện thứ hai trên >Q0, cho dù đầu vào là tích cực.

Nếu Qbằng 0, \Oký tự Ođược in.

Nếu Qlà khác không, chúng tôi tham gia kết quả của ternary thứ hai trên dòng mới và in nó, với jb. Nếu Qlà dương, danh sách tham gia và in là gQ\/, g(Q,"/").

Nếu Qlà âm, danh sách được nối và in là msdCg_Q\\. Chúng tôi bắt đầu với g_Q\\, đó là g(-Q,"\"). Sau đó, chúng tôi hoán chuyển các hàng và cột với C. msdbiến các bộ ký tự kết quả thành chuỗi, sẵn sàng để được nối trên dòng mới và được in.

Con trăn 2, 118

n=input()
a=[' O '[n==0:]]+['/ \\','\\ /','  /\\ '[n<0::2]]*abs(n)
a[-1]=a[0]
for x in[a,zip(*a)][n>0]:print''.join(x)

Tạo chuỗi xoắn kép dọc từ danh sách các chuỗi và hoán đổi nó để có được chuỗi ngang. Tôi chắc chắn rằng nó có thể được cải thiện.

Java, 500 488 byte

Lần thử đầu tiên của tôi, và thật không may, nó dài hơn 10 * so với nhà lãnh đạo hiện tại :(. Có ai có bất kỳ mẹo nào (ngoài việc sử dụng một ngôn ngữ khác) không?

import java.util.*;class t{public static void main(String[] args){Scanner sc=new Scanner(System.in);int n=Integer.parseInt(sc.nextLine());if(n>0){for(int i=0;i<n;i++)System.out.print(" /\\");o("");System.out.print('o');for(int i=0;i<n-1;i++)System.out.print("  /");o("  o");for(int i=0;i<n;i++)System.out.print(" \\/");}else if(n<0){o(" o ");for(int i=0;i<-n-1;i++){o("/ \\");o("\\ /");o(" \\ ");}o("/ \\");o("\\ /");o(" o ");}else o("o");}static void o(String s){System.out.println(s);}}

Haskell, 156 byte

h 0="O"
h n|n>0=' ':c n "/\\ "++"\nO"++c(n-1)"  /"++"  O\n "++c n "\\/ "
   |0<1=" O\n/ \\\n"++c(-n-1)"\\ /\n \\\n/ \\\n"++"\\ /\n O"
c x=concat.replicate x

Sau đó bạn có thể viết nó dưới dạng:

*Main> putStrLn $ h 1
 /\ 
O  O
 \/ 
*Main> putStrLn $ h 0
O
*Main> putStrLn $ h (-1)
 O
/ \
\ /
 O
*Main> putStrLn $ h 3
 /\ /\ /\ 
O  /  /  O
 \/ \/ \/ 
*Main> putStrLn $ h (-3)
 O
/ \
\ /
 \
/ \
\ /
 \
/ \
\ /
 O
*Main>

C #, 242 241 238 230 222 219 byte

Được thúc đẩy bởi nhận xét của Martin , đây là nỗ lực đầu tiên của tôi về một cái gì đó như thế này:

string h(int n){int x=0;string p="",r=n==0?"O":p;if(n>0){for(;x++<n;){r+=" /\\";p+=" \\/";}r+="\nO  ";for(;x-->2;)r+="/  ";r+="O\n"+p;}else if(n<0){r+=@" O
/ \
";for(--x;x-->n;)r+=@"\ /
 \
/ \
";r+=@"\ /
 O";}return r;}

Dễ đọc hơn:

string h(int n)
{
    int x = 0;
    string p = "",
            r = n==0 ? "O" : p;
    if (n > 0) {
        for (; x++ < n;) {
            r += " /\\";
            p += " \\/";
        }
        r += "\nO  ";
        for (; x-- > 2;) r += "/  ";
        r += "O\n" + p;
    }
    else if(n<0) {
        r += @" O
/ \
";
        for (--x; x-- > n;) r += @"\ /
 \
/ \
";
        r += @"\ /
 O";
    }
    return r;
}

C # 199 197 196 byte

string f(int n){var u=n<0;int m=u?-n:n;string a="",b=" O ";for(;m-->0;)b+="\n/ \\\n\\ /\n "+(m==0?"O ":u?"\\ ":"/ ");for(;++m<3;)a+=string.Concat(b.Split('\n').Select(s=>s[m]))+"\n";return u?b:a;}

Phiên bản bị đánh cắp:

    string f(int n)
    {
        var u = n < 0;
        int m = u ? -n : n;
        string a = "", b = " O ";
        for (; m-- > 0; ) b += "\n/ \\\n\\ /\n " + (m == 0 ? "O " : u ? "\\ " : "/ ");
        for (; ++m < 3;) a += string.Concat(b.Split('\n').Select(s => s[m])) + "\n"; 
        return u ? b : a;
    }

Ý tưởng là xây dựng màn hình ngang từ màn hình dọc bằng cách hiển thị ma trận chuyển vị của các ký tự.

Python 3, 118 byte

x=int(input())
print("O"if x==0else" /\\"*x+"\nO "+" / "*(x-1)+" O\n"+" \\/"*x if x>0else(" O"+"\n/ \\\n\\ /\n \\"*-x)[:-1]+"O")

Lần gửi mã golf đầu tiên của tôi, vì vậy nó có thể không ấn tượng chút nào.

Chỉ cần sử dụng Python ... nếu ... khác ... toán tử tạm thời để phân tách ba kịch bản. Điều đó mang lại một chuỗi được tạo từ việc lặp lại một số chuỗi nhỏ hơn một số lần nhất định để in.

Julia, 229 byte

Trời ơi, đây là cách, cách quá lớn. Đó là câu trả lời dài nhất cho đến nay bởi một biên độ lớn. Tôi có thể có thể tiết kiệm rất nhiều bằng cách trả lại chuỗi thay vì in nó hoặc bằng cách tránh tiếp cận ma trận hoàn toàn. Tôi sẽ thử nghiệm điều đó sau.

n->(if n==0 println("O")else m=abs(n);A=B=reshape(split(" / "*(n>0?"/":"\\")*" \\\\ /",""),(3,3));E=[" ";"O";" "];if m>1for i=2:m B=hcat(B,A)end end;B[:,1]=E;B=hcat(B,E);C=n>0?B:B';for i=1:size(C,1) println(join(C[i,:]))end end)

Điều này tạo ra một hàm lambda có một số nguyên duy nhất và in chuỗi xoắn kép được định dạng thích hợp. Để gọi nó, đặt tên cho nó, vd f=n->(...).

Ungolfed + giải thích:

function f(n)
    if n == 0
        println("O")
    else
        m = abs(n)

        # Split the string into a 3x3 matrix with a slash on the left,
        # or a backslash for n < 0
        A = B = reshape(split(" / " * (n > 0 ? "/" : "\\") * " \\\\ /", ""), (3, 3))

        # We can get the O lines where needed by appending this
        E = [" "; "O"; " "]

        # Grow the helix by abs(n)
        if m > 1
            for i = 2:m
                B = hcat(B, A)
            end
        end

        # Exchange the first column for E
        B[:,1] = E

        # Add E onto the right
        B = hcat(B, E)

        # If n is negative, we actually want the transpose
        C = n > 0 ? B : B'

        # Print the rows of C
        for i = 1:size(C, 1)
            println(join(C[i,:]))
        end
    end
end

Một vài ví dụ:

julia> f(1)
 /\
O  O
 \/

julia> f(-2)
 O 
/ \
\ /
 \
/ \
\ /
 O

Python 3, 135 byte

n=int(input());m=abs(n)-1;print({n:" O\n/ \\\n"+m*"\ /\n \\\n/ \\\n"+"\\ /\n O",m+1:n*" /\\"+"\nO"+"  /"*m+"  O\n"+" \/"*n,0:"O"}[n])

Dùng thử trực tuyến tại đây

Perl, 91 97

Chuyển đổi đã được chứng minh là quá đắt cuối cùng.

#!perl -n
print/-/?"\0\23"^" \\
/ \\
\\ /
"x-$_." O":-$_?" /\\"x$_.("*`"^" / "x$_." O
"." \\/"x$_):O

Giải pháp trước đây:

#!perl -n
$".="`"^"/ 
\\ /
/ \\
 "x abs.O;print/-/?$"=~y!/\\!\\/!r:/^0/?O:map{($"=~/^.{$_}(.)/mg,$/)}2,1,0

Kiểm tra tôi .

Lược đồ, 379 byte

Nỗ lực đầu tiên của tôi về môn đánh gôn và thật không may, một trong những bài dài nhất. :(

(define (h i) (define a string-append) (define (k n p q s e) (cond ((= i n) (p s (k (q n 1) p q s e))) ((= 0 n) e) (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\") (k (q n 1) p q s e))))) (if (= i 0) "O\n" (apply a (map (lambda (s) (a s "\n")) (if (> i 0) (k i (lambda (x y) (map a x y)) - '(" /" "O " " \\") '("\\" " O" "/")) (k i append + '(" O" "/ \\") '("\\ /" " O")))))))

Ung dung:

(define (h i)
  (define a string-append)

  (define (k n p q s e)
    (cond ((= i n) (p s (k (q n 1) p q s e)))
          ((= 0 n) e)
          (else (p `("\\ /" ,(if (> i 0) " / " " \\") "/ \\")
                   (k (q n 1) p q s e)))))

  (if (= i 0) "O\n"
      (apply a (map (lambda (s) (a s "\n"))
                    (if (> i 0)
                        (k i (lambda (x y) (map a x y)) -
                           '(" /" "O " " \\")
                           '("\\" " O" "/"))
                        (k i append +
                           '(" O" "/ \\")
                           '("\\ /" " O")))))))

Java, 282

Cách tiếp cận đầu tiên của tôi, với các tên biến đặc biệt tốt đẹp:

class H{public static void main(String[]_){int N=Integer.parseInt(_[0]),í=N;String ì="/ \\\n\\ /\n",I=" o \n",i="",l=I;for(;í-->0;)i+=" /\\";i+="\no";for(í=N;í-->1;)i+="  /";i+="  o\n";for(í=N;í-->0;)i+=" \\/";for(í=1;í++<-N;)l+=ì+" \\ \n";System.out.println(N<0?l+ì+I:N>0?i:"o");}}

_{Tôi không biết tại sao tôi làm điều này. Phải là một số điều giải trí.}

Java, 317

Mã golf đầu tiên của tôi cố gắng.

public class t{public static void main(String[]e){int n=Integer.parseInt(e[0]);String s=new String(new char[n==0?0:(n>0?n:-n)-1]),u="\0";System.out.print(n==0?"O":n>0?s.replace(u," /\\")+" /\\\nO"+s.replace(u,"  /")+"  O\n"+s.replace(u," \\/")+" \\/":" O \n/ \\\n"+s.replace(u,"\\ /\n \\ \n/ \\\n")+"\\ /\n O \n");}}

Python 3, 165 byte

x,a,b,c,d=int(input())-1,'\ /',' / ','/ \\','\ /\n \\\n/ \\\n'
print([[' O\n/ \\\n'+d*abs(x+2)+'\ /\n O',' /'+a*x+'\\\nO '+b*x+' O\n \\'+c*x+'/'],'OO'][x==-1][x>-1])

Hãy thử trực tuyến tại đây .

Perl, 193 197 187 180 166 163B

Hình phạt 1 byte cho chuyển đổi dòng lệnh -n. Chạy với echo 1|perl -M5.10.0 -n scratch.pl:

$_*=3;$s=($m=abs)==$_;$_?map{say if$_=join'',map{(map[/./g]," O ",(('/ \\', '\\ /',$s?' / ':' \\ ')x$m)[0..$m-2]," O")[$s?$_:$j][$s?$j:$_]}0..$m;$j++}0..$m:say'O'

Với khoảng trắng:

$_ *= 3;
$s = ($m = abs) == $_;
$_ ? map{
      say if $_=join '', map {
       ( map[/./g],
          " O ",
          (('/ \\', '\\ /',$s?' / ':' \\ ') x $m)[0..$m-2],
          " O"
        )[$s ? $_ : $j][$s ? $j : $_]
       }0..$m;
      $j++
    } 0..$m
  : say 'O'

PHP, 341

$s='';$n=$argv[1];$l=PHP_EOL;if($n>0){for($i=0;$i<$n;$i++)$s.=" /\\";$s.=$l;for($i=0;$i<$n;$i++){if($i==0)$s.='o';if($i<$n-1)$s.='  /';if($i==$n-1)$s.='  o';}$s.=$l;for($i=0;$i<$n;$i++)$s.=" \\/";}else{$n=abs($n);for($i=0;$i<$n;$i++){if($i== 0)$s.=' o '.$l;$s.="/ \\".$l."\\ /".$l;if($i < $n-1)$s.=' \\ '.$l;if($i==$n-1)$s.=' o '.$l;}}echo $s;

Phiên bản ung dung

$s = '';
$n = $argv[1];
echo PHP_EOL;
if($n > 0)
{
    for($i=0;$i<$n;$i++)
    {
        $s.=" /\\";
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        if($i==0) { 
            $s.='o';
        }
        if($i < $n-1) {
            $s.='  /';
        }    
        if( $i == $n-1)
        {
            $s.='  o';
        }
    }
    $s.=PHP_EOL;

    for($i=0;$i<$n;$i++)
    {
        $s.=" \\/";
    }
} else
{
    $n = abs($n);
    for($i=0;$i<$n;$i++)
    {
        if($i == 0) {
            $s.=' o '.PHP_EOL;    
        }    
        $s.="/ \\".PHP_EOL."\\ /".PHP_EOL;
        if($i < $n-1) {
            $s.=' \\ '.PHP_EOL;
        }    
        if( $i == $n-1) {
            $s.=' o '.PHP_EOL;
        }    
    }    
}

echo $s;

JAVA 377 384 byte

class F{public static void main(String[] a){int n=Integer.parseInt(a[0]);if(n>0){for(int i=0;i<n;i++)p(" /\\");p("\n");for(int i=0;i<n;i++){if(i==0)if(n>1)p("O  ");else p("O  O");else if(i==n-1)p("/  O");else p("/  ");}p("\n");for(int i=0;i<n;i++){p(" \\/");}}else{p(" O\n");for(int i=0;i<Math.abs(n);i++){p("/ \\\n\\ /\n O\n");}}}static void p(String s){System.out.print(s);}}

C ++ 269 262 258

#include <string>
#include <iostream>
int main(){int i,j;std::cin>>i;std::string s,u,t;if(i>0){for(j=i;j;j--){s+=" /\\";t+="/  ";u+=" \\/";}t[0]='O';t+="O";s=s+'\n'+t+'\n'+u;}else{for(j=i;j;j++)s+=" \\\n/ \\\n\\ /\n";s[1]='O';s+=" O";}std::cout<<(i==0?"O":s);}

R, 228 201

n=scan();z=cat;f=`for`;if(!n)z("O");if(n>0){f(i,1:n,z(" /\\"));z("\nO  ");if(n>1)f(i,2:n,z("/  "));z("O\n");f(i,1:n,z(" \\/"))};if(n<0){z(" O\n");f(i,-n:1,{z("/ \\\n\\ /\n ");if(i>1)z("\\\n")});z("O")}

Nỗ lực đầu tiên của tôi tại mã golf. Tôi nghĩ rằng nó hoạt động nhưng nó không tinh tế.

n=scan(); # enter number here
z=cat;
if(!n) z("O\n");
if(n>0){
  z(" ");
  for(i in 1:n) z("/\\ ");
  z("\nO");
  if(n>1){
    for(i in 2:n) z("  /")
  };
  z("  O\n ");
  for(i in 1:n) z("\\/ ")
};
if(n<0){
  z(" O \n");
  for(i in -n:1){
    z("/ \\\n\\ /");
    if(i>1) z("\n \\\n")
  };
z("\n O ")
}

Groovy, 142 134 129 125 120 118

a=args[0]as int;b="\n/ \\\n\\ /\n ";print!a?"O":a>0?" /\\"*a+"\nO  ${"/  "*(a-1)}O\n"+" \\/"*a:" O$b${"\\$b"*(1-a)}O"

Cuối cùng buộc bằng trăn 2!

Than , 28 24 22 byte

↙OＦ↔θ/¶\¶ \¶↗‖ＢO¿›Ｎ⁰⟲Ｔ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

↙O

In phần trên cùng Ovà để con trỏ xuống một khoảng trắng và bên trái.

Ｆ↔θ/¶\¶ \¶

In dây /, \và  \và lặp lại cho giá trị số tuyệt đối của đầu vào.

↗

Di chuyển trở lại cuối cùng \.

‖Ｂ

Phản xạ để tạo phía bên phải của chuỗi xoắn. Tôi làm điều này ở đây bởi vì nếu không thì ↗sẽ không phân tích rõ ràng.

O

Ghi đè cuối cùng \với một O.

¿›Ｎ⁰⟲Ｔ

Nếu đầu vào là dương thì xoay canvas.

Canvas , 33 32 30 byte

 /¶O：╴⤢╷\ /¶ \×＋；↔＋──╴０＜？↷｝╴‽O

Hãy thử nó ở đây!

Giải trình:

 /¶O:                           push " /\¶O" twice
     ╴⤢╷                        push the absolute value of the input, -1
        \ /¶ /×                 repeat "\ /¶ /" horizontally that many times
               ＋                append that horizontally to one of the first strings
                ;               and get the other, reverse it
                 ↔+             and then append it to the result of above. Now the top part of the helix is done
                   ──           vertically palindromize with no mirroring (works because of a misake - it just doesn't overlap smartly)
                     ╴0<? }     if the input is less than 0
                         ↷        rotate clockwise the whole thing
                           ╴‽   if the input is falsy (aka 0)
                             O    push O; implicitly output the top of stack

C ++, 352

Không phải câu trả lời ngắn nhất, mà là câu đầu tiên trong C ++ cho đến nay :)

#include <iostream>
int main(int argc, char* argv[]){int a=argv[0][0]-'0';if(a==0){printf("o");}else if(a>0){for(int i =0; i < a;i++){printf(" /\\");}printf("\no");for(int i=0;i<a-1;i++){printf("  /");}printf("  o\n");for(int i=0;i<a;i++){printf(" \\/");}}else{printf(" o\n/ \\\n\\ /\n");for(int i=0;i>a+1;i--){printf("/ \\\n\\ /\n");}printf(" o");};}

Đây là trong C ++ Shell với khoảng trắng để kiểm tra

perl 156

$==pop;print$=>0?' /\\'x$=.$/:'',$=>0?'O'.'  /'x$=."\bO
":'',$=>0?' \\/'x$=:'';print$=<0?" O":'';print"
/ \\
\\ /
 \\" for$=..-1;print$=<0?"\bO":!$=?"O":''

Nỗ lực khá thẳng về phía trước, golf thứ hai của tôi. Tôi nghĩ rằng các dòng mới được tính là 1 byte phải không?

Bây giờ để tìm ra làm thế nào để tham gia tất cả những con chim nhạn này với nhau .. Tôi có rất nhiều chỗ để cải thiện với những thứ đó :'';ở khắp mọi nơi.

C, 189 byte

char*h="6Er66 e66Ee 6rE66",*v="6e6 E6r r6E 6r6 6e6",*z="e",*u;b,m,w,c,p;f(n){b=n<0;u=b?v:n?h:z;for(m=b?4:1,w=n*(b?-3:3);u[p];p+=++c%((w+2)*m)==w*m?m:p%(6*m)==m*4?-m*3:0)putchar(u[p++]-22);}

Với khoảng trắng và dòng mới:

char *h="6Er66 e66Ee 6rE66",
     *v="6e6 E6r r6E 6r6 6e6",
     *z="e",
     *u;
b, m, w, c, p;
f(n) {
    b = n < 0;
    u = b ? v : n ? h : z;
    for (m = b ? 4 : 1, w = n * (b ? - 3 : 3);
         u[p];
         p += ++c % ((w + 2) * m) == w * m ? m : p % (6 * m ) == m * 4 ? - m * 3 : 0)
        putchar(u[p++] - 22);
 }

Một số lưu ý về cách tiếp cận:

• Lưu trữ các mẫu trong mảng ký tự. Chúng được thay đổi bởi 22 ký tự để tránh cần một loạt dấu gạch chéo ngược để thoát khỏi các ký tự đặc biệt.
• Sử dụng các mẫu riêng biệt cho ngang, dọc và không. Ban đầu tôi đã cân nhắc sử dụng một mẫu duy nhất và chỉ truyền tải nó theo các giá trị dương và âm khác nhau. Tôi đã không thực hiện nó, nhưng tôi có cảm giác rằng nó sẽ làm cho logic phức tạp hơn một chút. Đặc biệt vì dấu gạch chéo trung tâm có hướng ngược lại cho hai trường hợp. Và các bảng không lớn, vì vậy điều này có vẻ hứa hẹn hơn.
• Mã này chủ yếu chỉ là các tính toán chỉ mục, với logic để quyết định khi nào nó được thực hiện và khi các vòng lặp mẫu. Phần lớn toán học ở đó để nó hoạt động cho cả hai trường hợp với các kích thước và quy tắc lặp lại khác nhau của chúng.

Perl, 184 byte

$n=pop;$p=$n>0;$_=' \ /'x(1+abs$n*3);$n=$p?$n*4+1:3;$_=join'
',/.{$n}/g;$r=$p?'.':'.*
';s/($r$r)$r($r)/$1$2/g;$p and s/^\S|\S$/O/gm or s/^ \S $|(?<=^ )\S|\S $/O/g;y~\\/~/\\~if$p;print;

Tôi nghĩ rằng điều này sẽ ngắn hơn rất nhiều! Có lẽ có một số điều đơn giản tôi có thể làm để tiết kiệm một vài byte. Đã năm năm kể từ khi tôi lập trình nghiêm túc trong Perl!

PHP, 155

$n=$argv[1];$r='str_repeat';$k="/ \\\n\\ /\n";echo$n>0?" /{$r('\ /',$n-1)}\\\nO{$r('  /',$n-1)}  O\n \\{$r('/ \\',$n-1)}/":" O\n{$r("$k \\\n",-$n-1)}$k O";

J , 67 59 55 51 byte

(<&0|:' O '(0},[)(3,~3*|)$' / \\'({~,7$[)0,*) ::'O'

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