സങ്കലനത്തിന്റെയും കുറയ്ക്കലിന്റെയും കമാൻഡുകൾ നടപ്പിലാക്കിയ ശേഷം പരിഷ്‌ക്കരിച്ച അറേ പ്രിന്റുചെയ്യുക  


വൈഷമ്യ നില മീഡിയം
പതിവായി ചോദിക്കുന്നു ബൈറ്റ്ഡാൻസ് സിസ്കോ ക്സെൻ ഫ്രീചാർജ് ഹാക്കർ റാങ്ക് നാഗാരോ Opera തെരദത
അറേ

നിങ്ങൾക്ക് വലുപ്പം n ന്റെ ഒരു ശ്രേണി നൽകിയിരിക്കുന്നു, തുടക്കത്തിൽ അറേയിലെ എല്ലാ മൂല്യങ്ങളും 0 ആയിരിക്കും, കൂടാതെ അന്വേഷണങ്ങളും. ഓരോ ചോദ്യത്തിലും നാല് മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ചോദ്യത്തിന്റെ തരം, ശ്രേണിയുടെ ഇടത് പോയിന്റ്, ഒരു ശ്രേണിയുടെ വലത് പോയിന്റ്, ഒരു നമ്പർ കെ, നിങ്ങൾ ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നടത്തണം.

T = 0 ആണെങ്കിൽ, നൽകിയിരിക്കുന്ന ശ്രേണിയിലെ തന്നിരിക്കുന്ന ശ്രേണിയിലെ (ആരംഭം, അവസാനം) എല്ലാ സംഖ്യകളിലേക്കും k മൂല്യം ചേർക്കുക,

ടി = 1 ആണെങ്കിൽ, തന്നിരിക്കുന്ന ശ്രേണിയിലെ തന്നിരിക്കുന്ന ശ്രേണിയിലെ (ആരംഭം, അവസാനം) എല്ലാ സംഖ്യകളിൽ നിന്നും k മൂല്യം കുറയ്ക്കുക,

ഉദാഹരണം  

arr[]={0, 0, 0, 0, 0}
Query: {(0, 2, 4, 1), (1, 3, 5, 2), (0, 1, 4, 3)}
3 4 2 2 -2

വിശദീകരണം

(0, 2, 4, 1) ശ്രേണിയിലെ എല്ലാ സംഖ്യകളിലേക്കും 1 ചേർക്കുക, കാരണം ഇത് ടൈപ്പ് 0 ചോദ്യമാണ്.

(1, 3, 5, 2) ഒരു ടൈപ്പ് 2 ചോദ്യമായതിനാൽ പരിധിയിലെ എല്ലാ പൂർണ്ണസംഖ്യകളിൽ നിന്നും 1 കുറയ്ക്കുക.

(0, 1, 4, 3) ശ്രേണിയിലെ എല്ലാ സംഖ്യകളിലേക്കും 3 ചേർക്കുക, കാരണം ഇത് ടൈപ്പ് 0 ചോദ്യമാണ്.

സങ്കലനത്തിന്റെയും കുറയ്ക്കലിന്റെയും കമാൻഡുകൾ നടപ്പിലാക്കിയ ശേഷം പരിഷ്‌ക്കരിച്ച അറേ പ്രിന്റുചെയ്യുകമൊട്ടുസൂചി  

 

ഒന്നിലധികം ചോദ്യങ്ങൾക്ക് ശേഷം പരിഷ്‌ക്കരിച്ച അറേ പ്രിന്റുചെയ്യാനുള്ള അൽഗോരിതം  

  1. സമാരംഭിക്കുക ശ്രേണി 0.
  2. ഓരോ ചോദ്യത്തിനും,
  3. ടൈപ്പ് അന്വേഷണം മൂല്യങ്ങൾ ചേർക്കുന്നതിനാണെങ്കിൽ, മൂല്യം k ചേർത്ത് ഇടത് -1 സ്ഥാനത്ത് മൂല്യം അപ്ഡേറ്റ് ചെയ്യുക, വലത് സ്ഥാനത്ത് k മൂല്യം കുറയ്ക്കുക.
  4. ടൈപ്പ് അന്വേഷണം മൂല്യങ്ങൾ കുറയ്ക്കുകയാണെങ്കിൽ, മൂല്യം k കുറച്ചുകൊണ്ട് ഇടത് -1 സ്ഥാനത്ത് മൂല്യം അപ്ഡേറ്റ് ചെയ്യുക, വലത് സ്ഥാനത്ത് k മൂല്യം ചേർക്കുക.
  5. അറേയിലൂടെ സഞ്ചരിച്ച് മുമ്പത്തെ ഓരോ മൂല്യവും അറേയുടെ നിലവിലെ മൂല്യത്തിലേക്ക് ചേർക്കുക.
  6. അവസാന ശ്രേണി അച്ചടിക്കുക.
