केंद्र पाठ!


40

केंद्र पाठ!

इस चुनौती में आप विभिन्न लाइनों को केंद्रित करेंगे।

उदाहरण

Foo
barbaz

 Foo
barbaz
Hello
World

Hello
World
Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

विशेष विवरण

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

आपको इनपुट में सबसे लंबी लाइन के बीच केंद्रित होना चाहिए। यदि वह रेखा लंबाई में भी है, तो आपके प्रोग्राम / फ़ंक्शन को बाईं ओर केंद्र में रखना चाहिए। अधिकतम पंक्ति की लंबाई जो भी आपकी भाषा को संभाल सकती है लेकिन आपके कार्यक्रम को लंबाई में कम से कम 500 की लाइनों पर कार्य करना चाहिए।


लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


यह बाइट्स जीत में इतना छोटा कोड है!


एक से अधिक आंतरिक-स्थान कभी नहीं होंगे?
बिल्ली

@cat वहाँ कभी नहीं होगा किसी भी प्रमुख खाली स्थान या एक लाइन पर पिछली श्वेत रिक्ति (newline के लिए उम्मीद अगर वहाँ एक है)
Downgoat

हां, लेकिन मेरा मतलब है कि आंतरिक- शब्द, जैसे, शब्दों के बीच
बिल्ली

1
@cat ओह, शब्दों के बीच एक से अधिक व्हाट्सएप हो सकते हैं। उदाहरण के लिए foo(space)(space)(space)barएक पूरी तरह से स्वीकार्य इनपुट है
डाउनगैट

क्या हम मान सकते हैं कि हमेशा 1 से अधिक लाइन होगी?
गेमक्रॉप्स

जवाबों:


15

पायथ, 19 17 बाइट्स

2 बाइट्स जकूबे के लिए धन्यवाद

