Как я могу разбить несколько соединенных слов?

Я думаю, вы правы, полагая, что регулярное выражение не подходит для этого. Я бы подошел к этому, используя идею словаря - ищите самый длинный префикс, который является словом в словаре. Когда вы найдете это, отрежьте его и сделайте то же самое с оставшейся частью нити.

Вышеупомянутый метод имеет двусмысленность, например, "drivereallyfast" сначала найдет "driver", а затем возникнут проблемы с "eallyfast". Так что вам также придется вернуться, если вы столкнетесь с этой ситуацией. Или, поскольку у вас не так много строк для разделения, просто вручную обработайте те, которые не прошли автоматическое разделение.

Что ж, проблема не решается с помощью регулярного выражения. Решением (вероятно, не лучшим) было бы получить словарь и сопоставить регулярное выражение для каждой работы в словаре с каждым словом в списке, добавляя пробел в случае успеха. Конечно, это будет не очень быстро, но это будет легко запрограммировать и быстрее, чем вручную.

Потребуется решение на основе словаря. Это можно несколько упростить, если у вас ограниченный словарь слов, которые могут встречаться, иначе слова, образующие префикс других слов, будут проблемой.

Для этого я могу понизить мод, но пусть секретарь сделает это.

Вы потратите больше времени на словарное решение, чем на обработку вручную. Кроме того, у вас не будет 100% уверенности в решении, поэтому вам все равно придется уделить ему внимание вручную.

Может ли это сделать человек?

farsidebag
far sidebag
farside bag
far side bag

Вы не только должны использовать словарь, но, возможно, вам придется использовать статистический подход, чтобы выяснить, что наиболее вероятно (или, не дай бог, реальный HMM для выбранного вами человеческого языка ...)

Чтобы узнать, как сделать статистику, которая может быть полезной, я обращаюсь к доктору Питеру Норвигу, который решает другую, но связанную проблему проверки орфографии в 21 строке кода: http://norvig.com/spell-correct.html

(он немного обманывает, сворачивая каждый цикл for в одну строку ... но все же).

Обновлять Это застряло у меня в голове, поэтому мне пришлось родить его сегодня. Этот код выполняет такое же разбиение, что и описанный Робертом Гэмблом, но затем он упорядочивает результаты в зависимости от частоты слов в предоставленном файле словаря (который теперь, как ожидается, будет некоторым текстовым представителем вашего домена или английского языка в целом. Я использовал большой .txt из Norvig, ссылка на который приведена выше, и добавила к нему словарь, чтобы скрыть пропущенные слова).

Комбинация двух слов в большинстве случаев превосходит комбинацию из 3 слов, если разница в частоте не очень велика.

Я разместил этот код с небольшими изменениями в своем блоге

http://squarecog.wordpress.com/2008/10/19/splitting-words-joined-into-a-single-string/ а также немного написал об ошибке недополнения в этом коде ... Я был склонен просто тихо ее исправить, но решил, что это может помочь некоторым людям, которые раньше не видели трюка с журналом: http://squarecog.wordpress.com/2009/01/10/dealing-with-underflow-in-joint-probability-calculations/

Выведите свои слова, а также несколько моих собственных - обратите внимание, что происходит с "orcore":

perl splitwords.pl big.txt words
answerveal: 2 possibilities
 -  answer veal
 -  answer ve al

wickedweather: 4 possibilities
 -  wicked weather
 -  wicked we at her
 -  wick ed weather
 -  wick ed we at her

liquidweather: 6 possibilities
 -  liquid weather
 -  liquid we at her
 -  li quid weather
 -  li quid we at her
 -  li qu id weather
 -  li qu id we at her

driveourtrucks: 1 possibilities
 -  drive our trucks

gocompact: 1 possibilities
 -  go compact

slimprojector: 2 possibilities
 -  slim projector
 -  slim project or

orcore: 3 possibilities
 -  or core
 -  or co re
 -  orc ore

Код:

#!/usr/bin/env perl

use strict;
use warnings;

