Tome duas entradas, um vetor não-vazia / lista contendo dígitos 1e 2e uma corda (não, você não pode levar 0/1em vez disso). A string será uma das seguintes (em minúsculas, exatamente como está escrito abaixo:

increasing
decreasing
ones
twos
all
none

Se a sequência for ____, você retornará os índices ___:

• increasing... onde a lista muda de 1para 2(todos os 2que seguem diretamente após a 1)
• decreasing... onde a lista muda de 2para 1(todos os 1que seguem diretamente após a 2)
• ones ... de todos os dígitos que são 1
• twos ... de todos os dígitos que são 2
• all ... todos os dígitos
• none... nenhum dos dígitos. 0é bom se a lista estiver indexada em 1. Um número negativo é bom se a lista estiver indexada em 0. Você também pode gerar uma lista ou sequência vazia.

Casos de teste:

Estes são indexados em 1. Você pode escolher se deseja indexar 1 ou 0. Os mesmos vetores são usados ​​para cadeias diferentes nos casos de teste.

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

Pontuação

Como se trata de código-golfe , a resposta com o mínimo de bytes vence.

As explicações são incentivadas!

JavaScript (Firefox 30-57), 74 73 bytes

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

A compreensão de matrizes é uma maneira elegante de combinar mape filterde uma só vez. Editar: salvou 1 byte graças a @ edc65.

Python 2 , 136 131 119 108 97 bytes

• Salvo cinco bytes; usando uma lambdafunção
• Economizou doze bytes graças ao TFeld ; golfe duas condições.
• Economizou onze bytes graças ao Sr. Xcoder ; usando em enumerate()vez de range(len()).
• Salvo onze bytes usando uma lista em vez de um dicionário e usando 0-indexing (como na resposta de TFeld ) e golfe "adinot".find(m[0])para 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]]

Experimente online!

Python 2 , 117 111 110 99 97 92 bytes

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

Experimente online!

0-indexed

Mudou para usar a indexação de Jonathan e jogou golfe ord(m[0])/3-32paraord(t[0])/3%7

Haskell , 112 83 81 bytes

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

Experimente online! Exemplo de utilização: "increasing"%[1,1,2,1,2]. Os resultados são indexados em 1.

Em parte inspirado pela resposta de Lynn Haskell .

MATL , 32 31 30 29 bytes

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

A saída é baseada em 1 ou vazia.

Experimente online!

Explicação

O código calcula as seis saídas possíveis para a entrada da matriz e, em seguida, seleciona a saída apropriada, dependendo da entrada da string.

Para selecionar a saída, os pontos de código ASCII de todos os caracteres da entrada de sequência são adicionados. O módulo resultado dá 9 6, 1, 5, 2, 7, 0, respectivamente, para 'increasing', 'decreasing', 'ones', 'twos', 'all', 'none'. Como todos os números resultantes são distintos, isso pode ser usado como critério de seleção.

Em vez de realmente executar uma operação do módulo 9 na soma, a lista de entradas possíveis é estendida para 9 entradas (algumas das quais são falsas) e, portanto, a indexação nessa lista é feita automaticamente no módulo 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 bytes

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

Experimente online!

Gelatina , 27 bytes

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Experimente online!

-3 graças a Jonathan Allan .

Casca , 27 bytes

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

Experimente online!

-9 graças a H.PWiz .

Estou bastante orgulhoso desta resposta.

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

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

Experimente online!

Jq 1.5 , 131 bytes

Com base na abordagem do xcali , uma vez que a correspondência de strings é menor que a minha versão do array.

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

Assume que jq é chamado com -Rsopções e a entrada aparece em duas linhas, por exemplo

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

Expandido:

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

Experimente online!

Haskell , 91 bytes

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

Experimente online!

Laikoni salvou um byte.

J, 73 bytes

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

Seria curioso ver como isso pode ser significativamente condensado - acredito que sim (10 caracteres apenas para todas essas agendas)!

• g- verbo auxiliar para aumentar e diminuir, o que equivale a comparar os valores de \execuções infix de tamanho 2
• O resto apenas pega o primeiro caractere do "comando" e executa o caso correspondente usando Agenda @.

Experimente online!

Java 8, 233 229 216 bytes

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

Essa abordagem de String acabou mais do que eu esperava .. Mas, mesmo pensando que sou extremamente desafiada pela outra resposta do Java 8 , decidi publicá-la de qualquer maneira.
Definitivamente, pode-se jogar golfe, mesmo com essa abordagem. O "nenhum" e "aumento / diminuição" causaram principalmente alguma solução alternativa que custou alguns bytes.

O resultado é 1 indexado.

Explicação:

Experimente aqui.

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 bytes

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

Experimente online!

A lógica revisada é efetivamente a mesma da explicação abaixo, mas as correspondências de padrões foram reduzidas.

Anteriormente:

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

Experimente online!

Não gera nada se o critério não for correspondido.

Explicado:

$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