우리 집 밖에 10x10m 크기의 정원이 있습니다. 우리는 잔디를 심고 테라스를 만들고 싶습니다. 우리는 정원을 나누는 방법 을 결정 했지만 잔디의 양과 테라스 사이의 비율을 결정하지 않았습니다.

이를 시각화하는 데 도움이 필요하며 ASCII-art가 가장 좋은 방법입니다.

도전:

정원의 몇 퍼센트가 테라스 여야하는지 나타내는 [0, 100] (또는 선택적으로 십진수 [0, 1]) 범위의 정수를 사용하십시오 .

테라스 1 평방 미터는 대시 -또는 바로 표시 |됩니다. 1 평방 미터의 잔디는 해시 마크로 표시 #됩니다.

• 테라스의 양이 50 % 이하이면 정원은 왼쪽 하단에서 시작하여 가로로 채워지고 가로로 채워야합니다.
• 테라스의 양이 50 %를 초과하면 갑판이 다른 방법 (바 대신 대시)이되고 왼쪽 하단에서 시작하여 수평으로 채우고 수직으로 채우기를 원합니다.

예 :

N = 25%
||########
||########
||########
||########
||########
|||#######
|||#######
|||#######
|||#######
|||#######

N = 75%
##########
##########
-----#####
----------
----------
----------
----------
----------
----------
----------

N = 47%
||||######
||||######
||||######
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####

N = 50%
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####

N = 51%
##########
##########
##########
##########
-#########
----------
----------
----------
----------
----------

N = 0%
##########
##########
##########
##########
##########
##########
##########
##########
##########
##########

N = 100%
----------
----------
----------
----------
----------
----------
----------
----------
----------
----------

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 이깁니다. I / O에 관한 표준 규칙. 이것은 ASCII 기술이므로 위의 예와 같이 출력되어야합니다. 즉, 출력 ["|", "|" ...]이 정상이 아닙니다.

설명은 항상 권장됩니다 :)

APL (Dyalog) , 34 바이트

0-100 범위의 정수를 예상하는 익명 접두사 함수 많은 시스템에서 기본값 인 ⎕IO( i ndex O rigin) 이라고 가정 0합니다.

{'#-|'[⊖⍉⍣s⊢10 10⍴100↑⍵⍴1+s←50≥⍵]}

온라인으로 사용해보십시오!

{… } 람다; ⍵논쟁이다 :

 '#-|[… ] 다음 배열로 문자열을 색인화하십시오.

 50≥⍵ 50이 인수보다 크거나 같으면 1, 그렇지 않으면 0

 s← s에 저장 ( s mall 용)

 1+ 증가

 ⍵⍴ 주기적 r에 인자 길이에 eshape을

 100↑ 그 중 첫 100을 0으로 채우십시오.

 10 10⍴ r에 열 행과 열 열에 eshape

 ⊢ 그 수율 (분리형 s에서 10 10)

 ⍉⍣s 작 으면 조옮김

 ⊖ 거꾸로 뒤집다

J , 39, 38 37 바이트

