stdin 또는 명령 행을 통해 정수 N을받는 프로그램을 작성하십시오.

N이 0이면 단일 문자 O를 표준 출력으로 인쇄해야합니다.

N이 양수 이면 N 세그먼트 너비로 그려진 이 수평 ASCII 아트 이중 나선 이 인쇄되어야합니다.

N이 1이면 출력은 다음과 같습니다.

 /\
O  O
 \/

N이 2이면 출력은 다음과 같습니다.

 /\ /\
O  /  O
 \/ \/

N이 3이면 출력은 다음과 같습니다.

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

N이 4이면 출력은 다음과 같습니다.

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

패턴은 더 큰 N에 대해 똑같은 방식으로 계속 됩니다. 끝을 /제외하고 나선이 교차하는 모든 위치에 슬래시 ( )를 사용해야합니다 O.

N이 음수 인 경우 -N 세그먼트의 키가 그려진 이 세로 ASCII 아트 이중 나선을 인쇄해야합니다.

N이 -1이면 출력은 다음과 같습니다.

 O
/ \
\ /
 O

N이 -2이면 출력은 다음과 같습니다.

 O
/ \
\ /
 \
/ \
\ /
 O

N이 -3이면 출력은 다음과 같습니다.

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

N이 -4이면 출력은 다음과 같습니다.

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

패턴은 더 작은 N에 대해 똑같은 방식으로 계속 됩니다. 끝을 \제외하고 나선이 교차하는 모든 위치에 백 슬래시 ( )를 사용해야합니다 O.

세부

• 프로그램 대신 N을 정수로 사용하여 결과를 정상적으로 인쇄하거나 문자열로 반환하는 함수를 작성할 수 있습니다.
• N에 대한 출력에는 선택적으로 후행 줄 바꿈이 포함될 수 있습니다.
• 임의의 N에 대한 임의의 출력 라인은 선택적으로 4 개 이하의 후행 공간을 포함 할 수있다.
• 지정된 패턴에 속하지 않는 선행 공간이 없어야합니다.
• 바이트 단위의 가장 짧은 코드가 이깁니다.

CJam, 56 55 53 52 50 바이트

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

그 크기 좀 봐! 주범은 수직 나선 대신 N = 0특수한 경우 입니다.\/

작동 방식은 다음과 같습니다.

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.

코드는 세 부분으로 나뉩니다.

• 부분이 X0>"\/"=" / \\\ / "+하나 있습니다 "/ / \\\ / "또는 "\ / \\\ / "나선 단순히 다른 구성되어 있습니다으로 중요하다 "/ \"및 "\ /"중 하나에 합류 " / "하거나 " \ ". 예를 들어 input을 고려하면 2마지막 반복 문자열은 "/ / \\ / / / \\ / "(이스케이프가없는) 것입니다. 이것은 분명히 /시작 부분에 여분이 있고 끝 부분에 여분의 공간이 있습니다.
• 두 번째 부분은 위의 문자열을 추가로 수정하고 나누는 것입니다. 입력 2의 경우 줄 바꿈이없는 원하는 최종 문자열은 " O / \\\ / / / \\\ / O"이지만 위의 포인트 후에는 "/ / \\\ / / / \\\ / ". 따라서 첫 번째 문자를 제거하고 공백과 'O시작 부분과 'O끝 부분을 추가합니다 . 그런 다음 마침내 3의 일부로 나눕니다.
• 마지막으로, 우리는이 분할 스트링을 수직 나선으로 바꾸는지를 결정합니다. 개행으로 부품을 결합하십시오. 이 문자와 단일 문자 중에서 선택하십시오 'O(입력 0의 경우).

여기에서 온라인으로 사용해보십시오

자바 스크립트 (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>

템플릿 문자열을 사용하면 줄 바꿈이 중요합니다.

더 읽기

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'
)  

Pyth, 52 바이트

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

데모.

설명:

