एक तार से एक वर्ग उत्कीर्ण करें

21

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

एक वर्ग स्ट्रिंग वह है जहाँ:

  • प्रत्येक पंक्ति में समान वर्ण होते हैं
  • प्रत्येक पंक्ति पर वर्णों की संख्या पंक्तियों की संख्या के बराबर होती है।

निम्नलिखित संभव इनपुट स्ट्रिंग पर विचार करें:

abcde
fgh
asdf
foobar

सबसे बड़ा वर्ग आप इसमें से ले सकते हैं जिसमें पहला वर्ण ( atopleft कोने में) शामिल है:

abc
fgh
asd

साइड-लेंथ 4 का एक वर्ग नहीं हो सकता है, क्योंकि दूसरी लाइन पर्याप्त लंबी नहीं है। अब इस संभावित इनपुट पर विचार करें:

a
bcd
edf
ghi

यहाँ सबसे बड़ा वर्ग बस है a । तल में बने 3x3 वर्ग में बहुत पहला वर्ण नहीं है, और गिनती नहीं है।

यहाँ कुछ और परीक्षण मामले हैं:

a

a

abc
def
gh

ab
de

ab
cd

ab
cd

abcde
fghij
klm
no

abc
fgh
klm

a
b

a

आपको एलएफ, सीआर या सीआरएलएफ की अपनी पसंद से इनपुट की आवश्यकता हो सकती है।

न्यूलाइन वर्ण (ओं) को रेखा की लंबाई का हिस्सा नहीं माना जाता है।

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

इनपुट एक स्ट्रिंग या 1 डी चार सरणी है; यह तार की सूची नहीं है।

आप मान सकते हैं कि इनपुट नॉन-खाली है और सभी लाइनें नॉन-खाली हैं, और इसमें केवल प्रिंट करने योग्य ASCII शामिल हैं, जिसमें रिक्त स्थान और newlines (लाइन सीमांकक के लिए) शामिल हैं, लेकिन टैब नहीं।

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

code-golf  string 
— पावेल
स्रोत
— पावेल
5
एक दिलचस्प चुनौती के लिए +1, सख्त I / O के लिए -1
— डेनिस
@ डेनिस हर समाधान का उपयोग करने की आवश्यकता नहीं है .split('\n')इसलिए मुझे नहीं लगता कि कुछ को मुफ्त में क्यों मिलना चाहिए।
— पावेल
2
यह उबाऊ बॉयलरप्लेट के लिए बाइट्स जोड़ने के बारे में (बस) नहीं है। कुछ दृष्टिकोण (जैसे, पुनरावर्ती कार्य) पूरी तरह से अव्यावहारिक हो जाते हैं यदि पूर्व या पोस्टप्रोसेसिंग हो।
— डेनिस
@ डेनिस मैंने इसके बारे में ऐसा नहीं सोचा था। क्या आपको लगता है कि मुझे इसे अभी बदलना चाहिए, या बहुत देर हो चुकी है?
— पावेल

जवाबों:

5

ब्रेकीलॉग , 11 बाइट्स

ṇ⊇ᵐẹa₀ṁcᵐ~ṇ

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

व्याख्या

ṇ             Split on linebreaks
 ⊇ᵐ           Take a subset of each line
   ẹ          Split the lines into list of chars
    a₀        Take a prefix of this list of lists of chars
      ṁ       It is a square matrix
       cᵐ     Concatenate the list of chars back into strings
         ~ṇ   Join the strings with linebreaks
— Fatalize
स्रोत
कम से कम समाधान पर अच्छा काम (अब तक), Brachylog यकीन है कि वर्गों पसंद है, है ना?
— पावेल
@ पावेल ṁबिल्ट-इन वास्तव में काफी आसान है!
— घातक
7

भूसी , 13 बाइट्स

►oΛ≈S+TzṀ↑Nḣ¶

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

व्याख्या

