सामान्य अग्रणी स्थान निकालें

Question

जब पायथन में कोडिंग होती है, तो कभी-कभी आप एक फ़ंक्शन के भीतर एक बहुस्तरीय स्ट्रिंग चाहते हैं, जैसे

def f():
    s = """\
    Line 1
    Line 2
    Line 3"""

^{(बैकलैश एक अग्रणी नई पंक्ति को हटाने के लिए है)}

यदि आप वास्तव में प्रिंट आउट लेने की कोशिश करते हैं s, तो आप प्राप्त करेंगे

    Line 1
    Line 2
    Line 3

यही हम नहीं चाहते हैं! बहुत अधिक प्रमुख व्हाट्सएप है!

चुनौती

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

इनपुट STDIN या फ़ंक्शन तर्क के माध्यम से हो सकता है, और आउटपुट STDOUT या फ़ंक्शन रिटर्न मान के माध्यम से हो सकता है। आप किसी भी बिलिन का उपयोग नहीं कर सकते हैं जो बहु-तार तार के लिए डिज़ाइन किए गए हैं या यह सटीक कार्य करते हैं, जैसे कि पायथन textwrap.dedent।

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स में समाधान जीतता है। मानक खामियां लागू होती हैं।

परीक्षण के मामलों

"a"                                  ->   "a"
"   abc"                             ->   "abc"
"   abc\n def\n  ghi"                ->   "  abc\ndef\n ghi"
"    a\n    b\n    c"                ->   "a\nb\nc"
"    a\n    b\n    c\nd"             ->   "    a\n    b\n    c\nd"
"   a   b\n     c     d\n    e f"    ->   "a   b\n  c     d\n e f"

उदाहरण के लिए, अंतिम परीक्षण मामला है

   a   b
     c     d
    e f

और प्रमुख स्थानों को अलग करने के बाद इस तरह दिखना चाहिए:

a   b
  c     d
 e f

Comments

क्या उत्पादन में व्हॉट्सएप का स्थान है?

— orlp

@orlp नहीं, यह स्पष्ट नहीं किया जाएगा।

— Sp3000

Answer 1

CJam, 20 14 बाइट्स

qN/_z{S-}#f>N*

एल्गोरिथम :

