Creating implementation for idiom 49 : Split a space-separated string

Idiom

# 49 Split a space-separated string

Created by

Lead paragraph

Build list chunks consisting in substrings of the string s, separated by one or more space characters.

New implementation

Language

Imports

Code

Documentation URL

Original attribution URL

Online runnable demo

Username

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations

#include <string.h>

chunks[0] = strtok(s, " ");
for (int i = 1; i < N; ++i)
{
    chunks[i] = strtok(NULL, " ");
    
    if (!chunks[i])
        break;
}

(require '[clojure.string :refer [split]])

(def chunks (split s #"\s+"))

#include <sstream>
#include <algorithm>
#include <iterator>
#include <list>

std::istringstream x(s);
std::list<std::string> chunks;
std::copy(std::istream_iterator<std::string>(x), std::istream_iterator<std::string>(), std::back_inserter(chunks));

Doc
Origin

string[] chunks = s.Split(' ');

Demo
Doc

import std.range;

auto chunks = s.splitter;

s.split(new RegExp('\\s+'))

Demo

chunks = String.split(s)

Chunks = string:tokens(S, [$\s]).

import "strings"

chunks := strings.Split(s, " ")

Demo
Doc

import "strings"

chunks := strings.Fields(s)

Demo
Doc

def chunks = s.split(/\s+/)

Demo

chunks = words s

let chunks = s.split(/ +/);

import static java.util.List.of;
import java.util.ArrayList;
import java.util.List;

List<String> chunks
    = new ArrayList<>(of(s.split(" +")));

import static java.util.regex.Pattern.compile;
import java.util.Scanner;

Scanner t = new Scanner(s);
t.useDelimiter(compile(" +"));
String chunks[] = t.tokens()
    .toArray(String[]::new);
t.close();

import static java.util.regex.Pattern.compile;
import java.util.List;
import java.util.Scanner;

Scanner t = new Scanner(s);
t.useDelimiter(compile(" +"));
List<String> chunks = t.tokens().toList();
t.close();

import static java.util.Arrays.asList;
import java.util.List;

List<String> chunks = asList(s.split(" +"));

import static java.util.List.of;
import java.util.List;

List<String> chunks = of(s.split(" +"));

String chunks[] = s.split(" +");

val chunks = s.split("\\s+".toRegex())

 
(defun words (s)
  (if (equalp s "") nil 
      (let ((p (position #\Space s )))
    (cond ((null p) (list s))
          ((zerop p ) (words (subseq s 1)))
          (T (cons (subseq s 0 p) (words (subseq s (+ 1 p ))))))))) 

(setf chunks (words s))

chunks = {}
for substring in s:gmatch("%S+") do
   table.insert(chunks, substring)
end

@import Foundation;

NSArray *chunks=[s componentsSeparatedByString:@" "];

$chunks = preg_split('/ +/', $s);

Uses Classes;

chunks.StrictDelimiter := True;
chunks.Delimiter := ' ';
chunks.DelimitedText := s;

@chunks = split /\s+/, $s;

chunks = s.split()

from re import split

chunks = split(' +', s)

chunks = s.split

let chunks: Vec<_> = s.split_ascii_whitespace().collect();

Demo
Doc

let chunks: Vec<_> = s.split(' ').collect();

Demo
Doc

let chunks: Vec<_> = s.split_whitespace().collect();

Demo
Doc

val chunks = s.split(" ")

(define (tokenize l)
  (let loop ((t '())
             (l l))
    (if (pair? l)
        (let ((c (car l)))
          (if (char=? c #\space)
              (cons (reverse t) (loop '() (cdr l)))
              (loop (cons (car l) t) (cdr l))))
        (if (null? t)
            '()
            (list (reverse t))))))

(define (string-split s)
  (map list->string (tokenize (string->list s))))

Origin

chunks := s substrings

Preview