I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Determine if a string has all the same characters

Determine if a string has all the same characters
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Given a character string   (which may be empty, or have a length of zero characters):

•   create a function/procedure/routine to:
•   determine if all the characters in the string are the same
•   indicate if or which character is different from the previous character
•   display each string and its length   (as the strings are being examined)
•   a zero─length (empty) string shall be considered as all the same character(s)
•   process the strings from left─to─right
•   if       all the same character,   display a message saying such
•   if not all the same character,   then:
•   display a message saying such
•   display what character is different
•   only the 1st different character need be displayed
•   display where the different character is in the string
•   the above messages can be part of a single message
•   display the hexadecimal value of the different character

Use (at least) these seven test values   (strings):

•   a string of length   0   (an empty string)
•   a string of length   3   which contains three blanks
•   a string of length   1   which contains:   2
•   a string of length   3   which contains:   333
•   a string of length   3   which contains:   .55
•   a string of length   6   which contains:   tttTTT
•   a string of length   9   with a blank in the middle:   4444   444k

Show all output here on this page.

## Ada

`with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;with Ada.Text_IO; use Ada.Text_IO;procedure Test_All_Chars_Are_Same is   procedure All_Chars_Are_Same (S : in String) is      First_Diff : Natural := 0;   begin      Put_Line ("Input = """ & S & """, length =" & S'Length'Image);      for I in S'First + 1 .. S'Last loop         if S(I) /= S(S'First) then            First_Diff := I;            exit;         end if;      end loop;      if First_Diff = 0 then         Put_Line (" All characters are the same.");      else         Put (" First difference at position" & First_Diff'Image &              ", character = '" & S(First_Diff) &              "', hex = ");         Put (Character'Pos (S(First_Diff)), Width => 0, Base => 16);         New_Line;      end if;   end All_Chars_Are_Same;begin   All_Chars_Are_Same ("");   All_Chars_Are_Same ("   ");   All_Chars_Are_Same ("2");   All_Chars_Are_Same ("333");   All_Chars_Are_Same (".55");   All_Chars_Are_Same ("tttTTT");   All_Chars_Are_Same ("4444 444k");end Test_All_Chars_Are_Same;`
Output:
```Input = "", length = 0
All characters are the same.
Input = "   ", length = 3
All characters are the same.
Input = "2", length = 1
All characters are the same.
Input = "333", length = 3
All characters are the same.
Input = ".55", length = 3
First difference at position 2, character = '5', hex = 16#35#
Input = "tttTTT", length = 6
First difference at position 4, character = 'T', hex = 16#54#
Input = "4444 444k", length = 9
First difference at position 5, character = ' ', hex = 16#20#```

## ALGOL 68

`BEGIN    # return the position of the first different character in s           #    #     or UPB s + 1 if all the characters are the same                 #    OP  FIRSTDIFF = ( STRING s )INT:        IF UPB s <= LWB s        THEN            # 0 or 1 character                                            #            UPB s + 1        ELSE            # two or more characters                                      #            INT  result := LWB s + 1;            CHAR c1      = s[ LWB s ];            FOR s pos FROM LWB s + 1 TO UPB s WHILE s[ s pos ] = c1 DO result +:= 1 OD;            result        FI # FIRSTDIFF # ;    # convert a character to a hex string                                 #    PROC hex = ( CHAR c )STRING:        BEGIN            STRING result := "";            INT    n      := ABS c;            IF n = 0            THEN                result := "0"            ELSE                WHILE n > 0 DO                    INT d = n MOD 16;                    n OVERAB 16;                    IF d < 10                    THEN REPR ( d + ABS "0" )                    ELSE REPR ( ( d - 10 ) + ABS "0" )                    FI +=: result                OD            FI;            result        END # hex # ;    # show whether s contains all the same character of the first diff    #    PROC show first diff = ( STRING s )VOID:        IF  print( ( """", s, """ (length ", whole( ( UPB s + 1 ) - LWB s, 0 ), "): " ) );            INT diff pos = FIRSTDIFF s;            diff pos > UPB s        THEN            # all characters the same                                     #            print( ( "all characters are the same", newline ) )        ELSE            # not all characters are the same                             #            print( ( "first different character """                   , s[ diff pos ]                   , """(0x", hex( s[ diff pos ] )                   , ") at position: "                   , whole( diff pos, 0 )                   , newline                   )                 )        FI # show first diff # ;    # task test cases                                                     #    show first diff( ""          );    show first diff( "   "       );    show first diff( "2"         );    show first diff( "333"       );    show first diff( ".55"       );    show first diff( "tttTTT"    );    show first diff( "4444 444k" )END`
Output:
```"" (length 0): all characters are the same
"   " (length 3): all characters are the same
"2" (length 1): all characters are the same
"333" (length 3): all characters are the same
".55" (length 3): first different character "5"(0x35) at position: 2
"tttTTT" (length 6): first different character "T"(0x54) at position: 4
"4444 444k" (length 9): first different character " "(0x20) at position: 5
```

## Arturo

`strings: [    "", "   ", "2", "333", ".55", "tttTTT",     "4444   444k", "pépé", "🐶🐶🐺🐶", "🎄🎄🎄🎄"] allSameChars?: function [str][    if empty? str -> return ø    current: first str    loop.with:'i str 'ch [        if ch <> current -> return i    ]    return ø] loop strings 's [    prints ["\"" ++ s ++ "\"" ~"(size |size s|):"]    firstNotSame: allSameChars? s    if? null? firstNotSame -> print "all the same."    else -> print ~"first different char `|get s firstNotSame|` at position |firstNotSame|."]`
Output:
```"" (size 0): all the same.
"   " (size 3): all the same.
"2" (size 1): all the same.
"333" (size 3): all the same.
".55" (size 3): first different char `5` at position 1.
"tttTTT" (size 6): first different char `T` at position 3.
"4444   444k" (size 11): first different char ` ` at position 4.
"pépé" (size 4): first different char `é` at position 1.
"🐶🐶🐺🐶" (size 4): first different char `🐺` at position 2.
"🎄🎄🎄🎄" (size 4): all the same.```

## AutoHotkey

`testCases := ["", "   ", "2", "333", ".55", "tttTTT", "4444 4444k"]for key, str in testCases {	MsgBox % "Examining `'" str "`' which has a length of " StrLen(str) ":`n"	if (StrLen(str) == 0) or (StrLen(str) == 1) {		MsgBox % "  All characters in the string are the same.`n"		continue	}	firstChar := SubStr(str, 1, 1)	Loop, Parse, str 	{		if (firstChar != A_LoopField) {			hex := Format("0x{:x}", Ord(A_LoopField))			MsgBox % "  Not all characters in the string are the same.`n  Character `'" A_LoopField "`' (" hex ") is different at position " A_Index ".`n", *			break		}		if (A_Index = StrLen(str))			MsgBox % "  All characters in the string are the same.`n", *	}} `
Output:
```Examining '' which has a length of 0:
All characters in the string are the same.
Examining '   ' which has a length of 3:
All characters in the string are the same.
Examining '2' which has a length of 1:
All characters in the string are the same.
Examining '333' which has a length of 3:
All characters in the string are the same.
Examining '.55' which has a length of 3:
Not all characters in the string are the same.
Character '5' (0x35) is different at position 2.
Examining 'tttTTT' which has a length of 6:
All characters in the string are the same.
Examining '4444 4444k' which has a length of 10:
Not all characters in the string are the same.
Character ' ' (0x20) is different at position 5.
```

## AWK

` # syntax: GAWK -f DETERMINE_IF_A_STRING_HAS_ALL_THE_SAME_CHARACTERS.AWKBEGIN {    for (i=0; i<=255; i++) { ord_arr[sprintf("%c",i)] = i } # build array[character]=ordinal_value    n = split(",   ,2,333,.55,tttTTT,4444 444k",arr,",")    for (i in arr) {      width = max(width,length(arr[i]))    }    width += 2    fmt = "| %-*s | %-6s | %-8s | %-8s | %-3s | %-8s |\n"    head1 = head2 = sprintf(fmt,width,"string","length","all same","1st diff","hex","position")    gsub(/[^|\n]/,"-",head1)    printf(head1 head2 head1) # column headings    for (i=1; i<=n; i++) {      main(arr[i])    }    printf(head1) # column footing    exit(0)}function main(str,  c,first_diff,hex,i,leng,msg,position) {    msg = "yes"    leng = length(str)    for (i=1; i<leng; i++) {      c = substr(str,i+1,1)      if (substr(str,i,1) != c) {        msg = "no"        first_diff = "'" c "'"        hex = sprintf("%2X",ord_arr[c])        position = i + 1        break      }    }    printf(fmt,width,"'" str "'",leng,msg,first_diff,hex,position)}function max(x,y) { return((x > y) ? x : y) } `
Output:
```|-------------|--------|----------|----------|-----|----------|
| string      | length | all same | 1st diff | hex | position |
|-------------|--------|----------|----------|-----|----------|
| ''          | 0      | yes      |          |     |          |
| '   '       | 3      | yes      |          |     |          |
| '2'         | 1      | yes      |          |     |          |
| '333'       | 3      | yes      |          |     |          |
| '.55'       | 3      | no       | '5'      | 35  | 2        |
| 'tttTTT'    | 6      | no       | 'T'      | 54  | 4        |
| '4444 444k' | 9      | no       | ' '      | 20  | 5        |
|-------------|--------|----------|----------|-----|----------|
```

## BCPL

`get "libhdr" let diffchar(s) = valof\$(  for i=2 to s%0        unless s%i = s%1 resultis i    resultis 0\$) let show(s) be\$(  let i = diffchar(s)    writef("*"%S*" (length %N): ", s, s%0)    test i=0        do writes("all the same.*N")        or writef("'%C' at index %N.*N", s%i, i)\$) let start() be\$(  show("")    show("   ")    show("2")    show("333")    show(".55")    show("tttTTT")    show("4444 444k")\$)`
Output:
```"" (length 0): all the same.
"   " (length 3): all the same.
"2" (length 1): all the same.
"333" (length 3): all the same.
".55" (length 3): '5' at index 2.
"tttTTT" (length 6): 'T' at index 4.
"4444 444k" (length 9): ' ' at index 5.```

## C

### Solution with an index to a table

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

` #include<string.h>#include<stdio.h> int main(int argc,char** argv){    int i,len;    char reference;     if(argc>2){        printf("Usage : %s <Test String>\n",argv);        return 0;    }     if(argc==1||strlen(argv)==1){        printf("Input string : \"%s\"\nLength : %d\nAll characters are identical.\n",argc==1?"":argv,argc==1?0:(int)strlen(argv));        return 0;    }     reference = argv;    len = strlen(argv);     for(i=1;i<len;i++){        if(argv[i]!=reference){            printf("Input string : \"%s\"\nLength : %d\nFirst different character : \"%c\"(0x%x) at position : %d\n",argv,len,argv[i],argv[i],i+1);            return 0;        }    }     printf("Input string : \"%s\"\nLength : %d\nAll characters are identical.\n",argv,len);     return 0; } `

Output :

