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

{{trans|Kotlin}}

 

print(‘Examining [’s‘] which has a length of ’s.len‘:’)

I s.len > 1

V strs = [‘’, ‘ ’, ‘2’, ‘333’, ‘.55’, ‘tttTTT’, ‘4444 444k’]

L(s) strs

 

{{out}}

Not all characters in the string are the same.

' ' (0x20) is different at position 4

</pre>

 

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

 

"", " ", "2", "333", ".55", "tttTTT",

"4444 444k", "pépé", "🐶🐶🐺🐶", "🎄🎄🎄🎄"

if? null? firstNotSame -> print "all the same."

else -> print ~"first different char `|get s firstNotSame|` at position |firstNotSame|."

 

{{out}}

 

=={{header|AutoHotkey}}==

for key, str in testCases {

MsgBox % "Examining `'" str "`' which has a length of " StrLen(str) ":`n"

}

}

{{out}}

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

 

=={{header|BASIC}}==

10 'SAVE"SAMECHAR", A

20 DEFINT A-Z

250 WEND

260 IF DC$="" THEN I=1

{{out}}

<pre>

==={{header|QuickBASIC}}===

Works with QBASIC, VB-DOS, PDS 7.x

DECLARE SUB DifChar (sString AS STRING, wc AS INTEGER, dc AS STRING)

 

END SUB

 

{{out}}

<pre>

 

=={{header|BCPL}}==

 

let diffchar(s) = valof

show("tttTTT")

show("4444 444k")

{{out}}

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

"tttTTT" (length 6): 'T' at index 4.

"4444 444k" (length 9): ' ' at index 5.</pre>

 

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

 

}

Output :

<pre>

</pre>

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

* @param s the given string, NULL terminated.

*

*

*

* @warning This function compare characters (single-bytes, unicode etc.).

* @param s the given NULL terminated string.

*/

{

#ifdef WIDE_CHAR

if (argc < 2)

{

}

else

{

}

 

return EXIT_SUCCESS;

 

{{output}}

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

if (str[i] != ch) {

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

return;

}

all_characters_are_the_same("4444 444k");

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(defn check-all-chars-same [s]

(println (format "String (%s) of len: %d" s (count s)))

"tttTTT"

"4444 444k"])

 

{{out}}

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

{{libheader| System.SysUtils}}

{{Trans|D}}

program Determine_if_a_string_has_all_the_same_characters;

 

Analyze(w);

Readln;

{{out}}

<pre>

" " 0x20 is different at position 5

</pre>

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

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

let fN n=if String.length n=0 then None else n.ToCharArray()|>Array.tryFindIndex(fun g->g<>n.[0])

allSame "tttTTT"

allSame "4444 444k"

{{out}}

<pre>

First different character in <<<4444 444k>>> (length 9) is hex 20 at position 4

</pre>

=={{header|Factor}}==

 

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

"tttTTT"

"4444 444k"

{{out}}

<pre>

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

</pre>

 

=={{header|FreeBASIC}}==

 

input "Enter string: ", s

 

'otherwise, success!

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

analyze(s)

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

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

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

}

{{out}}

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

 

=={{header|Haskell}}==

import Data.List (span)

import Data.Char (ord)

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

(inconsistentChar s)) <$>

 

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

 

 

inconsistentChar :: Eq a => [a] -> Maybe (Int, a)

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

 

</pre>

 

 

=={{header|JavaScript}}==

const arr = [...s];

const at = arr.findIndex(

}

 

{{out}}<pre>

"" => Length:0 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';

// MAIN ---

return main()

{{Out}}

<pre>First inconsistent character:

 

 

 

def firstdifferent:

| [lpad(10), length, ($d == null)] + (if $d then [$d, .[$d:$d+1]] else null end) )

| @tsv

{{out}}

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

"4444 444k" 9 false 4

"🐶🐶🐺🐶" 4 false 2 🐺

 

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

 

=={{header|Maple}}==

local i, index;

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

CheckSame(".55");

CheckSame("tttTTT");

{{out}}

<pre>

 

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

AllSameCharacters[s_String] := Module[{c = Characters[s], i = 0, tf},

If[Length[c] > 1,

AllSameCharacters[".55"]

AllSameCharacters["tttTTT"]

{{out}}

<pre>input = "", Length = 0, All the same!

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

 

=={{header|Nim}}==

 

proc analyze(str: string) =

var strings = @["", " ", "2", "333", ".55", "tttTTT", "4444 444k"]

for str in strings:

{{out}}

<pre>'': [len: 0] all characters are the same

=={{header|OCaml}}==

Original version by [http://rosettacode.org/wiki/User:Vanyamil User:Vanyamil]

(* Task: Determine if a string has all the same characters *)

 

|> List.iter format_answer

;;

{{out}}

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

 

=={{header|Plain English}}==

Start up.

Show the uniformity of "".

If the count is -1, write "contains all the same character." on the console; exit.

Convert the byte to a nibble string.

{{out}}

<pre>

{{works with|SWI-Prolog|7}}

 

:- system:set_prolog_flag(double_quotes,chars) .

 

.

 

 

{{out}}

 

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

=={{header|Quackery}}==

 

[ 0 swap

dup size 0 = iff

$ ".55" task

$ "tttTTT" task

 

{{out}}

 

=={{header|R}}==

{

{

#R has a distinction between the length of a string and that of a character vector. It is a common source

stop("This task is intended for character vectors with lengths of at most 1.")

}

{

cat("Examining a character vector of length 0.\n")

TRUE

}

{

cat("Examining a character vector of length 1, containing an empty string.\n")

"which is of length", paste0(strLength, ":"), "\n")

#strsplit outputs a list. Its first element is the vector of characters that we desire.

#Our use of match is using R's vector recycling rules. Every element is being checked

#against the first.

{

cat("It has no duplicates.\n")

{

cat("It has duplicates. ")

cat(sQuote(firstDifferentCharacter), "is the first different character. It has hex value",

sprintf("0x%X", as.integer(charToRaw(firstDifferentCharacter))),

print(isAllSame("tttTTT"))

cat("Test: A string of length 9 which contains 4444 444k:\n")

{{out}}

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

 

=={{header|Racket}}==

 

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

 

(module+ test

 

{{out}}

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;

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

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

 

=={{header|Ring}}==

nputStr = [""," ","2","333",".55","tttTTT","4444 444k"]

 

? " All characters are the same."

next

{{out}}

<pre>

Input = '4444 444k', length = 9

First difference at position 5, character = ' '

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

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

 

Sub Main_SameCharacters()

Dim arr, i As Integer, respons As Integer

SameCharacters = True

End If

{{out}}

<pre>Analyze : [], lenght 0 : All characters are the same.

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

{{trans|C#}}

 

Sub Analyze(s As String)

End Sub

 

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

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var analyze = Fn.new { |s|

"🎄🎄🎄🎄"

]

 

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