क्षैतिज रूप से संरेखित ASCII कला

Question

आपका कार्य इनपुट दो "एएससीआईआई आर्ट" के रूप में स्वीकार करना है, और क्षैतिज रूप से एक दूसरे के बगल में कला के प्रत्येक टुकड़े को संरेखित करना है।

उदाहरण के लिए, मान लें कि आपके पास दो तार हैं, "abc\ndef"और "123\n456"। स्ट्रिंग का निर्माण करने के लिए आपको उन्हें क्षैतिज रूप से संरेखित करने की आवश्यकता है "abc123\ndef456"। मैं इसे" क्षैतिज रूप से संरेखित कर रहा हूं "कह रहा हूं क्योंकि जब इनपुट, मुद्रित होते हैं, तो इस तरह दिखते हैं:

abc
def

तथा:

123
456

प्रिंट होने पर आउटपुट, इस तरह दिखेगा:

abc123
def456

ध्यान दें कि एक इनपुट दूसरे के बगल में कैसे रखा गया है।

---

इनपुट

• इनपुट स्ट्रिंग्स होगा, और दो अलग-अलग तर्क हो सकते हैं, या स्ट्रिंग्स के अनुक्रम के रूप में।
• कला के पात्रों में 32-126 (समावेशी) रेंज में दशमलव कोड होंगे।
• केवल दो के बजाय संरेखित करने के लिए कला की एक मनमानी संख्या का समर्थन करना ठीक है (लेकिन स्पष्ट रूप से आपको कम से कम दो का समर्थन करना होगा)।
• आप मान सकते हैं कि प्रत्येक कला में समान आयाम होंगे, और उनमें कम से कम एक रेखा होगी।

• आपको कम से कम 100x100 वर्ण कला का समर्थन करने में सक्षम होना चाहिए।

• साइट पर सम्मेलनों के साथ संरेखित करने के लिए, तर्क आदेश कोई फर्क नहीं पड़ता। इससे कोई फर्क नहीं पड़ता कि कौन सी कला बाईं या दाईं ओर है।

---

उत्पादन

• आउटपुट संरेखित कला होगी जैसा कि ऊपर उल्लेख किया गया है, या तो स्टडआउट पर लौटा या आउटपुट।

• वैकल्पिक में कोई अनुगामी व्हाट्सएप।

• संरेखित कलाओं के बीच कोई दृश्य विभाजक नहीं होना चाहिए।

---

इनपुट और आउटपुट आर्ट्स स्ट्रींग \nया \rसीमांकित होनी चाहिए । यह 2D-सरणियों की अनुमति देने के लिए अत्यधिक तुच्छ होगा।

प्रस्तुतियाँ कार्य या पूर्ण कार्यक्रम हो सकती हैं।

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

"abc\ndef", "123\n456" -> "abc123\ndef456".

"qwertyuiop\n asdfghjkl", "Some other\nTextFiller" -> "qwertyuiopSome other\n asdfghjklTextFiller"

"  *  \n *** \n*****\n *** \n  *  \n", "  +  \n  +  \n+++++\n  +  \n  +  \n" -> "  *    +  \n ***   +  \n*****+++++\n ***   +  \n  *    +  \n"

Comments

क्या हम नई सुर्खियों के बजाय एक कस्टम सीमांकक का उपयोग कर सकते हैं? यानी "|"या " "?

— R

मैं कह रहा हूँ कि किसी भी कला को बर्बाद करने की तरह नहीं दिया जाएगा।

— Carcigenicate

क्या हम \rइसके बजाय उपयोग कर सकते हैं \n?

— एडम

@ Adám ज़रूर। मैं शब्दांकन अद्यतन करूँगा।

— कार्सिनेट

क्या प्रमुख व्हाट्सएप ठीक है?

— आदम

Answer 1

कैनवस , 1 बाइट

×

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

Comments

कारण जो इसके लिए एक बिल्टिन नहीं है ? : P

— caird coinheringaahing

वह भी उचित नहीं है। ; -;

— 15

PPCG पर @KevinCruijssen यह आम तौर पर जो भी आप चाहते हैं कि इनपुट लेने की अनुमति है, और स्टैक-आधारित भाषा के लिए वर्तमान ऑर्डर रिवर्स की तुलना में अधिक समझ में आता है।

