ਅਧਾਰ 7 ਲੀਟਕੋਡ ਹੱਲ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਬਲੂਮਬਰਗ Garena
ਗਣਿਤ

ਸਮੱਸਿਆ ਬੇਸ 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 ਲੀਟਕੋਡ ਸਲਿachਸ਼ਨ ਲਈ ਪਹੁੰਚ

ਸਮੱਸਿਆ ਬੇਸ 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 ਦਿੱਤੇ ਗਏ ਇੰਪੁੱਟ ਦੀ ਲੰਬਾਈ ਹੈ, ਐਮ (ਐਨ) ਉਹ ਸਮਾਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਦੋ 2-ਬਿੱਟ ਸੰਖਿਆਵਾਂ ਨੂੰ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ. ਇਸ ਲਈ, ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਲੋਗਰੀਥਮਿਕ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (ਲੌਗ ਐਨ), ਕੰਪਾਈਲਰ ਸਟੈਕ ਦੁਆਰਾ ਵਰਤੀ ਗਈ ਥਾਂ. ਇੱਥੇ n ਸੰਖਿਆ ਦੀ ਲੰਬਾਈ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਇਸ ਲਈ, ਸਪੇਸ ਦੀ ਗੁੰਝਲਤਾ ਵੀ ਲੋਗਰੀਥਮਿਕ ਹੈ.