গল্ফড + সিতে দ্রুত বাছাই করা

Question

[ সর্বশেষ আপডেট: বেঞ্চমার্ক প্রোগ্রাম এবং প্রাথমিক ফলাফলগুলি উপলব্ধ, নীচে দেখুন]

সুতরাং আমি একটি ক্লাসিক অ্যাপ্লিকেশন: বাছাই সহ গতি / জটিলতা ট্রেড অফ পরীক্ষা করতে চাই।

একটি এএনএসআই সি ফাংশন লিখুন যা ক্রমবর্ধমান ক্রমে ভাসমান পয়েন্ট সংখ্যাগুলির অ্যারে সাজায় ।

আপনি কোনও লাইব্রেরি, সিস্টেম কল, মাল্টিথ্রেডিং বা ইনলাইন এএসএম ব্যবহার করতে পারবেন না ।

কোডের দৈর্ঘ্য এবং কার্য সম্পাদন : দুটি উপাদান বিবেচনা করে এন্ট্রি বিচার করা হয় । স্কোরিং নিম্নরূপ: এন্ট্রিগুলি দৈর্ঘ্য অনুসারে বাছাই করা হবে (হোয়াইটস্পেস ছাড়াই # চ্যারিটারের লগ, যাতে আপনি কিছু ফর্ম্যাটিং রাখতে পারেন) এবং পারফরম্যান্স দ্বারা (একটি মানদণ্ডের উপর # সেকেন্ডের লগ), এবং প্রতিটি বিরতি [সেরা, সবচেয়ে খারাপ] রৈখিকভাবে স্বাভাবিক করা [ 0,1]। একটি প্রোগ্রামের মোট স্কোর দুইটি স্বাভাবিক করা স্কোরের গড় হবে। সর্বনিম্ন স্কোর জয়। ব্যবহারকারী প্রতি এক এন্ট্রি।

বাছাই করতে হবে (শেষ পর্যন্ত) স্থানে থাকতে হবে (অর্থাত ইনপুট অ্যারেটি রিটার্নের সময় সাজানো মান থাকতে হবে) এবং আপনাকে অবশ্যই নাম সহ নিম্নলিখিত স্বাক্ষরটি ব্যবহার করতে হবে:

void sort(float* v, int n) {

}

অক্ষর গণনা করতে হবে: sortফাংশনে যারা রয়েছে, স্বাক্ষর অন্তর্ভুক্ত রয়েছে, এবং এটি দ্বারা ডাকা অতিরিক্ত ফাংশন (তবে পরীক্ষার কোডটি সহ নয়)।

প্রোগ্রামটি অবশ্যই floatদৈর্ঘ্যের যেকোন সংখ্যার মান এবং অ্যারে>> ০ 0, 2 ^ 20 অবধি পরিচালনা করতে হবে।

আমি sortএকটি পরীক্ষামূলক প্রোগ্রামে প্লাগ এবং তার নির্ভরতাগুলি প্লাগ করব এবং জিসিসিতে সংকলন করব (অভিনব বিকল্প নেই)। আমি এতে একগুচ্ছ অ্যারে ফিড করব, ফলাফলগুলির সঠিকতা এবং মোট রানের সময় যাচাই করব। উবুন্টু ১৩ এর অধীনে একটি ইন্টেল কোর আই 7740 কিমি (ক্লার্কসফিল্ড) এ টেস্টগুলি চালানো হবে
short মানগুলি এলোমেলোভাবে হবে, চর্বি-লেজ বিতরণ সহ (ধনাত্মক এবং নেতিবাচক উভয় সীমার মধ্যে)। সদৃশ উপাদানগুলিকে কিছু পরীক্ষায় অন্তর্ভুক্ত করা হবে।
পরীক্ষা প্রোগ্রামটি এখানে উপলভ্য: https://gist.github.com/anonymous/82386fa028f6534af263
এটি জমা হিসাবে আমদানি করে user.c। TEST_COUNTপ্রকৃত বেঞ্চমার্কে পরীক্ষার কেসগুলির সংখ্যা ( 3000) হবে Please প্রশ্ন মন্তব্যে কোনও প্রতিক্রিয়া জানান দয়া করে।

সময়সীমা: 3 সপ্তাহ (7 এপ্রিল 2014, 16:00 GMT) আমি 2 সপ্তাহের মধ্যে মাপদণ্ডটি পোস্ট করব।
প্রতিযোগীদের আপনার কোড না দেওয়ার জন্য সময়সীমার কাছাকাছি পোস্ট করা ভাল advis

প্রাথমিক ফলাফল, মাপদণ্ডের প্রকাশনা হিসাবে:
এখানে কিছু ফলাফল রয়েছে। শেষ কলামটি শতাংশ হিসাবে স্কোর দেখায়, জনি কেজকে প্রথম স্থানে রাখলে তত উন্নত। অ্যালগোরিদমগুলি যা বিশদের চেয়ে ধীরে ধীরে মাত্রার অর্ডার ছিল পরীক্ষার একটি উপসেটে চালিত হয়েছিল এবং সময় এক্সট্রাপোলেটেড ছিল। সি এর নিজস্ব qsortতুলনা করার জন্য অন্তর্ভুক্ত করা হয়েছে (জনি দ্রুত!)। সমাপ্তির সময় আমি একটি চূড়ান্ত তুলনা সম্পাদন করব।

Comments

আপনি কি মানদণ্ড সরবরাহ করতে পারেন? ডেটার প্রকৃতির উপর ভিত্তি করে বিভিন্ন বাছাই করা ফাংশন ভিন্নভাবে সম্পাদন করে। উদাহরণস্বরূপ বুদ্বুদ বাছাই ছোট অ্যারেগুলির জন্য stdlib কুইকোর্টের চেয়ে দ্রুত। আমরা আপনার মানদণ্ডের জন্য অনুকূলিত করতে চাই।

— ক্লদিউ

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

— স্তর নদী সেন্ট

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

— জোনাথন ভ্যান মাত্রে

@ স্টেভেভারল: আমি অনুসরণ করি না আপনার ইউনিট কী তা বিবেচ্য নয় কারণ আপনি যাইহোক এটি 0 থেকে 1 পর্যন্ত স্কেল করেন। যদি মিনিট 1 ঘন্টা হয় এবং সর্বোচ্চ 3 ঘন্টা হয় তবে 1.5 মিনিট সময় লাগে এমন কিছু হবে 0.2 মিনিট নির্বিশেষে মিনিট 60 মিনিট, সর্বাধিক 180 মিনিট, এবং এটি 90 মিনিট সময় নেয়

— ক্লদিউ

ওপি কেবল কোনও ইনলাইন অ্যাসেমব্লিকেই বলেনি - তিনি অন্তর্মুখী সম্পর্কে কিছু বলেননি।

— পল আর

Answer 1

150 চরিত্র

Quicksort।

/* 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

১৫০ টি চর (সাদা জায়গা ছাড়াই)

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

দুর্দান্ত, প্রথম এন্ট্রি!

— মাউ

এসএসইতে একটি উত্তর পোস্ট করতে নির্দ্বিধায় এবং আমি এটিকে স্কোরবোর্ডে তালিকাবদ্ধ করব, যদিও আমি চ্যালেঞ্জের জন্য 'পোর্টেবল' সমাধানগুলিতে আগ্রহী।

— মাউ

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 অক্ষর

মোটেও দ্রুত নয়, তবে অবিশ্বাস্যভাবে ছোট। এটি একটি সিলেক্ট সাজ্ট এবং বুদ্বুদ সাজানোর অ্যালগরিদমের মধ্যে আমার একটি হাইব্রিড gu আপনি যদি সত্যিই এটি পড়ার চেষ্টা করছেন তবে আপনার জানা উচিত যে ++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একটি চর সংরক্ষণ করে।

— ugoren

ওয়েল, ++i-v-nহিসাবে একই ++i != v+nশুধুমাত্র অবশ্যই একটি শর্তাধীন, মধ্যে।

— wchargin

@ ইউগোরেন আমার মনে হয় আপনি সেই মন্তব্যটি ভুল উত্তরের উপর পোস্ট করেছেন

— ASKASK

@ এএসএএসএএসকে, if(*i>v[n])...->*i>v[n]?...:0

— উগোরেন

আপনি কি নিশ্চিত যে প্রেসিডেন্সটি কীভাবে কাজ করে?

— জিজ্ঞাসা

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];
}  

পিএস: আবিষ্কার করেছে এটি এখনও চিকুইসোর্টের চেয়ে 10x ধীর। আপনি পাশাপাশি এই এন্ট্রি উপেক্ষা করতে পারেন।

Comments

আপনার ব্যবধানের পছন্দটি আরও ভাল হতে পারে। সম্ভবত এটি কেন চিকুইসোর্টের চেয়ে অনেক ধীর। en.wikipedia.org/wiki/Shellsort#Gap_sequences

— FDinoff

ফাঁক সিকোয়েন্সটি গতিকে কতটা প্রভাবিত করে তা জানতে পেরে আমি অবাক হয়ে গেলাম। একটি ভাল ক্রম সহ এটি কুইকোর্টের কাছাকাছি আসে তবে আমার অভিজ্ঞতায় ধীর থাকে।

— ফ্লোরিয়ান এফ

নিজেকে নিয়ে খুব কষ্ট করবেন না। আপনি তৃতীয় স্থানে রয়েছেন।

— কেভিন 20

Answer 5

395 চরিত্র

Mergesort।

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 অক্ষর

Radix একবারে 8 বিট বাছাই করে? সঠিকভাবে সাজানোর জন্য নেতিবাচক ফ্লোটগুলি পাওয়ার জন্য অভিনব বিটহ্যাক ব্যবহার করুন ( http://stereopsis.com/radix.html থেকে চুরি হয়েছে )। এটি যে কমপ্যাক্ট নয়, তবে এটি সত্যিই দ্রুত (দ্রুততম প্রিলিমেন্ট প্রবেশের চেয়ে 8x ডলার দ্রুত)। আমি গতি ট্রিমিং কোড আকারের জন্য আশা করছি ...

#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

511 424 চরিত্র

ইনডিস রেডিক্সসোর্ট

আপডেট: ছোট অ্যারে মাপের জন্য সন্নিবেশ সাজানোর দিকে স্যুইচ করে (৪.০ এর একটি ফ্যাক্টর দ্বারা বেঞ্চমার্কের কার্যকারিতা বাড়ায়)।

#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

নিস! মূল উত্তরটি পতাকাঙ্কিত করার চেষ্টা করুন।

— মাউ

@ মাউ: ধন্যবাদ এবং করব। বেঞ্চমার্কিং কোডটিতে একটি ত্রুটি উল্লেখ করতে চেয়েছিলেন। কাস্ট টু void*ইন qsort(লাইন 88) পয়েন্টার গাণিতিকটি ছুঁড়ে দিচ্ছে।

— MojoJojoBojoHojo 31'14

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 এর কাছে যথেষ্ট সংকোচিত করতে পারি না :)

— কমপুশিপ

আপনার প্রোগ্রামটি কিছু ক্ষেত্রে সম্পূর্ণ হতে ব্যর্থ হয়েছে এবং অন্যান্য ক্ষেত্রে সীমা ছাড়িয়ে লিখতে ব্যর্থ বলে মনে হচ্ছে।

— মাউ

@ মাউ আমি এটিকে কিছু ইনপুটটিতে ম্যানুয়ালি পরীক্ষা করে দেখেছি এবং ঠিকঠাক কাজ করেছে বলে মনে হয়েছিল, তবে সময় না পাওয়ার কারণে আমি খুব তীব্রভাবে এটি পরীক্ষা করিনি তাই আমি নিশ্চিত যে কোথাও কোনও খারাপ আচরণ আছে। আপনি কি এমন কোনও পরীক্ষার মামলা পোস্ট করতে পারেন যেখানে আপনি সমস্যার মধ্যে পড়েছেন?

— কমপিউশিপ

পরীক্ষার প্রোগ্রাম উপরে উপলব্ধ :)

— মাউ

হুম আমি এটি চালানোর চেষ্টা করেছি, আমি কিছু un মুনম্যাপ_চঙ্ক () পেয়ে যাচ্ছি: ক্লিনআপ অংশে অবৈধ পয়েন্টার `ত্রুটি, তবে পরীক্ষায় ব্যর্থ হওয়া সম্পর্কে কিছুই নেই। তবে আপনি ঠিক বলেছেন যে এখানে অফ-ওয়ান ত্রুটি রয়েছে এবং আমার মনে হচ্ছে কিছু সিকোয়েন্সিংয়ের সমস্যা রয়েছে (কমা-বিচ্ছিন্ন বিবৃতিগুলির তালিকাটি আমি যা আশা করি তা তা করে না)। আমি এটি ঠিক করার চেষ্টা করব।

— কমপিউশিপ

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

আপনি সাদা স্থানটি কেটে কিছু অক্ষর সংরক্ষণ করতে পারেন save এবং সম্ভবত বাধ্যতামূলক ফাংশনের স্বাক্ষরও রয়েছে, তবে যেহেতু এমন কয়েকটি এন্ট্রি রয়েছে যা গণনা করা হয়েছে যে আমি প্রশ্নকর্তাকে এটি গণনা করা উচিত কিনা তা পরিষ্কার করতে বলেছি।

— জোনাথন ভ্যান মাত্রে

@ ব্যবহারকারী19425: আপনি পরীক্ষা প্রোগ্রামটি TEST_COUNT= 3000 দিয়ে চালালে এটি অন্তত একটি পরীক্ষায় ব্যর্থ বলে মনে হচ্ছে।

— মৌ

Answer 10

154 166 টি অক্ষর

ঠিক আছে, এখানে একটি দীর্ঘ কিন্তু দ্রুত quicksort হয়।

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;}}

সাজানো ইনপুটগুলি টিকে থাকার জন্য এখানে একটি সংশোধন করা হয়েছে is এবং ফর্ম্যাট করা যেহেতু সাদা স্থান গণনা করে না।

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

এই সংস্করণটি কিছু ক্ষেত্রে সীমাবদ্ধতার বাইরে লিখতে হবে বলে মনে হচ্ছে, অন্যের মধ্যে শেষ হচ্ছে না।

— মাউ

PS: ঠিক আছে, এটি একটি সাজানো সেট খুব ধীর। তবে সমস্যার বিবৃতিটি জানায় যে ইনপুটটি এলোমেলো।

— ফ্লোরিয়ান এফ

মানগুলি এলোমেলো। তারা কোন ক্রমে থাকবে সে সম্পর্কে আমি কিছুই বলিনি :-) তবে হ্যাঁ, রয়েছে সমস্ত মানের প্রায় 10% ক্রমবর্ধমান ক্রমে সাজানো এবং আরও 10% অবতরণ ক্রমে coveringেকে রাখা।

— মৌ

যথেষ্ট ফর্সা। এবং বাছাই করা ইনপুটটিতে একটি সাজানোর () কাজ করা উচিত। আমি আমার

— ফ্লোরিয়ান এফ

Answer 11

150 চরিত্র

শেলসোর্ট (ডাব্লু / নুথ ফাঁক)

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 + nq) দ্বারা প্রতিস্থাপন করতে হবে।

#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;
    }
}