30

प्रेरणा स्त्रोत। * मुझे विश्वास नहीं होता कि हमारे सामने यह चुनौती नहीं है:

कार्य

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

उदाहरण

SIMPLE देता है SIMPLE

POLLSऔर EPEESदेता हैPEOPLELESS

LYESऔर APRONSदेता हैLAYPERSONS

ABCDEऔर a cऔर 123 567देता हैAa1B 2Cc3D E567

"\n$?*और (खाली स्ट्रिंग) और ,(.)" (अनुगामी स्थान) देता है ",\(n.$)?"* (अनुगामी स्थान)

^{* छोटे APL समाधान हैं।}

code-golf string sorting

— एडम
स्रोत

चूंकि यह मूल रूप से सिर्फ एक ट्रांसपोज़ ऑपरेशन है, इसलिए हमारे पास कुछ चुनौतियां हैं जो बहुत समान हैं, लेकिन संभवत: कोई भी ऐसा नहीं है।

— मार्टिन एंडर

7

मेरे सीएस एचडब्ल्यू पर यह सवाल था, क्या इसका मतलब है कि मैं इसे एक होमवर्क प्रश्न के रूप में बंद कर सकता हूं? ; पी

— डाउनगोट

@EriktheOutgolfer कूल! मैंने आज कुछ सीखा।

— आदम

23

जेली , 1 बाइट

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

"ट्रांसपोज़" बिल्ट-इन स्ट्रिंग्स की सूची में ठीक यही करेगा।

— लिन
स्रोत

मुझे उत्सुकता है, अगर आपको रिक्त स्थान के साथ छोटे तार लगाना पड़े तो कोड कैसा दिखेगा?

— Adám

2

वह होगा z⁶। z"ट्रांसपोज़र लेफ्ट, राइट के साथ पैडिंग" है; ⁶एक स्थान है।

— लिन

1

@ Adám जेली सूचियों पर बहुत अच्छा काम करती है; बिल्ट-इन एंड एंड लैंग्वेज कन्सट्रक्शन / डिज़ाइन कहाँ से शुरू होते हैं?

— स्टीनबर्गघ

1

@ लिली में जेली? एटम्स और क्विक लिस्ट में कुछ भी बिल्ड-इन हैं।

— 16

2

@ Adám ;"(तत्व-वार सहमति ) एक अंतर्निहित के बिना कार्य को हल करेगा।

— डेनिस

8

पायथन 2, 101 89 86 69 बाइट्स

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

f=lambda s:' '*any(s)and''.join(x[:1]for x in s)+f([x[1:]for x in s])

पुराने समाधान:

w=input();o=''
while any(w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

lambda s:''.join(''.join([c,''][c<' ']for c in x)for x in map(None,*[list(y)for y in s]))

w=input();o=''
while any(x>=' 'for x in w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

^{गणित के लिए धन्यवाद मुझे गूंगा महसूस करने के लिए;) मुझे बाइट्स का एक गुच्छा बचा लिया। (पुराने समाधान पर)}

— Kade
स्रोत

क्या आप बस नहीं कर सकते थे while any(w):? पायथन में खाली तार झूठा है।

— मैथमैनंदन

@ मथमंदन आप बिलकुल सही हैं, पता नहीं मैं क्या सोच रहा था ..

— केड

कोई समस्या नहीं है :) आपका नया समाधान बहुत अच्छा लग रहा है, सिवाय इसके कि मुझे लगता है कि आपको पहले से सोचना चाहिए f=।

— मैथमैडैन

आप []पुनरावर्ती कॉल को बंद कर सकते हैं , छोड़कर f(x[1:] for x in s), जो इसे एक जनरेटर समझ बनाता है, जो इस संदर्भ में एक सूची के रूप में कार्य करता है।

— बायूसेल

8

पर्ल 6 , 34 32 बाइट्स

{[~] flat roundrobin |$_».comb}

~~{roundrobin(|$_».comb).flat.join}~~