• हमने सबसे पहले इनपुट को नई कड़ियों में विभाजित किया और एक प्रति ली ( qN/_)
• फिर नॉन स्पेस कैरेक्टर वाले सबसे छोटे कॉलम की गणना न्यूलाइन सेपरेटेड एरे को ट्रांसपोज़ करके की जाती है और फिर पहले नॉन-ऑल-स्पेस रो के इंडेक्स की तलाश की जाती है ( z{S-}#)
• तब हम बस प्रत्येक लाइन से कई वर्णों को दूर करते हैं ( f>)
• अंत में, हम फिर से newline से जुड़ते हैं ( N*)

कोड विस्तार

qN/               e# Read the entire input and split it on newline
   _z             e# Take a copy and transpose rows with columns.
                  e# Now we would have a bunch of all space rows. These rows are the ones
                  e# we want to remove (in form of columns) 
     {  }#        e# Get the index of the first item from the transposed array that returns
                  e# true for this block
      S-          e# From each part, remove spaces. If the part is all-space, it will return
                  e# an empty string, which is false in CJam. We finally will get the index
                  e# of the first non-all-space row (or column)
          f>      e# We take that index and remove that many characters from starting of each
                  e# row of the initial newline separated input
            N*    e# Join the array back using newlines and automatically print the result

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

Answer 2

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

jbu>R!rhCG6G.z

कार्यान्वयन बहुत अच्छा है।

1. u .zएक सार में स्टड की सभी लाइनों को पकड़ लेता है, इसे अंदर डालता है G। तब यह आंतरिक शरीर का मूल्यांकन करता है, परिणाम डालता है Gऔर ऐसा तब तक करता रहता है जब तक कि यह (निश्चित बिंदु) नहीं बदलता।

2. !rhCG6स्थानांतरित करता है G, ट्रांसपोज़्ड एरे (पहला कॉलम) का पहला तत्व प्राप्त करता है, इसे किसी भी व्हाट्सएप से हटाता है, और जाँचता है कि क्या कोई नॉन-व्हाट्सएप वर्ण बचे हैं।

3. 2 से मूल्य एक बूलियन है, जिसे एक इंट 0 या 1 के रूप में देखा जा सकता है। >R Gयह संख्या पकड़ लेता है और प्रत्येक पंक्ति के बाईं ओर से कई वर्णों को काट देता है G। चरण 1, 2 और 3 संयुक्त रूप से इसका मतलब है कि जब तक कोई शुद्ध व्हाट्सएप कॉलम नहीं बचा है तब तक यह व्हाट्सएप के स्तंभों को अलग रखना होगा।

4. jb newlines द्वारा लाइनों के सरणी में शामिल होता है और इसे प्रिंट करता है।

Comments

क्या आप कृपया इसे एक छोटा सा विवरण दे सकते हैं? यह मेरे लिए बहुत अजीब है!

— बोबेल

@bobbel स्पष्टीकरण जोड़ा गया।

— orlp

वास्तव में महान, धन्यवाद! इसके बारे में कभी नहीं सुना! इस ऑनलाइन को आजमाने के लिए मैंने पाया: pyth.herokuapp.com/…

— bobbel

Answer 3

सीड - 26 बाइट्स

:;/(^|\n)\S/q;s/^ //mg;b

साथ दौड़ो -rz

बहुत सीधा:

  /(^|\n)\S/q;           - quit if there is a line that starts with non-space
              s/^ //mg;  - remove exactly one space in each line
:;                     b - repeat

-rविकल्प विस्तारित रेगेक्स पर मुड़ता है, -zपूरे इनपुट को एक स्ट्रिंग के रूप में पढ़ता है (वास्तव में लाइन सीमांकक के रूप में एनयूएल-बाइट का उपयोग करता है)

Comments

क्या आपको :;N;$!bसिंगल पैटर्न स्पेस में इनपुट लाइनों को इकट्ठा करने के लिए शुरुआत करने की जरूरत नहीं है? संपादित करें: नहीं, तुम नहीं; वो क्या है -zध्वज के लिए है।

— टोबे स्पाइट

आप इसे गोल्फ कर सकते :;/^\S/M!s/^ //mg;tहैं, अब आवश्यकता नहीं है-r

— कृति लिथोस

Answer 4

एसडब्ल्यूआई-प्रोलॉग, 233 223 217 बाइट्स

a(A):-b(A,0,0,0,N),w(A,N,0).
b([A|T],P,K,M,N):-P=1,(A=10,b(T,0,0,M,N);b(T,1,0,M,N));A\=32,(M=0;K<M),b(T,1,0,K,N);I=K+1,b(T,0,I,M,N).
b(_,_,_,N,N).
w([A|T],N,P):-P<N,A=32,Q=P+1,w(T,N,Q);put(A),A=10,w(T,N,0);w(T,N,P);!.

संपादित करें : पूरी तरह से मेरे जवाब को बदल दिया। यह अब तार के बजाय चरित्र कोड का उपयोग करता है।

इसे कॉल करने का एक उदाहरण होगा a(` a b\n c d\n e f`)., बैकक्वाटर के साथ। "यदि आपको पुराने SWI-Prolog डिस्ट्रीब है तो आपको इसके बजाय दोहरे उद्धरण चिह्नों का उपयोग करने की आवश्यकता हो सकती है ।

Answer 5

जूलिया, 93 92 81 बाइट्स

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

s->for i=(p=split(s,"\n")) println(i[min([search(j,r"\S")[1]for j=p]...):end])end

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और स्टडआउट को प्रिंट करता है।

असंगठित + स्पष्टीकरण:

function f(s)
    # Split s into an array on newlines
    p = split(s, "\n")

    # Get the smallest amount of leading space by finding the
    # position of the first non-space character on each line
    # and taking the minimum
    m = min([search(j, r"\S")[1] for j in p]...)

    # Print each line starting after m
    for i in p
        println(i[m:end])
    end
end

Comments

आप रिक्त स्थान की संख्या गिनने के बजाय पहले गैर-स्थान की तलाश करके कुछ स्थान बचा सकते हैं। इसके बजाय minimum([length(search(j, r"^ +")) for j in p])+1, उपयोग करें minimum([search(j,r"[^ ]")[1]for j=p])। चूंकि चुनौती बताती है कि सभी लाइनों में नॉन-स्पेस टेक्स्ट होगा, यह सुरक्षित है, और आपको 9 बाइट्स बचाता है (जिसमें [1] के =बजाय ' 3 का उपयोग करके सहेजा गया है ). Still looking to see if more can be saved. (I wish I could drop the ), लेकिन खोज में किसी भी प्रकार का एन्यूमरेटर सरणी उत्पन्न होती है, जबकि न्यूनतम आवश्यकता होती है एक इंट प्रकार)

— ग्लेन ओ

ऊपर की गलती - जाहिर है, मैंने अपने संपादन का उपयोग किया है - यह 9 बाइट्स नहीं है, लेकिन 6, क्योंकि मैं नोट करने में विफल रहा कि आपने गोल्फ फॉर्म में उपयोग किया था। वैसे भी, मैं लूप को शुरू करने में p को परिभाषित करके दो और पात्रों को बचा सकता हूं:s->for i=(p=split(s,"\n")) println(i[minimum([search(j,r"[^ ]")[1]for j=p]):end])end

— Glen O

ठीक है, यहां एक और एक को थोड़ा और दाढ़ी बनाने के लिए है - minimum(x)जब xएक सरणी का उपयोग करने के बजाय min(x...), एक अतिरिक्त बाइट के लिए सहेजा गया है, (मैं इसे जूलिया गोल्फिंग टिप्स की मेरी सूची में जोड़ने जा रहा हूं)।

— ग्लेन ओ

@GlenO अच्छा, सुझाव के लिए धन्यवाद। इसके अलावा, चूंकि जूलिया पीसीआरई का उपयोग करता है, इसलिए गैर-अंतरिक्ष वर्णों के \Sबजाय मिलान किया जा सकता है [^ ], जो एक बाइट बचाता है।

— एलेक्स ए।

अरे, यह उल्लेख करने के लिए धन्यवाद - मैं रेगेक्स के साथ अच्छा नहीं हूं, लेकिन यह पता चला कि \Sमेरे समाधान के लिए भी उपयोगी है।

— ग्लेन ओ

Answer 6

जावा, 159

क्योंकि जावा की विशिष्ट कमी है ...

void f(String...a){int s=1<<30,b;a=a[0].split("\n");for(String x:a)s=(b=x.length()-x.trim().length())<s?b:s;for(String x:a)System.out.println(x.substring(s));}

यह सिर्फ लंबाई की छंटनी की लंबाई की तुलना करता है, फिर सबस्ट्रिंग को थूकता है। कुछ भी नहीं फैंसी। स्क्रॉलबार-बिगड़ा के लिए:

void f(String...a){
    int s=1<<30,b;
    a=a[0].split("\n");
    for(String x:a)
        s=(b=x.length()-x.trim().length())<s?b:s;       
    for(String x:a)
        System.out.println(x.substring(s));
}

Answer 7

पर्ल, 47 33

धन्यवाद पर्ल के अंतर्निहित लूप का उपयोग करने के सुझाव के लिए @ThisSuitIsBlackNot

#!/usr/bin/perl -00p
/^( +).*(\n\1.*)*$/&&s/^$1//mg

00pझंडे के लिए कोड + 3 की रेखा के लिए ऊपर 30 बाइट्स के रूप में स्कोर किया गया है ।

एक समारोह के रूप में मूल संस्करण:

sub f{$_=@_[0];/^( +).*(\n\1.*)*$/&&s/^$1//mgr}

यह तर्क डालता है $_, फिर सभी लाइनों पर मौजूद व्हाट्सएप को लालच से मिलान करने का प्रयास करता है /^( +).*(\n\1.*)*$/- यदि सफल, $1अब सबसे लंबे समय तक सामान्य उपसर्ग है, और हम s/^$1//mgrइसे हर पंक्ति की शुरुआत से हटाने के लिए प्रतिस्थापन निष्पादित करते हैं और परिणामस्वरूप स्ट्रिंग वापस करते हैं।

परीक्षा

$ cat 53219.data
   a   b
     c     d
    e f
$ ./53219.pl <53219.data 
a   b
  c     d
 e f

Comments

बहुत ही शांत। आप कमांड लाइन पर चलकर कुछ बाइट्स को शेव कर सकते हैं: perl -00pe '/^( +).*(\n\1.*)*$/&&s/^$1//mg'(30 बाइट्स + 3 के लिए 00p)।

— ThisSuitIsBlackNot 20

/meऊपर देखने के लिए सिर -00p; धन्यवाद @ThisSuit

— स्पाइट

Answer 8

पायथन 2, 86 79 75 बाइट्स

यह लगभग निश्चित रूप से कुछ और छोटा किया जा सकता है, लेकिन अभी यह बुरा नहीं है।

4 बाइट बचाने के लिए xnor का धन्यवाद!

s=input().split('\n')
for k in s:print k[min(x.find(x.strip())for x in s):]

Comments

अग्रणी स्थानों की गणना करने का एक छोटा तरीका है x.find(x.strip())।

— xnor

@ अच्छी कॉल, धन्यवाद! मैं पूरे दिन आप से 60 बाइट के समाधान की प्रतीक्षा कर रहा हूं; पी

— केड

input()पाइथन 2 में इस डेटा पर चर्चा होगी।

— स्टीवन रूंबल्स्की

@StevenRumbalski, मुझे लगता है कि इनपुट उद्धरणों से घिरा हुआ है। मैं इसके लिए हिसाब करने के लिए 2 बाइट गिनती में जोड़ता था, लेकिन कई लोगों ने कहा है कि मुझे इसकी आवश्यकता नहीं है।

— केड

यह कार्यक्रम दुखद है:):

— हाइपरनेट्रिनो

Answer 9

रूबी: 77 73 70 66 65 65 57 57 40 वर्ण

f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}

नमूना रन:

irb(main):001:0> f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}
=> #<Proc:0x00000001855948@(irb):1 (lambda)>

