Мені подобається мистецтво ascii, і мені дуже нудно, тому я знайшов деяких персонажів ascii і почав робити випадкові речі, 8-бітний замок Маріо, лабіринти та арки. Я виявив, що арки можна легко укласти акуратно.

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

Виклик

Створіть програму, функцію або будь-який інший стандартний формат, який приймає ціле число, яке більше або дорівнює 0 (якщо ви не робите бонус) і виводить ascii art із вказаною кількістю арк.

Випробування

Вхід:

7

Вихід:

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

Alt:

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

Вхід:

1

Вихід:

╔═╗
╨─╨

Alt:

+-+
| |
---

• Якщо ціле число дорівнює 0, то нічого не виведіть
• Це питання буде в utf-8, кожен символ буде рахуватися як "байт"
• Це кодогольф, тому найкоротша відповідь виграє.
• У вас є можливість використовувати +-+замість ╔═╗, ---замість ╨─╨, і |замість║

Бонус (не вирішено, чи дозволяти це в альтернативній версії, оскільки це не буде настільки складно)

-10%, якщо програма підтримує від’ємні числа і перевертає дуги так

╥╥╥╥─╥╥╥╥
║║║╚═╝║║║
║║╚═══╝║║
║╚═════╝║
╚═══════╝

CJam, 59 байт

qi:Lg"^Za"a{_0=1'Z3*tsa\{'[2*\*}%+}L(*'rL*a2*N*a+9462ff+N**

Спробуйте тут!

Python 2, 106 байт (94 символи)

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

Досить прямо. Друкує рядок за рядком із зміною кількості горизонтальних та вертикальних смуг. Останній рядок друкується окремо.

Я відчуваю, що пропускаю деякі оптимізації. Той факт, що символи є декількома байтами, означає, що ви не можете зробити щось подібне '║╨'[n>0], тому я не знайшов хорошого способу надрукувати останній рядок у циклі. Потворно, що стільки маніпуляцій відбувається з лічильником. Мені б хотілося безпосередньо оновити рядки, якs+='║' , але індекс також використовується для горизонтальних .

Перл, 78 82 ч

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

На жаль, я не змогла знайти спосіб скористатися бонусом, не збільшивши розмір більш ніж на 10%. Я все ще можу перемогти.

Безумовно

Досить прямо, насправді. ╨$n╨Поступово нарощує нижню лінію ( ), при цьому скорочуючи верхню лінію ( ══) двома символами, закінчуючи, коли її більше не можна скорочувати, тому мені не потрібно возитися з лічильниками.

 $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

Bash, 124 байти (112 символів)

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

Проба зразка:

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

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

bash-4.3$ bash ascii-arch.sh 0

Japt -R , 29 байт

Використання +& -. Пожертвував 4 байти, щоб обробити криваву перевірку введення!

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

Спробуй це

Пояснення

                                  :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

JavaScript (ES6), 101 символ

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:""

Пояснення

Рекурсивна функція, яка друкує кожен рядок

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

Тест

Тест не використовує параметр за замовчуванням для сумісності браузера.

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

<input type="number" oninput="result.textContent=solution(+this.value)" />
<pre id="result"></pre>

PHP (109 символів)

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

Досі потрібно позбутися цього str_repeat, але більшість альтернатив не оброблять мулібайтові символи.

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

Сітківка , 79 ч

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

Спробуйте в Інтернеті.

Для цього використовується нова функція в Retina, яка замінює десятковий номер \d+списком такої кількості символів $0$*═.

Швидкий (209 байт)

Можливо, Свіфт - це не найкраща мова для цього. Це вперше я намагаюся зробити завдання з гольфу з кодом:

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)

Ruby, 90 байт (74 символи)

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

Проба зразка:

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 

Haskell, 151 162 байт

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

Редагувати: я забув розглянути 0як вхід

𝔼𝕊𝕄𝕚𝕟, 54 символів / 95 байт

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

Try it here (Firefox only).

Пояснення

⩥ïⓜᵖ⟮ ⍘|ď⟯$+`+⦃⟮⍘-ď (ï⟯-$)*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

ПРИМІТКА. Це використовує хороші блоки копіювання ol, щоб потрапити на місця, де звичайна змінна заява не могла дістатися.

Sed, 97 байт (81 символ)

(96 байт (80 символів) код + 1 символ командного рядка)

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

Вхід очікується як одиничний ціле число.

Проба зразка:

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 байт (75 символів)

(104 байти (74 символи) код + 1 символ командного рядка)

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

Вхід очікується як одиничний ціле число.

Проба зразка:

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//' <<< ''

Полотно , 15 байт

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

Спробуйте тут!

Пояснення:

{    ]            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