গল্ফ আমার "প্রাক-গল্ফড" সি


12

পটভূমি

সি আমার জমা দেওয়ার জন্য, আমার একটি প্রসেসিং সরঞ্জাম প্রয়োজন। অন্যান্য অনেক ভাষার মতো, সাদা উত্স বেশিরভাগ সি উত্সে অপ্রাসঙ্গিক (তবে সর্বদা নয়!) এখনও মানুষের পক্ষে কোডটিকে অনেক বেশি বোধগম্য করে তোলে। একটি সম্পূর্ণ গল্ফড সি প্রোগ্রাম যা একটিমাত্র রিন্ডান্ট হোয়াইটস্পেস ধারণ করে না খুব সহজেই পঠনযোগ্য।

সুতরাং, আমি হোয়াইটস্পেস এবং কখনও কখনও মন্তব্য সহ জমা দেওয়ার জন্য সি-তে আমার কোড লিখতে চাই , সুতরাং প্রোগ্রামটি লেখার সময় একটি বোধগম্য কাঠামো রাখে। সর্বশেষ পদক্ষেপটি হ'ল সমস্ত মন্তব্য এবং অপ্রয়োজনীয় সাদা স্থান সরিয়ে ফেলা। এটি একটি ক্লান্তিকর এবং নির্বোধ কাজ যা সত্যই কোনও ইন্টার্নের দ্বারা কম্পিউটার প্রোগ্রাম করা উচিত।

কার্য

একটি প্রোগ্রাম বা ফাংশন লিখুন যা নিম্নলিখিত বিধি অনুসারে কিছু "প্রাক-গল্ফড" সি উত্স থেকে মন্তব্য এবং রিডান্ট্যান্ট হোয়াইটস্পেসকে সরিয়ে দেয়:

  • একটি \(ব্যাকস্ল্যাশ) একটি লাইনের একেবারে শেষ চরিত্র হিসাবে লাইন ধারাবাহিকতা । যদি আপনি এটি খুঁজে পান তবে আপনাকে অবশ্যই নিম্নলিখিত লাইনটিকে একই লজিকাল লাইনের অংশ হিসাবে গণ্য করতে হবে (উদাহরণস্বরূপ আপনি অন্য কিছু করার আগে \নিম্নলিখিতটি এবং নিম্নলিখিতটি \n(নিউলাইন) সম্পূর্ণভাবে মুছে ফেলতে পারেন )
  • মন্তব্যগুলি কেবল এক-লাইন ফর্ম্যাটটি ব্যবহার করে শুরু করবে //। সুতরাং এগুলি সরাতে আপনি বাকী লজিকাল রেখাটিকে এড়িয়ে যান যেখানেই আপনি স্ট্রিং আক্ষরিকের// বাইরে পড়েন (নীচে দেখুন)।
  • হোয়াইটস্পেসের অক্ষরগুলি হ'ল (স্পেস), \t(ট্যাব) এবং \n(নতুন লাইন, সুতরাং এখানে একটি লজিকাল লাইনের শেষ)।
  • যখন আপনি শ্বেত স্পেসের সিকোয়েন্সটি খুঁজে পান, তখন চারপাশে থাকা অ-সাদা অংশের অক্ষরগুলি পরীক্ষা করুন। যদি

    • উভয়ই আলফানিউমেরিক বা আন্ডারস্কোর (রেঞ্জ [a-zA-Z0-9_]) বা are
    • উভয় হয় +বা
    • উভয় হয় -বা
    • পূর্ববর্তীটি হ'ল /এবং নিম্নলিখিতটি হ'ল*

    তারপরে একটি একক স্থান ( ) অক্ষরের সাথে ক্রমটি প্রতিস্থাপন করুন ।

    অন্যথায়, ক্রমটি পুরোপুরি বাদ দিন।

    এই নিয়মের কিছু ব্যতিক্রম রয়েছে :

    • প্রিপ্রসেসর নির্দেশিকা অবশ্যই আপনার আউটপুটে তাদের নিজস্ব লাইনে উপস্থিত হবে। একটি প্রিপ্রসেসর নির্দেশিকা হ'ল একটি লাইন #
    • একটি স্ট্রিং আক্ষরিক বা চরিত্রের আক্ষরিক ভিতরে , আপনার কোনও সাদা স্থান অপসারণ করা উচিত নয়। যে কোনও "(ডাবল-কোট) / '(একক উদ্ধৃতি) যা সরাসরি বিজোড় সংখ্যার ব্যাকস্ল্যাশ ( \) দ্বারা শুরু হয় না যা স্ট্রিং আক্ষরিক / অক্ষর আক্ষরিক শুরু হয় বা শেষ হয় । আপনি গ্যারান্টিযুক্ত যে স্ট্রিং এবং চরিত্রের অক্ষরগুলি একই লাইনে শুরু হয়েছিল তারা শুরু করেছিল। স্ট্রিং আক্ষরিক এবং চরিত্রের অক্ষরগুলি বাসা বাঁধতে পারে না, সুতরাং 'একটি স্ট্রিং আক্ষরিক" অভ্যন্তরের অভ্যন্তরের পাশাপাশি একটি অক্ষরের আক্ষরিক ভিতরে কোনও বিশেষ অর্থ থাকে না।

আই / ও স্পেসিফিকেশন

ইনপুট এবং আউটপুট অবশ্যই নিউলাইন বর্ণগুলি বা অ্যারে / স্ট্রিংগুলির তালিকাসমূহের সাথে অক্ষরের ক্রমগুলি (স্ট্রিংগুলি) হওয়া উচিত যা নিউলাইন অক্ষর ধারণ করে না। আপনি ব্যবহার অ্যারে / করণীয় তালিকা চয়ন করেন তাহলে, প্রতিটি উপাদান তাই নতুন লাইন, একটি লাইন প্রতিনিধিত্ব করে অন্তর্নিহিত প্রতিটি উপাদান পরে।

আপনি ধরে নিতে পারেন ইনপুটটি একটি বৈধ সি প্রোগ্রামের উত্স কোড is এর অর্থ এটিতে কেবল মুদ্রণযোগ্য এএসসিআইআই অক্ষর, ট্যাব এবং নিউলাইন রয়েছে। বিকৃত ইনপুটটিতে অপরিজ্ঞাত আচরণের অনুমতি রয়েছে।

