डुप्लिकेट को सरणी से निकालें और इसे दूसरे डुप्लिकेट में सहेजें [

Nov 24 2020

मुझे किसी अन्य मौजूदा सरणी से डुप्लिकेट किए गए मानों के बिना एक सरणी बनाने का काम सौंपा गया है। इसलिए मैंने ऐसा किया, लेकिन मैं जानना चाहता हूं कि क्या ऐसा करने का कोई और बेहतर तरीका है।

उदाहरण इनपुट / आउटपुट

Input: 1, 15, 1, 5, 1, 3

Output: 1, 15, 5, 3

मेरा कोड

#include <stdio.h>

int main(void) {
  const int ARRAY_SIZE = 5;

  int m[ARRAY_SIZE], p[ARRAY_SIZE];


  for(int i = 0; i < ARRAY_SIZE; i++) {
    printf("Enter number: ");
    scanf("%d",&m[i]);
  }
  // k variable is used to be the new indexing of the array p;
  int k = 0;

  // if it has a duplication dup is changed to 1;
  int dup = 0;
  
  // Loops through the array.
  for(int i =0; i < ARRAY_SIZE; i++) {
    for(int j = i +1; j <ARRAY_SIZE ; j++) {
        if(m[i] == m[j]) {
            dup = 1;
            break;
        }
    }
    if(dup != 1) {
      p[k++] = m[i];
    }
    dup = 0;
  }

  printf("The array without repeated values\n");

  for(int i = 0; i < k; i++) {
    printf("%d\n",p[i]);
  }

  return 0;
}

मुझे कुछ सुझाव चाहिए।

अग्रिम में धन्यवाद। :)

जवाब

1 TobySpeight Nov 24 2020 at 19:55

यदि इनपुट में वास्तव में संख्याओं के बीच अल्पविराम है, तो हम यहां उसके लिए अनुमति देना चाहेंगे:

scanf("%d",&m[i]);

किसी भी स्थिति में, वापसी मूल्य की जांच करना महत्वपूर्ण है scanf(), अन्यथा हम उन मानों का उपयोग कर सकते हैं जिन्हें ठीक से आरंभ नहीं किया गया है।

यह शायद इनपुट, आउटपुट और प्रोसेसिंग के लिए अलग-अलग फ़ंक्शन लिखने के लायक है, और फिर एक सरल main()है जो तीनों को एक साथ जोड़ता है।

1 Noname Nov 24 2020 at 18:25

आंतरिक लूप को फिर से व्यवस्थित करके एक ध्वज "डुबकी" से बचा जा सकता है। यहां एक संक्षिप्त संस्करण है, किसी तरह थोड़ा सा अंदर-बाहर ताकि हम p[k++]=मौके पर अपनी बात सही कर सकें :

    for (int i = 0; i < ARRAY_SIZE; i++) {

        for (int j = i + 1; m[i] != m[j]; j++) { /*NO! m[i+1] will be illegal */

            if (j == ARRAY_SIZE) {
                p[k++] = m[i];        // copy this one, next "i" please
                break;
            }
        }
    }

स्पष्टता के लिए मैं लगभग इसे आंतरिक पाश के रूप में पसंद करता हूं:


     for (int j = i + 1;; j++) {

          if (j == ARRAY_SIZE) {
              p[k++] = m[i];        // copy this one, next please
              break;
          }
          if (m[i] == m[j])
              break;               // skip, next 
     }

यह अधिक सममित है; आप इस अनन्त लूप (कोई मध्य अभिव्यक्ति) के लिए दो निकास स्थितियों की तुलना आसानी से कर सकते हैं।

jARRAY_SIZE तक पहुंचने पर पहले जांच करना महत्वपूर्ण है , और उसके बाद ही इसका उपयोग करें m[j]।

एक सरणी के लिए जैसे 120000000...000012मुझे लगता है कि यह नए, अद्वितीय सरणी में खोज करने के लिए तेज़ होगा ... लेकिन हाँ, इसीलिए छंटाई एक उपयोगी पहला (और मुख्य) कदम है।

पहला (कॉम्पैक्ट) संस्करण और भी गलत है । m[j]अंतिम तत्व के लिए पहले से ही अवैध होगा।