Tomar dos entradas, un vector no vacío / lista que contiene los dígitos 1y 2y una cadena (no, no se puede tomar 0/1en su lugar). La cadena será una de las siguientes (en minúsculas, exactamente como se escribe a continuación:

increasing
decreasing
ones
twos
all
none

Si la cadena es ____, deberá devolver los índices ___:

• increasing... donde la lista cambia de 1a 2(todo lo 2que sigue directamente después de a 1)
• decreasing... donde la lista cambia de 2a 1(todo lo 1que sigue directamente después de a 2)
• ones ... de todos los dígitos que son 1
• twos ... de todos los dígitos que son 2
• all ... todos los dígitos
• none... ninguno de los dígitos. 0está bien si la lista está indexada en 1. Un número negativo está bien si la lista está indexada en 0. También puede generar una lista o cadena vacía.

Casos de prueba:

Estos están indexados en 1. Puede elegir si desea 1 indexado o 0 indexado. Los mismos vectores se utilizan para diferentes cadenas en los casos de prueba.

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

Puntuación

Como se trata de código de golf , gana la respuesta con la menor cantidad de bytes.

¡Se alientan las explicaciones!

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]

Las comprensiones de matriz son una forma ordenada de combinar mapy filterde una vez. Editar: guardado 1 byte gracias a @ edc65.

Python 2 , 136 131 119 108 97 bytes

• Guardado cinco bytes; utilizando una lambdafunción
• Guardado doce bytes gracias a TFeld ; Golf dos condiciones.
• Salvó once bytes gracias al Sr. Xcoder ; usando en enumerate()lugar de range(len()).
• Se guardaron once bytes usando una lista en lugar de un diccionario y usando 0-indexing (como en la respuesta de TFeld ) y jugar al golf "adinot".find(m[0])a 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]]

Pruébalo en línea!

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

Pruébalo en línea!

0-indexado

Cambió a usar la indexación de Jonathan y jugó golf ord(m[0])/3-32aord(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]]

Pruébalo en línea! Ejemplo de uso: "increasing"%[1,1,2,1,2]. Los resultados están indexados en 1.

Parcialmente inspirado por la respuesta de Lynn Haskell .

MATL , 32 31 30 29 bytes

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

La salida se basa en 1 o está vacía.

Pruébalo en línea!

Explicación

El código calcula las seis salidas posibles para la entrada de la matriz y luego selecciona la salida apropiada según la entrada de la cadena.

Para seleccionar la salida, se agregan los puntos de código ASCII de todos los caracteres de la entrada de cadena. El modulo número 9 da 6, 1, 5, 2, 7, 0, respectivamente, para 'increasing', 'decreasing', 'ones', 'twos', 'all','none' . Como todos los números resultantes son distintos, esto puede usarse como criterio de selección.

En lugar de realizar realmente una operación del módulo 9 en la suma, la lista de posibles entradas se extiende a 9 entradas (algunas de las cuales son ficticias), por lo que la indexación en esa lista se realiza automáticamente en el 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]]

Pruébalo en línea!

Jalea , 27 bytes

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Pruébalo en línea!

-3 gracias a Jonathan Allan .

Casco , 27 bytes

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

Pruébalo en línea!

-9 gracias a H.PWiz .

Estoy muy orgulloso de esta respuesta.

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

Pruébalo en línea!

Jq 1.5 , 131 bytes

Basado en el enfoque de xcali ya que la coincidencia de cadenas es más corta que mi versión de matriz.

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

Asume que jq se invoca con -Rsopciones y la entrada aparece en dos líneas, por ejemplo

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

Pruébalo en línea!

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

Pruébalo en línea!

Laikoni salvó un byte.

J 73 bytes

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

Sería curioso ver cómo esto se puede condensar significativamente: creo que sí (¡10 caracteres solo para todos esos padres de la agenda!)

• g - verbo auxiliar para aumentar y disminuir, lo que equivale a comparar los valores de infijo \ series de de tamaño 2
• El resto solo toma el primer carácter del "comando" y ejecuta el caso correspondiente usando Agenda @.

Pruébalo en línea!

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

Este enfoque de String terminó más tiempo de lo que esperaba ... Pero aunque pensé que la otra respuesta de Java 8 me superaba enormemente , decidí publicarlo de todos modos.
Definitivamente se puede jugar golf, incluso con este enfoque. El "ninguno" y el "aumento / disminución" causaron principalmente una solución que costó algunos bytes.

El resultado es 1 indexado.

Explicación:

Pruébalo aquí.

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

Pruébalo en línea!

La lógica revisada es efectivamente la misma que la explicación a continuación, pero las coincidencias de patrones se han acortado.

Previamente:

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

Pruébalo en línea!

No genera nada si el criterio no coincide.

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