Negatif olmayan bir tamsayı N alan (STDIN / komut satırı üzerinden) alan bir program yazın.

N 0 olduğunda, programınız yazdırılmalıdır O(bu büyük harf Oh, sıfır değil).

N 1 olduğunda, programınız yazdırılmalıdır

\|/
-O-
/|\

N 2 olduğunda, programınız yazdırılmalıdır

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

N 3 olduğunda, programınız yazdırılmalıdır

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

Daha büyük N için, bu desen aynı şekilde devam eder. "Güneş" sekiz ışınlarının her uygun bir N yapılmalıdır -, |, /, veya \karakterlerin.

ayrıntılar

• Bir program yerine, bir tamsayı alan bir işlev yazabilirsiniz. İşlev, güneş tasarımını normal şekilde yazdırmalı veya bir dize olarak döndürmelidir.

• Ya yapmalısın

  • hiç iz bırakma alanı yoksa veya
  • Yalnızca yeterli boşluk vardır, böylece desen mükemmel (2N + 1) * (2N + 1) bir dikdörtgendir.

• N'nin herhangi biri ya da tamamı için çıktı isteğe bağlı olarak takip eden bir yeni satıra sahip olabilir.

puanlama

Bayt cinsinden en kısa kod kazanır.

Pyth, 39 38 36 bayt

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

Çevrimiçi deneyin: Pyth Compiler / Executor

açıklama

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"

Başka bir 36 baytlık çözüm şöyle olacaktır:

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

Sanırım bu yaklaşımı kullanarak minimal bir çözüme oldukça yaklaşıyorum, ancak C'de çok daha iyi bir yaklaşım olduğunu hissedemiyorum. 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

Phew - Ben php cevabı yendi!

-rParametre kullanmak için + 1 puan .

Sed sınırlamaları nedeniyle, sadece N alanını bir N uzayına dönüştürmek için neredeyse 100 bayt yakmak zorundayız. Gerisi eğlenceli şeyler.

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

açıklama

• İlk satır N = 0 durumu için erken bir çıkış.
• Sonraki 15 satır (en fazla :) N'yi N boşluklu bir dizgeye dönüştürür
• s/ // bir boşluk kaldırır
• s^.*^\\&|&/^;taN-1 boşluklarını şu değerlere dönüştürür: \+ N-1 boşluk + |+ N-1 boşluk +/
• Yineleyin, her yinelemeyi yazdırın \ve /bir alanı sağa, bir alanı sola kaydırın ...
• ... biz eşleşene kadar \|/, ki bunlar yerine -O-geçecek ve netikete atlayacaktır.
• yerine sahip -ve baskı
• yerine -0-sahip /|\, ve değiştirme ile -ve ana döngüye geri atlama
• Yineleyin, her yinelemeyi yazdırın \ve /bir alanı sağa, bir alanı sola kaydırın ...
• ... bitene kadar \$bittikten sonra bitti ve istifa ettik .

Çıktı

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

J, 37 34 40 bayt

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

Kullanımı:

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

Açıklama (soldan sağa):

• i: liste oluşturur -n, -(n-1), ..., n-1, n

• ( )"*/~@i:i'nin Descartes ürününü yaratır: kendisiyle bir matris düzenlemesinde, örneğin n = 1aşağıdaki 3-by-3matrisi yaratır

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

• Tamsayılı her matris elemanı x yiçin aşağıdakileri yaparız:

• +&|,-,+,[,] özelliklerin bir listesini hesaplamak

  • +&| abs(x)+abs(y), eşittir 0iff (eğer ve sadece ise) x=0vey=0
  • -xy, eşittir 0iff, x=yyani köşegendeyiz
  • +x + y, eşittir 0iff, x=-yyani biz köşegen
  • [x, eşittir 0iff x=0yani orta sıradayız
  • ]y, eşittir 0iff y=0yani orta sütundayız

• 'O\/-|'#~0=bu yukarıdaki özellik değerlerini karşılaştırmak 0ve almak idizesinden inci karakter 'O\/-|'eğer iinci mülkiyet doğrudur.

• Ortaya çıkan karakter dizisindeki ilk karakter her zaman ihtiyacımız olan karakter olacaktır, eğer karakter boşsa boşluğa ihtiyacımız var
• {. Bir dizenin ilk karakterini alır ve eğer kimse yoksa, tıpkı ihtiyacımız olduğu gibi doldurma gibi bir boşluk karakteri döndürür.
• Şimdi ihtiyacımız olan matrisimiz var, bu yüzden bir kez ile stdout'a yazdıracağız 1:echo

Burada çevrimiçi deneyin.

PHP, 182 bayt

Bu ilk cevabım için eğlenceli bir aktivite gibi görünüyordu. Kodumla ilgili yorumlarınızı bekliyoruz.

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

İşte yorumsuz golf kodu:

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

Royhowie tarafından kod ile düzenlendi

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)

Baskılar koordinat olup olmadığını kontrol ederek her bir çizgi oluşturarak, satır satır (i,j)(merkezli (0,0)) tatmin j==-i, j==0, j==ibir kesmek ile, ya da biri merkez çizgisi çalışması için.

CJam, 48 45 43 41 38 bayt

Bu hala çok uzun ve hala bazı gereksiz şeyler yapıyorum, ama işte:

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

Burada çevrimiçi deneyin

