Ecrivez un programme qui prend (via STDIN / ligne de commande) un entier non négatif N.

Lorsque N est Oégal à 0, votre programme doit être imprimé (c'est la capitale, Oh, pas zéro).

Lorsque N vaut 1, votre programme devrait imprimer

\|/
-O-
/|\

Quand N vaut 2, votre programme devrait imprimer

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

Quand N vaut 3, votre programme devrait imprimer

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

Pour un plus grand N, ce motif continue exactement de la même manière. Chacun des huit rayons du « soleil » doit être faite de N des appropriés -, |, /ou \caractères.

Détails

• Au lieu d'un programme, vous pouvez écrire une fonction qui prend un entier. La fonction doit imprimer le dessin du soleil normalement ou le renvoyer sous forme de chaîne.

• Vous devez soit

  • ne pas avoir d'espaces de fin, ou
  • n’avez que suffisamment d’espaces de fin pour que le motif soit un rectangle parfait (2N + 1) * (2N + 1).

• La sortie de tout ou partie des N peut éventuellement avoir une nouvelle ligne.

Notation

Le code le plus court en octets gagne.

Pyth, 39 38 36 octets

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

Essayez-le en ligne: Compilateur / Exécuteur Pyth

Explication

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"

Une autre solution de 36 octets serait:

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

Je pense que je me rapproche assez d'une solution minimale en utilisant cette approche, mais je ne peux m'empêcher de penser qu'il existe une bien meilleure approche dans C. Ungolfed:

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

Ouf - j'ai battu la réponse php!

Score + 1 pour utiliser le -rparamètre.

En raison des limitations de sed, nous devons graver près de 100 octets, il suffit de convertir N en chaîne de N espaces. Le reste est le truc amusant.

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

Explication

• La première ligne est une sortie anticipée pour le cas N = 0.
• Les 15 lignes suivantes (jusqu’à la :) convertissent N en une chaîne de N espaces
• s/ // supprime un espace
• s^.*^\\&|&/^;taconvertit les espaces N-1 en: \+ N-1 espaces + |+ N-1 espaces +/
• Itérez, imprimez chaque itération et déplacez \un espace à droite et /un espace à gauche ...
• ... jusqu'à ce que nous correspondions \|/, qui est remplacé par -O-et saute à l' nétiquette
• remplacer par -et imprimer
• remplacer -0-par /|\, et remplacer par -et sauter dans la boucle principale
• Itérez, imprimez chaque itération et déplacez \un espace à droite et /un espace à gauche ...
• ... jusqu'à ce que nous correspondions \$qui indique étaient terminés, et quittez.

Sortie

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

J, 37 34 40 octets

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

Usage:

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

Explication (de gauche à droite):

• i: génère la liste -n, -(n-1), ..., n-1, n

• ( )"*/~@i:crée le produit Descartes de i: avec lui-même dans un arrangement matriciel, par exemple pour n = 1crée la 3-by-3matrice suivante

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

• pour chaque élément de matrice avec des entiers x ynous faisons ce qui suit

• +&|,-,+,[,] calculer une liste de propriétés

  • +&| abs(x)+abs(y), est égal à 0ssi (si et seulement si) x=0ety=0
  • -xy, égal à 0ssf x=yon est sur la diagonale
  • +x + y, égal à 0ssi x=-yon est sur l'anti-diagonale
  • [x, égal à 0ssf x=0on est sur la rangée du milieu
  • ]y, est égal à 0Ssf y=0nous sommes dans la colonne du milieu

• 'O\/-|'#~0=Comparez ces valeurs de propriété ci-dessus à 0et prenez le icaractère th de la chaîne 'O\/-|'si la ipropriété th est true.

• le premier caractère de la chaîne résultante sera toujours celui dont nous avons besoin, si la chaîne est vide, nous avons besoin d'un espace
• {. prend le premier caractère d'une chaîne et s'il n'y en a aucun, il retourne un caractère d'espace comme remplissage, comme nous en avons besoin
• nous avons maintenant la matrice exacte dont nous avons besoin, donc nous l’imprimons sur stdout une fois avec 1:echo

Essayez-le en ligne ici.

PHP, 182 octets

Cela semblait être une activité amusante pour ma première réponse. Les commentaires sur mon code sont les bienvenus.

<?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":"";}}?>

Voici le code non-golfé avec des commentaires:

<?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>

Édité avec code par 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)

Prints ligne par ligne, créant chaque ligne en vérifiant si la coordonnée (i,j)(centrée sur (0,0)) satisfait j==-i, j==0, j==i, ou pas, avec un hack pour faire le travail de la ligne centrale.

CJam, 48 45 43 41 38 octets

C'est encore trop long et je continue à faire des choses redondantes, mais voici:

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

Essayez-le en ligne ici

SpecBAS - 117 octets

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"

Ceci imprime les barres obliques et les tirets dans une boucle, puis pointe le "O" au milieu.

Sortie utilisant 1, 2 et 9

JavaScript (ES6) 97 98

Cela semble assez différent ...

// 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 ... ou 14 pour la "version du tricheur"

Sortez les sauts de ligne pour "jouer au golf".

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

Version du tricheur, nommez le script, quel que soit le code source de votre choix, sous 255 caractères (nécessite un disque HPFS):

interpret '%0'

EDIT: Juste pour être clair, la version du tricheur n'est pas censée compter! C'est juste pour être stupide et montrer qu'un vieux chien peut encore faire des tours. :)

Par exemple, pour le divertissement et les jeux, implémentation des expressions "lambda" de style Java-8 / C11 sur un itérateur de liste. Non testé, mais devrait fonctionner sur un ordinateur central IBM d'environ 1979. ;)

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

- Le code d'appel suppose que vous avez déjà créé une tige (tableau), naturellement.

Haskell, 109 98 96 octets

Merci à nimi et mauris pour leur aide!

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

Explication:

L'opérateur #spécifie quel caractère apparaît aux coordonnées (i, j), avec le soleil centré à (0,0). Function fconstruit la chaîne de résultat en mappant #toutes les paires de coordonnées allant de -n à n.

Usage:

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

R, 177 149 octets

Mickey T. est l'homme! Il m'a aidé à réparer ma solution initialement incorrecte et à économiser 28 octets. Merci 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 + explication:

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

Toute autre suggestion est la bienvenue!

C #, 230 226 octets

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

Comme demandé, la version non-golfée: 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; 
    }

