Jewels and stones: Difference between revisions

Content added Content deleted

Inline

Revision as of 23:00, 13 May 2022

Task

Create a function which takes two string parameters: 'stones' and 'jewels' and returns an integer.

Both strings can contain any number of upper or lower case letters. However, in the case of 'jewels', all letters must be distinct.

The function should count (and return) how many 'stones' are 'jewels' or, in other words, how many letters in 'stones' are also letters in 'jewels'.

Note that:

Only letters in the ISO basic Latin alphabet i.e. 'A to Z' or 'a to z' need be considered.
A lower case letter is considered to be different from its upper case equivalent for this purpose, i.e., 'a' != 'A'.
The parameters do not need to have exactly the same names.
Validating the arguments is unnecessary.

So, for example, if passed "aAAbbbb" for 'stones' and "aA" for 'jewels', the function should return 3.

This task was inspired by this problem.

Other tasks related to string operations:

Metrics

Counting

Remove/replace

Anagrams/Derangements/shuffling

Find/Search/Determine

Formatting

Song lyrics/poems/Mad Libs/phrases

Tokenize

Sequences

11l

Translation of: Python

<lang 11l>F count_jewels(s, j)

  R sum(s.map(x -> Int(x C @j)))

print(count_jewels(‘aAAbbbb’, ‘aA’)) print(count_jewels(‘ZZ’, ‘z’))</lang>

Output:

3
0

<lang 8080asm> org 100h jmp demo ;;; Count jewels. ;;; Input: BC = jewels, DE = stones. ;;; Output: BC = count ;;; Destroyed: A, DE, HL jewel: lxi h,jarr ; Zero out the page of memory xra a jzero: mov m,a inr l jnz jzero jrjwl: ldax b ; Get jewel inx b mov l,a ; Mark the corresponding byte in the array inr m ana a ; If 'jewel' is 0, we've reached the end jnz jrjwl ; Otherwise, do next jewel lxi b,0 ; BC = count (we no longer need the jewel string) jrstn: ldax d ; Get stone inx d ana a ; If zero, we're done rz mov l,a ; Get corresponding byte in array mov a,m ana a jz jrstn ; If zero, it is not a jewel inx b ; But otherwise, it is a jewel jmp jrstn ;;; Demo code demo: lxi b,jewels ; Set up registers lxi d,stones call jewel ; Call the function ;;; Print the number lxi h,num ; Pointer to number string push h ; Push to stack mov h,b ; HL = number to print mov l,c lxi b,-10 ; Divisor dgt: lxi d,-1 ; Quotient dgtlp: inx d ; Divide using trial subtraction dad b jc dgtlp mvi a,'0'+10 add l ; HL = remainder-10 pop h ; Get pointer dcx h ; Decrement pointer mov m,a ; Store digit push h ; Put pointer back xchg ; Go on with new quotient mov a,h ; If 0, we're done ana l jnz dgt ; If not 0, next digit pop d ; Get pointer and put it in DE mvi c,9 ; CP/M syscall to print string jmp 5 db '*****' ; Placeholder for ASCII number output num: db '$' ;;; Example from the task jewels: db 'aA',0 stones: db 'aAAbbbb',0 ;;; Next free page of memory is used for the jewel array jpage: equ $/256+1 jarr: equ jpage*256</lang>

Output:

8086 Assembly

<lang asm> cpu 8086 bits 16 org 100h section .text jmp demo ;;; Count jewels. ;;; Input: DS:SI = jewels, DS:DX = stones ;;; Output: CX = how many stones are jewels ;;; Destroyed: AX, BX, SI, DI jewel: xor ax,ax mov cx,128 ; Allocate 256 bytes (128 words) on stack .zloop: push ax ; Set them all to zero loop .zloop mov di,sp ; DI = start of array xor bh,bh .sjwl: lodsb ; Get jewel mov bl,al inc byte [ss:di+bx] ; Set corresponding byte test al,al ; If not zero, there are more jewels jnz .sjwl mov si,dx ; Read stones .sstn: lodsb ; Get stone mov bl,al ; Get corresponding byte mov bl,[ss:di+bx] add cx,bx ; Add to count (as word) test al,al ; If not zero, there are more stones jnz .sstn add sp,256 ; Otherwise, we are done - free the array dec cx ; The string terminator is a 'jewel', so remove ret ;;; Demo demo: mov si,jewels ; Set up registers mov dx,stones call jewel ; Call the function ;;; Print number mov ax,10 ; Result is in CX xchg ax,cx ; Set AX to result and CX to divisor (10) mov bx,num ; Number pointer dgt: xor dx,dx div cx ; Divide AX by 10 add dl,'0' ; Remainder is in DX - add ASCII 0 dec bx ; Store digit in string mov [bx],dl test ax,ax ; Any more digits? jnz dgt ; If so, next digit mov dx,bx ; When done, print string mov ah,9 int 21h ret section .data db '*****' ; Placeholder for ASCII number output num: db '$' stones: db 'aAAbbbb',0 ; Example from the task jewels: db 'aA',0</lang>

Output:

Ada

<lang Ada>with Ada.Text_IO;

