Bitişik elementlər arasındakı fərqlə ya da 0 ya da 1 ilə maksimum uzunluq ardıcıllığı

Çətinlik səviyyəsi Mühit
Tez-tez soruşulur Cisco Expedia Kvalifikasiya SAP Laboratoriyaları Teradata
Geyim Dinamik proqramlaşdırmaBaxılıb 76

Sistem dizaynı ilə bağlı müsahibə sualları o qədər açıq ola bilər ki, düzgün hazırlaşmağı bilmək çox çətindir. İndi satın aldıqdan sonra Amazon, Microsoft və Adobe-nin dizayn dövrlərini sındıra bilirəm Bu kitabı. Gündəlik bir yenidən nəzərdən keçirin dizayn sualı və söz verirəm ki, dizayn dövrünü sındıra bilərsiniz.

Problem bəyanat

Sizə verilir tam array. Problem "Bitişik elementlər arasındakı fərq ya da 0 ya da 1 olsun" maksimum uzunluq ardıcıllığı, bitişik elementlər arasındakı fərqlə maksimum ardıcıllıq uzunluğunun 0 və ya 1-dən başqa olmaması istənir.

misal

arr[] = {1, 4, 5, 2, 6, 5, 4, 8}
5

Izahat

Növbəti = 4, 5, 6, 5, 4

arr[] = {1, -3, -2, 0, -1, -2, -3, -4}
6

Izahat

Növbəti = -3, -2, -1, -2, -3, -4

Bitişik elementlər arasındakı fərqlə ya da 0 ya da 1 ilə maksimum uzunluq ardıcıllığını tapmaq üçün alqoritm

1. Declare a Map.
2. Set maxValue to 0.
3. Traverse the array starting from i=0 to while i<n (length of the array).
  1. Initialize a variable temp to 0.
  2. Check if Map contains the key as arr[i-1],
    1. If true, then get the value of arr[i-1] and store it to temp.
  3. Check if Map contains the key as arr[i],
    1. If true, then find the greater between the temp and the value of arr[i] in the map, and store it to temp.
  4. Check if Map contains the key as arr[i+1],
    1. If true, then find the greater between the temp and the value of arr[i+1] in the map, and store it to temp.
  5. Check if the temp is greater than maxValue,
    1. If true then store the value of temp to maxValue.
  6. And put the arr[i] as a key and temp as a value into the map.
4. Return maxValue.

Izahat

Bizə bir tam array, problem ifadələri maksimum ardıcıllıq uzunluğunu tapmağı xahiş edir. Və seçilmiş ardıcıllıq elə olmalıdır ki, bitişik dəyərlər arasında 0 və ya 1-dən başqa heç bir fərq olmayacaqdır. Bunu həll etmək üçün istifadə edəcəyik qarışdırma həllimizi səmərəli etmək. Açarı array elementi olaraq qoyacağıq və açarın dəyərini götürək həmişə maksimum dəyəri tapaq temp saxlayaq.

Bir nümunəni nəzərdən keçirək və bunu başa düşək:

misal

Arr [] = {1, 4, 5, 2, 6, 5, 4, 8}

Etdiyimiz ilk şey a elan etməkdir xəritə çünki müzakirə etdiyimiz alqoritmə görə bir sıra elementi və temp tempini saxlayacağıq. MaxValue dəyərini 0 olaraq təyin edin. Bu dəyişəni qaytaracağıq. Bu dəyişkəndə nə varsa, bizim cavabımız olardı. Dizini keçib massivin uzunluğuna çatmasını təmin edəcəyik. Dizini hər dəfə yeni i dəyəri ilə keçdiyimiz zaman 0 temp dəyərini başlatırıq.

i = 0, arr [i] = 1, temp = 0, maxValue = 0 Map = {}

Hansı şərtin yerinə yetiriləcəyini yoxlayın. Bu vəziyyətdə şərt yoxdur. Buna görə temp ++ edir və tempin maxValue-dan böyük olub olmadığını yoxlayır. Doğru olduqda tempi maxValue-a daxil edin və dəyəri və tempini xəritəyə daxil edin.