সামনের এবং পিছনের হোয়াইটস্পেস / খালি লাইন হয় মঞ্জুরিপ্রাপ্ত নয়

পরীক্ষার মামলা

  1. ইনপুট

    main() {
        printf("Hello, World!"); // hi
    }
    

    আউটপুট

    main(){printf("Hello, World!");}
    
  2. ইনপুট

    #define max(x, y) \
        x > y ? x : y
    #define I(x) scanf("%d", &x)
    a;
    b; // just a needless comment, \
            because we can!
    main()
    {
        I(a);
        I(b);
        printf("\" max \": %d\n", max(a, b));
    }
    

    আউটপুট

    #define max(x,y)x>y?x:y
    #define I(x)scanf("%d",&x)
    a;b;main(){I(a);I(b);printf("\" max \": %d\n",max(a,b));}
    
  3. ইনপুট

    x[10];*c;i;
    main()
    {
        int _e;
        for(; scanf("%d", &x) > 0 && ++_e;);
        for(c = x + _e; c --> x; i = 100 / *x, printf("%d ", i - --_e));
    }
    

    আউটপুট

    x[10];*c;i;main(){int _e;for(;scanf("%d",&x)>0&&++_e;);for(c=x+_e;c-->x;i=100/ *x,printf("%d ",i- --_e));}
    
  4. ইনপুট

    x;
    #include <stdio.h>
    int main()
    {
        puts("hello // there");
    }
    

    আউটপুট

    x;
    #include<stdio.h>
    int main(){puts("hello // there");}
    
  5. ইনপুট (একটি বাস্তব বিশ্বের উদাহরণ)

    // often used functions/keywords:
    #define P printf(
    #define A case
    #define B break
    
    // loops for copying rows upwards/downwards are similar -> macro
    #define L(i, e, t, f, s) \
            for (o=i; o e;){ strcpy(l[o t], l[o f]); c[o t]=c[s o]; }
    
    // range check for rows/columns is similar -> macro
    #define R(m,o) { return b<1|b>m ? m o : b; }
    
    // checking for numerical input is needed twice (move and print command):
    #define N(f) sscanf(f, "%d,%d", &i, &j) || sscanf(f, ",%d", &j)
    
    // room for 999 rows with each 999 cols (not specified, should be enough)
    // also declare "current line pointers" (*L for data, *C for line length),
    // an input buffer (a) and scratch variables
    r, i, j, o, z, c[999], *C, x=1, y=1;
    char a[999], l[999][999], (*L)[999];
    
    // move rows down from current cursor position
    D()
    {
        L(r, >y, , -1, --)
        r++ ? strcpy(l[o], l[o-1]+--x), c[o-1]=x, l[o-1][x]=0 : 0;
        c[y++] = strlen(l[o]);
        x=1;
    }
    
    // move rows up, appending uppermost to current line
    U()
    {
        strcat(*L, l[y]);
        *C = strlen(*L);
        L(y+1, <r, -1, , ++)
        --r;
        *l[r] = c[r] = 0;
    }
    
    // normalize positions, treat 0 as max
    X(b) R(c[y-1], +1)
    Y(b) R(r, )
    
    main()
    {
        for(;;) // forever
        {
            // initialize z as current line index, the current line pointers,
            // i and j for default values of positioning
            z = i = y;
            L = l + --z;
            C = c + z;
            j = x;
    
            // prompt:
            !r || y/r && x > *C
                ? P "end> ")
                : P "%d,%d> ", y, x);
    
            // read a line of input (using scanf so we don't need an include)
            scanf("%[^\n]%*c", a)
    
                // no command arguments -> make check easier:
                ? a[2] *= !!a[1],
    
                // numerical input -> have move command:
                // calculate new coordinates, checking for "relative"
                N(a)
                    ? y = Y(i + (i<0 | *a=='+') * y)
                        , x = X(j + (j<0 || strchr(a+1, '+')) * x)
                    :0
    
                // check for empty input, read single newline
                // and perform <return> command:
                : ( *a = D(), scanf("%*c") );
    
            switch(*a)
            {
                A 'e':
                    y = r;
                    x = c[r-1] + 1;
                    B;
    
                A 'b':
                    y = 1;
                    x = 1;
                    B;
    
                A 'L':
                    for(o = y-4; ++o < y+2;)
                        o<0 ^ o<r && P "%c%s\n", o^z ? ' ' : '>', l[o]);
                    for(o = x+1; --o;)
                        P " ");
                    P "^\n");
                    B;
    
                A 'l':
                    puts(*L);
                    B;
    
                A 'p':
                    i = 1;
                    j = 0;
                    N(a+2);
                    for(o = Y(i)-1; o<Y(j); ++o)
                        puts(l[o]);
                    B;
    
                A 'A':
                    y = r++;
                    strcpy(l[y], a+2);
                    x = c[y] = strlen(a+2);
                    ++x;
                    ++y;
                    B;
    
                A 'i':
                    D();
                    --y;
                    x=X(0);
                    // Commands i and r are very similar -> fall through
                    // from i to r after moving rows down and setting
                    // position at end of line:
    
                A 'r':
                    strcpy(*L+x-1, a+2);
                    *C = strlen(*L);
                    x = 1;
                    ++y > r && ++r;
                    B;
    
                A 'I':
                    o = strlen(a+2);
                    memmove(*L+x+o-1, *L+x-1, *C-x+1);
                    *C += o;
                    memcpy(*L+x-1, a+2, o);
                    x += o;
                    B;
    
                A 'd':
                    **L ? **L = *C = 0, x = 1 : U();
                    y = y>r ? r : y;
                    B;
    
                A 'j':
                    y<r && U();
            }
        }
    }
    

    আউটপুট

    #define P printf(
    #define A case
    #define B break
    #define L(i,e,t,f,s)for(o=i;o e;){strcpy(l[o t],l[o f]);c[o t]=c[s o];}
    #define R(m,o){return b<1|b>m?m o:b;}
    #define N(f)sscanf(f,"%d,%d",&i,&j)||sscanf(f,",%d",&j)
    r,i,j,o,z,c[999],*C,x=1,y=1;char a[999],l[999][999],(*L)[999];D(){L(r,>y,,-1,--)r++?strcpy(l[o],l[o-1]+--x),c[o-1]=x,l[o-1][x]=0:0;c[y++]=strlen(l[o]);x=1;}U(){strcat(*L,l[y]);*C=strlen(*L);L(y+1,<r,-1,,++)--r;*l[r]=c[r]=0;}X(b)R(c[y-1],+1)Y(b)R(r,)main(){for(;;){z=i=y;L=l+--z;C=c+z;j=x;!r||y/r&&x>*C?P"end> "):P"%d,%d> ",y,x);scanf("%[^\n]%*c",a)?a[2]*=!!a[1],N(a)?y=Y(i+(i<0|*a=='+')*y),x=X(j+(j<0||strchr(a+1,'+'))*x):0:(*a=D(),scanf("%*c"));switch(*a){A'e':y=r;x=c[r-1]+1;B;A'b':y=1;x=1;B;A'L':for(o=y-4;++o<y+2;)o<0^o<r&&P"%c%s\n",o^z?' ':'>',l[o]);for(o=x+1;--o;)P" ");P"^\n");B;A'l':puts(*L);B;A'p':i=1;j=0;N(a+2);for(o=Y(i)-1;o<Y(j);++o)puts(l[o]);B;A'A':y=r++;strcpy(l[y],a+2);x=c[y]=strlen(a+2);++x;++y;B;A'i':D();--y;x=X(0);A'r':strcpy(*L+x-1,a+2);*C=strlen(*L);x=1;++y>r&&++r;B;A'I':o=strlen(a+2);memmove(*L+x+o-1,*L+x-1,*C-x+1);*C+=o;memcpy(*L+x-1,a+2,o);x+=o;B;A'd':**L?**L=*C=0,x=1:U();y=y>r?r:y;B;A'j':y<r&&U();}}}
    