►oΛ≈S+TzṀ↑Nḣ¶  Implicit input, say "ab\nc".
            ¶  Split at newlines: ["ab","c"]
           ḣ   Take prefixes: [["ab"],["ab","c"]]
       z  N    Zip with [1,2,3..
        Ṁ↑     by taking that many characters from each row: [["a"],["ab","c"]]
►o             Find rightmost element that satisfies this:
  Λ            all strings in
    S+T        the list concatenated to its transpose
   ≈           have the same length: ["a"]
               Implicitly print separated by newlines.
— Zgarb
स्रोत
1
यह एक प्रोग्रामिंग भाषा भी कैसे है - आपने अभी कुछ अस्पष्ट यूनिकोड वर्णों को चिपकाया है! ;)
— शलजम
1
@Petar गोल्फ की दुनिया में आपका स्वागत है, जो विशेष रूप से कुछ कार्य करने के लिए संभव के रूप में कुछ बाइट्स का उपयोग करने के लिए डिज़ाइन किए गए हैं। इसका एक हिस्सा एक कस्टम कोड पेज होना है, ताकि सामान्य 95 प्रिंट करने योग्य CCII के बजाय प्रत्येक संभावित बाइट के लिए एक चरित्र हो। लेकिन चिंता मत करो, वहाँ भी अधिक सुपाठ्य गोल्फ की भाषाएं हैं; उदाहरण के लिए मेरी MATL प्रविष्टि [/ बेशर्म आत्म-प्रचार]
— Sanchises
5

GNU sed , 106 + 1 94 + 2 = 96 बाइट्स

-rzझंडे के लिए +2 बाइट्स । का उपयोग करता है गंदा पात्रों NUL और BEL, के रूप में दिखाया @और# यहाँ है। एक xxd डंप के लिए नीचे देखें।

मुझे नीचे भेजने के लिए @seshoumara को धन्यवाद -z।

s/^/@/gm
s/.*/#&\n/
:B
s/@(.)/\1@/mg
s/#(.+\n)/\1#/m
/#.*@./M!b
/@\n.*#/!bB
:
s/@[^\n]*|#.*//g

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

व्याख्या

यह पाठ में दो कर्सर डालकर काम करता है - एक लाइनों पर कदम रखने के लिए और एक स्तंभों पर कदम रखने के लिए। कर्सर को क्रमशः एनयूएल (0x00) और बीईएल (0x07) द्वारा दर्शाया जाता है, लेकिन नीचे दिए गए उदाहरणों में मैं उपयोग करूंगा @और #। मान लीजिए हमारे पास यह इनपुट है:

abcde
fgh
asdf
foobar

बीईएल कर्सर को 0 वें कॉलम से पहले डाला जाता है और बीई कर्सर को 0 वीं लाइन से पहले डाला जाता है (यहां मैंने लेगबिलिटी के लिए कॉलम को जोड़ कर रखा है; लेकिन वास्तव में कोई लेफ्ट पैडिंग नहीं है):

#@abcde
 @fgh
 @asdf
 @foobar

एक पाश में, श्रोताओं को क्रमशः एक वर्ण दाएं और एक पंक्ति नीचे ले जाया जाता है:

 a@bcde
#f@gh
 a@sdf
 f@oobar
 ab@cde
 fg@h
#as@df
 fo@obar
 abc@de
 fgh@
 asd@f
#foo@bar

प्रत्येक पुनरावृत्ति के बाद, यह दो स्थितियों की जाँच करता है:

  1. लाइन कर्सर के साथ लाइन पर, एक कॉलम कर्सर है और क्या कॉलम कर्सर दाईं ओर जा सकता है?
  2. लाइन कर्सर से पहले की तर्ज पर, क्या हर कॉलम कर्सर दाईं ओर जा सकता है?

यदि या तो स्थिति झूठी है, तो लूप समाप्त हो जाता है। स्क्रिप्ट @प्रत्येक पंक्ति के बाद #और पैटर्न स्पेस में सब कुछ हटाने के बाद समाप्त होती है।

xxd डंप

