Lấy một mảng các số nguyên chứa số âm, số dương và số không. Nhóm nó với một lần lặp và tại chỗ sao cho tất cả các số âm đứng trước, theo sau là tất cả các số không, theo sau là tất cả các số dương.

Thí dụ:

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

Lưu ý rằng các số không cần phải được sắp xếp đầy đủ: chỉ cần sắp xếp theo dấu.

Vì vậy, mảng cuối cùng sẽ trông như thế này: -, -, ..., -, -, 0, 0, ..., 0, 0, +, +, ..., +, +

Quy tắc

• Bạn chỉ có thể sử dụng mảng đầu vào và một lượng bộ nhớ bổ sung không đổi (nghĩa là bạn không thể tạo thêm bất kỳ mảng nào)
• Bạn chỉ có thể sử dụng một vòng lặp, có thể chỉ thực hiện nhiều lần bằng độ dài của mảng. Bạn không được sử dụng các hàm dựng sẵn che giấu bất kỳ loại vòng lặp nào. Điều này bao gồm các chức năng sắp xếp tích hợp.
• Kết quả phải ở định dạng tôi mô tả

Người chiến thắng sẽ là người sẽ gửi mã ngắn nhất (tính bằng byte) thay đổi mảng ban đầu thành định dạng chính xác (như được mô tả ở trên).

C, 92

Điều này có thể có thể được giảm ít nhất 10 byte; Có nhiều biểu hiện sẽ lãng phí.

Đối số đầu tiên phải trỏ đến phần đầu của mảng; điểm thứ hai nên sau khi kết thúc mảng.

*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 với trình tạo thử nghiệm ngẫu nhiên:

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

SỐ LIỆU 242

Theo trang wikipedia chính xác. Cảm ơn @PeterTaylor

Đưa đầu vào dưới dạng một tập hợp các số được phân tách bằng dấu cách từ std in và đầu ra cũng như std out.

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
}

Python 2: 116 byte

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

Đây là một bản dịch Python được đánh golf của mã giả quốc kỳ Hà Lan.

112 byte có thể

Không chắc chắn, nếu điều này được cho phép. Nó tạo ra một mảng thứ hai có kích thước 3 (lượng bộ nhớ bổ sung không đổi!).

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

C, 90

Thực hiện đơn giản thuật toán trong bài viết trên wikipedia theo nhận xét của Peter Taylor về câu hỏi.

Mong đợi để tìm dữ liệu trong một mảng được gọi anhư câu trả lời C khác. n, pVà zđược gợi ý cho chèn âm và số dương và zero. nvà pđược lấy làm đối số chỉ đến các yếu tố đầu tiên và cuối cùng của dữ liệu.

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

ECMAScript 157 byte

Lấy các số dưới dạng không gian được phân tách hoặc dấu phẩy được phân tách từ hộp thoại nhắc và trả về kết quả bằng hộp thoại cảnh báo.

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

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

Cú pháp biến tương đối dài dòng của PHP là một chút đau ở đây ...

Nổi loạn - 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

Đây là một cổng trực tiếp của cờ giả quốc gia Hà Lan wikipedia. Dưới đây là cách nó trông vô dụng:

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

Ví dụ sử dụng:

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

Lưu ý Mảng Rebol (khối) không sử dụng dấu phẩy -[5 3 0 -6 2 0 5]

Và nếu OK của nó bao bọc điều này thành một hàm có một mảng và sửa đổi nó tại chỗ thì chúng ta có thể đưa nó xuống tới 128 ký tự:

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

Trong thực tế nếu không cần trả về mảng (tức là chỉ cần sửa đổi) thì bạn có thể tắt thêm 1 char.

C ++

Giải pháp không chơi gôn: n đếm các tiêu cực được thêm vào trước mảng. Đối với mỗi phần tử nếu hoán đổi âm với phần tử tại n, nếu hoán đổi bằng 0 với phần tử tại n + 1 khác hoán đổi với phần tử cuối cùng.

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

Camam - 72 67

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

Đầu vào: [5 3 4 0 -6 2 0 5]
Đầu ra:[-6 0 0 4 2 3 5 5]

Dùng thử tại http://cjam.aditsu.net/

Giải trình:

Đây là một triển khai khác của thuật toán từ wikipedia, sử dụng Tcho ivà Ucho j(cả hai tự động được khởi tạo thành 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