sub find_matches($);
sub find_matches_rec($\@\@);
sub find_word_seq_score(@);
sub get_word_stats($);
sub print_results($@);
sub Usage();

our(%DICT,$TOTAL);
{
  my( $dict_file, $word_file ) = @ARGV;
  ($dict_file && $word_file) or die(Usage);

  {
    my $DICT;
    ($DICT, $TOTAL) = get_word_stats($dict_file);
    %DICT = %$DICT;
  }

  {
    open( my $WORDS, '<', $word_file ) or die "unable to open $word_file\n";

    foreach my $word (<$WORDS>) {
      chomp $word;
      my $arr = find_matches($word);


      local $_;
      # Schwartzian Transform
      my @sorted_arr =
        map  { $_->[0] }
        sort { $b->[1] <=> $a->[1] }
        map  {
          [ $_, find_word_seq_score(@$_) ]
        }
        @$arr;


      print_results( $word, @sorted_arr );
    }

    close $WORDS;
  }
}


sub find_matches($){
    my( $string ) = @_;

    my @found_parses;
    my @words;
    find_matches_rec( $string, @words, @found_parses );

    return  @found_parses if wantarray;
    return \@found_parses;
}

sub find_matches_rec($\@\@){
    my( $string, $words_sofar, $found_parses ) = @_;
    my $length = length $string;

    unless( $length ){
      push @$found_parses, $words_sofar;

      return @$found_parses if wantarray;
      return  $found_parses;
    }

    foreach my $i ( 2..$length ){
      my $prefix = substr($string, 0, $i);
      my $suffix = substr($string, $i, $length-$i);

      if ( exists $DICT{$prefix} ){
        my @words = ( @$words_sofar, $prefix );
        find_matches_rec( $suffix, @words, @$found_parses );
      }
    }

    return @$found_parses if wantarray;
    return  $found_parses;
}


## Just a simple joint probability
## assumes independence between words, which is obviously untrue
## that's why this is broken out -- feel free to add better brains
sub find_word_seq_score(@){
    my( @words ) = @_;
    local $_;

    my $score = 1;
    foreach ( @words ){
        $score = $score * $DICT{$_} / $TOTAL;
    }

    return $score;
}

sub get_word_stats($){
    my ($filename) = @_;

    open(my $DICT, '<', $filename) or die "unable to open $filename\n";

    local $/= undef;
    local $_;
    my %dict;
    my $total = 0;

    while ( <$DICT> ){
      foreach ( split(/\b/, $_) ) {
        $dict{$_} += 1;
        $total++;
      }
    }

    close $DICT;

    return (\%dict, $total);
}

sub print_results($@){
    #( 'word', [qw'test one'], [qw'test two'], ... )
    my ($word,  @combos) = @_;
    local $_;
    my $possible = scalar @combos;

    print "$word: $possible possibilities\n";
    foreach (@combos) {
      print ' -  ', join(' ', @$_), "\n";
    }
    print "\n";
}

sub Usage(){
    return "$0 /path/to/dictionary /path/to/your_words";
}

Лучшим инструментом для работы здесь является рекурсия, а не регулярные выражения. Основная идея состоит в том, чтобы начать поиск слова с начала строки, затем взять оставшуюся часть строки и найти другое слово и так далее, пока не будет достигнут конец строки. Рекурсивное решение является естественным, поскольку возврат с возвратом должен происходить, когда данный остаток строки не может быть разбит на набор слов. В приведенном ниже решении используется словарь для определения того, что является словом, и распечатываются решения по мере их нахождения (некоторые строки могут быть разбиты на несколько возможных наборов слов, например, wickedweather может быть проанализирован как «мы злые на нее»). Если вам нужен только один набор слов, вам нужно будет определить правила выбора наилучшего набора, возможно, выбрав решение с наименьшим количеством слов или установив минимальную длину слова.

#!/usr/bin/perl

use strict;

my $WORD_FILE = '/usr/share/dict/words'; #Change as needed
my %words; # Hash of words in dictionary