এটি , তাই সংক্ষিপ্ততম (বাইটে) বৈধ উত্তর জেতে।



উত্তর:


4

পিপ , 148 135 133 138 বাইট

aRM"\
"R`("|').*?(?<!\\)(\\\\)*\1`{lPBaC:++i+191}R[`//.*``#.*`{X*aJw.`(?=`}.')M[A`\w`RL2"++""--""/*"]w`¶+`'·C(192+,#l)][x_WR'¶{aRw'·}xnsl]

বাইটগুলি সিপি -1222 এ গণনা করা হয় , তাই এবং ·প্রতিটি বাইট হয়। নোট করুন যে এটি সি কোডটি একটি একক কমান্ড-লাইন আর্গুমেন্ট হিসাবে প্রত্যাশা করে, যার (প্রকৃত কমান্ড লাইনে) প্রচুর পরিমাণে অব্যাহতি ক্রমের ব্যবহার প্রয়োজন। এটি অনলাইনে চেষ্টা করে দেখুন এটি অনেক সহজ !

কিছুটা অবারিত সংস্করণটির ব্যাখ্যা

কোডটি কয়েকটি কৌশল দ্বারা প্রতিস্থাপন অপারেশনগুলির একটি গোছা করে।

ব্যাকস্ল্যাশ ধারাবাহিকতা

আমরা RMসমস্ত আক্ষরিক স্ট্রিং এর ঘটনা

"\
"

অর্থাৎ ব্যাকস্ল্যাশ এর পরে নিউলাইন।

স্ট্রিং এবং চরিত্রের আক্ষরিক

আমরা একটি কলব্যাক ফাংশন সহ একটি রেজেক্স প্রতিস্থাপন ব্যবহার করি:

`("|').*?(?<!\\)(\\\\)*\1`

{
 lPBa
 C(++i + 191)
}

রেজেক্স একক বা ডাবল উদ্ধৃতিটির সাথে মেলে, তার পরে একটি অ লোভী থাকে .*?যা সম্ভব কম কম 0 বা তার বেশি অক্ষরের সাথে মেলে। পূর্ববর্তী অক্ষরটি ব্যাকস্ল্যাশ নয় তা নিশ্চিত করার জন্য আমাদের নেতিবাচক চেহারা রয়েছে; তারপরে আমরা আবারও উদ্বোধনী ডিলিমিটারের পরে একটি সংখ্যক ব্যাকস্ল্যাশগুলির সাথে মিলিত।

কলব্যাক ফাংশনটি স্ট্রিং / চরিত্রটিকে আক্ষরিক করে তালিকার পিছনে ফেলে দেয় l। এটির পরে অক্ষর কোড 192 ( À) দিয়ে শুরু হওয়া এবং প্রতিস্থাপিত প্রতিটি আক্ষরিকের সাথে বাড়িয়ে একটি অক্ষর দেয় । সুতরাং, কোড এর মত রূপান্তরিত হয়:

printf("%c", '\'');

printf(À, Á);

এই প্রতিস্থাপনের অক্ষরগুলি উত্স কোডে না হওয়ার গ্যারান্টিযুক্ত, যার অর্থ আমরা পরে এগুলিকে নির্বিঘ্নে পিছনে স্থান দিতে পারি।

মন্তব্য

`//.*`

x

রেজেক্স //নতুন লাইন পর্যন্ত সমস্ত কিছু মেলে এবং এর সাথে প্রতিস্থাপন করে x(খালি স্ট্রিংয়ের প্রিসেট)।

প্রাক প্রসেসরের নির্দেশাবলী

`#.*`

_WR'¶

পাউন্ড সাইন ইন দিয়ে শুরু হওয়া অ-নিউলাইন অক্ষরগুলির মোড়ানো র্যাপগুলি

যে স্পেসগুলি বাদ দেওয়া উচিত নয়

{
 (
  X*a J w.`(?=`
 ) . ')
}
M
[
 A`\w` RL 2
 "++"
 "--"
 "/*"
]

{
 a R w '·
}

এখানে অনেক কিছু চলছে। প্রথম অংশটি প্রতিস্থাপনের জন্য রেজিজেসের এই তালিকা তৈরি করে:

[
 `(?a)\w\s+(?=(?a)\w)`  Whitespace surrounded by [a-zA-Z_]
 `\+\s+(?=\+)`          Whitespace surrounded by +
 `\-\s+(?=\-)`          Whitespace surrounded by -
 `\/\s+(?=\*)`          Whitespace surrounded by / *
]

উল্লেখ্য lookaheads ব্যবহার উদাহরণস্বরূপ, মেলে, শুধু e define P printf। এই ম্যাচটি এইভাবে ব্যবহার করে না P, যার অর্থ পরবর্তী ম্যাচটি এটি ব্যবহার করতে পারে।

আমরা তালিকায় থাকা একটি ফাংশনকে ম্যাপিং করে এই রেজিজেসের তালিকা তৈরি করি

[
 [`(?a)\w` `(?a)\w`]
 "++"
 "--"
 "/*"
]

এবং ফাংশন প্রতিটি উপাদানকে এটি করে:

(X*aJw.`(?=`).')
 X*a              Map unary X to elements/chars a: converts to regex, escaping as needed
                  Regexes like `\w` stay unchanged; strings like "+" become `\+`
    J             Join the resulting list on:
     w             Preset variable for `\s+`
      .`(?=`       plus the beginning of the lookahead syntax
(           ).')  Concatenate the closing paren of the lookahead

আমাদের পুনঃসূত্রগুলি একবার হলে, আমরা তাদের উপস্থিতিগুলি এই কলব্যাক ফাংশনটির সাথে প্রতিস্থাপন করব:

{aRw'·}

যা প্রতিটি ম্যাচে হোয়াইটস্পেসের রানকে প্রতিস্থাপন করে ·

হোয়াইটস্পেস নির্মূল এবং পরিষ্কার

[w `¶+` '·]

[x n s]

তিনটি পরপর প্রতিস্থাপন wখালি স্ট্রিং ( x) এর জন্য হোয়াইটস্পেসের বাকি রানগুলি ), নতুন লাইনের জন্য রান এবং ·স্পেসের পরিবর্তে।

স্ট্রিং এবং অক্ষর আক্ষরিক পিছনে প্রতিস্থাপন

C(192+,#l)

l

আমরা অক্ষরগুলি গ্রহণ করে 192 + range(len(l))এবং রূপান্তর করে অক্ষরগুলির বিকল্প হিসাবে হিসাবে ব্যবহার করা সমস্ত অক্ষরের একটি তালিকা তৈরি করি । এরপরে আমরা এর প্রতিটিটিকে এর সাথে সম্পর্কিত আক্ষরিক সাথে প্রতিস্থাপন করতে পারি l

এবং এটাই! ফলস্বরূপ স্ট্রিংটি স্বয়ংক্রিয়ভাবে মুদ্রিত হয়।


দুর্দান্ত, আমি মুগ্ধ (+1)! একটি সহ //একটি স্ট্রিং আক্ষরিক ভিতরে স্পষ্টভাবে একটি পরীক্ষা ক্ষেত্রে জন্য একটি ভাল ধারণা, আমি এক আগামীকাল যুক্ত করতে হবে।
ফেলিক্স প্যালম্যান

আহ ... এখন আমি এখানে একটি সূক্ষ্ম
বাগও পেয়েছি

আমি 14 দিন পরে (পরবর্তী সপ্তাহের শেষের) পরে একজন বিজয়ী বাছাই করতে যাচ্ছি এবং যদি আপনি এই বাগটি ঠিক করার জন্য সময় পান তবে আপনার সমাধানটি প্রথম প্রার্থী হবে । এখনই, আপনি সর্বনিম্ন স্কোর করেছেন :)
ফেলিক্স Palmen

1
@ ফেলিক্সপ্যালম্যান ফিক্সড!
ডিএলস্ক

7

হাস্কেল , 327 360 418 394 বাইট

g.(m.w.r.r=<<).lines.f
n:c:z="\n#_0123456789"++['A'..'Z']++['a'..'z']
(!)x=elem x
f('\\':'\n':a)=f a
f(a:b)=a:f b
f a=a
m('#':a)=c:a++[n]
m a=a
g(a:'#':b)=a:[n|a/=n]++c:g b
g(a:b)=a:g b
g a=a
s=span(!" \t")
r=reverse.snd.s
l n(a:b)d|a==d,n=a:w(snd$s b)|1>0=a:l(not$n&&a=='\\')b d
w('/':'/':_)=[]
w(a:b)|a!"\"'"=a:l(1>0)b a|(p,q:u)<-s b=a:[' '|p>"",a!z&&q!z||[a,q]!words"++ -- /*"]++w(q:u)
w a=a

এটি অনলাইন চেষ্টা করুন!

এই লিখতে অনেক মজা লাগল! প্রথমে fফাংশনটি উপস্থিত হয় এবং লাইনগুলির শেষে সমস্ত ব্যাকস্ল্যাশগুলি সরিয়ে ফেলে তারপরে linesএটি নতুন লাইনের স্ট্রিংগুলির তালিকায় বিভক্ত হয়। তারপরে আমরা লাইনগুলিতে একগুচ্ছ ফাংশন ম্যাপ করি এবং সেগুলি আবার একত্রিত করি। এই ফাংশনগুলি: বাম ( t) থেকে এবং ডান দিক থেকে ( r.t.rযেখানে rরয়েছে reverse) ফালা সাদা করা ; স্ট্রিং এবং চরিত্রের অক্ষরকে উপেক্ষা করার সাথে সাথে মন্তব্যগুলি অপসারণ করুন w; এবং অবশেষে শেষের দিকে একটি নতুনলাইন চরিত্র যুক্ত করে যদি লাইনটি একটি # দিয়ে শুরু হয়। সমস্ত লাইন একসাথে ফিরে একত্রিত হওয়ার পরে g# টি অক্ষর সন্ধান করে এবং এটি একটি নতুন লাইন দ্বারা পূর্ববর্তী হয় তা নিশ্চিত করে।

wকিছুটা জটিল তাই আমি এটি আরও ব্যাখ্যা করব। প্রথমে আমি "//" এর জন্য যাচাই করি যেহেতু wআমি জানি আমি একটি স্ট্রিং আক্ষরিক না আছি আমি জানি এটি একটি মন্তব্য তাই আমি বাকী রেখাটি ফেলে রাখি। পরবর্তী আমি পরীক্ষা করে দেখি যে হেডটি স্ট্রিং বা অক্ষর অক্ষরে অক্ষরের জন্য একটি সীমানার কিনা। যদি এটি হয় তবে আমি এটিকে প্রিপেন্ড করি এবং যে ব্যাটনটি lঅক্ষরগুলির মধ্যে দিয়ে চলে তা পাস করে "পলায়ন" অবস্থার সন্ধান করি nযা দিয়ে যদি একটানা একাধিক সংখ্যক টানা বিপর্যয় ঘটে থাকে। যখন lএকটি ডিলিমিটার সনাক্ত করে এবং পালানোর অবস্থায় না থাকে তখন এটি লাঠিয়ালটি পিছনে ফিরে যায় w, আক্ষরিকের পরে শ্বেত স্পেস নির্মূল করতে ছাঁটাই করে কারণ wপ্রথম চরিত্রটি শ্বেত স্পেস না হওয়ার প্রত্যাশা করে। কখনwলেজটির সাদা অংশ সন্ধান করতে স্প্যান ব্যবহার করে এমন কোনও সীমানা খুঁজে পাওয়া যায় না। আশেপাশের চরিত্রগুলিকে যোগাযোগের আওতায় আনা যায় না এবং যদি থাকে তবে একটি স্থান সন্নিবেশ করানো যায় কিনা তা যদি এটির কোনও পরীক্ষা করে থাকে। তারপরে এটি সাদা স্থান শেষ হওয়ার পরে পুনরাবৃত্তি করে। যদি কোনও সাদা জায়গা না থাকে তবে কোনও স্থান isোকানো হয় না এবং এটি যেভাবেই চলতে থাকে।

সম্পাদনা: আমার প্রোগ্রামে একটি বাগ চিহ্নিত করার জন্য @ ডিএলসকে অনেক ধন্যবাদ, যা আমাকে এটির সংক্ষিপ্ত করার পক্ষে আসলে একটি পথ দেখিয়েছিল! প্যাটার্ন ম্যাচিংয়ের জন্য হুর!

সম্পাদনা 2: আমি এমন একজন নির্বোধ, যে অনুমানটি পড়া শেষ করেনি! আবারও ডিএলসকে ধন্যবাদ জানাতে চাই!

সম্পাদনা 3: সবেমাত্র কিছু বিরক্তিকর ধরণের হ্রাস জিনিসটি লক্ষ্য e=elemকরা গেছে Char->[Char]->Boolযা কোনও কারণে পরিবর্তিত হয়েছিল , সুতরাং এটি বন্ধ হয়ে যাচ্ছে e[a,q]। এটি সঠিক হতে বাধ্য করার জন্য আমাকে একটি টাইপ স্বাক্ষর যুক্ত করতে হয়েছিল। কেউ কি জানেন যে আমি কীভাবে এটি ঠিক করতে পারি? হাস্কেলের আগে এর আগে কখনও আমার এই সমস্যা হয়নি। Tio

সম্পাদনা 4: বাগের জন্য দ্রুত ঠিক করা @ ফেলিক্সপ্যালম্যান আমাকে দেখিয়েছে। আমার কিছুটা সময় পেলে এটি পরে গল্ফ করার চেষ্টা করতে পারে।

EDIT5: -24 বাইট @ লিনকে ধন্যবাদ! ধন্যবাদ! আমি জানতাম না যে আপনি প্যাটার্ন ম্যাচিংয়ের মতো n:c:z=...সত্যই দুর্দান্ত ব্যবহার করে বিশ্বব্যাপী সুযোগগুলিতে জিনিস বরাদ্দ করতে পারেন ! অপারেটর তৈরির জন্যও ভাল ধারণাelem আমি এটি ভেবেছি thought



2
আপনি ভয়ঙ্কর মনোমরফিজম সীমাবদ্ধতার মধ্যে চলেছেন ; সংজ্ঞা দেওয়া e x y=elem x y(বা এমনকি e x=elem x) আপনার সমস্যার সমাধান করে। (আমি eএকটি অপারেটরের নাম বদলে দিয়েছি (!)।)
লিন

3

সি, 497 494 490 489 বাইট

যেহেতু আমরা সি প্রক্রিয়াজাত করছি, আসুন এটি সি ব্যবহার করে করি ! ফাংশন f()চর পয়েন্টার pএবং আউটপুট থেকে পয়েন্টার qপর্যন্ত ইনপুট নেয় এবং ধরে নেয় যে ইনপুটটি ASCII এ রয়েছে:

#define O*q++
#define R (r=*p++)
#define V(c)(isalnum(c)||c==95)
char*p,*q,r,s,t;d(){isspace(r)?g():r==47&&*p==r?c(),g():r==92?e():(O=s=r)==34?b():r==39?O=R,a():r?a():(O=r);}a(){R;d();}b(){((O=R)==34?a:r==92?O=R,b:b)();}c(){while(R-10)p+=r==92;}e(){R-10?s=O=92,O=r,a():h();}j(){(!isspace(R)?r==47&&*p==r?c(),j:(t=r==35,d):j)();}f(){t=*p==35;j();}i(){V(s)&&V(r)||s==47&&r==42||(s==43||s==45)&&r==s&&*p==s?O=32:0;d();}h(){isspace(R)?g():i();}g(){(r==10?t?O=r,j:*p==35?s-10?s=O=r,j:0:h:h)();}

আমরা ধরে নিই যে ফাইলটি সুগঠিত - স্ট্রিং এবং চরিত্রের অক্ষরগুলি বন্ধ রয়েছে এবং চূড়ান্ত লাইনে কোনও মন্তব্য থাকলে এটি বন্ধ করার জন্য অবশ্যই একটি নতুন লাইন থাকতে হবে।

ব্যাখ্যা

প্রাক-গল্ফযুক্ত সংস্করণটি আরও কিছুটা সুগঠিত, আমি ভয় করি:

#define O *q++=
#define R (r=*p++)
#define V(c)(isalnum(c)||c=='_')
char*p,*q,r,s,t;
d(){isspace(r)?g():r=='/'&&*p==r?c(),g():r=='\\'?e():(O s=r)=='"'?b():r=='\''?O R,a():r?a():(O r);}
a(){R;d();}
b(){((O R)=='"'?a:r=='\\'?O R,b:b)();}
c(){while(R!='\n')p+=r=='\\';}
e(){R!='\n'?s=O'\\',O r,a():h();}
j(){(!isspace(R)?r=='/'&&*p==r?c(),j:(t=r=='#',d):j)();}
f(){t=*p=='#';j();}
i(){V(s)&&V(r)||s=='/'&&r=='*'||(s=='+'||s=='-')&&r==s&&*p==s?O' ':0;d();}
h(){isspace(R)?g():i();}
g(){(r=='\n'?t?O r,j:*p=='#'?s!='\n'?s=O r,j:0:h:h)();}

এটি লেজ পুনরাবৃত্তি দ্বারা একটি রাষ্ট্র মেশিন প্রয়োগ করে। সহায়ক ম্যাক্রো এবং ভেরিয়েবলগুলি

  • Oজন্য utput
  • Rথেকে মধ্যে EAD ইনপুটr
  • Vভি এলিড শনাক্তকারী অক্ষর নির্ধারণ করতে (যেহেতু !isalnum('_'))
  • pএবং q- I / O পয়েন্টারগুলি বর্ণিত হিসাবে
  • r- শেষ অক্ষর r ead হতে
  • s- এর সাম্প্রতিক অ-শ্বেতস্থান চরিত্রের অ্যাভড
  • t- টি AG যখন একটি প্রাক প্রসেসর নির্দেশ নিয়ে কাজ

আমাদের রাজ্যগুলি হয়

  • a() - সাধারণ সি কোড
  • b() - স্ট্রিং আক্ষরিক
  • c() - মন্তব্য
  • d() - সাধারণ সি কোড, পড়ার পরে r
  • e() - পালানোর ক্রম
  • f() - প্রাথমিক অবস্থা (প্রধান ফাংশন)
  • g() - হোয়াইটস্পেসে
  • h()- হোয়াইটস্পেসে - প্রেরণ g()বাi()
  • i() - অবিলম্বে সাদা স্থানের পরে - আমাদের কি কোনও স্থানের অক্ষর সন্নিবেশ করা প্রয়োজন?
  • j() - প্রাথমিক শ্বেত স্থান - কখনও কোনও স্থানের অক্ষর প্রবেশ করান না

পরীক্ষা প্রোগ্রাম

#define DEMO(code)                              \
    do {                                        \
        char in[] = code;                       \
        char out[sizeof in];                    \
        p=in;q=out;f();                         \
        puts("vvvvvvvvvv");                     \
        puts(out);                              \
        puts("^^^^^^^^^^");                     \
    } while (0)

#include<stdio.h>
#include<stdlib.h>
int main()
{
    DEMO(
         "main() {\n"
         "    printf(\"Hello, World!\"); // hi\n"
         "}\n"
         );
    DEMO(
         "#define max(x, y)                               \\\n"
         "    x > y ? x : y\n"
         "#define I(x) scanf(\"%d\", &x)\n"
         "a;\n"
         "b; // just a needless comment, \\\n"
         "        because we can!\n"
         "main()\n"
         "{\n"
         "    I(a);\n"
         "    I(b);\n"
         "    printf(\"\\\" max \\\": %d\\n\", max(a, b));\n"
         "}\n"
         );
    DEMO(
         "x[10];*c;i;\n"
         "main()\n"
         "{\n"
         "    int _e;\n"
         "    for(; scanf(\"%d\", &x) > 0 && ++_e;);\n"
         "    for(c = x + _e; c --> x; i = 100 / *x, printf(\"%d \", i - --_e));\n"
         "}\n"
         );
    DEMO(
         "// often used functions/keywords:\n"
         "#define P printf(\n"
         "#define A case\n"
         "#define B break\n"
         "\n"
         "// loops for copying rows upwards/downwards are similar -> macro\n"
         "#define L(i, e, t, f, s) \\\n"
         "        for (o=i; o e;){ strcpy(l[o t], l[o f]); c[o t]=c[s o]; }\n"
         "\n"
         "// range check for rows/columns is similar -> macro\n"
         "#define R(m,o) { return b<1|b>m ? m o : b; }\n"
         "\n"
         "// checking for numerical input is needed twice (move and print command):\n"
         "#define N(f) sscanf(f, \"%d,%d\", &i, &j) || sscanf(f, \",%d\", &j)\n"
         "\n"
         "// room for 999 rows with each 999 cols (not specified, should be enough)\n"
         "// also declare \"current line pointers\" (*L for data, *C for line length),\n"
         "// an input buffer (a) and scratch variables\n"
         "r, i, j, o, z, c[999], *C, x=1, y=1;\n"
         "char a[999], l[999][999], (*L)[999];\n"
         "\n"
         "// move rows down from current cursor position\n"
         "D()\n"
         "{\n"
         "    L(r, >y, , -1, --)\n"
         "    r++ ? strcpy(l[o], l[o-1]+--x), c[o-1]=x, l[o-1][x]=0 : 0;\n"
         "    c[y++] = strlen(l[o]);\n"
         "    x=1;\n"
         "}\n"
         "\n"
         "// move rows up, appending uppermost to current line\n"
         "U()\n"
         "{\n"
         "    strcat(*L, l[y]);\n"
         "    *C = strlen(*L);\n"
         "    L(y+1, <r, -1, , ++)\n"
         "    --r;\n"
         "    *l[r] = c[r] = 0;\n"
         "}\n"
         "\n"
         "// normalize positions, treat 0 as max\n"
         "X(b) R(c[y-1], +1)\n"
         "Y(b) R(r, )\n"
         "\n"
         "main()\n"
         "{\n"
         "    for(;;) // forever\n"
         "    {\n"
         "        // initialize z as current line index, the current line pointers,\n"
         "        // i and j for default values of positioning\n"
         "        z = i = y;\n"
         "        L = l + --z;\n"
         "        C = c + z;\n"
         "        j = x;\n"
         "\n"
         "        // prompt:\n"
         "        !r || y/r && x > *C\n"
         "            ? P \"end> \")\n"
         "            : P \"%d,%d> \", y, x);\n"
         "\n"
         "        // read a line of input (using scanf so we don't need an include)\n"
         "        scanf(\"%[^\\n]%*c\", a)\n"
         "\n"
         "            // no command arguments -> make check easier:\n"
         "            ? a[2] *= !!a[1],\n"
         "\n"
         "            // numerical input -> have move command:\n"
         "            // calculate new coordinates, checking for \"relative\"\n"
         "            N(a)\n"
         "                ? y = Y(i + (i<0 | *a=='+') * y)\n"
         "                    , x = X(j + (j<0 || strchr(a+1, '+')) * x)\n"
         "                :0\n"
         "\n"
         "            // check for empty input, read single newline\n"
         "            // and perform <return> command:\n"
         "            : ( *a = D(), scanf(\"%*c\") );\n"
         "\n"
         "        switch(*a)\n"
         "        {\n"
         "            A 'e':\n"
         "                y = r;\n"
         "                x = c[r-1] + 1;\n"
         "                B;\n"
         "\n"
         "            A 'b':\n"
         "                y = 1;\n"
         "                x = 1;\n"
         "                B;\n"
         "\n"
         "            A 'L':\n"
         "                for(o = y-4; ++o < y+2;)\n"
         "                    o<0 ^ o<r && P \"%c%s\\n\", o^z ? ' ' : '>', l[o]);\n"
         "                for(o = x+1; --o;)\n"
         "                    P \" \");\n"
         "                P \"^\\n\");\n"
         "                B;\n"
         "\n"
         "            A 'l':\n"
         "                puts(*L);\n"
         "                B;\n"
         "\n"
         "            A 'p':\n"
         "                i = 1;\n"
         "                j = 0;\n"
         "                N(a+2);\n"
         "                for(o = Y(i)-1; o<Y(j); ++o)\n"
         "                    puts(l[o]);\n"
         "                B;\n"
         "\n"
         "            A 'A':\n"
         "                y = r++;\n"
         "                strcpy(l[y], a+2);\n"
         "                x = c[y] = strlen(a+2);\n"
         "                ++x;\n"
         "                ++y;\n"
         "                B;\n"
         "\n"
         "            A 'i':\n"
         "                D();\n"
         "                --y;\n"
         "                x=X(0);\n"
         "                // Commands i and r are very similar -> fall through\n"
         "                // from i to r after moving rows down and setting\n"
         "                // position at end of line:\n"
         "\n"
         "            A 'r':\n"
         "                strcpy(*L+x-1, a+2);\n"
         "                *C = strlen(*L);\n"
         "                x = 1;\n"
         "                ++y > r && ++r;\n"
         "                B;\n"
         "\n"
         "            A 'I':\n"
         "                o = strlen(a+2);\n"
         "                memmove(*L+x+o-1, *L+x-1, *C-x+1);\n"
         "                *C += o;\n"
         "                memcpy(*L+x-1, a+2, o);\n"
         "                x += o;\n"
         "                B;\n"
         "\n"
         "            A 'd':\n"
         "                **L ? **L = *C = 0, x = 1 : U();\n"
         "                y = y>r ? r : y;\n"
         "                B;\n"
         "\n"
         "            A 'j':\n"
         "                y<r && U();\n"
         "        }\n"
         "    }\n"
         "}\n";);
}

এটি উত্পাদন করে

main(){printf("Hello, World!");}
#define max(x,y)x>y?x:y
#define I(x)scanf("%d",&x)
a;b;main(){I(a);I(b);printf("\" max \": %d\n",max(a,b));}
x[10];*c;i;main(){int _e;for(;scanf("%d",&x)>0&&++_e;);for(c=x+_e;c-->x;i=100/ *x,printf("%d ",i- --_e));}
#define P printf(
#define A case
#define B break
#define L(i,e,t,f,s)for(o=i;o e;){strcpy(l[o t],l[o f]);c[o t]=c[s o];}
#define R(m,o){return b<1|b>m?m o:b;}
#define N(f)sscanf(f,"%d,%d",&i,&j)||sscanf(f,",%d",&j)
r,i,j,o,z,c[999],*C,x=1,y=1;char a[999],l[999][999],(*L)[999];D(){L(r,>y,,-1,--)r++?strcpy(l[o],l[o-1]+--x),c[o-1]=x,l[o-1][x]=0:0;c[y++]=strlen(l[o]);x=1;}U(){strcat(*L,l[y]);*C=strlen(*L);L(y+1,<r,-1,,++)--r;*l[r]=c[r]=0;}X(b)R(c[y-1],+1)Y(b)R(r,)main(){for(;;){z=i=y;L=l+--z;C=c+z;j=x;!r||y/r&&x>*C?P"end> "):P"%d,%d> ",y,x);scanf("%[^\n]%*c",a)?a[2]*=!!a[1],N(a)?y=Y(i+(i<0|*a=='+')*y),x=X(j+(j<0||strchr(a+1,'+'))*x):0:(*a=D(),scanf("%*c"));switch(*a){A'e':y=r;x=c[r-1]+1;B;A'b':y=1;x=1;B;A'L':for(o=y-4;++o<y+2;)o<0^o<r&&P"%c%s\n",o^z?' ' :'>',l[o]);for(o=x+1;--o;)P" ");P"^\n");B;A'l':puts(*L);B;A'p':i=1;j=0;N(a+2);for(o=Y(i)-1;o<Y(j);++o)puts(l[o]);B;A'A':y=r++;strcpy(l[y],a+2);x=c[y]=strlen(a+2);++x;++y;B;A'i':D();--y;x=X(0);A'r':strcpy(*L+x-1,a+2);*C=strlen(*L);x=1;++y>r&&++r;B;A'I':o=strlen(a+2);memmove(*L+x+o-1,*L+x-1,*C-x+1);*C+=o;memcpy(*L+x-1,a+2,o);x+=o;B;A'd':**L?**L=*C=0,x=1:U();y=y>r?r:y;B;A'j':y<r&&U();}}}

