अंतरिक्ष द्वारा लंबवत रूप से अलग किए गए तीन कॉलम प्रिंट करें

Question

कार्य

• अंतरिक्ष द्वारा अलग किए गए इनपुट स्ट्रिंग को लें।
• शब्दों को वर्णानुक्रम में क्रमबद्ध करें।
• उन्हें अंतरिक्ष (एस) द्वारा अलग किए गए 3 कॉलमों में लंबवत रूप से प्रिंट करें।

चुनौती

• सभी तीन स्तंभों की ऊंचाइयों को यथासंभव समान रूप से भारित किया जाना चाहिए।
• सभी तीन स्तंभों को संरेखित किया जाना चाहिए।

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

उदाहरण

यदि इनपुट है:

"cat caterpillar pie frog elephant pizza", 

आउटपुट होना चाहिए:

cat         elephant pie
caterpillar frog     pizza

कृपया मामलों से सावधान रहें, यदि इनपुट है:

"a b c d e f g" 

के रूप में मुद्रित किया जाना चाहिए:

a c e
b d f
    g

# or

a d f
b e g
c

# and not

a d g
b e
c f

Comments

इसके अलावा, मैं आपको सख्त I / O आवश्यकता को हटाने की सलाह दूंगा; यही है, किसी भी रूप में स्ट्रिंग की सूची के रूप में इनपुट लें (उत्तरदाता चाहते हैं) और एक कार्यक्रम या सूची लेने वाले फ़ंक्शन के रूप में।

— हाइपरएन्यूट्रीनो

यह उत्पादन के लिए स्वीकार्य है यह पहला उदाहरण के लिए?

— caird coinheringaahing

@Satendra "ऑफ-टॉपिक के रूप में होल्ड पर रखने के बारे में चिंता न करें ...", जब / यदि प्रश्न पर्याप्त रूप से अच्छा है तो इसे फिर से खोल दिया जाएगा। | आप सैंडबॉक्स का उपयोग करने पर विचार कर सकते हैं।

— 15:20 बजे user202729

कृपया मुख्य साइट पर पोस्ट करने से पहले अपनी चुनौतियों पर प्रतिक्रिया प्राप्त करने के लिए भविष्य में सैंडबॉक्स का उपयोग करने पर विचार करें ।

— Mego

@ सतेन्द्र नीस पहली चुनौती। यदि सबसे कम अंतर पर कॉलम को एक ही स्थान से अलग किया जाना चाहिए, तो आपको ऐसा करना चाहिए।

— Adám

Answer 1

हस्क , 24 17 बाइट्स

TmoTT' §CȯmLTC3Ow

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

व्याख्या

यह आश्चर्यजनक रूप से मुश्किल चुनौती थी, क्योंकि हस्क के पास वर्तमान में दिए गए कई हिस्सों में एक सूची को तोड़ने के लिए एक बिलिन की कमी है।

TmoTT' §CȯmLTC3Ow  Implicit input, say s="bbb a cc ddd e"
                w  Split at spaces: x=["bbb","a","cc","ddd","e"]
             C3    Cut into slices of length 3: [["bbb","a","cc"],["ddd","e"]]
            T      Transpose: [["bbb","ddd"],["a","e"],["cc"]]
         ȯmL       Map length: [2,2,1]
                   These are the correct lengths of the columns.
       §C      O   Sort x and split into these lengths: [["a","bbb"],["cc","ddd"],["e"]]
                   These are the columns of the correct output, without padding.
 mo                For each column,
    T'             transpose and pad with spaces: [["ab"," b"," b"],["cd","cd"," d"],["e"]]
   T               then transpose back: [["a  ","bbb"],["cc ","ddd"],["e"]]
T                  Transpose the whole list: [["a  ","cc ","e"],["bbb","ddd"]]
                   Implicitly join each row by spaces,
                   join the resulting strings by newlines and print.

Answer 2

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

Ṣœs3ZG

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

Comments

@DLosc यह वास्तव में a b c d e f gमामले के साथ भी परीक्षण किया गया है, और मैंने अन्य व्यापक परीक्षण किए क्योंकि मुझे पहले भी ऐसा महसूस हुआ था। ओह, और इसकी कमी से आता है G( जी छुटकारा के रूप में प्रारूप ) बिलिन।

— एर्ग आउटफोलर

आह, एक बिलिन है। (मैं हैरान क्यों हूं?) जो बहुत कुछ समझाता है।

— DLosc 7

Answer 3

अजगर ३ , 148 बाइट्स

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

