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

From Rosetta Code


Task
Jewels and stones
You are encouraged to solve this task according to the task description, using any language you may know.
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:

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


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



8080 Assembly[edit]

	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
Output:
3


8086 Assembly[edit]

	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
Output:
3

Ada[edit]

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[edit]

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[edit]

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


AppleScript[edit]

Functional[edit]

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

Idiomatic[edit]

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")
Output:
6

AutoHotkey[edit]

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[edit]

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

BASIC[edit]

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"
 
Output:
aAAbbbb in aA: 3
ZZZZ in z: 0

BASIC256[edit]

 
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("[email protected]", "[email protected]")
print contar_joyas("AB", "")
 
Output:
Igual que la entrada de FreeBASIC.

Bracmat[edit]

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

Output

3

C[edit]

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#[edit]

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++[edit]

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

D[edit]

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

F#[edit]

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

Factor[edit]

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

Euphoria[edit]

 
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!
 
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[edit]

 
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("[email protected]", _
"[email protected]")
print contar_joyas("AB", "")
 
Output:
3
0
53
0

Go[edit]

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
}

Haskell[edit]

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

Or in terms of filter rather than foldr

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

J[edit]

 
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[edit]

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[edit]

(() => {
 
// 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[edit]

$ 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[edit]

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[edit]

// 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[edit]

 
{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[edit]

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 count
end
 
print(count_jewels("aAAbbbb", "aA"))
print(count_jewels("ZZ", "z"))
Output:
3
0

Maple[edit]

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


MATLAB / Octave[edit]

 
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[edit]

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[edit]

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

Objeck[edit]

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[edit]

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[edit]

#!/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
Output:
aAAbbbb aA = 3
aAAbbbb abc = 5
ZZ z = 0

Phix[edit]

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

Prolog[edit]

 
 
:- 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[edit]

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.
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[edit]

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[edit]

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

Racket[edit]

#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[edit]

(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

REXX[edit]

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[edit]

# 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
 

Output:

3
0

Ruby[edit]

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

Rust[edit]

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[edit]

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[edit]

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

Snobol[edit]

*       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

Swift[edit]

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[edit]

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[edit]

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

VBA[edit]

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 = res
End Function
Public Sub main()
Debug.Print count_jewels("aAAbbbb", "aA")
Debug.Print count_jewels("ZZ", "z")
End Sub
Output:
 3 
 0 

Visual Basic .NET[edit]

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

Wren[edit]

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

zkl[edit]

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