첫 번째 섹션 M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)은 함수를 정의하며, g두 개의 입력을받습니다. 첫 번째 입력 G은 사용할 반복 횟수입니다. 이것은 입력의 절대 값입니다. 두 번째 입력 H은 나선의 중심에 배치 할 문자입니다.

이 함수는 양의 나선형의 3 줄과 음의 나선형의 3 열로 구성된 3 개의 요소 목록을 반환합니다.

첫 번째 요소는로 정의됩니다 Jj"/\\"*hGd. 공백 *hGd문자열입니다 G+1. j"/\\"*hGd해당 문자열을 "/\"delimeter로 결합합니다 . 맨 J앞에는 나중에 사용할 수 있도록 결과 값이 저장됩니다.

두 번째 요소는 jP*G+*2dH*2\O입니다. 우리는로 시작합니다 +*2dH. 입력 문자 다음에 공백이 두 개 있습니다. 그런 다음로 문자열 G시간을 반복합니다 *G. 그런 다음로 최종 캐릭터를 제거합니다 P. 마지막으로이 문자열을로 두 O문자로 묶습니다 j ... *2\O.

세 번째 요소는로 생성됩니다 _J. 이것은 단순히 첫 번째 줄의 반대입니다.

후자 섹션은 ?jb?gQ\/>Q0msdCg_Q\\Q\O양, 음 및 0의 세 가지 다른 가능성 중에서 선택합니다. 첫 번째 if-then 조건 on Q입력. 두 번째 조건 >Q0은 입력이 양수인지 여부입니다.

경우 Q제로, \O캐릭터가 O인쇄됩니다.

Q0이 아닌 경우 , 우리는 두 번째 삼항 결과를 개행으로 결합하고로 인쇄합니다 jb. 경우 Q긍정적, 가입 및 인쇄 목록입니다 gQ\/, g(Q,"/").

Q음수 인 경우 결합 및 인쇄 된 목록은 msdCg_Q\\입니다. 우리는 시작 g_Q\\이다, g(-Q,"\"). 그런 다음 행과 열을로 바꿉니다 C. msd결과 튜플을 문자열로 바꾸어 줄 바꿈에 결합하여 인쇄 할 수 있습니다.

파이썬 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)

문자열 목록에서 세로 이중 나선을 만들고 가로를 가져 오도록 바꿉니다. 나는 그것이 향상 될 수 있다고 확신합니다.

자바, 500 488 바이트

내 첫 번째 시도, 불행히도 현재 리더보다 10 * 길다. (. 다른 언어를 사용하는 것 이외의 팁이 있습니까?

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);}}

하스켈, 156 바이트

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

그런 다음 다음과 같이 쓸 수 있습니다.

*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 바이트

Martin의 의견 에 의해 촉진 된 다음과 같은 것에 대한 첫 번째 시도는 다음과 같습니다.

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;}

더 읽기 쉽게 :

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 바이트

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;}

언 골프 버전 :

    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;
    }

아이디어는 바뀐 문자 매트릭스를 렌더링하여 세로 표시에서 가로 표시를 작성하는 것입니다.

파이썬 3, 118 바이트

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")

내 첫 번째 코드 골프 제출물이므로 전혀 인상적이지 않을 수 있습니다.

세 가지 시나리오를 구분하기 위해 Python의 ... if ... else ... 삼항 연산자를 사용하십시오. 이렇게하면 일부 작은 문자열을 특정 횟수만큼 반복하여 인쇄 할 수 있습니다.

줄리아, 229 바이트

사람 아,이, 방법입니다 방법이 너무 크다. 지금까지 가장 긴 대답입니다. 인쇄하지 않고 문자열을 반환하거나 행렬 방식을 완전히 피함으로써 많은 비용을 절약 할 수 있습니다. 나중에 실험 해 보겠습니다.

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)

단일 정수를 가져 와서 적절한 형식의 이중 나선을 인쇄하는 람다 함수를 만듭니다. 호출하려면 이름을 지정하십시오 (예 :) f=n->(...).

언 골프 + 설명 :

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

