Um script que exclui espaços extras entre letras no texto

Eu tenho um documento de texto que tem uma carga de texto que tem um espaço extra adicionado após cada letra!

Exemplo:

T h e  b o o k  a l s o  h a s  a n  a n a l y t i c a l  p u r p o s e  w h i c h  i s  m o r e  i m p o r t a n t…

Visualmente:

T␣h␣e␣␣b␣o␣o␣k␣␣a␣l␣s␣o␣␣h␣a␣s␣␣a␣n␣␣a␣n␣a␣l␣y␣t␣i ␣c␣a␣l␣␣p␣u␣r␣p␣o␣s␣e␣␣w␣h␣i␣c␣h␣␣i␣s␣␣m␣o␣r␣e␣␣i␣ m␣p␣o␣r␣t␣a␣n␣t…

Observe que há um espaço extra após cada letra, portanto, há dois espaços entre palavras consecutivas.

Existe uma maneira de obter awkou sedexcluir os espaços extras? (Infelizmente, este documento de texto é enorme e levaria muito tempo para ser processado manualmente.)  Compreendo que esse seja provavelmente um problema muito mais complexo a ser resolvido com apenas um script bash simples, pois também precisa haver algum tipo de reconhecimento de texto.

Como posso abordar esse problema?

O regex a seguir removerá o primeiro espaço em qualquer sequência de espaços. Isso deve fazer o trabalho.

s/ ( *)/\1/g

Então, algo como:

perl -i -pe 's/ ( *)/\1/g' infile.txt

... substituirá infile.txt por uma versão "fixa".

Use wordsegment, um pacote NLP de segmentação de palavras em Python puro:

$ pip install wordsegment
$ python2.7 -m wordsegment <<<"T h e b o o k a l s o h a s a n a n a l y t i c a l p u r p o s e w h i c h i s m o r e i m p o r t a n t"
the book also has an analytical purpose which is more important

Com base no fato de que a entrada inclui espaços duplos entre as palavras, existe uma solução muito mais simples. Você simplesmente altera os espaços duplos para um caracter não utilizado, remove os espaços e altera o caracter não utilizado de volta para um espaço:

echo "T h e  b o o k  a l s o  h a s  a n  a n a l y t i c a l  p u r p o s e  w h i c h  i s  m o r e  i m p o r t a n t  " | sed 's/  /\-/g;s/ //g;s/\-/ /g'

... saídas:

O livro também tem um objetivo analítico mais importante

Perl para o resgate!

Você precisa de um dicionário, ou seja, um arquivo listando uma palavra por linha. No meu sistema, ele existe como /var/lib/dict/words, também vi arquivos semelhantes como /usr/share/dict/britishetc.

Primeiro, você se lembra de todas as palavras do dicionário. Em seguida, você lê a entrada linha por linha e tenta adicionar caracteres a uma palavra. Se possível, lembre-se da palavra e tente analisar o resto da linha. Se você chegar ao final da linha, você produzirá a linha.

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

my $words = '/var/lib/dict/words';
my %word;

sub analyze {
    my ($chars, $words, $pos) = @_;
    if ($pos == @$chars) {
        $_[3] = 1;  # Found.
        say "@$words";
        return
    }
    for my $to ($pos .. $#$chars) {
        my $try = join q(), @$chars[ $pos .. $to ];
        if (exists $word{$try}) {
            analyze($chars, [ @$words, $try ], $to + 1, $_[3]);
        }
    }
}


open my $WORDS, '<', $words or die $!;
undef @word{ map { chomp; lc $_ } <$WORDS> };

while (<>) {
    my @chars = map lc, /\S/g;
    analyze(\@chars, [], 0, my $found = 0);
    warn "Unknown: $_" unless $found;
}

Para sua entrada, ele gera 4092 possíveis leituras no meu sistema.

Nota: esta resposta (como algumas outras aqui) é baseada em uma versão anterior da pergunta em que as palavras não foram delimitadas. A versão mais recente pode ser respondida trivialmente .

Em uma entrada como:

T h e b o o k a l s o h a s a n a n a l y t i c a l p u r p o s e w h i c h i s m o r e i m p o r t a n t

Você poderia tentar:

 $ tr -d ' ' < file | grep -oiFf /usr/share/dict/words | paste -sd ' '
 The book also has ana na l y tic al purpose which ism ore important

Ele processa da esquerda para a direita e encontra uma palavra mais longa após a seguinte.

Obviamente, aqui, não é a melhor seleção de palavras, pois essa frase não faz sentido, mas, para chegar à correta, você precisará de ferramentas capazes de entender a gramática ou o significado do texto ou, pelo menos, algumas estatísticas. informações sobre quais palavras provavelmente serão encontradas para criar o conjunto de palavras mais provável. Parece que a solução é uma biblioteca especializada, encontrada por Lynn

Semelhante à versão de Dewi Morgan, mas com sed:

$ echo "f o o  t h e  b a r" | sed -r "s/[ ]{1}([^ ]{1})/\1/g"
foo the bar

Embora possa (e deva) ser feito com uma linha única do Perl, um pequeno analisador C também seria muito rápido e também é muito pequeno (e espero que muito correto):

#include <stdio.h>
#include <stdlib.h>

int main()
{
  char c1 = '\0', c2 = '\0', tmp_c;

  c1 = fgetc(stdin);
  for (;;) {
    if (c1 == EOF) {
      break;
    }
    c2 = fgetc(stdin);
    if (c2 == EOF) {
      if (c1 != ' ') {
        fputc(c1, stdout);
      }
      break;
    }
    if (c1 == c2 && c1 == ' ') {
      tmp_c = fgetc(stdin);
      if (tmp_c != EOF) {
        if (tmp_c != '\n') {
          ungetc(tmp_c, stdin);
          fputc(' ', stdout);
        } else {
          ungetc(tmp_c, stdin);
        }
      } else {
        break;
      }
    } else if (c1 != ' ') {
      fputc(c1, stdout);
    }
    c1 = c2;
  }
  exit(EXIT_SUCCESS);
}

Compilado com

gcc-4.9 -O3 -g3  -W -Wall -Wextra -std=c11 lilcparser.c -o lilcparser

(o programa é um pouco menor que 9kb)

Use em um tubo como por exemplo:

echo "T h e  b o o k  a l s o  h a s  a n  a n a l y t i c a l  p u r p o s e  w h i c h  i s  m o r e  i m p o r t a n t  " | ./lilcparser

Eu tentei isso e parece funcionar:

echo "<text here>" | sed -r 's/(\w)(\s)/\1/g'

O sedcomando captura dois grupos e retorna apenas o primeiro.

Em c ++, eu faria isso:

#include <fstream>
using namespace std;

int main()
{   
    fstream is("test.txt", std::ios::in);

    char buff;
    vector<char>str;

    while (!is.eof()){is.get(buff);str.push_back(buff);} //read file to string

    for (int a=0;a<str.size();++a)if (str[a] == ' ' && str[a + 1] != ' ')str.erase(str.begin()+a);
    is.close();

    ofstream os("test.txt", std::ios::out | std::ios::trunc); //clear file for rewrite

    os.write(str.data(), str.size() * sizeof(char)); //write chars
    os.close();

    return 0;
    }

Alterará o conteúdo do arquivo de texto de teste, na mesma sequência, mas com os espaços entre as letras removidos. (Requer um espaço entre cada letra para ser preciso).

$ echo 'F o u r  s c o r e  a n d' | \
txr -t '(mapcar* (opip (split-str @1 "  ")
                       (mapcar (op regsub #/ / ""))
                       (cat-str @1 " "))
                 (get-lines))'
Four score and


$ txr -e '(awk (:begin (set fs "  "))
               ((mf (regsub #/ / ""))))'  # mf: modify fields
F o u r  s c o r e  a n d
Four score and


$ awk -F'  ' '{for(i=1;i<=NF;i++)gsub(/ /,"",$i);print}'
F o u r  s c o r e  a n d
Four score and