Jewels and stones: Difference between revisions

{{trans|Python}}

 

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

 

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

 

{{out}}

</pre>

 

 

jmp demo

;;; Count jewels.

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

jpage: equ $/256+1

 

{{out}}

 

<pre>3</pre>

 

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

 

bits 16

org 100h

num: db '$'

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

 

{{out}}

 

<pre>3</pre>

 

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

<pre>aAAbbbb in aA: 3

ZZZZ in z: 0</pre>

 

function contar_joyas(piedras, joyas)

cont = 0

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

print contar_joyas("AB", "")

{{out}}

 

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

0</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

 

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

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

{{out}}

<pre>3

0</pre>

 

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

3

</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>

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>

 

 

'''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[]|

<pre>3</pre>

 

 

'''Module''':

 

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

 

 

'''Main''':

 

{{out}}

<pre>Jewels.count("aAAbbbb", "aA") = 3

Jewels.count("ZZ", "z") = 0</pre>

 

=={{header|Kotlin}}==

 

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

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

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

<pre>

3

 

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

{{trans|Java}}

 

class JewelsStones {

return count;

}

 

{{out}}

0

</pre>

 

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

{{out}}

<pre>

0

</pre>

 

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

0</pre>

 

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

0</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" )

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

<pre>3

 

=={{header|Ring}}==

jewels = "aA"

next

return num

Output:

<pre>3

0</pre>

 

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

</pre>

 

 

 

 

{{out}}

 

=={{header|Wren}}==

{{trans|Kotlin}}

 

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

 

{{out}}

3

0

</pre>

 

=={{header|zkl}}==

{{out}}

<pre>3