介绍

您是停车场的主管，而您的经理正在为缩小规模做准备。

它是去年PAT最高级别中问题的简化版本。

挑战

你被要求计算有多少车是在很多的同时，在最。

适用标准规则。这是一个代码高尔夫球，因此最短的代码获胜。

第一行是条目的数量（不超过100,000，如果您愿意，您的输入可能不包含此行，因为这只是确定输入在何处结束的临时命令）。以下文本每行包含一个条目。每个条目包括三个数字：

<Car plate number> <Time (seconds) since open> <0(In) | 1(Out)>

修改2：可以使用三元组数组作为输入。

修改3：您可以在一个条目中更改数字的顺序。您可以选择使用哪个。（请参阅“备注”部分）

假定以下条件，则输入是有效的：

• Car plate number是10000〜范围内的整数99999
• Time是0〜范围内的整数86400

和

• 条目不一定按时间顺序排列。
• 第一秒之前没有车。
• 有没有必要在最后一秒钟后，没有车。
• 汽车在驶入之前不会离开。
• Car plate number是独特的。（但同一辆车可能会多次访问）
• 因此，当汽车已经进入其中时，它不可能进入该区域。
• 同一辆车不会在同一时间进出time。
• 进/出时，一辆车被认为是很多车。

例子1

输入值

11
97845 36000 1
75487 16500 1
12345 16 0
75486 3300 0
12345 6500 1
97845 32800 0
12345 16400 0
97846 16501 1
97846 16500 0
75486 8800 1
75487 3300 0

输出量

3

说明

在16500，车12345和75487人在停车场。

例子2

我这样做是因为我发现很多代码都失败了。

输入（省略第一行）

12345 16400 0
12345 16500 1
75487 16500 0
75487 16600 1

输出量

2

说明

在16500，车12345和75487人在停车场。

备注

实际上，并非所有三个输出都需要。至少，您只需要plate + time或in / out + time作为结果。但是在两种情况下，该算法略有不同，因此较短的选择在某种语言中仍然是未知的。当然，您可以使用所有三个数字。所以我让他们处于挑战之中。

Mathematica，33个字节

