Hãy hai đầu vào, một vector không trống / danh sách có chứa chữ số 1và 2và một chuỗi (không, bạn có thể không mất 0/1thay vào đó). Chuỗi sẽ là một trong những điều sau đây (viết thường, chính xác như được viết dưới đây:

increasing
decreasing
ones
twos
all
none

Nếu chuỗi là ____ thì bạn sẽ trả về các chỉ số ___:

• increasing... nơi danh sách thay đổi từ 1thành 2(mọi 2thứ theo sau trực tiếp sau a 1)
• decreasing... nơi danh sách thay đổi từ 2thành 1(mọi 1thứ theo sau trực tiếp sau a 2)
• ones ... của tất cả các chữ số 1
• twos ... của tất cả các chữ số 2
• all ... tất cả các chữ số
• none... Không có chữ số nào. 0là tốt nếu danh sách là 1 chỉ mục. Một số âm là tốt nếu danh sách được lập chỉ mục 0. Bạn cũng có thể xuất ra một danh sách trống hoặc chuỗi.

Các trường hợp thử nghiệm:

Đây là 1 chỉ mục. Bạn có thể chọn nếu bạn muốn lập chỉ mục 1 hoặc 0 chỉ mục. Các vectơ giống nhau được sử dụng cho các chuỗi khác nhau trong các trường hợp thử nghiệm.

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

Chấm điểm

Vì đây là môn đánh gôn , câu trả lời có ít byte nhất sẽ thắng.

Giải thích được khuyến khích!

JavaScript (Firefox 30-57), 74 73 byte

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

Hiểu mảng là một cách kết hợp gọn gàng mapvà filtertrong một lần. Chỉnh sửa: Đã lưu 1 byte nhờ @ edc65.

Python 2 , 136 131 119 108 97 byte

• Đã lưu năm byte; sử dụng một lambdachức năng.
• Đã lưu mười hai byte nhờ TFeld ; chơi golf hai điều kiện.
• Đã lưu mười một byte nhờ ông Xcoder ; sử dụng enumerate()thay vì range(len()).
• Lưu mười một byte bằng cách sử dụng một danh sách thay vì một từ điển và sử dụng 0-indexing (như trong câu trả lời của TFeld ) và chơi gôn "adinot".find(m[0])đến 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]]

Hãy thử trực tuyến!

Python 2 , 117 111 110 99 97 92 byte

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

Hãy thử trực tuyến!

0-xuất hiện

Chuyển sang sử dụng chỉ mục của Jonathan , và golfed ord(m[0])/3-32đểord(t[0])/3%7

Haskell , 112 83 81 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng : "increasing"%[1,1,2,1,2]. Kết quả là 1 chỉ số.

Một phần lấy cảm hứng từ câu trả lời của Haskell của Lynn .

MATL , 32 31 30 29 byte

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

Đầu ra là 1 dựa, hoặc trống.

Hãy thử trực tuyến!

Giải trình

Mã này tính toán sáu đầu ra có thể cho đầu vào mảng, sau đó chọn đầu ra thích hợp tùy thuộc vào đầu vào chuỗi.

Để chọn đầu ra, các điểm mã ASCII của tất cả các ký tự của đầu vào chuỗi được thêm vào. Kết quả modulo 9 cho 6, 1, 5, 2, 7, 0lần lượt cho 'increasing', 'decreasing', 'ones', 'twos', 'all', 'none'. Vì tất cả các số kết quả là khác biệt, điều này có thể được sử dụng làm tiêu chí lựa chọn.

Thay vì thực sự thực hiện thao tác modulo 9 trên tổng, danh sách các đầu vào có thể được mở rộng thành 9 mục (một số trong số đó là giả), và do đó việc lập chỉ mục vào danh sách đó được tự động thực hiện theo modulo 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

Python 2 , 92 byte

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

Hãy thử trực tuyến!

Thạch , 27 byte

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Hãy thử trực tuyến!

-3 cảm ơn Jonathan Allan .

Husk , 27 byte

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

Hãy thử trực tuyến!

-9 cảm ơn H.PWiz .

Tôi khá tự hào về câu trả lời này.

Java (OpenJDK 8) , 266 217 213 205 172 171 155 131 byte

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

Hãy thử trực tuyến!

Jq 1.5 , 131 byte

Dựa trên cách tiếp cận của xcali vì khớp chuỗi ngắn hơn phiên bản mảng của tôi.

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

Giả sử jq được gọi với -Rscác tùy chọn và đầu vào xuất hiện trên hai dòng, vd

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

Mở rộng:

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

Hãy thử trực tuyến!

Haskell , 91 byte

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

Hãy thử trực tuyến!

Laikoni lưu một byte.

J, 73 byte

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

Sẽ tò mò muốn xem làm thế nào điều này có thể được cô đọng đáng kể - tôi tin rằng nó có thể (10 ký tự chỉ dành cho tất cả các chương trình nghị sự!)

• g - động từ trợ giúp để tăng và giảm, chỉ tương đương với việc so sánh các giá trị của infix \ chạy của kích thước 2
• Phần còn lại chỉ lấy ký tự đầu tiên từ "lệnh" và thực hiện trường hợp tương ứng bằng Chương trình nghị sự @.

Hãy thử trực tuyến!

Java 8, 233 229 216 byte

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

Cách tiếp cận Chuỗi này đã kết thúc lâu hơn tôi mong đợi .. Nhưng thậm chí còn nghĩ rằng tôi cực kỳ bị ruồng bỏ bởi câu trả lời Java 8 khác , tôi vẫn quyết định đăng nó.
Nó chắc chắn có thể được đánh gôn, ngay cả với cách tiếp cận này .. Việc "không" và "tăng / giảm" chủ yếu gây ra một số cách giải quyết có giá vài byte ..

Kết quả là 1 chỉ mục.

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Hãy thử trực tuyến!

Logic sửa đổi có hiệu quả giống như giải thích dưới đây, nhưng các kết quả khớp mẫu đã được rút ngắn.

Trước đây:

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

Hãy thử trực tuyến!

Đầu ra không có gì nếu các tiêu chí không phù hợp.

Giải thích:

$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