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


મુશ્કેલી સ્તર મધ્યમ
વારંવાર પૂછવામાં આવે છે એડોબ એમેઝોન સફરજન ByteDance ફેસબુક Google MakeMyTrip માઈક્રોસોફ્ટ Nvidia ઓરેકલ પેટીએમ વીએમવેર ઝોહો
અરે શબ્દમાળા વર્ક એપ્લિકેશન

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

"સૌથી મોટી સંખ્યા II રચવા માટે આપેલ નંબર્સને ગોઠવો" સમસ્યામાં, અમે એક આપ્યું છે એરે સકારાત્મક પૂર્ણાંકોની. તેમને એવી રીતે ગોઠવો કે ગોઠવણી સૌથી મોટો મૂલ્ય રચે.

ઇનપુટ ફોર્મેટ  

પ્રથમ અને એક જ લાઇન જેમાં પૂર્ણાંક એન હોય છે.

N અવકાશ-વિભાજિત પૂર્ણાંકોવાળી બીજી લાઇન.

આઉટપુટ ફોર્મેટ  

ગોઠવણી પછી અંતિમ એરેવાળી પ્રથમ અને એકમાત્ર લાઇન.

અવરોધ  

  • 1 <= n <= 10 ^ 5
  • 0 <= એ [હું] <= 10 ^ 6

ઉદાહરણ  

5
80 9
980

સમજૂતી: સામાન્ય સ sortર્ટિંગ 80, 9. આપશે. પરંતુ, તે ખોટું છે કારણ કે આપણને સૌથી મોટી સંખ્યાની જરૂર છે. તેથી અમારું ફંક્શન 809 અને 980 ની તુલના કરશે, અને સ ,ર્ટ કરેલા એરે તરીકે 9, 80 આપે છે.

અલ્ગોરિધમ  

આ પદ્ધતિમાં, મુખ્ય વિચાર એ લાઇબ્રેરી સ sortર્ટ ફંક્શનનો ઉપયોગ કરવાનો છે. જેમાં ફંક્શન આપણા કમ્પેરેશન ફંક્શનનો ઉપયોગ કરે છે. તુલના ફંક્શન એવી રીતે કાર્ય કરે છે કે, ધારો કે ત્યાં બે અને નંબરો X અને Y છે, પછી તે XY અને YX ને જોડે છે અને વધારે મૂલ્ય લે છે.

1. અમારા સરખામણી ફંક્શનનો ઉપયોગ કરીને એરે સ arર્ટ કરો એટલે કે, સ (ર્ટ કરો (એઆર, એઆર + એન, સરખામણી)

2. સ theર્ટ કરેલ એરે છાપો

અમલીકરણ  

સી ++ પ્રોગ્રામ, એ ક્રમાંકિત ક્રમાંકિત સૌથી મોટી સંખ્યા II ની રચના કરવા માટે આપેલ નંબર્સ

#include <bits/stdc++.h>
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 printLargest(vector<string> arr)
{
    sort(arr.begin(), arr.end(), myCompare);
    for(auto u: arr)
    {
        cout<<u;
    }
    cout<<endl;
}

int main()
{
   int n;
   cin>>n;
   vector<string> v;
   for(int i=0;i<n;i++)
   {
       string x;
       cin>>x;
       v.push_back(x);
   }
   printLargest(v);
   return 0;
}

જાવા પ્રોગ્રામ ટુ એરેન્જમેન્ટ આપેલ નંબરને સૌથી મોટી નંબર II રચવા માટે

import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Vector;
class sum
{
    static void printLargest(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());
        System.out.println();
    }
    public static void main(String[] args)  
    { 
        Scanner sr = new Scanner(System.in);
        Vector<String> v = new Vector<String>();
        int n = sr.nextInt();
        for(int i=0;i<n;i++)
        {
            String x;
            x = sr.next();
            v.add(x);
        }
        printLargest(v);
    }
}
6
1 10 952 42 19 7821
95278214219110

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

સમય જટિલતા

ઓ (એન * લnગન) જ્યાં n આપેલ એરેનું કદ છે. અહીં આપણે સingર્ટિંગ અને ખ્યાલનો ઉપયોગ કરીએ છીએ સોર્ટિંગ O (nlogn) ની ચાલી રહેલ સમયની જટિલતા છે અને O (n) સમયમાં ચાલે છે.

આ પણ જુઓ
સ્વ સિવાય એરેનું ઉત્પાદન

અવકાશ જટિલતા

ઓ (1) કારણ કે આપણે અહીં કોઈ સહાયક જગ્યાનો ઉપયોગ કરતા નથી.