Multisplit: Difference between revisions

 

'''Extra Credit:''' provide information that indicates which separator was matched at each separation point and where in the input string that separator was matched.

 

=={{header|Ada}}==

multisplit.adb:

with Ada.Text_IO;

 

Pos := String_Lists.Next (Pos);

end loop;

 

{{out}}

 

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

 

# MODE to hold the split results #

SPLITINFO token = test tokens[ t ];

print( ( "token: [", text OF token, "] at: ", whole( position OF token, 0 ), " delimiter: (", delimiter OF token, ")", newline ) )

{{out}}

<pre>

token: [c] at: 10 delimiter: ()

</pre>

 

=={{header|AutoHotkey}}==

Sep := ["==","!=", "="]

Res := StrSplit(Str, Sep)

for k, v in Sep

N .= (N?"|":"") "\Q" v "\E"

{{out}}

<pre>a,,b,,c

 

=={{header|AWK}}==

# syntax: GAWK -f MULTISPLIT.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

separators: '!=' '==' '=' '!='

</pre>

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

sep$() = "==", "!=", "="

PRINT "String splits into:"

ENDIF

UNTIL m% = LEN(s$)

{{out}}

<pre>

=={{header|Bracmat}}==

This is a surprisingly difficult task to solve in Bracmat, because in a naive solution using a alternating pattern ("=="|"!="|"=") the shorter pattern <code>"="</code> would have precedence over <code>"=="</code>. In the solution below the function <code>oneOf</code> iterates (by recursion) over the operators, trying to match the start of the current subject string <code>sjt</code> with one operator at a time, until success or reaching the end of the list with operators, whichever comes first. If no operator is found at the start of the current subject string, the variable <code>nonOp</code> is extended with one byte, thereby shifting the start of the current subject string one byte to the right. Then a new attempt is made to find an operator. This is repeated until either an operator is found, in which case the unparsed string is restricted to the part of the input after the found operator, or no operator is found, in which case the <code>whl</code> loop terminates.

= operator

. !arg:%?operator ?arg

& put$!unparsed

& put$\n

{{out}}

<pre>a {!=} {==} b {=} {!=} c</pre>

=={{header|C}}==

What kind of silly parsing is this?

#include <string.h>

 

 

return 0;

 

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

'''Extra Credit Solution'''

 

using System.Collections.Generic;

using System.Linq;

}

}

 

{{out}}

<pre>a{"!=", (1, 3)}{"==", (3, 5)}b{"=", (6, 7)}{"!=", (7, 9)}c

</pre>

 

=={{header|CoffeeScript}}==

multi_split = (text, separators) ->

# Split text up, using separators to break up text and discarding

console.log multi_split 'a!===b=!=c', ['==', '!=', '='] # [ 'a', '', 'b', '', 'c' ]

console.log multi_split '', ['whatever'] # [ '' ]

 

=={{header|D}}==

 