irb(main):002:0> puts f["   a   b\n     c     d\n    e f"]
a   b
  c     d
 e f
=> nil

irb(main):003:0> f["   a   b\n     c     d\n    e f"] == "a   b\n  c     d\n e f"
=> true

Comments

कैसे के बारे में f=->t{t.gsub /^#{t.scan(/^ */).min}/,""}?

— वेंटरो

यह बढ़िया है, @Ventero। धन्यवाद।

— मैनटवर्क

Answer 10

सी #, 18 + 145 = 163 बाइट्स

आवश्यक (18 बाइट्स):

using System.Linq;

विधि (145 बाइट्स):

string R(string s){var l=s.Split('\n');return string.Join("\n",l.Select(x=>string.Concat(x.Skip(l.Select(z=>z.Length-z.Trim().Length).Min()))));}

विधि लाइनों पर अग्रणी रिक्त स्थान की सबसे कम मात्रा की गणना करती है और एन लाइनों को छोड़ दिया गया (जहां एन पहले गणना की गई संख्या है) के साथ, सभी लाइनों से बना एक नया स्ट्रिंग बनाता है ।

Answer 11

सी #, 149 बाइट्स कुल

प्रोग्रामफॉक्स के रूप में व्यावहारिक रूप से एक ही समाधान है, हालांकि ट्रिम करने के लिए वर्णों की संख्या मैन्युअल रूप से गणना की जाती है।

using System.Linq;

और समारोह ही:

string D(string s){var l=s.Split('\n');int i=0;while(l.All(a=>a[i]==' '))i++;return string.Join("\n",l.Select(b=>b.Substring(i)));}

Comments

@ProgramFOX मैंने आपके समाधान को तब तक नहीं देखा था जब तक कि मैंने पृष्ठ btw को ताज़ा नहीं किया: o)

