Mein Chef möchte jetzt, dass ich einen Mechanismus implementiere, mit dem er nach einem Element in einem Array suchen und ihm den Index / die Indizes geben kann, in denen dieser Wert vorkommt.

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, die ein Array und einen Wert (String, Integer, Float oder Boolean) empfängt, und geben Sie die Indizes des Arrays zurück, an dem der Wert auftritt (entweder 0 oder 1 indiziert, je nachdem, was Sie bevorzugen). Wenn der Wert nicht im Array enthalten ist, geben Sie ein leeres Array zurück.

Eingang:

Ein Array A und ein Wert V, die in A vorhanden sein können oder nicht.

Ausgabe:

Ein Array, das die Indizes enthält, bei denen V in A vorkommt, oder, falls V in A nicht vorkommt, ein leeres Array.

Testfälle:

Bitte beachten Sie, dass die Testfälle auf 0 basieren.

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]

Wertung:

Das ist Code-Golf , also gewinnt die niedrigste Punktzahl in Bytes.

Pyth , 2 Bytes

0-indiziert.

xE

Probieren Sie es online! oder Überprüfen Sie alle Testfälle

Erläuterung

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

Das mkonsumiert zwei Argumente und prüft jedes Element im Array, ob es dem anderen Argument entspricht. Es fgibt die Indizes der wahrheitsgemäßen Einträge eines Arrays zurück.

Probieren Sie es online!

Python 3 , 45 Bytes

-3 Bytes dank @EriktheOutgolfer und @Chris_Rands

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

Test Suite.

Heute habe ich gelernt 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]

Probieren Sie es online! oder Überprüfen Sie alle Testfälle

R (+ Pryr), 20 Bytes

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

Welches zur Funktion auswertet

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

Wobei entweder ader zu suchende Wert und bder Vektor sein können oder umgekehrt. Wenn zwei Vektoren ungleicher Länge angezeigt werden (ein einzelner Wert zählt als ein Vektor der Länge 1 in R), wird R den kürzeren Vektor so umschließen, dass er der Länge des längeren Vektors entspricht. Dann wird die Gleichheit geprüft. Dies erzeugt einen logischen Vektor. whichLiefert die Indizes, bei denen dieser Vektor wahr ist.

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

Das obige Snippet funktioniert möglicherweise nicht in allen Browsern. Hier ist ein TIO-Link .

JavaScript (ES6), 44 43 Byte

