வரிசையில் அதிகபட்ச தூரம்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அடோப் அமேசான் கூகிள் ஆரக்கிள்
அணி ஹாஷ்

“வரிசையில் அதிகபட்ச தூரம்” என்ற சிக்கல் உங்களுக்கு வழங்கப்பட்டுள்ளது என்று கூறுகிறது “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) n என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை. ஏனென்றால் நாங்கள் 2 டி வரிசை அல்லது மேட்ரிக்ஸின் வரிசைகளில் பயணிக்கிறோம். ஆனால் எங்கள் உள்ளீட்டு மேட்ரிக்ஸின் நெடுவரிசைகளை நாங்கள் ஒருபோதும் பயணிக்கவில்லை.

விண்வெளி சிக்கலானது

ஓ (1) நாங்கள் ஒரு நிலையான இடத்தைப் பயன்படுத்தினோம். நிலையான மாறிகளின் எண்ணிக்கையை மட்டுமே நாங்கள் பயன்படுத்தியுள்ளோம். அணுகுமுறை நிலையான இட சிக்கலைக் கொண்டுள்ளது.

குறிப்புகள்