ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಡೋಬ್ ಅಮೆಜಾನ್ ಆಪಲ್ ಬ್ಲೂಮ್ಬರ್ಗ್ ಕ್ಯಾಪಿಟಲ್ ಒನ್ ಸಿಸ್ಕೋ ಫೇಸ್ಬುಕ್ ಗೂಗಲ್ ದೋಚಿದ ಇಂಟೆಲ್ ಐಎಕ್ಸ್ಎಲ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ನುಟಾನಿಕ್ಸ್ ಒರಾಕಲ್ ಪೇಟ್ಮ್ Snapchat ಉಬರ್ ಯಾಂಡೆಕ್ಸ್
ಲಿಂಕ್ಡ್-ಲಿಸ್ಟ್ ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳು

“ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್” ಸಮಸ್ಯೆಯಲ್ಲಿ, ಕೊಟ್ಟಿರುವ ಏಕೈಕ ಪೂರ್ಣಾಂಕವೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕು ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿ ಇದು ಪಾಲಿಂಡ್ರೋಮ್ ಅಥವಾ ಇಲ್ಲ.

ಉದಾಹರಣೆ

List = {1 -> 2 -> 3 -> 2 -> 1}
true

ವಿವರಣೆ # 1: ಪ್ರಾರಂಭ ಮತ್ತು ಹಿಂದಿನ ಎಲ್ಲಾ ಅಂಶಗಳು ಮೌಲ್ಯದಲ್ಲಿ ಒಂದೇ ಆಗಿರುವುದರಿಂದ ಪಟ್ಟಿ ಪಾಲಿಂಡ್ರೋಮ್ ಆಗಿದೆ.

List = {1 -> 2 -> 3 -> 4 -> 5}
false

ವಿವರಣೆ # 2: ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಬರುವ ಅಂಶಗಳು ಒಂದೇ ಆಗಿರದ ಕಾರಣ ಪಟ್ಟಿ ಪಾಲಿಂಡ್ರೋಮ್ ಅಲ್ಲ.

ಅನುಸಂಧಾನ (ಪುನರಾವರ್ತನೆ)

ಪಾಲಿಂಡ್ರೋಮ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ರಚನೆಯ ಹಿಂಭಾಗದಿಂದ ನೋಡ್‌ಗಳ ವಿವರಗಳನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಸುಲಭ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಎ ಏಕ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಎಂದರೆ ನಾವು ಯಾವುದೇ ನೋಡ್ ಅನ್ನು ತಲುಪಲು ಮಾತ್ರ ಪುನರಾವರ್ತಿಸಬಹುದು. ಹೀಗಾಗಿ, ನೋಡ್‌ಗಳನ್ನು ಹಿಂಭಾಗದಿಂದ ಹಿಡಿದಿಡಲು ಕೆಲವು ಡೇಟಾ ರಚನೆಯನ್ನು ಬಳಸುವುದು ಮುಖ್ಯವಾಗುತ್ತದೆ, ಉದಾ ಸ್ಟಾಕ್ ಇದು ಇತ್ತೀಚಿನ ಆಯ್ಕೆಯನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಇರಿಸುವ ಕಾರಣ ಸಂಭವನೀಯ ಆಯ್ಕೆಯಾಗಿದೆ. ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಸಹ ಇದೇ ರೀತಿ ಬಳಸಬಹುದು. ರಿವರ್ಸ್ ಕ್ರಮದಲ್ಲಿ ನೋಡ್ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಪುನರಾವರ್ತನೆ ಒಂದು ಸೊಗಸಾದ. ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ ಕೆಳಗಿನ ಸಾಮಾನ್ಯ ಸೂಡೊಕೋಡ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

inorderTraversal(root)
{
    if(root == null)
        return;
    inorderTraversal(root.left);
    print(root.data);
    inorderTraversal(root.right);
}

