Construir arcos ASCII

17

Me gusta el arte ascii y me aburro mucho, así que encontré algunos personajes ascii y comencé a hacer cosas al azar, mario castle de 8 bits, laberintos y arcos. Descubrí que los arcos se podían apilar fácilmente de una manera ordenada.

╔═══════╗
║╔═════╗║
║║╔═══╗║║
║║║╔═╗║║║
╨╨╨╨─╨╨╨╨

Desafío

Cree un programa, función o cualquier otro formato estándar que acepte un número entero mayor o igual a 0 (a menos que esté haciendo la bonificación) y genere un arte ascii con la cantidad de arcos especificados.

Casos de prueba

Entrada:

7

Salida:

╔═════════════╗
║╔═══════════╗║
║║╔═════════╗║║
║║║╔═══════╗║║║
║║║║╔═════╗║║║║
║║║║║╔═══╗║║║║║
║║║║║║╔═╗║║║║║║
╨╨╨╨╨╨╨─╨╨╨╨╨╨╨

Alt:

+-------------+
|+-----------+|
||+---------+||
|||+-------+|||
||||+-----+||||
|||||+---+|||||
||||||+-+||||||
||||||| |||||||
---------------

Entrada:

1

Salida:

╔═╗
╨─╨

Alt:

+-+
| |
---
  • Si el número entero es 0, no muestre nada
  • Esta pregunta estará en utf-8, cada personaje contará como un "byte"
  • Este es codegolf, por lo que gana la respuesta más corta.
  • Tiene la opción de usar en +-+lugar de ╔═╗, en ---lugar de ╨─╨y en |lugar de║

Bonificación (no se decidió si permitir esto en la versión alternativa porque no sería tan difícil)

-10% si el programa admite números negativos y voltea los arcos así

╥╥╥╥─╥╥╥╥
║║║╚═╝║║║
║║╚═══╝║║
║╚═════╝║
╚═══════╝
code-golf  ascii-art 
— JuanPatata
fuente
3
AFAIK esos no son caracteres ASCII. unicode-art
— flawr
welp, @flawr tienes razón. Qué pasa ahora ...
— JuanPotato
¡El mundo se va a derrumbar! No se preocupe, tal vez sólo mencionan que no son parte del estándar ASCII, pero la etiqueta de ASCII-art sigue vigente (la etiqueta Unicode era una broma.)
— flawr
Sin embargo, parece ASCII extendido, por lo que probablemente estés bien.
— Mama Fun Roll
2
@ ՊՓԼՃՐՊՃՈԲՍԼ No hay una versión estándar de ASCII extendido en.wikipedia.org/wiki/Extended_ASCII Lo más parecido es la página de códigos 437 en.wikipedia.org/wiki/Code_page_437 que era estándar en los EE. UU. Y en muchos otros países, pero encuentro cuando copie y pegue esto en un editor de página de códigos 437 y de nuevo en las ventanas que "interpreta" como arcos +---+en la parte superior, los lados |y la parte inferior de los -----cuales me parece bien. Juanpotato, si desea utilizar caracteres no ascii, indique la codificación en la pregunta. Tal como está, estoy votando para cerrar como poco claro.
— Level River St el

Respuestas:

2

Python 2, 106 bytes (94 caracteres)

n=input();j=1
exec"s=j/2*'║';print s+'╔'+'═'*(2*n-j)+'╗'+s;j+=2;"*n
if n:t='╨'*n;print t+'─'+t

Muy claro. Imprime línea por línea con un número variable de barras horizontales y verticales. La última línea se imprime por separado.

Siento que me faltan algunas optimizaciones. El hecho de que los caracteres son de varios bytes significa que no puede hacer algo así '║╨'[n>0], por lo que no encontré una buena manera de imprimir la última línea en el bucle. Es feo que haya tanta manipulación en el mostrador. Me gustaría actualizar las cadenas directamente, como s+='║', pero el índice también se usa para barras horizontales.

— xnor
fuente
Ahora puede usar +-|para construir los arcos, vea op para ver ejemplos.
— JuanPotato
2
@JuanPotato OP significa póster original. ¿Te refieres a la pregunta?
— Addison Crump
1
@flagasspam sí, acabo de ver usos donde significa publicación original
— JuanPotato
2

Perl, 78 82 caracteres

