ಎಪಿ ರೂಪಿಸುವ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಮುದ್ರಿಸಿ


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಸೆಂಚರ್ ಅಕೋಲೈಟ್ ಕ್ಯಾಡೆನ್ಸ್ ಇಂಡಿಯಾ ಗೂಗಲ್ ಮಾಹಿತಿ ಎಡ್ಜ್ ಪ್ರತ್ಯಕ್ಷ pinterest
ಅರೇ ಹ್ಯಾಶ್ ಹುಡುಕಲಾಗುತ್ತಿದೆ

“ಎಪಿ ಅನ್ನು ರೂಪಿಸುವ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಮುದ್ರಿಸು” ಎಂಬ ಸಮಸ್ಯೆ ನಾವು ವಿಂಗಡಿಸಿದ್ದೇವೆ ಎಂದು ಹೇಳುತ್ತದೆ ಪೂರ್ಣಾಂಕ ರಚನೆ. ಅಂಕಗಣಿತದ ಪ್ರಗತಿಯನ್ನು ರೂಪಿಸುವ ಎಲ್ಲ ತ್ರಿವಳಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಕಾರ್ಯವಾಗಿದೆ.

ಎಪಿ ರೂಪಿಸುವ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಮುದ್ರಿಸಿ

ಉದಾಹರಣೆ

arr[] = {1,3,5,7,8,12,15,16,20,30}
(1, 3, 5), (3, 5, 7), (1, 8, 15), (8, 12, 16), (12, 16, 20)

ವಿವರಣೆ

ಇವೆಲ್ಲವೂ ಎಪಿ ರೂಪಿಸುವ ತ್ರಿವಳಿಗಳು

arr[] = {2,4,5,6,9,14,18,24}
(2, 4, 6), (4, 5, 6), (4, 9, 14), (4, 14, 24)

ವಿವರಣೆ

ಇವೆಲ್ಲವೂ ಎಪಿ ರೂಪಿಸುವ ತ್ರಿವಳಿಗಳು

ಕ್ರಮಾವಳಿ

  1. ನಿಂದ ಲೂಪ್ i = 1 ರಿಂದ n-1(ಒಳಗೊಂಡಿಲ್ಲ).
  2. J ನ ಮೌಲ್ಯವನ್ನು ನನಗಿಂತ ಕಡಿಮೆ ಮತ್ತು k ನ ಮೌಲ್ಯವನ್ನು ನನಗಿಂತ ಒಂದಕ್ಕೆ ಹೊಂದಿಸಿ.
  3. ಆದರೆ j> = 0 && k <n.
    1. ಎರಡು ಪ್ರಸ್ತುತ ರಚನೆಯ ಅಂಶಗಳ ಮೊತ್ತವು ಇತರ ರಚನೆಯ ಅಂಶಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ,
      1. ನಿಜವಾಗಿದ್ದರೆ, ಪ್ರಸ್ತುತ ಮೂರು ಅಂಶಗಳನ್ನು ಮುದ್ರಿಸಿ ಮತ್ತು ಕ್ರಮವಾಗಿ ಕೆ ಮತ್ತು ಜೆ ಮೌಲ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಮತ್ತು ಹೆಚ್ಚಿಸಿ.
    2. ಎರಡು ಅಂಶಗಳ ಮೊತ್ತವು ಮತ್ತೊಂದು ಅಂಶಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ಕಡಿಮೆಯಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ನಂತರ, k ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಿ.
    3. ಎರಡು ಅಂಶಗಳ ಮೊತ್ತವು ಮತ್ತೊಂದು ಅಂಶಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ಹೆಚ್ಚಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ, ನಂತರ, j ಅನ್ನು 1 ರಿಂದ ಕಡಿಮೆ ಮಾಡಿ.

ವಿವರಣೆ

ನಾವು ಎ ನೀಡಿದ್ದೇವೆ ವಿಂಗಡಿಸಲಾಗಿದೆ ಸರಣಿ. ಅಂಕಗಣಿತದ ಪ್ರಗತಿಯನ್ನು ರೂಪಿಸುವ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ಅಂಕಗಣಿತದ ಪ್ರಗತಿಯನ್ನು ಒಂದು ಸಂಖ್ಯೆಯ ಅನುಕ್ರಮ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಇದರಲ್ಲಿ ಎಲ್ಲಾ ಅಂಶಗಳು ಸತತವಾಗಿ ಅವುಗಳ ನಡುವೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಅಂತರದೊಂದಿಗೆ ಇಡೀ ಅನುಕ್ರಮದಲ್ಲಿ ಬರುತ್ತವೆ. ಎಪಿ ಯ ಸೂತ್ರದಿಂದ ನಾವು ತ್ರಿವಳಿಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ, ಅದು + ಸಿ = 2 ಬಿ ಎಂದು ಹೇಳುತ್ತದೆ, ಅಂದರೆ ಎರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವು ಮೂರನೇ ಸಂಖ್ಯೆಯ ಎರಡು ಪಟ್ಟು ಸಮಾನವಾಗಿರುತ್ತದೆ.

