আলগা ব্যাপ্তি ব্যাখ্যা

Question

আলগা ব্যাপ্তি ব্যাখ্যা

লিস্টশার্প একটি ব্যাখ্যাযুক্ত প্রোগ্রামিং ল্যাঙ্গুয়েজ যার অনেকগুলি বৈশিষ্ট্য রয়েছে, এই বৈশিষ্ট্যগুলির মধ্যে একটি হল 1 সূচক ভিত্তিক পরিসীমা নির্মাতা যা এইরকম কাজ করে:

আপনি যত একটি সীমার সংজ্ঞায়িত (INT) TO (INT)বা শুধু (INT)যেখানে উভয় বা একক int- এ সর্বনিম্ন থেকে ফিরে যেতে পারেন সর্বোচ্চ int32 মান

তারপরে আপনি এই সীমার সীমানা ছাড়িয়ে যাওয়ার ভয় ছাড়াই কোনও অ্যারের উপাদানগুলি বের করতে এই ব্যাপ্তিগুলি ব্যবহার করতে পারেন

---

অতএব:

1 TO 5 উত্পন্ন: {1,2,3,4,5}

3 উত্পন্ন: {3}

ANDঅপারেটরটি ব্যবহার করে ব্যাপ্তি যুক্ত করা যেতে পারে

1 TO 5 AND 3 TO 6 উত্পন্ন: {1,2,3,4,5,3,4,5,6}

মনে রাখবেন এটি নেতিবাচক সংখ্যাগুলির সাথেও কাজ করে

3 TO -3 উত্পন্ন: {3,2,1,0,-1,-2,-3}

---

চ্যালেঞ্জটি নিম্নলিখিত:

ইনপুট

একটি অক্ষর অ্যারে এবং একটি স্ট্রিং হিসাবে পূর্ব নির্ধারিত ব্যাপ্তি দফা

আউটপুট

পরিসরের 1 সূচক ভিত্তিক অবস্থানের উপাদানগুলি (অস্তিত্বহীন / নেতিবাচক সূচকগুলি একটি খালি অক্ষরে অনুবাদ করে)

---

জয় কিভাবে

কোড-গল্ফ চ্যালেঞ্জ হিসাবে আপনি জিততে সংক্ষিপ্ততম বাইট গণনা সহ প্রোগ্রামটি তৈরি করার কথা

---

এটি চিহ্নিত করা হয়েছে যে খালি অক্ষরগুলির অস্তিত্ব নেই, সুতরাং আপনার এগুলি উপেক্ষা করা উচিত (এটি কেবল মানুষকে বিভ্রান্ত করার বিষয়টি বুঝতে সহজ করার জন্য আমি কেবল এখানে এগুলি দেখিয়েছি)

পরীক্ষার কেস:

input array is:
{'H','e','l','l','o',' ','W','o','r','l','d'}

range clause:
"1 TO 3" => "Hel"
"5" => "o"
"-10 TO 10" => "Hello Worl"
"0 AND 2 AND 4" => "el"
"8 TO 3" => "oW oll"
"-300 AND 300" => ""
"1 TO 3 AND 3 TO 1" => "HelleH"
"-20 TO 0 AND 1 AND 4" => "Hl"

Comments

আমাদের কি ইনপুট স্ট্রিং হিসাবে 1-সূচির পরিবর্তে 0-সূচক ব্যবহার করার অনুমতি দেওয়া হচ্ছে? তাহলে রেঞ্জের ক্লজটি হয়ে যায় "0 TO 2"=> {'H', 'e', 'l'}?

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

এএসসিআইআই টেবিলের একটি খালি অক্ষর নেই (মুদ্রণযোগ্যগুলি বাদে)। জায়গা ব্যবহারে কী সমস্যা?

— অ্যাড্রিয়ান্প

একটি চর অ্যারে মূলত একটি স্ট্রিং, এর জন্য খালি চরগুলি কেবল মুদ্রিত বা ফিরে আসবে না

— ডাউনরেপ_নেশন

এছাড়াও, উদাহরণস্বরূপ 3 TO 3কি কোনও ইনপুট হবে এবং প্রত্যাশিত আউটপুটটি কী?

— জর্দান