সীমাবদ্ধতা

এটি যেমন সংজ্ঞাগুলি ভঙ্গ করে

#define A (x)

নামটি সম্প্রসারণ থেকে পৃথক করে এমন স্থান সরিয়ে দিয়ে giving

#define A(x)

সম্পূর্ণ ভিন্ন অর্থ সহ এই কেসটি পরীক্ষা সেটগুলি থেকে অনুপস্থিত, সুতরাং আমি এটির সমাধান করব না।

আমি সন্দেহ করি যে আমি একাধিক পাস ইন-প্লেস রূপান্তর সহ একটি সংক্ষিপ্ত সংস্করণ তৈরি করতে সক্ষম হতে পারি - আমি পরের সপ্তাহে চেষ্টা করতে পারি।


আপনি সরিয়ে এক বাইট সংরক্ষণ করতে পারবেন =সংজ্ঞা শেষে Oএবং স্থান যে প্রতিটি কলের অনুসরণ পরিবর্তন Oএকটি মধ্যে =
জাকারি

আমাদের সম্পর্কে "সীমাবদ্ধতা"), এছাড়াও নিজেই প্রশ্নে আমার মন্তব্য দেখুন - সনাক্ত; এই মহান এই শুধু অত্যধিক জটিলতা বাড়ায় হবে।
ফেলিক্স Palmen

