ฉันชอบศิลปะ ascii และฉันเบื่อมากดังนั้นฉันจึงพบตัวละคร ASCII บางตัวและเริ่มทำสิ่งต่าง ๆ ปราสาทมาริโอ 8 บิตเขาวงกตและโค้ง ฉันพบว่าส่วนโค้งสามารถวางซ้อนกันได้อย่างง่ายดาย

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

ท้าทาย

สร้างโปรแกรมฟังก์ชั่นหรือรูปแบบมาตรฐานอื่น ๆ ที่รับจำนวนเต็มมากกว่าหรือเท่ากับ 0 (เว้นแต่ว่าคุณกำลังทำโบนัส) และเอาท์พุท ASCII art ตามจำนวนซุ้มประตูที่ระบุ

กรณีทดสอบ

การป้อนข้อมูล:

7

เอาท์พุท:

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

สำรอง:

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

การป้อนข้อมูล:

1

เอาท์พุท:

╔═╗
╨─╨

สำรอง:

+-+
| |
---

• ถ้าจำนวนเต็มเป็น 0 อย่าเอาท์พุทอะไรเลย
• คำถามนี้จะอยู่ใน utf-8 อักขระแต่ละตัวจะถูกนับเป็น "byte"
• นี่คือcodegolfดังนั้นคำตอบที่สั้นที่สุดชนะ
• คุณมีตัวเลือกของการใช้+-+แทน╔═╗, ---แทน╨─╨และ|แทน║

โบนัส (ไม่ได้ตัดสินใจว่าจะอนุญาตให้ใช้กับรุ่นอื่นหรือไม่เพราะจะไม่เป็นเรื่องยาก)

-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+='║'แต่ดัชนีใช้สำหรับแถบแนวนอนด้วย

Perl, 78 82 ตัวอักษร

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

น่าเศร้าที่ฉันไม่สามารถหาวิธีที่จะใช้ประโยชน์จากโบนัสโดยไม่เพิ่มขนาดได้มากกว่า 10% ฉันอาจจะชนะ

Ungolfed

ค่อนข้างตรงไปตรงมาจริงๆ สร้างบรรทัดล่าง ( ╨$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 นั้น แต่ทางเลือกส่วนใหญ่จะไม่จัดการกับตัวอักษร 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;

จอประสาทตา 79 ตัวอักษร

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

ลองออนไลน์

นี้ใช้คุณลักษณะใหม่ในจอประสาทตาที่มาแทนที่ตัวเลขทศนิยมที่มีรายชื่อของตัวละครหลาย\d+ ๆ$0$*═

Swift (209 ไบต์)

Probably Swift ไม่ใช่ภาษาที่ดีที่สุดสำหรับสิ่งนี้นี่เป็นครั้งแรกที่ฉันพยายามทำรหัสกอล์ฟที่ท้าทาย:

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

หมายเหตุ: นี่ใช้ประโยชน์จากบล็อกสำเนาที่ดีเพื่อให้ได้จุดที่ตัวแปรธรรมดาไม่สามารถประกาศได้

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

Canvas ขนาด 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