— द्विजिमा

@KevinCruijssen हालांकि मुझे सिर्फ इतना याद है कि मेरे पास रिवर्स ऐड के लिए बिल्ट-इन है, इसलिए मैं पोस्ट अपडेट कर रहा हूं: p

— dzaima

तो कैनवस के पास इसके लिए दो भवन हैं? ठीक है क्यों नहीं?

— केयर्ड संथैराहिंगिंग

Answer 2

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

(unlines.).(.lines).zipWith(++).lines

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

लाइनों की सूची के रूप में IO बस होगा zipWith(++)। : पी

Answer 3

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

lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))

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

Comments

अंतरिक्ष को हटाकर इसे छोटा भी किया जा सकता है। : पी

— बिलकुल अमानवीय

यदि आप लाइनों की इनपुट और आउटपुट सूची चाहते हैं, जैसा कि आपने पहले किया था, तो आप इसे 30 तक ले सकते हैं: इसे ऑनलाइन आज़माएं!

मैं वहाँ बैठ गया जैसे 5 मिनट यह तय करने की कोशिश कर रहा था कि क्या मुझे इसकी अनुमति देनी चाहिए। जैसा कि हास्केल उत्तर दिखाता है, यह चुनौती को कुछ अधिक तुच्छ बना देगा। मुझे लगता है कि अति तुच्छ समाधान अभी उतना लोकप्रिय नहीं होगा।

— कार्कजेनिकेट

Answer 4

05AB1E , 6 बाइट्स

|¶¡øJ»

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

व्याख्या

|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines

Comments

बहुत खराब जगह के बीच दो आदानों की अनुमति नहीं थी :(।

— मैजिक ऑक्टोपस Urn

Answer 5

जेली , 4 बाइट्स

Ỵ€ZY

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

Answer 6

पर्ल 5 -0F , 28 बाइट्स

शामिल +2के लिए \nकरने के लिए तर्क -F(यह "कोड" तो यह गिनती करना चाहिए)

STDIN पर एक दूसरे के बाद सीधे इनपुट दें।

#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F

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

Answer 7

बैश + कोरुटिल्स, 14

• 4 बाइट्स @DavidFoerster की बदौलत बच गए।

paste -d "" $@

इनपुट को दो फ़ाइल नाम कमांड-लाइन मापदंडों के रूप में दिया गया है।

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

Comments

आप 4 बाइट्स बचा सकते हैं:paste -d "" $@

— डेविड फ़ॉस्टर

@DavidFoerster धन्यवाद! अजीब - मैंने कोशिश की कि पहले और यह काम नहीं किया। संपादित करें - मैं अब देखता हूं - इसके बजाय -d "", मैंने कोशिश की -d"", जो निश्चित रूप से अलग नहीं है-d

— डिजिटल ट्रॉमा

Answer 8

पर्ल 6 , 27 बाइट्स

{join "\n",[Z~] $_>>.lines}

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

कला की मनमानी संख्या के साथ काम करता है। सूची की सूची के रूप में IO सिर्फ होगा &[Z~]।

Answer 9

एपीएल (Dyalog यूनिकोड) , 9 बाइट्स ^SBCS

पूरा कार्यक्रम। किसी भी लंबाई के \rतार की सूची के लिए संकेत (STDIN) । जब तक उनकी पंक्तियों की संख्या समान होती है तब तक तार अलग-अलग हो सकते हैं और विभिन्न चौड़ाई के हो सकते हैं। प्रिंट्स (STDOUT) परिणामस्वरूप ASCII कला।

⊃,/⎕FMT¨⎕

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

⎕ मूल्यांकन किए गए इनपुट के लिए संकेत

⎕FMT¨ प्रारूप (सभी नियंत्रण वर्णों का मूल्यांकन करें और वर्ण मैट्रिक्स लौटाएं) प्रत्येक

,/ उन्हें क्षैतिज रूप से संयोजित करें (कटाव में कमी)

⊃ खुलासा (क्योंकि कमी ने रैंक को 1 से घटाकर 0 कर दिया)

Answer 10

जावा 8, 100 84 78 बाइट्स

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}

