Rosetta Code

Unique characters: Difference between revisions

Page Discussion

Unique characters (view source)

Revision as of 20:03, 24 March 2024

8,537 bytes added ,  1 month ago
Add two StandardML versions
(Add two StandardML versions)
 
(20 intermediate revisions by 13 users not shown)
Line 15:
 
=={{header|11l}}==
<langsyntaxhighlight lang="11l">DefaultDict[Char, Int] d
L(s) [‘133252abcdeeffd’, ‘a6789798st’, ‘yxcdfgxcyz’]
L(c) s
Line 22:
L(k) sorted(d.keys())
I d[k] == 1
print(k, end' ‘’)</langsyntaxhighlight>
 
{{out}}
Line 30:
 
=={{header|8080 Assembly}}==
<langsyntaxhighlight lang="8080asm">puts: equ 9 ; CP/M print syscall
TERM: equ '$' ; CP/M string terminator
org 100h
Line 86:
;;; Memory
upage: equ ($/256)+1 ; Workspace for 'unique'
outbuf: equ (upage+1)*256 ; Output </langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|8086 Assembly}}==
<langsyntaxhighlight lang="asm"> cpu 8086
org 100h
puts: equ 9 ; MS-DOS syscall to print a string
Line 141:
section .bss
uniqws: resb 256
outbuf: resb 256</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">DEFINE MAX="128"
CHAR ARRAY counts(MAX)
 
Line 192:
FI
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Unique_characters.png Screenshot from Atari 8-bit computer]
Line 200:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
 
procedure Unique_Characters is
Line 230:
Count ("yxcdfgxcyz");
Put_Only_Once;
end Unique_Characters;</langsyntaxhighlight>
{{out}}
<pre>1 5 6 b g s t z</pre>
Line 236:
=={{header|ALGOL 68}}==
Case sensitive. This assumes a small character set (e.g. ASCII where max abs char is 255). Would probably need some work if CHAR is Unicode.
<langsyntaxhighlight lang="algol68">BEGIN # find the characters that occur once only in a list of stings #
# returns the characters that occur only once in the elements of s #
OP UNIQUE = ( []STRING s )STRING:
Line 257:
# task test case #
print( ( UNIQUE []STRING( "133252abcdeeffd", "a6789798st", "yxcdfgxcyz" ), newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 267:
The filtering here is case sensitive, the sorting dependent on locale.
 
<langsyntaxhighlight lang="applescript">on uniqueCharacters(listOfStrings)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ""
Line 279:
return (mutableSet's sortedArrayUsingDescriptors:({sortDescriptor})) as list
end uniqueCharacters</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{"1", "5", "6", "b", "g", "s", "t", "z"}</langsyntaxhighlight>
 
===Core language only===
This isn't quite as fast as the ASObjC solution above, but it can be case-insensitive if required. (Simply leave out the 'considering case' statement round the call to the handler). The requirement for AppleScript 2.3.1 is just for the 'use' command which loads the "Heap Sort" script. If "Heap Sort"'s loaded differently or compiled directly into the code, this script will work on systems at least as far back as Mac OS X 10.5 (Leopard) and possibly earlier. Same output as above.
 
<langsyntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- OS X 10.9 (Mavericks) or later
use sorter : script "Heap Sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Heapsort#AppleScript>
 
Line 321:
considering case
return uniqueCharacters({"133252abcdeeffd", "a6789798st", "yxcdfgxcyz"})
end considering</langsyntaxhighlight>
 
 
Line 328:
Composing a solution from existing generic primitives, for speed of drafting and refactoring, and for high levels of code reuse.
 
<langsyntaxhighlight lang="applescript">use framework "Foundation"
 
 
Line 481:
((current application's NSArray's arrayWithArray:xs)'s ¬
sortedArrayUsingSelector:"compare:") as list
end sort</langsyntaxhighlight>
{{Out}}
<pre>{"1", "5", "6", "b", "g", "s", "t", "z"}</pre>
 
=={{header|APL}}==
<langsyntaxhighlight APLlang="apl">uniques ← (⊂∘⍋⌷⊣)∘(∪(/⍨)(1=(≢⊢))⌸)∘∊</langsyntaxhighlight>
{{out}}
<pre> uniques '133252abcdeeffd' 'a6789798st' 'yxcdfgxcyz'
Line 493:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">arr: ["133252abcdeeffd" "a6789798st" "yxcdfgxcyz"]
str: join arr
 
print sort select split str 'ch -> 1 = size match str ch</langsyntaxhighlight>
 
{{out}}
Line 503:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f UNIQUE_CHARACTERS.AWK
#
Line 529:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 539:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 DEFINT A-Z
20 DIM C(255)
30 READ A$: IF A$="" GOTO 90
Line 554:
140 DATA "a6789798st"
150 DATA "yxcdfgxcyz"
160 DATA ""</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let uniques(strings, out) be
Line 587:
uniques(strings, out)
writef("%S*N", out)
$)</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|BQN}}==
<langsyntaxhighlight lang="bqn">Uniq ← (⍷/˜1=/⁼∘⊐)∧∘∾</langsyntaxhighlight>
 