ಮೇಲಿನ ಕೋಡ್ ಮೊದಲು ಮುದ್ರಿಸುತ್ತದೆ ಬಿಟ್ಟು ಮರದ ನೋಡ್ಗಳು ಏಕೆಂದರೆ ನೋಡ್ನ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುವ ಮೊದಲು ಯಾವುದೇ ಮೂಲದ ಎಡ ಮಕ್ಕಳಿಗೆ ಹೋಗಲು ನಾವು ಪುನರಾವರ್ತಿತವಾಗಿ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತೇವೆ. ಅಂತೆಯೇ, ನಾವು ಬಳಸಬಹುದು ಪುನರಾವರ್ತನೆ ಮೊದಲು ಕೊನೆಯ ನೋಡ್‌ಗಳಿಗೆ ಹೋಗಲು ಮತ್ತು ಕಾರ್ಯವು ಬ್ಯಾಕ್‌ಟ್ರಾಕ್ ಮಾಡಿದಾಗ, ನಾವು ನೋಡ್ ಮೌಲ್ಯಗಳನ್ನು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಪಡೆಯುತ್ತೇವೆ. ಮುಂದಕ್ಕೆ ಪುನರಾವರ್ತಿಸಲು ನಾವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದು ಪುನರಾವರ್ತನೆಯಿಂದ ಪ್ರಭಾವಿತವಾಗುವುದಿಲ್ಲ. ಈ ರೀತಿಯಾಗಿ, ಅಂಶಗಳನ್ನು ಹೋಲಿಸಲು ನಾವು ಪುನರಾವರ್ತನೆಯಿಂದ ಪಡೆದ ಫಾರ್ವರ್ಡ್ ಇಟರೇಟರ್ ಮೌಲ್ಯ ಮತ್ತು ರಿವರ್ಸ್ ನೋಡ್ನ ಮೌಲ್ಯವನ್ನು ಹೋಲಿಸಬಹುದು.

ಕ್ರಮಾವಳಿ

  1. ಒಂದು ಕಾರ್ಯ isPalindrome () ಇದರೊಂದಿಗೆ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ತಲೆ ಪಾಲಿಂಡ್ರೋಮ್ ಅಥವಾ ಇಲ್ಲ
  2. ನಾವು ವರ್ಗದ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಹೆಸರಿಸಿದ್ದೇವೆ ಮುಂದೆ ಫಾರ್ವರ್ಡ್ ಪುನರಾವರ್ತನೆಗಳಿಗಾಗಿ ನೋಡ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು
  3. In isPalindrom ():
    • ಪ್ರಾರಂಭಿಸಿ ಮುಂಭಾಗ = ತಲೆ
    • ಹಿಂತಿರುಗಿ palindromeCheck (ತಲೆ)
  4. In palindromeCheck (ಪ್ರಸ್ತುತ):
    • If ಪ್ರಸ್ತುತ is ಶೂನ್ಯ:
      • ರಿಟರ್ನ್ ನಿಜವಾದ
    • If palindromeCheck (current.next) is ಸುಳ್ಳು:
      • ರಿಟರ್ನ್ ಸುಳ್ಳು
    • If ಸದ್ಯದ ಬೆಲೆ is ಅಲ್ಲ ಸಮಾನವಾಗಿರುತ್ತದೆ front.value
      • ರಿಟರ್ನ್ ಸುಳ್ಳು
    • ಹೆಚ್ಚಳ ಮುಂಭಾಗ:
      • ಮುಂಭಾಗ = ಮುಂಭಾಗ. ಮುಂದಿನ
    • ರಿಟರ್ನ್ ನಿಜವಾದ ನಾವು ಎಲ್ಲಾ ತಪಾಸಣೆಗಳನ್ನು ಮಾಡಿದಂತೆ
  5. ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸಿ

ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;
struct listNode
{
    int value;
    listNode* next;
    listNode(int x)
    {
        value = x;
        next = NULL;
    }
};

bool palindromeCheck(listNode* head)
{
    if(head == NULL)
        return true;
    if(!palindromeCheck(head->next))
        return false;
    if(front->value != head->value)
        return false;
    front = front->next;
    return true;
}

bool isPalindrome(listNode* head)
{
    front = head;
    return palindromeCheck(head);
}