— Sok

Answer 12

अजगर 3, 100

def f(s):t=s.split("\n");return"\n".join([c[min([len(c)-len(c.lstrip(" "))for c in t]):]for c in t])

Answer 13

जावास्क्रिप्ट, ईएस 6, 89 86 बाइट्स

यह एक पूरी तरह से सिर्फ RegEx मिलान और प्रतिस्थापन का उपयोग कर रहा है।

f=x=>eval(`x.replace(/(^|\\n) {${--`
${x}`.match(/\n */g).sort()[0].length}}/g,"$1")`)

// Snippet related stuff
B.onclick=x=>P.innerHTML=f(T.value)

<textarea id=T></textarea><br>
<button id=B>Trim</button>
<pre id=P></pre>

हमेशा की तरह, फ़ायरफ़ॉक्स केवल, ES6 के बाद से। बाद में ES5 संस्करण जोड़ देगा।

Comments

ऐसा लगता है जैसे कि यह एक स्ट्रिंग के रूप में एक नियमित अभिव्यक्ति शाब्दिक लिखने के लिए कम हो और फिर इसे eval था

— Downgoat

@ vihan1086 आप सही हो सकते हैं। मैं इसे एक कोशिश देता हूं।

— ऑप्टिमाइज़र

Answer 14

के, 31 बाइट्स