# Open dictionary, load words into hash
open(WORDS, $WORD_FILE) or die "Failed to open dictionary: $!\n";
while (<WORDS>) {
  chomp;
  $words{lc($_)} = 1;
}
close(WORDS);

# Read one line at a time from stdin, break into words
while (<>) {
  chomp;
  my @words;
  find_words(lc($_));
}

sub find_words {
  # Print every way $string can be parsed into whole words
  my $string = shift;
  my @words = @_;
  my $length = length $string;

  foreach my $i ( 1 .. $length ) {
    my $word = substr $string, 0, $i;
    my $remainder = substr $string, $i, $length - $i;
    # Some dictionaries contain each letter as a word
    next if ($i == 1 && ($word ne "a" && $word ne "i"));

    if (defined($words{$word})) {
      push @words, $word;
      if ($remainder eq "") {
        print join(' ', @words), "\n";
        return;
      } else {
        find_words($remainder, @words);
      }
      pop @words;
    }
  }

  return;
}

Алгоритм Витерби намного быстрее. Он вычисляет те же оценки, что и рекурсивный поиск в ответе Дмитрия выше, но за время O (n). (Поиск Дмитрия занимает экспоненциальное время; Витерби делает это с помощью динамического программирования.)

import re
from collections import Counter

def viterbi_segment(text):
    probs, lasts = [1.0], [0]
    for i in range(1, len(text) + 1):
        prob_k, k = max((probs[j] * word_prob(text[j:i]), j)
                        for j in range(max(0, i - max_word_length), i))
        probs.append(prob_k)
        lasts.append(k)
    words = []
    i = len(text)
    while 0 < i:
        words.append(text[lasts[i]:i])
        i = lasts[i]
    words.reverse()
    return words, probs[-1]

def word_prob(word): return dictionary[word] / total
def words(text): return re.findall('[a-z]+', text.lower()) 
dictionary = Counter(words(open('big.txt').read()))
max_word_length = max(map(len, dictionary))
total = float(sum(dictionary.values()))

Тестирование:

>>> viterbi_segment('wickedweather')
(['wicked', 'weather'], 5.1518198982768158e-10)
>>> ' '.join(viterbi_segment('itseasyformetosplitlongruntogetherblocks')[0])
'its easy for me to split long run together blocks'

Чтобы быть практичным, вам, вероятно, понадобится пара уточнений:

• Добавляйте журналы вероятностей, а не умножайте вероятности. Это позволяет избежать потери значимости с плавающей запятой.
• В ваших материалах обычно используются слова, которых нет в вашем корпусе. Этим подстрокам необходимо присвоить ненулевую вероятность в виде слов, иначе вы не получите решения или получите плохое решение. (Это так же верно и для вышеупомянутого алгоритма экспоненциального поиска.) Эта вероятность должна быть выведена из вероятностей корпуса слов и правдоподобно распределена среди всех других слов-кандидатов: общая тема в статистических языковых моделях известна как сглаживание. (Однако можно обойтись некоторыми довольно грубыми хитростями.) Именно здесь алгоритм O (n) Витерби срывает алгоритм поиска, потому что рассмотрение слов, не являющихся корпусом, увеличивает фактор ветвления.

Это связано с проблемой, известной как разделение идентификатора или токенизация имени идентификатора. В случае OP входные данные кажутся конкатенациями обычных слов; при разделении идентификаторов входными данными являются имена классов, имена функций или другие идентификаторы из исходного кода, и проблема усложняется. Я понимаю, что это старый вопрос, и OP либо решил свою проблему, либо перешел, но в случае, если кто-то еще столкнется с этим вопросом при поиске разделителей идентификаторов (как я был не так давно), я хотел бы предложить Спираль ( «SPlitters для идентификаторов: библиотека»). Он написан на Python, но поставляется с утилитой командной строки, которая может читать файл идентификаторов (по одному на строку) и разбивать каждый из них.

Разделение идентификаторов обманчиво сложно. Программисты обычно используют аббревиатуры, акронимы и фрагменты слов при именовании вещей, и они не всегда используют согласованные соглашения. Даже в тех случаях, когда идентификаторы следуют некоторому соглашению, например, верблюжьему регистру, могут возникнуть неоднозначности.

