सुपरसोनिक डोमिनोज़ झुकाव

10

कार्य

एक प्रोग्राम लिखें जो तीन पूर्णांक m , n या तो STDIN से या कमांड-लाइन तर्क के रूप में पढ़ता है , आयामों × × n द्वारा 2 × 1 और 1 × 2 डोमिनोज़ के आयत के सभी संभावित झुकावों को प्रिंट करता है और अंत में मान्य टाइलों की संख्या को पढ़ता है।

एक व्यक्तिगत टाइलिंग के डोमिनोज़ को 2 × 1 के- लिए दो डैश ( ) और 1 × 6 डोम के लिए दो ऊर्ध्वाधर सलाखों ( ) द्वारा दर्शाया जाना है । प्रत्येक टाइलिंग (पिछले एक सहित) को एक लाइनफीड द्वारा पालन किया जाना है।|

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

आपका प्रोग्राम 1024 बाइट्स से अधिक लंबा नहीं हो सकता है। इसे सभी इनपुट्स के लिए काम करना है जैसे कि m × n । 64 ।

( 4x6 आयत के सभी डोमिनोज़ प्रिंट से प्रेरित होकर ।)

उदाहरण

$ sdt 4 2
----
----

||--
||--

|--|
|--|

--||
--||

||||
||||

5
$ sdt 4 2 scoring
5

स्कोरिंग

आपका स्कोर इनपुट के लिए आपके कार्यक्रम के निष्पादन समय से निर्धारित होता है सेट झंडे के सेट के साथ 8 8 के निर्धारित होता है।

इसे सबसे तेज कोड बनाने के लिए तेज़ कंप्यूटर चुनौती बजाय , मैं आधिकारिक स्कोर निर्धारित करने के लिए अपने कंप्यूटर (Intel Core i7-3770, 16 GiB PC3-12800 RAM) पर सभी प्रस्तुतियाँ चलाऊंगा।

कृपया अपने कोड को संकलित और / या निष्पादित करने के बारे में विस्तृत निर्देश छोड़ दें। यदि आपको अपनी भाषा के संकलक / दुभाषिया के विशिष्ट संस्करण की आवश्यकता है, तो उस आशय का विवरण दें।

यदि मेरे पास बिना जमा किए पद छोड़ने का अधिकार सुरक्षित है:

  • मेरे ऑपरेटिंग सिस्टम के लिए कोई मुफ्त (बीयर के रूप में) संकलक / दुभाषिया नहीं है (फेडोरा 21, 64 बिट्स)।

  • हमारे प्रयासों के बावजूद, आपका कोड काम नहीं करता है और / या मेरे कंप्यूटर पर गलत आउटपुट उत्पन्न करता है।

  • संकलन या निष्पादन में एक घंटे से अधिक समय लगता है।

  • आपके कोड या एकमात्र उपलब्ध संकलक / दुभाषिया में rm -rf ~समान रूप से गड़बड़ करने के लिए एक सिस्टम कॉल या कुछ होता है।

लीडरबोर्ड

मैंने सभी सबमिशनों को फिर से बनाया है, दोनों संकलन और निष्पादन के लिए 10,000 पुनरावृत्तियों के साथ एक लूप में निष्पादित किया जा रहा है और निष्पादन (कोड की गति के आधार पर) और मतलब की गणना के लिए 100 से 10,000 पुनरावृत्तियों के बीच।

ये परिणाम थे:

User          Compiler   Score                              Approach

