두 개의 입력, 숫자가 포함 된 비어 있지 않은 벡터 / 목록을 가지고 1와 2및 문자열을 (아니, 당신이 취할 수 없습니다 0/1대신). 문자열은 다음 중 하나입니다 (소문자로 정확히 아래에 적어 놓은대로).

increasing
decreasing
ones
twos
all
none

문자열이 ____이면 인덱스 ___을 반환해야합니다.

• increasing... 목록의 변경 사항 1을 2(매 2직후 이하 1)
• decreasing... 목록의 변경 사항 2을 1(매 1직후 이하 2)
• ones ... 인 모든 숫자 중 1
• twos ... 인 모든 숫자 중 2
• all ... 모든 자릿수
• none... 숫자가 없습니다. 0목록이 1 인덱싱되면 괜찮습니다. 목록의 색인이 0이면 음수가 좋습니다. 빈 목록이나 문자열을 출력 할 수도 있습니다.

테스트 사례 :

이들은 1 인덱스입니다. 1 인덱싱 또는 0 인덱싱을 원하는지 선택할 수 있습니다. 테스트 사례에서 서로 다른 문자열에 동일한 벡터가 사용됩니다.

--------------------------------
Vector:
1 1 2 2 2 1 2 2 1 1 2

String       - Output
increasing   - 3, 7, 11
decreasing   - 6, 9
ones         - 1, 2, 6, 9, 10 
twos         - 3, 4, 5, 7, 8, 11
all          - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
none         - 0 / []

------------------------------------
Vector:
1

String:
ones         - 1
all          - 1
decreasing / increasing / twos / none  - 0 / []

채점

이대로 코드 골프바이트 수가 가장 적은 답이 이깁니다.

설명이 권장됩니다!

자바 스크립트 (Firefox 30-57), 74 73 바이트

(a,[s],i=0,p)=>[for(e of a)if({i:e>p,d:e<p,o:e<2,t:e>1,a:1}[p=e,i++,s])i]

배열 함축는 결합의 깔끔한 방법 map과 filter한 가지있다. 편집 : @ edc65 덕분에 1 바이트가 절약되었습니다.

파이썬 (2) , 136 (131) 119 (108) 97 바이트

• 5 바이트를 절약했습니다. 사용하여 A lambda기능.
• TFeld 덕분에 12 바이트를 절약했습니다 . 골프 두 가지 조건.
• Mr. Xcoder 덕분에 11 바이트를 절약했습니다 . enumerate()대신에 사용 합니다 range(len()).
• 목록 대신 사전을 사용하고 사용하여 열한 바이트를 저장 0(같이 -indexing TFeld의 대답 )과 골프 "adinot".find(m[0])에 ord(m[0])/3-32.

lambda l,m:[j for j,k in enumerate(l)if[1,j*k<j*l[~-j],0,j*k>j*l[~-j],0,k<2,k>1][ord(m[0])/3-32]]

온라인으로 사용해보십시오!

파이썬 (2) , 117 (111) 110 99 97 92 바이트

lambda l,t:[i for i,v in enumerate(l)if[l[i+i/~i]<v,0,v<2,v>1,1,l[i+i/~i]>v][ord(t[0])/3%7]]

온라인으로 사용해보십시오!

0색인

사용하여 전환 조나단의 인덱싱 및 golfed ord(m[0])/3-32에ord(t[0])/3%7

하스켈 , 112 83 81 바이트

s%l=[i|(i,p,q)<-zip3[1..]l$l!!0:l,elem(s!!0,1<2)$zip"idota"[q<p,p<q,p<2,1<p,1<2]]

온라인으로 사용해보십시오! 사용법 예 : "increasing"%[1,1,2,1,2]. 결과는 1- 색인입니다.

Lynn의 Haskell answer에서 부분적으로 영감을 얻었습니다 .

MATL , 32 31 30 29 바이트

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

출력이 1 기반이거나 비어 있습니다.

온라인으로 사용해보십시오!

설명

이 코드는 배열 입력에 대해 가능한 6 가지 출력을 계산 한 다음 문자열 입력에 따라 적절한 출력을 선택합니다.

