C कोड संकेतक

Question

स्थिति: आप एक हाई स्कूल शिक्षक हैं, अपने कंप्यूटिंग क्लास को सिखाते हैं कि C प्रोग्राम कैसे लिखें। हालाँकि, चूंकि यह शब्द की शुरुआत है, इसलिए आपने उन्हें इंडेंटेशन और रिक्ति के महत्व के बारे में नहीं सिखाया है। जैसा कि आप उनके काम को चिह्नित कर रहे हैं, आपकी आँखें इतनी पीड़ा देती हैं कि आप पीड़ा में चिल्लाते हैं, और महसूस करते हैं कि यह नहीं चल सकता है।

कार्य: आपने किसी भी भाषा में एक प्रोग्राम लिखने का फैसला किया है, जो इनपुट के रूप में एक मान्य सी सोर्सकोड लेता है और इसे अच्छी तरह से स्वरूपित करता है। आपको यह तय करना चाहिए कि एक अच्छी तरह से प्रारूपित कोड क्या है, क्योंकि यह एक लोकप्रियता प्रतियोगिता है। आपको जितनी सुविधाएँ दी जा सकती हैं उतनी लागू करने के लिए प्रोत्साहित किया जाता है, निम्नलिखित कुछ उदाहरण हैं:

• प्रत्येक पंक्ति के सामने उचित इंडेंटेशन जोड़ें
• के बाद रिक्त स्थान ,और अन्य ऑपरेटरों, जैसे परिवर्तित int a[]={1,2,3};करने के लिए जोड़ें int a[] = {1, 2, 3};। याद रखें कि हालांकि स्ट्रिंग शाब्दिक के भीतर ऑपरेटरों को संसाधित नहीं करना है।
• प्रत्येक पंक्ति के बाद अनुगामी रिक्त स्थान निकालें
• बयानों को कई लाइनों में अलग करना, जैसे कि छात्र एक पंक्ति में tmp=a;a=b;b=tmp;या int f(int n){if(n==1||n==2)return 1;else return f(n-1)+f(n-2);}सभी लिख सकते हैं, आप उन्हें अलग-अलग लाइनों में अलग कर सकते हैं। forहालांकि छोरों से अवगत रहें , उनमें अर्धविराम हैं, लेकिन मुझे नहीं लगता कि आपको उन्हें विभाजित करना चाहिए।
• प्रत्येक फ़ंक्शन को परिभाषित करने के बाद एक नई लाइन जोड़ें
• एक और अन्य विशेषताएं आप अपने छात्रों के कोड को समझने में मदद के साथ आ सकते हैं।

जीत के मानदंड: यह एक लोकप्रियता प्रतियोगिता है, इसलिए अधिकांश उत्थान के साथ उत्तर जीतता है। एक टाई के मामले में, सबसे अधिक सुविधाओं के साथ जवाब ने जीत हासिल की। यदि वह फिर से टाई है तो सबसे छोटा कोड जीत जाता है।

आपको अपने उत्तर में उन विशेषताओं की सूची शामिल करने का सुझाव दिया गया है जिन्हें आपने लागू किया है, साथ ही एक नमूना इनपुट और आउटपुट भी।

संपादित करें: जैसा कि टिप्पणियों में अनुरोध किया गया है, एक नमूना इनपुट है, हालांकि ध्यान रखें कि यह केवल संदर्भ के लिए है और आपको यथासंभव अधिक सुविधाओं को लागू करने की सिफारिश की जाती है।

इनपुट:

#include <stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n"); //Semicolon added in the string just to annoy you
             /* Now we take the input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
        s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
}}printf("Your name in upper case is:\n%s\n",s);
   return 0;}

इस तरह से मैं सामान्य रूप से इस कोड को प्रारूपित करूंगा: (मैं एक आलसी व्यक्ति हूं)

#include <stdio.h>
#include <string.h>
int main() {
    int i;
    char s[99];
    printf("----------------------\n;;What is your name?;;\n----------------------\n"); //Semicolon added in the string just to annoy you
    /* Now we take the input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++) {
        if(s[i]>='a'&&s[i]<='z') {
            s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
        }
    }
    printf("Your name in upper case is:\n%s\n",s);
    return 0;
}

मुझे लगता है कि यह पढ़ना आसान है:

#include <stdio.h>
#include <string.h>
int main() {
    int i;
    char s[99];
    printf("----------------------\n;;What is your name?;;\n----------------------\n"); //Semicolon added in the string just to annoy you
    /* Now we take the input: */
    scanf("%s", s);
    for(i = 0; i < strlen(s); i++) {
        if(s[i] >= 'a' && s[i] <= 'z') {
            s[i] -= ('a' - 'A'); //this is same as s[i]=s[i]-'a'+'A'
        }
    }
    printf("Your name in upper case is:\n%s\n", s);
    return 0;
}

इसके अलावा, अब जब मुझे उत्तर मिलने शुरू हो गए हैं, तो सबसे अधिक मतों की गिनती के साथ अंतिम उत्तर के 5 दिन बाद स्वीकार किया जाएगा, अर्थात यदि 5 दिनों के भीतर अधिक नए उत्तर नहीं मिलते हैं, तो यह प्रतियोगिता समाप्त हो जाएगी।

Comments

नीचे वोट के लिए कोई कारण?

— user12205

मैं सभी अनावश्यक व्हाट्सएप ( s/\s+/ /) को हटा सकता था और इसे एक दिन कह सकता था

— शाफ़्ट फ्रीक

@ratchet फ्रीक आप कर सकते हैं, लेकिन मुझे नहीं लगता कि यह बहुत सारे अपवोट्स के साथ एक उत्तर होगा।

— user12205

इनाम खरीदने के लिए @Quincunx धन्यवाद। मुझे लगा कि मेरा सवाल चूसा।

— user12205 11

@CousinCocaine: यह एक लोकप्रियता संदर्भ है। वे सुरुचिपूर्ण, या मानक तरीके से समस्या को हल करने के लिए डिज़ाइन नहीं किए गए हैं। वे सबसे अच्छे तरीके से समस्या को हल करने के लिए डिज़ाइन किए गए हैं जो आप संभवतः कल्पना कर सकते हैं।

— स्वस्तिक

Answer 1