Ceci est mon premier post, donc excuses si j'ai fait quelque chose de mal. Tous les commentaires et corrections sont les bienvenus.

Ruby: 98 92 caractères

Proc qui retourne une chaîne avec le soleil.

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}

Échantillon échantillon:

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

Rouille, 215 caractères

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

J'ai essayé d'utiliser une méthode de découpage en chaîne (en créant une chaîne d' n-1espaces et en effectuant un découpage vers et à partir d'un index) comme ceci:

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

Mais c'est en fait 3 caractères plus long.

Code non golfé:

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

Ce que j’aime, c’est la façon dont je rase quelques caractères sur les chaînes de formatage. Par exemple,

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

est équivalent à

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

parce que "l'incrémentation automatique" de la position de l'argument de chaîne de format n'est pas affectée par la spécification manuelle du nombre et agit de manière totalement indépendante.

Octave 85

Bulding matrices comme toujours =) eyeproduit une matrice d'identité, le reste est explicite, je pense.

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 octets

Je ne sais pas si cela peut être joué au golf plus ... C'est très simple. Tout d'abord, nous créons un m x mtableau ( m=2n+1) de chaînes vides; puis, nous dessinons les personnages dans les lignes ( y=x, y=-x, y=net x=n). Ensuite, nous lâchons O en un point (n, n)et imprimons le tout, sous la forme de mchaînes de longueur 1 sur chaque ligne, de manière à éviter tout espacement supplémentaire par rapport à l’impression native du tableau.

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

Tester:

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

Matlab, 93 87 octets

Malheureusement, l'entête de la fonction doit être si grosse ... A part ça, je pense que c'est assez bien joué au golf. Je me demande si cela pourrait être mieux fait avec certaines des différences de syntaxe dans Octave.

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 octets

La partie difficile était de savoir comment changer les barres obliques de chaque côté. Je me suis décidé pour définir un lambda qui utilise les symboles à utiliser.

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

Peut probablement être joué au golf plus, explication à venir.

Essayez-le en ligne ici .

Perl, 94

Il y a beaucoup d'opérateurs ternaires imbriqués ici, mais je pense que le code est assez simple.

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

Essayez-le ici: ideone.com/E8MC1d

C # - 291 (programme complet)

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 octets

(+1 est pour -pdrapeau avec noeud dans la console)

fixé:

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

usage:

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 octets

Golfé

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

Sortie

>>> 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 octets

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

Cela ne gagnera aucun prix tel quel, mais j'étais assez content que cela fonctionne!

Merci à Sp3000 pour ses astuces de golf.

Python, 175 129 127 125 octets

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

Essayez-le en ligne ici .

Ruby - 130 octets

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

usage:

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 octets

Non, ce n'est pas une langue de golf. Mais je pense que ce site a besoin de plus de 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).

Testé avec swiplLinux. Invoquer comme ceci: swipl -s asciiSun.prolog; puis interrogez votre taille de soleil souhaité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 octets

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

L'essayer

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>