출력을 선택하기 위해 문자열 입력의 모든 문자의 ASCII 코드 포인트가 추가됩니다. 결과 모듈 (9)가 제공 6, 1, 5, 2, 7, 0는 각각에 대한 'increasing', 'decreasing', 'ones', 'twos', 'all', 'none'. 모든 결과 숫자가 고유하기 때문에 선택 기준으로 사용할 수 있습니다.

실제로 합계에서 모듈로 9 연산을 수행하는 대신 가능한 입력 목록이 9 개의 항목으로 확장되므로 (일부는 더미 임) 해당 목록에 대한 색인화는 자동으로 모듈로 9로 수행됩니다.

d     % Implicit input: numeric vector. Push vector of consecutive differences.
      % Contains -1, 0 or 1
Q~    % For each entry: add 1, negate. This turns -1 into 1, other values into 0
f     % Push indices of nonzeros
Q     % Add 1 to each entry (compensates the fact that computing consecutive
      % differences removes one entry). This the output for 'decreasing'
Gq    % Push input again. Subtract 1 from the code points
f     % Push indices of nonzeros. This is the output for 'twos'
OO    % Push two zeros. These are used as placeholders
Go    % Push input and compute parity of each entry
f     % Push indices of nonzeros. This is the output for 'ones'
Gd    % Push input and compute consecutive differences
1=    % Test each entry for equality with 1
f     % Push indices of nonzeros 
Q     % Add 1. This is the output for 'increasing'
Gf    % Push indices for all input (nonzero) entries. This is the output for 'all'
O     % Push zeros. Used as placeholder
[]    % Push empty array. This is the output for 'none'
Xh    % Concatenate stack into a cell array
j     % Input a string
s     % Sum of code points
)     % Use as an index into the cell aray. Implicitly display

파이썬 2 , 92 바이트

lambda a,s:[i for i,(x,y)in enumerate(zip([0]+a,a))if[0<x<y,0,y<2,y>1,1,x>y][ord(s[0])/3%7]]

온라인으로 사용해보십시오!

젤리 , 27 바이트

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

온라인으로 사용해보십시오!

Jonathan Allan 에게 -3 감사합니다 .

껍질 , 27 바이트