ArrayIndexOutOfBoundsExceptionSTDERR के साथ एक से बाहर निकलता है क्योंकि यह परिणाम STDOUT को मुद्रित करता है, जिसकी अनुमति है ।

-6 बाइट्स @ OlivierGrégoire को धन्यवाद ।

स्पष्टीकरण:

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

a->b->{                        // Method with two String parameters and no return-type
  for(int i=0;;)               //  Loop over the substrings of the first input
    System.out.println(        //   Print:
     a.split("\n")[i]          //    The substring of the first input
     +b.split("\n")[i++]);}    //    plus the same-indexed substring of the second input

Comments

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}78 बाइट्स। अतिरिक्त साइड-इफेक्ट न होने के बारे में कुछ भी नहीं कहा जाता है। इसलिए हम केवल एक अपवाद होने तक गिन सकते हैं।

— ओलिवियर ग्रेजायर

@ OlivierGrégoire धन्यवाद! और STDERR के लिए एक त्रुटि के साथ बाहर निकलना वास्तव में अनुमति देता है क्योंकि यह सब कुछ STDOUT को मुद्रित करता है।

— केविन क्रूज़सेन

Answer 11

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

->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}

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

एक मेमना दो तार लेकर और एक स्ट्रिंग वापस कर रहा है। डिफ़ॉल्ट सेट करनाsplit सीमांकक को नईलाइन पर करने से $;=$/;कोई बाइट नहीं बचती है, लेकिन यह बाकी को थोड़ा अच्छा बना देता है।

माणिक , 49 बाइट्स (मनमाने ढंग से कई तार)

->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}

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

सिर्फ मनोरंजन के लिए। यह पता चला है कि हम केवल 1 बाइट की अतिरिक्त लागत पर स्ट्रिंग्स की एक सरणी को स्वीकार कर सकते हैं।

Answer 12

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

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")

Answer 13

आश्चर्य है , 21 बाइट्स

->#oN.zip#++.-> <>"
"

उपयोग उदाहरण:

(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]

#n के बजाय प्रयोग किया जाता है \n नई सूचियों को दर्शाने लिए किया जाता है।

व्याख्या

वर्बोज़ संस्करण:

(map #oN) . (zip #con) . (map split "#n")

नई सरणी के साथ इनपुट ऐरे में प्रत्येक स्ट्रिंग को विभाजित करें, स्ट्रिंग समवर्ती के साथ ज़िप करें, और प्रत्येक आइटम को आउटपुट करें।

Answer 14

कोटलिन , 73 बाइट्स

a,b->a.split("\n").mapIndexed{i,s->s+b.split("\n")[i]}.joinToString("\n")

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

Answer 15

++ , 24 बाइट्स जोड़ें

L,c10CdVAptA$pG$tBcB@£+n

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

Answer 16

सी, 96 बाइट्स

#define L(s)for(;*s++>10;)putchar(s[-1]);
i;f(s,t)char*s,*t;{for(;i=!!s[-i];puts("")){L(s)L(t)}}

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

Answer 17

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

करी सिंटैक्स में इनपुट लेता है (a)(b)।

a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`

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

Answer 18

जूलिया 0.6 , 41 बाइट्स

(a,b)->map(*,split(a,'\n'),split(b,'\n'))

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

Answer 19

पॉवरशेल , 51 49 बाइट्स

param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}

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

नई कहानियों के साथ शाब्दिक तार के रूप में इनपुट लेता है। आप इसके बजाय `n(PowerShell में newline सीमांकक का उपयोग नहीं कर सकते हैं \n)।

हम सबसे पहले -splitनई कथानक पर बायाँ इनपुट स्ट्रिंग बनाते हैं, जो उसी के माध्यम से एक सरणी और लूप बनाता है|%{...} । प्रत्येक पुनरावृत्ति, हम सही इनपुट स्ट्रिंग के साथ नए सिरे से विभाजित करते हैं, फिर से नई सूचियों, अनुक्रमित और बढ़े हुए पर विभाजित करते हैं।

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

Answer 20

APL (Dyalog Unicode) , 22 बाइट्स ( Adám's SBCS )

{⊃,/↑¨⍵}'[^\n]+'⎕S'&'¨

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

Answer 21

लाल , 78 बाइट्स

func[a b][b: split b"^/"foreach c split a"^/"[prin c print first b b: next b]]

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

Answer 22

जाप -R , 8 7 बाइट्स

·íV· m¬

कोशिश करो

---

व्याख्या

             :Implicit input of strings U & V
·            :Split U on newlines
  V·         :Split V on newlines
 í           :Interleave
     m       :Map
      ¬      :  Join
             :Implicitly join with newlines and output

---

विकल्प

·Ë+V·gE

कोशिश करो

             :Implicit input of strings U & V
·            :Split U on newlines
 Ë           :Map over each element at index E and rejoin with newlines
   V·        :  Split V on newlines
     gE      :  Get the element at index E
  +          :  Append to the current element
             :Implicitly join with newlines and output

Answer 23

बैश , 92 बाइट्स

a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"

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

Ungolfed:

array=()                             # Initialize the array
for argument in "${@}"; do           # Loop over the arguments list
  index='0'                          # Reset the index
  while IFS='' read -r 'line'; do    # Loop over every line of the current argument
    array[index]+="${line}"          # Append the line to its corresponding place
    (( index++ ))                    # Increment the index
  done <<< "${argument}"             # End while loop
done                                 # End for loop
printf '%s\n' "${array[@]}"          # Print array's content

उदाहरण:

$ foo $'abc\ndef' $'123\n456'
abc123
def456

$ foo $'qwertyuiop\n asdfghjkl' $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

$ foo \
>   $'  *  \n *** \n*****\n *** \n  *  \n' \
>   $'  +  \n  +  \n+++++\n  +  \n  +  \n'
  *    +  
 ***   +  
*****+++++
 ***   +  
  *    +  


# https://gist.github.com/nxnev/dad0576be7eb2996b860c320c01d0ec5
$ foo "$(< input1)" "$(< input2)" "$(< input3)" > output

---

मेरे पास एक छोटा भी है, लेकिन यह असफल हो जाता है यदि दूसरा readकथन एक गैर-शून्य मान लौटाता है।

बैश , 55 बाइट्स

while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done

नोट: tio.run<&3 पर काम नहीं कर रहा है

यह एक तर्क के बजाय फ़ाइल डिस्क्रिप्टर ( 1और 3) का उपयोग करता है:

$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

Answer 24

चारकोल , 8 बाइट्स

ＰθＭ⌕θ¶→η

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input

कई इनपुट्स को स्वीकार करने के लिए 2 बाइट्स जोड़ें:

ＦＡ«ＰιＭ⌕ι¶→

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry

अनपेड इनपुट स्वीकार करने के लिए 4 बाइट्स जोड़ें:

ＰθＭ⌈Ｅ⪪θ¶Ｌι→η

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right

Answer 25

जावास्क्रिप्ट (Node.js) , 79 बाइट्स

a=>(b=a.map(x=>x.split`
`))[i=0].map(y=>b.map(z=>c+=z[i],c="")&&++i&&c).join`
`

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

केवल 2 के बजाय एक साथ जुड़ने वाले ASCII कला की मनमानी संख्या का समर्थन करता है (जैसा कि 2 पिछले जेएस उत्तरों में है)।

Answer 26

क्लीन , 61 बाइट्स

import StdEnv
$a b=flatlines[u++v\\u<-mklines a&v<-mklines b]

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

Answer 27

स्विफ्ट 4 , 119 बाइट्स

func f(s:[String])->String{return s[0].split{$0=="\n"}.enumerated().map{$0.1+s[1].split{$0=="\n"}[$0.0]+"\n"}.joined()}

व्याख्या

func f(s: [String]) -> String {
    return s[0].split{ $0=="\n" }       //splitting the first string after every \n
    .enumerated()                       //create a tuple of offsets and elements
    .map {
        $0.1 +                          //current element
        s[1].split{$0 == "\n"}[$0.0] +  //splitting the second string + indexing
        "\n"                            //new line after every line
     }
     .joined()
}

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