पाठ को दाएं-संरेखित करें

Question

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

उदाहरण के लिए, स्ट्रिंग

Programming
Puzzles
&
Code
Golf

और संख्या 5का उत्पादन होगा:

Progr
ammin
    g
Puzzl
   es
    &
 Code
 Golf

जबकि एक ही तार और संख्या 10का उत्पादन होगा:

Programmin
         g
   Puzzles
         &
      Code
      Golf

डोर

a

b

और संख्या 5 का उत्पादन होगा:

    a
      <-- note the 5 spaces
    b

सबसे छोटा कोड जीतता है!

Comments

पाठ कहता है " जब आवश्यक हो तो लाइनों को तोड़ें [...]", लेकिन आपके उदाहरण बताते हैं कि आप हर शब्द के बाद टूट जाते हैं , तब भी जब यह फिट होगा। कृपया स्पष्ट करें: क्या हम प्रत्येक शब्द को एक नई पंक्ति में रखते हैं, या क्या हम एक वास्तविक शब्द-रैपिंग एल्गोरिदम को लागू करते हैं?

— तिमवी

क्या इनपुट लाइन के बीच में रिक्त स्थान हो सकते हैं, उदा Programming Puzzles\n&\nCode Golf?

— Sp3000

@ sp3000 रिक्त स्थान सहित कोई भी वर्ण हो सकता है।

— ट्रेबुचेट

@ टिमवी: उदाहरण में प्रति पंक्ति एक शब्द है। बेहतर होगा कि कुछ बहु-शब्द लाइनों को शामिल किया जाए ताकि यह स्पष्ट हो सके कि एक पंक्ति के भीतर का स्थान विशेष नहीं है। (यानी केवल नई ख़बरें हैं, और गैर-नई ख़बरें हैं।)

— पीटर कॉर्ड्स

Answer 1

अजगर, 14 बाइट्स