{{out}}
Line 601:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
 
Line 633:
printf("%s\n", uniques(strings, buf));
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <map>
 
Line 653:
}
std::cout << '\n';
}</langsyntaxhighlight>
 
{{out}}
Line 659:
156bgstz
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
var SA: array [0..2] of string = ('133252abcdeeffd', 'a6789798st', 'yxcdfgxcyz');
 
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;
 
procedure ShowUniqueChars(Memo: TMemo);
var I: integer;
var S: string;
begin
{Concatonate all strings}
S:='';
for I:=0 to High(SA) do S:=S+SA[I];
{Get all characters that appear once}
S:=CharsAppearingOnce(S);
Memo.Lines.Add(S);
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
156bgstz
 
Elapsed Time: 0.959 ms.
 
</pre>
 
 
=={{header|Factor}}==
{{works with|Factor|0.99 build 2074}}
<langsyntaxhighlight lang="factor">USING: io sequences sets.extras sorting ;
 
{ "133252abcdeeffd" "a6789798st" "yxcdfgxcyz" }
concat non-repeating natural-sort print</langsyntaxhighlight>
{{out}}
<pre>
Line 673 ⟶ 731:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">Dim As Integer c(255), i, a
Dim As String s
Do
Line 689 ⟶ 747:
 
Data "133252abcdeeffd", "a6789798st", "yxcdfgxcyz", ""
Sleep</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">window 1, @"Unique characters"
 
void local fn DoIt
CountedSetRef set = fn CountedSetWithCapacity(0)
CFArrayRef array = @[@"133252abcdeeffd",@"a6789798st",@"yxcdfgxcyz"]
CFStringRef string, chr
long index
CFMutableArrayRef mutArray = fn MutableArrayWithCapacity(0)
for string in array
for index = 0 to len(string) - 1
CountedSetAddObject( set, mid(string,index,1) )
next
next
for chr in set
if ( fn CountedSetCountForObject( set, chr ) == 1 )
MutableArrayAddObject( mutArray, chr )
end if
next
MutableArraySortUsingSelector( mutArray, @"compare:" )
print fn ArrayComponentsJoinedByString( mutArray, @"" )
end fn
 
fn DoIt
 
HandleEvents</syntaxhighlight>
{{out}}
<pre>156bgstz</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 718 ⟶ 808:
sort.Slice(chars, func(i, j int) bool { return chars[i] < chars[j] })
fmt.Println(string(chars))
}</langsyntaxhighlight>
 
{{out}}
Line 726 ⟶ 816:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (group, sort)
 
uniques :: [String] -> String
Line 739 ⟶ 829:
"a6789798st",
"yxcdfgxcyz"
]</langsyntaxhighlight>
{{Out}}
<pre>156bgstz</pre>
Line 745 ⟶ 835:
 
Or folding the strings down to a hash of character frequencies:
<langsyntaxhighlight lang="haskell">import qualified Data.Map.Strict as M
 
