Determine if a string has all the same characters: Difference between revisions

Show all output here on this page.

 

<br><br>

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

procedure Test_All_Chars_Are_Same is

All_Chars_Are_Same ("tttTTT");

All_Chars_Are_Same ("4444 444k");

 

{{out}}

 

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

# return the position of the first different character in s #

# or UPB s + 1 if all the characters are the same #

IF d < 10

THEN REPR ( d + ABS "0" )

FI +=: result

OD

show first diff( ".55" );

show first diff( "tttTTT" );

{{out}}

<pre>

"tttTTT" (length 6): first different character "T"(0x54) at position: 4

"4444 444k" (length 9): first different character " "(0x20) at position: 5

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f DETERMINE_IF_A_STRING_HAS_ALL_THE_SAME_CHARACTERS.AWK

BEGIN {

}

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

{{out}}

<pre>

|-------------|--------|----------|----------|-----|----------|

</pre>

 

=={{header|C}}==

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

#include<string.h>

#include<stdio.h>

 

}

Output :

<pre>

First different character : " "(0x20) at position : 5

</pre>

 

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

{{trans|D}}

 

namespace AllSame {

}

}

{{out}}

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

 

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

 

size_t len = str.length();

std::cout << "input: \"" << str << "\", length: " << len << '\n';

char ch = str[0];

std::cout << "Not all characters are the same.\n";

return;

}

}

 

all_characters_are_the_same("");

all_characters_are_the_same(" ");

all_characters_are_the_same("4444 444k");

return 0;

 

{{out}}

Character ' ' (hex 20) at position 5 is not the same as '4'.

 

</pre>

 

(strequ) for auto-test

 

(if (not str) (setf str (list "" " " "2" "333" ".55" "tttTTT" "4444 444k")))

(dolist (s str)

(format t "\"~a\" [~d] : All characters are identical.~%" s (length s)) t)

((char/= (char s i) (char s 0))

 

{{out}}

=={{header|D}}==

{{trans|Kotlin}}

 

void analyze(string s) {

analyze(str);

}

{{out}}

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

Not all characters in the string are the same.

' ' (0x20) is different at position 3</pre>

 

=={{header|Factor}}==

 

: find-diff ( str -- i elt ) dup ?first [ = not ] curry find ;

"tttTTT"

"4444 444k"

{{out}}

<pre>

"tttTTT" — length 6 — contains a different character at index 3: 'T' (0x54)

"4444 444k" — length 9 — contains a different character at index 4: ' ' (0x20)

</pre>

 

=={{header|Go}}==

 

import "fmt"

analyze(s)

}

 

{{out}}

All characters in the string are the same.

</pre>

 

=={{header|Haskell}}==

import Data.List (span)

import Data.Char (ord)

 

inconsistentChar [] = Nothing

inconsistentChar xs@(x:_) =

c : "' (0x" ++ showHex (ord c) ")" ++ " at char " ++ show (succ n))

(inconsistentChar s)) <$>

 

and inconsistentChar could alternatively be defined in terms of ''findIndex'':

 

 

inconsistentChar [] = Nothing

{{Out}}

<pre> ' ' -> consistent

'4444 444' -> inconsistent ' ' (0x20) at char 5</pre>

 

 

 

 

 

<pre>

 

 

 

 

 

=={{header|Java}}==

public static void main(String[] args){

String[] tests = {"", " ", "2", "333", ".55", "tttTTT", "4444 444k"};

System.out.println("\tAll characters in the string are the same.");

}

{{out}}

 

'4' (0x34) is different at position 7

</pre>

 

=={{header|Julia}}==

 

function testfunction(strings)

"🎄🎄🎄🎄",

])

<pre>

String | Length | All Same | First Different(Hex) | Position

=={{header|Kotlin}}==

{{trans|Go}}

println("Examining [$s] which has a length of ${s.length}:")

if (s.length > 1) {

analyze(str)

}

{{out}}

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

 

=={{header|Lambdatalk}}==