ഇതും കാണുക
വിപരീത ക്രമത്തിൽ ഫിബൊനാച്ചി നമ്പറുകൾ അച്ചടിക്കുക

വിശദീകരണം

ഞങ്ങൾക്ക് ഒരു അറേ നൽകിയിട്ടുണ്ട്, തുടക്കത്തിൽ, അറേയിലെ എല്ലാ മൂല്യങ്ങളും 0 ആണ്. ഞങ്ങൾക്ക് a ഉം നൽകിയിട്ടുണ്ട് q ചോദ്യങ്ങളുടെ എണ്ണം, അന്വേഷണം രണ്ട് തരത്തിലായിരിക്കും, ഓരോ ചോദ്യത്തിലും അതിന്റെ തരം, ശ്രേണി, ഒരു സംഖ്യ എന്നിവ അടങ്ങിയിരിക്കുന്നു. അന്വേഷണത്തിന്റെ തരം 0 ആണെങ്കിൽ, പരിധിക്കുള്ളിൽ വരുന്ന എല്ലാ സംഖ്യകളിലേക്കും ഞങ്ങൾ k മൂല്യം ചേർക്കും. ഞങ്ങൾക്ക് അന്വേഷണ തരം 1 ആയി നൽകിയിട്ടുണ്ടെങ്കിൽ, പരിധിക്കുള്ളിൽ എല്ലാ സംഖ്യകളിൽ നിന്നും k മൂല്യം കുറയ്ക്കും. എല്ലാ ചോദ്യങ്ങളും നടപ്പിലാക്കിയ ശേഷം, ഫലമായുണ്ടാകുന്ന അറേ ഞങ്ങൾ അച്ചടിക്കും.

ഈ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന്. ആദ്യം ഞങ്ങൾക്ക് ഏത് തരത്തിലുള്ള അന്വേഷണം നൽകിയിട്ടുണ്ടെന്ന് പരിശോധിക്കേണ്ടതുണ്ട്. അന്വേഷണം ആദ്യ തരത്തിലുള്ളതാണെങ്കിൽ, അറേയിലെ ശ്രേണിയുടെ ആരംഭ പോയിന്റിലേക്ക് ഞങ്ങൾ k മൂല്യം ചേർക്കുന്നു. കൂടാതെ, അറേയുടെ ശ്രേണിയുടെ അവസാന സ്ഥാനത്ത് നിന്ന് k മൂല്യം കുറയ്ക്കുക.

മുമ്പ് സൂചിപ്പിച്ച സാങ്കേതികതയ്ക്ക് വിപരീതമായി ഞങ്ങൾ ചെയ്യും. ടൈപ്പ് 1 അന്വേഷണം ഉപയോഗിക്കാൻ ഞങ്ങൾക്ക് നൽകിയിട്ടുണ്ടെങ്കിൽ, അതിൽ ഇൻറിജർ അറേയുടെ എല്ലാ മൂല്യങ്ങളും പരിധിക്കുള്ളിൽ കുറയ്ക്കണം. ഒരു അറേയുടെ ആരംഭ ശ്രേണി മൂല്യത്തിൽ നിന്ന് k മൂല്യം കുറയ്ക്കും. അതിനുശേഷം, ശ്രേണിയുടെ എൻ‌ഡ്‌പോയിൻറ് സൂചികയിൽ‌ k മൂല്യം ചേർക്കുക.

