在计时应用程序中对赛车手进行排序

Question

我正在创建一个使用 AMB MyLaps 解码器 P3 协议的应用程序。

我想不出一种根据圈数和圈速对赛车手进行分类的方法。例如，第 1 位的人跑了 3 圈，第 2 位的人跑了 2 圈。但是，我如何订购 2 人在同一圈的情况？

这是我用来保存信息的记录：

type
  TTimingRecord = record
    position: integer;
    transId: integer;
    racerName:  string;
    kartNumber: integer;
    lastPassingN: integer;
    laps: integer;
    lastRTCTime:  TDateTime;
    bestTimeMs: Extended;
    lastTimeMs: Extended;
    gapTimeMs:  Extended;
    splitTimeMs:  Extended;
    timestamp:  TDateTime;
  end;

为每位赛车手创造一个新纪录。

我目前使用的代码是：

procedure sortRacers();
var
  Pos, Pos2: Integer;
  Temp: TTimingRecord;
  GapTime: Extended;
begin
  for Pos := 0 to length(DriversRecord)-1 do
  begin
    for Pos2 := 0 to Length(DriversRecord)-2 do
    begin
      if(DriversRecord[Pos2].laps < DriversRecord[Pos2+1].laps)then
      begin
        Temp := DriversRecord[Pos2];
        DriversRecord[Pos2] := DriversRecord[Pos2+1];
        DriversRecord[Pos2+1] := Temp;
      end
      else if DriversRecord[Pos2].laps = DriversRecord[Pos2+1].laps then
           begin
             if DriversRecord[Pos2].lastRTCTime > DriversRecord[Pos2+1].lastRTCTime then
             begin
              Temp := DriversRecord[Pos2];
              DriversRecord[Pos2] := DriversRecord[Pos2+1];
              DriversRecord[Pos2+1] := Temp;
             end;
           end;
    end;
  end;

  for pos := 1 to length(DriversRecord) -1 do   //Gap Time
  begin
    if DriversRecord[Pos].laps = DriversRecord[0].laps then
    begin
      DriversRecord[Pos].gapTimeMs := DriversRecord[Pos].lastRTCTime - DriversRecord[0].lastRTCTime;

      DriversRecord[Pos].splitTimeMs := DriversRecord[Pos].lastRTCTime - DriversRecord[Pos-1].lastRTCTime;
    end;
  end;
end;

但效果不太好:)

Answer 1

我假设根据您对问题的评论，您已将问题分解为排序和比较，并且您已经涵盖了排序部分。剩下的就是订单比较。

您需要一个函数来执行字典顺序比较，该比较首先基于完成的圈数，然后是自该圈开始以来的时间。基本上它会是这样的：

function CompareRacers(const Left, Right: TTimingRecord): Integer;
begin
  Result := CompareValue(Left.laps, Right.laps);
  if Result=0 then
    Result := CompareDateTime(Left.lastRTCTime, Right.lastRTCTime);
end;

您会在Math 中找到CompareValue，在DateUtils 中找到CompareDateTime。

我不确定lastRTCTime 值的含义是什么。您可能需要对调用CompareDateTime 的结果取反才能得到您想要的结果。

Result := -CompareDateTime(Left.lastRTCTime, Right.lastRTCTime);

另外，如果在单圈中超车会怎样？大概在赛车手完成当前圈之前，您无法检测到这一点。

Answer 2

不要自己做排序算法，试试这个技术（如果你有兼容的 Delphi 版本）：Best way to sort an array

您的函数可能如下所示：

uses Types;

function CustomSort(const Left, Right: TTimingRecord): Integer
begin
  If (left.laps > right.laps) then
     result := GreaterThanValue
  else 
  if (left.laps < right.laps) then
      result := LessThanValue
  else 
  begin
      // Same laps count... Test on LastRTCTime 
      if (left.lastRTCTime < right.lastRTCTime) then
          result := GreaterThanValue1
      else
      if (left.lastRTCTime > right.lastRTCTime) then
          result := LessThanValue
      else
          result := EqualsValue; 
  end;
