ढीली श्रेणियों की व्याख्या करें

Question

ढीली श्रेणियों की व्याख्या करें

ListSharp एक व्याख्या की गई प्रोग्रामिंग भाषा है जिसमें कई विशेषताएं हैं, उन विशेषताओं में से एक 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'}?

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

ASCII तालिका में एक खाली वर्ण (गैर-मुद्रण योग्य लोगों को छोड़कर) नहीं है। अंतरिक्ष का उपयोग करने में क्या गलत है?

— एड्रिंपैंप

एक चार सरणी मूल रूप से एक तार है, खाली

— छतों के लिए

इसके अलावा, उदाहरण के लिए 3 TO 3कभी इनपुट होगा और अपेक्षित आउटपुट क्या होगा?

— जॉर्डन

आपको ANDआईएनजी गुणकों के लिए कुछ परीक्षण मामलों की आवश्यकता होती है। इसके अलावा, आपने जवाब नहीं दिया कि क्या हम शून्य-आधारित अनुक्रमण का उपयोग कर सकते हैं, जो अधिकांश भाषाओं में मानक है।

— mbomb007

Answer 1

पायथन 2 - 239 211 210 बाइट्स

इस समाधान को आगे बढ़ाने के लिए @ mbomb007 और @Cyoce को धन्यवाद !

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

शानदार पहला जवाब! PPCG में आपका स्वागत है!

— mbomb007

पायथन में गोल्फ के लिए टिप्स देखने से आपको लाभ हो सकता है । आप एक टैब के साथ डबल-इंडेंटेशन के लिए 2 स्थान बदल सकते हैं। आप कोड ifको उसी पंक्ति पर रख सकते हैं और उन्हें अर्धविराम से अलग कर सकते हैं। और अंदर जगह हटा दें [x] for। इसके अलावा, या 1if b else-1तो एक बाइट के साथ बदला जा सकता है । b and 1or-12*bool(b)-1

— mbomb007

धन्यवाद! मैंने पहले ही देखा और (उनमें से कुछ) का उपयोग करने की कोशिश की। बाद में फिर से सभी उत्तरों के माध्यम से एक और नज़र होगी। :)

— डेको १

और मुझे लगता है कि आप एक अनाम का उपयोग कर सकते हैं 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 ","..") - एक पारंपरिक रेंज के साथ बदलें।
• .replaceAll(" AND ", ",") - सभी को बदलें और अल्पविराम से।
• "[${...}]" - ग्रूवी में "सूची" संकेतन के साथ इसे घेरें।
• Eval.me(...) - Groovy कोड के रूप में स्ट्रिंग का मूल्यांकन करें।
• .flatten() - 2 डी सरणी और 1D सरणी के मिश्रण को 1D सरणी में समतल करें।
• .collect{v[it]} - सरणी से एकल संरचना में सूचकांकों को इकट्ठा करें।

यहाँ उत्पादन से नल को हटाने वाला 115 113 बाइट समाधान है: https://groovyconsole.appspot.com/edit/518592484841340928

यहाँ एक 117 बाइट समाधान है अगर आप कहते हैं कि इसे 0 के बजाय 1 पर अनुक्रमित किया जाना चाहिए: https://groovyconsole.appspot.com/edit/5205468955803648

यदि आप चाहते हैं कि मैं 113/117 बाइट के लिए मूल स्वैप करूं, तो मुझे बताएं।

Comments

यदि आप मुझे ऐसे पात्रों के लिए "नल" का उपयोग करना पसंद नहीं करते हैं, जो "-नुल" के लिए अंत में +5 बाइट्स नहीं हैं, जो सेट से सभी नल को हटा देता है।

— मैजिक ऑक्टोपस Urn

मैं इस चतुर संयोग से प्यार करता हूँ

— downrep_nation

मैंने हालांकि इससे कुछ सीखा, कभी नहीं पता था कि ग्रूवी Eval.me(...)अब तक था ; व्यवहार में इसका उपयोग करना हास्यास्पद रूप से असुरक्षित होगा, फिर भी जानने के लिए एक अच्छी बात है।

— मैजिक ऑक्टोपस उर्फ़

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 बाइट्स

मेरे उत्तर में 1Darco1 के उत्तर के समान कुछ विचार हैं , लेकिन प्रारंभ से एक अलग दृष्टिकोण (सूचियों के बजाय स्ट्रिंग स्लाइसिंग) का उपयोग करके, यह काफी कम समाप्त हो गया। 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]या दूसरे मान के समान उपयोग करता हूं , यदि कोई है। फिर मुझे किसी भी नकारात्मक रेंज मान को अधिक नकारात्मक पर समायोजित करना होगा, इसलिए वे स्लाइसिंग के साथ गड़बड़ नहीं करेंगे। 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

