Determine if a string has all unique characters: Difference between revisions

{{trans|Kotlin}}

 

[Char = Int] charMap

V dup = Char("\0")

print(‘#<40 #2 #10 #8 #. #.’.format(‘------------------------’, ‘------’, ‘----------’, ‘--------’, ‘---’, ‘---------’))

L(s) [‘’, ‘.’, ‘abcABC’, ‘XYZ ZYX’, ‘1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ’]

 

{{out}}

 

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

BYTE ARRAY hex=['0 '1 '2 '3 '4 '5 '6 '7 '8 '9 'A 'B 'C 'D 'E 'F]

 

Test("XYZ ZYX")

Test("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ")

{{out}}

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

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

procedure Test_All_Chars_Unique is

All_Chars_Unique ("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ");

end Test_All_Chars_Unique;

 

{{out}}

 

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

# mode to hold the positions of duplicate characters in a string #

MODE DUPLICATE = STRUCT( INT original, first duplicate );

FI

OD

{{out}}

<pre>

{{Trans|Python}}

{{Trans|JavaScript}}

use framework "Foundation"

use scripting additions

return lst

end tell

{{Out}}

<pre>Indices (1-based) of any duplicated characters:

=={{header|Arturo}}==

 

"", ".", "abcABC", "XYZ ZYX",

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ",

]

]

 

{{out}}

 

=={{header|AutoHotkey}}==

arr := [], res := ""

for i, v in StrSplit(str)

res := StrSplit(res, "`n").1

