সাধারণ নেতৃস্থানীয় স্থানগুলি সরান

Question

পাইথনে কোডিং করার সময়, কখনও কখনও আপনি কোনও ফাংশনের মধ্যে একটি বহুমাত্রিক স্ট্রিং চান, যেমন

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

^{(ব্যাকস্ল্যাশ হল একটি শীর্ষস্থানীয় নিউলাইন সরানো)}

আপনি যদি প্রিন্ট করার চেষ্টা করেন sতবে আপনি পাবেন

    Line 1
    Line 2
    Line 3

আমরা আদৌ যা চাই তা নয়! সেখানে অনেক বেশি হোয়াইটস্পেস রয়েছে!

চ্যালেঞ্জ

কেবলমাত্র বর্ণানুক্রমিক অক্ষর, স্পেস এবং নিউলাইনগুলিকে সমন্বিত একাধিক স্ট্রিং দেওয়া হয়েছে, প্রতিটি লাইনের শুরু থেকে সমস্ত সাধারণ স্পেস সরিয়ে ফেলুন। প্রতিটি লাইনে কমপক্ষে একটি অ-স্পেস অক্ষর থাকার গ্যারান্টিযুক্ত এবং এতে কোনও পিছনের স্থান থাকবে না। আউটপুটটির বহিরাগত সাদা স্থান থাকতে পারে না, এটি পুরো আউটপুটের আগে বা পরে বা স্বতন্ত্র লাইনের (একক alচ্ছিক ট্রেইলিং নিউলাইন বাদে)।

ইনপুটটি 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

সিজেম, 20 14 বাইট

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

অ্যালগরিদম :