एक लंबोदर जो तर्क के रूप में तार की एक सरणी लेता है, और एक स्ट्रिंग लौटाता है।

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

— SMLS
स्रोत

मैंने @_इसके बजाय इस्तेमाल किया होगा$_

— ब्रैड गिल्बर्ट b2gills

7

CJam , 4 बाइट्स

qN/z

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

हम 4 बाइट्स के लिए एक अनाम फ़ंक्शन भी लिख सकते हैं, जो स्टैक के शीर्ष पर तार की एक सूची की उम्मीद करता है:

{zs}

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

— मार्टिन एंडर
स्रोत

2

यह एक बाइट एक मिनट है!

— आदम डे

7

पायथ - 3 बाइट्स

बहुत सरल है, बाद में मोबाइल पर विस्तार जोड़ देगा।

s.T

परीक्षण सूट

s                         Join all the strings together
 .T                       Transpose, without chopping off overhang
  (Q implicit)

— Maltysen
स्रोत

4

@ डैनियल मैं स्कूल में भी हूं: पी

— माल्टसेन

स्पष्टीकरण जोड़ने पर कोई योजना?

— जॉन ड्वोरक

@JanDvorak यकीन है कि यह अब कर रही है।

— माल्टसेन

6

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

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

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

टेस्ट स्निपेट

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

g=a=>console.log("Input:",JSON.stringify(a),"Output:",JSON.stringify(f(a)))

g(["SIMPLE"])
g(["POLLS","EPEES"])
g(["LYES","APRONS"])
g(["ABCDE","a c","123 567"])
g(["\"\\n$?*",",(.)\" "]) // Backslash and quote are escaped, but in/output are correct

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

— नील

@ नील यह एक महान दृष्टिकोण है। मैं अपने खुद के बंद 6 बाइट्स में कामयाब रहा :-)

— ETHproductions

6

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

import Data.List
concat.transpose

Ideone पर इसे आज़माएं। उपयोग:

Prelude Data.List> concat.transpose$["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

बिल्ड-इन का उपयोग किए बिना: ( 38 34 बाइट्स)

f[]=[]
f x=[h|h:_<-x]++f[t|_:t<-x]

Ideone पर इसे आज़माएं। 4 बाइट्स ज़गरब की बदौलत! उपयोग:

Prelude> f["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

— Laikoni
स्रोत

1

आप वैकल्पिक संस्करण में सभी पार्नों को हटा सकते हैं। फिर भी आयात को हरा नहीं होगा।

— जर्बर्ब

क्या आपको वास्तव में आधार मामले की आवश्यकता है?

— xnor

कोई बात नहीं, बेशक आधार मामले की जरूरत है।

— xnor

@xnor आप बेस केस को अंत तक स्थानांतरित नहीं कर सकते हैं और f a=aबाइट को बचाने के लिए इसे बदल सकते हैं क्योंकि दोनों []का एक अलग प्रकार है ... इतना करीब।

— लकोनी

5

सी, 114 84 बाइट्स

लंबाई की गणना नहीं करने के लिए -20 बाइट्स।

i,b;f(char**s){b=1;while(b){i=-1;b=0;while(s[++i]>0)if(*s[i])putchar(*s[i]++),++b;}}

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

अधूरा और उपयोग:

i,b;f(char**s){
 b=1;
 while(b){
  i=-1;
  b=0;
  while(s[++i]>0)
   if(*s[i])
    putchar(*s[i]++),++b;
 }
}


int main(){
 char*a[]={ 
//  "POLLS","EPEES"
//  "LYES","APRONS"
 "ABCDE","a c","123 567"
 ,0};
 f(a);
 puts("");
}

— कार्ल नेफ
स्रोत

क्या प्रिंटफ / स्प्रिंट के उपयोग की अनुमति नहीं है? : D आप कुछ बाइट्स जीतेंगे।

— वॉलफ्रैट

सीधे प्रिंट किए बिना मुझे एक स्ट्रिंग आवंटित करने की आवश्यकता होगी, इसलिए यह कुछ भी कैसे बचा सकता है।

— कार्ल नेप ने

यह आपके संपादन से पहले था, जहां आपने ++ बी जोड़ा था और लंबाई गणना को हटा दिया था, इसलिए हाँ अब काम नहीं कर सकता है।

— वल्करैट

@Walfrat हां, लेकिन मेरे पास एक mallocऔर returnपहले और यह सिर्फ छपाई से अधिक लंबा था

— कार्ल नेफ

5

PHP, 68 67 बाइट्स

for(;$f=!$k=$f;$i++)for(;y|$v=$argv[++$k];$f&=""==$c)echo$c=$v[$i];

कमांड लाइन के तर्कों पर लूप। साथ चलाना -r।

भीतरी पाश के बाद, $fहै 1जब सभी स्ट्रिंग्स पूरा कर लें, 0वरना (बिटवाइज़ &डाले ""==$cपूर्णांक के लिए)।
बाहरी लूप का अगला पुनरावृत्ति: कॉपी $fटू $k(एक बाइट से बचाता है $k=0) और टॉगल $f:
जब सभी तार किए जाते हैं, $fतो अब होता है falseऔर लूप टूट जाता है।

— टाइटस
स्रोत

खाली इनपुट स्ट्रिंग्स के साथ काम नहीं करता है। अंतिम

— टेस्टकेस

@ सकल: नियत धन्यवाद।

— टाइटस

4

रेटिना , 13 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

O$#`.
$.%`
¶

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

व्याख्या

O$#`.
$.%`

यह रेटिना में मानक ट्रांसपोज़ेशन तकनीक पर आधारित है। हम Oसभी गैर-लाइनफ़ीड वर्णों ( .), $#उसी पंक्ति में उनके सामने वर्णों की संख्या ( $.%`), अर्थात उनकी क्षैतिज स्थिति को सॉर्ट ( ) करते हैं।

दूसरा चरण तब इनपुट से लाइनफीड हटाता है।

— मार्टिन एंडर
स्रोत

4

जावा, 19 + 155 = 174 160

String f(java.util.Queue<String> q){String s,r="";while(!q.isEmpty()){s=q.poll();r+=s.isEmpty()?"":s.charAt(0);if(s.length()>1)q.add(s.substring(1));}return r;}

Ungolfed:

  String f(java.util.Queue<String> q) {
    String s, r = "";
    while (!q.isEmpty()) {
      s = q.poll();
      r += s.isEmpty() ? "" : s.charAt(0);
      if (s.length() > 1) {
        q.add(s.substring(1));
      }
    }
    return r;
  }

आउटपुट:

सरल

PEOPLELESS

laypersons

Aa1B 2Cc3D E567

", (n। $)?" *

पहला संशोधन: कुछ बाइट्स को बचाने के लिए मर्ज किए गए स्ट्रिंग घोषणा। हटाए गए import, यह main()विधि द्वारा उपयोग किया गया था (यहां नहीं दिखाया गया है) जिसकी आवश्यकता भी थी LinkedList। Queueसीधे रेफरी करने के लिए यह कम बाइट्स है ।

स्ट्रिंग आर के साथ इनिशियलाइज़ स्ट्रिंग s कुछ और बचा सकता है

— Syamesh K

मुझे पता है कि यह लगभग एक साल पहले है, लेकिन आप कुछ बाइट्स कर सकते हैं:

String f(java.util.Queue<String>q){String s,r="";for(;!q.isEmpty();r+=s.isEmpty()?"":s.charAt(0))if((s=q.poll()).length()>1)q.add(s.substring(1));return r;}

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

3

PHP, 77 बाइट्स

golfed

function($a){for($d=1;$d!=$s;$i++){$d=$s;foreach($a as$v)$s.=$v[$i];}echo$s;}

अनाम फ़ंक्शन जो स्ट्रिंग की एक सरणी लेता है।

मुझे यकीन है कि यह अधिक गोल्फ हो सकता है, लेकिन यह जल्दी है। प्रत्येक पुनरावृत्ति पर, हम प्रत्येक दिए गए स्ट्रिंग से i-th अक्षर को पकड़ते हैं और इसे हमारे अंतिम स्ट्रिंग में जोड़ते हैं, एक बार में। अगर हम स्ट्रिंग्स के बिट्स को एक्सेस करते हैं, तो PHP चेतावनी देता है। हम केवल तभी रुकते हैं जब एक बार सभी तारों के माध्यम से लूपिंग के बाद कोई बदलाव नहीं किया गया है।

मुझे लगता है कि इसका उपयोग $dअधिक किया जा सकता है, लेकिन यह जल्दी है। : पी

— Xanderhall
स्रोत

आप वास्तव में एक ही तर्क में कैसे तार डालते हैं?

— टाइटस

@Titus। Y'now, मैं वास्तव में इसके बारे में कभी नहीं सोचा था। मैं सिर्फ थोड़े तुम ग्रहण कर सकता है।

— Xanderhall

3

दरअसल , 7 6 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

संपादित करें: -1 बाइट टीले पेलिकन के लिए धन्यवाद।

a Z♂ΣΣ

Ungolfing

          Implicit input each string.
a         Invert the stack so that the strings are in the correct order.
<space>   Get the number of items on the stack, len(stack).
Z         Zip all len(stack) strings into one, transposing them.
♂Σ        sum() every transposed list of chars into strings.
Σ         sum() again to join the strings together.

— Sherlock9
स्रोत

क्या आप इसे 6 बाइट्स बनाने के लिए # नहीं निकाल सकते?

— पेलिकन

Welp @Tealpelican, अब मैं अपने पुराने असल जवाब में से सभी के माध्यम से खुदाई और देखें कि क्या मैं नहीं बदल सकते करने के लिए जा रहा हूँ Z♂#Σकरने के लिए Z♂Σउन सभी को में। टिप के लिए धन्यवाद: D

— शर्लक

पहली बार भाषा में देखने पर, यह बहुत मजेदार लगता है! खुशी है कि मैं मदद कर सकता है :))