end));

Answer 3

将其视为两种不同的类别可能更容易。

显然你知道冒泡排序方法，所以我不再赘述。

对您的排序进行 2 次传递。 第一，你对圈数进行排序。

第二，您遍历整个排序圈列表。在数组中找到相同圈值的起点和终点。从开始点和结束点再次进行排序，但这次只比较次要值。如果相同值的计数大于 1，则遍历所有相同的辅助值。

Answer 4

这段代码是关于使用索引对数据进行排序的。比冒泡排序快得多。 它是动态的，并提供从数组中的起点到终点进行排序的能力。 代码本身比 Bubble-Sort 大，但没有多少算法可以在速度上进行比较。 代码（当理解它的工作原理时）可以很容易地修改以适应大多数类型的排序。在 65536 个字符串的数组上，它只需要进行 17 次比较（或大约） 与冒泡排序相比，每个比较周期的 CPU 周期要多一些，但仍然是最快的方法之一。 搜索与 BTREE 一样快。实际排序可能会慢一些，但之后数据更易于管理，无需真正平衡树。

享受吧。

注意：例程并不是实际问题的完整解决方案，但它提供了一种极快方法的开始。

---

TYPE
  DynamicIntegerArray = ARRAY OF INTEGER;
  DynamicStringArray  = ARRAY OF STRING;

VAR
  BinSortLo, BinSortMid, BinSortHi : INTEGER; 

FUNCTION FindMid:INTEGER;
  BEGIN
    FindMid:=BinSortLo+((BinSortHi-BinSortLo) DIV 2);
  END;

PROCEDURE ShiftIndexUpAndStorePointer(VAR ArrParamIndex: DynamicIntegerArray; HighBound:INTEGER);
  VAR
    x : INTEGER;
  BEGIN
    FOR x:=HighBound-1 DOWNTO BinSortMid DO ArrParamIndex[x+1] := ArrParamIndex[x];// Shift the index.
    ArrParamIndex[BinSortMid]:=HighBound;// Store the pointer to index at its sorted place
  END;

PROCEDURE BinarySortUp(CONST ArrParam:DynamicStringArray; VAR ArrParamIndex: DynamicIntegerArray; CONST LoBound,HighBound:INTEGER); OVERLOAD;
  VAR
    TempVar : STRING;
  BEGIN
    BinSortLo:=LoBound; BinSortHi:=HighBound; BinSortMid:=FindMid;
    TempVar := ArrParam[HighBound];
    REPEAT
  IF TempVar>ArrParam[ArrParamIndex[BinSortMid]] THEN BinSortLo:=BinSortMid ELSE BinSortHi:=BinSortMid;
  BinSortMid:=FindMid;
    UNTIL (BinSortMid=BinSortLo); {OR (BinSortMid=BinSortHi);}
    IF TempVar>ArrParam[ArrParamIndex[BinSortMid]] THEN INC(BinSortMid);// We always need a last check just in case.
    ShiftIndexUpAndStorePointer(ArrParamIndex,HighBound);
  END;

PROCEDURE DynamicCreateIndex(CONST ArrParam:DynamicStringArray; VAR ArrParamIndex: DynamicIntegerArray; CONST LoBound,HighBound:INTEGER);
  VAR
    x : INTEGER;
  BEGIN
    FOR x:=LoBound TO HighBound DO
    BinarySortUp(ArrParam,ArrParamIndex,LoBound,x);
  END;


BEGIN
{
1. Create your STRING ARRAY as a DynamicStringArray. 
2. Create your INDEX ARRAY as a DynamicIntegerArray.
3. Set the size of these arrays to any INTEGER size and fill the strings with data.
4. Run a call to DynamicCreateIndex(YourStringArray,YourIndexArray,0,SizeOfArray
Now you have a sorted Index of all the strings.

}
END.