[:|.>&50|:'#-|'"0{~_10]\100{.]$1+51>]

작동 방식 :

                     _10]\100{.]$1+51>] - prepares a 10x10 array of 0, 1 or 2
                                 1+51>] - 1 if N<=50 otherwise 2
                               ]$       - list of N copies of the above (1 or 2)
                          100{.         - the above list filled to 100 items with 0
                     _10]\              - reshape the list to a 10x10 array
           '#-|'"0                      - constant array of chars
                   {~                   - replaces each digit 0, 1 or 2 with #, - or |     
     >&50                               - is N>50 ? 
         |:                             - if not, transpose the array
                                          (in fact |: here is rearrange axes
                                           0 - transpose
                                           1 - leave it intact)        
 |.@                                    - reverse the order ot the rows

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 84 바이트

[0 ... 100] 에서 입력을 정수로 취합니다 .

n=>(y=9,g=x=>~y?'|-#'[[x,y][k=n/51|0]*9+x+y<n?k:2]+[`
`[x-9]]+g(x++-9?x:!y--):'')(0)

테스트 사례

let f =

n=>(y=9,g=x=>~y?'|-#'[[x,y][k=n/51|0]*9+x+y<n?k:2]+[`
`[x-9]]+g(x++-9?x:!y--):'')(0)

;[25, 75, 47, 50, 51, 0, 100]
.forEach(n => O.innerText += n + '%:\n' + f(n) + '\n')

<pre id=O></pre>

형식화 및 의견

n => (                          // given the terrace percentage n
  y = 9,                        // and starting with y = 9
  g = x =>                      // g = recursive function taking x:
    ~y ?                        //   if y is greater than or equal to 0:
      '|-#'[                    //     pick the relevant character:
        [x, y][k = n / 51 | 0]  //       using k = 1 if n > 50, 0 otherwise
        * 9 + x + y             //       and comparing either 10 * x + y or 10 * y + x
        < n ?                   //       with n; if we're located over the terrace area:
          k                     //         append either '|' or '-'
        :                       //       else:
          2                     //         append '#'
      ] +                       //     end of character insertion
      [`\n`[x - 9]] +           //     append a linefeed if x == 9
      g(x++ - 9 ? x : !y--)     //     update (x, y) and do a recursive call
    :                           //   else:
      ''                        //     stop recursion
)(0)                            // initial call to g with x = 0

파이썬 (2) , 121 (117) 116 바이트

def f(n):
 s=[('-|'[n<51]*n+'#'*100)[i*10:][:10]for i in range(10)]
 for l in[s,zip(*s)][n<51][::-1]:print''.join(l)

온라인으로 사용해보십시오!

젤리 , 23 바이트

<©51ị⁾|-ẋḷ"”#ẋ³¤s⁵Z®¡ṚY

온라인으로 사용해보십시오!

Ç바닥 글에서 숫자 를 변경하여 입력을 변경하십시오. 명령 행 인수가없는 프로그램에서 모나드 링크로 작동하며 허용 됩니다.

SWI 프롤로그, 249 바이트

p(X):-write(X).
r(X,Y,G):-G=<50,10*X-Y+1=<G,p('|').
r(_,_,G):-G=<50,p('#').
r(X,Y,G):-(10-Y)*10+X>G,p('#').
r(_,_,_):-p('-').
l(_,11,_):-nl.
l(X,Y,G):-r(Y,X,G),Z is Y+1,l(X,Z,G).
a(10,G):-l(10,1,G).
a(Y,G):-l(Y,1,G),Z is Y+1,a(Z,G).
s(G):-a(1,G),!.

해결책은 매우 간단합니다. 프로시 저는 a행을 l작성하고 행의 열에 문자를 기록한 후 r인쇄 할 문자를 결정합니다.

MATL , 26 바이트

'|-#'100:i>~o10eG50>?!E]P)

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

'|-#'     % Push this string
100:      % Push array [1 2 ... 100]
i         % Input a number and push it
>~        % Less than or equal (element-wise)? This transforms the
          % array into [true ... true false ... false]
o         % Convert to double. True becomes 1, false becomes 0
10e       % Rehaspe into 10-row matrix, in column-major order
G         % Push input
50>       % Greater than 50?
?         % If so
  !       %   Transpose
  E       %   Multiply by 2 (element-wise). So 0 remains as 0, and
          %   1 becomes 2
]         % End
P         % Flip vertically
)         % Index into string, modularly. So 1 corresponds to '|',
          % 2 to '-', and 0 to '#'
          % Implicitly display

파이썬 2 , 85 바이트

T=j=10
n=input()+T
while j:print([(n-j)/T*'|',min(n-T*j,T)*'-'][n>60]+'#'*T)[:T];j-=1

온라인으로 사용해보십시오!

