Un script que elimina espacios adicionales entre letras en el texto.

¡Tengo un documento de texto que tiene una carga de texto que tiene un espacio adicional agregado después de cada letra!

Ejemplo:

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 ...

Tenga en cuenta que hay un espacio adicional después de cada letra, por lo que hay dos espacios entre palabras consecutivas.

¿Hay alguna forma de obtener awko sedeliminar los espacios adicionales? (Desafortunadamente, este documento de texto es masivo y tomaría mucho tiempo para pasarlo manualmente).  Aprecio que este es probablemente un problema mucho más complejo de resolver con solo un simple script bash, ya que también debe haber algún tipo de reconocimiento de texto.

¿Cómo puedo abordar este problema?

La siguiente expresión regular eliminará el primer espacio en cualquier cadena de espacios. Eso debería hacer el trabajo.

s/ ( *)/\1/g

Entonces algo como:

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

... reemplazará infile.txt con una versión "fija".

Use wordsegmentun paquete NLP de segmentación de palabras de 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

Basado en el hecho de que la entrada incluye espacios dobles entre palabras, hay una solución mucho más simple. Simplemente cambie los espacios dobles a un carácter no utilizado, elimine los espacios y vuelva a cambiar el carácter no utilizado a un espacio:

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'

... salidas:

El libro también tiene un propósito analítico que es más importante.

¡Perl al rescate!

Necesita un diccionario, es decir, un archivo con una palabra por línea. En mi sistema, existe como /var/lib/dict/words, también he visto archivos similares como /usr/share/dict/britishetc.

Primero, recuerdas todas las palabras del diccionario. Luego, lee la entrada línea por línea e intenta agregar caracteres a una palabra. Si es posible, recuerda la palabra e intenta analizar el resto de la línea. Si llega al final de la línea, genera la línea.

#!/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 su entrada, genera 4092 lecturas posibles en mi sistema.

Nota: esta respuesta (como algunas otras aquí) se basa en una versión anterior de la pregunta donde las palabras no estaban delimitadas. La versión más nueva se puede responder trivialmente .

En una 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

Tu podrías intentar:

 $ 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

Procesa de izquierda a derecha y encuentra una palabra más larga después de la siguiente.

Obviamente, aquí, no es la mejor selección de palabras, ya que esa oración no tiene ningún sentido, pero para encontrar la correcta, necesitaría herramientas capaces de comprender la gramática o el significado del texto o al menos algunas estadísticas información sobre qué palabras es probable que se encuentren juntas para llegar al conjunto de palabras más probable. Parece que la solución es una biblioteca especializada encontrada por Lynn

Similar a la versión de Dewi Morgan, pero con sed:

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

Aunque podría (y debería) hacerse con una línea Perl, un analizador de C pequeño también sería muy rápido, y también es muy pequeño (y con suerte muy correcto):

#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 con

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

(el programa es un poco menos de 9kb)

Usar en una tubería como por ejemplo:

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

Intenté esto y parece funcionar:

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

El sedcomando captura dos grupos y devuelve solo el primero.

En c ++, haría esto:

#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;
    }

Cambiará el contenido del archivo de texto de prueba, en la misma cadena, pero con espacios entre letras eliminados. (Se requiere un espacio entre cada letra para ser exacto).

$ 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