SpecBAS - 117 bayt

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"

Bu, eğik çizgileri ve kısa çizgileri tek bir döngüde yazdırır ve ardından ortadaki "O" yu işaretler.

1, 2 ve 9 kullanarak çıktı

JavaScript (ES6) 97 98

Bu yeterince farklı görünüyor ...

// 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 ... veya "dolandırıcı sürümü" için 14

"Golf" yapmak için kankaları çıkarın.

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

Cheater'ın sürümü, 255 karakterin altındaki kaynak kodunu ne olursa olsun komut dosyasına adlandırın (HPFS disk gerektirir):

interpret '%0'

EDIT: Sadece açık olmak gerekirse, dolandırıcı'nın sürümü saymak için tasarlanmamıştır! Sadece aptal olmak ve yaşlı bir köpeğin hala numaralar yapabileceğini göstermek. :)

Örneğin, gerçek eğlence ve oyunlar için, bir liste yineleyici üzerinde Java-8 / C11 tarzı "lambda" ifadelerinin uygulanması. Test edilmedi, ancak yaklaşık 1979 IBM anabilgisayarında çalışmalı. ;)

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

- Arama kodu, zaten doğal olarak bir kök (dizi) yaptığınızı varsayar.

Haskell, 109 98 96 bayt

Nimi ve Mauris'e yardımları için teşekkürler!

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

Açıklama:

Operatör #, güneşin (0,0) ortalanmasıyla hangi karakterin koordinatlarda (i, j) görüneceğini belirler. İşlev f, #-n'den n'ye kadar olan tüm koordinat çiftleri üzerinde eşleme yaparak Sonuç Dizesini oluşturur .

Kullanımı:

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

R, 177 149 bayt

Mickey T. adam! Başlangıçta yanlış olan çözümümü düzeltmeme ve 28 byte tasarruf etmeme yardım etti . Sağol 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 + açıklama:

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

Başka önerilerinizi bekliyoruz!

C #, 230 226 bayt

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

İstendiği gibi, ungolfed versiyonu: 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; 
    }

Bu benim ilk gönderim, bu yüzden yanlış bir şey yaptıysam özür dilerim. Herhangi bir yorum ve düzeltmeler çok açıktır.

Yakut: 98 92 karakter

Sun ile bir dize döndüren işlem.

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}

Örnek çalışma:

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

Pas, 215 karakter

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

Bir dize dilimleme yöntemi kullanmaya çalıştım ( n-1boşluklar dizisi oluşturarak ve dizinden veya dizinden dilimleme yaparak) şöyle:

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

Ama bu aslında 3 karakter daha uzun.

Ungolfed kod:

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

Sevdiğim kısım, biçimlendirme dizgilerinde bir kaç karakter kazılmam. Örneğin,

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

eşittir

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

çünkü, string string argüman pozisyonu için "auto-incrementer", numaranın manuel olarak belirtilmesinden etkilenmez ve tamamen bağımsız hareket eder.

Octave 85

Her zaman olduğu gibi matrisler oluşturmak =) eyebir kimlik matrisi oluşturur, gerisi kendi kendini açıklayıcıdır.

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 bayt

Dunno eğer bu daha fazla golf oynayabilirse ... Çok basit. İlk önce boş dizelerin bir m x mdizisini ( m=2n+1) yaratırız ; o zaman, biz hatlarında karakterleri çizmek ( y=x, y=-x, y=nve x=n). Sonra O'yu noktaya bıraktık ve her satırı, her satırda uzunluk 1 dizisi (n, n)olarak biçimlendirilen her şeyi yazdırdık, mböylece diziyi yerel olarak yazdırmak için fazladan bir boşluk kalmadı.

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

Ölçek:

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

Matlab, 93 87 bayt

Ne yazık ki, işlev başlığı çok büyük olmalı ... Bunun dışında oldukça iyi golf oynadığını düşünüyorum. Octave'daki bazı sözdizimi farklılıklarıyla daha iyi yapılıp yapılmadığını merak ediyorum.

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 Taslak ) 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 bayt

Sert kısım her iki taraf için eğik çizgilerin nasıl değiştirileceğini bulmaktı. Kullanılacak sembolleri kullanan bir lambda tanımladım.

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

Daha fazla golf olabilir, açıklama yakında geliyor.

Burada çevrimiçi deneyin .

Perl, 94

Burada pek çok iç içe üçlü operatör var, ancak kodun oldukça basit olduğunu düşünüyorum.

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

Burada deneyin: ideone.com/E8MC1d

C # - 291 (tam program)

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 bayt

(+1, -pkonsolda düğümü olan bayrak içindir)

sabit:

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

kullanımı:

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 bayt

golfed

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

Çıktı

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

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

Bu olduğu gibi herhangi bir ödül kazanmayacak ama işe yaradığı için mutluydum!

Golf ipuçları için Sp3000 teşekkürler.

Python, 175 129 127 125 Bayt

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

Burada çevrimiçi deneyin .

Yakut - 130 bayt

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

kullanımı:

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 bayt

Hayır, bir golf dili değil. Ancak bu sitenin daha fazla Prolog'a ihtiyacı olduğunu düşünüyorum.

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

swiplLinux'ta test edildi . Öyle çağır swipl -s asciiSun.prolog:; sonra istediğiniz güneş büyüklüğünü sorgulayın:

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

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

Dene

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>