Напишіть програму, яка приймає ціле число N через stdin або командний рядок.

Якщо N дорівнює 0, одну букву Oпотрібно надрукувати у відтінку.

Якщо N позитивний , цю горизонтальну подвійну спіраль ASCII мистецтва , намальовану N відрізками в ширину, необхідно надрукувати.

Якщо N дорівнює 1, вихід:

 /\
O  O
 \/

Якщо N дорівнює 2, вихід:

 /\ /\
O  /  O
 \/ \/

Якщо N дорівнює 3, вихід:

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

Якщо N дорівнює 4, вихід:

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

Шаблон продовжується точно так само, як і для більшого N. Зауважте, що пряму косу рису ( /) слід використовувати в усіх місцях, коли хрестовини перетинаються, крім 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>

За допомогою шаблонного рядка підраховуються нові рядки.

Більш читабельний

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приєднується до цього рядка "/\"як деліметр. На Jпочатку зберігає отримане значення для подальшого використання.

Другий елемент - це jP*G+*2dH*2\O. Почнемо з +*2dH. Це два пробіли, за якими слід вводити символ. Потім ми повторюємо цей рядковий Gраз із *G. Потім ми видаляємо його остаточний характер за допомогою P. Нарешті, ми оточуємо цю рядок двома Oсимволами, з j ... *2\O.

Третій елемент генерується за допомогою _J. Це просто зворотний бік першого рядка.

Останній розділ ?jb?gQ\/>Q0msdCg_Q\\Q\Oвибирає між трьома різними можливостями, позитивною, негативною та нульовою. Перший if-then умови на Q, вхід. Друга умова про те >Q0, чи позитивний вхід.

Якщо Qдорівнює нулю, друкується \Oсимвол O.

Якщо Qце не нульове значення, ми приєднуємося до результату другого потрійника в нових рядках і друкуємо його, за допомогою 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)

Створює вертикальну подвійну спіраль із списку рядків і переміщує її, щоб отримати горизонтальну. Я впевнений, що це можна було б покращити.

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 байт

Підштовхнутий коментарем Мартіна , ось моя перша спроба щось подібне:

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

Ідея полягає в тому, щоб побудувати горизонтальний дисплей з вертикального дисплея шляхом надання перенесеної матриці символів.

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

Моє перше коли-небудь подання коду для гольфу, тож це може бути не зовсім вражаючим.

Просто використовує ... якщо ... інше ... потрійний оператор, щоб розділити три сценарії. Це дає рядок, який складається з повторення деяких менших рядків певну кількість разів для друку.

Юлія, 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

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

Спробуйте його онлайн тут

Перл, 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")))))))

Не підтверджений:

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

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 перемикач командної лінії. Виконати з 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 ")
}

Гроовий, 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

Зовсім не найкоротша відповідь, але перша в С ++ поки що :)

#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 ++ оболонці з пробілом для тестування

perl 156

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

Досить пряма спроба вперед, мій другий гольф. Я думаю, що нові рядки вважаються 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 символи, щоб уникнути необхідності купу зворотних нахилів, щоб уникнути спеціальних символів.
• Використовує окремі шаблони для горизонтальних, вертикальних та нульових. Я спочатку розглядав можливість використання одного єдиного шаблону, і просто прокладав його по-різному для позитивних і негативних значень. Я цього не реалізував, але у мене було відчуття, що це зробить логіку ще більш складною. Тим більше, що центральна коса риса має протилежний напрямок для двох випадків. І столи не такі великі, тому це здавалося більш перспективним.
• Код в основному є лише обчисленнями індексу, з логікою, щоб визначити, коли це зроблено та коли цикл. Значна частина математики є для того, щоб вона працювала для обох випадків з їх різними розмірами та правилами повторення.

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;

Я думав, що це буде набагато коротше! Можливо, є кілька простих речей, які я можу зробити, щоб зберегти кілька байт. Пройшло п’ять років, як я серйозно програмував у Перлі!

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'

Спробуйте в Інтернеті!