00000000: 732f 5e2f 002f 676d 0a73 2f2e 2a2f 0726  s/^/./gm.s/.*/.&
00000010: 5c6e 2f0a 3a42 0a73 2f00 282e 292f 5c31  \n/.:B.s/.(.)/\1
00000020: 002f 6d67 0a73 2f07 282e 2b5c 6e29 2f5c  ./mg.s/.(.+\n)/\
00000030: 3107 2f6d 0a2f 072e 2a00 2e2f 4d21 620a  1./m./..*../M!b.
00000040: 2f00 5c6e 2e2a 072f 2162 420a 3a0a 732f  /.\n.*./!bB.:.s/
00000050: 005b 5e5c 6e5d 2a7c 072e 2a2f 2f67       .[^\n]*|..*//g
— जॉर्डन
स्रोत
आप पहले लूप, ए को हटा सकते हैं, क्योंकि बयान में कहा गया है कि आपको इनपुट को एक स्ट्रिंग के रूप में पढ़ना है, इसलिए आप "लाइन 1 \ nline2 \ nline3" आदि प्राप्त कर सकते हैं। अन्य उत्तरों ने भी ऐसा किया। वह १०० से नीचे की गिनती प्राप्त करे :)
— शशमौरा
@ शेषेशमरा अन्य उत्तर देते हैं line1\nline2\nline3 कहाँ \nहै \x5C\x6E? कौन कौन से?
— जॉर्डन
क्या आप मुझे लिंक दे सकते हैं? (किसी भी उत्तर के निचले भाग पर "शेयर" पर क्लिक करें।) या मुझे एक तिवारी में दिखाएं जो आपका मतलब है? पायथन और PHP के सभी उत्तरों में मैं देख रहा हूं\n है कि एक नई लाइन वर्ण के रूप में व्याख्या की गई है ( और \x0Aनहीं \x5C\x6E) और मुझे एक पंक्ति के रूप में न्यूलाइन वर्णों के साथ सेड लेने का तरीका नहीं मिल रहा है।
— जॉर्डन
@seshoumara हाह, कोई बात नहीं, मुझे बस -zझंडा याद आया । धन्यवाद!
— जॉर्डन
4

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

l=input().split('\n')
i=0
while zip(*l[:i+1])[i:]:i+=1
for x in l[:i]:print x[:i]

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

एक दिलचस्प विधि, लेकिन 2 बाइट्स लंबे समय तक।

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

l=input().split('\n')
while len(zip(*l))<len(l):l.pop()
for x in l:print x[:len(l)]

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

— XNOR
स्रोत
1
inputकेवल एक पंक्ति नहीं पढ़ता है?
— पावेल
@Pavel, यदि आप ऑनलाइन उदाहरण को देखते हैं, तो आप देख सकते हैं कि इनपुट की एक-पंक्ति को बनाए रखने के लिए स्पष्ट न्यूलाइन वर्णों का उपयोग किया जा रहा है। संभवतः इस विधि के लिए चयन raw_input()करना क्योंकि अधिक बाइट जोड़ देगा।
— जेवियर
4

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

f=(s,i=1,m=s.match(`^${`(.{${i}}).*
`.repeat(i)}`))=>m?f(s,i+1)||m.slice(1):0

जब तक कोई नहीं मिलता है तब तक बड़े और बड़े वर्ग की खोज के लिए एक नियमित अभिव्यक्ति का उपयोग करता है।

नियमित अभिव्यक्ति यह एक 3x3 वर्ग के लिए होगी:

^(.{3}).*
(.{3}).*
(.{3}).*

इनपुट एक नई लाइन के साथ समाप्त होने की उम्मीद है, और आउटपुट एक सूची है।

स्पष्टीकरण:

f = (s,                                            //input
     i = 1,                                        //start searching for a 1x1 square
     m = s.match(`^${`(.{${i}}).*\n`.repeat(i)}`)  //match on the regex
    )=>
    m ? f(s, i+1)                   //if there's a match, recurse on the next-sized square
        || m.slice(1) :             //if there's not a next-sized square, return the match
        0                           //no match for this square, so stop recursing

स्निपेट:

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
3

आर , 84४ 83 81 76 बाइट्स

-5 बाइट्स पोर्टिंग डेनिस के दृष्टिकोण को करते हुएsum 

cat(substr(x<-readLines(),1,m<-sum(cummin(nchar(x))>=seq(x)))[1:m],sep='\n')

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

स्टडिन से पढ़ता है, एक नई रूपरेखा के बिना प्रिंटआउट करने के लिए प्रिंट करता है।

थोड़ा अपराजित:

x <- readLines()                    # read in input one line at a time;
                                    # saved as a vector of strings
minChar <- cummin(nchar(x))         # rolling minimum of all line lengths
lineNum <- seq(x)                   # line number
mins <- minChar>=lineNum            # the min between the line number and the line lengths
m <- sum(mins)                      # the sum of those is the size of the square
cat(substr(x,1,m)[1:m],sep='\n')    # print the first m characters of the first m lines,
                                    # and join with newlines

— ग्यूसेप
स्रोत
3

सी (जीसीसी) , 162 159 151 147 144 142 137 बाइट्स

यहाँ दूर गोल्फ के लिए कुछ स्ट्रोक होना चाहिए ...

