19

गैर-नकारात्मक पूर्णांक की दो सूचियां लें, और ASCII- बॉक्स को आउटपुट करें क्योंकि यह नीचे परिभाषित है।

कोनों और चौराहों प्लसस हैं: +(ASCII-code 43)
ऊर्ध्वाधर लाइनें बार हैं |(एएससीआईआई-कोड 124)
क्षैतिज रेखाएँ मिनीस -(ASCII-code 45) हैं

पहली इनपुट सूची क्षैतिज दिशा में, प्रत्येक प्लस चिह्न के बीच की संख्या को निर्दिष्ट करती है।

दूसरी इनपुट सूची ऊर्ध्वाधर दिशा में, प्रत्येक प्लस चिह्न के बीच सलाखों की संख्या निर्दिष्ट करती है।

कुछ उदाहरणों के साथ समझाना आसान है:

0    // No minuses between each + sign
0    // No bars between + signs

++
++

------------------
1 2   // First a single minus, then two minuses 
1 2   // First  one bar, then two bars

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


------------------
1 0 3 0 2 0
2 1 0 0

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

स्पष्टीकरण:

इनपुट ऑर्डर और प्रारूप वैकल्पिक हैं
केवल बक्सों को मुद्रित / प्रदर्शित किया जाना चाहिए, लेकिन एक अनुगामी स्थान या नए सिरे को स्वीकार किया जाता है।
यदि आप अधिक सुविधाजनक हैं, तो आप वैकल्पिक रूप से सभी इनपुट मानों में 1 जोड़ सकते हैं। दूसरा उदाहरण तब होगा 2 3; 2 3:।

यह कोड गोल्फ है, इसलिए बाइट्स जीतने वाला सबसे छोटा कोड है।

code-golf ascii-art

— स्टीवी ग्रिफिन
स्रोत

संबंधित: codegolf.stackexchange.com/questions/70377/ascii-box-rendering

— 12Me21

5

MATL , 25 22 21 बाइट्स

'|-+ '2:"1tiYsQ(]E!+)

1जोड़ा के साथ इनपुट का उपयोग करता है (चुनौती द्वारा अनुमत)।

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

व्याख्या

कोड शुरू 1में अंतिम परिणाम में गैर-अंतरिक्ष वर्णों के स्तंभ सूचकांकों के लिए एक सरणी बनाता है , और 0अन्यथा। तो अगर पहला इनपुट है [2 1 4 1 3 1]( [1 0 3 0 2 0]0-आधारित प्रारूप में होगा) यह सरणी होगी

1 0 1 1 0 0 0 1 1 0 0 1 1

ध्यान दें कि शून्य के रन की लंबाई इनपुट से कैसे संबंधित है। विशेष रूप से, इस सरणी को निम्नानुसार बनाया गया है:

सरणी को एकल में प्रारंभ करें 1।
इनपुट के संचयी योग की गणना करें और जोड़ें 1। उदाहरण में यह देता है [3 4 8 9 12 13]।
चरण 2 द्वारा 1दिए गए (1-आधारित) सूचकांकों के साथ प्रविष्टियों को असाइन करके चरण 1 से सरणी बढ़ाएं । मध्यवर्ती प्रविष्टियां स्वचालित रूप से करने के लिए हैं 0।

एक समान सरणी पंक्तियों के लिए बनाई गई है। दूसरा इनपुट [3 2 1 1](या [2 1 0 0 ]) देता है

1 0 0 1 0 1 1 1

अब दूसरे ऐरे को गुणा 2, ट्रांसपोज़्ड और पहले के साथ प्रसारण के साथ जोड़ा गया है। यह 2D सरणी देता है

3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3

स्ट्रिंग में अनुक्रमण '|-+ 'एक 2 डी चार सरणी के रूप में अंतिम परिणाम देता है। चूंकि इंडेक्सिंग मॉड्यूलर और 1-आधारित है, इसलिए इंडेक्स 0अंतिम तत्व (स्पेस) से मेल खाता है।

'|-+ '                   % Push this string
      2:"       ]        % Do this twice
         1               % Push 1 (initial array)
          t              % Push another 1 (contents to be filled in)
           i             % Take input
            Ys           % Cumulative sum
              Q          % Add 1
               (         % Fill 1 into those entries of the array
                 E       % Multiply by 2
                  !      % Transpose
                   +     % Add, with broadcast
                    )    % Index (modular, 1-based) into the string

— लुइस मेंडो
स्रोत

6

पायथन 2, 117 बाइट्स

def f(h,v):r="+"+"+".join("-"*i for i in h)+"+\n";print r+r.join(("|"+"|".join(" "*i for i in h)+"|\n")*i for i in v)+r

इसे आइडोन पर आज़माएं।

इससे बहुत ज्यादा उम्मीद नहीं है। वास्तव में सरल है, बस सब कुछ एक साथ खींचने के लिए अजगर जोड़ और स्ट्रिंग गुणन का उपयोग करता है।

— एससीबी
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 83 बाइट्स

(a,b,g=(a,[s,t])=>t+a.map(n=>s.repeat(n)+t).join``+`
`)=>g(b,[g(a,` |`),g(a,`-+`)])

आउटपुट में दो अनुगामी न्यूलाइन्स शामिल हैं।

— नील
स्रोत

वाह। तो इसी तरह के जवाब लगभग उसी समय पोस्ट किए गए। ;)

— अरनौल्ड

(आपने मुझे 2 मिनट और 2 बाइट्स से हराया, हालांकि।)

— अरनौल्ड

