स्ट्रिंग-ब्लॉक ओवरलैपिंग

Question

चुनौती:

मल्टी-लाइन स्ट्रिंग्स की एक सूची को देखते हुए, उन्हें ओवरलैप करें (शीर्ष-बाएं में) और परिणाम को आउटपुट करें।

उदाहरण:

इनपुट: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
आउटपुट:

cbaa
bbaa
bbaa
aaaa

चुनौती नियम:

• इनपुट-प्रारूप लचीला है। आपको इनपुट को लाइनों की 2 डी सूची (यानी [["aaaa","aaaa","aaaa","aaaa"],["bb","bb","bb"],["c"]]) या 3 डी पात्रों की सूची (यानी ) के रूप में प्राप्त करने की अनुमति है [[["a","a","a","a"],["a","a","a","a"],["a","a","a","a"],["a","a","a","a"]],[["b","b"],["b","b"],["b","b"]],[["c"]]]। आपको STDIN के माध्यम से एक-एक करके सभी इनपुट लेने की अनुमति है। आदि।
• आउटपुट स्वरूप सख्त है। आप मल्टी-लाइन स्ट्रिंग को प्रिंट या वापस करने का विकल्प चुन सकते हैं। (यदि आपकी भाषा में कोई तार नहीं है, तो वर्णों की 2 डी सूची के रूप में आउटपुट को विकल्प के रूप में अनुमति दी जाती है। लेकिन केवल तभी जब आपकी भाषा में तार न हों।)
• इनपुट-सूची का क्रम निश्चित रूप से महत्वपूर्ण है (लेकिन यदि आप चुनते हैं तो आपको इनपुट को रिवर्स में लेने की अनुमति है)।
• इनपुट में केवल यूनिकोड रेंज ( ) में मुद्रण योग्य ASCII होगा ।$[33,126]$!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
• इनपुट केवल आयताकार होंगे (इसलिए कोई अजीब आकार नहीं)। आउटपुट आवश्यक आयत नहीं हैं, हालांकि।
• अनुगामी रिक्त स्थान और एक एकल अनुगामी न्यूलाइन की अनुमति है। लीडिंग स्पेस और / या न्यूलाइन्स नहीं।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट ढीले निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

