Unique characters in each string: Difference between revisions
Unique characters in each string (view source)
Revision as of 10:27, 15 February 2024
, 3 months ago→{{header|Wren}}: Minor tidy
m (Python alternatives) |
m (→{{header|Wren}}: Minor tidy) |
||
(11 intermediate revisions by 8 users not shown) | |||
Line 18:
{{trans|Python}}
<
print(sorted(Set(Array(LIST.join(‘’))).filter(ch -> all(:LIST.map(w -> w.count(@ch) == 1)))))</
{{out}}
Line 28:
=={{header|Action!}}==
<
CHAR ARRAY uniq(MAX)
Line 94:
FI
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Unique_characters_in_each_string.png Screenshot from Atari 8-bit computer]
Line 102:
=={{header|Ada}}==
<
procedure Unique_Characters is
Line 133:
2 => Occurences ("2b6178c97a938stf"),
3 => Occurences ("3ycxdb1fgxa2yz")));
end Unique_Characters;</
{{out}}
<pre>1 2 3 a b c</pre>
=={{header|ALGOL 68}}==
<
# of stings #
OP UNIQUEINEACH = ( []STRING s )STRING:
Line 170:
STRING unique = UNIQUEINEACH []STRING( "1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz" );
FOR c FROM LWB unique TO UPB unique DO print( ( " ", unique[ c ] ) ) OD
END</
{{out}}
<pre>
Line 180:
The filtering here is case sensitive, the sorting dependent on locale.
<
use framework "Foundation"
Line 200:
end uniqueCharactersInEachString
uniqueCharactersInEachString({"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"})</
{{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>
Line 253:
considering case
uniqueCharactersInEachString({"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"})
end considering</
=={{header|Arturo}}==
<
uniques: split first arr
Line 266:
]
print sort uniques</
{{out}}
Line 273:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f UNIQUE_CHARACTERS_IN_EACH_STRING.AWK
#
Line 305:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 313:
3 strings, 43 characters, 20 different, 6 unique: 123abc
</pre>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">(∧∘(∊/⊣)´ (∊∧∊⌾⌽)⊸/¨) "1a3c52debeffd"‿"2b6178c97a938stf"‿"3ycxdb1fgxa2yz"</syntaxhighlight>
{{out}}
<pre>"123abc"</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
var SA: array [0..2] of string = ('1a3c52debeffd', '2b6178c97a938stf', '3ycxdb1fgxa2yz');
function CharsAppearingOnce(S: string): string;
{Return all character that only occur once}
var SL: TStringList;
var I,Inx: integer;
begin
SL:=TStringList.Create;
try
{Store each character and store a count}
{of the number of occurances in the object}
for I:=1 to Length(S) do
begin
{Check to see if letter is already in list}
Inx:=SL.IndexOf(S[I]);
{Increment the count if it is, otherwise store it}
if Inx>=0 then SL.Objects[Inx]:=Pointer(Integer(SL.Objects[Inx])+1)
else SL.AddObject(S[I],Pointer(1));
end;
{Sort the list}
SL.Sort;
{Now return letters with a count of one}
Result:='';
for I:=0 to SL.Count-1 do
if integer(SL.Objects[I])<2 then Result:=Result+SL[I];
finally SL.Free; end;
end;
function CommonToAllStrs(SA: array of string): string;
{Get all the letters shared by all the strings in SA}
var I,J,Cnt: integer;
var S1: string;
var C: char;
begin
Result:='';
{Exit if empty array}
if Length(SA)<1 then exit;
{Get the first string}
S1:=SA[0];
for I:=1 to Length(S1) do
begin
{Character from 1st string }
C:=S1[I];
{Count # of occurences}
Cnt:=1;
for J:=1 to High(SA) do
if Pos(C,SA[J])>0 then Inc(Cnt);
{grab it if it appears in all other string}
if Cnt=Length(SA) then Result:=Result+C;
end;
end;
procedure ShowCharsAppearOnce(Memo: TMemo);
var I: integer;
var S: string;
var SS: array of string;
begin
SetLength(SS,0);
{Get all single appearance characters}
for I:=0 to High(SA) do
begin
SetLength(SS,Length(SS)+1);
SS[High(SS)]:=CharsAppearingOnce(SA[I]);
end;
{Get the ones shared by all string}
S:=CommonToAllStrs(SS);
Memo.Lines.Add(S);
end;
</syntaxhighlight>
{{out}}
<pre>
123abc
Elapsed Time: 1.238 ms.
</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)
</syntaxhighlight>
{{out}}
<pre>
Line 328 ⟶ 420:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<
{ "1a3c52debeffd" "2b6178c97a938sf" "3ycxdb1fgxa2yz" }
Line 337 ⟶ 429:
! intersect-all obtain elements present in every string -> "1a3c2bf"
! [ duplicates ] gather obtain elements that repeat within a single string -> "efd798xy"
! without from the first string, remove elements that are in the second -> "1a3c2b"</
{{out}}
<pre>
Line 344 ⟶ 436:
=={{header|FreeBASIC}}==
<
'count occurrences of character c in string s
dim as integer i, r = 0
Line 369 ⟶ 461:
next i
print uniq</
{{out}}<pre>123abc</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn StringCharacterIsUnique( string as CFStringRef, chr as CFStringRef ) as BOOL
long count = 0, length = len(string)
CFRange range = fn StringRangeOfString( string, chr )
while ( range.location != NSNotFound )
count++
range.location++
range = fn StringRangeOfStringWithOptionsInRange( string, chr, 0, fn CFRangeMake(range.location,length-range.location) )
wend
end fn = (count == 1)
void local fn DoIt
CFArrayRef strings = @[@"1a3c52debeffd",@"2b6178c97a938stf",@"3ycxdb1fgxa2yz"]
CFStringRef chr
CFMutableArrayRef array = fn MutableArrayWithCapacity(0)
long i, j, count, length = len(strings[0])
for i = 0 to length - 1
chr = mid(strings[0],i,1)
if ( fn StringCharacterIsUnique( strings[0], chr ) )
count = 1
for j = 1 to len(strings) - 1
if ( fn StringCharacterIsUnique( strings[j], chr ) )
count++
end if
next
if ( count == len(strings) ) then MutableArrayAddObject( array, chr )
end if
next
MutableArraySortUsingSelector( array, @"compare:" )
print fn ArrayComponentsJoinedByString( array, @" " )
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
1 2 3 a b c
</pre>
=={{header|Go}}==
<
import (
Line 402 ⟶ 539:
sort.Slice(chars, func(i, j int) bool { return chars[i] < chars[j] })
fmt.Println(string(chars))
}</
{{out}}
Line 410 ⟶ 547:
=={{header|Haskell}}==
<
import Data.Maybe (fromJust)
import qualified Data.Set as S
Line 440 ⟶ 577:
"2b6178c97a938stf",
"3ycxdb1fgxa2yz"
]</
{{Out}}
<pre>123abc</pre>
=={{header|J}}==
<syntaxhighlight lang="j"> /:~@> (e. # [)&.>/ (-. -.@~: # ])&.> '1a3c52debeffd';'2b6178c97a938stf';'3ycxdb1fgxa2yz'
123abc</syntaxhighlight>
=={{header|JavaScript}}==
<
"use strict";
Line 507 ⟶ 648:
// MAIN ---
return main();
})();</
{{Out}}
<pre>123abc</pre>
Line 516 ⟶ 657:
'''Helper functions'''
<
def bow(stream):
reduce stream as $word ({}; .[($word|tostring)] += 1);
Line 540 ⟶ 681:
elif (.[0]|length) == 0 then empty
else [.[0], [ .[1:] | intersections]] | ios
end;</
'''The task'''
<
# convert each string to an array of the constituent characters
map((explode | map([.]|implode)))
Line 552 ⟶ 693:
["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
| [once_in_each_string]
</syntaxhighlight>
{{out}}
<pre>
Line 559 ⟶ 700:
=={{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;
Intersection @@ uniques</
{{out}}
<pre>{"1", "2", "3", "a", "b", "c"}</pre>
=={{header|Nim}}==
<
var result = AllChars
Line 586 ⟶ 727:
result = result * uniqueChars # Intersection.
echo result</
{{out}}
Line 593 ⟶ 734:
=={{header|Pascal}}==
{{works with|Extended Pascal}}
<
type
Line 676 ⟶ 817:
end;
writeLn
end.</
{{out}}
1 2 3 a b c
=={{header|Perl}}==
<
use strict; # https://rosettacode.org/wiki/Unique_characters_in_each_string
Line 691 ⟶ 832:
$chars !~ /$_.*$_/ && # the 'only once in each string' test
@strings == $chars =~ s/$_//g, # the 'in every string' test
$chars =~ /./g ]}\n";</
{{out}}
<pre>
Line 698 ⟶ 839:
=={{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>
Line 710 ⟶ 851:
<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>
Line 717 ⟶ 858:
=={{header|Picat}}==
<
main =>
Line 729 ⟶ 870:
foreach(E in L)
Map.put(E,Map.get(E,0)+1)
end.</
{{out}}
Line 735 ⟶ 876:
=={{header|PicoLisp}}==
<
(if (assoc K (val V))
(inc (nth (cadr @) N))
Line 755 ⟶ 896:
"1a3c52debeffd"
"2b6178c97a938stf"
"3ycxdb1fgxa2yz" ) ) )</
{{out}}
<pre>
Line 762 ⟶ 903:
=={{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']
Line 773 ⟶ 914:
Or, avoiding intermediate lists.
<
print(sorted(ch for ch in set("".join(LIST)) if all(w.count(ch) == 1 for w in LIST)))</
{{out}}
Line 784 ⟶ 925:
We can also avoid concatenating all strings in the input list.
<
LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
Line 794 ⟶ 935:
if all(w.count(ch) == 1 for w in LIST)
)
)</
{{out}}
Line 804 ⟶ 945:
Or, avoid calling <code>count()</code> for every distinct character in every string in the input list.
<
LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
Line 817 ⟶ 958:
)
)
)</
{{out}}
Line 823 ⟶ 964:
['1', '2', '3', 'a', 'b', 'c']
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery"> [ 0 128 of
swap witheach
[ 2dup peek
1+ unrot poke ] ] is countchars ( $ --> [ )
[ [] swap witheach
[ 1 = join ] ] is justones ( [ --> [ )
[ witheach
[ over i^ peek +
swap i^ poke ] ] is addnests ( [ [ --> [ )
[ [] swap witheach
[ 3 = if [ i^ join ] ] ] is threesfound ( [ --> $ )
$ "1a3c52debeffd" nested
$ "2b6178c97a938stf" nested join
$ "3ycxdb1fgxa2yz" nested join
witheach [ countchars justones ]
2 times addnests
threesfound
witheach [ emit sp ]</syntaxhighlight>
{{out}}
<pre>1 2 3 a b c </pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
put sort keys [∩] $strings.map: *.comb.Bag.grep: *.value == 1</
{{out}}
<pre>1 2 3 a b c</pre>
Line 842 ⟶ 1,013:
On an '''EBCDIC''' machine, the lowercase letters and the uppercase letters aren't contiguous.
<
parse arg $ /*obtain optional arguments from the CL*/
if $='' | $="," then $= '1a3c52debeffd' "2b6178c97a938stf" '3ycxdb1fgxa2yz'
Line 865 ⟶ 1,036:
say 'unique characters are: ' @ /*display the unique characters found. */
say
say 'Found ' L " unique characters." /*display the # of unique chars found. */</
{{out|output|text= when using the default input:}}
<pre>
Line 874 ⟶ 1,045:
=={{header|Ring}}==
<
see "working..." + nl
see "Unique characters in each string are:" + nl
Line 920 ⟶ 1,091:
end
return sum
</syntaxhighlight>
{{out}}
<pre>
Line 928 ⟶ 1,099:
Found 6 unique characters in each string
done...
</pre>
=={{header|RPL}}==
{{works with|HP|48G}}
≪ → word char
≪ 0
1 word SIZE '''FOR''' j
word j DUP SUB char == +
'''NEXT'''
≫ ≫ '<span style="color:blue">OCCHAR</span>' STO
≪ "" → words char
≪ { } words 1 GET
1 OVER SIZE '''FOR''' j
DUP j DUP SUB 'char' STO
words 1 ≪ char <span style="color:blue">OCCHAR</span> ≫ DOLIST
'''IF''' ΠLIST 1 == '''THEN''' SWAP char + SWAP '''END'''
'''NEXT''' DROP SORT
≫ ≫ '<span style="color:blue">UNICHARS</span>' STO
{ "1a3c52debeffd" "2b6178c97a938stf" "3ycxdb1fgxa2yz" } <span style="color:blue">UNICHARS</span>
{{out}}
<pre>
1: { "1" "2" "3" "a" "b" "c" }
</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(" ")
</syntaxhighlight>
{{out}}
<pre>1 2 3 a b c</pre>
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
MainModule: {
_start: (lambda locals: pos Position<String>() b Bool()
(for c in (sort "1a3c52debeffd") do (= b true)
(for str in ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"] do
(= pos (find str c))
(if (or (is-end pos) (find Range(in: str (+ (get-idx pos) 1) -0) c))
(= b false)))
(if b (textout c " "))
) )
}</syntaxhighlight>
{{out}}
<pre>
1 2 3 a b c
</pre>
=={{header|Wren}}==
{{libheader|Wren-seq}}
{{libheader|Wren-sort}}
<
import "./sort" for Sort
var strings = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
Line 955 ⟶ 1,168:
Sort.insertion(uniqueChars)
System.print("Found %(uniqueChars.count) unique character(s) common to each string, namely:")
System.print(uniqueChars.join(" "))</
{{out}}
Line 963 ⟶ 1,176:
</pre>
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">fn main() {
strings := ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]!
mut u := map[rune]int{}
Line 987 ⟶ 1,200:
chars.sort()
println(chars.string())
}</
{{out}}
Line 995 ⟶ 1,208:
=={{header|XPL0}}==
<
int Char, I, J;
string 0; \use null-terminated string convention
Line 1,012 ⟶ 1,225:
if Unique(0, Char) & Unique(1, Char) & Unique(2, Char) then
[ChOut(0, Char); ChOut(0, ^ )];
]</
{{out}}
Line 1,021 ⟶ 1,234:
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<
local i, r
r = 0
Line 1,048 ⟶ 1,261:
print uniq$
end</
{{out}}
<pre>123abc</pre>
|