N tamsayı stdin veya komut satırı üzerinden alan bir program yazın.

N, 0 ise, tek harf Ostdout'a yazdırılmalıdır.

N pozitifse , N yatay olarak çizilen bu yatay ASCII art çift ​​sarmal , N kesimleri geniş olarak yazdırılmalıdır.

N 1 ise, çıktı:

 /\
O  O
 \/

N 2 ise, çıktı:

 /\ /\
O  /  O
 \/ \/

N, 3 ise, çıkış:

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

N 4 ise, çıktı:

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

Desen, daha büyük N için aynı şekilde devam eder. Eğik çizginin ( /), Ouçlar hariç, helezonların çaprazlandığı tüm yerlerde kullanılması gerektiğini unutmayın .

N negatif ise , bu dikey ASCII art çift sarmal, -N segmentleri uzun çizilmiş, basılmalıdır.

N -1 ise, çıkış:

 O
/ \
\ /
 O

N, -2 ise, çıkış:

 O
/ \
\ /
 \
/ \
\ /
 O

N, -3 ise, çıkış:

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

N, -4 ise, çıktı:

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

Desen, daha küçük N için aynı şekilde devam eder. \Helezonların Ouçları hariç, her yerinde çapraz çizgiler ( ) kullanılmalıdır .

ayrıntılar

• Bir program yerine, N'yi bir tamsayı olarak alan ve sonucu normal olarak basan veya dizge olarak döndüren bir işlev yazabilirsiniz.
• Herhangi bir N için çıktı isteğe bağlı olarak takip eden bir yeni satır içerebilir.
• Herhangi bir N için herhangi bir çıktı satırı isteğe bağlı olarak 4 veya daha az takip alanı içerebilir.
• Belirtilen desenin bir parçası olmayan hiçbir ön boşluk olmamalıdır.
• Bayt cinsinden en kısa kod kazanır.

CJam, 56 55 53 52 50 bayt

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

Şu boyuta bak! Ana suçlular N = 0özel durum ve dikey sarmalın \yerine /.

İşte nasıl çalışıyor:

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.

Kod üç bölüme ayrılmıştır:

• Bölüm X0>"\/"=" / \\\ / "+ya verir "/ / \\\ / "ya "\ / \\\ / "sarmalı basitçe alternatif oluşur gibi önemli olan "/ \"ve "\ /"ya katıldı " / "ya " \ ". Örneğin, girdiyi düşünürseniz 2, tekrarlanan son dizginiz "/ / \\ / / / \\ / "(kaçmadan) olur. Bunun belli ki /başlangıçta fazladan ve sonda fazladan bir boşluk var.
• İkinci kısım, yukarıdaki dizgiyi ilave şeyler ile düzeltip bölmektir. Bir giriş için 2, yeni satırlar olmadan istenen son dize olacaktır " O / \\\ / / / \\\ / O", ancak yukarıdaki noktadan sonra, sadece biz var "/ / \\\ / / / \\\ / ". Böylece ilk karakteri kaldırırız, boşluk ekleriz 'O, başında ve 'Osonunda diğerini . Sonra nihayet 3 bölüme ayırdık
• Son olarak, bu bölünmüş ipin dikey bir sarmal için transpoze edilip edilmemesine karar veririz; Parçalara newlines ile katılın; Ve bununla tek bir karakter arasında seçim yap 'O(0 harf girişi için)

Burada çevrimiçi deneyin

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>

Şablonlanmış dizgiyi kullanarak, yeni satırlar sayılır.

Daha okunabilir

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 bayt

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

Gösteri.

Açıklama:

İlk bölüm, iki girdi alan M[Jj"/\\"*hGdjP*G+*2dH*2\O_J)bir işlevi tanımlar g. İlk girdi, Gkullanılacak tekrar sayısıdır. Bu, girişin mutlak değeridir. İkinci girdi, Hspirallerin ortasına yerleştirilecek karakterdir.

İşlev, pozitif sarmalın 3 satırından ve negatif sarmalın 3 sütunundan oluşan 3 öğe listesi döndürür.

İlk eleman, tarafından tanımlanır Jj"/\\"*hGd. boşlukların *hGddizesidir G+1. j"/\\"*hGdbu dizgiyi "/\"sınırlayıcı olarak birleştirir . Başlangıçta Jelde edilecek değeri gelecekteki kullanım için kaydeder.

İkinci unsur ise jP*G+*2dH*2\O. İle başlıyoruz +*2dH. Bu, giriş karakteri tarafından takip edilen iki boşluktur. Ardından, bu dize Gzamanlarını ile tekrarlarız *G. Sonra son karakterini ile kaldırırız P. Son olarak, bu dizgiyi iki Okarakterle çevreliyoruz j ... *2\O.

Üçüncü eleman ile üretilir _J. Bu sadece ilk satırın tam tersidir.

İkinci bölüm, ?jb?gQ\/>Q0msdCg_Q\\Q\Oüç farklı olasılık arasından seçim yapar, pozitif, negatif ve sıfır. İlk if-then koşulları açıksa Qgirdi. İkinci koşullar >Q0, girişin pozitif olup olmadığı.

Eğer Qsıfırdır, \Okarakter O, basılır.

QSıfır değilse , ikinci üçlünün sonucunu yeni satırlarda birleştirip yazdırıyoruz jb. Eğer Qpozitif katıldı ve baskılı listedir gQ\/, g(Q,"/").

