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

Если N равно 0, одна буква Oдолжна быть напечатана на стандартный вывод.

Если N положительно , эта горизонтальная двойная спираль ASCII art , нарисованная 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")

Моя первая в истории подача кода в гольф, так что это может быть совсем не впечатляюще.

Просто использует троичный оператор 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->(...).

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

Проверь меня .

Схема, 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");}}

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

С ++ 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.

¿›Ｎ⁰⟲Ｔ

Если вход был положительным, поверните холст.

Холст , 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

С ++, 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 байт, верно?

Теперь, чтобы выяснить, как объединить все эти троицы вместе ... У меня есть много возможностей для совершенствования с этими :'';везде.

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'

Попробуйте онлайн!