เขียนโปรแกรมที่รับจำนวนเต็ม N ผ่าน stdin หรือบรรทัดคำสั่ง

ถ้า N เป็น 0 ตัวอักษรเดียวOจะต้องพิมพ์เป็น stdout

ถ้า N เป็นค่าบวก ASCII แนวนอนนี้จะต้องพิมพ์ส่วนที่เป็นเกลียวคู่ที่วาด N ส่วนที่กว้าง

ถ้า N คือ 1 เอาต์พุตจะเป็น:

 /\
O  O
 \/

ถ้า N คือ 2 เอาต์พุตจะเป็น:

 /\ /\
O  /  O
 \/ \/

ถ้า N คือ 3 เอาต์พุตจะเป็น:

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

ถ้า N คือ 4 เอาต์พุตจะเป็น:

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

รูปแบบยังคงดำเนินต่อไปในลักษณะเดียวกันกับเอ็นที่มีขนาดใหญ่ขึ้นโปรดทราบว่า/ต้องใช้เครื่องหมายทับด้านหน้า ( ) ในทุกสถานที่ที่เกลียวไขว้ยกเว้นOปลาย

ถ้า N เป็นค่าลบ ASCII ศิลปะแนวตั้งนี้จะต้องพิมพ์ส่วนที่เป็นเกลียวคู่ --N ที่วาดขึ้นสูง

ถ้า 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>"\/"=" / \\\ / "+จะช่วยให้การอย่างใดอย่างหนึ่ง"/ / \\\ / "หรือ"\ / \\\ / "ซึ่งเป็นสิ่งสำคัญเป็นเกลียวที่ทำขึ้นเพียงสำรอง"/ \"และ"\ /"เข้าร่วมโดยทั้งสองหรือ" / " " \ "ตัวอย่างเช่นถ้าคุณพิจารณาว่าเป็นอินพุต2สตริงที่ซ้ำกันครั้งสุดท้ายของคุณจะเป็น"/ / \\ / / / \\ / "(โดยไม่ต้องหลบหนี) เห็นได้ชัดว่านี้มี/จุดเริ่มต้นที่พิเศษและพื้นที่พิเศษในตอนท้าย
• ส่วนที่สองคือการแก้ไขสตริงข้างต้นด้วยสิ่งเพิ่มเติมและแยก สำหรับการป้อนข้อมูล2สตริงสุดท้ายที่ต้องการโดยไม่ต้องขึ้นบรรทัดใหม่จะเป็นแต่หลังจากที่จุดดังกล่าวข้างต้นเรามีเพียง" O / \\\ / / / \\\ / O" "/ / \\\ / / / \\\ / "ดังนั้นเราจึงลบตัวอักษรตัวแรกเพิ่มช่องว่างและ'Oที่จุดเริ่มต้นและอีก'Oตัวในตอนท้าย จากนั้นเราก็แบ่งมันออกเป็น 3 ส่วน
• ในที่สุดเราตัดสินใจว่าจะแปลงสตริงแยกนี้เป็นเกลียวในแนวตั้งหรือไม่ เข้าร่วมส่วนโดยการขึ้นบรรทัดใหม่; และเลือกระหว่างตัวละครนี้กับตัวละครตัวเดียว'O(สำหรับกรณีที่ใส่ 0)

ลองออนไลน์ได้ที่นี่

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>

การใช้สตริง templated จะขึ้นบรรทัดใหม่

อ่านเพิ่มเติม

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สุดท้ายเราล้อมรอบสายนี้มีสองตัวละครด้วยOj ... *2\O

_Jองค์ประกอบที่สามจะถูกสร้างขึ้นด้วย นี่เป็นเพียงการย้อนกลับของบรรทัดแรก

ส่วนหลัง?jb?gQ\/>Q0msdCg_Q\\Q\Oเลือกระหว่างตำแหน่งที่แตกต่างกันสามค่าคือค่าบวกค่าลบและศูนย์ เงื่อนไข if-then แรกเปิดQอินพุต เงื่อนไขที่สองเปิดอยู่>Q0ไม่ว่าอินพุตจะเป็นค่าบวกหรือไม่

หากQเป็นศูนย์\OอักขระOจะถูกพิมพ์

ถ้าQไม่ใช่ศูนย์ที่เราเข้าร่วมผลมาจากการ ternary jbที่สองในการขึ้นบรรทัดใหม่และพิมพ์ด้วย หากQเป็นบวกรายการเข้าร่วมและพิมพ์เป็น,gQ\/g(Q,"/")

