Jewels and stones
Create a function which takes two string parameters: 'stones' and 'jewels' and returns an integer.
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
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.
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contains most consonants
- Find words which contains more than 3 vowels
- Find words which first and last three letters are equals
- Find words which odd letters are consonants and even letters are vowels or vice_versa
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 Bottles of Beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
11l
<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
8080 Assembly
<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:
3
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:
3
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:
+3 +52 +0 +0
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:
<lang applescript>6</lang>
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:
3
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.
Bracmat
<lang Bracmat> ( f
= stones jewels N . !arg:(?stones.?jewels) & 0:?N & ( @( !stones : ? ( %@ : [%( @(!jewels:? !sjt ?) & 1+!N:?N | ) & ~ ) ? ) | !N ) )
& f$(aAAbbbb.aA) </lang> Output
3
C
<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++
<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
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
D
<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
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:
3
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:
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: <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:
3
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
<lang 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:
3
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
<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:
3
MATLAB / Octave
<lang Matlab>
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
<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
Objeck
<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
<lang 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")</lang>
- Output:
3 0
Prolog
<lang 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
<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
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
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
VBA
<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
<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
<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