Chúng tôi có một khu vườn vuông 10 x 10 mét bên ngoài ngôi nhà của chúng tôi. Chúng tôi muốn trồng cỏ và làm sân thượng. Chúng tôi đã quyết định cách phân chia khu vườn, nhưng chúng tôi chưa quyết định tỷ lệ giữa lượng cỏ và sân thượng.

Chúng tôi cần trợ giúp để hình dung nó, và nghệ thuật ASCII rõ ràng là cách tốt nhất để làm điều đó.

Thử thách:

Lấy một số nguyên trong phạm vi bao gồm [0, 100] (hoặc thập phân tùy ý [0, 1]) đại diện cho bao nhiêu phần trăm của khu vườn nên là sân thượng.

Một mét vuông sân thượng sẽ được đại diện bởi một dấu gạch ngang -hoặc một thanh |. Một mét vuông cỏ sẽ được thể hiện bằng dấu băm #.

• Nếu số lượng sân thượng nhỏ hơn hoặc bằng 50%, thì khu vườn nên được che bằng các thanh, bắt đầu ở góc dưới bên trái, và điền vào theo chiều dọc, sau đó theo chiều ngang.
• Nếu số lượng sân thượng là hơn 50% thì chúng tôi muốn sàn là cách khác (dấu gạch ngang thay vì thanh), và bắt đầu ở góc dưới bên trái, và điền theo chiều ngang, sau đó theo chiều dọc.

Ví dụ:

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

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

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

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

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

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

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

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng. Các quy tắc chuẩn liên quan đến I / O. Đây là nghệ thuật ASCII, vì vậy đầu ra sẽ giống như các ví dụ ở trên. Tức ["|", "|" ...]là đầu ra không ổn.

Giải thích được khuyến khích như mọi khi :)

APL (Dyalog) , 34 byte

Hàm tiền tố ẩn danh mong đợi số nguyên trong phạm vi 0 chàng100. Giả sử ⎕IO( I ndex O rigin) 0là mặc định trên nhiều hệ thống.

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

Hãy thử trực tuyến!

{... } lambda; ⍵là đối số:

 '#-|[... ] chỉ số chuỗi với các mảng sau:

 50≥⍵ 1 nếu 50 lớn hơn hoặc bằng đối số, khác 0

 s← cửa hàng trong s (cho s mall)

 1+ tăng

 ⍵⍴ chu kỳ r eshape đến chiều dài đối số

 100↑ lấy hàng trăm đầu tiên, đệm bằng số không

 10 10⍴ r eshape đến mười hàng và mười cột

 ⊢ mang lại (tách stừ 10 10)

 ⍉⍣s chuyển vị nếu nhỏ

 ⊖ lộn ngược

J , 39, 38 37 byte

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

Làm thế nào nó hoạt động:

                     _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

Hãy thử trực tuyến!

JavaScript (ES6), 84 byte

Lấy đầu vào dưới dạng một số nguyên trong [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)

Các trường hợp thử nghiệm

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>

Định dạng và nhận xét

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

Python 2 , 121 117 116 byte

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)

Hãy thử trực tuyến!

Thạch , 23 byte

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

Hãy thử trực tuyến!

Thay đổi số trước Çtrong chân trang để thay đổi đầu vào. Hoạt động như một liên kết đơn âm trong một chương trình không có đối số dòng lệnh, được phép .

SWI Prolog, 249 byte

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

Giải pháp khá đơn giản. Thủ tục atạo các hàng, lviết ký tự vào các cột trong một hàng và rquyết định ký tự nào sẽ được in ra.

MATL , 26 byte

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

'|-#'     % 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

Python 2 , 85 byte

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

Hãy thử trực tuyến!

Trong cả hai trường hợp, mỗi dòng được đệm bên phải #đến độ dài 10, cho phép chúng tôi chia sẻ mã đó giữa hai trường hợp. Số 10 được sử dụng thường xuyên đủ để răng cưa T=10tiết kiệm được số byte khá.

Ruby , 92 82 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

Mỗi ô trong lưới có một số lũy tiến bắt đầu từ góc dưới bên trái và tiến hành theo chiều ngang hoặc chiều dọc tùy thuộc vào giá trị của n:

Nếu n>50, số 100-y*10+xkhác là nóx*10+9-y

Than , 25 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ                          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

Husk , 24 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử nó ở đây!

Giải trình:

┐*                     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 byte

[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

Hãy thử trực tuyến!

APL (Dyalog Classic) , 33 byte

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

Hãy thử trực tuyến!

dựa trên câu trả lời của Adám

⎕d là chuỗi '0123456789'

∘., Sản phẩm của Cartesian

⍨ với chính nó

⍎¨ đánh giá từng cái - lấy ma trận 10x10 là 0,99

⍵>ma trận boolean cho nơi đối số ⍵lớn hơn

⊢ đóng vai trò là dải phân cách

(⍉+⍨)⍣(⍵≤50)nếu ⍵≤50 nhân đôi ma trận ( +với chính nó) và hoán vị ( ⍉)

⊖ đảo ngược dọc

'#-|'[ ]lập chỉ mục chuỗi '#-|'với từng phần tử của ma trận

q , 51 byte

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

Võng mạc , 72 62 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 10 byte với một số trợ giúp từ @MartinEnder. Giải trình:

.+
$*|

Lặp lại |số lần đã cho

T`|`-`.{51,}

Nhưng nếu đầu vào ít nhất là 51, hãy đổi chúng thành -s.

$
100$*#

Nối 100 #s.

M!10`.{10}

Chia thành 10 nhóm 10, loại bỏ mọi thứ còn sót lại.

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

Nếu đầu vào ít nhất là 51, hoán chuyển kết quả.

O`

Sắp xếp kết quả.

Giải pháp thay thế, cũng là 62 byte:

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

Sắp xếp trước khi hoán vị cho phép tiết kiệm một byte với điều kiện chuyển vị nhưng tốn một byte để có kết quả theo đúng thứ tự.

Python 2 , 106 103 byte

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

Hãy thử trực tuyến!

PHP, 119 + 1 byte

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

Chạy như ống với -nRhoặc thử trực tuyến .

Thạch , 24 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Tôi sử dụng quá nhiều bản sao ...

³<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 byte

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

Hãy thử trực tuyến!

Đọc ntừ stdin và in vườn đến stdout.

Giải trình:

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