അറേയിലെ പരമാവധി ദൂരം


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു അഡോബി ആമസോൺ ഗൂഗിൾ ഒറാക്കിൾ
അറേ ഹാഷ്

“അറേയിലെ പരമാവധി ദൂരം” എന്ന പ്രശ്നം നിങ്ങൾക്ക് നൽകിയിട്ടുണ്ടെന്ന് പറയുന്നു “N” ഇല്ല. അറേകളുടെയും എല്ലാ അറേകളുടെയും ആരോഹണ ക്രമത്തിൽ നൽകിയിരിക്കുന്നു. ഒരു എന്നതിലെ രണ്ട് അക്കങ്ങളുടെ പരമാവധി വ്യത്യാസം / കേവല വ്യത്യാസം കണ്ടെത്തുക എന്നതാണ് നിങ്ങളുടെ ചുമതല ശ്രേണി കൂടാതെ രണ്ട് സംഖ്യകൾ തമ്മിലുള്ള പരമാവധി ദൂരം നമുക്ക് നിർവചിക്കാം abs | ab |. വ്യത്യസ്ത ശ്രേണികൾ രൂപീകരിക്കുന്നതിനും കണ്ടെത്തുന്നതിനും നിങ്ങൾക്ക് രണ്ട് അക്കങ്ങൾ തിരഞ്ഞെടുക്കാം abs | ab | പരമാവധി വ്യത്യാസമായി.

ഉദാഹരണം

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

വിശദീകരണം

കാരണം രണ്ടാമത്തെ അറേയിലെ '0' സംഖ്യയും മൂന്നാമത്തെ അറേയിലെ '5' സംഖ്യയും മുഴുവൻ അറേയിലും പരമാവധി കേവല വ്യത്യാസം നൽകുന്നു.

അൽഗോരിതം

  1. ഒരു വേരിയബിൾ output ട്ട്‌പുട്ട് പ്രഖ്യാപിച്ച് 0 ആയി സജ്ജമാക്കുക.
  2. മിനിമം മൂല്യം ഇതായി സജ്ജമാക്കുക varray[0] [0].
  3. പരമാവധി മൂല്യം സജ്ജമാക്കുക varray's ആദ്യ വരി ദൈർഘ്യം, പരമാവധി= varray [0] [0th വരിയുടെ നീളം -1].
  4. ആദ്യ അറേയുടെ ആദ്യ ഘടകവും രണ്ടാമത്തെ അറേ അവസാന ഘടകവും തമ്മിലുള്ള വ്യത്യാസത്തിന്റെ ആദ്യ മൂല്യവും ആദ്യ അറേയുടെ അവസാന ഘടകവും രണ്ടാമത്തെ അറേയുടെ ആദ്യ ഘടകവും തമ്മിലുള്ള വ്യത്യാസവും കണ്ടെത്തുക
  5. അതിനാൽ, മുകളിലുള്ള വരിയിൽ നിന്നും output ട്ട്‌പുട്ടിൽ നിന്നും ഉൽ‌പാദിപ്പിക്കുന്ന മൂല്യം തമ്മിലുള്ള പരമാവധി മൂല്യം കണ്ടെത്തി .ട്ട്‌പുട്ടിലേക്ക് സംഭരിക്കുക.
  6. ഇതിനിടയിലുള്ള ചെറിയ മൂല്യം കണ്ടെത്തുക varray [i] [0] ഒപ്പം ഏറ്റവും കുറഞ്ഞ അത് ഏറ്റവും കുറഞ്ഞതായി സജ്ജമാക്കുക.
  7. തമ്മിലുള്ള വലിയ മൂല്യം കണ്ടെത്തുക varray [i] [row_size-1] ഒപ്പം പരമാവധി അത് പരമാവധി സജ്ജമാക്കുക.
  8. അറേ അവസാനിക്കുന്നതുവരെ മുകളിലുള്ള പ്രക്രിയ ആവർത്തിക്കുക.
  9. Return ട്ട്‌പുട്ട് നൽകുന്നു.

അറേയിലെ പരമാവധി ദൂരത്തിനായുള്ള ഒരു വിശദീകരണം

വ്യത്യസ്ത അറേകളിലെ രണ്ട് അക്കങ്ങൾ തമ്മിലുള്ള പരമാവധി കേവല വ്യത്യാസം കണ്ടെത്തുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. നമുക്ക് നെസ്റ്റഡ് 'ഫോർ ലൂപ്പ്' ഉപയോഗിക്കാനും എല്ലാ അക്കങ്ങളുടെയും പരമാവധി വ്യത്യാസം കണ്ടെത്തുന്നതിലൂടെ ഇത് എളുപ്പമാക്കാനും കഴിയും.

