यह पहली बार है जब मैं सरणियों के साथ काम कर रहा हूं इसलिए मैं अपनी स्कूल की किताब पर कुछ अभ्यास करने की कोशिश कर रहा हूं। असाइनमेंट द्वारा जाता है:

एक सरणी में 10 नंबर स्टोर करें, उनमें से प्रत्येक को एक ही नंबर को दो बार प्रिंट किए बिना प्रिंट करें।

उदाहरण:

सरणी मान: 1, 2, 4, 6, 3, 7, 8, 44, 2,1

प्रिंट करने योग्य मान: 1, 2, 4, 6, 3, 7, 8, 44

मैं सरणी में 10 मानों में से प्रत्येक को स्टोर करने के लिए लूप बनाने में कामयाब रहा, लेकिन मैं यह नहीं समझ सकता कि एक दूसरे के बीच संग्रहीत मानों को कैसे जांचें।

मेरा कोड अब तक।

int main()
{
    int array[10], values[10], i;

    printf("insert 10 integers:");
    for(i=0; i<10; i++)
    {
        printf("\n");
        scanf("%d", &array[i]);
    }

    return 0;
}

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

संपादित करें 1:

int main()
{
    int array[10], values[10], i, a=1;

    printf("insert 10 integers:");
    for(i=0; i<10; i++)
    {
        printf("\n");
        scanf("%d", &array[i]);
        a=i-1;
        if(array[i]!=array[a])
        {
            values[i]=array[i];
        }
    }
    for(i=0; i<10; i++)
    {
        printf("\n%d", values[i]);
    }
    return 0;
}

मैंने कोड का यह नया भाग लिखा है जो वास्तव में एक दूसरे के बराबर वाले को फिर से प्रिंट किए बिना सरणी के मूल्यों को प्रिंट कर रहा है। ऐसा करने के लिए मैंने एक नई अनुक्रमणिका, 'ए' का उपयोग करने के बारे में सोचा, जो हमेशा पहली अनुक्रमणिका 'i' से 1 से कम होगी। सिवाय इसके कि मैं अभी भी 10 नंबर प्रिंट करता हूं और हटाए गए मानों को यादृच्छिक मानों के साथ प्रतिस्थापित करता हूं

3
Scottisos 4 मार्च 2020, 19:00
6
यदि आप पहले सरणी को क्रमबद्ध करते हैं, तो इसका ट्रैक रखना बहुत आसान हो जाएगा।
 – 
Govind Parmar
4 मार्च 2020, 19:02
1
क्या यह होमवर्क असाइनमेंट है? एक आसान तरीका यह होगा कि दो नेस्टेड लूप हों, बाहरी लूप 0 से 9 तक जा रहा हो, और एक आंतरिक लूप (for (int j = 0; j < i; j++)) जो इंडेक्स तक सरणी की जांच करता है i. उदाहरण के लिए, यदि i 2 है, तो आंतरिक लूप केवल सूचकांकों 0 और 1 की जांच करेगा। अगर आप j == i तक पहुंचने से पहले इस लूप से बाहर निकल जाते हैं, तो नंबर प्रिंट न करें। बड़े सरणियों के लिए, उचित दृष्टिकोण एक डेटा संरचना का उपयोग करना होगा जो आपको तुरंत बताएगी कि क्या संख्या पहले ही दर्ज की जा चुकी है (एक हैश टेबल या एक पेड़)।
 – 
Groo
4 मार्च 2020, 19:05
1
सत्य। लेकिन ए) ऐसा लगता है कि वांछित आउटपुट को सॉर्ट नहीं किया गया है (स्वीकार्य रूप से आप "प्रिंट करने योग्य मान" कैसे पढ़ते हैं) पर निर्भर करता है) बी) मेरा अनुमान है कि सॉर्टिंग पाठ्यक्रम में कुछ 2 अध्याय आगे है।
 – 
Yunnosch
4 मार्च 2020, 19:06
1
आप इसे कागज पर कैसे करेंगे? संकेत: आपके सभी नंबर कागज के टुकड़े पर लिखे गए हैं। कागज के टुकड़े से पहला नंबर लें, जांचें कि क्या यह पहले से ही कागज के टुकड़े पर लिखा हुआ है, यदि नहीं, तो इसे कागज के टुकड़े पर लिख लें। फिर लें कागज ए के टुकड़े से दूसरा नंबर, जांचें कि क्या यह पहले से ही कागज के टुकड़े पर लिखा गया है, यदि नहीं, तो इसे कागज के टुकड़े पर लिखें और इसी तरह।
 – 
