Il mio capo ora vuole che io implementi un meccanismo che gli permetta di cercare un oggetto in un array e gli dia l'indice / gli indici in cui si verifica quel valore.

Il tuo compito:

Scrivi un programma o una funzione che riceve un array e un valore (String, Integer, Float o Boolean) e restituisce gli indici dell'array in cui si verifica il valore (0 o 1 indicizzato, a seconda di quale preferisci). Se il valore non è nella matrice, restituire una matrice vuota.

Ingresso:

Un array A e un valore V, che possono o meno essere presenti in A.

Produzione:

Un array contenente gli indici in corrispondenza dei quali V si presenta in A o, se V non si verifica in A, un array vuoto.

Casi test:

Si noti che i casi di test sono basati su 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]

punteggio:

Questo è code-golf , quindi vince il punteggio più basso in byte.

Pyth , 2 byte

0-indicizzati.

xE

Provalo online! oppure Verifica tutti i casi di test

Spiegazione

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 byte

mf

Le mconsuma due argomenti, e controlla ogni elemento dell'array se è uguale l'altro argomento, frestituisce gli indici delle voci truthy di un array.

Provalo online!

Python 3 , 45 byte

-3 byte grazie a @EriktheOutgolfer e @Chris_Rands

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

Test Suite.

Oggi ho imparato enumerate(x) == zip(range(len(x)),x).

Python 3 , 47 byte

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

Provalo online! oppure Verifica tutti i casi di test

R (+ pryr), 20 byte

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

Che valuta la funzione

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

Dove uno apuò essere il valore da cercare e bil vettore o viceversa. Quando viene presentato con due vettori di lunghezze disuguali (un singolo valore conta come un vettore di lunghezza 1 in R), R avvolgerà quello più corto in modo che corrisponda alla lunghezza di quello più lungo. Quindi viene verificata l'uguaglianza. Questo genera un vettore logico. whichfornisce gli indici in cui questo vettore è vero.

Provalo online!

JavaScript, 39 byte

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

Lo snippet sopra potrebbe non funzionare su tutti i browser, quindi ecco un link TIO .

JavaScript (ES6), 44 43 byte