আপনার ANDবহুগুণ রেঞ্জের জন্য কিছু পরীক্ষার কেস দরকার । এছাড়াও, আপনি উত্তর দিলেন না যে আমরা শূন্য-ভিত্তিক সূচক ব্যবহার করতে পারি, যা বেশিরভাগ ভাষায় আদর্শ।

— mbomb007

Answer 1

পাইথন 2 - 239 211 210 বাইট

ধন্যবাদ @ mbomb007 এবং @Cyoce আরও golfing এই সমাধান জন্য!

def r(s):
 t=[]
 for x in s.split("AND"):
  if"T"in x:a=map(int,x.split("TO"));b=2*(a[0]<a[1])-1;t+=range(a[0],a[1]+b,b)
  else:t+=int(x),
 return t
lambda p,v:[(['']+p+['']*max(map(abs,r(v))))[x]for x in r(v)]

সোজা-এগিয়ে পদ্ধতির। জেনারেটর এবং একটি পুনরাবৃত্ত সংস্করণ চেষ্টা করেছে, তবে তারা প্রতিটি লুপের জন্য সহজকে পরাস্ত করতে পারেনি। আমি একটি গল্ফিং নুব, সুতরাং এটি সম্ভবত বেশ কিছুটা উন্নত হতে পারে। এছাড়াও, এই স্নিপেটের প্রধান ত্রুটিটি হ'ল তালিকার অবজেক্ট হিসাবে পরিসরটি প্রতিটি সময় অক্ষরের অ্যারে থেকে পুনরুদ্ধার করার পরে পুনরায় গণনা করা হয় (শেষ লাইনটি দেখুন, তালিকা বোঝার জন্য)। এর অর্থ r(s)নির্ধারিত len(r(s)) + 1সময় হয়।

অবরুদ্ধ কোড:

def find_range(string):
    result = []

    # Split at each AND and look at each element separately
    for element in string.split("AND"):
        # Element is just a number, so add that number to the result list
        if "TO" not in string:
            result += [int(string)]

        # Generate a list with all the values in between the boundaries 
        # (and the boundaries themselves, of course) and append it to the result list
        else:
            boundaries = map(int, string.split("TO"))
            ascending = boundaries[0] < boundaries[1]

            # range(start, stop, step) returns [start, ..., stop - 1], so extend the stop value accordingly
            # range(8, 3, 1) returns just [], so choose respective step (negative for a descending sequence)
            result += range(boundaries[0], boundaries[1] + (1 if ascending else -1), 1 if ascending else -1)

# Make the char array 1-indexed by appending an empty char in 0th position
# Add enough empty chars at the end so too large and negative values won't wrap around
interpret = lambda chars, range_expr: [(['']+chars+['']*max(map(abs, find_range(range_expr))))[x] for x in find_range(range_expr)]

পরীক্ষার কেস:

c = list("Hello World")
print interpret(c, "1 TO 3")
print interpret(c, "5")
print interpret(c, "-10 TO 10")
print interpret(c, "0 AND 2 AND 4")
print interpret(c, "8 TO 3")
print interpret(c, "-300 AND 300")

আউটপুট:

['H', 'e', 'l']
['o']
['', '', '', '', '', '', '', '', '', '', '', 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l']
['', 'e', 'l']
['o', 'W', ' ', 'o', 'l', 'l']
['', '']

Comments

দুর্দান্ত প্রথম উত্তর! পিপিসিজিতে আপনাকে স্বাগতম!

— mbomb007

পাইথনে গল্ফিংয়ের টিপস দেখে আপনি উপকৃত হতে পারেন । আপনি একক ট্যাব দিয়ে ডাবল-ইনডেন্টেশনের জন্য 2 টি স্পেস প্রতিস্থাপন করতে পারেন। আপনি নিম্নলিখিত ifলাইনটিতে কোডটি রেখে দিতে পারেন এবং সেমিকোলনগুলি দিয়ে তাদের আলাদা করতে পারেন। এবং স্থানটি সরিয়ে ফেলুন [x] for। এছাড়াও, 1if b else-1হয় b and 1or-1বা 2*bool(b)-1একটি বাইট সংরক্ষণ সঙ্গে প্রতিস্থাপন করা যেতে পারে ।

— mbomb007

ধন্যবাদ! আমি ইতিমধ্যে তাদের কয়েকটি ব্যবহার করে দেখেছি (চেষ্টা করেছি)। সমস্ত উত্তর পরে আবার দেখা হবে। :)

— দারকো 1