`fN!+mmëI=2ε¬moΘẊe><€¨Ÿȧö¨←

온라인으로 사용해보십시오!

H.PWiz 덕분에 -9 .

나는이 답변을 매우 자랑스럽게 생각합니다.

자바 (오픈 JDK 8) , 266 (217) 213 205 172 171 155 131 바이트

s->a->{int i=0,l=0,c=s.charAt(0)-97;for(int e:a){if(++i>1&(c==8&e>l|c==3&e<l)|c==14&(l=e)<2|c>18&l>1|c<1)System.out.print(i+",");}}

온라인으로 사용해보십시오!

Jq 1.5 , 131 바이트

문자열 일치가 내 배열 버전보다 짧기 때문에 xcali 의 접근 방식을 기반으로 합니다.

def D(s):[.[1]|gsub(" ";"")|match(s;"g").offset+(s|length)];./"
"|{i:D("12"),d:D("21"),o:D("1"),t:D("12"),a:D("."),n:[]}[.[0][0:1]]

jq가 -Rs옵션과 함께 호출 되고 입력이 두 줄에 있다고 가정합니다.

decreasing
1 1 2 2 2 1 2 2 1 1 2

넓히는:

def D(s): [
      .[1]                              # find where s appears
    | gsub(" ";"")                      # in the input and add
    | match(s;"g").offset + (s|length)  # length to get ending index
  ]
;

  ./"\n"                                # split on newline
| {i:D("12"),                           # increasing
   d:D("21"),                           # decreasing
   o:D("1"),                            # ones
   t:D("2"),                            # twos
   a:D("."),                            # all
   n:[]                                 # none
  }[.[0][0:1]]

온라인으로 사용해보십시오!

하스켈 , 91 바이트

(c:_)!l=[i|(i,y,x)<-zip3[1..]l$l!!0:l,c/='i'||x<y,c>'d'||x>y,c/='o'||y<2,c<'t'||y>1,c/='n']

온라인으로 사용해보십시오!

Laikoni는 바이트를 저장했습니다.

J, 73 바이트

g=.[:I.[=0,2-/\]
(_1 g])`(1 g])`(1=])`(2=])`(i.@#@])`_1:@.('idotan'i.{.@[)

이것이 어떻게 크게 압축 될 수 있는지 궁금해 할 것입니다. 나는 할 수 있다고 생각합니다 (모든 의제에 대한 10 문자)!

• g-증가 및 감소를위한 도우미 동사. 이는 \크기 2 의 접두사 런 값을 비교하는 것과 같습니다.
• 나머지는 "command"에서 첫 번째 문자를 가져 와서 Agenda를 사용하여 해당하는 경우를 실행합니다. @.

온라인으로 사용해보십시오!

자바 8, 233 229 216 바이트

l->s->{int i=s.charAt(0)-97,k=0,j=1;for(s=(l+"").replaceAll("[^12]","");s.length()*j>0;System.out.print(j++<0?"":(k+=j)+","),s=s.substring(j))j=i<1?0:s.indexOf(i<4?"21":i<9?"12":i<14?" ":i<15?"1":"2")+(i>2&i<9?1:0);}

이 String 접근법은 내가 예상했던 것보다 길어졌습니다. 그러나 다른 Java 8 answer에 의해 크게 벗어나 있다고 생각하더라도 어쨌든 게시하기로 결정했습니다.
"없음"과 "증가 / 감소"는 주로 몇 바이트의 비용이 드는 해결 방법을 일으켰습니다.

결과는 1- 색인입니다.

설명:

여기에서 시도하십시오.

l->s->{                          // Method with List and String parameters
  int i=s.charAt(0)-97,          //  First character of the String - 97
                                 //   (i=8; d=3; o=14; t=19; a=0; n=13)
      k=0,                       //  Total counter
      j=1;                       //  Index integer
  for(s=(l+"")                   //  toString of the List,
         .replaceAll("[^12]","");//   and leave only the 1s and 2s 
      s.length()*j>0             //  Loop as long as `j` and the size of the String
                                 //  are both larger than 0
      ;                          //   After every iteration:
      System.out.print(          //    Print:
       j++<0?                    //     If `j` is -1:
        ""                       //      Print nothing
       :                         //     Else:
        (k+=j)+",")              //      Print the current index
      ,s=s.substring(j))         //    And then remove the part of the String we've checked
    j=i<1?                       //   If "all":
                                 //    Change `j` to 0
      :                          //   Else:
       s.indexOf(                //    Replace `j` with the next index of:
        i<1?                     //     If "all":
         s.charAt(0)+""          //      The next character
        :i<4?                    //     Else-if "decreasing":
         "21"                    //      Literal "21"
        :i<9?                    //     Else-if "increasing":
         "12"                    //      Literal "12"
        :i<14?                   //     Else-if "none":
         " "                     //      Literal space (any char that isn't present)
        :i<15?                   //     Else-if "one":
         "1"                     //      Literal "1"
        :                        //     Else(-if "two"):
         "2")                    //      Literal "2"
       +(i>2&i<9?1:0);           //     +1 if it's "increasing"/"decreasing"
                                 //  End of loop (implicit / single-line body)
}                                // End of method

Perl 5 , 71 + 2 ( -nl) = 73 바이트

$p=/l/?'.':/t/?2:/^o/?1:/d/?21:/i/?12:0;$_=<>;s/ //g;say pos while/$p/g

온라인으로 사용해보십시오!

수정 된 논리는 아래 설명과 사실상 동일하지만 패턴 일치가 단축되었습니다.

이전 :

$p=/all/?'.':/^o/?1:/^t/?2:/^d/?21:/^i/?12:0;$_=<>;s/ //g;say pos while/$p/g

온라인으로 사용해보십시오!

기준이 일치하지 않으면 아무것도 출력하지 않습니다.

설명 :

$p=          # set the pattern to seach based on the input string
  /all/?'.'  # any character
 :/^o/?1     # starts with 'o', find ones
 :/^t/?2     # starts with 't', find twos
 :/^d/?21    # starts with 'd', find decreasing
 :/^i/?12    # starts with 'i', find increasing
 :0;         # anything else: create pattern that won't match
$_=<>;s/ //g;# read the digits and remove spaces
say pos while/$p/g # output position(s) of all matches