^{Durchgestrichen 44 ist immer noch regulär 44; (}

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

1 Byte dank @Arnauld gespeichert

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Ï

Probieren Sie es online!

1-indiziert.

C # 88 72 Bytes

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

16 Bytes dank @LiefdeWen eingespart.

Probieren Sie es online!

Gelee , 3 Bytes

⁼€T

Probieren Sie es online!

-1 Danke an Herrn Xcoder . (dyadische Ketten)

Haskell , 41 39 Bytes

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

Probieren Sie es online!

Zwei Bytes dank @flawr gespart

Haskell ist statisch typisiert, daher musste ich die Testfälle mit einer kleinen Umgehungslösung ausführen.

Schale , 5 Bytes

`fNm=

Probieren Sie es online! 1-indiziert.

Erläuterung

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

7 Bytes gespart !!! danke an Eric Duminil.

Probieren Sie es online aus.

Ruby, 38 Bytes

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

Probieren Sie es online!

Google Sheets, 101 Bytes

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

Wert Vin A1und Array Ain, B1wobei jeder Eintrag durch ein Komma getrennt ist. Null-Einträge sind nicht zulässig (Zeile 5 unten zeigt, was passiert).

Erläuterung:

Offset(A1,0,0,1,Counta(Split(B1,",")))Gibt einen Bereich zurück, der eine Zeile hoch und so viele Spalten breit ist, wie Einträge in vorhanden sind A1.

=IfError(Join(",",Filter(Column(~),Exact(Split(B1,","),A1))),"")filtert die Spaltennummern dieses Bereichs basierend darauf, ob der Wert in A1genau einem der Werte in entspricht, B1und verknüpft sie alle in einer durch Kommas getrennten Liste.

Clojure , 40 Bytes

Erster Versuch, Code Golf zu spielen.

keep-indexed ordnet hier eine Funktion einer Auflistung zu, übergibt den aktuellen Index an den Callback und gibt alle Nicht-Null-Rückgabewerte zurück.

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

Probieren Sie es online!

APL (Dyalog Unicode) , 2 Byte ^SBCS

Nimmt das zu suchende Element als linkes Argument (muss skalar sein, um ein Element des Lookup-Arrays anstelle eines Subarrays zu finden) und das Lookup-Array (das bis zu 15 Dimensionen haben kann) als rechtes Argument. Gibt eine Liste von Indizes zurück, von denen jeder so viele Elemente wie die Anzahl der Dimensionen im Nachschlage-Array haben kann.

⍸⍷

Probieren Sie es online!

⍸ Findet heraus, wo

⍷ gefunden

Batch, 86 Bytes

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

Übernimmt Eingaben als Befehlszeilenparameter (wertet dann die Array-Elemente als separate Parameter). Hinweis: Das Zitieren von Zeichenfolgen wird als Teil der Übereinstimmung betrachtet, z. B. "1"nicht gleich 1(würde 6 Byte kosten).

Python 2 , 49 Bytes

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

Probieren Sie es online!

Nicht kurz genug, aber ich fand es cool. ¯ \ _ (ツ) _ / ¯

Perl 5 , 28 Bytes

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

Probieren Sie es online!

Die Ausgabe ist 1-indiziert.
Eine anonyme Funktion ist für Perl ziemlich ungewöhnlich, aber es ist die kürzeste, die ich mir vorstellen kann. grep ..., 1 .. @_iteriert über die Indizes des Eingabearrays (tatsächlich geht es eine Zelle über die letzte hinaus, aber es spielt keine Rolle) und behält nur den Index bei, der erfüllt $_[$_]eq$_[0], d. h. Diejenigen, bei denen der Wert des Elements ( $_[$_]) dem Wert entspricht, den wir behalten müssen ( $_[0]).

Etwas länger (31 Bytes (30 + -lFlag)), aber als volles Programm:

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

Probieren Sie es online!

Haskell , 37 33 Bytes

import Data.List
findIndices.(==)

Danke @Laikoni für -4 Bytes!

Probieren Sie es 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 dank @TAsk mit Vectoranstelle von ArrayList.
-1 Byte mit Stackanstelle von Vector.
-2 Bytes dank @Jakob durch Eingabe von a ArrayListanstelle eines Arrays.

0-indiziert

Erläuterung:

Probieren Sie es hier aus.

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

Probieren Sie es online!

Es ist 1-indiziert, wie unten gezeigt:

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

Eingang [Array, Wert]

[{12, 14, 14, 2, "Hallo Welt!", 3, 12, 12}, 12]

Ausgabe

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

Haskell, 29 Bytes

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

Probieren Sie es online!

Japt , 9 Bytes

mȶV©YÄÃf

1-indiziert.

Die Japt-Eingabe unterstützt keine Booleschen Werte, daher wurden sie durch 0und 1in den Testfällen ersetzt.

Probieren Sie es online! mit dem -QFlag, um die Array-Ausgabe zu formatieren.

0-indizierte Lösung, 11 Bytes

l o f@gX ¶V

Probieren Sie es online!

Perl 6 , 21 Bytes

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

Probieren Sie es online!

Das :kAdverb to grepweist es an, die übereinstimmenden Schlüssel (Indizes) der Eingabesequenz zurückzugeben, die mit dem Prädikat übereinstimmen * === $^v.

Wenn Zeichenfolgen und Zahlen als gleichwertig angesehen würden, könnte man ein grep-Prädikat von just $^vanstelle von verwenden * === $^v.

Common Lisp, 66 Bytes

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

Probieren Sie es online!

TXR Lisp , 26 Bytes

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

Mit anderen Worten: "Wo ist Argument 2 gleich Argument 1?"

Lauf:

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

Ein bisschen dunkel :) Das erste Eingabeargument ist ein vecvon Werten und das zweite ist der gesuchte Wert. %ordnet Indizes Werten zu, und die Menge #{%2}gibt für diesen Wert " truthy" (das Eingabeargument %2) oder "falsy" zurück nil. comp setzt diese zusammen.

C 340 362 166 115 Bytes

Hallo alle. Mein erstes Mal hier. Ich dachte, da es mir Spaß macht (zu versuchen), optimierten Code zu schreiben, kann ich dies auch versuchen.

@ Rodney - ~ 39 Bytes aus dem Includes

@ Zacharý - 7 Bytes mit impliziter Eingabe

0-indiziert .

Wie man läuft:

Gemäß dem @Arnolds-Vorschlag nimmt das Programm Argumente auf eine viel C-freundlichere Art und Weise entgegen. Dadurch konnte ich die Größe der Datei um etwas mehr als die Hälfte reduzieren.

Die Argumente sollten in der folgenden Reihenfolge übergeben werden, value [element1 ...] wobei geschweifte Klammern optionale Argumente angeben

Möglicherweise müssen Sie den angegebenen Zeichenfolgen Anführungszeichen hinzufügen, um die Bedingung von zu erfüllen 12 != "12". Auf meinem System kann dies auf folgende Weise erfolgen

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

Golf gespielt

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