Split a character string based on change of character: Difference between revisions

{{trans|C++}}

V res = ‘’

L(ch) input

R res

{{out}}

=={{header|8080 Assembly}}==

jmp demo

;;; Split the string under DE on changing characters,

jmp 5

string: db 'gHHH5YY++///',5Ch,'$'

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|8086 Assembly}}==

org 100h

section .text

string: db 'gHHH5YY++///\$'

section .bss

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program splitcar64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}<pre> gg, HHH, 5, YY, ++, ///, \ </pre>

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

BYTE i

CHAR curr,last

Test("gHHH5YY++///\")

Test("gHHH 5++,,,///\")

{{out}}

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

=={{header|Ada}}==

with Ada.Text_IO;

procedure Split is

Print_Tokens ("gHHH5YY+++");

end split;

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

# returns s with ", " added between each change of character #

PROC split on characters = ( STRING s )STRING:

print( ( split on characters( "gHHH5YY++///\" ), newline ) )

{{out}}

<pre>

=={{header|ANSI BASIC}}==

DECLARE EXTERNAL FUNCTION FN_split$

NEXT i

LET FN_split$ = split$

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> split 'gHHH5YY++///\'

===Functional===

{{Trans|JavaScript}}

map(curry(intercalate)'s |λ|(""), ¬

group("gHHH5YY++///\\")))

{}

end if

{{Out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

===Straightforward===

(Also case-sensitve.)

set len to (count input)

if (len < 2) then return input

-- Test code:

{{output}}

===ASObjC===

use framework "Foundation"

-- Test code:

{{output}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program splitcar.s */

output : gg, HHH, 5, YY, ++, ///, \

=={{header|Arturo}}==

loop split {gHHH5YY++///\} 'ch [

if? or? empty? current

]

'parts ++ current

{{out}}

=={{header|AutoHotkey}}==

for i, v in StrSplit(str)

res .= (v=prev) ? v : (res?", " :"") v , prev := v

return res

Outputs:<pre>g, HHH, 5, YY, ++, ///, \</pre>

===RegEx Version===

return RegExReplace(str, "(.)\1*(?!$)", "$0, ")

Outputs:<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|AWK}}==

# syntax: GAWK -f SPLIT_A_CHARACTER_STRING_BASED_ON_CHANGE_OF_CHARACTER.AWK

BEGIN {

return(new_str)

}

{{out}}

<pre>

=={{header|BaCon}}==

Literal strings in BaCon are passed to the C compiler as they are; a backslash therefore needs to be escaped.

c$ = LEFT$(txt$, 1)

END IF

PRINT d$;

{{out}}

<pre>

=={{header|BASIC256}}==

if length(instring$) < 2 then return instring$

ret$ = left(instring$,1)

end function

=={{header|BBC BASIC}}==

PRINT FN_split( "gHHH5YY++///\" )

END

split$ += d$

NEXT

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

*(counter--)='\0';

return realloc(result,strlen(result));

{{out}}

<pre>

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

using System.Linq;

using System.Collections.Generic;

public static string Delimit<T>(this IEnumerable<T> source, string separator = "") => string.Join(separator ?? "", source);

{{out}}

<pre>

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

// Solution for http://rosettacode.org/wiki/Split_a_character_string_based_on_change_of_character

#include<string>

int main(){

std::cout << split("gHHH5 ))YY++,,,///\\", ", ") << std::endl;

{{out}}

<pre>g, HHH, 5, , )), YY, ++, ,,,, ///, \</pre>

=={{header|Clojure}}==

(println (clojure.string/join ", " (map first (re-seq #"(.)\1*" s)))))

(print-cchanges "gHHH5YY++///\\")

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|CLU}}==

split_on_change = iter (s: string) yields (string)

part: string := ""

end

stream$putl(po, rslt)

{{out}}

<pre>g, HHH, 5, YYY, ++, ///, \</pre>

=={{header|COBOL}}==

identification division.

program-id. split-ch.

end program split-ch.

{{out}}

<pre>

=={{header|Common Lisp}}==

(loop :for prev := nil :then c

:for c :across string

(split "gHHH5YY++///\\")

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

Doing more work that what's being ask, the following solution builds a list of strings then output it:

(flet ((make-buffer ()

(make-array 0 :element-type 'character :adjustable t :fill-pointer t)))

(format t "~{~A~^, ~}"(nreverse result)))))

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Cowgol}}==

sub split(in: [uint8], buf: [uint8]): (out: [uint8]) is

print(split("gHHH5YY++//\\", &buf[0]));

{{out}}

<pre>g, HHH, 5, YY, ++, //, \</pre>

=={{header|D}}==

void main() {

}

writeln();

{{output}}

=={{header|Dyalect}}==

var c

var str = ""

}

{{out}}

=={{header|EasyLang}}==

a$[] = strchars a$

cp$ = a$[0]

s$ &= c$

.

{{out}}

<pre>

=={{header|Elixir}}==

IO.puts " input string: #{str}"

String.graphemes(str)

end

{{out}}

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

let splitRuns s = Regex("""(.)\1*""").Matches(s) |> Seq.cast<Match> |> Seq.map (fun m -> m.Value) |> Seq.toList

{{out}}

<pre>["g"; "HHH"; "5"; "YY"; "++"; "///"; "\"]</pre>

=={{header|Factor}}==

"gHHH5YY++///\\"

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth|0.7.3}}

: C@A+ A @ C@ [ 1 CHARS ]L A +! ;

: SPLIT. ( c-addr u --) SWAP A ! A @ C@

s" gHHH5YY++///\" TEST

s" gHHH5 ))YY++,,,///\" TEST

{{out}}

<pre>input: gHHH5YY++///\

If the problem were to be solved by writing a "main line" only, there would have to be a declaration of the text variable there but since a subroutine can receive a CHARACTER variable of any size (the actual size is passed as a secret parameter), this can be dodged.

Can't display the inserted commas in a different colour so as not to look like any commas in TEXT.

CHARACTER*(*) TEXT !The text.

PROGRAM POKE

CALL SPLATTER("gHHH5YY++///\") !The example given.

Unfortunately, the syntax highlighter has failed to notice the terminating quote character, presumably because the preceding backslash might be an "escape sequence" trigger, a facility ''not'' used in Fortran text ''literals'' except possibly as a later modernist option.

=={{header|FreeBASIC}}==

if len(instring) < 2 then return instring

dim as string ret = left(instring,1)

next i

return ret

=={{header|Frink}}==

{{out}}

<pre>

=={{header|FutureBasic}}==

FB can process either Pascal strings (slowly being deprecated), or Apple's Core Foundation CFStrings (and Objective-C NSStrings). Here's the old-school Pascal string function:

local fn SplitString( inputStr as Str255 ) as Str255

Str255 resultStr

HandleEvents

And here's the recommended CFString counterpart:

local fn SplitString( inputStr as CFStringRef ) as CFStringRef

NSUInteger i

HandleEvents

'''Output for either function:'''

<pre>

=={{header|Go}}==

Treating "character" as a byte:

import (

}

return b.String()

{{out}}

<pre>

=={{header|Haskell}}==

main :: IO ()

{{Out}}

or as a hand-written fold:

import Data.Bool (bool)

main :: IO ()

main =

<pre>g, HHH, 5, YY, ++, ///, \</pre>

or in terms of '''span''':

charGroups :: String -> [String]

main :: IO ()

main =

{{Out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|IS-BASIC}}==

110 PRINT S$(1);

120 FOR I=2 TO LEN(S$)

140 PRINT S$(I);

150 NEXT

=={{header|J}}==

'''Solution:'''

'''Example Usage:'''

=={{header|Java}}==

import java.util.ArrayList;

return output.toString();

}

{{Out}}

===ES6===

{{Trans|Haskell}}

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

Or, in terms of a general `span` function:

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|jq}}==

# output: a stream of runs

def runs:

end;

{{out}}

Using the -r ("raw output") command-line option of jq:

Starting with

;'Split a string based on change of character, in Jsish';

;splitOnChange('aaa');

;splitOnChange('aaaba');

Then

Giving

;'Split a string based on change of character, in Jsish';

splitOnChange('gH HH5YY++//,/\') ==> g, H, , HH, 5, YY, ++, //, ,, /, \

=!EXPECTEND!=

Which tests as:

=={{header|Julia}}==

using IterTools

str = "gHHH5YY++///\\"

sep = map(join, groupby(identity, str))

{{out}}

=={{header|Kotlin}}==

fun splitOnChange(s: String): String {

val s = """gHHH5YY++///\"""

println(splitOnChange(s))

{{out}}

=={{header|Lambdatalk}}==

{def mysplit

{def mysplit.r

{mysplit gHHH5YY++///\}

-> g HHH 5 YY ++ /// \

=={{header|Lua}}==

Note that the backslash must be quoted as a double backslash as Lua uses C-like escape sequences.

local outStr, nextChar = inStr:sub(1, 1)

for pos = 2, #inStr do

end

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

'''Alternative:'''

Simply scan difference in reverse order and insert delimiter in place, the loop counter i will not update with length of s.

for i=#s,2,-1 do

if s:sub(i,i)~=s:sub(i-1,i-1) then

end

return s

=={{header|Ksh}}==

#!/bin/ksh

print "Original: ${str}"

print " Split: $(_splitonchg "${str}" "${delim}")"

{{out}}<pre>

Original: gHHH5YY++///\

Stack New open a new stack object as current stack, and keep the old one. After the end of block execution old stack get back as current stack. Data statement push to bottom (we read from top, so using data we get a FIFO type). Letter$ pops a string or raise an error if no string found at the top of stack.

Module PrintParts(splitthis$) {

Def string m$, p$

}

PrintParts "gHHH5YY++///\"

=={{header|Maple}}==

Added an additional backlash to escape the \ character at the end.

local start,i,len;

start := 1;

printf("%s", str[start..len]);

end proc;

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

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

The backslash (\) must be escaped with another backslash when defining the string.

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|MiniScript}}==

output = []

lastLetter = s[0]

lastLetter = letter

end for

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Modula-2}}==

FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;

ReadChar

{{out}}

<pre>g

=={{header|Nim}}==

result = ""

assert splitOnDiff("""gHHH5YY++///\""") == """g, HHH, 5, YY, ++, ///, \"""

{{output}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|ooRexx}}==

If str=='' Then str= 'gHHH5YY++///\' /*Not specified? Then use the default.*/

i=1

i=j

End

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Pascal}}==

{$IFDEF FPC}

{$MODE DELPHI}{$COPERATORS ON}

BEGIN

writeln(SplitAtChars(TestString));

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Perl}}==