@Arnauld आपने अपने डेमो पर समय बर्बाद किया ;-)

— नील

हां मेरा अनुमान है कि। ^ ^ दिलचस्प बात यह है कि, मेरे संस्करण में दो अनुगामी न्यूलाइन्स के साथ 81 बाइट्स होंगे।

— अरनुलद

2

सीजाम, 50 बाइट्स

0lS/:i0++:H;lS/:i0+{H{'-*}%'+*N+o{H{S*}%'|*N+o}*}%

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

— anOKsquirrel
स्रोत

1

पायथ, 45 बाइट्स

AQj.i*hlH]Js.i*hlG\+m*d\-G-mjb*d]XJ"+-""| "Hk

एक प्रोग्राम जो STDIN पर दो अल्पविराम द्वारा अलग-अलग सूचियों का इनपुट लेता है और परिणाम को प्रिंट करता है।

यहाँ अभी भी कुछ गोल्फ होना बाकी है।

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

स्पष्टीकरण बाद में आ रहा है

— TheBikingViking
स्रोत

1

हास्केल, 55 बाइट्स

f[a,b]x=a:do n<-x;(b<$[1..n])++[a]
g x=f[f"+-"x,f"| "x]

एक फ़ंक्शन को परिभाषित करता है gजो दो इनपुट सूचियों को लेता है और एक सूची देता है जिसमें आउटपुट की लाइनें होती हैं

— डायने
स्रोत

0

PowerShell v2 +, 89 बाइट्स

param($a,$b)($x="+$(($a|%{'-'*$_})-join'+')+")
$b|%{,"|$(($a|%{' '*$_})-join'|')|"*$_;$x}

डांग, मुझे नहीं लगता कि मैं जावास्क्रिप्ट को पकड़ सकता हूं।

इनपुट $aऔर $bस्पष्ट सरणियों के रूप में लेता है । चर के $xमाध्यम से $aऔर कुछ स्ट्रिंग संघनन के आधार पर बक्से की शीर्ष पंक्ति होने के लिए चर सेट करता है । इसलिए इसे पाइप लाइन में रखा गया है। फिर, हम लूप के माध्यम $bसे पाइप लाइन पर दो तार डालते हैं - एक ही स्टाइल स्ट्रिंग लेकिन रिक्त स्थान के |बजाय और हाइफ़न +और $x। उन तारों को Write-Outputप्रोग्राम पूरा होने पर निहित के साथ पाइप लाइन से इकट्ठा किया जाता है , उनके बीच डिफ़ॉल्ट नईलाइन के साथ।

उदाहरण

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(0) @(0)
++
++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,0,3,0,2,0) @(2,1,0,0)
+-++---++--++
| ||   ||  ||
| ||   ||  ||
+-++---++--++
| ||   ||  ||
+-++---++--++
+-++---++--++
+-++---++--++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,4,1) @(1,2,1)
+-+----+-+
| |    | |
+-+----+-+
| |    | |
| |    | |
+-+----+-+
| |    | |
+-+----+-+

— AdmBorkBork
स्रोत

0

रूबी, 66 बाइट्स

->x,y{d=->c,m,z=x{c+z.map{|w|m*w}*c+c+$/}
d[d[?+,?-],d[?|,' '],y]}

— एम-Chrzan
स्रोत

0

जेली , 30 26 बाइट्स

Ḣị“+-“| ”ị@
1;+\Ṭ
Ç€,€/Ñ€Y

यह TryItOnline पर परीक्षण करें

कैसे?

लिया गया इनपुट दो सूचियों की एक सूची है [vertical, horizontal], और बढ़े हुए विकल्प का उपयोग करता है
- इसलिए उदाहरण 3 लेता [[3,2,1,1], [2,1,4,1,3,1]]
है इनमें से प्रत्येक को फिर एक बूलियन सरणी में परिवर्तित किया जाता है जो क्रमशः rowType या rowCharacterType का संकेत देता है, जैसे [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
बक्से तब पंक्तियों को बनाने से निर्मित होते हैं। rowType और rowCharacterType संयोजनों द्वारा पहचाने जाने वाले वर्ण - यानी एक rowType "+-"या तो पहचानता है या "| "एक rowCharacterType उन दो वर्णों में से किसी एक की पहचान करता है।

Ḣị“+-“| ”ị@ - Link 1, create a row: [rowType, [rowCharaterTypes]]
Ḣ           - head - get the rowType
  “+-“| ”   - list of strings ["+-", "| "]
 ị          - index into (if rowType is 1 "+-"; if rowType is 0 "| ")
         ị@ - index into with reversed operands (index into that from rowCharaterTypes)
                (replace each 1 in rowCharaters with "+" or "|" and each 0 with "-" or " ")

1;+\Ṭ - Link 2, create the Type lists from the inputs: int[] nCharacters
1;    - 1 concatenated with the input
  +\  - reduce with addition (accumulation provides the indices)
    Ṭ - boolean array with 1s at those indices
            As an example take the vertical of example 3:
            [3,2,1,1] -> [1,3,2,1,1] -> [1,4,6,7,8] -> [1,0,0,1,0,1,1,1]
            each of which will be passed as a rowType for Link 1

Ç€,€/Ñ€Y - Main link, takes one argument: [Vertical, Horizontal] (incremented option)
Ç€       - call the last link (2) for each of the two lists in the input
  ,€/    - pair each and reduce (making a list of [rowtype [rowCharacterTypes]])
     Ñ€  - call the next link (1) for each
       Y - join on line feeds

— जोनाथन एलन
स्रोत

कुछ ASCII- बॉक्स ड्रा करें