අනුක්‍රමික ලීට්කෝඩ් විසඳුමෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිය


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇමේසන්
අරා වර්ග කිරීම

ගැටළු ප්රකාශය

“අනුක්‍රමයෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිද” යන ගැටලුවේදී අපට අරාවක් ලබා දී ඇත, දැන් උත්පාදනය කළ හැකි නම් උත්තර දිය යුතුය අංක ගණිත ප්‍රගතිය අනුක්‍රමය නැවත සකස් කිරීමෙන්.

උදාහරණයක්

arr = [3,1,5]
true

පැහැදිලි කිරීම: අපට අරාව {1,3,5 as ලෙස නැවත සකස් කළ හැකිය, එය අංක 2 ලෙස පොදු වෙනසක් සහිත ගණිතමය ප්‍රගතියක් සාදයි, එබැවින් ප්‍රතිදානය සත්‍ය වේ.

අනුක්‍රමික ලීට්කෝඩ් විසඳුමෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිය

අංක ගණිත ශ්‍රේණියක් යනු යාබද අංකය අතර වෙනස නියත වන ශ්‍රේණියක්. ඉතා මූලික ප්‍රවේශයක් වනුයේ අරාව වර්ග කර යාබද මූලද්‍රව්‍ය අතර වෙනස පරීක්ෂා කිරීමයි, වෙනස සියලු අඛණ්ඩ යුගල සඳහා එක හා සමාන නම් එය ගණිතමය ප්‍රගතියක් වන අතර එසේ නොවුවහොත් එය ගණිතමය ප්‍රගතියක් නොවේ.

අනුක්‍රමික ලීට්කෝඩ් විසඳුමෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිය

වර්ග කිරීම සඳහා කාල සංකීර්ණත්වය nlogn වේ. අරාව සඳහා විමසුම් වගුවක් නිර්මාණය කිරීමෙන් අපට කාල සංකීර්ණතාව වැඩි දියුණු කළ හැකිය.

AP හි n වන පදය = a + (n-1) * d, මෙහි a යනු ශ්‍රේණියේ පළමු අංගය වන අතර n යනු මූලද්‍රව්‍ය ගණන වන අතර d යනු පොදු වෙනසකි.

AP හි අවම මූලද්‍රව්‍යය = a සහ

AP හි උපරිම මූලද්‍රව්‍යය = a + (n-1) * d එසේ වේ

d = (උපරිම-අවම) / (n-1).

  1. අරාවෙහි අවම සහ උපරිම අංග අපි සොයා ගනිමු. එය භාවිතා කිරීමෙන් අපට d (පොදු වෙනස) ගණනය කළ හැකිය.
  2. අරාව සඳහා විමසුම් වගුවක් සාදන්න.
  3. දැන් අපි දන්නවා පළමු අංගය සහ පොදු වෙනස.
  4. A සහ d මගින් සාදන ලද අංක ගණිත ශ්‍රේණියේ සියලුම n මූලද්‍රව්‍යයන් බැලීමේ වගුවේ තිබේදැයි අපි පරීක්ෂා කරන්නෙමු.
  5. බැලීමේ වගුවේ සියලුම අංග තිබේ නම් අපට අනුක්‍රමයෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිය. එසේ නොමැති නම් අපට අනුක්‍රමයෙන් අංක ගණිත ප්‍රගතියක් ලබා ගත නොහැක.

ක්රියාත්මක කිරීම

අනුපිළිවෙලින් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකි C ++ කේතය

#include <bits/stdc++.h> 
using namespace std; 
  bool canMakeArithmeticProgression(vector<int>& arr) {
  unordered_set<int> seen;
  int mi = INT_MAX, mx = INT_MIN, n = arr.size();
        for (int a : arr) {
            mi = min(mi, a);
            mx = max(mx, a);
            seen.insert(a);
        }
        int diff = mx - mi;
        if (diff % (n - 1) != 0) {
            return false;
        }
        diff /= n - 1;
        while (--n > 0) {
            if (seen.find(mi)==seen.end()) {
                return false;
            }
            mi += diff;
        }
        return true;
    }
int main() 
{ 
 vector<int> arr = {3,5,1}; 
 cout <<boolalpha;   
 cout<<canMakeArithmeticProgression(arr)<<endl; 
 return 0;
}
true

අනුපිළිවෙලින් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකි ජාවා කේතය

import java.util.*; 
public class Tutorialcup {
 public static boolean canMakeArithmeticProgression(int[] arr) {
        Set<Integer> seen = new HashSet<>();
        int mi = Integer.MAX_VALUE, mx = Integer.MIN_VALUE, n = arr.length;
        for (int a : arr) {
            mi = Math.min(mi, a);
            mx = Math.max(mx, a);
            seen.add(a);
        }
        int diff = mx - mi;
        if (diff % (n - 1) != 0) {
            return false;
        }
        diff /= n - 1;
        while (--n > 0) {
            if (!seen.contains(mi)) {
                return false;
            }
            mi += diff;
        }
        return true;
    }
  public static void main(String[] args) {
    int [] arr = {3,5,1}; 
    System.out.println( canMakeArithmeticProgression(arr));
  }
}
true

අනුක්‍රමික ලීට්කෝඩ් ද්‍රාවණයෙන් අංක ගණිතමය ප්‍රගතියක් ලබා ගත හැකිය යන සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

ඉහත කේතයේ කාල සංකීර්ණතාව වේ සාමාන්ය (n) මන්ද, අපි බැලීමේ වගුවක් නිර්මාණය කිරීම සඳහා අරාව හරහා ගමන් කරන අතර ගණිත ශ්‍රේණියේ සියලුම අංග බැලීමේ වගුවේ තිබේදැයි පරීක්ෂා කරමු. මෙහි n යනු ආදාන අරාවේ ප්‍රමාණයයි.

අවකාශයේ සංකීර්ණතාව

ඉහත කේතයේ අවකාශය සංකීර්ණ වේ සාමාන්ය (n) මොකද අපි අරාව සඳහා බැලීමේ වගුවක් නිර්මාණය කරනවා. මෙහි n යනු ආදාන අරාවේ ප්‍රමාණයයි.

ආශ්රිත