Schreiben Sie ein Programm, das (über STDIN / Kommandozeile) eine nicht negative ganze Zahl N aufnimmt.

Wenn N 0 ist, sollte Ihr Programm drucken O(das ist das Kapital Oh, nicht Null).

Wenn N 1 ist, sollte Ihr Programm drucken

\|/
-O-
/|\

Wenn N 2 ist, sollte Ihr Programm drucken

\ | /
 \|/
--O--
 /|\
/ | \

Wenn N 3 ist, sollte Ihr Programm drucken

\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

Für ein größeres N setzt sich dieses Muster auf die gleiche exakte Weise fort. Jede der acht Strahlen der „Sonne“ sollte von N der entsprechenden gemacht werden -, |, /, oder \Zeichen.

Einzelheiten

• Anstelle eines Programms können Sie auch eine Funktion schreiben, die eine Ganzzahl annimmt. Die Funktion sollte das Sonnenmuster normal drucken oder als Zeichenfolge zurückgeben.

• Sie müssen entweder

  • haben überhaupt keine nachgestellten Leerzeichen, oder
  • Verfügen Sie nur über genügend nachgestellte Leerzeichen, damit das Muster ein perfektes (2N + 1) * (2N + 1) Rechteck ist.

• Die Ausgabe für ein beliebiges oder alle N kann optional einen nachgestellten Zeilenumbruch enthalten.

Wertung

Der kürzeste Code in Bytes gewinnt.

Pyth, 39 38 36 Bytes

jbXmXXj\|m*\ Q2d\\_hd\/JhyQQX*\-JQ\O

Probieren Sie es online aus: Pyth Compiler / Executor

Erläuterung

jbXmXXj\|m*\ Q2d\\_hd\/JhyQQX*\-JQ\O   implicit: Q = input
                       JhyQ            J = 1 + 2*Q
    m                  J               map each d of [0,1,...,2*Q] to:
          *\ Q                           " "*input
         m    2                          list with twice " "*input
      j\|                                join this list by "|"
     X         d\\                       replace the value at d to "\"
    X             _hd\/                  replace the value at -(d+1) to "/"
  X                        Q           replace line Q by:
                             *\-J        "-"*J
                            X    Q\O     replace element at Q with "O"
jb                                     join by "newlines"

Eine weitere 36-Byte-Lösung wäre:

jbmXXj\|m*?\-KqdQ\ Q2d\\_hd?\OK\/hyQ

C: 116 102 99 95 92 90

s(n){for(int c=-n,r=c;r<=n;c++)putchar(c>n?c=-c,r++,10:c?r?c-r?c+r?32:47:92:45:r?124:79);}

Ich denke, dass ich mit diesem Ansatz einer minimalen Lösung ziemlich nahe komme, aber ich kann nicht aufhören, das Gefühl zu haben, dass es bei C. Ungolfed einen viel besseren Ansatz gibt:

void s(int n) {
  for(
    int c = -n, r = c;
    r <= n;
    c++
  )
    putchar(
      c > n
        ? c = -c, r++, '\n'
        : c
          ? r
            ? c - r
              ? c + r
                ? ' '
                : '/'
              : '\\'
            : '-'
          : r
            ? '|'
            : 'O'
    );
}

GNU sed, 252 + 1

Puh - ich habe die PHP-Antwort geschlagen!

Punktzahl + 1 für die Verwendung des -rParameters.

Aufgrund von Einschränkungen müssen wir fast 100 Bytes brennen und nur N in eine Folge von N Leerzeichen umwandeln. Der Rest ist das lustige Zeug.

/^0/{y/0/O/;q}
s/./<&/g
s/9/8 /g
s/8/7 /g
s/7/6 /g
s/6/5 /g
s/5/4 /g
s/4/3 /g
s/3/2 /g
s/2/1 /g
s/1/ /g
s/0//g
:t
s/ </<          /g
tt
s/<//g
:
s/ //
s^.*^\\&|&/^;ta
:a
/\\$/q
p
s^\\\|/^-O-^;tn
s^(\\)? (/)?^\2 \1^g;ta
:n
y/ /-/
p
s^-O-^/|\\^
y/-/ /
ta

Erläuterung