এবং আমি মনে করি আপনি একটি নামবিহীন ব্যবহার করতে পারেন lambda, কারণ এটি পুনরাবৃত্ত হয় না।

— mbomb007

t+=[int(x)]ক্যানবেকোমt+=int(x),

— সাইয়েস

Answer 2

গ্রোভি ( 99 97 বাইট)

{n,v->Eval.me("[${n.replaceAll(" TO ","..").replaceAll(" AND ",",")}]").flatten().collect{v[it]}}

এটি এখানে চেষ্টা করুন: https://groovyconsole.appspot.com/edit/5155820207603712

ব্যাখ্যা:

• .replaceAll(" TO ","..") - এটিকে একটি traditionalতিহ্যগত ব্যাপ্তির সাথে প্রতিস্থাপন করুন।
• .replaceAll(" AND ", ",") - কমা দিয়ে সমস্ত অ্যান্ডস প্রতিস্থাপন করুন।
• "[${...}]" - গ্রোভির "তালিকা" স্বরলিপি দিয়ে এটিকে ঘিরে।
• Eval.me(...) - গ্রোভি কোড হিসাবে স্ট্রিং মূল্যায়ন করুন।
• .flatten() - 2D অ্যারে এবং 1 ডি অ্যারের মিশ্রণটিকে 1D অ্যারে সমতল করুন।
• .collect{v[it]} - অ্যারে থেকে সূচকগুলি একক কাঠামোর মধ্যে সংগ্রহ করুন।

আউটপুট থেকে নালগুলি সরানোর জন্য এখানে একটি 115 113 বাইট সমাধান রয়েছে: https://groovyconsole.appspot.com/edit/5185924841340928

এখানে 117 বাইট সমাধান রয়েছে যদি আপনি এটি 0 এর পরিবর্তে 1 এ সূচী করা দরকার: https://groovyconsole.appspot.com/edit/5205468955803648

আপনি যদি 113/117 বাইট একের জন্য আমার আসলটি সরিয়ে নিতে চান তবে আমাকে জানান।

Comments

আপনি যদি সেখানে না থাকা অক্ষরগুলির জন্য আমাকে "নালস" ব্যবহার করতে পছন্দ না করেন তবে শেষে "5-বাইট" -নুল ", যা সেট থেকে সমস্ত নাল সরিয়ে দেয়।

— ম্যাজিক অক্টোপাস আরন

আমি এই চতুর কাকতালীয়তাটি পছন্দ করি

— ডাউনরেপ_নেশন

যদিও আমি এর থেকে কিছু শিখেছি, গ্রোভির এখন Eval.me(...)অবধি কখনই জানা ছিল না; বাস্তবে এটি ব্যবহার করা হাস্যকরভাবে সুরক্ষিত হবে, এটি এখনও একটি দুর্দান্ত জিনিস cool

— ম্যাজিক অক্টোপাস উর্ন

Answer 3

সি #, 342 বাইট

a=>r=>{var s=r.Replace(" AND","").Replace(" TO ","|").Split();int b=a.Length,i=0,n,m,j,o;var c=new List<char>();for(;i<s.Length;){var d=s[i++].Split('|');if(d.Length<2)c.Add(b<(n=int.Parse(d[0]))||n<1?' ':a[n-1]);else{o=(m=int.Parse(d[0]))<(n=int.Parse(d[1]))?1:-1;for(j=m;o>0?j<=n:j>=n;j+=o)c.Add(b<j||j<1?' ':a[j-1]);}}return c.ToArray();};

অবহেলিত পদ্ধতি:

static char[] f(char[] a, string r)
{
    var s=r.Replace(" AND","").Replace(" TO ","|").Split();
    int b=a.Length,i=0,n,m,j,o;
    var c=new List<char>();
    for(;i<s.Length;)
    {
        var d=s[i++].Split('|');
        if(d.Length<2)
            c.Add(b<(n=int.Parse(d[0]))||n<1?' ':a[n-1]);
        else
        {
            o=(m=int.Parse(d[0]))<(n=int.Parse(d[1]))?1:-1;
            for(j=m;o>0?j<=n:j>=n;j+=o)
                c.Add(b<j||j<1?' ':a[j-1]);
        }
    }

    return c.ToArray();
}

পরীক্ষার কেস সহ সম্পূর্ণ প্রোগ্রাম:

using System;
using System.Collections.Generic;

namespace InterpretLooseRanges
{
    class Program
    {
        static void PrintCharArray(char[] a)
        {
            for (int i=0; i<a.Length; i++)
                Console.Write(a[i]);
            Console.WriteLine();
        }

        static void Main(string[] args)
        {
            Func<char[],Func<string,char[]>>f= a=>r=>{var s=r.Replace(" AND","").Replace(" TO ","|").Split();int b=a.Length,i=0,n,m,j,o;var c=new List<char>();for(;i<s.Length;){var d=s[i++].Split('|');if(d.Length<2)c.Add(b<(n=int.Parse(d[0]))||n<1?' ':a[n-1]);else{o=(m=int.Parse(d[0]))<(n=int.Parse(d[1]))?1:-1;for(j=m;o>0?j<=n:j>=n;j+=o)c.Add(b<j||j<1?' ':a[j-1]);}}return c.ToArray();};

            char[] ar = {'H','e','l','l','o',' ','W','o','r','l','d'};

            PrintCharArray(f(ar)("1 TO 3"));
            PrintCharArray(f(ar)("5"));
            PrintCharArray(f(ar)("-10 TO 10"));
            PrintCharArray(f(ar)("0 AND 2 AND 4"));
            PrintCharArray(f(ar)("8 TO 3"));
            PrintCharArray(f(ar)("-300 AND 300"));
        }
    }
}

একটি নিখুঁত সমাধান, একটি চর তালিকা ব্যবহার করে যা ' 'খালি চরিত্র হিসাবে ব্যবহার করে এবং কাজটি সম্পন্ন করে। শীঘ্রই উন্নতি আশা করি।

Answer 4

স্কালা, 165 বাইট

(s:String,r:String)=>r split "AND"map(_ split "TO"map(_.trim.toInt))flatMap{case Array(a,b)=>if(a<b)a to b else a to(b,-1)
case x=>x}map(i=>s lift(i-1)getOrElse "")

ব্যাখ্যা:

(s:String,r:String)=> //define a function
r split "AND"         //split the range expression at every occurance of "AND"
map(                  //map each part...
  _ split "TO"          //split at to
  map(                  //for each of these splitted parts, map them to...
    _.trim.toInt          //trim all whitespace and parse as an int
  )                    
)                     //now we have an Array[Array[Int]]
flatMap{              //map each inner Array...
  case Array(a,b)=>if(a<b)a to b else a to(b,-1) //if it has two elements, create a Range
  case x=>x             //otherwise just return it
}                     //and flatten, so we get an Array[Int]
map(i=>               //for each int
  s lift(i-1)         //try to get the char with index i-1, since Scala is zero-based
  getOrElse ""        //otherwise return ""
) 

Answer 5

পাইথন 2, 156 155 বাইট

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

s,r=input()
o=""
for x in r.split("AND"):
    i=map(int,x.split("TO"));d=2*(i[0]<i[-1])-1
    for _ in-1,0:i[_]-=11**9*(i[_]<0)
    o+=s[i[0]-1:i[-1]+d-1:d]
print o

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

ভাগ্যক্রমে, আমি পূর্ণসংখ্যার মধ্যে ফাঁকযুক্ত স্ট্রিংগুলি পার্স করতে পারি। স্ট্রিংয়ের শেষ থেকে পাইথন সূচকে নেতিবাচক সূচক, সুতরাং আমি যদি i[-1]হয় তবে তা হয় হিসাবে একই i[0]বা দ্বিতীয় মান হিসাবে ব্যবহার করতে পারি । তারপরে আমাকে যে কোনও নেতিবাচক সীমার মানগুলিকে আরও negativeণাত্মক সাথে সামঞ্জস্য করতে হবে , সুতরাং তারা কাটা কাটাতে গোলযোগ করবে না। 11**9( 2357947691) দ্বারা নেতিবাচক মানগুলিকে গুণিত করা পূর্ণসংখ্যার ন্যূনতম মান ব্যবহার করে রেঞ্জগুলির জন্য অ্যাকাউন্ট করবে। তারপরে, রেঞ্জটি বিপরীত হলে কেবল বিপরীত স্লাইস ব্যবহার করে স্ট্রিংটি স্লাইস করুন।

শূন্য-সূচক (151 বাইট) সহ:

s,r=input()
o=""
for x in r.split("AND"):
    i=map(int,x.split("TO"));d=2*(i[0]<i[-1])-1
    for _ in-1,0:i[_]-=11**9*(i[_]<0)
    o+=s[i[0]:i[-1]+d:d]
print o

Comments

সাবাশ! কাটা স্পষ্টভাবে এখানে যাওয়ার উপায়। আমার rangeপদ্ধতির মূলত ঠিক এটির একটি সুপার ভারবোজ ফর্ম। এমনকি আপনি পুরো if"T"in x: else:অংশটি থেকে মুক্তি পেয়েছেন । +1

— দারকো

Answer 6

আর, 142 বাইট

ধরে নিচ্ছি আমি চ্যালেঞ্জটি সঠিকভাবে বুঝতে পেরেছি, আমি এখানে ধরে নিচ্ছি যে rএটি স্ট্রিং ফর্ম্যাটে পূর্ব-সংজ্ঞায়িত ব্যাপ্তি ধারা, এবং ইনপুট অ্যারে ("হ্যালো ওয়ার্ল্ড", উদাহরণগুলিতে) স্টিডিন থেকে পড়েছে।

r=eval(parse(t=paste("c(",gsub("AND",",",gsub("TO",":",r)),")")))
o=strsplit(readline(),e<-"")[[1]][r[r>0]]
o[is.na(o)]=e
c(rep(e,sum(r<1)),o)

কিছু পরীক্ষার কেস:

r="1 TO 3"
[1] "H" "e" "l"

r="5"
[1] "o"

r="-10 TO 10"
[1] ""  ""  ""  ""  ""  ""  ""  ""  ""  ""  ""  "H" "e" "l" "l" "o" " " "w" "o" "r" "l"

r="0 AND 2 AND 4"
[1] ""  "e" "l"

r="8 TO 3"
[1] "o" "w" " " "o" "l" "l"

r="-300 AND 300"
[1] "" ""

Ungolfed / ব্যাখ্যা

লাইন 1

r=eval(parse(t=paste("c(",gsub("AND",",",gsub("TO",":",r)),")")))

আর এর একটি দুর্দান্ত ইনফিক্স অপারেটর রয়েছে :যা সিকোয়েন্স তৈরি করে। 1:5দেয় [1, 2, 3, 4, 5], 0:-2দেয় [0, -1, -2]। সুতরাং, আমরা এর TOসাথে আলগা পরিসীমা ধারাটি প্রতিস্থাপন করব :।

                                         gsub("TO",":",r)

ব্যাখ্যা ANDকরা কেবল কনটেক্সটেশন। আমরা তার জন্য ফাংশনটি cব্যবহার করতে পারি, যা স্বতঃস্ফূর্তভাবে কমা দ্বারা পৃথক পৃথক সংখ্যক আর্গুমেন্ট নিতে সক্ষম হয়। সুতরাং আমরা ANDসঙ্গে প্রতিস্থাপন,

                          gsub("AND",",",      ...       )

এবং তারপর পুরো জিনিস মোড়ানো c(, )।

               paste("c(",              ...               ,")")

এটি এমন চরিত্রের স্ট্রিং দেয় যা দেখতে দেখতে পারে c( 1 : 5 , 7 )। আমরা parse"এক্সপ্রেশন" টাইপ রূপান্তর করতে এবং তারপরে evalঅভিব্যক্তিটি মূল্যায়ন করতে কল করি। এর পরে সংখ্যার ফলস্বরূপ ক্রমটি ভেরিয়েবলটিতে পুনরায় বরাদ্দ করা হয় r।

r=eval(parse(t=                     ...                        ))

লাইন 2

o=strsplit(readline(),e<-"")[[1]][r[r>0]]

কুরুচিপূর্ণ অংশের জন্য - আর তে স্ট্রিংগুলি নিয়ে কাজ করা, যা দ্রুত অগোছালো হয়ে যায়। প্রথমে আমরা eএকটি খালি স্ট্রিং হতে সংজ্ঞায়িত করি (আমাদের এটি পরে প্রয়োজন হবে)।

                      e<-""

