శ్రేణిలో గరిష్ట దూరం


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe అమెజాన్ గూగుల్ ఒరాకిల్
అర్రే హాష్

“శ్రేణిలో గరిష్ట దూరం” సమస్య మీకు ఇవ్వబడింది “N” లేదు. శ్రేణుల మరియు అన్ని శ్రేణుల ఆరోహణ క్రమంలో ఇవ్వబడ్డాయి. మీ పని ఏమిటంటే రెండు సంఖ్యల గరిష్ట వ్యత్యాసం / సంపూర్ణ వ్యత్యాసాన్ని కనుగొనడం అమరిక మరియు మేము రెండు సంఖ్యల మధ్య గరిష్ట దూరాన్ని నిర్వచించవచ్చు abs | ab |. వేర్వేరు శ్రేణులను రూపొందించడానికి మీరు రెండు సంఖ్యలను ఎంచుకోవచ్చు మరియు కనుగొనవచ్చు abs | ab | గరిష్ట వ్యత్యాసంగా.

ఉదాహరణ

[  [1,2,3],
[0,2,3],
[1,4,5] ]
5

వివరణ

ఎందుకంటే రెండవ శ్రేణిలోని '0' సంఖ్య మరియు మూడవ శ్రేణిలోని '5' సంఖ్య మొత్తం శ్రేణిలో గరిష్ట సంపూర్ణ వ్యత్యాసాన్ని ఇస్తుంది.

అల్గారిథం

  1. వేరియబుల్ అవుట్‌పుట్‌ను డిక్లేర్ చేసి 0 గా సెట్ చేయండి.
  2. కనిష్ట విలువను ఇలా సెట్ చేయండి varray[0] [0].
  3. గరిష్ట విలువను సెట్ చేయండి varray's మొదటి వరుస పొడవు అంటే, గరిష్ట= వర్రే [0] [0th అడ్డు వరుస పొడవు -1].
  4. మొదటి శ్రేణి యొక్క మొదటి మూలకం మరియు రెండవ శ్రేణి చివరి మూలకం మరియు మొదటి శ్రేణి యొక్క చివరి మూలకం మరియు రెండవ శ్రేణి యొక్క మొదటి మూలకం మధ్య వ్యత్యాసం యొక్క గరిష్ట విలువను కనుగొనండి
  5. కాబట్టి, పై పంక్తి మరియు అవుట్పుట్ నుండి ఉత్పత్తి చేయబడిన విలువ మధ్య గరిష్ట విలువను కనుగొని దాన్ని అవుట్పుట్కు నిల్వ చేయండి.
  6. మధ్య చిన్న విలువను కనుగొనండి varray [i] [0] మరియు కనీస మరియు దానిని కనిష్టానికి సెట్ చేయండి.
  7. మధ్య పెద్ద విలువను కనుగొనండి varray [i] [row_size-1] మరియు గరిష్ట మరియు దానిని గరిష్టంగా సెట్ చేయండి.
  8. శ్రేణి ముగిసే వరకు పై విధానాన్ని పునరావృతం చేయండి.
  9. రిటర్న్ అవుట్పుట్.

శ్రేణిలో గరిష్ట దూరానికి వివరణ

వేర్వేరు శ్రేణులలోని రెండు సంఖ్యల మధ్య గరిష్ట సంపూర్ణ వ్యత్యాసాన్ని కనుగొనడం మా పని. మేము కేవలం 'ఫర్ లూప్' కోసం సమూహాన్ని ఉపయోగించవచ్చు మరియు అన్ని సంఖ్యల గరిష్ట వ్యత్యాసాన్ని కనుగొనడం ద్వారా సులభం చేయవచ్చు.

కానీ సమూహ ఉచ్చులను ఉపయోగించడం మరియు శ్రేణి యొక్క అన్ని అంశాలను దాటడానికి బదులుగా. మేము సరళమైనదాన్ని ఉపయోగించవచ్చు కోసం లూప్ మరియు సమర్థవంతమైన పరిష్కారం కలిగి. అన్ని అంశాలు ఇన్పుట్ శ్రేణిలో ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడినందున. వేర్వేరు శ్రేణుల చివరి మరియు మొదటి అంశాల మధ్య తేడాలను మనం కనుగొనాలి. ఎందుకంటే ఈ రెండు స్థాన సంఖ్యలు మాత్రమే గరిష్ట వ్యత్యాసాన్ని ఇవ్వగలవు. అన్నింటికంటే, ప్రతి శ్రేణి క్రమబద్ధీకరించబడుతుంది మరియు మొదటి మూలకం ఎల్లప్పుడూ ఇతరులలో తక్కువ లేదా కనిష్టంగా ఉంటుంది. మరియు చివరి మూలకం శ్రేణి యొక్క అతిపెద్ద సంఖ్య అవుతుంది.