നെസ്റ്റഡ് ലൂപ്പുകൾ ഉപയോഗിക്കുന്നതിനും അറേയിലെ എല്ലാ ഘടകങ്ങളും സഞ്ചരിക്കുന്നതിനും പകരം. നമുക്ക് ലളിതമായ ഒന്ന് ഉപയോഗിക്കാം വേണ്ടി ലൂപ്പ് ചെയ്ത് കാര്യക്ഷമമായ പരിഹാരം കാണുക. എല്ലാ ഘടകങ്ങളും ഇൻപുട്ട് അറേയിലെ ആരോഹണ ക്രമത്തിൽ അടുക്കിയിരിക്കുന്നതിനാൽ. വ്യത്യസ്ത അറേകളുടെ അവസാന, ആദ്യ ഘടകങ്ങൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ ഞങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ട്. കാരണം ഈ രണ്ട് സ്ഥാനങ്ങളുള്ള സംഖ്യകൾക്ക് മാത്രമേ പരമാവധി വ്യത്യാസം നൽകാൻ കഴിയൂ. എല്ലാത്തിനുമുപരി, ഓരോ അറേയും അടുക്കിയിരിക്കുന്നു, ആദ്യ ഘടകം എല്ലായ്പ്പോഴും മറ്റുള്ളവയിൽ ഏറ്റവും കുറഞ്ഞതോ കുറഞ്ഞതോ ആണ്. അവസാന ഘടകം അറേയുടെ ഏറ്റവും വലിയ സംഖ്യയായിരിക്കും.

അതിനാൽ നമുക്ക് ഇവിടെ ഒരു ഉദാഹരണം എടുത്ത് പരിഹരിക്കാം:

ഇൻ‌പുട്ട്: arr [] [] = {, 0,2,4}, {2,3}, {4,5,6}};

Put ട്ട്‌പുട്ട് = 0, പരമാവധി = 4, കുറഞ്ഞത് = 0, i = 1

= ട്ട്‌പുട്ട് = എസ്ടിഡി :: പരമാവധി (output ട്ട്‌പുട്ട്,

std :: max (abs (varray [i] [varray [i]. വലുപ്പം () - 1] - കുറഞ്ഞത്),

abs (പരമാവധി-വേരിയ [i] [0])))

Store ട്ട്‌പുട്ട് 3 ആയി സംഭരിക്കുന്നു

പരമാവധി 4 ആയി തുടരുന്നു, കുറഞ്ഞത് 0, i = 2 ആയി അവശേഷിക്കുന്നു

= ട്ട്‌പുട്ട് = എസ്ടിഡി :: പരമാവധി (output ട്ട്‌പുട്ട്,

std :: max (abs (varray [i] [varray [i]. വലുപ്പം () - 1] - കുറഞ്ഞത്),

abs (പരമാവധി-വേരിയ [i] [0])))

വ്യത്യസ്ത അറേകളുടെ അവസാന, ആദ്യ ഘടകങ്ങൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ

0 ഉം 6 ഉം അതിൽ 6 ഉം പരമാവധി വ്യത്യാസമാണ് അതിനാൽ output ട്ട്‌പുട്ട് 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

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (n) ഇവിടെ n എന്നത് അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. കാരണം ഞങ്ങൾ 2 ഡി അറേ അല്ലെങ്കിൽ മാട്രിക്സിന്റെ വരികളിലൂടെ സഞ്ചരിക്കുകയായിരുന്നു. എന്നാൽ ഞങ്ങൾ ഒരിക്കലും ഞങ്ങളുടെ ഇൻപുട്ട് മാട്രിക്സിന്റെ നിരകളിലൂടെ സഞ്ചരിച്ചിട്ടില്ല.

ബഹിരാകാശ സങ്കീർണ്ണത

O (1) ഞങ്ങൾ സ്ഥിരമായ ഇടം ഉപയോഗിച്ചതിനാൽ. സ്ഥിരമായ വേരിയബിളുകളുടെ എണ്ണം മാത്രമേ ഞങ്ങൾ ഉപയോഗിച്ചിട്ടുള്ളൂ. സമീപനത്തിന് സ്ഥിരമായ സ്ഥല സങ്കീർണ്ണതയുണ്ട്.

അവലംബം