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

<langsyntaxhighlight lang="ada">

END</langsyntaxhighlight>

END FUNCTION</langsyntaxhighlight>

<langsyntaxhighlight AppleScriptlang="applescript">intercalate(", ", ¬

end tail</langsyntaxhighlight>

<langsyntaxhighlight lang="freebasic">txt$ = "gHHH5YY++///\\"

NEXT</langsyntaxhighlight>

<langsyntaxhighlight lang="bbcbasic">REM >split

= split$</langsyntaxhighlight>

<langsyntaxhighlight lang="c">#include <stdio.h>

}</langsyntaxhighlight>

<langsyntaxhighlight lang="csharp">using System;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="cpp">

}</langsyntaxhighlight>

<langsyntaxhighlight lang="clojure">(defn print-cchanges [s]

<langsyntaxhighlight lang="lisp">(defun split (string)

<langsyntaxhighlight lang="lisp">(defun split (string)

(split "gHHH5YY++///\\")</langsyntaxhighlight>

<langsyntaxhighlight Dlang="d">import std.stdio;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="dyalect">func String.smartSplitSmartSplit() {

var last = this.lenLength() - 1

print("gHHH5YY++///\\".smartSplitSmartSplit())</langsyntaxhighlight>

a$[] = str_split a$"gHHH5YY++///\\"

ca$[] = strchars a$[0]

for i rangecp$ len= a$[1]

for c$ ifin a$[i] <> c$

if bc$ &=<> ", "cp$

c s$ &= a$[i]", "

b$ &= a$[i].

print bs$</lang>

<langsyntaxhighlight lang="elixir">split = fn str ->

split.("gHHH5YY++///\\")</langsyntaxhighlight>

<langsyntaxhighlight lang="fsharp">open System.Text.RegularExpressions

printfn "%A" (splitRuns """gHHH5YY++///\""")</langsyntaxhighlight>

<langsyntaxhighlight lang="factor">USE: splitting.monotonic

"aaabbccccdeeff" [ [ = ] monotonic-split ", " join print ] bi@</langsyntaxhighlight>

<langsyntaxhighlight Forthlang="forth">CREATE A 0 ,

BYE</langsyntaxhighlight>

For this example a DO-loop stepping along the text is convenient, but in a larger context it would probably be most useful to work along the text with fingers L1 and L2 marking the start and finish positions of each sequence. <langsyntaxhighlight Fortranlang="fortran"> SUBROUTINE SPLATTER(TEXT) !Print a comma-separated list. Repeated characters constitute one item.

END</langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

}</langsyntaxhighlight>

<langsyntaxhighlight Haskelllang="haskell">import Data.List (group, intercalate)

main = putStrLn $ intercalate ", " (group "gHHH5YY++///\\")</langsyntaxhighlight>

<langsyntaxhighlight ISlang="is-BASICbasic">100 LET S$="gHHH5YY++///\"

160 PRINT</langsyntaxhighlight>

<langsyntaxhighlight lang="j">splitChars=: (1 ,~ 2 ~:/\ ]) <;.2 ]

delimitChars=: ', ' joinstring splitChars</langsyntaxhighlight>

<langsyntaxhighlight lang="j"> delimitChars 'gHHH5YY++///\'

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

}</langsyntaxhighlight>

<langsyntaxhighlight JavaScriptlang="javascript">(() => {

const concatmain = xs() =>

xs.length > 0 ? (group("gHHH5YY++///\\") => {

return unit.concat.applyjoin(unit", xs");

// groupByTuple (,) :: (a -> ab -> Bool) -> [(a], -> [[a]]b)

const groupByTuple = (f, xs)a => {

const dctb => xs.slice(1){

.reduce((atype: "Tuple", x) => {

"0": consta,

h = a.active.length > 0 ? a.active[0] "1": undefinedb,

length: blnGroup = h !== undefined && f(h2, x);

return*[Symbol.iterator]() {

for (const k in active: blnGroup ? a.active.concat([x]this) : [x],{

sofar:if blnGroup ? a.sofar : a.sofar.concat([a.active]!isNaN(k)) {

} yield this[k];

}, { }

active: xs.length > 0 ? [xs[0]] : [],}

sofar: []}

});

};// MAIN ---

const// mapmain =:: IO(f, xs) => xs.map(f);

intercalate(', ', xs.slice(i)

map(concat] : [xs, group(stringChars('gHHH5YY++///\\')))[]];

)};

<langsyntaxhighlight lang="jq"># input: a string

"gHHH5YY++///\\" | [runs] | join(", ")</langsyntaxhighlight>

<langsyntaxhighlight lang="javascript">#!/usr/bin/env jsish

;splitOnChange('gH HH5YY++//,/\\');</langsyntaxhighlight>

<langsyntaxhighlight lang="javascript">#!/usr/bin/env jsish

*/</langsyntaxhighlight>

<langsyntaxhighlight lang="julia"># v0.6

println("string: $str\nseparated: ", join(sep, ", "))</langsyntaxhighlight>

<langsyntaxhighlight scalalang="kotlin">// version 1.0.6

}</langsyntaxhighlight>

<langsyntaxhighlight Lualang="lua">function charSplit (inStr)

print(charSplit("gHHH5YY++///\\"))</langsyntaxhighlight>

<langsyntaxhighlight lang="lua">function splitdiff(s)

end</langsyntaxhighlight>

<langsyntaxhighlight Maplelang="maple">splitChange := proc(str::string)

splitChange("gHHH5YY++///\\");</langsyntaxhighlight>

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

<langsyntaxhighlight Mathematicalang="mathematica">StringJoin@@Riffle[StringCases["gHHH5YY++///\\", p : (x_) .. -> p], ", "]</langsyntaxhighlight>

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

<langsyntaxhighlight MiniScriptlang="miniscript">s = "gHHH5YY++///\"

print output.join("")</langsyntaxhighlight>

<langsyntaxhighlight lang="modula2">MODULE CharacterChange;

END CharacterChange.</langsyntaxhighlight>

<syntaxhighlight lang ="nim">proc splitOnDiff(str: string) : string =

var prevChar : char = str[0]

echo splitOnDiff("""gHHH5YY++///\""")</langsyntaxhighlight>

<langsyntaxhighlight lang="oorexx">Parse Arg str . /*obtain optional arguments from the CL*/

Say ol</langsyntaxhighlight>

<langsyntaxhighlight lang="perl">use strict;

}</langsyntaxhighlight>

=={{header|Perl 6Phix}}==

Original:["g, HHH, 5, YY, ++, ///, \", "gHHH5YY++///\"]

=={{header|PhixPicoLisp}}==

if length(in) then(glue

integer prev", = in[1]"

for i=1 to length(in) domake

integer(for chX = in[i]Str

(if ch!(=prev thenX (car Fin))

out &= ",(conc "Fin (cons X))

prev = ch(link (setq Fin (cons X))) ) ) ) ) ) )

<langsyntaxhighlight lang="purebasic">Procedure splitstring(s$)

EndIf</langsyntaxhighlight>

<langsyntaxhighlight lang="python">from itertools import groupby

print(f'Input: {txt}\nSplit: {splitter(txt)}')</langsyntaxhighlight>

<langsyntaxhighlight lang="python">def splitterz(text):

print(splitterz(txt))</langsyntaxhighlight>

<langsyntaxhighlight lang="python">import itertools

print(' output string: %s' % ', '.join(groups))</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">#lang racket

", "))</langsyntaxhighlight>