V.ztr+1.[l.T.zNd6

प्रदर्शन

मुझे लगता है कि यह पहली बार केंद्र-पैड का कार्य .[उपयोगी रहा है। सबसे लंबी लाइन की लंबाई गैर-ट्रंकिंग ट्रांज़ोज़ ( .T) का उपयोग करके पाई जाती है ।

अनुगामी रिक्त स्थान को सामने की ओर एक गैर-स्थान वर्ण जोड़कर, रिक्त स्थान को हटाकर, फिर जोड़े गए वर्ण को हटा दिया जाता है।


1
हमें संभवतः सरणी में अधिकतम लंबाई की आवश्यकता है। यह बहुत बार आता है। +1
माल्टीसेन

विनिर्देशों का कहना है कि "आउटपुट में व्हाट्सएप को अनुगामी करने की अनुमति नहीं है।" ऐसा प्रतीत होता है कि आउटपुट में प्रत्येक छोटी लाइन पर व्हॉट्सएप का पता चलता है, इसलिए मुझे यकीन नहीं है कि यह मायने रखता है।
आलू

@ पोटेटो धन्यवाद - जब से मैंने उत्तर दिया, वह जोड़ा गया।
इसहाक

31

विम, 43 36 35 बाइट्स

VGrx:sor
G:let &tw=col("$")
uu:%ce

पोस्ट न करना बहुत अच्छा है। अनुगामी न्यूलाइन पर ध्यान दें; यह महत्वपूर्ण है।

एक पात्र को बचाने के लिए @Marth का धन्यवाद !

विम-फ्रेंडली प्रारूप:

VGrx:sor<cr>G:let &tw=col("$")<cr>uu:%ce<cr>

स्पष्टीकरण:

VGrx                   replace every character with an "x"
:sor<cr>               sort (since all chars are now same, sorts by line length)
G                      go to the very last line
:let &tw=col("$")<cr>  set &tw to column number of last char on this line
                         "let &tw" is equivalent to "set tw"
                         tw is short for textwidth, used in :center
uu                     undo the sort, and the replacing-with-x too
:%ce<cr>               center over entire file (%), using textwidth set earlier

1
निश्चित रूप से यह सब इन्सर्ट मोड में किया जाना चाहिए, है ना?
एलेक्स ए।

9
@AlexA। इसमें से कोई भी इन्सर्ट मोड में नहीं किया गया है। ಠ_ಠ
दरवाज़े

यदि आप sor!सॉर्ट क्रम को उल्टा col("$")करने के लिए उपयोग करते हैं, तो आप उपयोग कर सकते हैं पहली पंक्ति की लंबाई प्राप्त करने के लिए (अब आदेश के बाद सबसे लंबा है) का उपयोग करने के बजाय G$, कुल 1 बाइट की बचत! संपादित करें : या आप G:let &tw=col("$")इसके बजाय क्रम क्रम और उपयोग रख सकते हैं ।
Marth

@ धन्यवाद! मैंने बाद वाला (बिना किसी विशेष कारण के) चुना।
दरवाज़े

:h :sortमेरे माध्यम से देखने पर मुझे पता चला कि आप मेल में टेक्स्ट को छोड़ने के लिए एक रेगेक्स पास कर सकते हैं, इसलिए आप :sor /./लंबाई (+4 बाइट्स) पर सॉर्ट करने के लिए उपयोग कर सकते हैं , जो आपको VGrx(-4 बाइट्स) और दूसरी पूर्ववत ( -1 बाइट्स)। आप कमांड को चेन करने के |बजाय विभाजकों का उपयोग भी कर सकते हैं <cr>, जो आपको :पहले let(-1 बाइट्स) को छोड़ देने की अनुमति देता है (ध्यान दें कि आपको sor!समाधान का उपयोग करना होगा , फिर Gएक पूर्व कमांड नहीं है)। तो :sor! /./|let &tw=col("$")|u|%ce (एक अनुगामी के साथ <CR>) 2 बाइट्स बचाना चाहिए।
मारुत

23

गणितज्ञ, 96 बाइट्स

StringRiffle[#~StringPadLeft~Floor[Max@(l=StringLength)@a/2+l@#/2]&/@(a=#~StringSplit~"
"),"
"]&

मुझसे यह मत पूछिए कि यह कैसे काम करता है, मैंने तब तक इसके साथ काम किया जब तक कि यह सही उत्पादन नहीं हुआ।


27
+1 के लिए "मुझसे यह न पूछें कि यह कैसे काम करता है, मैंने इसके साथ तब तक काम किया जब तक कि यह सही आउटपुट नहीं बन गया"
बिल्ली

4
@ मुझे लगता है कि मैं अपने सभी गोल्फ कैसे करूँ।
lirtosiast

11

फंकिटॉन , गैर-प्रतिस्पर्धी

इस चुनौती ने आलसी दृश्यों के लिए एक "अधिकतम मूल्य" (और न्यूनतम मूल्य) समारोह की कमी को उजागर किया है, इसलिए ... मैंने उन्हें मूल पुस्तकालय (वे क्रमशः ⊤ और ⊤ कहा जाता है) में जोड़ा। इसलिए मैंने इसे गोल्फ के जवाब के रूप में प्रस्तुत करने की जहमत नहीं उठाई (इसे मान्य होने के लिए ation फ़ंक्शन घोषणा में शामिल करना होगा), इसलिए यहां सिर्फ मुख्य कार्यक्रम है।

(function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})()अपने ब्राउज़र कंसोल में कुछ अच्छा प्रतिपादन प्राप्त करने के लिए निष्पादित करें।

   ╓───╖         ╔════╗  ┌───╖  ╔═══╗
 ┌─╢ ‡ ╟─┐       ║ 10 ╟──┤ ǁ ╟──╢   ║
 │ ╙───╜ │       ╚════╝  ╘═╤═╝  ╚═══╝
 │ ┌───╖ │  ┌──────────────┴──────────────────┐
 └─┤ ‼ ╟─┘┌─┴─╖ ┌───╖ ┌───╖ ┌───╖ ┌───╖       │     │
   ╘═╤═╝  │ ɱ ╟─┤ ⊤ ╟─┤ + ╟─┤ ~ ╟─┤ ℓ ╟───┐ ┌─┴─╖ ┌─┴─╖ ╔════╗
     │    ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═══╝ ╘═══╝   │ │ ɱ ╟─┤ ʝ ╟─╢ 10 ║
    ┌───╖ ╔═╧═╕ ╔═══╗ ┌─┴──╖ ┌───╖ ╔════╗ │ ╘═╤═╝ ╘═══╝ ╚════╝
  ┌─┤ ℓ ╟─╢   ├─╢ 1 ║ │ >> ╟─┤ … ╟─╢ 32 ║ │   │
  │ ╘═══╝ ╚═╤═╛ ╚═╤═╝ ╘═╤══╝ ╘═╤═╝ ╚════╝ │ ╔═╧═╕ ╔═══╗
  └─────────┘     └─────┘      │   ┌───╖  ├─╢   ├─╢ 0 ║
                               └───┤ ‡ ╟──┘ ╚═╤═╛ ╚═══╝
                                   ╘═╤═╝      │
                                     └────────┘

व्याख्या

मेरा मानना ​​है कि इस साइट पर यह पहला फंसीटॉन जवाब हो सकता है जो लैम्ब्डा अभिव्यक्ति का उपयोग करता है।

  • सबसे पहले, हम ǁnewlines (ASCII 10) पर इनपुट स्ट्रिंग को विभाजित करने के लिए उपयोग करते हैं । यह एक आलसी अनुक्रम देता है।
  • हम उस अनुक्रम को ɱ(मानचित्र) से गुजरते हैं , यह एक लंबो देते हैं जो प्रत्येक स्ट्रिंग की लंबाई की गणना करता है, और फिर सबसे लंबी लाइन की लंबाई प्राप्त करने के लिए अंतिम अनुक्रम से गुजरता है।
  • हम उस अनुक्रम को दूसरे के माध्यम से भी पास करते हैं ɱ, यह एक लंबो प्रदान करता है जो प्रत्येक स्ट्रिंग की लंबाई की गणना करता है, इसे पहले की गणना की गई अधिकतम पंक्ति लंबाई से घटाता है, 2 से विभाजित करता है (वास्तव में शिफ्ट-राइट 1), कई रिक्त स्थान (ASCM 32) उत्पन्न करता है और फिर उन जगहों पर स्ट्रिंग को समतल करता है। (ज्यामितीय कारणों के लिए, मैंने एक फ़ंक्शन घोषित किया है जो उल्टे मापदंडों के साथ कॉल (स्ट्रिंग समवर्ती) करता है।)
  • अंत में, हम ʝविभाजक के रूप में newlines (ASCII 10) का उपयोग करके सभी तारों को एक साथ वापस लाने के लिए उपयोग करते हैं।

+1 यह कितना भयानक है और "यह 716 अक्षर है, कुल 1,508 बाइट्स"
बिल्ली

9

रेटिना , 54 52 बाइट्स

+m`^(.)+$(?<=(?=[^\t]*^..(?<-1>.)+(?(1)^))[^\t]*)
 $0 

\tरों वास्तविक टैब के साथ प्रतिस्थापित कर सकते हैं, लेकिन मैं का उपयोग किया है \tयहाँ, क्योंकि अन्यथा एसई रिक्त स्थान के लिए टैब में परिवर्तित कर देंगे। ध्यान दें कि दूसरी पंक्ति में एक अग्रणी स्थान है।

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

व्याख्या

मूल विचार एक पंक्ति से मेल खाता है जो कम से कम दो वर्णों में सबसे लंबी रेखा (या तकनीकी रूप से, किसी भी अन्य पंक्ति की तुलना में दो वर्णों से कम) से दो वर्णों की दूरी पर है , और इसे दो स्थानों में घिरा हुआ है। यह दोहराया जाता है जब तक कि हम अब ऐसी रेखा नहीं पा सकते हैं, जिसका अर्थ है कि सभी रेखाएं अधिकतम लंबाई के एक वर्ण के भीतर हैं (जहां एक वर्ण समता बेमेल के लिए खाता है, और गारंटी देता है कि इन पंक्तियों को बाईं ओर स्थानांतरित कर दिया गया है- बीच में)।

वास्तविक रेगेक्स के लिए:

^(.)+$

1प्रत्येक वर्ण के लिए समूह पर एक कब्जा धकेलते समय बस किसी एक पंक्ति से मेल खाता है ।

(?<=...[^\t]*)

एक लुकबाइंड है जो दाएं-बाएं से मेल खाता है और कर्सर को स्ट्रिंग की शुरुआत में ले जाता है, ताकि अंदर का लुकहेड पूरी स्ट्रिंग की जांच कर सके। ध्यान दें कि एंकर की कमी के कारण, लुकहेड को कहीं और से लागू किया जा सकता है, लेकिन यह अतिरिक्त मैचों का निर्माण नहीं करता है। हम जानते हैं कि [^\t]हमेशा स्ट्रिंग में किसी भी वर्ण से मेल खाएगा , क्योंकि इनपुट में केवल रिक्त स्थान और लाइनफीड शामिल करने की गारंटी है जहां तक ​​व्हाट्सएप का संबंध है।

(?=[^\t]*^..(?<-1>.)+(?(1)^))

यह लुकहैड एक पंक्ति खोजने की कोशिश करता है जो कि वर्तमान में हमारे द्वारा मेल खाने वाले की तुलना में कम से कम दो वर्ण लंबा है। [^\t]*किसी भी लाइन से मेल खाने में सक्षम होने के लिए स्ट्रिंग के माध्यम से चलता है। ^यह सुनिश्चित करता है कि हम लाइन की शुरुआत से शुरुआत कर रहे हैं। ..फिर दो अतिरिक्त वर्णों से मेल खाता है जिनकी हमें लंबी रेखा के लिए आवश्यकता होती है। अब (?<-1>.)+समूह से पॉपिंग करते समय उस पंक्ति में अलग-अलग वर्णों से मेल खाता है 1(ध्यान दें कि .लाइनफीड से मेल नहीं खा सकता है, इसलिए यह एक लाइन के लिए विवश है)। अंत में, (?(1)^)दावा करता है कि हम पूरे समूह को खाली करने में कामयाब रहे 1। यदि लाइन आवश्यकता से कम है, तो यह संभव नहीं है, क्योंकि समूह 1 से पॉप करने के लिए लाइन में पर्याप्त वर्ण नहीं हैं जो अक्सर इसे खाली करने के लिए पर्याप्त हैं।


7

जोल्फ , 3 बाइट्स

नॉन-कंपेटिंग, अपडेट पोस्टेड प्रश्न।

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

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / it मुझे लगा कि यह एक उपयोगी कार्य होगा।


1
यह एक मानक ढील है, और स्पष्ट रूप से अस्वीकृत-अनुमति नहीं है, इसका बुरा रूप तब तक है जब तक कि यह आपके द्वारा बनाई गई भाषा में नहीं बनता, न कि आप इसे बनाते हैं।
एलियास बेनेवेदेस

3
@EliasBenevedes मैंने प्रतियोगिता से पहले फीचर जोड़ा। मैं अक्सर अपने कोड को तब तक अपडेट नहीं करता जब तक यह रीलेवेंट नहीं हो जाता।
कॉनर ओ'ब्रायन

7

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

s=>(m=l=s.split`
`).map(x=>(v=x.length/2)<m?v:m=v).map((x,i)=>" ".repeat(m-x)+l[i]).join`
`

2 बाइट्स @ edc65 की बदौलत बच गए !

व्याख्या

s=>(
  m=                // m = max line length (divided by 2)
    l=s.split`
`)                  // l = array of lines
.map(x=>            // for each line
  (v=x.length/2)    // v = current line length / 2
    <m?v:m=v        // set m to the max line length and return v
)
.map((x,i)=>        // for each line length / 2
  " ".repeat(m-x)   // add spaces before
    +l[i]           // add line text
)
.join`
`                   // return lines as a newline-separated string

परीक्षा


.repeatगैर-पूर्णांक मानों को स्वीकार और काट- |0
छाँट

7

CJam, 26 23 19 बाइट्स

qN/_z,f{1$,m2/S*\N}

मेरा पहली बार CJam का उपयोग करते हुए! चार बाइट्स ने मार्टिन ब्यूटनर को धन्यवाद दिया। इसे ऑनलाइन आज़माएं।

व्याख्या

qN/    e# Read input and split each line
_z,    e# Transpose a copy and get its length to find the longest line
f{     e# For each line...
  1$,- e# Subtract its length from the longest length
  2/   e# Divide by two to get just the spaces to add to the left
  S*\  e# Add a string with that many spaces to the beginning
  N    e# Add a newline to go on to the next line
}

1
यहाँ कुछ सुझाव दिए गए हैं :)qN/_z,f{1$,m2/S*\N}
मार्टिन एंडर

6

LabVIEW, 3 या 35 LabVIEW प्रिमिटिव

जब तक कोई नहीं छोड़ता है, तब तक लाइनों को ढूँढता है, फिर गणना करता है कि सब कुछ जोड़ने और डालने के लिए कितने स्थान हैं।

वैकल्पिक रूप से आप स्ट्रिंग संकेतकों पर अंतर्निहित केंद्र संरेखण का उपयोग कर सकते हैं, यह थोड़े हालांकि धोखा देने जैसा महसूस करता है।


6

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

def f(s):
 t=s.split('\n')
 for y in t:print(max(len(f)for f in t)-len(y))/2*' '+y  

2 वर्णों को बचाने के लिए @xnor को धन्यवाद

उदाहरण इनपुट:

f("""Programming Puzzles
&
Code Golf""")

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

Programming Puzzles
         &
     Code Golf

और str.center () और str.rstrip (धन्यवाद @JF) का उपयोग करके 84 बाइट्स के साथ दूसरे स्थान पर समाप्त होता है।

def f(s):
 t=s.split('\n')
 for y in t:print y.center(max(len(f)for f in t)).rstrip()

यह lenआपके द्वारा दो बार उपयोग किए जाने वाले चर को असाइन करने के लिए चार्ट को नहीं बचाता है - जो 5 चार्ट (जैसे range) पर भी टूटता है । इसके अलावा, आप mapसूची COMP के लिए उपयोग कर सकते हैं ।
xnor

@ ट्रेलम, आप ट्रेलिंग स्थान से छुटकारा पाने के लिए str.rstrip()कॉल centerकरने के बाद उपयोग कर सकते हैं ।
JF

आप एक पूर्ण कार्यक्रम के साथ 7 बाइट्स बचा सकते हैं और उपयोग कर सकते हैं len(max(a,key=len)), यह देखें
ბიმო

5

टीस्क्रिप्ट , 24 बाइट्स

£p.R((aßln)¯-ln)/2)+l,§)

लाइनों के माध्यम से लूप्स, floor((max line length - line length) / 2)शुरुआत में रिक्त स्थान जोड़ता है ।

Ungolfed

£   p.R((aß  ln)¯  -ln)/2)+l,§   )
xl(#p.R((am(#ln)X()-ln)/2)+l,`\n`)

xl(#    // Loops through newlines
    p.R(   // Repeats spaces
      (
       am(#ln)    // Map all line lengths
              X() // Get largest line length
       -ln)       // Subtract current line length
      /2)  // Divide by two
      +l,  // Add current line text
`\n`)

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


5
मेरे जवाब क्यों कम होते जा रहे हैं? मुझे लगता है कि उपयोगकर्ता नाम / अवतार बदलने का समय आ गया है: पी
डाउनगोट

2016-07-27 के अनुसार निश्चित किया गया। : पी
user48538

5

पावरशेल, 58 67 बाइट्स

58 बाइट्स नीचे @ mazzy की टिप्पणियों के लिए धन्यवाद:

param($a)$a|%{$_|% *ft(($a|% le*|sort)[-1]/2+$_.length/2)}


# It takes an array of strings as input
PS C:\Temp> .\center.ps1 'aaa','bb','c'
aaa
bb
 c


# Or here, read from a file
PS C:\Temp> .\center.ps1 (gc t.txt)
info0:info1:info2:info3
      info0:info1
          ttt
          tt
           t
  • यह स्ट्रिंग की एक सरणी लेता है $a, प्रत्येक स्ट्रिंग के साथ छोरों पर |%{...}
  • शॉर्टकट के string.padleft()माध्यम से प्रत्येक स्ट्रिंग पर विधि को कॉल करता है % -member, जो पैरामीटर के रूप में वांछित अंतिम पंक्ति की लंबाई लेता है।
    • ज़रुरत है array_longest_line_length/2 + current_line_length/2
    • अंतिम भाग है current_line_length/2->$_.length/2
    • अन्य भाग लूप के माध्यम से हर बार सरणी की अधिकतम लाइन लंबाई को पुन: परिकलित कर रहा है, और ऐसा ऐसा होता है कि नेस्टेड लूप के साथ लाइन की लंबाई का एक सरणी बनाते हैं, इस प्रकार, फिर अंतिम एक लेता है।

आप 58 बाइट पाने के लिए
शॉर्टनिंग

1
@ माज़ी बेहतर है! चूँकि आपने उत्तर के रूप में पोस्ट नहीं किया था, इसलिए मैंने अपने उत्तर को क्रेडिट के साथ संपादित किया है।
TessellatingHeckler

3

एमएसीएस लिस्प, 203 बाइट्स

(let((f 0)(l 0))(dolist(s(split-string(buffer-string)"\n"))(set'l(string-width s))(when(> l f)(set'f l)))(let((fill-column f))(goto-char(point-min))(while(<(point)(point-max))(center-line)(next-line)))))

Ungolfed:

(let ((f 0) (l 0))
  (dolist (s (split-string(buffer-string) "\n"))
    (set 'l (string-width s))
    (when (> l f)
      (set 'f l)))
    (let ((fill-column f))
      (goto-char (point-min))
      (while (< (point) (point-max))
        (center-line)
        (next-line)))))

केंद्रित:

               (let ((f 0) (l 0))
 (dolist (s (split-string(buffer-string) "\n"))
           (set 'l (string-width s))
                 (when (> l f)
                  (set 'f l)))
             (let ((fill-column f))
            (goto-char (point-min))
         (while (< (point) (point-max))
                 (center-line)
                (next-line)))))

3

HTML, 40 बाइट्स

<xmp style=float:left;text-align:center>

स्निपेट में </xmp>टैग शामिल है क्योंकि कोड स्निपेट दर्शक चाहता है कि मेरे टैग संतुलित रहें।


2

MATL , 22 31 बाइट्स

`jtYz~]xXhc4X4H$ZuZ{Zv

प्रत्येक पंक्ति एक अनुगामी रेखा के साथ इनपुट है (जो कि enterकीस्ट्रोक है)। एक खाली रेखा (दो enterकीस्ट्रोक्स) इनपुट के अंत को चिह्नित करती है।

उदाहरण

>> matl `jtYz~]xXhc4X4H$ZuZ{Zv
> foo
> barbaz
> 
 foo
barbaz

व्याख्या

`          % do...
  j        % input one string
  tYz~     % is it not empty?
]          % ...while
x          % delete last input (empty string)
Xh         % concatenate all inputs into a cell array
c          % convert to char (2D array). This fills with spaces to the right
4X4H$Zu    % center justify
Z{         % convert to cell array of strings
Zv         % remove trailing blanks of each string

2

रूबी, 76 68 61 बाइट्स

->t{(s=t.split$/).map{|l|l.center(s.map(&:size).max).rstrip}}

नमूना रन:

2.1.5 :001 > puts ->t{(s=t.split$/).map{|l|l.center(s.map(&:size).max).rstrip}}["Programming Puzzles\n&\nCode Golf"]
Programming Puzzles
         &
     Code Golf

53 बाइट्स:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
डैनिएरो

मैंने centerपहले भी कोशिश की थी , लेकिन जैसा कि मैं समझता हूं, कि अकेले "अनुगामी व्हाट्सएप को आउटपुट की अनुमति नहीं है" नियम को तोड़ देगा। &:sizeभाग के लिए धन्यवाद - मैंने भी कोशिश की, लेकिन मैंने निश्चित रूप से सिंटैक्स के आसपास कुछ धमाका किया।
मैनटवर्क

2

हास्केल, 111 81 77 बाइट्स

l=length
f s|q<-lines s=unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q]

F फ़ंक्शन के लिए इनपुट, आउटपुट मुद्रित नहीं है।

उपयोग: इंटरप्रेटर में लोड करें ghci center.hsऔर फिर यदि आप दिए गए स्ट्रिंग पर f का आउटपुट प्रिंट करना चाहते हैंputStr$f"Programming Puzzles\n&\nCode Golf"

संपादित करें: 34 बाइट्स के लिए nimi के लिए धन्यवाद , बहुत अच्छा काम! : डी


दो और बातें: प्रस्तावना के नवीनतम संस्करण का एक इन्फ़िक्स संस्करण भी शामिल है map: <$>replicate(...)' 'द्वारा प्रतिस्थापित किया जा सकता है [1.. ...]>>" "। सभी में सभी unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q]:।
नीमी