procedure Jewels_And_Stones is

  function Count (Jewels, Stones : in String) return Natural is
     Sum : Natural := 0;
  begin
     for J of Jewels loop
        for S of Stones loop
           if J = S then
              Sum := Sum + 1;
              exit;
           end if;
        end loop;
     end loop;
     return Sum;
  end Count;

  procedure Show (Jewels, Stones : in String) is
     use Ada.Text_IO;
  begin
     Put (Jewels);
     Set_Col (12); Put (Stones);
     Set_Col (20); Put (Count (Jewels => Jewels,
                               Stones => Stones)'Image);
     New_Line;
  end Show;

begin

  Show ("aAAbbbb", "aA");
  Show ("ZZ",      "z");

end Jewels_And_Stones;</lang>

Output:

aAAbbbb    aA       3
ZZ         z        0

ALGOL 68

<lang algol68>BEGIN

   # procedure that counts the number of times the letters in jewels occur in stones #
   PROC count jewels = ( STRING stones, jewels )INT:
        BEGIN
            # count the occurences of each letter in stones #
            INT upper a pos = 0;
            INT lower a pos = 1 + ( ABS "Z" - ABS "A" );
            [ upper a pos : lower a pos + 26 ]INT letter counts;
            FOR c FROM LWB letter counts TO UPB letter counts DO letter counts[ c ] := 0 OD;
            FOR s pos FROM LWB stones TO UPB stones DO
                CHAR s = stones[ s pos ];
                IF   s >= "A" AND s <= "Z" THEN letter counts[ upper a pos + ( ABS s - ABS "A" ) ] +:= 1
                ELIF s >= "a" AND s <= "z" THEN letter counts[ lower a pos + ( ABS s - ABS "a" ) ] +:= 1
                FI
            OD;
            # sum the counts of the letters that appear in jewels #
            INT count := 0;
            FOR j pos FROM LWB jewels TO UPB jewels DO
                CHAR j = jewels[ j pos ];
                IF   j >= "A" AND j <= "Z" THEN count +:= letter counts[ upper a pos + ( ABS j - ABS "A" ) ]
                ELIF j >= "a" AND j <= "z" THEN count +:= letter counts[ lower a pos + ( ABS j - ABS "a" ) ]
                FI 
            OD;
            count
        END # count jewels # ;

   print( ( count jewels( "aAAbbbb", "aA" ), newline ) );
   print( ( count jewels( "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz"
                        , "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz"
                        )
          , newline
          )
        );
   print( ( count jewels( "AB", "" ), newline ) );
   print( ( count jewels( "ZZ", "z" ), newline ) )

END</lang>

Output:

APL

Works with: Dyalog APL

<lang apl>jewels ← +/∊⍨</lang>

Output:

      'aA' jewels 'aAAbbbb'
3

AppleScript

Functional

<lang applescript>-- jewelCount :: String -> String -> Int on jewelCount(jewels, stones)

   set js to chars(jewels)
   script
       on |λ|(a, c)
           if elem(c, jewels) then
               a + 1
           else
               a
           end if
       end |λ|
   end script
   foldl(result, 0, chars(stones))

end jewelCount

-- OR in terms of filter -- jewelCount :: String -> String -> Int on jewelCount2(jewels, stones)

   script
       on |λ|(c)
           elem(c, jewels)
       end |λ|
   end script
   length of filter(result, stones)

end jewelCount2

-- TEST -------------------------------------------------- on run

   unlines(map(uncurry(jewelCount), ¬
       {Tuple("aA", "aAAbbbb"), Tuple("z", "ZZ")}))

end run

-- GENERIC FUNCTIONS -------------------------------------

-- Tuple (,) :: a -> b -> (a, b) on Tuple(a, b)

   {type:"Tuple", |1|:a, |2|:b}

end Tuple

-- chars :: String -> [Char] on chars(s)

   characters of s

end chars

-- elem :: Eq a => a -> [a] -> Bool on elem(x, xs)

   considering case
       xs contains x
   end considering

end elem

-- filter :: (a -> Bool) -> [a] -> [a] on filter(f, xs)

   tell mReturn(f)
       set lst to {}
       set lng to length of xs
       repeat with i from 1 to lng
           set v to item i of xs
           if |λ|(v, i, xs) then set end of lst to v
       end repeat
       return lst
   end tell

end filter

-- foldl :: (a -> b -> a) -> a -> [b] -> a on foldl(f, startValue, xs)

   tell mReturn(f)
       set v to startValue
       set lng to length of xs
       repeat with i from 1 to lng
           set v to |λ|(v, item i of xs, i, xs)
       end repeat
       return v
   end tell

end foldl

-- map :: (a -> b) -> [a] -> [b] on map(f, xs)

   tell mReturn(f)
       set lng to length of xs
       set lst to {}
       repeat with i from 1 to lng
           set end of lst to |λ|(item i of xs, i, xs)
       end repeat
       return lst
   end tell

end map

-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: First-class m => (a -> b) -> m (a -> b) on mReturn(f)

   if class of f is script then
       f
   else
       script
           property |λ| : f
       end script
   end if

end mReturn

-- Returns a function on a single tuple (containing 2 arguments) -- derived from an equivalent function with 2 distinct arguments -- uncurry :: (a -> b -> c) -> ((a, b) -> c) on uncurry(f)

   script
       property mf : mReturn(f)'s |λ|
       on |λ|(pair)
           mf(|1| of pair, |2| of pair)
       end |λ|
   end script

end uncurry

-- unlines :: [String] -> String on unlines(xs)

   set {dlm, my text item delimiters} to ¬
       {my text item delimiters, linefeed}
   set str to xs as text
   set my text item delimiters to dlm
   str

end unlines</lang>

Output:

3
0

Idiomatic

<lang applescript>on jewelsAndStones(stones, jewels)

   set counter to 0
   considering case
       repeat with thisCharacter in stones
           if (thisCharacter is in jewels) then set counter to counter + 1
       end repeat
   end considering
   
   return counter

end jewelsAndStones

jewelsAndStones("aAAbBbb", "aAb")</lang>

Output:

Arturo

<lang rebol>count: function [jewels,stones][

   size select split stones => [in? & jewels]

]

print count "aA" "aAAbbbb"</lang>

Output:

AutoHotkey

<lang AutoHotkey>JewelsandStones(ss, jj){ for each, jewel in StrSplit(jj) for each, stone in StrSplit(ss) if (stone == jewel) num++ return num }</lang> Example:<lang AutoHotkey>MsgBox % JewelsandStones("aAAbbbbz", "aAZ") return</lang>

Outputs:

AWK

<lang AWK># syntax: GAWK -f JEWELS_AND_STONES.AWK BEGIN {

   printf("%d\n",count("aAAbbbb","aA"))
   printf("%d\n",count("ZZ","z"))
   exit(0)

} function count(stone,jewel, i,total) {

   for (i=1; i<length(stone); i++) {
     if (jewel ~ substr(stone,i,1)) {
       total++
     }
   }
   return(total)

} </lang>

Output:

3
0

BASIC

<lang basic>10 READ N% 20 FOR A%=1 TO N% 30 READ J$,S$ 40 GOSUB 100 50 PRINT S$;" in ";J$;":";J% 60 NEXT 70 END

100 REM Count how many stones (S$) are jewels (J$). 110 DIM J%(127) 120 J%=0 130 FOR I%=1 TO LEN(J$): J%(ASC(MID$(J$,I%,1)))=1: NEXT 140 FOR I%=1 TO LEN(S$): J%=J%+J%(ASC(MID$(S$,I%,1))): NEXT 150 ERASE J% 160 RETURN

