Meu chefe agora quer que eu implemente um mecanismo que permita que ele procure por um item em uma matriz e forneça a ele os índices / índices onde esse valor ocorre.

Sua tarefa:

Escreva um programa ou função que receba uma matriz e um valor (String, Inteiro, Flutuante ou Booleano) e retorne os índices da matriz na qual o valor ocorre (0 ou 1 indexado, o que você preferir). Se o valor não estiver na matriz, retorne uma matriz vazia.

Entrada:

Uma matriz A e um valor V, que podem ou não estar presentes em A.

Saída:

Uma matriz contendo o (s) índice (s) no qual o V ocorre em A ou, se V não ocorrer em A, uma matriz vazia.

Casos de teste:

Observe que os casos de teste são baseados em 0.

12, [12,14,14,2,"Hello World!",3,12,12]         -> [0,6,7]
"Hello World", ["Hi", "Hi World!", 12,2,3,True] -> []
"a", ["A",True,False,"aa","a"]                  -> [4]
12, [12,"12",12]                                -> [0,2]

Pontuação:

Isso é código-golfe , então a pontuação mais baixa em bytes vence.

Pitão , 2 bytes

Indexado a 0.

xE

Experimente online! ou Verifique todos os casos de teste

Explicação

xEQ  - Full Program. Takes Input from standard input. Q means evaluated input and is implicit at the end of the program.

x   - Get all the indexes of x in y
 E  - Evaluated Input #2 - The value
  Q - The list - Evaluated Input #1

MATL , 2 bytes

mf

Ele mconsome dois argumentos e verifica se cada elemento da matriz é igual ao outro argumento, fretorna os índices das entradas verdadeiras de uma matriz.

Experimente online!

Python 3 , 45 bytes

-3 bytes graças a @EriktheOutgolfer e @Chris_Rands

lambda y,x:[i for i,j in enumerate(x)if j==y]

Suíte de teste.

Hoje eu aprendi enumerate(x) == zip(range(len(x)),x).

Python 3 , 47 bytes

lambda n,l:[x for x in range(len(l))if l[x]==n]

Experimente online! ou Verifique todos os casos de teste

R (+ pryr), 20 bytes

pryr::f(which(a==b))

Que avalia a função

function (a, b) 
which(a == b)

Onde qualquer um apode ser o valor a ser procurado e bo vetor, ou o contrário. Quando apresentado com dois vetores de comprimentos desiguais (um valor único conta como um vetor de comprimento 1 em R), R envolverá o menor com o comprimento do maior. Então a igualdade é verificada. Isso gera um vetor lógico. whichfornece os índices onde esse vetor é verdadeiro.

Experimente online!

JavaScript, 39 bytes

e=>a=>[...a.keys()].filter(i=>a[i]===e)

f=
e=>a=>[...a.keys()].filter(i=>a[i]===e)

console.log(f(12)([12,14,14,2,"Hello World!",3,12,12]));
console.log(f("Hello World")(["Hi", "Hi World!", 12,2,3,true]));
console.log(f("a")(["A",true,false,"aa","a"])); 
console.log(f(12)([12,14,14,2,"Hello World!",3,12,'12']));

O snippet acima pode não funcionar em todos os navegadores, então aqui está um link TIO .

JavaScript (ES6), 44 43 bytes

^{O riscado 44 ainda é regular 44;}

v=>a=>a.map((x,i)=>x===v&&++i).filter(x=>x)

Guardado 1 bytes graças a @Arnauld

let f=
v=>a=>a.map((x,i)=>x===v&&++i).filter(x=>x)
;

console.log(f(12)([12,14,14,2,"Hello World!",3,12,12]));         // => [1,7,8]
console.log(f("Hello World")(["Hi", "Hi World!", 12,2,3,true])); // => []
console.log(f("a")(["A",true,false,"aa","a"]));                  // => [5]

05AB1E , 4 bytes

QāsÏ

Experimente online!

1 indexado.

C #, 88 72 bytes

using System.Linq;a=>o=>a.Select((i,n)=>o.Equals(i)?n:-1).Where(n=>n>=0)

Economizou 16 bytes graças a @LiefdeWen.

Experimente online!

Gelatina , 3 bytes

⁼€T

Experimente online!

-1 graças ao Sr. Xcoder . (cadeias diádicas)

Haskell , 41 39 bytes

v!l=fst<$>(filter((==v).snd)$zip[1..]l)

Experimente online!

Salvou dois bytes graças a @flawr

