1

我正在创建一个使用 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;

但效果不太好:)

4

4 回答 4

2

我从您对问题的评论中假设您已将问题分解为排序和比较，并且您已经涵盖了排序部分。这留下了订单比较。

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

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;

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

我不确定的是lastRTCTime价值观的意义是什么。您可能需要否定调用CompareDateTime的结果才能获得您想要的结果。

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

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

于 2013-04-02T14:22:24.727 回答
1

与其自己做排序算法，不如试试这个技术（如果你有兼容的 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));
于 2013-04-02T14:24:35.753 回答
0

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

显然你知道冒泡排序方法，所以我不会深入讨论。

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

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

于 2013-04-02T20:51:50.297 回答
0

此代码是关于使用索引对数据进行排序的。比冒泡排序快得多。它是动态的，并提供从数组中的起点到终点进行排序的能力。代码本身比 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.
于 2013-04-08T03:31:41.383 回答