$n='─';$_='══'x pop;while(s/══//){print"$s╔═$_╗$s\n";$s.="║";$n="╨$n╨"}$s&&print$n

Lamentablemente, no pude encontrar una manera de aprovechar el bono sin aumentar el tamaño en más del 10%. Todavía puedo prevalecer.

Sin golf

Bastante sencillo, de verdad. Acumula la línea de fondo ( ╨$n╨) de forma incremental, mientras acorta la línea de arriba ( ══) en dos caracteres, terminando cuando ya no se puede acortar, por lo que no tengo que meterme con los contadores.

 $n = '─'; # Bottom line
 $_ = '══'x pop; # "Top" line, length from commandline argument
 while (s/══//) { # Shorten top line by two characters
     print "$s╔═$_╗$s\n"; # Print current line with $s (sides)
     $s .= "║";           # Append vertical bar to sides
     $n  = "╨$n╨";        # Widen bottom line
 }
 $s && print $n; # Print bottom line if input is not 0
— type_outcast
fuente
Creo que esto imprime un solo ─para n = 0, pero no debería imprimir nada.
— Lynn
@Mauris Lo acabo de ejecutar y tienes razón
— JuanPotato
1
@Mauris Dang! Estás absolutamente en lo correcto. Mi versión original estaba bien, pero en algún momento perdí el cheque. Fijo, al costo de 4 caracteres. Gracias por ver eso.
— type_outcast
Sé que esto es antiguo, pero para agregar al comentario de @ Abigail, también puede guardar bytes usando -n: ¡ Pruébelo en línea!
— Dom Hastings
1

Bash, 124 bytes (112 caracteres)

printf -vh %$1s
b=${h// /╨}
h=${h// /═}
for((n=$1;n--;)){
echo $v╔$h${h:1}╗$v
h=${h#?}
v+=║
}
(($1))&&echo $b─$b

Ejecución de muestra:

bash-4.3$ bash ascii-arch.sh 7
╔═════════════╗
║╔═══════════╗║
║║╔═════════╗║║
║║║╔═══════╗║║║
║║║║╔═════╗║║║║
║║║║║╔═══╗║║║║║
║║║║║║╔═╗║║║║║║
╨╨╨╨╨╨╨─╨╨╨╨╨╨╨

bash-4.3$ bash ascii-arch.sh 1
╔═╗
╨─╨

bash-4.3$ bash ascii-arch.sh 0
— hombre trabajando
fuente
1

Japt -R , 29 bytes

Usos +y -. Sacrificado 4 bytes para manejar el sangriento validación de entrada !

©Æ'+²¬q-p´UÑÄÃpS û| p-pNÑÄ)ªP

Intentalo

Explicación

                                  :Implicit input of integer U
©                                 :Logical AND with U
 Æ                                :Map the range [0,U)
  '+                              :  Literal "+"
    ²                             :  Repeat twice
     ¬                            :  Split
      q                           :  Join with
       -                          :   Literal "-"
        p                         :   Repeat
         ´U                       :    Decrement U
           Ñ                      :    Multiply by 2
            Ä                     :    Add 1
             Ã                    :End mapping
              pS                  :Push a space
                 û|               :Centre pad each element with "|" to the length of the longest element
                    p     )       :Push
                     -            : Literal "-"
                      p           : Repeat
                       N          :  The array of inputs (which will be cast to an integer if we perform a mathematical operation on it)
                        ÑÄ        :  Multiply by 2 and add 1
                           ª      :Logical OR
                            P     :The empty string
                                  :Implicitly join with newlines and output
— Lanudo
fuente
falla en la entrada0
— dzaima
@dzaima, ¿qué quieres decir? ¿Cómo puedes tener un arco de tamaño 0?
— Shaggy
If the integer is 0 then don't output anythingdel desafío: /
— dzaima
@dzaima, Oh, me perdí eso. Gracias. En primer lugar: ¡Boo-urnas para ingresar la validación! En segundo lugar, Japt puede nada sin salida - que pude de salida 0, falseo una cadena vacía a un costo de algunos bytes, pero no sé si alguno de estos sería aceptable, excepto, tal vez, la cadena vacía, lo que me costaría 5 bytes ( 0solo me costaría 1)
— Shaggy
0

JavaScript (ES6), 101 caracteres

f=(n,i=0)=>n?i-n?(b="║"[r="repeat"](i))+`╔${"═"[r]((n-i)*2-1)}╗${b}
`+f(n,i+1):(g="╨"[r](n))+"─"+g:""

Explicación

Función recursiva que imprime cada línea.

f=(n,i=0)=>              // f = recursive function, i = current line (default = 0)
  n?                     // if n != 0
    i-n?                 // if we are not in the last line, print the line
      (b="║"[r="repeat"](i))+`╔${"═"[r]((n-i)*2-1)}╗${b}
`+f(n,i+1)               // add the output of the next line
    :(g="╨"[r](n))+"─"+g // if we ARE in the last line, print the last line
  :""                    // print nothing if n = 0

Prueba

La prueba no utiliza el parámetro predeterminado para la compatibilidad del navegador.

Mostrar fragmento de código

— usuario81655
fuente
0

PHP (109 caracteres)

$s='';for($b=($n=$argv[1])?'─':'';$n--;){echo$s.'╔═'.str_repeat('══',$n)."╗$s\n";$s.='║';$b="╨{$b}╨";}echo$b;

Todavía necesito deshacerme de ese str_repeat, pero la mayoría de las alternativas no manejarán los caracteres mulyibyte.

$s = '';
// Initialise $b (bottom) to '─' or '' for n==0
for ($b = ($n = $argv[1]) ? '─' : ''; $n--;) {
    // Echo sides + arch + sides
    echo $s . '╔═' . str_repeat('══', $n) . "╗$s\n";
    // Growing sides
    $s .= '║';
    // Growing bottom
    $b = "╨{$b}╨";
}
// Show bottom
echo $b;
— mk8374876
fuente
0

Retina , 79 caracteres

.+
$0$*═$0$*═╗
^═
╔
+`(║*)╔═(═+)═╗║*$
$0¶$1║╔$2╗║$1
(\S+)$
$0¶$1
T`═╔╗║`─╨`\S+$

Pruébalo en línea.

Esto usa una nueva característica en Retina que reemplaza un número decimal \d+con una lista de tantos caracteres $0$*═.

— Trauma digital
fuente
0

Swift (209 bytes)

Probablemente Swift no es el mejor lenguaje para esto, esta es la primera vez que intento hacer un desafío de código de golf:

func *(l:String,r: Int)->String{return r>0 ?l+(l*(r-1)):""}
let n=Int(readLine()!)!
for i in 0...(n-1){let a=("║"*i)+"╔═";let b=a+("══"*(n-1-i))+"╗"+("║"*i);print(b)};print("╨"*n+"─"+"╨"*n)
— genesisxyz
fuente
0

Ruby, 90 bytes (74 caracteres)

->n{n.times{|i|puts ?║*i+?╔+?═*((n-i)*2-1)+?╗+?║*i}>0&&puts(?╨*n+?─+?╨*n)}

Ejecución de muestra:

2.1.5 :001 > ->n{n.times{|i|puts ?║*i+?╔+?═*((n-i)*2-1)+?╗+?║*i}>0&&puts(?╨*n+?─+?╨*n)}[7]
╔═════════════╗
║╔═══════════╗║
║║╔═════════╗║║
║║║╔═══════╗║║║
║║║║╔═════╗║║║║
║║║║║╔═══╗║║║║║
║║║║║║╔═╗║║║║║║
╨╨╨╨╨╨╨─╨╨╨╨╨╨╨
 => nil 

2.1.5 :002 > ->n{n.times{|i|puts ?║*i+?╔+?═*((n-i)*2-1)+?╗+?║*i}>0&&puts(?╨*n+?─+?╨*n)}[1]
╔═╗
╨─╨
 => nil 

2.1.5 :003 > ->n{n.times{|i|puts ?║*i+?╔+?═*((n-i)*2-1)+?╗+?║*i}>0&&puts(?╨*n+?─+?╨*n)}[0]
 => false
— hombre trabajando
fuente
0

Haskell, 151 162 bytes

r=replicate
c=concat
f n=putStr$unlines[c[r i '║',"╔",r(2*(n-i)-1)'═',"╗",r i '║']|i<-[0..n-1]]++c[r n '╨',r(signum n)'─',r n '╨']
main=readLn>>=f

Editar: olvidé tratar 0como entrada

— basile-henry
fuente
0

𝔼𝕊𝕄𝕚𝕟, 54 caracteres / 95 bytes

⩥ïⓜᵖ⟮ ⍘|ď⟯$+`+⦃⟮⍘-ď (ï⟯-$)*2-1)}+`+Ⅰ$;ï⅋ᵖⅠï+⬭+Ⅰï,Ⅱ*2+1

Try it here (Firefox only).

Explicación

⩥ïⓜᵖ⟮ ⍘|ď⟯$+`+⦃⟮⍘-ď (ï⟯-$)*2-1)}+`+Ⅰ$;ï⅋ᵖⅠï+⬭+Ⅰï,Ⅱ*2+1 // implicit: ï=input, $=mapped item
                                                       // PHASE 1
⩥ïⓜ                                                   // create a range to map over
    ᵖ                                                  // push to stack:
     ⟮ ⍘|ď⟯$                                            // | repeated $ times
           +`+⦃⟮⍘-ď (ï⟯-$)*2-1)}+`                      // & +[- repeated 2$-1 times]+
                                 +Ⅰ$;                  // & | repeated $ times
                                                       // PHASE 2
                                     ï⅋                // if ï>0
                                       ᵖ               // push to stack 2 items:
                                        Ⅰï+⬭+Ⅰï,      // | repeated $ times & [space] & | repeated $ times
                                                 Ⅱ*2+1 // and - repeated 2ï+1
                                                       // implicit stack output, newline-separated

NOTA: esto hace uso de buenos bloques de copia antiguos para llegar a los lugares donde no se puede alcanzar la declaración de variables ordinarias.

— Mama Fun Roll
fuente
0

Sed, 97 bytes (81 caracteres)

(Código de 96 bytes (80 caracteres) + opción de línea de comando de 1 carácter)

s/.(.*)/2&\13/
t
:
H
s/(.+)11(.+)/4\1\24/
t
y/1234/─╨╨╨/
H
g
s/\n//
y/1234/═╔╗║/

Entrada esperada como entero unario .

Ejecución de muestra:

bash-4.3$ sed -r 's/.(.*)/2&\13/;t;:;H;s/(.+)11(.+)/4\1\24/;t;y/1234/─╨╨╨/;H;g;s/\n//;y/1234/═╔╗║/' <<< '1111111'
╔═════════════╗
║╔═══════════╗║
║║╔═════════╗║║
║║║╔═══════╗║║║
║║║║╔═════╗║║║║
║║║║║╔═══╗║║║║║
║║║║║║╔═╗║║║║║║
╨╨╨╨╨╨╨─╨╨╨╨╨╨╨

bash-4.3$ sed -r 's/.(.*)/2&\13/;t;:;H;s/(.+)11(.+)/4\1\24/;t;y/1234/─╨╨╨/;H;g;s/\n//;y/1234/═╔╗║/' <<< '1'
╔═╗
╨─╨

bash-4.3$ sed -r 's/.(.*)/2&\13/;t;:;H;s/(.+)11(.+)/4\1\24/;t;y/1234/─╨╨╨/;H;g;s/\n//;y/1234/═╔╗║/' <<< ''

Sed, 105 bytes (75 caracteres)

(104 bytes (74 caracteres) de código + opción de línea de comando de 1 carácter)

y/1/═/
s/.(.*)/╔&\1╗/
t
:
H
s/(.+)══(.+)/║\1\2║/
t
y/╔║╗═/╨╨╨─/
H
g
s/\n//

Entrada esperada como entero unario .

Ejecución de muestra:

bash-4.3$ sed -r 'y/1/═/;s/.(.*)/╔&\1╗/;t;:;H;s/(.+)══(.+)/║\1\2║/;t;y/╔║╗═/╨╨╨─/;H;g;s/\n//' <<< '1111111'
╔═════════════╗
║╔═══════════╗║
║║╔═════════╗║║
║║║╔═══════╗║║║
║║║║╔═════╗║║║║
║║║║║╔═══╗║║║║║
║║║║║║╔═╗║║║║║║
╨╨╨╨╨╨╨─╨╨╨╨╨╨╨

bash-4.3$ sed -r 'y/1/═/;s/.(.*)/╔&\1╗/;t;:;H;s/(.+)══(.+)/║\1\2║/;t;y/╔║╗═/╨╨╨─/;H;g;s/\n//' <<< '1'
╔═╗
╨─╨

bash-4.3$ sed -r 'y/1/═/;s/.(.*)/╔&\1╗/;t;:;H;s/(.+)══(.+)/║\1\2║/;t;y/╔║╗═/╨╨╨─/;H;g;s/\n//' <<< ''
— hombre trabajando
fuente
0

Lienzo , 15 bytes.

-＊+∔］⤢：↷±ｎ│Ｌ-×∔

Pruébalo aquí!

Explicación:

{    ]            map over 1..input
 -*                 repeat "-" counter times
   +∔               append "+" to that
      ⤢           transpose
       :          create a duplicate of that
        ↷±        rotated 90°, then reversed horizontally
          n       overlap the 2
           |      and palindromize horizontally with 1 overlap
            L     get the with of that
             -×   repear "-" that many times
               ∔  and add vertically to the rest of the output
— dzaima
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.