i,l=9;char*p,s[9][8];main(t){for(p=s;~(*p=getchar());)p=*p<32?*p=0,l=(t=strlen(s+i))<l?t:l,s[++i]:p+1;for(i=0;i<l;puts(s+i++))s[i][l]=0;}

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

— cleblanc
स्रोत
हो सकता !=-1है >-1या getchar()उत्पादन मान शून्य से छोटा हो सकता है ? क्या यह भी हो सकता है +1?
— जोनाथन फ्रेच
संभावित 158 बाइट्स ।
— जोनाथन फ्रीच
@JonathanFrech मैं ~शून्य से एक का पता लगाने के लिए उपयोग कर सकता हूं ।
— क्लेब्लांक
1
@ हिचकीकॉक नवीनतम गोल्फ संस्करण में काम करने लगता है।
— क्लीब्लांक
2

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

L€«\‘>Jx@Z
ỴÇÇY

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

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

ỴÇÇY        Main link. Argument: s (string)

Ỵ           Split s at linefeeds, yielding a string array.
 Ç          Apply the helper link.
  Ç         Apply the helper link again.
   Y        Join, separating by linefeeds.


L€«\‘>Jx@Z  Helper link. Argument: A (string array/2D character array)

L€          Compute the length of each row/line.
  «\        Take the cumulative minimum.
    ‘       Increment each minimum.
      J     Indices; yield [1, ..., len(A)].
     >      Perform elementwise comparison. If the output should have n lines, this
            yields an array of n ones and len(A)-n zeroes.
         Z  Zip/transpose A.
       x@   For each string t in the result to the right, repeat its characters as
            many times as indicated in the result to the left, discarding all but
            the first n characters.
— डेनिस
स्रोत
2

जावा 8, 150 बाइट्स

s->{String q[]=s.split("\n"),r="";int l=q[0].length(),i=0,t;for(;i<l;l=t<l?t:l)t=q[i++].length();for(i=0;i<l;)r+=q[i++].substring(0,l)+"\n";return r;}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                          // Method with String as both parameter and return-type 
  String q[]=s.split("\n"),   //  Split the input on new-lines, and put it in an array
         r="";                //  Result-String, starting empty
  int l=q[0].length(),        //  Length of the lines, starting at the length of line 1
      i=0,                    //  Index-integer, starting at 0
      t;                      //  Temp integer
  for(;i<l;                   //  Loop (1) from 0 to `l` (exclusive)
      l=t<l?                  //    After every iteration: if `t` is smaller than `l`:
         t                    //     Change `l` to `t`
        :                     //    Else:
         l)                   //     Leave `l` the same
    t=q[i++].length();        //   Set `t` to the length of the current line
                              //  End of loop (1) (implicit / single-line body)
  for(i=0;i<l;                //  Loop (2) from 0 to `l` (the determined square dimension)
    r+=                       //   Append the result-String with:
       q[i++].substring(0,l)  //    The current row chopped at `l-1`
       +"\n"                  //    + a new-line
  );                          //  End of loop (2)
  return r;                   //  Return the result-String
}                             // End of method
— केविन क्रूज़सेन
स्रोत
2

MATL , 33 बाइट्स

10-~ft1)wdhqY<tn:vX<X>:GYbowt3$)c

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

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

— Sanchises
स्रोत
1
@Pavel Guiseppe एक और संस्करण की बात कर रहा था, जिसे मैंने वापस रोल किया क्योंकि इसमें वास्तव में एक बग था।
— Sanchises
1

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

f=
s=>(g=s=>s.slice(0,a.findIndex((e,i)=>a.some((s,j)=>j<=i&!s[i]))))(a=s.split`
`).map(g).join`
`
<textarea oninput=o.textContent=f(this.value+`\n`)></textarea><pre id=o>
स्निपेट का विस्तार करें

इनपुट में एक अनुगामी न्यूलाइन की आवश्यकता है।

— नील
स्रोत
1

APL (Dyalog) , 25 बाइट्स *

टैसिट उपसर्ग फ़ंक्शन। मैट्रिक्स लौटाता है।

(↑↑⍨2⍴(⌊/≢,≢¨))⎕AV[3]∘≠⊆⊢

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

यह वास्तव में दो स्वतंत्र कार्यों में से एक है, ⎕AV[3]∘≠⊆⊢जो कि अजीब इनपुट प्रारूप से संबंधित है और ↑↑⍨2⍴(⌊/≢,≢¨)जो वास्तविक दिलचस्प काम करता है।