हाँ, मुझे याद है कि मैंने पिछले सबमिशन में नए मैप इन्फिक्स का उल्लेख किया था। प्रतिकृति चाल कैसे काम करती है?
तुलसी-मुर्गी

l1 >> l2बनाता है (लंबाई l1) l2 की प्रतियां और उन्हें संघनित करता है। जैसे "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<(एकल सूची में 1,2 की 4 प्रतियां)। हमारे मामले में यह [1..n]>>" "एक स्पेस की n प्रतियां है जो कि जैसा है वैसा ही replicateहै।
निम्मी

अच्छा, स्पष्टीकरण के लिए धन्यवाद! :)
तुलसी-मुर्गी

2

आर, 126 बाइट्स

कोड

for(z in 1){l=scan(,"");m=sapply(l,nchar);t=max(m[m==max(m)]);for(i in 1:length(m))cat(rep(" ",(t-m[i])/2),l[i],"\n", sep="")}

ungolfed

for(z in 1){                          # any way to get rid of this?
  l=scan(,"")
  m <- sapply(l,nchar)
  t <- max(m[m==max(m)])
  for(i in 1:length(m)){
    cat(rep(" ",(t-m[i])/2),l[i],"\n", sep="")
  }
}

संभवतः ऐसा करने के लिए बेहतर तरीके हैं, फिर भी इस पर काम करना है।