Haskell é digitado estaticamente, então tive que usar um pouco de solução alternativa para executar os casos de teste.

Casca , 5 bytes

`fNm=

Experimente online! 1 indexado.

Explicação

       -- implicitly input a value v and a list L
   m=  -- map "equals v" over the list L, resulting in a list of truthy and falsy values
`fN    -- filter the natural numbers N by discarding the numbers at falsy positions 
          and keeping the ones at truthy positions

Ruby, 46 40 39 bytes

->e,a{i=-1;a.map{|x|i+=1;x==e&&i}-[!1]}

Salvo 7 bytes !!! graças a Eric Duminil.

Experimente online.

Ruby, 38 bytes

->e,a{a.each_index.select{|x|a[x]==e}}

Experimente online!

Planilhas Google, 101 bytes

=IfError(Join(",",Filter(Column(Offset(A1,0,0,1,Counta(Split(B1,",")))),Exact(Split(B1,","),A1))),"")

Valor Vem A1e matriz Ano B1com cada entrada separadas por uma vírgula. Entradas nulas não são permitidas (a linha 5 abaixo mostra o que acontece).

Explicação:

Offset(A1,0,0,1,Counta(Split(B1,",")))retorna um intervalo com uma linha de altura e tantas colunas de largura quanto entradas A1.

=IfError(Join(",",Filter(Column(~),Exact(Split(B1,","),A1))),"")filtra os números de coluna desse intervalo com base em se o valor in A1é exatamente cada um dos valores B1e concatena todos eles em uma lista delimitada por vírgulas.

Clojure , 40 bytes

Primeira tentativa de código de golfe.

keep-indexed mapeia uma função sobre uma coleção aqui, passando o índice atual para o retorno de chamada e produzindo valores de retorno diferentes de zero.

