एक पुनरावृत्ति के साथ नकारात्मक, शून्य और सकारात्मक पूर्णांकों की एक सरणी का आदेश देना

Question

ऋणात्मक संख्याओं, धनात्मक संख्याओं और शून्य वाले पूर्णांकों की एक सरणी लें। इसे एक पुनरावृत्ति के साथ समूहित करें और इस तरह से कि सभी नकारात्मक संख्याएं पहले आएं, उसके बाद सभी शून्य, उसके बाद सभी सकारात्मक संख्याएं।

उदाहरण:

Input:  5, 3, 0, -6, 2, 0, 5
Output: -6, 0, 0, 3, 2, 5, 5

ध्यान दें कि नंबरों को पूरी तरह से सॉर्ट करने की आवश्यकता नहीं है: बस साइन द्वारा सॉर्ट किया गया है।

तो, अंतिम सरणी इस तरह दिखाई देगी: -, -, ..., -, -, 0, 0, ..., 0, 0, +, +, ..., +, +

नियम

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

विजेता वह व्यक्ति होगा जो सबसे छोटा कोड (बाइट्स में गिना गया) जमा करेगा, जो प्रारंभिक सरणी को एक सही प्रारूप में बदलता है (जैसे ऊपर वर्णित है)।

Comments

उर्फ डच राष्ट्रीय ध्वज समस्या ।

— पीटर टेलर

@PeterTaylor Thx, अब मैं समझता हूँ कि कार्य क्या है!

— यादृच्छिक

वास्तव में यह कोडगॉल्फ.स्टैकएक्सचेंज.com / questions / 504 / … उपयोग 1 पुनरावृत्ति और 1 सरणी सीमा के अलावा।

— ऑप्टिमाइज़र

अंतर्निहित सॉर्ट फ़ंक्शन की अनुमति नहीं है, है ना?

— KSFT

@KSFT कॉलिंग sort(...)ठीक नहीं है क्योंकि यह संभवतः एक से अधिक पुनरावृत्तियों को करता है।

— इओनिया बिज़ुआ

Answer 1

सी, 92

यह संभवतः कम से कम 10 बाइट्स द्वारा कम किया जा सकता है; बहुत से भाव व्यर्थ जा रहे हैं।

पहला तर्क सरणी की शुरुआत को इंगित करना चाहिए; सरणी के अंत के बाद दूसरा बिंदु होना चाहिए।

*x;f(b,e)int*b,*e;{for(x=b;x<e;x++)*x>0&&--e-x?*x--^=*e^=*x^=*e:*x<0?b-x?*x^=*b=*x:0,b++:0;}

यादृच्छिक परीक्षण जनरेटर के साथ Ungolfed:

*x;
f(b,e)int*b,*e;{
    for(x=b;x<e;x++) {
        if(*x<0) {
            if(b == x)
                b++;
            else
                *b++ = *x, *x=0;
        } else if(*x>0 && x != --e) {
            *x^=*e^=*x^=*e;
            x--;
        }
    }
}

int main()
{
    int a[999];
    srand(time(0));
    int n = rand() % 50;
    int i;
    for(i = 0; i < n; i++) printf("%d ", a[i] = rand() % 9 - 4);
    f(a, a+n);
    puts("");
    for(i = 0; i < n; i++) printf("%d ", a[i]);
    return 0;
}

Comments

