느슨한 범위 해석

ListSharp 는 많은 기능을 가진 해석 된 프로그래밍 언어입니다. 이러한 기능 중 하나는 다음과 같은 1 인덱스 기반 범위 작성자입니다.

범위를 정의 (INT) TO (INT)하거나 (INT)둘 다 또는 단일 int가 min에서 max 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 인덱스 기반 위치에있는 요소 (기존 / 음수가 아닌 인덱스는 빈 문자로 변환 됨)

이기는 방법

A와 코드 골프 도전 당신은 이길 짧은 바이트 수와 프로그램을 만들 가정된다

그것은 빈 문자가 존재하지 않는다고 지적 했으므로 무시해야합니다 (여전히 사람들을 이해하기 쉽게하기 위해 여기에 표시했습니다)

테스트 사례 :

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"

파이썬 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시간을 의미 합니다.

Ungolfed 코드 :

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']
['', '']

그루비 ( 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 ", ",") -모든 ands를 쉼표로 바꾸십시오.
• "[${...}]" -Groovy의 "목록"표기법으로 둘러 쌉니다.
• Eval.me(...) -문자열을 Groovy 코드로 평가하십시오.
• .flatten() -2D 배열과 1D 배열의 혼합물을 1D 배열로 평평하게합니다.
• .collect{v[it]} -배열의 인덱스를 단일 구조로 수집하십시오.

여기에서의 (115) 의 출력으로부터 제거 널 113 바이트 용액 : https://groovyconsole.appspot.com/edit/5185924841340928

117 바이트 솔루션은 0 대신 1로 색인해야한다고 말하면 다음과 같습니다. https://groovyconsole.appspot.com/edit/5205468955803648

113/117 바이트의 원본을 바꾸려면 알려주세요.

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

ungolfed 방법 :

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

' '빈 문자로 사용 하고 작업을 수행 하는 char 목록을 사용하는 순진한 솔루션 . 곧 개선되기를 바라고 있습니다.

스칼라, 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 ""
) 

파이썬 2, 156155 바이트

내 대답은 1Darco1의 대답 과 비슷한 아이디어를 가지고 있지만 시작과 다른 접근 방식 (목록이 아닌 문자열 슬라이싱)을 사용하면 꽤 짧아졌습니다. 0 인덱싱이 허용되면 4 바이트 더 짧아집니다.

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

R, 142 바이트

내가 도전을 올바르게 이해했다고 가정하면, 여기서는 r문자열 형식의 사전 정의 된 범위 절이고 입력 배열 (예에서 "Hello world")을 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)

일부 테스트 사례 :

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

언 골프 / 설명

1 호선

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

R에는 :시퀀스를 생성 하는 멋진 연산자 가 있습니다. 1:5제공 [1, 2, 3, 4, 5]하고 0:-2제공합니다 [0, -1, -2]. 따라서 TO느슨한 범위 의 in 절을로 바꿉니다 :.

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

추악한 부분을 위해-R에서 문자열을 다루면 빨리 지저분 해집니다. 먼저 e빈 문자열로 정의 합니다 (나중에 필요함).

                      e<-""

stdin에서 읽고 빈 문자열을 분할하여 문자열을 개별 문자 배열로 변환합니다. (예 : "Hi"에서 [ "H", "i"]로 이동) 길이 1의 목록을 반환하므로 [[1]]작업 할 수있는 배열을 가져 오려면 첫 번째 요소 를 요청해야합니다 . 어이, 나는 이것이 지저분한 것이라고 경고했다.

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

R 인덱스는 1부터 시작하며 음수로 멋진 기능을 갖습니다. 가정하자가 x있다 ['a', 'b', 'c']. x[1]의외로 전화하면을 반환합니다 'a'. 호출 x[-1]모두의 반환 x 을 제외 지수 1즉, ['b', 'c']. 이것은 멋진 기능이지만이 문제에 대한 부정적인 지수에주의해야합니다. 지금은 입력 배열의 요소를 index로 반환 >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)

마지막으로, 음수 (및 0) 지수를 어떻게 처리합니까? 모두 빈 문자열을 반환해야하므로 빈 문자열을 N 번 반복하십시오. 여기서 N은 인 인덱스 수입니다 <1.

  rep(e,sum(r<1))

마지막으로, 우리는 이전에 정의 된 o이 (잠재적으로 비어있는) 목록에 연결합니다.

c(      ...      ,o)

자바 스크립트 (ES6), 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>

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

파이썬 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"AND" 에서 절을 분할하고 "TO"에서 각각의 결과 하위 절을 분할하고 결과 문자열을 intusing으로 변환합니다 map. 결과는 각각 1 개 또는 2 개의 항목을 갖습니다 (하위 조항에 "TO"가없는 경우 1).
인덱스 0 및 -1의 값을 검사하여 범위의 단계 매개 변수를 1 또는 -1로 사용하여 이들 각각에 대해 0 기반 범위를 구성합니다 (한 항목이있는 목록은 두 인덱스에 해당 항목이 있음).
제공된 인덱스가 범위 내에있는 경우 이러한 범위를 실행하고 출력 목록을 구성합니다 ( if 0<=i<len(a)).

젤리 , 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

Clojure의 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정수 사이를 "삭제"기능 인자 매칭 처리 1 개 또는 2의 경우 인자 그 그것에 관한 것이다.

전화 컨벤션 : (f "Hello World" "1 TO 3 AND 2 AND 8 TO 2")