{`0:(&/{(0;#*=x)@*x}'" "=x)_'x}

इनपुट को स्ट्रिंग्स की एक सूची बनाता है और परिणाम को स्टडआउट पर प्रिंट करता है।

Answer 15

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

unlines.until(any(/=' ').map head)(map tail).lines

उपयोग उदाहरण: unlines.until(any(/=' ').map head)(map tail).lines $ " abc\n def\n ghi"->" abc\ndef\n ghi\n"

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

                                           lines    -- split the input at newlines into a list of lines
        until                                       -- repeat the 2nd argument, i.e.
                                 map tails          -- cut off the heads of all lines
                                                    -- until the the first argument returns "True", i.e.
             any(/=' ').map head                    -- the list of heads contains at least one non-space
unlines                                             -- transform back to a single string with newlines in-between

Answer 16

पायथन, 94/95

लैम्ब्डा (94 बाइट्स):

f=lambda s:'\n'.join(l[min(l.find(l.strip()) for l in s.split('\n')):] for l in s.split('\n'))

डिफ (95 बाइट्स)

def f(s):l=s.split('\n');m=min(i.find(i.strip())for i in l);return '\n'.join(i[m:] for i in l);

Answer 17

बैश + सेड + कोरुटिल्स, 74 , 56 , 55

परीक्षण डेटा

s="\
   a   b
     c     d
    e f"

उत्तर

cut -c$[`grep -o '^ *'<<<"$s"|sort|line|wc -c`]-<<<"$s"

उत्पादन

a   b
  c     d
 e f

Comments

कुछ साधारण गोल्फ परिवर्तन इसे मेरी गिनती में 56 तक लाता है:cut -c$[`grep -o '^ *'<<<"$s"|sort|sed q|wc -c`]-<<<"$s"

— डिजिटल ट्रॉमा

@ डिटगलट्रामा: अच्छा, मैं $[]अंकगणित के बारे में भूल गया । cutकॉलम चयन के लिए उपयोग करना बेहतर है। मैंने कभी इसके sed qविकल्प के रूप में नहीं देखा head -n1, यह एक अच्छी गोल्फिंग ट्रिक है। धन्यवाद!

— थोर

head -n1बनाम के बारे में, उपयोग-लिनक्स पैकेज में sed qएक lineउपकरण है।

— मैनटवर्क

@manatwork: जो एक चरित्र को बचाता है, मैं उसका उपयोग करूंगा। ध्यान दें कि यह पदावनत है और भविष्य में गायब हो सकता है, यह उपयोग -लाइनक्स के स्रोत ट्री में deprecated.txt से है : "क्यों: बेकार, कोई भी इस कमांड का उपयोग नहीं करता है, सिर (1) बेहतर है"।

— थोर

Answer 18

आर, 118 111 बाइट्स

आर के अद्भुत स्ट्रिंग फ़ंक्शंस का उपयोग करना :) यह पहले से ही पोस्ट किए गए अन्य समाधानों के समान / समान है। इनपुट STDIN और बिल्लियों के माध्यम से STDOUT में है।

cat(substring(a<-scan(,'',sep='|'),Reduce(min,lapply(strsplit(a,' '),function(x)min(which(x>''))-1))),sep='\n')

परीक्षण और स्पष्टीकरण

> cat(substring(a<-scan(,'',sep='|'),Reduce(min,lapply(strsplit(a,' '),function(x)min(which(x>''))-1))),sep='\n')
1:                  a<-scan(,'',sep='|') # get the input lines
2:                                                         strsplit(a,' ') # split lines on spaces
3:                                                  lapply(                ,function(x)min(which(x>''))-1) # get min index - 1 for non space of each line
4:                                      ,Reduce(min,                                                      ) # get the min of those
5:        substring(                                                                                       ) # trim it off
6:    cat(                                                                                                  ,sep='\n') # output each line
7:
Read 6 items
              a<-scan(,'',sep='|') # get the input lines
                                                     strsplit(a,' ') # split lines on spaces
                                              lapply(                ,function(x)min(which(x>''))-1) # get min index - 1 for non space of each line
                                  ,Reduce(min,                                                      ) # get the min of those
    substring(                                                                                       ) # trim it off
cat(                                                                                                  ,sep='\n') # output each line
> 

Comments

अरे, 3k प्रतिनिधि पर बधाई!

— एलेक्स ए।

@AlexA। चीयर्स, यह मेरे लिए महत्वपूर्ण नहीं था ... लेकिन :)

— मिकट

आपका मतलब है कि आपका जीवन नकली इंटरनेट बिंदुओं के आसपास नहीं घूमता है? : पी

— एलेक्स ए।

@AlexA। उम्मीद नहीं है :) 6k पर बधाई

— मिकट

Answer 19

जूलिया, 72 62 61 57 54 49 बाइट्स

g=s->ismatch(r"^\S"m,s)?s:g(replace(s,r"^ "m,""))

Ungolfed:

g(s)=
if ismatch(r"^\S"m,s)       # Determines if there's a newline followed by something other than a space
                            # Note: the m in r"^ "m says to work in multiline mode.
    s                       # If there is, return the string as the final result.
else                        # otherwise...
    m=replace(s,r"^ "m,"")  # Remove first space after each newline, and space at start of string.
    g(m)                    # Feed back into the function for recursion
end

पुराना समाधान (57 बाइट्स):

g(s)=ismatch(r"
\S","
"s)?s:g(replace(s,"
 ","
")[2:end])

मूल समाधान (72 बाइट्स):

g(s)=all([i[1]<33for i=split(s,"\n")])?g(replace(s,"\n ","\n")[2:end]):s

Answer 20

k (24 बाइट्स)

एक स्ट्रिंग को एक तर्क के रूप में लेता है और एक स्ट्रिंग देता है (नई-नई अनुगामी के साथ)।

{`/:(&//&:'~^s)_'s:`\:x}

उदाहरण:

k) f:{`/:(&//&:'~^s)_'s:`\:x};
k) f"   a   b\n     c     d\n    e f"
"a   b\n  c     d\n e f\n