ถ้าเป็นลบรายการเข้าร่วมและพิมพ์เป็นQ msdCg_Q\\เราเริ่มต้นด้วยซึ่งเป็นg_Q\\ จากนั้นเราย้ายแถวและคอลัมน์ที่มีg(-Q,"\") เปลี่ยน tuples ผลลัพธ์ของอักขระเป็นสตริงพร้อมที่จะเข้าร่วมในการขึ้นบรรทัดใหม่และพิมพ์Cmsd

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

สร้างเกลียวคู่ในแนวตั้งจากรายการสตริงและสลับเพื่อให้ได้แนวนอน ฉันแน่ใจว่ามันจะดีขึ้น

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

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

แนวคิดคือการสร้างการแสดงผลแนวนอนจากการแสดงผลแนวตั้งโดยการแสดงเมทริกซ์ transposed ของตัวละคร

Python 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 ... ถ้า ... อย่างอื่น ... ผู้ประกอบการที่ประกอบไปด้วยสามคนเพื่อแยกสถานการณ์ทั้งสาม ที่ให้สายที่ทำจากการทำซ้ำสตริงขนาดเล็กบางครั้งจำนวนที่แน่นอนในการพิมพ์

Julia, 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->(...)เรียกว่าให้มันชื่อเช่น

คำอธิบาย Ungolfed +:

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

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

ลองออนไลน์ได้ที่นี่

Perl, 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

ทดสอบฉัน

Scheme, 379 bytes

ความพยายามครั้งแรกของฉันที่การตีกอล์ฟและโชคไม่ดีที่หนึ่งที่ยาวที่สุด :(

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

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

_{ฉันไม่รู้ว่าทำไมฉันถึงทำเช่นนี้ ต้องเป็นสิ่งสันทนาการ}

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

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

ลองออนไลน์ได้ที่นี่

Perl, 193 197 187 180 166 163B

โทษ 1 ไบต์สำหรับ -n commandline switch ทำงานด้วย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;

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

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"

ในที่สุดก็ผูกด้วยหลาม 2!

ถ่าน , 28 24 22 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

↙O

พิมพ์ด้านบนOและวางเคอร์เซอร์ลงหนึ่งช่องว่างและซ้าย

Ｆ↔θ/¶\¶ \¶

พิมพ์สตริง/, \และ \และทำซ้ำสำหรับค่าจำนวนที่แน่นอนของการป้อนข้อมูล

↗

\ย้ายกลับไปที่ผ่านมา

‖Ｂ

สะท้อนให้เห็นถึงการสร้างด้านขวามือของเกลียว ฉันทำสิ่งนี้ที่นี่เพราะไม่เช่นนั้น↗จะไม่แยกกันอย่างไม่น่าสงสัย

O

เขียนทับสุดท้ายกับ\O

¿›Ｎ⁰⟲Ｔ

หากอินพุตเป็นบวกให้หมุนผ้าใบ

Canvas , 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 พร้อมช่องว่างเพื่อทดสอบ

Perl 156

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

ความพยายามไปข้างหน้าค่อนข้างสวยกอล์ฟที่สองของฉัน ฉันคิดว่าบรรทัดใหม่นับเป็น 1 ไบต์ใช่ไหม

ตอนนี้จะคิดออกว่าจะเข้าร่วม ternaries ทุกคนร่วมกัน .. ฉันมีจำนวนมากของห้องพักสำหรับการปรับปรุงกับคน:'';ทุกที่

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 ตัวเพื่อหลีกเลี่ยงการใช้แบ็กสแลชจำนวนมากเพื่อหลีกเลี่ยงอักขระพิเศษ
• ใช้รูปแบบที่แยกต่างหากสำหรับแนวนอนแนวตั้งและศูนย์ ตอนแรกฉันคิดว่าใช้รูปแบบเดียวและเพียงข้ามมันแตกต่างกันสำหรับค่าบวกและลบ ฉันไม่ได้ใช้มัน แต่ฉันรู้สึกว่ามันจะทำให้ตรรกะค่อนข้างซับซ้อนมากขึ้น โดยเฉพาะอย่างยิ่งเนื่องจากเครื่องหมายทับกลางมีทิศทางตรงกันข้ามสำหรับทั้งสองกรณี และตารางไม่ใหญ่มากดังนั้นนี่จึงดูมีแนวโน้มมากกว่า
• รหัสส่วนใหญ่เป็นเพียงการคำนวณดัชนีโดยมีตรรกะในการตัดสินใจว่าจะทำเมื่อใดและเมื่อรูปแบบวนซ้ำ คณิตศาสตร์ส่วนใหญ่อยู่ที่นั่นเพื่อให้สามารถใช้ได้กับทั้งสองกรณีด้วยมิติและกฎการทำซ้ำที่แตกต่างกัน

Perl, 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 อย่างจริงจัง!

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'

ลองออนไลน์!