Jewels and stones

From Rosetta Code
Revision as of 09:54, 23 October 2023 by Not a robot (talk | contribs) (add SETL)


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

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

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

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


Note that:

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

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

This task was inspired by this problem.


Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences



11l

Translation of: Python
F count_jewels(s, j)
   R sum(s.map(x -> Int(x C @j)))

print(count_jewels(‘aAAbbbb’, ‘aA’))
print(count_jewels(‘ZZ’, ‘z’))
Output:
3
0

360 Assembly

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

8080 Assembly

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

8086 Assembly

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

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux
/* 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"
Output:
Program 64 bits start.
Result: 3
Result: 0

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

ALGOL 68

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

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

END
Output:
         +3
        +52
         +0
         +0

APL

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


AppleScript

Functional

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

-- OR in terms of filter
-- jewelCount :: String -> String -> Int
on jewelCount2(jewels, stones)
    script
        on |λ|(c)
            elem(c, jewels)
        end |λ|
    end script
    length of filter(result, stones)
end jewelCount2

-- TEST --------------------------------------------------
on run
    
    unlines(map(uncurry(jewelCount), ¬
        {Tuple("aA", "aAAbbbb"), Tuple("z", "ZZ")}))
    
end run


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

-- Tuple (,) :: a -> b -> (a, b)
on Tuple(a, b)
    {type:"Tuple", |1|:a, |2|:b}
end Tuple

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

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

-- filter :: (a -> Bool) -> [a] -> [a]
on filter(f, xs)
    tell mReturn(f)
        set lst to {}
        set lng to length of xs
        repeat with i from 1 to lng
            set v to item i of xs
            if |λ|(v, i, xs) then set end of lst to v
        end repeat
        return lst
    end tell
end filter

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl

-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map

-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn

-- Returns a function on a single tuple (containing 2 arguments)
-- derived from an equivalent function with 2 distinct arguments
-- uncurry :: (a -> b -> c) -> ((a, b) -> c)
on uncurry(f)
    script
        property mf : mReturn(f)'s |λ|
        on |λ|(pair)
            mf(|1| of pair, |2| of pair)
        end |λ|
    end script
end uncurry

-- unlines :: [String] -> String
on unlines(xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set str to xs as text
    set my text item delimiters to dlm
    str
end unlines
Output:
3
0

Idiomatic

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

jewelsAndStones("aAAbBbb", "aAb")
Output:
6

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux
/* 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"
Output:

with the file unixdict.txt

Program 32 bits start.
Result: 3
Result: 0

Arturo

count: function [jewels,stones][
    size select split stones => [in? & jewels]
]

print count "aA" "aAAbbbb"
Output:
3

AutoHotkey

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

AWK

# syntax: GAWK -f JEWELS_AND_STONES.AWK
BEGIN {
    printf("%d\n",count("aAAbbbb","aA"))
    printf("%d\n",count("ZZ","z"))
    exit(0)
}
function count(stone,jewel,  i,total) {
    for (i=1; i<length(stone); i++) {
      if (jewel ~ substr(stone,i,1)) {
        total++
      }
    }
    return(total)
}
Output:
3
0

BASIC

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

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

200 DATA 2
210 DATA "aA","aAAbbbb"
220 DATA "z","ZZZZ"
Output:
aAAbbbb in aA: 3
ZZZZ in z: 0

BASIC256

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", "")
Output:
Same as FreeBASIC entry.

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
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

FreeBASIC

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

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

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
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
Output:
Same as FreeBASIC entry.

MSX Basic

The GW-BASIC solution works without any changes.

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
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
Output:
Same as FreeBASIC entry.

Run BASIC

Works with: Just BASIC
Works with: Liberty BASIC
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
Output:
Same as FreeBASIC entry.

True BASIC

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
Output:
Same as FreeBASIC entry.

VBA

Translation of: Phix
Function count_jewels(stones As String, jewels As String) As Integer
    Dim res As Integer: res = 0
    For i = 1 To Len(stones)
        res = res - (InStr(1, jewels, Mid(stones, i, 1), vbBinaryCompare) <> 0)
    Next i
    count_jewels = res
End Function
Public Sub main()
    Debug.Print count_jewels("aAAbbbb", "aA")
    Debug.Print count_jewels("ZZ", "z")
End Sub
Output:
 3 
 0 

Visual Basic .NET

Translation of: C#
Module Module1

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

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

End Module
Output:
3
0

Yabasic

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
Output:
Same as FreeBASIC entry.


BCPL

get "libhdr"

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

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

let start() be
$(  show("aA", "aAAbbbb")
    show("z", "ZZ")
$)
Output:
"aA" in "aAAbbbb": 3
"z" in "ZZ": 0

BQN

Similar in nature to APL, mostly due to how trivial the problem is in an array language.

Jewels+´˜
  "aA" Jewels "aAAbbbb"
3

Bracmat

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

Output

3

C

Translation of: Kotlin
#include <stdio.h>
#include <string.h>

int count_jewels(const char *s, const char *j) {
    int count = 0;
    for ( ; *s; ++s) if (strchr(j, *s)) ++count;
    return count;
}

int main() {
    printf("%d\n", count_jewels("aAAbbbb", "aA"));
    printf("%d\n", count_jewels("ZZ", "z"));
    return 0;
}
Output:
3
0

C#

using System;
using System.Linq;

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

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

C++

Translation of: D
#include <algorithm>
#include <iostream>

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

int main() {
    using namespace std;

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

    return 0;
}
Output:
3
0

CLU

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

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

start_up = proc ()
    show("aA", "aAAbbbb")
end start_up
Output:
"aA" in "aAAbbbb": 3

Cowgol

include "cowgol.coh";

sub count_jewels(stones: [uint8], jewels: [uint8]): (count: uint16) is
    var jewel_mark: uint8[256];
    MemZero(&jewel_mark as [uint8], 256);

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

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

sub print_and_count(stones: [uint8], jewels: [uint8]) is
    print(jewels);
    print(" in ");
    print(stones);
    print(": ");
    print_i16(count_jewels(stones, jewels));
    print_nl();
end sub;

print_and_count("aAAbbbb", "aA");
print_and_count("ZZ", "z");
Output:
aA in aAAbbbb: 3
z in ZZ: 0

Crystal

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

# The above solution works for that case, but fails with certain other "jewels":
stones, jewels = "aA^Bb", "^b"
stones.count(jewels) # => 4
# '^b' in the "jewels" is read as "characters other than 'b'".

# This works as intended though:
stones.count { |c| jewels.chars.includes?(c) } # => 2

D

Translation of: Kotlin
import std.algorithm;
import std.stdio;

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

void main() {
    countJewels("aAAbbbb", "aA").writeln;
    countJewels("ZZ", "z").writeln;
}
Output:
3
0

Delphi

Works with: Delphi version 6.0


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


Draco

proc nonrec count_jewels(*char jewels, stones) word:
    [256] bool jewel;
    word count;
    byte i;
    char c;
    
    for i from 0 upto 255 do jewel[i] := false od;
    while c := jewels*; c ~= '\e' do
        jewel[c] := true;
        jewels := jewels + 1;
    od;
    
    count := 0;
    while c := stones*; c ~= '\e' do
        if jewel[c] then count := count + 1 fi;
        stones := stones + 1
    od;
    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
Output:
'aA' in 'aAAbbbb': 3
'z' in 'ZZ': 0

Dyalect

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

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"


F#

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

Factor

USING: kernel prettyprint sequences ;

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

"aAAbbbb" "aA"
"ZZ" "z" [ count-jewels . ] 2bi@
Output:
3
0

Euphoria

function number_of(object jewels, object stones) -- why limit ourselves to strings?
integer ct = 0
    for i = 1 to length(stones) do
        ct += find(stones[i],jewels) != 0
    end for
    return ct
end function

? number_of("aA","aAAbbbb")
? number_of("z","ZZ")
? number_of({1,"Boo",3},{1,2,3,'A',"Boo",3}) -- might as well send a list of things to find, not just one!
Output:
3
0
4 -- 1 is found once, "Boo" is found once, and 3 is found twice = 4 things in the search list were found in the target list

Go

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

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

Outer loop stones, index into jewels:

package main
  
import (
    "fmt"
    "strings"
)

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

func main() {
    fmt.Println(js("aAAbbbb", "aA"))
}
Output:
3

Outer loop jewels, count stones:

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

Construct jewel set, then loop over stones:

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

Construct stone multiset, then loop over jewels:

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

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

Or in terms of filter rather than foldr

jewelCount
  :: Eq a
  => [a] -> [a] -> Int
jewelCount jewels = length . filter (`elem` jewels)

--------------------------- TEST -------------------------
main :: IO ()
main = do
  print $ jewelCount "aA" "aAAbbbb"
  print $ jewelCount "z" "ZZ"
Output:
3
0

J

   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

A simpler implementation, which satisfies the task requirements but does not explicitly ignore non-letters, would be:

jewels=: +/@e.

Java

import java.util.HashSet;
import java.util.Set;

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

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

        return count;
    }

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

JavaScript

(() => {

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

    // TEST -----------------------------------------------
    return [
            ['aA', 'aAAbbbb'],
            ['z', 'ZZ']
        ]
        .map(x => jewelCount(...x))
})();
Output:
[3, 0]

Joy

DEFINE jewels == [in 1 0 choice +] cons 0 swap fold.

"aAAbbbb" "aA" jewels.
"ZZ" "z" jewels.
Output:
3
0

jq

$ jq -n --arg stones aAAbbbb --arg jewels aA '
  [$stones|split("") as $s|$jewels|split("") as $j|$s[]|
  select(. as $c|$j|contains([$c]))]|length'
Output:
3

Julia

Module:

module Jewels

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

end  # module Jewels

Main:

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

Kotlin

// Version 1.2.40

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

fun main(args: Array<String>) {
    println(countJewels("aAAbbbb", "aA"))
    println(countJewels("ZZ", "z"))
}
Output:
3
0

Lambdatalk

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

{countjewels aAAbbbb aA} -> 3
{countjewels ZZ z}       -> 0

Lua

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

print(count_jewels("aAAbbbb", "aA"))
print(count_jewels("ZZ", "z"))
Output:
3
0

MACRO-11

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

Maple

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

Mathematica / Wolfram Language

JewelsStones[j_String, s_String] := Count[MemberQ[Characters[j], #] & /@ Characters[s], True]
JewelsStones["aA", "aAAbbbb"]
JewelsStones["ZZ", "z"]
Output:
3
0

MATLAB / Octave

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

min

Works with: min version 0.19.6
(('' '' '') => spread if) :if?

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

(swap indexof -1 !=) :member?

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

"aAAbbbb" "aA" count-jewels puts!
"ZZ" "z" count-jewels puts!
Output:
3
0

Modula-2

MODULE Jewels;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

PROCEDURE WriteInt(n : INTEGER);
VAR buf : ARRAY[0..15] OF CHAR;
BEGIN
    FormatString("%i", buf, n);
    WriteString(buf)
END WriteInt;

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

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

    RETURN c
END CountJewels;

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

    ReadChar
END Jewels.
Output:
3
0

Nim

import sequtils

func countJewels(stones, jewels: string): Natural =
  stones.countIt(it in jewels)

echo countJewels("aAAbbbb", "aA")
echo countJewels("ZZ", "z")
Output:
3
0

Objeck

Translation of: Java
use Collection.Generic;

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

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

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

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

OCaml

let jewels j s =
  String.(fold_left (fun n c -> if contains j c then succ n else n) 0 s)

Perl

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

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

print count_jewels 'aA' , 'aAAbbbb';
print count_jewels 'z'  , 'ZZ';
Output:
3
0

Alternate using regex

#!/usr/bin/perl

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

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

print "$_ = ", count_jewels( split ), "\n" for split /\n/, <<END;
aAAbbbb aA
aAAbbbb abc
ZZ z
END
Output:
aAAbbbb aA = 3
aAAbbbb abc = 5
ZZ z = 0

Phix

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

Picat

List comprehension

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

Recursion

jewels_and_stones2(Jewels,Stones) = N =>
  jewels_and_stones2(Jewels,Stones,0,N).

jewels_and_stones2([],_Stones,N,N).
jewels_and_stones2([J|Jewels],[S|Stones],N0,N) :-
  jewels_and_stones2_(J,[S|Stones],0,JN),
  jewels_and_stones2(Jewels,Stones,N0+JN,N).

% Check just this jewel on all the 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).

Foreach loop

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

Test

go =>
  Tests = [["aA","aAAbbbb"],
           ["z","ZZ"]
           ],
  println(tests=Tests),
  foreach([Jewels,Stones] in Tests)
    println([jewels=Jewels,stone=Stones]),
    println(js1=jewels_and_stones1(Jewels,Stones)),
    println(js2=jewels_and_stones2(Jewels,Stones)),
    println(js3=jewels_and_stones3(Jewels,Stones)),
    nl
  end,
  nl.
Output:
tests = [[aA,aAAbbbb],[z,ZZ]]
[jewels = aA,stone = aAAbbbb]
js1 = 3
js2 = 3
js3 = 3

[jewels = z,stone = ZZ]
js1 = 0
js2 = 0
js3 = 0

Benchmark

For a larger test we can see the differences between the three approaches. Here are 100 000 000 random stones and (atmost) 15 jewels (we remove any duplicate jewel).

go2 =>
  Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
  Len = Alpha.len,
  _ = random2(),
  NumStones = 100_000_000,
  NumJewels = 15, % Atmost number of jewels (duplicates are removed)
  
  Stones = [Alpha[random(1,Len)] : _ in 1..NumStones],
  Jewels = [Alpha[random(1,Len)] : _ in 1..NumJewels].sort_remove_dups,
  println(jewels=Jewels),
  nl,  
  time(println(js1=jewels_and_stones1(Jewels,Stones))),
  time(println(js2=jewels_and_stones2(Jewels,Stones))),
  time(println(js3=jewels_and_stones3(Jewels,Stones))),
  nl.
Output:
NumStones: 100_000_000  NumJewels = 15
jewels = TwurtRabSXx

js1 = 21154798

CPU time 15.087 seconds.

js2 = 21154796

CPU time 11.024 seconds.

js3 = 21154798

CPU time 11.94 seconds.

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


PL/M

100H:

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

/* CP/M BDOS CALL */
BDOS: PROCEDURE (FN, ARG);
    DECLARE FN BYTE, ARG ADDRESS;
    GO TO 5;