আমরা স্টিডিন থেকে পড়েছি এবং খালি স্ট্রিনে বিভক্ত হয়ে অক্ষরটির স্ট্রিংটিকে পৃথক অক্ষরের অ্যারে রূপান্তর করি। দৈর্ঘ্য 1 একটি তালিকা দেখুন (যেমন আমরা "হাই" থেকে যান [ "এইচ", "আমি"]।) এই আয়, তাই আমরা প্রথম উপাদান জন্য জিজ্ঞাসা করতে হবে [[1]]একটি অ্যারের যে আমরা সাথে কাজ করতে পারেন জন্য। ওহ, আমি আপনাকে সতর্ক করে দিয়েছিলাম যে এটা অগোছালো।

  strsplit(readline(), ... )[[1]]

আর সূচকগুলি 1 থেকে শুরু হয় এবং নেতিবাচক সংখ্যার সাথে একটি দুর্দান্ত বৈশিষ্ট্য রয়েছে। ধরুন xহয় ['a', 'b', 'c']। কলিং x[1]unsurprisingly আয় 'a'। কল করা হচ্ছে x[-1]সব আয় x ব্যতীত সূচক 1, অর্থাত্ ['b', 'c']। এটি একটি দুর্দান্ত বৈশিষ্ট্য, তবে এর মানে হল যে এই সমস্যাটির জন্য আমাদের আমাদের নেতিবাচক সূচকে সতর্ক থাকতে হবে। সুতরাং আপাতত, আমরা কেবল ইনডেক্স অ্যারের উপাদানগুলি সূচক সহ ফিরিয়ে >0দেব এবং ফলাফলটি নির্ধারিত করি o।

o=               ...             [r[r>0]]

লাইন 3

তবে সমস্যা আছে! সূচকের দৈর্ঘ্যের চেয়ে বড় সূচকগুলির জন্য, কেবলমাত্র NAমানগুলি দেয়। খালি স্ট্রিং ফিরিয়ে আনতে আমাদের এটি দরকার। সুতরাং আমরা সেই উপাদানগুলির নতুন সংজ্ঞা দিই oযার is.na(o)জন্য TRUEখালি স্ট্রিং হওয়া উচিত।

o[is.na(o)]=e

লাইন 4

c(rep(e,sum(r<1)),o)

অবশেষে, আমরা কীভাবে নেতিবাচক (এবং শূন্য) সূচকগুলি ব্যবহার করব? তাদের সকলকে খালি স্ট্রিং ফিরিয়ে দেওয়া দরকার, তাই আমরা খালি স্ট্রিংটি N বারটি পুনরাবৃত্তি করি, যেখানে N হল সূচকগুলির সংখ্যা <1।

  rep(e,sum(r<1))

অবশেষে, আমরা oএই (সম্ভাব্য খালি) তালিকার পূর্ব নির্ধারিত সংশ্লেষ করি ।

c(      ...      ,o)

Answer 7

জাভাস্ক্রিপ্ট (ES6), 141

২ টি প্যারামিটার সহ অজানা ফাংশন, প্রথমটি হ'ল অক্ষর অ্যারে (কোনও স্ট্রিং হতে পারে), দ্বিতীয় স্ট্রিংটির ব্যাপ্তি সংজ্ঞা রয়েছে।

রিটার্ন মান হ'ল একটি অ্যারে যেখানে প্রতিটি উপাদান হয় একক অক্ষর বা জেএস মান হতে পারে undefined। যখন সংক্ষিপ্তকরণ করা হয়, ফলস্বরূপ প্রশ্নের প্রথম সংস্করণে পরীক্ষার কেস হিসাবে "খালি" চর হিসাবে অপরিজ্ঞিত দেখানো কমা দ্বারা পৃথকীকৃত অক্ষরগুলির ক্রমগুলির ফলস্বরূপ। আপনি
ব্যবহার .joinকরে প্রশ্নের বর্তমান সংস্করণে টেস্ট কেস আউটপুটের মতো স্ট্রিং ফলাফল পেতে পারেন।

(l,r,u,z=[])=>(r+' E').replace(/\S+/g,x=>x>'T'?u=t:x>'A'?[...Array((t-(w=(u=u||t)-(d=+u<t?1:-1)-1)-1)*d)].map(_=>z.push(l[w+=d]),u=0):t=x)&&z

কম গল্ফড

