Question

我要做的是确定括号是否正确。例如，([][[]]<<>>)是vallid，但][]<<(>>)不是。

我有一个工作版本，但效率很高，当它获得1000多个括号时，它只是疯狂的慢。我希望有人可能会提出一些可能的改进或其他方法来做到这一点。

这是我的代码：

program Codex;

const
    C_FNAME = 'zavorky.in';

var TmpChar     : char;
    leftBrackets, rightBrackets : string;
    bracketPos         : integer;
    i,i2,i3         : integer;
    Arr, empty : array [0..10000] of String[2];
    tfIn    : Text;
    result : boolean;

begin
    leftBrackets := ' ( [ /* ($ <! << ';
    rightBrackets := ' ) ] */ $) !> >> ';
    i := 0;
    result := true;
    Assign(tfIn, C_FNAME);
    Reset(tfIn);

    { load data into array }
    while not eof(tfIn) do
    begin
        while not eoln(tfIn) do
        begin
            read(tfIn, TmpChar);
            if (TmpChar <> ' ') then begin
                if (TmpChar <> '') then begin
                    Arr[i] := Arr[i] + TmpChar;
                    end
                end
            else
                begin                                       
                    i := i + 1;
                end
        end;

        i2 := -1;
        while (i2 < 10000) do begin     
            i2 := i2 + 1;
            {if (i2 = 0) then
                writeln('STARTED LOOP!');}
            if (Arr[i2] <> '') then begin
                bracketPos := Pos(' ' + Arr[i2] + ' ',rightBrackets);
                if (bracketPos > 0) then begin
                    if (i2 > 0) then begin
                        if(bracketPos = Pos(' ' + Arr[i2-1] + ' ',leftBrackets)) then begin
                            {write(Arr[i2-1] + ' and ' + Arr[i2] + ' - MATCH ');}

                            Arr[i2-1] := '';
                            Arr[i2] := '';
                            { reindex our array }
                            for i3 := i2 to 10000 - 2 do begin
                                Arr[i3 - 1] := Arr[i3+1];
                                end;

                            i2 := -1;
                            end;
                        end;                    
                    end;
                end;
            end;

        {writeln('RESULT: ');}
        For i2:=0 to 10 do begin
            if (Arr[i2] <> '') then begin
                {write(Arr[i2]);}
                result := false;
            end;
            {else
            write('M');}
        end;

        if (result = true) then begin
            writeln('true');
            end
        else begin
            writeln('false');
        end;

        result := true;

        { move to next row in file }
        Arr := empty;
        i := 0;
        readln(tfIn);
    end;

    Close(tfIn);

    readln;
end.

zavorky.in文件中的输入数据如下所示：

<< $) >> << >> ($ $) [ ] <! ( ) !>
( ) /* << /* [ ] */ >> <! !> */

我确定每一行是否有效。一行中的最大括号数为10000。

Answer 1

您从文件中读取字符。以逐字节模式读取的文件非常慢。您需要优化读取字符串（缓冲区）的方式，或者首先将文件加载到内存中。

下面我提出另一种处理获取字符串的方法。

首先，我宣布会说明你可能拥有的括号的结果：

end

我决定这样做，因为现在你不仅限于括号表达式的长度和/或括号类型的数量。每个收盘和相应的开盘括号的指数差等于10.

这是函数的代码：

procedure BlckRead;
var
  f: file;
  pc, pline: { PChar } PAnsiChar;
  Ch: { Char } AnsiChar;
  LngthLine, LngthPc: word;
begin
  AssignFile(f, 'b:\br.txt');   //open the file
  Reset(f, 1);
  GetMem(pc, FileSize(f) + 1);  //initialize memory blocks
  inc(pc, FileSize(f)); //null terminate the string
  pc^ := #0;
  dec(pc, FileSize(f)); //return the pointer to the beginning of the block

  GetMem(pline, FileSize(f)); //not optimal, but here is just an idea.
  pline^ := #0;//set termination => length=0
  BlockRead(f, pc^, FileSize(f)); // read the whole file
                                  //you can optimize that if you wish,
                                  //add exception catchers etc.
  LngthLine := 0; // current pointers' offsets
  LngthPc := 0;
  repeat
    repeat
      Ch := pc^;
      if (Ch <> #$D) and (Ch <> #$A) and (Ch <> #$0) then
      begin // if the symbol is not string-terminating then we append it to pc
        pline^ := Ch;
        inc(pline);
        inc(pc);
        inc(LngthPc);
        inc(LngthLine);
      end
      else
      begin //otherwise we terminate pc with Chr($0);
        pline^ := #0;
        inc(LngthPc);
        if LngthPc < FileSize(f) then
          inc(pc);
      end;
    until (Ch = Chr($D)) or (Ch = Chr($A)) or (Ch = Chr($0)) or
      (LngthPc = FileSize(f));

    dec(pline, LngthLine);
    if LngthLine > 0 then //or do other outputs
      Showmessage(pline + #13#10 + Booltostr(ExpressionIsValid(pline), true));

    pline^ := #0; //actually can be skipped but you know your file structure better
    LngthLine := 0;
  until LngthPc = FileSize(f);

  FreeMem(pline);                          //free the blocks and close the file
  dec(pc, FileSize(f) - 1);
  FreeMem(pc);
  CloseFile(f);
end;

也许，我们通过创建一个字节数组来做额外的工作，但似乎这个方法是i）更容易理解，ii）是灵活的，因为我们可以改变括号表达式的长度，例如使用和检查{{ 1}} / k括号等。

<强>追加

一旦我看到主要问题在于组织块文件读取，我就在这里给出一个如何做到这一点的想法：

...0110011

Answer 2

您将所有数据保存到内存中（甚至几次），然后您需要进行大量检查。我认为你走在正确的轨道上，但你可以采取更容易的步骤。

创建一个整数数组（默认值= 0），其长度为您拥有的括号数（例如“( [ /* ($ <! << ' ==> 6）
现在确保您遵守要求。逐行阅读文件并仅考虑前10000个。This可以提供帮助。
每次从第一个数组中找到一个元素（例如leftBrackets）时，将+1添加到步骤1的数组的相应索引的值。示例如下： '[' ==> checkArray[1] += 1
对右栏进行相同操作，但这次检查该值是否大于0.如果是，则以相同的方式减去1（例如']' ==> checkArray[1] -= 1），否则您只找到无效括号

我希望这会有所帮助并祝你好运。

Answer 3

我认为以下内容应该有效，并且将是 O（n），其中n是字符串的长度。首先建立两个功能。

IsLeft（文胸：TBracket）可以确定括号是左括号还是右括号，因此IsLeft（'＆lt;'）= TRUE，IsLeft（'＆gt;＆gt;'） = FALSE。

IsMatchingPair（bra，ket：TBracket）可以确定两个括号是否具有相同的“类型”，因此IsMatchingPair（'（'，'）'）= TRUE，但IsMatchingPair（'{ '，'＆gt;＆gt;'）= FALSE。

然后构建一个堆栈 TBracketStack ，其中包含三个函数 procedure Push（bra：TBracket），以及 function Pop：TBracket 和 function IsEmpty：boolean 。

现在应该使用以下算法（需要一些额外的代码来确保您不会意外地脱离字符串的结尾）：

 BracketError := FALSE;
 while StillBracketsToProcess(BracketString) and not BracketError do
 begin
   bra := GetNextBracket(BracketString);
   if IsLeft(bra) then 
     Stack.Push(bra) 
   else
     BracketError := Stack.IsEmpty or not IsMatchingPair(Stack.Pop,bra)
 end;

检查括号顺序是否有效

3 个答案: