Unique characters: Difference between revisions

=={{header|11l}}==

L(s) [‘133252abcdeeffd’, ‘a6789798st’, ‘yxcdfgxcyz’]

L(c) s

L(k) sorted(d.keys())

I d[k] == 1

{{out}}

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

TERM: equ '$' ; CP/M string terminator

org 100h

;;; Memory

upage: equ ($/256)+1 ; Workspace for 'unique'

{{out}}

<pre>156bgstz</pre>

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

org 100h

puts: equ 9 ; MS-DOS syscall to print a string

section .bss

uniqws: resb 256

{{out}}

<pre>156bgstz</pre>

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

CHAR ARRAY counts(MAX)

FI

OD

{{out}}

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

=={{header|Ada}}==

procedure Unique_Characters is

Count ("yxcdfgxcyz");

Put_Only_Once;

{{out}}

<pre>1 5 6 b g s t z</pre>

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

# returns the characters that occur only once in the elements of s #

OP UNIQUE = ( []STRING s )STRING:

# task test case #

print( ( UNIQUE []STRING( "133252abcdeeffd", "a6789798st", "yxcdfgxcyz" ), newline ) )

{{out}}

<pre>

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

set astid to AppleScript's text item delimiters

set AppleScript's text item delimiters to ""

return (mutableSet's sortedArrayUsingDescriptors:({sortDescriptor})) as list

{{output}}

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

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

considering case

return uniqueCharacters({"133252abcdeeffd", "a6789798st", "yxcdfgxcyz"})

Composing a solution from existing generic primitives, for speed of drafting and refactoring, and for high levels of code reuse.

((current application's NSArray's arrayWithArray:xs)'s ¬

sortedArrayUsingSelector:"compare:") as list

{{Out}}

<pre>{"1", "5", "6", "b", "g", "s", "t", "z"}</pre>

=={{header|APL}}==

{{out}}

<pre> uniques '133252abcdeeffd' 'a6789798st' 'yxcdfgxcyz'

=={{header|Arturo}}==

str: join arr

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f UNIQUE_CHARACTERS.AWK

#

exit(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 DIM C(255)

30 READ A$: IF A$="" GOTO 90

140 DATA "a6789798st"

150 DATA "yxcdfgxcyz"

{{out}}

<pre>156bgstz</pre>

=={{header|BCPL}}==

let uniques(strings, out) be

uniques(strings, out)

writef("%S*N", out)

{{out}}

<pre>156bgstz</pre>

=={{header|BQN}}==

{{out}}

=={{header|C}}==

#include <string.h>

printf("%s\n", uniques(strings, buf));

return 0;

{{out}}

<pre>156bgstz</pre>

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

#include <map>

}

std::cout << '\n';

{{out}}

=={{header|Factor}}==

{{works with|Factor|0.99 build 2074}}

{ "133252abcdeeffd" "a6789798st" "yxcdfgxcyz" }

{{out}}

<pre>

=={{header|FreeBASIC}}==

Dim As String s

Do

Data "133252abcdeeffd", "a6789798st", "yxcdfgxcyz", ""

{{out}}

<pre>156bgstz</pre>

=={{header|Go}}==

import (

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

fmt.Println(string(chars))

{{out}}

=={{header|Haskell}}==

uniques :: [String] -> String

"a6789798st",

"yxcdfgxcyz"

{{Out}}

<pre>156bgstz</pre>

Or folding the strings down to a hash of character frequencies:

--------- UNIQUE CHARACTERS FROM A LIST OF STRINGS -------

"a6789798st",

"yxcdfgxcyz"

{{Out}}

<pre>156bgstz</pre>

=={{header|JavaScript}}==

"use strict";

// MAIN ---

return JSON.stringify(main());

{{Out}}

<pre>["1","5","6","b","g","s","t","z"]</pre>

Or, folding the strings (with Array.reduce) down to a hash of character frequencies:

"use strict";

return JSON.stringify(main());

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

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

'''Works with gojq, the Go implementation of jq'''

# bag of words

def bow(stream):

def in_one_just_once:

bow( .[] | explode[] | [.] | implode) | with_entries(select(.value==1)) | keys;

'''The task'''

{{out}}

<pre>

=={{header|Julia}}==

function is_once_per_all_strings_in(a::Vector{String})

println(is_once_per_all_strings_in(list))

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

counts = Dict{Char, Int}()

for c in prod(list)

@btime is_once_per_all_strings_in(list)

@btime uniquein(list)

['1', '5', '6', 'b', 'g', 's', 't', 'z']

1.740 μs (28 allocations: 3.08 KiB)

This can be rectified (see Phix entry) if we don't save the counts as we go but just exclude entries with duplicates:

s = sort(collect(prod(list)))

l = length(s)

@btime uniquein2(list)

['1', '5', '6', 'b', 'g', 's', 't', 'z']

1.010 μs (14 allocations: 1.05 KiB)

=={{header|Lua}}==

unpack = unpack or table.unpack -- compatibility for all Lua versions

end

table.sort (list)

{{out}}<pre>1 5 6 b g s t z</pre>

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

{{out}}

<pre>{"1", "5", "6", "b", "g", "s", "t", "z"}</pre>

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”.

var charCount: CountTable[char]

if count == 1: ch

{{out}}

=={{header|Pascal}}==

{{works with|Extended Pascal}}

type

writeLn

{{out}}

<pre>156bgstz</pre>

=={{header|Perl}}==

{{trans|Raku}}

use strict;

"133252abcdeeffd", "a6789798st", "yxcdfgxcyz", "AАΑSäaoö٥🤔👨‍👩‍👧‍👧";

my $uca = Unicode::Collate->new();

{{out}}

<pre>

=={{header|Phix}}==

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

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

{{out}}

<pre>

=={{header|PicoLisp}}==

(let R NIL

(mapc

"133252abcdeeffd"

"a6789798st"

{{out}}

<pre>

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

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

CALL PRINT(.BUFFER);

CALL EXIT;

{{out}}

<pre>156BGSTZ</pre>

=={{header|Python}}==

from itertools import chain, groupby

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>['1', '5', '6', 'b', 'g', 's', 't', 'z']</pre>

Or reducing the given strings down to a hash of character frequencies:

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>['1', '5', '6', 'b', 'g', 's', 't', 'z']</pre>

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.

for @list, (@list, 'AАΑSäaoö٥🤔👨‍👩‍👧‍👧') {

"\n (DUCET) Unicode collation order: ",

.map( *.comb ).Bag.grep( *.value == 1 )».key.collate.join, "\n";

{{out}}

<pre>133252abcdeeffd a6789798st yxcdfgxcyz

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 $= '133252abcdeeffd' "a6789798st" 'yxcdfgxcyz' /*use defaults.*/

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

say

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

<pre>

=={{header|Ring}}==

see "working..." + nl

see "Unique characters are:" + nl

end

return sum

{{out}}

<pre>

=={{header|Vlang}}==

strings := ["133252abcdeeffd", "a6789798st", "yxcdfgxcyz"]

mut m := map[rune]int{}

})

println(chars.string())

{{out}}

{{libheader|Wren-seq}}

{{libheader|Wren-sort}}

import "/sort" for Sort

Sort.insertion(uniqueChars)

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

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

data "133252abcdeeffd", "a6789798st", "yxcdfgxcyz", ""

repeat

next i

print s$

{{out}}

<pre>

=={{header|XPL0}}==

char Tbl(128), Str;

string 0;

for I:= 0 to 127 do

if Tbl(I) = 1 then ChOut(0, I);

{{out}}