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

{{Template:Strings}}

<br><br>

 

=={{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",

while [and? i<size chars

not? done][

if? not? key? seen ch [

]

else [

]

]

 

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

 

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

</pre>

 

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

'0' is repeated at positions 9 24 in <<<1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ>>> (length 36)

</pre>

=={{header|Factor}}==

sequences sets ;

 

"XYZ ZYX"

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"

{{out}}

<pre>

</pre>

 

 

 

{{out}}

<pre>

 

 

 

 

</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 q: "«\(.)»";

"abcABC",

"XYZ ZYX",

(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 : : []

«abcABC» : 6 : : []

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

 

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

The first duplicated character is "0" (0x30) which appears at index {10, 25}.

</pre>

 

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

The string contains duplicate characters.

Character 🐡 (1f421) is present at positions 3 and 8.</pre>

 

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

{{out}}

<pre>

</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|Raku}}==

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>

 

 

{{out}}

 

=={{header|Wren}}==

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