क्योंकि हम इंडेंटेशन और व्हॉट्सएप के बारे में बात कर रहे हैं, हमें बस एक प्रोग्रामिंग में कोड लिखना होगा जो वास्तव में व्हाट्सएप के आसपास डिज़ाइन किया गया है , क्योंकि यह सबसे आसान है, है ना?

तो समाधान है:

यहाँ यह base64 में है:

ICAgCQogICAgCgkJICAgIAkgCiAgICAKCQkgICAgCQkKICAgIAoJCSAgICAJICAKICAgIAoJCSAgICAJIAkKICAgIAoJCSAKIAogCQoKICAgCSAKICAgCQoJCQkgICAJCQkgCQkKCSAgCQoJICAJICAKICAgCQoJCQkgICAJIAkgCgkgIAkKCSAgCSAJCiAgIAkKCQkJICAgCSAgCQoJICAJCgkgIAkgCQogICAJCgkJCSAgIAkgICAgIAoJICAJCgkgIAkgCQogICAJCgkJCSAgIAkJCQkJIAkKCSAgCQoJICAJCSAKICAgCQoJCQkgICAJICAgCSAKCSAgCQoJICAJICAgIAogICAJCgkJCSAgIAkgCSAgIAoJICAJCgkgIAkgICAJCQogICAJCgkJCSAgIAkgCSAgCQoJICAJCgkgIAkgIAkgIAogICAJIAogICAJCgkJIAogCSAJCQkKICAgCQoJCQkJCiAgCgkKCiAgIAkgIAogICAJCgkJCQkKICAKCQoKICAgCSAJCgoJCgogICAJCSAKICAgCQkKICAgCQkKCQkJICAgCQoJICAJCQkgICAgCSAKICAgCQoJCSAKIAkgCQkJCiAgIAkKCQkJCQogIAoJCgogICAJICAgIAogICAJIAogICAJIAoJCSAKIAkgCQkJCiAgIAkKCQkJCQogIAoJCgogICAJICAgCQkKICAgCSAJCiAgIAkgCQoJCQkgICAJCgkgICAJCSAgICAJIAogICAJCgkJIAogCSAJCQkKICAgCQoJCQkJCiAgCgkKCiAgIAkgIAkgIAogICAJIAkKICAgCSAJCgkJCSAgIAkKCSAgCQkJICAgIAkgCiAgIAkKCQkgCiAJIAkJCQogICAJCgkJCQkKICAKCQoKICAgCQkKICAgCQoJCQkgICAJIAkgCgkgIAkKCSAgCQkgIAogICAJCgkJCSAgIAkJCQkgCQkKCSAgCQoJICAJCSAJCiAgIAkKCQkJICAgCQkJCQkgCQoJICAJCgkgIAkJCSAKICAgCQoJCQkgICAJCQkgCQkKCSAgCQoJICAJCQkJCiAgIAkKCQkJICAgCSAgIAkgCgkgIAkKCSAgCQkgCQkKICAgCQoJCQkgICAJIAkgCSAKCSAgCQoJICAJCQkgIAogICAJCgkJCSAgIAkgCQkJCQoJICAJCgkgIAkJCSAJCiAgIAkKCQkJICAgCSAJICAgCgkgIAkKCSAgCSAgCSAJCiAgIAkKCQkJICAgCSAJICAJCgkgIAkKCSAgCSAgCQkgCiAgIAkKCQkJCQogIAoJCgogICAJCSAgCiAgIAkgCiAgICAKCQkgCgkKCiAgIAkJIAkKICAgCQoJCQkJCiAgICAgCSAKICAgIAoJCSAgICAJCQogICAJCQoJCQkgICAJCgkgICAJCSAKCQoKICAgCQkJIAogICAJCQogICAJCQoJCQkgICAJCgkgIAkJCSAKIAkgCQkJCiAgIAkKCQkJCQogICAgIAkgCiAgICAKCQkgCgkKCiAgIAkJCQkKICAgCQoJCQkJCiAgICAgCSAJCgkJCQoJICAJIAkgCgoJCgogICAJICAJCQkKICAgCSAKICAgIAoJCSAKCQoKICAgCQkgCQkKICAgCQoJCQkJCiAgICAgCSAKICAgCSAKCQkgCgkKCiAgIAkJCSAgCiAgIAkgIAoJCQkgICAJIAkJCQkKCSAgCQoJICAJCQkJIAogICAJCgkJCQkKICAKCQoKICAgCQkJIAkKICAgCSAgCgkJCSAgIAkgCQkJCQoJICAJCgkgIAkJCQkJCiAgIAkKCQkJCQogIAoJCgogICAJCQkJIAogICAJCgkJCQkKICAgICAJIAogICAJCQoJCSAKCQoKICAgCQkJCQkKICAgCQoJCQkJCiAgICAgCSAKICAgCSAgCgkJIAoJCgogICAJICAJIAkKICAgCSAJCiAgIAkgCQoJCQkgICAJCgkgICAJCSAgICAJCgkJCQkKICAKCQoKICAgCSAgCQkgCiAgIAkgCQogICAJIAkKCQkJICAgCQoJICAJCQkgICAgCQoJCQkJCiAgCgkKCiAgIAkJCQogICAJIAkgCgkKICAgICAJCQoJCQkKICAgCSAgCQogCiAKCSAgCSAgIAogCiAKCQkgCSAgIAogICAJICAgICAKCQogICAgIAkgICAgIAoJCiAgICAgCQoJICAJCiAKIAkgIAkKCiAgIAkgICAKCgkKCiAgIAkgCSAJCiAgIAkKCQkJICAgCSAJIAoJICAJCgkgIAkJICAgCiAgIAkKCQkJICAgCSAgIAkgCgkgIAkKCSAgCQkgIAkKICAgCQoJCQkJCiAgCgkKCiAgIAkJICAgCiAgIAkgCiAgICAKCQkgCgkKCiAgIAkJICAJCiAgIAkgIAoJCQkgICAJIAkJCSAgCgkgIAkKCSAgCQkgCSAKICAgCSAKICAgCQoJCSAgICAJCgkJCQkKICAKCQoKICAgCQkgCSAKICAgCQoJCQkJCiAgCgkKCiAgIAkgCQkgCiAgIAkKCQkJICAgCSAJCQkJCgkgIAkKCSAgCSAgICAgCiAgIAkKCQkJCQogIAoJCgogICAJICAgICAKICAgCSAgCgkJCSAgIAkgCSAJIAoJICAJCgkgIAkgICAgCQogICAJCgkJCQkKICAKCQoKICAgCSAgICAJCiAgIAkKCQkJCQogICAgIAkgCiAgIAkKCQkgCgkKCiAgIAkgCQkJCiAgIAkKCQkJICAgCSAJIAoJICAJCgkgIAkgICAJIAogICAJCgkJCQkKICAKCQoKICAgCSAgIAkgCiAgIAkgCiAgICAKCQkgCgkKCiAgIAkKICAgCSAgCiAgIAkKCQkJCQkgICAgCQoJCgkgICAgCSAKCQkJCgkgIAkgCSAKICAgCSAKCQkJICAgCQoJICAJCgkgIAkgICAJCiAgIAkgCgkJCSAgIAkgCgkgIAkKCSAgCSAgCSAKICAgCSAKCQkJICAgCQkKCSAgCQoJICAJICAJCQogICAJIAoJCQkgICAJICAKCSAgCQoJICAJIAkgIAoKICAgCSAgIAkKCiAJIAkJCgogCiAJIAkJCgogICAJIAkgCgogCSAJIAoKIAogCSAJCQoKICAgCSAgCSAKCiAJIAkgCSAJCgogCiAJIAkJCgogICAJICAJCQoKIAkgCSAJCSAKCiAKIAkgCQkKCiAgIAkgCSAgCgogCSAJIAkJCQoKICAgCSAJCQoKIAogCQoKCgo=