1

गीमा, 160 बाइट्स

\L<T>=@push{i;$0}@set{m;@cmpn{@length{$0};${m;};$m;$m;@length{$0}}}
?=
\Z=@repeat{@sub{@line;1};@set{o;@right{@div{@add{$m;@length{$i}};2};$i}\n${o;}}@pop{i}}$o

ज्यादातर मेरी उत्सुकता के लिए लिखा गया है कि उचित सरणी संरचना और उचित लूप निर्देश के बिना भाषा में क्या किया जा सकता है।

नमूना रन:

bash-4.3$ gema '\L<T>=@push{i;$0}@set{m;@cmpn{@length{$0};${m;};$m;$m;@length{$0}}};?=;\Z=@repeat{@sub{@line;1};@set{o;@right{@div{@add{$m;@length{$i}};2};$i}\n${o;}}@pop{i}}$o' <<< $'Programming Puzzles\n&\nCode Golf'
Programming Puzzles
         &
     Code Golf

1

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

$/=(my@l=lines)».chars.max;for @l {put ' 'x($/-.chars)/2~$_} # 61 bytes

उपयोग:

$ perl6 -e '$/=(my@l=lines)».chars.max;for @l {put " "x($/-.chars)/2~$_}' <<< \
'Programming Puzzles
&
Code Golf'
Programming Puzzles
         &
     Code Golf

