Jewels and stones: Difference between revisions
add ABC
Catskill549 (talk | contribs) |
Not a robot (talk | contribs) (add ABC) |
||
| (144 intermediate revisions by 64 users not shown) | |||
Line 1:
[[Category:Puzzles]]
{{task}}
;Task:
Line 8 ⟶ 10:
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 [https://en.wikipedia.org/wiki/ISO_basic_Latin_alphabet 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 [https://leetcode.com/problems/jewels-and-stones/description/ this problem].
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight 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’))</syntaxhighlight>
{{out}}
<pre>
3
0
</pre>
=={{header|360 Assembly}}==
<syntaxhighlight lang="360asm">* Jewels and stones - 24/04/2023
JEWELS CSECT
USING JEWELS,R13 base register
B 72(R15) skip savearea
DC 17F'0' savearea
SAVE (14,12) save previous context
ST R13,4(R15) link backward
ST R15,8(R13) link forward
LR R13,R15 set addressability
LA R7,EX1 @ex(1,1)
LA R6,1 i=1
DO WHILE=(CH,R6,LE,N) do i=1 to n
MVC CSTO,0(R7) csto=ex(i,1)
MVC CJEW,16(R7) cjew=ex(i,2)
BAL R14,COUNT r0=count(csto,cjew)
LR R1,R0 count
XDECO R1,XDEC edit count
MVC PG(6),XDEC+6 output count
XPRNT PG,L'PG print buffer
LA R7,32(R7) @ex+=32
LA R6,1(R6) i++
ENDDO , enddo i
FIN L R13,4(0,R13) restore previous savearea pointer
RETURN (14,12),RC=0 restore registers from calling save
*
COUNT CNOP 0,4 count(csto,cjew) -------------------
STM R2,R14,COUNTSA save context
MVC CC,CSTO cc=csto
BAL R14,LENGTH call length(csto)
STH R0,LCSTO lcsto=length(csto)
MVC CC,CJEW cc=cjew
BAL R14,LENGTH call length(cjew)
STH R0,LCJEW lcjew=length(cjew)
XR R3,R3 ret=0
LA R6,1 i=1
DO WHILE=(CH,R6,LE,LCSTO) do i=1 to length(csto)
LA R2,CSTO-1 @csto-1
AR R2,R6 @csto-1+i
MVC C,0(R2) c=substr(csto,i,1)
SR R1,R1 k=0 ....index(cjew,c)...........
LA R7,1 j=1 |
DO WHILE=(CH,R7,LE,LCJEW) do j=1 to length(cjew) |
LA R9,CJEW-1 @cjew-1 |
AR R9,R7 @cjew-1+j |
IF CLC,0(1,R9),EQ,C THEN if substr(cjew,j,1)=c then |
LR R1,R7 k=j |
ENDIF , endif |
LA R7,1(R7) j++ |
ENDDO , enddo j ........................
IF LTR,R1,NZ,R1 THEN if index(cjew,c)<>0 then
LA R3,1(R3) ret=ret+1
ENDIF , endif
LA R6,1(R6) i++
ENDDO , enddo i
LR R0,R3 return value ret
LM R2,R14,COUNTSA restore context
BR R14 return
COUNTSA DS 14A context store -- end count ---------
*
LENGTH CNOP 0,4 length(cc) -------------------------
STM R2,R14,LENGTSA save context
LA R10,0 l=0
LA R9,CC @cc
LA R8,1 k=1
DO WHILE=(C,R8,LE,=A(16)) do k=1 to 16
MVC C,0(R9) c=subsctr(cc,k,1)
IF CLC,C,NE,=C' ' THEN if c<>' ' then
LA R10,1(R10) l=l+1
ELSE , else
B LEAVEK leave k
ENDIF , endif
LA R9,1(R9) @cc++
LA R8,1(R8) k++
ENDDO , enddo k
LEAVEK LR R0,R10 set return value
LM R2,R14,LENGTSA restore context
BR R14 return
LENGTSA DS 14A context store -- end length --------
*
N DC H'2' n
EX1 DC CL16'aAAbbbb' stones(1)
DC CL16'aA' jewels(1)
EX2 DC CL16'ZZ' stones(2)
DC CL16'z' jewels(2)
CSTO DS CL16 csto
CJEW DS CL16 cjew
LCSTO DS H length of csto
LCJEW DS H length of cjew
CC DS CL16 cc
C DS CL1 c
PG DC CL80' ' buffer
XDEC DS CL12 temp for xdeco
REGEQU
END JEWELS</syntaxhighlight>
{{out}}
<pre>
3
0
</pre>
=={{header|8080 Assembly}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|8086 Assembly}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program jewels64.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/************************************/
/* Initialized data */
/************************************/
.data
szMessResult: .asciz "Result: "
szStone1: .asciz "aAAbbbb"
szJewels1: .asciz "aA"
szStone2: .asciz "ZZ"
szJewels2: .asciz "z"
szCarriageReturn: .asciz "\n"
szMessStart: .asciz "Program 64 bits start.\n"
/************************************/
/* UnInitialized data */
/************************************/
.bss
sZoneConv: .skip 24
/************************************/
/* code section */
/************************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
ldr x0,qAdrszStone1
ldr x1,qAdrszJewels1
bl countJewels
ldr x0,qAdrszStone2
ldr x1,qAdrszJewels2
bl countJewels
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc 0 // perform the system call
qAdrszStone1: .quad szStone1
qAdrszJewels1: .quad szJewels1
qAdrszStone2: .quad szStone2
qAdrszJewels2: .quad szJewels2
qAdrsZoneConv: .quad sZoneConv
qAdrszMessResult: .quad szMessResult
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszMessStart: .quad szMessStart
/***************************************************/
/* count jewels in stone */
/***************************************************/
/* r0 contains stone address */
/* r1 contains jewels address */
/* r0 return jewels count */
countJewels:
stp x1,lr,[sp,-16]!
stp x2,x3,[sp,-16]!
stp x4,x5,[sp,-16]!
stp x6,x7,[sp,-16]!
mov x4,#0 // counter
mov x3,#0 // index stone
1:
ldrb w6,[x0,x3] // load byte of stone
cmp x6,#0 // end stone ?
beq 3f
mov x5,#0 // index jewels
2:
ldrb w2,[x1,x5] // load byte of jewels
cmp x2,#0 // end jewels ?
cinc x3,x3,eq // yes -> increment index stone
beq 1b // and loop
cmp x6,x2 // compare byte
cinc x5,x5,ne // not equal -> increment jewels index
bne 2b // and loop
add x4,x4,#1 // else increment counter
add x3,x3,#1 // incremente index stone
b 1b // and loop
3: // result display
mov x0,x4
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessResult
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrszCarriageReturn
bl affichageMess
mov x0,x4
100:
ldp x6,x7,[sp],16
ldp x4,x5,[sp],16
ldp x2,x3,[sp],16
ldp x1,lr,[sp],16
ret
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 64 bits start.
Result: 3
Result: 0
</pre>
=={{header|ABC}}==
<syntaxhighlight lang="abc">HOW TO RETURN stones count.in jewels:
PUT 0 IN count
FOR stone IN stones:
IF stone in jewels: PUT count+1 IN count
RETURN count
WRITE "aAAbbbb" count.in "aA"/
WRITE "ZZ" count.in "z"/</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Ada}}==
<syntaxhighlight 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;</syntaxhighlight>
{{out}}
<pre>aAAbbbb aA 3
ZZ z 0</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre> +3
+52
+0
+0</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">jewels ← +/∊⍨</syntaxhighlight>
{{out}}
<pre> 'aA' jewels 'aAAbbbb'
3</pre>
=={{header|AppleScript}}==
===Functional===
<syntaxhighlight 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</syntaxhighlight>
{{Out}}
<pre>3
0</pre>
----
===Idiomatic===
<syntaxhighlight 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")</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">6</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program jewels.s */
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language ARM assembly*/
.include "../constantes.inc"
/************************************/
/* Initialized data */
/************************************/
.data
szMessResult: .asciz "Result: "
szStone1: .asciz "aAAbbbb"
szJewels1: .asciz "aA"
szStone2: .asciz "ZZ"
szJewels2: .asciz "z"
szCarriageReturn: .asciz "\n"
szMessStart: .asciz "Program 32 bits start.\n"
/************************************/
/* UnInitialized data */
/************************************/
.bss
sZoneConv: .skip 24
/************************************/
/* code section */
/************************************/
.text
.global main
main: @ entry of program
ldr r0,iAdrszMessStart
bl affichageMess
ldr r0,iAdrszStone1
ldr r1,iAdrszJewels1
bl countJewels
ldr r0,iAdrszStone2
ldr r1,iAdrszJewels2
bl countJewels
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform the system call
iAdrszStone1: .int szStone1
iAdrszJewels1: .int szJewels1
iAdrszStone2: .int szStone2
iAdrszJewels2: .int szJewels2
iAdrsZoneConv: .int sZoneConv
iAdrszMessResult: .int szMessResult
iAdrszCarriageReturn: .int szCarriageReturn
iAdrszMessStart: .int szMessStart
/***************************************************/
/* count jewels in stone */
/***************************************************/
/* r0 contains stone address */
/* r1 contains jewels address */
/* r0 return jewels count */
countJewels:
push {r1-r6,lr} @ save registers
mov r4,#0 @ counter
mov r3,#0 @ index stone
1:
ldrb r6,[r0,r3] @ load byte of stone
cmp r6,#0 @ end stone ?
beq 3f
mov r5,#0 @ index jewels
2:
ldrb r2,[r1,r5] @ load byte of jewels
cmp r2,#0 @ end jewels ?
addeq r3,r3,#1 @ yes -> increment index stone
beq 1b @ and loop
cmp r6,r2 @ compare byte
addne r5,r5,#1 @ not equal -> increment jewels index
bne 2b @ and loop
add r4,r4,#1 @ else increment counter
add r3,r3,#1 @ incremente index stone
b 1b @ and loop
3: @ result display
mov r0,r4
ldr r1,iAdrsZoneConv
bl conversion10
ldr r0,iAdrszMessResult
bl affichageMess
ldr r0,iAdrsZoneConv
bl affichageMess
ldr r0,iAdrszCarriageReturn
bl affichageMess
mov r0,r4
100:
pop {r1-r6,pc}
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language ARM assembly*/
.include "../affichage.inc"
</syntaxhighlight>
{{Out}}
with the file unixdict.txt
<pre>
Program 32 bits start.
Result: 3
Result: 0
</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">count: function [jewels,stones][
size select split stones => [in? & jewels]
]
print count "aA" "aAAbbbb"</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">JewelsandStones(ss, jj){
for each, jewel in StrSplit(jj)
for each, stone in StrSplit(ss)
if (stone == jewel)
num++
return num
}</syntaxhighlight>
Example:<syntaxhighlight lang="autohotkey">MsgBox % JewelsandStones("aAAbbbbz", "aAZ")
return</syntaxhighlight>
Outputs:<pre>3</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk"># syntax: GAWK -f JEWELS_AND_STONES.AWK
BEGIN {
printf("%d\n",count("aAAbbbb","aA"))
Line 38 ⟶ 789:
return(total)
}
</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|BASIC}}==
<syntaxhighlight 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"
</syntaxhighlight>
{{out}}
<pre>aAAbbbb in aA: 3
ZZZZ in z: 0</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">
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", "")
</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="vb">100 cls
110 print contjoyas("aAAbbbb","aA")
120 print contjoyas("ZZ","z")
130 print contjoyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz","ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")
140 print contjoyas("AB","")
150 end
160 sub contjoyas(piedras$,joyas$)
180 sgte = 0
190 for i = 1 to len(piedras$)
200 bc = instr(joyas$,mid$(piedras$,i,1))
210 if bc <> 0 then sgte = sgte+1
220 next i
230 contjoyas = sgte
240 end sub</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="vb">
function contar_joyas(piedras as string, joyas as string) as integer
dim as integer bc, 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", "")
</syntaxhighlight>
{{out}}
<pre>3
0
53
0</pre>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">window 1, @"Jewels and Stones"
local fn JewelsAndStones( jewels as CFStringRef, stones as CFStringRef ) as long
long index, count = 0
for index = 0 to len(stones) - 1
if ( fn StringContainsString( jewels, mid(stones,index,1) ) ) then count++
next
end fn = count
print fn JewelsAndStones( @"aA", @"aAAbbbb" )
print fn JewelsAndStones( @"z", @"ZZ" )
HandleEvents</syntaxhighlight>
{{out}}
<pre>3
0</pre>
==={{header|GW-BASIC}}===
{{works with|QBasic}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|MSX BASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
<syntaxhighlight lang="qbasic">100 CLS
110 piedras$ = "aAAbbbb"
120 joyas$ = "aA"
130 GOSUB 240: PRINT cntjoyas
140 piedras$ = "ZZ"
150 joyas$ = "z"
160 GOSUB 240: PRINT cntjoyas
170 piedras$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz"
180 joyas$ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz"
190 GOSUB 240: PRINT cntjoyas
200 piedras$ = "AB"
210 joyas$ = ""
220 GOSUB 240: PRINT cntjoyas
230 END
240 sgte = 0
250 FOR i = 1 TO LEN(piedras$)
260 bc = INSTR(joyas$, MID$(piedras$, i, 1))
270 IF bc <> 0 THEN sgte = sgte + 1
280 NEXT i
290 cntjoyas = sgte
300 RETURN
310 END</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|MSX Basic}}===
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION contarjoyas (piedras$, joyas$)
cont = 0
FOR i = 1 TO LEN(piedras$)
bc = INSTR(1, joyas$, MID$(piedras$, i, 1))
IF bc <> 0 THEN cont = cont + 1
NEXT i
contarjoyas = cont
END FUNCTION
PRINT contarjoyas("aAAbbbb", "aA")
PRINT contarjoyas("ZZ", "z")
PRINT contarjoyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")
PRINT contarjoyas("AB", "")
END</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="vb">sub contar_joyas(piedras$, joyas$)
local count, i, bc
cont = 0
for i = 1 to len(piedras$)
bc = instr(joyas$, mid$(piedras$, i, 1))
if bc <> 0 cont = cont + 1
next i
return cont
end sub
print contar_joyas("aAAbbbb", "aA")
print contar_joyas("ZZ", "z")
print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")
print contar_joyas("AB", "")
end</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION contarjoyas(piedras$, joyas$)
LET c = 0
FOR i = 1 TO LEN(piedras$)
LET bc = POS(joyas$,(piedras$)[i:i+1-1],1)
IF bc <> 0 THEN LET c = c + 1
NEXT i
LET contarjoyas = c
END FUNCTION
PRINT contarjoyas("aAAbbbb", "aA")
PRINT contarjoyas("ZZ", "z")
PRINT contarjoyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")
PRINT contarjoyas("AB", "")
END</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|VBA}}===
{{trans|Phix}}<syntaxhighlight 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</syntaxhighlight>{{out}}
<pre> 3
0 </pre>
==={{header|Visual Basic .NET}}===
{{trans|C#}}
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>3
0</pre>
==={{header|Yabasic}}===
<syntaxhighlight lang="vb">print contar_joyas("aAAbbbb", "aA")
print contar_joyas("ZZ", "z")
print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")
print contar_joyas("AB", "")
end
sub contar_joyas(piedras$, joyas$)
local count, i, bc
cont = 0
for i = 1 to len(piedras$)
bc = instr(joyas$, mid$(piedras$, i, 1))
if bc <> 0 cont = cont + 1
next i
return cont
end sub</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
let jewels(j, s) = valof
$( let jewel = vec 255
let count = 0
for i = 0 to 255 do jewel!i := false
for i = 1 to j%0 do jewel!(j%i) := true
for i = 1 to s%0 do
if jewel!(s%i) then
count := count + 1
resultis count
$)
let show(j, s) be
writef("*"%S*" in *"%S*": %N*N", j, s, jewels(j, s))
let start() be
$( show("aA", "aAAbbbb")
show("z", "ZZ")
$)</syntaxhighlight>
{{out}}
<pre>"aA" in "aAAbbbb": 3
"z" in "ZZ": 0</pre>
=={{header|BQN}}==
Similar in nature to APL, mostly due to how trivial the problem is in an array language.
<syntaxhighlight lang="bqn">Jewels←+´∊˜</syntaxhighlight>
<syntaxhighlight lang="text"> "aA" Jewels "aAAbbbb"
3</syntaxhighlight>
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat"> ( f
= stones jewels N
. !arg:(?stones.?jewels)
& 0:?N
& ( @( !stones
: ?
( %@
: [%( @(!jewels:? !sjt ?)
& 1+!N:?N
|
)
& ~
)
?
)
| !N
)
)
& f$(aAAbbbb.aA)
</syntaxhighlight>
'''Output'''
<pre>3</pre>
=={{header|C}}==
{{trans|Kotlin}}
<
#include <string.h>
int count_jewels(const char *s, const char *j) {
int
for (
return count;
}
Line 59 ⟶ 1,120:
printf("%d\n", count_jewels("ZZ", "z"));
return 0;
}</
{{output}}
Line 65 ⟶ 1,126:
3
0
</pre>
=={{header|C sharp}}==
<syntaxhighlight 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);
}
}</syntaxhighlight>
{{out}}
<pre>
3
0
</pre>
=={{header|C++}}==
{{trans|D}}
<syntaxhighlight 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;
}</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|CLU}}==
<syntaxhighlight lang="clu">count_jewels = proc (jewels, stones: string) returns (int)
is_jewel: array[bool] := array[bool]$fill(0, 256, false)
for c: char in string$chars(jewels) do
is_jewel[char$c2i(c)] := true
end
n_jewels: int := 0
for c: char in string$chars(stones) do
if is_jewel[char$c2i(c)] then n_jewels := n_jewels + 1 end
end
return (n_jewels)
end count_jewels
show = proc (jewels, stones: string)
po: stream := stream$primary_output()
stream$putl(po, "\"" || jewels || "\" in \"" || stones || "\": "
|| int$unparse(count_jewels(jewels, stones)))
end show
start_up = proc ()
show("aA", "aAAbbbb")
end start_up</syntaxhighlight>
{{out}}
<pre>"aA" in "aAAbbbb": 3</pre>
=={{header|Cowgol}}==
<syntaxhighlight 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_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");</syntaxhighlight>
{{out}}
<pre>aA in aAAbbbb: 3
z in ZZ: 0</pre>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">stones, jewels = "aAAbbbb", "aA"
stones.count(jewels) # => 3
# The above solution works for that case, but fails with certain other "jewels":
stones, jewels = "aA^Bb", "^b"
stones.count(jewels) # => 4
# '^b' in the "jewels" is read as "characters other than 'b'".
# This works as intended though:
stones.count { |c| jewels.chars.includes?(c) } # => 2</syntaxhighlight>
=={{header|D}}==
{{trans|Kotlin}}
<syntaxhighlight 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;
}</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|classes, SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
function CommonLetters(S1,S2: string): integer;
{Count the number of letters in S1 are found in S2}
var I, J: integer;
begin
Result:=0;
for I:=1 to Length(S1) do
for J:=1 to Length(S2) do
if S1[I]=S2[J] then Inc(Result);
end;
procedure ShowJewelsStones(Memo: TMemo; Jewels,Stones: string);
{Show one Jewels-Stones comparison}
begin
Memo.Lines.Add(Jewels+' '+Stones+' '+IntToStr(CommonLetters(Jewels,Stones)));
end;
procedure TestJewelsStones(Memo: TMemo);
begin
ShowJewelsStones(Memo,'aAAbbbb', 'aA');
ShowJewelsStones(Memo,'ZZ','z');
end;
</syntaxhighlight>
{{out}}
<pre>
aAAbbbb aA 3
ZZ z 0
</pre>
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc nonrec count_jewels(*char jewels, stones) word:
[256] bool jewel;
word count;
byte i;
char c;
for i from 0 upto 255 do jewel[i] := false od;
while c := jewels*; c ~= '\e' do
jewel[c] := true;
jewels := jewels + 1;
od;
count := 0;
while c := stones*; c ~= '\e' do
if jewel[c] then count := count + 1 fi;
stones := stones + 1
od;
count
corp
proc nonrec show(*char jewels, stones) void:
writeln("'", jewels, "' in '", stones, "': ", count_jewels(jewels, stones))
corp
proc nonrec main() void:
show("aA", "aAAbbbb");
show("z", "ZZ")
corp</syntaxhighlight>
{{out}}
<pre>'aA' in 'aAAbbbb': 3
'z' in 'ZZ': 0</pre>
=={{header|Dyalect}}==
{{trans|Swift}}
<syntaxhighlight lang="dyalect">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"))</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
func count stones$ jewels$ .
len d[] 65536
for c$ in strchars jewels$
d[strcode c$] = 1
.
for c$ in strchars stones$
if d[strcode c$] = 1
cnt += 1
.
.
return cnt
.
print count "aAAbbbb" "aA"
print count "ZZ" "z"
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
let fN jewels stones=stones|>Seq.filter(fun n->Seq.contains n jewels)|>Seq.length
printfn "%d" (fN "aA" "aAAbbbb")
</syntaxhighlight>
{{out}}
<pre>
3
</pre>
=={{header|Factor}}==
<
: count-jewels ( stones jewels -- n ) [ member? ] curry count ;
"aAAbbbb" "aA"
"ZZ" "z" [ count-jewels . ] 2bi@</
{{out}}
<pre>
Line 78 ⟶ 1,404:
0
</pre>
=={{header|Euphoria}}==
<syntaxhighlight 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!
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|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:'''
<syntaxhighlight 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"))
}</syntaxhighlight>
{{out}}
<pre>3</pre>
'''Outer loop jewels, count stones:'''
<syntaxhighlight lang="go">func js(stones, jewels string) (n int) {
for _, b := range []byte(jewels) {
n += strings.Count(stones, string(b))
}
return
}</syntaxhighlight>
'''Construct jewel set, then loop over stones:'''
<syntaxhighlight 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
}</syntaxhighlight>
'''Construct stone multiset, then loop over jewels:'''
<syntaxhighlight 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
}</syntaxhighlight>
=={{header|Haskell}}==
<syntaxhighlight 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")]
</syntaxhighlight>
{{Out}}
<pre>3
0</pre>
Or in terms of filter rather than foldr
<syntaxhighlight 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"</syntaxhighlight>
{{Out}}
<pre>3
0</pre>
=={{header|J}}==
<syntaxhighlight 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
</syntaxhighlight>
A simpler implementation, which satisfies the task requirements but does not explicitly ignore non-letters, would be:
<syntaxhighlight lang=J>jewels=: +/@e.</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight 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"));
}
}</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Javascript}}==
<syntaxhighlight 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))
})();</syntaxhighlight>
{{Out}}
<pre>[3, 0]</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE jewels == [in 1 0 choice +] cons 0 swap fold.
"aAAbbbb" "aA" jewels.
"ZZ" "z" jewels.</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|jq}}==
<syntaxhighlight 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'</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|Julia}}==
'''Module''':
<syntaxhighlight lang="julia">module Jewels
count(s, j) = Base.count(x ∈ j for x in s)
end # module Jewels</syntaxhighlight>
'''Main''':
<syntaxhighlight lang="julia">@show Jewels.count("aAAbbbb", "aA")
@show Jewels.count("ZZ", "z")</syntaxhighlight>
{{out}}
<pre>Jewels.count("aAAbbbb", "aA") = 3
Jewels.count("ZZ", "z") = 0</pre>
=={{header|K}}==
<syntaxhighlight lang="k">jewels: +/~^?
jewels["aA";"aAAbbbb"]</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|Kotlin}}==
<
fun countJewels(s: String, j: String) = s.count { it in j }
Line 87 ⟶ 1,639:
println(countJewels("aAAbbbb", "aA"))
println(countJewels("ZZ", "z"))
}</
{{out}}
<pre>
3
0
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight 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
</syntaxhighlight>
=={{header|Lua}}==
{{trans|C}}
<syntaxhighlight 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"))</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|MACRO-11}}==
<syntaxhighlight lang="macro11"> .TITLE JWLSTN
.MCALL .TTYOUT,.EXIT
JWLSTN::JMP DEMO
; COUNT JEWELS R1 IN STONES R0, ANSWER IN R2
COUNT: MOV #200,R2 ; CLEAR JEWELS
MOV #6$,R3
1$: CLR (R3)+
SOB R2,1$
BR 3$
2$: MOVB #1,6$(R2) ; MARK JEWELS
3$: MOVB (R1)+,R2
BNE 2$
BR 5$
4$: MOVB 6$(R1),R3 ; COUNT JEWELS IN STONES
ADD R3,R2
5$: MOVB (R0)+,R1
BNE 4$
RTS PC
6$: .BLKB 400
DEMO: MOV #TESTS,R4
1$: MOV (R4)+,R1 ; READ TEST CASE
MOV (R4)+,R0
BEQ 2$ ; DONE?
JSR PC,COUNT ; COUNT
MOV R2,R0 ; DISPLAY RESULT
ADD #60,R0
.TTYOUT
MOV #15,R0
.TTYOUT
MOV #12,R0
.TTYOUT
BR 1$ ; NEXT
2$: .EXIT
TESTS: .WORD 1$,2$,3$,4$,0,0
1$: .ASCIZ /aA/
2$: .ASCIZ /aAAbbbb/
3$: .ASCIZ /z/
4$: .ASCIZ /ZZ/
.END JWLSTN</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Maple}}==
<syntaxhighlight 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")</syntaxhighlight>
{{Out|Output}}
<pre>3</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">JewelsStones[j_String, s_String] := Count[MemberQ[Characters[j], #] & /@ Characters[s], True]
JewelsStones["aA", "aAAbbbb"]
JewelsStones["ZZ", "z"]</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight 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)
</syntaxhighlight>
=={{header|min}}==
{{works with|min|0.19.6}}
<syntaxhighlight 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!</syntaxhighlight>
{{out}}
<pre>
3
Line 95 ⟶ 1,787:
</pre>
=={{header|
<syntaxhighlight 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.</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import sequtils
func countJewels(stones, jewels: string): Natural =
stones.countIt(it in jewels)
echo countJewels("aAAbbbb", "aA")
echo countJewels("ZZ", "z")</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Objeck}}==
{{trans|Java}}
<syntaxhighlight 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;
}
}</syntaxhighlight>
{{out}}
<pre>
3
0
</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let jewels j s =
String.(fold_left (fun n c -> if contains j c then succ n else n) 0 s)</syntaxhighlight>
=={{header|Perl}}==
<syntaxhighlight 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';</syntaxhighlight>
{{out}}
<pre>3
0</pre>
===Alternate using regex===
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>
aAAbbbb aA = 3
aAAbbbb abc = 5
ZZ z = 0
</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">stones</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">jewels</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stones</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stones</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">jewels</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"aAAbbbb"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"aA"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"ZZ"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"z"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
3
0
</pre>
=={{header|Picat}}==
===List comprehension===
<syntaxhighlight lang="picat">jewels_and_stones1(Jewels,Stones) = sum([1 : S in Stones, J in Jewels, S == J]).</syntaxhighlight>
===Recursion===
<syntaxhighlight lang="picat">jewels_and_stones2(Jewels,Stones) = N =>
jewels_and_stones2(Jewels,Stones,0,N).
jewels_and_stones2([],_Stones,N,N).
jewels_and_stones2([J|Jewels],[S|Stones],N0,N) :-
jewels_and_stones2_(J,[S|Stones],0,JN),
jewels_and_stones2(Jewels,Stones,N0+JN,N).
% Check just this jewel on all the stones
jewels_and_stones2_(_J,[],N,N).
jewels_and_stones2_(J,[S|Stones],N0,N) :-
( J == S ->
N1 = N0+1
;
N1 = N0
),
jewels_and_stones2_(J,Stones,N1,N).</syntaxhighlight>
===Foreach loop===
<syntaxhighlight lang="picat">jewels_and_stones3(Jewels,Stones) = N =>
N = 0,
foreach(J in Jewels, S in Stones)
if J == S then
N := N + 1
end
end.</syntaxhighlight>
===Test===
<syntaxhighlight lang="picat">go =>
Tests = [["aA","aAAbbbb"],
["z","ZZ"]
],
println(tests=Tests),
foreach([Jewels,Stones] in Tests)
println([jewels=Jewels,stone=Stones]),
println(js1=jewels_and_stones1(Jewels,Stones)),
println(js2=jewels_and_stones2(Jewels,Stones)),
println(js3=jewels_and_stones3(Jewels,Stones)),
nl
end,
nl.</syntaxhighlight>
{{out}}
<pre>tests = [[aA,aAAbbbb],[z,ZZ]]
[jewels = aA,stone = aAAbbbb]
js1 = 3
js2 = 3
js3 = 3
[jewels = z,stone = ZZ]
js1 = 0
js2 = 0
js3 = 0</pre>
===Benchmark===
For a larger test we can see the differences between the three approaches. Here are 100 000 000 random stones and (atmost) 15 jewels (we remove any duplicate jewel).
<syntaxhighlight lang="picat">go2 =>
Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
Len = Alpha.len,
_ = random2(),
NumStones = 100_000_000,
NumJewels = 15, % Atmost number of jewels (duplicates are removed)
Stones = [Alpha[random(1,Len)] : _ in 1..NumStones],
Jewels = [Alpha[random(1,Len)] : _ in 1..NumJewels].sort_remove_dups,
println(jewels=Jewels),
nl,
time(println(js1=jewels_and_stones1(Jewels,Stones))),
time(println(js2=jewels_and_stones2(Jewels,Stones))),
time(println(js3=jewels_and_stones3(Jewels,Stones))),
nl.</syntaxhighlight>
{{out}}
<pre>NumStones: 100_000_000 NumJewels = 15
jewels = TwurtRabSXx
js1 = 21154798
CPU time 15.087 seconds.
js2 = 21154796
CPU time 11.024 seconds.
js3 = 21154798
CPU time 11.94 seconds.</pre>
The recursion approach (<code>jewels_and_stones2/2</code>) is a little faster than the loop approach (<code>jewels_and_stones/3</code>).
=={{header|PL/M}}==
<syntaxhighlight lang="plm">100H:
/* FIND JEWELS AMONG STONES */
COUNT$JEWELS: PROCEDURE (JEWELS, STONES) BYTE;
DECLARE (JEWELS, STONES) ADDRESS;
DECLARE (J BASED JEWELS, S BASED STONES) BYTE;
DECLARE JFLAG (256) BYTE, I BYTE;
/* ZERO JEWEL FLAGS */
DO I=0 TO 255;
JFLAG(I) = 0;
END;
/* LOOP THROUGH JEWELS AND MARK THEM */
DO WHILE J <> '$';
JFLAG(J) = 1;
JEWELS = JEWELS + 1;
END;
/* COUNT THE JEWELS AMONG THE STONES */
I = 0;
DO WHILE S <> '$';
I = I + JFLAG(S);
STONES = STONES + 1;
END;
RETURN I;
END COUNT$JEWELS;
/* CP/M BDOS CALL */
BDOS: PROCEDURE (FN, ARG);
DECLARE FN BYTE, ARG ADDRESS;
GO TO 5;
END BDOS;
PRINT: PROCEDURE (STR);
DECLARE STR ADDRESS;
CALL BDOS(9, STR);
END PRINT;
/* NUMERIC OUTPUT */
PRINT$NUMBER: PROCEDURE (N);
DECLARE S (4) BYTE INITIAL ('...$');
DECLARE P ADDRESS, (N, C BASED P) BYTE;
P = .S(3);
DIGIT:
P = P-1;
C = N MOD 10 + '0';
N = N/10;
IF N > 0 THEN GO TO DIGIT;
CALL PRINT(P);
END PRINT$NUMBER;
/* PRINT JEWELS, STONES, AND AMOUNT OF JEWELS IN STONES */
TEST: PROCEDURE (J, S);
DECLARE (J, S) ADDRESS;
CALL PRINT(.'''$');
CALL PRINT(J);
CALL PRINT(.''' IN ''$');
CALL PRINT(S);
CALL PRINT(.''': $');
CALL PRINT$NUMBER(COUNT$JEWELS(J, S));
CALL PRINT(.(13,10,'$'));
END TEST;
/* UNFORTUNATELY, THE PL/M COMPILER ACCEPTS A VERY RESTRICTED CHARACTER SET
IN THE SOURCE CODE. (IT IS THE INTERSECTION OF VARIOUS POPULAR CHARSETS
FROM THE 1960S.) THIS CHARACTER SET DOES NOT INCLUDE LOWERCASE LETTERS.
HOWEVER, THIS CODE ASSUMES THE ASCII CHARACTER SET ANYWAY.
WE CAN INCLUDE LOWERCASE LETTERS ... BY WRITING THEIR ASCII CODES.
THE OUTPUT WILL BE CORRECT OF COURSE. */
CALL TEST(.( 97,'A$' ), .( 97,'AA',98,98,98,98,'$' ));
CALL TEST(.( 122,'$' ), .( 'ZZZZ$' ));
CALL BDOS(0,0);
EOF</syntaxhighlight>
{{out}}
<pre>'aA' IN 'aAAbbbb': 3
'z' IN 'ZZZZ': 0</pre>
=={{header|Prolog}}==
<syntaxhighlight 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)
.
</syntaxhighlight>
{{out}}
<pre>
/*
?- count_jewels("aAAbbbb","aA",N).
N = 3.
?- count_jewels("ZZ","z",N).
N = 0.
?- count_jewels("aAAbbbb","bcd",N) .
N = 4.
?-
*/
</pre>
====alternative version====
{{works with|SWI Prolog}}
<syntaxhighlight 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).</syntaxhighlight>
{{out}}
<pre>
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.
</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">def countJewels(s, j):
return sum(x in j for x in s)
print countJewels("aAAbbbb", "aA")
print countJewels("ZZ", "z")</syntaxhighlight>
{{Out}}
<pre>3
0</pre>
===Python 3 Alternative===
<syntaxhighlight 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"))</syntaxhighlight>
{{Out}}
<pre>3
0</pre>
=={{header|R}}==
<syntaxhighlight lang="r">J_n_S <- function(stones ="aAAbbbb", jewels = "aA") {
stones <- unlist(strsplit(stones, split = "")) # obtain a character vector
jewels <- unlist(strsplit(jewels, split = ""))
count <- sum(stones %in% jewels)
}
print(J_n_S("aAAbbbb", "aA"))
print(J_n_S("ZZ", "z"))
print(J_n_S("lgGKJGljglghGLGHlhglghoIPOgfdtrdDCHnvbnmBVC", "fFgGhH"))
</syntaxhighlight>
{{Out}}
<pre>> print(J_n_S("aAAbbbb", "aA"))
[1] 3
> print(J_n_S("ZZ", "z"))
[1] 0
> print(J_n_S("lgGKJGljglghGLGHlhglghoIPOgfdtrdDCHnvbnmBVC", "fFgGhH"))
[1] 16
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ 0 0 rot
witheach [ bit | ]
rot witheach
[ bit over & if
[ dip 1+ ] ]
drop ] is j&s ( $ $ --> n )
$ "aAAbbbb" $ "aA" j&s echo</syntaxhighlight>
{{out}}
<pre>3</pre>
=={{header|Racket}}==
<syntaxhighlight 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"))
</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub count-jewels ( Str $j, Str $s --> Int ) {
my %counts_of_all = $s.comb.Bag;
my @jewel_list = $j.comb.unique;
Line 104 ⟶ 2,256:
say count-jewels 'aA' , 'aAAbbbb';
say count-jewels 'z' , 'ZZ';</
{{Out}}
<pre>3
0</pre>
=={{header|Red}}==
<syntaxhighlight lang="rebol">Red [
title: "Jewels and stones"
red-version: 0.6.4
]
count: function [
"Returns the number of values in a block for which a function returns true"
values [any-list! string!] "The values from which to count"
fn [function!] "A function that returns true or false"
][
count: 0
foreach value values [if fn value [count: count + 1]]
count
]
count-jewels: function [
"Returns the count of 'jewels' in the 'stones'"
stones "The values to search for jewels"
jewels "The values to count in the stones"
][
result: 0
foreach jewel jewels [
result: result + count stones function [stone][stone = jewel]
]
]
print count-jewels "aAAbbbb" "aA"
print count-jewels "ZZ" "z"</syntaxhighlight>
{{out}}
<pre>
3
0
</pre>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Jewels ('aAAbbb') ('aA')>>
<Prout <Jewels ('ZZ') ('z')>>;
};
Jewels {
() (e.Jewels)
= 0;
(s.Stone e.Stones) (e.Jewels), e.Jewels: e.X s.Stone e.Y
= <+ 1 <Jewels (e.Stones) (e.Jewels)>>;
(s.Stone e.Stones) (e.Jewels)
= <Jewels (e.Stones) (e.Jewels)>;
};</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|REXX}}==
Programming note: a check is made so that only (Latin) letters are counted as a match.
<syntaxhighlight 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. */
number= 0 /*initialize number 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 number=number + 1
end /*j*/ /* [↑] if a letter and a match, bump number */
return number /*return the number of common letters. */
</syntaxhighlight>
{{out|output|text= when using the default inputs:}}
<pre>3
0</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring"># Project Jewels and Stones
jewels = "aA"
Line 132 ⟶ 2,353:
next
return num
</syntaxhighlight>
Output:
<pre>3
0</pre>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
≪ → stones jewels
≪ 0 1 jewels SIZE FOR j
stones jewels j j SUB
WHILE DUP2 POS REPEAT
LAST 1 + ROT SWAP OVER SIZE SUB SWAP ROT 1 + ROT ROT
END
DROP2
NEXT
≫
≫
'JnS' STO
"aAAbbbb" "aA" JnS
"ZZ" "z" JnS
{{out}}
<pre>
2:3
1:0
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">stones, jewels = "aAAbbbb", "aA"
stones.count(jewels) # => 3
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight 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"));
}
</syntaxhighlight>
Output:<pre>3
0</pre>
=={{header|Scala}}==
<syntaxhighlight 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"))
}</syntaxhighlight>
{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/Cz1HXAT/0 ScalaFiddle (JavaScript)] or by [https://scastie.scala-lang.org/7ZCCN5hISRuDqLWTKVBHow Scastie (JVM)].
=={{header|SETL}}==
<syntaxhighlight lang="setl">program count_jewels;
show("aA", "aAAbbbb");
show("z", "ZZ");
proc show(jewels, stones);
print("'" + jewels + "' in '" + stones + "': " + count(jewels, stones));
end proc;
proc count(jewels, stones);
jewels := {j : j in jewels};
return #[s : s in stones | s in jewels];
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>'aA' in 'aAAbbbb': 3
'z' in 'ZZ': 0</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func countJewels(s, j) {
s.chars.count { |c|
j.contains(c)
}
}
say countJewels("aAAbbbb", "aA") #=> 3
say countJewels("ZZ", "z") #=> 0</syntaxhighlight>
=={{header|Snobol}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|SQL}}==
<syntaxhighlight 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));
</syntaxhighlight>
{{out}}
<pre>
J=aA S=AaBbCcAa TOTAL = 4
</pre>
=={{header|Swift}}==
<syntaxhighlight 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"))</syntaxhighlight>
{{out}}
<pre>3
0</pre>
=={{header|Tcl}}==
<syntaxhighlight 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]</syntaxhighlight>
{{out}}
3
0
=={{header|Terraform}}==
<syntaxhighlight 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)
}</syntaxhighlight>
{{Out}}
<pre>$ 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
</pre>
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
MainModule: {
countJewels: (λ j String() st String() locals: n 0
(for s in st do
(if (contains j s) (+= n 1)))
(ret n)
),
_start: (λ (lout (countJewels "aA" "aAAbbbb"))
(lout (countJewels "b" "BB")))
}</syntaxhighlight>
{{out}}
<pre>
3
Line 139 ⟶ 2,584:
</pre>
=={{header|
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">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"))
}</syntaxhighlight>
{{out}}
<pre>
3
</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">var countJewels = Fn.new { |s, j| s.count { |c| j.contains(c) } }
System.print(countJewels.call("aAAbbbb", "aA"))
System.print(countJewels.call("ZZ", "z"))</syntaxhighlight>
{{out}}
<pre>
Line 148 ⟶ 2,617:
0
</pre>
=={{header|XPL0}}==
<syntaxhighlight 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);
]</syntaxhighlight>
{{out}}
<pre>
3
0
11
</pre>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn countJewels(a,b){ a.inCommon(b).len() }</syntaxhighlight>
<syntaxhighlight lang="zkl">println(countJewels("aAAbbbb", "aA"));
println(countJewels("ZZ", "z"));</syntaxhighlight>
{{out}}
<pre>3
0</pre>
| |||