jimmy23013    GCC (-O0)    46.11 ms =   1.46 ms + 44.65 ms  O(m*n*2^n) algorithm.
steveverrill  GCC (-O0)    51.76 ms =   5.09 ms + 46.67 ms  Enumeration over 8 x 4.
jimmy23013    GCC (-O1)   208.99 ms = 150.18 ms + 58.81 ms  Enumeration over 8 x 8.
Reto Koradi   GCC (-O2)   271.38 ms = 214.85 ms + 56.53 ms  Enumeration over 8 x 8.
math  fastest-code  combinatorics  tiling 
— डेनिस
स्रोत
इसे GOLF प्रतियोगिता क्यों नहीं बनाया गया? :(
— orlp
2
यदि आपने सुझाव दिया था कि सैंडबॉक्स में, मेरे पास हो सकता है। इससे मेरा सीपीयू और मुझे बहुत काम बचा होगा ...
— डेनिस
3
@ kirbyfan64sos जिस तरह से मैं इसे समझता हूं, इसमें केवल एक प्रकार का डोमिनो है, जिसे आप घुमा सकते हैं। यदि यह क्षैतिज है, तो यह इस तरह दिखता है --:। यदि यह लंबवत है, तो यह दो है |, दूसरे के नीचे एक है।
— रेटो कोराडी
1
आपकी चुनौती खराब नहीं है। समस्या यह है कि हमारे शीर्ष कोडर बहुत मजबूत हैं। पंक्तियों और स्तंभों की वैधता की जांच करने वाला मेरा समाधान 6x8 के लिए 1 मिनट के पास रहता है।
— edc65
1
मुझे लगता है कि अब सबसे अच्छी रणनीति असेंबली का उपयोग करना है, और जटिलता के समय से छुटकारा पाने के लिए 1024 बाइट्स से कम बाइनरी फ़ाइल प्राप्त करने का प्रयास करना है।
— jimmy23013

जवाबों:

5

सी

एक सीधा कार्यान्वयन ...

#include<stdio.h>
int a,b,c,s[65],l=0,countonly;
unsigned long long m=0;
char r[100130];
void w(i,x,o){
    int j,k;
    j=(1<<b)-1&~x;
    if(i<a-1){
        s[i+1]=j;
        w(i+1,j,1);
        for(k=j&j/2&-o;j=k&-k;k&=~j)
            w(i,x|3*j,j);
    }
    else if((j/3|j/3*2)==j)
        if(countonly)
            m++;
        else{
            if(c==b)
                for(k=0;k<b;r[k++,l++]=10)
                    for(j=0;j<a;j++)
                        r[l++]=45+79*!((s[j]|s[j+1])&(1<<k));
            else
                for(j=0;j<a;r[j++,l++]=10)
                    for(k=0;k<b;k++)
                        r[l++]=124-79*!((s[j]|s[j+1])&(1<<k));
            r[l++]=10;
            if(l>=100000){
                fwrite(r,l,1,stdout);
                l=0;
            }
        }
}

int main(){
    scanf("%d %d %d",&a,&b,&countonly);
    c=b;
    if(a<b){a^=b;b^=a;a^=b;}
    s[0]=s[a]=0;
    w(0,0,1);
    if(countonly)
        printf("%llu\n",m);
    else if(l)
        fwrite(r,l,1,stdout);
}

धोखा देने वाला संस्करण

#include<stdio.h>
#include<string.h>
int a,b,c,s[65],l=0,countonly;
unsigned long long m=0,d[256];
char r[100130];
void w2(){
    int i,j,k,x;
    memset(d,0,sizeof d);
    d[0]=1;
    j=0;
    for(i=0;i<a-1;i++){
        for(k=1;k<(1<<(b-1));k*=2)
            for(x=0;x<(1<<(b-2));x++)
                d[(x+x/k*k*3+k*3)^j]+=d[(x+x/k*k*3)^j];
        j^=(1<<b)-1;
    }
    for(x=0;x<(1<<b);x++)
        if((x/3|x/3*2)==x)
            m+=d[x^((1<<b)-1)^j];
    printf("%llu\n",m);
}

void w(i,x,o){
    int j,k;
    j=(1<<b)-1&~x;
    if(i<a-1){
        s[i+1]=j;
        w(i+1,j,1);
        for(k=j&j/2&-o;j=k&-k;k&=~j)
            w(i,x|3*j,j);
    }
    else if((j/3|j/3*2)==j){
        if(c==b)
            for(k=0;k<b;r[k++,l++]=10)
                for(j=0;j<a;j++)
                    r[l++]=45+79*!((s[j]|s[j+1])&(1<<k));
        else
            for(j=0;j<a;r[j++,l++]=10)
                for(k=0;k<b;k++)
                    r[l++]=124-79*!((s[j]|s[j+1])&(1<<k));
        r[l++]=10;
        if(l>=100000){
            fwrite(r,l,1,stdout);
            l=0;
        }
    }
}

int main(){
    scanf("%d %d %d",&a,&b,&countonly);
    c=b;
    if(a<b){a^=b;b^=a;a^=b;}
    s[0]=s[a]=0;
    if(countonly)
        w2();
    else{
        w(0,0,1);
        if(l)
            fwrite(r,l,1,stdout);
    }
}

तेज एल्गोरिथ्म का स्पष्टीकरण

यह बाएं से दाएं स्कैन करता है, और राज्य को बनाए रखता है d[i][j], जहां:

  • i में है [0,m) , जिसका अर्थ है वर्तमान कॉलम।
  • jआकार का एक बिट वेक्टर है n, जहां बिट 1 होगा यदि iइस कॉलम पर काम शुरू करने से पहले कॉलम में संबंधित स्थिति पहले से ही कब्जा है। यानी यह दाईं ओर के आधे हिस्से पर काबिज है-- ।
  • d[i][j] विभिन्न झुकावों की कुल संख्या है।

फिर कहते हैं e[i][j]= d[i][k]जहाँ आप वर्टिकल डोमिनोज़ बेस डाल सकते हैं, उसका योग बनता kहै j। e[i][j]उन झुकावों की संख्या होगी जहां प्रत्येक 1 बिट में jकिसी भी चीज का कब्जा होता है लेकिन बायां आधा भाग --। उन्हें भरें --और आपको मिल जाएगा d[i+1][~j]= e[i][j]। e[m-1][every bit being 1]याd[m][0] अंतिम उत्तर है।

एक भोले-भाले क्रियान्वयन से आपको कहीं न कहीं समय की जटिलता मिल जाएगी g[n]=2*g[n-1]+g[n-2] = O((sqrt(2)+1)^n)(पहले से ही काफी तेज अगर n = m = 8)। लेकिन आप इसके बजाय प्रत्येक संभावित डोमिनोज़ के लिए सबसे पहले लूप कर सकते हैं, और इसे हर उस टाइलिंग में जोड़ने का प्रयास कर सकते हैं जिसमें इस डोमिनो को जोड़ा जा सकता है, और परिणाम को मूल सरणी में विलय कर सकते हैं d(जैसे कि नैकपैक समस्या के लिए एल्गोरिथ्म)। और यह O (n * 2 ^ n) हो जाता है। और बाकी सब कार्यान्वयन विवरण हैं। पूरा कोड O (m * n * 2 ^ n) में चलता है।

— jimmy23013
स्रोत
@ डेनिस आप शायद इसे बदलने के लिए एक सर्वेक्षण शुरू करना चाहते हैं।
— jimmy23013
@ डेनिस को यकीन नहीं है कि आकार बढ़ाने से बहुत मदद मिली होगी। जबकि यह गणना समय को काफी बढ़ाता है, यह लगभग 100 गुना अधिक उत्पादन भी करता है। अपेक्षाकृत बोल, उत्पादन की मात्रा वास्तव में बड़ी है।
— रेटो कोराडी
पहला संस्करण निष्पादन: 0.286 s संकलन: 0.053 s Sum: 0.339 s दूसरा संस्करण निष्पादन: 0.002 s संकलन: 0.061 s Sum: 0.063 s (
— डेनिस
@ डेनिस ने ध्वज सेट होने पर O (m * n * 2 ^ n) में एक और एल्गोरिथ्म का उपयोग किया।
— jimmy23013
1
निष्पादन: १ ९ ० एमएस संकलन: ६ ms एमएस सम: २५ -O1seems एमएस ( मधुर स्थान प्रतीत होता है। मैंने सभी अनुकूलन स्तरों की कोशिश की है।)
— डेनिस
3

सी

अनुकूलन के एक दौर के बाद, और संशोधित नियमों के लिए अनुकूलित:

typedef unsigned long u64;

static int W, H, S;
static u64 RM, DM, NSol;
static char Out[64 * 2 + 1];

static void place(u64 cM, u64 vM, int n) {
  if (n) {
    u64 m = 1ul << __builtin_ctzl(cM); cM -= m;

    if (m & RM) {
      u64 nM = m << 1;
      if (cM & nM) place(cM - nM, vM, n - 1);
    }

    if (m & DM) {
      u64 nM = m << W;
      vM |= m; vM |= nM; place(cM - nM, vM, n - 1);
    }
  } else if (S) {
    ++NSol;
  } else {
    char* p = Out;
    for (int y = 0; y < H; ++y) {
      for (int x = 0; x < W; ++x) { *p++ = vM & 1 ? '|' : '-'; vM >>= 1; }
      *p++ = '\n';
    }
    *p++ = '\0';
    puts(Out);
    ++NSol;
  }
}

int main(int argc, char* argv[]) {
  W = atoi(argv[1]); H = atoi(argv[2]); S = (argc > 3);

  int n = W * H;
  if (n & 1) return 0;

  for (int y = 0; y < H; ++y) {
    RM <<= W; RM |= (1ul << (W - 1)) - 1;
  }
  DM = (1ul << (W * (H - 1))) - 1;

  place(-1, 0, n >> 1);
  printf("%lu\n", NSol);

  return 0;
}

मैंने 1024 वर्णों की लंबाई सीमा से टकरा जाना शुरू किया, इसलिए मुझे कुछ हद तक पठनीयता को कम करना पड़ा। बहुत कम परिवर्तनीय नाम, आदि।

निर्देश बनाएँ:

> gcc -O2 Code.c

सक्षम समाधान के साथ चलाएं:

> ./a.out 8 8 >/dev/null

केवल समाधान गणना के साथ चलाएं:

> ./a.out 8 8 s

कुछ टिप्पणियां:

  • बड़े परीक्षण उदाहरण के साथ, मैं अब अनुकूलन चाहता हूं। जबकि मेरा सिस्टम अलग है (मैक), आसपास -O2अच्छा लग रहा है।
  • कोड उस मामले के लिए धीमा हो गया है जहां आउटपुट उत्पन्न होता है। यह "केवल गिनती" मोड के अनुकूलन के लिए, और कोड की लंबाई कम करने के लिए एक सचेत बलिदान था।
  • सिस्टम कार्यों के लिए लापता और बाहरी घोषणाओं को शामिल करने के कारण कुछ संकलक चेतावनी होगी। कोड को पूरी तरह से अपठनीय बनाने के बिना मुझे अंत में 1024 वर्णों से नीचे ले जाना सबसे आसान तरीका था।

यह भी ध्यान दें कि कोड अभी भी वास्तविक समाधान उत्पन्न करता है, यहां तक ​​कि "केवल गिनती" मोड में भी। जब भी कोई समाधान पाया जाता है, तो vMबिटमास्क में 1उन पदों के लिए होता है जिसमें एक ऊर्ध्वाधर बार होता है, और 0एक क्षैतिज पट्टी के साथ पदों के लिए। केवल ASCII प्रारूप और वास्तविक आउटपुट में इस बिटमास्क के रूपांतरण को छोड़ दिया जाता है।

— रेटो कोराडी
स्रोत
@ डेनिस नया संस्करण। निष्पादन अपरिवर्तित होना चाहिए, लेकिन तेजी से संकलन। यदि हमें संकलन समय के लिए अनुकूलन करने की आवश्यकता है, तो हमें सिस्टम हेडर की आवश्यकता नहीं है!
— रेटो कोराडी
@ नई स्कोरिंग के लिए डेनिस अपडेट किया गया, और अनुकूलन के एक दौर के लिए। ध्यान दें कि मैं अब अनुकूलन चाहता हूं, जैसे कुछ -O2अच्छा होना चाहिए।
— रीटो कोराडी
निष्पादन: २५६ एमएस संकलन: ६५ एमएस सम: ३२१ एमएस ( -O2मधुर स्थान प्रतीत होता है। मैंने सभी अनुकूलन स्तरों की कोशिश की है।)
— डेनिस
1

सी

अवधारणा को पहले एक पंक्ति में क्षैतिज डोमिनोज़ की सभी संभावित व्यवस्थाओं को खोजना है, उन्हें स्टोर करना है r[]और फिर उन्हें ऊर्ध्वाधर डोमिनोज़ की सभी संभव व्यवस्था देने के लिए व्यवस्थित करना है।

एक पंक्ति में क्षैतिज डोमिनोज़ की स्थिति के लिए कोड को मेरे इस उत्तर से संशोधित किया गया है: https://codegolf.stackexchange.com/a/37888/15599 । यह व्यापक ग्रिड के लिए धीमा है, लेकिन यह 8x8 मामले के लिए कोई समस्या नहीं है।

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

f()क्षैतिज डोमिनोज़ की संभावित व्यवस्था की तालिका बनाता है, और केंद्र रेखा पर ऊर्ध्वाधर डोमिनोज़ की संभावित व्यवस्था के माध्यम से स्कैन करता है। इसके बाद पुनरावर्ती फ़ंक्शन को कॉल g()किया जाता है जो पंक्तियों में भर जाता है। यदि मुद्रण की आवश्यकता है, h()तो ऐसा करने के लिए फ़ंक्शन को कहा जाता है।

g()3 मापदंडों के साथ कहा जाता है। yवर्तमान पंक्ति है और dवह दिशा (ऊपर या नीचे) है जिसमें हम केंद्र को केंद्र से बाहर की ओर भर रहे हैं। xएक बिटमैप में ऊर्ध्वाधर डोमिनोज़ इंगित होते हैं जो पिछली पंक्ति से अपूर्ण हैं। R [] से एक पंक्ति में डोमिनोज़ की सभी संभव व्यवस्था की कोशिश की जाती है। इस सरणी में, 1 एक ऊर्ध्वाधर डोमिनोज़ और शून्य की एक जोड़ी को एक क्षैतिज डोमिनोज़ का प्रतिनिधित्व करता है। सरणी में एक मान्य प्रविष्टि में अंतिम पंक्ति से किसी भी अपूर्ण ऊर्ध्वाधर डोमिनोज़ को पूरा करने के लिए कम से कम पर्याप्त 1 होना चाहिए (x&r[j])==x:। इसमें अधिक 1 हो सकता है जो इंगित करता है कि नए ऊर्ध्वाधर डोमिनोज़ शुरू किए जा रहे हैं। अगली पंक्ति के लिए, फिर, हमें केवल नए डोमिनोज़ की आवश्यकता है, इसलिए हम प्रक्रिया को फिर से कहते हैं x^r[j]।

यदि अंतिम पंक्ति समाप्त हो गई है और बोर्ड के ऊपर या नीचे लटकने वाले अधूरे ऊर्ध्वाधर डोमिनोज़ नहीं हैं x^r[j]==0तो आधे को सफलतापूर्वक पूरा कर लिया गया है। यदि हम छपाई नहीं कर रहे हैं, तो नीचे की आधी को पूरा करना पर्याप्त है और c*cकुल व्यवस्था की संख्या का उपयोग करना है। यदि हम प्रिंट कर रहे हैं, तो शीर्ष आधे को भी पूरा करना आवश्यक होगा और फिर प्रिंटिंग फ़ंक्शन को कॉल करें h()।

कोड 

unsigned int W,H,S,n,k,t,r[1<<22],p,q[64];
long long int i,c,C;


//output: ascii 45 - for 0, ascii 45+79=124 | for 1
h(){int a;
  for(a=n;a--;a%W||puts(""))putchar(45+(q[a/W]>>a%W)%2*79);
  puts("");
}

g(y,d,x){int j;
  for(j=0;j<p;j++)if((x&r[j])==x){
    q[y]=r[j];
    if(y%(H-1)==0){
       (x^r[j])==0?
        y?c++,S||g(H/2-1,-1,i):h() 
       :0;
    }else{
      g(y+d,d,x^r[j]);
    }

  }    
}

e(z){int d;
  for(d=0;z;d++)z&=z-1;return n/2+1+d&1; 
}

f(){
  //k=a row full of 1's
  k=(1ULL<<W)-1;

  //build table of possible arrangements of horizontal dominoes in a row;
  //flip bits so that 1=a vertical domino and save to r[]
  for(i=0;i<=k;i++)(i/3|i/3<<1)==i?r[p++]=i^k:0;

  //for each arrangement of vertical dominoes on the centreline, call g()
  for(i=0;i<=k;i++)e(i)?c=0,g(H/2,1,i),C+=c*c:0;
  printf("%llu",C);
}


main(int argc, char* argv[]) {
  W = atoi(argv[1]); H = atoi(argv[2]); S = (argc > 3);
  1-(n=W*H)%2?
      H%2?W^=H,H^=W,W^=H,t=1:0,f()
    :puts("0");

}

ध्यान दें कि विषम संख्या में पंक्तियों और यहां तक ​​कि स्तंभों की संख्या के साथ इनपुट चालू चरण में 90 डिग्री है। यदि यह अस्वीकार्य है, तो h()इसे व्यवस्थित करने के लिए प्रिंटिंग फ़ंक्शन को बदला जा सकता है। (संपादित करें: आवश्यक नहीं, टिप्पणियाँ देखें।)

EDIT: एक नए फ़ंक्शन e()का उपयोग i(यानी सेंट्रीलाइन की संख्या को बढ़ाने वाले डोमिनोज़ की समता की जांच करने के लिए किया गया है ।) i(बोर्ड के आधे हिस्से में फैलने वाले सेंट्रलाइन पर आधे-डोमिनोज़ की संख्या ) की समानता समान होनी चाहिए। प्रत्येक आधे में रिक्त स्थान की कुल संख्या की विषमता (द्वारा दी गई n/2) क्योंकि केवल तभी डोमिनोज़ सभी उपलब्ध स्थान को भर सकते हैं। यह संपादन i के आधे मूल्यों को समाप्त कर देता है और इसलिए मेरे कार्यक्रम को लगभग दोगुना तेज बनाता है।

— स्तर नदी सेंट
स्रोत
निष्पादन: १ecut एमएस संकलन: ५० एमएस सम: ६ (एमएस ( -O0कुल के लिए सबसे प्यारा स्थान था। अन्य विकल्प संकलन धीमा कर देते हैं।)
— डेनिस
यह या तो समाप्त नहीं होता है, या कम से कम इनपुट के लिए बहुत लंबा समय लेता है 32 2 s। मैंने लगभग 15 मिनट के बाद इसे रोक दिया।
— रेटो कोराडी
@RetoKoradi वास्तव में, फिर भी 2 32 sलगभग तुरंत चलता है। सभी संभव ऊर्ध्वाधर डोमिनोज़ के माध्यम से स्कैनिंग H=2मामले के लिए बेहद बेकार है , क्योंकि वास्तव में हमारे पास पहले से ही सभी आवश्यक जानकारी है r[]। मैं आपके द्वारा 8 8 sबताए गए मामले के लिए एक पैच के लिए आधिकारिक समय से बहुत खुश हूं : if(H==2){C=p;if(!S)for(i=0;i<p;i++)q[0]=q[1]=r[i],h();}else for(i=0;i<=k;i++)c=0,g(H/2,1,i),C+=c*c;जैसा कि आप देख सकते हैं कि यह स्निपेट H=2 झंडे के सेट के साथ तुरंत चलेगा । समग्र रनटाइम तब बिल्डिंग द्वारा सीमित होता है r[]जिसमें निश्चित रूप से सुधार की गुंजाइश होती है।
— स्तर नदी सेंट
पूर्णता के लिए यहाँ आउटपुट को सही तरीके से चालू करने के लिए पैच है, यदि आवश्यक हो: if(t)for(a=n;a--;a%H||puts(""))putchar(124-(q[a%H]>>a/H)%2*79);else for(a=n;a--;a%W||puts(""))putchar(45+(q[a/W]>>a%W)%2*79);कोडेलट्रिक्स अभी भी 1000 बाइट्स से काफी नीचे है और संकलन समय पर प्रभाव न्यूनतम होना चाहिए। मैंने इन पैच को पिछली रात शामिल नहीं किया था क्योंकि मैं बहुत थका हुआ था।
— स्तर नदी सेंट
मेरा मतलब कल रात उस पर टिप्पणी करना था, लेकिन मैं भूल गया। चूंकि स्कोरिंग एक वर्ग पर किया जाता है, मैं किसी विशेष आदेश पर जोर नहीं दे रहा हूं।
— डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.