• Die erste Zeile ist ein vorzeitiger Ausstieg für den Fall N = 0.
• Die nächsten 15 Zeilen (bis zu :) konvertieren N in eine Folge von N Leerzeichen
• s/ // Entfernt ein Leerzeichen
• s^.*^\\&|&/^;takonvertiert N-1 Leerzeichen in: \+ N-1 Leerzeichen + |+ N-1 Leerzeichen +/
• Iteriere, drucke jede Iteration und verschiebe \ein Leerzeichen nach rechts und /ein Leerzeichen nach links ...
• ... bis wir übereinstimmen \|/, das durch ersetzt wird -O-und zum nEtikett springen
• ersetzen mit -und drucken
• ersetzen -0-mit /|\und ersetzen mit -und springen zurück in die Hauptschleife
• Iteriere, drucke jede Iteration und verschiebe \ein Leerzeichen nach rechts und /ein Leerzeichen nach links ...
• ... bis wir übereinstimmen, \$was anzeigt, dass es fertig ist, und beenden.

Ausgabe

 $ for i in {0..3}; do sed -rf asciisun.sed <<< $i ; done
 O
 \|/
 -O-
 /|\
 \ | /
  \|/ 
 --O--
  /|\ 
 / | \
 \  |  /
  \ | / 
   \|/  
 ---O---
   /|\  
  / | \ 
 /  |  \
 $

J, 37 34 40 Bytes