Answer 21

05AB1E , 10 बाइट्स

|©ζ®gð*Ûζ»

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

Comments

प्रतीक्षा, *स्ट्रिंग को दोहराता है ख एक बार की राशि? .. की कि सुविधा के बारे में पता था कि नहीं था *। s∍जब मैं एक निश्चित चरित्र को दोहराना चाहता हूं तो मैं आमतौर पर (स्वैप और लंबा) करता हूं।

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

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

— श्री Xcoder

Answer 22

गौक, 101 100

{match($0,/^( +)/,t);if(t[1]<s||s==""){s=t[1]};z[NR]=$0;}END{for(r in z){sub(s,"",z[r]);print z[r]}}

उदाहरण के लिए...

cat input.txt | gawk '{match($0,/^( +)/,t);if(t[1]<s||s==""){s=t[1]};z[NR]=$0;}END{for(r in z){sub(s,"",z[r]);print z[r]}}'

आउटपुट ...

a   b
  c     d
 e f

Comments

बस मुश्किल से परीक्षण किए गए संकेत: कब्जा न करें /^( +)/→ /^ +/(तब आपको t[0]इसके बजाय आवश्यक मूल्य होगा t[1]); परिवर्तन s==""→ !s; कोड के बाद {और }उसके आसपास निकालें if; ;पहले हटा दें }; Gkk- विशिष्ट फ़ंक्शन का उपयोग करने के बाद {और }उसके बाद कोड को निकालने में सक्षम होने के लिए for: {sub(s,"",z[r]);print z[r]}→ print gensub(s,"",1,z[r])।