(
 l, r, // input paramaters, array/string and string
 u,    // local variable start at 'undefined'
 z=[]  // local variable, will contain the ouput
) => 
  (r+' E') // add an end marker
  .replace( /\S+/g, x=> // execute for each nonspace substring
    x > 'T' // check if 'TO'
    ? u = t // if 'TO' save first value in u (it's a string so even 0 is a truthy value)
    : x > 'A' // check if 'AND' or 'E'
      ? (
          u = u||t, // if u is falsy, it's a single value range t -> t
          d = +u < t ? 1 :-1, // direction of range up or down,comparison has to be numeric, so the leading +
          w = u - d - 1, // starting value (decrement by 1 as js array are 0 based)
          u = 0, // set u to falsy again for next round
          [...Array((t - w - 1) * d)] // build the array of required number of elements
          .map(_ => z.push(l[w+=d])) // iterate adding elements of l to z
        )
      : t = x // if not a keyword, save value in t
  ) && z // return output in z

পরীক্ষা

f=
(l,r,u,z=[])=>(r+' E').replace(/\S+/g,x=>x>'T'?u=t:x>'A'?[...Array((t-(w=(u=u||t)-(d=+u<t?1:-1)-1)-1)*d)].map(_=>z.push(l[w+=d]),u=0):t=x)&&z

function run(x)
{
  R.value=x;
  O.textContent=f(L.value,x)
}

run("10 TO 5 AND 5 TO 10")

<table>
<tr><td>Base string</td><td><input id=L value="Hello World"></td></tr>
<tr><td>Custom range</td><td><input id=R ><button onclick='run(R.value)'>-></button></td></tr>
<tr><td>Output</td><td><pre id=O></pre></td></tr>
<tr><td>Test case ranges</td><td>
<select id=T onchange='run(this.value)'>
<option/>  
<option value="1 TO 3">1 TO 3 =&gt; {'H','e','l'}</option>
<option value="5">5 =&gt; {'o'}</option>
<option value="-10 TO 10">-10 TO 10 =&gt; {'','','','','','','','','','','','H','e','l','l','o',' ','W','o','r','l'}</option>
<option value="0 AND 2 AND 4">0 AND 2 AND 4 =&gt; {'','e','l'}
"8 TO 3" => {'o','W',' ','o','l','l'}</option>
<option value="-300 AND 300">-300 AND 300 =&gt; {'',''}</option>
<option value="1 TO 3 AND 3 TO 1">1 TO 3 AND 3 TO 1 =&gt; "HelleH"</option>
<option value="-20 TO 0 AND 1 AND 4">-20 TO 0 AND 1 AND 4 =&gt; "Hl"</option>
</select>
</td></tr>
</table>

Answer 8

পার্ল - 110 বাইট

প্রথম আর্গুমেন্ট হিসাবে স্ট্রিং সহ কমান্ড লাইনে স্ক্রিপ্ট কল করা এবং দ্বিতীয় হিসাবে পরিসীমা।

