ASCII मेहराब का निर्माण

Question

मुझे अस्सी की कला पसंद है और मैं बहुत ऊब गया हूं, इसलिए मुझे कुछ अस्की किरदार मिले और बेतरतीब चीजें, 8-बिट मारिओ कैसल, मेज़ और मेहराब बनाने शुरू किए। मैंने पाया कि मेहराब को बड़े करीने से आसानी से ढेर किया जा सकता है।

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

चुनौती

एक प्रोग्राम, फ़ंक्शन, या कोई अन्य मानक प्रारूप बनाएं जो एक पूर्णांक को स्वीकार करता है जो 0 से अधिक या इसके बराबर है (जब तक कि आप बोनस नहीं कर रहे हैं) और निर्दिष्ट किए गए मेहराब की मात्रा के साथ एससीआई कला को आउटपुट करता है।

परीक्षण के मामलों

इनपुट:

7

आउटपुट:

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

Alt:

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

इनपुट:

1

आउटपुट:

╔═╗
╨─╨

Alt:

+-+
| |
---

• यदि पूर्णांक 0 है तो कुछ भी आउटपुट न करें
• यह प्रश्न utf-8 में होगा, प्रत्येक वर्ण "बाइट" के रूप में गिना जाएगा
• यह कोडगोल्फ है इसलिए सबसे छोटा उत्तर जीतता है।
• आप का उपयोग करने का विकल्प होता है +-+करने के बजाय ╔═╗, ---के बजाय ╨─╨, और |के बजाय║

बोनस (यह तय नहीं किया गया कि वैकल्पिक संस्करण पर इसे अनुमति दी जाए क्योंकि यह उतना कठिन नहीं होगा)

-10% अगर प्रोग्राम नेगेटिव नंबर्स को सपोर्ट करता है और मेहराब को फ्लिप करता है

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

Comments

AFAIK वे ASCII वर्ण नहीं हैं। यूनिकोड-कला

— दोष

वेल्ड, @flawr आप सही हैं। अब क्या है ...

— जुआनपोटेटो

दुनिया ढहने वाली है! चिंता न करें, शायद केवल यह उल्लेख करें कि वे मानक ASCII का हिस्सा नहीं हैं, लेकिन

— एससीआई

हालांकि, विस्तारित ASCII जैसा दिखता है, इसलिए आप शायद ठीक हैं।

— मामा फन रोल

@ @ विस्तारित ASCII का कोई मानक संस्करण नहीं है en.wikipedia.org/wiki/Extended_ASCII निकटतम बात यह है कि कोडपेज 437 en.wikipedia.org/wiki/Code_page_437 है जो संयुक्त राज्य अमेरिका और कई अन्य देशों में मानक है लेकिन मुझे लगता है कि जब मुझे पता चलता है इसे एक कोडपेज 437 एडिटर में कॉपी और पेस्ट करें और विंडोज़ में इसे "इंटरप्रिट्स" के रूप +---+में शीर्ष, पक्षों |और नीचे के साथ मेहराब के रूप में "व्याख्या" करता है -----जो मुझे ठीक लगता है। जुआनपोटैटो, यदि आप गैर-एस्की पात्रों का उपयोग करना चाहते हैं, तो कृपया प्रश्न में एन्कोडिंग का संकेत दें। जैसा कि यह खड़ा है कि मैं अस्पष्ट के रूप में बंद करने के लिए मतदान कर रहा हूं।

— लेवल रिवर सेंट

Answer 1

सीजेएम, 59 बाइट्स

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

यहाँ यह कोशिश करो!

Comments

अब आप + - | का उपयोग कर सकते हैं मेहराब बनाने के लिए, उदाहरण के लिए op देखें।

— जुआनपोटेटो

Answer 2

अजगर 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+='║', लेकिन क्षैतिज पट्टियों के लिए भी सूचकांक का उपयोग किया जाता है।

Comments

अब आप +-|मेहराब बनाने के लिए उपयोग कर सकते हैं , उदाहरण के लिए ऑप देख सकते हैं।

— जुआनपोटेटो

@JuanPotato ओपी मूल पोस्टर के लिए खड़ा है। क्या आपका मतलब सवाल है?

— Addison Crump

@flagasspam हाँ, मैंने अभी-अभी उपयोग किया है जहाँ इसका मूल अर्थ है

— जुआनपोटेटो

Answer 3

पर्ल, 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

Comments

मुझे लगता है कि यह ─n = 0 के लिए एक प्रिंट करता है , लेकिन इसे कुछ भी नहीं छापना चाहिए।

— लिन

@ मौरिस मैं सिर्फ इसे चलाता था और आप सही हैं

— जुआनपोटेटो

@ मोरिस डांग! आप बिल्कुल सही कह रहे है। मेरा मूल संस्करण ठीक था, लेकिन कहीं-कहीं लाइन के साथ मैंने चेक खो दिया। 4 चरों की कीमत पर तय किया गया। इस बात के लिए धन्यवाद।

— type_outcast

मुझे पता है कि यह पुराना है, लेकिन @ एबिगेल की टिप्पणी में जोड़ने के लिए, आप बाइट्स का उपयोग करके -nभी बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

Answer 4

बैश, 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

Answer 5

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

Comments

इनपुट पर विफल रहता है0

— dzaima

@ दज़िमा, तुम्हारा क्या मतलब है? आपके पास आकार 0 का आर्च कैसे हो सकता है?

— झबरा

If the integer is 0 then don't output anythingचुनौती से: /

— dzaima

@ दज़िमा, ओह, मुझे वह याद आया। धन्यवाद। सबसे पहले: इनपुट सत्यापन के लिए बू-कलश! दूसरे, जाप कुछ भी उत्पादन नहीं कर सकता है - मैं कुछ बाइट्स की कीमत पर आउटपुट या एक खाली स्ट्रिंग कर सकता हूं 0, falseलेकिन मुझे नहीं पता कि उनमें से कोई भी स्वीकार्य होगा, शायद, खाली स्ट्रिंग, जिसकी कीमत मुझे 5 बाइट्स होगी ( 0केवल मेरी लागत 1) होगी।

— झबरा

Answer 6

जावास्क्रिप्ट (ईएस 6), 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>

Answer 7

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;

Answer 8

रेटिना , 79 वर्ण

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

इसे ऑनलाइन आज़माएं।

यह रेटिना में एक नई सुविधा का उपयोग करता है जो एक दशमलव संख्या \d+को कई पात्रों की सूची के साथ बदल देता है $0$*═।

Answer 9

स्विफ्ट (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)

Answer 10

रूबी, 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 

Answer 11

हास्केल, 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इनपुट के रूप में सौदा करना भूल गया

Answer 12

S, 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 'कॉपी ब्लॉक्स का उपयोग करता है जहाँ साधारण चर घोषित नहीं हो सकते।

Answer 13

सैड, 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/═╔╗║/' <<< ''

सैड, 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//' <<< ''

Answer 14

कैनवस , 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