STDIN / 명령 줄을 통해 음이 아닌 정수 N을 취하는 프로그램을 작성하십시오.

N이 0이면 프로그램은 인쇄해야합니다 O(자본은 0이 아닌 Oh).

N이 1이면 프로그램이 인쇄되어야합니다

\|/
-O-
/|\

N이 2 인 경우 프로그램은 인쇄해야합니다

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

N이 3이면 프로그램이 인쇄되어야합니다

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

더 큰 N의 경우,이 패턴은 동일한 정확한 방식으로 계속됩니다. 은 "태양"의 8 광선의 각 해당의 N 만들어 져야한다 -, |, /, 또는 \문자.

세부

• 프로그램 대신 정수를 사용하는 함수를 작성할 수 있습니다. 이 함수는 태양 디자인을 정상적으로 인쇄하거나 문자열로 반환해야합니다.

• 당신은

  • 후행 공백이 없거나
  • 후행 공백이 충분하므로 패턴이 완벽한 (2N + 1) * (2N + 1) 사각형입니다.

• 임의의 또는 모든 N에 대한 출력은 선택적으로 후행 개행을 가질 수있다.

채점

바이트 단위의 가장 짧은 코드가 이깁니다.

Pyth, 39 38 36 바이트

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

온라인 사용해보기 : Pyth Compiler / Executor

설명

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"

또 다른 36 바이트 솔루션은 다음과 같습니다.

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

나는이 접근법을 사용하여 최소한의 솔루션에 상당히 가까워지고 있다고 생각하지만 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

휴-나는 PHP 답변을 이겼다!

-r매개 변수 사용에 대한 점수 + 1

sed 제한으로 인해 N을 N 개의 문자열로 변환하기 위해 거의 100 바이트를 구워야합니다. 나머지는 재미있는 것들입니다.

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

설명

• 첫 번째 줄은 N = 0 사례의 초기 출구입니다.
• 다음 15 줄 (까지 :)은 N을 N 개의 문자열로 변환합니다.
• s/ // 하나의 공간을 제거합니다
• s^.*^\\&|&/^;taN-1 공백을 다음으로 변환합니다. \+ N-1 공백 + |+ N-1 공백 +/
• 반복, 각 반복 인쇄 \및 /한 칸 오른쪽으로, 한 칸 왼쪽으로 이동
• 우리가 일치 할 때까지 ... \|/, 이는로 대체 -O-하고, 점프 n라벨
• 교체 로 -및 인쇄
• 교체 -0-로 /|\, 그리고 교체 와 함께 -메인 루프로 다시 이동
• 반복, 각 반복 인쇄 \및 /한 칸 오른쪽으로, 한 칸 왼쪽으로 이동
• ... \$완료된 것을 나타 내기 위해 종료 할 때까지 .

산출

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

J, 37 34 40 바이트

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

용법:

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

설명 (왼쪽에서 오른쪽으로) :

• i: 목록을 생성 -n, -(n-1), ..., n-1, n

• ( )"*/~@i:i의 Descartes 곱을 생성합니다. 예를 들어 n = 1다음과 같은 3-by-3행렬 을 생성하기 위한 행렬 배열

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

• 정수 x y가있는 모든 행렬 요소에 대해 다음을 수행합니다.

• +&|,-,+,[,] 속성 목록을 계산

  • +&| abs(x)+abs(y), 0iff (만일 경우) x=0와 같고y=0
  • -XY, 동일 0IFF에 x=y우리가 대각선에있는 즉,
  • +X + Y, 동일 0IFF에 x=-y우리는 안티 대각선에있는 즉,
  • [X, 동일 0IFF에 x=0우리가 중간 행에있는 즉,
  • ]Y는 동일 0IFF에 y=0우리가 중간 컬럼에있는 즉,

• 'O\/-|'#~0=th 속성이 true 인 경우 위의 속성 값을 비교 하여 문자열에서 th 문자를 0가져옵니다 .i'O\/-|'i

• 결과 문자열의 첫 번째 문자는 항상 필요한 문자입니다. 문자열이 비어 있으면 공백이 필요합니다
• {. 문자열의 첫 번째 문자를 가져오고 아무도 없으면 공백 문자를 필요에 따라 패딩으로 반환합니다.
• 이제 필요한 정확한 행렬을 얻었으므로 stdout으로 한 번 인쇄합니다. 1:echo

여기에서 온라인으로 사용해보십시오.

PHP, 182 바이트

이것은 나의 첫 번째 대답에 대한 재미있는 활동처럼 보였다. 내 코드에 대한 의견은 환영합니다.

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

주석이 포함 된 골프 용 코드는 다음과 같습니다.

<?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의 코드로 편집

파이썬 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)

인쇄가 좌표 여부에 의해 각 행을 생성 한 라인 씩 (i,j)(중심 (0,0))을 만족하는 j==-i, j==0, j==i해킹으로, 또는 어느 것도 중심선 작동하게 없음.

CJam, 48 45 43 41 38 바이트

이것은 여전히 ​​너무 길고 여전히 중복 작업을하고 있지만 여기에갑니다.

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

여기에서 온라인으로 사용해보십시오

SpecBAS-117 바이트

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"

이렇게하면 슬래시와 대시가 한 루프에 인쇄 된 다음 중간에 "O"가 표시됩니다.