@ জাচারি - এর জন্য ধন্যবাদ - আমি ভুলে গিয়েছিলাম যখন আমি সাধারণ কোডটি এএসসিআইআই-নির্দিষ্ট করে O'\\'এবং O' 'উভয়ই একটি স্থান অর্জন করি।
টবি স্পিড


2

সি,  705   663  640 বাইট

৪০ বাইট গল্ফ করার জন্য @ জাচারাকে ধন্যবাদ এবং 23 বাইট গল্ফ করার জন্য @ নাহুয়েল ফুইলুলকে ধন্যবাদ!

#define A(x)(x>47&x<58|x>64&x<91|x>96&x<123)
#define K if(*C==47&(C[1]==47|p==47)){if(p==47)--G;for(c=1;c;*C++-92||c++)*C-10||--c;if(d)p=*G++=10,--d;
#define D if(!d&*C==35){d=1;if(p&p-10)p=*G++=10;}
#define S K}if((A(p)&A(*C))|(p==*C&l==43|p==45)|p==47&*C==42|p==95&(A(*C)|*C==95)|*C==95&(A(p)|p==95))p=*G++=32;}
#define W*C<33|*C==92
#define F{for(;W;C++)
c,d,e,p,l;g(char*C,char*G)F;for(;*C;*C>32&&*C-34&&*C-39&&(p=*G++=*C),*C-34&&*C-39&&C++){l=e=0;if(*C==34)l=34;if(*C==39)l=39;if(l)for(*G++=l,p=*G++=*++C;*C++-l|e%2;e=*(C-1)-92?0:e+1)p=*G++=*C;K}D if(d){if(W)F{*C-92||++d;*C-10||--d;if(!d){p=*G++=10;goto E;}}S}else{if(W)F;S}E:D}*G=0;}

এটি অনলাইন চেষ্টা করুন!


হতে for(;W;C++){}পারে for(;W;C++);?
জাকারি

@ জাচারা যা কখনও জিজ্ঞাসা করা হয়নি। এটি একেবারে শেষ ধাপের একটি টোল: অপ্রয়োজনীয় সাদা স্থান এবং মন্তব্যগুলি সরিয়ে ফেলুন।
ফেলিক্স Palmen

আমি তার কোডটি উল্লেখ করছিলাম, চ্যালেঞ্জ নয়।
জাকারি

@ জাচারি হাহা আমি দেখছি ... কোড এবং ইনপুট একই ভাষা হলে অদ্ভুত;)
ফেলিক্স প্যালম্যান

এটি কি 665 বাইটের জন্য কাজ করবে? goo.gl/E6tk8V
জাকারি

2

পার্ল 5, 250 + 3 (-00n) , 167 + 1 ( -পি ) বাইট

$_.=<>while s/\\
//;s,(//.*)|(("|')(\\.|.)*?\3)|/?[^"'/]+,$1|$2?$2:$&=~s@(\S?)\K\s+(?=(.?))@"$1$2"=~/\w\w|\+\+|--|\/\*/&&$"@ger,ge;$d++&&$l+/^#/&&s/^/
/,$l=/^#/m if/./

