सी में गोल्फिंग + फास्ट छँटाई

Question

[ नवीनतम अपडेट: बेंचमार्क प्रोग्राम और प्रारंभिक रिसेल उपलब्ध, नीचे देखें]

इसलिए मैं एक क्लासिक एप्लिकेशन के साथ गति / जटिलता ट्रेडऑफ का परीक्षण करना चाहता हूं: सॉर्टिंग।

एक ANSI C फ़ंक्शन लिखें जो बढ़ते हुए क्रम में फ्लोटिंग पॉइंट संख्याओं की एक सरणी को सॉर्ट करता है ।

आप किसी भी लाइब्रेरी, सिस्टम कॉल, मल्टीथ्रेडिंग या इनलाइन ASM का उपयोग नहीं कर सकते ।

प्रविष्टियाँ दो घटकों पर आंकी जाती हैं: कोड की लंबाई और प्रदर्शन। निम्नानुसार स्कोरिंग: प्रविष्टियाँ लंबाई के आधार पर हल की जाएंगी (व्हॉट्सएप पर बिना # लॉग इन के लॉग इन करें, ताकि आप कुछ फॉर्मेटिंग रख सकें) और प्रदर्शन द्वारा (एक बेंचमार्क पर # सेकंड्स का लॉग), और प्रत्येक अंतराल [सर्वोत्तम, सबसे खराब, रैखिक रूप से सामान्यीकृत] 0,1]। एक कार्यक्रम का कुल स्कोर दो सामान्यीकृत स्कोर का औसत होगा। सबसे कम स्कोर जीतता है। प्रति उपयोगकर्ता एक प्रविष्टि।

सॉर्टिंग (अंततः) को जगह में (यानी इनपुट सरणी को वापसी के समय में सॉर्ट किए गए मानों को शामिल करना होगा) करना होगा, और आपको निम्नलिखित हस्ताक्षर का उपयोग करना होगा, जिसमें नाम शामिल हैं:

void sort(float* v, int n) {

}

गिने जाने वाले वर्ण: sortफ़ंक्शन में, हस्ताक्षर शामिल हैं, इसके अतिरिक्त बुलाए गए अतिरिक्त कार्य (लेकिन परीक्षण कोड शामिल नहीं हैं)।

कार्यक्रम को floatलंबाई के => 0, 2 ^ 20 तक के किसी भी संख्यात्मक मान को संभालना चाहिए ।

मैं प्लग sortऔर इसकी निर्भरता को एक परीक्षण कार्यक्रम में बदलूंगा और जीसीसी (कोई फैंसी विकल्प नहीं) पर संकलन करूंगा । मैं इसमें सरणियों का एक गुच्छा खिलाऊंगा, परिणामों की शुद्धता और कुल रन समय की पुष्टि करेगा। उबंटू 13. के तहत इंटेल कोर i7 740QM (क्लार्क्सफील्ड) पर टेस्ट चलाए जाएंगे।
एरियर की लंबाई शॉर्ट ऐरे के उच्च घनत्व के साथ, पूरे अनुमत सीमा पर होगी। मूल्य एक वसा-पूंछ वितरण (दोनों सकारात्मक और नकारात्मक सीमाओं में) के साथ यादृच्छिक होंगे। डुप्लिकेट किए गए तत्वों को कुछ परीक्षणों में शामिल किया जाएगा।
परीक्षण कार्यक्रम यहां उपलब्ध है: https://gist.github.com/anonymous/82386fa028f6534af263
यह सबमिशन को आयात करता है user.c। TEST_COUNTवास्तविक बेंचमार्क में परीक्षण मामलों की संख्या ( ) 3000 होगी। कृपया प्रश्न टिप्पणियों में कोई प्रतिक्रिया दें।

समय सीमा: 3 सप्ताह (7 अप्रैल 2014, 16:00 जीएमटी)। मैं 2 सप्ताह में बेंचमार्क पोस्ट करूंगा।
प्रतिस्पर्धियों को अपना कोड देने से बचने के लिए समय सीमा के करीब पोस्ट करना उचित हो सकता है।

प्रारंभिक परिणाम, बेंचमार्क प्रकाशन के रूप में:
यहाँ कुछ परिणाम हैं। अंतिम कॉलम एक प्रतिशत के रूप में स्कोर दिखाता है, जॉनी केज को पहले स्थान पर रखना बेहतर है। एल्गोरिदम जो कि बाकी की तुलना में परिमाण धीमे के आदेश थे, परीक्षणों के एक सबसेट पर चलाए गए थे, और समय अतिरिक्त था। सी की खुद qsortकी तुलना के लिए शामिल है (जॉनी तेजी से!)। मैं समापन समय पर अंतिम तुलना करूँगा।

Comments

क्या आप बेंचमार्क प्रदान कर सकते हैं? डेटा की प्रकृति के आधार पर अलग-अलग सॉर्टिंग फ़ंक्शन अलग-अलग प्रदर्शन करते हैं। एग बबल सॉर्ट छोटे सरणियों के लिए स्टडलिब क्विकॉर्ट से तेज है। हम आपके बेंचमार्क के लिए ऑप्टिमाइज़ करना पसंद कर सकते हैं।

— क्लॉडिउ

@ कैलाडु मैं एक बार क्विकॉर्ट का एक प्यारा लघु संस्करण देखा गया, जो डेटा के साथ-साथ किसी भी अन्य भाग गया जहां हर तत्व अलग था। लेकिन अगर कुछ तत्व समान थे, तो यह एक निरपेक्ष घोंघा की गति से चला। मैं छांटे गए / आंशिक रूप से हल किए गए सरणियों में धुरी के खराब विकल्प के ज्ञात मुद्दे के बारे में बात नहीं कर रहा हूं। मेरा परीक्षण डेटा पूरी तरह से बेतरतीब ढंग से बदल दिया गया था। यह विशेष संस्करण अभी डुप्लिकेट की तरह नहीं था। अजीब, लेकिन सच है।

— लेवल रिवर सेंट

PPCG में आपका स्वागत है! यद्यपि हम भाषा-विशिष्ट चुनौतियों का निषेध नहीं करते हैं, हम जब भी संभव हो भाषा-अज्ञेय तरीके से प्रश्नों को तैयार करने के लिए दृढ़ता से प्रोत्साहित करते हैं। अपने अगले प्रश्न के लिए इस पर विचार करें, और इस एक के साथ मज़े करें!

— जोनाथन वान मैट्रे

@steveverrill: मैं अनुसरण नहीं करता। इससे कोई फर्क नहीं पड़ता कि आपकी इकाई क्या है क्योंकि आप इसे 0 से 1 तक किसी भी तरह से मापते हैं। यदि मिनट 1 घंटा है और अधिकतम 3 घंटे है, तो 1.5 घंटे लगने वाली चीज़ 0.25 होगी चाहे मिनट 60 मिनट हो, अधिकतम 180 मिनट है, और इसमें 90 मिनट लगते हैं

— क्लाउडी

ओपी ने केवल इनलाइन असेंबली के बारे में कहा - उन्होंने आंतरिक विषयों के बारे में कुछ नहीं कहा।

— पॉल आर

Answer 1

150 वर्ण

जल्दी से सुलझाएं।

/* 146 character.
 * sizeup 1.000; speedup 1.000; */
#define REC_SIZE    \
    sort(l, v+n-l); \
    n = l-v;

/* 150 character.
 * sizeup 1.027; speedup 1.038; */
#define REC_FAST  \
    sort(v, l-v); \
    n = v+n-l;    \
    v = l;

void sort(float* v, int n)
{
    while ( n > 1 )
     {
       float* l = v-1, * r = v+n, x = v[n/2], t;
L:
       while ( *++l < x );
       while ( x < (t = *--r) );

       if (l < r)
        {
          *r = *l; *l = t;
          goto L;
        }
       REC_FAST
     }
}

दबा हुआ।

void sort(float* v, int n) {
while(n>1){float*l=v-1,*r=v+n,x=v[n/2],t;L:while(*++l<x);while(x<(t=*--r));if(l<r){*r=*l;*l=t;goto L;}sort(v,l-v);n=v+n-l;v=l;}
}

Comments

दौड़ में अग्रणी!

— मऊ

Answer 2

150 आकर्षण (बिना व्हाट्सएप)

void sort(float *v, int n) {
    int l=0;
    float t, *w=v, *z=v+(n-1)/2;

    if (n>0) {
      t=*v; *v=*z; *z=t;
      for(;++w<v+n;)
        if(*w<*v)
        {
          t=v[++l]; v[l]=*w; *w=t;
        }
      t=*v; *v=v[l]; v[l]=t;
      sort(v, l++);
      sort(v+l, n-l);
    }
}

Comments

बहुत बढ़िया, पहली प्रविष्टि!

— मऊ

SSE के साथ उत्तर देने के लिए स्वतंत्र महसूस करें और मैं इसे स्कोरबोर्ड में सूचीबद्ध करूंगा, हालांकि मैं चुनौती के लिए 'पोर्टेबल' समाधानों में रुचि रखता हूं।

— मऊ

if(*w<*v) { t=v[++l]; v[l]=*w; *w=t; }हो सकता हैif(*w<*v) t=v[++l], v[l]=*w, *w=t;

— ASKASK

Answer 3

67 70 69 चरस

उपवास बिल्कुल नहीं, लेकिन अविश्वसनीय रूप से छोटा है। मुझे लगता है कि यह एक चयन प्रकार और बुलबुला सॉर्ट एल्गोरिथ्म के बीच एक संकर है। यदि आप वास्तव में इसे पढ़ने की कोशिश कर रहे हैं, तो आपको पता होना चाहिए कि ++i-v-nजैसा है वैसा ही है ++i != v+n।

void sort(float*v,int n){
    while(n--){
        float*i=v-1,t;
        while(++i-v-n)
            *i>v[n]?t=*i,*i=v[n],v[n]=t:0;
    }
}

Comments

if(a)b-> a?b:0एक चार बचाता है।

— २en

ठीक है, ++i-v-nके रूप में ही है ++i != v+nकेवल पाठ्यक्रम के एक सशर्त, में।

— व्रजीन

@ यूगोरेन मुझे लगता है कि आपने उस टिप्पणी को गलत उत्तर पर पोस्ट किया है

— ASKASK

@ASKASK, if(*i>v[n])...->*i>v[n]?...:0

— बदसूरत

क्या आप सुनिश्चित हैं कि उपस्थिति कैसे काम करती है?

— ASKASK

Answer 4

123 वर्ण (+3 नए अंक)

एक मानक शैल सॉर्ट, संपीड़ित।

d,i,j;float t;
void sort(float*v,int n){
for(d=1<<20;i=d/=2;)for(;i<n;v[j]=t)for(t=v[j=i++];j>=d&&v[j-d]>t;j-=d)v[j]=v[j-d];
}  

पुनश्च: पता चला कि यह अभी भी क्विकॉर्ट की तुलना में 10 गुना धीमा है। आप इस प्रविष्टि को अनदेखा कर सकते हैं।

Comments

अंतराल का आपका विकल्प बेहतर हो सकता है। Thats शायद क्यों यह quicksort की तुलना में बहुत धीमी है। en.wikipedia.org/wiki/Shellsort#Gap_fterences

— FDinoff

मुझे यह जानकर आश्चर्य हुआ कि अंतर अनुक्रम गति को कितना प्रभावित करता है। एक अच्छे अनुक्रम के साथ यह क्विकसॉर्ट के करीब आता है, लेकिन मेरे अनुभव में धीमा है।

— फ्लोरियन एफ

अपने आप पर बहुत मुश्किल मत बनो। आप तीसरे स्थान पर हैं।

— केविन

Answer 5

395 वर्ण

मर्ज़ सॉर्ट।

void sort(float* v,int n){static float t[16384];float*l,*r,*p,*q,*a=v,*b=v+n/2,
*c=v+n,x;if(n>1){sort(v,n/2);sort(v+n/2,n-n/2);while(a!=b&&b!=c)if(b-a<=c-b&&b-
a<=16384){for(p=t,q=a;q!=b;)*p++=*q++;for(p=t,q=t+(b-a);p!=q&&b!=c;)*a++=(*p<=
*b)?*p++:*b++;while(p!=q)*a++=*p++;}else{for(l=a,r=b,p=t,q=t+16384;l!=b&&r!=c&&
p!=q;)*p++=(*l<=*r)?*l++:*r++;for(q=b,b=r;l!=q;)*--r=*--q;for(q=t;p!=q;)*a++=
*q++;}}}

प्रारूपित।

static float* copy(const float* a, const float* b, float* out)
{   while ( a != b ) *out++ = *a++; return out;
}
static float* copy_backward(const float* a, const float* b, float* out)
{   while ( a != b ) *--out = *--b; return out;
}

static void ip_merge(float* a, float* b, float* c)
{
    /* 64K (the more memory, the better this performs). */
#define BSIZE (1024*64/sizeof(float))
    static float t[BSIZE];

    while ( a != b && b != c )
     {
       int n1 = b - a;
       int n2 = c - b;

       if (n1 <= n2 && n1 <= BSIZE)
        {
          float* p = t, * q = t + n1;
          /* copy [a,b] sequence. */
          copy(a, b, t);
          /* merge. */
          while ( p != q && b != c )
             *a++ = (*p <= *b) ? *p++ : *b++;
          /* copy remaining. */
          a = copy(p, q, a);
        }
       /* backward merge omitted. */
       else
        {
          /* there are slicker ways to do this; all require more support
           * code. */
          float* l = a, * r = b, * p = t, * q = t + BSIZE;
          /* merge until sequence end or buffer end is reached. */
          while ( l != b  && r != c && p != q )
             *p++ = (*l <= *r) ? *l++ : *r++;
          /* compact remaining. */
          copy_backward(l, b, r);
          /* copy buffer. */
          a = copy(t, p, a);
          b = r;
        }
     }
}

void sort(float* v, int n)
{
    if (n > 1)
     {
       int h = n/2;
       sort(v, h); sort(v+h, n-h); ip_merge(v, v+h, v+n);
     }
}

Answer 6

331 326 327 312 चर

क्या मूलांक एक बार में 8 बिट्स को सॉर्ट करता है। सही ढंग से सॉर्ट करने के लिए ( http://stereopsis.com/radix.html से चोरी ) नकारात्मक फ़्लैट पाने के लिए एक फैंसी बिटकॉइन का उपयोग करता है । यह उस कॉम्पैक्ट नहीं है, लेकिन यह वास्तव में तेज है (~ सबसे तेज प्रारंभिक प्रविष्टि की तुलना में 8 गुना तेज)। मुझे उम्मीद है कि स्पीड ट्रम्पिंग कोड साइज़ ...

#define I for(i=n-1;i>=0;i--)
#define J for(i=0;i<256;i++)
#define R for(r=0;r<4;r++)
#define F(p,q,k) I p[--c[k][q[i]>>8*k&255]]=q[i]

void sort(float *a, int n) {
  int *A = a,i,r,x,c[4][257],B[1<<20];
  R J c[r][i]=0;
  I {
    x=A[i]^=A[i]>>31|1<<31;
    R c[r][x>>8*r&255]++;
  }
  J R c[r][i+1]+=c[r][i];

  F(B,A,0);
  F(A,B,1);
  F(B,A,2);
  F(A,B,3)^(~B[i]>>31|1<<31);
}

Answer 7

५११ ४२४ वर्ण

Inplace radixsort

अद्यतन: छोटे सरणी आकार के लिए प्रविष्टि प्रकार पर स्विच (4.0 के कारक द्वारा मानदंड प्रदर्शन बढ़ाता है)।

#define H p[(x^(x>>31|1<<31))>>s&255]
#define L(m) for(i=0;i<m;i++)
void R(int*a,int n,int s){if(n<64){float*i,*j,x;for(i=a+1;i<a+n;i++){x=*i;for(
j=i;a<j&&x<j[-1];j--)*j=j[-1];*j=x;}}else{int p[513]={},*q=p+257,z=255,i,j,x,t
;L(n)x=a[i],H++;L(256)p[i+1]+=q[i]=p[i];for(z=255;(i=p[z]-1)>=0;){x=a[i];while
((j=--H)!=i)t=x,x=a[j],a[j]=t;a[i]=x;while(q[z-1]==p[z])z--;}if(s)L(256)R(a+p[
i],q[i]-p[i],s-8);}}void sort(float* v,int n){R(v,n,24);}

प्रारूपित।

/* XXX, BITS is a power of two. */
#define BITS 8
#define BINS (1U << BITS)
#define TINY 64

#define SWAP(type, a, b) \
    do { type t=(a);(a)=(b);(b)=t; } while (0)

static inline unsigned int floatbit_to_sortable_(const unsigned int x)
{   return x ^ ((0 - (x >> 31)) | 0x80000000);
}

static inline unsigned int sortable_to_floatbit_(const unsigned int x)
{   return x ^ (((x >> 31) - 1) | 0x80000000);
}

static void insertsort_(unsigned int* a, unsigned int* last)
{
    unsigned int* i;
    for ( i = a+1; i < last; i++ )
     {
       unsigned int* j, x = *i;
       for ( j = i; a < j && x < *(j-1); j-- )
          *j = *(j-1);
       *j = x;
     }
}

static void radixsort_lower_(unsigned int* a, const unsigned int size,
  const unsigned int shift)
{
    /* @note setup cost can be prohibitive for smaller arrays, switch to
     * something that performs better in these cases. */
    if (size < TINY)
     {
       insertsort_(a, a+size);
       return;
     }

    unsigned int h0[BINS*2+1] = {}, * h1 = h0+BINS+1;
    unsigned int i, next;

    /* generate histogram. */
    for ( i = 0; i < size; i++ )
       h0[(a[i] >> shift) % BINS]++;

    /* unsigned distribution.
     * @note h0[BINS] == h1[-1] == @p size; sentinal for bin advance. */
    for ( i = 0; i < BINS; i++ )
       h0[i+1] += (h1[i] = h0[i]);

    next = BINS-1;
    while ( (i = h0[next]-1) != (unsigned int) -1 )
     {
       unsigned int x = a[i];
       unsigned int j;
       while ( (j = --h0[(x >> shift) % BINS]) != i )
          SWAP(unsigned int, x, a[j]);
       a[i] = x;
       /* advance bins.
        * @note skip full bins (zero sized bins are full by default). */
       while ( h1[(int) next-1] == h0[next] )
          next--;
     }

    /* @note bins are sorted relative to one another at this point but
     * are not sorted internally. recurse on each bin using successive
     * radii as ordering criteria. */
    if (shift != 0)
       for ( i = 0; i < BINS; i++ )
          radixsort_lower_(a + h0[i], h1[i] - h0[i], shift-BITS);
}

void sort(float* v, int n)
{
    unsigned int* a = (unsigned int*) v;
    int i;

    for ( i = 0; i < n; i++ )
       a[i] = floatbit_to_sortable_(a[i]);

    radixsort_lower_(a, n, sizeof(int)*8-BITS);

    for ( i = 0; i < n; i++ )
       a[i] = sortable_to_floatbit_(a[i]);
}

Comments

अच्छा! मूल उत्तर को फ़्लैग करने का प्रयास करें।

— मऊ

@ मऊ: धन्यवाद और करेंगे। बेंचमार्किंग कोड में एक त्रुटि का उल्लेख करना चाहता था। (लाइन 88) void*में डाली qsortसूचक अंकगणित को फेंक रही है।

— MojoJojoBojoHojo

Answer 8

121 114 111 वर्ण

बस एक त्वरित और गंदा बुलबुले, पुनरावृत्ति के साथ। शायद बहुत कुशल नहीं है।

void sort(float*v,int n){int i=1;float t;for(;i<n;i++)v[i-1]>(t=v[i])&&(v[i]=v[i-1],v[i-1]=t);n--?sort(v,n):0;}

या, लंबा संस्करण

void sort(float* values, int n) {
  int i=1;  // Start at 1, because we check v[i] vs v[i-1]
  float temp;
  for(; i < n; i++) {
    // If v[i-1] > v[i] is true (!= 0), then swap.
    // Note I am assigning values[i] to temp here. Below I want to use commas
    // so the whole thing fits into one statement, but if you assign temp there you will get sequencing issues (i.e unpredictable swap results)
    values[i - 1] > (temp = values[i]) && (
    // I tried the x=x+y,y=x-y,x=x-y trick, but using a temp
    // turns out to be shorter even if we have to declare the t variable.
      values[i] = values[i - 1], 
      values[i - 1] = temp);
  }

  // If n == 1, we are done. Otherwise, sort the first n - 1 elements recursively. 
  // The 0 is just because the third statement cannot be empty.
  n-- ? sort(values, n) : 0;
}

Comments

एक तरफ के रूप में, मुझे वास्तव में एक दिलचस्प एल्गोरिथ्म यहां मिला: rosettacode.org/wiki/Sorting_algorithms/Pancake_sort#C, लेकिन मैं इसे 114 में हरा पाने के लिए पर्याप्त रूप से संपीड़ित नहीं कर सकता हूं:

— CompuChip

आपका कार्यक्रम कुछ मामलों में पूरा होने और अन्य मामलों में सीमा से बाहर लिखने में विफल लगता है।

— मऊ

@ मऊ मैंने इसे कुछ इनपुटों पर मैन्युअल रूप से परीक्षण किया और ठीक काम करने के लिए लग रहा था, लेकिन समय की कमी के कारण मैंने इसे पूरी तरह से परीक्षण नहीं किया, इसलिए मुझे यकीन है कि कहीं न कहीं कुछ बुरा व्यवहार है। क्या आप एक परीक्षण मामला पोस्ट कर सकते हैं जहाँ आप कृपया भाग गए?

— कंपूचिप

परीक्षण कार्यक्रम ऊपर उपलब्ध :)

— मऊ

हम्म मैंने इसे चलाने की कोशिश की, मुझे क्लीनअप भाग में कुछ 'munmap_chunk (): अमान्य पॉइंटर' त्रुटियां मिल रही हैं, लेकिन परीक्षण विफल होने के बारे में कुछ भी नहीं। हालाँकि आप सही कह रहे हैं कि एक-के-बाद-एक त्रुटि है, और मुझे कुछ सीक्वेंसिंग समस्याएं हैं (बयानों की अल्पविराम से अलग की गई सूची वह नहीं करती है जो मैं उससे उम्मीद करता हूं)। मैं इसे ठीक करने की कोशिश करूंगा।

— कॉम्पिटिशन

Answer 9

221 193 172 वर्ण

हीप्सोर्ट - सबसे छोटा नहीं है, लेकिन जगह और ओ (एन * लॉग (एन)) व्यवहार की गारंटी देता है।

static void sink(float* a, int i, int n, float t)
{
    float* b = a+i;

    for ( ; (i = i*2+2) <= n; b = a+i )
     {
       i -= (i == n || a[i] < a[i-1]) ? 1 : 0;

       if (t < a[i])
          *b = a[i];
       else
          break;
     }
    *b = t;
}

void sort(float* a, int n)
{
    int i;
    /* make. */
    for ( i = n/2-1; i >= 0; i-- )
       sink(a, i, n, a[i]);
    /* sort. */
    for ( i = n-1; i > 0; i-- )
     {
       float t = a[i]; a[i] = a[0];
       sink(a, 0, i, t);
     }
}

दबा हुआ।

void sort(float* a,int n){
#define F(p,q,r,x,y) for(i=n/p;q>0;){t=a[i];r;for(j=x;(b=a+j,j=j*2+2)<=y&&(j-=(j==y||a[j]<a[j-1]),t<a[j]);*b=a[j]);*b=t;}
float*b,t;int i,j;F(2,i--,,i,n)F(1,--i,a[i]=*a,0,i)
}

Comments

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

— जोनाथन वान मैट्रे

@ user19425: यदि आप परीक्षण कार्यक्रम को TEST_COUNT= 3000 के साथ चलाते हैं , तो यह कम से कम एक परीक्षा में विफल होता है।

— मऊ

Answer 10

154 166 वर्ण

ठीक है, यहाँ एक लंबी लेकिन तेज़ गति है।

void sort(float*v,int n){while(n>1){float*j=v,*k=v+n-1,t=*j;while(j<k){while(j<k&&*k>=t)k--;*j=*k;while(j<k&&*j<t)j++;*k=*j;}*k++=t;sort(k,v+n-k);n=j-v;}}

यहां सॉर्ट किए गए इनपुट को जीवित रखने के लिए एक सुधार है। और स्वरूपित चूंकि सफेद स्थान की गिनती नहीं है।

void sort(float*v, int n){
    while(n>1){
        float*j=v, *k=j+n/2, t=*k;
        *k = *j;
        k = v+n-1;
        while(j<k){
            while(j<k && *k>=t) k--;
            *j=*k;
            while(j<k && *j<t) j++;
            *k=*j;
        }
        *k++ = t;
        sort(k,v+n-k);
        n = j-v;
    }
}

Comments

यह संस्करण कुछ मामलों में सीमा से बाहर लिखने के लिए लगता है, दूसरों में समाप्त नहीं होता है।

— मऊ

पुनश्च: ठीक है, यह एक हल सेट पर बहुत धीमा है। लेकिन समस्या कथन में कहा गया है कि इनपुट यादृच्छिक है।

— फ्लोरियन एफ

मान यादृच्छिक हैं। मैंने कभी भी इस बारे में कुछ नहीं कहा कि वे किस क्रम में होंगे :-) लेकिन हां, आरोही क्रम में क्रमबद्ध किए गए सभी मानों का लगभग 10% और अवरोही क्रम में एक और 10% कवर हैं।