(fn[a b](keep-indexed #(if(= %2 a)%1)b))

Experimente online!

APL (Dyalog Unicode) , ^{SBCS de} 2 bytes

Leva o item a ser procurado como argumento à esquerda (deve ser escalar para localizar um item da matriz de pesquisa em vez de uma sub-matriz) e a matriz de pesquisa (que pode ter até 15 dimensões) como argumento correto. Retorna a lista de índices, cada um dos quais pode ter tantos elementos quanto o número de dimensões na matriz de pesquisa.

⍸⍷

Experimente online!

⍸ descobre onde

⍷ encontrado

Lote, 86 bytes

@set i=0
:g
@if "%~2"=="" exit/b
@if %1==%2 echo %i%
@set/ai+=1
@shift/2
@goto g

Recebe a entrada como parâmetros da linha de comando (valor e os elementos da matriz como parâmetros separados). Nota: A citação de string é considerada parte da correspondência, por exemplo "1", não será igual 1(custaria 6 bytes).

Python 2 , 49 bytes

lambda l,v:filter(lambda i:l[i]==v,range(len(l)))

Experimente online!

Não é curto o suficiente, mas achei legal. ¯ \ _ (ツ) _ / ¯

Perl 5 , 28 bytes

sub{grep$_[$_]eq$_[0],1..@_}

Experimente online!

A saída é indexada em 1.
Uma função anônima é bastante incomum para Perl, mas é a mais curta possível. grep ..., 1 .. @_itera sobre os índices da matriz de entrada (na verdade, vai uma célula além da última, mas não importa), mantendo apenas o índice que satisfaz $_[$_]eq$_[0], ou seja. aqueles em que o valor do elemento ( $_[$_]) é igual ao valor que precisamos manter ( $_[0]).

Um pouco mais (31 bytes (30 + -lsinalizador)), mas como um programa completo:

$@=<>;$@eq$_&&print$.-1while<>

Experimente online!

Haskell , 37 33 bytes

import Data.List
findIndices.(==)

Obrigado @Laikoni por -4 bytes!

Experimente online!

Java 8, 146 113 112 111 110 108 bytes

import java.util.*;l->o->{List r=new Stack();for(int i;(i=l.indexOf(o))>-1;l.set(i,null))r.add(i);return r;}

-2 bytes graças a @TAsk usando em Vectorvez de ArrayList.
-1 byte usando em Stackvez de Vector.
-2 bytes graças a @Jakob inserindo umArrayList vez de uma matriz.

Indexado a 0

Explicação:

Experimente aqui.

import java.util.*;    // Required import for Vector and Vector
l->o->{                // Method with List and Object parameters
  List r=new Stack();  //  Result-list
  for(int i;(i=l.indexOf(o))>=-1;
                       //  Loop as long as we can find the object in the list
    l.set(i,null))     //   After every iteration, remove the found item from the list
      r.add(i);        //    Add the index to the result-list
                       //  End of loop (implicit / single-line body)
  return r;            //  Return the result-List
}                      // End of method

05AB1E , 4 bytes

Qƶ0K

Experimente online!

É indexado 1, como mostrado abaixo:

IN A-#------------------------> [2,3,3,3,4]
IN B-#------------------------> 3
-----#------------------------+-----------------
Q    # Vectorized equivalence | [0,1,1,1,0]
 ƶ   # Lift by index          | [0,2,3,4,0]
  0K # Remove zeros           | [2,3,4]

Mathematica, 12 bytes

Position@##&

1-Indexado

entrada [Matriz, Valor]

[{12, 14, 14, 2, "Olá, mundo!", 3, 12, 12}, 12]

saída

{{1}, {7}, {8}}

Haskell, 29 bytes

e#l=[i|(i,h)<-zip[0..]l,h==e]    

Experimente online!

Japonês , 9 bytes

mȶV©YÄÃf

1 indexado.

A entrada Japt não suporta booleanos; portanto, eles foram substituídos por 0e 1nos casos de teste.

Experimente online! com o -Qsinalizador para formatar a saída da matriz.

Solução indexada em 0, 11 bytes

l o f@gX ¶V

Experimente online!

Perl 6 , 21 bytes

{grep :k,*===$^v,@^z}

Experimente online!

O :kadvérbio para grepdiz para retornar as chaves (índices) correspondentes da sequência de entrada que correspondem ao predicado* === $^v .

Se seqüências de caracteres e números forem considerados equivalentes, pode-se usar um predicado grep de apenas em $^vvez de * === $^v.

Lisp comum, 66 bytes

(lambda(x s)(loop as i in s as j from 0 when(equal i x)collect j))

Experimente online!

TXR Lisp , 26 bytes

(op where(op equal @@1)@2)

Em outras palavras, "Onde o argumento 2 é igual ao argumento 1?"

Corre:

1> (op where(op equal @@1) @2)
#<interpreted fun: lambda (#:arg-01-0166 #:arg-02-0167 . #:rest-0165)>
2> [*1 12 #(12 14 14 2 "Hello world!" 3 12 12)]
(0 6 7)
3> [*1 "Hello World" #("Hi" "Hi world!" 12 2 3 t)]
nil

Clojure, 39 38 bytes

#(filter(comp #{%2}%)(range(count %)))

Um pouco obscuro :) O primeiro argumento de entrada é um vecdos valores e o segundo é o valor pesquisado. %mapeia os índices para valores e o conjunto #{%2}retorna verdade (o argumento de entrada %2) ou falso nilpara esse valor. comp os compõe juntos.

C 340 362 166 115 bytes

Olá a todos. Minha primeira vez aqui. Eu percebi que, como eu gosto (tentando) de escrever código otimizado, também posso tentar.

@Rodney - ~ 39 bytes das inclusões

@ Zacharý - 7 bytes com digitação implícita

Indexado a 0 .

Como executar:

Conforme sugestão do @Arnolds, o programa aceita argumentos de uma maneira muito mais amigável em C. Isso me permite reduzir o tamanho do arquivo em pouco mais da metade.

Os argumentos devem ser passados ​​na seguinte ordem value [element1 ...] que chaves indicam argumentos opcionais

Você pode ou não ter que adicionar aspas escapadas a quaisquer strings fornecidas para satisfazer a condição de 12 != "12". No meu sistema, isso pode ser feito da seguinte maneira

prog-name.exe 12 3 "Hello" 12 4 "12"
Returns [2,4]     < This is incorrect

prog-name.exe 12 3 "\"Hello\"" 12 4 "\"12\""
Returns [2]       < Correct

golfed

#define P printf(
b=0;main(int c,char**v){P"[");for(--c;c-1;c--)b|=strcmp(v[1],v[c])?0:P b?",%i":"%i",c-2);P"]");}

destroçado

#define P printf(

//Implicit only works in global(I totally knew this after almost 4 years of C :P)
b = 0;
main(int c,char**v)
{

    P"[");

    //match loop
    //b is used to determine if this is the first iteration. it can be assumed that printf will always return >0
    //subract two from c to get correct index number of match
    for(--c; c-1; c--)
        b |= strcmp(v[1], v[c]) ? 0 : P b ? ",%i" : "%i", c-2);

    P"]");

    return 0;
}