Unique characters in each string: Difference between revisions

{{trans|Python}}

 

 

 

{{out}}

 

=={{header|Action!}}==

CHAR ARRAY uniq(MAX)

 

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Unique_characters_in_each_string.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure Unique_Characters is

2 => Occurences ("2b6178c97a938stf"),

3 => Occurences ("3ycxdb1fgxa2yz")));

{{out}}

<pre>1 2 3 a b c</pre>

 

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

# of stings #

OP UNIQUEINEACH = ( []STRING s )STRING:

STRING unique = UNIQUEINEACH []STRING( "1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz" );

FOR c FROM LWB unique TO UPB unique DO print( ( " ", unique[ c ] ) ) OD

{{out}}

<pre>

The filtering here is case sensitive, the sorting dependent on locale.

 

use framework "Foundation"

 

end uniqueCharactersInEachString

 

 

{{output}}

 

===Core language only===

This can be case-insensitive if required. (Just leave out the 'considering case' statement round the call to the handler). The requirement for AppleScript 2.3.1 is only for the 'use' command which loads the "Heap Sort" script. If "Heap Sort"'s instead loaded with the older 'load script' command or copied into the code, this will work on systems as far back as Mac OS X 10.5 (Leopard) and possibly earlier. Same output as above.

 

use sorter : script "Heap Sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Heapsort#AppleScript>

 

considering case

uniqueCharactersInEachString({"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"})

 

=={{header|Arturo}}==

 

uniques: split first arr

 

]

 

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f UNIQUE_CHARACTERS_IN_EACH_STRING.AWK

#

exit(0)

}

{{out}}

<pre>

 

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

// Unique characters in each string: Nigel Galloway. May 12th., 2021

let fN g=g|>Seq.countBy id|>Seq.filter(fun(_,n)->n=1)

let fUc g=g|>List.map fN|>Seq.concat|>Seq.countBy id|>Seq.filter(fun(_,n)->n=List.length g)|>Seq.map(fun((n,_),_)->n)|>Seq.sort

printfn "%s" (fUc ["1a3c52debeffd";"2b6178c97a938stf";"3ycxdb1fgxa2yz"]|>Array.ofSeq|>System.String)

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

 

{ "1a3c52debeffd" "2b6178c97a938sf" "3ycxdb1fgxa2yz" }

! intersect-all obtain elements present in every string -> "1a3c2bf"

! [ duplicates ] gather obtain elements that repeat within a single string -> "efd798xy"

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

'count occurrences of character c in string s

dim as integer i, r = 0

next i

 

{{out}}<pre>123abc</pre>

 

=={{header|Go}}==

 

import (

sort.Slice(chars, func(i, j int) bool { return chars[i] < chars[j] })

fmt.Println(string(chars))

 

{{out}}

 

=={{header|Haskell}}==

import Data.Maybe (fromJust)

import qualified Data.Set as S

"2b6178c97a938stf",

"3ycxdb1fgxa2yz"

{{Out}}

<pre>123abc</pre>

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>123abc</pre>

 

'''Helper functions'''

def bow(stream):

reduce stream as $word ({}; .[($word|tostring)] += 1);

elif (.[0]|length) == 0 then empty

else [.[0], [ .[1:] | intersections]] | ios

 

'''The task'''

# convert each string to an array of the constituent characters

map((explode | map([.]|implode)))

["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]

| [once_in_each_string]

{{out}}

<pre>

 

=={{header|Julia}}==

 

onceineachstring(list) = filter(c -> all(w -> count(x -> x == c, w) == 1, list), (sort ∘ unique ∘ prod)(list))

 

println(onceineachstring(list))

['1', '2', '3', 'a', 'b', 'c']

</pre>

 

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

uniques = Sort[Select[Tally[#], Last/*EqualTo[1]][[All, 1]]] & /@ sets;

{{out}}

<pre>{"1", "2", "3", "a", "b", "c"}</pre>

 

=={{header|Nim}}==

 

var result = AllChars

result = result * uniqueChars # Intersection.

 

 

{{out}}

=={{header|Pascal}}==

{{works with|Extended Pascal}}

 

type

end;

writeLn

{{out}}

1 2 3 a b c

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Unique_characters_in_each_string

$chars !~ /$_.*$_/ && # the 'only once in each string' test

@strings == $chars =~ s/$_//g, # the 'in every string' test

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">sets</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">intersection</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">set</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">),</span><span style="color: #000000;">once</span><span style="color: #0000FF;">}))</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"found %d unique common characters: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

 

=={{header|Picat}}==

 

main =>

foreach(E in L)

Map.put(E,Map.get(E,0)+1)

 

{{out}}

 

=={{header|PicoLisp}}==

(if (assoc K (val V))

(inc (nth (cadr @) N))

"1a3c52debeffd"

"2b6178c97a938stf"

{{out}}

<pre>

 

=={{header|Python}}==

 

print(sorted([ch for ch in set([c for c in ''.join(LIST)]) if all(w.count(ch) == 1 for w in LIST)]))

<pre>

['1', '2', '3', 'a', 'b', 'c']

Or, avoiding intermediate lists.

 

 

{{out}}

We can also avoid concatenating all strings in the input list.

 

 

LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]

if all(w.count(ch) == 1 for w in LIST)

)

 

{{out}}

Or, avoid calling <code>count()</code> for every distinct character in every string in the input list.

 

 

LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]

)

)

 

{{out}}

=={{header|Raku}}==

 

 

{{out}}

<pre>1 2 3 a b c</pre>

 

On an &nbsp;'''EBCDIC'''&nbsp; machine, &nbsp; the lowercase letters and the uppercase letters &nbsp; aren't &nbsp; contiguous.

parse arg $ /*obtain optional arguments from the CL*/

if $='' | $="," then $= '1a3c52debeffd' "2b6178c97a938stf" '3ycxdb1fgxa2yz'

say 'unique characters are: ' @ /*display the unique characters found. */

say

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

<pre>

 

=={{header|Ring}}==

see "working..." + nl

see "Unique characters in each string are:" + nl

end

return sum

{{out}}

<pre>

 

=={{header|Ruby}}==

 

uniqs_in_str = arr.map{|str| str.chars.tally.filter_map{|char, count| char if count == 1} }

puts uniqs_in_str.inject(&:intersection).sort.join(" ")

{{out}}

<pre>1 2 3 a b c</pre>

{{libheader|Wren-seq}}

{{libheader|Wren-sort}}

import "/sort" for Sort

 

Sort.insertion(uniqueChars)

System.print("Found %(uniqueChars.count) unique character(s) common to each string, namely:")

 

{{out}}

=={{header|Vlang}}==

{{trans|go}}

strings := ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]!

mut u := map[rune]int{}

chars.sort()

println(chars.string())

 

{{out}}

 

=={{header|XPL0}}==

int Char, I, J;

string 0; \use null-terminated string convention

if Unique(0, Char) & Unique(1, Char) & Unique(2, Char) then

[ChOut(0, Char); ChOut(0, ^ )];

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

local i, r

r = 0

print uniq$

{{out}}

<pre>123abc</pre>