इनपुट: ["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]
आउटपुट:

cbaa
bbaa
bbaa
aaaa

इनपुट: ["12345\n54321","00\n00\n00\n00","001\n011\n012"]
आउटपुट:

00145
01121
012
00

इनपुट: ["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]
आउटपुट:

this%^
is_a_+
testty
uiopas
t!
h_
i_
n_
g_

Comments

अनुगामी newlines की अनुमति है? या अधिक विशेष रूप से, अनुगामी न्यूलाइन्स की एक मनमानी राशि की अनुमति है?

— जद

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

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

Answer 1

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

a/Y

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

थोड़ी देर में जेली का इस्तेमाल नहीं किया था, लेकिन मुझे लगा कि टिप्पणियों में चुनौती पीटने योग्य थी। बहुत सीधे aइनपुट के प्रत्येक तत्व ( /) के बीच स्टैकिंग ऑपरेशन करने के लिए तार्किक और ( ) का उपयोग करता है । Yका उपयोग आवश्यक प्रारूप में प्रिंट करने के लिए किया जाता है।

Comments

बहुत सुंदर! मैं जैली tbh के साथ बहुत बुरा हूँ। मेरा तैयार समाधान ḷ""/Yउलट इनपुट-सूची के साथ था । के बारे में भी नहीं पता था a..

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

Answer 2

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

2 बाइट्स @Grimy की बदौलत सहेजे गए

मान लें कि लौटा स्ट्रिंग एक टर्मिनल पर मुद्रित होता है जो ANSI एस्केप कोड का समर्थन करता है । इसमें वर्णनीय चरित्र होता है ESC, जो \x1Bनीचे के रूप में बच जाता है।

a=>`\x1B[2J\x1B[H`+a.join`\x1B[H`

यह TIO पर काम नहीं करता है, लेकिन आप इसे ऑनलाइन आज़मा सकते हैं ! इसके बजाय कच्चे आउटपुट को देखने के लिए।

कैसे?

सीएसआई दृश्यों का इस्तेमाल किया कर रहे हैं:

• ईडी (प्रदर्शन में मिटा):

  ESC[2J

  जहाँ $2$ अर्थ है "संपूर्ण स्क्रीन साफ़ करें"

• कप (कर्सर स्थिति):

  ESC[H

  जिसका अर्थ है "कर्सर को पंक्ति $n$ , कॉलम $m$ " पर ले जाया जाता है , जहां $n$ और $m$ दोनों को छोड़ दिया गया है और अंतर्निहित रूप से $1$ (स्क्रीन के ऊपरी-बाएँ कोने) पर सेट किया गया है।

उदाहरण आउटपुट

Comments

ECMA-48 आज्ञाकारी टर्मिनल को मानते हुए, आप दोनों को छोड़ सकते हैं ;। इसके अलावा, मुझे लगता है कि यह "जावास्क्रिप्ट + टर्मिनल" या ऐसा ही कुछ होना चाहिए जो शुद्ध जावास्क्रिप्ट के साथ प्रतिस्पर्धा नहीं करता है।

— ग्रिमी

@ ग्रैमी थैंक्स! (रुचि रखने वाले किसी के लिए, यहां ECMA-48 विनिर्देश है - लेकिन मुझे यह नहीं मिला कि यह कहां उल्लेख किया गया है कि अर्धविराम को छोड़ा जा सकता है - यदि यह बिल्कुल उल्लेख किया गया है।)

— Arnauld

5.4.2.h कुछ भ्रमित करने वाला शब्द है, लेकिन दिलचस्प सा है if the last parameter sub-string(s) is empty, the separator preceding it may be omitted:। चूंकि केवल दो उप-स्ट्रिंग्स हैं, अंतिम प्रतिस्थापन से पहले विभाजक एकमात्र है, और इसे छोड़ा जा सकता है।

— ग्रिमी

मुझे एएनएसआई का पता नहीं है, लेकिन पहले \x1B[H+ आवश्यक है? क्या यह डिफ़ॉल्ट रूप से शीर्ष-बाएं से शुरू नहीं हो रहा है, और आपको केवल प्रत्येक इनपुट के बाद इसे रीसेट करने की आवश्यकता है (जो कि इसमें शामिल होता है)? या क्या यह शुरू में डिफ़ॉल्ट रूप से कहीं और शुरू होता है, और आपको स्पष्ट रूप से इसे उस स्थिति में कर्सर से शुरू करना होगा ताकि वह सफलतापूर्वक उस स्थिति में रीसेट हो सके?

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

@Arnauld चूंकि इस फ़ंक्शन को निष्पादित करते समय संभवतः आपके पास हमेशा टर्मिनल पर कुछ और होगा, मुझे लगता है कि सभी के बाद प्रारंभिक रीसेट की आवश्यकता है। के रूप में ommitting प्रिंट के लिए, मुझे लगता है कि f=a=>print(`\x1B[H`+a.join`\x1B[H`)के f(input_here)रूप में एक ही उत्पादन होगा print(f(input_here))? इसलिए मैं नहीं देखता कि आपको क्यों छोड़ना नहीं पड़ेगा printऔर बस एक स्ट्रिंग वापस करना होगा।

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

Answer 3

आर , 120 , 111 110 107 बाइट्स

function(x,`!`=ncol,M=array('',Reduce(pmax,Map(dim,x)))){for(m in x)M[1:!t(m),1:!m]=m
write(t(M),1,!M,,'')}

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

वर्णों की मैट्रिक्स की सूची को स्वीकार करने वाला एक फ़ंक्शन (3 डी इनपुट स्वीकार किया जाता है)।

(जैसा कि आप बाइट गिनती से नोटिस कर सकते हैं, यह आर में करना बहुत आसान नहीं है ...)

• -9 बाइट्स @Giuseppe को धन्यवाद
• -4 बाइट्स @RobinRyder के लिए धन्यवाद

Comments

मैं वास्तव में एक 200 + बाइट समाधान की उम्मीद कर रहा था! मैं जब भी इस सवाल का पात्र हो जाता है एक अच्छा इनाम दे रहा हूँ

— Giuseppe

@Giuseppe: अभी भी अन्य भाषाओं की तुलना में अधिक ... :(

— digEmAll

111 बाइट्स केarray बजाय का उपयोग कर matrix!

— ग्यूसेप

@ गुइसेप: साफ!

— digEmAll

107 के लिए एक उपनाम के साथ ncol(आप प्राप्त करने के लिए स्थानांतरित कर सकते हैं nrow)।

— रॉबिन राइडर

Answer 4

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

n,f=None,filter
for l in map(n,*input()):print''.join(f(n,x)[-1]for x in map(n,*f(n,l)))

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

---

स्पष्टीकरण (उदाहरण के साथ):

इनपुट के रूप में एक 2D सूची लेता है।

Input: [["12345","54321"],["00","00","00","00"],["001","011","012"]]

प्रत्येक इनपुट आयत की पंक्तियों को प्राप्त करने के लिए पहले इनपुट सूची को ज़िप किया जाता है ( map(None,l)यह एक ज़िप सबसे लंबा है):

map(n,*input())   gives:

('12345', '00', '001')
('54321', '00', '011')
(None, '00', '012')
(None, '00', None)

इन पंक्तियों में से प्रत्येक को हटाए गए Nones पर फ़िल्टर्ड किया जाता है , और फिर से ज़िप किया जाता है:

map(None,*filter(None,l))

filter(None,l) for each l gives:

('12345', '00', '001')
('54321', '00', '011')
('00', '012')
('00',)

map*... gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', None, '1'), ('4', None, None), ('5', None, None)]
[('5', '0', '0'), ('4', '0', '1'), ('3', None, '1'), ('2', None, None), ('1', None, None)]
[('0', '0'), ('0', '1'), (None, '2')]
['0', '0']

जो वांछित परिणाम की प्रत्येक स्थिति के लिए वर्णों की एक सूची है। इन सूचियों को फिर से फ़िल्टर्ड किया जाता है, और पिछले एक को लिया जाता है:

filter(None,x)   gives:

[('1', '0', '0'), ('2', '0', '0'), ('3', '1'), ('4',), ('5',)]
[('5', '0', '0'), ('4', '0', '1'), ('3', '1'), ('2',), ('1',)]
[('0', '0'), ('0', '1'), ('2',)]
['0', '0']

and with [-1]:

['0', '0', '1', '4', '5']
['0', '1', '1', '2', '1']
['0', '1', '2']
['0', '0']

अंत में परिणामी सूचियाँ शामिल हो जाती हैं और मुद्रित हो जाती हैं:

print''.join(..)

00145
01121
012
00

Comments

आरई "स्ट्रिंग्स की सूची लौटाता है", नियम बताता है कि "आउटपुट स्वरूप सख्त है। आप मल्टी-लाइन स्ट्रिंग को प्रिंट या वापस करना चुन सकते हैं। 2 डी या 3 डी सूचियों को आउटपुट की अनुमति नहीं है।" 88 बाइट का पूरा कार्यक्रम हालांकि ठीक लगता है

— जोनाथन एलन

@

— जोनाथनअल्लन

Answer 5

आर, 107 97 बाइट्स

function(x)for(i in 1:max(lengths(x))){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

TIO पर काम नहीं करता है, जो \rगाड़ी के रिटर्न चरित्र के उपयोग से संबंधित हो सकता है । यह आर के मेरे स्थानीय स्थापना पर काम करता है।

पंक्तियों के वेक्टर वाली सूची के रूप में इनपुट लेता है:

x <- list(c("aaaa","aaaa","aaaa","aaaa"),c("bb","bb","bb"),c("c"))

प्रत्येक आयत की पंक्तियों पर लूप्स, प्रत्येक के बाद एक गाड़ी वापसी की छपाई, लाइन को फिर से शुरू करना।

यदि हम नियमों को थोड़ा बढ़ाते हैं, तो हम इनपुट की लंबाई की जांच कर सकते हैं और सिर्फ लूप को असीम रूप से प्रिंट कर सकते हैं, जिससे बड़ी मात्रा में नए सिरे से छपाई होती है:

आर, 85 बाइट्स

function(x)for(i in 1:8e8){for(m in x)if(i<=length(m))cat(m[i],'\r',sep='');cat('
')}

Comments

106 बाइट्स आप यहाँ और वहाँ एक गोल्फ कर देख अच्छा लगा!

— ग्यूसेप

संभवतः 97 बाइट्स ; यह स्पष्ट नहीं है कि यह वास्तव में तब से काम कर रहा है जब मैं केवल TIO

— Giuseppe

@Giuseppe हाय! आपका सुझाव मेरे लिए काम करता है। यदि हमें अनुगामी नईलाइनों को प्रिंट करने की अनुमति दी जाती है, तो इसके बजाय लूप के लिए केवल मनमाने ढंग से बड़े का उपयोग करना संभव है, लेकिन मुझे लगता है कि यह चुनौती की सीमा को आगे बढ़ा रहा है।

— JAD

@ जेएडी: महान विचार का उपयोग करना \r, और वापस स्वागत है! बस एक नोट, मुझे लगता है कि यह केवल इंटरैक्टिव आर सत्रों में काम करता है (जब यह interactive()सच है)

— digEmAll

@digEmAll यह rscriptकमांडलाइन का उपयोग करके मेरी मशीन पर काम करता है । मुझे संदेह है कि यह विंडोज / लिनक्स की चीज है, क्योंकि विंडोज \r\nनईलाइन और लिनक्स के लिए उपयोग करता है \n।

— JAD

Answer 6

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

बेनामी मौन उपसर्ग समारोह तर्क के रूप में 2 डी चरित्र सरणियों की सूची ले रहा है। प्रिंटों।

(⊃{⍺@(⍳⍴⍺)⊢⍵}/)⌽,∘⊂1⌷↑

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

यह एक कैनवस बनाकर काम करता है, जो कि ब्लॉक की सूची में जोड़ता है, और एक फ़ंक्शन के साथ कम (तह) करता है जो कोने में ब्लॉक रखता है।

↑ एक ऑर्थोगोनल 3 डी ब्लॉक बनाने के लिए 2 डी ब्लॉक को मिलाएं, उन्हें आवश्यकतानुसार रिक्त स्थान के साथ पैडिंग करें

1⌷ पहली परत ले लो

⊂ लगा देना कि
 ∘ उसके बाद
⌽, ब्लॉक के उलट सूची पहले जोड़ें

(… ) निम्नलिखित tacit फ़ंक्शन लागू करें:

 {… }/ निम्नलिखित अनाम लंबोदर का उपयोग कम करें:

  ⊢⍵ कैनवास के रूप में सही तर्क के साथ…

  ⍺@(… निम्नलिखित सूचकांकों पर)  रखे गए, बाएं तर्क के तत्वों के साथ संशोधन करें :

   ⍴⍺ बाएं तर्क का आकार

   ⍳ɩ कि आकार की एक सरणी के ndices

 ⊃ खुलासा (क्योंकि कमी रैंक को कम करने के लिए संलग्न)

Answer 7

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

unlines.foldl((const?)?)[]
(g?(a:b))(c:d)=g a c:(g?b)d;(_?a)b=a++b

इनपुट को रिवर्स ऑर्डर में स्ट्रिंग्स की सूची की सूची के रूप में लिया जाता है, उदाहरण के लिए पहला टेस्ट केस [["c"],["bb","bb","bb"],["aaaa","aaaa","aaaa","aaaa"]]:।

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

Answer 8

05AB1E , 12 बाइट्स

पोर्ट ऑफ TFeld के अजगर समाधान
2 बाइट्स के लिए धन्यवाद बचाया मटमैला

ζεðKζðδK€θJ,

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

व्याख्या

ζ             # transpose input with space as filler
 ε            # apply to each
  ðK          # remove spaces
    ζ         # transpose with space as filler
     ðδK      # deep remove spaces
        €θ    # get the tail of each
          J   # join each
           ,  # print

वैकल्पिक 14 बाइट संस्करण

õζεÅ»DŠg.$J}θ,

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

व्याख्या

õζ              # zip with empty string as filler
  ε             # apply to each
   Å»      }    # cumulative reduce by
     D          # duplicate second input
      Š         # move down twice on stack
       g.$      # remove len(other_copy) elements from the other input
          J     # join with other copy
            θ,  # print the last element

Comments

ओह, यह याद रखने की जरूरत है कि --no-lazyअभी भी एक मैप का उपयोग करना है / निहितार्थ के लिए प्रिंट के साथ फिल्टर का उपयोग करें y, बाइट को बचाने के लिए vy...,:) की तुलना में : मुझे पता था कि विरासत संस्करण में काम किया था, लेकिन नए संस्करण में यह आउटपुट भी होगा [...]। पता नहीं था कि कमी के कारण था --no-lazy। ;) के रूप में ही जवाब के लिए, बहुत अच्छा! मुझे पता था कि एक संचयी कमी आवश्यक थी, लेकिन जब मैं खुद इसे आज़माता हूं तो वास्तव में यह काम नहीं कर सकता। आप इसे इतना आसान बनाते हैं ..

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

मैंने इसे नियमों में उल्लिखित किया था, लेकिन परीक्षण के मामलों में इसे लागू करना भूल गया .., लेकिन रिक्त स्थान इनपुट में नहीं होगा। तो आप शायद वहाँ कुछ बाइट्स बचा सकते हैं क्योंकि ज़िप-फिलर डिफ़ॉल्ट रूप से एक जगह है। (यह सुनिश्चित नहीं है कि यह आपके पहले उत्तर में कुछ भी बचाता है, लेकिन पोर्ट में यह हो सकता है।)

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

õζεõKहो सकता है ζεðK, õζõδKहो सकता है ζðδK।

— ग्रैमी

@ चिकना: ओह हाँ, रिक्त स्थान अब इनपुट में नहीं हो सकते। धन्यवाद!

— 15

Answer 9

कैनवस , 5 बाइट्स

Ｈ１１╋╋

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

यदि ओवरलैपिंग /+ \→ X, -+ |→ +, आदि ठीक होगा, तो 2 बाइट्स काम करेंगे।

Answer 10

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

for t in map(None,*input()):
 r=''
 for s in t:
	if s:r=s+r[len(s):]
 print r

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

Answer 11

PowerShell 6 , केवल कंसोल, 20 बाइट्स

अर्नुलद के जवाब पर आधारित है । यह केवल कंसोल के साथ काम करता है और टीआईओ पर काम नहीं करता है।

cls
$args-join"`e[H"

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

---

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

$args|%{$l=$_-split'
';$r=&{$r+($l|%{''})|%{($x=$l[$j++])+($_-replace"^.{0,$("$x"|% Le*)}")}|?{$_}}}
$r

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

unrolled:

$args|%{
    $l=$_-split"`n"
    $r=&{                           # run this scriptblock in a new scope
        $r+($l|%{''})|%{
            $x=$l[$j++]             # a new line or $null
            $w="$x"|% Length
            $y=$_-replace"^.{0,$w}" # remove first chars from the current line
            $x+$y                   # output the new line plus tail of the overlapped line
        }|?{$_}                     # filter out not empty lines only
    }                               # close the scope and remove all variables created in the scope
}
$r

Answer 12

सी # (.NET कोर) , 68 + 23 = 91 बाइट्स

n=>{C.Clear();n.ForEach(k=>{C.SetCursorPosition(0,0);C.Write(k);});}

23 बाइट्स आयात के लिए है, using C=System.Console;

TIO में काम नहीं करता है, क्योंकि यह कंसोल नहीं है।

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

Answer 13

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

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

->i,*r{i.map{|e|j=-1;e.map{|l|r[j+=1]||='';r[j][0,l.size]=l}};r*$/}

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

Answer 14

C (GCC, MinGW) 138 बाइट्स

मान लेता है कि सीआर वर्तमान लाइन की शुरुआत में कर्सर रखता है।

d,i,l;f(S,n,p,t)char**S,*p,*t;{for(d=i=0;i<n;d+=l)p=strchr(t=S[i],10),printf("\n%.*s\r"+!!i,l=p?p-t:strlen(t),t),S[i++]+=l+!!p;d&&f(S,n);}

के साथ परीक्षण किया गया:

int main()
{
    char *test1[] = {"aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"};
    char *test2[] = {"12345\n54321","00\n00\n00\n00","001\n011\n012"};
    char *test3[] = {"sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"};

    f(test1, 3);
    f(test2, 3);
    f(test3, 3);
}

Answer 15

ऑक्टेव , 71 67 बाइट्स

function y=f(x)
for k=1:size(x)
y(1:(t=size(x{k})),1:t(2))=x{k};end

फंक्शन जो चार्ट मैट्रीस के एक ऊर्ध्वाधर सेल ऐरे को लेता है, और एक चार मैट्रिक्स देता है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

Answer 16

जावास्क्रिप्ट (ब्राउज़र) , 216 208 204 बाइट्स

इस पर मेरा प्रयास। मैं आकार के बारे में खुश नहीं हूं, और सुधार के लिए निश्चित रूप से अधिक होना चाहिए, लेकिन मैं गोल्फ में अनुभव नहीं कर रहा हूं।

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;i++){j=a[i];if(!j)j=b[i];a[i]=b[i].padStart(j.length,j)}return a}).map(s=>x(s)).join(n)

वैसे भी, यह जो भी करता है वह पहले सभी स्ट्रिंग्स को विभाजित करता है, फिर सभी स्ट्रिंग्स को उल्टा करता है, फिर एक कम ऑपरेशन में लूपिंग करता है और सभी स्ट्रिंग्स को एक साथ जोड़ता है। फिर सभी तारों को फिर से उल्टा कर दें और फिर उन्हें वापस नए सिरे से जोड़ दें।

केविन क्रूज़सेन के लिए विशेष धन्यवाद मुझे याद दिलाने के लिए कि लूप के लिए अंतिम भाग अंत में होता है और कुल 8 बाइट की बचत होती है।

var n='\n',x=s=>s.split``.reverse().join``,i,j,f=a=>a.map(s=>s.split(n).map(y=>x(y))).reduce((a,b)=>{for(i=0;i<b.length;a[i]=b[i++].padStart(j.length,j))if(!(j=a[i]))j=b[i];return a}).map(s=>x(s)).join(n)

console.log(f(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(f(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(f(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

Comments

दोनों ('')चार बाइट्स बचाने के लिए दो `हो सकते हैं :)

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

इसके अलावा, आप के for(i=0;i<b.length;i++){j=a[i];if(!j)j=b[i];a[i]=b[i].padStart(j.length,j)}साथ बदल सकते हैं for(i=0;i<b.length;a[i]=b[i++].padStart(j.length,j))if(!(j=a[i]))j=b[i];।

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

के jसाथ पहले असाइन किया गया है (j=a[i]), फिर अगर-स्टेटमेंट if(!...)j=b[i];(जहां ...है (j=a[i]), तो अपडेट किया गया मान है j) के साथ ;a[i]=b[i++].padStart(j.length,j))किया जाता है , और फिर फ़ोर-लूप पुनरावृत्ति के अंत में किया जाता है .. निश्चित नहीं है कि समस्या कहाँ है, और यह काम करने लगता है?

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

ooohhh .... * बड़ी आंखें * जो कुछ

— खोलती हैं

Btw, यदि आपने उन्हें अभी तक नहीं देखा है, तो <सभी भाषाओं में गोल्फिंग के लिए टिप्स > और जावास्क्रिप्ट में गोल्फिंग के लिए टिप्स दोनों को पढ़ना दिलचस्प हो सकता है। :)

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

Answer 17

सी (जीसीसी) , 51 47 बाइट्स

f(char**s){for(;*s;printf("\e[s%s\e[u",*s++));}

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

सीट्स के लिए -4 बाइट्स धन्यवाद।

कर्सर स्थिति को बचाने / पुनर्स्थापित करने के लिए CSI अनुक्रम का उपयोग करता है। बस पारित स्ट्रिंग सरणी से अधिक पुनरावृति करता है (उसी प्रारूप मेंargv ) और <save position>string<restore position>प्रत्येक के लिए प्रिंट ।

यह कर्सर को सबसे ऊपर बाईं ओर छोड़ता है, इसलिए टर्मिनल पर दौड़ते समय बाद में पर्याप्त नई सुर्खियाँ छोड़ना ज़रूरी होता है ताकि प्रॉम्प्ट इनपुट को क्लोब न करे।

Answer 18

Japt -P , 7 बाइट्स

मल्टी-लाइन स्ट्रिंग्स की एक सरणी के रूप में इनपुट लेता है, एक एकल मल्टी-लाइन स्ट्रिंग आउटपुट करता है।

ú y_¸¬Ì

कोशिश करो

ú y_¸¬Ì     :Implicit input of array
ú           :Right pad each line of each element with spaces to the length of the longest
  y         :Transpose
   _        :Map
    ¸       :  Split on spaces
     ¬      :  Join
      Ì     :  Last character
            :Implicitly join and output

Answer 19

टी-SQL क्वेरी, 297 295 बाइट्स

इनपुट के रूप में विभाजक के रूप में ator और तालिका चर का उपयोग करना।

DECLARE @ table(a varchar(max),k int identity(1,1))
INSERT @ values('aaaa¶aaaa¶aaaa¶aaaa'),('bb¶bv¶bb'),('c');

WITH c as(SELECT k,row_number()over(partition
by k order by k)s,value v FROM @ CROSS APPLY
string_split(a,'¶')s),m(i,l,e)as(SELECT*FROM c
WHERE k=1UNION ALL
SELECT k,s,STUFF(e,1,len(v),v)FROM m
JOIN c ON-~i=k and s=l)SELECT
top 1with ties e FROM m
ORDER BY rank()over(partition by l order by-i)

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

Answer 20

जावास्क्रिप्ट (ब्राउज़र), 129 124 बाइट्स

कोड गोल्फिंग में मेरा पहला प्रयास। मैंने नियमों (खामियों, मानक नियमों ...) में दिए गए लिंक को पढ़ा, इसलिए मुझे आशा है कि मैंने कुछ भी गलत किया है!

---

मैंने इनपुट्स को रखा क्योंकि वे पहली पोस्ट (फ्लैट एरे फॉर्म) में हैं।

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

5 बाइट बचाने के लिए केविन क्रूज़सेन का धन्यवाद ।

---

टेस्ट:

_=o=>{o=o.map(i=>i.split`\n`),r=o.shift();for(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;return r.join`\n`}

console.log(_(["aaaa\naaaa\naaaa\naaaa","bb\nbb\nbb","c"]));
console.log(_(["12345\n54321","00\n00\n00\n00","001\n011\n012"]));
console.log(_(["sm\noo\nmr\nee\nt!\nh_\ni_\nn_\ng_","!@#$%^\n&*()_+\nqwerty\nuiopas","this\nis_a\ntest"]));

Comments

PPCG में आपका स्वागत है! अच्छा पहला उत्तर, +1 मुझसे। गोल्फ के लिए कुछ छोटी चीजें: :) for(a of o){for(l in a){b=a[l],r[l]=(r[l])?b+r[l].slice(b.length):b}}हो सकती हैंfor(a of o)for(l in a)b=a[l],r[l]=r[l]?b+r[l].slice(b.length):b;

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

@ केविनक्रूजसेन - धन्यवाद, मैंने अपनी पोस्ट अपडेट कर दी है! मैंने पोस्ट करने से पहले इन दो गाइडों को पढ़ा, वे दोनों उपयोगी थे। लेकिन मुझे संभवतः कुछ तरकीबें याद आती हैं जो मेरे प्रयास को और भी बेहतर बना सकती हैं!

— केविन बिबोललेट

मेरी पहली टिप्पणी से एक और बात जो आपको याद आती है वह है चारों ओर की कोष्ठक, =(r[l])?जिसे हटाया जा सकता है =r[l]?:)

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

@ KévinBibollet, के अंतिम परिणाम को वापस करने के लिए इसकी आवश्यकता है r। इसके बिना, मैपिंग का परिणाम बदले दिया जाएगा।

— झबरा

यदि आप परीक्षण मामलों में उपयोग किए जाने वाले I / O प्रारूप को बनाए रखना चाहते हैं , हालांकि, आप अभी भी 85 बाइट्स तक नीचे जा सकते हैं, लेकिन आपको ध्यान देना चाहिए कि I / O लचीला है।

— झबरा

Answer 21

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

L.tb0VyQsme #dy #N

इसे ऑनलाइन आज़माएं!(नोट: कोड केवल एक ब्लॉक का मूल्यांकन करता है, दुभाषिया का परीक्षण सूट मोड इनपुट की प्रत्येक पंक्ति के लिए एक बार प्रोग्राम चलाता है)

TFeld के पायथन 2 समाधान के आधार पर ।

स्पष्टीकरण:

L.tb0         # define a lambda function called y which does a transpose, padding with integer 0's
VyQ           # loop over transposed first input line (Q = eval(input()) ) (loop index = N)
   s          # concatenate array of strings (implicitly printed)
    m         # map over
         y #N # transpose of non-falsy values of N
     e        # for each item: last element of array
       #d     # relevant space at the start! filter with identity function, removes falsy values

एल्गोरिथ्म ही क्यों काम करता है, इसकी व्याख्या के लिए, TFeld का जवाब देखें।

Answer 22

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

ＦθＰι

इसे ऑनलाइन (क्रिया) आज़माएँ या इसे ऑनलाइन (शुद्ध) आज़माएँ ।

स्पष्टीकरण:

मल्टी-लाइन स्ट्रिंग्स के इनपुट-सूची पर लूप:

For(q)
Ｆθ

और कर्सर को स्थानांतरित किए बिना मल्टी-लाइन स्ट्रिंग प्रिंट करें:

Multiprint(i);
Ｐι