{def firstDifferingChar

{def firstDifferingChar.r

{firstDifferingChar tttTTT}

-> at position 3 t becomes T

 

=={{header|Lua}}==

print(string.format("Examining [%s] which has a length of %d:", s, string.len(s)))

if string.len(s) > 1 then

end

 

{{out}}

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

Not all characters in the string are the same.

' ' (0x20) is different at position 4</pre>

 

=={{header|Nanoquery}}==

{{trans|Java}}

s = str(s)

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

for s in tests

analyze(s)

{{out}}

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

Not all characters in the string are the same.

' ' (0x20) is different at position 4</pre>

 

=={{header|Pascal}}==

{$IFDEF FPC}

{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=16}{$ALIGN 16}

For i := Low(TestData) to HIgh(TestData) do

OutIsAllSame(TestData[i]);

<pre>

"" of length 0 contains all the same character

 

=={{header|Perl}}==

use warnings;

use feature 'say';

say 'the same character in all positions.'

}

{{out}}

<pre>"" (length: 0) has the same character in all positions.

 

=={{header|Phix}}==

{{out}}

<pre>

"🎄🎄🎄🎄" (length 4): all characters are the same

</pre>

 

=={{header|PicoLisp}}==

(let (Lst (chop Str) C (car Lst) P 2 F)

(prin Str ": ")

(equal? "333")

(equal? ".55")

{{out}}

<pre>

.55: First different character 5 at position: 2

tttTTT: First different character T at position: 4

</pre>

 

 

{{Works with|Python|3.7}}

 

from itertools import groupby

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First, if any, points of difference:

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

 

 

from itertools import takewhile

# MAIN ---

if __name__ == '__main__':

 

Putting itertools aside, we could equivalently define ''inconsistentChar'' as:

 

def inconsistentChar(s):

'''Just the first inconsistent character and its index,

(Just(ix) for ix in enumerate(s) if s[0] != ix[1]),

Nothing()

{{Out}}

<pre>Consistency tests of seven strings:

'tttTTT' -> inconsistent 'T' (0x54) at char 4

'4444 444' -> inconsistent ' ' (0x20) at char 5</pre>

 

=={{header|Racket}}==

 

(define (first-non-matching-index l =)

 

(module+ test

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

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.

 

my $i = 0;

my %m;

%m{$_}.push: ++$i for $str.comb;

"\c[LATIN CAPITAL LETTER A WITH DIAERESIS]\c[COMBINING MACRON]" ~

"\c[LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON]",

{{out}}

<pre>"" (length: 0), has the same character in all positions.

 

=={{header|REXX}}==

@chr= ' [character' /* define a literal used for SAY.*/

@all= 'all the same character for string (length' /* " " " " " " */

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)*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

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

</pre>

 

=={{header|Ruby}}==

 

strings.each do |str|

puts pos ? "first different char #{str[pos].inspect} (#{'%#x' % str[pos].ord}) at position #{pos}." : "all the same."

end

{{out}}

<pre>"" (size 0): all the same.

 

=={{header|Rust}}==

println!("Checking string {:?} of length {}:", input, input.chars().count());

 

test_string(string);

}

{{out}}

<pre>

Checking string "🎄🎄🎄🎄" of length 4:

All characters in the string are the same

</pre>

 

=={{header|Scala}}==

 

object StringAllSameCharacters {

}

 

{{out}}

<pre>

 

=={{header|Sidef}}==

var chars = str.chars

chars.range.to_a.each_cons(2, {|a,b|

say "first different char '#{str[idx]}' (#{'%#x' % str[idx].ord}) at position #{idx}."

}

{{out}}

<pre>

'🐶🐶🐺🐶' (size 4): first different char '🐺' (0x1f43a) at position 2.

'🎄🎄🎄🎄' (size 4): all the same.

</pre>

 

=={{header|Standard ML}}==

datatype result=allSame | difference of string*char*int ;

val chkstring = fn input =>

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

("tttTTT", 6, difference ("54", #"T", 4)),

("4444 444k", 9, difference ("20", #" ", 5))]:

 

=={{header|Tcl}}==

 

array set yesno {1 Yes 0 No}

$c [binary encode hex $c] $i]

}

 

{{out}}

Tested: 'jjjjjjj' (len: 7). All Same? Yes.

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Analyze(s As String)

End Sub

 

{{out}}

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

' ' (0x20) is different at position 4</pre>

 

{{trans|Go}}

}

}

 

var analyze = Fn.new { |s|

var chars = s.codePoints.toList

var le = chars.count

if (le > 1) {

for (i in 1...le) {

System.print(" Not all characters in the string are the same.")

var c = String.fromCodePoint(chars[i])

System.print(" '%(c)' (0x%(hex)) is different at position %(i+1).\n")

return

"🎄🎄🎄🎄"

]

 

{{out}}

 

=={{header|XPL0}}==

 

proc StrSame(S); \Show if string has same characters

StrSame("tttTTT");

StrSame("4444 444k");

 

{{out}}

 

=={{header|zkl}}==

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

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

'wrap(c){ "'%s' (0x%x)[%d]".fmt(c,c.toAsc(), str.find(c)+1) })

.concat(", "));

{{out}}

<pre>