#include<stdio.h>
#include<stdlib.h>

#define MOD 1000000007

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    int N;
    scanf("%d", &N);

    if (N <= 1) {
        printf("NO HOURS\n");
        return 0;
    }

    int *A = (int*)malloc(N * sizeof(int));

    for (int i = 0; i < N; i++) {
        scanf("%d", &A[i]);
    }

    qsort(A, N, sizeof(int), compare);

    int count = 0;

    for (int i = 0; i < N - 1; i++) {
        for (int j = i + 1; j < N; j++) {
            if ((A[i] + A[j]) % 60 == 0) {
                count = (count + 1) % MOD;
            }
        }
    }

    if (count > 0) {
        printf("%d\n", count);
    } else {
        printf("NO HOURS\n");
    }

    free(A);

    return 0;
}

Hours Count ✅
NPCI

Googly or Not googly ✅
NPCI

import java.util.*;

class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }

        ArrayList<Integer> arr = new ArrayList<>();
        int c = 1;

        for (int i = 0; i < n - 1; i++) {
            if (a[i] != a[i + 1]) {
                arr.add(c);
                c = 1;
            } else {
                c++;
            }
        }

        arr.add(c);

        int ans = 0;

        if (arr.size() == 2) {
            ans = Math.min(arr.get(0), arr.get(1)) * 2;
        } else if (arr.size() > 2) {
            ans = Collections.max(arr.subList(1, arr.size() - 1)) * 2;
        }

        System.out.println(ans);
    }
}

Longest Mirror subArray
NPCI✅

Hours Count ✅

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

vector<int> solve(int Q, vector<vector<int>> queries) {
    vector<int> ans, a(10005, 0);

    for (vector<int>& query : queries) {
        int type = query[0], element = query[1];

        if (type == 0) {
            a[element] = 1;
        } else {
            if (a[element]) {
                ans.push_back(1);
                a[element] = 0;
            } else {
                ans.push_back(0);
            }
        }
    }

    return ans;
}

BST Queries ✅

Opening For GIS Executive( 0-2 Year Only)

Location - Corporate Office Noida West.

Email:- Support@dvertex.com

Reduce to one ✅
NPCI

📣 Job Title: Salesforce Developer (Freshers)

🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟

🏢 Company: VITTECH PVT LTD

📍Location: Pune

👉 Exp: 0- 1 Years

📩 Mail: megha@vittech.in

bool help(int n,unordered_set<char>&mpp)
{
    string s=to_string(n);
    for(auto it:s)
    {
        if(mpp.count(it)) return 1;
    }
    return 0;
}
int solve(vector<int>&a,int n)
{
    sort(a.begin(),a.end());
    int maxi=a[n-1];
    string s=to_string(maxi);
    unordered_set<char>mpp;
    for(auto it:s) mpp.insert(it);

    int ans=-1;
    for(int i=0;i<n-1;i++)
    {
        if(help(a[i],mpp)==0) ans=a[i];
    }
    if(ans==-1) return -1;
    return ans+maxi;
}

Microsoft ✅

Budget planning ✅

#include <bits/stdc++.h>


using namespace std;

int n;
int a[30];
int memo[1 << 23];
int inf = 100;

int solve(int flag){
  if(memo[flag] != -1) return memo[flag];
  if(flag == 1) return 1;

  int ret = inf;
  int b = __builtin_popcount(flag);
  for(int i = n - 1; i >= 0; i--){
    if(flag & (1 << i)){
      int next = (flag ^ (1 << i)) | (1 << (i - 1));
      for(int j=0;j<i;j++)for(int k=0;k<j+1;k++){
        if(a[j] + a[k] == a[i]){
          int tmp = solve(next | (1 << j) | (1 << k));
          if(tmp != inf){
            ret = min(ret, max(b, tmp));
          }
        }
      }
      break;
    }
  }

  return memo[flag] = ret;
}

int main(){
cin>>n;

  for(int i=0;i<n;i++)
  {cin>>a[i];
  }
  memset(memo, -1, sizeof(memo));
  int ans = solve(1 << (n - 1));
  if(ans == inf) ans = -1;
cout<<ans<<endl;
}

Minimum contrast ✅

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

#define mod 1000000007
#define N 300009


int dp[59][59];
string s[N],t,p,ans;

int f(int i,int j)
{
    if(i==t.size())
        return p.size()-j;
    if(j==p.size())
        return t.size()-i;
    if(dp[i][j]!=-1)
        return dp[i][j];
    if(t[i]==p[j])
        return dp[i][j] = f(i+1,j+1);
    return dp[i][j] = 1 + min({ f(i+1,j), f(i,j+1), f(i+1,j+1)});
}

int main()
{
  ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
   int n;
   cin>>n;
   int i=0;
   while(i<n)
       cin>>s[i++];
    
     int q,best,j,k;
    
     cin>>q;
     while(q--)
     {
         cin>>t;
         best=INT_MAX;
         i=0;
         while(i<n)
         {
             p=s[i];
             j=0;
             while(j<t.size())
             {
                 k=0;
                 while(k<p.size())
                 {
                     dp[j][k]=-1;
                     k++;
                 }
                 j++;
             }
             j=f(0,0);
             if(j<best)
             {
                 best=j;
                 ans=p;
             }
             i++;
         }
         cout << ans << "\n";
     }
}

Auto Suggest ✅

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

int min(int x, int y, int z)
{
    return min(min(x, y), z);
}

int levenshteinDist(string str1, string str2, int m, int n)
{
    int dp[m + 1][n + 1];

    for (int i = 0; i <= m; i++)
    {
        for (int j = 0; j <= n; j++)
        {
            if (i == 0)
                dp[i][j] = j;

            else if (j == 0)
                dp[i][j] = i;

            else if (str1[i - 1] == str2[j - 1])
                dp[i][j] = dp[i - 1][j - 1];

            else
                dp[i][j] = 1 + min(dp[i][j - 1],     
                                   dp[i - 1][j],     
                                   dp[i - 1][j - 1]);
        }
    }

    return dp[m][n];
}

int main()
{
    int n;
    cin >> n;
  
    vector<string> v(n);
    for (int i = 0; i < n; ++i)
    {
        cin >> v[i];
     
    }
    string s;
    cin >> s;
   
    int mindist = INT_MAX;
    string beststr = "zzzzzzzzzzz";

    for (int i = 0; i < n; ++i)
    {
        int heredist = levenshteinDist(s, v[i], s.size(), v[i].size());
        if (heredist < mindist)
        {
            mindist = heredist;
            beststr = v[i];
            continue;
        }
        if (heredist == mindist)
        {
            if (beststr > v[i])
            {
                // cout << beststr << " " << v[i] << "\n";
                beststr = v[i];
            }
            continue;
        }
    }

    cout << beststr;

    return 0;
}