Interpretazione di intervalli liberi

ListSharp è un linguaggio di programmazione interpretato che ha molte funzionalità, una di queste è un creatore di intervalli basato su 1 indice che funziona in questo modo:

Definisci un intervallo come (INT) TO (INT)o solo (INT)dove entrambi o il singolo int possono andare dal valore minimo al massimo int32

Quindi puoi usare quegli intervalli per estrarre elementi di un array senza temere di oltrepassare i suoi limiti

perciò:

1 TO 5 genera: {1,2,3,4,5}

3 genera: {3}

Gli intervalli possono essere aggiunti utilizzando l' ANDoperatore

1 TO 5 AND 3 TO 6 genera: {1,2,3,4,5,3,4,5,6}

ricorda che funziona anche con numeri negativi

3 TO -3 genera: {3,2,1,0,-1,-2,-3}

La sfida è la seguente:

Ingresso

Un array di caratteri e la clausola range precedentemente definita come stringa

Produzione

Gli elementi in 1 posizioni basate sull'indice dell'intervallo (gli indici non esistenti / negativi si traducono in un carattere vuoto)

Come vincere

Come sfida al code-golf dovresti creare il programma con il numero di byte più breve per vincere

È stato sottolineato che non esistono caratteri vuoti, quindi dovresti ignorarli (li ho mostrati solo qui per renderlo più facile da capire ma confondeva le persone)

Casi test:

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 byte

Grazie a @ mbomb007 e @Cyoce per l'ulteriore golf questa soluzione!

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

Approccio diretto. Ho provato generatori e una versione ricorsiva, ma non potevano battere il semplice per ogni ciclo. Sono un golfista, quindi molto probabilmente questo può essere migliorato un po '. Inoltre, il principale difetto di questo frammento è che l'intervallo come oggetto elenco viene nuovamente calcolato ogni volta che un elemento viene recuperato dall'array di caratteri (vedere l'ultima riga, comprensione dell'elenco). Questo significa che r(s)viene eseguito i len(r(s)) + 1tempi.

Codice non golfato:

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

Casi test:

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

Produzione:

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

Groovy ( 99 97 byte)

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

Provalo qui: https://groovyconsole.appspot.com/edit/5155820207603712

Spiegazione:

• .replaceAll(" TO ","..") - Sostituisci il con un intervallo tradizionale.
• .replaceAll(" AND ", ",") - Sostituisci tutti i caratteri con una virgola.
• "[${...}]" - Circondalo con la notazione "elenco" in Groovy.
• Eval.me(...) - Valuta la stringa come codice Groovy.
• .flatten() - Appiattire la miscela di array 2D e array 1D in un array 1D.
• .collect{v[it]} - Raccogliere gli indici dall'array in un'unica struttura.

Ecco una soluzione a 115 113 byte che rimuove i null dall'output: https://groovyconsole.appspot.com/edit/5185924841340928

Ecco una soluzione a 117 byte se dici che DEVE essere indicizzata a 1 invece di 0: https://groovyconsole.appspot.com/edit/5205468955803648

Se vuoi che sostituisca l'originale con quello da 113/117 byte, fammi sapere.

C #, 342 byte

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

Metodo non golfato:

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

Programma completo con casi di test:

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

Una soluzione ingenua, usando una lista di caratteri, che usa ' 'come carattere vuoto e fa il lavoro. Spero di migliorare presto.

Scala, 165 byte

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

Spiegazione:

(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, 156 155 byte

La mia risposta ha idee simili alla risposta di 1Darco1 , ma usando un approccio diverso dall'inizio (affettare le stringhe piuttosto che le liste), è diventato un po 'più breve. Sarebbe più corto di quattro byte se fosse consentita l'indicizzazione 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

Provalo online

Fortunatamente, posso analizzare le stringhe contenenti spazi in numeri interi. Indicizzazione negativa negli indici Python dalla fine della stringa, quindi uso i[-1]sia lo stesso che i[0]il secondo valore, se ce n'è uno. Quindi devo regolare i valori dell'intervallo negativo su un valore più negativo, in modo che non interferiscano con lo slicing. Moltiplicare i valori negativi per11**9 ( 2357947691) verranno calcolati gli intervalli utilizzando il valore minimo intero. Quindi, basta tagliare la stringa, usando la sezione inversa se l'intervallo è invertito.

Con indicizzazione zero (151 byte):

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 byte

Supponendo di aver compreso correttamente la sfida, qui presumo che rsia la clausola di intervallo predefinita in formato stringa e che l'array di input ("Hello world", negli esempi) sia letto da stdin.

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)

Alcuni casi di test:

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 / spiegato

Linea 1

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

