सिंगल मूव्स का उपयोग करके ऐरे तत्व को k से मूव करना

मान लीजिए हमारे पास एक ऐरे है जिसमें 1 से n तक n तत्व शफल्ड ऑर्डर में हैं। एक और पूर्णांक K दिया गया है। N लोग हैं जो बैडमिंटन खेलने के लिए कतार में खड़े हैं। पहले दो खिलाड़ी खेलने जाएंगे, फिर हारने वाला कतार के अंत में जाएगा। विजेता कतार के अगले व्यक्ति के साथ खेलेगा और इसी तरह। वे तब तक खेलेंगे जब तक कोई लगातार K बार नहीं जीत जाता। फिर वह खिलाड़ी विजेता बन जाता है।

यदि कतार [2, 1, 3, 4, 5] है और K = 2, तो आउटपुट 5 होगा। व्याख्या देखें:

(2, 1) खेलते हैं, 2 जीतता है, इसलिए 1 कतार में जुड़ जाएगा: [3, 4, 5, 1] (2, 3) खेलते हैं, 3 जीतता है, 2 जुड़ता है: [4, 5, 1, 2] (3, 4) खेलते हैं, 4 जीतता है, 3 जुड़ता है: [5, 1, 2, 3] (4, 5) खेलते हैं, 5 जीतता है, 4 जुड़ता है: [1, 2, 3, 4] (5, 1) खेलते हैं, 5 जीतता है, 1 जुड़ता है: [2, 3, 4, 1] चूंकि 5 लगातार दो मैच जीतता है, आउटपुट 5 है।

एल्गोरिदम

winner(arr, n, k)

शुरुआत
    यदि k >= n-1, तो n वापस करें
    best_player := 0
    win_count := 0
    arr में प्रत्येक तत्व e के लिए करें
        यदि e > best_player, तो
            best_player := e
            यदि e 0वां तत्व है, तो win_count := 1
        अन्यथा
            win_count को 1 से बढ़ाएं
        यदि win_count >= k, तो best_player वापस करें
    पूर्ण
    best_player वापस करें
समाप्त

उदाहरण

#include <iostream>
using namespace std;

int winner(int arr[], int n, int k) {
    if (k >= n - 1) return n;
    int best_player = 0, win_count = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] > best_player) {
            best_player = arr[i];
            if (i) win_count = 1;
        } else {
            win_count += 1;
        }
        if (win_count >= k) return best_player;
    }
    return best_player;
}

int main() {
    int arr[] = {3, 1, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    cout << winner(arr, n, k);
    return 0;
}