#include <bits/stdc++.h>
  using namespace std;
 
const int N = 1e5+1;
queue<int>q[N];

void solve(){
 
  int n,k;
  cin>>n;
 
  // 1 2 3
 
  vector<int>v(n);

 
  int ans = 1e9;
 
  for(int i=0;i<n;i++){
    cin>>v[i];
  }
 
  cin>>k;
 
    for(int i=0;i<n;i++){
     
      if(q[v[i]].size()==k)q[v[i]].pop();
     
      if(q[v[i]].size()==k-1){
        ans = min(i-q[v[i]].front(),ans);
       
      }
      q[v[i]].push(i);
  }
 
 
  if(ans == 1e9){cout<<"-1"<<endl;return;}
  
 
  cout<<ans-k+1<<endl;
  return;
 
 

 
 
 
}

  signed main() {

    solve();

    return 0;

  }

this was video streaming ✅
Amazon

int64_t getDiscountPairs(int x, vector<int> price)
{
  const size_t n = price.size();
  map<int, int64_t> cnt;
  int64_t res = 0;
  for (int i = 0; i < n; i++) {
    int uu = price[i];
    int v = uu % x;
    if (v == 0) res += cnt[0];
    else res += cnt[x - v]; 
    cnt[v]++;
  }
  return res;
}

use long instead of int_64

Amazon ✅

#include <bits/stdc++.h>
using namespace std;

class SinglyLinkedListNode {
public:
    int data;
    SinglyLinkedListNode* next;

    SinglyLinkedListNode(int node_data) {
        this->data = node_data;
        this->next = nullptr;
    }
};

SinglyLinkedListNode* findLongestList(SinglyLinkedListNode* head) {
    if (!head) return nullptr;

    SinglyLinkedListNode* curr = head;
    SinglyLinkedListNode* start = head;
    SinglyLinkedListNode* bestStart = head;

    int length = 1;
    int bestLength = 1;

    while (curr->next) {
        if (curr->data >= curr->next->data) {
            length++;
        } else {
            if (length > bestLength) {
                bestLength = length;
                bestStart = start;
            }
            length = 1;
            start = curr->next;
        }
        curr = curr->next;
    }

    // Check at the end in case the best sub-list is at the very end.
    if (length > bestLength) {
        bestLength = length;
        bestStart = start;
    }

    // Truncate the list after the longest non-increasing sub-list
    SinglyLinkedListNode* temp = bestStart;
    for (int i = 1; i < bestLength && temp; i++) {
        temp = temp->next;
    }
    if (temp) {
        temp->next = nullptr;
    }

    return bestStart;
}

C++✅

#include<bits/stdc++.h>
using namespace std;

vector<int> getMeanRankCount(vector<int>& rank) {
    int n = rank.size();
    vector<long long> prefixSum(n + 1, 0);
    for (int i = 0; i < n; ++i) {
        prefixSum[i + 1] = prefixSum[i] + rank[i];
    }

    vector<int> res(n, 0);
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < n; ++j) {
            long long sum = prefixSum[j + 1] - prefixSum[i];
            long long len = j - i + 1;
           
            if (sum % len == 0) {
                long long mean = sum / len;
                if (mean <= n) {
                    res[mean - 1]++;
                }
            }
        }
    }
    return res;
}

int main() {
    vector<int> ranks = {4,7,3,6,5,2,1};
    vector<int> result = getMeanRankCount(ranks);
   
    for (int val : result) {
        cout << val << " ";
    }
    return 0;
}

Amazon C++✅