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

Show all output here on this page.

 

<br><br>

 

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

"4444 444k" - Length 9 - Contains the following duplicate characters :

'4' (0x34) at positions : 1 2 3 4 6 7 8

</pre>

 

=={{header|Factor}}==

sequences sets ;

 

"XYZ ZYX"

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ"

{{out}}

<pre>

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ" — length 36 — contains repeated characters:

'0' (0x30) at indices 9 and 24.

</pre>

 

=={{header|Go}}==

 

import "fmt"

analyze(s)

}

 

{{out}}

'🐡' (0x1f421) is duplicated at positions 3 and 8.

</pre>

 

=={{header|Haskell}}==

import Data.Char (ord, toUpper)

import Numeric (showHex)

 

hexFromChar :: Char -> String

hexFromChar c = map toUpper $ showHex (ord c) ""

string :: String -> String

char :: Char -> String

char c = ['\'', c, '\'']

size :: String -> String

size = show . length

positions :: (Int, Int) -> String

forTable :: String -> [String]

forTable xs = string xs : go (allUnique xs)

go Nothing = [size xs, "yes", "", "", ""]

go (Just (u, ij)) = [size xs, "no", char u, hexFromChar u, positions ij]

showTable :: Bool -> Char -> Char -> Char -> [[String]] -> String

showTable _ _ _ _ [] = []

(if header

then z : hr : zs

[hr]

where

vss = map (map length) contents

ms = map maximum (transpose vss) :: [Int]

top = replicate (length hr) hor

bss = map (map (`replicate` ' ') . zipWith (-) ms) vss

zss@(z:zs) =

zipWith

contents

bss

table xs =

showTable

(["string", "length", "all unique", "1st diff", "hex", "positions"] :

map forTable xs)

allUnique

:: (Ord b, Ord a, Num b, Enum b)

=> [a] -> Maybe (a, (b, b))

where

go [] = Nothing

go ([_]:us) = go us

go (((u, i):(_, j):_):_) = Just (u, (i, j))

main :: IO ()

main =

putStrLn $

{{out}}

<pre>

+--------------------------------------+------+----------+--------+---+---------+</pre>

 

 

import Numeric (showHex)

import Data.Char (ord)

 

duplicatedCharIndices :: String -> Maybe (Char, [Int])

where

 

main :: IO ()

main =

fTable

"First duplicated character, if any:"

(maybe

"None"

unwords

[ show c

, intercalate ", " (show <$> ixs)

]))

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

 

fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String

fTable s xShow fxShow f xs =

{{Out}}

<pre>First duplicated character, if any:

"XYZ ZYX" (7) -> 'X' (0x58) at 0, 6

"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ" (36) -> '0' (0x30) at 9, 24</pre>

 

=={{header|JavaScript}}==

 

'use strict';

 

const duplicatedCharIndices = s => {

const

groupBy(on(eq)(snd))(

zip(enumFrom(0))(chars(s))

)

)

);

};

 

console.log(

fTable('First duplicated character, if any:')(

)(maybe('None')(tpl => {

const [c, ixs] = Array.from(tpl);

// chars :: String -> [Char]

const chars = s => s.split('');

 

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

// eq (==) :: Eq a => a -> a -> Bool

const eq = a => b => a === b;

 

// filter :: (a -> Bool) -> [a] -> [a]

xs.length

) : Infinity;

 

// maybe :: b -> (a -> b) -> Maybe a -> b

const snd = tpl => tpl[1];

 

 

// take :: Int -> [a] -> [a]

// MAIN ---

return main();

{{Out}}

<pre>First duplicated character, if any:

 

 

'use strict';

 

// duplicatedCharIndices :: String -> Maybe (Char, [Int])

 

// ------------------------TEST------------------------

console.log(

fTable('First duplicated character, if any:')(

)(maybe('None')(tpl => {

const [c, ixs] = Array.from(tpl);

// chars :: String -> [Char]

const chars = s => s.split('');

 

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

const compose = (...fs) =>

x => fs.reduceRight((a, f) => f(a), x);

 

// enumFrom :: Enum a => a -> [a]

}

 

 

 

// fTable :: String -> (a -> String) -> (b -> String)

).join('\n');

};

 

// length :: [a] -> Int

// Default value (v) if m is Nothing, or f(m.Just)

f => m => m.Nothing ? v : f(m.Just);

 

// ord :: Char -> Int

const ord = c => c.codePointAt(0);

 

// showHex :: Int -> String

 

// snd :: (a, b) -> b

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

xs.slice(0, n)

) : [].concat.apply([], Array.from({

return x.done ? [] : [x.value];

}));

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

// MAIN ---

return main();

{{Out}}

<pre>First duplicated character, if any:

 

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

🐠🐟🐡🦈🐬🐳🐋🐡 8 no 🐡 (1f421) 3 8

</pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

say "no duplicated characters."

}

{{out}}

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

'Δ' GREEK CAPITAL LETTER DELTA (0x394) in positions: 1, 4</pre>

 

{{out}}

 

 

 

 

 

 

</pre>

 

 

{{out}}

<pre>

 

=={{header|Python}}==

Defined in terms of itertools.groupby:

 

 

from itertools import groupby

def duplicatedCharIndices(s):

'''Just the first duplicated character, and

'''

def go(xs):

if 1 < len(xs):

(k, list(v)) for k, v in groupby(

key=snd

)

]))

else:

return Nothing()

'''

return {'type': 'Maybe', 'Nothing': True}

 

 

None is m or m.get('Nothing')

) else f(m.get('Just'))

 

 

'''Second member of a pair.'''

return tpl[1]

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First duplicated character, if any:

 

 

 

 

from functools import reduce

def duplicatedCharIndices(s):

'''Just the first duplicated character, and

'''

 

 

fTable('First duplicated character, if any:')(

showSample

'', '.', 'abcABC', 'XYZ ZYX',

'1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ'

 

 

 

 

'''Second member of a pair.'''

return tpl[1]

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First duplicated character, if any:

'XYZ ZYX' (7) -> 'X' (0x58) at [0, 6]

'1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ' (36) -> '0' (0x30) at [9, 24]</pre>

 

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

The characters in the string aren't all unique.

The character 0 ('30'x) at position 10 is repeated at position 25

</pre>

 

=={{header|Ruby}}==

".",

"abcABC",

puts res

end

{{out}}

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

"🐠🐟🐡🦈🐬🐳🐋🐡" (size 8) has duplicate char 🐡 (0x1f421) on 2 and 7.

</pre>

=={{header|Tcl}}==

 

array set yesno {1 Yes 2 No}

}

}

{{out}}

<pre>

--> Character 'é' (hex: 0xe9) reappears at indexes: 1 3.

</pre>

=={{header|XPL0}}==

 

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

StrUnique("1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ");

StrUnique("thequickbrownfoxjumps");

 

{{out}}

 

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