આપેલ નંબરને સૌથી મોટી સંખ્યા બનાવવા માટે ગોઠવો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન MakeMyTrip પેટીએમ ઝોહો
અરે શબ્દમાળા

સમસ્યા નિવેદન

ધારો કે તમારી પાસે પૂર્ણાંકોની એરે છે. સમસ્યા "આપેલ નંબરોને સૌથી મોટી સંખ્યા બનાવવા માટે ગોઠવો" એરેને ફરીથી ગોઠવવા માટે પૂછે છે કે આઉટપુટ મહત્તમ મૂલ્ય હોવું જોઈએ જે એરેની સંખ્યા સાથે બનાવી શકાય.

ઉદાહરણ

[34, 86, 87, 765]
878676534

સમજૂતી: આપણી પાસે એકબીજા સાથે આ સંખ્યા છે કે તે સર્વોચ્ચ મૂલ્ય ઉત્પન્ન કરે છે. આપણી પાસે સૌથી મોટી કિંમત 765 છે, પરંતુ જો આપણે તેને આગળ ધપાવીએ તો આપણું આઉટપુટ જે મૂલ્ય અમને મળ્યું છે તેના કરતા ઓછું થશે, તેથી આપણે પહેલા 87 86 અને પછી XNUMX XNUMX અને પછી બાકીના લેવાનું રહેશે. પરિણામ બાકીના અંકોથી શરૂ થવું જોઈએ.

અલ્ગોરિધમ થી ગોઠવો આપેલ નંબરને સૌથી મોટી સંખ્યા બનાવવા માટે

1 Compare and check which value is lexicographically greater.
2. The greater value will put forward.
3. Return that value.

સમજૂતી

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

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

હવે આપણે તેમને માત્ર ધ્યાન દોરવાનું છે અથવા તેઓ જે રીતે સ haveર્ટ કરે છે તે પ્રમાણે તેમને છાપવા પડશે. ઉપરાંત, આપણે શબ્દમાળા ફોર્મેટમાં ઇનપુટ લેવું જોઈએ, જેથી અમે તેમને શબ્દકોષીય ક્રમમાં ગોઠવી શકીએ.

આપેલ નંબરને સૌથી મોટી સંખ્યા બનાવવા માટે ગોઠવો

કોડ

સૌથી મોટી સંખ્યા બનાવવા માટે આપેલ નંબરોની ગોઠવણી માટે સી ++ કોડ

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int myCompare(string X, string Y)
{
    string XY = X.append(Y);
    string YX = Y.append(X);

    return XY.compare(YX) > 0 ? 1: 0;
}
void getLargest(vector<string> arr)
{
    sort(arr.begin(), arr.end(), myCompare);

    for (int i=0; i < arr.size() ; i++ )
        cout << arr[i];
}
int main()
{
    vector<string> arr;
    arr.push_back("34");
    arr.push_back("86");
    arr.push_back("87");
    arr.push_back("765");
    getLargest(arr);
    return 0;
}
878676534

આપેલ નંબરોની વ્યવસ્થા કરવા માટે જાવા કોડ સૌથી મોટી સંખ્યા બનાવે છે

import java.util.Collections;
import java.util.Iterator;
import java.util.Comparator;
import java.util.Vector;

class rearrangNumericString
{
    public static void getLargest(Vector<String> arr)
    {

        Collections.sort(arr, new Comparator<String>()
        {
            @Override
            public int compare(String X, String Y)
            {

                String XY=X + Y;

                String YX=Y + X;

                return XY.compareTo(YX) > 0 ? -1:1;
            }
        });

        Iterator it = arr.iterator();

        while(it.hasNext())
            System.out.print(it.next());

    }
    public static void main (String[] args)
    {
        Vector<String> arr = new Vector<>();
        arr.add("34");
        arr.add("86");
        arr.add("87");
        arr.add("765");
        getLargest(arr);
    }
} 
878676534

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

સમય જટિલતા

ઓ (એન * | એસ | લ logગ એન) જ્યાં “એન” સંખ્યાઓની ગણતરી છે અને | એસ | સૌથી મોટી સંખ્યાની લંબાઈ સૂચવે છે. મર્જ કરો સ sortર્ટ કરો એન લોગએન તુલના કરશે પરંતુ ત્યારથી દરેક તુલના લે છે. એસ સૌથી ખરાબ કિસ્સામાં સમય. સમયની જટિલતા પણ એન * | એસ | હશે લોગએન.

અવકાશ જટિલતા

ઓ (એન * | એસ |) જ્યાં “એન” સંખ્યાઓની ગણતરી છે. અહીં | એસ | આંકડાકીય ઇનપુટની લંબાઈ સૂચવે છે.