l=sorted(input().split())
n=-~len(l)//3
f=lambda l:[i.ljust(max(map(len,l)))for i in l+['']]
for i in zip(f(l[:n]),f(l[n:n*2]),f(l[n*2:])):print(*i)

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

इस पर वर्किन ’। मैंने जो कुछ भी आज़माया है वह उत्पादन को लोप कर देता है ...

Comments

148 बाइट्स का उपयोग पायथन 3.

— 15

Answer 4

मैथेमेटिका, 115 बाइट्स

Grid[Transpose@PadRight@TakeList[#,Last@IntegerPartitions[Tr[1^#],3]]&@Sort@StringSplit@#/. 0->"",Alignment->Left]&

इसे वुल्फराम सैंडबॉक्स पर आज़माएं

निम्नलिखित कोड पेस्ट करें और Shift + एंटर दबाएं

Grid[Transpose@PadRight@TakeList[#,Last@IntegerPartitions[Tr[1^#],3]]&@Sort@StringSplit@#/. 0->"",Alignment->Left]&["cat caterpillar pie frog elephant pizza"]

Comments

@HalvardHummel तय

— J42161217

Answer 5

पर्ल 5 , 134 + 1 ( -a) = 135 बाइट्स

$.=(sort{$b=~y///c-length$a}(@F=sort@F))[0]=~y///c;@a=splice@F,0,@F/3;@b=splice@F,0,@F/2;printf"%-$.s "x3 .$/,shift@a,shift@b,$_ for@F

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

Comments

इसका क्या मतलब है?

— xyz123

Answer 6

05AB1E , 8 बाइट्स

#{.B3äζ»

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

---

#        | Split on spaces.
 {       | Sort aphabetically.
  .B     | Pad to max string length.
    3ä   | Split into columns.
      ζ  | Transpose.
       » | Print with newlines.

Answer 7

जावास्क्रिप्ट 181 175 बाइट्स

f=a=>(a=a.split` `).sort().map(c=>(t[y]=[...t[y]||[],c],M[x]>(l=c.length)?0:M[x]=l,a[++y*3+x]?y:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`
`

console.log(f("cat caterpillar pie frog elephant pizza"))
console.log("-------------------")
console.log(f("cat caterpillar pie frog frog123123 pizza"))
console.log("-------------------")
console.log(f("a b c d e f g"))
console.log("-------------------")
console.log(f("a b c d e f"))
console.log("-------------------")
console.log(f("a b c d e"))
console.log("-------------------")
console.log(f("a b c d"))

/*
f=a=>(a=a.split` `).sort().map(c=>((t[y] =t[y]||[])[x]=c,M[x]>(l=c.length)?0:M[x]=l,++y*3+x<a.length?0:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`\n`

f=a=>(a=a.split` `).sort().map(c=>(t[y]=[...t[y]||[],c],M[x]>(l=c.length)?0:M[x]=l,++y*3+x<a.length?0:y=x++*0),M=[t=[x=y=0]])&&t.map(x=>x.map((c,y)=>c.padEnd(M[y])).join` `).join`\n`

*/

Answer 8

जे , 73 बाइट्स

,.@(' ',"1[:>|:)@((](s,(s=.]{.1:),(1:{.~[-2*]))([:<.0.5+%&3))@#];.1])@/:~

मैं इस गड़बड़ी को बाद में समझा सकता हूं अगर कोई दिलचस्पी रखता है।

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

Answer 9

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

≔⪪θ ηＦη«⊞υ⌊η≔⟦⟧ηＦ⪪θ ¿¬№υκ⊞ηκ»ＦＥ³✂υ÷×ιＬυ³÷×⊕ιＬυ³Ｉ1«Ｐ⪫ι¶¿ιＭ⊕⌈ＥιＬκ→

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अगर मुझे 3 शब्दों से कम के मामले को संभालना नहीं है तो 2 बाइट्स सहेजें। वहाँ शायद एक छँटाई "eval" मैं का उपयोग किया जाना चाहिए ... स्पष्टीकरण:

≔⪪θ η

रिक्त स्थान पर इनपुट विभाजित करें।

Ｆη«⊞υ⌊η≔⟦⟧ηＦ⪪θ ¿¬№υκ⊞ηκ»

सरणी को सॉर्ट करें।

ＦＥ³✂υ÷×ιＬυ³÷×⊕ιＬυ³Ｉ1«

सरणी के लगभग तीन बराबर स्लाइस पर लूप करें। ( Ｉ1वास्तव में होना चाहिए ¦¹।)

Ｐ⪫ι¶

नए सिरे से स्लाइस में शामिल हों और कर्सर को स्थानांतरित किए बिना इसे प्रिंट करें।

¿ιＭ⊕⌈ＥιＬκ→

यदि स्लाइस खाली नहीं है, तो स्लाइस में सबसे लंबे शब्द की लंबाई से एक गुना अधिक सही है।

Answer 10

न्यूनतम जेएस के 358 बाइट्स:

function f(b){let d=[,,,],e=b.split(" ").sort(),g=[],h=[];for(var j in e){var k=Math.min(2,Math.floor(j/Math.floor(e.length/3)));d[k]||(d[k]=[],g[k]=e[j].length),d[k].push(e[j]),2==k&&h.push(""),g[k]=Math.max(e[j].length,g[k])}for(var o in g)for(var p=0;p<g[o]+1;p++)for(var q in h)h[q]+=q>=d[o].length||p>=d[o][q].length?" ":d[o][q][p];return h.join("\n")}

function f(b){let d=[,,,],e=b.split(" ").sort(),g=[],h=[];for(var j in e){var k=Math.min(2,Math.floor(j/Math.floor(e.length/3)));d[k]||(d[k]=[],g[k]=e[j].length),d[k].push(e[j]),2==k&&h.push(""),g[k]=Math.max(e[j].length,g[k])}for(var o in g)for(var p=0;p<g[o]+1;p++)for(var q in h)h[q]+=q>=d[o].length||p>=d[o][q].length?" ":d[o][q][p];return h.join("\n")}

console.log(f("cat caterpillar pie frog elephant pizza"));
console.log(f("a b c d e f g"));

Comments

@StephenLeppik np

— jamespgilbert

Answer 11

GNU sed , 92 + 1 = 93 बाइट्स

+1 बाइट्स के लिए -rध्वज के ।

मैंने इसे बिल्कुल नहीं देखा है, लेकिन यह मेरी अपेक्षा बहुत सरल था।

s/$/ /
s/(\S+ ){1,3}/:&\n/g
:
s/:(\S)/\1:/g
/:\S/!bZ
s/: / &/g
t
:Z
s/: / :/g
t
s/ *:.*$//gm

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

Answer 12

बॉर्न शेल, 172 बाइट्स

F=/tmp/t
<$1 tr \  \\n|sort>$F
N=$(wc -w $F|awk '{print $1/3}')
for i in 0 1 2
do
awk 'NR%N==C {print}' N=$N C=$i $F 
done|awk '{printf "%s%s",$1,NR%3?" ":"\n"}'|column -t

पारंपरिक रूप से स्वरूपित होने पर यह अधिक पठनीय है:

#! /bin/sh
F=/tmp/t
<$1 tr \  \\n | sort > $F
N=$(wc -w $F | awk '{print $1/3}')

for i in 0 1 2
do    
    awk -v N=$N -v C=$i 'NR % N == C {print}' $F 
done |
    awk '{printf "%s%s", $1, NR % 3 == 0? "\n" : " " }' | column -t

प्रति कॉलम एक बार इनपुट को स्कैन करने की कीमत पर, यह कोई सरणियों का उपयोग नहीं करता है। एक अधिक जटिल awk प्रोग्राम 3 फ़ाइलों (प्रत्येक Nth शब्द के लिए एक) को खोल सकता है, इनपुट को एक पास में संसाधित करता है। फिर उन्हें एक ही अंतिम पंक्ति का उपयोग करके समेटा और मुद्रित किया जा सकता है।

चर Nकी सख्त जरूरत नहीं है; 4 बाइट्स की कीमत के लिए, हम 3 बार इनपुट को स्कैन करने से बचाते हैं।

Comments

PPCG में आपका स्वागत है! चूंकि यह एक कोड गोल्फ चुनौती है, इसलिए हमें बायटेकाउंट को कम से कम करने के लिए सभी उत्तरों की आवश्यकता होती है। आप ऐसा कर सकते हैं कि आपने जिन तरीकों का उल्लेख किया है - व्हाट्सएप को हटाना, चालान को छोटा करना, आदि एक बार जब आप ऐसा कर लेते हैं, तो अपने उत्तर में एक हेडर जोड़ें जिसमें प्रयुक्त भाषा और बाइट्स की संख्या होती है। और अपने वर्तमान संस्करण को "अनलॉल्फ़्ड" समाधान के रूप में रखने के लिए स्वतंत्र महसूस करें।

— DLosc

आप 358 बाइट कार्यक्रम के बारे में एक दृश्य क्यों नहीं बना रहे हैं?

— xyz123