--------- UNIQUE CHARACTERS FROM A LIST OF STRINGS -------
Line 768 ⟶ 858:
"a6789798st",
"yxcdfgxcyz"
]</langsyntaxhighlight>
{{Out}}
<pre>156bgstz</pre>
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">(() => {
"use strict";
 
Line 823 ⟶ 913:
// MAIN ---
return JSON.stringify(main());
})();</langsyntaxhighlight>
{{Out}}
<pre>["1","5","6","b","g","s","t","z"]</pre>
Line 830 ⟶ 920:
Or, folding the strings (with Array.reduce) down to a hash of character frequencies:
 
<langsyntaxhighlight lang="javascript">(() => {
"use strict";
 
Line 859 ⟶ 949:
 
return JSON.stringify(main());
})();</langsyntaxhighlight>
{{Out}}
<pre>["1","5","6","b","s","t","g","z"]</pre>
 
=={{header|J}}==
The simple approach here is to merge the argument strings and find characters which occur exactly once in that intermediate result:
<lang J>uniques =: [:/:~~.@;#~1=+/"1@=@;</lang>
<syntaxhighlight lang="j">uniques=: ~.#~1=#/.~</syntaxhighlight>
In other words, <code>~.</code> finds the distinct characters, <code>#/.~</code> finds the corresponding counts of those characters, so <code>1=#/.~</code> is true for the characters which occur exactly once, and <code>#~</code> filters the distinct characters based on those truth values.
{{out}}
<pre> uniques ;'133252abcdeeffd';'a6789798st';'yxcdfgxcyz'
156bgstz</pre>
 
Here, <code>;</code> as a separator between quoted strings builds a list of the strings, and <code>;</code> as a prefix of that list merges the contents of the strings of that list into a single string. We could just as easily have formed a single string, but that's not what the task asked for. (Since <code>uniques</code> is a verb (aka a "function"), it's not a list element in this context.)
 
=={{header|jq}}==
Line 873 ⟶ 967:
'''Works with gojq, the Go implementation of jq'''
 
The following "bag-of-words" solution is quite efficient as it takes advantage of the fact that jq implements JSON objects as a hash.<langsyntaxhighlight lang="jq">
# bag of words
def bow(stream):
Line 882 ⟶ 976:
def in_one_just_once:
bow( .[] | explode[] | [.] | implode) | with_entries(select(.value==1)) | keys;
</syntaxhighlight>
</lang>
'''The task'''
<langsyntaxhighlight lang="jq">["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"]
| in_one_just_once</langsyntaxhighlight>
{{out}}
<pre>
Line 892 ⟶ 986:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">list = ["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"]
 
function is_once_per_all_strings_in(a::Vector{String})
Line 901 ⟶ 995:
 
println(is_once_per_all_strings_in(list))
</langsyntaxhighlight>{{out}}<pre>
['1', '5', '6', 'b', 'g', 's', 't', 'z']
</pre>
One might think that the method above suffers from too many passes through the text with one pass per count, but with a small text length the dictionary lookup takes more time. Compare times for a single pass version:
 
<langsyntaxhighlight lang="julia">function uniquein(a)
counts = Dict{Char, Int}()
for c in prod(list)
Line 919 ⟶ 1,013:
@btime is_once_per_all_strings_in(list)
@btime uniquein(list)
</langsyntaxhighlight>{{out}}<pre>
['1', '5', '6', 'b', 'g', 's', 't', 'z']
1.740 μs (28 allocations: 3.08 KiB)
Line 926 ⟶ 1,020:
 
This can be rectified (see Phix entry) if we don't save the counts as we go but just exclude entries with duplicates:
<langsyntaxhighlight lang="julia">function uniquein2(a)
s = sort(collect(prod(list)))
l = length(s)
Line 935 ⟶ 1,029:
 
@btime uniquein2(list)
</langsyntaxhighlight>{{out}}<pre>
['1', '5', '6', 'b', 'g', 's', 't', 'z']
1.010 μs (14 allocations: 1.05 KiB)
Line 942 ⟶ 1,036:
 