200 DATA 2 210 DATA "aA","aAAbbbb" 220 DATA "z","ZZZZ" </lang>

Output:

aAAbbbb in aA: 3
ZZZZ in z: 0

BASIC256

<lang BASIC256> function contar_joyas(piedras, joyas) cont = 0 for i = 1 to length(piedras) bc = instr(joyas, mid(piedras, i, 1), 1) if bc <> 0 then cont += 1 next i return cont end function

print contar_joyas("aAAbbbb", "aA") print contar_joyas("ZZ", "z") print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz") print contar_joyas("AB", "") </lang>

Output:

Igual que la entrada de FreeBASIC.

BCPL

<lang bcpl>get "libhdr"

let jewels(j, s) = valof $( let jewel = vec 255

   let count = 0
   for i = 0 to 255 do jewel!i := false
   for i = 1 to j%0 do jewel!(j%i) := true
   for i = 1 to s%0 do 
       if jewel!(s%i) then
           count := count + 1
   resultis count

$)

let show(j, s) be

   writef("*"%S*" in *"%S*": %N*N", j, s, jewels(j, s))

let start() be $( show("aA", "aAAbbbb")

   show("z", "ZZ")

$)</lang>

Output:

"aA" in "aAAbbbb": 3
"z" in "ZZ": 0

Bracmat

<lang Bracmat> ( f

 =   stones jewels N
   .   !arg:(?stones.?jewels)
     & 0:?N
     & ( @( !stones
          :   ?
              (   %@
                : [%(   @(!jewels:? !sjt ?)
                      & 1+!N:?N
                    |
                    )
              & ~
              )
              ?
          )
       | !N
       )
 )

& f$(aAAbbbb.aA) </lang> Output

C

Translation of: Kotlin

<lang c>#include <stdio.h>

include <string.h>

int count_jewels(const char *s, const char *j) {

   int count = 0;
   for ( ; *s; ++s) if (strchr(j, *s)) ++count;
   return count;

}

int main() {

   printf("%d\n", count_jewels("aAAbbbb", "aA"));
   printf("%d\n", count_jewels("ZZ", "z"));
   return 0;

}</lang>

Output:

3
0

C#

<lang csharp>using System; using System.Linq;

public class Program {

   public static void Main() {
       Console.WriteLine(Count("aAAbbbb", "Aa"));
       Console.WriteLine(Count("ZZ", "z"));
   }

   private static int Count(string stones, string jewels) {
       var bag = jewels.ToHashSet();
       return stones.Count(bag.Contains);
   }

}</lang>

Output:

3
0

C++

Translation of: D

<lang cpp>#include <algorithm>

include <iostream>

int countJewels(const std::string& s, const std::string& j) {

   int count = 0;
   for (char c : s) {
       if (j.find(c) != std::string::npos) {
           count++;
       }
   }
   return count;

}

int main() {

   using namespace std;

   cout << countJewels("aAAbbbb", "aA") << endl;
   cout << countJewels("ZZ", "z") << endl;

   return 0;

}</lang>

Output:

3
0

CLU

<lang clu>count_jewels = proc (jewels, stones: string) returns (int)

   is_jewel: array[bool] := array[bool]$fill(0, 256, false)
   for c: char in string$chars(jewels) do
       is_jewel[char$c2i(c)] := true
   end
   
   n_jewels: int := 0
   for c: char in string$chars(stones) do
       if is_jewel[char$c2i(c)] then n_jewels := n_jewels + 1 end
   end
   return (n_jewels)

end count_jewels

show = proc (jewels, stones: string)

   po: stream := stream$primary_output()
   
   stream$putl(po, "\"" || jewels || "\" in \"" || stones || "\": "
               || int$unparse(count_jewels(jewels, stones)))

end show

start_up = proc ()

   show("aA", "aAAbbbb")

end start_up</lang>

Output:

"aA" in "aAAbbbb": 3

Cowgol

<lang cowgol>include "cowgol.coh";

sub count_jewels(stones: [uint8], jewels: [uint8]): (count: uint16) is

   var jewel_mark: uint8[256];
   MemZero(&jewel_mark as [uint8], 256);

   while [jewels] != 0 loop
       jewel_markjewels := 1;
       jewels := @next jewels;
   end loop;

   count := 0;
   while [stones] != 0 loop
       count := count + jewel_markstones as uint16;
       stones := @next stones;
   end loop;

end sub;

sub print_and_count(stones: [uint8], jewels: [uint8]) is

   print(jewels);
   print(" in ");
   print(stones);
   print(": ");
   print_i16(count_jewels(stones, jewels));
   print_nl();

end sub;

print_and_count("aAAbbbb", "aA"); print_and_count("ZZ", "z");</lang>

Output:

aA in aAAbbbb: 3
z in ZZ: 0

Crystal

<lang ruby>stones, jewels = "aAAbbbb", "aA" stones.count(jewels) # => 3

The above solution works for that case, but fails with certain other "jewels":

stones, jewels = "aA^Bb", "^b" stones.count(jewels) # => 4

'^b' in the "jewels" is read as "characters other than 'b'".

This works as intended though:

stones.count { |c| jewels.chars.includes?(c) } # => 2</lang>

D

Translation of: Kotlin

<lang d>import std.algorithm; import std.stdio;

int countJewels(string s, string j) {

   int count;
   foreach (c; s) {
       if (j.canFind(c)) {
           count++;
       }
   }
   return count;

}

void main() {

   countJewels("aAAbbbb", "aA").writeln;
   countJewels("ZZ", "z").writeln;

}</lang>

Output:

3
0

Draco

<lang draco>proc nonrec count_jewels(*char jewels, stones) word:

   [256] bool jewel;
   word count;
   byte i;
   char c;
   
   for i from 0 upto 255 do jewel[i] := false od;
   while c := jewels*; c ~= '\e' do
       jewel[c] := true;
       jewels := jewels + 1;
   od;
   
   count := 0;
   while c := stones*; c ~= '\e' do
       if jewel[c] then count := count + 1 fi;
       stones := stones + 1
   od;
   count

corp

proc nonrec show(*char jewels, stones) void:

   writeln("'", jewels, "' in '", stones, "': ", count_jewels(jewels, stones))

corp

proc nonrec main() void:

   show("aA", "aAAbbbb");
   show("z", "ZZ")

corp</lang>

Output:

'aA' in 'aAAbbbb': 3
'z' in 'ZZ': 0

Dyalect

Translation of: Swift

<lang dyalect>func countJewels(stones, jewels) {

   stones.Iterate().Map(x => jewels.Contains(x) ? 1 : 0).Reduce(0, (x,y) => x + y)

}

print(countJewels("aAAbbbb", "aA")) print(countJewels("ZZ", "z"))</lang>

Output:

3
0

F#

<lang fsharp> let fN jewels stones=stones|>Seq.filter(fun n->Seq.contains n jewels)|>Seq.length printfn "%d" (fN "aA" "aAAbbbb") </lang>

Output:

Factor

<lang factor>USING: kernel prettyprint sequences ;

count-jewels ( stones jewels -- n ) [ member? ] curry count ;

"aAAbbbb" "aA" "ZZ" "z" [ count-jewels . ] 2bi@</lang>

Output:

3
0

Euphoria

<lang Euphoria> function number_of(object jewels, object stones) -- why limit ourselves to strings? integer ct = 0

   for i = 1 to length(stones) do
       ct += find(stones[i],jewels) != 0
   end for
   return ct

end function

? number_of("aA","aAAbbbb") ? number_of("z","ZZ") ? number_of({1,"Boo",3},{1,2,3,'A',"Boo",3}) -- might as well send a list of things to find, not just one! </lang>

Output:

3
0
4 -- 1 is found once, "Boo" is found once, and 3 is found twice = 4 things in the search list were found in the target list

FreeBASIC

<lang freebasic> function contar_joyas(piedras as string, joyas as string) as integer

   dim as integer bc, cont: cont = 0
   for i as integer = 1 to len(piedras)
       bc = instr(1, joyas, mid(piedras, i, 1))
       if bc <> 0 then cont += 1
   next i
   contar_joyas = cont

end function

print contar_joyas("aAAbbbb", "aA") print contar_joyas("ZZ", "z") print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", _

                  "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")