⎕AV[3]∘≠ एलएफ से अंतर ( ए टोमिक वी एक्टर का तीसरा तत्व - चरित्र सेट)

⊆ विभाजन (उनके पूर्ववर्ती से बड़े मूल्यों पर शुरू होने वाले पदार्थ और 0 पर ड्रॉप)

⊢ बहस

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

 2⍴(... ) लंबाई 2 के लिए निम्नलिखित को फिर से आकार दें:

  ⌊/ की न्यूनतम

  ≢ तार की संख्या

  , के बाद

  ≢¨ प्रत्येक स्ट्रिंग में वर्णों की संख्या

↑⍨ उस से कई पंक्तियों और स्तंभों को लें

 ↑ एक तार बनाने के लिए एक साथ मिश्रित तार (रिक्त स्थान के साथ पैडिंग)

* क्लासिक में ⎕ML( एम प्रवासन एल evel ) 3(कई प्रणालियों पर डिफ़ॉल्ट) और बाईं ओर के ⊂लिए ⊆और प्रतिस्थापन । Tio!⊃↑

— एडम
स्रोत
यदि यह Dyalog Classic में समान लंबाई है तो आप यह कह सकते हैं कि यह Dyalog Classic है और फुटनोट का उपयोग नहीं करते हैं।
— पावेल
@ पावेल दोनों क्लासिक हैं और ⎕ML←3पदावनत हैं, इसलिए मैं भाषा दिखाना चाहूंगा क्योंकि यह सामान्य रूप से दिखाई देगी। वास्तव में, मेरे लगभग सभी Dyalog APL सॉल्यूशंस क्लासिक को केवल इसलिए ग्रहण करते हैं क्योंकि हम वर्णों के बजाय बाइट्स की गिनती करते हैं, हालांकि यहां तक ​​कि यूनिकोड संस्करण 256 वर्णों से कम का अर्थ देता है।
— Adám
1

PHP, 123 बाइट्स

for(;preg_match("#^(\S{".++$i."}.*
){"."$i}#",$s="$argv[1]
"););while($k<$i-1)echo substr(split("
",$s)[+$k++],0,$i-1),"
";

PHP 5.4, 5.5 या 5.6 की आवश्यकता है। बाद के PHP के splitसाथ बदलें explode।

इसे ऑनलाइन चलाएं php -nr '<code> '<string>'
या इसके लिए प्रयास करें । (सुनिश्चित करें कि आप suiting PHP संस्करण का चयन करें!)

— टाइटस
स्रोत
1

पर्ल 5, 60 +5 (-0777 पी) बाइट्स

$.++while/^(.{$.}.*
){$.}/;$_=join"
",(/.{$.}/gm)[0..--$.-1]

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

  • इनपुट की अंतिम पंक्ति को आउटपुट के मामले में एक नई रेखा के साथ समाप्त होना चाहिए।
  • दो लगातार newlines -00 के मामले में -0777 द्वारा विकल्प बदला जा सकता है।
— नहुएल फौलीउल
स्रोत
दो लगातार नए किस्से संभव हैं, इसलिए आपको इसकी आवश्यकता होगी -0777। वैसे भी क्या करें -00और क्या न करें -0777।
— पावेल
-0ऑक्टल फॉर्मेट में रिकॉर्ड सेपरेटर को निर्दिष्ट 777करना है, कोई विभाजक नहीं होने का संकेत करने के लिए एक विशेष मान है इसलिए पूरी फ़ाइल पढ़ी जाती है, 0"पैराग्राफ मोड" को इंगित करने के लिए एक और विशेष मूल्य है, विभाजक 1 लगातार newlines से अधिक है
— नहुएल फौलेउल
1

पर्ल 6 , 158 140 बाइट्स

my$c;for ^(my@b=lines).elems {any(@b.head(++$c).map({.substr(0,$c).chars <$c}))&&$c--&&last;};say @b.head($c).map({.substr(0,$c)}).join("
")

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

मेरे पहले पर्ल 6 जवाब के लिए हुर्रे। मैं कुछ कमांड लाइन विकल्पों के साथ खेलूँगा देखने के लिए कि क्या मैं इसे थोड़ा और अधिक गोल्फ कर सकता हूं। सभी मदद बाइट्स बचाने में आपका स्वागत है!

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