Wir haben einen quadratischen 10x10 Meter großen Garten vor unserem Haus. Wir wollen Gras pflanzen und eine Terrasse bauen. Wir haben entschieden, wie der Garten aufgeteilt werden soll, aber wir haben nicht das Verhältnis zwischen Grasmenge und Terrasse festgelegt.

Wir brauchen Hilfe bei der Visualisierung, und ASCII-Kunst ist eindeutig der beste Weg, dies zu tun.

Herausforderung:

Nehmen Sie eine ganze Zahl im Einschlussbereich [0, 100] (oder optional eine Dezimalzahl [0, 1]), die angibt, wie viele Prozent des Gartens eine Terrasse sein sollen.

Ein Quadratmeter Terrasse wird durch einen Strich -oder eine Bar dargestellt |. Ein Quadratmeter Gras wird durch ein Rautezeichen dargestellt #.

• Wenn der Terrassenanteil 50% oder weniger beträgt, sollte der Garten ab der linken unteren Ecke mit Balken bedeckt und vertikal und dann horizontal gefüllt werden.
• Wenn der Terrassenanteil mehr als 50% beträgt, soll der Belag umgekehrt (Striche anstelle von Balken) und in der unteren linken Ecke beginnen und horizontal und dann vertikal ausgefüllt werden.

Beispiele:

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

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

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

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

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

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

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

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes. Standardregeln für E / A. Dies ist ASCII-artig, daher sollte die Ausgabe wie in den obigen Beispielen aussehen. Dh die Ausgabe ["|", "|" ...]ist nicht OK.

Erklärungen sind wie immer erwünscht :)

APL (Dyalog) , 34 Bytes

Anonyme Präfixfunktion, die eine Ganzzahl im Bereich von 0 bis 100 erwartet. Nimmt an ⎕IO( I ndex O rigin) zu sein 0, was auf vielen Systemen Standard ist.

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

Probieren Sie es online!

{… } Lambda; ⍵ist Argument:

 '#-|[… ] Indizieren Sie den String mit folgendem Array:

 50≥⍵ 1, wenn 50 größer oder gleich Argument ist, sonst 0

 s← Laden in s (für s Einkaufszentrum)

 1+ Zuwachs

 ⍵⍴ zyklisch r eshape zu Argumente Länge

 100↑ Nehmen Sie die ersten hundert davon und füllen Sie sie mit Nullen

 10 10⍴ r eshape bis zehn Reihen und zehn Spalten

 ⊢ ergibt das (trennt sich svon 10 10)

 ⍉⍣s transponieren, wenn klein

 ⊖ umdrehen

J , 39, 38, 37 Bytes

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

Wie es funktioniert:

                     _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

Probieren Sie es online!

JavaScript (ES6), 84 Byte

Übernimmt die Eingabe als Ganzzahl in [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)

Testfälle

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>

Formatiert und kommentiert

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 Bytes

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)

Probieren Sie es online!

Jelly , 23 Bytes

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

Probieren Sie es online!

Ändern Sie die Nummer zuvor Çin der Fußzeile, um die Eingabe zu ändern. Funktioniert als monadische Verknüpfung in einem Programm ohne Befehlszeilenargumente, was zulässig ist .

SWI-Prolog, 249 Bytes

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

Die Lösung ist ziemlich einfach. Prozedur aerstellt Zeilen, lschreibt Zeichen in Spalten in einer Zeile und rentscheidet, welches Zeichen ausgedruckt werden soll.

MATL , 26 Bytes

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

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

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

Probieren Sie es online!

In beiden Fällen ist jede Zeile rechts mit #der Länge 10 aufgefüllt , sodass wir diesen Code zwischen den beiden Fällen teilen können. Die Zahl 10 wurde oft genug verwendet, um durch Aliasing T=10eine anständige Anzahl von Bytes einzusparen.

Ruby , 92 82 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

Jede Zelle im Raster hat eine fortlaufende Nummer, die links unten beginnt und je nach dem Wert von n horizontal oder vertikal verläuft:

Wenn ja n>50, ist die Nummer 100-y*10+xandersx*10+9-y

Holzkohle , 25 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Schale , 24 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es hier aus!

Erläuterung:

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

[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

Probieren Sie es online!

APL (Dyalog Classic) , 33 Byte

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

Probieren Sie es online!

beyogen auf Adáms Antwort

⎕d ist die Zeichenfolge '0123456789'

∘., kartesisches Produkt

⍨ mit sich selbst

⍎¨ bewerte jedes - erhalte eine 10x10 Matrix von 0..99

⍵> Boolesche Matrix für wo das Argument ⍵ größer ist

⊢ fungiert als Trennzeichen

(⍉+⍨)⍣(⍵≤50)wenn ⍵≤50 die Matrix ( +mit sich selbst) verdoppeln und transponieren (⍉ )

⊖ vertikale Umkehrung

'#-|'[ ]Indizieren Sie die Zeichenfolge '#-|'mit jedem Element der Matrix

q , 51 Bytes

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

Retina , 72 62 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 10 Bytes mit Hilfe von @MartinEnder gespeichert. Erläuterung:

.+
$*|

Wiederholen Sie |die angegebene Anzahl von Malen

T`|`-`.{51,}

Wenn die Eingabe jedoch mindestens 51 war, ändern Sie sie in -s.

$
100$*#

100 #s anhängen .

M!10`.{10}

Teilen Sie sich in 10 Gruppen zu je 10 auf und werfen Sie alles weg, was übrig bleibt.

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

Wenn die Eingabe mindestens 51 war, transponieren Sie das Ergebnis.

O`

Sortieren Sie das Ergebnis.

Alternative Lösung, auch 62 Bytes:

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

Das Sortieren vor dem Transponieren ermöglicht eine Byte-Einsparung unter der Bedingung für das Transponieren, kostet jedoch ein Byte, um das Ergebnis in der richtigen Reihenfolge zu erhalten.

Python 2 , 106 103 Bytes

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

Probieren Sie es online!

PHP, 119 + 1 Bytes

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

Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Gelee , 24 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Ich verwende zu viele hochgestellte Zeichen ...

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

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

Probieren Sie es online!

Liest nvon stdin und druckt den Garten nach stdout.

Erläuterung:

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