— मऊ

काफी उचित। और एक सॉर्ट () सॉर्ट किए गए इनपुट पर काम करना चाहिए। मैं अपना सबमिशन अपडेट करूंगा, फिर ...

— फ्लोरियन एफ

Answer 11

150 वर्ण

शेल्सॉर्ट (w / नथ गैप)।

void sort(float* v, int n) {
float*p,x;int i,h=0;while(2*(i=h*3+1)<=n)h=i;for(;h>0;h/=3)for(i=h;i<n;i++){x=v[i];for(p=v+i-h;p>=v&&x<*p;p-=h)p[h]=*p;p[h]=x;}
}

प्रारूपित।

static void hsort(float* v, const int h, const int n)
{
    int i;
    for (i = h; i < n; i++) {
        float* p, x = v[i];
        for (p = v + i-h; p >= v && x < *p; p -= h)
            p[h] = *p;
        p[h] = x;
    }
}

void sort(float* v, int n)
{
    int i, h = 0;
    while (2*(i = h*3+1) <= n)
        h = i;
    for (; h > 0; h /= 3)
        hsort(v, h, n);
}

Answer 12

सी 270 (गोल्फ)

#define N 1048576
void sort(float*v,int n)
{
float f[N],g;
int m[N],i,j,k,x;
g=v[0];k=0;
for(i=0;i<n;i++){for(j=0;j<n;j++){if(m[j]==1)continue;if(v[j]<g){g=v[j];k=j;}}f[i]=g;m[k]=1;for(x=0;x<n;x++){if(m[x]==0){g=v[x];k=x;break;}}}
for(i=0;i<n;i++){v[i]=f[i];}
}