— 19-22 को मैनटवर्क

कहने के लिए क्षमा करें, लेकिन आपका मूल कोड और मेरे आकार अनुकूलन दोनों ही पिछले एक के अलावा एक अनएन्डेटेड लाइन के साथ इनपुट पर विफल हो रहे हैं। (उदाहरण के लिए "\one \ nzero \ n \one \ nwotwo"।)

— manatwork

Answer 23

सी जीसीसी, 74 बाइट्स

main(_,z){z=1;while(-~(_=getchar()))putchar(_==32&&z?0:(z=_==10?1:0,_));}

केवल सभी व्हाट्सएप को हटाता है, पिछली लाइनों से संबंधित नहीं, समाप्त करने के लिए मदद का अनुरोध करता है। ALSO, सामान्य व्हाट्सएप के संदर्भ में, क्या ओपी का अर्थ है कि किस लाइन में सबसे कम प्रमुख स्थान हैं, प्रत्येक स्थान से हटाए जाने वाले रिक्त स्थान की संख्या कितनी है?

Comments

हां, सबसे अग्रणी स्थानों के साथ लाइन का उपयोग करना सही है।

— Sp3000

Answer 24

स्टैक्ड , नॉन-कमिंग, 43 बाइट्स

:lines'^ +'match$#'"!MIN' '*0# '^'\+''mrepl

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

