मेरे पास एक ऐसा फ़ंक्शन है जो एक हस्ताक्षरित छोटा लेता है और इसके लिए बिट मान प्रदर्शित करता है। वर्तमान में यह अग्रणी 0 के अलावा सभी प्रदर्शित करता है, और मैं इसके बजाय सभी 16 बिट स्थानों को प्रदर्शित करना चाहता हूं।

void display_result(unsigned short result)
{
     if(result >> 1)
     {
          display_result(result >> 1);
     }
     if(result & 1)
     {
          putc('1', stdout);
     }
     else
     {
          putc('0', stdout);
     }
     return;
}

उदाहरण इनपुट: 3
वांछित आउटपुट: ००००००००००००००११
वास्तविक आउटपुट: 11

मेरे कोड के बारे में मेरी समझ यह थी कि यह अनिवार्य रूप से परिणाम के बिट मानों के माध्यम से पुनरावृत्त होता है जिस तरह से यह एक सरणी के माध्यम से होता है, अगर कथन के आधार पर आउटपुट होता है, लेकिन वास्तव में ऐसा नहीं होता है, जो मुझे बताता है कि मुझे कुछ याद आ रहा है। क्या कोई इस पर कुछ प्रकाश डाल सकता है? (नोट: मैंने पोस्ट करने से पहले इस जानकारी की खोज की है, लेकिन मेरे खोज फू में कमी हो सकती है)।

0
jrbobdobbs83 6 अक्टूबर 2020, 20:27

2 जवाब

सबसे बढ़िया उत्तर

आपको पूर्ण 16 पुनरावृत्तियों की आवश्यकता है, न कि केवल तब तक जब तक कोई महत्वपूर्ण अंक न हों। अपने दृष्टिकोण का उपयोग करके, आप गहराई पैरामीटर जोड़ सकते हैं:

#include <stdio.h>
#include <limits.h>
    static void display_result_n_(unsigned short result, int n)
    {
         if(--n) { display_result_n_(result>>1,n); }
         if(result & 1) { putc('1', stdout); }
         else { putc('0', stdout); }
         return;
    }

void display_result(unsigned short result)
{
    display_result_n_(result,sizeof(unsigned short)*CHAR_BIT);
}
int main()
{
    display_result(3);
    puts("");
}

या आप इसे पुनरावृत्त रूप से कर सकते हैं। दो मूलांकों के आधार के लिए, आपको प्रत्यावर्तन की आवश्यकता नहीं है (आपके लिए रिकर्सन द्वारा किया गया) यदि आप बस दूसरे (सबसे महत्वपूर्ण) पक्ष से परीक्षण करते हैं 1<<15 मास्क को 16 बार खिसकाना।

void display_result(unsigned short result)
{
    unsigned mask = 1U<<((sizeof(unsigned short))*CHAR_BIT-1);
    for(;mask;mask>>=1) putc('0'+ !!(result&mask),stdout );
}
0
PSkocik 6 अक्टूबर 2020, 20:54

रिकर्सिव फ़ंक्शन को यह जानने की जरूरत है कि इसे कितनी बार पुनरावर्ती रूप से बुलाया जाना चाहिए। अहस्ताक्षरित शॉर्ट प्रकार की वस्तु के आकार को जानने के लिए इसे किसी भी तरह की आवश्यकता है।

सामान्य तौर पर दो दृष्टिकोण होते हैं।

पहला दो दो कार्यों को लिखता है। पहले वाले में कम से कम एक पैरामीटर होगा, संख्या, और दूसरे में कम से कम दो पैरामीटर होंगे, संख्या और वर्तमान बिट स्थिति।

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

#include <stdio.h>
#include <limits.h>

FILE * display_result( unsigned short n, size_t size, FILE *fp )
{
    if ( size != 0 )
    {
        display_result( n >> 1, size - 1, fp );
        fputc( ( n & 1 ) + '0', fp );
    }
    
    return fp;
}

FILE * bit_image( unsigned short n, FILE *fp )
{
    display_result( n, sizeof( unsigned short ) * CHAR_BIT, fp );
    
    return fp;
}

int main(void) 
{
    for ( unsigned short i = 0; i < 16; i++ )
    {
        fputc( '\n', bit_image( i, stdout ) );
    }
    
    return 0;
}

प्रोग्राम आउटपुट है

0000000000000000
0000000000000001
0000000000000010
0000000000000011
0000000000000100
0000000000000101
0000000000000110
0000000000000111
0000000000001000
0000000000001001
0000000000001010
0000000000001011
0000000000001100
0000000000001101
0000000000001110
0000000000001111

दूसरा दृष्टिकोण एक स्थिर स्थानीय चर होना है जो रिकर्सिव कॉल की गणना करेगा।

उदाहरण के लिए

#include <stdio.h>
#include <limits.h>

FILE * display_result( unsigned short n, FILE *fp )
{
    static size_t size;
    
    if ( size != CHAR_BIT * sizeof( unsigned short ) )
    {
        ++size;
        display_result( n >> 1, fp );
        fputc( ( n & 1 ) + '0', fp );
        --size;
    }
    
    return fp;
}

int main(void) 
{
    for ( unsigned short i = 0; i < 16; i++ )
    {
        fputc( '\n', display_result( i, stdout ) );
    }
    
    return 0;
}

प्रोग्राम आउटपुट वही है जो ऊपर दिखाया गया है।

-1
Vlad from Moscow 6 अक्टूबर 2020, 21:10