સૌથી વધુ પરિમિતિ ત્રિકોણ લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે સી 3 આઇઓટી
મઠ સોર્ટિંગ

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

સમસ્યામાં ”સૌથી મોટું પરિમિતિ ત્રિકોણ ”આપણને n વેલ્યુ સાથે એક એરે આપવામાં આવે છે. બધા મૂલ્યો હકારાત્મક પૂર્ણાંકો છે. ત્રિકોણની મહત્તમ પરિમિતિ શોધવા માટે પૂછો જે આપણે આ મૂલ્યોથી બનાવી શકીએ છીએ. જો ત્રિકોણ બનાવવું શક્ય ન હોય તો આપણે 0 પ્રિન્ટ કરવાની જરૂર છે.

ઉદાહરણ

arr = [3,2,3,4]
10

સમજૂતી: ત્રિકોણની સૌથી મોટી પરિમિતિ જે આ મૂલ્યોનો ઉપયોગ કરીને રચાય છે તે 10 છે અને ત્રિકોણની બાજુઓ 4,3,3 છે.

મોટા પરિમિતિ ત્રિકોણ લીટકોડ સોલ્યુશન માટે અભિગમ

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

સૌથી મોટી પરિમિતિ ત્રિકોણ માટે લેટકોડ સોલ્યુશન

જેમ કે પ્રશ્ન, સૌથી વધુ પરિમિતિ ત્રિકોણ શોધવા માટે પૂછે છે, તેથી શરતોને સંતોષતા તમામ સંભવિત ત્રિકોણોમાંથી, એક <b> સી, બી + સી> એ, અને + સી> બી અમને ત્રિપુટી શોધવાની જરૂર છે, જેના માટે + બી + સી મહત્તમ છે.

તેથી આપણે સૌથી મોટી પરિમિતિ મેળવવા માટે શક્ય તેટલું વિશાળ a, b અને c ની કિંમતો જોઈએ છે. આપણે એરેને સ sortર્ટ કરીશું અને પછી જો તેઓ પ્રમેયને સંતોષશે તો અમે સૌથી મોટા ત્રણ મૂલ્યોથી પ્રારંભ કરીશું. જો તે કરે તો તેમની રકમ આવશ્યક મૂલ્ય છે. નહિંતર, અમે આગામી ત્રણ સૌથી મોટા મૂલ્યો માટે તપાસ કરીશું.

જો આવી કોઈ ત્રિપુટી અસ્તિત્વમાં નથી તો ત્રિકોણની સૌથી મોટી પરિમિતિ 0 છે.

 અમલીકરણ

સૌથી વધુ પરિમિતિ ત્રિકોણ માટે સી ++ કોડ

#include <bits/stdc++.h> 
using namespace std; 
    int largestPerimeter(vector<int>&  arr) {
        int n=arr.size();
        sort(arr.begin(),arr.end());
       for (int i =n - 1; i > 1; --i)
            if (arr[i] < arr[i - 1] + arr[i - 2])
                return arr[i] + arr[i - 1] + arr[i - 2];
        return 0;
    }
int main() 
{ 
 vector<int> arr = { 3,2,3,4 }; 
 cout<<largestPerimeter(arr)<<endl; 
 return 0;
}
10

મોટા પરિમિતિ ત્રિકોણ માટે જાવા કોડ

import java.util.Arrays; 
public class Tutorialcup {
    public static int largestPerimeter(int[] arr) {
        Arrays.sort(arr);
        int n= arr.length;
        for (int i =n - 1; i > 1; --i)
            if (arr[i] < arr[i - 1] + arr[i - 2])
                return arr[i] + arr[i - 1] + arr[i - 2];
        return 0;
    }
  public static void main(String[] args) {
    int [] arr = {3,2,3,4}; 
    int ans= largestPerimeter(arr);
    System.out.println(ans);
  }
}

 

10

મોટા પરિમિતિ ત્રિકોણ લીટકોડ સોલ્યુશનનું જટિલતા વિશ્લેષણ

સમયની જટિલતા

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

જગ્યાની જટિલતા

ઉપરોક્ત કોડની અવકાશ જટિલતા છે ઓ (1) કારણ કે આપણે જવાબ સંગ્રહવા માટે માત્ર એક વેરીએબલ વાપરી રહ્યા છીએ.

સંદર્ભ