jm.[\ QdscRQ.z

प्रदर्शन

पायथ के पैड ऑपरेटर का उपयोग करता है।

Answer 2

अजगर 2, 84

s,n=input()
for w in s.split('\n'):
 w=w or' '
 while w:print w[:n].rjust(n);w=w[n:]

इनपुट के रूप में एक स्ट्रिंग के साथ newlines और एक नंबर, और परिणाम प्रिंट करता है। इनपुट में प्रत्येक पंक्ति के लिए, nएक बार में चार्ट ले जाता है और प्रिंट rjustकरने से पहले रिक्त स्थान के साथ बाईं ओर पैड बनाने के लिए प्रिंट का उपयोग करता है ।

मैंने हैक के साथ खाली लाइन का मामला तय किया w=w or' '। वहाँ शायद एक बेहतर तरीका है, लेकिन मैं इसके बारे में ज्यादा सोचने वाला नहीं हूं।

Answer 3

सीजेएम, 21 बाइट्स

li_qN/Sfe|f/ff{\Se[N}

1 बाइट से गोल्फिंग के लिए @ Sp3000 को धन्यवाद और 3 और के लिए मार्ग प्रशस्त किया।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

li                     Read an integer L from the first line of input.
  _                    Push a copy.
   qN/                 Split the remaining input at linefeeds.
      Sfe|             Map `OR " "'; the replaces empty lines with a space.
          f/           Split each line into chunks of length L.
            ff{     }  For each chunk, push L and the chunk; then:
               \         Swap L with the chunk.
                Se[      Left-pad the chunk to length L by prepending " ".
                   N     Push a linefeed.

Answer 4

अजगर, १६

jm>Q+*\ QdscRQ.z

इसे यहाँ ऑनलाइन आज़माएँ

व्याख्या

jm>Q+*\ QdscRQ.z             : Q is the number on the first line, .z takes the rest
           cRQ.z             : chop each line of .z into chunks of Q characters
 m        s                  : remove nested lists and map over the result
    +*\ Qd                   : add Q spaces to each line d
  >Q                         : take the last Q characters of that result
j                            : join results on newlines

Answer 5

पर्ल, 39 बाइट्स

perl -ni5 -e 's!^$|.{1,$^I}!printf"%${^I}s
",$&!ge'

के लिए 36 बाइट्स + 3 बाइट्स -ni। रैप चौड़ाई को तर्क के रूप में पारित किया जाता है -i।

रिक्त स्थानों को ठीक से रिक्त स्थान पर रखकर उन्हें संभालती है:

$ echo -e "Programming\nPuzzles\n\n&\n\nCode\nGolf" | perl -ni5 -e 's!^$|.{1,$^I}!printf"%${^I}s
",$&!ge'
Progr
ammin
    g
Puzzl
   es

    &

 Code
 Golf

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

यह समाधान इनपुट के माध्यम से लूप में प्रतिस्थापन संचालक का उपयोग करता है, बराबर forलूप पर एक बाइट की बचत करता है । वास्तविक चाल, हालांकि प्रतिस्थापन के LHS पर regex में है:

^$|.{1,$^I}

वैश्विक संशोधक के साथ, यह $^Iएक समय में वर्णों से मेल खाएगा ; जब $^Iस्ट्रिंग में शेष अक्षर से कम हैं , तो यह सब कुछ अंत तक मेल खाएगा। ^$रिक्त लाइनों को संभालने के लिए इसके साथ प्रत्यावर्तन की आवश्यकता होती है। उदाहरण के लिए:

$ echo -e "foo\n\nbar" | perl -ni2 -E 'say "<$_>" for /^$|.{1,$^I}/g'
<fo>
<o>
<>
<ba>
<r>

प्रतिस्थापन के आरएचएस बस printfरिक्त स्थान को बाएं-पैड के साथ रिक्त स्थान के साथ उपयोग करता है।

Comments

मैं हमेशा भूल जाता हूँ $^I!

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

@DomHastings मैंने chilemagic से वह चाल सीखी, जिसने एक अन्य चुनौती पर एक टिप्पणी में इसका उल्लेख किया ।

— ThisSuitIsBlackNot

Answer 6

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

काश जेएस के पास पैड फंक्शन होता। ओह अच्छा।

(a,b)=>a.replace(eval(`/(.{${b}})(?!\\n)/g`),`$1
`).split`
`.map(c=>(Array(b).join` `+c).slice(-b)).join`
`

स्पष्टीकरण:

(a, b)=>

  // searches for sequences of characters longer than b without a newline after them and
  // adds a newline after every b characters of the sequence
  a.replace(eval(`/(.{${b}})(?!\\n)/g`), '$1\n')
    .split('\n')
    .map(c=>

      // prepends b spaces to each string then slices it from the right down to length b
      ( Array(b).join(' ') + c ).slice(-b)

    ).join('\n')

Answer 7

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

f(s,n)=for i=split(s,"\n") while length(i)>0 println(lpad(i[1:min(n,end)],n));length(i)<n?break:(i=i[min(n+1,end):end])end;end

Ungolfed:

function f(s::String, n::Int)
    for i in split(s, "\n")
        while length(i) > 0
            println(lpad(i[1:min(n,end)], n))
            length(i) < n ? break : (i = i[min(n+1,end):end])
        end
    end
end

Answer 8

बैश, 62 , 61 + सुविधा, 59

यदि Nकॉल करने वाले द्वारा इनपुट की पहली पंक्ति के रूप में इसे पढ़ने के बजाय, छोटा किया जा सकता है।

# width as a function arg: 59 chars
f()while read -rn$1 r;do [[ $r ]]&&printf %$1s\\n "$r";done
# width on stdin: 64 chars  (not updated with later suggestions&ideas)
read N;while read -rn$N r;do [[ $r ]]&&printf %$N's\n' "$r";done

यह इनपुट में खाली लाइनों को संभालने में विफल रहता है। अन्यथा, यह इनपुट डेटा को शब्द-विभाजन, पथनाम विस्तार, या अन्यथा इसे कच्चे डेटा से अधिक नहीं मानता है।

read -n$Nएक चरित्र बचाता है, लेकिन readमुंज की सुविधा देता है \।

यह [[ $r ]]&&देखने की जरूरत read -n4नहीं है क्योंकि यह देखने के लिए कि अगली चर एक नई पंक्ति है नहीं देख सकते हैं। तो यह r4-चार स्ट्रिंग के लिए सेट होता है, और अगला रीड शून्य-चार रिक्त स्ट्रिंग पैदा करता है। वास्तविक नई ख़बर को फ़िल्टर किए बिना इन झूठी न्यूलाइन्स को फ़िल्टर करने के लिए ट्रैकिंग स्थिति की आवश्यकता होगी: चाहे पिछली पंक्ति अधिकतम-लंबाई थी या नहीं। या तो अधिक कोड या पूरी तरह से अलग दृष्टिकोण की आवश्यकता होगी।

[[ $r ]][ -n "$r" ]अगर लाइन शुरू होती है -z foo, या है *या कुछ और, अगर आप उपयोग करते हैं, तो त्रुटियों से बचने के लिए आवश्यकता से कम है [ $r ]।

औचित्य मानक प्रिंटफ "% 4s" प्रारूप स्ट्रिंग के साथ होता है।

के साथ टेस्ट करें

f()(while read -rn$1 r;do [[ $r ]]&&printf %$1s\\n "$r";done); (echo 4; echo -e "*\n\\"; cat /tmp/lines) | f 4

Comments

1. मैं -rबाइट की गिनती में शामिल हूं । 2. f()(while ... done)थोड़ा छोटा है।

— डेनिस

@ डेनिस: बिना [[ $r ]]&&, अगर एन = 4, लंबाई 4 की एक इनपुट लाइन एक खाली आउटपुट लाइन का उत्पादन करेगी जहां पहले कोई नहीं था। क्योंकि read4 वर्णों की एक स्ट्रिंग लौटाता है, फिर अगली कॉल पर एक नई लाइन देखता है और तुरंत लौटता है। इसके अलावा, ()टिप के लिए धन्यवाद । मुझे नहीं पता था कि आप fn को इस तरह परिभाषित कर सकते हैं।

— पीटर कॉर्ड्स

मैं बैश में गोल्फ के लिए टिप्स पढ़ने की सलाह देता हूं । यह एक महान संसाधन है।

— डेनिस

दरअसल, चूंकि whileपहले से ही कंपाउंड है, इसलिए आपको कोष्ठकों की भी जरूरत नहीं है:f()while ... done

— डेनिस

@ डेनिस: वाह, हॅक्स। लिंक के लिए धन्यवाद। उन चीजों में से एक जोड़ी मेरे लिए नई थी, और मैंने एक और चीज़ के बारे में एक और जवाब तय किया :) मैं आम तौर पर गोल्फ नहीं करता, लेकिन> एक कमांड-लाइन के नशेड़ी होने के 15 साल ने मुझे एक चीज़ सिखाई या दो :)

— पीटर कॉर्ड्स

Answer 9

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

import Data.List.Split
k[]=[""]
k x=x
f n=unlines.(map(\l->([1..n-length l]>>" ")++l).k.chunksOf n=<<).lines

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

*Main> putStr $ f 5 "a\n\nb\ncd\nMatamorphosis"
    a

    b
   cd
Matam
orpho
  sis

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

                              .lines   -- split input string at newlines
                           =<<         -- for every line
                  chunksOf n           --    split into chunks of length n
                k                      --    fix empty lines
    map                                --    for every chunk
        \l->([1..n-length l]>>" "      --      make a string of missing spaces
                        ++l            --      and append the chunk
unlines                                -- join padded chunks with newlines in-between

Answer 10

जीएनयू जाग + बाश, 70

f()(awk -vFPAT=.\{,$1} '{for(i=0;i++<NF;){printf "%'$1's\n",$i}}/^$/')

आवक प्रोग्राम में गिनती को स्लॉट करने के लिए बैश का उपयोग करना संभव है। यह एक NR==1{N=$0}ब्लॉक के साथ पढ़ने से छोटा है ।

एक समय में एक पंक्ति पढ़ें। FPAT का उपयोग करते हुए, सबसे अधिक -4 वर्ण विखंडू में विभाजित करें। (विभाजकों के बजाय फ़ील्ड से मेल खाता है। GNU एक्सटेंशन।) प्रत्येक फ़ील्ड को अलग से प्रिंट करें। (डिफ़ॉल्ट ORS = \ n)।

/^$/नियम खाली लाइनों, जो एनएफ = 0 है और इस तरह अन्य ब्लॉक में सभी पर मुद्रित नहीं है वहाँ मुद्रित करने के लिए है। तो मेरे शुद्ध बैश समाधान के विपरीत, यह वास्तव में सामान्य मामले में काम करता है।

अर्ध-असंबंधित, लेकिन पर्ल के लिए अब तक का मेरा विचार सिर्फ पर्ल कोड के लिए 112 वर्णों का है:

(echo 4; echo -e 'foo\nbar'; echo -e "*\n\\"; echo '~$(true)'; cat /tmp/lines) |  # test input
perl -e '$N=<>;$/=\1;print "$N\n"; while(<>){if(/\n/ or length($l)>=$N){printf("%$4s\n",$l);$l=/\n/?"":$_;}else{$l.=$_;}}'

यह नए में से एक खाता है, और वैसे भी बहुत लंबा है। $/=\1एक बार में एक बाइट पढ़ता है। हम $ l को जोड़ते हैं। संभवत: फिक्स्ड-चौड़ाई स्प्लिट दृष्टिकोण वाला एक लाइन-ऑन-टाइम छोटा होगा।

Answer 11

बाश + GNU बर्तन, 41

fold -$1|sed ":;s/^.\{,$[$1-1]\}\$/ &/;t"

स्ट्रिंग इनपुट के माध्यम से STDIN है, चौड़ाई कमांड-लाइन arg द्वारा इनपुट है:

ubuntu@ubuntu:~$ echo 'Programming
Puzzles
&
Code
Golf'|./ralign.sh 10
Programmin
         g
   Puzzles
         &
      Code
      Golf
ubuntu@ubuntu:~$

Answer 12

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

s,n=input();N='\n'
for w in[i.lstrip()if i.replace(' ','').isalpha()else i for i in s.replace(N,'\n ').split(N)]:
 while w:print w[:n].rjust(n);w=w[n:]

यह ऊपर दिए गए @ xnor के उत्तर का एक अनुकूलन है, क्योंकि उनकी नई कहानियों को ठीक से संभालना नहीं है।

---

forपाश से बदला गया था:

for w in s.split('\n'):

सेवा मेरे:

for w in[i.lstrip()if i.replace(' ','').isalpha()else i for i in s.replace(N,'\n ').split(N)]:

---

उदाहरण

$ python main.py
"Programming\n\n\nPuzzles\n\n&\n\nCode\nGolf", 5
Progr
ammin
    g


Puzzl
   es

    &

 Code
 Golf

Answer 13

सी #, 143 बाइट्स

(s,n)=>Join("\n",s.Split('\n').SelectMany(l=>(l.Any()?l:" ").Select((c,i)=>new{c,i}).GroupBy(o=>o.i/n,o=>o.c).Select(g=>Concat(g).PadLeft(n))))

Linq आप बहुत सुंदर अभिव्यक्ति बनाने की सुविधा देता है। GroupByयहाँ उपयोगी है, लेकिन यह शर्म की बात है कि वे इंडेक्स लेने के लिए फ़ंक्शन अधिभार नहीं बना सकते हैं।

Func<string, int, string>इसे चलाने के लिए मेमने को असाइन करें

कम गोल्फ वाला:

Func<string, int, string> Align = (s, n) => Join("\n", 
    s.Split('\n')
     .SelectMany(l => (l.Any() ? l : " ")
         .Select((c, i) => new { c, i })
         .GroupBy(o => o.i / n, o => o.c)
         .Select(g => Concat(g).PadLeft(n))));

Answer 14

ग्रूवी, 63 बाइट्स

सही ढंग से आवंटित स्ट्रिंग लौटाता है। क्या अब तक पैडलेफ्ट (और पैडलाइट, पैडकेंटर) फ़ंक्शन नहीं था।

f={s,n->s.split("(?<=\\G.{$n})|\n")*.padLeft(n," ").join("\n")}

Answer 15

जावास्क्रिप्ट 174 136

function R(s,x){return s.replace(new RegExp(".{"+x+"}","g"),"$&\n").replace(/[^\n]*/g,function(m){
while(m.length<x)m=" "+m;return m;})}

Answer 16

सीलोन, 107

String w(String s,Integer n)=>"\n".join{for(l in s.lines)for(p in l.partition(n))String(p).padLeading(n)};

Answer 17

मतलाब, 99 बाइट्स

6 बाइट निकालने के लिए @ बीकर को धन्यवाद!

उपयोग और अनाम फ़ंक्शन:

@(s,k)fliplr(char(cellfun(@fliplr,strsplit(regexprep(s,sprintf('\\S{%i}',k),'$0\n'),'\n'),'un',0))) 

फ़ंक्शन को परिभाषित करें और ansइसे कॉल करने के लिए उपयोग करें:

>> @(s,k)fliplr(char(cellfun(@fliplr,strsplit(regexprep(s,sprintf('\\S{%i}',k),'$0\n'),'\n'),'un',0)))

ans =

@(s,k)fliplr(char(cellfun(@fliplr,strsplit(regexprep(s,sprintf('\\S{%i}',k),'$0\n'),'\n'),'un',0)))

>> ans(['Programming' 10 'Puzzles' 10 '&' 10 'Code' 10 'Golf'], 5) %% 10 is line feed

ans =

Progr
ammin
    g
Puzzl
   es
    &
 Code
 Golf

Answer 18

बर्लेस्क, 28 बाइट्स

नीचे दिए गए संस्करण के समान है, लेकिन पंक्ति 1 को संख्या और अन्य लाइनों को स्ट्रिंग के रूप में मानता है।

lng_riPpun{pPco{pP' lp}mu}Wl

उपयोग के रूप में:

$ cat input.txt | blsq --stdin "lng_riPpun{pPco{pP' lp}mu}Wl"
Progr
ammin
    g
Puzzl
   es
    &
 Code
 Golf

पुराना संस्करण (16 बाइट्स):

{5co{5' lp}mu}Wl

उदाहरण:

blsq ) "Programming\nPuzzles\n&\nCode\nGolf"{5co{5' lp}mu}Wl
Progr
ammin
    g
Puzzl
   es
    &
 Code
 Golf