Rosetta Code

Unique characters in each string: Difference between revisions

Page Discussion

Unique characters in each string (view source)

Revision as of 10:27, 15 February 2024

7,409 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(14 intermediate revisions by 10 users not shown)
Line 18:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">V LIST = [‘1a3c52debeffd’, ‘2b6178c97a938stf’, ‘3ycxdb1fgxa2yz’]
 
print(sorted(Set(Array(LIST.join(‘’))).filter(ch -> all(:LIST.map(w -> w.count(@ch) == 1)))))</langsyntaxhighlight>
 
{{out}}
Line 28:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">DEFINE MAX="128"
CHAR ARRAY uniq(MAX)
 
Line 94:
FI
OD
RETURN</langsyntaxhighlight>
{{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}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
 
procedure Unique_Characters is
Line 133:
2 => Occurences ("2b6178c97a938stf"),
3 => Occurences ("3ycxdb1fgxa2yz")));
end Unique_Characters;</langsyntaxhighlight>
{{out}}
<pre>1 2 3 a b c</pre>
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # find the characters that occur once only in each element of a list #
# 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</langsyntaxhighlight>
{{out}}
<pre>
Line 180:
The filtering here is case sensitive, the sorting dependent on locale.
 
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
 
Line 200:
end uniqueCharactersInEachString
 
uniqueCharactersInEachString({"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"})</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{"1", "2", "3", "a", "b", "c"}</langsyntaxhighlight>
 
===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.
 
<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 253:
considering case
uniqueCharactersInEachString({"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"})
end considering</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">arr: ["1a3c52debeffd" "2b6178c97a938stf" "3ycxdb1fgxa2yz"]
uniques: split first arr
 
Line 266:
]
 
print sort uniques</langsyntaxhighlight>
 
{{out}}
Line 273:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f UNIQUE_CHARACTERS_IN_EACH_STRING.AWK
#
Line 305:
exit(0)
}
</syntaxhighlight>
</lang>
{{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#}}==
<langsyntaxhighlight lang="fsharp">
// 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>
</lang>
{{out}}
<pre>
Line 328 ⟶ 420:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: io kernel sequences.interleaved sets sorting ;
 
{ "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"</langsyntaxhighlight>
{{out}}
<pre>
Line 344 ⟶ 436:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">function count_char( s as string, c as string ) as uinteger
'count occurrences of character c in string s
dim as integer i, r = 0
Line 369 ⟶ 461:
next i
 
print uniq</langsyntaxhighlight>
{{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}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 402 ⟶ 539:
sort.Slice(chars, func(i, j int) bool { return chars[i] < chars[j] })
fmt.Println(string(chars))
}</langsyntaxhighlight>
 
{{out}}
Line 410 ⟶ 547:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import qualified Data.Map.Strict as M
import Data.Maybe (fromJust)
import qualified Data.Set as S
Line 440 ⟶ 577:
"2b6178c97a938stf",
"3ycxdb1fgxa2yz"
]</langsyntaxhighlight>
{{Out}}
<pre>123abc</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> /:~@> (e. # [)&.>/ (-. -.@~: # ])&.> '1a3c52debeffd';'2b6178c97a938stf';'3ycxdb1fgxa2yz'
123abc</syntaxhighlight>
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">(() => {
"use strict";
 
Line 460 ⟶ 601:
wordCount = ws.length;
 
return sort([
...ws.slice(1).reduceRight(
(a, x) => intersect(x)(
Line 469 ⟶ 610:
]
.filter(c => wordCount === charFreqs[c])
).joinslice("");
.sort()
.join("");
})() : "";
 
Line 480 ⟶ 623:
"3ycxdb1fgxa2yz"
]);
 
 
// --------------------- GENERIC ---------------------
Line 500 ⟶ 644:
// The intersection of two sets.
b => new Set([...a].filter(i => b.has(i)));
 
 
// sort :: Ord a => [a] -> [a]
const sort = xs =>
// An A-Z sorted copy of xs.
[...xs].slice().sort(
(a, b) => a < b ? -1 : (a > b ? 1 : 0)
);
 
 
// MAIN ---
return main();
})();</langsyntaxhighlight>
{{Out}}
<pre>123abc</pre>
Line 521 ⟶ 657:
 
'''Helper functions'''
<langsyntaxhighlight lang="jq"># bag of words
def bow(stream):
reduce stream as $word ({}; .[($word|tostring)] += 1);
Line 545 ⟶ 681:
elif (.[0]|length) == 0 then empty
else [.[0], [ .[1:] | intersections]] | ios
end;</langsyntaxhighlight>
 