=={{header|Lua}}==
<langsyntaxhighlight Lualang="lua">local strings = {"133252abcdeeffd", "a6789798st", "yxcdfgxcyz"}
unpack = unpack or table.unpack -- compatibility for all Lua versions
 
local map = {}
for i, str in ipairs (strings) do
local map = {}
for i=1, string.len(str) do
local char = string.sub(str,i,i)
if map[char] == true -- store uniquenil onlythen
map[char] = true
else
map[char] = false
end
end
local list = {}
end
for char, bool in pairs (map) do
 
table.insert (list, char) -- all unique in list
local list = {}
for char, bool in pairs (map) do
if bool then
table.insert (list, char)
end
table.sort (list) -- sorted list
print (unpack (list))
end
table.sort (list)
</lang>
print (unpack (list))</syntaxhighlight>
{{out}}<pre>
{{out}}<pre>1 2 3 5 a6 b cg ds et fz</pre>
6 7 8 9 a s t
c d f g x y z
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Select[Tally[Sort[Characters[StringJoin[{"133252abcdeeffd", "a6789798st", "yxcdfgxcyz"}]]]], Last /* EqualTo[1]][[All, 1]]</langsyntaxhighlight>
{{out}}
<pre>{"1", "5", "6", "b", "g", "s", "t", "z"}</pre>
Line 973 ⟶ 1,071:
One solution, but others are possible, for instance concatenating the strings and building the count table from it rather than merging several count tables. And to build the last sequence, we could have used something like <code>sorted(toSeq(charCount.pairs).filterIt(it[1] == 1).mapIt(it[0]))</code>, which is a one liner but less readable and less efficient than our solution using “collect”.
 
<langsyntaxhighlight Nimlang="nim">import algorithm, sugar, tables
 
var charCount: CountTable[char]
Line 984 ⟶ 1,082:
if count == 1: ch
 
echo sorted(uniqueChars)</langsyntaxhighlight>
 
{{out}}
Line 991 ⟶ 1,089:
=={{header|Pascal}}==
{{works with|Extended Pascal}}
<langsyntaxhighlight lang="pascal">program uniqueCharacters(output);
 
type
Line 1,047 ⟶ 1,145:
writeLn
end.</langsyntaxhighlight>
{{out}}
<pre>156bgstz</pre>
Line 1,053 ⟶ 1,151:
=={{header|Perl}}==
{{trans|Raku}}
<langsyntaxhighlight lang="perl"># 20210506 Perl programming solution
 
use strict;
Line 1,065 ⟶ 1,163:
"133252abcdeeffd", "a6789798st", "yxcdfgxcyz", "AАΑSäaoö٥🤔👨‍👩‍👧‍👧";
my $uca = Unicode::Collate->new();
print $uca->sort ( grep { $seen{$_} == 1 } keys %seen )</langsyntaxhighlight>
{{out}}
<pre>
Line 1,072 ⟶ 1,170:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">once</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
Line 1,082 ⟶ 1,180:
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">set</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</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 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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,089 ⟶ 1,187:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de uni (Lst
(let R NIL
(mapc
Line 1,107 ⟶ 1,205:
"133252abcdeeffd"
"a6789798st"
"yxcdfgxcyz" ) ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 1,114 ⟶ 1,212:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="pli">100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 1,162 ⟶ 1,260:
CALL PRINT(.BUFFER);
CALL EXIT;
EOF</langsyntaxhighlight>
{{out}}
<pre>156BGSTZ</pre>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">'''Unique characters'''
 
from itertools import chain, groupby
Line 1,201 ⟶ 1,299:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>['1', '5', '6', 'b', 'g', 's', 't', 'z']</pre>
 
Or reducing the given strings down to a hash of character frequencies:
<langsyntaxhighlight lang="python">'''Unique characters'''
 
from functools import reduce
Line 1,247 ⟶ 1,345:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>['1', '5', '6', 'b', 'g', 's', 't', 'z']</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery"> [ [] swap
witheach join
[] 0 128 of
rot witheach
[ 2dup peek
1+ unrot poke ]
witheach
[ 1 = if
[ i^ join ] ] ] is task ( [ --> $ )
 
[]
$ "133252abcdeeffd" nested join
$ "a6789798st" nested join
$ "yxcdfgxcyz" nested join
 
task echo$</syntaxhighlight>
 
{{out}}
 
<pre>156bgstz</pre>
 
=={{header|Raku}}==
One has to wonder where the digits 0 through 9 come in the alphabet... 🤔 For that matter, What alphabet should they be in order of? Most of these entries seem to presuppose ASCII order but that isn't specified anywhere. What to do with characters outside of ASCII (or Latin-1)? Unicode ordinal order? Or maybe DUCET Unicode collation order? It's all very vague.
 
<syntaxhighlight lang="raku" perl6line>my @list = <133252abcdeeffd a6789798st yxcdfgxcyz>;
 
for @list, (@list, 'AАΑSäaoö٥🤔👨‍👩‍👧‍👧') {
Line 1,261 ⟶ 1,382:
"\n (DUCET) Unicode collation order: ",
.map( *.comb ).Bag.grep( *.value == 1 )».key.collate.join, "\n";
}</langsyntaxhighlight>
{{out}}
<pre>133252abcdeeffd a6789798st yxcdfgxcyz
Line 1,281 ⟶ 1,402:
 
On an &nbsp;'''EBCDIC'''&nbsp; machine, &nbsp; the lowercase letters and the uppercase letters &nbsp; aren't &nbsp; contiguous.
<langsyntaxhighlight lang="rexx">/*REXX pgm finds and shows characters that are unique to only one string and once only.*/
parse arg $ /*obtain optional arguments from the CL*/
if $='' | $="," then $= '133252abcdeeffd' "a6789798st" 'yxcdfgxcyz' /*use defaults.*/
Line 1,299 ⟶ 1,420:
say 'unique characters are: ' @ /*display the unique characters found. */
say
say 'Found ' L " unique characters." /*display the # of unique chars found. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,308 ⟶ 1,429:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see "working..." + nl
see "Unique characters are:" + nl
Line 1,341 ⟶ 1,462:
end
return sum
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,349 ⟶ 1,470:
Found 8 unique characters
done...
</pre>
 
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
≪ DUP SIZE → string length
≪ 1 length '''FOR''' n
string n DUP SUB
'''NEXT'''
length 1 '''FOR''' n
1 n 1 - START
'''IF''' DUP2 ≥ '''THEN''' SWAP '''END'''
n ROLLD
'''NEXT'''
n ROLLD
-1 '''STEP'''
2 length '''START''' + '''NEXT'''
≫ ≫
‘SORTS’ STO
≪ DUP 1 DUP SUB → str char1
≪ str SIZE
'''IF''' DUP 1 >
'''THEN'''
DROP 1
'''WHILE''' str OVER 1 + DUP SUB char1 == '''REPEAT''' 1 + '''END'''
'''END'''
char1
≫ ≫
‘OCHST’ STO
≪ "" 1 3 PICK SIZE '''FOR''' j
OVER j GET +
'''NEXT'''
SWAP DROP
SORTS "" SWAP 1
'''WHILE''' OVER SIZE OVER ≥ '''REPEAT'''
DUP2 OVER SIZE SUB OCHST
'''IF''' OVER 1 ==
'''THEN''' 5 ROLL SWAP + 4 ROLLD
'''ELSE''' DROP
'''END'''
+
'''END'''
DROP2
≫
‘UNCHR’ STO
===Shorter code but increased memory requirements===
≪ → strings
≪ { 255 } 0 CON 1 strings SIZE '''FOR''' j
strings j GET 1 OVER SIZE '''FOR''' k
DUP k DUP SUB NUM ROT SWAP DUP2 GET 1 + PUT SWAP
'''NEXT'''
DROP
'''NEXT'''
≫
"" 1 255 '''FOR''' j
'''IF''' OVER j GET 1 == '''THEN''' j CHR + '''END'''
'''NEXT'''
SWAP DROP
≫
‘UNCHR’ STO
 
{"133252abcdeeffd", "a6789798st", "yxcdfgxcyz"} UNCHR
{{out}}
<pre>
1: "156bgstz"
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">words = ["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"]
 
counter = words.inject({}){|h, word| word.chars.tally(h)}
puts counter.filter_map{|char, count| char if count == 1}.sort.join
</syntaxhighlight>
{{out}}
<pre>
156bgstz
</pre>
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
 
MainModule: {
v: ["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"],
 
_start: (λ
(for p in (group-by (split (join v "") "")) do
(if (== (size (snd p)) 1) (textout (fst p))))
)
}</syntaxhighlight>
{{out}}
<pre>
156bgstz
</pre>
 
=={{header|Standard ML}}==
Using an Array:
<syntaxhighlight lang="sml">
fun uniqueChars xs =
let
val arr = Array.array(256, 0)
val inc = (fn c => Array.update(arr, ord c, Array.sub(arr, ord c)+1))
val _ = List.app inc (List.concat (List.map String.explode xs))
val ex1 = (fn (i,n,a) => if n=1 then (chr i)::a else a)
in
String.implode (Array.foldri ex1 [] arr)
end
</syntaxhighlight>
{{out}}
<pre>
- uniqueChars ["133252abcdeeffd","a6789798st","yxcdfgxcyz"];
val it = "156bgstz" : string
</pre>
 
A different approach:
<syntaxhighlight lang="sml">
(*
group [1,1,2,4,4,4,2,2,2,1,1,1,3]
=> [[1,1], [2], [4,4,4], [2,2,2], [1,1,1], [3]]
*)
fun group xs =
let
fun collectGroups(a,[]) = [[a]]
| collectGroups(a,b::bs) = if a = (hd b) then (a::b)::bs else [a]::b::bs
in
List.foldr collectGroups [] xs
end
 
fun uniqueChars2 xs =
let
(* turn the strings into one big list of characters *)
val cs = List.concat (List.map String.explode xs)
(* sort the big list of characters *)
val scs = ListMergeSort.sort Char.> cs
(* collect the groups *)
val gs = group scs
(* filter out groups with more than one member *)
val os = List.filter (fn a => null (tl a)) gs
in
String.implode (List.concat os)
end
</syntaxhighlight>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
fn main() {
strings := ["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"]
mut m := map[rune]int{}
for s in strings {
for c in s {
m[c]++
}
}
mut chars := []rune{}
for k, v in m {
if v == 1 {chars << k}
}
chars.sort_with_compare(fn(i &rune, j &rune) int {
if *i < *j {return -1}
if *i > *j {return 1}
return 0
})
println(chars.string())
}
</syntaxhighlight>
 
{{out}}
<pre>
156bgstz
</pre>
 
Line 1,354 ⟶ 1,643:
{{libheader|Wren-seq}}
{{libheader|Wren-sort}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Lst
import "./sort" for Sort
 
var strings = ["133252abcdeeffd", "a6789798st","yxcdfgxcyz"]
Line 1,362 ⟶ 1,651:
Sort.insertion(uniqueChars)
System.print("Found %(uniqueChars.count) unique character(s), namely:")
System.print(uniqueChars.join(" "))</langsyntaxhighlight>
 
{{out}}
Line 1,369 ⟶ 1,658:
1 5 6 b g s t z
</pre>
 
 
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="yabasic">dim c(255)
data "133252abcdeeffd", "a6789798st", "yxcdfgxcyz", ""
repeat
Line 1,387 ⟶ 1,675:
next i
print s$
end</langsyntaxhighlight>
{{out}}
<pre>
Line 1,395 ⟶ 1,683:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">int List, I, N, C;
char Tbl(128), Str;
string 0;
Line 1,411 ⟶ 1,699:
for I:= 0 to 127 do
if Tbl(I) = 1 then ChOut(0, I);
]</langsyntaxhighlight>
 
{{out}}
Myrmidon
23

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311962...362852"