स्पष्टीकरण: प्रत्येक क्रमिक न्यूनतम संख्या को संग्रहीत करने के लिए एक रिक्त सरणी का उपयोग किया जाता है। एक इंट सरणी 0 वाला मास्क है जिसमें यह संकेत दिया गया है कि संख्या अभी तक कॉपी नहीं की गई है। न्यूनतम मूल्य प्राप्त करने के बाद एक मुखौटा = 1 स्किप पहले से ही उपयोग किए गए नंबर। फिर सरणी को मूल में कॉपी किया जाता है।

मैंने लाइब्रेरी फ़ंक्शंस के उपयोग को समाप्त करने के लिए कोड बदल दिया।

Answer 13

144

मैंने बेशर्मी से जॉनी का कोड ले लिया, एक छोटा अनुकूलन जोड़ा और बहुत ही गंदे तरीके से कोड को संपीड़ित किया। यह छोटा और तेज होना चाहिए।

ध्यान दें कि आपके संकलक के आधार पर, सॉर्ट (q, v + n- ++ q) को सॉर्ट (++ q, v +q) द्वारा प्रतिस्थापित किया जाना चाहिए।

#define w ;while(
void sort(float*v, int n){
    w n>1){
        float *p=v-1, *q=v+n, x=v[n/2], t
        w p<q){
            w *++p<x )
            w *--q>x );
            if( p<q ) t=*p, *p=*q, *q=t;
        }
        sort(q,v+n- ++q);
        n = p-v;
    }
}

खैर, वास्तव में, मैंने अपना कोड बनाया और इसे अनुकूलित किया, लेकिन ऐसा लगता है कि जॉनी ने पहले ही सभी सही विकल्प बना लिए हैं। तो मैं अपने कोड के साथ अर्ध समाप्त कर दिया। मुझे गोटो ट्रिक के बारे में नहीं सोचा था, लेकिन मैं इसके बिना कर सकता था।

Answer 14

228 वर्ण

Radixsort।

void sort(float* v, int n) {
#define A(x,y,z) for(x=y;x<z;x++)
#define B h[(a[i]^(a[i]>>31|1<<31))>>j*8&255]
    int m[1<<20],*a=v,*b=m,*t,i,j;
    A(j,0,4) {
        int h[256] = {};
        A(i,0,n) B++;
        A(i,1,256) h[i] += h[i-1];
        for (i = n-1; i >= 0; i--)
            b[--B] = a[i];
        t = a, a = b, b = t;
    }
}