Prenez deux entrées, un vecteur / liste non vide contenant des chiffres 1et2 et une chaîne (non, vous ne pouvez pas prendre à la 0/1place). La chaîne sera l'une des suivantes (en minuscules, exactement comme écrit ci-dessous:

increasing
decreasing
ones
twos
all
none

Si la chaîne est ____, vous devez renvoyer les indices ___:

• increasing... où la liste passe de 1à2 (tout ce 2qui suit directement après a 1)
• decreasing... où la liste passe de 2à1 (tout ce 1qui suit directement après a 2)
• ones ... de tous les chiffres qui sont 1
• twos ... de tous les chiffres qui sont 2
• all ... tous les chiffres
• none... aucun des chiffres. 0est bien si la liste est indexée 1. Un nombre négatif est correct si la liste est indexée 0. Vous pouvez également afficher une liste ou une chaîne vide.

Cas de test:

Ils sont indexés 1. Vous pouvez choisir si vous voulez 1 indexé ou 0 indexé. Les mêmes vecteurs sont utilisés pour différentes chaînes dans les cas de test.

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

Notation

Comme il s'agit de code-golf , la réponse avec le moins d'octets l'emporte.

Les explications sont encouragées!

JavaScript (Firefox 30-57), 74 73 octets

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

Les compréhensions de tableau sont une manière ordonnée de combiner mapet filteren une seule fois. Edit: 1 octet enregistré grâce à @ edc65.

Python 2 , 136 131 119 119 108 97 octets

• Enregistré cinq octets; en utilisant une lambdafonction.
• Enregistré douze octets grâce à TFeld ; jouer au golf deux conditions.
• Onze octets enregistrés grâce à M. Xcoder ; en utilisantenumerate() au lieu de range(len()).
• Onze octets enregistrés en utilisant une liste au lieu d'un dictionnaire et en utilisant 0-indexing (comme dans la réponse de TFeld ) et en jouant "adinot".find(m[0])au golf 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]]

Essayez-le en ligne!

Python 2 , 117 111 110 99 97 92 octets

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

Essayez-le en ligne!

0-indexé

Passé à l'aide de l'indexation de Jonathan et joué ord(m[0])/3-32au golford(t[0])/3%7

Haskell , 112 83 81 octets

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

Essayez-le en ligne! Exemple d' utilisation: "increasing"%[1,1,2,1,2]. Les résultats sont indexés 1.

En partie inspiré par la réponse Haskell de Lynn .

MATL , 32 31 30 29 octets

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

La sortie est basée sur 1 ou vide.

Essayez-le en ligne!

Explication

Le code calcule les six sorties possibles pour l'entrée de tableau, puis sélectionne la sortie appropriée en fonction de l'entrée de chaîne.

Pour sélectionner la sortie, les points de code ASCII de tous les caractères de l'entrée de chaîne sont ajoutés. Le résultat modulo 9 donne 6, 1, 5, 2, 7, 0respectivement 'increasing', 'decreasing', 'ones', 'twos', 'all', 'none'. Étant donné que tous les nombres résultants sont distincts, cela peut être utilisé comme critère de sélection.

Au lieu d'effectuer réellement une opération modulo 9 sur la somme, la liste des entrées possibles est étendue à 9 entrées (dont certaines sont factices), et donc l'indexation dans cette liste se fait automatiquement 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 octets

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

Essayez-le en ligne!

Gelée , 27 octets

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Essayez-le en ligne!

-3 merci à Jonathan Allan .

Husk , 27 octets

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

Essayez-le en ligne!

-9 grâce à H.PWiz .

Je suis assez fier de cette réponse.

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

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

Essayez-le en ligne!

Jq 1,5 , 131 octets

Basé sur l' approche de xcali car la correspondance des chaînes est plus courte que ma version de tableau.

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

Suppose que jq est appelé avec des -Rsoptions et que l'entrée apparaît sur deux lignes, par exemple

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

Étendu:

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

Essayez-le en ligne!

Haskell , 91 octets

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

Essayez-le en ligne!

Laikoni a enregistré un octet.

J, 73 octets

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

Serait curieux de voir comment cela peut être condensé de manière significative - je crois que cela peut (10 caractères juste pour toutes ces parens de l'ordre du jour!)

• g - verbe auxiliaire pour augmenter et diminuer, ce qui revient à comparer les valeurs de l'infixe \ de taille 2
• Le reste saisit simplement le premier caractère de la "commande" et exécute le cas correspondant en utilisant Agenda @.

Essayez-le en ligne!

Java 8, 233 229 216 octets

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

Cette approche String a fini plus longtemps que ce à quoi je m'attendais. Mais même si je suis énormément dépassé par l'autre réponse Java 8 , j'ai décidé de la publier quand même.
Il peut certainement être joué au golf, même avec cette approche. Le "aucun" et "l'augmentation / la diminution" ont principalement provoqué une solution de contournement qui a coûté quelques octets ..

Le résultat est indexé 1.

Explication:

Essayez-le ici.

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 octets

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

Essayez-le en ligne!

La logique révisée est en fait la même que l'explication ci-dessous, mais les correspondances de modèle ont été raccourcies.

Précédemment:

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

Essayez-le en ligne!

N'affiche rien si les critères ne correspondent pas.

Expliqué:

$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