Gevşek aralıkları yorumlama

ListSharp birçok özelliğe sahip yorumlanmış bir programlama dilidir, bu özelliklerden biri şu şekilde çalışan 1 indeks tabanlı bir aralık yaratıcısıdır:

Sen gibi bir aralığı tanımlamak (INT) TO (INT)ya da sadece (INT)nerede ikisi veya tek int dakika arasındaki gidebilir max int32 değeri

Daha sonra bu aralıkları, sınırlarını aşmaktan korkmadan bir dizinin öğelerini çıkarmak için kullanabilirsiniz

dolayısıyla:

1 TO 5 oluşturur: {1,2,3,4,5}

3 oluşturur: {3}

Aralıklar ANDoperatör kullanılarak eklenebilir

1 TO 5 AND 3 TO 6 oluşturur: {1,2,3,4,5,3,4,5,6}

bunun negatif sayılarla da çalıştığını unutmayın

3 TO -3 oluşturur: {3,2,1,0,-1,-2,-3}

Zor olan şudur:

Giriş

Dize olarak bir karakter dizisi ve önceden tanımlanmış aralık yan tümcesi

Çıktı

Aralığın 1 dizin tabanlı konumundaki öğeler (mevcut olmayan / negatif dizinler boş bir karaktere çevrilir)

Nasıl kazanılır

Bir kod-golf meydan okuma olarak, kazanmak için en kısa bayt sayısı ile programı oluşturmak gerekiyor

Boş karakterlerin mevcut olmadığı belirtildi, bu yüzden onları görmezden gelmelisiniz (sadece burada daha kolay anlaşılmasını sağlamak için gösterdim, ancak insanları karıştırdı)

Test senaryoları:

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"

Python 2 - 239 211 210 bayt

Bu çözümü daha da golf oynamak için @ mbomb007 ve @Cyoce'a teşekkürler !

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)]

Basit yaklaşım. Denenmiş jeneratörler ve özyinelemeli bir sürüm, ancak her döngü için basit olanı yenemediler. Ben bir golf çaylak değilim, bu yüzden bu büyük olasılıkla biraz geliştirilebilir. Ayrıca, bu snippet'in en büyük kusuru, karakter dizisinden her öğe alındığında bir liste nesnesi olarak aralığın tekrar hesaplanmasıdır (son satıra, liste kavramasına bakın). Bu r(s), yürütme len(r(s)) + 1süreleri anlamına gelir .

Kod çözülmemiş kod:

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)]

Test senaryoları:

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

Çıktı:

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

Harika ( 99 97 Bayt)

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

Burada deneyin: https://groovyconsole.appspot.com/edit/5155820207603712

Açıklama:

• .replaceAll(" TO ","..") - yerine geleneksel bir aralık yerleştirin.
• .replaceAll(" AND ", ",") - Tüm and'ları virgülle değiştirin.
• "[${...}]" - Groovy "liste" gösterimi ile çevreleyin.
• Eval.me(...) - Dizeyi Groovy kodu olarak değerlendirin.
• .flatten() - 2D dizinin ve 1D dizisinin karışımını 1D diziye düzleştirin.
• .collect{v[it]} - Diziden endeksleri tek bir yapıda toplayın.

İşte null'ları çıktıdan kaldıran 115 113 baytlık bir çözüm: https://groovyconsole.appspot.com/edit/5185924841340928

İşte 0 yerine 1'de dizine eklenmelidir ZORUNDA 117 baytlık bir çözüm: https://groovyconsole.appspot.com/edit/5205468955803648

113/117 baytlık bir orijinali değiştirmemi istiyorsanız, bana bildirin.

C #, 342 bayt

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();};

Ungolfed yöntemi:

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();
}

Test senaryolarıyla birlikte tam program:

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"));
        }
    }
}

' 'Boş bir karakter olarak kullanılan ve işi yapan bir char listesi kullanan saf bir çözüm . Yakında iyileşmek umuduyla.

Scala, 165 bayt

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

Açıklama:

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

Python 2, 156155 bayt

Cevabım 1Darco1'in cevabı ile benzer fikirlere sahip , ancak başlangıçtan farklı bir yaklaşım kullanarak (listeler yerine dize dilimleme), biraz daha kısa oldu. 0-endekslemeye izin verilirse dört bayt daha kısa olur.

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

Çevrimiçi deneyin

Neyse ki, boşluk içeren dizeleri tamsayılara ayırabilirim. Dizenin sonundan itibaren Python dizinlerinde negatif indeksleme, bu yüzden i[-1]ya i[0]varsa ya da ikinci değerle aynı olmak için kullanılır . Daha sonra herhangi bir negatif aralık değerini daha negatif olarak ayarlamalıyım , böylece dilimlemeyle uğraşmazlar. Negatif değerlerin 11**9( 2357947691) ile çarpılması, tamsayı min değerini kullanan aralıkları dikkate alır. Ardından, aralık tersine çevrilirse ters dilim kullanarak dizeyi dilimleyin.

Sıfır indeksleme ile (151 bayt):

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

R, 142 bayt

Meydan okumayı doğru anladığımı varsayarak, burada rdize biçiminde önceden tanımlanmış aralık cümlesi olduğunu ve giriş dizisinin (örneklerde "Merhaba dünya") stdin'den okunduğunu varsayıyorum.

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)

Bazı test örnekleri:

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 / açıkladı

Satır 1

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

