একটি বাশ ব্রেস সম্প্রসারণ প্রসারিত করুন

Question

বেশিরভাগ historicalতিহাসিক কারণে, বাক্স সিনট্যাক্স এবং প্রোগ্রামিং প্যারাডিমগুলির বেশ একটি হজ পড - এটি এটিকে বিশ্রী এবং কখনও কখনও গল্ফকে হতাশ করতে পারে However তবে এটির কিছুটা কৌশল রয়েছে যা এটি অন্যান্য মূলধারার স্ক্রিপ্টের সাথে প্রায়শই প্রতিযোগিতামূলক করে তুলতে পারে slee ভাষা। এর মধ্যে একটি হ'ল বন্ধনী সম্প্রসারণ ।

দুটি ধনুর্বন্ধনী প্রসারণের প্রাথমিক ধরণ রয়েছে:

• তালিকার ধনুর্বন্ধনীগুলিতে স্বতন্ত্র স্ট্রিংগুলির অনুলিপি-বিচ্ছিন্ন তালিকা থাকতে পারে (নকল এবং খালি স্ট্রিং সহ)। উদাহরণস্বরূপ {a,b,c,,pp,cg,pp,}প্রসারিত হবে a b c pp cg pp(ফাঁকা স্ট্রিংগুলির চারপাশের স্পেসগুলি নোট করুন)।
• সিকোয়েন্স ব্রেসগুলিতে সিকোয়েন্স এন্ডপয়েন্টগুলি পৃথক করে থাকতে পারে ..। Ptionচ্ছিকভাবে অন্য ..একটি অনুসরণ করতে পারে, তারপরে একটি ধাপের আকার। সিকোয়েন্স এন্ডপয়েন্টগুলি হয় পূর্ণসংখ্যা বা অক্ষর হতে পারে। ক্রমটি স্বয়ংক্রিয়ভাবে আরোহণ বা নীচে নেমে যাবে যা অনুযায়ী শেষের অবস্থানটি বেশি। উদাহরণ স্বরূপ:
  • {0..15} প্রসারিত হবে 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
  • {-10..-5} প্রসারিত হবে -10 -9 -8 -7 -6 -5
  • {3..-6..2} প্রসারিত হবে 3 1 -1 -3 -5
  • {a..f} প্রসারিত হবে a b c d e f
  • {Z..P..3} প্রসারিত হবে Z W T Q

এর বাইরে, তালিকা ব্রেসগুলির সাথে ক্রম এবং তালিকার ধনুর্বন্ধনী উপস্থিত থাকতে পারে:

• {a,b,{f..k},p} প্রসারিত হবে a b f g h i j k p
• {a,{b,c}} প্রসারিত হবে a b c

ধনুর্বন্ধনী তার উভয় পাশের অ-হোয়াইটস্পেস স্ট্রিং দিয়ে প্রসারিত হয়। উদাহরণ স্বরূপ:

• c{a,o,ha,}t প্রসারিত হবে cat cot chat ct

এটি একত্রে একত্রিত একাধিক ধনুর্বন্ধনীগুলির জন্যও কাজ করে:

• {ab,fg}{1..3} প্রসারিত হবে ab1 ab2 ab3 fg1 fg2 fg3

এটি বেশ জটিল হতে পারে। উদাহরণ স্বরূপ:

• {A..C}{x,{ab,fg}{1..3},y,} প্রসারিত হবে Ax Aab1 Aab2 Aab3 Afg1 Afg2 Afg3 Ay A Bx Bab1 Bab2 Bab3 Bfg1 Bfg2 Bfg3 By B Cx Cab1 Cab2 Cab3 Cfg1 Cfg2 Cfg3 Cy C

যাইহোক, যদি বিস্তারের মধ্যে শ্বেত স্থান থাকে তবে এগুলি কেবল পৃথক বিস্তৃতি হিসাবে প্রসারিত হয়। উদাহরণ স্বরূপ:

• {a..c} {1..5} প্রসারিত হবে a b c 1 2 3 4 5

অর্ডার কীভাবে সর্বদা সংরক্ষিত থাকে তা নোট করুন।

---

এই চ্যালেঞ্জের জন্য এন্ট্রিগুলি উপরে বর্ণিত অনুসারে ব্যাশ বন্ধনী সম্প্রসারণ প্রসারণ করবে। নির্দিষ্টভাবে:

• bash(বা অন্যান্য শেল যে একই সম্প্রসারণ সম্পাদন করে) দ্বারা বিবর্তনের অনুমতি নেই
• সিকোয়েন্স ব্রেসগুলি সর্বদা নম্বর-থেকে-সংখ্যা, লোয়ারকেস-থেকে-লোয়ারকেস বা বড় হাত থেকে বড় বড় কোনও মিশ্রণ ছাড়াই থাকবে। নম্বরগুলি 32-বিট স্বাক্ষরিত ব্যাপ্তিতে পূর্ণসংখ্যা হবে। যদি দেওয়া হয়, theচ্ছিক পদক্ষেপের আকারটি সর্বদা একটি ধনাত্মক পূর্ণসংখ্যার হবে। (নোট করুন যে ব্যাশ পাশাপাশি প্রসারিত হবে {A..z}, তবে এই চ্যালেঞ্জের জন্য এটি এড়ানো যেতে পারে)
• তালিকার ধনুর্বন্ধনীতে পৃথক আইটেমগুলি সর্বদা কেবল উচ্চ - এবং নিম্ন-বর্ণের বর্ণমালা অক্ষর (ফাঁকা স্ট্রিং অন্তর্ভুক্ত) সমন্বিত থাকে
• তালিকার ধনুর্বন্ধনীগুলিতে অন্যান্য ধনুর্বন্ধনী প্রসারণের নির্বিচারে বাসা থাকতে পারে
• ধনুর্বন্ধনী সময় নির্বিচারে সংখ্যার হতে পারে। এটি আপনার ভাষার স্মৃতিশক্তি দ্বারা সীমাবদ্ধ থাকবে, সুতরাং প্রত্যাশাটি হ'ল আপনি তাত্ত্বিকভাবে নির্বিচার সংখ্যক কনটেন্টেশনগুলি করতে পারেন তবে যদি / আপনি যখন স্মৃতি থেকে বেরিয়ে যান যা আপনার বিরুদ্ধে গণনা করবে না।

উপরের পাঠ্যের উদাহরণগুলি টেস্টকেস হিসাবে পরিবেশন করে। সংক্ষিপ্ত আকারে, প্রতিটি আউটপুট একই লাইনের সাথে ইনপুট প্রতিটি লাইন, তারা হ'ল:

ইনপুট

{0..15}
{-10..-5}
{3..-6..2}
{a..f}
{Z..P..3}
{a,b,{f..k},p}
{a,{b,c}}
c{a,o,ha,}t
{ab,fg}{1..3}
{A..C}{x,{ab,fg}{1..3},y,}
{a..c} {1..5}
{a{0..100..10},200}r

আউটপুট

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
-10 -9 -8 -7 -6 -5
3 1 -1 -3 -5
a b c d e f
Z W T Q
a b f g h i j k p
a b c
cat cot chat ct
ab1 ab2 ab3 fg1 fg2 fg3
Ax Aab1 Aab2 Aab3 Afg1 Afg2 Afg3 Ay A Bx Bab1 Bab2 Bab3 Bfg1 Bfg2 Bfg3 By B Cx Cab1 Cab2 Cab3 Cfg1 Cfg2 Cfg3 Cy C
a b c 1 2 3 4 5
a0r a10r a20r a30r a40r a50r a60r a70r a80r a90r a100r 200r

Comments