ಇಡೀ ಶ್ರೇಣಿಯನ್ನು ಲೂಪ್‌ಗಾಗಿ ಒಂದು ಮತ್ತು ಎ ಲೂಪ್ ಮಾಡುವಾಗ, 'ವೆಲ್ ಲೂಪ್' ನಾವು ಮೂರು ಅಂಶಗಳನ್ನು ಎಪಿ ರೂಪಿಸಬಹುದೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ನಾವು ಫಾರ್ ಲೂಪ್ ಮೂಲಕ ಸಂಚರಿಸುವಾಗಲೆಲ್ಲಾ ನಾವು ಜೆ ಮೌಲ್ಯವನ್ನು ಐ ಮೌಲ್ಯಕ್ಕಿಂತ ಕಡಿಮೆ ಮತ್ತು ಕೆ ಮೌಲ್ಯವನ್ನು ಐ ಮೌಲ್ಯಕ್ಕಿಂತ ಒಂದಕ್ಕೆ ಹೊಂದಿಸುತ್ತೇವೆ. ಇದು ನಮಗೆ ಪರಿಶೀಲಿಸಲು ಒಂದು ಅಂಶವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಪ್ರತಿ ಬಾರಿಯೂ ನಾವು ಮೂರು ಅಂಶಗಳನ್ನು ಹೊಂದಿರುವಾಗ arr [i], arr [j], ಮತ್ತು arr [k] ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಪ್ರತಿಯೊಂದಕ್ಕೂ ಬದಲಾಗುವ i, j, ಮತ್ತು k ನ ಮೌಲ್ಯ ಲೂಪ್ ಆಗಿರಲಿ ಅಥವಾ ಒಳಗೆ ಇರಲಿ ಲೂಪ್ ಮಾಡುವಾಗ.

ಎರಡು ಅಂಶಗಳ ಮೊತ್ತವು ಮೂರನೆಯ ಅಂಶಕ್ಕೆ ಸಮಾನವಾಗಿದೆ ಎಂದು ನಾವು ಕಂಡುಕೊಂಡರೆ, ನಾವು ಆ ಮೂರು ರಚನೆಯ ಅಂಶಗಳನ್ನು ಮುದ್ರಿಸಲಿದ್ದೇವೆ, ಅವು ಎಪಿ ರಚಿಸಬಹುದು. ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಪ್ರಕಾರ ನಾವು ಜೆ ಮತ್ತು ಕೆ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸುತ್ತೇವೆ. ನಾವು ಎರಡು ಅಂಶಗಳ ಮೊತ್ತವನ್ನು ಮೂರನೇ ಅಂಶಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ಕಡಿಮೆ ಕಂಡುಕೊಂಡರೆ. ನಾವು k ನ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತೇವೆ, ಅಥವಾ ಮೂರನೆಯ ಅಂಶಕ್ಕಿಂತ ಎರಡು ಪಟ್ಟು ಹೆಚ್ಚಿನ ಮೊತ್ತವನ್ನು ನಾವು ಕಂಡುಕೊಂಡರೆ, ನಾವು j ನ ಮೌಲ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ. ನಾವು ಇಡೀ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವವರೆಗೆ ಮತ್ತು ಎಪಿ ರಚಿಸುವ ಎಲ್ಲ ಅಂಶಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವವರೆಗೆ ಇದು ಮುಂದುವರಿಯುತ್ತದೆ.

ಕೋಡ್

ಎಪಿ ಅನ್ನು ರೂಪಿಸುವ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಮುದ್ರಿಸಲು ಸಿ ++ ಕೋಡ್

#include<iostream>

using namespace std;

void getTripletsWithAP(int arr[], int n)
{
  for (int i = 1; i < n - 1; i++)
  {
    int j = i - 1, k = i + 1;
        while(j >= 0 && k < n)
        {
            if (arr[j] + arr[k] == 2 * arr[i])
            {
        cout <<arr[j]<< " "<<arr[i]<<" "<<arr[k]<< endl;
                k++;
                j--;
            }
            else if (arr[j] + arr[k] < 2 * arr[i])
                k++;
            else
                j--;
        }
  }
}
int main()
{
  int arr[] = {1,3,5,7,8,12,15,16,20,30};
  int n = sizeof(arr) / sizeof(arr[0]);
  getTripletsWithAP(arr, n);
  return 0;
}
1 3 5
3 5 7
1 8 15
8 12 16
12 16 20

ಎಪಿ ರೂಪಿಸುವ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯಲ್ಲಿ ಎಲ್ಲಾ ತ್ರಿವಳಿಗಳನ್ನು ಮುದ್ರಿಸಲು ಜಾವಾ ಕೋಡ್

class TripletAP
{
    public static void getTripletsWithAP(int arr[], int n)
    {
        for (int i = 1; i < n - 1; i++)
        {
            int j = i - 1, k = i + 1;
            while(j >= 0 && k < n)
            {
                if (arr[j] + arr[k] == 2 * arr[i])
                {
                    System.out.println(arr[j] +" " +arr[i]+ " " + arr[k]);
                    k++;
                    j--;
                }
                else if (arr[j] + arr[k] < 2 * arr[i])
                    k++;
                else
                    j--;
            }
        }
    }
    public static void main (String[] args)
    {
        int arr[] = {1,3,5,7,8,12,15,16,20,30};
        int n = arr.length;
        getTripletsWithAP(arr, n);
    }
}
1 3 5
3 5 7
1 8 15
8 12 16
12 16 20

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್2ಅಲ್ಲಿ “ಎನ್”  ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ. ಏಕೆಂದರೆ ನಾವು ಎರಡು ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅಲ್ಲಿ ನಾವು ಮೊದಲ ಲೂಪ್ ಅಂತ್ಯವನ್ನು ತಲುಪುವವರೆಗೆ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಎರಡನೇ ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಅನ್ನು ಎಪಿ ಅಂಶಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (1) ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸ್ಥಳದ ಅಗತ್ಯವಿಲ್ಲ.