두 경우 모두 각 줄이 오른쪽에 #길이 10까지 채워져 두 경우 사이에서 해당 코드를 공유 할 수 있습니다. 별칭 10은 T=10적절한 수의 바이트를 저장하기에 충분할 정도로 자주 10을 사용했습니다 .

루비 , 92 82 바이트

->n{puts (r=0..9).map{|y|r.map{|x|n>(n>50?100-y*10+x:x*10+9-y)?"|-"[n/51]:?#}*''}}

온라인으로 사용해보십시오!

작동 방식 :

그리드의 모든 셀에는 왼쪽 하단에서 시작하여 n 값에 따라 가로 또는 세로로 진행되는 점진적 숫자가 있습니다.

인 경우 n>50숫자는 100-y*10+x그렇지 않은 경우x*10+9-y

숯 , 25 바이트

ＮθＧTχ#↶Ｆ÷θχ⟦χ⟧﹪θχ¿›θ⁵⁰‖Ｔ↖

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ                          Input integer into q
  Ｇ                         Draw filled polygon
   T                        Directions Right, Down, Left
    χ                       Size 10
     #                      Filled with `#`
      ↶                     Rotate cursor left (now points up)
       Ｆ÷θχ                 Repeat q/10 times (integer divide)
           ⟦χ⟧              Print 10 `|`s and move to the next column
              ﹪θχ           Print (q mod 10) `|`s
                 ¿›θ⁵⁰      If q > 50
                      ‖Ｔ↖   Reflect diagonally

껍질 , 24 바이트

↔?T†▼'-≤50⁰S↑C10+R⁰'|∞'#

온라인으로 사용해보십시오!

설명

↔?T†▼'-≤50⁰S↑C10+R⁰'|∞'#  Input is a number, say n=12
                     ∞'#  Infinite string of #s: "#######...
                +         Prepend to it
                   '|     the character |
                 R⁰       repeated n times: "||||||||||||####...
             C10          Cut to pieces of length 10: ["||||||||||","||##########","##..
           S↑             Take first 10 pieces.
 ?     ≤50⁰               If n is at most 50,
  T                       then transpose,
   †▼'-                   else take minimum with '-' for each character.
↔                         Reverse, implicitly print separated by newlines.

SOGL V0.12 , 21 바이트

┐* #M*+Mm√H.M»>?H§┐┌ŗ

여기 사용해보십시오!

설명:

┐*                     push a vertical bar repeated input times
   #M*                 push "#" repeated 100 times
      +                add the two together
       Mm              mold to a length of 100
         √             convert to a square
          H            rotate clockwise
           .M»>?       if the input is greater than 50
                H        rotate the array clockwise again
                 §       reverse it horizontally
                  ┐┌ŗ    replace "|" with "-"

dc , ₂₁₀ 197 바이트

[256r^1-255/]sx?dddI/dsT9r-sYI%ddIr-sqdsesm-I/sN[[lNlxx124*PIlN-lxx35*PIPlq1-dsq0<o]dsoxlN1+sNledsq0<oq]sJ50!<J[Ilxx35*PIPlY1-dsY0<E]sElY0<E[lmlxx45*PIlm-lxx35*PIP]sClTI>C[Ilxx45*PIPlT1-dsT0<Z]dsZx

온라인으로 사용해보십시오!

APL (Dyalog Classic) , 33 바이트

f←{'#-|'[⊖(⍉+⍨)⍣(⍵≤50)⊢⍵>⍎¨∘.,⍨⎕d]}

온라인으로 사용해보십시오!

Adám의 답변을 바탕으로

⎕d 문자열입니다 '0123456789'

∘., 카티 전 곱

⍨ 그 자체로

⍎¨ 각각 평가-0..99의 10x10 행렬을 얻습니다.

⍵>인수 ⍵가 큰 부울 행렬

⊢ 분리기 역할을

(⍉+⍨)⍣(⍵≤50)⍵≤50 인 경우 행렬 +자체를 두 배로 늘리고 조옮김 ( ⍉)

⊖ 수직 반전

'#-|'[ ]'#-|'행렬의 각 요소로 문자열 을 색인화하십시오.

q , 51 바이트

{-1@'reverse$[i;::;flip]10 10#@[100#"#";til x;:;"|-"i:x>50];}

망막 , 72 62 바이트

.+
$*|
T`|`-`.{51,}
$
100$*#
M!10`.{10}
O$s`(?<!-.*)\S
$.%`
O`

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 편집 : @ MartinEnder의 도움으로 10 바이트를 저장했습니다. 설명:

.+
$*|

|주어진 횟수만큼 반복

T`|`-`.{51,}

그러나 입력 값이 51 이상이면 -s로 변경하십시오 .

$
100$*#

100 #초 추가

M!10`.{10}

남은 모든 것을 버리고 10 개의 10 개 그룹으로 나눕니다.

O$s`(?<!-.*)\S
$.%`

입력이 51 이상인 경우 결과를 바꿉니다.

O`

결과를 정렬하십시오.

대체 솔루션, 62 바이트 :

.+
$*|
T`|`-`.{51,}
$
100$*#
M!10`.{10}
O`
O$^s`\S(?!.*-)
$.%`

전치하기 전에 정렬하면 전치 조건에서 바이트를 절약 할 수 있지만 올바른 순서로 결과를 얻으려면 바이트 비용이 듭니다.

파이썬 2 , 106 103 바이트

n=input();x=n>50;k=x*81+10
while k>0:s='';exec"s+='|-##'[x::2][n<k];k+=x or 10;"*10;print s;k+=x*81-101

온라인으로 사용해보십시오!

PHP, 119 + 1 바이트

$r=str_pad("",100,"#");for($x=50<$n=$argn;$n--;)$r[90+($x?$n%10*2-$n:$n/10-$n%10*10)]="|-"[$x];echo chunk_split($r,10);

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

젤리 , 24 바이트

³<51
ȷ2Ḷ<s⁵ZḤ$Ç¡Ṛị“-|#”Y

온라인으로 사용해보십시오!

작동 원리

너무 많은 위첨자를 사용합니다 ...

³<51 ~ Helper link.

³    ~ The input.
 <   ~ Is smaller than
  51 ~ 51?
     ~ Yields 1 for truthy, 0 for falsy.

ȷ2Ḷ<s⁵ZḤ$Ç¡Ṛị“-|#”Y ~ Main link.

ȷ2                  ~ 1e2 (i.e compressed 100).
  Ḷ                 ~ Lowered range. Yields [0, 100) ∩ ℤ.
   <                ~ Is smaller than the input? (element-wise).
    s⁵              ~ Split into sublists of length 10.
         Ç¡         ~ Repeat <last link as a monad> times (either 1 or 0 times).
      ZḤ$           ~ Zip (transpose) and unhalve element-wise.
           Ṛ        ~ Reverse.
            ị       ~ Modular, 1-based indexing into...
             “-|#”  ~ The literal string "-|#".
                  Y ~ Join by newlines.

R , 102 바이트

n=scan();m=matrix("#",y<-10,y);m[0:n]="if"(n<51,"|","-");write("if"(n>50,m[,y:1],t(m[y:1,])),"",y,,"")

온라인으로 사용해보십시오!

nstdin에서 읽고 정원을 stdout으로 인쇄합니다.

설명:

n=scan()               # read from stdin
m=matrix("#",10,10)               # create 10x10 matrix of "#"
m[0:n]="if"(n<51,"|","-")         # set the first n entries in m to the appropriate character
m="if"(n>50,                      # prepare for printing using write
       m[,10:1],                  # reverse m left to right
       t(m[10:1,]))               # flip m top to bottom and transpose
write(m,"",10,,"")                # write m to stdout in 10 columns with no separator