Search a list: Difference between revisions

{{trans|Python}}

 

 

L(needle) (‘Washington’, ‘Bush’)

print(haystack.index(needle)‘ ’needle)

X.catch ValueError

 

{{out}}

 

=={{header|ACL2}}==

(cond ((endp xs) nil)

((equal e (first xs)) i)

 

(defun index-of (e xs)

 

=={{header|ActionScript}}==

===Using the built-in Error class===

function lowIndex(listToSearch:Vector.<String>, searchString:String):int

{

throw new Error("String not found: " + searchString);

return index;

 

===Using a custom error===

In StringNotFoundError.as:

public class StringNotFoundError extends Error {

public function StringNotFoundError(message:String) {

}

}

In a separate file:

var list:Vector.<String> = Vector.<String>(["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Boz", "Zag"]);

function lowIndex(listToSearch:Vector.<String>, searchString:String):int

return index;

}

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

Check ("Washington");

Check ("Bush");

{{out}}

<pre>

 

=={{header|Aime}}==

search(list l, text s)

{

 

return 0;

{{out}}

<pre>Bush is at 4

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

FILE needle exception; STRING ref needle;

end on value error: reset(needle exception)

OD

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

PROC index = ([]STRING hay stack, STRING needle)INT:(

FI

OD

{{out}}

<pre>

 

=={{header|Arturo}}==

 

loop [Bush Washington] 'needle [

if? empty? i -> panic ~"|needle| is not in haystack"

else -> print [i needle]

 

{{out}}

 

=={{header|AutoHotkey}}==

needle = bush, washington

Loop, Parse, needle, `,

Else

MsgBox % A_LoopField . " not in haystack"

 

=={{header|AWK}}==

In the following implementation we can reach the strings by numeric index with the array <code>haystack_byorder</code> (so, e.g. <code>haystack_byorder[4]</code> gives Bush), and know the "position" of the needle (if it exists) using it as string index for the array <code>haystack</code>, as example does. ('''Beware''': this method does not work when there are duplicates!)

 

BEGIN {

# create the array, using the word as index...

print "Washington is not here";

}

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

DATA foo, bar, bletch, foo, bar, fum, fred, jim, sheila, barney, flarp, zxc

DATA spqr, wombat, shme, foo, bar, baz, bongo, spam, eggs, snork, foo, bar

EXIT DO

END IF

 

{{out}}

Word to search for? (Leave blank to exit)

</pre>

 

==={{header|IS-BASIC}}===

110 STRING A$(1 TO 55)*8

120 FOR I=1 TO 55

240 LOOP

250 DATA foo,bar,baz,quux,quuux,quuuux,bazola,ztesch,foo,bar,thud,grunt,foo,bar,bletch,foo,bar,fum,fred,jim,sheila,barney,flarp,zxc

 

=={{header|Batch File}}==

The index of this simple implementation is 1-based. The "haystack" data are borrowed from the [[Search_a_list#BASIC|BASIC]] implementation.

setlocal enabledelayedexpansion

 

%==We are done==%

echo.

{{Out}}

<pre>"foo": Found 6 times. First instance:[1] Last instance:[35].

Press any key to continue . . .</pre>

 

 

=={{header|Bracmat}}==

For both subtasks, pattern matching is used. The second subtasks proceeds in two steps. First, the first word that occurs twice is found (if it exists). Then, the last occurrence of this word is found using forced backtracking (see the <code>~</code> node) until failure.

occurrences in the haystack and print the needle

: ?list

| out$"No word occurs more than once."

)

{{out}}

<pre>The word 'haystack' occurs at 1-based index 14

=={{header|Burlesque}}==

 

 

If you want all indices:

 

 

=={{header|C}}==

 

#include <string.h>

 

printf("Last index for Zag: %d\n", search_last_needle("Zag", haystack));

return 0;

 

{{out}}

=={{header|C sharp|C#}}==

 

using System.Collections.Generic;

 

}

}

 

=={{header|C++}}==

The following code shows three different ways to solve the task.

 

#include <algorithm>

#include <iterator>

std::cout << "\n=== Word not occuring at all ===\n";

test("Goofy");

 

{{out}} (note that in C++, indices start at 0):

=== C++11 ===

{{works with|g++ version 4.8.4, clang++ version 3.4| "-std=c++11" }}

* list class

* initialization strings

} // main

 

{{out}}

<pre>

 

=={{header|Ceylon}}==

value haystack = [

"Zig", "Zag", "Wally", "Ronald", "Bush",

assertEquals(firstIdx, 4);

assertEquals(lastIdx, 7);

 

=={{header|Clojure}}==

(let [idx (.indexOf haystack "Zig")]

(if (neg? idx)

(throw (Error. "item not found."))

 

Extra credit: Since Clojure vectors implement java.util.List, you can switch .indexOf for .lastIndexOf to find the highest index of your value.

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. Search-List.

DISPLAY "Found last of " needle " at " haystack-index "."

END-IF

 

{{out}}

 

=={{header|Common Lisp}}==

(dolist (needle '(Washington Bush))

(let ((index (position needle haystack)))

(if index

(progn (print index) (princ needle))

{{out}}

<pre>

</pre>

The position function solves this task elegantly.

CL-USER> (defparameter *list* '(Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo))

*LIST*

7

CL-USER> (position 'Washington *list*)

 

=={{header|D}}==

 

auto firstIndex(R, T)(R hay, T needle) {

assert(firstIndex(h, "Bush") == 4);

assert(lastIndex(h, "Bush") == 7);

 

=={{header|Delphi}}==

 

 

{$APPTYPE CONSOLE}

list.Free;

end;

{{out}}

<pre>

=={{header|DWScript}}==

 

 

function Find(what : String) : Integer;

 

PrintLn(Find("Ronald")); // 3

 

=={{header|E}}==

 

 

/** meet the 'raise an exception' requirement */

 

println(find("Ronald")) # prints 3

 

=={{header|Elena}}==

import extensions;

var haystack := new string[]{"Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Bozo"};

{

if (index == -1)

}

}

 

=={{header|Elixir}}==

 

Enum.each(~w(Bush Washington), fn needle ->

if index, do: (IO.puts "#{index} #{needle}"),

else: raise "#{needle} is not in haystack\n"

 

{{out}}

Erlang lists can be accessed with the function lists:nth/2, which starts at 1 (first element). As such Erlang can be considered 1-indexed for this problem.

Note that you could set the indexing to 0 by modifying the function call in pos/2.

-export([main/0]).

 

 

print({Needle, undefined}) -> io:format("~s is not in haystack.~n",[Needle]);

 

{{out}}

The procedure can be made into a function to search with other strings, take user input and give output of the searched haystack.

 

include std/search.e

include std/console.e

--wait for user to press a key to exit

any_key()

 

{{out}}

 

=={{header|F_Sharp|F#}}==

// A System.Collections.Generic.KeyNotFoundException

// is raised, if the predicate does not evaluate to

 

=={{header|Factor}}==

'[ _ = ] find drop [ "Not found" throw ] unless* ; inline

 

: find-last-index ( seq elt -- i )

 

( scratchpad ) { "a" "b" "c" "d" "c" } "c" find-index .

=={{header|Forth}}==

{{works with|4tH|3.61.5}}

 

create haystack

;

 

 

 

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

s" Hillary" haystack LastIndexOf . \ => 7

s" Washington" haystack needleIndex . \ => aborted: Not found

 

=={{header|Fortran}}==

 

 

implicit none

end subroutine find_needle

 

 

 

 

 

 

{{out}}

<pre>

</pre>

 

=={{header|GAP}}==

haystack := Eratosthenes(10000);;

needle := 8999;;

# 1

LastPosition(a, 0);

See also [[Sieve of Eratosthenes#GAP|Eratosthenes]] and [[Knuth shuffle#GAP|Shuffle]] functions in RosettaCode.

 

=={{header|Go}}==

Data used by both examples below. (You can give multiple files to go run, like <tt>$ go run data.go example.go</tt>)

 

var haystack = []string{"Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty",

"zork", "gork", "bork", "sodium", "phosphorous", "californium",

"copernicium", "gold", "thallium", "carbon", "silver", "gold", "copper",

===Linear search===

 

import "fmt"

}

return -1

{{out}}

<pre>

===Map lookup===

More efficient, if you're doing lots of lookups, is to build a map. This example doesn't completely conform to the task but gives the idea that you could store indexes as map values.

 

import "fmt"

fmt.Println(n, m[n])

}

{{out}}

<pre>

 

=={{header|Groovy}}==

def needles = ["Washington","Bush","Wally"]

needles.each { needle ->

println "Last index: " + lastindex + " " + needle

}

 

{{out}}

=={{header|Haskell}}==

Libraries and data:

 

haystack=["Zig","Zag","Wally","Ronald","Bush","Krusty","Charlie","Bush","Bozo"]

I use 'lambda' notation for readability.

:Find 'just' an index:

Want to know if there are there more Bushes hiding in the haystack?

To be complete. Here is the 'point free' version of the task:

 

=={{header|HicEst}}==

CHARACTER needle*10

 

WRITE(ClipBoard) "Last ", needle, "found in position ", last

! Last bush found in position 8

 

=={{header|Icon}} and {{header|Unicon}}==

link lists

 

every i := p!arglist

return \i

 

{{libheader|Icon Programming Library}}

Taken from the public domain Icon Programming Library's [http://www.cs.arizona.edu/icon/library/src/procs/lists.icn lindex in lists] which generates list indices for x of any type

local i

 

if lst[i] === x then suspend i

 

 

{{out}}

List has a <code>indexOf</code> method which does not raise an exception on lookup failure but returns <code>nil</code> therefore I extend List with a <code>firstIndex</code> method that does raise an exception. I also create a <code>lastIndex</code> extension that finds the last index of a matching object by iterating in reverse over the list. Note that all these methods find any object not just strings.

 

List firstIndex := method(obj,

indexOf(obj) ifNil(NotFound raise)

writeln(needle," is not in haystack")

)pass

{{out}}

<pre>firstIndex("Washington"): Washington is not in haystack

For example:

 

Needles =: ;:'Washington Bush'

9 4

Haystack i: Needles NB. last positions

 

Note that the arguments to <code>i.</code> can be anything (ie either or both may be scalars, lists, multidimensional arrays, etc). Nonmatches get a result of 1+largest valid index.

<code>e.</code> finds whether items are members of a set, returning a bitmask to select the members:

 

0 1

1 2 3 4 5 6 7 8 9 e. 2 3 5 60

 

<code>I.</code> finds indices, but performs a binary search (which requires that the list being searched is sorted). This can be useful for finding non-exact matches (the index of the next value is returned for non-exact matches).

 

1 2 4 9 6

(;:'eight five four nine one seven six three two') I. ;:'two three five sixty'

 

To format output similar to the other examples, one might write:

 

Washington is not in haystack

 

Or broken up into components and defined as a verb/function for finding the last positions:

idxmissing=: #@[ I.@:= ] NB. indices of items not found

fmtdata=: 8!:0@] NB. format atoms as boxed strings

Haystack findLastIndex Needles NB. usage

Washington is not in haystack

 

To elaborate a bit: Array-oriented languages (like J) consume the input and produce the output ''in toto''.

=={{header|Java}}==

for Lists, they have an indexOf() method:

import java.util.Arrays;

 

else

System.out.println(index + " " + needle);

 

for arrays, you have to do it manually:

String[] haystack = { "Zig","Zag","Wally","Ronald","Bush","Krusty","Charlie","Bush","Bozo"};

else

System.out.println(index + " " + needle);

 

{{out}}

 

=={{header|JavaScript}}==

var needles = ['Bush', 'Washington']

 

else

throw needles[i] + " does not appear in the haystack"

 

The following {{works with|JavaScript|1.6}}:

var idx = haystack.indexOf(needle);

if (idx == -1)

break

}

 

 

Or, generalising enough (in ES5) to allow for varying definitions of the type of match we are looking for:

 

 

function findIndex(fnPredicate, list) {

})

}

 

Output:

 

"first": [

[

]

]

 

=={{header|jq}}==

 

In the following, the output is shown after the "# =>":

["a","b","c"] | index("b")

# => 1

 

["a","b","c","b","d"] | indices("b")[-1]

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

@show indexin(["yes"], ["no", "?", "yes", "maybe", "yes"])

@show findin(["no", "?", "yes", "maybe", "yes"], ["yes"])

 

{{out}}

 

=={{header|K}}==

Needles:("Washington";"Bush")

 

{{out}}

"Not Found")

("Bush"

 

Additional:

Here we use the dyadic verb _sm (string match) instead of _bin (binary search).

 

Needles2:Needles,,"Zag"

 

{{out}}

"Not found")

("Bush"

4 9)

("Zag"

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

index = haystack.indexOf(needle)

if (index == -1) throw Exception("$needle does not occur in the list")

 

{{out}}

 

=={{header|Lang5}}==

: find-index

2dup eq length iota swap select swap drop

: ==>search apply ;

 

{{out}}

<pre>[ hello is not in haystack

Lasso arrays have a findindex method which returns all matching indexes. [http://lassoguide.com/operations/containers.html?#array]

 

 

#haystack->findindex('Bush')->first // 5

handle_error => {^ error_msg ^}

fail_if(not #haystack->findindex('Washington')->first,'Washington is not in haystack.')

 

{{out}}

8

Washington is not in haystack.</pre>

 

=={{header|Lingo}}==

needle = "oranges"

 

end if

 

 

=={{header|Lisaac}}==

haystack := "Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo".split;

"Washington Bush".split.foreach { needle : STRING;

" is not in haystack\n".print;

};

 

=={{header|Logo}}==

if empty? :list [(throw "NOTFOUND 0)]

if equal? :item first :list [output 1]

 

showindex "dog [My dog has fleas] ; dog found at position 2 in My dog has fleas

 

=={{header|Lua}}==

 

item = io.read()

for i,v in ipairs(list)

if v == item then print(i) end

 

=={{header|M2000 Interpreter}}==

Normally we use Exist(inventoryA, "key") and if it is true then we get the value as Eval(inventoryA) without using second search, by temporary use of an index. We can read that index by making a variable to bind a property of COM object (the object under the inventory).

 

Module Checkit {

Flush ' empty stack

}

CheckIt

 

Extra-Extra: Find all occurrences displaying the indexes for each one.

 

Module CheckThis {

Inventory Queue Haystack= "foo", "bar", "baz", "quux", "quuux", "quuuux", "bazola", "ztesch", "foo", "bar", "thud", "grunt"

}

CheckThis

 

=={{header|Maple}}==

occurences := ListTools:-SearchAll(needle,haystack):

try

catch :

print("Erros: Needle not found in the haystack"):

{{Out|Examples}}

needle := "Washington":

The last occurence is at index 8</pre>

 

This examples shows you the first appearance, the last appearance, and all appearances (as a list):

needle = "Zag";

first = Position[haystack,needle,1][[1,1]]

last = Position[haystack,needle,1][[-1,1]]

gives back:

7

 

=={{header|MATLAB}}==

 

searchCollection.m:

%firstLast is a string containing either 'first' or 'last'. The 'first'

assert(~isempty(index),['The string ''' searchItem ''' does not exist in this collection of strings.']);

 

 

{{out}}

>> searchCollection(list,'c','first')

 

>> searchCollection(list,'g','last')

??? Error using ==> searchCollection at 11

 

=={{header|Maxima}}==

needle: "Zag";

 

if emptyp(opt) then return(idx),

opt: first(opt),

 

{{out|Usage}}

 

=={{header|MAXScript}}==

 

for needle in #("Washington","Bush") do

format "% %\n" index needle

)

 

{{out}}

 

=={{header|Nanoquery}}==

{{trans|Python}}

append $haystack "Zig" "Zag" "Wally" "Ronald" "Bush" "Krusty" "Charlie"

append $haystack "Bush" "Bozo"

println $needle + " is not in haystack"

end

{{out}}

<pre>Washington is not in haystack

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

end needle

{{out}}

<pre>

 

=={{header|Nim}}==

 

for needle in ["Bush", "Washington"]:

echo f, " ", needle

else:

 

=={{header|Objeck}}==

 

class Test {

};

}

 

=={{header|Objective-C}}==

{{works with|Objective-C|2.0+}}

for (id needle in @[@"Washington",@"Bush"]) {

int index = [haystack indexOfObject:needle];

else

NSLog(@"%i %@", index, needle);

 

=={{header|OCaml}}==

let rec loop n = function

[] -> raise Not_found

Washington is not in haystack

4 Bush

 

=={{header|Oforth}}==

indexOf returns null if an object is not into a collection, not an exception.

 

haystack indexOf(needle) dup ifNull: [ drop ExRuntime throw("Not found", needle) ] ;

 

needleIndex("Bush", Haystack) println

Haystack lastIndexOf("Bush") println

 

{{out}}

For ordered collections, this will always be the first item.

For unordered collections, the index returned is undetermined.

a = .array~of(1,2,3,4,4,5)

say a~index(4)

d["foo"] = 4

d["bar"] = 4

 

=={{header|Oz}}==

(the operation is quite inefficient, after all).

A possible implementation:

%% Lazy list of indices of Y in Xs.

fun {Indices Y Xs}

{Show {List.last {Indices "Bush" Haystack}}}

 

 

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.3 and above}}

my(i=setsearch(v,n));

if(i,

);

i

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

my @haystack = qw(Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo);

print "$needle is not in haystack\n";

}

{{out}}

<pre>

 

You could install a non-standard module List::MoreUtils:

 

my @haystack = qw(Zig Zag Wally Ronald Bush Krusty Charlie Bush Bozo);

print "$needle is not in haystack\n";

}

 

Alternatively, if you need to do this a lot, you could create a hash table mapping values to indices in the haystack:

 

my %haystack_indices;

print "$needle is not in haystack\n";

}

{{out}}

<pre>

 

=={{header|Phix}}==

 

=={{header|Phixmonti}}==

"soap" "methamphetamine" "severed cat heads" "cup"

pstack

endif

endif

 

Other solution with syntactic sugar for list construction.

 

 

0 var acum

search

endwhile

 

=={{header|PHP}}==

 

foreach (array("Washington","Bush") as $needle) {

else

echo "$i $needle\n";

{{out}}

<pre>

4 Bush

</pre>

 

=={{header|PicoLisp}}==

Note that in PicoLisp all indexes are one-based

(the first element has the position '1')

(- (length Lst) (index Item (reverse Lst)) -1) )

 

(findNeedle index 'Washington Lst)

(findNeedle index 'Bush Lst)

{{out}}

<pre>Washington not found

 

=={{header|PL/I}}==

declare haystack (0:9) character (200) varying static initial

('apple', 'banana', 'celery', 'dumpling', 'egg', 'flour',

signal condition(missing_needle);

return (lbound(haystack,1)-1);

 

=={{header|Plain English}}==

Start up.

Make an example haystack.

Put the bale's next into the bale.

Bump the count.

{{out}}

<pre>

The index of "b" is 2

</pre>

 

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

function index($haystack,$needle) {

$index = $haystack.IndexOf($needle)

index $haystack "house"

index $haystack "paragraph"

<b>Output:</b>

<pre>

===PowerShell Extra credit===

The -Verbose switch is available to any advanced function.

function Find-Needle

{

 

$haystack = @("word", "phrase", "preface", "title", "house", "line", "chapter", "page", "book", "house")

Find-Needle "house" $haystack

{{Out}}

<pre>

4

</pre>

Find-Needle "house" $haystack -Verbose

{{Out}}

<pre>

4

</pre>

Find-Needle "house" $haystack -LastIndex -Verbose

{{Out}}

<pre>

9

</pre>

Find-Needle "title" $haystack -LastIndex -Verbose

{{Out}}

<pre>

3

</pre>

Find-Needle "something" $haystack -Verbose

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog

L = ["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Boz", "Zag"],

 

my_write(Name) :-

writef(' %s', [Name]).

 

{{out}}

true.

</pre>

 

=={{header|Python}}==

 

for needle in ("Washington","Bush"):

print haystack.index(needle), needle

except ValueError, value_error:

{{out}}

<pre>

The following shows the default information given

when the exception is not captured in the program:

>>> haystack.index('Bush')

4

haystack.index('Washington')

ValueError: list.index(x): x not in list

 

There is no built-in method for returning the highest index of a repeated string in a Python list, tuple or array, (although strings have [http://docs.python.org/library/stdtypes.html?highlight=rindex#str.rindex rindex]).

Instead we need to look for the index in the reversed list and adjust the result.

return len(haystack)-1 - haystack[::-1].index(needle)

 

assert hi == haystack.index(n), "index == hi_index if needle occurs only once"

 

 

=={{header|R}}==

{

indices <- which(haystack %in% needle)

if(length(indices)==0) stop("no needles in the haystack")

if(return.last.index.too) range(indices) else min(indices)

Example usage:

haystack2 <- c("no", "sewing", "equipment", "in", "here")

haystack3 <- c("oodles", "of", "needles", "needles", "needles", "in", "here")

find.needle(haystack2) # error

find.needle(haystack3) # 3

 

=={{header|Racket}}==

The function index returns the index of the the element x in the sequence xs.

If the element is not found, then #f is returned.

(for/first ([(x i) (in-indexed xs)]

#:when (equal? x y))

 

If the last index of an element is needed, for/last is used:

(for/last ([(x i) (in-indexed xs)]

#:when (equal? x y))

 

Both index and index-last can handle any sequence such as lists, vectors, sets etc.

Let us test with a linked list:

 

(for/list ([needle '("Bender" "Bush")])

 

(for/list ([needle '("Bender" "Bush")])

{{out}}

<pre>

 

{{works with|Rakudo Star|2016.07}}

for <Washington Bush> -> $needle {

say "$needle -- { @haystack.first($needle, :k) // 'not in haystack' }";

 

{{out}}

Or, including the "extra credit" task:

{{works with|Rakudo Star|2016.07}}

 

for <Washingston Bush> -> $needle {

say "$needle -- not in haystack";

}

 

{{out}}

<br>

If you plan to do many searches on the same large list, you might want to build a search hash first for efficient look-up:

 

my %index;

for <Washington Bush> -> $needle {

say "$needle -- { %index{$needle} // 'not in haystack' }";

 

=={{header|REBOL}}==

Title: "List Indexing"

URL: http://rosettacode.org/wiki/Index_in_a_list

reform [needle "=>" locate/largest haystack needle]

]

 

{{out}}

<br><br>The haystack items may have any character, including blanks.

<br>A ''null'' value isn't allowed in this method of representing values.

hay.= /*initialize the haystack collection. */

hay.1 = 'sodium'

if found then return j /*return the haystack index number. */

else say needle "wasn't found in the haystack!"

 

===version 2===

this counter may be any sufficiently high number.

<br><br>The array may be out of order (but not recommended!).

hay.0 = 1000 /*safely indicate highest item number. */

hay.200 = 'Binilnilium'

if found then return j /*return the haystack index number. */

else say needle "wasn't found in the haystack!"

 

===version 3===

<br>variable names. Therefore, there shouldn't be any REXX variable names (in this

<br>program) that have a leading underscore &nbsp; ('''_''').

hay.=0 /*initialize the haystack collection. */

hay._sodium = 1

if found then return j /*return the haystack index number. */

else say needle "wasn't found in the haystack!"

 

===version 4===

This method uses a simple string (so haystack items can't have embedded blanks or tabs in them).

<br>Code was added to uppercase both the &nbsp; '''haystack''' &nbsp; and the &nbsp; '''needle''' &nbsp; to make the search &nbsp; ''case insensitive''.

/*───────────────names of the first 200 elements of the periodic table.─────────────*/

_= 'hydrogen helium lithium beryllium boron carbon nitrogen oxygen fluorine neon sodium'

else say needle "wasn't found in the haystack!"

return 0 /*indicates the needle wasn't found. */

 

=={{header|Ring}}==

haystack = ["alpha","bravo","charlie","delta","echo","foxtrot","golf",

"hotel","india","juliet","kilo","lima","mike","needle",

if !=index see " last found at index " + last + nl

else see "not found" + nl ok

Output:

<pre>

first found at index : 14

last found at index : 22

</pre>

 

=={{header|Ruby}}==

 

%w(Bush Washington).each do |needle|

raise "#{needle} is not in haystack\n"

end

{{out}}

<pre>

 

'''Extra credit'''

last = haystack.rindex(item)

if last > haystack.index(item)

end

end

or

# multi_item is => {"Bush"=>[4, 7]}

multi_item.each do |key, val|

puts "#{key} appears at index #{val}"

end

 

=={{header|Rust}}==

Rust encourages to encode possible errors in function's return type. For example, <code>position</code> returns <code>Option<usize></code>, which can be <code>None</code> or <code>Some(x)</code>.

 

let haystack=vec!["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie",

"Bush", "Boz", "Zag"];

println!("First occurence of 'Rob' at {:?}",haystack.iter().position(|s| *s=="Rob"));

}

 

{{out}}

===Version that panics===

 

let haystack=vec!["Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie",

"Bush", "Boz", "Zag"];

println!("First occurence of 'Rob' at {:?}",haystack.iter().position(|s| *s=="Rob").unwrap());

}

 

{{out}}

 

=={{header|S-lang}}==

define find(needle)

($1, $2) = find("Ronald"); % returns 3, 9

($1, $2) = find("McDonald"); % throws ApplicationError, labelled "an exception"

 

=={{header|Sather}}==

{{trans|C_sharp}}

 

main is

haystack :ARRAY{STR} := |"Zig", "Zag", "Wally", "Ronald", "Bush", "Krusty", "Charlie", "Bush", "Bozo"|;

end;

end;

 

=={{header|Scala}}==

not using those or similar methods might be written like this:

 

def firstNeedle(needle: String, haystack: Seq[String]) = findNeedles(needle, haystack).head

 

It does raise an exception if there's no needle.

 

=={{header|Scheme}}==

'("Zig" "Zag" "Wally" "Ronald" "Bush" "Krusty" "Charlie" "Bush" "Bozo"))

 

(if tail

(- (length tail) 1)

{{out}}

<pre>

 

=={{header|SenseTalk}}==

put ("apple", "banana", "cranberry" ,"durian", "eggplant", "grape", "banana", "appl", "blackberry") into fruitList

 

end if

end findInList

Note: Sensetalk indexes from 1

 

=={{header|Sidef}}==

 

%w(Bush Washington).each { |needle|

die "#{needle} is not in haystack";

}

{{out}}

<pre>

</pre>

Extra credit:

{{out}}

<pre>

 

=={{header|Slate}}==

{'Washington'. 'Bush'} do: [| :needle |

(haystack indexOf: needle)

lastIndex: (haystack lastIndexOf: word).

lastIndex isNotNil /\ (lastIndex > firstIndex) ifTrue:

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}{{works with|Smalltalk/X}}

Notice: Smalltalk indexes start at 1.

haystack := 'Zig,Zag,Wally,Ronald,Bush,Krusty,Charlie,Bush,Bozo' subStrings: $,.

{ 'Washington' . 'Bush' } do: [:word |

('last occurence of %1 is at index %2' % { word . l }) displayNl ]

]

the above example did not raise an exception; the following does (a handler has been added to proceed for more search words):

{{works with|Smalltalk/X}}

Notice: the code below uses the ST/X embedded-expression-string extension.

haystack := 'Zig,Zag,Wally,Ronald,Bush,Krusty,Charlie,Bush,Bozo' subStrings: $,.

[

'but I don''t care and proceed...' printCR.

ex proceed.

{{out}}

<pre>not found exception raised for: Washington

=={{header|Standard ML}}==

 

fun loop (n, []) = NONE

| loop (n, x::xs) = if pred x then SOME n

SOME i => print (Int.toString i ^ " " ^ needle ^ "\n")

| NONE => print (needle ^ " is not in haystack\n"))

 

=={{header|Swift}}==

{{works with|Swift|2.x+}}

for needle in ["Washington","Bush"] {

if let index = haystack.indexOf(needle) {

print("\(needle) is not in haystack")

}

{{works with|Swift|1.x}}

for needle in ["Washington","Bush"] {

if let index = find(haystack, needle) {

println("\(needle) is not in haystack")

}

 

The second task:

{{works with|Swift|2.x+}}

 

// the second part can be done several ways, but extending any Array of Comparable objects is the most generic approach

extension Array where Element : Comparable {

 

 

 

=={{header|Tcl}}==

foreach needle {Bush Washington} {

if {[set idx [lsearch -exact $haystack $needle]] == -1} {

puts "$needle appears at index $idx in the haystack"

}

'''Extra credit:'''

foreach needle {Bush Washington} {

set indices [lsearch -all -exact $haystack $needle]

puts "$needle appears first at index [lindex $indices 0] and last at [lindex $indices end]"

}

 

=={{header|TorqueScript}}==

Find multiple needles in a haystack:

 

{

%hc = getWordCount(%haystack);

return %string;

 

How to use it:

 

 

returns:

 

 

=={{header|TUSCRIPT}}==

SET haystack="Zig'Zag'Wally'Ronald'Bush'Krusty'Charlie'Bush'Bozo"

PRINT "haystack=",haystack

ENDIF

RELEASE S_TABLE needle

 

{{out}}

{{works with|pdksh}}

{{works with|Z Shell}}

haystack="Zip Zag Wally Ronald Bush Krusty Charlie Bush Bozo"

 

echo "The greatest index for $1 is: $greatest_index";fi

else echo $1 is absent from haystatck.;fi

 

{{out}}

If it's not present, an exception is thrown with a diagnostic message of 'missing'.

The search is expressed by <code>~|</code>, the built-in distributing filter operator.

 

The explanation is somewhat longer than the program.

* The <code>^|</code> operator takes a right operand consisting of a pair of functions <math>(f,g)</math>, and returns a function that takes a pair <math>(x,y)</math> to the result <math>(f(x),g(y))</math>.

 

Test program:

 

{{out}}

<pre>(1,3)</pre>

 

=={{header|VBA}}==

Optional start As Integer = 1, Optional reverse As Boolean = False) As Long

'Adapted from https://stackoverflow.com/questions/12414168/use-of-custom-data-types-in-vba

End If

Next i

Bush is at position 5. And last position is 8.</pre>

 

=={{header|VBScript}}==

Shamelessly derived from the BASIC version.

data = "foo,bar,baz,quux,quuux,quuuux,bazola,ztesch,foo,bar,thud,grunt," &_

"foo,bar,bletch,foo,bar,fum,fred,jim,sheila,barney,flarp,zxc," &_

End If

Loop

{{out}}

<pre>F:\VBScript>cscript /nologo search_a_list.vbs

 

F:\VBScript></pre>

 

=={{header|Wart}}==

Wart uses the function <code>pos</code> to search a list for an element.

Here's how it's implemented:

default n :to 0

if seq

if (head = x)

n

 

{{out|Usage}}

=={{header|Wren}}==

{{libheader|Wren-seq}}

 

var find = Fn.new { |haystack, needle|

System.print("The needle is %(needle).")

find.call(haystack, needle)

 

{{out}}

 

=={{header|XPL0}}==

include c:\cxpl\stdlib; \provides StrCmp routine, etc.

int Haystack; \('int' is used instead of 'char' for 2D array)

Text(0, "First index for Zag: "); IntOut(0, Search("Zag", true)); CrLf(0);

Text(0, "Last index for Zag: "); IntOut(0, Search("Zag", false)); CrLf(0);

 

{{out}}

Last index for Zag: 9

</pre>

 

=={{header|Yorick}}==

needles = ["Bush", "Washington"];

for(i = 1; i <= numberof(needles); i++) {

if(numberof(w) > 1)

write, format="Needle %s appears last at index %d\n", needles(i), w(0);

 

=={{header|zkl}}==

Find last needle:

haystack.filterNs('==("Bozo"))[-1]; // -->3, indexError if not found

Use a bit bucket of ASCIIZ strings

if((n:=haystack.findString("Charlie")) != Void) n else throw(Exception.IndexError);