-Min@Accumulate[2#2-1&@@@Sort@#]&

我必须更好地阅读问题说明，以意识到有一种更简单的算法不需要牌照信息。

未命名函数返回整数；输入格式是形式的有序三元组列表{time, 0|1, license plate}。我们从Sorting 开始，它使列表按时间顺序排列，并且还通过在0s之前对1s 进行排序来打破时间关系；然后2#2-1&@@@保留到达/离开的信息并忘记其余信息，并将0s 转换为-1s。

Accumulate计算该列表的运行总计；结果是列出每次到达/离开后停车场中汽车数量的负数。然后Min从中选取最小（最负）的负号。

Mathematica，56个字节

Max[<|#|>~Count~0&/@FoldList[List,{},#3->#2&@@@Sort@#]]&

原始提交（前几条评论引用了此提交）。未命名函数返回整数；输入格式是形式的有序三元组列表{time, 0|1, license plate}。

我们选择将时间输入放在第一位，将输入/输出输入放在第二位的原因是，以便Sort@#按时间顺序对列表进行排序，如果同时到达，则在到达之前记录到达时间。之后，#3->#2&@@@返回license plate -> 0|1仍按时间顺序排列的形式的“规则”列表。

然后，FoldList[List,{},...]创建该规则列表的所有初始段的列表。实际上，它确实弄乱了那些最初的细分市场。所述k第初始段结束是与深度2一个规则，在深度3一个规则，...，和在深度一个规则的列表k1。（FoldList[Append,{},...]将产生更自然的结果。）但是，<|#|>将这些初始片段中的每一个都变成一个“关联”，这具有两个理想的效果：首先，它完全使我们刚刚创建的嵌套列表结构变平；其次，它迫使以后的规则优先于以前的规则，这正是我们在这里所需要的-对于任何离开停车场的汽车，其初始进入的记录现在已经完全消失了（对于重新进入的汽车也是如此） 。

因此，剩下要做的就是每个关联中有Count多少个0，然后取Max。

Haskell，76 63 61字节

@nimi的建议的变体节省了2个字节。

f l=maximum$scanl1(+)[(-1)^c|i<-[0..8^6],(_,b,c)<-l,i==2*b+c]

期望参数以问题语句给出的顺序为三元组列表。

对于每个可能的时间（以及更多时间），我们首先搜索即将到来的汽车事件，然后搜索离开的汽车事件，然后将其转换为正负列表。我们取该列表的部分和，然后取这些部分和的最大值。

PHP 7.1，126个 117字节

for(;$s=file(i)[++$i];)$d[+substr($s,6)][$s[-2]]++;ksort($d);foreach($d as$a){$r=max($r,$n+=$a[0]);$n-=$a[1];}echo$r;

从文件中获取输入i，忽略第一行。用运行-r。
在输入中需要尾随换行符。更换-2用-3的Windows。

分解

# generate 2-dim array; first index=time, second index=0/1 (in/out);
# values=number of cars arriving/leaging; ignore plate number
for(;$s=file(i)[++$i];) # read file line by line (includes trailing newline)
    $d[+substr($s,6)][$s[-2]]++;    # substring to int=>time, last but one character=>1/0
ksort($d);                      # sort array by 1st index (time)
foreach($d as$a)    # loop through array; ignore time
{
    $r=max($r,                      # 2. update maximum count
        $n+=$a[0]                   # 1. add arriving cars to `$n` (current no. of cars)
    );
    $n-=$a[1];                      # 3. remove leaving cars from `$n`
}
echo$r;                         # print result

C，147字节

完整的程序，从中读取输入stdin。

int r[86402]={},u,i,n,t;g(s,o){for(;s<86401;n<r[s]?n=r[s]:0,++s)r[s+o]+=o?-1:1;}main(){for(n=0;scanf("%d%d%d",&u,&t,&i)==3;g(t,i));printf("%d",n);}

在ideone上尝试一下。

八度，50，64 38个字节

@(A)-min(cumsum(sortrows(A)(:,2)*2-1))

与@Greg Martin的Mathematica答案相同

该函数获取3列数组 [time, i/o,plateN]

先前的答案：

@(A){[t,O]=A{:};max(cumsum(sparse({++t(!O),t}{2},1,!O*2-1)))}{2}

该函数仅从包含三个输入的单元格数组的前两个元素中获得两个输入t：time和O：I / O A！

创建一个稀疏矩阵以对每个记录的现有汽车数量进行计数。因此，考虑退出时间+ 1代表轿厢退出，并且将1更改为-1，将0更改为1。
在这里使用稀疏非常重要，因为可能同时有多辆轿厢到达或离开。
然后找到计算得出的总和，代表该批次中当前汽车的数量和最大数量。

JavaScript（ES6），63 73 71字节

d=>Math.max(...d.sort((a,[b,c])=>a[s=0]-b||a[1]-c).map(e=>s+=1-e[1]*2))

这接受输入作为有序条目数组[time, inout, plate]。不幸的是，由于相同的出站时间意味着两辆车都在同一时刻被考虑到这一事实，因此排序算法必须0在之前订购1，这花费了11个字节。

学分

• 通过完全移动map函数内部的移位和乘法，我节省了1个字节（感谢Neil）。
• 我在sort函数中使用了一个分解后的参数，节省了另外两个字节（感谢edc65）。

演示版

// test the two examples
console.log([[[36000,1],[16500,1],[16,0],[3300,0],[6500,1],[32800,0],[16400,0],[16501,1],[16500,0],[8800,1],[3300,0]],[[16400,0],[16500,1],[16500,0],[16600,1]]].map(
// answer submission
d=>Math.max(...d.sort((a,[b,c])=>a[s=0]-b||a[1]-c).map(e=>s+=1-e[1]*2))
));

JavaScript（ES6），83 … 68 70字节

编辑：修复以支持第二个示例

将输入作为数组的[in_out, time, plate]数组。但是该plate列实际上被忽略。

a=>a.sort(([a,b],[c,d])=>b-d||a-c).map(v=>a=(n+=1-v[0]*2)<a?a:n,n=0)|a

测试

let f =

a=>a.sort(([a,b],[c,d])=>b-d||a-c).map(v=>a=(n+=1-v[0]*2)<a?a:n,n=0)|a

console.log(f([
  [1, 36000, 97845],
  [1, 16500, 75487],
  [0, 16,    12345],
  [0, 3300,  75486],
  [1, 6500,  12345],
  [0, 32800, 97845],
  [0, 16400, 12345],
  [1, 16501, 97846],
  [0, 16500, 97846],
  [1, 8800,  75486],
  [0, 3300,  75487]
]));

console.log(f([
  [0, 16400, 12345],
  [1, 16500, 12345],
  [0, 16500, 75487],
  [1, 16600, 75487]
]));