print contar_joyas("AB", "") </lang>

Output:

Go

Four solutions are shown here. The first of two simpler solutions iterates over the stone string in an outer loop and makes repeated searches into the jewel string, incrementing a count each time it finds a stone in the jewels. The second of the simpler solutions reverses that, iterating over the jewel string in the outer loop and accumulating counts of matching stones. This solution works because we are told that all letters of the jewel string must be unique. These two solutions are simple but are both O(|j|*|s|).

The two more complex solutions are analogous to the two simpler ones but build a set or multiset as preprocessing step, replacing the inner O(n) operation with an O(1) operation. The resulting complexity in each case is O(|j|+|s|).

Outer loop stones, index into jewels: <lang go>package main

import (

   "fmt"
   "strings"

)

func js(stones, jewels string) (n int) {

   for _, b := range []byte(stones) {
       if strings.IndexByte(jewels, b) >= 0 {
           n++
       }
   }
   return

}

func main() {

   fmt.Println(js("aAAbbbb", "aA"))

}</lang>

Output:

Outer loop jewels, count stones: <lang go>func js(stones, jewels string) (n int) {

   for _, b := range []byte(jewels) {
       n += strings.Count(stones, string(b))
   }
   return

}</lang>

Construct jewel set, then loop over stones: <lang go>func js(stones, jewels string) (n int) {

   var jSet ['z' + 1]int
   for _, b := range []byte(jewels) {
       jSet[b] = 1
   }
   for _, b := range []byte(stones) {
       n += jSet[b]
   }
   return

}</lang>

Construct stone multiset, then loop over jewels: <lang go>func js(stones, jewels string) (n int) {

   var sset ['z' + 1]int
   for _, b := range []byte(stones) {
       sset[b]++
   }
   for _, b := range []byte(jewels) {
       n += sset[b]
   }
   return

}</lang>

Haskell

<lang haskell>jewelCount

 :: Eq a
 => [a] -> [a] -> Int

jewelCount jewels = foldr go 0

 where
   go c
     | c `elem` jewels = succ
     | otherwise = id

TEST -------------------------

main :: IO () main = mapM_ print $ uncurry jewelCount <$> [("aA", "aAAbbbb"), ("z", "ZZ")] </lang>

Output:

3
0

Or in terms of filter rather than foldr

<lang haskell>jewelCount

 :: Eq a
 => [a] -> [a] -> Int

jewelCount jewels = length . filter (`elem` jewels)

TEST -------------------------

main :: IO () main = do

 print $ jewelCount "aA" "aAAbbbb"
 print $ jewelCount "z" "ZZ"</lang>

Output:

3
0

J

  NB. jewels sums a raveled equality table
  NB. use: x jewels y  x are the stones, y are the jewels.
  intersect =: -.^:2
  jewels =: ([: +/ [: , =/~) ~.@:intersect&Alpha_j_

  'aAAbbbb ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz' jewels&>&;: 'aA ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz'

3 52

  'none' jewels

0

  'ZZ' jewels 'z'

0

</lang>

Java

<lang java>import java.util.HashSet; import java.util.Set;

public class App {

   private static int countJewels(String stones, String jewels) {
       Set<Character> bag = new HashSet<>();
       for (char c : jewels.toCharArray()) {
           bag.add(c);
       }

       int count = 0;
       for (char c : stones.toCharArray()) {
           if (bag.contains(c)) {
               count++;
           }
       }

       return count;
   }

   public static void main(String[] args) {
       System.out.println(countJewels("aAAbbbb", "aA"));
       System.out.println(countJewels("ZZ", "z"));
   }

}</lang>

Output:

3
0

JavaScript

<lang javascript>(() => {

   // jewelCount :: String -> String -> Int
   const jewelCount = (j, s) => {
       const js = j.split();
       return s.split()
           .reduce((a, c) => js.includes(c) ? a + 1 : a, 0)
   };

   // TEST -----------------------------------------------
   return [
           ['aA', 'aAAbbbb'],
           ['z', 'ZZ']
       ]
       .map(x => jewelCount(...x))

})();</lang>

Output:

[3, 0]

jq

<lang jq>$ jq -n --arg stones aAAbbbb --arg jewels aA '

 [$stones|split("") as $s|$jewels|split("") as $j|$s[]|
 select(. as $c|$j|contains([$c]))]|length'</lang>

Output:

Julia

Module: <lang julia>module Jewels

count(s, j) = Base.count(x ∈ j for x in s)

end # module Jewels</lang>

Main: <lang julia>@show Jewels.count("aAAbbbb", "aA") @show Jewels.count("ZZ", "z")</lang>

Output:

Jewels.count("aAAbbbb", "aA") = 3
Jewels.count("ZZ", "z") = 0

Kotlin

<lang scala>// Version 1.2.40

fun countJewels(s: String, j: String) = s.count { it in j }

fun main(args: Array<String>) {

   println(countJewels("aAAbbbb", "aA"))
   println(countJewels("ZZ", "z"))

}</lang>

Output:

3
0

Lambdatalk

<lang scheme> {def countjewels

{def countjewels.r
 {lambda {:a :b :c}
  {if {A.empty? :a}
   then :c
   else {countjewels.r {A.rest :a}
                       :b
                       {if {= {A.in? {A.first :a} :b} -1}
                        then :c
                        else {+ :c 1}}}}}}
{lambda {:a :b}
 {countjewels.r {A.split :a} {A.split :b} 0}}}

-> countjewels

{countjewels aAAbbbb aA} -> 3 {countjewels ZZ z} -> 0 </lang>

Lua

Translation of: C

<lang lua>function count_jewels(s, j)

   local count = 0
   for i=1,#s do
       local c = s:sub(i,i)
       if string.match(j, c) then
           count = count + 1
       end
   end
   return count

end

print(count_jewels("aAAbbbb", "aA")) print(count_jewels("ZZ", "z"))</lang>

Output:

3
0

Maple

<lang Maple>count_jewel := proc(stones, jewels) local count, j, letter: j := convert(jewels,set): count := 0: for letter in stones do if (member(letter, j)) then count++: end if: end do: return count: end proc: count_jewel("aAAbbbb", "aA")</lang>

Output:

Mathematica / Wolfram Language

<lang Mathematica>JewelsStones[j_String, s_String] := Count[MemberQ[Characters[j], #] & /@ Characters[s], True] JewelsStones["aA", "aAAbbbb"] JewelsStones["ZZ", "z"]</lang>

Output:

3
0

MATLAB / Octave

   function s = count_jewels(stones,jewels)
   s=0;
   for c=jewels
       s=s+sum(c==stones);
   end
   %!test
   %! assert(count_jewels('aAAbbbb','aA'),3)
   %!test
   %! assert(count_jewels('ZZ','z'),0)

</lang>

min

Works with: min version 0.19.6

<lang min>(( ) => spread if) :if?

((1 0 if?) concat map sum) :count

(swap indexof -1 !=) :member?

(("" split) dip 'member? cons count) :count-jewels

"aAAbbbb" "aA" count-jewels puts! "ZZ" "z" count-jewels puts!</lang>

Output:

3
0

Modula-2

<lang modula2>MODULE Jewels; FROM FormatString IMPORT FormatString; FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

PROCEDURE WriteInt(n : INTEGER); VAR buf : ARRAY[0..15] OF CHAR; BEGIN

   FormatString("%i", buf, n);
   WriteString(buf)

END WriteInt;

PROCEDURE CountJewels(s,j : ARRAY OF CHAR) : INTEGER; VAR c,i,k : CARDINAL; BEGIN

   c :=0;

   FOR i:=0 TO HIGH(s) DO
       FOR k:=0 TO HIGH(j) DO
           IF (j[k]#0C) AND (s[i]#0C) AND (j[k]=s[i]) THEN
               INC(c);
               BREAK
           END
       END
   END;

   RETURN c

END CountJewels;

BEGIN

   WriteInt(CountJewels("aAAbbbb", "aA"));
   WriteLn;
   WriteInt(CountJewels("ZZ", "z"));
   WriteLn;

   ReadChar

END Jewels.</lang>

Output:

3
0

Nim

<lang Nim>import sequtils

func countJewels(stones, jewels: string): Natural =

 stones.countIt(it in jewels)

echo countJewels("aAAbbbb", "aA") echo countJewels("ZZ", "z")</lang>

Output:

3
0

Objeck

Translation of: Java

<lang Objeck>use Collection.Generic;

class JewelsStones {

 function : Main(args : String[]) ~ Nil {
   Count("aAAbbbb", "aA")->PrintLine();
   Count("ZZ", "z")->PrintLine();
 }

 function : Count(stones : String, jewels : String) ~ Int {
   bag := Set->New()<CharHolder>;

   each(i : jewels) {
     bag->Insert(jewels->Get(i));
   };

   count := 0;
   each(i : stones) {
     if(bag->Has(stones->Get(i))) {
       count++;
     };
   };

   return count;
 }

}</lang>

Output:

3
0

Perl

<lang perl>sub count_jewels {

   my( $j, $s ) = @_;
   my($c,%S);

   $S{$_}++     for split //, $s;
   $c += $S{$_} for split //, $j;
   return "$c\n";

}

print count_jewels 'aA' , 'aAAbbbb'; print count_jewels 'z' , 'ZZ';</lang>

Output:

3
0

Alternate using regex

<lang perl>#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Jewels_and_Stones#Perl use warnings;

sub count_jewels { scalar( () = $_[0] =~ /[ $_[1] ]/gx ) } # stones, jewels

print "$_ = ", count_jewels( split ), "\n" for split /\n/, <<END; aAAbbbb aA aAAbbbb abc ZZ z END</lang>

Output:

aAAbbbb aA = 3
aAAbbbb abc = 5
ZZ z = 0

Phix

function count_jewels(string stones, jewels)
    integer res = 0
    for i=1 to length(stones) do
        res += find(stones[i],jewels)!=0
    end for
    return res
end function
?count_jewels("aAAbbbb","aA")
?count_jewels("ZZ","z")

Output:

3
0

PL/M

<lang plm>100H:

/* FIND JEWELS AMONG STONES */ COUNT$JEWELS: PROCEDURE (JEWELS, STONES) BYTE;

   DECLARE (JEWELS, STONES) ADDRESS;
   DECLARE (J BASED JEWELS, S BASED STONES) BYTE;
   DECLARE JFLAG (256) BYTE, I BYTE;
  
   /* ZERO JEWEL FLAGS */
   DO I=0 TO 255;
       JFLAG(I) = 0;
   END;
   
   /* LOOP THROUGH JEWELS AND MARK THEM */
   DO WHILE J <> '$';
       JFLAG(J) = 1;
       JEWELS = JEWELS + 1;
   END;
   
   /* COUNT THE JEWELS AMONG THE STONES */
   I = 0;
   DO WHILE S <> '$';
       I = I + JFLAG(S);
       STONES = STONES + 1;
   END;
   RETURN I;

END COUNT$JEWELS;

/* CP/M BDOS CALL */ BDOS: PROCEDURE (FN, ARG);

   DECLARE FN BYTE, ARG ADDRESS;
   GO TO 5;

END BDOS;

PRINT: PROCEDURE (STR);

   DECLARE STR ADDRESS;
   CALL BDOS(9, STR);

END PRINT;

/* NUMERIC OUTPUT */ PRINT$NUMBER: PROCEDURE (N);

   DECLARE S (4) BYTE INITIAL ('...$');
   DECLARE P ADDRESS, (N, C BASED P) BYTE;
   P = .S(3);

DIGIT:

   P = P-1;
   C = N MOD 10 + '0';
   N = N/10;
   IF N > 0 THEN GO TO DIGIT;
   CALL PRINT(P);

END PRINT$NUMBER;

/* PRINT JEWELS, STONES, AND AMOUNT OF JEWELS IN STONES */ TEST: PROCEDURE (J, S);

   DECLARE (J, S) ADDRESS;
   CALL PRINT(.$');
   CALL PRINT(J);
   CALL PRINT(.' IN $');
   CALL PRINT(S);
   CALL PRINT(.: $');
   CALL PRINT$NUMBER(COUNT$JEWELS(J, S));
   CALL PRINT(.(13,10,'$'));

END TEST;

/* UNFORTUNATELY, THE PL/M COMPILER ACCEPTS A VERY RESTRICTED CHARACTER SET

  IN THE SOURCE CODE. (IT IS THE INTERSECTION OF VARIOUS POPULAR CHARSETS
  FROM THE 1960S.) THIS CHARACTER SET DOES NOT INCLUDE LOWERCASE LETTERS.
  HOWEVER, THIS CODE ASSUMES THE ASCII CHARACTER SET ANYWAY.
  WE CAN INCLUDE LOWERCASE LETTERS ... BY WRITING THEIR ASCII CODES. 
  THE OUTPUT WILL BE CORRECT OF COURSE. */

CALL TEST(.( 97,'A$' ), .( 97,'AA',98,98,98,98,'$' )); CALL TEST(.( 122,'$' ), .( 'ZZZZ$' ));

CALL BDOS(0,0); EOF</lang>

Output:

'aA' IN 'aAAbbbb': 3
'z' IN 'ZZZZ': 0

Prolog

- system:set_prolog_flag(double_quotes,codes) .

count_jewels(STONEs0,JEWELs0,COUNT)

-

findall(X,(member(X,JEWELs0),member(X,STONEs0)),ALLs) , length(ALLs,COUNT) .

</lang>

Output:

/*
?- count_jewels("aAAbbbb","aA",N).
N = 3.

?- count_jewels("ZZ","z",N).
N = 0.

?-  count_jewels("aAAbbbb","bcd",N) .
N = 4.

?-
*/

alternative version

Works with: SWI Prolog

<lang prolog>count_jewels(Stones, Jewels, N):-

   string_codes(Stones, Scodes),
   string_codes(Jewels, Jcodes),
   msort(Scodes, SScodes),
   sort(Jcodes, SJcodes),
   count_jewels(SScodes, SJcodes, N, 0).

count_jewels([], _, N, N):-!. count_jewels(_, [], N, N):-!. count_jewels([C|Stones], [C|Jewels], N, R):-

   !,
   R1 is R + 1,
   count_jewels(Stones, [C|Jewels], N, R1).

count_jewels([S|Stones], [J|Jewels], N, R):-

   J < S,
   !,
   count_jewels([S|Stones], Jewels, N, R).

count_jewels([_|Stones], Jewels, N, R):-

   count_jewels(Stones, Jewels, N, R).</lang>

Output:

Welcome to SWI-Prolog (threaded, 64 bits, version 8.0.2)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.
Please run ?- license. for legal details.

For online help and background, visit http://www.swi-prolog.org
For built-in help, use ?- help(Topic). or ?- apropos(Word).

?- count_jewels("aAAbbbb", "aA", N).
N = 3.

Python

<lang python>def countJewels(s, j):

   return sum(x in j for x in s)

print countJewels("aAAbbbb", "aA") print countJewels("ZZ", "z")</lang>

Output:

3
0

Python 3 Alternative

<lang python>def countJewels(stones, jewels):

   jewelset = set(jewels)
   return sum(1 for stone in stones if stone in jewelset)

print(countJewels("aAAbbbb", "aA")) print(countJewels("ZZ", "z"))</lang>

Output:

3
0

R

<lang R>J_n_S <- function(stones ="aAAbbbb", jewels = "aA") {

 stones <- unlist(strsplit(stones, split = "")) # obtain a character vector
 jewels <- unlist(strsplit(jewels, split = ""))
 count <- sum(stones %in% jewels)

}

print(J_n_S("aAAbbbb", "aA")) print(J_n_S("ZZ", "z")) print(J_n_S("lgGKJGljglghGLGHlhglghoIPOgfdtrdDCHnvbnmBVC", "fFgGhH")) </lang>

Output:

> print(J_n_S("aAAbbbb", "aA"))
[1] 3
> print(J_n_S("ZZ", "z"))
[1] 0
> print(J_n_S("lgGKJGljglghGLGHlhglghoIPOgfdtrdDCHnvbnmBVC", "fFgGhH"))
[1] 16

Quackery

<lang Quackery> [ 0 0 rot

   witheach [ bit | ] 
   rot witheach
     [ bit over & if 
         [ dip 1+ ] ] 
   drop ]             is j&s ( $ $ --> n )

 $ "aAAbbbb" $  "aA" j&s echo</lang>

Output:

Racket

<lang racket>#lang racket

(define (jewels-and-stones stones jewels)

 (length (filter (curryr member (string->list jewels)) (string->list stones))))

(module+ main

 (jewels-and-stones "aAAbbbb" "aA")
 (jewels-and-stones "ZZ" "z"))

</lang>

Output:

3
0

Raku

(formerly Perl 6) <lang perl6>sub count-jewels ( Str $j, Str $s --> Int ) {

   my %counts_of_all = $s.comb.Bag;
   my @jewel_list    = $j.comb.unique;

   return %counts_of_all ∩ @jewel_list.Bag ?? %counts_of_all{ @jewel_list }.sum !! 0;

}

say count-jewels 'aA' , 'aAAbbbb'; say count-jewels 'z' , 'ZZ';</lang>

Output:

3
0

Red

<lang rebol>Red [

   title: "Jewels and stones"
   red-version: 0.6.4

]

count: function [

   "Returns the number of values in a block for which a function returns true"
   values [any-list! string!] "The values from which to count"
   fn [function!] "A function that returns true or false"

][

   count: 0
   foreach value values [if fn value [count: count + 1]]
   count

]

count-jewels: function [

   "Returns the count of 'jewels' in the 'stones'"
   stones "The values to search for jewels"
   jewels "The values to count in the stones"

][

   result: 0
   foreach jewel jewels [
       result: result + count stones function [stone][stone = jewel]
   ]

]

print count-jewels "aAAbbbb" "aA" print count-jewels "ZZ" "z"</lang>

Output:

3
0

REXX

Programming note: a check is made so that only (Latin) letters are counted as a match. <lang rexx>/*REXX pgm counts how many letters (in the 1st string) are in common with the 2nd string*/ say count('aAAbbbb', "aA") say count('ZZ' , "z" ) exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ count: procedure; parse arg stones,jewels /*obtain the two strings specified. */

      #= 0                                      /*initialize the variable  #  to  zero.*/
                  do j=1  for length(stones)    /*scan STONES for matching JEWELS chars*/
                  x= substr(stones, j, 1)       /*obtain a character of the STONES var.*/
                  if datatype(x, 'M')  then if pos(x, jewels)\==0  then #= # + 1
                  end   /*j*/                   /* [↑]  if a letter and a match, bump #*/
      return #                                  /*return the number of common letters. */</lang>

output when using the default inputs:

3
0

Ring

<lang ring># Project Jewels and Stones

jewels = "aA" stones = "aAAbbbb" see jewelsandstones(jewels,stones) + nl jewels = "z" stones = "ZZ" see jewelsandstones(jewels,stones) + nl

func jewelsandstones(jewels,stones)

       num = 0
       for n = 1 to len(stones)
            pos = substr(jewels,stones[n])
            if pos > 0
               num = num + 1
            ok
       next
       return num

</lang> Output:

3
0

Ruby

<lang ruby>stones, jewels = "aAAbbbb", "aA"

stones.count(jewels) # => 3 </lang>

Rust

<lang rust>fn count_jewels(stones: &str, jewels: &str) -> u8 {

   let mut count: u8 = 0;
   for cur_char in stones.chars() {
       if jewels.contains(cur_char) {
           count += 1;
       }
   }
   count

} fn main() {

   println!("{}", count_jewels("aAAbbbb", "aA"));
   println!("{}", count_jewels("ZZ", "z"));

} </lang>

Output:

3
0

Scala

<lang Scala>object JewelsStones extends App {

 def countJewels(s: String, j: String): Int = s.count(i => j.contains(i))

 println(countJewels("aAAbbbb", "aA"))
 println(countJewels("ZZ", "z"))

}</lang>

Output:

See it in running in your browser by ScalaFiddle (JavaScript) or by Scastie (JVM).

Sidef

<lang ruby>func countJewels(s, j) {

   s.chars.count { |c|
       j.contains(c)
   }

}

say countJewels("aAAbbbb", "aA") #=> 3 say countJewels("ZZ", "z") #=> 0</lang>

Snobol

<lang snobol>* See how many jewels are among the stones

       DEFINE('JEWELS(JWL,STN)')               :(JEWELS_END)

JEWELS JEWELS = 0

       JWL = ANY(JWL)

JMATCH STN JWL = :F(RETURN)

       JEWELS = JEWELS + 1                     :(JMATCH)

JEWELS_END

Example from the task (prints 3)

       OUTPUT = JEWELS('aA','aAAbbbb')

Example with no jewels (prints 0)

       OUTPUT = JEWELS('z','ZZ')

END</lang>

Output:

3
0

SQL

<lang SQL>-- See how many jewels are among the stones declare @S varchar(1024) = 'AaBbCcAa' , @J varchar(1024) = 'aA';

declare @SLEN int = len(@S); declare @JLEN int = len(@J); declare @TCNT int = 0;

declare @SPOS int = 1; -- curr position in @S declare @JPOS int = 1; -- curr position in @J declare @FCHR char(1); -- char to find

while @JPOS <= @JLEN begin

set @FCHR = substring(@J, @JPOS, 1);

set @SPOS = 1;

while @SPOS > 0 and @SPOS <= @SLEN begin

set @SPOS = charindex(@FCHR, @S COLLATE Latin1_General_CS_AS, @SPOS);

if @SPOS > 0 begin set @TCNT = @TCNT + 1; set @SPOS = @SPOS + 1; end end

set @JPOS = @JPOS + 1; end print 'J='+@J+' S='+@S+' TOTAL = '+cast(@TCNT as varchar(8)); </lang>

Output:

J=aA S=AaBbCcAa TOTAL = 4

Swift

<lang swift>func countJewels(_ stones: String, _ jewels: String) -> Int {

 return stones.map({ jewels.contains($0) ? 1 : 0 }).reduce(0, +)

}

print(countJewels("aAAbbbb", "aA")) print(countJewels("ZZ", "z"))</lang>

Output:

3
0

Tcl

<lang Tcl>proc shavej {stones jewels} {

   set n 0
   foreach c [split $stones {}] {
       incr n [expr { [string first $c $jewels] >= 0 }]
   }
   return $n

} puts [shavej aAAbbbb aA] puts [shavej ZZ z]</lang>

Output:

3                                                                                       
0

Terraform

<lang hcl>variable "jewels" {

 default = "aA"

}

variable "stones" {

 default = "aAAbbbb"

}

locals {

  jewel_list = split("", var.jewels)
  stone_list = split("", var.stones)
  found_jewels = [for s in local.stone_list: s if contains(local.jewel_list, s)]

}

output "jewel_count" {

 value = length(local.found_jewels)

}</lang>

Output:

$ terraform apply --auto-approve

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

jewel_count = 3

$ TF_VAR_jewels=z TF_VAR_stones=ZZ terraform apply --auto-approve

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

jewel_count = 0

Transd

<lang Scheme>#lang transd

MainModule: {

   countJewels: (λ j String() st String() locals: n 0
       (for s in st do 
           (if (contains j s) (+= n 1)))
       (ret n)
   ),
   _start: (λ (lout (countJewels "aA" "aAAbbbb"))
              (lout (countJewels "b" "BB")))

}</lang>

Output:

3
0

VBA

Translation of: Phix

<lang vb>Function count_jewels(stones As String, jewels As String) As Integer

   Dim res As Integer: res = 0
   For i = 1 To Len(stones)
       res = res - (InStr(1, jewels, Mid(stones, i, 1), vbBinaryCompare) <> 0)
   Next i
   count_jewels = res

End Function Public Sub main()

   Debug.Print count_jewels("aAAbbbb", "aA")
   Debug.Print count_jewels("ZZ", "z")

End Sub</lang>

Output:

 3 
 0

Visual Basic .NET

Translation of: C#

<lang vbnet>Module Module1

   Function Count(stones As String, jewels As String) As Integer
       Dim bag = jewels.ToHashSet
       Return stones.Count(AddressOf bag.Contains)
   End Function

   Sub Main()
       Console.WriteLine(Count("aAAbbbb", "Aa"))
       Console.WriteLine(Count("ZZ", "z"))
   End Sub

End Module</lang>

Output:

3
0

Wren

Translation of: Kotlin

<lang ecmascript>var countJewels = Fn.new { |s, j| s.count { |c| j.contains(c) } }

System.print(countJewels.call("aAAbbbb", "aA")) System.print(countJewels.call("ZZ", "z"))</lang>

Output:

3
0

XPL0

<lang XPL0>string 0; \Use zero-terminated strings

func Count(Stones, Jewels); \Return number of letters in Stones that match letters in Jewels char Stones, Jewels; int Cnt, I, J; [Cnt:= 0; I:= 0; while Jewels(I) do

   [J:= 0;
   while Stones(J) do
       [if Stones(J) = Jewels(I) then Cnt:= Cnt+1;
       J:= J+1;
       ];
   I:= I+1;
   ];

return Cnt; ];

[IntOut(0, Count("aAAbbbb", "aA")); CrLf(0);

IntOut(0, Count("ZZ", "z"));  CrLf(0);
IntOut(0, Count("pack my box with five dozen liquor jugs", "aeiou"));  CrLf(0);

]</lang>

Output:

3
0
11

zkl

<lang zkl>fcn countJewels(a,b){ a.inCommon(b).len() }</lang> <lang zkl>println(countJewels("aAAbbbb", "aA")); println(countJewels("ZZ", "z"));</lang>

Output:

3
0

@@ Line 1,260: / Line 1,260: @@
 ZZ z = 0
 </pre>
-=={{header|Picat}}==
-===List comprehension===
-<lang Picat>jewels_and_stones1(Jewels,Stones) = sum([1 : S in Stones, J in Jewels, S == J]).</lang>
-===Recursion===
-<lang Picat>jewels_and_stones2(Jewels,Stones) = N =>
-  jewels_and_stones2(Jewels,Stones,0,N).
-jewels_and_stones2([],_Stones,N,N).
-jewels_and_stones2([J|Jewels],[S|Stones],N0,N) :-
-  jewels_and_stones2_(J,[S|Stones],0,JN),
-  jewels_and_stones2(Jewels,Stones,N0+JN,N).
-% Check just this jewel on all the stones
-jewels_and_stones2_(_J,[],N,N).
-jewels_and_stones2_(J,[S|Stones],N0,N) :-
-  ( J == S ->
-     N1 = N0+1
-    ;
-    N1 = N0
-  ),
-  jewels_and_stones2_(J,Stones,N1,N).</lang>
-===Foreach loop===
-<lang Picat>jewels_and_stones3(Jewels,Stones) = N =>
-  N = 0,
-  foreach(J in Jewels, S in Stones)
-     if J == S then
-       N := N + 1
-     end
-  end.</lang>
-===Test===
-<lang Picat>go =>
-  Tests = [["aA","aAAbbbb"],
-           ["z","ZZ"]
-           ],
-  println(tests=Tests),
-  foreach([Jewels,Stones] in Tests)
-    println([jewels=Jewels,stone=Stones]),
-    println(js1=jewels_and_stones1(Jewels,Stones)),
-    println(js2=jewels_and_stones2(Jewels,Stones)),
-    println(js3=jewels_and_stones3(Jewels,Stones)),
-    nl
-  end,
-  nl.</lang>
-{{out}}
-<pre>tests = [[aA,aAAbbbb],[z,ZZ]]
-[jewels = aA,stone = aAAbbbb]
-js1 = 3
-js2 = 3
-js3 = 3
-[jewels = z,stone = ZZ]
-js1 = 0
-js2 = 0
-js3 = 0</pre>
-===Benchmark===
-For a larger test we can see the differences between the three approaches. Here are 100 000 000 random stones and (atmost) 15 jewels (we remove any duplicate jewel).
-<lang Picat>go2 =>
-  Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-  Len = Alpha.len,
-  _ = random2(),
-  NumStones = 100_000_000,
-  NumJewels = 15, % Atmost number of jewels (duplicates are removed)
-  Stones = [Alpha[random(1,Len)] : _ in 1..NumStones],
-  Jewels = [Alpha[random(1,Len)] : _ in 1..NumJewels].sort_remove_dups,
-  println(jewels=Jewels),
-  nl,
-  time(println(js1=jewels_and_stones1(Jewels,Stones))),
-  time(println(js2=jewels_and_stones2(Jewels,Stones))),
-  time(println(js3=jewels_and_stones3(Jewels,Stones))),
-  nl.</lang>
-{{out}}
-<pre>NumStones: 100_000_000  NumJewels = 15
-jewels = TwurtRabSXx
-js1 = 21154798
-CPU time 15.087 seconds.
-js2 = 21154796
-CPU time 11.024 seconds.
-js3 = 21154798
-CPU time 11.94 seconds.</pre>
-The recursion approach (<code>jewels_and_stones2/2</code>) is a little faster than the loop approach (<code>jewels_and_stones/3</code>).
 =={{header|Phix}}==