पर्ल 5 आपको for @l {2 बाइट्स शेविंग करने और दूसरी बाइट शेविंग put " "करने के लिए बदलने की अनुमति देगा put" "। क्या यह पर्ल 6 के लिए सही है? (मैं पर्ल 6. नहीं जानता।) इसके अलावा, आपका आउटपुट यहां प्रदर्शित होने के कारण आवश्यक आउटपुट से मेल नहीं खाता; क्या वह टाइपो है?
msh210

@ msh210 पर्ल 6 इसके सिंटैक्स के साथ थोड़ा अधिक प्रतिबंधक है। यह हालांकि अन्य क्षेत्रों में इसके लिए बनाता है।
ब्रैड गिल्बर्ट b2gills

1

जाप, 25 २५

¡V=VwXl}R;¡Sp½*(V-Xl¹+X}R

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

यह काम किस प्रकार करता है

¡     V=VwXl}R;¡     Sp½*(V-Xl¹ +X}R
UmXYZ{V=VwXl}R;UmXYZ{Sp½*(V-Xl) +X}R

           // Implicit: U = input string, V = 0
UmXYZ{  }  // Map each item X in U through this function,
         R // splitting U at newlines beforehand:
  V=VwXl   //  Set V to max(X, Y.length).
           // V is now set to the length of the longest line.

UmXYZ{  }  // Map each item X in U with this function,
         R // again splitting U at newlines beforehand:
 ½*(V-Xl)  //  Take V minus X.length, and multiply by 1/2.
Sp         //  Repeat a space that many times.
        +X //  Concatenate X to the end.

0

PHP , 98 बाइट्स

function($s){foreach($a=explode("
",$s)as$l)echo str_pad($l,max(array_map(strlen,$a)),' ',2),"
";}

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

Ungolfed:

function str_center( $s ) {
    $a = explode( PHP_EOL, $s );
    $m = max( array_map( 'strlen', $a ) );
    foreach( $a as $l ) {
        echo str_pad( $l, $m, ' ', STR_PAD_BOTH ), PHP_EOL;
    }
}

आउटपुट:

Programming Puzzles
         &         
     Code Golf   

-1

05AB1E , 2 बाइट्स

.c

बिल्‍ड्स ने _ \ _ (ツ) _ / Built का निर्माण किया

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

स्पष्टीकरण:

.c   # Centralize the (implicit) multi-line input-string with preference to the left
     # (output the result implicitly)

(दाईं ओर वरीयता एक पूंजी के .Cबजाय होगी: अंतर देखें ।)


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.