Tenemos un jardín cuadrado de 10x10 metros fuera de nuestra casa. Queremos plantar hierba y hacer una terraza. Hemos decidido cómo dividir el jardín, pero no hemos decidido la proporción entre la cantidad de césped y la terraza.

Necesitamos ayuda para visualizarlo, y ASCII-art es claramente la mejor manera de hacerlo.

Desafío:

Tome un número entero en el rango inclusivo [0, 100] (u opcionalmente decimal [0, 1]) que representa el porcentaje del jardín que debe ser terraza.

Un metro cuadrado de terraza estará representado por un tablero -o una barra |. Un metro cuadrado de hierba estará representado por una marca hash #.

• Si la cantidad de terraza es menor o igual al 50%, entonces el jardín debe cubrirse con barras, comenzando en la esquina inferior izquierda y llenando verticalmente, luego horizontalmente.
• Si la cantidad de terraza es más del 50%, entonces queremos que la plataforma sea al revés (guiones en lugar de barras), y que comience en la esquina inferior izquierda, y se llene horizontalmente, luego verticalmente.

Ejemplos:

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

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

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

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

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

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

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

Este es el código de golf, por lo que gana el código más corto en bytes. Reglas estándar sobre E / S. Este es un arte ASCII, por lo que la salida debería parecerse a los ejemplos anteriores. Es decir, la salida ["|", "|" ...]no está bien.

Se alientan las explicaciones como siempre :)

APL (Dyalog) , 34 bytes

Función de prefijo anónimo que espera un entero en el rango 0–100. Asume ⎕IO( I ndex O rigin) ser 0, que es predeterminado en muchos sistemas.

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

Pruébalo en línea!

{... } lambda; ⍵es argumento:

 '#-|[... ] indexe la cadena con la siguiente matriz:

 50≥⍵ 1 si 50 es mayor o igual que el argumento, de lo contrario 0

 s← almacenar en s (para s mall)

 1+ incremento

 ⍵⍴ cíclicamente r eshape al argumento de longitud

 100↑ toma el primer centenar de eso, rellenando con ceros

 10 10⍴ r forme diez filas y diez columnas

 ⊢ rendimiento que (se separa sde 10 10)

 ⍉⍣s transponer si es pequeño

 ⊖ voltear al revés

J , 39, 38 37 bytes

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

Cómo funciona:

                     _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

Pruébalo en línea!

JavaScript (ES6), 84 bytes

Toma la entrada como un entero en [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)

Casos de prueba

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>

Formateado y comentado

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)

Pruébalo en línea!

Jalea , 23 bytes

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

Pruébalo en línea!

Cambie el número anterior Çen el pie de página para cambiar la entrada. Funciona como un enlace monádico en un programa sin argumentos de línea de comandos, lo cual está permitido .

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

La solución es bastante sencilla. El procedimiento acrea filas, lescribe caracteres en columnas en una fila y rdecide qué carácter debe imprimirse.

MATL , 26 bytes

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

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Pruébalo en línea!

En ambos casos, cada línea se rellena a la derecha #con una longitud de 10, lo que nos permite compartir ese código entre los dos casos. El número 10 se usó con la frecuencia suficiente para que el alias T=10guardara un número decente de bytes.

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]:?#}*''}}

Pruébalo en línea!

Cómo funciona:

Cada celda de la cuadrícula tiene un número progresivo que comienza en la esquina inferior izquierda y continúa horizontal o verticalmente según el valor de n:

Si n>50, de lo 100-y*10+xcontrario , el número esx*10+9-y

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Casco , 24 bytes

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

Pruébalo en línea!

Explicación

↔?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§┐┌ŗ

Pruébalo aquí!

Explicación:

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

Pruébalo en línea!

APL (Dyalog Classic) , 33 bytes

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

Pruébalo en línea!

basado en la respuesta de Adám

⎕d es la cuerda '0123456789'

∘., producto cartesiano

⍨ consigo mismo

⍎¨ evalúe cada uno: obtenga una matriz de 10x10 de 0..99

⍵>matriz booleana para donde el argumento ⍵es mayor

⊢ actúa como separador

(⍉+⍨)⍣(⍵≤50)si ⍵≤50 duplica la matriz ( +consigo misma) y transpone ( ⍉)

⊖ reverso vertical

'#-|'[ ]indexar la cadena '#-|'con cada elemento de la matriz

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`

Pruébalo en línea! El enlace incluye casos de prueba. Editar: guardado 10 bytes con ayuda de @MartinEnder. Explicación:

.+
$*|

Repite |el número de veces dado

T`|`-`.{51,}

Pero si la entrada fue al menos 51, cámbielos a -s.

$
100$*#

Añadir 100 #s.

M!10`.{10}

Divídase en 10 grupos de 10, desechando todo lo que quede.

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

Si la entrada fue al menos 51, transponga el resultado.

O`

Ordenar el resultado.

Solución alternativa, también 62 bytes:

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

La clasificación antes de la transposición permite un ahorro de bytes en la condición de la transposición, pero cuesta un byte para obtener el resultado en el orden correcto.

Python 2 , 106103 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

Pruébalo en línea!

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

Ejecutar como tubería -nRo probarlo en línea .

Jalea , 24 bytes

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

Pruébalo en línea!

Cómo funciona

Yo uso demasiados superíndices ...

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

Pruébalo en línea!

Lee nde stdin e imprime el jardín en stdout.

Explicación:

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