```[email protected]:~/doodles\$ ./a.out
Input string : ""
Length : 0
All characters are identical.
[email protected]:~/doodles\$ ./a.out "   "
Input string : "   "
Length : 3
All characters are identical.
[email protected]:~/doodles\$ ./a.out 2
Input string : "2"
Length : 1
All characters are identical.
[email protected]:~/doodles\$ ./a.out 333
Input string : "333"
Length : 3
All characters are identical.
[email protected]:~/doodles\$ ./a.out .55
Input string : ".55"
Length : 3
First different character : "5"(0x35) at position : 2
[email protected]:~/doodles\$ ./a.out tttTTT
Input string : "tttTTT"
Length : 6
First different character : "T"(0x54) at position : 4
[email protected]:~/doodles\$ ./a.out "4444 444k"
Input string : "4444 444k"
Length : 9
First different character : " "(0x20) at position : 5
```

### Solution with pointers

`/** * An example for RossetaCode - an example of string operation with wchar_t and * with old 8-bit characters. Anyway, it seem that C is not very UTF-8 friendly, * thus C# or C++ may be a better choice. */ #include <stdio.h>#include <stdlib.h>#include <string.h> /* * The wide character version of the program is compiled if WIDE_CHAR is defined */#define WIDE_CHAR #ifdef WIDE_CHAR#define CHAR wchar_t#else#define CHAR char#endif /** * Find a character different from the preceding characters in the given string. *  * @param s the given string, NULL terminated. *  * @return the pointer to the occurence of the different character or NULL if *         all characters in the string are exactly the same. *  * @notice This function return NULL also for empty strings. *  * @warning This function compare characters (single-bytes, unicode etc.). *          Therefore this is not designed to compare bytes. The NULL character *          is always treated as the end-of-string marker, thus this function *          cannot be used to scan strings with NULL character inside string, *          for an example "aaa\0aaa\0\0". */const CHAR* find_different_char(const CHAR* s){    /* The code just below is almost the same regardles        char or wchar_t is used. */     const CHAR c = *s;    while (*s && c == *s)    {        s++;    }    return *s ? s : (const CHAR*)NULL;} /** * Apply find_different_char function to a given string and output the raport. *  * @param s the given NULL terminated string. */void raport_different_char(const CHAR* s){#ifdef WIDE_CHAR    wprintf(L"\n");    wprintf(L"string: \"%s\"\n", s);    wprintf(L"length: %d\n", wcslen(s));    const CHAR* d = find_different_char(s);    if (d)    {        /*         * We have got the famous pointers arithmetics and we can compute         * difference of pointers pointing to the same array.         */        wprintf(L"character '%wc' (%#x) at %d\n", *d, *d, (int)(d - s));    }    else    {        wprintf(L"all characters are the same\n");    }    wprintf(L"\n");#else    putchar('\n');    printf("string: \"%s\"\n", s);    printf("length: %d\n", strlen(s));    const CHAR* d = find_different_char(s);    if (d)    {         /*         * We have got the famous pointers arithmetics and we can compute         * difference of pointers pointing to the same array.         */        printf("character '%c' (%#x) at %d\n", *d, *d, (int)(d - s));    }    else    {        printf("all characters are the same\n");    }    putchar('\n');#endif} /* There is a wmain function as an entry point when argv[] points to wchar_t */ #ifdef WIDE_CHARint wmain(int argc, wchar_t* argv[])#elseint main(int argc, char* argv[])#endif{    if (argc < 2)    {        raport_different_char(L"");        raport_different_char(L"   ");        raport_different_char(L"2");        raport_different_char(L"333");        raport_different_char(L".55");        raport_different_char(L"tttTTT");        raport_different_char(L"4444 444k");    }    else    {        raport_different_char(argv);    }     return EXIT_SUCCESS;}`
Output:
```string: ""
length: 0
all characters are the same

string: "   "
length: 3
all characters are the same

string: "2"
length: 1
all characters are the same

string: "333"
length: 3
all characters are the same

string: ".55"
length: 3
character '5' (0x35) at 1

string: "tttTTT"
length: 6
character 'T' (0x54) at 3

string: "4444 444k"
length: 9
character ' ' (0x20) at 4```

## C#

Translation of: D
`using System; namespace AllSame {    class Program {        static void Analyze(string s) {            Console.WriteLine("Examining [{0}] which has a length of {1}:", s, s.Length);            if (s.Length > 1) {                var b = s;                for (int i = 1; i < s.Length; i++) {                    var c = s[i];                    if (c != b) {                        Console.WriteLine("    Not all characters in the string are the same.");                        Console.WriteLine("    '{0}' (0x{1:X02}) is different at position {2}", c, (int)c, i);                        return;                    }                }             }            Console.WriteLine("    All characters in the string are the same.");        }         static void Main() {            var strs = new string[] { "", "   ", "2", "333", ".55", "tttTTT", "4444 444k" };            foreach (var str in strs) {                Analyze(str);            }        }    }}`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 1
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 3
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 4```

## C++

`#include <iostream>#include <string> void all_characters_are_the_same(const std::string& str) {    size_t len = str.length();    std::cout << "input: \"" << str << "\", length: " << len << '\n';    if (len > 0) {        char ch = str;        for (size_t i = 1; i < len; ++i) {            if (str[i] != ch) {                std::cout << "Not all characters are the same.\n";                std::cout << "Character '" << str[i]                    << "' (hex " << std::hex << static_cast<unsigned int>(str[i])                    << ") at position " << std::dec << i + 1                    << " is not the same as '" << ch << "'.\n\n";                return;            }        }    }    std::cout << "All characters are the same.\n\n";} int main() {    all_characters_are_the_same("");    all_characters_are_the_same("   ");    all_characters_are_the_same("2");    all_characters_are_the_same("333");    all_characters_are_the_same(".55");    all_characters_are_the_same("tttTTT");    all_characters_are_the_same("4444 444k");    return 0;}`
Output:
```input: "", length: 0
All characters are the same.

input: "   ", length: 3
All characters are the same.

input: "2", length: 1
All characters are the same.

input: "333", length: 3
All characters are the same.

input: ".55", length: 3
Not all characters are the same.
Character '5' (hex 35) at position 2 is not the same as '.'.

input: "tttTTT", length: 6
Not all characters are the same.
Character 'T' (hex 54) at position 4 is not the same as 't'.

input: "4444 444k", length: 9
Not all characters are the same.
Character ' ' (hex 20) at position 5 is not the same as '4'.

```

## Clojure

` (defn check-all-chars-same [s]  (println (format "String (%s) of len: %d" s (count s)))  (let [num-same (-> (take-while #(= (first s) %) s)                     count)]    (if (= num-same (count s))      (println "...all characters the same")      (println (format "...character %d differs - it is 0x%x"                       num-same                       (byte (nth s num-same)))))))   (map check-all-chars-same         [""          "   "          "2"          "333"          ".55"          "tttTTT"          "4444 444k"]) `
Output:
```(String () of len: 0
...all characters the same
String (   ) of len: 3
...all characters the same
String (2) of len: 1
...all characters the same
String (333) of len: 3
...all characters the same
String (.55) of len: 3
...character 1 differs - it is 0x35
String (tttTTT) of len: 6
...character 3 differs - it is 0x54
String (4444 444k) of len: 9
...character 4 differs - it is 0x20
```

## Common Lisp

Usage : (strequ string(s)) or (strequ) for auto-test

`(defun strequ (&rest str)    (if (not str) (setf str (list "" "   " "2" "333" ".55" "tttTTT" "4444 444k")))    (dolist (s str)        (do ((i 0 (1+ i)))            ((cond                ((= i (length s))                    (format t "\"~a\" [~d] : All characters are identical.~%" s (length s)) t)                ((char/= (char s i) (char s 0))                    (format t "\"~a\" [~d] : '~c' (0x~0x) at index ~d is different.~%" s (length s) (char s i) (char-int (char s i)) i) t))))))`
Output:
```""  : All characters are identical.
"   "  : All characters are identical.
"2"  : All characters are identical.
"333"  : All characters are identical.
".55"  : '5' (0x35) at index 1 is different.
"tttTTT"  : 'T' (0x54) at index 3 is different.
"4444 444k"  : ' ' (0x20) at index 4 is different.```

## D

Translation of: Kotlin
`import std.stdio; void analyze(string s) {    writefln("Examining [%s] which has a length of %d:", s, s.length);    if (s.length > 1) {        auto b = s;        foreach (i, c; s[1..\$]) {            if (c != b) {                writeln("    Not all characters in the string are the same.");                writefln("    '%c' (0x%x) is different at position %d", c, c, i);                return;            }        }    }    writeln("    All characters in the string are the same.");} void main() {    auto strs = ["", "   ", "2", "333", ".55", "tttTTT", "4444 444k"];    foreach (str; strs) {        analyze(str);    }}`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 0
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 2
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 3```

## Delphi

Translation of: D
` program Determine_if_a_string_has_all_the_same_characters; {\$APPTYPE CONSOLE} uses  System.SysUtils; procedure Analyze(s: string);var  b, c: char;  i: Integer;begin  writeln(format('Examining [%s] which has a length of %d:', [s, s.Length]));  if s.Length > 1 then  begin    b := s;    for i := 2 to s.Length - 1 do    begin      c := s[i];      if c <> b then      begin        writeln('    Not all characters in the string are the same.');        writeln(format('    "%s" 0x%x is different at position %d', [c, Ord(c), i]));        Exit;      end;    end;  end;  writeln('    All characters in the string are the same.');end; var  TestCases: array of string = ['', '   ', '2', '333', '.55', 'tttTTT', '4444 444k'];  w: string; begin  for w in TestCases do    Analyze(w);  Readln;end.`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
"5" 0x35 is different at position 2
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
"T" 0x54 is different at position 4
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
" " 0x20 is different at position 5
```

## F#

` // Determine if a string has all the same characters. Nigel Galloway: June 9th., 2020let fN n=if String.length n=0 then None else n.ToCharArray()|>Array.tryFindIndex(fun g->g<>n.) let allSame n=match fN n with               Some g->printfn "First different character in <<<%s>>> (length %d) is hex %x at position %d" n n.Length (int n.[g]) g              |_->printfn "All Characters are the same in <<<%s>>> (length %d)" n n.Length   allSame ""allSame "   "allSame "2"allSame "333"allSame ".55"allSame "tttTTT"allSame "4444 444k" `
Output:
```All Characters are the same in <<<>>> (length 0)
All Characters are the same in <<<   >>> (length 3)
All Characters are the same in <<<2>>> (length 1)
All Characters are the same in <<<333>>> (length 3)
First different character in <<<.55>>> (length 3) is hex 35 at position 1
First different character in <<<tttTTT>>> (length 6) is hex 54 at position 3
First different character in <<<4444 444k>>> (length 9) is hex 20 at position 4
```

## Factor