int main()
{
    listNode* head = new listNode(1);
    head->next = new listNode(2);
    head->next->next = new listNode(3);
    head->next->next->next = new listNode(2);
    head->next->next->next->next = new listNode(1);

    cout << (isPalindrome(head) ? "true\n" : "false\n");
    return 0;
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

class listNode
{
    int value;
    listNode next;
    listNode(int x)
    {
        value = x;
        next = null;
    }
}

class palindrome_linked_list
{
    static listNode front;
    public static void main(String args[])
    {
        listNode head = new listNode(1);
        head.next = new listNode(2);
        head.next.next = new listNode(3);
        head.next.next.next = new listNode(2);
        head.next.next.next.next = new listNode(1);

        System.out.println((isPalindrome(head)) ? "true" : "false");
    }

    static boolean palindromeCheck(listNode head)
    {
        if(head == null)
            return true;
        if(!palindromeCheck(head.next))
            return false;
        if(front.value != head.value)
            return false;
        front = front.next;
        return true;
    }

    static boolean isPalindrome(listNode head)
    {
        front = head;
        return palindromeCheck(head);
    }
}
true

ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಒ (ಎನ್) ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಒಮ್ಮೆ ಪಟ್ಟಿಯನ್ನು ದಾಟುತ್ತಿದ್ದಂತೆ. ಇಲ್ಲಿ, ಪಟ್ಟಿಯಲ್ಲಿನ N = ನೋಡ್‌ಗಳ ಸಂಖ್ಯೆ.

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

ಒ (ಎನ್) ಪ್ರತಿ ನೋಡ್ ರಚನೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತೇವೆ N ಮೆಮೊರಿಯಲ್ಲಿ ಚೌಕಟ್ಟುಗಳನ್ನು ಜೋಡಿಸಿ.

ಅಪ್ರೋಚ್ (ರಿವರ್ಸ್ ಇತರೆ ಅರ್ಧ)

ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಬಳಸಿದ ಜಾಗವನ್ನು ತೊಡೆದುಹಾಕಲು ಇರುವ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ ನಿರ್ದಿಷ್ಟ ಪಟ್ಟಿಯನ್ನು ಸ್ಥಳದಲ್ಲಿ ಮಾರ್ಪಡಿಸುವುದು. ಲಿಂಕ್ ಮಾಡಲಾದ ಪಟ್ಟಿಯ ದ್ವಿತೀಯಾರ್ಧವನ್ನು ನಾವು ಹಿಮ್ಮುಖಗೊಳಿಸುತ್ತೇವೆ ಮತ್ತು ಅನುಗುಣವಾದ ಮೌಲ್ಯಗಳು ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಎರಡೂ ಭಾಗಗಳಿಗೆ ಎರಡು ಫಾರ್ವರ್ಡ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಈ ಪ್ರಕ್ರಿಯೆಗಾಗಿ, ನಾವು ಇದನ್ನು ಮಾಡಬೇಕಾಗಿದೆ:

  • ಪಟ್ಟಿಯ ಮಧ್ಯಭಾಗವನ್ನು ಕಂಡುಕೊಳ್ಳಿ ಇದರಿಂದ ನಾವು ದ್ವಿತೀಯಾರ್ಧವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಬಹುದು.
  • ಪಟ್ಟಿಯ ದ್ವಿತೀಯಾರ್ಧವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಲು ಒಂದು ಕಾರ್ಯವನ್ನು ರಚಿಸಿ
  • ಮೊದಲ ಮತ್ತು ದ್ವಿತೀಯಾರ್ಧವು ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ

ಮೇಲಿನ ಎಲ್ಲಾ ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ಮಾಡಬಹುದು. ನಾವು ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಯನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಿದ ನಂತರ, ದ್ವಿತೀಯಾರ್ಧವು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ನಾವು ಪರಿಶೀಲಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಕ್ರಮಾವಳಿ

  1. If ತಲೆ is ಶೂನ್ಯ:
    • ನಿಜ ಹಿಂತಿರುಗಿ
  2. ಬಳಸಿ ಲಿಂಕ್ ಮಾಡಿದ ಪಟ್ಟಿಯ ಮಧ್ಯವನ್ನು ಹುಡುಕಿ ಮಿಡಲ್ಆಫ್ಲಿಸ್ಟ್ (ತಲೆಕಾರ್ಯ:
    • ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿ ನಿಧಾನ ಮತ್ತು ವೇಗವಾಗಿ ಎರಡೂ ಪಟ್ಟಿಯ ತಲೆಗೆ ತೋರಿಸುತ್ತವೆ
    • ರವರೆಗೆ fast.next ಮತ್ತು fast.next.next ಎರಡೂ ಇವೆ ಅಲ್ಲ ಸೊನ್ನೆ:
      1. ಹೆಚ್ಚಳ ನಿಧಾನ 1 ರ ಹೊತ್ತಿಗೆ, slow = slow.next
      2. ಹೆಚ್ಚಳ ವೇಗವಾಗಿ 2 ರ ಹೊತ್ತಿಗೆ, fast = fast.next.next
    • ನಿಧಾನ ಪಾಯಿಂಟರ್ ಈಗ ಪಟ್ಟಿಯ ಮಧ್ಯಕ್ಕೆ ಸೂಚಿಸುತ್ತದೆ
    • ರಿಟರ್ನ್ ನಿಧಾನ
  3. ಈಗ ನಾವು ಪಟ್ಟಿ ಕರೆಯ ದ್ವಿತೀಯಾರ್ಧವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುತ್ತೇವೆ ರಿವರ್ಸ್ಲಿಸ್ಟ್ (ತಲೆ = middle.next) ಕಾರ್ಯ
    • ಪ್ರಾರಂಭಿಸಿ ಕೊನೆಯ = ಶೂನ್ಯ
    • ಹಾಗೆಯೇ ತಲೆ ಶೂನ್ಯವಲ್ಲ:
      • ಮುಂದಿನ ನೋಡ್ ಅನ್ನು ತಾತ್ಕಾಲಿಕ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ ಮುಂದಿನ
      • ಬಳಸುವ ಮೂಲಕ ಪಾಯಿಂಟರ್ ದಿಕ್ಕನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಿ head.next = ಹಿಂದಿನ
      • prev = ತಲೆ
      • ಬಳಸಿ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದುವರಿಯಿರಿ ತಲೆ = ಮುಂದಿನ
    • ರಿಟರ್ನ್ ಕೊನೆಯ
  4. ಈಗ, ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿ ptr1 ಮತ್ತು ptr2 ಎರಡೂ ಭಾಗಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು:
    1. ptr1 = ತಲೆ
    2. ptr2 = ಪ್ರಾರಂಭ ದ್ವಿತೀಯಾರ್ಧದ
    3. ಹಾಗೆಯೇ ptr2 ಶೂನ್ಯವಲ್ಲ:
      1. if ptr1.ಮೌಲ್ಯ ಗೆ ಸಮನಾಗಿಲ್ಲ ptr2.ಮೌಲ್ಯ
        1. ರಿಟರ್ನ್ ಸುಳ್ಳು
    4. ರಿಟರ್ನ್ ನಿಜವಾದ ನಾವು ಮೊದಲ ಮತ್ತು ದ್ವಿತೀಯಾರ್ಧದಲ್ಲಿ ಪ್ರತಿ ನೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿದಂತೆ
  5. ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸಿ

ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>
using namespace std;
struct listNode
{
    int value;
    listNode* next;
    listNode(int x)
    {
        value = x;
        next = NULL;
    }
};

listNode* middleOfList(listNode* head)
{
    listNode *slow = head , *fast = head;
    while(fast->next != NULL && fast->next->next != NULL)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

listNode* reverseList(listNode* head)
{
    listNode *prev = NULL;
    while(head != NULL)
    {
        listNode* next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

bool isPalindrome(listNode* head)
{
    if(head == NULL)
        return true;
    listNode* middleNode = middleOfList(head);
    listNode* startOfSecondHalf = reverseList(middleNode->next);

    listNode *ptr1 = head , *ptr2 = startOfSecondHalf;
    while(ptr2 != NULL)
    {
        if(ptr1->value != ptr2->value)
            return false;
        ptr1 = ptr1->next;
        ptr2 = ptr2->next;
    }
    return true;
}

int main()
{
    listNode* head = new listNode(1);
    head->next = new listNode(2);
    head->next->next = new listNode(3);
    head->next->next->next = new listNode(2);
    head->next->next->next->next = new listNode(1);

    cout << (isPalindrome(head) ? "true\n" : "false\n");
    return 0;
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

class listNode
{
    int value;
    listNode next;
    listNode(int x)
    {
        value = x;
        next = null;
    }
}

class palindrome_linked_list
{
    public static void main(String args[])
    {
        listNode head = new listNode(1);
        head.next = new listNode(2);
        head.next.next = new listNode(3);
        head.next.next.next = new listNode(2);
        head.next.next.next.next = new listNode(1);

        System.out.println((isPalindrome(head)) ? "true" : "false");
    }

    static listNode middleOfList(listNode head)
    {
        listNode slow = head , fast = head;
        while(fast.next != null && fast.next.next != null)
        {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    static listNode reverseList(listNode head)
    {
        listNode prev = null;
        while(head != null)
        {
            listNode next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        return prev;
    }

    static boolean isPalindrome(listNode head)
    {
        if(head == null)
            return true;
        listNode middleNode = middleOfList(head);
        listNode startOfSecondHalf = reverseList(middleNode.next);

        listNode ptr1 = head , ptr2 = startOfSecondHalf;
        while(ptr2 != null)
        {
            if(ptr1.value != ptr2.value)
                return false;
            ptr1 = ptr1.next;
            ptr2 = ptr2.next;
        }
        return true;
    }
}
true

ಪಾಲಿಂಡ್ರೋಮ್ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಒ (ಎನ್) ಪಟ್ಟಿಯ ಮಧ್ಯಭಾಗವನ್ನು ಕಂಡುಹಿಡಿಯಲು, ಅದನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಲು ಮತ್ತು ಎರಡೂ ಭಾಗಗಳನ್ನು ಹೋಲಿಸಲು ನಾವು ರೇಖೀಯ ಕುಣಿಕೆಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ. ಇಲ್ಲಿ, N = ಪಟ್ಟಿಯ ಗಾತ್ರ.

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

ಒ (1) ನಾವು ಸ್ಥಿರವಾದ ಹೆಚ್ಚುವರಿ ಜಾಗವನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತೇವೆ.