I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Jewels and stones

Jewels and stones
You are encouraged to solve this task according to the task description, using any language you may know.

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:

1. Only letters in the ISO basic Latin alphabet i.e. 'A to Z' or 'a to z' need be considered.
2. A lower case letter is considered to be different from its upper case equivalent for this purpose, i.e., 'a' != 'A'.
3. The parameters do not need to have exactly the same names.
4. 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.

## 11l

Translation of: Python
`F count_jewels(s, j)   R sum(s.map(x -> Int(x C @j))) print(count_jewels(‘aAAbbbb’, ‘aA’))print(count_jewels(‘ZZ’, ‘z’))`
Output:
```3
0
```

## 8080 Assembly

`	org	100h	jmp	demo	;;;	Count jewels.	;;;	Input: BC = jewels, DE = stones.	;;;	Output: BC = count	;;;	Destroyed: A, DE, HLjewel:	lxi	h,jarr	; Zero out the page of memory	xra	ajzero:	mov	m,a	inr	l	jnz	jzerojrjwl:	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 codedemo:	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	; Divisordgt:	lxi	d,-1	; Quotientdgtlp:	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 outputnum:	db	'\$'	;;;	Example from the taskjewels:	db	'aA',0stones:	db	'aAAbbbb',0	;;;	Next free page of memory is used for the jewel arrayjpage:	equ	\$/256+1jarr:	equ	jpage*256`
Output:
`3`

## 8086 Assembly

`	cpu	8086	bits	16	org	100hsection	.text	jmp	demo	;;;	Count jewels.	;;;	Input: DS:SI = jewels, DS:DX = stones	;;;	Output: CX = how many stones are jewels	;;;	Destroyed: AX, BX, SI, DIjewel:	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	;;;	Demodemo:	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 pointerdgt:	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	retsection	.data	db	'*****'		; Placeholder for ASCII number outputnum:	db	'\$'stones:	db	'aAAbbbb',0	; Example from the taskjewels:	db	'aA',0`
Output:
`3`

`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;`
Output:
```aAAbbbb    aA       3
ZZ         z        0```

## ALGOL 68

`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( "[email protected]"                         , "[email protected]"                         )           , newline           )         );    print( ( count jewels( "AB", "" ), newline ) );    print( ( count jewels( "ZZ", "z" ), newline ) ) END`
Output:
```         +3
+52
+0
+0```

## APL

Works with: Dyalog APL
`jewels ← +/∊⍨`
Output:
```      'aA' jewels 'aAAbbbb'
3```

## AppleScript

### Functional

`-- jewelCount :: String -> String -> Inton 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 -> Inton 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 send chars -- elem :: Eq a => a -> [a] -> Boolon elem(x, xs)    considering case        xs contains x    end consideringend 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 tellend filter -- foldl :: (a -> b -> a) -> a -> [b] -> aon 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 tellend 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 tellend 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 ifend 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 scriptend uncurry -- unlines :: [String] -> Stringon 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    strend unlines`
Output:
```3
0```

### Idiomatic

`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 counterend jewelsAndStones jewelsAndStones("aAAbBbb", "aAb")`
Output:
`6`

## Arturo

`count: function [jewels,stones][    size select split stones => [in? & jewels]] print count "aA" "aAAbbbb"`
Output:
`3`

## AutoHotkey

`JewelsandStones(ss, jj){	for each, jewel in StrSplit(jj)		for each, stone in StrSplit(ss)			if (stone == jewel)				num++	return num}`
Example:
`MsgBox % JewelsandStones("aAAbbbbz", "aAZ")return`
Outputs:
`3`

## AWK

`# syntax: GAWK -f JEWELS_AND_STONES.AWKBEGIN {    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)} `
Output:
```3
0```

## BASIC

`10 READ N%20 FOR A%=1 TO N%30 READ J\$,S\$40 GOSUB 10050 PRINT S\$;" in ";J\$;":";J%60 NEXT70 END 100 REM Count how many stones (S\$) are jewels (J\$). 110 DIM J%(127)120 J%=0130 FOR I%=1 TO LEN(J\$): J%(ASC(MID\$(J\$,I%,1)))=1: NEXT140 FOR I%=1 TO LEN(S\$): J%=J%+J%(ASC(MID\$(S\$,I%,1))): NEXT150 ERASE J%160 RETURN 200 DATA 2210 DATA "aA","aAAbbbb"220 DATA "z","ZZZZ" `
Output:
```aAAbbbb in aA: 3
ZZZZ in z: 0```

## 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 contend function print contar_joyas("aAAbbbb", "aA")print contar_joyas("ZZ", "z")print contar_joyas("[email protected]", "[email protected]jklmnopqrstuvwxyz")print contar_joyas("AB", "") `
Output:
```Igual que la entrada de FreeBASIC.
```

## 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")\$)`
Output:
```"aA" in "aAAbbbb": 3
"z" in "ZZ": 0```

## Bracmat

`  ( f  =   stones jewels N    .   !arg:(?stones.?jewels)      & 0:?N      & ( @( !stones           :   ?               (   %@                 : [%(   @(!jewels:? !sjt ?)                       & 1+!N:?N                     |                     )               & ~               )               ?           )        | !N        )  )& f\$(aAAbbbb.aA) `

Output

`3`

## C

Translation of: Kotlin
`#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;}`
Output:
```3
0
```

## C#

`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);    }}`
Output:
```3
0
```

## C++

Translation of: D
`#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;}`
Output:
```3
0```

## 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`
Output:
`"aA" in "aAAbbbb": 3`

## 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_mark[[jewels]] := 1;        jewels := @next jewels;    end loop;     count := 0;    while [stones] != 0 loop        count := count + jewel_mark[[stones]] 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");`
Output:
```aA in aAAbbbb: 3
z in ZZ: 0```

## Crystal

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

## D

Translation of: Kotlin
`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;}`
Output:
```3
0```

## 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;    countcorp 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`
Output:
```'aA' in 'aAAbbbb': 3
'z' in 'ZZ': 0```

## Dyalect

Translation of: Swift
`func countJewels(stones, jewels) {    stones.Iterate().Map(x => jewels.Contains(x) ? 1 : 0).Reduce((x,y) => x + y, 0)} print(countJewels("aAAbbbb", "aA"))print(countJewels("ZZ", "z"))`
Output:
```3
0```

## F#

` let fN jewels stones=stones|>Seq.filter(fun n->Seq.contains n jewels)|>Seq.lengthprintfn "%d" (fN "aA" "aAAbbbb") `
Output:
```3
```

## Factor

`USING: kernel prettyprint sequences ; : count-jewels ( stones jewels -- n ) [ member? ] curry count ; "aAAbbbb" "aA""ZZ" "z" [ count-jewels . ] [email protected]`
Output:
```3
0
```

## 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 ctend 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! `
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

` 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 = contend function print contar_joyas("aAAbbbb", "aA")print contar_joyas("ZZ", "z")print contar_joyas("[email protected]", _                   "[email protected]")print contar_joyas("AB", "") `
Output:
```3
0
53
0
```

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

`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"))}`
Output:
`3`

Outer loop jewels, count stones:

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

Construct jewel set, then loop over stones:

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

Construct stone multiset, then loop over jewels:

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

`jewelCount  :: Eq a  => [a] -> [a] -> IntjewelCount 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")] `
Output:
```3
0```

Or in terms of filter rather than foldr

`jewelCount  :: Eq a  => [a] -> [a] -> IntjewelCount jewels = length . filter (`elem` jewels) --------------------------- TEST -------------------------main :: IO ()main = do  print \$ jewelCount "aA" "aAAbbbb"  print \$ jewelCount "z" "ZZ"`
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 =: ([: +/ [: , =/~) [email protected]:intersect&Alpha_j_    'aAAbbbb ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz' jewels&>&;: 'aA ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz'3 52    'none' jewels ''0   'ZZ' jewels 'z'0  `

## 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"));    }}`
Output:
```3
0```

## 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))})();`
Output:
`[3, 0]`

## 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'`
Output:
`3`

## Julia

Module:

`module Jewels count(s, j) = Base.count(x ∈ j for x in s) end  # module Jewels`

Main:

`@show Jewels.count("aAAbbbb", "aA")@show Jewels.count("ZZ", "z")`
Output:
```Jewels.count("aAAbbbb", "aA") = 3
Jewels.count("ZZ", "z") = 0```

## Kotlin

`// 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"))}`
Output:
```3
0
```

## Lambdatalk

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

## Lua

Translation of: C
`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 countend print(count_jewels("aAAbbbb", "aA"))print(count_jewels("ZZ", "z"))`
Output:
```3
0```

## 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")`
Output:
`3`

## Mathematica / Wolfram Language

`JewelsStones[j_String, s_String] := Count[MemberQ[Characters[j], #] & /@ Characters[s], True]JewelsStones["aA", "aAAbbbb"]JewelsStones["ZZ", "z"]`
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) `

## min

Works with: min version 0.19.6
`(('' '' '') => 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!`
Output:
```3
0
```

## Modula-2

`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 cEND CountJewels; BEGIN    WriteInt(CountJewels("aAAbbbb", "aA"));    WriteLn;    WriteInt(CountJewels("ZZ", "z"));    WriteLn;     ReadCharEND Jewels.`
Output:
```3
0```

## Nim

`import sequtils func countJewels(stones, jewels: string): Natural =  stones.countIt(it in jewels) echo countJewels("aAAbbbb", "aA")echo countJewels("ZZ", "z")`
Output:
```3
0```

## Objeck

Translation of: Java
`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;  }}`
Output:
```3
0
```

## 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';`
Output:
```3
0```

### Alternate using regex

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Jewels_and_Stones#Perluse warnings; sub count_jewels { scalar( () =  \$_[0] =~ /[ \$_[1] ]/gx ) } # stones, jewels print "\$_ = ", count_jewels( split ), "\n" for split /\n/, <<END;aAAbbbb aAaAAbbbb abcZZ zEND`
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
```

## Picat

### List comprehension

`jewels_and_stones1(Jewels,Stones) = sum([1 : S in Stones, J in Jewels, S == J]).`

### Recursion

`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 stonesjewels_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).`

### Foreach loop

`jewels_and_stones3(Jewels,Stones) = N =>  N = 0,  foreach(J in Jewels, S in Stones)     if J == S then       N := N + 1     end  end.`

### Test

`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.`
Output:
```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```

### 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).

`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.`
Output:
```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.```

The recursion approach (`jewels_and_stones2/2`) is a little faster than the loop approach (`jewels_and_stones/3`).

## PL/M

`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`
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).  `
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
`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).`
Output:
```Welcome to SWI-Prolog (threaded, 64 bits, version 8.0.2)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.

For built-in help, use ?- help(Topic). or ?- apropos(Word).

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

## Python

`def countJewels(s, j):    return sum(x in j for x in s) print countJewels("aAAbbbb", "aA")print countJewels("ZZ", "z")`
Output:
```3
0```

### Python 3 Alternative

`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"))`
Output:
```3
0```

## 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")) `
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

`  [ 0 0 rot     witheach [ bit | ]     rot witheach      [ bit over & if           [ dip 1+ ] ]     drop ]             is j&s ( \$ \$ --> n )   \$ "aAAbbbb" \$  "aA" j&s echo`
Output:
`3`

## 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")) `
Output:
```3
0```

## Raku

(formerly Perl 6)

`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';`
Output:
```3
0```

## Red

`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"`
Output:
```3
0
```

## REXX

Programming note:   a check is made so that only (Latin) letters are counted as a match.

`/*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. */`
output   when using the default inputs:
```3
0```

## Ring

`# Project  Jewels and Stones jewels = "aA"stones = "aAAbbbb"see jewelsandstones(jewels,stones) + nljewels = "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 `

Output:

```3
0```

## Ruby

`stones, jewels = "aAAbbbb", "aA" stones.count(jewels)  # => 3 `

## 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"));} `
Output:
```3
0```

## 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"))}`
Output:
See it in running in your browser by ScalaFiddle (JavaScript) or by Scastie (JVM).

## Sidef

`func countJewels(s, j) {    s.chars.count { |c|        j.contains(c)    }} say countJewels("aAAbbbb", "aA")    #=> 3say countJewels("ZZ", "z")          #=> 0`

## 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`
Output:
```3
0```

## SQL

`-- See how many jewels are among the stonesDECLARE @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 @SDECLARE @JPOS	INT = 1;	-- curr position in @JDECLARE @FCHR	CHAR(1);	-- char to find while @JPOS <= @JLENBEGIN 	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;ENDprint 'J='+@J+' S='+@S+' TOTAL = '+CAST(@TCNT AS VARCHAR(8)); `
Output:
```J=aA S=AaBbCcAa TOTAL = 4
```

## 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"))`
Output:
```3
0```

## 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]`
Output:
```3
0
```

## Terraform

`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)}`
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 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")))}`
Output:
```3
0
```

## VBA

Translation of: Phix
`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 = resEnd FunctionPublic Sub main()    Debug.Print count_jewels("aAAbbbb", "aA")    Debug.Print count_jewels("ZZ", "z")End Sub`
Output:
``` 3
0 ```

## Visual Basic .NET

Translation of: C#
`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`
Output:
```3
0```

## Vlang

Translation of: Go
`fn js(stones string, jewels string) int {	mut n := 0    for b in stones.bytes() {        if jewels.index_u8(b) >= 0 {            n++        }    }    return n} fn main() {    println(js("aAAbbbb", "aA"))}`
Output:
```3
```

## Wren

Translation of: Kotlin
`var countJewels = Fn.new { |s, j| s.count { |c| j.contains(c) } } System.print(countJewels.call("aAAbbbb", "aA"))System.print(countJewels.call("ZZ", "z"))`
Output:
```3
0
```

## XPL0

`string 0;       \Use zero-terminated strings func Count(Stones, Jewels);\Return number of letters in Stones that match letters in Jewelschar 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);]`
Output:
```3
0
11
```

## zkl

`fcn countJewels(a,b){ a.inCommon(b).len() }`
`println(countJewels("aAAbbbb", "aA"));println(countJewels("ZZ", "z"));`
Output:
```3
0```