जिन लोगों के पास एक पेपर पर कोड को प्रिंट करने के मुद्दे हैं, उनके लिए एनोटेट संस्करण है (आप उत्तर के अंत में इसके लिए एक कंपाइलर पा सकते हैं):

# heap structure:
# 1: read buffer
# 2: parser state
#   0: before indentation
#   1: after indentation
#   2: inside a string literal
#   3: inside a multiline comment
#   4: inside a single line comment
# 3: identation
# 4: old read buffer
# 5: parenthesis nesting amount

# -------------------
# initialize heap
# -------------------
SS 1 | SS 0 | TTS # [1] := 0
SS 2 | SS 0 | TTS # [2] := 0
SS 3 | SS 0 | TTS # [3] := 0
SS 4 | SS 0 | TTS # [4] := 0
SS 5 | SS 0 | TTS # [5] := 0
LSL 1 # goto L1

# -------------------
# sub: determine what to do in state 0
# -------------------
LSS 2 # LABEL L2
SS 1 | TTT | SS  59 | TSST | LTS 4 # if [1] == ; GOTO L4
SS 1 | TTT | SS  10 | TSST | LTS 5 # if [1] == \n GOTO L5
SS 1 | TTT | SS   9 | TSST | LTS 5 # if [1] == \t GOTO L5
SS 1 | TTT | SS  32 | TSST | LTS 5 # if [1] == ' ' GOTO L5
SS 1 | TTT | SS 125 | TSST | LTS 6 # if [1] == } GOTO L6
SS 1 | TTT | SS  34 | TSST | LTS 16 # if [1] == " GOTO L16
SS 1 | TTT | SS  40 | TSST | LTS 35 # if [1] == ( GOTO L35
SS 1 | TTT | SS  41 | TSST | LTS 36 # if [1] == ) GOTO L36

SS 2 | SS 1 | TTS # [2] := 1
LST 7 # call L7
SS 1 | TTT | TLSS # print [1]
LTL # return

LSS 4 # label L4 - ; handler
SS 1 | TTT | TLSS # print [1]
LTL # return

LSS 5 # label L5 - WS handler
LTL # return

LSS 6 # label L6 - } handler
# decrease identation by one
SS 3 | SS 3 | TTT | SS 1 | TSST | TTS # [3] := [3] - 1
SS 2 | SS 1 | TTS # [2] := 1
LST 7 # call L7
SS 1 | TTT | TLSS # print [1]
LTL # return

LSS 16 # label L16 - " handler
SS2 | SS 2 | TTS # [2] := 2
LST 7 # call L7
SS1 | TTT | TLSS # print [1]
LTL

LSS 35
SS 5 | SS 5 | TTT | SS 1 | TSSS | TTS # [5] := [5] + 1
SS 2 | SS 1 | TTS # [2] := 1
LST 7 # call L7
SS1 | TTT | TLSS # print [1]
LTL

LSS 36
SS 5 | SS 5 | TTT | SS 1 | TSST | TTS # [5] := [5] - 1
SS 2 | SS 1 | TTS # [2] := 1
LST 7 # call L7
SS1 | TTT | TLSS # print [1]
LTL

# -------------------
# sub: determine what to do in state 1
# -------------------
LSS 3 # LABEL L3
SS 1 | TTT | SS  10 | TSST | LTS 12 # if [1] == \n GOTO L12
SS 1 | TTT | SS 123 | TSST | LTS 13 # if [1] == { GOTO L13
SS 1 | TTT | SS 125 | TSST | LTS 14 # if [1] == } GOTO L14
SS 1 | TTT | SS  59 | TSST | LTS 15 # if [1] == ; GOTO L15
SS 1 | TTT | SS  34 | TSST | LTS 27 # if [1] == " GOTO L27
SS 1 | TTT | SS  42 | TSST | LTS 28 # if [1] == * GOTO L28
SS 1 | TTT | SS  47 | TSST | LTS 29 # if [1] == / GOTO L29
SS 1 | TTT | SS  40 | TSST | LTS 37 # if [1] == ( GOTO L37
SS 1 | TTT | SS  41 | TSST | LTS 38 # if [1] == ) GOTO L38
SS 1 | TTT | TLSS # print [1]
LTL # return

LSS 12 # LABEL L12 - \n handler
SS 2 | SS 0 | TTS # [2] := 0
LTL # return

LSS 13 # LABEL L13 - { handler
SS 1 | TTT | TLSS # print [1]
SS 2 | SS 0 | TTS # [2] := 0
SS 3 | SS 3 | TTT | SS 1 | TSSS | TTS # [3] := [3] + 1
LTL # return

LSS 14 # LABEL L14 - } handler
SS 3 | SS 3 | TTT | SS 1 | TSST | TTS # [3] := [3] - 1
LST 7 # call L7
SS 1 | TTT | TLSS # print [1]
SS 2 | SS 0 | TTS # [2] := 0
LTL # return