`USING: formatting io kernel math.parser sequences ; : find-diff ( str -- i elt ) dup ?first [ = not ] curry find ;: len. ( str -- ) dup length "%u — length %d — " printf ;: same. ( -- ) "contains all the same character." print ;: diff. ( -- ) "contains a different character at " write ; : not-same. ( i elt -- )    dup >hex diff. "index %d: '%c' (0x%s)\n" printf ; : sameness-report. ( str -- )    dup len. find-diff dup [ not-same. ] [ 2drop same. ] if ; {    ""    "   "    "2"    "333"    ".55"    "tttTTT"    "4444 444k"} [ sameness-report. ] each`
Output:
```"" — length 0 — contains all the same character.
"   " — length 3 — contains all the same character.
"2" — length 1 — contains all the same character.
"333" — length 3 — contains all the same character.
".55" — length 3 — contains a different character at index 1: '5' (0x35)
"tttTTT" — length 6 — contains a different character at index 3: 'T' (0x54)
"4444 444k" — length 9 — contains a different character at index 4: ' ' (0x20)
```

## FreeBASIC

`dim as string s, nxt input "Enter string:  ", s if len(s)<2 then   'A string with one or zero characters passes by default    print "All characters are the same."    endend if dim as ubyte i for i = 1 to len(s)-1    nxt = mid(s, i+1, 1)    if mid(s, i, 1)<>nxt then   'if any character differs from the previous one        print "First non-matching char is "+nxt        print "It occurs at position "+str(i+1)        print "Its hex value is "+hex(asc(nxt))        end    end ifnext i 'otherwise, success!print "All characters are the same."`
Output:
```Enter string:
All characters are the same.

Enter string:
All characters are the same.

Enter string:  2
All characters are the same.

Enter string:  333
All characters are the same.

Enter string:  .55
First non-matching char is 5
It occurs at position 2
Its hex value is 35

Enter string:  tttTTT
First non-matching char is T
It occurs at position 4
Its hex value is 54

Enter string:  4444 444k
First non-matching char is
It occurs at position 5
Its hex value is 20
```

## Go

`package main import "fmt" func analyze(s string) {    chars := []rune(s)    le := len(chars)    fmt.Printf("Analyzing %q which has a length of %d:\n", s, le)    if le > 1 {        for i := 1; i < le; i++ {            if chars[i] != chars[i-1] {                fmt.Println("  Not all characters in the string are the same.")                fmt.Printf("  %q (%#x) is different at position %d.\n\n", chars[i], i+1)                return            }        }    }    fmt.Println("  All characters in the string are the same.\n")} func main() {    strings := []string{        "",        "   ",        "2",        "333",        ".55",        "tttTTT",        "4444 444k",        "pépé",        "🐶🐶🐺🐶",        "🎄🎄🎄🎄",    }    for _, s := range strings {        analyze(s)    }}`
Output:
```Analyzing "" which has a length of 0:
All characters in the string are the same.

Analyzing "   " which has a length of 3:
All characters in the string are the same.

Analyzing "2" which has a length of 1:
All characters in the string are the same.

Analyzing "333" which has a length of 3:
All characters in the string are the same.

Analyzing ".55" which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 2.

Analyzing "tttTTT" which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 4.

Analyzing "4444 444k" which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 5.

Analyzing "pépé" which has a length of 4:
Not all characters in the string are the same.
'é' (0xe9) is different at position 2.

Analyzing "🐶🐶🐺🐶" which has a length of 4:
Not all characters in the string are the same.
'🐺' (0x1f43a) is different at position 3.

Analyzing "🎄🎄🎄🎄" which has a length of 4:
All characters in the string are the same.
```

## Groovy

Translation of: Java
`class Main {    static void main(String[] args) {        String[] tests = ["", "   ", "2", "333", ".55", "tttTTT", "4444 444k"]        for (String s : tests) {            analyze(s)        }    }     static void analyze(String s) {        println("Examining [\$s] which has a length of \${s.length()}")        if (s.length() > 1) {            char firstChar = s.charAt(0)            int lastIndex = s.lastIndexOf(firstChar as String)            if (lastIndex != 0) {                println("\tNot all characters in the string are the same.")                println("\t'\$firstChar' (0x\${Integer.toHexString(firstChar as Integer)}) is different at position \$lastIndex")                return            }        }        println("\tAll characters in the string are the same.")    }}`
Output:
```Examining [] which has a length of 0
All characters in the string are the same.
Examining [   ] which has a length of 3
Not all characters in the string are the same.
' ' (0x20) is different at position 2
Examining  which has a length of 1
All characters in the string are the same.
Examining  which has a length of 3
Not all characters in the string are the same.
'3' (0x33) is different at position 2
Examining [.55] which has a length of 3
All characters in the string are the same.
Examining [tttTTT] which has a length of 6
Not all characters in the string are the same.
't' (0x74) is different at position 2
Examining [4444 444k] which has a length of 9
Not all characters in the string are the same.
'4' (0x34) is different at position 7```

## Haskell

`import Numeric (showHex)import Data.List (span)import Data.Char (ord) inconsistentChar :: Eq a => [a] -> Maybe (Int, a)inconsistentChar [] = NothinginconsistentChar xs@(x:_) =  let (pre, post) = span (x ==) xs  in if null post       then Nothing       else Just (length pre, head post)  ---------------------------TEST----------------------------samples :: [String]samples = ["   ", "2", "333", ".55", "tttTTT", "4444 444"] main :: IO ()main = do  let w = succ . maximum \$ length <\$> samples      justifyRight n c = (drop . length) <*> (replicate n c ++)      f = (++ "' -> ") . justifyRight w ' ' . ('\'' :)  (putStrLn . unlines) \$    (\s ->        maybe          (f s ++ "consistent")          (\(n, c) ->              f s ++              "inconsistent '" ++              c : "' (0x" ++ showHex (ord c) ")" ++ " at char " ++ show (succ n))          (inconsistentChar s)) <\$>    samples`

and inconsistentChar could alternatively be defined in terms of findIndex:

`import Data.List (findIndex) inconsistentChar :: Eq a => [a] -> Maybe (Int, a)inconsistentChar [] = NothinginconsistentChar xs@(x:_) = findIndex (x /=) xs >>= Just . ((,) <*> (xs !!))`
Output:
```     '   ' -> consistent
'2' -> consistent
'333' -> consistent
'.55' -> inconsistent '5' (0x35) at char 2
'tttTTT' -> inconsistent 'T' (0x54) at char 4
'4444 444' -> inconsistent ' ' (0x20) at char 5```

## J

` Doc=: 2 : 'u :: (n"_)' task=: monad define common=. (; #) y  NB. the string and its length if. same y do.  common , <'same' else.  i =. differ y  c =. i { y  common , <((, (' (' , ') ' ,~ hex))c),'differs at index ',":i end.) hex=: ((Num_j_,26}.Alpha_j_) {~ 16 16 #: a.&i.)&> Doc 'convert ASCII literals to hex representation'assert '61' -: hex 'a'  `
```   STRINGS=: <;._2';   ;2;333;.55;tttTTT;4444 444k;'

same=: (2 > #@:~.)Doc'is 1 if the set of characters has less than 2 elements'
assert 1 1 1 1 0 0 0 -: same&>STRINGS

differ=: ([: >: [: {. [: I. 2 ~:/\ ])Doc'given different characters, return the zero index origin position of the character that differs'
assert 1 -: differ'abbb'

task&>STRINGS
+---------+-+-------------------------+
|         |0|same                     |
+---------+-+-------------------------+
|         |3|same                     |
+---------+-+-------------------------+
|2        |1|same                     |
+---------+-+-------------------------+
|333      |3|same                     |
+---------+-+-------------------------+
|.55      |3|5 (35) differs at index 1|
+---------+-+-------------------------+
|tttTTT   |6|T (54) differs at index 3|
+---------+-+-------------------------+
|4444 444k|9|  (20) differs at index 4|
+---------+-+-------------------------+
```

## Java

`public class Main{	public static void main(String[] args){		String[] tests = {"", "   ", "2", "333", ".55", "tttTTT", "4444 444k"};		for(String s:tests)			analyze(s);	} 	public static void analyze(String s){		System.out.printf("Examining [%s] which has a length of %d:\n", s, s.length());		if(s.length() > 1){			char firstChar = s.charAt(0);			int lastIndex = s.lastIndexOf(firstChar);			if(lastIndex != 0){				System.out.println("\tNot all characters in the string are the same.");				System.out.printf("\t'%c' (0x%x) is different at position %d\n", firstChar, (int) firstChar, lastIndex);				return;			}		}		System.out.println("\tAll characters in the string are the same.");	}}`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
Not all characters in the string are the same.
' ' (0x20) is different at position 2
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
Not all characters in the string are the same.
'3' (0x33) is different at position 2
Examining [.55] which has a length of 3:
All characters in the string are the same.
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
't' (0x74) is different at position 2
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
'4' (0x34) is different at position 7
```

## JavaScript

`const check = s => {  const arr = [...s];  const at = arr.findIndex(      (v, i) => i === 0 ? false : v !== arr[i - 1]  )  const l = arr.length;  const ok = at === -1;  const p = ok ? "" : at + 1;  const v = ok ? "" : arr[at];  const vs = v === "" ? v : `"\${v}"`  const h = ok ? "" : `0x\${v.codePointAt(0).toString(16)}`;  console.log(`"\${s}" => Length:\${l}\tSame:\${ok}\tPos:\${p}\tChar:\${vs}\tHex:\${h}`)} ['', '   ', '2', '333', '.55', 'tttTTT', '4444 444k', '🐶🐶🐺🐶', '🎄🎄🎄🎄'].forEach(check)`
Output:
```
""           => Length:0	Same:true	Pos:	Char:	Hex:
"   "        => Length:3	Same:true	Pos:	Char:	Hex:
"2"          => Length:1	Same:true	Pos:	Char:	Hex:
"333"        => Length:3	Same:true	Pos:	Char:	Hex:
".55"        => Length:3	Same:false	Pos:2	Char:"5"	Hex:0x35
"tttTTT"     => Length:6	Same:false	Pos:4	Char:"T"	Hex:0x54
"4444 444k"  => Length:9	Same:false	Pos:5	Char:" "	Hex:0x20
"🐶🐶🐺🐶"   => Length:4	Same:false	Pos:3	Char:"🐺"	Hex:0x1f43a
"🎄🎄🎄🎄"   => Length:4	Same:true	Pos:	Char:	Hex:

```

Alternatively, emphasising the composition of generic and reusable (pure value returning) library functions, and remaining agnostic about console.log (which is not part of JavaScript itself – doesn't feature in the ECMAScript standard – and is not available in all JS contexts).

`(() => {    'use strict';     // ---------- FIRST INCONSISTENT CHARACTER -----------     // inconsistentChar :: String -> Maybe (Char, Int)    const inconsistentChar = s =>        // Just the first inconsistent character in a        // string, paired with the index of its position,        // or Nothing if all of the characters in a string         // are the same.        2 > s.length ? (            Nothing()        ) : (() => {            const [h, ...t] = s;            const i = t.findIndex(c => h !== c);            return -1 !== i ? (                Just([t[i], 1 + i])            ) : Nothing();        })();      // ---------------------- TEST -----------------------    // main :: IO ()    const main = () =>        fTable(            'First inconsistent character:\n'        )(            s => `\${quoted("'")(s)} (\${[...s].length} chars)`        )(            maybe('None')(pair => {                const c = pair;                return `\${quoted("'")(c)} at index ` + (                    `\${pair} (\${showHex(ord(c))})`                );            })        )(            inconsistentChar        )([            '', '   ', '2', '333', '.55',            'tttTTT', '4444 444k',            '🐶🐶🐺🐶', '🎄🎄🎄🎄'        ]);      // ----------- REUSABLE GENERIC FUNCTIONS ------------     // Just :: a -> Maybe a    const Just = x => ({        type: 'Maybe',        Nothing: false,        Just: x    });      // Nothing :: Maybe a    const Nothing = () => ({        type: 'Maybe',        Nothing: true,    });      // fTable :: String -> (a -> String) ->     // (b -> String) -> (a -> b) -> [a] -> String    const fTable = s =>        // Heading -> x display function ->        //           fx display function ->        //    f -> values -> tabular string        xShow => fxShow => f => xs => {            const                ys = xs.map(xShow),                w = Math.max(...ys.map(length));            return s + '\n' + zipWith(                a => b => a.padStart(w, ' ') + ' -> ' + b            )(ys)(                xs.map(x => fxShow(f(x)))            ).join('\n');        };      // maybe :: b -> (a -> b) -> Maybe a -> b    const maybe = v =>        // Default value (v) if m is Nothing, or f(m.Just)        f => m => m.Nothing ? (            v        ) : f(m.Just);      // showHex :: Int -> String    const showHex = n =>        // Hexadecimal string for a given integer.        '0x' + n.toString(16);      // length :: [a] -> Int    const length = xs =>        // Returns Infinity over objects without finite        // length. This enables zip and zipWith to choose        // the shorter argument when one is non-finite,        // like cycle, repeat etc        'GeneratorFunction' !== xs.constructor        .constructor.name ? (            xs.length        ) : Infinity;      // list :: StringOrArrayLike b => b -> [a]    const list = xs =>        // xs itself, if it is an Array,        // or an Array derived from xs.        Array.isArray(xs) ? (            xs        ) : Array.from(xs || []);      // ord :: Char -> Int    const ord = c =>        // Unicode ordinal value of the character.        c.codePointAt(0);      // quoted :: Char -> String -> String    const quoted = c =>        // A string flanked on both sides        // by a specified quote character.        s => c + s + c;      // take :: Int -> [a] -> [a]    // take :: Int -> String -> String    const take = n =>        // The first n elements of a list,        // string of characters, or stream.        xs => 'GeneratorFunction' !== xs        .constructor.constructor.name ? (            xs.slice(0, n)        ) : [].concat.apply([], Array.from({            length: n        }, () => {            const x = xs.next();            return x.done ? [] : [x.value];        }));      // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]    const zipWith = f =>        // A map of f over each stepwise pair in         // xs and ys, up to the length of the shorter        // of those lists.        xs => ys => {            const                n = Math.min(length(xs), length(ys)),                vs = take(n)(list(ys));            return take(n)(list(xs))                .map((x, i) => f(x)(vs[i]));        };     // MAIN ---    return main()})();`
Output:
```First inconsistent character:

'' (0 chars) -> None
'   ' (3 chars) -> None
'2' (1 chars) -> None
'333' (3 chars) -> None
'.55' (3 chars) -> '5' at index 1 (0x35)
'tttTTT' (6 chars) -> 'T' at index 3 (0x54)
'4444 444k' (9 chars) -> ' ' at index 4 (0x20)
'🐶🐶🐺🐶' (4 chars) -> '🐺' at index 2 (0x1f43a)
'🎄🎄🎄🎄' (4 chars) -> None```

## jq

jq's "index origin" is 0. The hexadecimal encodings can be computed using the jq code at Non-decimal_radices/Convert#jq.

`jq -rn '   def firstdifferent:    label \$out    | foreach explode[] as \$i ({index:-1};        .prev = .i | .i = \$i | .index +=1;        if .prev and \$i != .prev then .index, break \$out else empty end)      // null ;   def lpad(\$n): " "*(\$n-length) + "\"\(.)\"" ;   [" "*10, "length", "same", "index", "char"],  (inputs   | firstdifferent as \$d   | [lpad(10), length, (\$d == null)] + (if \$d then [\$d, .[\$d:\$d+1]] else null end) )  | @tsv'`
Output:

Using as input the (JSON) strings shown in the first column of the output as shown below, the output is:

`           	length	same	index	char          ""	0	true       "   "	3	true         "2"	1	true       "333"	3	true       ".55"	3	false	1	5    "tttTTT"	6	false	3	T "4444 444k"	9	false	4	  "🐶🐶🐺🐶"	4	false	2	🐺 "🎄🎄🎄🎄"	4	true`

## Julia

`firstdifferent(s) = isempty(s) ? nothing : findfirst(x -> x != s, s) function testfunction(strings)   println("String                  | Length | All Same | First Different(Hex) | Position\n" *           "-----------------------------------------------------------------------------")    for s in strings        n = firstdifferent(s)        println(rpad(s, 27), rpad(length(s), 9), n == nothing ? "yes" :            rpad("no               \$(s[n])   (\$(string(Int(s[n]), base=16)))", 36) * string(n))    endend testfunction([	"",	"   ",	"2",	"333",    ".55",    "tttTTT",    "4444 444k",    "pépé",    "🐶🐶🐺🐶",    "🎄🎄🎄🎄",]) `
Output:
```String                  | Length | All Same | First Different(Hex) | Position
-----------------------------------------------------------------------------
0        yes
3        yes
2                          1        yes
333                        3        yes
.55                        3        no               5   (35)           2
tttTTT                     6        no               T   (54)           4
4444 444k                  9        no                   (20)           5
pépé                       4        no               é   (e9)           2
🐶🐶🐺🐶                 4        no               🐺  (1f43a)        9
🎄🎄🎄🎄                   4        yes
```

## Kotlin

Translation of: Go
`fun analyze(s: String) {    println("Examining [\$s] which has a length of \${s.length}:")    if (s.length > 1) {        val b = s        for ((i, c) in s.withIndex()) {            if (c != b) {                println("    Not all characters in the string are the same.")                println("    '\$c' (0x\${Integer.toHexString(c.toInt())}) is different at position \$i")                return            }        }    }    println("    All characters in the string are the same.")} fun main() {    val strs = listOf("", "   ", "2", "333", ".55", "tttTTT", "4444 444k")    for (str in strs) {        analyze(str)    }}`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 1
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 3
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 4```

## Lambdatalk

` {def firstDifferingChar  {def firstDifferingChar.r  {lambda {:w :i :n}   {if {or {> :i :n} {= {+ :i 1} {W.length :w}}}   then all characters are the same   else {if {not {W.equal? {W.get :i :w} {W.get {+ :i 1} :w}}}   then at position {+ :i 1} {W.get :i :w} becomes {W.get {+ :i 1} :w}    else {firstDifferingChar.r :w {+ :i 1} :n}}}}} {lambda {:w}  {if {= {W.length :w} 1}   then :w is a single character   else {firstDifferingChar.r :w 0 {W.length :w}}}}} -> firstDifferingChar  {firstDifferingChar 2}-> 2 is a single character{firstDifferingChar 333}-> all characters are the same{firstDifferingChar .55}-> at position 1 . becomes 5{firstDifferingChar tttTTT}-> at position 3 t becomes T `

## Lua

`function analyze(s)    print(string.format("Examining [%s] which has a length of %d:", s, string.len(s)))    if string.len(s) > 1 then        local last = string.byte(string.sub(s,1,1))        for i=1,string.len(s) do            local c = string.byte(string.sub(s,i,i))            if last ~= c then                print("    Not all characters in the string are the same.")                print(string.format("    '%s' (0x%x) is different at position %d", string.sub(s,i,i), c, i - 1))                return            end        end    end    print("    All characters in the string are the same.")end function main()    analyze("")    analyze("   ")    analyze("2")    analyze("333")    analyze(".55")    analyze("tttTTT")    analyze("4444 444k")end main()`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 1
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 3
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 4```

## Maple

`CheckSame:=proc(s)	local i, index;	printf("input: \"%s\", length: %a\n", s, StringTools:-Length(s));	for i from 2 to StringTools:-Length(s) do		if (s[i - 1] <> s[i]) then			printf("The given string has different characters.\n");			printf("The first different character is %a (0x%x) which appears at index %a.\n\n", 			 	  s[i], convert(s[i], 'bytes'), i);			return;		end if;	end do;	# if no difference found	printf("The given string has all same characters.\n\n");end proc: # TestCheckSame("");CheckSame("   ");CheckSame("2");CheckSame("333");CheckSame(".55");CheckSame("tttTTT");CheckSame("4444 444k");`
Output:
```input: "", length: 0
The given string has all same characters.

input: "   ", length: 3
The given string has all same characters.

input: "2", length: 1
The given string has all same characters.

input: "333", length: 3
The given string has all same characters.

input: ".55", length: 3
The given string has different characters.
The first different character is "5" (0x35) which appears at index 2.

input: "tttTTT", length: 6
The given string has different characters.
The first different character is "T" (0x54) which appears at index 4.

input: "4444 444k", length: 9
The given string has different characters.
The first different character is " " (0x20) which appears at index 5.

```

## Mathematica / Wolfram Language

`ClearAll[AllSameCharacters]AllSameCharacters[s_String] := Module[{c = Characters[s], i = 0, tf},  If[Length[c] > 1,    tf = AllTrue[Rest[c], (i++; # == First[c]) &];    If[tf,     Print["input = \"", s, "\", Length = ", StringLength[s],       ", All the same!"]     ,     Print["input = \"", s, "\", Length = ", StringLength[s],       ", Character " <> ToString[i + 1] <>        " is different from character " <> ToString[i], ", hex = ",       IntegerString[[email protected][c[[i + 1]]], 16]]     ]    ,    Print["input = \"", s, "\", Length = ", StringLength[s],      ", All the same!"]    ];  ]AllSameCharacters[""]AllSameCharacters["   "]AllSameCharacters["2"]AllSameCharacters["333"]AllSameCharacters[".55"]AllSameCharacters["tttTTT"]AllSameCharacters["4444 444k"]`
Output:
```input = "", Length = 0, All the same!
input = "   ", Length = 3, All the same!
input = "2", Length = 1, All the same!
input = "333", Length = 3, All the same!
input = ".55", Length = 3, Character 2 is different from character 1, hex = 35
input = "tttTTT", Length = 6, Character 4 is different from character 3, hex = 54
input = "4444 444k", Length = 9, Character 5 is different from character 4, hex = 20```

## Nanoquery

Translation of: Java
`def analyze(s)    s = str(s)    println "Examining [" + s + "] which has a length of " + str(len(s)) + ":"     if len(s) < 2        println "\tAll characters in the string are the same."        return    end     for i in range(0, len(s) - 2)        if s[i] != s[i + 1]            println "\tNot all characters in the string are the same."            println "\t'" + s[i + 1] + "' " + format("(0x%x)", ord(s[i + 1])) +\                    " is different at position " + str(i + 2)            return        end    end     println "\tAll characters in the string are the same."end tests = {"", "   ", "2", "333", ".55", "tttTTT", "444 444k"}for s in tests   analyze(s)end`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 2
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 4
Examining [444 444k] which has a length of 8:
Not all characters in the string are the same.
' ' (0x20) is different at position 4```

## Nim

`import strformat proc analyze(str: string) =    if str.len() > 1:        var first = str        for i, c in str:            if c != first:                echo "'", str, "': [len: ", str.len(), "] not all characters are the same. starts to differ at index ",                    i, ": '", first, "' != '", c, "' [", fmt"{ord(c):#x}", "]"                return    echo "'", str, "': [len: ", str.len(), "] all characters are the same" var strings = @["", "   ", "2", "333", ".55", "tttTTT", "4444 444k"]for str in strings:    analyze(str)`
Output:
```'': [len: 0] all characters are the same
'   ': [len: 3] all characters are the same
'2': [len: 1] all characters are the same
'333': [len: 3] all characters are the same
'.55': [len: 3] not all characters are the same. starts to differ at index 1: '.' != '5' [0x35]
'tttTTT': [len: 6] not all characters are the same. starts to differ at index 3: 't' != 'T' [0x54]
'4444 444k': [len: 9] not all characters are the same. starts to differ at index 4: '4' != ' ' [0x20]```

## OCaml

Original version by User:Vanyamil

` (*  Task: Determine if a string has all the same characters *) (*  Create a function that determines whether all characters in a string are identical,    or returns the index of first different character.     Using the option type here to combine the functionality.*)let str_first_diff_char (s : string) : int option =     let len = String.length s in    if len = 0     then None    else    let first = s. in    let rec helper idx =        if idx >= len         then None        else if s.[idx] = first        then helper (idx + 1)        else Some idx    in    helper 1;; (*  Task display: using format of Ada     Example:  Input = "333", length = 3 All characters are the same.Input = ".55", length = 3 First difference at position 2, character = '5', hex = 16#35#*) let format_answer s =     let first_line = "Input = \"" ^ s ^ "\", length = " ^ (s |> String.length |> string_of_int) in    let second_line = match str_first_diff_char s with        | None -> " All characters are the same."        | Some idx -> Printf.sprintf " First difference at position %d, character = %C, hex = %#x" (idx+1) s.[idx] (Char.code s.[idx])    in    print_endline first_line; print_endline second_line;; let _ =     [""; "   "; "2"; "333"; ".55"; "tttTTT"; "4444 444k"]    |> List.iter format_answer;; `
Output:
```Input = "", length = 0
All characters are the same.
Input = "   ", length = 3
All characters are the same.
Input = "2", length = 1
All characters are the same.
Input = "333", length = 3
All characters are the same.
Input = ".55", length = 3
First difference at position 2, character = '5', hex = 0x35
Input = "tttTTT", length = 6
First difference at position 4, character = 'T', hex = 0x54
Input = "4444 444k", length = 9
First difference at position 5, character = ' ', hex = 0x20
```

## Pascal

`program SameNessOfChar;{\$IFDEF FPC}   {\$MODE DELPHI}{\$OPTIMIZATION ON,ALL}{\$CODEALIGN proc=16}{\$ALIGN 16}{\$ELSE}  {\$APPTYPE CONSOLE}{\$ENDIF}uses  sysutils;//Format const  TestData : array[0..6] of String =     ('','   ','2','333','.55','tttTTT','4444 444k');function PosOfDifferentChar(const s: String):NativeInt;var  i: Nativeint;  ch:char;Begin  result := length(s);  IF result < 2 then    EXIT;  ch := s;  i := 2;  while (i< result) AND (S[i] =ch) do    inc(i);  result := i;end; procedure OutIsAllSame(const s: String);var  l,len: NativeInt;Begin  l := PosOfDifferentChar(s);  len := Length(s);  write('"',s,'" of length ',len);  IF l = len then    writeln(' contains all the same character')  else    writeln(Format(' is different at position %d "%s" (0x%X)',[l,s[l],Ord(s[l])]));end; var  i : NativeInt;begin  For i := Low(TestData) to HIgh(TestData) do    OutIsAllSame(TestData[i]);end.`
Output:
```"" of length 0 contains all the same character
"   " of length 3 contains all the same character
"2" of length 1 contains all the same character
"333" of length 3 contains all the same character
".55" of length 3 is different at position 2 "5" (0x35)
"tttTTT" of length 6 is different at position 4 "T" (0x54)
"4444 444k" of length 9 is different at position 5 " " (0x20)
```

## Perl

`use strict;use warnings;use feature 'say';use utf8;binmode(STDOUT, ':utf8');use List::AllUtils qw(uniq);use Unicode::UCD 'charinfo';use Unicode::Normalize qw(NFC); for my \$str (    '',    '   ',    '2',    '333',    '.55',    'tttTTT',    '4444 444k',    'Δ👍👨',    '🇬🇧🇬🇧🇬🇧🇬🇧',    "\N{LATIN CAPITAL LETTER A}\N{COMBINING DIAERESIS}\N{COMBINING MACRON}" .    "\N{LATIN CAPITAL LETTER A WITH DIAERESIS}\N{COMBINING MACRON}" .    "\N{LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON}") {    my @S;    push @S, NFC \$1 while \$str =~ /(\X)/g;    printf qq{\n"\$str" (length: %d) has }, scalar @S;    my @U = uniq @S;    if (1 != @U and @U > 0) {        say 'different characters:';        for my \$l (@U) {            printf "'%s' %s (0x%x) in positions: %s\n",                \$l, charinfo(ord \$l)->{'name'}, ord(\$l), join ', ', map { 1+\$_ } grep { \$l eq \$S[\$_] } 0..\$#S;        }    } else {        say 'the same character in all positions.'    }}`
Output:
```"" (length: 0) has the same character in all positions.

"   " (length: 3) has the same character in all positions.

"2" (length: 1) has the same character in all positions.

"333" (length: 3) has the same character in all positions.

".55" (length: 3) has different characters:
'.' FULL STOP (0x2e) in positions: 1
'5' DIGIT FIVE (0x35) in positions: 2, 3

"tttTTT" (length: 6) has different characters:
't' LATIN SMALL LETTER T (0x74) in positions: 1, 2, 3
'T' LATIN CAPITAL LETTER T (0x54) in positions: 4, 5, 6

"4444 444k" (length: 9) has different characters:
'4' DIGIT FOUR (0x34) in positions: 1, 2, 3, 4, 6, 7, 8
' ' SPACE (0x20) in positions: 5
'k' LATIN SMALL LETTER K (0x6b) in positions: 9

"Δ👍👨" (length: 3) has different characters:
'Δ' GREEK CAPITAL LETTER DELTA (0x394) in positions: 1
'👍' THUMBS UP SIGN (0x1f44d) in positions: 2
'👨' MAN (0x1f468) in positions: 3

"🇬🇧🇬🇧🇬🇧🇬🇧" (length: 4) has the same character in all positions.

"ǞǞǞ" (length: 3) has the same character in all positions.```

## Phix

`procedure samechar(sequence s)    string msg = "all characters are the same"    integer l = length(s)    if l>=2 then        integer ch = s        for i=2 to l do            integer si = s[i]            if si!=ch then                msg = sprintf(`first different character "%c"(#%02x) at position %d`,{si,si,i})                exit            end if        end for    end if    printf(1,"\"%s\" (length %d): %s\n",{s,l,msg})end procedure constant tests = {"","   ","2","333",".55","tttTTT","4444 444k",                  utf8_to_utf32("🐶🐶🐺🐶"),utf8_to_utf32("🎄🎄🎄🎄")}for i=1 to length(tests) do samechar(tests[i]) end for`
Output:
```"" (length 0): all characters are the same
"   " (length 3): all characters are the same
"2" (length 1): all characters are the same
"333" (length 3): all characters are the same
".55" (length 3): first different character "5"(#35) at position 2
"tttTTT" (length 6): first different character "T"(#54) at position 4
"4444 444k" (length 9): first different character " "(#20) at position 5
"🐶🐶🐺🐶" (length 4): first different character "🐺"(#1F43A) at position 3
"🎄🎄🎄🎄" (length 4): all characters are the same
```

## PicoLisp

`(de equal? (Str)   (let (Lst (chop Str)  C (car Lst)  P 2  F)      (prin Str ": ")      (for A (cdr Lst)         (NIL (= A C) (on F) (prin "First different character " A))         (inc 'P) )      (if F (prinl " at position: " P) (prinl "all characters are the same")) ) )(equal?)(equal? "   ")(equal? "333")(equal? ".55")(equal? "tttTTT")`
Output:
```: all characters are the same
: all characters are the same
333: all characters are the same
.55: First different character 5 at position: 2
tttTTT: First different character T at position: 4
```

## Plain English

`To run:Start up.Show the uniformity of "".Show the uniformity of "   ".Show the uniformity of "2".Show the uniformity of "333".Show the uniformity of ".55".Show the uniformity of "tttTTT".Show the uniformity of "4444 444k".Wait for the escape key.Shut down. To find the first different character in a string giving a byte and a count:If the string is blank, put -1 into the count; exit.Put the string's first's target into a first letter.Slap a substring on the string.Loop.If a counter is past the string's length, put -1 into the count; exit.Put the substring's first's target into a letter.If the letter is not the first letter, put the letter into the byte; put the counter minus 1 into the count; exit.Add 1 to the substring's first.Repeat. To show the uniformity of a string:Write """" then the string then """ (length " then the string's length then ") " on the console without advancing.Find the first different character in the string giving a byte and a count.If the count is -1, write "contains all the same character." on the console; exit.Convert the byte to a nibble string.Write "contains a different character at index " then the count then ": '" then the byte then "' (0x" then the nibble string then ")." on the console.`
Output:
```"" (length 0) contains all the same character.
"   " (length 3) contains all the same character.
"2" (length 1) contains all the same character.
"333" (length 3) contains all the same character.
".55" (length 3) contains a different character at index 1: '5' (0x35).
"tttTTT" (length 6) contains a different character at index 3: 'T' (0x54).
"4444 444k" (length 9) contains a different character at index 4: ' ' (0x20).
```

## Prolog

Works with: SWI-Prolog version 7
` :- system:set_prolog_flag(double_quotes,chars) . main:-same_or_different("") ,same_or_different("   ") ,same_or_different("2") ,same_or_different("333") ,same_or_different(".55") ,same_or_different("tttTTT") ,same_or_different("4444 444k"). %!  same_or_different(INPUTz0) same_or_different(INPUTz0):-system:format('input string is "~s" .~n',[INPUTz0]) ,examine(INPUTz0). %!  examine(INPUTz0) examine([]):-! ,system:format('all the same characters .~n',[]). examine([COMPARE0|INPUTz0]):-examine(INPUTz0,COMPARE0,2,_INDEX_). %!  examine(INPUTz0,COMPARE0,INDEX0,INDEX) examine([],_COMPARE0_,INDEX0,INDEX0):-! ,system:format('all the same characters .~n',[]). examine([COMPARE0|INPUTz0],COMPARE0,INDEX0,INDEX):-! ,INDEX1 is INDEX0 + 1 ,examine(INPUTz0,COMPARE0,INDEX1,INDEX). examine([DIFFERENT0|_INPUTz0_],COMPARE0,INDEX0,INDEX0):-prolog:char_code(DIFFERENT0,DIFFERENT_CODE) ,system:format('character "~s" (hex ~16r) different than "~s" at 1-based index ~10r .~n',[[DIFFERENT0],DIFFERENT_CODE,[COMPARE0],INDEX0]).  `
Output:
```/*
?- main .
input string is "" .
all the same characters .
input string is "   " .
all the same characters .
input string is "2" .
all the same characters .
input string is "333" .
all the same characters .
input string is ".55" .
character "5" (hex 35) different than "." at 1-based index 2 .
input string is "tttTTT" .
character "T" (hex 54) different than "t" at 1-based index 4 .
input string is "4444 444k" .
character " " (hex 20) different than "4" at 1-based index 5 .
true.

?-
*/
```

## Python

### Functional

What we are testing here is the cardinality of the set of characters from which a string is drawn, so the first thought might well be to use set.

On the other hand, itertools.groupby has the advantage of yielding richer information (the list of groups is ordered), for less work.

Works with: Python version 3.7
`'''Determine if a string has all the same characters''' from itertools import groupby  # firstDifferingCharLR :: String -> Either String Dictdef firstDifferingCharLR(s):    '''Either a message reporting that no character changes were       seen, or a dictionary with details of the  first character       (if any) that differs from that at the head of the string.    '''    def details(xs):        c = xs        return {            'char': repr(c),            'hex': hex(ord(c)),            'index': s.index(c),            'total': len(s)        }    xs = list(groupby(s))    return Right(details(xs)) if 1 < len(xs) else (        Left('Total length ' + str(len(s)) + ' - No character changes.')    )  # TEST ----------------------------------------------------# main :: IO ()def main():    '''Test of 7 strings'''     print(fTable('First, if any, points of difference:\n')(repr)(        either(identity)(            lambda dct: dct['char'] + ' (' + dct['hex'] +            ') at character ' + str(1 + dct['index']) +            ' of ' + str(dct['total']) + '.'        )    )(firstDifferingCharLR)([        '',        '   ',        '2',        '333',        '.55',        'tttTTT',        '4444 444'    ]))  # GENERIC ------------------------------------------------- # either :: (a -> c) -> (b -> c) -> Either a b -> cdef either(fl):    '''The application of fl to e if e is a Left value,       or the application of fr to e if e is a Right value.    '''    return lambda fr: lambda e: fl(e['Left']) if (        None is e['Right']    ) else fr(e['Right'])  # identity :: a -> adef identity(x):    '''The identity function.'''    return x  # fTable :: String -> (a -> String) -># (b -> String) -> (a -> b) -> [a] -> Stringdef fTable(s):    '''Heading -> x display function -> fx display function ->       f -> xs -> tabular string.    '''    def go(xShow, fxShow, f, xs):        ys = [xShow(x) for x in xs]        w = max(map(len, ys))        return s + '\n' + '\n'.join(map(            lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),            xs, ys        ))    return lambda xShow: lambda fxShow: lambda f: lambda xs: go(        xShow, fxShow, f, xs    )  # Left :: a -> Either a bdef Left(x):    '''Constructor for an empty Either (option type) value       with an associated string.    '''    return {'type': 'Either', 'Right': None, 'Left': x}  # Right :: b -> Either a bdef Right(x):    '''Constructor for a populated Either (option type) value'''    return {'type': 'Either', 'Left': None, 'Right': x}  # MAIN ---if __name__ == '__main__':    main()`
Output:
```First, if any, points of difference:

'' -> Total length 0 - No character changes.
'   ' -> Total length 3 - No character changes.
'2' -> Total length 1 - No character changes.
'333' -> Total length 3 - No character changes.
'.55' -> '5' (0x35) at character 2 of 3.
'tttTTT' -> 'T' (0x54) at character 4 of 6.
'4444 444' -> ' ' (0x20) at character 5 of 8.```

and for very long strings, itertools.takewhile (here used in the definition of a more general span function), should be slightly more efficient:

`'''Determine if a string has all the same characters''' from itertools import takewhile  # inconsistentChar :: String -> Maybe (Int, Char)def inconsistentChar(s):    '''Just the first inconsistent character and its position,       or Nothing if all the characters of s are the same,    '''    if s:        h = s        pre, post = span(lambda c: h == c)(s)        return Just((len(pre), post)) if post else Nothing()    else:        return Nothing()  # --------------------------TEST---------------------------# main :: IO ()def main():    '''Consistency tests of seven strings'''     samples = ['', '   ', '2', '333', '.55', 'tttTTT', '4444 444']    w = 1 + max(map(len, samples))     def pfx(s):        return ("'" + s).rjust(w) + "' -> "     def charPosn(ic):        i, c = ic        return "inconsistent '" + c + "' (" + hex(ord(c)) + ")" + (            " at char " + str(1 + i)        )     print(main.__doc__ + ':\n')    print(        '\n'.join([            pfx(s) + maybe('consistent')(charPosn)(                inconsistentChar(s)            )            for s in samples        ])    )  # -------------------------GENERIC------------------------- # Just :: a -> Maybe adef Just(x):    '''Constructor for an inhabited Maybe (option type) value.       Wrapper containing the result of a computation.    '''    return {'type': 'Maybe', 'Nothing': False, 'Just': x}  # Nothing :: Maybe adef Nothing():    '''Constructor for an empty Maybe (option type) value.       Empty wrapper returned where a computation is not possible.    '''    return {'type': 'Maybe', 'Nothing': True}  # maybe :: b -> (a -> b) -> Maybe a -> bdef maybe(v):    '''Either the default value v, if m is Nothing,       or the application of f to x,       where m is Just(x).    '''    return lambda f: lambda m: v if None is m or m.get('Nothing') else (        f(m.get('Just'))    )  # span :: (a -> Bool) -> [a] -> ([a], [a])def span(p):    '''The longest (possibly empty) prefix of xs       that contains only elements satisfying p,       tupled with the remainder of xs.       span p xs is equivalent to (takeWhile p xs, dropWhile p xs).    '''    def go(xs):        prefix = list(takewhile(p, xs))        return (prefix, xs[len(prefix):])    return lambda xs: go(xs)  # MAIN ---if __name__ == '__main__':    main()`

Putting itertools aside, we could equivalently define inconsistentChar as:

`# inconsistentChar :: String -> Maybe (Int, Char)def inconsistentChar(s):    '''Just the first inconsistent character and its index,       or Nothing if all the characters of s are the same.    '''    return next(        (Just(ix) for ix in enumerate(s) if s != ix),        Nothing()    )`
Output:
```Consistency tests of seven strings:

'' -> consistent
'   ' -> consistent
'2' -> consistent
'333' -> consistent
'.55' -> inconsistent '5' (0x35) at char 2
'tttTTT' -> inconsistent 'T' (0x54) at char 4
'4444 444' -> inconsistent ' ' (0x20) at char 5```

## R

`isAllSame<-function(string){  strLength<-nchar(string)  if(length(strLength)>1)  {    #R has a distinction between the length of a string and that of a character vector. It is a common source    #of problems when coming from another language. We will try to avoid the topic here.    #For our purposes, let us only say that there is a good reason why we have made    #isAllSame(c("foo", "bar") immediately throw an error.    stop("This task is intended for character vectors with lengths of at most 1.")  }  else if(length(strLength)==0)  {    cat("Examining a character vector of length 0.\n")    TRUE  }  else if(strLength==0)  {    cat("Examining a character vector of length 1, containing an empty string.\n")    TRUE  }  else  {    cat("Examining the string", paste0(sQuote(string), ","),        "which is of length", paste0(strLength, ":"), "\n")    #strsplit outputs a list. Its first element is the vector of characters that we desire.    characters<-strsplit(string, "")[]    #Our use of match is using R's vector recycling rules. Every element is being checked    #against the first.    differentElementIndex<-match(FALSE, characters==characters, nomatch = 0)    if(differentElementIndex==0)    {      cat("It has no duplicates.\n")      TRUE    }    else    {      cat("It has duplicates. ")      firstDifferentCharacter<-characters[differentElementIndex]      cat(sQuote(firstDifferentCharacter), "is the first different character. It has hex value",          sprintf("0x%X", as.integer(charToRaw(firstDifferentCharacter))),          "and is at index", paste0(differentElementIndex, "."), "\n")      FALSE    }  }} #Tests:cat("Test: A string of length 0 (an empty string):\n")cat("Test 1 of 2: An empty character vector:\n")print(isAllSame(character(0)))cat("Test 2 of 2: A character vector containing the empty string:\n")print(isAllSame(""))cat("Test: A string of length 3 which contains three blanks:\n")print(isAllSame("   "))cat("Test: A string of length 1 which contains 2:\n")print(isAllSame("2"))cat("Test: A string of length 3 which contains 333:\n")print(isAllSame("333"))cat("Test: A string of length 3 which contains .55:\n")print(isAllSame(".55"))cat("Test: A string of length 6 which contains tttTTT:\n")print(isAllSame("tttTTT"))cat("Test: A string of length 9 which contains 4444 444k:\n")print(isAllSame("4444 444k"))`
Output:
```Test: A string of length 0 (an empty string):
Test 1 of 2: An empty character vector:
Examining a character vector of length 0.
 TRUE
Test 2 of 2: A character vector containing the empty string:
Examining a character vector of length 1, containing an empty string.
 TRUE
Test: A string of length 3 which contains three blanks:
Examining the string ‘   ’, which is of length 3:
It has no duplicates.
 TRUE
Test: A string of length 1 which contains 2:
Examining the string ‘2’, which is of length 1:
It has no duplicates.
 TRUE
Test: A string of length 3 which contains 333:
Examining the string ‘333’, which is of length 3:
It has no duplicates.
 TRUE
Test: A string of length 3 which contains .55:
Examining the string ‘.55’, which is of length 3:
It has duplicates. ‘5’ is the first different character. It has hex value 0x35 and is at index 2.
 FALSE
Test: A string of length 6 which contains tttTTT:
Examining the string ‘tttTTT’, which is of length 6:
It has duplicates. ‘T’ is the first different character. It has hex value 0x54 and is at index 4.
 FALSE
Test: A string of length 9 which contains 4444 444k:
Examining the string ‘4444 444k’, which is of length 9:
It has duplicates. ‘ ’ is the first different character. It has hex value 0x20 and is at index 5.
 FALSE```

## Racket

`#lang racket (define (first-non-matching-index l =)  (and (not (null? l)) (index-where l (curry (negate =) (car l))))) (define (report-string-sameness s)  (printf "~s (length: ~a): ~a~%"          s          (string-length s)          (cond [(first-non-matching-index (string->list s) char=?)                 => (λ (i)                      (let ((c (string-ref s i)))                        (format "first different character ~s(~a) at position: ~a" c (char->integer c) (add1 i))))]                [else "all characters are the same"]))) (module+ test  (for-each report-string-sameness '("" "   " "2" "333" ".55" "tttTTT" "4444 444k")))`
Output:
```"" (length: 0): all characters are the same
"   " (length: 3): all characters are the same
"2" (length: 1): all characters are the same
"333" (length: 3): all characters are the same
".55" (length: 3): first different character #\5(53) at position: 2
"tttTTT" (length: 6): first different character #\T(84) at position: 4
"4444 444k" (length: 9): first different character #\space(32) at position: 5```

## Raku

(formerly Perl 6)

Works with: Rakudo version 2020.08.1

The last string demonstrates how Raku can recognize that glyphs made up of different combinations of combining characters can compare the same. It is built up from explicit codepoints to show that each of the glyphs is made up of different combinations.

`  -> \$str {    my \$i = 0;    print "\n{\$str.raku} (length: {\$str.chars}), has ";    my %m;    %m{\$_}.push: ++\$i for \$str.comb;     if %m > 1 {        say "different characters:";        say "'{.key}' ({.key.uninames}; hex ordinal: {(.key.ords).fmt: "0x%X"})" ~        " in positions: {.value.join: ', '}" for %m.sort( *.value );    } else {        say "the same character in all positions."    }} for    '',    '   ',    '2',    '333',    '.55',    'tttTTT',    '4444 444k',    '🇬🇧🇬🇧🇬🇧🇬🇧',    "\c[LATIN CAPITAL LETTER A]\c[COMBINING DIAERESIS]\c[COMBINING MACRON]" ~    "\c[LATIN CAPITAL LETTER A WITH DIAERESIS]\c[COMBINING MACRON]" ~    "\c[LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON]",    'AАΑꓮ𐌀𐊠Ꭺ'`
Output:
```"" (length: 0), has the same character in all positions.

"   " (length: 3), has the same character in all positions.

"2" (length: 1), has the same character in all positions.

"333" (length: 3), has the same character in all positions.

".55" (length: 3), has different characters:
'.' (FULL STOP; hex ordinal: 0x2E) in positions: 1
'5' (DIGIT FIVE; hex ordinal: 0x35) in positions: 2, 3

"tttTTT" (length: 6), has different characters:
't' (LATIN SMALL LETTER T; hex ordinal: 0x74) in positions: 1, 2, 3
'T' (LATIN CAPITAL LETTER T; hex ordinal: 0x54) in positions: 4, 5, 6

"4444 444k" (length: 9), has different characters:
'4' (DIGIT FOUR; hex ordinal: 0x34) in positions: 1, 2, 3, 4, 6, 7, 8
' ' (SPACE; hex ordinal: 0x20) in positions: 5
'k' (LATIN SMALL LETTER K; hex ordinal: 0x6B) in positions: 9

"🇬🇧🇬🇧🇬🇧🇬🇧" (length: 4), has the same character in all positions.

"ǞǞǞ" (length: 3), has the same character in all positions.

"AАΑꓮ𐌀𐊠Ꭺ" (length: 7), has different characters:
'A' (LATIN CAPITAL LETTER A; hex ordinal: 0x41) in positions: 1
'А' (CYRILLIC CAPITAL LETTER A; hex ordinal: 0x410) in positions: 2
'Α' (GREEK CAPITAL LETTER ALPHA; hex ordinal: 0x391) in positions: 3
'ꓮ' (LISU LETTER A; hex ordinal: 0xA4EE) in positions: 4
'𐌀' (OLD ITALIC LETTER A; hex ordinal: 0x10300) in positions: 5
'𐊠' (CARIAN LETTER A; hex ordinal: 0x102A0) in positions: 6
'Ꭺ' (CHEROKEE LETTER GO; hex ordinal: 0x13AA) in positions: 7```

## REXX

`/*REXX program verifies that  all characters  in a string are all the same (character). */@chr= '     [character'                               /* define a literal used for  SAY.*/@all= 'all the same character for string (length'     /*    "   "    "     "    "    "  */@.=                                              /*define a default for the  @.  array. */parse arg x                                      /*obtain optional argument from the CL.*/if x\=''  then       @.1= x                      /*if user specified an arg, use that.  */          else do;   @.1=                        /*use this null string if no arg given.*/                     @.2= '   '                  /* "    "          "    "  "  "    "   */                     @.3= 2                      /* "    "          "    "  "  "    "   */                     @.4= 333                    /* "    "          "    "  "  "    "   */                     @.5= .55                    /* "    "          "    "  "  "    "   */                     @.6= 'tttTTT'               /* "    "          "    "  "  "    "   */                     @.7= 4444 444k              /* "    "          "    "  "  "    "   */               end                               /* [↑]  seventh value contains a blank.*/      do j=1;    L= length(@.j)                   /*obtain the length of an array element*/     if j>1  &  L==0     then leave              /*if arg is null and  J>1, then leave. */     r= allSame(@.j)                             /*R:  ≡0,  or the location of bad char.*/     if r\==0  then ?= substr(@.j,r,1)           /*if  not  monolithic, obtain the char.*/     if r==0   then say '   ' @all L"):"  @.j               else say 'not' @all L"):"  @.j  @chr ?  "('"c2x(?)"'x)  at position"  r"]."     end   /*j*/exit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/allSame: procedure; parse arg y                  /*get a value from the argument list.  */         if y==''  then return 0                 /*if  Y  is null,  then return 0 (zero)*/         return verify(y, left(y,1) )            /*All chars the same?   Return 0 (zero)*/                                                 /*                else  return location*/`
output   when using the internal default inputs:
```    all the same character for string (length 0):
all the same character for string (length 3):
all the same character for string (length 1): 2
all the same character for string (length 3): 333
not all the same character for string (length 3): .55      [character 5 ('35'x)  at position 2].
not all the same character for string (length 6): tttTTT      [character T ('54'x)  at position 4].
not all the same character for string (length 9): 4444 444K      [character   ('20'x)  at position 5].
```

## Ring

` nputStr = ["","   ","2","333",".55","tttTTT","4444 444k"] for word in inputStr    for x = 1 to len(word)        for y = x + 1 to len(word)            if word[x] != word[y]               char = word[y]               ? "Input = " + "'" + word + "'" + ", length = " + len(word)               ? " First difference at position " + y + ", character = " + "'" + char + "'"               loop 3            ok        next    next     ? "Input = " + "'" + word + "'" + ", length = " + len(word)    ? "  All characters are the same."next `
Output:
```Input = '', length = 0
All characters are the same.
Input = '   ', length = 3
All characters are the same.
Input = '2', length = 1
All characters are the same.
Input = '333', length = 3
All characters are the same.
Input = '.55', length = 3
First difference at position 2, character = '5'
Input = 'tttTTT', length = 6
First difference at position 4, character = 'T'
Input = '4444 444k', length = 9
First difference at position 5, character = ' '
```

## Ruby

`strings = ["", "   ", "2", "333", ".55", "tttTTT", "4444   444k", "pépé", "🐶🐶🐺🐶", "🎄🎄🎄🎄"] strings.each do |str|  pos = str.empty? ? nil : str =~ /[^#{str}]/  print "#{str.inspect}  (size #{str.size}): "  puts pos ? "first different char #{str[pos].inspect} (#{'%#x' % str[pos].ord}) at position #{pos}." : "all the same."end `
Output:
```""  (size 0): all the same.
"   "  (size 3): all the same.
"2"  (size 1): all the same.
"333"  (size 3): all the same.
".55"  (size 3): first different char "5" (0x35) at position 1.
"tttTTT"  (size 6): first different char "T" (0x54) at position 3.
"4444   444k"  (size 11): first different char " " (0x20) at position 4.
"pépé"  (size 4): first different char "é" (0xe9) at position 1.
"🐶🐶🐺🐶"  (size 4): first different char "🐺" (0x1f43a) at position 2.
"🎄🎄🎄🎄"  (size 4): all the same.
```

## Rust

`fn test_string(input: &str) {    println!("Checking string {:?} of length {}:", input, input.chars().count());     let mut chars = input.chars();     match chars.next() {        Some(first) => {            if let Some((character, pos)) = chars.zip(2..).filter(|(c, _)| *c != first).next() {                println!("\tNot all characters are the same.");                println!("\t{:?} (0x{:X}) at position {} differs.", character, character as u32, pos);                 return;            }        },        None => {}    }     println!("\tAll characters in the string are the same");} fn main() {    let tests = ["", "   ", "2", "333", ".55", "tttTTT", "4444 444k", "pépé", "🐶🐶🐺🐶", "🎄🎄🎄🎄"];     for string in &tests {        test_string(string);    }}`
Output:
```Checking string "" of length 0:
All characters in the string are the same
Checking string "   " of length 3:
All characters in the string are the same
Checking string "2" of length 1:
All characters in the string are the same
Checking string "333" of length 3:
All characters in the string are the same
Checking string ".55" of length 3:
Not all characters are the same.
'5' (0x35) at position 2 differs.
Checking string "tttTTT" of length 6:
Not all characters are the same.
'T' (0x54) at position 4 differs.
Checking string "4444 444k" of length 9:
Not all characters are the same.
' ' (0x20) at position 5 differs.
Checking string "pépé" of length 4:
Not all characters are the same.
'é' (0xE9) at position 2 differs.
Checking string "🐶🐶🐺🐶" of length 4:
Not all characters are the same.
'🐺' (0x1F43A) at position 3 differs.
Checking string "🎄🎄🎄🎄" of length 4:
All characters in the string are the same
```

## Scala

`import scala.collection.immutable.ListMap object StringAllSameCharacters {   /**Transform an input String into an HashMap of its characters and its first occurrence index*/  def countChar( s : String) : Map[Char, Int] = {    val mapChar = s.toSeq.groupBy(identity).map{ case (a,b) => a->s.indexOf(a) }    val orderedMapChar = ListMap(mapChar.toSeq.sortWith(_._2 < _._2):_*)    orderedMapChar  }   /**Check if all the characters of a String are the same given an input Hashmap of it */  def areAllCharEquals ( mapChar : Map[Char, Int] ) : Boolean = {    return mapChar.size <= 1  }   /**Retrieve the first "breaking" different character of a String*/  def findFirstDifferentChar ( mapChar : Map[Char, Int] ) : Char = {    if(areAllCharEquals(mapChar) == false) mapChar.keys.toList(1)    else 0.toChar  }   /**Convert char to hexadecimal values as "0xHEXVALUE" */  def charToHexString ( c : Char) : String = "0x" + c.toHexString   /**Display results as asked in the ask*/  def reportResults( s : String) : String = {    val mapChar = countChar(s)    if (areAllCharEquals(mapChar)) s + " -- length " + s.size + " -- contains all the same character."    else {      val diffChar = findFirstDifferentChar(mapChar)      s + " -- length " + s.size +         " -- contains a different character at index " +         (s.indexOf(diffChar).toInt+1).toString + " : " + charToHexString(diffChar)    }  }   def main(args: Array[String]): Unit = {    println(reportResults(""))    println(reportResults("   "))    println(reportResults("2"))    println(reportResults("333"))    println(reportResults(".55"))    println(reportResults("tttTTT"))    println(reportResults("4444 444k"))  }  }  `
Output:
``` -- length 0 -- contains all the same character.
-- length 3 -- contains all the same character.
2 -- length 1 -- contains all the same character.
333 -- length 3 -- contains all the same character.
.55 -- length 3 -- contains a different character at index 2 : 0x35
tttTTT -- length 6 -- contains a different character at index 4 : 0x54
4444 444k -- length 9 -- contains a different character at index 5 : 0x20
```

## Sidef

`func analyze_string(str) {    var chars = str.chars    chars.range.to_a.each_cons(2, {|a,b|        chars[a] == chars[b] || return b    })    return str.len} var strings = ["", "   ", "2", "333", ".55", "tttTTT", "4444   444k", "pépé", "🐶🐶🐺🐶", "🎄🎄🎄🎄"] strings.each {|str|    print "'#{str}' (size #{str.len}): "    var idx = analyze_string(str)     if (idx == str.len) {        say "all the same."    }    else {        say "first different char '#{str[idx]}' (#{'%#x' % str[idx].ord}) at position #{idx}."    }}`
Output:
```'' (size 0): all the same.
'   ' (size 3): all the same.
'2' (size 1): all the same.
'333' (size 3): all the same.
'.55' (size 3): first different char '5' (0x35) at position 1.
'tttTTT' (size 6): first different char 'T' (0x54) at position 3.
'4444   444k' (size 11): first different char ' ' (0x20) at position 4.
'pépé' (size 4): first different char 'é' (0xe9) at position 1.
'🐶🐶🐺🐶' (size 4): first different char '🐺' (0x1f43a) at position 2.
'🎄🎄🎄🎄' (size 4): all the same.
```

## Standard ML

` datatype result=allSame | difference of string*char*int ;val chkstring =  fn input =>letval rec chk =  fn ([],n)     => allSame               |  ([x],n)    => allSame	       |  (x::y::t,n)=> if x=y then chk (y::t,n+1)	                                else difference (Int.fmt StringCvt.HEX(Char.ord(y)),y,n)in(  input,  String.size input ,   chk ( String.explode  input,2 )  )end; `

result (string, string length, same or (hex,char,position))

` - map chkstring [ "","   ","1","333",".55","tttTTT","4444 444k" ];val it =   [("", 0, allSame), ("   ", 3, allSame), ("1", 1, allSame),    ("333", 3, allSame), (".55", 3, difference ("35", #"5", 2)),    ("tttTTT", 6, difference ("54", #"T", 4)),    ("4444 444k", 9, difference ("20", #" ", 5))]: `

## Tcl

`package require Tcl 8.6 ; # For binary encode array set yesno {1 Yes 0 No} set test {    {}    {   }    {2}    {333}    {.55}    {tttTTT}    {4444 444k}    {jjjjjjj}} # Loop through test stringsforeach str \$test {    set chars [dict create] ; # init dictionary    set same 1    set prev {}    # Loop through characters in string    for {set i 0} {\$i < [string length \$str]} {incr i} {        set c [string index \$str \$i] ; # get char at index        if {\$prev == {}} {            set prev \$c ; # initialize prev if it doesn't exist        }        if {\$c != \$prev} {            set same 0            break ; # Found a different char, break out of the loop        }    }     # Handle Output    puts [format "Tested: %12s (len: %2d). All Same? %3s. " \              "'\$str'" [string length \$str] \$yesno(\$same)]    if {! \$same} {        puts [format " --> Different character '%s' (hex: 0x%s) appears at index: %s." \                  \$c [binary encode hex \$c] \$i]    }}`
Output:
```Tested:           '' (len:  0). All Same? Yes.
Tested:        '   ' (len:  3). All Same? Yes.
Tested:          '2' (len:  1). All Same? Yes.
Tested:        '333' (len:  3). All Same? Yes.
Tested:        '.55' (len:  3). All Same?  No.
--> Different character '5' (hex: 0x35) appears at index: 1.
Tested:     'tttTTT' (len:  6). All Same?  No.
--> Different character 'T' (hex: 0x54) appears at index: 3.
Tested:  '4444 444k' (len:  9). All Same?  No.
--> Different character ' ' (hex: 0x20) appears at index: 4.
Tested:    'jjjjjjj' (len:  7). All Same? Yes.
```

## VBA

Instr is a VBA Function which process the strings from left─to─right.

The Optional argument LowerUpper As Boolean can display True for "tttTTT", if you want.

SameCharacters("tttTTT", respons, False) or SameCharacters("tttTTT", respons) return False

SameCharacters("tttTTT", respons, True) return True (All characters are the same)

` Sub Main_SameCharacters()Dim arr, i As Integer, respons As Integer    arr = Array("", "   ", "2", "333", ".55", "tttTTT", "4444 444k", "111111112", " 123")    For i = LBound(arr) To UBound(arr)        If SameCharacters(arr(i), respons) Then            Debug.Print "Analyze : [" & arr(i) & "], lenght " & Len(arr(i)) & " : " & " All characters are the same."        Else            Debug.Print "Analyze : [" & arr(i) & "], lenght " & Len(arr(i)) & " : " & " is different at position " & respons & ", character = '" & Mid(arr(i), respons, 1) & "', hexa : (0x" & Hex(Asc(Mid(arr(i), respons, 1))) & ")"        End If    NextEnd SubFunction SameCharacters(sTxt, resp As Integer, Optional LowerUpper As Boolean = False) As BooleanDim A As String, B As String, i As Integer, temp As Integer    If Len(sTxt) > 1 Then        If LowerUpper Then            SameCharacters = UCase(sTxt) = String\$(Len(sTxt), UCase(Left\$(sTxt, 1)))        Else            SameCharacters = sTxt = String\$(Len(sTxt), Left\$(sTxt, 1))        End If        If Not SameCharacters Then resp = InStr(sTxt, Left\$(Replace(sTxt, Left\$(sTxt, 1), vbNullString), 1))    Else        SameCharacters = True    End IfEnd Function`
Output:
```Analyze : [], lenght 0 :  All characters are the same.
Analyze : [   ], lenght 3 :  All characters are the same.
Analyze : , lenght 1 :  All characters are the same.
Analyze : , lenght 3 :  All characters are the same.
Analyze : [.55], lenght 3 :  is different at position 2, character = '5', hexa : (0x35)
Analyze : [tttTTT], lenght 6 :  is different at position 4, character = 'T', hexa : (0x54)
Analyze : [4444 444k], lenght 9 :  is different at position 5, character = ' ', hexa : (0x20)
Analyze : , lenght 9 :  is different at position 9, character = '2', hexa : (0x32)
Analyze : [ 123], lenght 4 :  is different at position 2, character = '1', hexa : (0x31)```

## Visual Basic .NET

Translation of: C#
`Module Module1     Sub Analyze(s As String)        Console.WriteLine("Examining [{0}] which has a length of {1}:", s, s.Length)        If s.Length > 1 Then            Dim b = s(0)            For i = 1 To s.Length                Dim c = s(i - 1)                If c <> b Then                    Console.WriteLine("    Not all characters in the string are the same.")                    Console.WriteLine("    '{0}' (0x{1:X02}) is different at position {2}", c, AscW(c), i - 1)                    Return                End If            Next        End If        Console.WriteLine("    All characters in the string are the same.")    End Sub     Sub Main()        Dim strs() = {"", "   ", "2", "333", ".55", "tttTTT", "4444 444k"}        For Each s In strs            Analyze(s)        Next    End Sub End Module`
Output:
```Examining [] which has a length of 0:
All characters in the string are the same.
Examining [   ] which has a length of 3:
All characters in the string are the same.
Examining  which has a length of 1:
All characters in the string are the same.
Examining  which has a length of 3:
All characters in the string are the same.
Examining [.55] which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 1
Examining [tttTTT] which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 3
Examining [4444 444k] which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 4```

## Wren

Translation of: Go
Library: Wren-fmt
`import "/fmt" for Conv, Fmt var analyze = Fn.new { |s|    var chars = s.codePoints.toList    var le = chars.count    System.print("Analyzing %(Fmt.q(s)) which has a length of %(le):")    if (le > 1) {        for (i in 1...le) {            if (chars[i] != chars[i-1]) {                System.print("  Not all characters in the string are the same.")                var c = String.fromCodePoint(chars[i])                var hex = Conv.hex(chars[i])                System.print("  '%(c)' (0x%(hex)) is different at position %(i+1).\n")                return            }        }    }    System.print("  All characters in the string are the same.\n")} var strings = [    "",    "   ",    "2",    "333",    ".55",    "tttTTT",    "4444 444k",    "pépé",    "🐶🐶🐺🐶",    "🎄🎄🎄🎄"]for (s in strings) analyze.call(s)`
Output:
```Analyzing "" which has a length of 0:
All characters in the string are the same.

Analyzing "   " which has a length of 3:
All characters in the string are the same.

Analyzing "2" which has a length of 1:
All characters in the string are the same.

Analyzing "333" which has a length of 3:
All characters in the string are the same.

Analyzing ".55" which has a length of 3:
Not all characters in the string are the same.
'5' (0x35) is different at position 2.

Analyzing "tttTTT" which has a length of 6:
Not all characters in the string are the same.
'T' (0x54) is different at position 4.

Analyzing "4444 444k" which has a length of 9:
Not all characters in the string are the same.
' ' (0x20) is different at position 5.

Analyzing "pépé" which has a length of 4:
Not all characters in the string are the same.
'é' (0xe9) is different at position 2.

Analyzing "🐶🐶🐺🐶" which has a length of 4:
Not all characters in the string are the same.
'🐺' (0x1f43a) is different at position 3.

Analyzing "🎄🎄🎄🎄" which has a length of 4:
All characters in the string are the same.
```

## XPL0

`include xpllib;                 \contains StrLen function proc    StrSame(S);             \Show if string has same characterschar    S;int     L, I, J, K;[L:= StrLen(S);IntOut(0, L);  Text(0, ":       ^"");  Text(0, S);  ChOut(0, ^");  CrLf(0);for I:= 0 to L-1 do    for J:= I+1 to L-1 do        [if S(I) # S(J) then                [ChOut(0, \tab\ 9);                for K:= 0 to J do ChOut(0, ^ );                Text(0, "^^ Not same character: ");                ChOut(0, S(J));                Text(0, ", hex ");                SetHexDigits(2);                HexOut(0, S(J));                CrLf(0);                return;                ];        ];Text(0, "       All same character");  CrLf(0);]; [Text(0, "Length");  CrLf(0);StrSame("");StrSame("   ");StrSame("2");StrSame("333");StrSame(".55");StrSame("tttTTT");StrSame("4444 444k");]`
Output:
```Length
0:      ""
All same character
3:      "   "
All same character
1:      "2"
All same character
3:      "333"
All same character
3:      ".55"
^ Not same character: 5, hex 35
6:      "tttTTT"
^ Not same character: T, hex 54
9:      "4444 444k"
^ Not same character:  , hex 20
```

## zkl

`fcn stringSameness(str){  // Does not handle Unicode   sz,unique,uz := str.len(), str.unique(), unique.len();   println("Length %d: \"%s\"".fmt(sz,str));   if(sz==uz or uz==1) println("\tSame character in all positions");   else      println("\tDifferent: ",        unique[1,*].pump(List,	   'wrap(c){ "'%s' (0x%x)[%d]".fmt(c,c.toAsc(), str.find(c)+1) })        .concat(", "));}`
`testStrings:=T("", "   ", "2", "333", ".55", "tttTTT", "4444 444k");foreach s in (testStrings){ stringSameness(s) }`
Output:
```Length 0: ""
Same character in all positions
Length 3: "   "
Same character in all positions
Length 1: "2"
Same character in all positions
Length 3: "333"
Same character in all positions
Length 3: ".55"
Different: '5' (0x35)
Length 6: "tttTTT"
Different: 'T' (0x54)
Length 9: "4444 444k"
Different: ' ' (0x20), 'k' (0x6b)
```