Una sceneggiatura che elimina spazi aggiuntivi tra le lettere nel testo

Ho un documento di testo che ha un carico di testo che ha uno spazio aggiuntivo aggiunto dopo ogni lettera!

Esempio:

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…

visivamente:

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

Nota che c'è uno spazio extra dopo ogni lettera, quindi ci sono due spazi tra le parole consecutive.

C'è un modo per ottenere awko sedeliminare gli spazi extra? (Sfortunatamente questo documento di testo è enorme e richiederebbe molto tempo per essere esaminato manualmente.)  Mi rendo conto che questo è probabilmente un problema molto più complesso da risolvere con un semplice script bash in quanto deve esserci anche una sorta di riconoscimento del testo.

Come posso affrontare questo problema?

La seguente regex rimuoverà il primo spazio in qualsiasi stringa di spazi. Questo dovrebbe fare il lavoro.

s/ ( *)/\1/g

Quindi qualcosa del tipo:

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

... sostituirà infile.txt con una versione "fissa".

Utilizzare wordsegmentun pacchetto NLP di segmentazione delle parole pure-Python:

$ 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

Sulla base del fatto che l'input include doppi spazi tra le parole, esiste una soluzione molto più semplice. Devi semplicemente cambiare i doppi spazi in un personaggio inutilizzato, rimuovere gli spazi e cambiare il personaggio inutilizzato in uno spazio:

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'

... uscite:

Il libro ha anche uno scopo analitico che è più importante

Perl in soccorso!

È necessario un dizionario, ovvero un file che elenchi una parola per riga. Sul mio sistema, esiste come /var/lib/dict/words, ho visto anche file simili come /usr/share/dict/britishecc.

Innanzitutto, ricordi tutte le parole del dizionario. Quindi, leggi l'input riga per riga e provi ad aggiungere caratteri a una parola. Se è possibile, ricordi la parola e provi ad analizzare il resto della riga. Se si raggiunge la fine della linea, si genera la linea.

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

Per il tuo input, genera 4092 possibili letture sul mio sistema.

Nota: questa risposta (come poche altre qui) si basa su una versione precedente della domanda in cui le parole non erano delimitate. Alla versione più recente può essere data una risposta banale .

Su un input come:

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

Puoi provare:

 $ 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

Elabora da sinistra a destra e trova una parola più lunga dopo la successiva.

Ovviamente, qui, non è la migliore selezione di parole poiché quella frase non ha alcun senso, ma per trovare quella giusta, avresti bisogno di strumenti in grado di comprendere la grammatica o il significato del testo o almeno alcune statistiche informazioni su quali parole è probabile che si trovino insieme per trovare l'insieme di parole più probabile. Sembra che la soluzione sia una libreria specializzata trovata da Lynn

Simile alla versione di Dewi Morgan, ma con sed:

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

Sebbene potrebbe (e dovrebbe) essere fatto con un one-liner Perl, anche un piccolo parser C sarebbe molto veloce, ed è anche molto piccolo (e si spera molto corretto):

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

Compilato con

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

(programm è un po 'meno di 9kb)

Utilizzare in un tubo come ad esempio:

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

Ho provato questo e sembra funzionare:

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

Il sedcomando acquisisce due gruppi e restituisce solo il primo.

In c ++, farei questo:

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

Cambierà il contenuto del file di testo di prova, nella stessa stringa, ma rimuovendo gli spazi tra le lettere. (Richiede uno spazio tra ogni lettera per essere precisi).

$ 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