Nous avons un jardin carré de 10x10 mètres à l'extérieur de notre maison. Nous voulons planter de l'herbe et faire une terrasse. Nous avons décidé comment diviser le jardin, mais nous n'avons pas décidé du rapport entre la quantité d'herbe et la terrasse.

Nous avons besoin d'aide pour le visualiser, et l'art ASCII est clairement le meilleur moyen de le faire.

Défi:

Prenez un entier dans la plage inclusive [0, 100] (ou éventuellement décimal [0, 1]) représentant le pourcentage de jardin qui devrait être en terrasse.

Un mètre carré de terrasse sera représenté par un tiret -ou une barre |. Un mètre carré d'herbe sera représenté par une marque de hachage #.

• Si la quantité de terrasse est inférieure ou égale à 50%, le jardin doit être recouvert de barres, en commençant dans le coin inférieur gauche, et rempli verticalement, puis horizontalement.
• Si la quantité de terrasse est supérieure à 50%, nous voulons que le platelage soit dans l'autre sens (tirets au lieu de barres), et en commençant dans le coin inférieur gauche, et remplissez horizontalement, puis verticalement.

Exemples:

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

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

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

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

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

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

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

C'est le code-golf donc le code le plus court en octets gagne. Règles standard concernant les E / S. C'est de l'art ASCII, donc la sortie devrait ressembler aux exemples ci-dessus. C'est-à-dire que la sortie ["|", "|" ...]n'est pas OK.

Les explications sont encouragées comme toujours :)

APL (Dyalog) , 34 octets

Fonction de préfixe anonyme attendant un entier compris entre 0 et 100. Suppose que ⎕IO( I ndex O rigin) est 0, ce qui est le cas par défaut sur de nombreux systèmes.

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

Essayez-le en ligne!

{… } Lambda; ⍵est l'argument:

 '#-|[… ] Indexez la chaîne avec le tableau suivant:

 50≥⍵ 1 si 50 est supérieur ou égal à l'argument, sinon 0

 s← magasin à s (pour s mall)

 1+ incrément

 ⍵⍴ cyclique r Eshape à longueur d'argument

 100↑ prenez la première centaine de cela, remplissez de zéros

 10 10⍴ r forme à dix lignes et dix colonnes

 ⊢ rendement qui (séparé sde10 10 )

 ⍉⍣s transposer si petit

 ⊖ retourner à l'envers

J , 39, 38 37 octets

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

Comment ça fonctionne:

                     _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

Essayez-le en ligne!

JavaScript (ES6), 84 octets

Prend l'entrée comme un entier dans [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)

Cas de test

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>

Formaté et commenté

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 116 octets

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)

Essayez-le en ligne!

Gelée , 23 octets

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

Essayez-le en ligne!

Modifiez le nombre avant Çdans le pied de page pour modifier l'entrée. Fonctionne comme un lien monadique dans un programme sans arguments de ligne de commande, ce qui est autorisé .

SWI Prolog, 249 octets

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

La solution est assez simple. La procédure acrée des lignes, lécrit des caractères dans les colonnes d'une ligne et rdécide quel caractère doit être imprimé.

MATL , 26 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

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

Essayez-le en ligne!

Dans les deux cas, chaque ligne est complétée à droite par #une longueur de 10, ce qui nous permet de partager ce code entre les deux cas. Le nombre 10 a été utilisé assez souvent pour que l'aliasing T=10enregistre un nombre décent d'octets.

Rubis , 92 82 octets

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

Essayez-le en ligne!

Comment ça fonctionne:

Chaque cellule de la grille a un numéro progressif partant du coin inférieur gauche et se poursuivant horizontalement ou verticalement en fonction de la valeur de n:

Si n>50, le nombre est 100-y*10+xsinon c'estx*10+9-y

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

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

Essayez-le en ligne!

Explication

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

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

Essayez-le ici!

Explication:

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

[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

Essayez-le en ligne!

APL (Dyalog Classic) , 33 octets

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

Essayez-le en ligne!

basé sur la réponse d'Adám

⎕d est la chaîne '0123456789'

∘., produit cartésien

⍨ avec lui-même

⍎¨ évaluer chacun - obtenir une matrice 10x10 de 0..99

⍵> matrice booléenne pour laquelle l'argument ⍵ est plus grand

⊢ agit comme séparateur

(⍉+⍨)⍣(⍵≤50)si ⍵≤50 doublez la matrice ( +avec elle-même) et transposez (⍉ )

⊖ inversion verticale

'#-|'[ ]indexer la chaîne '#-|'avec chaque élément de la matrice

q , 51 octets

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

Rétine , 72 62 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Edit: 10 octets enregistrés avec l'aide de @MartinEnder. Explication:

.+
$*|

Répétez |le nombre de fois donné

T`|`-`.{51,}

Mais si l'entrée était d'au moins 51, remplacez-les par l' -art.

$
100$*#

Ajouter 100 #s.

M!10`.{10}

Divisez-vous en 10 groupes de 10, jetez tout ce qui reste.

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

Si l'entrée était au moins 51, transposez le résultat.

O`

Triez le résultat.

Solution alternative, également 62 octets:

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

Le tri avant la transposition permet d'économiser un octet sur la condition de transposition mais coûte un octet pour obtenir le résultat dans le bon ordre.

Python 2 , 106 103 octets

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

Essayez-le en ligne!

PHP, 119 + 1 octets

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

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Gelée , 24 octets

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

Essayez-le en ligne!

Comment ça fonctionne

J'utilise trop d'exposants ...

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

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

Essayez-le en ligne!

Lit n partir de stdin et imprime le jardin sur stdout.

Explication:

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