LSS 15 # LABEL L15 - ; handler
SS 1 | TTT | TLSS # print [1]
SS 5 | TTT | LTS 10 # if [5] == 0 GOTO L39
LTL

LSS 39
SS 2 | SS 0 | TTS # [2] := 0
LTL # return

LSS 27 # label L27 - " handler
SS1 | TTT | TLSS # print [1]
SS2 | SS 2 | TTS # [2] := 2
LTL

LSS 28 # label L28 - * handler - this might start a comment
SS 4 | TTT | SS  47 | TSST | LTS 30 # if [4] == / GOTO L30
SS1 | TTT | TLSS # print [1]
LTL

LSS 29 # label L29 - / handler - this might start a comment
SS 4 | TTT | SS  47 | TSST | LTS 31 # if [4] == / GOTO L31
SS1 | TTT | TLSS # print [1]
LTL

LSS 30 # label L30 - /* handler
SS1 | TTT | TLSS # print [1]
SS2 | SS 3 | TTS # [2] := 3
LTL

LSS 31 # label L31 - // handler
SS1 | TTT | TLSS # print [1]
SS2 | SS 4 | TTS # [2] := 4
LTL

LSS 37
SS 5 | SS 5 | TTT | SS 1 | TSSS | TTS # [5] := [5] + 1
SS1 | TTT | TLSS # print [1]
LTL

LSS 38
SS 5 | SS 5 | TTT | SS 1 | TSST | TTS # [5] := [5] - 1
SS1 | TTT | TLSS # print [1]
LTL

# -------------------
# sub: print identation
# -------------------
LSS 7 # label L7 - print identation
SS 10 | TLSS # print \n
SS 3 | TTT # push [3]
LSS 9 # label L9 - start loop
SLS | LTS 8 # if [3] == 0 GOTO L8
SLS | LTT 8 # if [3] < 0 GOTO L8 - for safety
SS 32 | TLSS # print ' '
SS 32 | TLSS # print ' '
SS 1  | TSST # i := i - 1
LSL 9 # GOTO L9
LSS 8 # label L8 - end loop
LTL #

# -------------------
# sub: L21 - string literal handler
# -------------------
LSS 21
SS 1 | TTT | SS  10 | TSST | LTS 24 # if [1] == \n GOTO L24
SS 1 | TTT | SS  34 | TSST | LTS 25 # if [1] == " GOTO L25
SS 1 | TTT | TLSS # print [1]
LTL

LSS 24 # \n handler - this should never happen, but let's be prepared and reset the parser
SS 2 | SS 0 | TTS # [2] := 0
LTL # return

LSS 25 # " handler - this might be escaped, so be prepared
SS 4 | TTT | SS  92 | TSST | LTS 26 # if [4] == \ GOTO L26
SS 2 | SS 1 | TTS # [2] := 1
SS 1 | TTT | TLSS # print [1]
LTL

LSS 26 # \\" handler - escaped quotes don't finish the literal
SS 1 | TTT | TLSS # print [1]
LTL

# -------------------
# sub: L22 - multiline comment handler
# -------------------
LSS 22
SS 1 | TTT | SS  47 | TSST | LTS 32 # if [1] == / GOTO L32
SS 1 | TTT | TLSS # print [1]
LTL

LSS 32
SS 4 | TTT | SS  42 | TSST | LTS 33 # if [4] == * GOTO L33
SS 1 | TTT | TLSS # print [1]
LTL

LSS 33
SS 1 | TTT | TLSS # print [1]
SS 2 | SS 1 | TTS # [2] := 1
LTL
# -------------------
# sub: L23 - singleline comment handler
# -------------------
LSS 23
SS 1 | TTT | SS  10 | TSST | LTS 34 # if [1] == \n GOTO L34
SS 1 | TTT | TLSS # print [1]
LTL

LSS 34
SS 2 | SS 0 | TTS # [2] := 0
LTL

# -------------------
# main loop
# -------------------
LSS 1 # LABEL L1
SS 4 | SS 1 | TTT | TTS # [4] := [1]
SS 1 | TLTS # [1] := read

SS 2 | TTT | LTS 10 # if [2] == 0 GOTO L10
SS 2 | TTT | SS 1 | TSST | LTS 17 # if [2] == 1 GOTO L17
SS 2 | TTT | SS 2 | TSST | LTS 18 # if [2] == 2 GOTO L18
SS 2 | TTT | SS 3 | TSST | LTS 19 # if [2] == 3 GOTO L19
SS 2 | TTT | SS 4 | TSST | LTS 20 # if [2] == 4 GOTO L20

LSS 17
LST 3  # call L3
LSL 11 # GOTO L11

LSS 10 # label L10
LST 2  # call L2
LSL 11

LSS 18
LST 21
LSL 11

LSS 19
LST 22
LSL 11

LSS 20
LST 23

LSS 11 # label L11
LSL 1  # goto L1
LLL # END

यह अभी भी प्रगति पर है, हालांकि उम्मीद है कि इसे अधिकांश मानदंडों को पारित करना चाहिए!

वर्तमान में समर्थित विशेषताएं:

• {और }वर्णों के आधार पर पहचान को ठीक करें ।
• के बाद एक नई पंक्ति जोड़ें ;
• स्ट्रिंग शाब्दिकों के अंदर इंडेंटेशन वर्णों को संभालना (इस तथ्य सहित कि स्ट्रिंग शाब्दिक को मुठभेड़ करते समय बंद नहीं किया जाता है \")
• एकल और बहुभाषी टिप्पणियों के अंदर इंडेंटेशन पात्रों को संभालें
• कोष्ठक के अंदर (एक forब्लॉक की तरह ) यदि नईलाइन वर्ण नहीं जोड़े जाते हैं

उदाहरण इनपुट (मैंने Quincunx की टिप्पणी के आधार पर कुछ किनारे मामले जोड़े हैं, ताकि आप जांच सकें कि यह ठीक से व्यवहार करता है)

    /* Hai Worldz. This code is to prevent formatting: if(this_code_is_touched){,then+your*program_"doesn't({work)}correctl"y.} */
#include<stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n\""); //Semicolon added in the {;} string just to annoy you
             /* Now we take the {;} input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
        s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
}}printf("Your \"name\" in upper case is:\n%s\n",s);
   return 0;}

उदाहरण आउटपुट:

[~/projects/indent]$ cat example.c | ./wspace indent.ws 2>/dev/null

/* Hai Worldz. This code is to prevent formatting: if(this_code_is_touched){,then+your*program_"doesn't({work)}correctl"y.} */
#include<stdio.h>
#include<string.h>
int main() {
  int i;;
  char s[99];;
  printf("----------------------\n;;What is your name?;;\n----------------------\n\"");; //Semicolon added in the {;} string just to annoy you
  /* Now we take the {;} input: */
  scanf("%s",s);;
  for(i=0;i<strlen(s);i++){
    if(s[i]>='a'&&s[i]<='z'){
      s[i]-=('a'-'A');; //this is same as s[i]=s[i]-'a'+'A'
    }
  }
  printf("Your \"name\" in upper case is:\n%s\n",s);;
  return 0;;
}

ध्यान दें, क्योंकि व्हॉट्सएप ईओएफ का समर्थन नहीं करता है क्योंकि इंट्रिप्टर की जांच एक अपवाद को फेंकती है, जिसे हमें दबाने की जरूरत है। चूंकि EOF के लिए जाँच करने के लिए व्हॉट्सएप में कोई रास्ता नहीं है (जहाँ तक मुझे पता है कि यह मेरा पहला व्हाट्सएप प्रोग्राम है) यह कुछ अपरिहार्य है, मुझे उम्मीद है कि समाधान अभी भी मायने रखता है।

यह वह स्क्रिप्ट है जिसका उपयोग मैंने एनोटेट संस्करण को उचित व्हाट्सएप में संकलित करने के लिए किया था:

#!/usr/bin/env ruby
ARGF.each_line do |line|
  data = line.gsub(/'.'/) { |match| match[1].ord }
  data = data.gsub(/[^-LST0-9#]/,'').split('#').first
  if data
    data.tr!('LST',"\n \t")
    data.gsub!(/[-0-9]+/){|m| "#{m.to_i<0?"\t":" "}#{m.to_i.abs.to_s(2).tr('01'," \t")}\n" }
    print data
  end
end

चलाने के लिए:

./wscompiler.rb annotated.ws > indent.ws

नोट यह है कि, के अलावा परिवर्तित करने से S, Lऔर Tवर्ण, के साथ भी एक लाइन टिप्पणियों की अनुमति #है, और स्वचालित रूप से उनके खाली स्थान के प्रतिनिधित्व में संख्या और सरल चरित्र शाब्दिक बदल सकते हैं। यदि आप चाहते हैं तो अन्य व्हाट्सएप परियोजनाओं के लिए इसका उपयोग करने के लिए स्वतंत्र महसूस करें

Comments

बुरा नहीं! :) लेकिन यह अच्छा होगा यदि यह लूप के लिए तीन लाइनों में विभाजित नहीं होता है (कम से कम मेरी राय में ... यह अभी भी मतदाताओं को तय करना है)। एक अनुस्मारक के रूप में, C में लूप के लिए वाक्यविन्यास हैfor(i=0;i<10;i++)

— user12205

@ace: चूंकि व्हॉट्सएप इस तरह के अपवाद को जोड़ने वाली उच्च स्तरीय भाषा नहीं है, इसलिए यह इतना आसान नहीं है। कहा कि मैं अभी भी टिप्पणियों और शाब्दिक के साथ दो मुद्दों को ठीक करने की कोशिश करता हूं, और साथ ही छोरों को ठीक करने का प्रबंधन करने की कोशिश करता हूं (मुझे लगता है कि ;अंदर (/ )ब्लॉकों को अनदेखा करना पर्याप्त होगा)। मुझे लगता है कि समाधान "प्रयोग करने योग्य" पर विचार करने के लिए पर्याप्त होना चाहिए।

— सेतुपति

@ace: मुझे लगता है कि मैं अपवादों को जोड़ने में कामयाब रहा, इसलिए अब उत्पन्न कोड ठीक से इंडेंट होने लगता है। उदाहरण को अपने एक में बदल दिया

— स्वस्तिक

Answer 2

आसान तरीका अपनाएं , तकनीकी रूप से केवल एक चरित्र का उपयोग करें:=

मैं एक विम गुरु नहीं हूं, लेकिन मैं कभी भी इसे कम नहीं आंकता हूं और कुछ इसे प्रोग्रामिंग लैंग्वेज मानते हैं। मेरे लिए यह समाधान वैसे भी एक विजेता है।

फ़ाइल को विम में खोलें:

vim file.c

विम के भीतर निम्नलिखित कुंजियाँ दबाएँ

gg=G

स्पष्टीकरण:

gg फ़ाइल के शीर्ष पर जाता है

= इंडेंटेशन को ठीक करने के लिए एक कमांड है

G यह फ़ाइल के अंत में ऑपरेशन करने के लिए कहता है।

आप बचा सकते हैं और साथ छोड़ सकते हैं :wq

vimकमांड-लाइन से कमांड को चलाने देना संभव है , इसलिए यह एक-लाइनर में भी किया जा सकता है, लेकिन मैं उन लोगों को छोड़ देता हूं जो vimमुझसे बेहतर जानते हैं।

---

खराब इंडेंट के साथ एक वैध इनपुट फ़ाइल (रिट्रेक्ट.के) का उदाहरण दें ।

/* Fibonacci Series c language */
#include<stdio.h>

int main()
{
int n, first = 0, second = 1, next, c;

            printf("Enter the number of terms\n");
scanf("%d",&n);
  printf("First %d terms of Fibonacci series are :-\n",n);

          for ( c = 0 ; c < n ; c++ )
   {
if ( c <= 1 )
         next = c;
 else
                                     {
next = first +    second;
              first = second;
        second = next;
      }
      printf("%d\n",next);
   }
 return 0;
}

Vim में खोलें: vim fibonacci.cदबाएँgg=G

/* Fibonacci Series c language */
#include<stdio.h>

int main()
{
  int n, first = 0, second = 1, next, c;

  printf("Enter the number of terms\n");
  scanf("%d",&n);
  printf("First %d terms of Fibonacci series are :-\n",n);

  for ( c = 0 ; c < n ; c++ )
  {
    if ( c <= 1 )
      next = c;
    else
    {
      next = first +    second;
      first = second;
      second = next;
    }
    printf("%d\n",next);
  }
  return 0;
}

Comments

स्रोत: stackoverflow.com/a/2355848/1919382

— चचेरा भाई

इसे छोटा किया जा सकता है =GZZ। (विम गोल्फ FTW!)

— दरवाज़े

Answer 3

चूंकि इसका उपयोग शिक्षक को छात्र के कोड को बेहतर ढंग से समझने में मदद करने के लिए किया जाएगा, इसलिए पहले इनपुट को सैनिटाइज करना महत्वपूर्ण है। पूर्व-प्रोसेसर निर्देश अनावश्यक हैं, क्योंकि वे केवल अव्यवस्था को घुसपैठ करते हैं, और मैक्रोज़ फ़ाइल में दुर्भावनापूर्ण कोड भी पेश कर सकते हैं। हम ऐसा नहीं चाहते हैं! इसके अलावा, छात्र द्वारा लिखी गई मूल टिप्पणियों को बनाए रखना पूरी तरह से अनावश्यक है, क्योंकि वे वैसे भी पूरी तरह से बेकार हैं।

इसके बजाय, जैसा कि सभी जानते हैं कि अच्छे कोड को इंडेंटेशन और संरचना को ठीक करने के अलावा, अच्छी टिप्पणियों की आवश्यकता होती है, परिणाम को और अधिक समझने के लिए कोड के मुख्य बिंदुओं के आसपास कुछ अत्यधिक उपयोगी टिप्पणियां क्यों नहीं जोड़नी चाहिए! यह निश्चित रूप से छात्र द्वारा किए गए काम का आकलन करने में शिक्षक की मदद करेगा!

तो इस से:

    /* Hai Worldz. This code is to prevent formatting: if(this_code_is_touched){,then+your*program_"doesn't({work)}correctl"y.} */
#include<stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n\""); //Semicolon added in the {;} string just to annoy you
             /* Now we take the {;} input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
        s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
}}printf("Your \"name\" in upper case is:\n%s\n",s);
   return 0;}

आइए इस का उत्पादन करें:

int main() {
    /* This will declare i. */
    int i;
    /* This will declare s[99]. */
    char s[99];
    /* This will call the function called printf with 1 parameters */
    printf("----------------------\n;;What is your name?;;\n----------------------\n\"");
    /* This will call the function called scanf with 2 parameters */
    scanf("%s", s);
    /* This will start a for loop, with initializator i = 0. It will loop until i < strlen(s), and will i++ at each iteration */
    for (i = 0; i < strlen(s); i++) {
        /* This will check, whether s[i] >= 'a' && s[i] <= 'z' is true or not. */
        if (s[i] >= 'a' && s[i] <= 'z') {
            s[i] -= 'a' - 'A';
        }
    }
    /* This will call the function called printf with 2 parameters */
    printf("Your \"name\" in upper case is:\n%s\n", s);
    /* This will return from the function. */
    return 0;
}

क्या यह बेहतर नहीं है, अभिव्यक्ति के चारों ओर उपयोगी टिप्पणियों के साथ?

---

तो यह मणि का उपयोग करने वाला एक रूबी समाधान है cast, जो एक सी पार्सर है _{(हां, मैं धोखा दे रहा हूं)} । चूंकि यह कोड को पार्स करेगा, और इसे खरोंच से फिर से प्रिंट करेगा इसका मतलब है कि परिणाम पूरी तरह से इंडेंट होगा और सुसंगत भी होगा, उदाहरण के लिए:

• ब्लॉक स्तर पर आधारित कोड में उचित इंडेंटेशन
• भाव, कथन, स्थिति आदि के बारे में लगातार व्हाट्सएप करना
• कोड की संरचना के आधार पर पूर्ण री-इंडेंटिंग
• आदि।

और यह भी कि कोड कैसे काम करता है, इसके बारे में अत्यधिक उपयोगी टिप्पणियां होंगी, जो छात्रों और शिक्षक दोनों के लिए उपयोगी होंगी!

indent.rb

#!/usr/bin/env ruby
require 'cast'

code = ''
ARGF.each_line do |line|
  if line=~/\A#/
    code << "// #{line.strip}\n"
  else
    code << line
  end
end

class Comment < C::Literal
  field :val
  initializer :val
  def to_s
    "/* #{val} */"
  end
end

tree = C.parse(code)
tree.preorder do |n|
  break if n.kind_of?(Comment)
  if n.kind_of?(C::Declaration)
    dd = []
    n.declarators.each do |d|
      dd << "declare #{d.indirect_type ? d.indirect_type.to_s(d.name) : d.name}"
      dd.last << " and set it to #{d.init}" if d.init
    end
    unless dd.empty?
      n.insert_prev(Comment.new("This will #{dd.join(", ")}."))
    end
  end rescue nil
  n.parent.insert_prev(Comment.new("This will call the function called #{n.expr} with #{n.args.length} parameters")) if n.kind_of?(C::Call) rescue nil
  n.insert_prev(Comment.new("This will start a for loop, with initializator #{n.init}. It will loop until #{n.cond}, and will #{n.iter} at each iteration")) if n.kind_of?(C::For) rescue nil
  n.insert_prev(Comment.new("This will check, whether #{n.cond} is true or not.")) if n.kind_of?(C::If) rescue nil
  n.insert_prev(Comment.new("This will return from the function.")) if n.kind_of?(C::Return) rescue nil
end

puts tree

Gemfile

source "http://rubygems.org"
gem 'cast', '0.2.1'

Comments

+1 के लिएit is completely unnecessary to retain the original comments the student wrote, as they are probably completely useless anyway

— सीनोप्सिस

वे टिप्पणियाँ मेरे लिए अवांछनीय हैं। वे अव्यवस्था का परिचय देते हैं क्योंकि वे केवल निम्नलिखित पंक्ति को आराम देते हैं।

— जस्टिन

@Quincunx मुझे लगता है कि आप व्यंग्य टैग से चूक गए। यह एक लोकप्रियता प्रतियोगिता है।

— सिटपुटी

Answer 4

बैश, 35 वर्ण

इनपुट फ़ाइल को "input.c" नाम दिया जाना चाहिए और वर्तमान कार्यशील निर्देशिका में रखा जाना चाहिए।

sh <(wget -q -O- http://x.co/3snpk)

उदाहरण आउटपुट, मूल प्रश्न में इनपुट दिया गया है:

आपके हार्डवेयर के आधार पर इसे चलाने में कुछ सेकंड लग सकते हैं, इसलिए धैर्य रखें :)

Comments

आप जानते हैं कि यह कोड-गोल्फ नहीं है, है ना?

— जस्टिन

फ्लाइट पर AStyle को डाउनलोड करने और संकलित करने के लिए +1 क्या आप केवल उपयोगकर्ता की सुविधा के लिए AStyle को नहीं छोड़ेंगे? तो निकालें rm?

— tomsmeding

चूंकि यह कोड-गोल्फ नहीं है, इसलिए मुझे लगता है कि बेहतर होगा कि आप अपने पास्टबिन की सामग्री यहां डाल दें, क्योंकि एक त्वरित रूप से मैंने यह भी नहीं देखा कि आप वास्तव में बाहरी कमांड के साथ कोड को ठीक से प्रारूपित कर रहे हैं

— SztupY

@Quincunx: इसका मतलब थोड़ा सा ट्रोल जवाब है: P

— Riot

@tomsmeding: मैं अपने कोड को साइड इफेक्ट्स नहीं देना चाहूंगा, जैसे कि उपयोगकर्ता के डिस्क स्थान को अप्रत्याशित रूप से ऊपर ले जाना ...

— Riot

Answer 5

माणिक

code = DATA.read

# first, we need to replace strings and comments with tilde escapes to avoid parsing them
code.gsub! '~', '~T'
lineComments = []
code.gsub!(/\/\/.*$/) { lineComments.push $&; '~L' }
multilineComments = []
code.gsub!(/\/\*.*?\*\//m) { multilineComments.push $&; '~M' }
strs = []
code.gsub!(/"(\\.|[^"])*"|'.'/) { strs.push $&; '~S' } # character literals are considered strings

# also, chop out preprocessor stuffs
preprocessor = ''
code.gsub!(/(^#.*\n)+/) { preprocessor = $&; '' }

# clean up newlines and excess whitespace
code.gsub! "\n", ' '
code.gsub! /\s+/, ' '
code.gsub!(/[;{}]/) { "#{$&}\n" }
code.gsub!(/[}]/) { "\n#{$&}" }
code.gsub! /^\s*/, ''
code.gsub! /\s+$/, ''

# fix for loops (with semicolons)
code.gsub!(/^for.*\n.*\n.*/) { $&.gsub ";\n", '; ' }

# now it's time for indenting; add indent according to {}
indentedCode = ''
code.each_line { |l|
    indentedCode += ('    ' * [indentedCode.count('{') - indentedCode.count('}') - (l =~ /^\}/ ? 1 : 0), 0].max) + l
}
code = indentedCode

# finally we're adding whitespace for more readability. first get a list of all operators
opsWithEq = '= + - * / % ! > < & | ^ >> <<'
opsNoEq = '++ -- && ||'
ops = opsWithEq.split + opsWithEq.split.map{|o| o + '=' } + opsNoEq.split
ops = ops.sort_by(&:length).reverse
# now whitespace-ize them
code.gsub!(/(.)(#{ops.map{|o| Regexp.escape o }.join '|'})(.)/m) { "#{$1 == ' ' ? ' ' : ($1 + ' ')}#{$2}#{$3 == ' ' ? ' ' : (' ' + $3)}" }

# special-cases: only add whitespace to the right
ops = ','.split
code.gsub!(/(#{ops.map{|o| Regexp.escape o }.join '|'})(.)/m) { "#{$1}#{$2 == ' ' ? ' ' : (' ' + $2)}" }
# special-cases: only add whitespace to the left
ops = '{'.split
code.gsub!(/(.)(#{ops.map{|o| Regexp.escape o }.join '|'})/m) { "#{$1 == ' ' ? ' ' : ($1 + ' ')}#{$2}" }

# replace the tilde escapes and preprocessor stuffs
stri = lci = mci = -1
code.gsub!(/~(.)/) {
    case $1
    when 'T'
        '~'
    when 'S'
        strs[stri += 1]
    when 'L'
        lineComments[lci += 1] + "\n#{code[0, $~.begin(0)].split("\n").last}"
    when 'M'
        multilineComments[mci += 1]
    end
}
code = (preprocessor + "\n" + code).gsub /^ +\n/, ''

puts code
__END__
    /* Hai Worldz. This code is to prevent formatting: if(this_code_is_touched){,then+your*program_"doesn't({work)}correctl"y.} */
#include<stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n\""); //Semicolon added in the {;} string just to annoy you
             /* Now we take the {;} input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
        s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
}}printf("Your \"name\" in upper case is:\n%s\n",s);
   return 0;}

आउटपुट:

#include <stdio.h>
#include<string.h>

int main() {
    int i;
    char s[99];
    printf("----------------------\n;;What is your name?;;\n----------------------\n");
    //Semicolon added in the string just to annoy you
     /* Now we take the input: */ scanf("%s", s);
    for(i = 0; i < strlen(s); i ++ ) {
        if(s[i] >= 'a' && s[i] <= 'z') {
            s[i] -= ('a' - 'A');
            //this is same as s[i]=s[i]-'a'+'A'
        }
    }
    printf("Your name in upper case is:\n%s\n", s);
    return 0;
}

@ SztupY के एज केस इनपुट के लिए आउटपुट :

#include<stdio.h>
#include<string.h>

/* Hai Worldz. This code is to prevent formatting: if(this_code_is_touched){,then+your*program_"doesn't({work)}correctl"y.} */ int main() {
    int i;
    char s[99];
    printf("----------------------\n;;What is your name?;;\n----------------------\n\"");
    //Semicolon added in the {;} string just to annoy you
     /* Now we take the {;} input: */ scanf("%s", s);
    for(i = 0; i < strlen(s); i ++ ) {
        if(s[i] >= 'a' && s[i] <= 'z') {
            s[i] -= ('a' - 'A');
            //this is same as s[i]=s[i]-'a'+'A'
        }
    }
    printf("Your \"name\" in upper case is:\n%s\n", s);
    return 0;
}

अब तक की विशेषताएं:

• [x] प्रत्येक पंक्ति के सामने उचित इंडेंटेशन जोड़ें
• [x]के बाद रिक्त स्थान ,और अन्य ऑपरेटरों, जैसे परिवर्तित int a[]={1,2,3};करने के लिए जोड़ें int a[] = {1, 2, 3};। याद रखें कि हालांकि स्ट्रिंग शाब्दिक के भीतर ऑपरेटरों को संसाधित नहीं करना है।
• [x] प्रत्येक पंक्ति के बाद अनुगामी रिक्त स्थान निकालें
• [x]बयानों को कई लाइनों में अलग करना, जैसे कि छात्र एक पंक्ति में tmp=a;a=b;b=tmp;या int f(int n){if(n==1||n==2)return 1;else return f(n-1)+f(n-2);}सभी लिख सकते हैं, आप उन्हें अलग-अलग लाइनों में अलग कर सकते हैं। forहालांकि छोरों से अवगत रहें , उनमें अर्धविराम हैं, लेकिन मुझे नहीं लगता कि आपको उन्हें विभाजित करना चाहिए।
• [ ] प्रत्येक फ़ंक्शन को परिभाषित करने के बाद एक नई लाइन जोड़ें
• [ ] एक और अन्य विशेषताएं आप अपने छात्रों के कोड को समझने में मदद के साथ आ सकते हैं।

Answer 6

यह अजगर में लिखा गया है और GNU कोडिंग मानकों पर आधारित है।

अब तक की विशेषताएं:

• इंडेंटिंग ब्लॉक
• विभाजन लाइनें (उन चीजों को विभाजित कर सकती हैं जो नहीं होनी चाहिए)
• GNU- शैली फ़ंक्शन परिभाषाएँ

कोड:

import sys

file_in = sys.argv[1]

# Functions, for, if, while, and switch statements
def func_def(string):
    ret = ["", "", ""]
    func_name = ""
    paren_level = -1
    consume_id = False

    for x in string[::-1]:
        if x == "{":
            ret[2] = "{"
        elif ret[1] == "":
            if x == "(":
                paren_level -= 1
                func_name += x
            elif x == ")":
                paren_level += 1
                func_name += x
            elif paren_level == -1 and x.isspace():
                if consume_id:
                    ret[1] = func_name[::-1]
            elif paren_level == -1:
                consume_id = True
                func_name += x
            else:
                func_name += x
        else:
            # Return Type
            ret[0] += x
    else:
        ret[1] = func_name[::-1]

    ret[0] = ret[0][::-1]

    # Handle the case in which this is just a statement
    if ret[1].split("(")[0].strip() in ["for", "if", "while", "switch"]:
        ret = [ret[1], ret[2]] # Don't print an extra line

    return ret

with open(file_in) as file_obj_in:
    line_len = 0
    buffer = ""
    in_str = False
    no_newline = False
    indent_level = 0
    tab = " " * 4
    no_tab = False
    brace_stack = [-1]

    while True:
        buffer += file_obj_in.read(1)
        if buffer == "":
            break
        elif "\n" in buffer:
            if not no_newline:
                print(("" if no_tab else indent_level * tab) + buffer, end="")
                buffer = ""
                line_len = indent_level * 4
                no_tab = False
                continue
            else:
                buffer = ""
                line_len = indent_level * 4
                no_newline = False
                continue
        elif buffer[-1] == '"':
            in_str = not in_str
        elif buffer.isspace():
            buffer = ""
            continue

        if "){" in "".join(buffer.split()) and not in_str:
            for x in func_def(buffer):
                print(indent_level * tab + x)
            buffer = ""
            line_len = indent_level * 4
            no_newline = True
            indent_level += 1
            brace_stack[0] += 1
            brace_stack.append((brace_stack[0], True))
            continue
        elif buffer[-1] == "}" and not in_str:
            brace_stack[0] -= 1
            if brace_stack[-1][1]: # If we must print newline and indent
                if not buffer == "}":
                    print(indent_level * tab + buffer[:-1].rstrip("\n"))
                indent_level -= 1
                print(indent_level * tab + "}")
                buffer = ""
                line_len = indent_level * 4
            else:
                pass
            brace_stack.pop()
        line_len += 1

        if line_len == 79 and not in_str:
            print(indent_level * tab + buffer)
            buffer = ""
            line_len = indent_level * 4
            continue
        elif line_len == 78 and in_str:
            print(indent_level * tab + buffer + "\\")
            buffer = ""
            line_len = indent_level * 4
            no_tab = True
            continue

उदाहरण इनपुट (तर्क के रूप में फ़ाइल नाम दें):

#include <stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n"); //Semicolon added in the string just to annoy you
             /* Now we take the input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
        s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
}}printf("Your name in upper case is:\n%s\n",s);
   return 0;}

उदाहरण आउटपुट:

#include <stdio.h>
#include<string.h>
int
main()
{
    int i;
    char s[99];
    printf("----------------------\n;;What is your name?;;\n------------------\
----\n"); //Semicolon added in the string just to annoy you
    /* Now we take the input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++)
    {
        if(s[i]>='a'&&s[i]<='z')
        {
            s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
        }
    }
    printf("Your name in upper case is:\n%s\n",s);
    return 0;
}

यह होगा कीड़े की है।

Answer 7

नेट

Visual Studio का उपयोग करके उस फ़ाइल को खोलें

इनपुट:

#include<stdio.h>
#include<string.h>
int main() {
int i;
char s[99];
     printf("----------------------\n;;What is your name?;;\n----------------------\n\""); //Semicolon added in the {;} string just to annoy you
             /* Now we take the {;} input: */
    scanf("%s",s);
    for(i=0;i<strlen(s);i++){if(s[i]>='a'&&s[i]<='z'){
            s[i]-=('a'-'A'); //this is same as s[i]=s[i]-'a'+'A'
    }
}printf("Your \"name\" in upper case is:\n%s\n",s);
       return 0;}

आउटपुट:

Comments

यह एक अच्छा विचार है, लेकिन चुनौती एक प्रोग्रामिंग प्रतियोगिता है। क्या आप एक प्रोग्राम लिख सकते हैं जो इस फाइल को विजुअल स्टूडियो के साथ खोलता है, फिर इसे सुंदर प्रिंट में सहेजता है?

— जस्टिन