1, 2 및 9를 사용한 출력

자바 스크립트 (ES6) 97 98

이것은 충분히 다른 것 같습니다 ...

// 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 ... 또는 14

라인 피드를 꺼내 "골프"하십시오.

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 's version에서 255 자 미만으로 원하는 소스 코드를 원하는대로 스크립트 이름을 지정하십시오 (HPFS 디스크 필요).

interpret '%0'

편집 : 분명히하기 위해 사기꾼의 버전은 중요하지 않습니다! 그것은 단지 바보이며 오래된 개가 여전히 속임수를 보여줄 수 있음을 보여줍니다. :)

예를 들어, 실제 재미와 게임의 경우 목록 반복기에 Java-8 / C11 스타일 "lambda"표현식을 구현합니다. 테스트되지는 않았지만 1979 년경 IBM 메인 프레임에서 실행되어야합니다. ;)

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

-호출 코드는 자연스럽게 줄기 (배열)를 만들었다 고 가정합니다.

하스켈, 109 98 96 바이트

도움을 주신 nimi와 Mauris에게 감사합니다!

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

설명:

연산자 #는 태양이 (0,0)을 중심으로 좌표 (i, j)에 표시 할 문자를 지정합니다. 함수 는 -n에서 n까지의 모든 좌표 쌍 f에 맵핑하여 결과 문자열을 빌드합니다 #.

용법:

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

R, 177149 바이트

미키 티가 남자 다! 그는 내 원래 잘못된 솔루션을 해결 도움 과 28 바이트를 저장합니다. 고마워 미키!

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

언 골프 + 설명 :

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

더 이상의 제안은 환영합니다!

C #을 230 226 바이트

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

요청에 따라 ungolfed 버전 : 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; 
    }

이것은 내가 잘못한 일이라면 사과하는 첫 번째 게시물입니다. 모든 의견과 수정은 매우 환영합니다.

루비 : 98 92 자

Sun과 함께 문자열을 반환하는 Proc.

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}

샘플 실행 :

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

녹, 215 자

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

다음과 같이 문자열 슬라이싱 방법을 사용하려고했습니다 ( n-1공백 문자열을 만들고 인덱스와 슬라이싱).

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

그러나 실제로 3 자 더 깁니다.

Ungolfed 코드 :

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

내가 좋아하는 부분은 서식 문자열에서 몇 가지 문자를 면도하는 방법입니다. 예를 들어

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

에 해당

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

형식 문자열 인수 위치에 대한 "자동 증가 기"는 숫자를 수동으로 지정해도 영향을받지 않으며 완전히 독립적으로 작동합니다.

옥타브 85

항상 =)처럼 Bulding 행렬 eye은 항등 행렬을 생성하고 나머지는 자명합니다.

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 바이트

골프를 더 많이 할 수 있다면 Dunno ... 매우 간단합니다. 먼저 빈 문자열 의 m x m배열 ( m=2n+1)을 만듭니다 . 다음, 우리가 줄의 문자를 그리는 ( y=x, y=-x, y=n, 및 x=n). 그런 다음 point에 O를 넣고 배열을 기본적으로 인쇄 할 때 여분의 간격이 없도록 각 줄에 길이가 1 인 문자열로 (n, n)서식이 지정된 모든 것을 m인쇄합니다.

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

테스트:

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

MATLAB, 93 87 바이트

슬프게도 함수 헤더는 너무 커야합니다 ... 그 외에도 골프를 잘하는 것 같습니다. 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 '']

자바 스크립트 ( ES7 초안 ) 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 바이트

어려운 부분은 각면에 슬래시를 전환하는 방법을 알아내는 것입니다. 기호를 사용하는 람다를 정의하기로 결정했습니다.

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

더 많은 골프를 치는 것 같습니다. 설명이 곧 올 것입니다.

여기에서 온라인으로 사용해보십시오 .

펄, 94

여기에는 중첩 된 삼항 연산자가 많이 있지만 코드가 상당히 간단하다고 생각합니다.

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

여기에서 사용해보십시오 : ideone.com/E8MC1d

C #-291 (전체 프로그램)

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

자바 스크립트 (ES6) 139 135 140 + 1 바이트

(+1은 -p콘솔에서 노드가있는 플래그입니다.)

결정된:

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

용법:

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

언 골프 :

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 바이트

골프

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

산출

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

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

언 골프

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 바이트

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

이상은 그대로 상을받지는 못했지만, 그것이 효과가있을 정도로 기뻤습니다!

골프 팁을위한 Sp3000에 감사합니다.

파이썬, 175129127125 바이트

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

여기에서 온라인으로 사용해보십시오 .

루비-130 바이트

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

용법:

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

펄 85 91 90 89 86B

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

언 골프 드 :

# 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

프롤로그, 219 바이트

아닙니다. 골프 언어는 아닙니다. 하지만이 사이트에는 더 많은 프롤로그가 필요하다고 생각합니다.

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에서 테스트되었습니다 . 다음과 같이 호출하십시오. swipl -s asciiSun.prolog; 그런 다음 원하는 태양 크기를 쿼리하십시오.

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

언 골프 드 :

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

자바 스크립트 (ES6) 142 140 134 117 바이트

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

시도 해봐

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>