• আমরা প্রথমে নিউলাইনগুলিতে ইনপুট বিভক্ত করি এবং একটি অনুলিপি গ্রহণ করি ( qN/_)
• তারপরে স্পেসহীন অক্ষরের সাথে ক্ষুদ্রতম কলামটি নিউলাইন পৃথক পৃথক অ্যারে স্থানান্তর করে এবং পরে কেবল প্রথম অ-সমস্ত স্থানের সারিটির সূচকটি অনুসন্ধান করে গণনা করা হয় ( z{S-}#)
• তারপরে আমরা কেবল প্রতিটি লাইন ( f>) থেকে অনেকগুলি অক্ষর সরিয়ে ফেলি
• অবশেষে, আমরা আবার নতুন লাইনে যোগদান করি ( 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 নিউলাইন দ্বারা লাইনের অ্যারে যোগদান করে এবং এটি মুদ্রণ।

Comments

আপনি কি দয়া করে এ সম্পর্কে একটি ছোট ব্যাখ্যা দিতে পারেন? এটা আমার কাছে খুব অদ্ভুত!

— বববেল

@ বুবল ব্যাখ্যার যোগ হয়েছে।

— orlp

সত্যিই দুর্দান্ত, ধন্যবাদ! এ সম্পর্কে কখনও শুনিনি! অনলাইনে এটি চেষ্টা করার জন্য আমি পাই: পাইথ.হেরোকুয়াপস্.প

— বোবল

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পুরো ইনপুটটিকে একক স্ট্রিং হিসাবে পড়বে (আসলে লাইন ডিলিমিটার হিসাবে NUL- বাইট ব্যবহার করে)

Comments

:;N;$!bএকক প্যাটার্ন স্পেসে ইনপুট লাইনগুলিকে একত্রিত করার জন্য আপনার কি আর শুরু করার দরকার নেই ? সম্পাদনা: না আপনি না; যে কি -zপতাকা জন্য।

— টবি স্পিড 20

আপনি এটিকে গল্ফ করতে পারেন :;/^\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`).ব্যাককোটিস সহ এটির কল করার একটি উদাহরণ । আপনার "যদি পুরানো এসডাব্লুআই-প্রোলোগ বিতরণ করে থাকে তবে পরিবর্তে আপনার ডাবল উদ্ধৃতি ব্যবহার করতে হবে ।

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 বাইট সংরক্ষণ করে (3 টি সহ including =ইন ). Still looking to see if more can be saved. (I wish I could drop the [1] instead এর পরিবর্তে ব্যবহার করে সংরক্ষণ করা হয়েছে , তবে অনুসন্ধানে কোনও প্রকারের একটি এনামুরেটর অ্যারে তৈরি করা হয়, যদিও সর্বনিম্ন প্রয়োজন একটি ইন্টার টাইপ)

— গ্লেন ও

উপরের ভুলটি ক্ষমা করুন - দৃশ্যত, আমি আমার সম্পাদনাগুলি ব্যবহার করেছি - এটি 9 বাইট নয়, 6, কারণ আমি খেয়াল করতে ব্যর্থ হয়েছি যে আপনি = গল্ফযুক্ত আকারে ব্যবহার করেছেন। যাইহোক, আমি লুপটির জন্য পি শুরু করে আরও দুটি চরিত্র সংরক্ষণ করতে পারি:s->for i=(p=split(s,"\n")) println(i[minimum([search(j,r"[^ ]")[1]for j=p]):end])end

— গ্লেন ও

ঠিক আছে, এখানে একটি বিট আরো শেভ অন্য এক নেই - বরং ব্যবহার না করে minimum(x)যখন xএকটি অ্যারের, ব্যবহার min(x...), এক অতিরিক্ত বাইট সংরক্ষিত জন্য (আমি জুলিয়া golfing টিপস আমার তালিকা এই এক যোগ করা যাচ্ছে না)।

— গ্লেন ও

@ গ্লেনো নিস, পরামর্শের জন্য ধন্যবাদ। এছাড়াও, যেহেতু জুলিয়া PCRE ব্যবহার করে, অ স্পেস দিয়ে মিলেছে করা যাবে \Sবদলে [^ ]যা বাইট সংরক্ষণ করে,।

— অ্যালেক্স এ।

আরে, এটি উল্লেখ করার জন্য ধন্যবাদ - আমি রেজেক্সের সাথে ভাল নই, তবে এটি \Sআমার সমাধানের পক্ষেও কার্যকর is

— গ্লেন ও

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

পার্লের অন্তর্নিহিত লুপটি ব্যবহারের পরামর্শের জন্য @ থিসসুইটআইএস ব্ল্যাক নটকে ধন্যবাদ

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

উপরেরগুলি 00pপতাকাগুলির জন্য কোডের লাইনের জন্য 30 বাইট হিসাবে স্কোর করা হয় ।

মূল সংস্করণ, একটি ফাংশন হিসাবে:

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

এটি যুক্তিটিকে রাখে $_, তারপরে লোভের সাথে সমস্ত লাইনে উপস্থিত সাদা স্পেসের সাথে মেলানোর চেষ্টা করে /^( +).*(\n\1.*)*$/- যদি সফল হয় তবে $1এখন দীর্ঘতম সাধারণ উপসর্গ রয়েছে এবং আমরা s/^$1//mgrপ্রতি লাইনের শুরু থেকে এটি মুছতে এবং ফলস্বরূপ স্ট্রিংটি ফিরিয়ে দিতে প্রতিস্থাপনটি কার্যকর করি ute

পরীক্ষা

$ 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)।

— এইসুইটসস ব্ল্যাকনট

/meমাথা নিচু করার জন্য -00p; ধন্যবাদ @ThisSuit

— টবি

Answer 8

পাইথন 2, 86 79 75 বাইট

এটি প্রায় অবশ্যই আরও কিছু সংক্ষিপ্ত করা যেতে পারে, তবে এখনই এটি খারাপ নয় right

এক্সনোরকে 4 টি বাইট সংরক্ষণের জন্য ধন্যবাদ!

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 এ এই ডেটা বন্ধ করে দেবে।

— স্টিভেন রাম্বালস্কি

@ স্টিভেন রাম্বালস্কি, আমি ধরে নিই যে ইনপুটটি চারপাশে উদ্ধৃতিযুক্ত। আমি এটিতে অ্যাকাউন্টে বাইট কাউন্টে 2 যোগ করতাম তবে একাধিক লোক বলেছে যে আমার দরকার নেই।

— কেড

এই প্রোগ্রামটি দুঃখজনক: ):

— হাইপারনিউটারিনো

Answer 9

রুবি: 77 73 70 66 65 58 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}/,""}?

— ভেন্টোরো

এটি দুর্দান্ত, @ ভেন্টোরো। ধন্যবাদ.

— manatwork

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 পৃষ্ঠা রিফ্রেশ আপনার সমাধান দেখেনি

— সোক

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

জাভাস্ক্রিপ্ট, ES6, 89 86 বাইট

এটি সম্পূর্ণরূপে কেবল রেজিএক্স ম্যাচিং এবং বিকল্পগুলি ব্যবহার করছে।

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>

সর্বদা হিসাবে, কেবল ফায়ারফক্স, ইএস 6 থেকে। পরে ES5 সংস্করণ যুক্ত করবে।

Comments

মনে হচ্ছে যেন কোনও স্ট্রিং হিসাবে নিয়মিত এক্সপ্রেশন আক্ষরিক লেখা এবং তারপরে এটি

— উদ্দীপনাটি

@ 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'))

Def (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, একটি হল lineutil-লিনাক্স প্যাকেজের মধ্যে হাতিয়ার।

— manatwork

@ মান্যাটওয়ার্ক: এটি একটি চরিত্র সংরক্ষণ করে, আমি এটি ব্যবহার করব। মনে রাখবেন যে অবচিত এবং ভবিষ্যতে অদৃশ্য পারে, এই থেকে deprecated.txt util-লিনাক্স এর উৎস গাছ: "কেন: বেহুদা, কেউ এই কমান্ড, মাথা (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

আরে, 3 কে রেপগুলিতে অভিনন্দন!

— অ্যালেক্স এ।

@AlexA। চিয়ার্স, আমার কাছে এটি গুরুত্বপূর্ণ মনে হয় নি ... তবে :)

— মিকিটি

আপনার মানে আপনার জীবনটি নকল ইন্টারনেট পয়েন্টগুলির চারপাশে ঘোরে না ? : পি

— অ্যালেক্স এ।

@AlexA। আশা করছি না :) 6 কে অভিনন্দন

— মিকিটি

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

কে (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

05 এ বি 1 ই , 10 বাইট

|©ζ®gð*Ûζ»

এটি অনলাইন চেষ্টা করুন!

Comments

অপেক্ষা করুন, *স্ট্রিং পুনরাবৃত্তি খ একটি সময়ের পরিমাণ? .. যে বৈশিষ্ট্য সম্পর্কে জানতাম না *। আমি s∍যখন কিছু নির্দিষ্ট চরিত্রের পুনরাবৃত্তি করতে চাই তখন আমি সাধারণত (অদলবদল এবং লম্বা করা) করি।

— কেভিন ক্রুইজসেন

হ্যাঁ, প্রকৃতপক্ষে, এটি স্ট্রিংয়ের জন্য কাজ করে, মূলত কারণ ভেক্টরাইজেশন স্ট্রিংয়ের ক্ষেত্রে যথেষ্ট অর্থ দেয় না এবং иঅক্ষরের একটি তালিকা দেয়।

— মিঃ এক্সকোডার

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; ;পূর্বে অপসারণ }; জবুথবু ব্যক্তি-নির্দিষ্ট ফাংশন ব্যবহার করে অপসারণ পাবে {এবং }পরে কোড চারপাশের for: {sub(s,"",z[r]);print z[r]}→ print gensub(s,"",1,z[r])।

— manatwork

দুঃখিত, তবে আপনার মূল কোড এবং আমার আকারের অপটিমাইজেশন সহ দুটিই সর্বশেষ কোডটি বাদে একটি আনইন্ডেন্টেড লাইনের সাহায্যে ইনপুটটিতে ব্যর্থ হচ্ছে। (উদাহরণস্বরূপ "␠one \ nzero \ n␠one \ n␠␠two"।)

— manatwork

Answer 23

সি জিসিসি, 74 বাইট

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

কেবলমাত্র পূর্ববর্তী লাইনের সাথে সম্পর্কিত নয়, সমস্ত শ্বেত স্পেস সরিয়ে দেয়, সমাপ্তির জন্য অনুরোধ করছে ing 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

জাভাস্ক্রিপ্ট (ES6), 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

জাভাস্ক্রিপ্ট ES6, 85 বাইট

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

নতুন লাইনগুলি তাৎপর্যপূর্ণ

ইএস 5 ডেমো:

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

জাভাস্ক্রিপ্ট ( ES6 ) 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>