Jabberwocky
4 मार्च 2020, 19:21
1
हाँ, यह 1,3,4,5,7,8 होना चाहिए। यदि उपयोगकर्ता एक ही संख्या को कई बार दर्ज करता है, तो अनिवार्य रूप से दो बार या अधिक दोहराए बिना मूल्यों को प्रिंट करना।
 – 
Scottisos
4 मार्च 2020, 19:28

3 जवाब

मुझे गोविंद परमार का सुझाव पसंद है।

एक और तरीका यह हो सकता है कि "डुप्लिकेट* जैसा कि आप उन्हें प्रिंट करते हैं की सूची रखें।

उदाहरण के लिए (छद्म कोड):

#define ARRAY_SIZE 10

void get_values(int[] array, int n_elements) {     
    printf("insert %d integers:", n_elements);
    for(int i=0; i<n_elements i++) {
        printf("\n");
        scanf("%d", &array[i]);
    }
}

bool check_printed (int[] array, int idx) {
    int value = array[idx];
    for (int i=0; i < idx-1; i++) {
        if (array[i] == value) {
            return TRUE;
        }
    }
    return FALSE;
}

int main() {
    int array[ARRAY_SIZE];    
    get_values(array, ARRAY_SIZE);    
    for(i=0; i<ARRAY_SIZE; i++) {
        if (!check_printed(array[i]) {
          printf("\n%d", array[i]);
        }
    }
    return 0;
}
4
FoggyDay 4 मार्च 2020, 20:39
- मैं सहमत हूं, मैंने तदनुसार अपना उत्तर अपडेट कर दिया है।
 – 
FoggyDay
4 मार्च 2020, 20:35

जब तक तत्वों की संख्या कम है, आपको प्रदर्शन के बारे में चिंता करने की आवश्यकता नहीं है। इसलिए आप वर्तमान तत्व से पहले सभी तत्वों के माध्यम से आसानी से लूप कर सकते हैं यह देखने के लिए कि क्या वर्तमान मान पहले ही मुद्रित किया जा चुका है।

दूसरे शब्दों में - यदि आप वर्तमान में जानना चाहते हैं कि तत्व को इंडेक्स 3 पर प्रिंट करना है या नहीं, तो देखें कि इंडेक्स 0, 1 या 2 में तत्व समान मान है या नहीं।

इसे कई तरीकों से लागू किया जा सकता है - यहाँ एक है:

for(int i=0; i<10; i++)
{
    // Flag to tell if current element shall be printed.
    //       Set flag to 1, i.e. assume current element shall be printed
    int doPrint = 1;

    // Now check for duplicates in the elements before the i'th element
    for(int j=0; j<i; j++)
    {
        if (values[i] == values[j])
        {
            // Duplicate found. Don't print. Clear flag.
            doPrint = 0;
        }
    }

    // Print if doPrint-flag is still 1
    if (doPrint) printf("%d ", values[i]);
}
printf("\n");

इस कार्यान्वयन में जटिलता ओ (एन ^ 2) है और इसलिए यह विशाल सरणी के लिए उपयुक्त नहीं है लेकिन जब तक आपके पास केवल 10 तत्व हों, यह ठीक और सरल है।

2
4386427 4 मार्च 2020, 20:28

यह बहुत आसान है।

शुरुआत के लिए यदि आपको केवल एक सरणी को आउटपुट करने की आवश्यकता है जब इसे न बदलें। किसी सरणी को आउटपुट करना और उसे बदलना दो अलग-अलग चीजें हैं।

साथ ही मूल सरणी को आउटपुट करने के लिए समान आकार की सहायक सरणी घोषित करने के लिए संसाधन की खपत होगी।

आपको जो चाहिए वह दो नेस्टेड लूप हैं और कुछ भी नहीं।

और अपने प्रोग्राम में मैजिक नंबर जैसे 10 का प्रयोग न करें। नामित स्थिरांक का प्रयोग करें।

यहाँ एक प्रदर्शनकारी कार्यक्रम है।

#include <stdio.h>

int main(void) 
{
    int array[] = { 1, 2, 4, 6, 3, 7, 8, 44, 2, 1 };
    const size_t N = sizeof( array ) / sizeof( *array );

    for ( size_t i = 0; i < N; i++ )
    {
        size_t j = 0;
        while ( j != i && array[j] != array[i] ) ++j;

        if ( j == i ) printf( "%d ", array[i] );
    }

    putchar( '\n' );

    return 0;
}

इसका आउटपुट है

1 2 4 6 3 7 8 44 
1
Vlad from Moscow 4 मार्च 2020, 19:49