R ha un bel operatore infix :che genera sequenze. 1:5dà [1, 2, 3, 4, 5]e 0:-2dà [0, -1, -2]. Quindi, sostituiamo la TOclausola in the loose range con :.

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

L'interpretazione ANDè solo concatenazione. Possiamo usare la funzione cper questo, che è prontamente in grado di accettare un numero arbitrario di argomenti, separati da virgola. Quindi sostituiamo ANDcon,

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

e poi avvolgere il tutto in c(, ).

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

Questo produce una stringa di caratteri che potrebbe apparire come c( 1 : 5 , 7 ). Chiamiamo parseper convertire per digitare "espressione" e quindi evalper valutare l'espressione. La sequenza di numeri risultante viene quindi riassegnata alla variabile r.

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

Linea 2

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

Ora per la parte brutta - gestire le stringhe in R, che diventa rapidamente disordinato. Per prima cosa definiamo euna stringa vuota (ne avremo bisogno in seguito).

                      e<-""

Leggiamo dallo stdin e convertiamo la stringa di caratteri in una matrice di singoli caratteri dividendola nella stringa vuota. (Ad esempio andiamo da "Ciao" a ["H", "i"].) Questo restituisce un elenco di lunghezza 1, quindi dobbiamo chiedere il primo elemento [[1]]per ottenere un array con cui possiamo lavorare. Ugh, ti avevo avvertito che era un casino.

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

Gli indici R iniziano da 1 e hanno una bella caratteristica con numeri negativi. Supponiamo che lo xsia ['a', 'b', 'c']. Chiamare x[1]non sorprende restituisce 'a'. La chiamata x[-1]restituisce tutto x tranne l' indice 1, ad es ['b', 'c']. Questa è una caratteristica interessante, ma significa che dobbiamo stare attenti ai nostri indici negativi per questo problema. Quindi per ora restituiamo semplicemente gli elementi dell'array di input con index >0e assegniamo il risultato a o.

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

Linea 3

Tuttavia, c'è un problema! Per indici maggiori della lunghezza dell'array, R restituisce solo NAvalori. Ne abbiamo bisogno per restituire stringhe vuote. Quindi ridefiniamo gli elementi di ocui is.na(o)deve TRUEessere la stringa vuota.

o[is.na(o)]=e

Linea 4

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

Infine, come gestiamo gli indici negativi (e zero)? Devono tutti restituire la stringa vuota, quindi ripetiamo la stringa vuota N volte, dove N è il numero di indici che sono <1.

  rep(e,sum(r<1))

Infine, concateniamo l' oelenco precedentemente definito in questo elenco (potenzialmente vuoto).

c(      ...      ,o)

JavaScript (ES6), 141

Funzione senza nome con 2 parametri, il primo è l'array di caratteri (può essere una stringa), il secondo la stringa contenente la definizione dell'intervallo.

Il valore restituito è un array in cui ogni elemento può essere un singolo carattere o il valore js undefined. Se sottoposto a stringhe, ciò si traduce in una sequenza di caratteri separati da virgola che hanno indefinito mostrato come carattere "vuoto" - come i casi di test nella prima versione della domanda.
Utilizzando .joinè possibile ottenere un risultato stringa simile all'output del test case nella versione corrente della domanda.

(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

Meno 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

Test

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 byte

Chiamare lo script nella riga di comando con la stringa come primo argomento e l'intervallo come secondo.

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

De-offuscato:

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 byte

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

Tutti i test sono su ideone

Divide la clausola, s, ON "e", divide ciascuna delle risultanti sotto-clausole on "a", converte le stringhe risultanti da intutilizzare map. I risultati avranno ciascuno 1 o 2 elementi (1 se nella sotto-clausola non era presente "TO").
Crea intervalli basati su 0 per ognuno di questi utilizzando il parametro step dell'intervallo come 1 o -1 mediante l'ispezione dei valori agli indici 0 e -1 (un elenco con una voce ha quella voce su entrambi gli indici).
Esegue questi intervalli e crea un elenco dell'output, se gli indici forniti sono in-range ( if 0<=i<len(a)).

Gelatina , 28 27 25 byte

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

TryItOnline (funzionerà anche con una stringa anziché con una matrice di caratteri)

Come?

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

Oh, che mostro ho creato ... Ma in realtà erano 260 quando stavo per inviarlo.

Edit: rimosso uno spazio da #(get r %_""), (if_(< f t)e (take-nth 2_%)(indicato come _).

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

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

Usa clojure.string/splitper dividere per "AND" e "", take-nthelimina "TO" tra numeri interi, la corrispondenza degli argomenti delle funzioni gestisce il caso di 1 o 2 argomenti e questo è tutto.

Convenzione di chiamata: (f "Hello World" "1 TO 3 AND 2 AND 8 TO 2")