আমি এটি দেখেছিলাম এবং সমস্ত প্রান্তের কেসগুলির কারণে কেবল বিশ্লেষণ করার জন্য এটি একটি ব্যথা :-(

— নীল

Answer 1

রুবি, 405 403 401 400 বাইট

একজন জ্ঞানী ব্যক্তি (জেমি জাওনস্কি) একবার বলেছিলেন, "কিছু লোক যখন সমস্যার মুখোমুখি হয়, তখন মনে হয় 'আমি জানি, আমি নিয়মিত অভিব্যক্তি ব্যবহার করব।' এখন তারা দুটি সমস্যা আছে."

আমি মনে করি না যতক্ষণ না আমি পুনরাবৃত্তিমূলক রেগেক্সের সাহায্যে এই সমস্যাটি সমাধান করার চেষ্টা না করে আমি সেই উদ্ধৃতিটির পুরোপুরি প্রশংসা করেছি। প্রথমদিকে, রেজেক্স কেসগুলি সহজ বলে মনে হয়েছিল, যতক্ষণ না বন্ধনী সংলগ্ন চিঠিগুলিতে জড়িত প্রান্তের মামলাগুলি আমাকে মোকাবেলা করতে হয়েছিল এবং তারপরে আমি জানতাম যে আমি জাহান্নামে আছি।

যাইহোক, পরীক্ষার কেসগুলি সহ এটি এখানে অনলাইনে চালাও

->s{s.gsub!(/{(-?\w+)..(-?\w+)(..(\d+))?}/){x,y=$1,$2;a,b,c=[x,y,$4].map &:to_i
$1[/\d/]?0:(a,b=x,y)
k=a<b ?[*a..b]:[*b..a].reverse
?{+0.step(k.size-1,$4?c:1).map{|i|k[i]}*?,+?}}
r=1
t=->x{x[0].gsub(/^{(.*)}$/){$1}.scan(/(({(\g<1>|,)*}|[^,{}]|(?<=,|^)(?=,|$))+)/).map{|i|i=i[0];i[?{]?r[i]:i}.flatten}
r=->x{i=x.scan(/({(\g<1>)*}|[^{} ]+)/).map(&t)
i.shift.product(*i).map &:join}
s.split.map(&r)*' '}

Ungolfed:

->s{
  s.gsub!(/{(-?\w+)..(-?\w+)(..(\d+))?}/){  # Replace all range-type brackets {a..b..c}
    x,y=$1,$2;a,b,c=[x,y,$4].map &:to_i     # Set up int variables
    $1[/\d/]?0:(a,b=x,y)                    # Use int variables for a,b if they're numbers
    k=a<b ?[*a..b]:[*b..a].reverse          # Create an array for the range in the correct direction
    '{'+                                    # Return the next bit surrounded by brackets
      0.step(k.size-1,$4?c:1).map{|i|k[i]   # If c exists, use it as the step size for the array
      }*','                                 # Join with commas
      +'}'
  }
  r=1                                       # Dummy value to forward-declare the parse function `r`
  t=->x{                                    # Function to parse a bracket block
    x=x[0].gsub(/^{(.*)}$/){$1}             # Remove outer brackets if both are present
                                            # x[0] is required because of quirks in the `scan` function
    x=x.scan(/(({(\g<1>|,)*}|[^,{}]|(?<=,|^)(?=,|$))+)/)
                                            # Regex black magic: collect elements of outer bracket
    x.map{|i|i=i[0];i[?{]?r[i]:i}.flatten   # For each element with brackets, run parse function
  }
  r=->x{                                    # Function to parse bracket expansions a{b,c}{d,e}
    i=x.scan(/({(\g<1>)*}|[^{} ]+)/)        # Regex black magic: scan for adjacent sets of brackets
    i=i.map(&t)                             # Map all elements against the bracket parser function `t`
    i.shift.product(*i).map &:join          # Combine the adjacent sets with cartesian product and join them together
  }
  s.split.map(&r)*' '                       # Split on whitespace, parse each bracket collection
                                            #   and re-join with spaces
}

Answer 2

পাইথন 2.7, 752 728 বাইট

বাহ, এটি একটি চ্যালেঞ্জের কোড গল্ফের গোছার মতো!

একটি ল্যাম্বডা ছোট করার জন্য @ নীলকে ধন্যবাদ জানাই

def b(s,o,p):
 t,f=s>':'and(ord,chr)or(int,str);s,o=t(s),t(o);d=cmp(o,s)
 return list(map(f,range(s,o+d,int(p)*d)))
def e(s):
 c=1;i=d=0
 while c:d+=-~'{}}'.count(s[i])%3-1;i+=1;c=i<len(s)and 0<d
 return i
def m(s):
 if len(s)<1:return[]
 if','==s[-1]:return m(s[:-1])+['']
 i=0
 while i<len(s)and','!=s[i]:i+=e(s[i:])
 return[s[:i]]+m(s[i+1:])
n=lambda a,b:[c+d for c in a for d in b]or a or b
def p(s):
 h=s.count
 if h('{')<1:return[s]
 f,l=s.index('{'),e(s)
 if h('{')<2and h('..')>0and f<1:s=s[1:-1].split('..');return b(s[0],s[1],s[2])if len(s)>2 else b(s[0],s[1],1)
 if f>0 or l<len(s):return n(p(s[:f]),n(p(s[f:l]),p(s[l:])))
 return sum(map(list,map(p,m(s[1:-1]))),[])
o=lambda s:' '.join(p('{'+s.replace(' ',',')+'}'))

ব্যাখ্যা

• b: চশমা অনুসারে পরিসর গণনা করে।
• e: প্রথম বাহ্যিকতম বন্ধনী বন্ধনী অবস্থানে ফিরে আসে। পুনরাবৃত্ত।
• m: কমাতে বহিরাগত উপাদানগুলি বিভক্ত করে। পুনরাবৃত্তি.
• n: খালিগুলি পরীক্ষা করার সময় অ্যারেগুলিকে একত্রিত করে। আমি and/orকাজ পেতে পারিনি ।
• p: যেখানে বেশিরভাগ কাজ শেষ হয়। সমস্ত কেস পরীক্ষা করে (সীমা, কেবল তালিকা, একত্রিত করা প্রয়োজন)। পুনরাবৃত্তি.
• o: কি ইনপুট নিতে হবে। ইনপুট / আউটপুট এতে বিন্যাস করে p।

---

আমি অনুভব করি যে আমি কিছু জায়গায় উন্নতি করতে পারি, তাই আরও গল্ফ করার চেষ্টা করব। এছাড়াও আমার ব্যাখ্যায় আরও বিস্তারিত বলা উচিত।

Comments

আমি [c+d for c in a for d in b] or a or bকাজ আশা করতে হবে ।

— নীল

Answer 3

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 465 427 425 বাইট

f=s=>/\{/.test(s)?f(s.replace(/([^,{}]*\{[^{}]*\})+[^,{}]*/,t=>t.split(/[{}]+/).map(u=>u.split`,`).reduce((a,b)=>[for(c of a)for(d of b)c+d]))):s.split`,`.join` `
s=>f(`{${s.split` `}}`.replace(/\{(-?\w+)\.\.(-?\w+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{m=(a>'@')+(a>'_');a=parseInt(a,m?36:10);o=parseInt(o,m?36:10);e=+e||1;if(o<a)e=-e;for(r=[];e<0?o<=a:a<=o;a+=e)r.push(m?a.toString(36):a);r=`{${r}}`;return m-1?r:r.toUpperCase()}))

fঅতিরিক্ত ES6 ভার্সনের অতিরিক্ত 10 বাইট:

f=s=>/\{/.test(s)?f(s.replace(/([^,{}]*\{[^{}]*\})+[^,{}]*/,t=>t.split(/[{}]+/).map(u=>u.split`,`).reduce((a,b)=>[].concat(...a.map(c=>b.map(d=>c+d)))))):s.split`,`.join` `
g=s=>f(`{${s.split` `}}`.replace(/\{(-?\w+)\.\.(-?\w+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{m=(a>'@')+(a>'_');a=parseInt(a,m?36:10);o=parseInt(o,m?36:10);e=+e||1;if(o<a)e=-e;for(r=[];e<0?o<=a:a<=o;a+=e)r.push(m?a.toString(36):a);r=`{${r}}`;return m-1?r:r.toUpperCase()}))
h=(s,t=s.replace(/\{[^{}]*\}/,""))=>s!=t?h(t):!/[{}]/.test(s)

<input oninput="o.textContent=h(this.value)?g(this.value):'{Invalid}'"><div id=o>

ব্যাখ্যা: স্পেসটি কমাতে পরিবর্তন করে এবং {}ধারাবাহিকতার জন্য পুরো স্ট্রিংটি মোড়ানো দ্বারা শুরু করা হয় (ধারণার জন্য @ ব্লুকে ধন্যবাদ)। তারপরে সমস্ত {..}কনস্ট্রাক্টসের জন্য অনুসন্ধান করে এবং সেগুলি {,}নির্মাণে প্রসারিত করে । এরপরে পুনরাবৃত্তিটি {,}অভ্যন্তরীণ থেকে সমস্ত কন্সট্রাক্টকে বারবার প্রসারিত করতে ব্যবহার করে। অবশেষে সমস্ত কমা স্থানগুলির সাথে প্রতিস্থাপন করে।

f=s=>/\{/.test(s)?                  while there are still {}s
 f(s.replace(                       recursive replacement
  /([^,{}]*\{[^{}]*\})+[^,{}]*/,    match the deepest group of {}s
  t=>t.match(/[^{}]+/g              split into {} terms and/or barewords
   ).map(u=>u.split`,`              turn each term into an array
   ).reduce((a,b)=>                 loop over all the arrays
    [for(c of a)for(d of b)c+d]))   cartesian product
  ):s.split`,`.join` `              finally replace commas with spaces
s=>f(                               change spaces into commas and wrap
 `{${s.split` `}}`.replace(         match all {..} seqences
   /\{([-\w]+)\.\.([-\w]+)(\.\.(\d+))?\}/g,(m,a,o,_,e)=>{
    m=(a>'@')+(a>'_');              sequence type 0=int 1=A-Z 2=a-z
    a=parseInt(a,m?36:10);          convert start to number
    o=parseInt(o,m?36:10);          convert stop to number
    e=+e||1;                        convert step to number (default 1)
    if(o<a)e=-e;                    check if stepping back
    for(r=[];e<0?o<=a:a<=o;a+=e)    loop over each value
     r.push(m?a.toString(36):a);    convert back to string
    r=`{${r}}`;                     join together and wrap in {}
    return m-1?r:r.toUpperCase()})) convert type 1 back to upper case