Jewels and stones: Difference between revisions
Content added Content deleted
Drkameleon (talk | contribs) (Replaced content with "=={{header|Arturo}}== <lang rebol>count: function [jewels,stones][ size select split stones => [in? & jewels] ] print count "aA" "aAAbbbb"</lang> {{out}} <pre>3...") |
|||
Line 1: | Line 1: | ||
=={{header|Arturo}}== |
|||
[[Category:Puzzles]] |
|||
<lang rebol>count: function [jewels,stones][ |
|||
size select split stones => [in? & jewels] |
|||
] |
|||
print count "aA" "aAAbbbb"</lang> |
|||
{{task}} |
|||
;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: |
|||
:# 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}} |
|||
<lang 11l>F count_jewels(s, j) |
|||
R sum(s.map(x -> Int(x C @j))) |
|||
print(count_jewels(‘aAAbbbb’, ‘aA’)) |
|||
print(count_jewels(‘ZZ’, ‘z’))</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|8080 Assembly}}== |
|||
<lang 8080asm> org 100h |
|||
jmp demo |
|||
;;; Count jewels. |
|||
;;; Input: BC = jewels, DE = stones. |
|||
;;; Output: BC = count |
|||
;;; Destroyed: A, DE, HL |
|||
jewel: lxi h,jarr ; Zero out the page of memory |
|||
xra a |
|||
jzero: mov m,a |
|||
inr l |
|||
jnz jzero |
|||
jrjwl: ldax b ; Get jewel |
|||
inx b |
|||
mov l,a ; Mark the corresponding byte in the array |
|||
inr m |
|||
ana a ; If 'jewel' is 0, we've reached the end |
|||
jnz jrjwl ; Otherwise, do next jewel |
|||
lxi b,0 ; BC = count (we no longer need the jewel string) |
|||
jrstn: ldax d ; Get stone |
|||
inx d |
|||
ana a ; If zero, we're done |
|||
rz |
|||
mov l,a ; Get corresponding byte in array |
|||
mov a,m |
|||
ana a |
|||
jz jrstn ; If zero, it is not a jewel |
|||
inx b ; But otherwise, it is a jewel |
|||
jmp jrstn |
|||
;;; Demo code |
|||
demo: lxi b,jewels ; Set up registers |
|||
lxi d,stones |
|||
call jewel ; Call the function |
|||
;;; Print the number |
|||
lxi h,num ; Pointer to number string |
|||
push h ; Push to stack |
|||
mov h,b ; HL = number to print |
|||
mov l,c |
|||
lxi b,-10 ; Divisor |
|||
dgt: lxi d,-1 ; Quotient |
|||
dgtlp: inx d ; Divide using trial subtraction |
|||
dad b |
|||
jc dgtlp |
|||
mvi a,'0'+10 |
|||
add l ; HL = remainder-10 |
|||
pop h ; Get pointer |
|||
dcx h ; Decrement pointer |
|||
mov m,a ; Store digit |
|||
push h ; Put pointer back |
|||
xchg ; Go on with new quotient |
|||
mov a,h ; If 0, we're done |
|||
ana l |
|||
jnz dgt ; If not 0, next digit |
|||
pop d ; Get pointer and put it in DE |
|||
mvi c,9 ; CP/M syscall to print string |
|||
jmp 5 |
|||
db '*****' ; Placeholder for ASCII number output |
|||
num: db '$' |
|||
;;; Example from the task |
|||
jewels: db 'aA',0 |
|||
stones: db 'aAAbbbb',0 |
|||
;;; Next free page of memory is used for the jewel array |
|||
jpage: equ $/256+1 |
|||
jarr: equ jpage*256</lang> |
|||
{{out}} |
|||
<pre>3</pre> |
|||
=={{header|8086 Assembly}}== |
|||
<lang asm> cpu 8086 |
|||
bits 16 |
|||
org 100h |
|||
section .text |
|||
jmp demo |
|||
;;; Count jewels. |
|||
;;; Input: DS:SI = jewels, DS:DX = stones |
|||
;;; Output: CX = how many stones are jewels |
|||
;;; Destroyed: AX, BX, SI, DI |
|||
jewel: xor ax,ax |
|||
mov cx,128 ; Allocate 256 bytes (128 words) on stack |
|||
.zloop: push ax ; Set them all to zero |
|||
loop .zloop |
|||
mov di,sp ; DI = start of array |
|||
xor bh,bh |
|||
.sjwl: lodsb ; Get jewel |
|||
mov bl,al |
|||
inc byte [ss:di+bx] ; Set corresponding byte |
|||
test al,al ; If not zero, there are more jewels |
|||
jnz .sjwl |
|||
mov si,dx ; Read stones |
|||
.sstn: lodsb ; Get stone |
|||
mov bl,al ; Get corresponding byte |
|||
mov bl,[ss:di+bx] |
|||
add cx,bx ; Add to count (as word) |
|||
test al,al ; If not zero, there are more stones |
|||
jnz .sstn |
|||
add sp,256 ; Otherwise, we are done - free the array |
|||
dec cx ; The string terminator is a 'jewel', so remove |
|||
ret |
|||
;;; Demo |
|||
demo: mov si,jewels ; Set up registers |
|||
mov dx,stones |
|||
call jewel ; Call the function |
|||
;;; Print number |
|||
mov ax,10 ; Result is in CX |
|||
xchg ax,cx ; Set AX to result and CX to divisor (10) |
|||
mov bx,num ; Number pointer |
|||
dgt: xor dx,dx |
|||
div cx ; Divide AX by 10 |
|||
add dl,'0' ; Remainder is in DX - add ASCII 0 |
|||
dec bx ; Store digit in string |
|||
mov [bx],dl |
|||
test ax,ax ; Any more digits? |
|||
jnz dgt ; If so, next digit |
|||
mov dx,bx ; When done, print string |
|||
mov ah,9 |
|||
int 21h |
|||
ret |
|||
section .data |
|||
db '*****' ; Placeholder for ASCII number output |
|||
num: db '$' |
|||
stones: db 'aAAbbbb',0 ; Example from the task |
|||
jewels: db 'aA',0</lang> |
|||
{{out}} |
|||
<pre>3</pre> |
|||
=={{header|Ada}}== |
|||
<lang Ada>with Ada.Text_IO; |
|||
procedure Jewels_And_Stones is |
|||
function Count (Jewels, Stones : in String) return Natural is |
|||
Sum : Natural := 0; |
|||
begin |
|||
for J of Jewels loop |
|||
for S of Stones loop |
|||
if J = S then |
|||
Sum := Sum + 1; |
|||
exit; |
|||
end if; |
|||
end loop; |
|||
end loop; |
|||
return Sum; |
|||
end Count; |
|||
procedure Show (Jewels, Stones : in String) is |
|||
use Ada.Text_IO; |
|||
begin |
|||
Put (Jewels); |
|||
Set_Col (12); Put (Stones); |
|||
Set_Col (20); Put (Count (Jewels => Jewels, |
|||
Stones => Stones)'Image); |
|||
New_Line; |
|||
end Show; |
|||
begin |
|||
Show ("aAAbbbb", "aA"); |
|||
Show ("ZZ", "z"); |
|||
end Jewels_And_Stones;</lang> |
|||
{{out}} |
|||
<pre>aAAbbbb aA 3 |
|||
ZZ z 0</pre> |
|||
=={{header|ALGOL 68}}== |
|||
<lang algol68>BEGIN |
|||
# procedure that counts the number of times the letters in jewels occur in stones # |
|||
PROC count jewels = ( STRING stones, jewels )INT: |
|||
BEGIN |
|||
# count the occurences of each letter in stones # |
|||
INT upper a pos = 0; |
|||
INT lower a pos = 1 + ( ABS "Z" - ABS "A" ); |
|||
[ upper a pos : lower a pos + 26 ]INT letter counts; |
|||
FOR c FROM LWB letter counts TO UPB letter counts DO letter counts[ c ] := 0 OD; |
|||
FOR s pos FROM LWB stones TO UPB stones DO |
|||
CHAR s = stones[ s pos ]; |
|||
IF s >= "A" AND s <= "Z" THEN letter counts[ upper a pos + ( ABS s - ABS "A" ) ] +:= 1 |
|||
ELIF s >= "a" AND s <= "z" THEN letter counts[ lower a pos + ( ABS s - ABS "a" ) ] +:= 1 |
|||
FI |
|||
OD; |
|||
# sum the counts of the letters that appear in jewels # |
|||
INT count := 0; |
|||
FOR j pos FROM LWB jewels TO UPB jewels DO |
|||
CHAR j = jewels[ j pos ]; |
|||
IF j >= "A" AND j <= "Z" THEN count +:= letter counts[ upper a pos + ( ABS j - ABS "A" ) ] |
|||
ELIF j >= "a" AND j <= "z" THEN count +:= letter counts[ lower a pos + ( ABS j - ABS "a" ) ] |
|||
FI |
|||
OD; |
|||
count |
|||
END # count jewels # ; |
|||
print( ( count jewels( "aAAbbbb", "aA" ), newline ) ); |
|||
print( ( count jewels( "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz" |
|||
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz" |
|||
) |
|||
, newline |
|||
) |
|||
); |
|||
print( ( count jewels( "AB", "" ), newline ) ); |
|||
print( ( count jewels( "ZZ", "z" ), newline ) ) |
|||
END</lang> |
|||
{{out}} |
|||
<pre> +3 |
|||
+52 |
|||
+0 |
|||
+0</pre> |
|||
=={{header|APL}}== |
|||
{{works with|Dyalog APL}} |
|||
<lang apl>jewels ← +/∊⍨</lang> |
|||
{{out}} |
|||
<pre> 'aA' jewels 'aAAbbbb' |
|||
3</pre> |
|||
=={{header|AppleScript}}== |
|||
===Functional=== |
|||
<lang applescript>-- jewelCount :: String -> String -> Int |
|||
on jewelCount(jewels, stones) |
|||
set js to chars(jewels) |
|||
script |
|||
on |λ|(a, c) |
|||
if elem(c, jewels) then |
|||
a + 1 |
|||
else |
|||
a |
|||
end if |
|||
end |λ| |
|||
end script |
|||
foldl(result, 0, chars(stones)) |
|||
end jewelCount |
|||
-- OR in terms of filter |
|||
-- jewelCount :: String -> String -> Int |
|||
on jewelCount2(jewels, stones) |
|||
script |
|||
on |λ|(c) |
|||
elem(c, jewels) |
|||
end |λ| |
|||
end script |
|||
length of filter(result, stones) |
|||
end jewelCount2 |
|||
-- TEST -------------------------------------------------- |
|||
on run |
|||
unlines(map(uncurry(jewelCount), ¬ |
|||
{Tuple("aA", "aAAbbbb"), Tuple("z", "ZZ")})) |
|||
end run |
|||
-- GENERIC FUNCTIONS ------------------------------------- |
|||
-- Tuple (,) :: a -> b -> (a, b) |
|||
on Tuple(a, b) |
|||
{type:"Tuple", |1|:a, |2|:b} |
|||
end Tuple |
|||
-- chars :: String -> [Char] |
|||
on chars(s) |
|||
characters of s |
|||
end chars |
|||
-- elem :: Eq a => a -> [a] -> Bool |
|||
on elem(x, xs) |
|||
considering case |
|||
xs contains x |
|||
end considering |
|||
end elem |
|||
-- filter :: (a -> Bool) -> [a] -> [a] |
|||
on filter(f, xs) |
|||
tell mReturn(f) |
|||
set lst to {} |
|||
set lng to length of xs |
|||
repeat with i from 1 to lng |
|||
set v to item i of xs |
|||
if |λ|(v, i, xs) then set end of lst to v |
|||
end repeat |
|||
return lst |
|||
end tell |
|||
end filter |
|||
-- foldl :: (a -> b -> a) -> a -> [b] -> a |
|||
on foldl(f, startValue, xs) |
|||
tell mReturn(f) |
|||
set v to startValue |
|||
set lng to length of xs |
|||
repeat with i from 1 to lng |
|||
set v to |λ|(v, item i of xs, i, xs) |
|||
end repeat |
|||
return v |
|||
end tell |
|||
end foldl |
|||
-- map :: (a -> b) -> [a] -> [b] |
|||
on map(f, xs) |
|||
tell mReturn(f) |
|||
set lng to length of xs |
|||
set lst to {} |
|||
repeat with i from 1 to lng |
|||
set end of lst to |λ|(item i of xs, i, xs) |
|||
end repeat |
|||
return lst |
|||
end tell |
|||
end map |
|||
-- Lift 2nd class handler function into 1st class script wrapper |
|||
-- mReturn :: First-class m => (a -> b) -> m (a -> b) |
|||
on mReturn(f) |
|||
if class of f is script then |
|||
f |
|||
else |
|||
script |
|||
property |λ| : f |
|||
end script |
|||
end if |
|||
end mReturn |
|||
-- Returns a function on a single tuple (containing 2 arguments) |
|||
-- derived from an equivalent function with 2 distinct arguments |
|||
-- uncurry :: (a -> b -> c) -> ((a, b) -> c) |
|||
on uncurry(f) |
|||
script |
|||
property mf : mReturn(f)'s |λ| |
|||
on |λ|(pair) |
|||
mf(|1| of pair, |2| of pair) |
|||
end |λ| |
|||
end script |
|||
end uncurry |
|||
-- unlines :: [String] -> String |
|||
on unlines(xs) |
|||
set {dlm, my text item delimiters} to ¬ |
|||
{my text item delimiters, linefeed} |
|||
set str to xs as text |
|||
set my text item delimiters to dlm |
|||
str |
|||
end unlines</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
---- |
|||
===Idiomatic=== |
|||
<lang applescript>on jewelsAndStones(stones, jewels) |
|||
set counter to 0 |
|||
considering case |
|||
repeat with thisCharacter in stones |
|||
if (thisCharacter is in jewels) then set counter to counter + 1 |
|||
end repeat |
|||
end considering |
|||
return counter |
|||
end jewelsAndStones |
|||
jewelsAndStones("aAAbBbb", "aAb")</lang> |
|||
{{output}} |
|||
<lang applescript>6</lang> |
|||
=={{header|AutoHotkey}}== |
|||
<lang AutoHotkey>JewelsandStones(ss, jj){ |
|||
for each, jewel in StrSplit(jj) |
|||
for each, stone in StrSplit(ss) |
|||
if (stone == jewel) |
|||
num++ |
|||
return num |
|||
}</lang> |
|||
Example:<lang AutoHotkey>MsgBox % JewelsandStones("aAAbbbbz", "aAZ") |
|||
return</lang> |
|||
Outputs:<pre>3</pre> |
|||
=={{header|AWK}}== |
|||
<lang AWK># syntax: GAWK -f JEWELS_AND_STONES.AWK |
|||
BEGIN { |
|||
printf("%d\n",count("aAAbbbb","aA")) |
|||
printf("%d\n",count("ZZ","z")) |
|||
exit(0) |
|||
} |
|||
function count(stone,jewel, i,total) { |
|||
for (i=1; i<length(stone); i++) { |
|||
if (jewel ~ substr(stone,i,1)) { |
|||
total++ |
|||
} |
|||
} |
|||
return(total) |
|||
} |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre>3 |
|||
0</pre> |
|||
=={{header|BASIC}}== |
|||
<lang basic>10 READ N% |
|||
20 FOR A%=1 TO N% |
|||
30 READ J$,S$ |
|||
40 GOSUB 100 |
|||
50 PRINT S$;" in ";J$;":";J% |
|||
60 NEXT |
|||
70 END |
|||
100 REM Count how many stones (S$) are jewels (J$). |
|||
110 DIM J%(127) |
|||
120 J%=0 |
|||
130 FOR I%=1 TO LEN(J$): J%(ASC(MID$(J$,I%,1)))=1: NEXT |
|||
140 FOR I%=1 TO LEN(S$): J%=J%+J%(ASC(MID$(S$,I%,1))): NEXT |
|||
150 ERASE J% |
|||
160 RETURN |
|||
200 DATA 2 |
|||
210 DATA "aA","aAAbbbb" |
|||
220 DATA "z","ZZZZ" |
|||
</lang> |
|||
{{out}} |
|||
<pre>aAAbbbb in aA: 3 |
|||
ZZZZ in z: 0</pre> |
|||
=={{header|BASIC256}}== |
|||
<lang BASIC256> |
|||
function contar_joyas(piedras, joyas) |
|||
cont = 0 |
|||
for i = 1 to length(piedras) |
|||
bc = instr(joyas, mid(piedras, i, 1), 1) |
|||
if bc <> 0 then cont += 1 |
|||
next i |
|||
return cont |
|||
end function |
|||
print contar_joyas("aAAbbbb", "aA") |
|||
print contar_joyas("ZZ", "z") |
|||
print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz") |
|||
print contar_joyas("AB", "") |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
Igual que la entrada de FreeBASIC. |
|||
</pre> |
|||
=={{header|Bracmat}}== |
|||
<lang Bracmat> ( f |
|||
= stones jewels N |
|||
. !arg:(?stones.?jewels) |
|||
& 0:?N |
|||
& ( @( !stones |
|||
: ? |
|||
( %@ |
|||
: [%( @(!jewels:? !sjt ?) |
|||
& 1+!N:?N |
|||
| |
|||
) |
|||
& ~ |
|||
) |
|||
? |
|||
) |
|||
| !N |
|||
) |
|||
) |
|||
& f$(aAAbbbb.aA) |
|||
</lang> |
|||
'''Output''' |
|||
<pre>3</pre> |
<pre>3</pre> |
||
=={{header|C}}== |
|||
{{trans|Kotlin}} |
|||
<lang c>#include <stdio.h> |
|||
#include <string.h> |
|||
int count_jewels(const char *s, const char *j) { |
|||
int count = 0; |
|||
for ( ; *s; ++s) if (strchr(j, *s)) ++count; |
|||
return count; |
|||
} |
|||
int main() { |
|||
printf("%d\n", count_jewels("aAAbbbb", "aA")); |
|||
printf("%d\n", count_jewels("ZZ", "z")); |
|||
return 0; |
|||
}</lang> |
|||
{{output}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|C sharp}}== |
|||
<lang csharp>using System; |
|||
using System.Linq; |
|||
public class Program |
|||
{ |
|||
public static void Main() { |
|||
Console.WriteLine(Count("aAAbbbb", "Aa")); |
|||
Console.WriteLine(Count("ZZ", "z")); |
|||
} |
|||
private static int Count(string stones, string jewels) { |
|||
var bag = jewels.ToHashSet(); |
|||
return stones.Count(bag.Contains); |
|||
} |
|||
}</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|C++}}== |
|||
{{trans|D}} |
|||
<lang cpp>#include <algorithm> |
|||
#include <iostream> |
|||
int countJewels(const std::string& s, const std::string& j) { |
|||
int count = 0; |
|||
for (char c : s) { |
|||
if (j.find(c) != std::string::npos) { |
|||
count++; |
|||
} |
|||
} |
|||
return count; |
|||
} |
|||
int main() { |
|||
using namespace std; |
|||
cout << countJewels("aAAbbbb", "aA") << endl; |
|||
cout << countJewels("ZZ", "z") << endl; |
|||
return 0; |
|||
}</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Cowgol}}== |
|||
<lang cowgol>include "cowgol.coh"; |
|||
sub count_jewels(stones: [uint8], jewels: [uint8]): (count: uint16) is |
|||
var jewel_mark: uint8[256]; |
|||
MemZero(&jewel_mark as [uint8], 256); |
|||
while [jewels] != 0 loop |
|||
jewel_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");</lang> |
|||
{{out}} |
|||
<pre>aA in aAAbbbb: 3 |
|||
z in ZZ: 0</pre> |
|||
=={{header|D}}== |
|||
{{trans|Kotlin}} |
|||
<lang d>import std.algorithm; |
|||
import std.stdio; |
|||
int countJewels(string s, string j) { |
|||
int count; |
|||
foreach (c; s) { |
|||
if (j.canFind(c)) { |
|||
count++; |
|||
} |
|||
} |
|||
return count; |
|||
} |
|||
void main() { |
|||
countJewels("aAAbbbb", "aA").writeln; |
|||
countJewels("ZZ", "z").writeln; |
|||
}</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|F_Sharp|F#}}== |
|||
<lang fsharp> |
|||
let fN jewels stones=stones|>Seq.filter(fun n->Seq.contains n jewels)|>Seq.length |
|||
printfn "%d" (fN "aA" "aAAbbbb") |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
</pre> |
|||
=={{header|Factor}}== |
|||
<lang factor>USING: kernel prettyprint sequences ; |
|||
: count-jewels ( stones jewels -- n ) [ member? ] curry count ; |
|||
"aAAbbbb" "aA" |
|||
"ZZ" "z" [ count-jewels . ] 2bi@</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|Euphoria}}== |
|||
<lang Euphoria> |
|||
function number_of(object jewels, object stones) -- why limit ourselves to strings? |
|||
integer ct = 0 |
|||
for i = 1 to length(stones) do |
|||
ct += find(stones[i],jewels) != 0 |
|||
end for |
|||
return ct |
|||
end function |
|||
? number_of("aA","aAAbbbb") |
|||
? number_of("z","ZZ") |
|||
? number_of({1,"Boo",3},{1,2,3,'A',"Boo",3}) -- might as well send a list of things to find, not just one! |
|||
</lang> |
|||
{{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|FreeBASIC}}== |
|||
<lang freebasic> |
|||
function contar_joyas(piedras as string, joyas as string) as integer |
|||
dim as integer bc, cont: cont = 0 |
|||
for i as integer = 1 to len(piedras) |
|||
bc = instr(1, joyas, mid(piedras, i, 1)) |
|||
if bc <> 0 then cont += 1 |
|||
next i |
|||
contar_joyas = cont |
|||
end function |
|||
print contar_joyas("aAAbbbb", "aA") |
|||
print contar_joyas("ZZ", "z") |
|||
print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", _ |
|||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz") |
|||
print contar_joyas("AB", "") |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
53 |
|||
0 |
|||
</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:''' |
|||
<lang go>package main |
|||
import ( |
|||
"fmt" |
|||
"strings" |
|||
) |
|||
func js(stones, jewels string) (n int) { |
|||
for _, b := range []byte(stones) { |
|||
if strings.IndexByte(jewels, b) >= 0 { |
|||
n++ |
|||
} |
|||
} |
|||
return |
|||
} |
|||
func main() { |
|||
fmt.Println(js("aAAbbbb", "aA")) |
|||
}</lang> |
|||
{{out}} |
|||
<pre>3</pre> |
|||
'''Outer loop jewels, count stones:''' |
|||
<lang go>func js(stones, jewels string) (n int) { |
|||
for _, b := range []byte(jewels) { |
|||
n += strings.Count(stones, string(b)) |
|||
} |
|||
return |
|||
}</lang> |
|||
'''Construct jewel set, then loop over stones:''' |
|||
<lang go>func js(stones, jewels string) (n int) { |
|||
var jSet ['z' + 1]int |
|||
for _, b := range []byte(jewels) { |
|||
jSet[b] = 1 |
|||
} |
|||
for _, b := range []byte(stones) { |
|||
n += jSet[b] |
|||
} |
|||
return |
|||
}</lang> |
|||
'''Construct stone multiset, then loop over jewels:''' |
|||
<lang go>func js(stones, jewels string) (n int) { |
|||
var sset ['z' + 1]int |
|||
for _, b := range []byte(stones) { |
|||
sset[b]++ |
|||
} |
|||
for _, b := range []byte(jewels) { |
|||
n += sset[b] |
|||
} |
|||
return |
|||
}</lang> |
|||
=={{header|Haskell}}== |
|||
<lang haskell>jewelCount |
|||
:: Eq a |
|||
=> [a] -> [a] -> Int |
|||
jewelCount jewels = foldr go 0 |
|||
where |
|||
go c |
|||
| c `elem` jewels = succ |
|||
| otherwise = id |
|||
--------------------------- TEST ------------------------- |
|||
main :: IO () |
|||
main = mapM_ print $ uncurry jewelCount <$> [("aA", "aAAbbbb"), ("z", "ZZ")] |
|||
</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
Or in terms of filter rather than foldr |
|||
<lang haskell>jewelCount |
|||
:: Eq a |
|||
=> [a] -> [a] -> Int |
|||
jewelCount jewels = length . filter (`elem` jewels) |
|||
--------------------------- TEST ------------------------- |
|||
main :: IO () |
|||
main = do |
|||
print $ jewelCount "aA" "aAAbbbb" |
|||
print $ jewelCount "z" "ZZ"</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|J}}== |
|||
<lang J> |
|||
NB. jewels sums a raveled equality table |
|||
NB. use: x jewels y x are the stones, y are the jewels. |
|||
intersect =: -.^:2 |
|||
jewels =: ([: +/ [: , =/~) ~.@:intersect&Alpha_j_ |
|||
'aAAbbbb ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz' jewels&>&;: 'aA ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz' |
|||
3 52 |
|||
'none' jewels '' |
|||
0 |
|||
'ZZ' jewels 'z' |
|||
0 |
|||
</lang> |
|||
=={{header|Java}}== |
|||
<lang java>import java.util.HashSet; |
|||
import java.util.Set; |
|||
public class App { |
|||
private static int countJewels(String stones, String jewels) { |
|||
Set<Character> bag = new HashSet<>(); |
|||
for (char c : jewels.toCharArray()) { |
|||
bag.add(c); |
|||
} |
|||
int count = 0; |
|||
for (char c : stones.toCharArray()) { |
|||
if (bag.contains(c)) { |
|||
count++; |
|||
} |
|||
} |
|||
return count; |
|||
} |
|||
public static void main(String[] args) { |
|||
System.out.println(countJewels("aAAbbbb", "aA")); |
|||
System.out.println(countJewels("ZZ", "z")); |
|||
} |
|||
}</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Javascript}}== |
|||
<lang javascript>(() => { |
|||
// jewelCount :: String -> String -> Int |
|||
const jewelCount = (j, s) => { |
|||
const js = j.split(''); |
|||
return s.split('') |
|||
.reduce((a, c) => js.includes(c) ? a + 1 : a, 0) |
|||
}; |
|||
// TEST ----------------------------------------------- |
|||
return [ |
|||
['aA', 'aAAbbbb'], |
|||
['z', 'ZZ'] |
|||
] |
|||
.map(x => jewelCount(...x)) |
|||
})();</lang> |
|||
{{Out}} |
|||
<pre>[3, 0]</pre> |
|||
=={{header|jq}}== |
|||
<lang jq>$ jq -n --arg stones aAAbbbb --arg jewels aA ' |
|||
[$stones|split("") as $s|$jewels|split("") as $j|$s[]| |
|||
select(. as $c|$j|contains([$c]))]|length'</lang> |
|||
{{Out}} |
|||
<pre>3</pre> |
|||
=={{header|Julia}}== |
|||
'''Module''': |
|||
<lang julia>module Jewels |
|||
count(s, j) = Base.count(x ∈ j for x in s) |
|||
end # module Jewels</lang> |
|||
'''Main''': |
|||
<lang julia>@show Jewels.count("aAAbbbb", "aA") |
|||
@show Jewels.count("ZZ", "z")</lang> |
|||
{{out}} |
|||
<pre>Jewels.count("aAAbbbb", "aA") = 3 |
|||
Jewels.count("ZZ", "z") = 0</pre> |
|||
=={{header|Kotlin}}== |
|||
<lang scala>// Version 1.2.40 |
|||
fun countJewels(s: String, j: String) = s.count { it in j } |
|||
fun main(args: Array<String>) { |
|||
println(countJewels("aAAbbbb", "aA")) |
|||
println(countJewels("ZZ", "z")) |
|||
}</lang> |
|||
{{output}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|Lambdatalk}}== |
|||
<lang scheme> |
|||
{def countjewels |
|||
{def countjewels.r |
|||
{lambda {:a :b :c} |
|||
{if {A.empty? :a} |
|||
then :c |
|||
else {countjewels.r {A.rest :a} |
|||
:b |
|||
{if {= {A.in? {A.first :a} :b} -1} |
|||
then :c |
|||
else {+ :c 1}}}}}} |
|||
{lambda {:a :b} |
|||
{countjewels.r {A.split :a} {A.split :b} 0}}} |
|||
-> countjewels |
|||
{countjewels aAAbbbb aA} -> 3 |
|||
{countjewels ZZ z} -> 0 |
|||
</lang> |
|||
=={{header|Lua}}== |
|||
{{trans|C}} |
|||
<lang lua>function count_jewels(s, j) |
|||
local count = 0 |
|||
for i=1,#s do |
|||
local c = s:sub(i,i) |
|||
if string.match(j, c) then |
|||
count = count + 1 |
|||
end |
|||
end |
|||
return count |
|||
end |
|||
print(count_jewels("aAAbbbb", "aA")) |
|||
print(count_jewels("ZZ", "z"))</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Maple}}== |
|||
<lang Maple>count_jewel := proc(stones, jewels) |
|||
local count, j, letter: |
|||
j := convert(jewels,set): |
|||
count := 0: |
|||
for letter in stones do |
|||
if (member(letter, j)) then |
|||
count++: |
|||
end if: |
|||
end do: |
|||
return count: |
|||
end proc: |
|||
count_jewel("aAAbbbb", "aA")</lang> |
|||
{{Out|Output}} |
|||
<pre>3</pre> |
|||
=={{header|MATLAB}} / {{header|Octave}}== |
|||
<lang Matlab> |
|||
function s = count_jewels(stones,jewels) |
|||
s=0; |
|||
for c=jewels |
|||
s=s+sum(c==stones); |
|||
end |
|||
%!test |
|||
%! assert(count_jewels('aAAbbbb','aA'),3) |
|||
%!test |
|||
%! assert(count_jewels('ZZ','z'),0) |
|||
</lang> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.6}} |
|||
<lang min>(('' '' '') => spread if) :if? |
|||
((1 0 if?) concat map sum) :count |
|||
(swap indexof -1 !=) :member? |
|||
(("" split) dip 'member? cons count) :count-jewels |
|||
"aAAbbbb" "aA" count-jewels puts! |
|||
"ZZ" "z" count-jewels puts!</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|Modula-2}}== |
|||
<lang modula2>MODULE Jewels; |
|||
FROM FormatString IMPORT FormatString; |
|||
FROM Terminal IMPORT WriteString,WriteLn,ReadChar; |
|||
PROCEDURE WriteInt(n : INTEGER); |
|||
VAR buf : ARRAY[0..15] OF CHAR; |
|||
BEGIN |
|||
FormatString("%i", buf, n); |
|||
WriteString(buf) |
|||
END WriteInt; |
|||
PROCEDURE CountJewels(s,j : ARRAY OF CHAR) : INTEGER; |
|||
VAR c,i,k : CARDINAL; |
|||
BEGIN |
|||
c :=0; |
|||
FOR i:=0 TO HIGH(s) DO |
|||
FOR k:=0 TO HIGH(j) DO |
|||
IF (j[k]#0C) AND (s[i]#0C) AND (j[k]=s[i]) THEN |
|||
INC(c); |
|||
BREAK |
|||
END |
|||
END |
|||
END; |
|||
RETURN c |
|||
END CountJewels; |
|||
BEGIN |
|||
WriteInt(CountJewels("aAAbbbb", "aA")); |
|||
WriteLn; |
|||
WriteInt(CountJewels("ZZ", "z")); |
|||
WriteLn; |
|||
ReadChar |
|||
END Jewels.</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Nim}}== |
|||
<lang Nim>import sequtils |
|||
func countJewels(stones, jewels: string): Natural = |
|||
stones.countIt(it in jewels) |
|||
echo countJewels("aAAbbbb", "aA") |
|||
echo countJewels("ZZ", "z")</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Objeck}}== |
|||
{{trans|Java}} |
|||
<lang Objeck>use Collection.Generic; |
|||
class JewelsStones { |
|||
function : Main(args : String[]) ~ Nil { |
|||
Count("aAAbbbb", "aA")->PrintLine(); |
|||
Count("ZZ", "z")->PrintLine(); |
|||
} |
|||
function : Count(stones : String, jewels : String) ~ Int { |
|||
bag := Set->New()<CharHolder>; |
|||
each(i : jewels) { |
|||
bag->Insert(jewels->Get(i)); |
|||
}; |
|||
count := 0; |
|||
each(i : stones) { |
|||
if(bag->Has(stones->Get(i))) { |
|||
count++; |
|||
}; |
|||
}; |
|||
return count; |
|||
} |
|||
}</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|Perl}}== |
|||
<lang perl>sub count_jewels { |
|||
my( $j, $s ) = @_; |
|||
my($c,%S); |
|||
$S{$_}++ for split //, $s; |
|||
$c += $S{$_} for split //, $j; |
|||
return "$c\n"; |
|||
} |
|||
print count_jewels 'aA' , 'aAAbbbb'; |
|||
print count_jewels 'z' , 'ZZ';</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
===Alternate using regex=== |
|||
<lang perl>#!/usr/bin/perl |
|||
use strict; # https://rosettacode.org/wiki/Jewels_and_Stones#Perl |
|||
use warnings; |
|||
sub count_jewels { scalar( () = $_[0] =~ /[ $_[1] ]/gx ) } # stones, jewels |
|||
print "$_ = ", count_jewels( split ), "\n" for split /\n/, <<END; |
|||
aAAbbbb aA |
|||
aAAbbbb abc |
|||
ZZ z |
|||
END</lang> |
|||
{{out}} |
|||
<pre> |
|||
aAAbbbb aA = 3 |
|||
aAAbbbb abc = 5 |
|||
ZZ z = 0 |
|||
</pre> |
|||
=={{header|Phix}}== |
|||
<lang Phix>function count_jewels(string stones, jewels) |
|||
integer res = 0 |
|||
for i=1 to length(stones) do |
|||
res += find(stones[i],jewels)!=0 |
|||
end for |
|||
return res |
|||
end function |
|||
?count_jewels("aAAbbbb","aA") |
|||
?count_jewels("ZZ","z")</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|Prolog}}== |
|||
<lang prolog> |
|||
:- system:set_prolog_flag(double_quotes,codes) . |
|||
count_jewels(STONEs0,JEWELs0,COUNT) |
|||
:- |
|||
findall(X,(member(X,JEWELs0),member(X,STONEs0)),ALLs) , |
|||
length(ALLs,COUNT) |
|||
. |
|||
</lang> |
|||
{{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}} |
|||
<lang prolog>count_jewels(Stones, Jewels, N):- |
|||
string_codes(Stones, Scodes), |
|||
string_codes(Jewels, Jcodes), |
|||
msort(Scodes, SScodes), |
|||
sort(Jcodes, SJcodes), |
|||
count_jewels(SScodes, SJcodes, N, 0). |
|||
count_jewels([], _, N, N):-!. |
|||
count_jewels(_, [], N, N):-!. |
|||
count_jewels([C|Stones], [C|Jewels], N, R):- |
|||
!, |
|||
R1 is R + 1, |
|||
count_jewels(Stones, [C|Jewels], N, R1). |
|||
count_jewels([S|Stones], [J|Jewels], N, R):- |
|||
J < S, |
|||
!, |
|||
count_jewels([S|Stones], Jewels, N, R). |
|||
count_jewels([_|Stones], Jewels, N, R):- |
|||
count_jewels(Stones, Jewels, N, R).</lang> |
|||
{{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}}== |
|||
<lang python>def countJewels(s, j): |
|||
return sum(x in j for x in s) |
|||
print countJewels("aAAbbbb", "aA") |
|||
print countJewels("ZZ", "z")</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
===Python 3 Alternative=== |
|||
<lang python>def countJewels(stones, jewels): |
|||
jewelset = set(jewels) |
|||
return sum(1 for stone in stones if stone in jewelset) |
|||
print(countJewels("aAAbbbb", "aA")) |
|||
print(countJewels("ZZ", "z"))</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Racket}}== |
|||
<lang racket>#lang racket |
|||
(define (jewels-and-stones stones jewels) |
|||
(length (filter (curryr member (string->list jewels)) (string->list stones)))) |
|||
(module+ main |
|||
(jewels-and-stones "aAAbbbb" "aA") |
|||
(jewels-and-stones "ZZ" "z")) |
|||
</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
<lang perl6>sub count-jewels ( Str $j, Str $s --> Int ) { |
|||
my %counts_of_all = $s.comb.Bag; |
|||
my @jewel_list = $j.comb.unique; |
|||
return %counts_of_all ∩ @jewel_list.Bag ?? %counts_of_all{ @jewel_list }.sum !! 0; |
|||
} |
|||
say count-jewels 'aA' , 'aAAbbbb'; |
|||
say count-jewels 'z' , 'ZZ';</lang> |
|||
{{Out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|REXX}}== |
|||
Programming note: a check is made so that only (Latin) letters are counted as a match. |
|||
<lang rexx>/*REXX pgm counts how many letters (in the 1st string) are in common with the 2nd string*/ |
|||
say count('aAAbbbb', "aA") |
|||
say count('ZZ' , "z" ) |
|||
exit /*stick a fork in it, we're all done. */ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
count: procedure; parse arg stones,jewels /*obtain the two strings specified. */ |
|||
#= 0 /*initialize the variable # to zero.*/ |
|||
do j=1 for length(stones) /*scan STONES for matching JEWELS chars*/ |
|||
x= substr(stones, j, 1) /*obtain a character of the STONES var.*/ |
|||
if datatype(x, 'M') then if pos(x, jewels)\==0 then #= # + 1 |
|||
end /*j*/ /* [↑] if a letter and a match, bump #*/ |
|||
return # /*return the number of common letters. */</lang> |
|||
{{out|output|text= when using the default inputs:}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Ring}}== |
|||
<lang ring># Project Jewels and Stones |
|||
jewels = "aA" |
|||
stones = "aAAbbbb" |
|||
see jewelsandstones(jewels,stones) + nl |
|||
jewels = "z" |
|||
stones = "ZZ" |
|||
see jewelsandstones(jewels,stones) + nl |
|||
func jewelsandstones(jewels,stones) |
|||
num = 0 |
|||
for n = 1 to len(stones) |
|||
pos = substr(jewels,stones[n]) |
|||
if pos > 0 |
|||
num = num + 1 |
|||
ok |
|||
next |
|||
return num |
|||
</lang> |
|||
Output: |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Ruby}}== |
|||
<lang ruby>stones, jewels = "aAAbbbb", "aA" |
|||
stones.count(jewels) # => 3 |
|||
</lang> |
|||
=={{header|Rust}}== |
|||
<lang rust>fn count_jewels(stones: &str, jewels: &str) -> u8 { |
|||
let mut count: u8 = 0; |
|||
for cur_char in stones.chars() { |
|||
if jewels.contains(cur_char) { |
|||
count += 1; |
|||
} |
|||
} |
|||
count |
|||
} |
|||
fn main() { |
|||
println!("{}", count_jewels("aAAbbbb", "aA")); |
|||
println!("{}", count_jewels("ZZ", "z")); |
|||
} |
|||
</lang> |
|||
Output:<pre>3 |
|||
0</pre> |
|||
=={{header|Scala}}== |
|||
<lang Scala>object JewelsStones extends App { |
|||
def countJewels(s: String, j: String): Int = s.count(i => j.contains(i)) |
|||
println(countJewels("aAAbbbb", "aA")) |
|||
println(countJewels("ZZ", "z")) |
|||
}</lang> |
|||
{{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|Sidef}}== |
|||
<lang ruby>func countJewels(s, j) { |
|||
s.chars.count { |c| |
|||
j.contains(c) |
|||
} |
|||
} |
|||
say countJewels("aAAbbbb", "aA") #=> 3 |
|||
say countJewels("ZZ", "z") #=> 0</lang> |
|||
=={{header|Snobol}}== |
|||
<lang snobol>* See how many jewels are among the stones |
|||
DEFINE('JEWELS(JWL,STN)') :(JEWELS_END) |
|||
JEWELS JEWELS = 0 |
|||
JWL = ANY(JWL) |
|||
JMATCH STN JWL = '' :F(RETURN) |
|||
JEWELS = JEWELS + 1 :(JMATCH) |
|||
JEWELS_END |
|||
* Example from the task (prints 3) |
|||
OUTPUT = JEWELS('aA','aAAbbbb') |
|||
* Example with no jewels (prints 0) |
|||
OUTPUT = JEWELS('z','ZZ') |
|||
END</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|SQL}}== |
|||
<lang SQL>-- See how many jewels are among the stones |
|||
declare @S varchar(1024) = 'AaBbCcAa' |
|||
, @J varchar(1024) = 'aA'; |
|||
declare @SLEN int = len(@S); |
|||
declare @JLEN int = len(@J); |
|||
declare @TCNT int = 0; |
|||
declare @SPOS int = 1; -- curr position in @S |
|||
declare @JPOS int = 1; -- curr position in @J |
|||
declare @FCHR char(1); -- char to find |
|||
while @JPOS <= @JLEN |
|||
begin |
|||
set @FCHR = substring(@J, @JPOS, 1); |
|||
set @SPOS = 1; |
|||
while @SPOS > 0 and @SPOS <= @SLEN |
|||
begin |
|||
set @SPOS = charindex(@FCHR, @S COLLATE Latin1_General_CS_AS, @SPOS); |
|||
if @SPOS > 0 begin |
|||
set @TCNT = @TCNT + 1; |
|||
set @SPOS = @SPOS + 1; |
|||
end |
|||
end |
|||
set @JPOS = @JPOS + 1; |
|||
end |
|||
print 'J='+@J+' S='+@S+' TOTAL = '+cast(@TCNT as varchar(8)); |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
J=aA S=AaBbCcAa TOTAL = 4 |
|||
</pre> |
|||
=={{header|Swift}}== |
|||
<lang swift>func countJewels(_ stones: String, _ jewels: String) -> Int { |
|||
return stones.map({ jewels.contains($0) ? 1 : 0 }).reduce(0, +) |
|||
} |
|||
print(countJewels("aAAbbbb", "aA")) |
|||
print(countJewels("ZZ", "z"))</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Tcl}}== |
|||
<lang Tcl>proc shavej {stones jewels} { |
|||
set n 0 |
|||
foreach c [split $stones {}] { |
|||
incr n [expr { [string first $c $jewels] >= 0 }] |
|||
} |
|||
return $n |
|||
} |
|||
puts [shavej aAAbbbb aA] |
|||
puts [shavej ZZ z]</lang> |
|||
{{out}} |
|||
3 |
|||
0 |
|||
=={{header|Terraform}}== |
|||
<lang hcl>variable "jewels" { |
|||
default = "aA" |
|||
} |
|||
variable "stones" { |
|||
default = "aAAbbbb" |
|||
} |
|||
locals { |
|||
jewel_list = split("", var.jewels) |
|||
stone_list = split("", var.stones) |
|||
found_jewels = [for s in local.stone_list: s if contains(local.jewel_list, s)] |
|||
} |
|||
output "jewel_count" { |
|||
value = length(local.found_jewels) |
|||
}</lang> |
|||
{{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|VBA}}== |
|||
{{trans|Phix}}<lang vb>Function count_jewels(stones As String, jewels As String) As Integer |
|||
Dim res As Integer: res = 0 |
|||
For i = 1 To Len(stones) |
|||
res = res - (InStr(1, jewels, Mid(stones, i, 1), vbBinaryCompare) <> 0) |
|||
Next i |
|||
count_jewels = res |
|||
End Function |
|||
Public Sub main() |
|||
Debug.Print count_jewels("aAAbbbb", "aA") |
|||
Debug.Print count_jewels("ZZ", "z") |
|||
End Sub</lang>{{out}} |
|||
<pre> 3 |
|||
0 </pre> |
|||
=={{header|Visual Basic .NET}}== |
|||
{{trans|C#}} |
|||
<lang vbnet>Module Module1 |
|||
Function Count(stones As String, jewels As String) As Integer |
|||
Dim bag = jewels.ToHashSet |
|||
Return stones.Count(AddressOf bag.Contains) |
|||
End Function |
|||
Sub Main() |
|||
Console.WriteLine(Count("aAAbbbb", "Aa")) |
|||
Console.WriteLine(Count("ZZ", "z")) |
|||
End Sub |
|||
End Module</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
|||
=={{header|Wren}}== |
|||
{{trans|Kotlin}} |
|||
<lang ecmascript>var countJewels = Fn.new { |s, j| s.count { |c| j.contains(c) } } |
|||
System.print(countJewels.call("aAAbbbb", "aA")) |
|||
System.print(countJewels.call("ZZ", "z"))</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
</pre> |
|||
=={{header|XPL0}}== |
|||
<lang XPL0>string 0; \Use zero-terminated strings |
|||
func Count(Stones, Jewels); |
|||
\Return number of letters in Stones that match letters in Jewels |
|||
char Stones, Jewels; |
|||
int Cnt, I, J; |
|||
[Cnt:= 0; |
|||
I:= 0; |
|||
while Jewels(I) do |
|||
[J:= 0; |
|||
while Stones(J) do |
|||
[if Stones(J) = Jewels(I) then Cnt:= Cnt+1; |
|||
J:= J+1; |
|||
]; |
|||
I:= I+1; |
|||
]; |
|||
return Cnt; |
|||
]; |
|||
[IntOut(0, Count("aAAbbbb", "aA")); CrLf(0); |
|||
IntOut(0, Count("ZZ", "z")); CrLf(0); |
|||
IntOut(0, Count("pack my box with five dozen liquor jugs", "aeiou")); CrLf(0); |
|||
]</lang> |
|||
{{out}} |
|||
<pre> |
|||
3 |
|||
0 |
|||
11 |
|||
</pre> |
|||
=={{header|zkl}}== |
|||
<lang zkl>fcn countJewels(a,b){ a.inCommon(b).len() }</lang> |
|||
<lang zkl>println(countJewels("aAAbbbb", "aA")); |
|||
println(countJewels("ZZ", "z"));</lang> |
|||
{{out}} |
|||
<pre>3 |
|||
0</pre> |
Revision as of 12:50, 19 February 2021
Arturo
<lang rebol>count: function [jewels,stones][
size select split stones => [in? & jewels]
]
print count "aA" "aAAbbbb"</lang>
- Output:
3