for(split AND,pop@ARGV){$_>0?print+(split//,"@ARGV")[$_-1]:0for(/(.+)TO(.+)/?($1>$2?reverse$2..$1:$1..$2):$_)}

অপ্রচলিত:

for $subrange (split 'AND', $ARGV[1]) {
    for $index ($subrange =~ /(.+)TO(.+)/
        ? ($1 > $2 ? reverse $2..$1 : $1..$2) # All indices of that range
        : $subrange) # Otherwise, an index only
    {
        if ($index > 0) {
            # Here, 'split' returns an array of all characters
            print((split //, $ARGV[0])[$index - 1]);
        }
    }
}

Answer 9

পাইথন 2, 146 বাইট

lambda s,a:[a[i]for x in[map(int,c.split('TO'))for c in s.split('AND')]for i in range(x[0]-1,x[-1]-2*(x[-1]<x[0]),1-2*(x[-1]<x[0]))if 0<=i<len(a)]

সমস্ত পরীক্ষার এ ideone

s"এবং" এ, ধারাটি বিভক্ত করে, ফলাফলের প্রতিটি সাব- ক্লজকে "টু" -তে বিভক্ত করে, ফলাফলটি intব্যবহার করে স্ট্রিংগুলিকে রূপান্তরিত করে map। ফলাফলগুলির প্রত্যেকটিতে 1 বা 2 টি আইটেম থাকবে (1 টি যদি "সাব-ক্লজটিতে উপস্থিত না থাকে)"।
সূচক 0 এবং -1 এর মানগুলি পরীক্ষা করে 1 বা -1 হিসাবে রেঞ্জের স্টেপ প্যারামিটার ব্যবহার করে এগুলির জন্য 0-ভিত্তিক রেঞ্জগুলি তৈরি করে (এক এন্ট্রি সহ একটি তালিকাতে উভয় সূচকে এন্ট্রি থাকে)।
প্রদত্ত সূচকগুলি ইন-রেঞ্জ ( if 0<=i<len(a)) হলে এই ব্যাপ্তিগুলি চালায় এবং আউটপুটের একটি তালিকা তৈরি করে ।

Answer 10

জেলি , 28 27 25 বাইট

œṣ⁾TOj”rV
œṣ“Ñþ»Ç€Ff⁹J¤ị⁹

ট্রাইআইটঅনলাইন (চরের অ্যারের পরিবর্তে স্ট্রিং দিয়েও কাজ করবে)

কিভাবে?

œṣ⁾TOj”rV - Link 1, construct sub-range: subclause
  ⁾TO     - string "TO"
œṣ        - split on sublists
     j    - join with
      ”r  - character "r"
        V - evaluate as Jelly code
                (r is the Jelly dyad for inclusive range, which works just like TO
                 when no r is present the string evaluates to the number:
                 " -20 "       evaluates to -20;
                 " -20 r -19 " evaluates to [-20,-19];
                 " 3 r -3 "    evaluates to [3,2,1,0,-1,-2,-3]; etc.)

œṣ“Ñþ»Ç€Ff⁹J¤ị⁹ - Main link: range clause, array 
  “Ñþ»          - compression of the string "AND"
œṣ              - split on sublists
      ǀ        - call the last link (1) as a monad for each
        F       - flatten list
            ¤   - nilad and link(s) as a nilad
          ⁹     - right argument (the array)
           J    - range for length [1,2,...,len(array)]
         f      - filter keep
                      (Jelly indexing is modular so keep only in-bound indexes)
             ị⁹ - index into the array

Answer 11

ক্লোজার 232 230 229 বাইট

ওহ আমি কী দানব তৈরি করেছি ... তবে আমি যখন এটি জমা দিতে যাচ্ছিলাম তখন এটি 260 ছিল।

সম্পাদনা: এর থেকে একটি স্থান সরিয়ে নিয়েছে #(get r %_""), (if_(< f t)এবং (take-nth 2_%)(হিসাবে নির্দেশিত _)।

(let[S clojure.string/split](fn[r s](apply str(map #(get r %"")(mapcat #(apply(fn([f][(dec f)])([f t](if(< f t)(range(dec f)t)(reverse(range(dec t)f)))))%)(map #(mapv read-string(take-nth 2%))(map #(S % #" ")(S s #" AND "))))))))

কম গল্ফড:

(def f (let[S clojure.string/split]
         (fn[r s] (->> (map #(S % #" ") (S s #" AND "))
                       (map #(mapv read-string (take-nth 2 %)))
                       (mapcat #(apply(fn
                                        ([f][(dec f)])
                                        ([f t](if (< f t)
                                                (range (dec f) t)
                                                (reverse (range (dec t) f)))))  %))
                       (map #(get r % ""))
                       (apply str)))))

ব্যবহার clojure.string/splitদ্বারা "এবং" এবং "বিভাজিত করা", take-nthথেকে "ড্রপ" পূর্ণসংখ্যার মধ্যে, ফাংশন যুক্তি ম্যাচিং হ্যান্ডলগুলি 1 বা 2 আর্গুমেন্ট কেস এবং যে এটি সম্পর্কে।

আহ্বান সম্মেলন: (f "Hello World" "1 TO 3 AND 2 AND 8 TO 2")

Comments

আপনি সাধারণভাবে স্পেসগুলি সরিয়ে বিশেষ করে #চরগুলির মধ্যে প্রচুর বাইটের একটি হ্যাক সরিয়ে ফেলতে পারেন ।

— ক্লিমেজিক

আপনি কি নিশ্চিত যে আমি যে কোনও একটির মধ্যে একটি স্থান সরিয়ে ফেলতে পারি #? আমি এটি সাফল্য ছাড়াই চেষ্টা করেছি, এটি আগের টোকেনের সাথে "একীভূত" হয়ে যায়। ওহ, %সেখানে আরও একটি জায়গা সরিয়ে ফেলতে হবে।

— নিকোনিহার