Спираль реализует множество алгоритмов разделения идентификаторов, включая новый алгоритм под названием Ronin. Он использует различные эвристические правила, английские словари и таблицы частот токенов, полученные из репозиториев исходного кода майнинга. Ronin может разделять идентификаторы, в которых не используется верблюжий регистр или другие соглашения об именах, включая такие случаи, как разделение J2SEProjectTypeProfiler на [J2SE, Project, Type, Profiler], что требует, чтобы считыватель распознал J2SE как единое целое. Вот еще несколько примеров того, что может разделить Ронин:

# spiral mStartCData nonnegativedecimaltype getUtf8Octets GPSmodule savefileas nbrOfbugs
mStartCData: ['m', 'Start', 'C', 'Data']
nonnegativedecimaltype: ['nonnegative', 'decimal', 'type']
getUtf8Octets: ['get', 'Utf8', 'Octets']
GPSmodule: ['GPS', 'module']
savefileas: ['save', 'file', 'as']
nbrOfbugs: ['nbr', 'Of', 'bugs']

Используя примеры из вопроса OP:

# spiral wickedweather liquidweather  driveourtrucks gocompact slimprojector
wickedweather: ['wicked', 'weather']
liquidweather: ['liquid', 'weather']
driveourtrucks: ['driveourtrucks']
gocompact: ['go', 'compact']
slimprojector: ['slim', 'projector']

Как видите, он не идеален. Стоит отметить, что Ronin имеет ряд параметров, и их настройка позволяет разделить driveourtrucks, но за счет ухудшения производительности идентификаторов программ.

Более подробную информацию можно найти в Репозиторий на GitHub для Spiral.

Выпущен пакет Python Santhosh thottingal под названием mlmorph, который можно использовать для морфологического анализа.

https://pypi.org/project/mlmorph/

Примеры:

from mlmorph import Analyser
analyser = Analyser()
analyser.analyse("കേരളത്തിന്റെ")

Дает

[('കേരളം<np><genitive>', 179)]

Также он вел блог на тему https://thottingal.in/blog/2017/11/26/towards-a-malayalam-morphology-analyser/

Простое решение с Python: установите пакет отрывок слова: pip install wordsegment.

$ echo thisisatest | python -m wordsegment
this is a test

pip install wordninja

>>> import wordninja
>>> wordninja.split('bettergood')
['better', 'good']

Это будет работать, если это camelCase. JavaScript !!!

function spinalCase(str) {
  let lowercase = str.trim()
  let regEx = /\W+|(?=[A-Z])|_/g
  let result = lowercase.split(regEx).join("-").toLowerCase()

  return result;
}

spinalCase("AllThe-small Things");

Одно из решений может быть с рекурсией (то же самое можно преобразовать в динамическое программирование):

static List<String> wordBreak(
    String input,
    Set<String> dictionary
) {

  List<List<String>> result = new ArrayList<>();
  List<String> r = new ArrayList<>();

  helper(input, dictionary, result, "", 0, new Stack<>());

  for (List<String> strings : result) {
    String s = String.join(" ", strings);
    r.add(s);
  }

  return r;
}

static void helper(
    final String input,
    final Set<String> dictionary,
    final List<List<String>> result,
    String state,
    int index,
    Stack<String> stack
) {

  if (index == input.length()) {

    // add the last word
    stack.push(state);

    for (String s : stack) {
      if (!dictionary.contains(s)) {
        return;
      }
    }

    result.add((List<String>) stack.clone());

    return;
  }

  if (dictionary.contains(state)) {
    // bifurcate
    stack.push(state);
    helper(input, dictionary, result, "" + input.charAt(index),
           index + 1, stack);

    String pop = stack.pop();
    String s = stack.pop();

    helper(input, dictionary, result, s + pop.charAt(0),
           index + 1, stack);

  }
  else {
    helper(input, dictionary, result, state + input.charAt(index),
           index + 1, stack);
  }

  return;
}

Другое возможное решение - использование структуры данных Tries.