string[] multiSplit(in string s, in string[] divisors) pure nothrow {

.join(" {} ")

.writeln;

{{out}} (separator locations indicated by braces):

<pre>a {} {} b {} {} c</pre>

 

=={{header|Elixir}}==

{{trans|Erlang}}

 

=={{header|Erlang}}==

["a",[],"b",[],"c"]

</pre>

 

=={{header|FreeBASIC}}==

FreeBASIC does not have a built in 'split' function so we need to write one:

 

Sub Split(s As String, sepList() As String, result() As String, removeEmpty As Boolean = False, showSepInfo As Boolean = False)

Print

Print "Press any key to quit"

 

{{out}}

5 : c

</pre>

 

=={{header|Go}}==

 

import (

func main() {

fmt.Printf("%q\n", ms("a!===b=!=c", []string{"==", "!=", "="}))

{{out}}

<pre>

 

=={{header|Haskell}}==

 

case filter (`isPrefixOf` s) delims of

[] -> Nothing

 

main :: IO ()

main = do

mapM_

putStrLn

{{out}}

<pre>split string:

Or as a fold:

 

import Data.Bool (bool)

 

in reverse $ (ts, [], length s) : ps

main :: IO ()

{{Out}}

<pre>[("a","!=",1),("","==",3),("b","=",6),("","!=",7),("c","",10)]</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

s := "a!===b=!=c"

# just list the tokens

procedure arb()

suspend .&subject[.&pos:&pos <- &pos to *&subject + 1]

 

{{out}}

 

=={{header|J}}==

end.

 

Explanation:

 

 

Then, loop through the possibilities, skipping over those separators which would overlap with previously used separators.

 

 

Example use:

 

S multisplit '=';'!=';'=='

'X123Y' multisplit '1';'12';'123';'23';'3'

 

=={{header|Java}}==

 

public class MultiSplit {

return result;

}

 

<pre>Regex split:

Based on Ruby example.

{{libheader|Underscore.js}}

return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");

}

var sep_regex = RegExp(_.map(seps, function(sep) { return RegExp.escape(sep); }).join('|'));

return string.split(sep_regex);

 

===ES6===

 

{{Trans|Haskell}} (Multisplit by fold example)

 

/// Delimiter list -> String -> list of parts, delimiters, offsets

multiSplit(delims, strTest)

);

{{Out}}

<pre>[

Both helper functions could be made inner functions of the main function, but are kept separate here for clarity.

 

# a single character from the input string.

# The input should be a nonempty string, and delims should be

then .[0:length-1] + [ .[length-1] + $x ]

else . + [$x]

'''Examples'''

("a!===b=!=c",

=={{header|Julia}}==

From REPL:

julia> split(s, r"==|!=|=")

5-element Array{SubString{String},1}:

""

"c"

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println("\nThe delimiters matched and the indices at which they occur are:")

println(matches)

 

{{out}}

=={{header|Lua}}==

The function I've written here is really excessive for this task but it has historically been hard to find example code for a good Lua split function on the Internet. This one behaves the same way as Julia's Base.split and I've included a comment describing its precise operation.

Returns a table of substrings by splitting the given string on

occurrences of the given character delimiters, which may be specified

for k, v in pairs(multisplit) do

print(k, v)

{{Out}}

<pre>Key Value

Code from BBC BASIC with little changes to fit in M2000.

 

Module CheckIt {

DIM sep$()

}

CheckIt

 

Just use the built-in function "StringSplit":

{{Out}}

<pre>{a,,b,,c}</pre>

 

=={{header|MiniScript}}==

result = []

startPos = 0

end function

 

{{Out}}

<pre>["a", "{!=}", "", "{==}", "b", "{=}", "", "{!=}"]</pre>

 

=={{header|Nim}}==

var i, lastMatch = 0

while i < text.len:

for j, s in sep:

if text[i..text.high].startsWith s:

yield (s, true)

lastMatch = i + s.len

break

inc i

for token, isSep in "a!===b=!=c".tokenize(["==", "!=", "="]):

if isSep: stdout.write '{',token,'}'

else: stdout.write token

{{out}}

<pre>a{!=}{==}b{=}{!=}c</pre>

=={{header|Perl}}==

 

my ($sep, $string, %opt) = @_ ;

$sep = join '|', map quotemeta($_), @$sep;

print "\n";

print "'$_' " for multisplit ['==','!=','='], "a!===b=!=c", keep_separators => 1;

 

{{Out}}

'a' '!=' '' '==' 'b' '=' '' '!=' 'c'

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(setq Sep (mapcar chop Sep))

(make

 

(println (multisplit "a!===b=!=c" '("==" "!=" "=")))

{{out}}

<pre>("a" (1 "!=") NIL (3 "==") "b" (6 "=") NIL (7 "!=") "c")

 

=={{header|Pike}}==

array sep = ({"==", "!=", "=" });

 

 

result;

 

=={{header|PowerShell}}==

$string = "a!===b=!=c"

$separators = [regex]"(==|!=|=)"

 

$matchInfo

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog.

{!},

[].

my_sort(<, (N, N1, _), (N, N2, _)) :-

N1 > N2.

{{out}}

<pre>?- multisplit(['==', '!=', '='], 'ax!===b=!=c', Lst, []).

 

=={{header|Python}}==

>>> def ms2(txt="a!===b=!=c", sep=["==", "!=", "="]):

if not txt or not sep:

['a', (1, 1), '', (0, 3), 'b', (2, 6), '', (1, 7), 'c']

>>> ms2(txt="a!===b=!=c", sep=["=", "!=", "=="])

 

'''Inspired by C-version'''

lastmatch = i = 0

matches = []

>>> multisplit('a!===b=!=c', ['!=', '==', '='])

['a', (0, 1), (1, 3), 'b', (2, 6), (0, 7), 'c']

 

'''Alternative version'''

return List.index(min(List))

 

S = "a!===b=!=c"

multisplit(S, ["==", "!=", "="]) # output: ['a', [1, 1], '', [0, 3], 'b', [2, 6], '', [1, 7], 'c']

 

=={{header|Racket}}==

 

#lang racket

(regexp-match* #rx"==|!=|=" "a!===b=!=c" #:gap-select? #t #:match-select values)

;; => '("a" ("!=") "" ("==") "b" ("=") "" ("!=") "c")

 

=={{header|REXX}}==

parse arg $ /*obtain optional string from the C.L. */

if $='' then $= "a!===b=!=c" /*None specified? Then use the default*/

$=changestr(null, $, showNull) /* ··· showing of "null" chars. */

say 'new string:' $ /*now, display the new string to term. */

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>'''output''' &nbsp; when using the default input:

 

=={{header|Ring}}==

# Project : Multisplit

 

see "" + n + ": " + substr(str, 1, pos-1) + " Sep By: " + sep[n] + nl

next

Output:

<pre>

The simple method, using a regular expression to split the text.

 

separators = ['==', '!=', '=']

 

 

p multisplit_simple(text, separators) # => ["a", "", "b", "", "c"]

 

The version that also returns the information about the separations.

 

sep_regex = Regexp.union(separators)

separator_info = []

 

p multisplit(text, separators)

 

Also demonstrating a method to rejoin the string given the separator information.

 

str = info[0].zip(info[1])[0..-2].inject("") {|str, (piece, (sep, idx))| str << piece << sep}

str << info[0].last

 

p multisplit_rejoin(multisplit(text, separators)) == text

 

=={{header|Run BASIC}}==

sep$ = "=== != =! b =!="

 

split$ = word$(str$,1,theSep$)

print i;" ";split$;" Sep By: ";theSep$

{{out}}

<pre>1 a! Sep By: ===

 

=={{header|Scala}}==

def multiSplit(str:String, sep:Seq[String])={

def findSep(index:Int)=sep find (str startsWith (_, index))

}

 

{{out}}

<pre>List(a, , b, , c)</pre>

=={{header|Scheme}}==

{{works with|Gauche Scheme}}

(use srfi-42)

 

(define (glean shards)

(list-ec (: x (index i) shards)

<b>Testing:</b>

<pre>

First approach, using line delimiters. Lines are delimited by an array of separator strings, normally [CRLF, LF, CR, lineSeparator(0x2028), paragraphSeparator(0x2029)]. Supplying an alternate set of delimiters lets us split a string by a different (ordered) set of strings:

 

set separators to ["==", "!=", "="]

 

Output:

 

Second approach, using a pattern. SenseTalk's pattern language lets us define a pattern (a regex) which can then be used to split the string and also to display the actual separators that were found.

set separatorPattern to <"==" or "!=" or "=">

 

 

put each occurrence of separatorPattern in source

Output:

 

=={{header|Sidef}}==

sep = sep.map{.escape}.join('|');

var re = Regex.new(keep_sep ? "(#{sep})" : sep);

[false, true].each { |bool|

say multisplit(%w(== != =), 'a!===b=!=c', keep_sep: bool);

{{out}}

<pre>

["a", "!=", "", "==", "b", "=", "", "!=", "c"]

</pre>

 

=={{header|Tcl}}==

This simple version does not retain information about what the separators were:

set map {}; foreach s $sep {lappend map $s "\uffff"}

return [split [string map $map $text] "\uffff"]

}

{{out}}

<pre>a {} b {} c</pre>

to the match information (because the two collections of information

are of different lengths).

foreach s $sep {lappend sr [regsub -all {\W} $s {\\&}]}

set sepRE [join $sr "|"]

}

return [list [lappend pieces [string range $text $start end]] $match]

Demonstration code:

set matchers {"==" "!=" "="}

lassign [multisplit $input $matchers] substrings matchinfo

puts $substrings

{{out}}

<pre>

The <code>:gap 0</code> makes the horizontal collect repetitions strictly adjacent. This means that <code>coll</code> will quit when faced with a nonmatching suffix portion of the data rather than scan forward (no gap allowed!). This creates an opportunity for the <code>tail</code> variable to grab the suffix which remains, which may be an empty string.

 

@(coll :gap 0)@(choose :shortest tok)@\

@tok@{sep /==/}@\

@(output)

@(rep)"@tok" {@sep} @(end)"@tail"

 

Runs:

{{trans|Racket}}

 

 

Here the third boolean argument means "keep the material between the tokens", which in the Racket version seems to be requested by the argument <code>#:gap-select? #:t</code>.

=={{header|UNIX Shell}}==

{{works with|bash}}

local str=$1

shift

if [[ $original == $recreated ]]; then

echo "successfully able to recreate original string"

 

{{out}}

 

=={{header|VBScript}}==

Function multisplit(s,sep)

arr_sep = Split(sep,"|")

WScript.StdOut.WriteLine

WScript.StdOut.Write "Extra Credit: " & multisplit_extra("a!===b=!=c","!=|==|=")

{{out}}

<pre>

Extra Credit: a(!=)(==)b(=)(!=)c

</pre>

 

=={{header|Yabasic}}==

s$ = "==,!=,="

 

print left$(t$, l - 1), " with separator ", n$(j)

t$ = right$(t$, len(t$) - (l + len(n$(j))) + 1)

 

=={{header|zkl}}==

{{trans|Python}}

lastmatch := i := 0; matches := List();

while(i < text.len()){

if(i > lastmatch) matches.append(text[lastmatch,i-lastmatch]);

return(matches);

{{out}}

<pre>