<langsyntaxhighlight lang="rexx">/*REXX program splits a string based on change of character ───► a comma delimited list.*/

say ' output string: ' $ /*stick a fork in it, we're all done. */</langsyntaxhighlight>

<langsyntaxhighlight lang="rexx">/* REXX */

say ' output string: ' result </langsyntaxhighlight>

<langsyntaxhighlight lang="ring">

<langsyntaxhighlight lang="ruby">def split(str)

split("gHHH5YY++///\\")</langsyntaxhighlight>

<langsyntaxhighlight Rustlang="rust">fn splitter(string: &str) -> String {

}</langsyntaxhighlight>

<langsyntaxhighlight Scalalang="scala">// Split a (character) string into comma (plus a blank) delimited strings

println(runLengthSplit("""gHHH5YY++///\"""))</langsyntaxhighlight>

<langsyntaxhighlight lang="sed">echo 'gHHH5YY++///\' | sed 's/\(.\)\1*/&, /g;s/, $//'</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">func group(str) {

say group(ARGV[0] \\ 'gHHH5YY++///\\').join(', ')</langsyntaxhighlight>

<langsyntaxhighlight lang="sml">(*

fun groupString str = String.concatWith ", " (map implode (group (explode str)))</langsyntaxhighlight>

<langsyntaxhighlight lang="swift">public extension String {

print("gHHH5YY++///\\".splitOnChanges().joined(separator: ", "))</langsyntaxhighlight>

<langsyntaxhighlight lang="basic">SUB SPLITUNIQUE$(s$)

END</langsyntaxhighlight>

<langsyntaxhighlight Tcllang="tcl">set string "gHHH5YY++///\\"

puts $string</langsyntaxhighlight>

<langsyntaxhighlight lang="lisp">(defun delimit (s)

(display (delimit "gHHH5YY++///\\")) ;; NB. The "\" character needs to be escaped</langsyntaxhighlight>

<langsyntaxhighlight XPL0lang="xpl0">string 0; \change to zero-terminated convention

]</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">fcn group(str){

group("gHHH5YY++///\\").println();</langsyntaxhighlight>

<langsyntaxhighlight lang="basic"> 10 LET s$="gHHH5YY++///\"

90 PRINT n$</langsyntaxhighlight>