'''The task'''
<langsyntaxhighlight lang="jq">def once_in_each_string:
# convert each string to an array of the constituent characters
map((explode | map([.]|implode)))
Line 557 ⟶ 693:
["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
| [once_in_each_string]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 564 ⟶ 700:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">list = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
 
onceineachstring(list) = filter(c -> all(w -> count(x -> x == c, w) == 1, list), (sort ∘ unique ∘ prod)(list))
 
println(onceineachstring(list))
</langsyntaxhighlight>{{out}}<pre>
['1', '2', '3', 'a', 'b', 'c']
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">sets = Characters /@ {"1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"};
uniques = Sort[Select[Tally[#], Last/*EqualTo[1]][[All, 1]]] & /@ sets;
Intersection @@ uniques</langsyntaxhighlight>
{{out}}
<pre>{"1", "2", "3", "a", "b", "c"}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils, tables
 
var result = AllChars
Line 591 ⟶ 727:
result = result * uniqueChars # Intersection.
 
echo result</langsyntaxhighlight>
 
{{out}}
Line 598 ⟶ 734:
=={{header|Pascal}}==
{{works with|Extended Pascal}}
<langsyntaxhighlight lang="pascal">program uniqueCharactersInEachString(output);
 
type
Line 681 ⟶ 817:
end;
writeLn
end.</langsyntaxhighlight>
{{out}}
1 2 3 a b c
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Unique_characters_in_each_string
Line 696 ⟶ 832:
$chars !~ /$_.*$_/ && # the 'only once in each string' test
@strings == $chars =~ s/$_//g, # the 'in every string' test
$chars =~ /./g ]}\n";</langsyntaxhighlight>
{{out}}
<pre>
Line 703 ⟶ 839:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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 715 ⟶ 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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 722 ⟶ 858:
 
=={{header|Picat}}==
<langsyntaxhighlight Picatlang="picat">import ordset.
 
main =>
Line 734 ⟶ 870:
foreach(E in L)
Map.put(E,Map.get(E,0)+1)
end.</langsyntaxhighlight>
 
{{out}}
Line 740 ⟶ 876:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de acc (V K N)
(if (assoc K (val V))
(inc (nth (cadr @) N))
Line 760 ⟶ 896:
"1a3c52debeffd"
"2b6178c97a938stf"
"3ycxdb1fgxa2yz" ) ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 767 ⟶ 903:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
 
print(sorted([ch for ch in set([c for c in ''.join(LIST)]) if all(w.count(ch) == 1 for w in LIST)]))
</langsyntaxhighlight>{{out}}
<pre>
['1', '2', '3', 'a', 'b', 'c']
</pre>
 
 
Or, avoiding intermediate lists.
 
<syntaxhighlight lang="python">LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
print(sorted(ch for ch in set("".join(LIST)) if all(w.count(ch) == 1 for w in LIST)))</syntaxhighlight>
 
{{out}}
<pre>
['1', '2', '3', 'a', 'b', 'c']
</pre>
 
 
We can also avoid concatenating all strings in the input list.
 
<syntaxhighlight lang="python">from itertools import chain
 
LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
 
print(
sorted(
ch
for ch in set(chain.from_iterable(LIST))
if all(w.count(ch) == 1 for w in LIST)
)
)</syntaxhighlight>
 
{{out}}
<pre>
['1', '2', '3', 'a', 'b', 'c']
</pre>
 
 
Or, avoid calling <code>count()</code> for every distinct character in every string in the input list.
 
<syntaxhighlight lang="python">from collections import Counter
 
LIST = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
 
print(
sorted(
set.intersection(
*(
set(char for char, count in counts.items() if count == 1)
for counts in (Counter(s) for s in LIST)
)
)
)
)</syntaxhighlight>
 
{{out}}
<pre>
['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" perl6line>my $strings = <1a3c52debeffd 2b6178c97a938stf 3ycxdb1fgxa2yz>;
 
put sort keys [∩] $strings.map: *.comb.Bag.grep: *.value == 1</langsyntaxhighlight>
{{out}}
<pre>1 2 3 a b c</pre>
Line 793 ⟶ 1,013:
 
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 in each string and once only. */
parse arg $ /*obtain optional arguments from the CL*/
if $='' | $="," then $= '1a3c52debeffd' "2b6178c97a938stf" '3ycxdb1fgxa2yz'
Line 816 ⟶ 1,036:
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 input:}}
<pre>
Line 825 ⟶ 1,045:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see "working..." + nl
see "Unique characters in each string are:" + nl
Line 871 ⟶ 1,091:
end
return sum
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 879 ⟶ 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}}==
<langsyntaxhighlight lang="ruby">arr = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
 
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>
</lang>
{{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}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Lst
import "./sort" for Sort
 
var strings = ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]
Line 906 ⟶ 1,168:
Sort.insertion(uniqueChars)
System.print("Found %(uniqueChars.count) unique character(s) common to each string, namely:")
System.print(uniqueChars.join(" "))</langsyntaxhighlight>
 
{{out}}
Line 914 ⟶ 1,176:
</pre>
 
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">fn main() {
strings := ["1a3c52debeffd", "2b6178c97a938stf", "3ycxdb1fgxa2yz"]!
mut u := map[rune]int{}
Line 938 ⟶ 1,200:
chars.sort()
println(chars.string())
}</langsyntaxhighlight>
 
{{out}}
Line 946 ⟶ 1,208:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">char List, Counter(128), Unique(3, 128);
int Char, I, J;
string 0; \use null-terminated string convention
Line 963 ⟶ 1,225:
if Unique(0, Char) & Unique(1, Char) & Unique(2, Char) then
[ChOut(0, Char); ChOut(0, ^ )];
]</langsyntaxhighlight>
 
{{out}}
Line 972 ⟶ 1,234:
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<langsyntaxhighlight lang="yabasic">sub count_char(s$, c$)
local i, r
r = 0
Line 999 ⟶ 1,261:
print uniq$
end</langsyntaxhighlight>
{{out}}
<pre>123abc</pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/312077...354788"