Eğer Qnegatif katıldı ve baskılı listesidir msdCg_Q\\. Biz başlamak g_Q\\olan g(-Q,"\"). Daha sonra satırları ve sütunları ile birlikte transpoze ediyoruz C. msdSonuçta ortaya çıkan karakter kümelerini karakter dizilerine çevirir, yeni hatlara katılmaya hazır ve yazdırılır.

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)

Dikey çift sarmalı bir dizeler listesinden oluşturur ve yatay olanı elde etmek için dönüştürür. İyileştirilebileceğinden eminim.

Java, 500 488 bayt

İlk denemem, ve maalesef şu anki liderden 10 * daha uzun :(.

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 bayt

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

Daha sonra şu şekilde yazabilirsiniz:

*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 Bayt

Teşvikiyle Martin'in açıklama , burada böyle bir şey benim ilk denemem:

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

Daha okunaklı:

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 bayt

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

Ungolfed versiyonu:

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

Fikir, yatay göstergeyi dikey göstergeden, karakterlerin aktarılan matrisini oluşturarak oluşturmaktır.

Python 3, 118 bayt

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

Benim ilk golf gönderimi kodladım, bu yüzden hiç etkileyici olmayabilir.

Sadece üç senaryoyu ayırmak için Python's ... if ... else ... ternary operatörünü kullanır. Bu, daha küçük bazı dizeleri yazdırmak için belirli sayıda tekrarlamaktan oluşan bir dize verir.

Julia, 229 bayt

Dostum, bu, bir yoldur yolu çok büyük. Bu, şu ana kadarki en büyük farkla en uzun cevap oldu. Büyük olasılıkla dizeyi yazdırmak yerine döndürerek veya matris yaklaşımından tamamen kaçınarak çok fazla tasarruf edebilirim. Bunu sonra deneyeceğim.

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)

Bu, tek bir tamsayı alan ve uygun şekilde biçimlendirilmiş çift sarmal basan bir lambda işlevi yaratır. Aramak için bir isim verin, örneğin f=n->(...).

Ungolfed + açıklama:

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

Birkaç örnek:

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

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

Python 3, 135 bayt

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

Burada çevrimiçi deneyin

Perl, 91 97

Transposing'in sonunda çok pahalı olduğu kanıtlandı.

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

Önceki çözüm:

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

Beni test et .

Şema, 379 bayt

Kod golf ilk denemem ve maalesef en uzun olanlardan biri. :(

(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

İlk yaklaşımım, özellikle değişken değişken isimleri:

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

_{Bunu neden yaptığım hakkında hiçbir fikrim yok. Bazı eğlence şey olmalı.}

Java, 317

İlk kod golf denemem.

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 bayt

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

Burada çevrimiçi deneyin .

Perl, 193 197 187 180 166 163B

-N komut satırı anahtarı için 1 bayt ceza. Çalıştır 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'

Boşluk ile:

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

Ungolfed versiyonu

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

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

İlk kod golf denemem. Bence işe yarıyor ama ince değil.

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

Harika, 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"

Sonunda python 2 ile bağlı!

Kömür , 28 24 22 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

↙O

Üstünü yazdırın Ove imleci aşağı ve sola bir boşluk bırakın.

Ｆ↔θ/¶\¶ \¶

Dizeleri Baskı /, \ve  \ve giriş mutlak sayı değeri için tekrarlayın.

↗

Sonuncuya geri dön \.

‖Ｂ

Sarmalın sağ tarafını oluşturmayı düşünün. Bunu burada yapıyorum çünkü aksi halde ↗kesin olarak ayrıştırılmaz.

O

Geçen üzerine yaz \bir ile O.

¿›Ｎ⁰⟲Ｔ

Girdi pozitifse, tuvali döndürün.

Tuval , 33 32 30 bayt

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

Burada dene!

Açıklama:

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

En kısa sürede değil, şimdiye kadar C ++ 'da ilk :)

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

Burada test etmek için boşluk olan C ++ Shell'de

perl 156

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

Oldukça yalındır girişimi, ikinci golf. Bence yeni satırlar 1 bayt olarak sayılıyor mu?

Şimdi tüm bu üçlülerin nasıl birleştirileceğini bulmak için .. Her yerdekilerle gelişim için çok yerim var :'';.

C, 189 bayt

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

Boşluk ve newlines ile:

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

Yaklaşımla ilgili bazı notlar:

• Deseni karakter dizilerine kaydeder. Özel karakterlerden kaçmak için bir sürü ters eğik çizgiye ihtiyaç duymamak için 22 karakter kaydırılırlar.
• Yatay, dikey ve sıfır için ayrı desenler kullanır. Başlangıçta tek bir kalıp kullanmayı düşünmüştüm ve sadece pozitif ve negatif değerler için farklı şekilde geziyordum. Uygulamamıştım, ama mantığı biraz daha karmaşık hale getireceğini hissediyorum. Özellikle merkezi eğik çizgi, iki durum için tam tersi yönde olduğundan. Masalar o kadar büyük değil, bu yüzden daha umut verici görünüyordu.
• Kod temel olarak sadece indeks hesaplamalarıdır, ne zaman yapıldığına ve kalıbın ne zaman döneceğine karar vermek mantıklıdır. Matematiğin çoğu orada, farklı boyutları ve tekrar kuralları ile her iki durumda da işe yaraması için orada.

Perl, 184 bayt

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

Bunun daha kısa olacağını sanıyordum! Muhtemelen birkaç bayttan tasarruf etmek için yapabileceğim bazı basit şeyler var. Perl'de ciddi program yaptığımdan beri beş yıl geçti!

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 bayt

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

Çevrimiçi deneyin!