delphi - ¿Existe una forma simplista de extraer números de una cadena siguiendo ciertas reglas?

lazarus freepascal

Question

Necesito extraer números de una cadena y colocarlos en una lista; existen algunas reglas para esto, como identificar si el número extraído es un número entero o flotante.

La tarea parece bastante simple pero me encuentro cada vez más confundido a medida que pasa el tiempo y realmente podría hacerlo con cierta orientación.

Tome la siguiente cadena de prueba como ejemplo:

There are test values: P7 45.826.53.91.7, .5, 66.. 4 and 5.40.3.

Las reglas a seguir al analizar la cadena son las siguientes:

• los números no pueden ser precedidos por una letra.

• Si encuentra un número y no está seguido por un punto decimal, entonces el número es como un entero.

• Si encuentra un número y le sigue un punto decimal, entonces el número es un flotante, por ejemplo, 5.

• ~ Si más números siguen el punto decimal, entonces el número sigue siendo un flotante, por ejemplo, 5.40

• ~ Otro punto decimal encontrado debería dividir el número, por ejemplo, 5.40.3 se convierte en (5.40 Flotante) y (3 Flotante)

• En el caso de una letra, por ejemplo, después de un punto decimal, por ejemplo, 3.H continuación, agregue 3. como Flotante a la lista (incluso si técnicamente no es válido)

Ejemplo 1

Para hacer esto un poco más claro, tomar la cadena de prueba citada sobre la salida deseada debe ser como sigue:

En la imagen de arriba, el color azul claro ilustra los números de flotación, el rojo pálido ilustra los enteros únicos (pero también tenga en cuenta cómo los flotadores unidos se dividen en flotadores separados).

• 45.826 (flotador)
• 53.91 (flotador)
• 7 (entero)
• 5 (entero)
• 66. (Flotador)
• 4 (entero)
• 5.40 (Flotador)
• 3. (Flotador)

Tenga en cuenta que hay espacios deliberados entre 66. y 3. arriba debido a la forma en que se formatearon los números.

Ejemplo 2:

Anoth3r Te5.t string .4 abc 8.1Q 123.45.67.8.9

• 4 (entero)
• 8.1 (Flotador)
• 123.45 (flotador)
• 67.8 (Flotador)
• 9 (entero)

Para dar una mejor idea, creé un nuevo proyecto durante la prueba que se parece a esto:

Ahora en la tarea real. Pensé que tal vez podría leer cada carácter de la cadena e identificar cuáles son los números válidos según las reglas anteriores, y luego agruparlos en una lista.

Para mi capacidad, esto era lo mejor que podía manejar:

El código es el siguiente:

unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;
type
TForm1 = class(TForm)
btnParseString: TButton;
edtTestString: TEdit;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
lstDesiredOutput: TListBox;
lstActualOutput: TListBox;
procedure btnParseStringClick(Sender: TObject);
private
FDone: Boolean;
FIdx: Integer;
procedure ParseString(const Str: string; var OutValue, OutKind: string);
public
{ public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.lfm}
{ TForm1 }
procedure TForm1.ParseString(const Str: string; var OutValue, OutKind: string);
var
CH1, CH2: Char;
begin
Inc(FIdx);
CH1 := Str[FIdx];
case CH1 of
''0''..''9'': // Found a number
begin
CH2 := Str[FIdx - 1];
if not (CH2 in [''A''..''Z'']) then
begin
OutKind := ''Integer'';
// Try to determine float...
//while (CH1 in [''0''..''9'', ''.'']) do
//begin
// case Str[FIdx] of
// ''.'':
// begin
// CH2 := Str[FIdx + 1];
// if not (CH2 in [''0''..''9'']) then
// begin
// OutKind := ''Float'';
// //Inc(FIdx);
// end;
// end;
// end;
//end;
end;
OutValue := Str[FIdx];
end;
end;
FDone := FIdx = Length(Str);
end;
procedure TForm1.btnParseStringClick(Sender: TObject);
var
S, SKind: string;
begin
lstActualOutput.Items.Clear;
FDone := False;
FIdx := 0;
repeat
ParseString(edtTestString.Text, S, SKind);
if (S <> '''') and (SKind <> '''') then
begin
lstActualOutput.Items.Add(S + '' ('' + SKind + '')'');
end;
until
FDone = True;
end;
end.

Claramente, no da el resultado deseado (el código fallido ha sido comentado) y mi enfoque probablemente sea incorrecto, pero creo que solo necesito hacer algunos cambios aquí y allá para una solución funcional.

En este punto, me he sentido bastante confundido y bastante perdido, a pesar de pensar que la respuesta es bastante cercana, la tarea se está volviendo cada vez más exasperante y realmente agradecería alguna ayuda.

EDITAR 1

Aquí me acerqué un poco más porque ya no hay números duplicados, pero el resultado sigue siendo claramente erróneo.

unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;
type
TForm1 = class(TForm)
btnParseString: TButton;
edtTestString: TEdit;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
lstDesiredOutput: TListBox;
lstActualOutput: TListBox;
procedure btnParseStringClick(Sender: TObject);
private
FDone: Boolean;
FIdx: Integer;
procedure ParseString(const Str: string; var OutValue, OutKind: string);
public
{ public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.lfm}
{ TForm1 }
// Prepare to pull hair out!
procedure TForm1.ParseString(const Str: string; var OutValue, OutKind: string);
var
CH1, CH2: Char;
begin
Inc(FIdx);
CH1 := Str[FIdx];
case CH1 of
''0''..''9'': // Found the start of a new number
begin
CH1 := Str[FIdx];
// make sure previous character is not a letter
CH2 := Str[FIdx - 1];
if not (CH2 in [''A''..''Z'']) then
begin
OutKind := ''Integer'';
// Try to determine float...
//while (CH1 in [''0''..''9'', ''.'']) do
//begin
// OutKind := ''Float'';
// case Str[FIdx] of
// ''.'':
// begin
// CH2 := Str[FIdx + 1];
// if not (CH2 in [''0''..''9'']) then
// begin
// OutKind := ''Float'';
// Break;
// end;
// end;
// end;
// Inc(FIdx);
// CH1 := Str[FIdx];
//end;
end;
OutValue := Str[FIdx];
end;
end;
OutValue := Str[FIdx];
FDone := Str[FIdx] = #0;
end;
procedure TForm1.btnParseStringClick(Sender: TObject);
var
S, SKind: string;
begin
lstActualOutput.Items.Clear;
FDone := False;
FIdx := 0;
repeat
ParseString(edtTestString.Text, S, SKind);
if (S <> '''') and (SKind <> '''') then
begin
lstActualOutput.Items.Add(S + '' ('' + SKind + '')'');
end;
until
FDone = True;
end;
end.

Mi pregunta es ¿cómo puedo extraer números de una cadena, agregarlos a una lista y determinar si el número es entero o flotante?

El cuadro de lista verde pálido de la izquierda (salida deseada) muestra cuáles deberían ser los resultados, el cuadro de lista azul pálido de la derecha (salida real) muestra lo que realmente obtuvimos.

Por favor asesóreme, gracias.

Tenga en cuenta que volví a agregar la etiqueta Delphi, ya que uso XE7, así que no la elimine, aunque este problema en particular está en Lazarus, mi solución debería funcionar tanto para XE7 como para Lazarus.

Answer 1

Aquí hay una solución usando regex. Lo implementé en Delphi (probado en 10.1, pero también debería funcionar con XE8), estoy seguro de que puedes adoptarlo para Lázaro, pero no estoy seguro de qué bibliotecas de expresiones regulares funcionan allí. El patrón de expresiones regulares usa la alternancia para hacer coincidir números como enteros o flotantes siguiendo sus reglas:

Entero:

(/b/d+(?![./d]))

• comenzó con un límite de palabra (por lo tanto, no hay letras, números ni guiones bajos antes, si los guiones bajos son un problema que podría usar (?<![[:alnum:]]) )
• luego une uno o más dígitos
• que no están seguidos de dígitos ni puntos

Flotador:

(/b/d+(?:/./d+)?)

• comenzó con un límite de palabra (por lo tanto, no hay letras, números ni guiones bajos antes, si los guiones bajos son un problema que podría usar (?<![[:alnum:]]) )
• luego une uno o más dígitos
• Opcionalmente, haga coincidir el punto seguido de otros dígitos.

Una aplicación de consola simple parece

program Test;
{$APPTYPE CONSOLE}
uses
System.SysUtils, RegularExpressions;
procedure ParseString(const Input: string);
var
Match: TMatch;
begin
WriteLn(''---start---'');
Match := TRegex.Match(Input, ''(/b/d+(?![./d]))|(/b/d+(?:/./d+)?)'');
while Match.Success do
begin
if Match.Groups[1].Value <> '''' then
writeln(Match.Groups[1].Value + ''(Integer)'')
else
writeln(Match.Groups[2].Value + ''(Float)'');
Match := Match.NextMatch;
end;
WriteLn(''---end---'');
end;
begin
ParseString(''There are test values: P7 45.826.53.91.7, .5, 66.. 4 and 5.40.3.'');
ParseString(''Anoth3r Te5.t string .4 abc 8.1Q 123.45.67.8.9'');
ReadLn;
end.

Answer 2

Hay tantos errores básicos en su código que decidí corregir su tarea, por así decirlo. Esta no es una buena forma de hacerlo, pero al menos se eliminan los errores básicos. ¡Ten cuidado de leer los comentarios!

procedure TForm1.ParseString(const Str: string; var OutValue,
OutKind: string);
//var
// CH1, CH2: Char; <<<<<<<<<<<<<<<< Don''t need these
begin
(*************************************************
* *
* This only corrects the ''silly'' errors. It is *
* NOT being passed off as GOOD code! *
* *
*************************************************)
Inc(FIdx);
// CH1 := Str[FIdx]; <<<<<<<<<<<<<<<<<< Not needed but OK to use. I removed them because they seemed to cause confusion...
OutKind := ''None'';
OutValue := '''';
try
case Str[FIdx] of
''0''..''9'': // Found the start of a new number
begin
// CH1 := Str[FIdx]; <<<<<<<<<<<<<<<<<<<< Not needed
// make sure previous character is not a letter
// >>>>>>>>>>> make sure we are not at beginning of file
if FIdx > 1 then
begin
//CH2 := Str[FIdx - 1];
if (Str[FIdx - 1] in [''A''..''Z'', ''a''..''z'']) then // <<<<< don''t forget lower case!
begin
exit; // <<<<<<<<<<<<<<
end;
end;
// else we have a digit and it is not preceeded by a number, so must be at least integer
OutKind := ''Integer'';
// <<<<<<<<<<<<<<<<<<<<< WHAT WE HAVE SO FAR >>>>>>>>>>>>>>
OutValue := Str[FIdx];
// <<<<<<<<<<<<< Carry on...
inc( FIdx );
// Try to determine float...
while (Fidx <= Length( Str )) and (Str[ FIdx ] in [''0''..''9'', ''.'']) do // <<<<< not not CH1!
begin
OutValue := Outvalue + Str[FIdx]; //<<<<<<<<<<<<<<<<<<<<<< Note you were storing just 1 char. EVER!
//>>>>>>>>>>>>>>>>>>>>>>>>> OutKind := ''Float''; ***** NO! *****
case Str[FIdx] of
''.'':
begin
OutKind := ''Float'';
// now just copy any remaining integers - that is all rules ask for
inc( FIdx );
while (Fidx <= Length( Str )) and (Str[ FIdx ] in [''0''..''9'']) do // <<<<< note ''.'' excluded here!
begin
OutValue := Outvalue + Str[FIdx];
inc( FIdx );
end;
exit;
end;
// >>>>>>>>>>>>>>>>>>> all the rest in unnecessary
//CH2 := Str[FIdx + 1];
// if not (CH2 in [''0''..''9'']) then
// begin
// OutKind := ''Float'';
// Break;
// end;
// end;
// end;
// Inc(FIdx);
// CH1 := Str[FIdx];
//end;
end;
inc( fIdx );
end;
end;
end;
// OutValue := Str[FIdx]; <<<<<<<<<<<<<<<<<<<<< NO! Only ever gives 1 char!
// FDone := Str[FIdx] = #0; <<<<<<<<<<<<<<<<<<< NO! #0 does NOT terminate Delphi strings
finally // <<<<<<<<<<<<<<< Try.. finally clause added to make sure FDone is always evaluated.
// <<<<<<<<<< Note there are better ways!
if FIdx > Length( Str ) then
begin
FDone := TRUE;
end;
end;
end;

Answer 3

La respuesta es bastante cercana, pero hay varios errores básicos. Para darle algunas sugerencias (sin escribir su código): dentro del ciclo while, DEBE SIEMPRE un incremento (el incremento no debería estar donde está, de lo contrario se obtiene un ciclo infinito) y DEBE verificar que no haya llegado al final de la cadena (de lo contrario obtendrías una excepción) y, finalmente, tu bucle while no debería depender de CH1, porque eso nunca cambia (lo que de nuevo da como resultado un bucle infinito). Pero mi mejor consejo aquí es rastrear a través de su código con el depurador, para eso está. Entonces tus errores se volverían obvios.

Answer 4

Sus reglas son bastante complejas, por lo que puede intentar construir una máquina de estados finitos (FSM, DFA - autómata finito determinista ).

Cada char provoca la transición entre estados.

Por ejemplo, cuando se encuentra en el estado "entero iniciado" y se encuentra con el espacio, se obtiene un valor entero y el FSM pasa al estado "todo lo que se desea".

Si se encuentra en el estado "entero iniciado" y cumple ".", FSM pasa al estado "flotante o lista de enteros iniciada" y así sucesivamente.

Answer 5

Usted tiene respuestas y comentarios que sugieren el uso de una máquina de estados, y yo lo apoyo completamente. Desde el código que muestra en Edit1, veo que todavía no implementó una máquina de estado. Por los comentarios, creo que no sabes cómo hacerlo, así que para empujarte en esa dirección, aquí hay un enfoque:

Defina los estados con los que necesita trabajar:

type
TReadState = (ReadingIdle, ReadingText, ReadingInt, ReadingFloat);
// ReadingIdle, initial state or if no other state applies
// ReadingText, needed to deal with strings that includes digits (P7..)
// ReadingInt, state that collects the characters that form an integer
// ReadingFloat, state that collects characters that form a float

Luego define el esqueleto de tu máquina. Para mantenerlo lo más fácil posible, opté por utilizar un enfoque de procedimiento directo, con un procedimiento principal y cuatro subprocedimientos, uno para cada estado.

procedure ParseString(const s: string; strings: TStrings);
var
ix: integer;
ch: Char;
len: integer;
str, // to collect characters which form a value
res: string; // holds a final value if not empty
State: TReadState;
// subprocedures, one for each state
procedure DoReadingIdle(ch: char; var str, res: string);
procedure DoReadingText(ch: char; var str, res: string);
procedure DoReadingInt(ch: char; var str, res: string);
procedure DoReadingFloat(ch: char; var str, res: string);
begin
State := ReadingIdle;
len := Length(s);
res := '''';
str := '''';
ix := 1;
repeat
ch := s[ix];
case State of
ReadingIdle: DoReadingIdle(ch, str, res);
ReadingText: DoReadingText(ch, str, res);
ReadingInt: DoReadingInt(ch, str, res);
ReadingFloat: DoReadingFloat(ch, str, res);
end;
if res <> '''' then
begin
strings.Add(res);
res := '''';
end;
inc(ix);
until ix > len;
// if State is either ReadingInt or ReadingFloat, the input string
// ended with a digit as final character of an integer, resp. float,
// and we have a pending value to add to the list
case State of
ReadingInt: strings.Add(str + '' (integer)'');
ReadingFloat: strings.Add(str + '' (float)'');
end;
end;

Ese es el esqueleto. La lógica principal está en los cuatro procedimientos estatales.

 procedure DoReadingIdle(ch: char; var str, res: string);
begin
case ch of
''0''..''9'': begin
str := ch;
State := ReadingInt;
end;
'' '',''.'': begin
str := '''';
// no state change
end
else begin
str := ch;
State := ReadingText;
end;
end;
end;
procedure DoReadingText(ch: char; var str, res: string);
begin
case ch of
'' '',''.'': begin // terminates ReadingText state
str := '''';
State := ReadingIdle;
end
else begin
str := str + ch;
// no state change
end;
end;
end;
procedure DoReadingInt(ch: char; var str, res: string);
begin
case ch of
''0''..''9'': begin
str := str + ch;
end;
''.'': begin // ok, seems we are reading a float
str := str + ch;
State := ReadingFloat; // change state
end;
'' '','','': begin // end of int reading, set res
res := str + '' (integer)'';
str := '''';
State := ReadingIdle;
end;
end;
end;
procedure DoReadingFloat(ch: char; var str, res: string);
begin
case ch of
''0''..''9'': begin
str := str + ch;
end;
'' '',''.'','','': begin // end of float reading, set res
res := str + '' (float)'';
str := '''';
State := ReadingIdle;
end;
end;
end;

Los procedimientos estatales deben ser autoexplicativos. Pero solo pregunta si algo no está claro.

Las dos cadenas de prueba dan como resultado los valores enumerados según lo especificado. Una de sus reglas era un poco ambigua y mi interpretación podría ser incorrecta.

los números no pueden ser precedidos por una letra

El ejemplo que proporcionó es "P7", y en su código solo verificó el carácter anterior inmediato. Pero, ¿y si se lee "P71"? Lo interpreté como que "1" debería omitirse como "7", aunque el carácter anterior de "1" es "7". Esta es la razón principal del estado de ReadingText de ReadingText , que termina solo en un espacio o período.