Jewels and stones: Difference between revisions

{{trans|Python}}

 

R sum(s.map(x -> Int(x C @j)))

 

print(count_jewels(‘aAAbbbb’, ‘aA’))

 

{{out}}

=={{header|8080 Assembly}}==

 

jmp demo

;;; Count jewels.

;;; Next free page of memory is used for the jewel array

jpage: equ $/256+1

 

{{out}}

=={{header|8086 Assembly}}==

 

bits 16

org 100h

num: db '$'

stones: db 'aAAbbbb',0 ; Example from the task

 

{{out}}

 

=={{header|Ada}}==

 

procedure Jewels_And_Stones is

Show ("aAAbbbb", "aA");

Show ("ZZ", "z");

 

{{out}}

 

=={{header|ALGOL 68}}==

# procedure that counts the number of times the letters in jewels occur in stones #

PROC count jewels = ( STRING stones, jewels )INT:

print( ( count jewels( "ZZ", "z" ), newline ) )

 

{{out}}

<pre> +3

{{works with|Dyalog APL}}

 

 

{{out}}

=={{header|AppleScript}}==

===Functional===

on jewelCount(jewels, stones)

set js to chars(jewels)

set my text item delimiters to dlm

str

{{Out}}

<pre>3

===Idiomatic===

 

set counter to 0

considering case

end jewelsAndStones

 

 

{{output}}

 

=={{header|Arturo}}==

size select split stones => [in? & jewels]

]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

for each, jewel in StrSplit(jj)

for each, stone in StrSplit(ss)

num++

return num

Outputs:<pre>3</pre>

 

=={{header|AWK}}==

BEGIN {

printf("%d\n",count("aAAbbbb","aA"))

return(total)

}

{{out}}

<pre>3

=={{header|BASIC}}==

 

20 FOR A%=1 TO N%

30 READ J$,S$

210 DATA "aA","aAAbbbb"

220 DATA "z","ZZZZ"

 

{{out}}

 

=={{header|BASIC256}}==

function contar_joyas(piedras, joyas)

cont = 0

print contar_joyas("ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")

print contar_joyas("AB", "")

{{out}}

<pre>

 

=={{header|BCPL}}==

 

let jewels(j, s) = valof

$( show("aA", "aAAbbbb")

show("z", "ZZ")

{{out}}

<pre>"aA" in "aAAbbbb": 3

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

 

=={{header|Bracmat}}==

= stones jewels N

. !arg:(?stones.?jewels)

)

& f$(aAAbbbb.aA)

'''Output'''

<pre>3</pre>

=={{header|C}}==

{{trans|Kotlin}}

#include <string.h>

 

printf("%d\n", count_jewels("ZZ", "z"));

return 0;

 

{{output}}

 

=={{header|C sharp}}==

using System.Linq;

 

return stones.Count(bag.Contains);

}

{{out}}

<pre>

=={{header|C++}}==

{{trans|D}}

#include <iostream>

 

 

return 0;

{{out}}

<pre>3

 

=={{header|CLU}}==

is_jewel: array[bool] := array[bool]$fill(0, 256, false)

for c: char in string$chars(jewels) do

start_up = proc ()

show("aA", "aAAbbbb")

{{out}}

<pre>"aA" in "aAAbbbb": 3</pre>

 

=={{header|Cowgol}}==

 

sub count_jewels(stones: [uint8], jewels: [uint8]): (count: uint16) is

 

print_and_count("aAAbbbb", "aA");

 

{{out}}

 

=={{header|Crystal}}==

stones.count(jewels) # => 3

 

 

# This works as intended though:

 

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

 

countJewels("aAAbbbb", "aA").writeln;

countJewels("ZZ", "z").writeln;

{{out}}

<pre>3

 

=={{header|Draco}}==

[256] bool jewel;

word count;

show("aA", "aAAbbbb");

show("z", "ZZ")

{{out}}

<pre>'aA' in 'aAAbbbb': 3

{{trans|Swift}}

 

stones.Iterate().Map(x => jewels.Contains(x) ? 1 : 0).Reduce((x,y) => x + y, 0)

}

print(countJewels("aAAbbbb", "aA"))

 

{{out}}

 