— पेलिकन

3

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

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

<textarea oninput=o.textContent=f(this.value.split`\n`)></textarea><div id=o>

स्निपेट का विस्तार करें

— नील
स्रोत

3

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

lambda*m:''.join(map(lambda*r:''.join(filter(None,r)),*m))

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

— कीर्तन प्रभाकरं
स्रोत

क्या आप स्थान नहीं हटा सकते lambda *m?

— आउटगोल्फर

मैंने बस यही किया! धन्यवाद!

— कीर्तन प्रभाकरन १६'१।

2

जे , 13 बाइट्स

({~/:)&;#\&.>

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

इस प्रश्न की प्रेरणा के आधार पर ।

इसे करने का दूसरा तरीका 27 बाइट्स लेता है, लेकिन ट्रांसपोज़ का उपयोग करके संचालित होता है। अधिकांश बाइट्स को पेडिंग से स्वचालित रूप से जोड़े गए शून्य को संभालना है।

[:u:0<:@-.~[:,@|:(1+3&u:)&>

व्याख्या

({~/:)&;#\&.>  Input: list of boxed strings S
          &.>  For each boxed string x in S
        #\       Get the length of each prefix from shortest to longest
                 This forms the range [1, 2, ..., len(x)]
                 Rebox it
(    )         Operate on S and the prefix lengths
      &;         Raze both
   /:            Grade up the raze of the prefix lengths
 {~              Index into the raze of S using the grades
               Return

— मील की दूरी पर
स्रोत

जम्मू के मिश्रित एरे को रोकना वास्तव में आपको यहां नुकसान पहुंचाता है। इसे एपीएल में आज़माएं।

— Adám

2

बाश + जीएनयू उपयोगिताओं, 55

 eval paste `sed "s/.*/<(fold -1<<<'&')/g"`|tr -d \\n\\t

STDIN (लाइन-अलग) और STDOUT के माध्यम से I / O।

sedएक करने के लिए प्रत्येक पंक्ति स्वरूपों बैश प्रक्रिया प्रतिस्थापन । ये तो वास्तविक interleaving करने evalमें एड कर pasteरहे हैं। trफिर अनावश्यक न्यूलाइन्स और टैब को हटा देता है।

Ideone।

— डिजिटल आघात
स्रोत

2

PHP, 63 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है

for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];

इस तरह से चलाएं:

php -r 'for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];' "\"\n\$?*" "" ",(.)\" " 2>/dev/null;echo
> ",\(n.$)?"*

व्याख्या

for(                       # Iterate over string index.
  ;
  $s ^= 1;                 # Continue until $s (stop iterating) is 1.
                           # Flip $s so each iteration starts with $s
                           # being 1.
  $i++                     # Increment string index.
)
  for(
    ;
    "n" | $w=$argv[++$$i]; # Iterate over all input strings. OR with "n"
                           # to allow for empty strings.
    $s &= $x<~■            # If last character printed was greater than
                           # \x0 (all printable chars), set $s to 0,
                           # causing the loop to continue.
  )
    echo $x = $w[$i];      # Print char $i of current string.

— aross
स्रोत

आईबीएम 850 ?! क्या यह PHP के लिए एक प्राकृतिक एन्कोडिंग है?

— प्रवेश

@ Adám "प्राकृतिक" से आपका क्या तात्पर्य है? PHP पाठ के रूप में 128-255 की सीमा में बाइट्स का इलाज करती है, जिसे इसलिए एक स्थिरांक के रूप में व्याख्या किया जाता है। यदि निरंतर अपरिभाषित है, तो इसे एक स्ट्रिंग के रूप में व्याख्या किया जाएगा। ऐसा है तो मैं (बाइनरी 1) के ~■बजाय "\x1"(बाइनरी 254) कर सकता हूं ।

— 13

1

समझा। ऐसा नहीं है कि आपको वास्तव में उस कोडपेज की आवश्यकता है, आपको बस 254 बाइट की आवश्यकता है।

— Adám

@ हाँ, कोडपेज सिर्फ इसे प्रिंट करने योग्य चार बनाता है जो थोड़ा कम कष्टप्रद है।

— aross

के महान उपयोग $$!

— टाइटस

2

पायथन 3, 75 बाइट्स

मुझे पता है कि दूसरा पायथन एक छोटा है, लेकिन यह पहली बार है जब मैंने mapअपने जीवन में कभी प्रयोग किया है तो मुझे इस पर बहुत गर्व है

lambda n:''.join(i[k]for k in range(max(map(len,n)))for i in n if len(i)>k)

— bioweasel
स्रोत

1

सी, 75 71 बाइट्स

केवल सीमा उत्पादन की लंबाई है। वर्तमान में यह 99 है, लेकिन आसानी से 999 (+1 बाइट) तक बढ़ाया जा सकता है।

i;main(a,b)char**b;{a--;for(;i<99;i++)*b[i%a+1]&&putchar(*b[i%a+1]++);}

Ungolfed:

i;
main( a, b )
char **b;
{
    a--;
    for( ; i < 99; i++ )
        *b[i % a + 1] && putchar( *b[i % a + 1]++ );
}

— Jacajack
स्रोत

1

ओरेकल SQL, 195 बाइट्स

    select listagg(b,'') within group(order by l,o) from(select substr(a,level,1) b,level l,o from i start with length(a)>0 connect by prior a=a and level<=length(a) and prior sys_guid() is not null)

iस्तंभ a(स्ट्रिंग युक्त) और o(स्ट्रिंग का क्रम ) नाम वाली तालिका से इसका इनपुट लेता है :

    create table i (a varchar2(4000), a integer)

स्पष्टीकरण:
हम CONNECT BYप्रत्येक पात्र में तारों को तोड़ने के लिए उनका शोषण कर रहे हैं । PRIOR SYS_GUID()किया जा रहा है NOT NULLसुनिश्चित हम एक पाश में फंस न करना पड़े।
हम तब एकल वर्णों को समेटते हैं, LISTAGGलेकिन हम उन्हें एक साथ फेरबदल करते हैंORDER BY खंड के , उन्हें मूल स्ट्रिंग में अपनी स्थिति से पहले आदेश देते हैं और उसके बाद ही वे स्ट्रिंग से आते हैं।

अन्य उत्तरों जितना छोटा नहीं है लेकिन एसक्यूएल वास्तव में एक स्ट्रिंग हेरफेर भाषा के रूप में नहीं है :)

— Demonblack
स्रोत

1

पायथन 2, 128 96

मैं यह उम्मीद कर रहा था कि इटर्टूल का उपयोग न करें

a=lambda a:"".join([i for i in reduce(lambda: b,c:b+c, map(None,*map(lambda m:list(m),a)) if i])

Ungolfed

 a=lambda a:                              #Start a lambda taking in a
    "".join(                              #Join the result together with empty string
        [i for i in reduce(               #For every item, apply the function and 'keep'
           lambda: b,c:b+c,               #Add lists from...
                map(None,*map(            #None = Identity function, over a map of...
                    lambda m:list(m), a)  #list made for mthe strings m
                   ) if i                 #truthy values only (otherwise the outer map will padd with None.
       ])

— Pureferret
स्रोत

इसे सुधारने पर प्रतिक्रिया / सलाह की सराहना करेंगे।

— शुद्धाटन

1

पर्ल ५ , 28 बाइट्स

26 बाइट्स कोड + 2 के लिए -0n।

s/^./!print$&/gem while/./

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

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

1

आर , 73 बाइट्स

for(i in 1:max(nchar(s<-scan(,""))))for(j in seq(s))cat(substr(s[j],i,i))

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

स्पष्टीकरण: बहुत सरल (लेकिन क्रिया), बस वें स्ट्रिंग के मुद्रण iचरित्र के माध्यम से लूप j। सौभाग्य से, substrयदि कोई आउट-ऑफ-रेंज इनपुट दिया जाता है तो एक खाली स्ट्रिंग देता है।

— user2390246
स्रोत

0

पायथन, 112 बाइट्स

i=len(x)if len(x)>len(y) else len(y) h=0 a="" while h<i: if h<len(x) a+=x[h] if h<len(y): a += y[h] h+=1 print a

— jacksonecac
स्रोत

6

तुम्हारा स्वरूपण वास्तव में गड़बड़ है .. तुम कहाँ से xऔर कहाँ से लाते yहो?

— Kade

0

पर्ल 5 , 53 बाइट्स

$i=0,map{push@{$a[$i++]},$_}/./g for<>;print@$_ for@a

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

तरीका

एक दो आयामी सरणी बनाता है जहां पंक्तियों की संख्या सबसे लंबे स्ट्रिंग की लंबाई के बराबर होती है और स्तंभों की अधिकतम संख्या तार की संख्या के बराबर होती है। फिर सरणी के प्रत्येक पंक्ति को रिक्ति के बिना आउटपुट करें।

— Xcali
स्रोत

0

TXR लिस्प , 20 बाइट्स

(opip weave cat-str)

चलाएँ:

1> (opip weave cat-str)
#<intrinsic fun: 0 param + variadic>
2> [*1 "LYES" "APRONS"]
"LAYPERSONS"
3> [*1 "ABCDE" "a c" "" "123 567"]
"Aa1B 2Cc3D E567"
4> [*1 "\"\\n$?*" "" ",(.) "]
"\",\\(n.$)? *"

weaveसमारोह आलसी तो यह एक सूची, रिटर्न जो कारण है कि हम एक स्ट्रिंग के लिए परिणाम के लिए मजबूर करने के लिए है है। आलसी होने के कारण, यह अनंत अनुक्रम बुन सकता है। उदाहरण के लिए, हम सम और विषम प्राकृतिक संख्याएँ बुन सकते हैं, जो स्वयं अनंत आलसी सूचियाँ हैं:

5> (take 20 (weave (range 2 : 2) (range 1 : 2)))
(2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19)

— Kaz
स्रोत

0

के (ओके) , 35 29 बाइट्स

समाधान:

{`c$r@&~^r:,/+(`i$x)[;!#,/x]}

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

उदाहरण:

> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("ABCDE";"a c";"123 567")
"Aa1B 2Cc3D E567"
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("\n$?*";"";",(.)\" ")
"\n,$(?.*)\" "
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("POLLS";"EPEES")
"PEOPLELESS"

स्पष्टीकरण:

सभी इनपुट सूचियों में 0 से अधिकतम (चपटी सूची की लंबाई) के सूचकांकों को बाहर निकालने के लिए 2-स्तरीय अनुक्रमण का उपयोग करें। उप-सूची की सीमा से परे कोई भी अनुक्रमण एक अशक्त लौटेगा। फ्लिप (90 घुमाएगी), समतल करें, और फिर गैर-अशक्त परिणामों को बाहर निकालें।

टिप्पणियाँ:

मैं पूर्णांक ( i$) में जाता हूं ताकि हमें उपयोगी नल मिलें, क्योंकि अंतरिक्ष ( ) को चार सूची के लिए शून्य माना जाता है, जिसका अर्थ है कि आप मान्य स्थानों से नल को बता सकते हैं।
इसके अलावा, मैं इनपुट के साथ काम करने के लिए TIO को प्राप्त नहीं कर सका (OK उत्तर में ठीक काम किया है) इसलिए TIO लिंक में "ABCDE" ... उदाहरण शामिल है।

— streetster
स्रोत

0

Jq 1.5 , 49 बाइट्स

map(explode)|transpose|map(map(values)[])|implode

व्याख्या

                      # example input:          ["LYES","APRONS"]
  map(explode)        # make list of ordinals   [[76,89,69,83],[65,80,82,79,78,83]]
| transpose           # zip lists               [[76,65],[89,80],[69,82],[83,79],[null,78],[null,83]]
| map(map(values)[])  # rm nulls and flatten    [76,65,89,80,69,82,83,79,78,83]
| implode             # convert back to string  "LAYPERSONS"

नमूना चलाना

$ paste input <(jq -Mrc 'map(explode)|transpose|map(map(values)[])|implode' input)
["SIMPLE"]                  SIMPLE
["POLLS","EPEES"]           PEOPLELESS
["LYES","APRONS"]           LAYPERSONS
["ABCDE", "a c", "123 567"] Aa1B 2Cc3D E567
["\"\\n$?*", "", ",(.)\" "] ",\(n.$)?"* 

$ echo -n 'map(explode)|transpose|map(map(values)[])|implode' | wc -c
  49

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

— jq170727
स्रोत

परस्पर संघर्ष

जेली , 1 बाइट

पायथन 2, 101 89 86 69 बाइट्स

पर्ल 6 , 34 32 बाइट्स

CJam , 4 बाइट्स

पायथ - 3 बाइट्स

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

टेस्ट स्निपेट

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

बिल्ड-इन का उपयोग किए बिना: ( 38 34 बाइट्स)

सी, 114 84 बाइट्स

PHP, 68 67 बाइट्स

रेटिना , 13 बाइट्स

व्याख्या

जावा, 19 + 155 = 174 160

PHP, 77 बाइट्स

golfed

दरअसल , 7 6 बाइट्स

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

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

जे , 13 बाइट्स

व्याख्या

बाश + जीएनयू उपयोगिताओं, 55

PHP, 63 बाइट्स

व्याख्या

पायथन 3, 75 बाइट्स

सी, 75 71 बाइट्स

ओरेकल SQL, 195 बाइट्स

पायथन 2, 128 96

पर्ल ५ , 28 बाइट्स

आर , 73 बाइट्स

पायथन, 112 बाइट्स

पर्ल 5 , 53 बाइट्स

TXR लिस्प , 20 बाइट्स

के (ओके) , 35 29 बाइट्स

Jq 1.5 , 49 बाइट्स