2025-01-10：找到连续赢 K 场比赛的第一位玩家。用go语言，有 n 位玩家参与比赛，玩家的编号从 0 到 n - 1。

你将获得一个长度为 n 的整数数组 skills，以及一个正整数 k，其中 skills[i] 表示第 i 位玩家的技能水平。

数组中的所有技能值都是不同的。

玩家按照编号从 0 到 n - 1 排成一列进行比赛。比赛规则如下：

1.队列中最前面的两名玩家进行对决，技能等级高的玩家获胜。

2.比赛结束后，获胜者留在队列前面，而失败者则被移到队列的末尾。

赢家的定义是：首次连续赢得 k 场比赛的玩家。请你返回这名玩家的编号。

n == skills.length。

2 <= n <= 100000。

1 <= k <= 1000000000。

1 <= skills[i] <= 1000000。

skills 中的整数互不相同。

答案2025-01-10：

chatgpt

题目来自leetcode3175。

大体步骤如下：

1. 首先在 findWinningPlayer 函数中，初始化计数器 cnt 为0，以及设定初始索引 i 和 lastI 都为0。这里记录了当前遍历的索引和上一个找到连续k胜利的玩家索引。

2. 进入循环，在每轮循环中，设定初试比较索引 j 为 i+1，然后在内部循环中，判断比较 j 是否小于n且技能是否高于当前玩家，并且计数器 cnt 小于 k 的情况下，递增 j 和 cnt。

3. 如果计数器 cnt 达到 k，说明当前玩家赢得了连续 k 场比赛，返回当前玩家的索引 i。

4. 如果不满足条件，将计数器 cnt 重新设为1（因为当前玩家至少赢了一场比赛），更新上一个找到连续k胜利的玩家索引 lastI 为当前玩家的索引 i，并将 i 更新为 j 继续循环寻找下一位玩家。

5. 在主函数 main 中定义了输入的技能数组 skills 和整数 k，然后调用 findWinningPlayer 函数来找到第一个连续赢得 k 场比赛的玩家索引，最后将结果打印出来。

总的时间复杂度是 O(n)，在最坏情况下会遍历一遍技能数组。

总的额外空间复杂度是 O(1)，因为只使用了常数个额外的变量来跟踪索引和计数器。

Go完整代码如下：

package main

import (
	"fmt"
)

func findWinningPlayer(skills []int, k int) int {
    n := len(skills)
    cnt := 0
    i, lastI := 0, 0

    for i < n {
        j := i + 1
        for j < n && skills[j] < skills[i] && cnt < k {
            j++
            cnt++
        }
        if cnt == k {
            return i
        }
        cnt = 1
        lastI = i
        i = j
    }
    return lastI
}


func main() {
	skills := []int{4,2,6,3,9}
	k := 2
	result := findWinningPlayer(skills,k)
	fmt.Println(result)
}

Rust完整代码如下：

fn find_winning_player(skills: Vec<i32>, k: i32) -> usize {
    let n = skills.len();
    let mut cnt = 0;
    let (mut i, mut last_i) = (0, 0);

    while i < n {
        let mut j = i + 1;
        while j < n && skills[j] < skills[i] && cnt < k {
            j += 1;
            cnt += 1;
        }
        if cnt == k {
            return i;
        }
        cnt = 1;
        last_i = i;
        i = j;
    }
    last_i
}

fn main() {
    let skills = vec![4, 2, 6, 3, 9];
    let k = 2;
    let result = find_winning_player(skills, k);
    println!("{}", result);
}

C完整代码如下：

#include <stdio.h>

int findWinningPlayer(int skills[], int n, int k) {
    int cnt = 0;
    int i, lastI = 0;

    for (i = 0; i < n; ) {
        int j = i + 1;
        while (j < n && skills[j] < skills[i] && cnt < k) {
            j++;
            cnt++;
        }
        if (cnt == k) {
            return i;
        }
        cnt = 1;
        lastI = i;
        i = j;
    }
    return lastI;
}

int main() {
    int skills[] = {4, 2, 6, 3, 9};
    int n = sizeof(skills) / sizeof(skills[0]);
    int k = 2;
    int result = findWinningPlayer(skills, n, k);
    printf("%d\n", result);
    return 0;
}

C++完整代码如下：

#include <iostream>
#include <vector>

int findWinningPlayer(std::vector<int>& skills, int k) {
    int n = skills.size();
    int cnt = 0;
    int i, lastI = 0;

    for (i = 0; i < n; ) {
        int j = i + 1;
        while (j < n && skills[j] < skills[i] && cnt < k) {
            j++;
            cnt++;
        }
        if (cnt == k) {
            return i;
        }
        cnt = 1;
        lastI = i;
        i = j;
    }
    return lastI;
}

int main() {
    std::vector<int> skills = {4, 2, 6, 3, 9};
    int k = 2;
    int result = findWinningPlayer(skills, k);
    std::cout << result << std::endl;
    return 0;
}

Python完整代码如下：

# -*-coding:utf-8-*-

def find_winning_player(skills, k):
    n = len(skills)
    cnt = 0
    i, last_i = 0, 0

    while i < n:
        j = i + 1
        while j < n and skills[j] < skills[i] and cnt < k:
            j += 1
            cnt += 1
        if cnt == k:
            return i
        cnt = 1
        last_i = i
        i = j
    return last_i

def main():
    skills = [4, 2, 6, 3, 9]
    k = 2
    result = find_winning_player(skills, k)
    print(result)

if __name__ == "__main__":
    main()

JavaScript完整代码如下：

function findWinningPlayer(skills, k) {
    let n = skills.length;
    let cnt = 0;
    let i, lastI = 0;

    for (i = 0; i < n; ) {
        let j = i + 1;
        while (j < n && skills[j] < skills[i] && cnt < k) {
            j++;
            cnt++;
        }
        if (cnt === k) {
            return i;
        }
        cnt = 1;
        lastI = i;
        i = j;
    }
    return lastI;
}

const skills = [4, 2, 6, 3, 9];
const k = 2;
const result = findWinningPlayer(skills, k);
console.log(result);