^{Cancellato 44 è ancora regolare 44; (}

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

Salvato 1 byte grazie 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 byte

QāsÏ

Provalo online!

1-indicizzati.

C #, 88 72 byte

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

16 byte salvati grazie a @LiefdeWen.

Provalo online!

Gelatina , 3 byte

⁼€T

Provalo online!

-1 grazie a Mr. Xcoder . (catene diadiche)

Haskell , 41 39 byte

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

Provalo online!

Due byte salvati grazie a @flawr

Haskell è tipicamente statico, quindi ho dovuto usare un po 'di soluzione per eseguire i casi di test.

Buccia , 5 byte

`fNm=

Provalo online!1-indicizzati.

Spiegazione

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

Rubino, 46 40 39 byte

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

Salvato 7 byte !!! grazie a Eric Duminil.

Provalo online.

Rubino, 38 byte

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

Provalo online!

Fogli Google, 101 byte

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

Valore Vin A1e array Ain B1con ogni voce separata da una virgola. Non sono ammessi valori null (la riga 5 in basso mostra cosa succede).

Spiegazione:

Offset(A1,0,0,1,Counta(Split(B1,",")))restituisce un intervallo che è alto una riga e tante colonne quante sono le voci in A1.

=IfError(Join(",",Filter(Column(~),Exact(Split(B1,","),A1))),"")filtra i numeri di colonna di tale intervallo in base al fatto che il valore in A1sia esattamente ciascuno dei valori in B1e li concatena in un elenco delimitato da virgole.

Clojure , 40 byte

Primo tentativo di codice golf.

keep-indexed mappa una funzione su una raccolta qui, passando l'indice corrente nel callback e producendo valori di ritorno diversi da zero.

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

Provalo online!

APL (Dyalog Unicode) , 2 byte ^SBCS

Prende l'elemento da cercare come argomento di sinistra (deve essere scalare per trovare un elemento dell'array di ricerca anziché un subarray) e l'array di ricerca (che può avere fino a 15 dimensioni) come argomento giusto. Restituisce un elenco di indici, ognuno dei quali può avere tanti elementi quanti sono il numero di dimensioni nella matrice di ricerca.

⍸⍷

Provalo online!

⍸ ɩ ndices dove

⍷ trovato

Lotto, 86 byte

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

Accetta input come parametri della riga di comando (valore quindi gli elementi dell'array come parametri separati). Nota: la quotazione di stringa è considerata parte della corrispondenza, ad esempio "1"non sarà uguale 1(costerebbe 6 byte).

Python 2 , 49 byte

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

Provalo online!

Non abbastanza breve, ma ho pensato che fosse bello. ¯ \ _ (ツ) _ / ¯

Perl 5 , 28 byte

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

Provalo online!

L'output è 1 indicizzato.
Una funzione anonima è abbastanza inusuale per Perl, ma sembra essere la più breve che mi venga in mente. grep ..., 1 .. @_scorre gli indici dell'array di input (in realtà va oltre una cella oltre l'ultima, ma non importa), mantenendo solo l'indice che soddisfa $_[$_]eq$_[0], ad es. quelli in cui il valore dell'elemento ( $_[$_]) è uguale al valore che dobbiamo mantenere ( $_[0]).

Leggermente più lungo (31 byte (30 + -lflag)), ma come programma completo:

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

Provalo online!

Haskell , 37 33 byte

import Data.List
findIndices.(==)

Grazie @Laikoni per -4 byte!

Provalo online!

Java 8, 146 113 112 111 110 108 byte

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 byte grazie a @TAsk usando Vectorinvece di ArrayList.
-1 byte usando Stackinvece di Vector.
-2 byte grazie a @Jakob inserendo ArrayListun array anziché un array.

0-indicizzato

Spiegazione:

Provalo qui.

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 byte

Qƶ0K

Provalo online!

È 1-indicizzato, come mostrato di seguito:

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 byte

Position@##&

1-indicizzato

input [Array, Value]

[{12, 14, 14, 2, "Hello World!", 3, 12, 12}, 12]

produzione

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

Haskell, 29 byte

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

Provalo online!

Japt , 9 byte

mȶV©YÄÃf

1-indicizzati.

L'input Japt non supporta i booleani, quindi sono stati sostituiti con 0e 1nei casi di test.

Provalo online! con il -Qflag per formattare l'output dell'array.

Soluzione 0 indicizzata, 11 byte

l o f@gX ¶V

Provalo online!

Perl 6 , 21 byte

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

Provalo online!

L' :kavverbio grepindica che restituisce i tasti corrispondenti (indici) della sequenza di input che corrispondono al predicato* === $^v .

Se stringhe e numeri fossero considerati equivalenti, si potrebbe usare un predicato grep di just $^vinvece di * === $^v.

Lisp comune, 66 byte

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

Provalo online!

TXR Lisp , 26 byte

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

In altre parole, "Dov'è l'argomento 2 uguale all'argomento 1?"

Correre:

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 byte

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

Un po 'oscuro :) Il primo argomento di input è uno vecdi valori e il secondo è il valore cercato. %associa gli indici ai valori e l'insieme #{%2}restituisce verità (l'argomento di input %2) o falsa nilper quel valore. comp compone questi insieme.

C 340 362 166 115 byte

Ciao a tutti. La mia prima volta qui. Ho pensato che da quando mi piace (tentando) di scrivere un codice ottimizzato, potrei anche provarlo.

@Rodney - ~ 39 byte dalle inclusioni

@ Zacharý - 7 byte con digitazione implicita

0 indicizzato .

Come eseguire:

Come suggerito da @Arnolds, il programma prende argomenti in modo molto più amichevole. Questo mi consente di ridurre la dimensione del file di poco più della metà.

Gli argomenti devono essere passati nel seguente ordine in value [element1 ...] cui le parentesi graffe indicano argomenti facoltativi

Potrebbe essere necessario o meno aggiungere virgolette di escape a qualsiasi stringa fornita per soddisfare la condizione di 12 != "12". Sul mio sistema questo può essere fatto nel modo seguente

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

ungolfed

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