i = 1, arr [i] = 4, temp = 0, maxValue = 1.

Xəritə = {1,1}

Yuxarıdakı şərtlə eyni, dəyərləri xəritəyə daxil edirik

i = 2, arr [i] = 5, temp = 0, maxValue = 1.

Xəritə = {1: 1, 4: 1}

Bu dəfə xəritənin 1-ün [i] -4 aralığına malik olduğu ilk şərti düzgün tapırıq. Buna görə 1-i temp olaraq götürür və temp ++ edir. Sonra maxValue 2-yə dəyişdirin və arr [i] daxil edin və temp.

Və sadəcə bu kimi şərtləri yoxlamağa və tempdə dəyərləri almağa davam edəcəyik. Xəritəyə daxil etməyə davam edin, nəhayət maxValue dəyərini çıxışı olaraq əldə edirik.

Bitişik elementlər arasındakı fərqlə ya da 0 ya da 1 ilə maksimum uzunluq ardıcıllığıPin

Kodu

Bitişik elementlər arasındakı fərqlə 0 və ya 1 olaraq maksimum uzunluq ardıcıllığını tapmaq üçün C ++ kodu

#include<iostream>
#include<unordered_map>

using namespace std;

int getMaximumLenSubsequence(int arr[], int n)
{
    unordered_map<int, int> MAP;
    int maxValue = 0;
    for (int i=0; i<n; i++)
    {
        int temp = 0;
        if (MAP.find(arr[i]-1) != MAP.end() && temp < MAP[arr[i]-1])
            temp = MAP[arr[i]-1];

        if (MAP.find(arr[i]) != MAP.end() && temp < MAP[arr[i]])
            temp = MAP[arr[i]];

        if (MAP.find(arr[i]+1) != MAP.end() && temp < MAP[arr[i]+1])
            temp = MAP[arr[i]+1];

        MAP[arr[i]] = temp + 1;

        if (maxValue < MAP[arr[i]])
            maxValue = MAP[arr[i]];
    }
    return maxValue;
}
int main()
{
    int arr[] = {1, 4, 5, 2, 6, 5, 4, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << getMaximumLenSubsequence(arr, n);
    return 0;
}
5

0 və ya 1 kimi bitişik elementlər arasındakı fərqlə maksimum uzunluq ardıcıllığını tapmaq üçün Java kodu

import java.util.HashMap;

class subsequenceLength
{
    public static int getMaximumLenSubsequence(int[] arr)
    {
        int maxValue = 0;
        HashMap<Integer, Integer> MAP = new HashMap<>();
        for (int i = 0; i < arr.length; i++)
        {
            int temp = 0;
            if (MAP.containsKey(arr[i] - 1))
            {
                temp = MAP.get(arr[i] - 1);
            }

            if (MAP.containsKey(arr[i]))
            {
                temp = Math.max(temp, MAP.get(arr[i]));
            }

            if (MAP.containsKey(arr[i] + 1))
            {
                temp = Math.max(temp, MAP.get(arr[i] + 1));
            }
            temp++;
            if (temp > maxValue)
            {
                maxValue = temp;
            }
            MAP.put(arr[i], temp);
        }
        return maxValue;
    }
    public static void main(String[] args)
    {
        int arr[] = { 1, 4, 5, 2, 6, 5, 4, 8};
        System.out.println(getMaximumLenSubsequence(arr));
    }
}
5

Mürəkkəblik təhlili

Zamanın mürəkkəbliyi

O (n) hara "N" massivdəki elementlərin sayıdır. Biz sadəcə sıradakı bütün elementlərin üstündən keçdik. HashMap istifadə etdiyimiz üçün xətti zaman mürəkkəbliyində edə bildik.

Kosmik Mürəkkəblik

O (n) hara "N" massivdəki elementlərin sayıdır. Xəritədə elementlərlə əlaqəli məlumatları saxladığımızdan, kosmik mürəkkəblik də xəttlidir.

Crack Sistemi Dizayn Müsahibələri
Translate »