1:echo('O\/-|'{.@#~0=+&|,-,+,[,])"*/~@i:

Verwendungszweck:

   (1:echo('O\/-|'{.@#~0=+&|,-,+,[,])"*/~@i:) 2  NB. prints to stdout:
\ | /
 \|/ 
--O--
 /|\ 
/ | \

Erklärung (von links nach rechts):

• i: Erzeugt Liste -n, -(n-1), ..., n-1, n

• ( )"*/~@i:Erstellt das Descartes-Produkt von i: mit sich selbst in einer Matrixanordnung, zB für die n = 1Erstellung der folgenden 3-by-3Matrix

  ┌─────┬────┬────┐
  │-1 -1│-1 0│-1 1│
  ├─────┼────┼────┤
  │0 -1 │0 0 │0 1 │
  ├─────┼────┼────┤
  │1 -1 │1 0 │1 1 │
  └─────┴────┴────┘
  

• Für jedes Matrixelement mit ganzen Zahlen machen x ywir folgendes

• +&|,-,+,[,] Berechnen Sie eine Liste von Eigenschaften

  • +&| abs(x)+abs(y), ist gleich 0iff (wenn und nur wenn) x=0undy=0
  • -xy, entspricht 0iff x=ydh wir sind auf der Diagonale
  • +x + y, entspricht 0iff x=-ydh wir sind auf der Antidiagonale
  • [x ist gleich 0iff, x=0dh wir befinden uns in der mittleren Reihe
  • ]y ist gleich 0iff, y=0dh wir befinden uns in der mittleren Spalte

• 'O\/-|'#~0=Vergleichen Sie diese obigen Eigenschaftswerte mit 0und nehmen Sie das ith-Zeichen aus der Zeichenfolge, 'O\/-|'wenn die ith-Eigenschaft wahr ist.

• Das erste Zeichen in der resultierenden Zeichenfolge ist immer dasjenige, das wir benötigen. Wenn die Zeichenfolge leer ist, benötigen wir ein Leerzeichen
• {. Nimmt das erste Zeichen einer Zeichenkette und gibt, wenn es kein Zeichen gibt, ein Leerzeichen als Auffüllung zurück, wie wir es brauchen
• Wir haben jetzt die exakte Matrix, die wir brauchen, damit wir sie einmal mit stdout drucken 1:echo

Probieren Sie es hier online aus.

PHP, 182 Bytes

Dies schien mir eine lustige Aktivität für meine erste Antwort zu sein. Kommentare zu meinem Code sind willkommen.

<?php function s($n){$e=2*$n+1;for($i=0;$i<$e*$e;$i++){$x=$i%$e;$y=floor($i/$e);echo$y==$x?($x==$n?"O":"\\"):($e-1==$x+$y?"/":($y==$n?"-":($x==$n?"|":" ")));echo$x==$e-1?"\n":"";}}?>

Hier ist der Code ohne Golfspieler mit Kommentaren:

<?php
function s($n) {
    $e=2*$n+1; //edge length
    for($i=0;$i<$e*$e;$i++) {
        $x = $i%$e; // current x coordinate
        $y = floor($i/$e); // current y coordinate

        if ($y==$n&&$x==$n) {
            // center of square
            echo'O';
        }
        else if ($y==$n) {
            // horizontal line
            echo'-';
        }
        else if ($x==$n) {
            // vertical line
            echo'|';
        }
        else if ($y==$x) {
            // diagonal line from top-left to bottom right
            echo'\\';
        }
        else if (($y-$n)==($n-$x)) {
            // diagonal line from bottom-left to top-right
            echo'/';
        }
        else {
            // empty space
            echo' ';
        }
        if ($x==$e-1) {
            // add new line for the end of the row
            echo"\n";
        }
    }
}?>
<pre>
<?php s(10); ?>
</pre>

Bearbeitet mit Code von royhowie

Python 2, 99

n=input()
R=range(-n,n+1)
for i in R:print''.join("O\|/ -"[[R,i,0,-i,j].index(j)^(i==0)]for j in R)

Druck Zeile für Zeile, wobei jede Zeile durch die Schaffung ob die Koordinaten Überprüfung (i,j)(zentrierte bei (0,0)) genügt j==-i, j==0, j==i, oder ohne, mit einem Hack der Mittellinie funktioniert.

CJam, 48 45 43 41 38 Bytes

Das ist immer noch zu lang und ich mache immer noch ein paar überflüssige Dinge, aber hier ist:

ri:R{_S*"\|/"@R-~S**1$N}%'-R*'O1$W$sW%

Probieren Sie es hier online aus

SpecBAS - 117 Bytes

1 INPUT s: LET t=s*2: FOR y=0 TO t: PRINT AT y,y;"\";AT y,t/2;"|";AT t-y,y;"/";AT t/2,y;"-": NEXT y: PRINT AT s,s;"O"

Dies druckt die Schrägstriche und Bindestriche in einer Schleife und setzt dann das "O" in der Mitte.

Ausgabe mit 1, 2 und 9

JavaScript (ES6) 97 98

Das scheint anders zu sein ...

// GOLFED
f=n=>(y=>{for(t='';++y<n;t+='\n')for(x=-n;++x<n;)t+='-O /\\|'[y?x?x-y?x+y?2:3:4:5:+!x]})(-++n)||t

// Ungolfed

F=n=>{
  ++n;
  t = '';
  for (y = -n; ++y < n; t += '\n')
    for (x = -n; ++x < n; )
      if (y != 0)
        if (x != 0)
          if (x != y)
            if (x != -y)
              t += ' '
            else
              t += '/'
          else
            t += '\\'
        else
          t += '|'
      else
        if (x != 0)
          t += '-'
        else 
          t += 'O'
  return t;
}
    
// TEST
function test(){ OUT.innerHTML = f(N.value|0); }
test()

input { width: 4em }

N: <input id=N value=5><button onclick="test()">Go</button>
<pre id="OUT"></pre>

OS / 2 Classic Rexx, 102 ... oder 14 für "Betrüger-Version"

Nehmen Sie die Zeilenvorschübe heraus, um Golf zu spielen.

w='%1'
o=center('O',w,'-')
m='center(space("\|/",w),%1)'
do w
  w=w-1
  interpret "o="m"|o|"m
end l
say o

Benennen Sie das Skript in der Cheater-Version mit einem beliebigen Quellcode unter 255 Zeichen (HPFS-Datenträger erforderlich):

interpret '%0'

EDIT: Nur um klar zu sein, die Version des Betrügers ist nicht dazu gedacht, zu zählen! Es ist nur dumm zu sein und zu zeigen, dass ein alter Hund immer noch Tricks machen kann. :)

zB Für echten Spaß und Spiel eine Implementierung von "Lambda" -Ausdrücken im Java-8 / C11-Stil auf einem Listeniterator. Nicht getestet, sollte aber auf einem IBM-Mainframe von ca. 1979 laufen. ;)

ForEachInList( 'Months.January.Days', 'Day' -> 'SAY "You have an appointment with" Day.Appointment.Name "on" Day.Appointment.Date' )
EXIT

ForEachInList: 
    SIGNAL ON SYNTAX
    PARSE ARG MyList "," MyVar "->" MyCommand
    INTERPRET ' MyListCount = ' || MyList || '.Count'
    DO ListIndex = 1 TO MyListCount
       INTERPRET MyVar || ' = ' || MyList || '.' || ListIndex
       INTERPRET MyCommand
    END
    RETURN
SYNTAX:
    SAY MyCommand ' is not a valid expression. '
    EXIT

- Das Aufrufen von Code setzt natürlich voraus, dass Sie bereits einen Stamm (Array) erstellt haben.

Haskell, 109 98 96 Bytes

Vielen Dank an Nimi und Mauris für ihre Hilfe!

0#0='O'
0#_='-'
_#0='|'
i#j|i==j='\\'|i== -j='/'|1<2=' '
f n=unlines[map(i#)[-n..n]|i<-[-n..n]]

Erläuterung:

Der Operator #gibt an, welches Zeichen bei den Koordinaten (i, j) angezeigt wird, wobei die Sonne bei (0,0) zentriert ist. Die Funktion erstellt fdie Ergebniszeichenfolge, indem #sie alle Koordinatenpaare im Bereich von -n bis n abbildet.

Verwendungszweck:

ghci> putStr $ f 2
\ | /
 \|/ 
--O--
 /|\ 
/ | \

R 177 149 Bytes

Mickey T. ist der Mann! Er hat mir geholfen, meine ursprünglich falsche Lösung zu reparieren und 28 Bytes zu sparen. Danke, Mickey!

m=matrix(" ",(w=2*(n=scan()+1)-1),w);m[row(m)==rev(col(m))]="/";diag(m)="\\";m[,n]="|";m[n,]="-";m[n,n]="O";m[,w]=paste0(m[,w],"\n");cat(t(m),sep="")

Ungolfed + Erklärung:

# Create a matrix of spaces, read n from stdin, assign w=2n+1
m <- matrix(" ", (w <- 2*(n <- scan() + 1) - 1), w)

# Replace the opposite diagonal with forward slashes
m[row(m) == rev(col(m))] <- "/"

# Replace the diagonal with backslashes
diag(m) <- "\\"

# Replace the vertical center line with pipes
m[, n] <- "|"

# Replace the horizontal center line with dashes
m[n, ] <- "-"

# Put an O in the middle
m[n, n] <- "O"

# Collapse the columns into single strings
m[, w] <- paste0(m[, w], "\n")

# Print the transposed matrix
cat(t(m), sep = "")

Weitere Vorschläge sind willkommen!

C #, 230 226 Bytes

string g(int n){string r="";int s=n*2+1;for(int h=0;h<s;h++){for(int w=0;w<s;w++){if(h==w){if(w==n){r+="O";}else{r+="\\";}}else if(w==s-h-1){r+="/";}else if(w==n){r+="|";}else if(h==n){r+="-";}else{r+=" ";}}r+="\n";}return r;}

Wie gewünscht, die ungolfed version: string ug (int n) {

        // The sting we'll be returning
        string ret = ""; 

        // The width and height of the output
        int s = n * 2 + 1; 

        // for loop for width and height
        for (int height = 0; height < s; height++) 
        {
            for (int width = 0; width < s; width++) 
            {
                // Matches on top-left to bottom-right diagonal line
                if (height == width) 
                {
                    // If this is the center, write the 'sun'
                    if (width == n) 
                    {
                        ret += "O"; 
                    }
                    // If this is not the center, add the diagonal line character
                    else 
                    {
                        ret += "\\"; 
                    }
                }
                // Matches on top-right to bottom-left diagonal line
                else if (width == s - height - 1) 
                { 
                    ret += "/";
                }
                // Matches to add the center line
                else if (width == n) 
                { 
                    ret += "|";
                }
                // Matches to add the horizontal line
                else if (height == n) 
                { 
                    ret += "-";
                }
                // Matches all others
                else 
                { 
                    ret += " "; 
                } 
            } 
            // Add a newline to separate each line
            ret += "\n"; 
        } 
        return ret; 
    }

Dies ist mein erster Beitrag, deshalb entschuldige ich mich, wenn ich etwas falsch gemacht habe. Kommentare und Korrekturen sind sehr willkommen.

Ruby: 98 92 Zeichen

Proc, der einen String mit der Sonne zurückgibt.

f=->n{x=(0..m=n*2).map{|i|s=?|.center m+1
s[i]=?\\
s[m-i]=?/
s}
x[n]=?O.center m+1,?-
x*?\n}

Probelauf:

irb(main):001:0> f=->n{x=(0..m=n*2).map{|i|s=?|.center m+1;s[i]=?\\;s[m-i]=?/;s};x[n]=?O.center m+1,?-;x*?\n}
=> #<Proc:0x000000020dea60@(irb):1 (lambda)>
irb(main):002:0> (0..3).each {|i| puts f[i]}
O
\|/
-O-
/|\
\ | /
 \|/ 
--O--
 /|\ 
/ | \
\  |  /
 \ | / 
  \|/  
---O---
  /|\  
 / | \ 
/  |  \
=> 0..3

Rust, 215 Zeichen

fn a(n:usize){for i in 0..n{println!("{}\\{}|{1}/{0}",s(i),s(n-i-1))}println!("{}O{0}",vec!["-";n].concat());for i in(0..n).rev(){println!("{}/{}|{1}\\{0}",s(i),s(n-i-1))}}fn s(n:usize)->String{vec![" ";n].concat()}

Ich habe versucht, eine Methode zum Aufteilen von Zeichenfolgen zu verwenden (indem ich eine Zeichenfolge von n-1Leerzeichen erstellt und in und aus einem Index aufgeteilt habe):

fn a(n:usize){let s=vec![" ";n-(n>0)as usize].concat();for i in 0..n{println!("{}\\{}|{1}/{0}",&s[..i],&s[i..])}println!("{}O{0}",vec!["-";n].concat());for i in(0..n).rev(){println!("{}/{}|{1}\\{0}",&s[..i],&s[i..])}}

Aber das sind eigentlich 3 Zeichen länger.

Ungolfed-Code:

fn asciisun_ungolfed(n: usize) {
    for i in 0..n {
        println!("{0}\\{1}|{1}/{0}", spaces(i), spaces(n-i-1))
    }
    println!("{0}O{0}", vec!["-"; n].concat());
    for i in (0..n).rev() {
        println!("{0}/{1}|{1}\\{0}", spaces(i), spaces(n-i-1))
    }
}
fn spaces(n: usize) -> String { vec![" "; n].concat() }

Der Teil, den ich mag, ist, wie ich ein paar Zeichen auf den Formatierungszeichenfolgen rasiere. Zum Beispiel,

f{0}o{1}o{1}b{0}ar

ist äquivalent zu

f{}o{}o{1}b{0}ar

da der "Auto-Inkrementierer" für die Position des Format-String-Arguments nicht durch die manuelle Angabe der Zahl beeinflusst wird und völlig unabhängig arbeitet.

Oktave 85

Bulding Matrizen wie immer =) eyeergibt eine Identitätsmatrix, der Rest ist meiner Meinung nach selbsterklärend.

m=(e=eye(2*(k=input('')+1)-1))*92+rot90(e)*47;m(:,k)='|';m(k,:)=45;m(k,k)='o';[m,'']

IDL 8,3, 135 Bytes

Keine Ahnung, ob man hier mehr Golf spielen kann ... Es ist sehr einfach. Zuerst erstellen wir ein m x mArray ( m=2n+1) von leeren Strings; Dann wir die Zeichen in Linien zeichnen ( y=x, y=-x, y=nund x=n). Dann legen wir das O an der Stelle ab (n, n)und drucken das Ganze, formatiert als mZeichenketten der Länge 1 in jeder Zeile, so dass es keinen zusätzlichen Abstand zum Drucken des Arrays von Haus aus gibt.

pro s,n
m=2*n+1
v=strarr(m,m)
x=[0:m-1]
v[x,x]='\'
v[x,m-x-1]='/'
v[n,x]='|'
v[x,n]='-'
v[n,n]='O'
print,v,f='('+strtrim(m,2)+'A1)'
end

Prüfung:

IDL> s,4
\   |   /
 \  |  / 
  \ | /  
   \|/   
----O----
   /|\   
  / | \  
 /  |  \ 
/   |   \

Matlab, 93 87 Bytes

Leider muss der Funktionsheader so groß sein ... Abgesehen davon denke ich, dass es ziemlich gut golfen ist. Ich frage mich, ob es mit einigen Syntaxunterschieden in Octave besser gehen könnte.

N=input('');E=eye(N)*92;D=rot90(E)*.52;H=ones(1,N)*45;V=H'*2.76;[E V D;H 79 H;D V E '']

Javascript ( ES7 Draft ) 115

f=l=>[['O |/\\-'[y^x?z+~x^y?y^l?x^l?1:2:5:3:x^l&&4]for(x in _)].join('')for(y in _=[...Array(z=2*l+1)])].join('\n')


// Snippet demo: (Firefox only)
for(var X of [0,1,2,3,4,5])
    document.write('<pre>' + f(X) + '</pre><br />');

Pyth - 52 Bytes

Das Schwierige war, herauszufinden, wie man die Schrägstriche für jede Seite vertauscht. Ich entschied mich dafür, ein Lambda zu definieren, das die zu verwendenden Symbole verwendet.

KdMms[*Kt-QdG*Kd\|*KdH)_UQjbg\\\/p\O*Q\-*\-Qjb_g\/\\

Kann wahrscheinlich mehr golfen werden, Erklärung folgt in Kürze.

Probieren Sie es hier online aus .

Perl, 94

Es gibt viele verschachtelte ternäre Operatoren, aber ich denke, der Code ist ziemlich einfach.

$n=<>;for$x(-$n..$n){for$y(-$n..$n){print$x^$y?$x+$y?$x?$y?$":'|':'-':'/':$x?'\\':'O'}print$/}

Probieren Sie es hier aus: ideone.com/E8MC1d

C # - 291 (vollständiges Programm)

using System;using System.Linq;class P{static void Main(string[] a){Func<int,int,int,char>C=(s,x,i)=>x==(2*s+1)?'\n':i==s?x==s?'O':'-':x==s?'|':x==i?'\\':x==2*s-i?'/':' ';int S=int.Parse(a[0])*2;Console.Write(Enumerable.Range(0,(S+1)*(S+1)+S).Select(z=>C(S/2,z%(S+2),z/(S+2))).ToArray());}}

JavaScript (ES6), 139 135 140 + 1 Byte

(+1 ist für -pFlag mit Node in der Konsole)

Fest:

t=(n,m)=>(m=2*n+1,(A=Array).from(A(m),(d,i)=>A.from(A(m),(e,j)=>i==j?j==n?"O":"\\":m-1==j+i?"/":i==n?"-":j==n?"|":" ").join("")).join("\n"))

Verwendungszweck:

t(3)
/*
\  |  /
 \ | / 
  \|/  
---O---
  /|\  
 / | \ 
/  |  \
*/

ungolfed:

var makeSun = function (n, m) {
    m = 2 * n + 1;    // there are 2*n+1 in each row/column
    return Array.from(Array(m), function (d, i) {
        return Array.from(Array(m), function (e, j) {
            // if i is j, we want to return a \
            // unless we're at the middle element
            // in which case we return the sun ("O")
            if (i == j) {
                return j == n ? "O" : "\\";
            // the other diagonal is when m-1 is j+i
            // so return a forward slash, /
            } else if (m - 1 == j + i) {
                return "/";
            // the middle row is all dashes
            } else if (i == n) {
                return "-";
            // the middle column is all pipes
            } else if (j == n) {
                return "|";
            // everything else is a space
            } else {
                return " ";
            }
        }).join("");
    }).join("\n");
}

Python 3, 193 186 Bytes

Golf gespielt

def f(n):
 s,b,e,d,g=' \\/|-';p,r,i='',int(n),0
 while r:print(s*i+b+s*(r-1)+d+s*(r-1)+e);r-=1;i+=1
 print(g*n+'O'+g*n);r+=1;i=n-1
 while r<n+1:print(s*i+e+s*(r-1)+d+s*(r-1)+b);r+=1;i-=1

Ausgabe

>>> f(3)
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

>>> f(5)
\    |    /
 \   |   /
  \  |  /
   \ | /
    \|/
-----O-----
    /|\
   / | \
  /  |  \
 /   |   \
/    |    \

Ungolfed

def f(n):
    s, b, e, d, g = ' \\/|-'
    p, r, i = '', int(n), 0
    while r:
        print(s*i + b + s*(r-1) + d + s*(r-1) + e)
        r -= 1
        i += 1
    print(g*n + 'O' + g*n)
    r += 1
    i = n-1
    while r < n+1:
        print(s*i + e + s*(r-1) + d + s*(r-1) + b)
        r += 1
        i -= 1

CJam, 59 55 Bytes

ri:A,W%{_S*"\|/"\*\A\-(S*_@@++}%_Wf%W%['-A*_'O\++]\++N*

Dies wird im jetzigen Zustand keine Preise gewinnen, aber ich war froh, dass es funktioniert hat!

Danke an Sp3000 für die Golftipps.

Python, 175 129 127 125 Bytes

s,q,x=' ','',int(input())
for i in range(x):d=(x-i-1);q+=(s*i+'\\'+s*d+'|'+s*d+'/'+s*i+'\n')
print(q+'-'*x+'O'+'-'*x+q[::-1])

Probieren Sie es hier online aus .

Ruby - 130 Bytes

def f(n);a=(0...n).map{|i|' '*i+"\\"+' '*(n-1-i)+'|'+' '*(n-1-i)+'/'+' '*i};puts(a+['-'*n+'O'+'-'*n]+a.reverse.map(&:reverse));end

Verwendungszweck:

irb(main):002:0> f(3)
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \

Perl 85 91 90 89 86B

map{$_=$r||O;s/^|$/ /mg;s/ (-*O-*) /-$1-/;$r="\\$s|$s/
$_
/$s|$s\\";$s.=$"}1..<>;say$r

Ungolfed:

# usage: echo 1|perl sun.pl

map {
    $_ = $r || O;  # no strict: o is "o". On the first run $r is not defined
    s/^|$/ /mg;    # overwriting $_ saves characters on these regexes
    s/ (-*O-*) /-$1-/;
    $r = "\\$s|$s/
$_
/$s|$s\\";         # Embedded newlines save 1B vs \n. On the first run $s is not defined.
    $s .= $"
} 1..<>;
say $r

Prolog, 219 Bytes

Nein, es ist keine Golfsprache. Aber ich denke, diese Seite braucht mehr Prolog.

s(N,N,N,79).
s(R,R,_,92).
s(R,C,N,47):-R+C=:=2*N.
s(N,_,N,45).
s(_,N,N,124).
s(_,_,_,32).
c(_,C,N):-C>2*N,nl.
c(R,C,N):-s(R,C,N,S),put(S),X is C+1,c(R,X,N).
r(R,N):-R>2*N.
r(R,N):-c(R,0,N),X is R+1,r(X,N).
g(N):-r(0,N).

Getestet mit swiplunter Linux. Rufen Sie wie folgt: swipl -s asciiSun.prolog; Dann fragen Sie nach Ihrer gewünschten Sonnengröße:

?- g(3).
\  |  /
 \ | /
  \|/
---O---
  /|\
 / | \
/  |  \
true .

Ungolfed:

 % Args to sym/4 are row, column, N and the character code to be output at that location.
sym(N,N,N,79).
sym(R,R,_,'\\').
sym(R,C,N,'/') :- R+C =:= 2*N.
sym(N,_,N,'-').
sym(_,N,N,'|').
sym(_,_,_,' ').

 % Args to putCols/3 are row, column, and N.
 % Recursively outputs the characters in row from col onward.
putCols(_,C,N) :- C > 2*N, nl.
putCols(R,C,N) :- sym(R,C,N,S), put_code(S), NextC is C+1, putCols(R,NextC,N).

 % Args to putRows/2 are row and N.
 % Recursively outputs the grid from row downward.
putRows(R,N) :- R > 2*N.
putRows(R,N) :- putCols(R,0,N), NextR is R+1, putRows(NextR,N).

putGrid(N) :- putRows(0,N).

JavaScript (ES6), 142 140 134 117 Byte

n=>(g=x=>x?`${t=` `[r=`repeat`](n-x--)}\\${s=` `[r](x)}|${s}/${t}
`+g(x):`-`[r](n))(n)+`O`+[...g(n)].reverse().join``

Versuch es

f=
n=>(g=x=>x?`${t=` `[r=`repeat`](n-x--)}\\${s=` `[r](x)}|${s}/${t}
`+g(x):`-`[r](n))(n)+`O`+[...g(n)].reverse().join``
i.addEventListener("input",_=>o.innerText=f(+i.value))
o.innerText=f(i.value=1)

<input id=i type=number><pre id=o>