R, :sekans üreten güzel bir infix operatörüne sahiptir. 1:5verir [1, 2, 3, 4, 5]ve 0:-2verir [0, -1, -2]. Bu nedenle, TOgevşek aralık yan tümcesini değiştiririz :.

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

Sözlü ANDçeviri sadece birleştirme işlemidir. Bu işlevi c, virgülle ayrılmış rastgele sayıda argüman alabilen işlevi kullanabiliriz . Biz yerini Yani ANDile,

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

ve sonra her şeyi sarın c(, ).

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

Bu, benzeyebilecek bir karakter dizesi verir c( 1 : 5 , 7 ). parse"Expression" türüne dönüştürmeye ve sonra evalifadeyi değerlendirmeye çağırırız . Elde edilen sayı dizisi daha sonra değişkene yeniden atanır r.

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

Hat 2

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

Şimdi çirkin kısım için - R'deki dizelerle uğraşmak, bu da hızlı bir şekilde dağınık hale geliyor. Önce eboş bir dize olarak tanımlarız (buna daha sonra ihtiyacımız olacak).

                      e<-""

Stdin'den okuyoruz ve boş karakter dizisine bölünerek karakter dizisini tek tek karakter dizisine dönüştürüyoruz. (Örneğin, "Merhaba" dan ["H", "i"] 'ye gideriz.) Bu, uzunluk 1'in bir listesini döndürür, bu nedenle ilk öğenin [[1]]birlikte çalışabileceğimiz bir dizi almasını istememiz gerekir . Ugh, bunun dağınık olduğu konusunda uyardım.

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

R, 1'den başlar ve negatif sayılarla güzel bir özelliğe sahiptir. Varsayalım xolduğunu ['a', 'b', 'c']. Arayan x[1]Unsurprisingly döner 'a'. Çağrı , dizin hariçx[-1] tümünün döndürülmesini sağlar . Bu harika bir özellik, ancak bu sorun için negatif endekslerimize dikkat etmemiz gerektiği anlamına geliyor. Şimdilik, girdi dizisinin öğelerini dizinle döndürüyoruz ve sonucu atayacağız .x 1['b', 'c']>0o

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

Satır 3

Ancak, bir sorun var! Dizinin uzunluğundan daha büyük dizinler için, R yalnızca NAdeğerleri döndürür . Boş dizeleri döndürmek için buna ihtiyacımız var. Biz unsurlarını yeniden tanımlamak Yani ohangi is.na(o)bir TRUEboş dize olmak.

o[is.na(o)]=e

Satır 4

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

Son olarak, negatif (ve sıfır) endekslerle nasıl başa çıkacağız? Hepsinin boş dizeyi döndürmesi gerekiyor, bu yüzden boş dizeyi N kez tekrarlıyoruz, burada N olan endeks sayısıdır <1.

  rep(e,sum(r<1))

Son olarak, önceden tanımlanmış o(potansiyel olarak boş) listeyle birleştiririz.

c(      ...      ,o)

JavaScript (ES6), 141

İlki karakter dizisidir (bir dize olabilir), ikincisi aralık tanımını içeren dize olan 2 parametreli isimsiz işlev.

Dönüş değeri, her öğenin tek bir karakter veya js değeri olabileceği bir dizidir undefined. Dizge haline getirildiğinde, sorunun ilk sürümünde test durumları olarak "boş" karakter olarak gösterilen tanımlanmamış bir virgülle ayrılmış karakter dizisi oluşur.
Kullanarak .joinsorunun mevcut sürümünde test senaryosu çıktısına benzer bir dize sonucu alabilirsiniz.

(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

Daha az golf

(
 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

Ölçek

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>

Perl - 110 bayt

Komut satırında komut dizesini ilk bağımsız değişken olarak dize ve aralık ikinci olarak çağırmak.

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

Gizlenmemiş:

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]);
        }
    }
}

Python 2, 146 bayt

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)]

Tüm testler ideone'de

Fıkra, böler s, üzerinde "AND", "TO" konulu çıkan bentlerde her biri için elde edilen dizeleri dönüştürür böler intkullanarak map. Sonuçların her biri 1 veya 2 maddeye sahip olacaktır (alt fıkrada "TO" yoksa 1).
0 ve -1 dizinlerindeki değerlerin incelenmesi ile 1 veya -1 aralığında adım parametresini kullanarak bunların her biri için 0 tabanlı aralıklar oluşturur (bir girişe sahip bir liste her iki dizinde de bu girişe sahiptir).
Bu aralıklar boyunca çalışır ve sağlanan dizinler aralık ( if 0<=i<len(a)) ise, çıktının bir listesini oluşturur .

Jöle , 28 27 25 bayt

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

TryItOnline (karakter dizisi yerine dize ile de çalışır)

Nasıl?

œṣ⁾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

Clojure 232 230 229 bayt

Ne yaratık yarattım ... Ama aslında teslim etmek üzereyken bu 260'dı.

Düzenleme: bir alan kaldırılır #(get r %_""), (if_(< f t)ve (take-nth 2_%)(belirtildiği gibi _).

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

Daha az golf:

(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" ve "" ile bölmeyi kullanır , take-nthtamsayılar arasına "TO" değerini bırakır, işlev argümanı eşleşmesi 1 veya 2 bağımsız değişkeni ele alır ve bununla ilgilidir.

Çağrı kuralı: (f "Hello World" "1 TO 3 AND 2 AND 8 TO 2")