നൽകിയ ഓരോ ചോദ്യത്തിനും. സൂചിപ്പിച്ച സാങ്കേതികത ഞങ്ങൾ നിർവഹിക്കണം. അതിനുശേഷം ഞങ്ങൾ ഒരു അറേ നിർമ്മിക്കും, അതിൽ അറേയുടെ നിലവിലെ മൂല്യത്തിലേക്ക് മുമ്പത്തെ മൂല്യം ചേർക്കും. നിലവിലെ മൂല്യത്തിലേക്ക് തുക സംഭരിക്കുക. അല്ലെങ്കിൽ അറേയുടെ നിലവിലെ മൂല്യം ഞങ്ങൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നുവെന്ന് പറയാം. ഒരു അറേ നിർമ്മിച്ച ശേഷം, ഞങ്ങൾ അറേ അച്ചടിക്കും. പരിഷ്‌ക്കരിച്ച അറേയുടെ ആഗ്രഹിച്ച ഫലമാണിത്.

ഇതും കാണുക
ചങ്ങാതിമാരുടെ ജോടിയാക്കൽ പ്രശ്നം

കോഡ്  

സങ്കലനത്തിന്റെയും കുറയ്ക്കലിന്റെയും കമാൻഡുകൾ നടപ്പിലാക്കിയ ശേഷം പരിഷ്‌ക്കരിച്ച അറേ പ്രിന്റുചെയ്യുന്നതിനുള്ള സി ++ കോഡ്

#include<iostream>
#include<stdio.h>
#include<string.h>

using namespace std;

void solveQuery(int arr[], int n, int T, int left, int right, int k)
{
    if (T == 0)
    {
        arr[left -1] += k;
        arr[right] += -k;
    }
    else
    {
        arr[left -1] += -k;
        arr[right] += k;
    }
    return;
}

void build(int arr[], int n)
{
    for (int i = 1; i < n; ++i)
        arr[i] += arr[i-1];

    return;
}

int main()
{
    int n = 5;
    int arr[n+1];

    memset(arr, 0, sizeof(arr));


    //query, left, right, k(value which is to add or subtract.
    solveQuery(arr, n, 0, 2, 4, 1);

    //query, left, right, k(value which is to add or subtract.
    solveQuery(arr, n, 1, 3, 5, 2);

    //query, left, right, k(value which is to add or subtract.
    solveQuery(arr, n, 0, 1, 4, 3);

    build(arr, n);

    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";
    return 0;
}
3 4 2 2 -2

സങ്കലനത്തിന്റെയും കുറയ്ക്കലിന്റെയും കമാൻഡുകൾ നടപ്പിലാക്കിയ ശേഷം പരിഷ്‌ക്കരിച്ച അറേ പ്രിന്റുചെയ്യാനുള്ള ജാവ കോഡ്

import java.util.Arrays;

class AdditionSubtractionQuery
{
    static void solveQuery(int arr[], int n, int T, int left, int right, int k)
    {
        if (T == 0)
        {
            arr[left -1] += k;
            arr[right] += -k;
        }
        else
        {
            arr[left -1] += -k;
            arr[right] += k;
        }
        return;
    }
    
    static void build(int arr[], int n)
    {
        for (int i = 1; i < n; ++i)
            arr[i] += arr[i-1];
    }
    
    public static void main(String arg[])
    {
        int n = 5;
        int arr[] = new int[n+1];
        Arrays.fill(arr, 0);

        //query, left, right, k(value which is to add or subtract.
        solveQuery(arr, n, 0, 2, 4, 1);

        //query, left, right, k(value which is to add or subtract.
        solveQuery(arr, n, 1, 3, 5, 2);

        //query, left, right, k(value which is to add or subtract.
        solveQuery(arr, n, 0, 1, 4, 3);

        build(arr, n);

        for (int i = 0; i < n; ++i)
            System.out.print(arr[i]+" ");
    }
}
3 4 2 2 -2

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

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

O (q + n) എവിടെ "Q" ചോദ്യങ്ങളുടെ എണ്ണം, കൂടാതെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. കാരണം ആദ്യം നമ്മൾ Q ചോദ്യങ്ങൾ നടത്തുന്നു, അത് O (1) സമയമെടുക്കുകയും തുടർന്ന് അറേ നിർമ്മിക്കുന്നതിന് O (N) സമയം ആവശ്യമാണ്.

ഇതും കാണുക
ഒരു സ്ട്രിംഗിൽ നെസ്റ്റഡ് പാരന്തസിസിസിന്റെ പരമാവധി ആഴം കണ്ടെത്തുക

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

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. പ്രവർത്തനങ്ങൾ നടത്താൻ ഞങ്ങൾ ഒരു അറേ സൃഷ്ടിച്ചതിനാൽ. സ്ഥല സങ്കീർണ്ണത രേഖീയമാണ്.