return """" str """`tlength = " StrLen(str) "`n" (res ? "Duplicates Found:`n" res : "Unique Characters")

for i, v in test

MsgBox % unique_characters(v)

Outputs:<pre>"" length = 0

Unique Characters

 

=={{header|AWK}}==

# syntax: GAWK -f DETERMINE_IF_A_STRING_HAS_ALL_UNIQUE_CHARACTERS.AWK

BEGIN {

}

function max(x,y) { return((x > y) ? x : y) }

{{out}}

<pre>

</pre>

 

 

O(n^2) method used for finding indices.

 

Hex function and loop similar to [[Determine if a string has all the same characters#BQN|Determine if a string has all the same characters]]

 

Hex←⊏⟜(∾"0A"+⟜↕¨10‿26)16{⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}

"XYZ ZYX"

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"

All characters are unique

All characters are unique

'X' (hex: 58, indices: ⟨ 0 7 ⟩) duplicated in string 'XYZ ZYX'

 

=={{header|C}}==

In interactive mode, strings with spaces have to be enclosed in double quotes ("")

#include<stdbool.h>

#include<string.h>

return 0;

}

Output, test strings from the task [[Determine_if_a_string_has_all_the_same_characters]] are also included :

<pre>

 

=={{header|C sharp|C#}}==

using System.Linq;

 

}

}

{{out}}

<pre>

 

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

#include <string>

 

string_has_repeated_character("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ");

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(defn uniq-char-string [s]

(let [len (count s)]

(inc idx)

(rest chars))))))))

 

{{out}}

 

=={{header|Common Lisp}}==

(eval-when (:compile-toplevel :load-toplevel)

(ql:quickload '("iterate")))

(return result))))

 

 

{{out}}

=={{header|D}}==

{{trans|C++}}

 

void uniqueCharacters(string str) {

uniqueCharacters("XYZ ZYX");

uniqueCharacters("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ");

{{out}}

<pre>input: ``, length: 0

{{libheader| System.SysUtils}}

{{Trans|Cpp}}

program Determine_if_a_string_has_all_unique_characters;

 

string_has_repeated_character('1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ');

readln;

{{out}}

Delphi strings are start index in one.

String contains a repeated character.

Character "0" (hex 0030) occurs at positions 11 and 26.</pre>

 

=={{header|Erlang|Erlang}}==

-module(string_examples).

-export([all_unique/1, all_unique_examples/0]).

["", ".", "abcABC", "XYZ ZYX",

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"]).

{{out}}

<pre>

 

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

// Determine if a string has all unique characters. Nigel Galloway: June 9th., 2020

let fN (n:string)=n.ToCharArray()|>Array.mapi(fun n g->(n,g))|>Array.groupBy(fun (_,n)->n)|>Array.filter(fun(_,n)->n.Length>1)

allUnique "XYZ ZYX"

allUnique "1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"

{{out}}

<pre>

 

=={{header|Factor}}==

sequences sets ;

 

"XYZ ZYX"

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"

{{out}}

<pre>

 

=={{header|Fortran}}==

program demo_verify

implicit none

 

end program demo_verify

 

{{out}}

 

</pre>

 

=={{header|Go}}==

 

import "fmt"

analyze(s)

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

printf("%-40s %2s %10s %8s %s %s%n", "String", "Length", "All Unique", "1st Diff", "Hex", "Positions")

printf("%-40s %-6d %-10s %-8s %-3s %-5s%n", input, input.length(), unique, diff, hex, position)

}

{{out}}

<pre>String Length All Unique 1st Diff Hex Positions

 

=={{header|Haskell}}==

import Data.Char (ord, toUpper)

import Data.Function(on)

main =

putStrLn $

{{out}}

<pre>

Alternatively, defining a duplicatedCharIndices function in terms of sortOn, groupBy, and filter:

 

import Data.Function (on)

import Numeric (showHex)

rjust n c = drop . length <*> (replicate n c <>)

w = maximum (length . xShow <$> xs)

{{Out}}

<pre>First duplicated character, if any:

 

Or, as an alternative to grouping and sorting – folding a string down to a Map of indices:

import qualified Data.Map.Strict as M

import Data.List (intercalate, foldl') --'

where

rjust n c = drop . length <*> (replicate n c <>)

{{Out}}

<pre>First duplicated character, if any:

=={{header|J}}==

Quotes surround the literals to make the computed one-at-a-time results present well in the combined table.

rc_unique=: monad define

string=. '"' , y , '"'

end.

)

Tests include those of the C example and a pair of MS-DOS line terminations.

<pre>

 

More uniqueness tests with performance comparison

NB. unique_index answers "Do the left and right indexes match?"

unique_index=: (i. -: i:)~

the set formation method 15% longer and uses 7 times additional memory.

)

 

=={{header|Java}}==

import java.util.HashMap;

import java.util.Map;

 

}

{{Out}}

<pre>

XYZ ZYX 7 no 'Z' 5A 3 5

1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ 36 no '0' 30 10 25

</pre>

 

=={{header|JavaScript}}==

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>First duplicated character, if any:

 

Or, as an alternative to sorting and grouping – folding a string down to a dictionary of indices:

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>First duplicated character, if any:

modification of `firstDuplicate` as defined here to implement the alternative

interpretation as the first character to be duplicated.

def firstDuplicate:

label $out

| .[.iu] += [ $ix] ;

if .[.iu]|length == 2 then [.iu, .[.iu]], break $out else empty end )

 

Some helper functions for accomplishing other aspects of the task:

def hex:

def stream:

if type=="string" then explode[0] else . end

 

def lpad($len): tostring | " " * ($len - width) + .;

"XYZ ZYX",

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ",

(data

| firstDuplicate as [$k, $v]

| "\(q|lpad(38)) : \(length|lpad(4)) : \($k // " ") : \($k |if . then hex else " " end) \($v // [])" )

{{out}}

«string» : |s| : C : hex IO=0

«» : 0 : : []

«XYZ ZYX» : 7 : Z : 5A [2,4]

«1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ» : 36 : 0 : 30 [9,24]

The last line above was adjusted manually as jq has no built-in function for computing the horizontal "printing" width of unicode strings in general.

 

=={{header|Julia}}==

alldup(a) = filter(x -> length(x) > 1, [findall(x -> x == a[i], a) for i in 1:length(a)])

firstduplicate(s) = (a = arr(s); d = alldup(a); isempty(d) ? nothing : first(d))

"🐠🐟🐡🦈🐬🐳🐋🐡",

])

<pre>

String | Length | All Unique | First Duplicate (Hex) | Positions

=={{header|Kotlin}}==

{{trans|Java}}

 

fun main() {

val position = if (dup.toInt() == 0) "" else "$pos1 $pos2"

System.out.printf("%-40s %-6d %-10s %-8s %-3s %-5s%n", input, input.length, unique, diff, hex, position)

{{out}}

<pre>String Length All Unique 1st Diff Hex Positions

would caused pattern to match, in the first example below, the substring "cocc" instead of "coc".

 

local function printf(fmt, ...) print(format(fmt,...)) end

 

show('XYZ ZYX')

show('1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ')

 

{{out}}

 

=={{header|Maple}}==

local i, index;

printf("input: \"%s\", length: %a\n", s, StringTools:-Length(s));

CheckUnique("abcABC");

CheckUnique("XYZ ZYX");

{{out}}

<pre>

 

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

UniqueCharacters[s_String] := Module[{c, len, good = True},

c = Characters[s];

UniqueCharacters["abcABC"]

UniqueCharacters["XYZ ZYX"]

{{out}}

<pre> with length 0

 

=={{header|Nanoquery}}==

s = str(s)

println "Examining [" + s + "] which has a length of " + str(len(s)) + ":"

for s in tests

analyze(s)

{{out}}

<pre>Examining [] which has a length of 0:

 

=={{header|Nim}}==

 

proc checkUniqueChars(s: string) =

 

for s in Strings:

 

{{out}}

=={{header|OCaml}}==

Using a map to store characters we've met (as keys) and their first position (as indexes).

type t = char

let compare = compare

printer "abcABC";

printer "XYZ ZYX";

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use feature 'say';

say "no duplicated characters."

}

{{out}}

<pre>"" (length: 0) has no duplicated characters.

=={{header|Phix}}==

As with [[Determine_if_a_string_has_all_the_same_characters#Phix]], you can use utf8_to_utf32() when needed.

<span style="color: #008080;">procedure</span> <span style="color: #000000;">all_uniq</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">chars</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>

<span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"2"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"333"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"55"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"tttTTT"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"tTTTtt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"4444 444k"</span><span style="color: #0000FF;">}</span>

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">,</span><span style="color: #000000;">all_uniq</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let P 0

(by

(uniq? "abcABC")

(uniq? "XYZ ZYX")

{{out}}

<pre>

 

=={{header|Prolog}}==

duplicates(S, Dups),

format('For value "~w":~n', S),

test :- report_duplicates('abcABC').

test :- report_duplicates('XYZ ZYX').

{{out}}

<pre>

Defined in terms of itertools.groupby:

 

 

from itertools import groupby

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First duplicated character, if any:

Or, as an alternative to sorting and grouping, folding a string down to a dictionary with '''reduce''':

 

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First duplicated character, if any:

Tested with Python 3.7.

 

 

pattern = '(.)' + '.*?' + r'\1'

show('XYZ ZYX')

show('1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ')

 

{{out}}

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ" (36): '0' (0x30) duplicates at 9, 24

</pre>

=={{header|R}}==

Most of this is adapted from [[Determine if a string has all the same characters#R]].

{

strLength <- nchar(string)

print(isAllUnique("XYZ ZYX"))

cat("Test: A string of length 36 doesn't contain the letter 'oh':\n")

{{out}}

<pre>Test: A string of length 0 (an empty string):

=={{header|Racket}}==

 

 

(define (first-non-unique-element.index seq)

(list "" "." "abcABC" "XYZ ZYX"

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ")))

 

{{out}}

Raku works with unicode natively and handles combining characters and multi-byte emoji correctly. In the last string, notice the the length is correctly shown as 11 characters and that the delta with a combining circumflex in position 6 is not the same as the deltas without in positions 5 & 9.

 

my $i = 0;

print "\n{$str.raku} (length: {$str.chars}), has ";

if any(%m.values) > 1 {

say "duplicated characters:";

'1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ',

'01234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ0X',

{{out}}

<pre>"" (length: 0), has no duplicated characters.

 

=={{header|REXX}}==

@.= /*assign a default for the @. array. */

parse arg @.1 /*obtain optional argument from the CL.*/

if p\==0 then return k /*Find a dup? Return location.*/

end /*k*/

{{out|output|text=&nbsp; when using the internal defaults}}

<pre>

 

=={{header|Ring}}==

inputStr = ["",".","abcABC","XYZ ZYX","1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"]

? " All characters are unique."

next

{{out}}

<pre>

Input = '1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ', length = 36

First duplicate at positions 10 and 25, character = '0'

</pre>

 

=={{header|Ruby}}==

".",

"abcABC",

puts res

end

{{out}}

<pre>"" (size 0) has no duplicates.

 

=={{header|Rust}}==

s.chars().enumerate().find_map(|(i, c)| {

s.chars()

}

}

{{out}}

<pre>"" (length 0) is unique

 

=={{header|Sidef}}==

gather {

for k,v in (str.chars.kv) {

}

say "has no duplicates." if !dups

{{out}}

<pre>

 

=={{header|Tcl}}==

 

array set yesno {1 Yes 2 No}

}

}

{{out}}

<pre>

</pre>

 

chars := s.runes()

le := chars.len

analyze(s)

}

 

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var analyze = Fn.new { |s|

"🐠🐟🐡🦈🐬🐳🐋🐡"

]

 

{{out}}

 

=={{header|XPL0}}==

 

proc StrUnique(S); \Show if string has unique chars

StrUnique("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ");

StrUnique("thequickbrownfoxjumps");

 

{{out}}

^ ^ Duplicate character: u, hex 75

</pre>

 

=={{header|zkl}}==

sz,unique,uz,counts := str.len(), str.unique(), unique.len(), str.counts();

println("Length %d: \"%s\"".fmt(sz,str));

else Void.Skip

}.fp(str)).concat(", "));

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ",

"01234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ0X");

{{out}}

<pre>