આધાર 7 લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે બ્લૂમબર્ગ ગરેના
મઠ

સમસ્યા બેઝ 7 લીટકોડ સોલ્યુશન, અમને નંબરને બેઝ 7 નંબરમાં રૂપાંતરિત કરવા કહે છે. આપેલ નંબર નંબર લાઇન પર બંને દિશામાં 10 મિલિયન સુધી નકારાત્મક અથવા સકારાત્મક હોઈ શકે છે. સમસ્યા સરળ લાગે છે અને દશાંશ સંખ્યાને એક અલગ આધારમાં રૂપાંતરિત કરવાનું છે. બાયનરી ફોર્મેટમાં કોઈ સંખ્યાના રૂપાંતરની જેમ. બેઝ 2 હોવાને બદલે બેઝ 7 છે. રીટર્નિંગ વેલ્યુ એક શબ્દમાળા હોવી જોઈએ. ચાલો થોડા ઉદાહરણો જોઈએ.

ઉદાહરણ

100
"202"

સ્પષ્ટતા: રૂપાંતર પછી આધાર 202 માં 7 નંબર દશાંશ ફોર્મેટમાં 100 મેળવે છે. બેઝ 202 = 7 * (2 ^ 7) + 2 * (0 ^ 7) + 1 * (2 ^ 7) = 0 માં બેઝ 100 માં 7.

આધાર 7 લીટકોડ સોલ્યુશન

-7
"-10"

સમજૂતી: આપેલ નંબર -7 બેઝ 7 માં રૂપાંતર કર્યા પછી -10 આપશે.

બેઝ 7 લીટકોડ સોલ્યુશન માટે અભિગમ

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

તેથી, ચાલો 100 ને ઇનપુટ તરીકે ધ્યાનમાં લઈએ. પ્રથમ, આપણે સંખ્યાને 7 દ્વારા વિભાજીત કરીશું, ભાગાકાર 14 છે, અને બાકીની સંખ્યા 2 છે. પછી બાકીનો સંગ્રહ કરવામાં આવે છે અને ભાગાકાર ફરીથી વિભાગ માટે મોકલવામાં આવે છે. હવે, ભાગ 2 બને છે, અને બાકીનો સંગ્રહિત થાય છે. હમણાં સુધી, રૂપાંતરિત સંખ્યા 20 બને છે. ત્યારબાદ ભાગાકાર ફરીથી વિભાગ માટે મોકલવામાં આવે છે પરંતુ પરત આવે છે કારણ કે તે આપેલા આધાર (7) કરતા ઓછા છે. આમ, અંતિમ પરિણામ 202 બહાર આવે છે.

કોડ

બેઝ 7 લીટકોડ સોલ્યુશન માટે સી ++ કોડ

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

string convertToBase7(int num) {
    if(num < 0)return "-" + convertToBase7(-num);
    else if(num < 7) return to_string(num);
    else
        return convertToBase7(num/7) + convertToBase7(num%7);
}

int main(){
    cout<<convertToBase7(100);
}
202

બેઝ 7 લીટકોડ સોલ્યુશન માટે જાવા કોડ

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

class Solution {
    public static String convertToBase7(int num) {
        if(num < 0)return "-" + convertToBase7(-num);
        else if(num < 7) return Integer.toString(num);
        else
            return convertToBase7(num/7) + convertToBase7(num%7);
    }
    
    public static void main(String[] args){
    	System.out.print(convertToBase7(100));
    }
}
202

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

સમય જટિલતા

ઓ (એમ (એન) લ nગ એન), જ્યાં n આપેલ ઇનપુટની લંબાઈ છે, એમ (એન) તે સમય છે જે બે 2-બીટ નંબરોને વિભાજિત કરવા માટે લે છે. તેથી, સમયની જટિલતા લોગરીધમિક છે.

અવકાશ જટિલતા

ઓ (લ nગ એન), કમ્પાઇલર સ્ટેક દ્વારા વપરાયેલી જગ્યા. અહીં n એ સંખ્યાની લંબાઈને રજૂ કરે છે. તેથી, અવકાશ જટિલતા પણ લોગરીધમિક છે.