use warnings;

use feature 'say';

}

say "Orginal: $string\n Split: 「" . join('」, 「', @S) . "」\n";

{{out}}

<pre>Orginal: gHHH5YY++///\

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">split_on_change</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">split_on_change</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`gHHH5YY++///\`</span><span style="color: #0000FF;">))</span>

{{Out}}

<pre>

=={{header|PicoLisp}}==

(let (Str (chop Str) Fin)

(glue

(conc Fin (cons X))

(link (setq Fin (cons X))) ) ) ) ) ) )

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Pike}}==

string input = "gHHH5YY++///\\"; // \ needs escaping

string last_char;

}

{{Out}}

<pre>

After executing the following code, for example:

The rider looks like this:

Source: "abcdef"

Now when we <code>Bump the rider.</code>, it looks like this:

Source: "bcdef"

Another bump, and:

Source: "cdef"

Now let's say we have a complete token and want to start a new one. We can

and now the rider looks like this:

Source: "cdef"

And that's all there is to it.

Start up.

Split "gHHH5YY++///\" into some string things by change of character.

If the string thing's next is not nil, write ", " on the console without advancing.

Put the string thing's next into the string thing.

{{out}}

<pre>

=={{header|PowerShell}}==

{{trans|BBC BASIC}}

function Split-String ([string]$String)

{

$splitString

}

Split-String "gHHH5YY++///\"

{{Out}}

<pre>

=={{header|PureBasic}}==

Define *p.Character = @s$,

c_buf.c = *p\c

splitstring("gHHH5YY++///\")

Input()

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

===Python3.6+===

Using [[https://docs.python.org/3.6/library/itertools.html#itertools.groupby itertools.groupby]].

def splitter(text):

if __name__ == '__main__':

txt = 'gHHH5YY++///\\' # Note backslash is the Python escape char.

{{out}}

===Python: Using zip===

return (''.join(x + ('' if x == nxt else ', ')

for x, nxt in zip(txt, txt[1:] + txt[-1])))

if __name__ == '__main__':

txt = 'gHHH5YY++///\\'

{{out}}

===Python2===

try: input = raw_input

groups.append(''.join(g))

print(' input string: %s' % s)

{{out}} &nbsp; when using the default input:

<pre>

=={{header|Quackery}}==

iff size done

behead swap

dip [ $ ", " join ]

recurse join ] is runs$ ( $ --> $ )

'''Testing in Quackery shell.'''

<pre>/O> $ "gHHH5YY++///\" runs$ echo$

=={{header|Racket}}==

{{trans|Python}}

(define (split-strings-on-change s)

(map list->string (group-by values (string->list s) char=?)))

<

)

{{out}}

{{works with|Rakudo|2017.05}}

# Testing:

put 'Original: ', $string;

put ' Split: ', group-chars($string).join(', ');

{{out}}

=={{header|REXX}}==

===version 1===

parse arg str /*obtain optional arguments from the CL*/

if str=='' then str= 'gHHH5YY++///\' /*Not specified? Then use the default.*/

end /*j*/ /* [↓] keep peeling chars until done. */

say ' input string: ' str /*display the original string & output.*/

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

<pre>

===version 2===

Parse arg str /*obtain optional arguments from the CL*/

if str=='' then str= 'gHHH5YY++///\' /*Not specified? Then use the default.*/

result=result||x

say ' input string: ' input

{{out]]

<pre> input string: gHHH5YY++///\

=={{header|Ring}}==

see split("gHHH5YY++///\")

next

return split

Output:

<pre>

=={{header|Ruby}}==

puts " input string: #{str}"

s = str.chars.chunk(&:itself).map{|_,a| a.join}.join(", ")

end

{{out}}

=={{header|Rust}}==

let chars: Vec<_> = string.chars().collect();

let mut result = Vec::new();

println!("input string: {}", test_string);

println!("output string: {}", splitter(test_string));

{{out}}

===Alternate using IterTools===

pub fn split_text(s: &str) -> Vec<String> {

}

}

=={{header|Scala}}==

// based on a change of character (left to right).

// See https://rosettacode.org/wiki/Split_a_character_string_based_on_change_of_character#Scala

(s + 'X').sliding(2).map(pair => pair.head + (if (pair.head != pair.last) ", " else "")).mkString("")

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/c4dp8GT/2 ScalaFiddle (JavaScript)]

or by [https://scastie.scala-lang.org/mDoBS77YSG2Z7w5xdAPzcw Scastie (JVM)].

def runLengthSplit(s:String):List[String] = {

def recursiveSplit(acc:List[String], rest:String): List[String] = rest match {

val result = runLengthSplit("""gHHH5YY++///\""")

println(result.mkString(","))

{{Out}}

<pre>

=={{header|Sed}}==

Output:

g, HHH, 5, YY, ++, ///, \

=={{header|Sidef}}==

gather {

while (var match = (str =~ /((.)\g{-1}*)/g)) {

}

{{out}}

<pre>

=={{header|SNOBOL4}}==

{{works with|SNOBOL4, SPITBOL for Linux}}

* Program: split_on_change_of_character.sbl

* To run: sbl split_on_change_of_character.sbl

output = split_string

{{out}}

<pre>

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

* Head-Tail implementation of grouping

*)

fun group xs = group' nil xs

{{out}}

=={{header|Swift}}==

func splitOnChanges() -> [String] {

guard !isEmpty else {

}

{{out}}

=={{header|Tailspin}}==

composer splitEquals

<reps> <nextReps>*

'gHHH5YY++///\' -> splitEquals -> !OUT::write

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|tbas}}==

{{Trans|BBC BASIC}}

DIM c$, d$, split$, i%

c$ = LEFT$(s$, 1)

PRINT SPLITUNIQUE$("gHHH5YY++///\")

=={{header|Tcl}}==

This is most concise with regular expressions. Note well the two steps: it could be achieved in one very clever regexp, but being that clever is usually a bad idea (for both readability and performance, in this case).

regsub -all {(.)\1*} $string {\0, } string

regsub {, $} $string {} string

{{out}}

=={{header|VBA}}==

Option Explicit

Split_Special = R

End Function

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>

=={{header|Wren}}==

if (s.count == 0) return ""

var res = []

var s = "gHHH5YY++///\\"

{{out}}

=={{header|XLISP}}==

(defun delim (old-list new-list current-char)

(if (null old-list)

(list->string (delim (string->list s) '() (car (string->list s)))) )

{{out}}

<pre>g, HHH, 5, YY, ++, ///, \</pre>