यह प्रत्येक पंक्ति ( '^ +'match$#'"!) की शुरुआत में रिक्त स्थान की मात्रा का पता लगाकर काम करता है , न्यूनतम प्राप्त कर रहा है, एक स्थान को कई बार दोहराता है, और प्रत्येक पंक्ति में कुछ भी नहीं के साथ प्रतिस्थापित करता है।

Answer 25

विम, 33 , 31 बाइट्स

qq/\v%^(\s.*\n?)*%$
:%s/.
@qq@q## Heading ##

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

पुराना संस्करण:

qq:g/\v%^(\s.*\n?)*%$/%s/.
n@qq@q

Answer 26

स्टैक्स , 9 बाइट्स

ü═≤+Σî║┘`

इसे चलाएं और डीबग करें

Answer 27

कॉफीस्क्रिप्ट, 112 बाइट्स

f=(x)->(a=x.split "\n").map((v)->v[Math.min.apply(null,a.map((v)->(r=/^ +/.exec v)&&r[0].length))...]).join "\n"

Answer 28

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

नए अंक आवश्यक हैं और प्रत्येक को 1 बाइट के रूप में गिना जाता है:

f=x=>(a=x.split`
`).map(v=>v.slice(Math.min(...a.map(v=>(r=/^ +/.exec(v))&&r[0].length)))).join`
`

डेमो

अन्य ES6 उत्तरों के साथ, वे फिलहाल फ़ायरफ़ॉक्स में काम करते हैं।

f=x=>(a=x.split`
`).map(v=>v.slice(Math.min(...a.map(v=>(r=/^ +/.exec(v))&&r[0].length)))).join`
`

// For demonstration purposes
console.log = x => X.innerHTML += x + `\n<hr>`;

console.log(f("a"));
console.log(f("   abc"));
console.log(f("   abc\n def\n  ghi"));
console.log(f("    a\n    b\n    c"));
console.log(f("    a\n    b\n    c\nd"));
console.log(f("   a   b\n     c     d\n    e f"));

<pre id=X></pre>

Comments

यह बहुत अच्छा होगा यदि

— डाउनवॉटर

Answer 29

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

s=>s.split`
`.map(z=>z.slice(Math.min(...s.match(/^ */gm).map(l=>l.length)))).join`
`

नई लाइनें महत्वपूर्ण हैं

ES5 डेमो:

function t(s) {
  return s.split("\n").map(function(z) {
    return z.slice(Math.min.apply(0, s.match(/^ */gm).map(function(l) {
      return l.length;
    })));
  }).join('');
}

// Demo
document.getElementById('go').onclick = function() {
  document.getElementById('r').innerHTML = t(document.getElementById('t').value)
};

Input:
<br>
<textarea id="t"></textarea>
<br>
<button id="go">Run</button>
<br>Output:
<br>
<pre style="background-color:#DDD;" id="r"></pre>

Answer 30

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

पुनरावर्ती, प्रत्येक पंक्ति से एक समय में एक स्थान को हटाने की कोशिश कर रहा है जब तक कि एक गैर-स्थान नहीं मिलता है।

नीचे दिए गए स्निपेट का परीक्षण करें - केवल ES6, फ़ायरफ़ॉक्स

f=s=>(r=s.replace(/^./gm,x=>(k|=x>' ',''),k=0),k?s:f(r))

// Test
test=
[[ "a", "a" ]
,["   abc", "abc" ]
,["   abc\n def\n  ghi", "  abc\ndef\n ghi" ]
,["    a\n    b\n    c", "a\nb\nc" ]
,["    a\n    b\n    c\nd", "    a\n    b\n    c\nd" ]
,["   a   b\n     c     d\n    e f","a   b\n  c     d\n e f" ]]

var tb=''
test.forEach(t=>{
  t[2]=f(t[0])
  t[3]=t[2]==t[1]?'OK':'FAIL'
  tb+='<tr><td>'+t.join('</td><td>')+'</td></tr>'
})
B.innerHTML=tb

td { white-space: pre; font-family: monospace; border: 1px solid#444; vertical-align:top}
#I,#O { height:100px; width: 200px }

<b>Your test:</b>
<table><tr><td><textarea id=I></textarea></td>
<th><button onclick='O.innerHTML=f(I.value)'>-></button></th>
<td id=O></td></tr></table>
<b>Test cases:</b><br>
<table ><tr><th>Input</th><th>Expected</th><th>Output</th><th>Result</th></tr>
<tbody id=B></tbody></table>