END BDOS;

PRINT: PROCEDURE (STR);
    DECLARE STR ADDRESS;
    CALL BDOS(9, STR);
END PRINT;

/* NUMERIC OUTPUT */
PRINT$NUMBER: PROCEDURE (N);
    DECLARE S (4) BYTE INITIAL ('...$');
    DECLARE P ADDRESS, (N, C BASED P) BYTE;
    P = .S(3);
DIGIT:
    P = P-1;
    C = N MOD 10 + '0';
    N = N/10;
    IF N > 0 THEN GO TO DIGIT;
    CALL PRINT(P);
END PRINT$NUMBER;

/* PRINT JEWELS, STONES, AND AMOUNT OF JEWELS IN STONES */
TEST: PROCEDURE (J, S);
    DECLARE (J, S) ADDRESS;
    CALL PRINT(.'''$');
    CALL PRINT(J);
    CALL PRINT(.''' IN ''$');
    CALL PRINT(S);
    CALL PRINT(.''': $');
    CALL PRINT$NUMBER(COUNT$JEWELS(J, S));
    CALL PRINT(.(13,10,'$'));
END TEST;

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

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

CALL BDOS(0,0);
EOF
Output:
'aA' IN 'aAAbbbb': 3
'z' IN 'ZZZZ': 0

Prolog

:- system:set_prolog_flag(double_quotes,codes) .

count_jewels(STONEs0,JEWELs0,COUNT)
:-
findall(X,(member(X,JEWELs0),member(X,STONEs0)),ALLs) ,
length(ALLs,COUNT)
.
Output:
/*
?- count_jewels("aAAbbbb","aA",N).
N = 3.

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

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

?-
*/

alternative version

Works with: SWI Prolog
count_jewels(Stones, Jewels, N):-
    string_codes(Stones, Scodes),
    string_codes(Jewels, Jcodes),
    msort(Scodes, SScodes),
    sort(Jcodes, SJcodes),
    count_jewels(SScodes, SJcodes, N, 0).

count_jewels([], _, N, N):-!.
count_jewels(_, [], N, N):-!.
count_jewels([C|Stones], [C|Jewels], N, R):-
    !,
    R1 is R + 1,
    count_jewels(Stones, [C|Jewels], N, R1).
count_jewels([S|Stones], [J|Jewels], N, R):-
    J < S,
    !,
    count_jewels([S|Stones], Jewels, N, R).
count_jewels([_|Stones], Jewels, N, R):-
    count_jewels(Stones, Jewels, N, R).
Output:
Welcome to SWI-Prolog (threaded, 64 bits, version 8.0.2)
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software.
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

def countJewels(s, j):
    return sum(x in j for x in s)

print countJewels("aAAbbbb", "aA")
print countJewels("ZZ", "z")
Output:
3
0

Python 3 Alternative

def countJewels(stones, jewels):
    jewelset = set(jewels)
    return sum(1 for stone in stones if stone in jewelset)

print(countJewels("aAAbbbb", "aA"))
print(countJewels("ZZ", "z"))
Output:
3
0

R

J_n_S <- function(stones  ="aAAbbbb", jewels = "aA") {
  stones <- unlist(strsplit(stones, split = "")) # obtain a character vector
  jewels <- unlist(strsplit(jewels, split = ""))
  count <- sum(stones %in% jewels)
}

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

Quackery

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

  $ "aAAbbbb" $  "aA" j&s echo
Output:
3

Racket

#lang racket

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

(module+ main
  (jewels-and-stones "aAAbbbb" "aA")
  (jewels-and-stones "ZZ" "z"))
Output:
3
0

Raku

(formerly Perl 6)

sub count-jewels ( Str $j, Str $s --> Int ) {
    my %counts_of_all = $s.comb.Bag;
    my @jewel_list    = $j.comb.unique;

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

say count-jewels 'aA' , 'aAAbbbb';
say count-jewels 'z'  , 'ZZ';
Output:
3
0

Red

Red [
    title: "Jewels and stones"
    red-version: 0.6.4
]

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

count-jewels: function [
    "Returns the count of 'jewels' in the 'stones'"
    stones "The values to search for jewels"
    jewels "The values to count in the stones"
][
    result: 0
    foreach jewel jewels [
        result: result + count stones function [stone][stone = jewel]
    ]
]

print count-jewels "aAAbbbb" "aA"
print count-jewels "ZZ" "z"
Output:
3
0

REXX

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

/*REXX pgm counts how many letters (in the 1st string) are in common with the 2nd string*/
say  count('aAAbbbb', "aA")
say  count('ZZ'     , "z" )
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
count: procedure;  parse arg stones,jewels       /*obtain the two strings specified.    */
       #= 0                                      /*initialize the variable  #  to  zero.*/
                   do j=1  for length(stones)    /*scan STONES for matching JEWELS chars*/
                   x= substr(stones, j, 1)       /*obtain a character of the STONES var.*/
                   if datatype(x, 'M')  then if pos(x, jewels)\==0  then #= # + 1
                   end   /*j*/                   /* [↑]  if a letter and a match, bump #*/
       return #                                  /*return the number of common letters. */
output   when using the default inputs:
3
0

Ring

# Project  Jewels and Stones
 
jewels = "aA"
stones = "aAAbbbb"
see jewelsandstones(jewels,stones) + nl
jewels = "z"
stones = "ZZ"
see jewelsandstones(jewels,stones) + nl

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

Output:

3
0

RPL

Works with: Halcyon Calc version 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
Output:
 2:3
 1:0


Ruby

stones, jewels = "aAAbbbb", "aA"

stones.count(jewels)  # => 3

Rust

fn count_jewels(stones: &str, jewels: &str) -> u8 {
    let mut count: u8 = 0;
    for cur_char in stones.chars() {
        if jewels.contains(cur_char) {
            count += 1;
        }
    }
    count
}
fn main() {
    println!("{}", count_jewels("aAAbbbb", "aA"));
    println!("{}", count_jewels("ZZ", "z"));
}
Output:
3
0

Scala

object JewelsStones extends App {
  def countJewels(s: String, j: String): Int = s.count(i => j.contains(i))

  println(countJewels("aAAbbbb", "aA"))
  println(countJewels("ZZ", "z"))
}
Output:
See it in running in your browser by ScalaFiddle (JavaScript) or by Scastie (JVM).

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

Sidef

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

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

Snobol

*       See how many jewels are among the stones
        DEFINE('JEWELS(JWL,STN)')               :(JEWELS_END)
JEWELS  JEWELS = 0
        JWL = ANY(JWL)
JMATCH  STN JWL = ''                            :F(RETURN)
        JEWELS = JEWELS + 1                     :(JMATCH)  
JEWELS_END
                                                
*       Example from the task (prints 3)
        OUTPUT = JEWELS('aA','aAAbbbb')
*       Example with no jewels (prints 0)
        OUTPUT = JEWELS('z','ZZ')
END
Output:
3
0

SQL

-- See how many jewels are among the 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));
Output:
J=aA S=AaBbCcAa TOTAL = 4

Swift

func countJewels(_ stones: String, _ jewels: String) -> Int {
  return stones.map({ jewels.contains($0) ? 1 : 0 }).reduce(0, +)
}

print(countJewels("aAAbbbb", "aA"))
print(countJewels("ZZ", "z"))
Output:
3
0

Tcl

proc shavej {stones jewels} {
    set n 0
    foreach c [split $stones {}] {
        incr n [expr { [string first $c $jewels] >= 0 }]
    }
    return $n
}
puts [shavej aAAbbbb aA]
puts [shavej ZZ z]
Output:
3                                                                                       
0

Terraform

variable "jewels" {
  default = "aA"
}

variable "stones" {
  default = "aAAbbbb"
}

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

output "jewel_count" {
  value = length(local.found_jewels)
}
Output:
$ terraform apply --auto-approve

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

Outputs:

jewel_count = 3

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

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

Outputs:

jewel_count = 0

Transd

#lang transd

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

V (Vlang)

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

Wren

Translation of: Kotlin
var countJewels = Fn.new { |s, j| s.count { |c| j.contains(c) } }

System.print(countJewels.call("aAAbbbb", "aA"))
System.print(countJewels.call("ZZ", "z"))
Output:
3
0

XPL0

string 0;       \Use zero-terminated strings

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

zkl

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