몇 가지 예 :

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

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

파이썬 3, 135 바이트

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])

여기에서 온라인으로 사용해보십시오

펄, 91 97

조옮김은 결국 너무 비싸다는 것이 입증되었습니다.

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

이전 솔루션 :

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

나를 테스트 하십시오 .

구성표, 379 바이트

코드 골프와 불행히도 가장 긴 골프 중 하나에 대한 나의 첫 번째 시도. :(

(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")))))))

ungolfified :

(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")))))))

자바, 282

특히 멋진 변수 이름을 가진 첫 번째 접근법 :

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");}}

_{왜 내가 이것을하고 있는지 전혀 모른다. 오락적인 것이어야합니다.}

자바, 317

내 첫 번째 코드 골프 시도.

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");}}

파이썬 3, 165 바이트

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])

여기에서 온라인으로 사용해보십시오 .

펄 193 197 187 180 166 163B

-n 명령 줄 스위치의 경우 1 바이트 페널티 로 실행 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'

공백으로 :

$_ *= 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;

언 골프 버전

$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;

자바 377 384 바이트

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=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 ")
}

당연, 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"

마침내 파이썬 2와 묶여 있습니다!

숯 , 28 24 22 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

↙O

상단을 인쇄하고 O커서를 한 칸 아래로 왼쪽으로 두십시오.

Ｆ↔θ/¶\¶ \¶

문자열을 인쇄 /, \및  \상기 입력의 절대 값의 값을 반복한다.

↗

마지막으로 돌아갑니다 \.

‖Ｂ

나선의 오른쪽을 작성하도록 반영하십시오. 그렇지 않으면 ↗모호하지 않게 구문 분석하지 않기 때문에 여기에서 수행합니다 .

O

로 마지막 \을 덮어 씁니다 O.

¿›Ｎ⁰⟲Ｔ

입력이 양수이면 캔버스를 회전시킵니다.

캔버스 , 33 32 30 바이트

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

여기 사용해보십시오!

설명:

 /¶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

전혀 짧은 대답은 아니지만 지금까지 C ++의 첫 번째 답변 :)

#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");};}

테스트 할 공백 이 있는 C ++ Shell에 있습니다.

펄 156

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

제 2의 골프 인 꽤 빠른 시도. 줄 바꿈이 1 바이트로 간주된다고 생각합니까?

이제 모든 삼항을 어떻게 합칠 지 알아 내기 위해 .. 나는 모든 곳의 사람들과 함께 개선의 여지가 많이 :'';있습니다.

C, 189 바이트

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);}

공백과 줄 바꿈으로 :

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);
 }

접근 방식에 대한 몇 가지 참고 사항 :

• 패턴을 문자형 배열로 저장합니다. 특수 문자를 피하기 위해 많은 백 슬래시가 필요하지 않도록 22 자로 이동합니다.
• 가로, 세로 및 0에 별도의 패턴을 사용합니다. 나는 처음에 하나의 단일 패턴을 사용하는 것을 고려하고 양수 값과 음수 값에 대해 다르게 횡단합니다. 나는 그것을 구현하지는 않았지만 논리가 좀 더 복잡해질 것이라고 생각했다. 특히 중앙 슬래시가 두 경우의 반대 방향을 갖기 때문입니다. 그리고 테이블은 그렇게 크지 않기 때문에 더 유망한 것처럼 보입니다.
• 코드는 주로 인덱스 계산에 불과하며, 완료 시점과 패턴 반복시기를 결정하는 논리가 있습니다. 많은 수의 수학이 있으므로 차원과 반복 규칙이 다른 두 경우 모두에 적용됩니다.

펄, 184 바이트

$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;

나는 이것이 훨씬 짧아 질 것이라고 생각했다! 몇 바이트를 절약하기 위해 할 수있는 간단한 일이있을 것입니다. 내가 Perl에서 진지하게 프로그래밍 한 지 5 년이 지났다!

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 바이트

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

온라인으로 사용해보십시오!