મોટા જૂથ લીટકોડ સોલ્યુશનની ગણતરી કરો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે મર્કરી
અરે

સમસ્યા ગણતરી પૂર્ણ જૂથ લીટકોડ સોલ્યુશન અમને પૂર્ણાંકો પૂરો પાડે છે. આપણે 1 અને n (સમાયેલ) ની વચ્ચેની દરેક સંખ્યાના અંકોનો સરવાળો શોધવા માટે જરૂરી છે. ત્યારબાદ અમે સમાન અંકોના સરવાળા સાથે સંખ્યાઓને જૂથ બનાવીશું અને ગણતરી રાખીશું. પછી આપણે મહત્તમ ગણતરી સાથે જૂથોની સંખ્યાની ગણતરી કરવાની જરૂર છે. આ પહેલા મૂંઝવણભર્યું લાગે છે. તેથી, ચાલો થોડા ઉદાહરણો જોઈએ.

ઉદાહરણો

મોટા જૂથ લીટકોડ સોલ્યુશનની ગણતરી કરો

n = 13
4

સમજૂતી: તેમના અંકોના સરવાળો અનુસાર જૂથ થયેલ નંબરો [1, 10], [2,11], [3,12], [4,13], [5], [6], []], [ 7], [8]. તેથી, ત્યાં 9 જૂથો છે જેમાં મહત્તમ આવર્તન 4 હોય છે. તેથી જવાબ, 2.

n = 2
2

સમજૂતી: તે જ રીતે, જો તમે 2 સુધીના નંબરો જોશો. ત્યાં ફક્ત 2 સંખ્યાઓ છે, 1 અને 2. આમ જવાબ 2 જૂથો છે જેની મહત્તમ આવર્તન 1 છે.

અભિગમ

સમસ્યાની ગણતરી સૌથી મોટા જૂથ લીટકોડ સોલ્યુશનએ અમને એક પૂર્ણાંક પૂરો પાડ્યો. અને મહત્તમ આવર્તન ધરાવતા નંબરોના જૂથોની સંખ્યા ગણવા માટે પૂછ્યું જ્યાં અમે તેમના અંકોની રકમ પ્રમાણે સંખ્યાઓને જૂથબદ્ધ કરી. ઇનપુટ એ 10000 ની મહત્તમ અવરોધ છે. અમે એક બનાવીએ છીએ એરે સંખ્યાના અંકોના સરવાળાની આવર્તન રાખવા માટે. નું મહત્તમ કદ CNT એરે 36 હોવો જોઈએ. કારણ કે મહત્તમ રકમવાળા ઇનપુટ 36 હશે. તેથી, અમે 1 થી n સુધી દરેક સંખ્યા માટે અંકોનો સરવાળો શોધવાની પ્રક્રિયાનું અનુકરણ કરીએ છીએ. આવર્તનના મૂલ્યાંકન દરમિયાન, અમે અત્યાર સુધીની ગણતરી કરવામાં આવતી મહત્તમ આવર્તન સંગ્રહિત કરીએ છીએ. હવે, અમે એક નવો લૂપ શરૂ કરીએ અને મહત્તમ આવર્તન ધરાવતા જૂથોની સંખ્યા ગણીએ.

ગણતરીના મોટા જૂથ લીટકોડ સોલ્યુશન માટેનો કોડ

સી ++ કોડ

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

int sumDigits(int n){
    int sum = 0;
    while(n>0){
        sum += (n%10);
        n /= 10;
    }
    return sum;
}

int countLargestGroup(int n) {
    int cnt[37];
    memset(cnt, 0, sizeof cnt);
    int mx = 0;
    for(int i=0;i<=n;i++){
        int s = sumDigits(i);
        cnt[s]++;
        if(cnt[s] > mx)
            mx = cnt[s];
    }
    
    int ans = 0;
    for(int i=0;i<37;i++){
        if(cnt[i] == mx)
            ans++;
    }
    return ans;
}

int main(){
    cout<<countLargestGroup(13);
}
4

જાવા કોડ

import java.util.*;
import java.lang.*;
import java.io.*;

class Solution {
  
    public static int sumDigits(int n){
        int sum = 0;
        while(n>0){
            sum += (n%10);
            n /= 10;
        }
        return sum;
    }

    public static int countLargestGroup(int n) {
        int cnt[] = new int[37];
        for(int i=0;i<37;i++)cnt[i] = 0;
        int mx = 0;
        for(int i=1;i<=n;i++){
            int s = sumDigits(i);
            cnt[s]++;
            if(cnt[s] > mx)
                mx = cnt[s];
        }

        int ans = 0;
        for(int i=0;i<37;i++){
            if(cnt[i] == mx)
                ans++;
        }
        return ans;
    }
    
    public static void main(String[] args){
    	System.out.print(countLargetGroup(13));
    }
    
}
4

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન), કારણ કે પ્રથમ લૂપ રન ઇનપુટ પર આધારિત છે. આમ સમય જટિલતા રેખીય છે.

અવકાશ જટિલતા

ઓ (1), કારણ કે આપણી પાસે સતત કદનો એરે છે. આમ જગ્યાના જટિલતા ઇનપુટને ધ્યાનમાં લીધા વિના સતત રહે છે.