এটি অনলাইনে চেষ্টা করুন


হ্যাঁ আমি কেবল একটি অনুকূল-সমাধান সমাধান রেখেছি। আমি সবেমাত্র টিও লিঙ্কটি যুক্ত করেছি, সময় পেলে আমি এটি গল্ফটিতে দেখব।
নাহুয়েল ফিউইলুল

কোডের আগে স্থাপন করা হলে প্রিপ্রসেসর নির্দেশিকা তাদের নিজস্ব লাইনে থাকে যেমন পরীক্ষার ক্ষেত্রে যেমন প্রয়োজন হয় তবে আমি পরিবর্তন যুক্ত করব
নাহুয়েল ফিউইলুল

1
স্থির আপডেট দেখুন
নাহুয়েল ফিউইলুল

0

পাইথন 2 , 479 456 445 434 502 497 বাইট

e=enumerate
import re
u=re.sub
def f(s):
 r=()
 for l in u(r'\\\n','',s).split('\n'):
	s=p=w=0;L=[]
	for i,c in e(l):
	 if(p<1)*'//'==l[i:i+2]:l=l[:i]
	 if c in"'\""and w%2<1:
		if p in(c,0):L+=[l[s:i+1]];s=i+1
		p=[0,c][p<1]
	 w=[0,w+1]['\\'==c]
	r+=L+[l[s:]],
 S=''
 for l in r:s=''.join([u('. .',R,u('. .',R,u('\s+',' ',x))).strip(),x][i%2]for i,x in e(l));S+=['%s','\n%s\n'][s[:1]=='#']%s
 print u('\n\n','\n',S).strip()
def R(m):g=m.group(0);f=g[::2];return[f,g][f.isalnum()or f in'++ -- /*']

এটি অনলাইন চেষ্টা করুন!

সম্পাদনা: ফিক্সড অন্তর্ভুক্ত করা - -, + +এবং/ *

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.