=={{header|F_Sharp|F#}}==

let fN jewels stones=stones|>Seq.filter(fun n->Seq.contains n jewels)|>Seq.length

printfn "%d" (fN "aA" "aAAbbbb")

{{out}}

<pre>

 

=={{header|Factor}}==

 

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

 

"aAAbbbb" "aA"

{{out}}

<pre>

 

=={{header|Euphoria}}==

function number_of(object jewels, object stones) -- why limit ourselves to strings?

integer ct = 0

? 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!

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

function contar_joyas(piedras as string, joyas as string) as integer

dim as integer bc, cont: cont = 0

"ABCDEFGHIJKLMNOPQRSTUVWXYZ@abcdefghijklmnopqrstuvwxyz")

print contar_joyas("AB", "")

{{out}}

<pre>

 

'''Outer loop stones, index into jewels:'''

import (

func main() {

fmt.Println(js("aAAbbbb", "aA"))

{{out}}

<pre>3</pre>

 

'''Outer loop jewels, count stones:'''

for _, b := range []byte(jewels) {

n += strings.Count(stones, string(b))

}

return

 

'''Construct jewel set, then loop over stones:'''

var jSet ['z' + 1]int

for _, b := range []byte(jewels) {

}

return

 

'''Construct stone multiset, then loop over jewels:'''

var sset ['z' + 1]int

for _, b := range []byte(stones) {

}

return

 

=={{header|Haskell}}==

:: Eq a

=> [a] -> [a] -> Int

main :: IO ()

main = mapM_ print $ uncurry jewelCount <$> [("aA", "aAAbbbb"), ("z", "ZZ")]

{{Out}}

<pre>3

Or in terms of filter rather than foldr

 

:: Eq a

=> [a] -> [a] -> Int

main = do

print $ jewelCount "aA" "aAAbbbb"

{{Out}}

<pre>3

 

=={{header|J}}==

NB. jewels sums a raveled equality table

NB. use: x jewels y x are the stones, y are the jewels.

0

 

=={{header|Java}}==

import java.util.Set;

 

System.out.println(countJewels("ZZ", "z"));

}

{{out}}

<pre>3

 

=={{header|Javascript}}==

 

// jewelCount :: String -> String -> Int

]

.map(x => jewelCount(...x))

{{Out}}

<pre>[3, 0]</pre>

 

=={{header|jq}}==

[$stones|split("") as $s|$jewels|split("") as $j|$s[]|

 

{{Out}}

 

'''Module''':

 

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

 

 

'''Main''':

 

{{out}}

 

=={{header|Kotlin}}==

 

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

println(countJewels("aAAbbbb", "aA"))

println(countJewels("ZZ", "z"))

 

{{output}}

 

=={{header|Lambdatalk}}==

{def countjewels

{def countjewels.r

{countjewels aAAbbbb aA} -> 3

{countjewels ZZ z} -> 0

 

=={{header|Lua}}==

{{trans|C}}

local count = 0

for i=1,#s do

 

print(count_jewels("aAAbbbb", "aA"))

{{out}}

<pre>3

 

=={{header|Maple}}==

local count, j, letter:

j := convert(jewels,set):

return count:

end proc:

{{Out|Output}}

<pre>3</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

JewelsStones["aA", "aAAbbbb"]

{{out}}

<pre>3

 

=={{header|MATLAB}} / {{header|Octave}}==

function s = count_jewels(stones,jewels)

s=0;

%!test

%! assert(count_jewels('ZZ','z'),0)

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

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

 

"aAAbbbb" "aA" count-jewels puts!

{{out}}

<pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

{{out}}

<pre>3

 

=={{header|Nim}}==

 

func countJewels(stones, jewels: string): Natural =

 

echo countJewels("aAAbbbb", "aA")

 

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

 

class JewelsStones {

return count;

}

 

{{out}}

 

=={{header|Perl}}==

my( $j, $s ) = @_;

my($c,%S);

 

print count_jewels 'aA' , 'aAAbbbb';

{{out}}

<pre>3

0</pre>

===Alternate using regex===

 

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

aAAbbbb abc

ZZ z

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">stones</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">jewels</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"aAAbbbb"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"aA"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">count_jewels</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"ZZ"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"z"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

===List comprehension===

 

 

===Recursion===

jewels_and_stones2(Jewels,Stones,0,N).

 

N1 = N0

),

 

===Foreach loop===

N = 0,

foreach(J in Jewels, S in Stones)

N := N + 1

end

 

===Test===

Tests = [["aA","aAAbbbb"],

["z","ZZ"]

nl

end,

 

{{out}}

===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).

Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",

Len = Alpha.len,

time(println(js2=jewels_and_stones2(Jewels,Stones))),

time(println(js3=jewels_and_stones3(Jewels,Stones))),

 

{{out}}

 

=={{header|PL/M}}==

 

/* FIND JEWELS AMONG STONES */

 

CALL BDOS(0,0);

{{out}}

<pre>'aA' IN 'aAAbbbb': 3

=={{header|Prolog}}==

 

 

:- system:set_prolog_flag(double_quotes,codes) .

.

 

 

{{out}}

 

{{works with|SWI Prolog}}

string_codes(Stones, Scodes),

string_codes(Jewels, Jcodes),

count_jewels([S|Stones], Jewels, N, R).

count_jewels([_|Stones], Jewels, N, R):-

 

{{out}}

 

=={{header|Python}}==

return sum(x in j for x in s)

 

print countJewels("aAAbbbb", "aA")

{{Out}}

<pre>3

 

===Python 3 Alternative===

jewelset = set(jewels)

return sum(1 for stone in stones if stone in jewelset)

 

print(countJewels("aAAbbbb", "aA"))

{{Out}}

<pre>3

 

=={{header|R}}==

stones <- unlist(strsplit(stones, split = "")) # obtain a character vector

jewels <- unlist(strsplit(jewels, split = ""))

print(J_n_S("ZZ", "z"))

print(J_n_S("lgGKJGljglghGLGHlhglghoIPOgfdtrdDCHnvbnmBVC", "fFgGhH"))

{{Out}}

<pre>> print(J_n_S("aAAbbbb", "aA"))

=={{header|Quackery}}==

 

witheach [ bit | ]

rot witheach

drop ] is j&s ( $ $ --> n )

 

 

{{out}}

 

=={{header|Racket}}==

 

(define (jewels-and-stones stones jewels)

(jewels-and-stones "aAAbbbb" "aA")

(jewels-and-stones "ZZ" "z"))

{{out}}

<pre>3

=={{header|Raku}}==

(formerly Perl 6)

my %counts_of_all = $s.comb.Bag;

my @jewel_list = $j.comb.unique;

 

say count-jewels 'aA' , 'aAAbbbb';

{{Out}}

<pre>3

 

=={{header|Red}}==

title: "Jewels and stones"

red-version: 0.6.4

 

print count-jewels "aAAbbbb" "aA"

{{out}}

<pre>

=={{header|REXX}}==

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

say count('aAAbbbb', "aA")

say count('ZZ' , "z" )

if datatype(x, 'M') then if pos(x, jewels)\==0 then #= # + 1

end /*j*/ /* [↑] if a letter and a match, bump #*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>3

 

=={{header|Ring}}==

jewels = "aA"

next

return num

Output:

<pre>3

 

=={{header|Ruby}}==

 

stones.count(jewels) # => 3

 

=={{header|Rust}}==

let mut count: u8 = 0;

for cur_char in stones.chars() {

println!("{}", count_jewels("ZZ", "z"));

}

Output:<pre>3

0</pre>

 

=={{header|Scala}}==

def countJewels(s: String, j: String): Int = s.count(i => j.contains(i))

 

println(countJewels("aAAbbbb", "aA"))

println(countJewels("ZZ", "z"))

{{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}}==

s.chars.count { |c|

j.contains(c)

 

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

 

=={{header|Snobol}}==

DEFINE('JEWELS(JWL,STN)') :(JEWELS_END)

JEWELS JEWELS = 0

* Example with no jewels (prints 0)

OUTPUT = JEWELS('z','ZZ')

 

{{out}}

 

=={{header|SQL}}==

declare @S varchar(1024) = 'AaBbCcAa'

, @J varchar(1024) = 'aA';

end

print 'J='+@J+' S='+@S+' TOTAL = '+cast(@TCNT as varchar(8));

 

{{out}}

 

=={{header|Swift}}==

return stones.map({ jewels.contains($0) ? 1 : 0 }).reduce(0, +)

}

 

print(countJewels("aAAbbbb", "aA"))

 

{{out}}

 

=={{header|Tcl}}==

set n 0

foreach c [split $stones {}] {

}

puts [shavej aAAbbbb aA]

{{out}}

3

 

=={{header|Terraform}}==

default = "aA"

}

output "jewel_count" {

value = length(local.found_jewels)

 

{{Out}}

 

=={{header|Transd}}==

 

MainModule: {

_start: (λ (lout (countJewels "aA" "aAAbbbb"))

(lout (countJewels "b" "BB")))

{{out}}

<pre>

 

=={{header|VBA}}==

Dim res As Integer: res = 0

For i = 1 To Len(stones)

Debug.Print count_jewels("aAAbbbb", "aA")

Debug.Print count_jewels("ZZ", "z")

<pre> 3

0 </pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function Count(stones As String, jewels As String) As Integer

End Sub

 

{{out}}

<pre>3

=={{header|Vlang}}==

{{trans|Go}}

mut n := 0

for b in stones.bytes() {

fn main() {

println(js("aAAbbbb", "aA"))

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

 

System.print(countJewels.call("aAAbbbb", "aA"))

 

{{out}}

 

=={{header|XPL0}}==

 

func Count(Stones, Jewels);

IntOut(0, Count("ZZ", "z")); CrLf(0);

IntOut(0, Count("pack my box with five dozen liquor jugs", "aeiou")); CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

{{out}}

<pre>3