— 1Darco1 8

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)),")")))

R का एक अच्छा infix ऑपरेटर है :जो दृश्यों को उत्पन्न करता है। 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]रूप से रिटर्न कॉलिंग 'a'। कॉलिंग x[-1]सभी के रिटर्न x छोड़कर सूचकांक 1, यानी ['b', 'c']। यह एक अच्छा फीचर है, लेकिन इसका मतलब है कि हमें इस समस्या के लिए अपने नकारात्मक सूचकांकों से सावधान रहना होगा। तो अभी के लिए, हम केवल इनपुट सरणी के तत्वों को इंडेक्स के साथ लौटाते हैं >0, और परिणाम को असाइन करते हैं o।

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

पंक्ति 3

हालाँकि, वहाँ एक समस्या है! सरणी की लंबाई से अधिक होने वाले सूचकांकों के लिए, R केवल NAमान लौटाता है। हमें इसे खाली तारों को वापस करने की आवश्यकता है। इसलिए हम के तत्वों को फिर से परिभाषित oजिसके लिए is.na(o)है TRUEखाली स्ट्रिंग के लिए।

o[is.na(o)]=e

पंक्ति 4

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

अंत में, हम नकारात्मक (और शून्य) सूचकांकों से कैसे निपटते हैं? उन्हें सभी को खाली स्ट्रिंग वापस करने की आवश्यकता है, इसलिए हम खाली स्ट्रिंग एन बार दोहराते हैं, जहां एन सूचकांकों की संख्या है <1।

  rep(e,sum(r<1))

अंत में, हम पहले से परिभाषित oइस (संभावित रूप से खाली) सूची को संक्षिप्त करते हैं ।

c(      ...      ,o)

Answer 7

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

2 मापदंडों के साथ कार्य करते हैं, पहला चरित्र सरणी (या तो एक स्ट्रिंग हो सकता है), दूसरा स्ट्रिंग जिसमें रेंज परिभाषा है।

रिटर्न वैल्यू एक ऐसा ऐरे है, जहां प्रत्येक तत्व या तो एक एकल वर्ण या js मान हो सकता है 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)]

सभी परीक्षण आइडोन पर हैं

s"और" पर , खंड को विभाजित करता है, "TO" पर परिणामी उप-खंडों में से प्रत्येक को विभाजित करता है, जिसके परिणामस्वरूप स्ट्रिंग का intउपयोग करने के लिए परिवर्तित करता है map। परिणाम में से प्रत्येक में 1 या 2 आइटम होंगे (1 यदि कोई "TO" उप-खंड में मौजूद नहीं था)।
अनुक्रमित 0 और -1 के मानों के निरीक्षण द्वारा (या एक प्रविष्टि के साथ एक सूची जिसमें दोनों अनुक्रमों में प्रविष्टि है) प्रत्येक के लिए 0-आधारित श्रेणियों का निर्माण 1 या -1 के रूप में करता है।
इन सीमाओं के माध्यम से चलाता है और आउटपुट की एक सूची का निर्माण करता है, यदि प्रदान किए गए अनुक्रमित इन-रेंज ( if 0<=i<len(a)) हैं।

Answer 10

जेली , 28 27 25 बाइट्स

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

TryItOnline (एक सरणी के बजाय स्ट्रिंग के साथ भी काम करेगा)

कैसे?

œṣ⁾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"AND" और "" से विभाजित करने के लिए उपयोग करता है, take-nthपूर्णांक के बीच "TO" को छोड़ता है, फ़ंक्शन तर्क मिलान 1 या 2 तर्कों के मामले को संभालता है और इसके बारे में है।

सम्मेलन बुलाना: (f "Hello World" "1 TO 3 AND 2 AND 8 TO 2")

Comments

आप सामान्य रूप से रिक्त स्थान को हटाकर बहुत सारे बाइट्स की एक बिल्ली को हटा सकते हैं, विशेष रूप से #वर्णों के बीच ।

— १०

क्या आप वाकई किसी के बीच की जगह निकाल सकते हैं #? मैंने इसे सफलता के बिना आजमाया, यह पिछले टोकन के साथ "मर्ज" हो जाता है। ओह, %वहाँ से पहले हटाने के लिए एक और स्थान ।

— निकोनिराह