मैंने कोड ब्लॉक में यह कोशिश की और यह संकलन नहीं करता है, 3 त्रुटियां हैं। आपने क्या संकलित किया? x * परिभाषित नहीं है और आपने {से पहले वेरिएबल बना दिया है।

— bacchusbeale

@bacchusbeale आप इसे डिफ़ॉल्ट (C89) मोड में gcc के साथ संकलित कर सकते हैं। CodeBlocks एक संकलक नहीं है, इसलिए मैं यह नहीं बता सकता कि आप किस संकलक का उपयोग कर रहे हैं, लेकिन यह gcc के साथ काम करता है। सभी कंपाइलरों के साथ काम न करने का कारण K & R-style घोषणाएं हैं, जो ANSI मानक का पालन नहीं करती हैं।

— feersum

Answer 2

STATA 242

विकिपीडिया पृष्ठ का अनुसरण करता है। धन्यवाद @PeterTaylor

एक स्थान के रूप में इनपुट को std से संख्याओं के अलग-अलग सेट के रूप में लेता है और आउटपुट के साथ-साथ std को भी बाहर निकालता है।

di _r(a)
token $a//converts to array (kind of)
loc i=0
loc j=0
loc q=wordcount($a)
loc n=`q'-1
while `j'<=`n' {
loc t=``j''
if `t'<0{
loc `j'=``i''
loc `i'=`t'
loc ++i
loc ++j
}
else if `t'>0{
loc `j'=``n''
loc `n'=`t'
loc --n
}
else
loc ++j
}
//used only to output
forv x=1/`q'{
di ``x'' _c
}

Answer 3

पायथन 2: 116 बाइट्स

a=input();i=j=0;n=len(a)
while j<n:b=a[j];r,s=b<0,b>0;c=i*r+n*s-s+j*(b==0);a[c],a[j]=b,a[c];i+=r;n-=s;j+=b<1
print a

यह डच राष्ट्रीय ध्वज छद्म कोड का एक गोल्फ का अनुवाद है।

संभावित 112 बाइट्स

यकीन नहीं, अगर इसकी अनुमति हो। यह आकार 3 का एक दूसरा सरणी बनाता है (अतिरिक्त मेमोरी की निरंतर मात्रा!)।

a=input();i=j=0;n=len(a)-1
while j<=n:b=a[j];k=(i,j,n)[cmp(b,0)+1];a[k],a[j]=b,a[k];i+=b<0;n-=b>0;j+=b<1
print a

Answer 4

सी, 90

प्रश्न पर पीटर टेलर की टिप्पणी के अनुसार विकिपीडिया लेख में एल्गोरिथ्म का सीधा कार्यान्वयन।

aअन्य सी उत्तर की तरह बुलाया सरणी में डेटा खोजने की उम्मीद है । n, pऔर zनकारात्मक और सकारात्मक संख्या और शून्य के सम्मिलन के लिए संकेत हैं। nऔर pडेटा के पहले और अंतिम तत्वों की ओर इशारा करते हुए तर्क के रूप में लिया जाता है।

f(n,p){int t,z;for(z=n;p-z;z++)(t=a[z])?a[z]>0?a[z]=a[p],a[p--]=t:(a[z]=a[n],a[n++]=t):0;}

Answer 5

ECMAScript 157 बाइट्स

संख्याओं को स्थान के रूप में अलग किया जाता है या अल्पविराम को एक त्वरित संवाद से अलग किया जाता है और एक चेतावनी संवाद के साथ परिणाम देता है।

for(v=prompt().split(/,?\s+/),s=function(j,n){t=v[j],v[j]=v[n],v[n]=t},i=j=0,n=v.length-1;j<=n;)
!(~~v[j]<0&&!s(i++,j++)||~~v[j]>0&&!s(j,n--))&&j++;alert(v);

Answer 6

PHP (146)

function f($s){for($i=0,$n=count($s)-1;$j++<=$n;)if($k=$s[$j]){$l=$k>0?n:i;$x=$s[$$l];$s[$$l]=$k;$s[$j]=$x;$k>0?$n--|$j--:$i++;}echo print_r($s);}

http://3v4l.org/ivRX5

PHP का अपेक्षाकृत वर्बोज़ वेरिएबल सिंटैक्स थोड़ा दर्दनाक है ...

Answer 7

प्रतिबल - 149 142 140

a: to-block input i: j: 1 n: length? a while[j <= n][case[a/:j < 0[swap at a ++ i at a ++ j]a/:j > 0[swap at a j at a -- n]on[++ j]]]print a

यह डच राष्ट्रीय ध्वज विकिपीडिया स्यूडोकोड का प्रत्यक्ष बंदरगाह है। नीचे यह बताया गया है कि यह कैसा दिखता है:

a: to-block input
i: j: 1
n: length? a

while [j <= n] [
    case [
        a/:j < 0 [swap at a ++ i at a ++ j]
        a/:j > 0 [swap at a j at a -- n]
        on       [++ j]
    ]
]

print a

उपयोग उदाहरण:

rebol dutch-flag.reb <<< "5 3 0 -6 2 0 5"
-6 0 0 2 3 5 5

एनबी। Rebol arrays (ब्लॉक) अल्पविराम का उपयोग नहीं करते -[5 3 0 -6 2 0 5]

और अगर इसका ओके इसे एक फ़ंक्शन में लपेटता है जो एक सरणी लेता है और इसे जगह में संशोधित करता है तो हम इसे 128 चार्ट तक नीचे ला सकते हैं:

>> f: func[a][i: j: 1 n: length? a while[j <= n][case[a/:j < 0[swap at a ++ i at a ++ j]a/:j > 0[swap at a j at a -- n]on[++ j]]]n]

>> array: [5 3 0 -6 2 0 5]
== [5 3 0 -6 2 0 5]

>> print f array
-6 0 0 2 3 5 5

>> ;; and just to show that it as modified array

>> array
== [-6 0 0 2 3 5 5]

वास्तव में अगर सरणी वापस करने की आवश्यकता नहीं है (यानी। बस संशोधित) तो आप 1 और चार दाढ़ी काट सकते हैं।

Answer 8

सी ++

गैर-गोल्फ समाधान: n सरणी के सामने जोड़े गए नकारात्मक मायने रखता है। प्रत्येक तत्व के लिए यदि n पर तत्व के साथ नकारात्मक स्वैप होता है, यदि शून्य तत्व के साथ n + 1 और अंतिम तत्व के साथ स्वैप होता है।

void p(int* k,int n)
{
for(int i=0;i<n;i++)
{
cout<<*(k+i)<<' ';
}
cout<<endl;
}

void s(int *x,int i,int j)
{
int t=*(x+j);
*(x+j)=*(x+i);
*(x+i)=t;
}
void f(int *x,int L)
{
int n=0;
int k;
for(int i=1;i<L;i++)
{
k=*(x+i);
if(k<0)
{
s(x,i,n);
n++;
}
else if(k==0)
{
s(x,i,n+1);
}
else if(k>0)
{
s(x,i,L-1);
}
}
}

int main()
{
int x[]={5,2,-1,0,-2,4,0,3};
f(x,8);
p(x,8);
return 0;
}

Answer 9

सीजेएम - 72 67

q~_,(:N;{_U=:B0>{U1$N=tNBtN(:N;}{B{U1$T=tTBtT):T;}{}?U):U;}?UN>!}gp

इनपुट: [5 3 4 0 -6 2 0 5]
आउटपुट:[-6 0 0 4 2 3 5 5]

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

यह विकिपीडिया से एल्गोरिथ्म का एक और कार्यान्वयन है, जिसके Tलिए iऔर इसके Uलिए j(दोनों स्वचालित रूप से प्रारंभ में 0 पर)।

q~                    read and evaluate the array (let's call it "A")
_,(:N;                keep A on the stack and set N ← size of A - 1  
{                     do...  
    _U=:B             keep A on the stack and set B ← A[U] (also leaving B on the stack)  
    0>{               if B > 0
        U1$N=t        A[U] ← A[N]
        NBt           A[N] ← B
        N(:N;         N ← N - 1
    }{                else
        B{            if B ≠ 0
            U1$T=t    A[U] ← A[T]
            TBt       A[T] ← B
            T):T;     T ← T + 1
        }{            else (do nothing)
        }?            end if
        U):U;         U ← U + 1
    }?                end if
UN>!}g                ...while not (U > N)
p                     print representation of A