కాబట్టి ఇక్కడ ఒక ఉదాహరణ తీసుకొని దాన్ని పరిష్కరించుకుందాం:

ఇన్‌పుట్: arr [] [] = {, 0,2,4}, {2,3}, {4,5,6}};

అవుట్పుట్ = 0, గరిష్ట = 4, కనిష్ట = 0, నేను = 1

output = std :: max (అవుట్పుట్,

std :: max (abs (varray [i] [varray [i] .size () - 1] - కనిష్ట),

abs (గరిష్ట-వర్రే [i] [0])))

అవుట్పుట్ 3 గా స్టోర్

గరిష్టంగా 4 గా ఉంది, కనిష్ట 0 గా ఉంటుంది, i = 2

output = std :: max (అవుట్పుట్,

std :: max (abs (varray [i] [varray [i] .size () - 1] - కనిష్ట),

abs (గరిష్ట-వర్రే [i] [0])))

వేర్వేరు శ్రేణుల చివరి మరియు మొదటి మూలకం మధ్య తేడాలు

0 మరియు 6 మరియు వీటిలో 6 గరిష్ట వ్యత్యాసం కాబట్టి అవుట్పుట్ 6 అవుతుంది

మరియు తిరిగి 6.

శ్రేణిలో గరిష్ట దూరం

శ్రేణిలో గరిష్ట దూరం కోసం సి ++ ప్రోగ్రామ్

#include <iostream>
#include<vector>
#include<cstdlib>
using namespace std;
int getMaxDistance(vector<vector <int>> varray)
{
    int output=0;
    int minimum=varray[0][0];
    int maximum=varray[0][varray[0].size()-1];

    for(int i = 1 ; i < varray.size() ; i++ )
    {
        output=std::max(output, std::max( abs( varray[i][varray[i].size()-1] - minimum ), abs(maximum-varray[i][0]) ) );
        minimum=std::min( minimum, varray[i][0] );
        maximum=std::max( maximum, varray[i][varray[i].size()-1]);
    }
    return output;

}
int main()
{
    vector<vector<int>> vec= {{0,2,4},{2,3,4},{4,5,6}};
    cout<<"Maximum distance is:"<<getMaxDistance(vec);
    return 0;
}
Maximum distance is: 6

శ్రేణిలో గరిష్ట దూరం కోసం జావా ప్రోగ్రామ్

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

class maximumDistance
{
    public static int getMaxDistance(int array[][])
    {
        int output=0;
        int minimum=array[0][0];
        int maximum=array[0][array[0].length-1];

        for(int i = 1 ; i < array.length ; i++ )
        {
            output=Math.max(output, Math.max(Math.abs( array[i][array[i].length-1] - minimum ), Math.abs(maximum-array[i][0]) ) );
            minimum=Math.min( minimum, array[i][0] );
            maximum=Math.max( maximum, array[i][array[i].length-1]);
        }
        return output;

    }
    public static void main(String args[])
    {
        int arr[][]= {{0,2,4},{2,3},{4,5,6}};
        System.out.println("Maximum distance is:"+(getMaxDistance(arr)));
    }
}
Maximum distance is: 6

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై) ఇక్కడ n అనేది శ్రేణిలోని మూలకాల సంఖ్య. ఎందుకంటే మేము 2D శ్రేణి లేదా మాతృక వరుసల మీదుగా ప్రయాణిస్తున్నాము. కానీ మేము మా ఇన్పుట్ మ్యాట్రిక్స్ యొక్క నిలువు వరుసలను ఎప్పుడూ దాటలేదు.

అంతరిక్ష సంక్లిష్టత

O (1) మేము స్థిరమైన స్థలాన్ని ఉపయోగించాము. మేము వేరియబుల్స్ యొక్క స్థిరమైన సంఖ్యను మాత్రమే ఉపయోగించాము కాబట్టి. విధానం స్థిరమైన స్థల సంక్లిష్టతను కలిగి ఉంది.

ప్రస్తావనలు