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

 

=={{header|Action!}}==

BYTE ARRAY hex=['0 '1 '2 '3 '4 '5 '6 '7 '8 '9 'A 'B 'C 'D 'E 'F]

 

Test("tttTTT")

Test("4444 444k")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Determine_if_a_string_has_all_the_same_characters.png Screenshot from Atari 8-bit computer]

 

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

show first diff( "4444 444k" );

show first diff( "4444|444k" )

{{out}}

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

==={{header|Applesoft BASIC}}===

20 LET Q$ = CHR$ (34)

30 HOME

240 LET C$ = MID$ (S$,I,1)

250 LET SAME = C$ = ""

{{out}}

<pre>

==={{header|GWBASIC}}===

Works with BASICA

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.

 

Hex function is pieced together from BQNcrate idioms.

Hex←⊏⟜(∾"0A"+⟜↕¨10‿26)16{⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}

 

"tttTTT"

"4444 444k"

All characters are the same

All characters are the same

'5' (hex: 35, index: 0) mismatched in string '.55'

'T' (hex: 54, index: 2) mismatched in string 'tttTTT'

 

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

 

return EXIT_SUCCESS;

 

{{output}}

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

{{trans|D}}

 

namespace AllSame {

}

}

{{out}}

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

 

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

#include <string>

 

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>

</pre>

=={{header|Erlang|Erlang}}==

-module(string_examples).

-export([examine_all_same/1, all_same_examples/0]).

"🎄🎄🎄🎄"],

lists:foreach(fun examine_all_same/1, Strings).

{{out}}

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

 

=={{header|Factor}}==

 

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

"tttTTT"

"4444 444k"

{{out}}

<pre>

fancier format statement would eliminate the need for the HEX()

procedure.

program demo_verify

implicit none

 

end program demo_verify

{{out}}

<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

Here's a relatively concise (and grammatical) approach. For grammatical reasons we report the count of characters up through the differing character position, rather than its index:

 

task=: {{

if. 1>:#t=. ~.y do.

echo '"',ch,'" (hex: ',(hfd 3 u:ch),', character ',j,' of ',(":#y),') differs from previous characters in "',y,'"'

end.

 

And here's the task examples with this approach:

 

all 0 character(s) same in ""

all 3 character(s) same in " "

"5" (hex: 35, character 2 of 3) differs from previous characters in ".55"

"T" (hex: 54, character 4 of 6) differs from previous characters in "tttTTT"

 

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

 

 

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">samechar</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">utf8_to_utf32</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"🐶🐶🐺🐶"</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">utf8_to_utf32</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"🎄🎄🎄🎄"</span><span style="color: #0000FF;">)}</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> <span style="color: #000000;">samechar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

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

{

strLength <- nchar(string)

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>

 

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

 

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

This is not a particularly efficient solution, but it gets the job done.

 

/*

This code is an implementation of "Determination if a string has all the same characters" in SQL ORACLE 19c

select same_characters_in_string('4444 444k') as res from dual

;

 

{{out}}

 

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

=={{header|Vlang}}==

{{trans|Go}}

chars := s.runes()

le := chars.len

analyze(s)

}

 

{{out}}

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