음, 양의 정수를 각각 필터링해 모은 두 리스트를 합칩니다. 구글은 파이썬을 좋아하긴 하나 보네요.

def do(alist):
    return [x for x in alist if x < 0] + [x for x in alist if x >= 0]

print do([-1, 1, 3, -2, 2])

근데 문제가 너무 간단한데 왠지 in-place로 풀어야하는 제약이 있는게 합당해보입니다. 그렇다고 하면 위에 이인욱님께서 푸신 방법이 맞습니다. (아마존 면접문제하고도 비슷하네요)

list = [1, 2, 3, 4, 5, -5, -4, -3, -2, -1]

def sort_item(list):
    t1, t2 = [], []
    for i in list:
        if i < 0:
            t1.append(i)
        else:
            t2.append(i)
    result = t1 + t2
    return result

print sort_item(list)

가장 단순한 답 제출합니다 ㅋ

자바코드입니다. 버블정렬에서 swap의 조건문만 살짝 바꿔서 풀어보았습니다.

public class Test{
    public static void main(String args[]) throws Exception{
        int[] list = {-1,1,-3,3,-2,2,4};
        int length = list.length-1;
        for(int i=0; i<length; i++){
            for(int j=0; j<(length-i); j++){
                if(list[j] > 0 && list[j+1] < 0){
                    int k = list[j];
                    list[j] = list[j+1];
                    list[j+1] = k;
                }
            }
        }
        for(int k : list) {
            System.out.print(k+" ");
        }
    }
}

너무 1차원적이 풀이지만 올려봅니다^^; 파이썬입니다

_input = [-1, 1, 3, -2, 2]

alist  = []
blist  = []

for n in _input:
    if n < 0:
        alist.append(n)
    else:
        blist.append(n)

print(alist + blist)

import java.util.*;

public class SpecialSort { //JAVA

    private static Scanner scan = new Scanner(System.in);
    private static String strSort = new String();
    private static String[] sorts = null;

    public static void main(String[] args) {

        System.out.println("n개의 정수를 가진 배열을 입력하시오: ");

        strSort = scan.nextLine();
        sorts = strSort.split(" ");

        for(String sort : sorts) if( sort.startsWith("-") ) System.out.print(sort + " ");
        for(String sort : sorts) if( !sort.startsWith("-") ) System.out.print(sort + " ");
    }

}

Console

n개의 정수를 가진 배열을 입력하시오: 
-1 1 3 -2 2
-1 -2 1 3 2 

#include <stdio.h>

int main(void)

{
    int aList[5] = {-1,1,3,-2,2 };

    int i = 0, j = 0, cnt = 1;

    int nTmp = 0;

    for (i = 0; i < 5 - 1; i++)
    {
        for (j = i + 1; j < 4; j++)
        {

            if (aList[j] < 0)
            {
                if (aList[i] < aList[j] && aList[i] < 0)
                {
                    nTmp = aList[i];
                    aList[i] = aList[j];
                    aList[j] = nTmp;
                }

                else if (aList[i] > aList[j] && aList[i] > 0)
                {
                    nTmp = aList[i];
                    aList[i] = aList[j];
                    aList[j] = nTmp;
                }

            }
        }
    }

    return 0;
}

알고리즘 못해요 ㅠㅠ (잉여잉여..)

list1 =  [-1, 1, 3, -2, 2]
print([i for i in list1 if i < 0] + [i for i in list1 if i > 0])

(defn special-sort [& lst]
  (let [{neg false, pos true} (group-by pos? lst)]
    (concat neg pos)))

Clojure 코드입니다. ^^

좀 더 pythonic 하게 만들려고 노력했습니다. (0은 양의정수 취급했습니다.)

def special_sort(s):
    v = map(int, s.split())
    return " ".join(map(str, filter(lambda a:a<0, v)
        +filter(lambda a:a>=0, v)))

print special_sort("-1 1 3 -2 2") 

결과: -1 -2 1 3 2

coding by python beginner

t0 = [-1, 1, 3, -2, 2]
l1, l2 = [], []
for i in range( len(t0) ):
    if t0[i] < 0: l1.append( t0[i] )
    else: l2.append( t0[i] )
print( l1 + l2 )

Ruby

몇가지 풀이 추가.

p [-1,1,3,-2,2].partition {|_|_<0}*', ' 
p [-1,1,3,-2,2].partition {|_|_<0}.flatten 
p [-1,1,3,-2,2].partition {|_|_<0}.reduce :concat 
p [-1,1,3,-2,2].group_by {|_|_<0}.flat_map(&:last)
p [-1,1,3,-2,2].select {|_|_<0} + a.select{|e|e>=0}
a = [-1,1,3,-2,2]; n = a.select {|_|_<0}; p n+(a-n)
p [-1,1,3,-2,2].group_by{|_|_<0}.map(&:last).flatten
p [-1,1,3,-2,2].group_by(&:negative?).flat_map(&:last)
p [-1,1,3,-2,2].reduce ([[],[]]) {|a,n| a[n<0?0:1]<< n; a}.flatten

sample = [-1, 1, 3, -2, 2];li1 = [];li2 = []
for x in sample:
    if x<0:li1.append(x)
    elif x>0:li2.append(x)
print (li1+li2)

파이썬 3.5.1

파이썬 초보입니다. 어떤분이 리스트 컴프리핸션으로 구현하는것이 짧다고 해서 한번 구현해보았습니다.

numbers=[ -1, -1, 3, -2, 2, 5, -9, 0, -10 ]

newlist_minus =[i for i in numbers if i<0]
newlist_plus =[i for i in numbers if i>=0]
print(newlist_minus+newlist_plus)

a = [-1,1,3,-2,2] b=[];c=[] for i in range(len(a)): if a[i] < 0: b.append(a[i]) else : c.append(a[i])

print(b+c)

Python

list = [-1, 1, 3, -2, 2]

a_list=[]
b_list=[]

for i in list:
    if i < 0:
        a_list.append(i)
    elif i > 0:
        b_list.append(i)

print(a_list + b_list)

n = [-1,1,3,-2,2]

n1 = [] n2 = []

for i in n: if i < 0: n1.append(i) else: n2.append(i)

print(n1 + n2)

// SP_SpecialSort.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"
#include <string.h>
int g_nData[] = { -1, 1, 3, -2, 2};
void SpecialSort(int* pData,int nSize)
{
    int *pnTemp = new int[nSize];
    int nPIndex = nSize-1;
    int nNIndex = 0;
    for(int iter = 0; iter < nSize ; iter ++)
    {
        if(pData[iter] < 0)
        {
            pnTemp[nNIndex] = pData[iter];
            nNIndex ++;
        }
        if(pData[nSize - iter - 1] >= 0)
        {
            pnTemp[nPIndex] = pData[nSize - iter - 1];
            nPIndex --;
        }
    }
    memcpy(pData,pnTemp,sizeof(int)*nSize);
}
int _tmain(int argc, _TCHAR* argv[])
{   
    int nSize = sizeof(g_nData)/sizeof(int);
    SpecialSort(g_nData,nSize);
    for(int iter = 0 ; iter < nSize ; iter ++)
    {
        printf("%d ",g_nData[iter]);
    }
    return 0;
}

Ruby

def sort(nums); nums.group_by{|i|i<0}.inject([]){|s,v|s+v[1]}; end;

파이썬 2.7.6입니다.

def s_sort(input):
    input_list = map(int, input.split())
    p_list = []
    m_list = []
    for i in input_list:
        if i >= 0:
            p_list.append(i)
        else:
            m_list.append(i)
    result = m_list + p_list
    return result

print s_sort("-1 1 3 -2 2")

입력에 0이 포함되는지 포함될 경우 어떻게 처리하는지에 대하여는 명확하지 않네요.

초보입니다. 지적 바랍니다.

c(v[v<0], v[v==0], v[v>0])

R로 풀었습니다. 0일 경우 그냥 양수와 음수 사이에 오도록 했습니다. 결과입니다

> v=c(1,-5,-2,0,3,-1,2,5,0,-6)
> c(v[v<0], v[v==0], v[v>0])
 [1] -5 -2 -1 -6  0  0  1  3  2  5

Java입니다.

        int[] in={-1,1,3,-2,2,0,0,4,100,-21,0};
        int l=in.length, i;
        for(i=0;i<l;i++) if(in[i]<0) System.out.print(in[i]+" ");
        for(i=0;i<l;i++) if(in[i]==0) System.out.print(in[i]+" ");
        for(i=0;i<l;i++) if(in[i]>0) System.out.print(in[i]+" ");

그냥 이렇게 하면 되네요 ㅋㅋㅋ

#출력예시
-1 -2 -21 0 0 0 1 3 2 4 100 

혹은, 다른 풀이 (요건 작성해놓고 아까워서 올려요 ㅎㅎ)

package h_Special_Sort;
public class SpecialSort {
    public static void main(String[] args) {
        int[] in={-1,1,3,-2,2,0,0,4,100,-21,0};
        int l=in.length, i,j,k, count0=0;
        int[] n={0,0};
        int[][] arr=new int[2][l]; //arr[0][]:음수,arr[1][]:양수

        for(i=0;i<l;i++){
            if(in[i]<0) arr[0][n[0]++]=in[i];
            else if(in[i]>0) arr[1][n[1]++]=in[i];
            else if(in[i]==0) count0++;
        }

        for(j=0;j<2;j++) for(i=0;i<n[j];i++){
            System.out.print(arr[j][i]+" ");
            if(j==0 && i+1==n[j] && count0>0) for(k=0;k<count0;k++) System.out.print(0+" ");
        }
    }
}

python 2.4 입니다.

def s_sort(arg_list):
    negative_n = []
    positive_n = []

    for n in arg_list:
        val = int(n)
        if val < 0 :
            negative_n.append(val)
        else:
            positive_n.append(val)

    return negative_n + positive_n

def main():
    arg_val = raw_input("input >>")

    print s_sort(arg_val.split())

if __name__ == '__main__':
    main()

입력 받은 값을 리스트에 넣어준뒤에 0보다 작은 값이 들어갈 negative_n과 0 또는 0 이상의 값이 들어갈 positive_n에 분기하여 넣어주고 마지막에 하나로 합쳐주는 형식으로 해결했습니다.

python 3.4 입니다.

import unittest

def method1(unsorted):
    minus_items = gather_minus(unsorted)
    plus_items = gather_plus(unsorted)

    sorted = minus_items + plus_items

    return sorted

def gather_plus(items):
    plus_items = [item for item in items if item > 0]
    return plus_items

def gather_minus(items):
    minus_items = [item for item in items if item < 0]
    return minus_items

class TestSpeicalSort(unittest.TestCase):
    def test_solution(self):
        self.assertEqual(method1([-1, 1, 3, -2, 2]), [-1, -2, 1, 3, 2])

    def test_gather_plus(self):
        self.assertEqual(gather_plus([-1, 2, 3, 4, -2]), [2, 3, 4 ])

    def test_gather_minus(self):
        self.assertEqual(gather_minus([-1, 2, 3, 4, -2]), [-1, -2])

if __name__ == "__main__":
    unittest.main()

저도 bubble sort가 생각나어 바로 적용했습니다.

public class SpecialSort {

    public static void main(String[] args) {
        int[] data = {-1, 1, 3, -2, 2};
        int length = data.length - 1;

        int[] specialSort = specialSort(data, length);
        for(int i=0; i<specialSort.length; i++){
            System.out.printf("%d ", specialSort[i]);
        }
    }

    private static int[] specialSort(int[] data, int length) {
        for(int i=0; i<length-1; i++){
            for(int k=0; k<length-i; k++){
                if(data[k] > 0 && data[k+1] < 0){
                    int temp = data[k];
                    data[k] = data[k+1];
                    data[k+1] = temp; 
                }
            }
        }
        return data;
    }
}

파이썬 3.4 입니다.

def special_sort(data):
    data.sort()
    result=[]
    for x in data:
        if x >= 0:
            result.append(x)
    for x in data:
        if x < 0:
            result.insert(0,x)
    result=" ".join(map(str,result))
    return result

data = list(map(int,input("각 숫자를 스페이스로 구분하여 한줄에 입력하시오.\n").split()))

print(special_sort(data))

// C# 입니다.
using System;

class Program
{
    static int[] numbers = new int[] { 6, -1, 1, 3, -2, 2 };

    static void Main()
    {
        for (var i = 1; i < numbers.Length; i++)
        {
            if (numbers[i] > 0)
            {
                continue;
            }
            for (var k = i; k > 0; k--)
            {
                if (numbers[k - 1] * numbers[k] > 0)
                {
                    break;
                }
                SwitchValue(numbers, k - 1, k);
            }
        }
        foreach (var aNumber in numbers)
        {
            Console.Write(aNumber + "  ");
        }
        Console.WriteLine("");
    }

    static void SwitchValue(int[] array, int first, int second)
    {
        int temp = array[first];
        array[first] = array[second];
        array[second] = temp;
    }
}

#include <stdio.h>
#include <conio.h>


#define ArrSize(n) sizeof(n)/sizeof(n[0])


void main() {
    int Arr[10];
    int temp;
    for(int i = 0; i < ArrSize(Arr); i++) {
        scanf("%d", &Arr[i]);
    }
    for(int i = 0; i < ArrSize(Arr) - 1; i++) {
        for(int j = 0; j < ArrSize(Arr) - 1; j++) {
            if(Arr[j+1] < 0 && Arr[j] > 0) {
                temp = Arr[j];
                Arr[j] = Arr[j+1];
                Arr[j+1] = temp;
            }
        }
    }
    for(int i = 0; i < ArrSize(Arr); i++) { 
        printf("%d ", Arr[i]);
    }
    _getch();
}

ruby

a = [-1, 1, 3, -2, 2]

b = []
c = []
a.each do |ab|
  if ab < 0
    b << ab
  else
    c << ab
  end

end

d = b + c

python 입니다. 풀이가 생각보다 단순했습니다.

import unittest

def func(l):
  m, p = [], []
  for i in range(len(l)):
    if l[i]<0 : m.append(l[i])
    else : p.append(l[i])
  return m+p 

class Test(unittest.TestCase):
  def test1(self):
    self.assertEqual([-1, -2, 1, 3, 2], func([-1, 1, 3, -2, 2]))

if __name__ == "__main__":
  unittest.main()

요렇게 하면 되지 않을까요? 문제의 의도가 stable, unstable 개념을 알고 있느냐를 묻는 것 같은데요?

 * stable sort인 merge sort를 사용한다.
   quick sort는 unstable sort 이기 때문에 사용할 수 없다.
 * 단, 비교 조건을 다음과 같이 바꾼다.
   음수와 음수 간에 비교는 equal을 리턴
   양수와 양수 간에 비교는 equal을 리턴
   음수와 양수 간에 비교는 음수<양수를 리턴

Complexity는 merge sort이기 때문에 당연히 time=O(n log n), space=O(n) 입니다.

Using python 코드가 너무 짧아서 a 생성하는 코드까지 붙여버렸습니다...허..

from random import randint

a = []
for i in xrange(10):
    a.append(randint(-10,20))

def sSort(a):
    return [x for x in a if x<0]+[x for x in a if x>0]
print sSort(a)

#data
array = [-1, 1, 3, -2, 2]


#처리
def ssort(src):
    nlist = []
    plist = []
    for n in array:
        if n < 0 :
            nlist.append(n)
        else:
            plist.append(n)
    return nlist+plist


#입출력
print(ssort(array))

C로 풀었습니다.

int arr[]={-1, 1, 3, -2, 2};
    int i, j, temp;

    for(i=0; i<ARR_SIZE; i++)
        for(j=0; j<ARR_SIZE-i; j++){
            if(arr[j]>0 && arr[j+1] < 0){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

흠 일단 코더처럼 만들긴했는데, 시간복잡도 같은걸 이해하려면 알고리즘 공부를 좀해야겠어요...

#414.py
lists=[-4 ,-7, -1, 0, 3, 99, -1,1]
minus=[]
notminus=[]
for x in lists:
    if x<0:
        minus.append(x)
    else:
        notminus.append(x)

print minus+notminus

    Sub main()
        Dim arr() As Integer = Array.ConvertAll(Split(Console.ReadLine, " "), Function(d As String) CInt(d))
        arr = arr.Where(Function(n As Integer) n < 0).OrderByDescending(Function(d As Integer) d).ToArray.Union(arr.Where(Function(n As Integer) n >= 0).ToArray).ToArray

        Console.WriteLine(String.Join(" ", arr))

        Console.ReadLine()
    End Sub

Linq를 사용하여 음수부분배열을 가져오고 내림차순으로 정렬뒤 정수부분배열과 합쳤습니다.

파이썬을 공부하고 있어서 파이썬으로 머지소트를 살짝 응용해 보았습니다.

import math

def gsort(data, start, end):
    if end - start == 0:
        return
    else:
        gsort(data, start, math.floor((end + start) / 2))
        gsort(data, math.floor((end + start) / 2) + 1, end)
        gsort_merge(data, start, math.floor((end + start) / 2), end)

def gsort_merge(data, start, mid, end):
    tmp = []
    i = start
    j = mid + 1

    while i <= mid:
        if data[i] < 0:
            tmp.append(data[i])
        else:
            break
        i += 1

    while j <= end:
        if data[j] < 0:
            tmp.append(data[j])
        else:
            break;
        j += 1

    while i <= mid:
        tmp.append(data[i])
        i += 1

    while j <= end:
        tmp.append(data[j])
        j += 1

    data[start:end+1] = tmp;


if __name__ == "__main__":
    #data = [-1, -3, 1, 3, -2, 2]
    data = [ -1, 1, 3, -2, 2]
    gsort(data, 0, len(data) - 1)
    print(data)

print("Please insert a string including arbitrary numbers.\nEach number can be negative or positive, \nbut they have to be split by a comma(',').")
alist = input()

splitter = (',')
palette = alist.split(splitter)
for i in range(0, len(palette)):
    palette[i] = int(palette[i])
negalist = []; posilist = []

for ii in range(0, len(palette)):
    if (palette[ii]) > 0:
        posilist.append(str(palette[ii]))
    elif (palette[ii]) < 0:
        negalist.append(str(palette[ii]))
    else:
        continue

print((" ".join(negalist)) + " " + (" ".join(posilist)))

그냥 리스트를 입력받아서 변환 후 값을 대응하는 식으로 했습니다!

Swift로 문제 풀어보았습니다.

let l = [-1, 1, 3, -2, 2]
let r = l.filter { $0 < 0 } + l.filter { $0 >= 0 }
print(r) // [-1, -2, 1, 3, 2]

다른 분들하고 코드가 너무 비슷하네요

def SpSort(a) : 
 am = []
 ap = []

 for i in a:
    if i < 0 : am.append(i)
    else : ap.append(i)

 return am + ap


print SpSort ([-1, 1, 3, -2, 2] )

C#으로 작성했습니다. BucketSort를 이용하여 두개의 버킷 0보다 작은 숫자와 0 혹은 그 이상의 버킷에 담고 그대로 inputs에 넣었습니다.

using System.Collections.Generic;

        public void SpecialSort(List<int> inputs)
        {
            if (inputs.Count <= 1) return;
            var buckets = new List<int>[2];
            for (int i = 0; i < inputs.Count; i++)
            {
                var temp = inputs[i] < 0 ? 0 : 1;
                if (buckets[temp] == null) buckets[temp] = new List<int>();
                buckets[temp].Add(inputs[i]);
            }
            var k = 0;
            for (int i = 0; i < buckets.Length; i++)
            {
                if (buckets[i] == null) continue;
                for (int j = 0; j < buckets[i].Count; j++)
                    inputs[k++] = buckets[i][j];
            }
        }

파이썬 2.7

data = [-1, 5, 4, -2, 2,- 7]

pos_num = sorted([x for x in data if x > 0]) # 양의 정수만을 선택하여 정렬

result = sorted([x for x in data if x < 0])  # 음의 정수만을 선택하여 정렬
result.reverse()  # 정렬된 음의 정수를 뒤집는다.

result.extend(pos_num)  # 음의 정수의 끝에 양의 정수를 넣는다.

for i in result:
    print i,

sample_array = [-1, 1, 3, -2, 2]

sorted_array = [x for x in sample_array if x < 0 ] + [x for x in sample_array if x >= 0]
print(sorted_array)

• python으로 작성하였습니다.

s=[-1,1,3,-2,2]

sMns=filter(lambda x: x<0,s)
sPls=filter(lambda x: x>0,s)

print " ".join(str(i) for i in sMns+sPls)

print [x for x in p if x<0]+[x for x in p if x>=0]

음. 리스트를 가정하고(배열) 풀었습니다. for문 2번써서 음수먼저 리스트에 넣고, 그 후에 양수를 삽입하였습니다.

def special_sort(input1):
    a=[]
    for i in input1:
        if i<0:
            a.append(i)
    for i in input1:
        if i>0:
            a.append(i)
    return a


input1 = [-1,1,3,-2,2]
print special_sort(input1)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define Arrlen 5

void PrintArr(int arr[]);
void SpecialSort(int arr[]);

int main(void){
        srand((unsigned)time(NULL));
        int i;
        int arr[Arrlen];
        for(i=0;i<Arrlen;i++)
                arr[i]=rand()%20-10;
        PrintArr(arr);
        SpecialSort(arr);
        PrintArr(arr);
}

void PrintArr(int arr[]){
        int i;
        for(i=0;i<Arrlen;i++)
                printf("%4d",arr[i]);
        printf("\n");
}

void SpecialSort(int arr[]){
        int inspect,tmp,negativenum=0,i;
        for(inspect=0;inspect<Arrlen;inspect++){
                if(arr[inspect]<0){
                        for(i=inspect;i>negativenum;i--){
                                tmp=arr[i];
                                arr[i]=arr[i-1];
                                arr[i-1]=tmp;
                        }
                        negativenum++;
                }
        }
}

한가지 배열 말고도 여러가지 배열로 실험해 보기 위해서 난수함수를 사용해봤어요~~

C# 입니다. One Loop으로 인소트를 활용하여 처리해보았습니다.
0이나 음의 수를 넣을 타겟 인덱스를 정의하여 인덱스에 같은 수를 추가후 기존의 아이템을 제거하였습니다.
타겟 인덱스는 0과 음수의 경계선을 가리키도록 하기위해, 음수가 나오면 증가시키고, 0이 나오면 증가시키지 않았습니다.
사실 리스트의 아이템 수정이 너무 잦게되면 대량의 리스트 처리시 너무 비효율적인데,
이미 많은 분들이 다양한 답을 내주셔서 할게 없었습니다 ㅎㅎ

List<int> nums = new List<int>() { -1, 1, 3, -2, 2, 0, -4 };
int t = 0;

for (int i = 0; i < nums.Count; i++)
{
    int num = nums[i];
    if (num > 0) continue;

    nums.RemoveAt(i);
    nums.Insert(t, num);
    if (num < 0) t++;
}
nums.ForEach(x => Console.Write(x + " "));

data=[-3,5,-4,2,1]
ans1=[]
ans2=[]
for i in data:
    if i < 0:
        ans1.append(i)
    else:
        ans2.append(i)
ans=ans1+ans2
print(ans)
파이썬 3.4

void sort(int [] arr) {
        ArrayList<Integer> list = new ArrayList<Integer>();

        for(int i=0; i<arr.length; i++) {
            if(arr[i] < 0) {
                list.add(arr[i]);
            }
        }

        for(int i=0; i<arr.length; i++) {
            if(arr[i] > 0) {
                list.add(arr[i]);
            }
        }
        System.out.print(list);
    }



    void sort2(int [] arr) {
        for(int i=0; i<arr.length; i++) {
            for(int j=0; j<arr.length-1; j++) {
                if(arr[j] > 0 && arr[j+1] < 0) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        System.out.print(Arrays.toString(arr));
    }

java. 두가지로 풀어보았습니다.

파이썬3.4

# 예전 나의 풀이
# 2016/3/21
a = [-1, 1, 3, -2, 2]
m = list(filter(lambda x: x < 0, a))
p = list(filter(lambda x: x >= 0, a))
print(m + p)



# 2016/10/20
# 파이썬 내부의 sort 함수를 이용하되, 
# 비교방법을 다르게 정의해서 풀어봄
# 예전 어떤 문제에서 상파님의 풀이를 참고하였음
from functools import cmp_to_key as cmp

def f(a, b):
    if a<0 and b>0: return -1
    elif a>0 and b<0: return 1
    else: return 0

q = [-1, 1, 3, -2, 2]
ans = sorted(q, key=cmp(f))    # 파이썬2.7에서는 다르게 사용함
print(ans)

파이썬3.5.1

li = list(map(int,input().split()))
li = list(reversed(sorted([x for x in li if x < 0]))) + sorted([x for x in li if x >= 0])
print(li)

Python 3.4

data = [-1, 1, 3, -2, 2]
output = []

{ output.append(x) for x in data if x < 0 }
{ output.append(x) for x in data if x >= 0 }

print(output)

a=[-1,1,3,-2,2]
b=[]
c=[]
d=[]
e=[]
for i in range(len(a)):
    if a[i]<0:
        b.append(a[i])
    elif a[i]==0:
        d.append(0)
    else:
        c.append(a[i])
c.sort()
for i in b:
    e.append(str(i))
e.sort()
for i in e:
    b.append(int(i))
    b.pop(0)
a=b+d+c
print(a)

tmp1 = c(-1, 1, 3, -2, 2)
c(subset(tmp1, tmp1 < 0), subset(tmp1, tmp1 > 0))

R로 작성했습니다. 많은 분들이 이미 같은 방식으로 해결하셨네요.

package javaCoding;

import java.util.ArrayList; import java.util.List;

/ * 자바로 간단하게 풀었습니다. * @author pc02 /

public class Coding012 {

public static void main(String[] args) {

    int[] arr=new int[10];
    arr[0]=-5;
    arr[1]=-10;
    arr[2]=5;
    arr[3]=6;
    arr[4]=-7;
    arr[5]=15;
    arr[6]=25;
    arr[7]=-1;
    arr[8]=7;
    arr[9]=-9;

    List list=new ArrayList<>();
    List list2=new ArrayList<>();
    List list3=new ArrayList<>();

    for (int i = 0; i < arr.length; i++) {
        if(arr[i]<0){
            list.add(arr[i]);
        }
        else{
            list2.add(arr[i]);
        }
    }

    for (int i = 0; i < list.size(); i++) {
        list3.add(list.get(i));
    }
    for (int i = 0; i < list2.size(); i++) {
        list3.add(list2.get(i));
    }

    for (int i = 0; i < list3.size(); i++) {

        if(i==list3.size()-1){
            System.out.print(list3.get(i)); 
            break;
        }
        System.out.print(list3.get(i)+","); 
    }



}

}

Delphi 2010

procedure TForm4.btnSpecialSortClick(Sender: TObject);
  function SpecialSort(str: string): string;
  var
    sList, sList2: TStringList;
    i, N: Integer;
  begin
    sList := TStringList.create;
    sList2 := TStringList.create;
    try
      sList.Delimiter := ' ';
      sList.CommaText := str; // Data를 Space키로 Array 처리하기

      for i := 0 to sList.Count - 1 do
        if pos('-', sList[i]) > 0 then
          sList2.Add(sList[i]);
      for i := 0 to sList.Count - 1 do
        if pos('-', sList[i]) = 0 then
          sList2.Add(sList[i]);

      sList2.Delimiter := ' ';
      result := sList2.CommaText; // 결과 Data 쓰기
    finally
      sList.Free;
    end;
  end;

var
  s: string;
begin
  s := '-1 1 3 -2 2';
  Memo1.Lines.Add(s + ' special sort => ' + SpecialSort(s));
end;

in_a = [-1,1,3,-2,2]
out_a=[]
for i in range(len(in_a)):
    if in_a[i] < 0 :
        out_a+=[in_a[i]]
for i in range(len(in_a)):
    if in_a[i] > 0 :
        out_a+=[in_a[i]]
print(out_a)

Python 3.5.2

inplace 로 해결하고 싶은 경우 quicksort 알고리즘의 일부를 활용하면 됩니다.

template <size_t Siz>
static void Sort(std::array<int, Siz>& arr) {
    // pivot 숫자를 0으로 설정하고 quicksort 의 좌우정렬을 실행.

    // 일단 0을 오른쪽 끝에 모두 몰아 넣는다.
    for (int i = 0, j = 1; i < Siz; ++i) {
        if (arr[i] == 0) {
            swap(arr, i, Siz-j);
            ++j;
        }
    }

    int stored = 0;
    for (int i = 0; i < Siz; ++i) {
        if (arr[i] <= 0) {
            swap(arr, i, stored++);
        }
    }
}

늅늅입니다. 파이썬을 보고 자극받아, arraylist 를 하나만 사용해서 돌리는 방법으로 만들어 보았습니다.

public static ArrayList<Integer> resultNum;

    public static void main(String args[])
    {
        int[] numList = {-1,1,-3,3,-2,2,4};
        resultNum = new ArrayList<Integer>();

        Sorting(numList);
    }

    public static void Sorting(int[] numList)
    {
        int tempIndex = 0;
        for(int i = 0; i < numList.length; i++)
        {
            if(numList[i] < 0)
            {
                resultNum.add(tempIndex, numList[i]);
                tempIndex++;
            }
            else
            {
                resultNum.add(resultNum.size(), numList[i]);
            }
        }

        for (int number : resultNum) 
        {
            System.out.print(String.valueOf(number) + " ");
        }
    }

결과는 -1 -3 -2 1 3 2 4 이렇게 나옵니다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication9
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = {-1, 2, 9, 3, -5, -3, 10, 4, 7}; // 정렬해야 할 배열

            List<int> negative_list = new List<int>(); // 음수 리스트
            List<int> positive_list = new List<int>(); // 양수 리스트

            for(int i = 0; i < arr.Length; i++)
            {
                if(arr[i] > 0) // 양수 일때
                {
                    positive_list.Add(arr[i]);
                }
                else // 음수 일때
                {
                    negative_list.Add(arr[i]);
                }
            }

            int[] new_arr = new int[arr.Length]; // 정렬 된 값을 넣을 배열

            for(int i = 0; i < negative_list.Count; i++)
            {
                new_arr[i] = negative_list[i]; //음수값 대입
            }

            for(int i = 0; i < positive_list.Count; i++)
            {
                new_arr[negative_list.Count + i] = positive_list[i]; //양수값 대입
            }

            for(int i = 0; i < new_arr.Length; i++)
            {
                Console.Write(new_arr[i] + " ");
            }

        }
    }
}

정렬이라는 말에 어울리는 소스 같지는 않지만 일단 단순하게 짜봤습니다

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication9
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 1, 2, 9, 3, -5, -3, 10, 4, -10 }; // 정렬해야 할 배열

            for(int i = 0; i < arr.Length; i++)
            {
                int temp_i = i;
                if (arr[i] < 0) //만약 음수일 경우
                {
                    for(int j = i-1; j >= 0; j--)
                    {                        
                        if(arr[j] > 0) //현재 i번째 숫자가 음수인데 앞쪽(i-1)에 양수가 있다면
                        {
                            int temp = arr[temp_i];
                            arr[temp_i] = arr[j];
                            arr[j] = temp;
                            temp_i = j;
                        }
                    }
                }
                for (int k = 0; k < arr.Length; k++)
                {
                    Console.Write(arr[k] + " ");
                }
                Console.WriteLine();
            }

        }
    }
}

C++ 코드 Stack으로 O(n) 만에 풀기

#include <iostream> 
#include <cstdlib> 
#include <stack> 
#include <vector> 
using namespace std; 

int main(){
    vector<int> v;  
    int n; // 배열의 길이  
    cin >> n; 
    for (int i = 0; i < n; i++){
        int no; 
        cin >> no; // 배열의 원소를 받는다. 
        v.push_back(no);  
    }
    stack<int> negative,positive; // 0은 없다고 가정 
    for (int i = v.size()-1; i >= 0; i--){
        if (v[i] < 0) negative.push(v[i]);  
        else positive.push(v[i]);  
    }
    while (!negative.empty()){
        cout << negative.top() << " ";  
        negative.pop();  
    }
    while (!positive.empty()){
        cout << positive.top() << " ";  
        positive.pop();  
    }
    cout << endl; 
    return 0; 
}

파이썬 코드입니다. 양수와 음수를 따로 리스트에 저장하여 둘을 더하는 방식으로 구성했습니다.

inp = list(input().split(' '))
a=[]
b=[]

for i in inp:
    i = int(i)
    if i<0: a.append(i)
    else: b.append(i)

print(a+b)

파이썬 초보입니다. 많은 피드백 부탁드립니다!

#include <stdio.h>
#include <stdlib.h>

void main(){
    int arr[] = {-1, 1, 3, -2, 2};
    int* temp;
    int size = sizeof(arr)/4;
    temp = (int*) malloc (sizeof(int)*size);
    int c=0;
    for(int i=0; i < size;i++) {
        if(arr[i]<0) {
            temp[c]=arr[i];
            c++;
        }
    }
    for(int i=0; i < size;i++) {
        if(arr[i]>0) {
            temp[c]=arr[i];
            c++;
        }
    }
    for(int i=0; i < size;i++) 
        printf("%1d ", temp[i]);

}

#include <iostream> 

using namespace std;

int main()
{
    int arr[5] = { -1,1,3,-2,2 };
    int tempNum = -1;

    for (int i = 0; i < _countof(arr); i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

    for (int i = 0; i < _countof(arr); i++)
    {
        if (arr[i] >= 0)
        {
            bool tempSorting = false;
            int tempIdx = 0;
            for (int j = i; j < _countof(arr); j++)
            {
                if (tempSorting)
                {
                    int sour = arr[j];
                    arr[j] = tempNum;
                    tempNum = sour;
                    if (tempIdx == j) break;
                }

                if (arr[j] < 0&&!tempSorting)
                {
                    tempNum = arr[j];
                    tempIdx = j;
                    j= i - 1;
                    tempSorting = true;
                }
            }
            tempNum = -1;
        }
    }
    for (int i = 0; i < _countof(arr); i++)
    {
        cout << arr[i] << " ";
    }
}

Java

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.function.Function;
import java.util.stream.Collectors;

public class IntSortTester {

    public static Function<int[], List<Integer>> intSort = l -> {
        List<Integer> result = Arrays.stream(l).filter(i->i<0).boxed().collect(Collectors.toList());
        result.addAll(Arrays.stream(l).filter(i->i>=0).boxed().collect(Collectors.toList()));
        return result;
    };
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            String input = sc.nextLine();
            List<Integer> sortedList = intSort.apply(Arrays.stream(input.split(" ")).mapToInt(Integer::parseInt).toArray());
            sortedList.forEach(i->System.out.print(i + " "));
        }
    }
}

• -1 1 3 -2 2
• -1 -2 1 3 2

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <string>

using namespace std;

void sorting(int*, int*, const int);

int main(void) {
    int array[] = { -1,1,3,-2,2 };
    const int len = sizeof(array) / sizeof(int);
    int sort[len] = { 0, };

    for (int i = 0; i < len; i++) {
        cout << array[i] << " ";
    }

    sorting(array, sort, len);

    system("pause");
    return 0;
}
void sorting(int* array,int* sort, const int len) {
    int k = 0;

    for (int i = 0; i<len; i++)
    {
        if (array[i] < 0) {
            sort[k++] = array[i];
        }
    }
    for (int i = 0; i < len; i++) {
        if (array[i] >= 0) {
            sort[k++] = array[i];
        }
    }
    cout << "ans : ";
    for (int i = 0; i < len; i++) {
        cout << sort[i] << " ";
    }
}

import java.util.ArrayList;

public class SpecialSort {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] A = {-1,1,3,-2,2};

        ArrayList<Integer> negList = new ArrayList<Integer>();
        ArrayList<Integer> posList = new ArrayList<Integer>();
        ArrayList<Integer> zerList = new ArrayList<Integer>();

        for (int i = 0; i < A.length; i++) {
            if (A[i] > 0) {
                posList.add(A[i]);
            }else if (A[i] < 0) {
                negList.add(A[i]);
            }else
                zerList.add(A[i]);
        }

        for (int i = 0; i < negList.size(); i++) {
            System.out.print(negList.get(i) + " ");
        }

        for (int i = 0; i < zerList.size(); i++) {
            System.out.print(zerList.get(i) + " ");
        }

        for (int i = 0; i < posList.size(); i++) {
            System.out.print(posList.get(i) + " ");
        }
    }

}

int main(int argc, char *argv[]) {

int arry[5]={-1,1,3,2,-2};
int last[5]={};
int k=0;
int minuscount=0;
int i;


for(i=0; i<5; i++){
    if(arry[i]<0){
        last[k]=arry[i];
        k+=1;
        minuscount+=1;  
    }
}

for(i=0; i<5; i++){
    if(arry[i]>0){
        last[minuscount]=arry[i];
        minuscount+=1;  
    }
}

for(i=0; i<5; i++){
    printf("%d\n",last[i]);
}

return 0;

} ``` 5개 값 아무거나 넣어도 실행됩니다.

//Linq로

List<int> arr = new List<int>() { -1, 1, 3, -2, 2 };
foreach (int v in (new List<int>(arr)).Where(k => k < 0).Concat(new List<int>(arr).Where(k => k > 0)))
    Console.WriteLine(v);

lst = [-1,1,3,-2,2]

mi_lst = [x for x in lst if x < 0]
ad_lst = [x for x in lst if x > 0]

print(mi_lst+ad_lst)

print(sorted([-1, 1, 3, -2, 2], key=lambda x: 1 if x > 0 else 0))

Python 3.5.2에서 작성하였습니다.

nums = [-1,1,3,-2,2]
print([x for x in nums if x < 0]+[x for x in nums if x > 0])

#### 2016.12.15 D-434 ####

C(11) gcc -std=c11

#include <stdio.h>
#include <stdlib.h>

void append(int **p, int val, int index);
void print(int **p, int size);

int main(void)
{
    int *minus = (int *)malloc(0 * sizeof (int));
    int *plus = (int *)malloc(0 * sizeof (int));
    int minus_index = 0, plus_index = 0;
    int n;

    while (scanf("%d", &n) == 1)
    {
        if (n < 0)
        {
            append(&minus, n, minus_index);
            ++minus_index;
        }
        else
        {
            append(&plus, n, plus_index);
            ++plus_index;
        }
    }
    print(&minus, minus_index);
    print(&plus, plus_index);
    putchar('\n');

    free(minus);
    free(plus);
    return 0;
}

void append(int **p, int val, int index)
{
    *p = (int *)realloc(*p, (index+1) * sizeof (int));
    (*p)[index] = val;
}

void print(int **p, int size)
{
    for (int i=0; i<size; ++i)
        printf("%d ", (*p)[i]);
}

#python 2.7.xx

arr = [-1,1,3,-2,2]
normal = filter(lambda x :x < 0, arr) + filter(lambda x: x >= 0,arr)
print normal

#include <stdio.h>

void Shift(int arr[], int idx_start, int idx_end)
{
    int tmp = arr[idx_end];
    for (int i = idx_end - 1; i >= idx_start; i--)
    {
        arr[i + 1] = arr[i];
    }
    arr[idx_start] = tmp;
}

int main()
{
    int arrSrc[5] = { -1, 1, 3, -2, -5 };

    {
        int idx_insertNegative;
        bool bFindPositive = false;
        for (int i = 0; i < 5; i++)
        {
            if (!bFindPositive && arrSrc[i] >= 0)
            {
                idx_insertNegative = i;
                bFindPositive = !bFindPositive;
            }
            else if (bFindPositive && arrSrc[i] < 0)
            {
                Shift(arrSrc, idx_insertNegative, i);
                idx_insertNegative++;
            }

        }
    }

    for (int i = 0; i < 5; i++)
        printf("%d ", arrSrc[i]);
    printf("\n");

    return 0;
}

def special_sort(data):
    print([x for x in data if x<0]+[y for y in data if y>0])
special_sort([-1, 1, 3, -2, 2])

import java.util.ArrayList;
import java.util.Scanner;

public class Special_Sort {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<Integer> a = new ArrayList<Integer>();
        int plus = 0;
        int minus = 0;
        while((scan.hasNextInt())){
            int n = scan.nextInt();
            System.out.println(n);
            if(n >= 0)
                a.add((plus++) + minus,n);
            else
                a.add(plus + (minus++), n);
        }
        for(int i : a){
            System.out.print(i+ " ");
        }
    }

}

import java.util.Arrays;

public class SpecialSort {

    public static void main(String[] args) {
        int n = 5;
        int[] a = new int[]{-1, 1, 3, -2, 2};

        for (int i = 0; i < n - 1; i++) {
            for (int j = n - 1; j > i; j--) {
                if (a[j - 1] * a[j] < 0 && a[j - 1] > a[j]) {
                    int temp = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

public int [] go(int [] a) {
        ArrayList<Integer> sort = new ArrayList<Integer>();

        for(int i=0 ; i<a.length ; i++) {   //ArrayList에 음수먼저 저장
            if(a[i]<0) sort.add(a[i]);
        }

        for(int i=0 ; i<a.length ; i++) {   //ArrayList에 양수 저장
            if(a[i]>=0) sort.add(a[i]);
        }

        for(int i=0 ; i<sort.size() ; i++) { 
            a[i]=sort.get(i);
        }
        return a;
    }

a=[-1,1,3,-2,2]
b=[]
for i in a:
    if i <0:
        b.append(i)
for i in a:
    if i>0:
        b.append(i)
print(b)

#include <iostream>
#include <vector>

using namespace std;

void printNumber(vector<int>arr);
void specialSort(vector<int>&before, vector<int>&after, bool flag);

int main()
{
    bool flag = false;
    int index = 0;
    vector<int> before = { -1, 1, 3, -2, 2 };
    vector<int> after;
    after.reserve(before.size());

    printNumber(before);
    specialSort(before, after, flag);
    printNumber(after);
    return 0;
}

void specialSort(vector<int>&before, vector<int>&after, bool flag) {
    for (int i = 0; i < before.size(); i++) {
        if (before.at(i) < 0 && flag == false)
            after.push_back(before.at(i));

        else if (before.at(i) > 0 && flag == true)
            after.push_back(before.at(i));

        if (i == before.size() - 1 && flag == false) {
            i = -1;
            flag = true;
        }
        if (i == before.size() - 1 && flag == true)
            break;
    }
}

void printNumber(vector<int>arr) {
    for (int i = 0; i < arr.size(); i++) {
        cout << arr.at(i) << " ";
    }
    cout << "\n";
}

-1 1 3 -2 2
-1 -2 1 3 2

a=[-1, 1, 3, -2, 2, -7,-5,-9,-10,3,5,4,2,7]
b=[]
c=[]
for i in range(len(a)):
    if a[i]<0:
        b.append(a[i])
    else:
        c.append(a[i])
d=b+c
print(d)

python 3.6 한줄 : 리시트에서 음수모으고 양수모아서 합치기, 0 이 있다면 무조건 가운데

알고리즘

special_sort = [i for i in LIST if i<0] + [j for j in LIST if j==0] + [k for k in LIST if k>0]

구현

def special_sort(LIST): # 구글 면접 해답 함수
    sort = [i for i in LIST if i<0] + [j for j in LIST if j==0] + [k for k in LIST if k>0]
    return sort

>>> in_array = list(map(int, input("Enter numbers: ").split())) # 입력받아 int array list 로 저장
Enter numbers: -1 1 3 -2 2
>>> print(" ".join(map(str, special_sort(in_array)))) # 정렬숫자 받아 리스트로 변환출력
-1 -2 1 3 2

>>> in_array = list(map(int, input("Enter numbers: ").split()))
Enter numbers: 1 -4 -3 -5 1 3 -6 7 0
>>> print(" ".join(map(str, special_sort(in_array))))
-4 -3 -5 -6 0 1 1 3 7

a = [-1,1,3,-2,2]
a.sort(key = int)
for i in range(len(a)):
    if a[i] < a[i+1] < 0:
        a.append(a[i])
        a[i] = a[i+1]
        a[i+1]=a[-1]
        a.pop()
print(a)

C-Sharp

using static System.Console;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] arr = { -1, 1, 3, -2, 2};
        arr.Where(n => n < 0).ToList().Concat(arr.Where(n => n >= 0)).ToList().ForEach(n => Write(n + " "));
    }
}

public static void main(String[] args) {
        int [] arr = {-2,2,31,-321,2,3,4,5,-2};
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<arr.length;i++)
            if(arr[i]<0 )
                list.add(arr[i]);

        for(int i=0;i<arr.length;i++)
            if(arr[i]>0)
                list.add(arr[i]);

        System.out.println(list);

원글을 보니 O(n) 의 시간복잡도와 O(1) 의 공간복잡도로 풀라고 하고 있네요.

머리좀 쥐어뜯다가 포기했습니다.

어떻게 푸나요?

아래는 그냥 쉬운방법으로 ㅠㅠ

javascript(ES6)

var list = [-1, 1, 3, -2, 2];

var minus = v => v < 0;
var plus = v => v > 0;
var zero = v => v === 0;
var answer = list.filter(minus).concat(list.filter(zero), list.filter(plus));

console.log(`ans : ${answer.join(" ")}`);

#include<stdio.h>

int main(void) {
    int arr[10] = { 1,2,-3,4,5, -6, -2, 3, -8, 9};//갯수는 마음대로
    int temp;
    int i,j;
    for (i = 0;i < 10;i++) {
        if (arr[i] < 0) {
            if(i != 0) {
                for(j=i;j>0;j--){
                    if (arr[j - 1] < 0)
                        break;
                    else {
                        temp = arr[j];
                        arr[j] = arr[j - 1];
                        arr[j - 1] = temp;
                    }
                }
            }
        }
    }
    for (i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
}

자바, 배열의 처음부터 끝값까지 for문으로 조회해서 음수는 음수 array list에 양수는 양수 array list 에 저장후 둘을 합친다. 나중에 코드로 작성할예정

a = [-1, 1, 3, -2, 2]

minus_number = []
plus_number = []


for i in range(0,len(a)):
    if a[i] < 0:
        minus_number.append(a[i])
    elif a[i] >= 0:
        plus_number.append(a[i])


print ("Sorted  list is :", (minus_number + plus_number))

num=[-1,1,3,-2,2]
plus_num=[]
minus_num=[]
def special_sort(num):
    for i in range(len(num)):
        if num[i]<0:
            minus_num.append(num[i])
        else:
            plus_num.append(num[i])
    print(minus_num+plus_num)

special_sort(num)

def special_sorting(arr):
    minus_list = []
    plus_list = []
    for i in arr:
        if (i >= 0):
            plus_list.append(i)
        else:
            minus_list.append(i)
    result_list = minus_list + plus_list
    return result_list

#in-place: bubble sort var.
lst = [-1, 1, 3, -2, 2]
for last in range(len(lst)):
    for i in range(last):
        if lst[i] > 0 and lst[i+1] < 1:
            (lst[i], lst[i+1]) = (lst[i+1], lst[i])

print(lst)

부끄러운 답안입니다..ㅠ 양수 음수 각각 배열 선언해서 나눈 다음 순서대로 합칩니다.. 더 나은 방법이 있는지 생각해보고 업데이트 해보겠습니다.

public class Ex7 {
    // -1 1 3 -2 2 ans: -1 -2 1 3 2.
    private static int[] array = {-1,1,3,-2,2};
    public static void main(String[] args) {
        sort();
    }
    public static void sort(){
        int[] minus = new int[array.length];
        int[] plus = new int[array.length];
        int idx = 0;
        int idx2 = 0;
        for ( int i = 0; i < array.length; i++ ){
            if ( array[i] < 0 ){
                minus[idx++] = array[i];
            }
            if ( array[i] >= 0 ){
                plus[idx2++] = array[i];
            }
        }
        for( int i = 0; i < idx; i++){
            array[i] = minus[i];
        }
        for( int i = 0; i < idx2; i++){
            array[i+idx] = plus[i];
        }
    }
}

def alignment(insertList):

    negative = []
    positive = []
    for num in insertList: 
        if num < 0:
            negative.append(num)
        elif num > 0:
            positive.append(num)
    print(negative + positive)



alignment([-1, 1, 3, -2, 2])

Python 3로 풀었습니다.

def special_sort(items):
    return [x for x in items if x < 0] + [x for x in items if x >= 0]

def specialSort(arr):
    a=[]
    b=[]
    for i in range(0,len(arr)):
        if(arr[i]<0):
            a.append(arr[i])
        else:
            b.append(arr[i])
    arr = a+b
    return arr

a = [-1,1,3,-2,2,-1,-3,-4]
print(specialSort(a))
``````{.python}
def specialSort(arr):
    a=[]
    b=[]
    for i in range(0,len(arr)):
        if(arr[i]<0):
            a.append(arr[i])
        else:
            b.append(arr[i])
    arr = a+b
    return arr

a = [-1,1,3,-2,2,-1,-3,-4]
print(specialSort(a))

list = [-1, 1, 3, -2, 2]
res = [a for a in list if a < 0] + [a for a in list if a ==0 ] + [a for a in list if a > 0]

print(res)

Python 2.7

givenList = [1,-1,0,4,6,-5]
print givenList
givenList.sort()
mySortList = []

for x in givenList:
    if x < 0:
        mySortList.insert(0, x)
    else:
        mySortList.append(x)

print mySortList    

public class SpecialSort {
    public static void main(String[] args) {
        int[] nums = {-1, 1, 3, -2, 2};
        int[] result = new int[nums.length];
        int cnt=0, i;
        for(i=0; i<nums.length; i++) {
            if(nums[i]<0) {
                result[cnt] = nums[i];
                cnt++;              
            }
        }
        for(i=0; i<nums.length; i++) {
            if(nums[i]>0) {
                result[cnt] = nums[i];
                cnt++;
            }
        }
        for(i=0; i<nums.length; i++) System.out.println(result[i]);
    }
}

Python으로 작성했습니다.

Q = [-1, 1, 3, -2, 2]
def SpecialSort(Q):
    minor, major = [], []
    for num in Q:
        if num < 0:
            minor.append(abs(num))
        if num >= 0:
            major.append(num)
    major.sort()
    minor.sort()
    minor = [i*(-1) for i in minor]
    return(minor + major)
SpecialSort(Q)

R로 작성했습니다.

Q <- c(-1, 1, 3, -2, 2)
SpecialSort <- function(Q){
  minor <- Q[Q < 0]
  major <- Q[Q >= 0]
  major <- major[order(major)]
  minor <- minor[order(minor, decreasing = T)]
  result <- c(minor, major)
  return(result)
}
SpecialSort(Q)

list_data=[3,1,7,2,-1,5,-9,-7,10]
minus_list_data=[]
list_dh=[]
len_list_data=len(list_data)
print(list_data)


for i in range(len_list_data-1):
    if list_data[i]<0:
        minus_list_data.append(list_data[i])

for j in range(len_list_data-1):
    if list_data[j]<0:
        list_dh.append(j)


for u in range(len(list_dh)):
    list_data[list_dh[u]]='K'

for gg in range(len(list_dh)):
    list_data.remove('K')
for p in range(len(list_data)):
    minus_list_data.append(list_data[p])

print(minus_list_data)

def sorting_int(a) :  # type(a) == list

    for i in range(1, len(a)) :

        if a[i-1] * a[i] > 0 :
            pass

        else :
            n = i

            while n > 0 :
                if a[n-1] * a[n] < 0 and a[n] < 0 :
                    a[n-1], a[n] = a[n], a[n-1]
                    n -= 1

                else :
                    n -= 1

            continue
    return a

[Python 3.6]

print([num for num in inputArray if num < 0] + [num for num in inputArray if not num < 0])

lst = [-1, 1, 3, -2, 2]
print([x for x in lst if x < 0] + [x for x in lst if x >= 0])
print(list(filter(lambda x : x<0, lst)) + list(filter(lambda x : x>=0, lst)))

import java.util.ArrayList;
import java.util.List;

public class Example28 {

    public static void main(String[] args) {
        int nArray[] = new int[] { -1, 1, 3, -2, 2 };

        List<Integer> minus = new ArrayList<>();
        List<Integer> plus = new ArrayList<>();

        for (int n : nArray) {
            if (n < 0)
                minus.add(n);
            else
                plus.add(n);
        }

        minus.addAll(plus);

        for(Integer n : minus) {
            System.out.print(n + " ");
        }
    }
}

두개 따로 list로 받고 하나로 합쳤습니다.

arr=[-1,1,3,-2,2]
plus=[]
minus=[]
for i in arr:
    if(i<0):
        minus.append(i)
    else:
        plus.append(i)
print(minus+plus)

# python 3.6
inp = [-1, 1, 3, -2, 2]
lst_l = list()
lst_r = list()
for v in inp:
    if v < 0:
        lst_l.append(v)
    else:
        lst_r.append(v)
print(lst_l + lst_r)

def special_sort(x):
   return  [i for i in x if i<0]+[i for i in x if i>0]

spelis=[-1,1,3,-2,2]

list= [spelis[b]  for b,a in enumerate(spelis) if a < 0]
list.sort()

comlis = [spelis[b] for b,a in enumerate(spelis) if a > 0]
spelis = list + comlis

print(spelis)

처음으로 글써봅니다.. 초보라서 더잘하지는 못했어요; 죄송함다 음수만 정렬되는 기능도 넣어봤는데 조잡스럽나요?

저는 음수는 list_negative에 저장하고, 양수는 list_positive에 저장하여 list_negative를 익스텐드해서 new_list에 저장했습니다.

datalist = [-1, 1, 3, -2, 2]
list_negative = []
list_positive = []
for i in datalist:
    if i < 0:
        list_negative.append(i)
    else:
        list_positive.append(i)
list_negative.extend(list_positive)
new_list = list_negative
print(new_list)

# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3)
import sys
import io

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

# n개의 정수를 가진 배열이 있다.
# 이 배열은 양의정수와 음의 정수를 모두 가지고 있다.
# 이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다.
# 정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다.
# 또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.
# 예. -1 1 3 -2 2 ans: -1 -2 1 3 2.

#numbers = [-1, 1, 3, -2, 2]
import random
numbers = [random.randint(1,10)*(random.randint(1,2)*2-3) for i in range(10)]
print("원래 배열 :", numbers)

minus = [x for x in numbers if x < 0]
plus = [x for x in numbers if x > 0]

print("수정한 배열 :", minus+plus)

import java.util.ArrayList;
import java.util.List;

public class SpecialSortTest {
    public static void main(String[] args) {
        List<Byte> data = new ArrayList<>();
        //정수는 int타입이기 때문에 byte로 캐스팅(Casting)한다
        data.add((byte)-1); data.add((byte)1); data.add((byte)3); data.add((byte)-2); data.add((byte)2);
        //음수
        List<Byte> nagative = new ArrayList<>();
        //양수
        List<Byte> dual = new ArrayList<>();

        //음수와 양수를 분리한다
        for(byte b1 : data) {
            if(b1>0) {
                dual.add(b1);
            }else if(b1<0) {
                nagative.add(b1);
            }
        }
        //출력
        for(byte b3: nagative){
            System.out.print(b3 + "\t");
        }
        for(byte b2: dual){
            System.out.print(b2 + "\t");
        }
    }
}

ex_list = [-1,1,3,-2,2]
ex2_list = []

def positive(x):
    return x > 0

def positive2(x):
    return x < 0

ex2_list.extend(filter(positive2,ex_list))
ex2_list.extend(filter(positive,ex_list))

print (ex2_list)

#input:배열, output:순서변경된배열

S=[-1, 1, 3, -2, 2]

def change_array(input):
    dic = {value:idx for idx,value in enumerate(input)}
    dic_values = list(dic.keys())
    idx_lst01 = []
    idx_lst02 = []
    for n in dic_values:
        if n < 0:
            idx_lst01.append(dic[n])
        else:
            idx_lst02.append(dic[n])
    idx_lst01.extend(idx_lst02)
    result = [input[idx] for idx in idx_lst01]
    print(result)

change_array(S)

def SpecialSort(list): list_negative = [] list_positive = [] for i in list: if i < 0: list_negative.append(i) else: list_positive.append(i) list_negative.extend(list_positive) sortedList = list_negative
print(sortedList)

SpecialSort([-1,1,3,-2,2])

def katadsuke(s, i, a):   # 음수를 앞으로 옮긴 후 나머지 양수들을 정리
    while i < (a-1):
        s[i+1], s[a] = s[a], s[i+1]
        i += 1 

def google(s):
    i = 0  # 좌표설정
    for a in range(len(s)):
        if s[a] < 0:
            s[i], s[a] = s[a], s[i]  # 바꾸고
            katadsuke(s, i, a)  # 나머지를 정리하고
            i += 1              # 좌표를 이동 
    return s

[num for num in arr if num <0] + [num for num in arr if num >0]

python 3.5.2 입니다.

0은 역시 가운대죠!!

N_list = [-1, 1, 3, -2, 2]

ddd = []
ppp = []
zero = []
for i in range(len(N_list)):
    if N_list[i] < 0:
        ddd.append(N_list[i])
    elif N_list[i] == 0:
        zero.append(N_list[i])
    else:
        ppp.append(N_list[i])

print(ddd+zero+ppp)

N_list = [-1, 1, 3, -2, 2]

ddd = []
ppp = []
zero = []
for i in range(len(N_list)):
    if N_list[i] < 0:
        ddd.append(N_list[i])
    elif N_list[i] == 0:
        zero.append(N_list[i])
    else:
        ppp.append(N_list[i])

print(ddd+zero+ppp)

inputarray = [-1, 1, 3, -2, 2]
negative = []
positive = []
for i in inputarray:
    if i < 0: 
        negative.append(i)
    elif i > 0:
        positive.append(i)
new = negative + positive
print new

전 뭐든지 어렵게 하는 재능(?)이 있는 것 같네요.. 이렇게 하지 말라는 의미에서 코드 첨부합니다ㅋㅋㅋㅋㅋ

import java.util.Arrays;

public class 클래스 명 {
    public static int[] inputNbs = {-16, -23, -1, 1, 3, -2, 2, -8, 5, 8, 0};
    public static int[] minusNbs = new int[inputNbs.length]; public static int[] plusNbs = new int[inputNbs.length];

    public static void distinguishPlusMinus() {
        int plus = 0; int minus = 0;
        for(int a = 0; a < inputNbs.length; a++) {
            if(inputNbs[a] >= 0) {
                plusNbs[plus] = inputNbs[a]; plus++;
            } else {
                minusNbs[minus] = inputNbs[a]; minus++;
            }
        }
        if(plusNbs[plus -1] == 0) {
            plusNbs[plus] = -1;
        }
    }

    public static void main(String[] args) {
        int plus = 0; int minus = 0;
        distinguishPlusMinus();
        System.out.print("ans: ");

        while(minusNbs[minus] != 0) {
            System.out.print(minusNbs[minus] +" "); minus++;
        }
        while(plusNbs[plus] != 0 && plusNbs[plus] != -1 || plusNbs[plus +1] != 0 && plusNbs[plus] != -1) {
            System.out.print(plusNbs[plus] +" "); plus++;
        }
    }
}

import java.util.ArrayList; import java.util.Scanner;

public class SpecialSort {

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    ArrayList<Integer> a = new ArrayList<Integer>();
    int plus = 0;
    int minus = 0;
    while((scan.hasNextInt())){
        int n = scan.nextInt();
        System.out.println(n);
        if(n >= 0)
            a.add((plus++) + minus,n);
        else
            a.add(plus + (minus++), n);
    }
    for(int i : a){
        System.out.print(i+ " ");
    }
}

}

a=[-1, 1, 3, -2, 2]
d=[]
c=[]
for x in a:
    if (x>0):
        d.append(x)
    else:
        c.append(x)
c.extend(d)
print(c)

A=[-1, 1, 3, -2, 2, -5, 7, -4, 5]
B=[A[i] for i in range(len(A)) if A[i]<0]
C=[A[i] for i in range(len(A)) if A[i]>=0]
A=B+C
print(A)

#!/usr/bin/env python

list = [1, -3, -8, 4, 7, -5, 3, -4, 6, -1]

##음수 양수 구분
def classifer(target, size):
    for i in list:
        if 0 < target[i]:
            positive.append(target[i])
        if 0 > target[i]:
            nagative.append(target[i])
        else:
            print('Neither negative numbers nor positive numbers.')


positive=[]
nagative=[]

classifer(list)

##양수 부분 Sorting
positive.sort()

##음수 부분과 양수 부분 합계
result=nagative + positive
print(result)

lst = [-1,1,3,-2,2]
minus =[x for x in lst if x <0]
plus = [x for x in lst if x > 0]
print(minus + plus)

a = [-1 , 1, 3, -2, 2]
print( [x for x in a if x < 0] + [x for x in a if x >= 0] )

array = [3,2,7,-2,1,-1,-3,5]      # 배열 샘플


def arraysort(array):
    sortarray =[]
# 음의 정수를 먼저 새로운 리스트에 추가
    for i in array:
        if i < 0:
            sortarray.append(i)
        else:
            pass
# 양의 정수를 음의 정수 뒤로 추가
    for i in array:
        if i >= 0:
            sortarray.append(i)
        else:
            pass
    print(sortarray)

arraysort(array)

• *결과값

[-2, -1, -3, 3, 2, 7, 1, 5]

package programming;

import java.util.Arrays;

public class google1 {

    public static void main(String[] args) {
        int sr[] = {-1,1,3,-2,2};

        specialSort(sr,0,sr.length);

        System.out.println(Arrays.toString(sr));

    }
    static void specialSort(int[] arr, int s, int e) {

        int i = s-1, j, temp; // 변수 i는 삽입 되어야하는 인덱스위치
            for (j = s; j < e; j++) {

                if (arr[j] < 0) {
                    i++;

                    temp = arr[j];
                    for(int k=j; k>i; k--){
                        // 삽입되어야하는 인덱스위치 다음 원소부터 반복문이 진행되고있는 j원소까지 배열을 복사해준다.
                      arr[k] = arr[k-1];      
                    }
                    arr[i] = temp;              
                    // 마지막으로 인덱스에다가 원소 삽입
                }                                   
            }
    }
}

public class Main {

    public static void main(String[] args) {

        int[] ex = { -1, 1, 3, -2, 2 };
        int[] ans = new int[ex.length];

        int i = 0;
        for (int j = 0; j < ex.length; j++) {
            if (ex[j] < 0) {
                ans[i] = ex[j];
                i++;
            }
        }
        for (int j = 0; j < ex.length; j++) {
            if (ex[j] > 0) {
                ans[i] = ex[j];
                i++;
            }
        }
        for (int k : ans) {
            System.out.print(k + "  ");
        }
    }
}

    private void makeVal(int[] n) {
        // TODO Auto-generated method stub
        //양수 배열
        ArrayList plusList = new ArrayList();
        //음수 배열 
        ArrayList minusList = new ArrayList();
        ArrayList resultList = new ArrayList();

        //0의 경우? -> 양수로 처리

        for(int i=0; i<n.length; i++)
        {
            if(n[i] >=0)
            {
                plusList.add(n[i]);
            }
            else
            {
                minusList.add(n[i]);
            }
        }

        for(int j=0; j<minusList.size(); j++)
        {
            resultList.add(minusList.get(j));
        }

        for(int j=0; j<plusList.size(); j++)
        {
            resultList.add(plusList.get(j));
        }

        for(int j=0; j<resultList.size(); j++)
        {
            System.out.println(j+"번값 : "+resultList.get(j));
        }
    }

좀 더 생각해보면 더 잘 나올거같긴 한데..다른분거 보시는게 좋을거같습니다

#include <stdio.h>
#include <stdlib.h>

void SpecialSort(int *p, int len) {
    int *neg = (int*)calloc(sizeof(int), len);
    int *pos = (int*)calloc(sizeof(int), len);

    int i = 0, j = 0, k = 0;
    while (i < len) {
        if (p[i] < 0) {
            neg[j] = p[i];
            j++;
        }
        else {
            pos[k] = p[i];
            k++;
        }
        i++;
    }
    for (int l = 0; l < j; l++) 
        p[l] = neg[l];
    for (int l = j; l < len; l++)
        p[l] = pos[l - j];

    free(neg); free(pos);
}

void main() {
    int a[] = { -1, 2, 3, -4, -5, 6, -7, -8, -9, 10 };
    SpecialSort(a, sizeof(a) / sizeof(int));
    for (int i = 0; i < sizeof(a) / sizeof(int); i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

arr_is =[-1, 1, 3, -2, 2, -5, -1]
list_mi = []
list_ple = []
arr_str = [str(i) for i in arr_is]
for i in arr_str:
    if i[0] == '-':
        list_mi.append(i)
    else:
        list_ple.append(i)
list_arr_is = list_mi + list_ple
print(list_arr_is)

numList = [-1, 1, 3, -2, 2]

def specialSort(list):
    i = 0
    count = 0
    temp1 = 0
    temp2 = 0
    while(i < len(list) - 1):
        if(list[i] > 0 and list[i+1] < 0):
            temp1 = list[i]
            temp2 = list[i+1]
            list[i+1] = temp1
            list[i] = temp2
            count += 1

        i += 1

    # 한번만 돌리면 안되고 원하는 결과가 나올 때까지 계속 돌려야 한다. 기존의 돌렸던 함수는 return시킨다.
    if(count != 0):
        count = 0
        specialSort(list)
        return

    print(list)

specialSort(numList)

list = [1, 2, 3, 4, 5, -5, -4, -3, -2, -1] #n개의 정수를 가진 배열
j1 = []
j2 = []
j3 = []

for i in list:
    if i<0:
        j1.append(i)
    elif i==0:
        j2.append(i)
    else:
        j3.append(i)
print(j1 + j2 + j3)

python 3.6

a = input('Please enter an array of integer, separating with spaces: ').split(' ')
a_neg = [int(i) for i in a if int(i) < 0]
a_pos = [int(i) for i in a if int(i) > 0]
print('ans:', ' '.join(map(str,a_neg + a_pos)))

파이썬 입니다.

def ssort(*n): ##튜플형태로 입력받자
    minus=[]
    plus=[]
    for i in range(len(n)):
        if n[i]<=0: ##음수라면
            minus.append(str(n[i])) ##주의할 점은 int형으로 구성된 list는 join으로 출력 못한다. str형태로 바꿔줘야함.
        elif n[i]>=0: ##양수라면
            plus.append(str(n[i]))
    result=" ".join(minus)+" "+" ".join(plus)
    return result

data = [-1, 1, 3, -2, 2]

minus = []
plus = []

for x in data:
    if x < 0:
        minus.append(x)
    else:
        plus.append(x)

print(minus + plus)    

s=[-1, 1, 3, -2, 2]
s1 = []
s2 = []

for i in [-1,1,3,-2,2]:
    if i < 0:
        s1.append(i)
    else:
        s2.append(i)
print(s1 + s2)

def special_sort(numbers):
    return [x for x in numbers if x <= 0] + [x for x in numbers if x > 0]

if __name__ == '__main__':
    num_list = [-1, 1, 3, -2, 2]
    print(special_sort(num_list))

public class level_1_special_sort {

public static void main(String[] args) {

    int[] array = {-10, 7, 0, 3, -5, 10, 1, -2};

    int length = array.length;
    int i;

    for(i = 0; i < length; i++)
    {
        if(array[i] < 0)
        {
            System.out.print(array[i] + " ");
        }
    }
    for(i = 0; i < length; i++)
    {

        if(array[i] == 0)
        {
            System.out.print(array[i] + " ");
        }
    }
    for(i = 0; i < length; i++)
    {
        if(array[i] > 0)
        {
        System.out.print(array[i] + " ");
        }
    }
}

}

v = [-1, 1, 3, -2, 2]
print(list(filter(lambda x:x<0,v)) + list(filter(lambda x: x>=0, v)))

자바욥

    int[] arr = {-1, 1, 3, -2, 2};

    public static void main(String[] args)
    {
        main ma = new main();
        int[] arr = ma.arr;
        int length = arr.length;
        int tmp = 0, cnt = 0;
        while(cnt < length)
        {
            for(int i = 0; i < length; i++)
            {
                if(arr[i] < 0)
                {
                    if(i > 0 && arr[i-1] > 0)
                    {
                        tmp = arr[i];
                        arr[i] = arr[i-1];
                        arr[i-1] = tmp;
                    }
                }
            }
            cnt++;
        }
        System.out.println(Arrays.toString(arr));
    }

function test1(input)
    tmp1 = convert(Any, input)
    tmp2_1 = Any[filter(n-> n < 0, tmp1)]
    tmp2_2 = filter(n -> n > 0, tmp1)

    return( push!(tmp2_1, tmp2_2) )
end

julia

x <- c(-1, 1, 3, -2, 2)

specialSort <- function(x){
  n <- length(x)
  minus <- NULL
  plus <- NULL

  for (i in 1 : n){
    if(x[i] < 0){
      minus <- c(minus,x[i])
    }  
    else{
      plus <- c(plus, x[i])
    }
  }
ans <- c(minus, plus)
ans
}

#1.
x=[1,3,-2,2,-3,1]
li_p=[]
li_n=[]
for i in x:
    if i<0:
        a.append(i)
    elif number>=0:
        b.append(i)
print(a+b)

#2. list comprehension

list_positive=[i for i in x if i>=0]
list_negative=[i for i in x if i<0]
print(list_negative+list_positive)

s<-c(-1,1,3,-2,2,-1,0,7,-6)
sort(c(subset(s,s<0),subset(s,s==0),subset(s,s>0)),decreasing = F)

p<-NULL
m<-NULL
result<-NULL
for(i in 1:NROW(s)){
  if(s[i]<0){
    m<-c(m,s[i])
  }else if(s[i]>=0){
    p<-c(p,s[i])
  }
  result<-c(m,p)
}
result[order(result,decreasing=F)]

lis = [-1, 1, 3, -2, 2]
def SpecialSort(lis):
    listForNega = []
    listForPosi = []
    count = 0
    for i in lis:
        if i == 0 : count += 1
        elif i < 0 :
            listForNega.append(i)
        else :
            listForPosi.append(i)
    if count == 0 :
        return listForNega + listForPosi
    else :
        return listForNega + [0] + listForPosi

if __name__ == "__main__" :
    print(SpecialSort(lis))

Python 3.6

arr = [-1, 1, 3, -2, 2]
print([i for i in arr if i < 0] + [i for i in arr if i >= 0])

def specialsort(list):
    plus = []
    minus = []
    for i in list:
        if i >= 0:
            plus.append(i)
        else:
            minus.append(i)
    return minus+plus

number = input().split(" ")
number = [int(i) for i in number]
minus =[]
for i in number : 
    if(i<0) :
        minus.append(i)
        del number[number.index(i)]
    else :
        continue
for i in number :
    minus.append(i)

number=minus

print(number)

# 파이썬

sample = [-1, 1, 3, -2,2]
answer = [x for x in sample if x < 0] + [x for x in sample if x >= 0]
print(answer)

var _primary = [-1, 1, 3, -2, 2];

function _align (x) {
  var _get = [];
  for (var i = 0; i < x.length; i++) {
    if (x[i] < 0) {
      _get.push(x[i]);
    };
  };
  for (var i = 0; i < x.length; i++) {
    if (x[i] >= 0) {
      _get.push(x[i]);
    };
  };
return _get;
};



console.log(_align(_primary));

import java.util.*;

public class Main { public static void main(String[] args) { Scanner scanf=new Scanner(System.in); int[] arr= {-1, 1 ,3 ,-2 ,2}; int cnt=0; int cnt2=0; ArrayList arr2=new ArrayList();

    for(int i=0; i<arr.length; i++) {
        if(arr[i]<0) {
            arr2.add(arr[i]);
        }
    }
    for(int i=0; i<arr.length; i++) {
        if(arr[i]>=0) {
            arr2.add(arr[i]);
        }
    }
    for(int i=0; i<arr2.size(); i++) {
        System.out.println(arr2.get(i));
    }

}

}```{.java}

```

파이썬입니다.

real=[-1,1,3,-2,3]
front=[]
back=[]
for x in real:
    if x<0:front+=[x]
    else:back+=[x]
realsort=front+back

def special_sort():
    s=[]
    i=0
    while i<5:

        s.append(int(input('type ints')))
        i +=1
    print s

    i=0
    minus=[]
    plus=[]

    while i<5:
        if s[i]<0:
            minus.append(s[i])
        elif s[i]>0:
            plus.append(s[i])
        i +=1
    i=0 
    while i<len(plus):
        minus.append(plus[i])
        i +=1

    print(minus)

negative_list=[]
positive_list=[]
num_list=[-1,-2,5,-6,1,3,5,-2,5,3]

for k in num_list:
    if k>0:
        positive_list.append(k)
    if k<0:
        negative_list.append(k)

num_list=negative_list+positive_list

print(num_list)

#include <Stdio.h>

int main(){
    int arr[50];
    int num=0;
    int len=0, temp;
    int i=0;
    char c=0;
    while(c!='\n'){
        scanf("%d%c",&num,&c);
        arr[len++]=num;
    }/* 음수는 앞으로, 양수는 뒤로 */
    while(i!=len-1){    // i값이 len-1이라면 정렬 끝
        if(arr[i]>0){
            if(arr[i+1]<0){
                temp=arr[i+1];
                arr[i+1]=arr[i];
                arr[i]=temp;
                i=0;
            }
        }
        i++;
    }
    for(i=0; i<len; i++)    printf("%d ",arr[i]);
}

public class SpecialSort {

    ArrayList<Integer> minusList = new ArrayList<Integer>();
    ArrayList<Integer> plusList = new ArrayList<Integer>();
    ArrayList<Integer> resultList = new ArrayList<Integer>();

    public void minusListAdd(Integer item){
        minusList.add(item);
    }

    public void plusListAdd(Integer item) {
        plusList.add(item);
    }

    public void setArraylist(int[] arraylist) {
        for(int i = 0; i < arraylist.length; i++) {
            if(arraylist[i] >= 0) {
                plusListAdd(arraylist[i]);
            } else {
                minusListAdd(arraylist[i]);
            }
        }
    }

    public void resultListAdd() {
        for(int i = 0; i < minusList.size(); i++) {
            resultList.add(minusList.get(i));
        }
        for(int i = 0; i < plusList.size(); i++) {
            resultList.add(plusList.get(i));
        }
    }

    public void show() {
        for(int i = 0; i < resultList.size(); i++) {
            System.out.print(resultList.get(i) + ",");
        }
        System.out.println();
    }

}

자바입니당

package CodingDojang;
import java.util.*;

class GoogleSort {
    private static int[] specialSort(int[] _input) {
        int temp;

        for(int i = 0; i < _input.length - 1; i++) {
            for(int j = (_input.length - 2 - i); j >= 0; j--) {
                if(_input[j] >= 0 && _input[j+1] < 0) {
                    temp = _input[j];
                    _input[j] = _input[j+1];
                    _input[j+1] = temp;
                }
            }
        }

        return _input;
    }

    public static void main(String args[]) {
        int[] input = {1,3,4,7,-5};
        int[] output;

        output = specialSort(input);

        for(int i = 0; i < output.length; i++) {
            System.out.printf("%d ", output[i]);
        }
    }
}

public class SpecialSort {

    public static void main(String[] args) {
        int[] arr = {-1, 1, 3, -2, 2};
        int[] ansArr = new int[arr.length];

        for (int i = 0; i < ansArr.length; i++) {
            ansArr[i] = 0;
        }

        int cnt = 0;
        for (int i = 0; i < ansArr.length; i++) {
            if(arr[i]<0) {
                ansArr[cnt] = arr[i];
                cnt++;
            }
        }

        cnt = ansArr.length-1;
        for (int i = ansArr.length-1 ; i >= 0; i--) {
            if(arr[i]>0) {
                ansArr[cnt] = arr[i];
                cnt--;
            }
        }

        for (int i = 0; i < ansArr.length; i++) {
            System.out.print(ansArr[i] + " ");
        }
    }

}

import random

def main():
    pass
    n_num = 0
    p_num = 0

    n = random.randrange(4, 9)
    nums = []

    for i in range(0, n):
        nums.append(int(input()))

    n_index = []
    p_index = []
    for i in range(0, n):
        if nums[i] < 0:
            n_index.append(i)
        else:
            p_index.append(i)

    sort_list = []
    for n in n_index:
        sort_list.append(nums[n])
    for p in p_index:
        sort_list.append(nums[p])

    print(sort_list)

main()

def specialsort(*numbers):
    minus = []
    plus = []
    for deviding in numbers:
        if deviding > 0: plus.append(deviding)
        else: minus.append(deviding)
    return minus + plus

Python 3

//자바 선택정렬을 약간 달리해봤습니다. package Q1;

public class Q28 {

public static void main(String[] args) { int emp; int[] arr = {-1,8,5,45,-6,-8,10,15,91,-46,-22,-84,46,-78,-62}; for(int i = 0; i0 &&arr[j+1]<0) { emp = arr[j]; arr[j]= arr[j+1]; arr[j+1]= emp; } } } for (int i=0; i<arr.length;i++) { System.out.print(arr[i] +" "); } } }

'''
n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다. 이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다.

정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다. 또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.

예. -1 1 3 -2 2 ans: -1 -2 1 3 2.
'''

sample = [-1, 1, 3, -2, 2]

minus = []
plus = []

for i in sample:
    if i < 0:
        minus.append(i)
    else:
        plus.append(i)
result = []
result = minus + plus
print(result)

파이썬 입니다

import random
N = list([random.randint(-100, 100) for i in range(30)])
n1, n2 = [], []
for i in range(len(N)):
    if N[i] < 0:
        n1.append(N[i])
    else:
        n2.append(N[i])
print(' 난수 배열 : ', N, '\n','정렬 배열 : ', n1+n2)

# sol.1
lst = [-1,1,3,-2,2]
x = []
y = []
for i in lst:
    if i < 0:
        x.append(i)
    else:
        y.append(i)
print(x + y)

# sol.2
lst = [-1,1,3,-2,2]
def specialSort(lst):
    lst1 = lst[:]
    x = []
    cnt = 0
    for i in range(len(lst1)):
        if lst1[i] < 0:
            x.insert(cnt,lst1[i])
            cnt += 1
        else:
            x.append(lst1[i])
    return x
specialSort(lst)  # [-1, -2, 1, 3, 2]

"""
Special Sort
먼저 3개의 리스트를 선언.
첫번째 리스트에 임의의 숫자를 저장.
리스트의 인덱스를 이용하여 음의정수인지, 양의정수인지 확인
음의정수이면 리스트 2번째에, 양의정수이면 리스트 3번째에 저장
리스트 2,3을 더해서 저장 후 출력.
"""
a = [-1,1,3,-2,2]
b, c = [],[]
for i in a:
    if i < 0:
        b.append(i)
    else:
        c.append(i)
result = b + c
print(result)

import java.util.Scanner;

public class Sort{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

        int i,j,k,r,temp;

        System.out.println("몇 개의 정수를 배열하시겠습니까?");
        int input = sc.nextInt();
        int [] n = new int [input];

        System.out.println(input + "개의 정수를 입력해주세요.");
        for(i=0;i<input;i++){
            n[i] = sc.nextInt();
        }

        for(j=0;j<input;j++){
            for(k=0;k<input-1;k++){
                if(n[k]>=n[k+1]){
                temp=n[k];
                n[k]=n[k+1];
                n[k+1]=temp;
                }
                else;
            }
        }

        System.out.print("배열 결과는 ");

        for(r=0;r<=input-1;r++){
        System.out.print(n[r] + " ");
        }

        System.out.println("입니다.");
    }
}

Swift입니다.

var inputArray = [-1, 1, 3, -2, 2];
print ( inputArray.filter { $0 < 0} + inputArray.filter {$0 >= 0})

def special_sort(lis) :
    pos = []
    nega = []
    for i in lis :
        if i > 0 : pos.append(i)
        else: nega.append(i)
    nega.extend(pos)
    return nega

print(special_sort([-1,1,3,-2,2]))

Common Lisp

(defun special-sort (li)
  (flet ((test (x)
           (< x 0)))
    (append (remove-if-not #'test li) (remove-if-not (complement #'test) li))))

(special-sort '(-1 1 3 -2 2))

(-1 -2 1 3 2)

import java.util.Arrays;

public class SpecialSort {

    public static int[] minusArray(int[] array){

        int count = 0;

        for(int i=0; i< array.length; i++){
            if(array[i] < 0){
                count++;
            }
        }

        int[] minusArray = new int[count];

        int minusCount = 0;

        for(int i = 0; i < array.length ; i++){
            if(array[i] < 0){
                minusArray[minusCount++] = array[i];
            }
        }

        return minusArray;
    }
    public static int[] plusArray(int[] array){

        int count = 0;

        for(int i=0; i< array.length; i++){
            if(array[i] > 0){
                count++;
            }
        }

        int[] plusArray = new int[count];

        int plusCount = 0;

        for(int i = 0; i < array.length ; i++){
            if(array[i] > 0){
                plusArray[plusCount++] = array[i];
            }
        }

        return plusArray;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {-1, 1, 3, -2, 2};

        int[] array1 = minusArray(array);
        int[] array2 = plusArray(array);

        int[] array3 = new int[array1.length + array2.length];

        System.arraycopy(array1, 0, array3, 0, array1.length);
        System.arraycopy(array2, 0, array3, array1.length, array2.length);

        System.out.println(Arrays.toString(array3));


    }

}

arr = [-1,1,3,-2,2]
minorArr = []
positiveArr = []

for i in range(len(arr)):
    if arr[i] < 0:
        minorArr.append(arr[i])
    else:
        positiveArr.append(arr[i])

print("\n")
minorArr.sort(reverse=True)

resultArr = minorArr+positiveArr

for i in range(len(resultArr)):
    print(resultArr[i])

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PracticeWW
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr1 = { -1, 1, 3, -2, 2 };
            int[] arr2= new int[5];
            int index = 0;

            foreach (var a in arr1)
            {
                if (a < 0)
                {
                    arr2[index++] = a;
                }
            }

            foreach (var a in arr1)
            {
                if (a > 0)
                {
                    arr2[index++] = a;
                }
            }

            foreach (var a in arr2)
                Console.WriteLine(a);
        }
    }
}

    public static String specialSort(int[] iArr) {
        int[] tmpArr1 = new int[iArr.length];
        int[] tmpArr2 = new int[iArr.length];
        int j = 0;
        int k = 0;
        for(int i = 0; i < iArr.length; i++) {
            if(iArr[i] < 0) tmpArr1[j++] = iArr[i];
            else tmpArr2[k++] = iArr[i];
        }
        for(int i = 0; i < j; i++) {
            iArr[i] = tmpArr1[i];
        }
        for(int i = j, l = 0; i < j + k; i++, l++) {
            iArr[i] = tmpArr2[l];
        }
        String[] strArr = Arrays.stream(iArr).mapToObj(String::valueOf).toArray(String[]::new);
        return String.join(", ", strArr);
    }

public static int[] sort(int[] arr){
        int poArr[] = new int[arr.length];
        int neArr[] = new int[arr.length];
        int resArr[] = new int[arr.length];
        int neCnt = 0,poCnt = 0;

        for(int i = 0; i< arr.length; i++){
            if(arr[i]<0){
                neArr[neCnt] = arr[i];
                neCnt++;
            }else{
                poArr[poCnt] = arr[i];
                poCnt++;
            }
        }


        Arrays.sort(poArr);
        Arrays.sort(neArr);

        for(int i =0; i< resArr.length ; i++){
            if(neArr[i]!=0){
                resArr[i] = neArr[i];
            }else{
                if(poArr[i]!=0){
                    resArr[i] = poArr[i];
                }
            }
        }
        return resArr;
    }

// Special Sort
package main

import (
    "fmt"
)

func main() {
    var input []int
    input = []int{-1, 1, 3, -2, 2}
    rstNeg, rstPos := []int{}, []int{}
    for _, v := range input {
        if v < 0 {
            rstNeg = append(rstNeg, v)
        } else {
            rstPos = append(rstPos, v)
        }
    }
    rst := []int{}
    rst = append(rst, rstNeg...)
    rst = append(rst, rstPos...)
    fmt.Println(rst)
}

python3 입니다

numbers = [-1, 1, 3, -2, 2]

negative = []
positive = []
for number in numbers:
    if number < 0:
        negative.append(number)
    else:
        positive.append(number)

result = negative + positive
print(result)

#include <stdio.h>
#include <stdlib.h>

int special_sort(int* arr_ray, int n, int* temp)
{
    int i, j=0;
    for(i=0;i<n;i++)
    {
        if(arr_ray[i]<0)
        {
            temp[j] = arr_ray[i];
            j++;
        }
    }
    for(i=0;i<n;i++)
    {
        if(arr_ray[i] >= 0)
        {
            temp[j] = arr_ray[i];
            j++;
        }
    }
}

int main()
{
    int *arr, i, j, n;
    printf("입력할 정수 개수를 입력하세요 : ");
    scanf("%d", &n);
    arr = (int*)malloc(sizeof(int)*n); //동적메모리 할당 
    int num[sizeof(int)*n];
    int *result = num; //결과값을 받을 포인트 배열에 num의 주솟값을 넣는다. 
    for(i=0;i<n;i++)
    {
        printf("%d번째 정수를 입력하세요 : ", i+1);
        scanf("%d", arr+i); // &arr[i]로 대체가능 
    }
    special_sort(arr, n, result); //스페셜 소트 호출!! 


    for(j=0;j<n;j++)
        printf("%d ", num[j]);
        free(arr);
    return 0;
}

#0이 나올떄 까지 문자열을 입력 받음

primarystr = []
n = 0

while(1):
    n = int(input("정수를 입력하시오: "))
    if n == 0:
        break
    primarystr.append(n)

print(list(primarystr))
length = int(len(primarystr))
print("리스트의 길이: ", length)

#양수리스트, 음수리스트 생성

pos = []
neg = []

#primarystr를 앞에서 부터 검사하며 양수를 pos에, 음수를neg에 순서대로 저장

for i in range(length):
    k = primarystr[i]
    if primarystr[i] > 0:
        pos.append(k)
    else:
        neg.append(k)

ans = neg + pos
print(list(ans))

#0이 나올떄 까지 문자열을 입력 받음

primarystr = []
n = 0

while(1):
    n = int(input("정수를 입력하시오: "))
    if n == 0:
        break
    primarystr.append(n)

print(list(primarystr))
length = int(len(primarystr))
print("리스트의 길이: ", length)

#양수리스트, 음수리스트 생성

pos = []
neg = []

#primarystr를 앞에서 부터 검사하며 양수를 pos에, 음수를neg에 순서대로 저장

for i in range(length):
    k = primarystr[i]
    if primarystr[i] > 0:
        pos.append(k)
    else:
        neg.append(k)

ans = neg + pos
print(list(ans))

import java.util.ArrayList;


public class SpecialSort_updated {

    public static void main(String[] args) {
        String[] arr = {"-1", "1", "3", "-2", "2"};
        ArrayList minus = new ArrayList();
        ArrayList plus = new ArrayList();

        for(int i=0; i<arr.length; i++) {
            if(arr[i].startsWith("-")){
                minus.add(arr[i]);
            } else {
                plus.add(arr[i]);
            }
        }

        for(int i=0; i<minus.size(); i++){
            System.out.println(minus.get(i));
        }

        for(int i=0; i<plus.size(); i++){
            System.out.println(plus.get(i));
        }

    }
}

public void Special()
{
    int[] nArraySort = {-1, 1, 3, -2, 2 };
    int nIndex = 0;

    int[] nArrayComp = new int[5];

    for(int i=0; i< nArraySort.Length; i++)
    {
        if (nArraySort[i] < 0)
        {
            nArrayComp[nIndex++] = nArraySort[i];
        }
    }

    for (int i = 0; i < nArraySort.Length; i++)
    {
        if (nArraySort[i] > 0)
        {
            nArrayComp[nIndex++] = nArraySort[i];
        }
    }
    foreach(var item in nArrayComp)
    {
        Console.Write(item  + " ");
    }
    Console.WriteLine();
}

def special_sort(a):
    list=[]
    a = a.split()
    l = len(a)
    for i in range(0,l):
        source1 = int(a[i])
        if source1 < 0:
            list.append(source1)
    for j in range(0, l):
        source2 = int(a[j])
        if source2 >= 0:
            list.append(source2)
    return print(list)

a = input("Enter the integers: ", )
special_sort(a)

import java.util.ArrayList;
import java.util.Scanner;

public class 2 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<Integer> a = new ArrayList<Integer>();
        int plus = 0;
        int minus = 0;
        while((scan.hasNextInt())){
            int n = scan.nextInt();
            System.out.println(n);
            if(n >= 0)
                a.add((plus++) + minus,n);
            else
                a.add(plus + (minus++), n);
        }
        for(int i : a){
            System.out.print(i+ " ");
        }
}
}

C

#include <stdio.h>
#define N 10

int main() {
    int n[N] = { 0, }, i, cnt = 0, t[N], j = 0;
    for (i = 0; i < N; i++) {
        scanf_s("%d", &n[i]);
        if(n[i]>=0)
            t[cnt++] = n[i];
    }

    for (i = 0; i < N; i++) 
        if (n[i] < 0) 
            n[j++] = n[i];
    cnt=j;
    for (i = 0; i < N - cnt; i++) n[j++] = t[i];

    for (i = 0; i < N; i++) printf("%d ", n[i]);
    printf("\n");

    return 0;
}

my_list = [-1,1,3,-2,2]

positive=[]
negative =[]

for x in my_list:
    if x >0:
        positive.append(x)
    else : 
        negative.append(x)

final_list=[negative+positive]

print (final_list) 

num = [-1,1,3,-2,2]

def sor(num):
    minus=[]
    plus=[]
    for i in num:
        if i < 0:
            minus.append(i)
        else:
            plus.append(i)
    result = minus+plus
    return result
print(sor(num))

def PosNeg(lst): Pos_l = [] Neg_l = [] for number in lst: if number > 0: Pos_l.append(number) elif number < 0: Neg_l.append(number) result = Neg_l + Pos_l return result

l = [-1,1,3,-2,2] print(PosNeg(l))

  public static void main(String[] args) throws Exception { 
        int[] nums = {-1, 1, 3, -2, 2};

        for (int i=0; i<nums.length-1; i++) {
            for (int j=0; j<nums.length-2; j++) {
                if(nums[j] > nums[j+1] && !(nums[j] < 0 && nums[j+1] < 0)) {
                    int tmp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }// 자바입니다. 기본적인 버블정렬인데 비교 대상이 음수가 아닐 경우에만 적용시켰습니다

a = [-1,1,3,-2,2]
b=[];c=[]
for i in range(len(a)):
    if a[i] < 0:
        b.append(a[i])
    else : c.append(a[i])

print(b+c)

파이썬으로 작성. 간단한 버블배열

n = int(input("리스트의 크기: "))

list = []

for i in range (0, n):
    list.append(int(input("정수 입력: ")))

for i in range (0, n - 1):
    flag = False

    for j in range (0, n - 1):
        if (list[j] > 0 and list[j + 1] < 0):
            list[j : j + 2] = reversed(list[j : j + 2])
            flag = True
    if flag == False:
        break;

for i in range (0, n):
    print(list[i], end=' ')

Array = [-1, 1, 3, -2, 2]
Array1 = []
Array2 = []
for i in Array:
    if i < 0:
        Array1.append(i)
    else:
        Array2.append(i)
Array = Array1 + Array2

print(Array)

Python 딱 생각나는대로 풀었습니다.

python

a=[-1, 1, 3, -2, 2]
nega=[]
posi=[]
for i in range(len(a)):
    if a[i]<0:
        nega.append(a[i])
    elif a[i]>0:
        posi.append(a[i])
print(nega+posi)

public static void main(String[] args) {

        int num[] = {-1, 1, 3, -2, 2};
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < num.length; i++) {
            if (num[i] < 0) {
                list.add(num[i]);
            }
        }
        for (int i = 0; i < num.length; i++) {
            if (num[i] > 0) {
                list.add(num[i]);
            }
        }
        System.out.println(list);
    }

그냥 순서대로 넣었네요.. 효율은 갖다버린 코드

num=list
num1=list
num=input("숫자입력하시오:").split()
num.sort()
num1=list(map(int,num))
print(num1)

public class Test{
    public static void main(String args[]) throws Exception{
        int[] list = {-1,1,-3,3,-2,2,4};
        int length = list.length-1;
        for(int i=0; i<length; i++){
            for(int j=0; j<(length-i); j++){
                if(list[j] > 0 && list[j+1] < 0){
                    int k = list[j];
                    list[j] = list[j+1];
                    list[j+1] = k;
                }
            }
        }
        for(int k : list) {
            System.out.print(k+" ");
        }
    }
}

int main()
{
    int arrNum[5] = { -4, 1, 3, -2, -1 };

    while (true)
    {
        bool isSwitch = false;

        for (int i = 0; i < 5; i++)
        {
            if (arrNum[i] > 0)
            {
                if (i + 1 < 5)
                {
                    if (arrNum[i + 1] < 0)
                    {
                        int temp;
                        temp = arrNum[i];
                        arrNum[i] = arrNum[i + 1];
                        arrNum[i + 1] = temp;
                        isSwitch = true;
                    }
                }
            }
        }

        if (!isSwitch)
        {
            break;
        }
    }

    for (int i = 0; i < 5; i++)
    {
        cout << arrNum[i] << " ";
    }
    cout << endl;
    return 0;
}

 function aaa(){
 const minusArray = [];
 const plusArray = [];
 const ar = [-1,1,3,-2,2];

for(let e of ar){
 if(e>=0){
    plusArray.push(e)
  } else{
    minusArray.push(e)
  }
  }
const c  = minusArray.concat(plusArray)

console.log(c);

```

파이썬 3.6 제출합니다.

임의의 리스트를 받아서 정답을 출력합니다.

def special_sort(num_list):
    def positive(x):
        return x >= 0

    def negative(x):
        return x < 0

    positive_list, negative_list = [], []
    positive_list = positive_list + list(filter(positive, num_list))
    positive_list = sorted(positive_list)
    negative_list = negative_list + list(filter(negative, num_list))
    negative_list = sorted(negative_list)
    negative_list = list(reversed(negative_list))
    return negative_list + positive_list

special_sort([-5,3,-1,5,-7,1,-2,0])


[-1, -2, -5, -7, 0, 1, 3, 5]

public class test {
    public static void main(String[] args) {
        int[] array = { -1, 1, 3, -2, 2 };
        int[] temp = new int[array.length];
        for (int i = 0; i < array.length; i++)
            if (array[i] < 0)
                temp[i] = array[i];
        Arrays.sort(temp);
        for (int i = array.length - 1; i > -1; i--)
            if (temp[i] != 0)
                System.out.print(temp[i] + " ");
        for (int i = 0; i < array.length; i++)
            if (array[i] > -1)
                System.out.print(array[i] + " ");
    }
}

Scanner sc = new Scanner(System.in); int count; int data; ArrayList Positive = new ArrayList<>(); ArrayList negative = new ArrayList<>();

public SpecialSort() {
    while(true) {

        if(count++ > 4) { break; }

        System.out.print("숫자를 입력해주세요 : ");
        data = sc.nextInt();

        if(data > 0) {
            Positive.add(data);
        } else {
            negative.add(data);
        }           
    }
    System.out.println(negative + ", " +  Positive);
}

    Scanner sc = new Scanner(System.in);
    int count;
    int data;
    ArrayList<Integer> Positive = new ArrayList<>();
    ArrayList<Integer> negative = new ArrayList<>();

    public SpecialSort() {
        while(true) {

            if(count++ > 4) { break; }

            System.out.print("숫자를 입력해주세요 : ");
            data = sc.nextInt();

            if(data > 0) {
                Positive.add(data);
            } else {
                negative.add(data);
            }           
        }
        System.out.println(negative + ", " +  Positive);
    }

def google(list):
    minus = [x for x in list if x<0]
    plus = [x for x in list if x>=0]
    print(minus+plus)

google([1,5,-5,9,-7,-2])

public class q28_specialSort {  
    public static void main(String[] args) {

        int[] arr = {-1, 1, 3, -2, 2};

        List<Integer> arrM = new ArrayList<Integer>(); 
        List<Integer> arrP = new ArrayList<Integer>();
        List<Integer> result = new ArrayList<Integer>();
        Integer arrZ = null;

        for(int i = 0 ; i < arr.length ; i++) {
            if(arr[i] < 0) {
                arrM.add(arr[i]);
            }
            else if(arr[i] == 0) {
                arrZ = 0;
            }
            else {
                arrP.add(arr[i]);
            }
        }

        result.addAll(arrM);
        if(arrZ != null) {
            result.add(arrZ);
        }
        result.addAll(arrP);

        System.out.println(result);             

    }
}

Python

test = [-1, 1, 3, -2, 2] # test = list(map(int, input().split(' ')))
neg = list(); pos = list();
for i in test:
    if i < 0:
        neg.append(i)
    else:
        pos.append(i)
print(neg+pos)
#Shorten version
print([i for i in test if i < 0] + [i for i in test if i >= 0])

package com.practicejava;

import java.util.Arrays;

public class SortNum {
    public static void main(String[] args) {
        int[] num = { -1, 1, 3, -2, 2 };
        int temp = 0;

        for (int i = 0; i < num.length - 1; i++) {
            if (num[i] > 0 && num[i + 1] < 0) {
                temp = num[i];
                num[i] = num[i + 1];
                num[i + 1] = temp;
                i = 0;
            }
        }
        System.out.println(Arrays.toString(num));
    }
}

list_old = [-1, 1, 3, -2, 2]
list_new_p, list_new_n  = [], []

for i in list_old:
    if i < 0:
        list_new_n.append(i)
    else:
        list_new_p.append(i)

print("ans: ", list_new_n + list_new_p)

[지적 환영입니다. 초보라 무조건 하드코딩..]

array = [-1,1,3,-2,2]
minusans = []
plusans = []

for i in array:
    if(i<0):
        minusans.append(i)
    elif(i>0):
        plusans.append(i)

print (minusans+plusans)

my_list = [-1, 1, 3, -2, 2]

minus_arr = []

for index, val in enumerate(my_list):
    if val < 0:
        temp = my_list.pop(index)
        minus_arr.append(temp)

result = minus_arr + my_list

print(result)

def solting(arr):
    return [num for num in arr if num<0]+[num for num in arr if num>0]

버블정렬과 유사하게 처리하였습니다.

/**
 * n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다. 이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야
 * 한다. 정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다. 또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.
 * 
 * 예. -1 1 3 -2 2 ans: -1 -2 1 3 2.
 * 
 * @author whitebeard-k
 *
 */
public class SpecialSort {

    public static void main(String[] args) {

        int[] array = { -1, 1, -5, 1, 9, 0, 2, 3, -2, 2, -9 };

        // 첫번째가 음수이면 커서는 두번째 
        int cursor = array[0] < 0 ? 1 : 0;

        for (int i = 1; i < array.length; i++) {

            // 현재 데이터가 음수 이면 cursor 위치에 음수를 넣고 인덱스까지 데이터를 밀어준다. 
            if (array[i] < 0) {
                swap(array, i, cursor);
                cursor++;
            }
        }

        for (int i : array)
            System.out.printf("%2d ", i);
    }

    // cursor에서 index까지 데이터를 밀어준다. 
    private static void swap(int[] array, int index, int cursor) {

        int temp = array[index];
        for (int i = index; i > cursor; i--) {
            array[i] = array[i - 1];
        }

        array[cursor] = temp;
    }
}

import java.util.*;

public class Shakkur { public static void main(String[] args) { Listnums=new ArrayList(Arrays.asList(-1, 1, 3, -2, 2)); int index=0;

    for(int i=0;i<nums.size();i++) {
        if(nums.get(i)<0) {
            if(i!=index) {
                int add=nums.get(i);
                nums.remove(i);
                nums.add(index, add);
            }
            index++;
        }
    }

    System.out.println(nums);
}

}

a = [-1, 1, 3, -2, 2]
result = []
result1 = []
for i in a:
    if i < 0:
        result.append(i)
    else:
        result1.append(i)

result.extend(result1)

array = [-1,1,3,-2,2,0]
print([i for i in array if i<0]+[i for i in array if i==0]+[i for i in array if i>0])

def solution():
    numbers = [-1, 1, 3, -2, 2]
    print(numbers)

    idx = 0
    for i in range(len(numbers)):
        if numbers[idx] > 0:
            numbers.append(numbers.pop(idx))
        else:
            idx += 1

    print(numbers)

class Main {

    public static void main(String[] args) {
        int numArr[] = {-1, 1, 3, -2, 2};
        numArr = sortSpecial(numArr);

        System.out.println(Arrays.toString(numArr));
    }

    static int[] sortSpecial(int[] numArr) {
        ArrayList<Integer> tmp = new ArrayList<Integer>();

        for (int i = 0; i < numArr.length; i++) {
            if (numArr[i] < 0) {
                tmp.add(numArr[i]);
            }
        }

        for (int i = 0; i < numArr.length; i++) {
            if (numArr[i] >= 0) {
                tmp.add(numArr[i]);
            }
        }

        for (int i = 0; i < numArr.length; i++) {
            numArr[i] = tmp.get(i);
        }

        return numArr;
    }

}

neg=[ ]
pos=[ ]

def order(num_list):
    for i in num_list:
        if i < 0:
            neg.append(i)
        elif i >= 0:
            pos.append(i)
    return neg+pos

order([-1,1,3,-2,2])

Python으로 작성

def do(list):
    return [x for x in list if x < 0] + [x for x in list if x > 0]

print(do([-1,1,3,-2,2])

파이썬

def fn(str1):
    list1 = str1.split(" ")
    minus_list = [x for x in list1 if int(x) < 0]
    plus_list = [x for x in list1 if int(x) >= 0]
    print(" ".join(minus_list + plus_list))


fn("-1 1 3 -2 2") 
# ans: -1 -2 1 3 2.

list=[-1,1,3,-2,2]
ans=[num for num in list if num<0]+[num for num in list if num>0]
print(ans)

data=[-1,1,3,-2,2]
plus=[]
minus=[]
for n in data:
    if n>=0:
        plus.append(n)
    else:
        minus.append(n)
print(minus+plus)

array = [50,9,5,3,7,58,5,0,-5,-7,3,-10,5,-52]  #임의의 배열

array_p = []  #0포함 양의 정수 저장할 배열
array_m = []  #음의 정수 저장할 배열

for i in array:
    if i < 0:
        array_m.append(i)
    elif i >= 0:
        array_p.append(i)

array_sort = array_m + array_p
print(array_m)
print(array_p)
print(array_sort)

<------결과-------> [-5, -7, -10, -52] [50, 9, 5, 3, 7, 58, 5, 0, 3, 5] [-5, -7, -10, -52, 50, 9, 5, 3, 7, 58, 5, 0, 3, 5]

include

include

int main(){ int userInput = 0; scanf("%d", &userInput);

int *numPtr = malloc(sizeof(int) * userInput);

// 할당 동적 메모리에 정수 저장
for(int i =0; i < userInput; i++)
{
    scanf("%d",&numPtr[i]);
}


//음수 먼저 뺴기
for(int i=0; i < userInput; i++)
{
    if(numPtr[i] < 0)  printf("%2d", numPtr[i]);
}

//양수 빼기
for(int i=0; i < userInput; i++)
{
    if(numPtr[i]>0)    printf("%2d", numPtr[i]);
}

}

파이썬입니다

pos,neg = [], []
for x in input().split():
    if int(x) > 0 : pos.append(x)
    else : neg.append(x)
print(" ".join(neg + pos))

c언어입니다. 

#include<stdio.h>
#include<algorithm>
using namespace std;

int main()
{
    int i;
    int a[] = {-1,5,4,2,3,-6,9,-19};
    int len = sizeof(a)/sizeof(int);
    printf("%d \n", len);
    sort(a, a+8);

    for(i=0; i<len; i++)
    {
        printf("%d ", a[i]);
    }

}

import java.util.ArrayList;

public class mainKong {
    public static void main(String[] args) {
        int[] n = {-1, 1, 3, -2, 2};
        ArrayList<Integer> result = new ArrayList<>();

        for(int i = 0; i < n.length; i++){
            if(n[i] < 0){
                result.add(n[i]);
            }
        }
        for(int i = 0; i < n.length; i++){
            if(n[i] == 0){
                result.add(n[i]);
            }
        }
        for(int i = 0; i < n.length; i++){
            if(n[i] > 0){
                result.add(n[i]);
            }
        }

        System.out.println(result.toString());
    }
}

#구글 전화면접 문제

def sorting(x):
    minus=[]
    plus=[]
    n=len(x)
    for i in range(0,n):
        if x[i]<0:
            minus.append(x[i])
        else:
            plus.append(x[i])

    return minus+plus


print(sorting([-1,1,3,-2,2]))

def sort(numlist):
    list= [num for num in numlist if num<0]+[num for num in numlist if num>=0]
    return list

파이썬입니다.

def sol(num):
   return [i for i in num if i < 0] + [i for i in num if i >= 0]

print(sol[-1,1,3,-2,2])

data=[-1,1,3,-2,2]
imsi=[]
result=[]
for i in data:
    if i < 0:
       imsi.append(i) 
    elif i > 0:
        result.append(i)
print(imsi+result)

list_num = ['-1', '1', '3', '-2', '2']

list_plus = []
list_minus = []
for i in range(len(list_num)):
    if int(list_num[i]) > 0:
        list_plus.append(list_num[i]) # 0보다 크면 플러스 리스트에 누적
    else:
        list_minus.append(list_num[i]) #0보다 작으면 마이너스 리스트에 누적

print(list_minus + list_plus) #마이너스 리스트를 먼저 출력하고 이어서 플러스 리스트를 출력

저랑 똑같은 생각을 하신 분들이 많이 계시는 군요

def sort1(lis):
     print(list(a for a in lis if a < 0 ) + list(b for b in lis if b > 0))

파이썬은 약어가 매력적이네요.

def s(*n):
    m = [i for i in n if i < 0]
    p = [i for i in n if i > 0]
    return m + p

lst_unsorted = list()
i = 1
n = int(input("array length"))
while i <= n:
    a = int(input("put the number"))
    lst_unsorted.append(a)
    i = i + 1

lst_negative = list()
lst_positive = list()
for i in lst_unsorted:
    if i < 0:
        lst_negative.append(i)
    elif i > 0:
        lst_positive.append(i)
lst_sorted = lst_negative + lst_positive

print(lst_sorted)

저는 python을 사용하였습니다. 리스트 컴프리헨션,, 처음듣네요^^ 배워갑니다~ 그리고 코드를 간결하게 하도록 연습할 필요가 있어보이네요^^ 화이팅합시다.

1. n개의 정수를 가진 배열을 입력으로 받는다.
2. 첫번째 수부터 검사해서 음수면 음수 배열에, 양수면 양수 배열에 추가한다.
3. 다음 수로 넘어간다.
4. 2번 반복
5. 모든 수를 검사했으면 음의 정수 배열 뒤에 양의 정수 배열을 붙인다.
6. 음의 정수 배열 내용을 출력한다.

inputData = input("정수 배열을 입력하세요. ").split()
negativeList = list()
positiveList = list()
answerStr = ""

for strElement in inputData:
    elementValue = int(strElement)
    if elementValue < 0:
        negativeList.append(elementValue)
    elif elementValue > 0:
        positiveList.append(elementValue)

for i in positiveList:
    negativeList.append(i)

for element in negativeList:
    answerStr = answerStr + str(element) + " "

print(answerStr)

원글에는 O(n) 시간 복잡도와 O(1) 공간복잡도를 요구하는데 이는 불가능합니다.

음의 정수들을 한 배열에, 다른 배열에 양의 정수를 넣고 반환하게되면 공간 복잡도는 O(n)이 됩니다. 그렇다고 정렬을 쓰게 되면 시간 복잡도가 O(n log n)이고 방법에 따라 O(n^2)가 될 수도 있습니다.

배열이 아니라 리스트였다면 양수를 발견하면 해당 요소를 뒤에 붙여주고 현재 요소를 지우는 형식으로 공간복잡도와 시간복잡도 만족이 가능합니다.

import numpy as np
arr = np.array([-1,2,4,6,7,5,-9])
m = arr[arr < 0]
p = arr[arr > 0]
print(np.append(m,p))

a=input().split()
l=len(a)
lst=[]

for b in range(l):
    for i in range(len(a)):
        if int(a[i])<0:
            lst.append(a.pop(i))
            break

res=' '.join(lst+a)
print(res)

C#

using System;
using System.Linq;

namespace CD028
{
    class Program
    {
        static void Main()
        {
            int[] input = { -1, 1, 3, -2, 2 };

            int[] result = input.Where(e => e <= 0).Concat(input.Where(e => e > 0)).ToArray();
            Console.WriteLine(string.Join(", ", result));
        }
    }
}

l1= input("input list : ")

l1 = list(l1)



l2 = [i for i in l1 if i < 0] + [i for i in l1 if i > 0]

print(l2)

list = [-1, 1, 3, -2, 2]

def sort_list(list): l1, l2 = [], [] for li in list: if li < 0: l1.append(li) else: l2.append(li) result = l1 + l2 return result print(sort_list(list)) 파이썬 3.7 버전입니다. 아직 파이썬 초보라서 많이 부족합니다.

// =============================================
        int[] n = { -1, 1, 3, -2, 2 };
        int[] minus = new int[n.length];

        for (int i = 0; i < n.length; i++) {
            if (n[i] < 0) {
                minus[i] = n[i];
            }
        }
        Arrays.sort(minus);
        for (int i = minus.length - 1; i > -1; i--) {
            if (minus[i] != 0) {
                System.out.print(minus[i] + " ");
            }
        }
        for (int j = 0; j < n.length; j++) {
            if (n[j] > -1) {
                System.out.print(n[j] + " ");
            }
        }

#pragma warning (disable : 4996)
#include <stdio.h>
int main()
{
    int mat1[5] = { 0 };
    int mat2[5] = { 0 };
    int i = 0, temp = 0;
    for (i = 0; i < 5; i++)
    {
        printf("정수를 입력하세요 : ");
        scanf("%d", &temp);
        if (temp < 0)
        {
            mat1[i] = temp;
        }
        else
        {
            mat2[i] = temp;
        }
    }
    for (i = 0; i < (sizeof(mat1) / sizeof(int)); i++)
    {
        if (mat1[i] != 0)
        {
            printf("%d ", mat1[i]);
        }
    }
    for (i = 0; i < (sizeof(mat2) / sizeof(int)); i++)
    {
        if (mat2[i] != 0)
        {
            printf("%d ", mat2[i]);
        }
    }
    return 0;
}

C입니다. 좀 더 간단하고 명료하게 할 수 있을 것 같은데 감이 안 잡히네요...

def sort_by_sign(src):
    negatives = []
    positives = []
    for i in src:
        if i < 0:
            negatives.append(i)
        else:
            positives.append(i)
    return negatives + positives

if __name__ == "__main__":
    source = [-1, 1, 3, -2, 2]
    print sort_by_sign(source)

그냥 심플한 접근...

def sorting(a):
    count=0
    for i in range (0, len(a)) :
        if a[i]<0 :
            a.insert(count,a.pop(i))
            count+=1
            print(a)
    return a

처음에는 리스트로 입력, 출력했다가 문제처럼 입출력하고 싶어서 이렇게 해봤습니다!

def new_sort():
    numbers = input("Enter: ")
    list = numbers.split()
    result = []
    for item in list:
        if int(item) < 0:
            print(item, end = " ")
    for item in list:
        if int(item) > 0:
            print(item, end = " ")

new_sort()

def sort(args:List[Int]): List[Int] = {
        args.filter(_ < 0) ++ args.filter(_ == 0) ++ args.filter(_ > 0)    
  }

#Special Sort

import numpy as np

#n개의 정수 무작위로 추출
n = 10
int = np.random.randint(-n,n, n)
int = list(int)

#음의 정수와 양의 정수를 구분해서 저장
neg_list = []
pos_list = []
for i in range(n):
    if int[i] < 0:
        neg_list.append(int[i])
    else:
        pos_list.append(int[i])

#분리된 음의 정수와 양의 정수를 합쳐준다.
final = neg_list + pos_list
print(int)
print(final)

num_list = [-1, 1, 3, -2, 2]

low_list = []
up_list = []

for i in num_list:
    if int(i) < 0:
        low_list.append(i)
    else:
        up_list.append(i)

print(low_list + up_list)

def special_sort(a): b=[] for i in range(0,len(a)): if(a[i](-1)>0): b.append(a[i]) for i in range(0,len(a)): if(a[i](-1)<0): b.append(a[i]) return b

qlist = [-1, 1, 3, -2, 2, 0,10,8,-20,7,-9,21] alist = [] mindex = 0 for index, i in enumerate(qlist): #for 반복문으로 요소의 값을 출력할 때 인덱스도 함께 출력하고 싶을 수도 있습니다. 이때는 enumerate를 사용합니다. if index == 0: alist.append(i) if i < 0: mindex = index else: if i < 0:
mindex = mindex+1 alist.insert(mindex, i) else: if i == 0: mindex = mindex+1 alist.insert(mindex,i) mindex = mindex-1 else: alist.append(i)

print(alist)

num_list=list(input().split())
cn=len(num_list)
for x in range(0,cn):
    num_list[x]=int(num_list[x])
for k in range(1,cn):
    if num_list[0]>=0:
        for x in range(0,cn):
            if num_list[x]<0 and num_list[x-1]>0:
                tmp=num_list[x]
                num_list[x]=num_list[x-1]
                num_list[x-1]=tmp
    elif num_list[0]<0:
        for x in range(1,cn):
            if num_list[x]<0 and num_list[x-1]>0:
                tmp=num_list[x]
                num_list[x]=num_list[x-1]
                num_list[x-1]=tmp
print(num_list)

array = [-1, 1, 3, -2, 2]

plus = []
minus = []

for i in array:
    if i > 0:
        plus.append(i)
    elif i < 0:
        minus.append(i)

print(minus + plus)

#include <stdio.h>

void sort(int* pArr) {
    int negativeArr[5];
    int positiveArr[5];
    int i = 0, po_index = 0, ne_index = 0;

    for(i = 0; i<5; i++) {
        if(pArr[i] <= 0) {
            negativeArr[ne_index++] = pArr[i];
        } else {
            positiveArr[po_index++] = pArr[i];
        }
    }

    for(i=0; i<ne_index; i++) {
        printf("%d, ", negativeArr[i]);
    }
    for(i=0; i<po_index; i++) {
        printf("%d, ", positiveArr[i]);
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    int arr[5] = {-1, 1, 3, -2, 2};

    sort(arr);
    return 0;
}

def f4(arr):
    pl = []
    mi = []
    for i in range(len(arr)):
        if arr[i] >=0 :
            pl.append(arr[i])
        else:
            mi.append(arr[i])
    mi.extend(pl)
    result = mi
    return result

python

a=input().split()
b=[]

for i in a:
    if int(i)<0:
        b.append(i)
for i in a:
    if int(i)>0:
        b.append(i)
print(b)

else

a=input().split()
print([i for i in a if int(i)<0]+[i for i in a if int(i)>0])

public class KimSanghyeop
{
    public static void main(String[] args)
    {
        int[] arr= {-1,1,3,-2,2,4,5,-5};

        int f1;
        int temp;
        boolean loop=true;
        while(loop)
        {
            loop=false;

            for(f1=0;f1<arr.length-1;f1++)
            {
                if(arr[f1] >0 && arr[f1+1] < 0)
                {
                    temp =arr[f1];

                    arr[f1] = arr[f1+1];
                    arr[f1+1]=temp;
                    loop=true;
                }
            }
        }

        for(f1=0;f1<arr.length;f1++)
        {
            System.out.print(arr[f1] + " ");
        }
    }
}

a <- c(-1, 1, 3, -2, 2)
f <- a[a < 0]
b <- a[a >= 0]
ans <- c(f, b)

def sorting(x):
    array = x
    nul1 =[]
    nul2 =[]
    for i in range(0,len(array)):
        if int(array[i]) >0 :
            nul1.append(int(array[i]))
        else:
            nul2.append(int(array[i]))
    print(nul2+nul1)

List = [-1,1,3,-2,2]
NewList=[]
for i in List :
    if i <= 0 :
        NewList.append(i)
for j in List :
    if j > 0 :
        NewList.append(j)
print(NewList)

list comprehension using any python

print([i for i in integers if i < 0] + [j for j in integers if j > 0])

old_list = [-1, 1, 3, - 2, 2]
print([x for x in old_list if x < 0] + [y for y in old_list if y >= 0])

s = [-1, 1, 3, -2 ,2]
result = []
for x in s:
    if x < 0:
        s.remove(x)
        result.append(x)
for x in s:
    result.append(x)
print(result)

c++

include "pch.h"

include

using namespace std;

int main() { int Array[] = { -1,1,3,-2,2 }; int Sub[5]; int CountSub = 0; int Plus[5]; int CountPlus = 0;

for (int z = 0; z < 5; z++) {
    Sub[z] = NULL;
    Plus[z] = NULL;
}

for (int i = 0; i < 5; i++) {
    if (Array[i] < 0) {
        Sub[CountSub] = Array[i];
        CountSub++;
    }

    else if (Array[i] >= 0) {
        Plus[CountPlus] = Array[i];
        CountPlus++;
    }
}

for (int i = 0; i < 5; i++) {
    if (Sub[i] != NULL) {
        cout << Sub[i] << " ";
    }
}

for (int j = 0; j < 5; j++) {
    if (Plus[j] != NULL) {
        cout << Plus[j] << " ";
    }
}

}

#include <stdio.h>

int main() {
    int array[5]={-1,1,2,-3,0};
    int i,temp,j,k=0;
    for(i=0;i<5;i++){
        if(array[i]<0){
            for(j=i;j>k;j--){
                temp=array[j];
                array[j]=array[j-1];
                array[j-1]=temp;
            }
            k++;
        }


    }
    for(i=0;i<5;i++){
        printf("%2d",array[i]);
    }
}

namespace codingdojang__
{
    class Program
    {
        static void Main(string[] args)
        {
            string minus = "";
            string plus = "";

            string[] inp = Console.ReadLine().Split(' ');

            foreach(string e in inp)
            {
                int var = int.Parse(e);

                if (var < 0)
                {
                    minus = $"{minus} {var.ToString()}";
                }
                else if (var > 0)
                {
                    plus = $"{plus} {var.ToString()}";
                }
            }

            Console.WriteLine($"{minus},{plus}");
        }
    }
}

c#

list = ['-5','-7','-1','3','-2','5','4']
result = []
def sortNum(list):
    t1 = []
    t2 = []
    for i in list:
        if int(i) < 0:
            t1.append(i)
        else:
            t2.append(i)
    result = t1 + t2
    return result

print(sortNum(list))

def solution(l):
    return [n for n in l if n < 0] + [n for n in l if n >= 0]

print(solution([-1,1,3,-2,2]))

Java 8 Multi Thread

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class tut02 {
  public static void main(String[] args) {
    int[] input = {-1, 1, 3, -2, 2, 0};
    tut02 t = new tut02();

    ExecutorService executor = Executors.newFixedThreadPool(2);
    List<Future<List<Integer>>> list = new ArrayList<>();
    List<Integer> result = new ArrayList<>();

    Callable<List<Integer>> negCall = t.new negativeRunnable(input);
    Callable<List<Integer>> posCall = t.new positiveRunnable(input);

    list.add(executor.submit(negCall));
    list.add(executor.submit(posCall));

    for (Future<List<Integer>> fut : list) {
      try {
        result.addAll(fut.get());
      } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
      }
    }

    executor.shutdown();
    System.out.println(result);
  }

  class negativeRunnable implements Callable<List<Integer>> {
    private int[] input;
    private List<Integer> result = new ArrayList<>(); 

    public negativeRunnable(int[] input) {
      this.input = input;
    }

    @Override
    public List<Integer> call() throws Exception {
      for (int i = 0; i < input.length; i++) {
        if (input[i] <= 0) {
          result.add(input[i]);
        }
      }

      return result;
    }
  }

  class positiveRunnable implements Callable<List<Integer>> {
    private int[] input;
    private List<Integer> result = new ArrayList<>(); 

    public positiveRunnable(int[] input) {
      this.input = input;
    }

    @Override
    public List<Integer> call() throws Exception {
      for (int i = 0; i < input.length; i++) {
        if (input[i] > 0) {
          result.add(input[i]);
        }
      }

      return result;
    }
  }
}

#include <stdio.h>

int main() {
    int array[5] = { -1,1,2,-3,5 };
    int plus[100];
    int minus[100];
    int a = 0;
    int b = 0;
    for (int i = 0; i < 5; i++)
    {
        if (array[i] > 0)
        {
            plus[a] = array[i];
            a++;
        }
        if (array[i] < 0)
        {
            minus[b] = array[i];
            b++;
        }
    }
    int t ;

    for (int j=0;j<3;j++)
    {
        minus[b] = plus[j];
        b++;
    }

    for (int k = 0; k < 5; k++)
    {
        printf("%d", minus[k]);
    }
    return 0;
}

c언어입니다

arr = [-1, 1, 3, -2, 2]

arr_Negative = []
arr_Positive = []


for i in arr:
    if i < 0:
        arr_Negative.append(i)
    else:
        arr_Positive.append(i)

print(arr_Negative)
print(arr_Positive)

arr_sorted = arr_Negative + arr_Positive
print(arr_sorted)

package com.test;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {


        int[] a = {-1, 1, 3, -2, 2};

        for(int i = 0; i<a.length; i++) {

            for(int j = i+1; j<a.length; j++) {
                if(a[i] > 0 && a[j]<0) {
                    int b = a[j];
                    a[j] = a[i]; 
                    a[i] = b;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }

}

#include <stdio.h>
#include <math.h>

int main(void){
    int args[5] = {-1,1,3,-2,2};
    int args_size, temp;

    args_size = sizeof(args)/sizeof(args[0]);

    //printf("%d",abs(-5));

    for(int i = 0;i < args_size;i++){
            if(abs(args[i++]) <= abs(args[i])){
                temp = args[i++];
                args[i++] = args[i];
                args[i] = temp;
            }
    }

    for(int i = 0;i < args_size;i++){
        printf("%d ",args[i]);
    }

    return 0;
}

list1 = [-1, 1, 3, -2, 2]
res1 = []
res2 = []

for i in list1 :
    if i < 0 : 
        res1.append(i)
    else :
        res2.append(i)
res1 = res1 + res2
print(res1) 

# special_sort.py
import copy
inp_list = [-1, 7, 1, -3, -2, 2, 10]
out_list = copy.deepcopy(inp_list)

j = 0
for i in range(len(inp_list)):
    if inp_list[i] < 0:
        out_list[j] = inp_list[i]
        j += 1

for i in range(len(inp_list)):
    if inp_list[i] > 0:
        out_list[j] = inp_list[i]
        j += 1

print(out_list)

답 : [-1, -3, -2, 7, 1, 2, 10]

NegativeList = []
PositiveList = []

for i in n:
    if list[i] < 0 : NegativeList.append(list[i])
for i in n:
    if list[i] > 0 : PositiveList.append(list[i])

print(NegativeList+PositiveList)

list_ = list(map(int, input("정수 리스트 입력 : ").split()))
print(' '.join(map(str, [i for i in list_ if i < 0] + [i for i in list_ if i >= 0])))

negative_list = []
positive_list = []
zero_list = []

num = input('정수를 입력하세요: ')
list = num.split(' ')

for i in list:
    i = int(i)
    if i <= 0:
        negative_list.append(i)
    elif i == 0:
        zero_list.append(i)
    else:
        positive_list.append(i)

sorted_list = negative_list + zero_list + positive_list
print(sorted_list)

public class SpecialSort {

    public static void main(String[] args) {
        // n개짜리 정수 배열에서
        // 음수는 앞에, 양수는 뒤에 위치하게 정렬
        // 단 음수간의 순서와 양수간의 순서는 변함이 없어야 함
        int[] input = {-1, 1, 3, -2, 2};
        int[] sorted = new int[input.length];
        int numSorted = 0;

        // 음수를 배열 앞에 정렬
        for(int i=0; i<input.length; i++)
        {
            if(input[i] < 0)
            {
                sorted[numSorted++] = input[i];
            }
        }
        // 양수를 배열 뒤에 정렬
        for(int i=0; i<input.length; i++)
        {
            if(input[i] >= 0)
            {
                sorted[numSorted++] = input[i];
            }
        }
        for(int i : sorted)
            System.out.print(i+" ");
    }

}

n = [-1, 1, 3, -2, 2]
a = []
b = []

for i in n :
    if i >= 0 :
        a.append(i)
    else :
        b.append(i)

print(b + a)

```{.python} neg_list =[] pos_list=[]

num =input('정수를 입력하시오:') list= num.split(' ')

for i in list: i= int(i) if i<=0: neg_list.append(i) else: pos_list.append(i)

sort_list = neg_list + pos_list

print(sort_list) ```neg_list =[] pos_list=[]

num =input('정수를 입력하시오:') list= num.split(' ')

for i in list: i= int(i) if i<=0: neg_list.append(i) else: pos_list.append(i)

sort_list = neg_list + pos_list

print(sort_list)

List = []
while True :
    List.append(input("숫자를 입력해 주세요 : "))
    print("종료하시려면 exit를 입력해 주세요")
    print("계속 입력하시려면 아무키나 누르세요")
    a = input()
    if a == "exit":
        break
    else :
        continue
List.sort()
print(List)

list_ex = [-1,1,3,-2,2]
list_a = []
list_b = []

for i in list_ex:
    if i < 0:
        list_a.append(i)
    elif i > 0:
        list_b.append(i)

list_result= list_a + list_b
print(list_result)

def special_sort(x):
    temp1, temp2 = [], []
    for i in x:
        if i < 0:
            temp1.append(i)
        else:
            temp2.append(i)
    result = temp1 + temp2
    return result

list = map(int, input().split())
print (special_sort(list))

파이썬스럽게 풀지 못한 파이썬 코드

nList = [-1, 1, 3, -2, 2]

def SpecialSort(lList, n):
    # Check if this list have to sort.
    if lList[n] < 0 and n == 0:
        return SpecialSort(lList, n+1)
    elif lList[n] < 0 and n != 0:
        if lList[n-1] < 0:
            return SpecialSort(lList, n+1)
        elif lList[n-1] > 0:
            lList[n-1], lList[n] = lList[n], lList[n-1]
            return SpecialSort(lList, n+1)
    elif lList[n] > 0:
        for i in range(n,len(lList)-1-n):
            if (lList[i] * lList[i+1]) < 0:
                lList[i], lList[i+1] = lList[i+1], lList[i]
                # print(lList)
                return SpecialSort(lList, n+1)
        return lList
    else:
        return lList

print(SpecialSort(nList, 0))

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main(void)
{

    vector<int>cv;
    cv.push_back(-1);
    cv.push_back(1);
    cv.push_back(3);
    cv.push_back(-2);
    cv.push_back(2);


    for (vector<int>::iterator itr = cv.begin(); itr != cv.end(); itr++)
    {
        if (*itr < 0)
        {
            cout << *itr << " ";


        }
    }
    cv.erase(remove_if(cv.begin(), cv.end(), [](int i) {return i < 0; }),cv.end());//조건에 만족하는것들을 뒤로밀고 제일먼저 조건충족한애가리킴

    for (vector<int>::iterator itr = cv.begin(); itr != cv.end(); itr++)
    {
        cout << *itr << " ";
    }

}

def Special_Sort(list):
    minlist, plulist=[],[]
    for i in list:
        if i < 0: minlist.append(i)
        else: plulist.append(i)
    return minlist+plulist


listt = [-1, 1, 3, -2, 2]
print(Special_Sort(listt))

javascript 풀이 입니다!

1. 문제

n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다. 이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다. 정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다. 또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.

예. -1 1 3 -2 2 ans: -1 -2 1 3 2.

2. 풀이

function specialSort(arr){
  const array = arr.splice('')
  const minusint = array.filter(item => item<0)
  const plusint = array.filter(item => item>0)
  const result = minusint.concat(plusint)
  return result
}

const array = [-1, 1, 3, -2, 2]
specialSort(array)
//출력값: [-1, -2, 1, 3, 2]

list_before = input("정수 배열을 입력하세요:" )
list_after = list_input.split(" ")
list_after = list(map(int, list_after))

for m in range(0,len(list_after)):
    for n in range(m, len(list_after)):
        if list_after[n]<0 and list_after[n-1]>0:
            tmp = list_after[n-1]
            list_after[n-1] = list_after[n]
            list_after[n] = tmp

print(list_after)

numberlist = [-1,1,3,-2,2]
print([i for i in numberlist if i < 0] + [i for i in numberlist if i >= 0])

plus_number = []
minus_number = []
def Special_Sort(sentence):
    for i in sentence:
        if i < 0:
            plus_number.append(i)
        else:
            minus_number.append(i)
    result = plus_number + minus_number
    return result


print(Special_Sort([-1, 1, 3, -2, 2]))

Python을 사용한 초보자의 단순한 풀이입니다.

int_minus = [] int_plus = [] int_0 = [] int_total = []

def int_arrange(int_a) : for i in int_a :

    if i < 0 :
       int_minus.append(i)
    elif i == 0 :
       int_0.append(i)
    else :
        int_plus.append(i)

int_total = int_minus + int_0 + int_plus ;

return(int_total)

a = [ -1, 1, 3, -2, 2]

print(int_arrange(a) )

inseq = [-1, 1, 3, -2, 2]
print(sorted([i for i in inseq if i < 0], reverse=True) + [i for i in inseq if i >= 0])

파이썬 입니다.

ls = [-1,1,3,-2,2]

positive = ""
negative = ""

for i in ls:
    if i > 0:
        positive += str(i)
    else:
        negative += str(i)

sort_number = negative + positive

print(sort_number)

기본적인 기능만을 사용한 Python 코드 입니다.

def func(*args):
    negative_list = []
    positive_list = []
    for i in args:
        if i < 0:
            negative_list.append(i)
        else:
            positive_list.append(i)
    return negative_list + positive_list


print(func(-1, 1, 3, -2, 2))
[-1, -2, 1, 3, 2]

l = [-1, 1, 3, -2, 2]
i = 0
while i < 4:
  if l[i] >= 0 and l[i + 1] < 0:
    ch = l[i]
    l[i] = l[i + 1]
    l[i + 1] = ch
    i = i - 1
  else:
    i = i + 1
print(l)

파이썬 3.7 기준으로 작성한 것입니다.

a = list(map(int, input().split()))
pluslist = []
minuslist = []
for i in range(len(a)):
    if a[i] < 0:
        minuslist.append(a[i])
    if a[i] > 0:
        pluslist.append(a[i])

b = minuslist + pluslist

print(b)

# 설명
# 먼저, a라는 리스트를 입력할 때마다 input함수를 이용해서 리스트 요소를 추가하게 합니다.
# 그 다음 양의 정수만 모여져 있는 리스트와 음의 정수만 모여져 있는 리스트를 빈 상태로 추가합니다.
# for반복문을 이용해서 음의 정수와 양의 정수를 if문으로 이용해서 분별하게 합니다.
# 만약 음의 정수이면 minuslist의 요소를 추가하게 합니다.
# 만약 양의 정수이면 pluslist의 요소를 추가하게 합니다.
# 그 다음에는 b라는 리스트를 minuslist와 pluslist의 요소를 합치게 합니다.
# 그런 다음 b라는 리스트를 출력하게 합니다.

이게 구글 전화면접이었다니, 저는 이때까지 몰랐네요. 심지어 전화로 하다니... 어쨋든 모두들 새해 복 많이 받으십시오.

파이썬으로 작성해보았습니다~

before = [-1, 1, 3, -2, 2]
neg = list(i for i in before if i < 0)
pos = list(i for i in before if i >= 0)
neg.extend(pos)
print(neg)

elif가 더 낫지만..

result=list()
result=[i for i in target if i<0]+[i for i in target if i>0]

print(result)

python 3.7.1 어쩌다보니 댓글을 컨닝했네요.

a=[-1, 1, 3, -2, 2]
[x for x in a if x<0]+[x for x in a if x>=0]

a=[-1, 1, 3, -2, 2]
def decbubble(b):
    for i in range(0,len(b)-1):
        for j in range(0,len(b)-1-i):
            if b[j]>0 and b[j+1]<0:
                b[j],b[j+1]=b[j+1],b[j]
    return b
decbubble(a)                

public class SpecialSort {
    public static void main(String[] args){
        sort(1,-1,3,2,-2);
    }

    public static void sort(int ... num){        
        System.out.print("정렬 전 배열 : ");
        for(int i=0;i<num.length;i++)
            System.out.print(num[i]);

        for(int j=1;j<num.length;j++){
            for(int i=0;i<num.length-j;i++){
                if(num[i] > 0 && num[i+1] <0){
                    int a=num[i];
                    num[i] = num[i+1];
                    num[i+1] = a;
                }
            }
        }

        System.out.print("\n정렬 후 배열 : ");
        for(int i=0;i<num.length;i++)
            System.out.print(num[i]);

        System.out.print("\n");       
    }
}

list = [-1, 1, 3, -2, 2]
a = []
b = []

for i in list :
    if i > 0 :
        a.append(i)
    else :
        b.append(i)

print(b + a)

파이썬입니당 비슷한 풀이가 많네요...

def special_sort(lst):
    ans_p = []
    ans_n = []
    for i in lst:
        if i>=0:
            ans_p.append(i)
        else:
            ans_n.append(i)
    return ans_n + ans_p

beYeol = [-1, 1, 3, -2, 2]
eum = []
yang = []
for i in beYeol :
    if i < 0 :
        eum.append(i)
    else :
        yang.append(i)
ans = eum + yang
for j in ans :
    print(j, end=' ')

str_num=input("배열을 입력하세요(띄어쓰기로 구분)").split()
view_num=[]
view_num2=[]
for cell_num in str_num:
    cell_num=int(cell_num)
    if cell_num < 0:
        view_num.append(cell_num)
    else:
        view_num2.append(cell_num)
print(view_num+view_num2)

num = input("숫자들을 입력하시오. : ").split(" ")
answer = []
for i in range(num.__len__()) :
    if (int(num[i]) < 0 ) :
        answer.append(int(num[i]))
for i in range(num.__len__()):
    if (int(num[i]) > 0) :
        answer.append(int(num[i]))
print(answer)

user_input = input("정수 배열을 입력하세요(공백으로 구분) : ").split()
negative_number = []
positive_number = []
for i in range(len(user_input)):
    if int(user_input[i]) < 0:
        negative_number.append(user_input[i])
    else: positive_number.append(user_input[i])
total_list = negative_number + positive_number
for i in total_list:
    print(i, end=" ")

var arr = [-3, 1, 14, 15, -2, 2];

for (var i = 0; i < arr.length; i++) {
    var index = arr.findIndex(function (item) {
        return Math.sign(item) > 0;
    });
    if (arr[i] < 0 && arr[i - 1] > 0) {
        var temp = arr.splice(i, 1);
        arr.splice(index, 0, temp[0])
    }
}

console.log(arr.join(' '));

import random
randombox = random.sample(range(-30,31),10)
box = []
boxbox = []
for inti in randombox:
    if inti >= 0: box.append(inti)
    else: boxbox.append(inti)
print(randombox)
print(boxbox + box)

arr = [-1,1,3,-2,2]
min=[]
max=[]
for i in arr:
    if i<0:
        min.append(i)
        continue
    max.append(i)

print(min+max)

``````
arr = [-1,1,3,-2,2]
min=[]
max=[]
for i in arr:
    if i<0:
        min.append(i)
        continue
    max.append(i)

print(min+max)

list_positive=[]
list_negative=[]

list_positive = list(filter(lambda x:x>0, my_list))
list_negative = list(filter(lambda x:x<0, my_list))
my_list = list_negative + list_positive

print(my_list)

a = [-1, 1, 3, -2, 2]
print([x for x in a if x < 0]+[x for x in a if x > 0])

list_positive=[]
list_negative=[]

list_positive = list(filter(lambda x:x>0, my_list))
list_negative = list(filter(lambda x:x<0, my_list))
my_list = list_negative + list_positive

print(my_list)

data = input("정수 입력: ")
numbers = list(data.split(' '))

zeros = []
positive = []
negative = []

for num in numbers:
    if int(num) > 0:
        positive.append(num)
    elif int(num) < 0:
        negative.append(num)
    elif int(num) == 0:
        zeros.append(num)

result = ' '.join(negative + zeros + positive)
print(result)

data=[-1,1,3,0,-2,0,2]
plus_list=[i for i in data if i>0]    #양의정수 리스트
minus_list=[i for i in data if i<0]    #음의정수 리스트
zero_list=[i for i in data if i==0]       #0 리스트

result=minus_list+zero_list+plus_list 
print(result)

problem=[-1,1,3,-2.2]
plus=[]
minus=[]
for i in problem:
    if i>0:
        plus.append(i)        
    else:
        minus.append(i)
answer=minus+plus
print(answer)

def specialsort(nums):
    t1, t2 = [], []
    for num in nums:
        if num < 0:
            t1.append(num)
        else:
            t2.append(num)
    return t1 + t2

nums = [-1, 1, 3, -2, 2]
print(specialsort(nums))

def s_sort(*t): p=[] m=[]     z=[]     for i in t: if i>0: p.append(i) elif i==0: z.append(i) else: m.append(i) print(m+z+p)

c로 풀어봤어요

include

int main() { int g[] = { -1, 1, -4, 3, -2, 2 , -1, 5}; int g_len = sizeof(g) / sizeof(int); int count = 0; int temp;

printf("배열: ");
for (int i = 0; i < g_len; i++)
    printf("%d ", g[i]);
printf("\n");

while (count < g_len - 1) {
    count = 0;
    for (int i = 0; i < g_len - 1; i++) {
        if (g[i] > 0 && g[i + 1] < 0) {
            temp = g[i];
            g[i] = g[i + 1];
            g[i + 1] = temp;
        }
        else
            count++;
    }
}
printf("정렬: ");
for (int i = 0; i < g_len; i++)
    printf("%d ", g[i]);
printf("\n");

}

num_list = input().split()
for i in range(len(num_list)):
    num_list[i] = int(num_list[i])

result_list = []

for elem in num_list:
    if elem < 0:
        result_list.append(elem)

for elem in num_list:
    if elem not in result_list:
        result_list.append(elem)
print(result_list)

제대로 한건지는 모르겠으나 결과는 제대로 나오내요

include

int main(void) { int arr[] = { -1, 1, 3, -2, 2 }; int i; printf("음수를 먼저 그다음에 양수로 하기");

for (i = 0; i < 5; i++)
{
    if (arr[i] < 0)
        printf("%d", arr[i]);
}
for (i = 0; i < 5; i++)
{
    if (arr[i]>0)
        printf("%d", arr[i]);

}
return 0;

}

def special_sort(a):
    list1 = []
    list2 = []
    for n in range(0,len(a)):
        if a[n]<0:
            list1.append(a[n])
        if a[n]>=0:
            list2.append(a[n])
    return list1+list2

arr = [1,-1,2,4,3,54,-19]

def FindP(lst) : result=[] for i in range(len(lst)) : if lst[i] > 0 : result.append(lst[i])

return result

def FindM(lst) : result=[] for i in range(len(lst)) : if lst[i] < 0 : result.append(lst[i])

return result

def SortList(lst) : lstP = FindP(lst) lstM = FindM(lst) result = lstM + lstP

return result

print(SortList(arr))

list = [-1,1,3,-2,2]
list_sorted  = []
for i in list:
    if i < 0:
        list_sorted.append(i)
    else:
        pass

for j in list:
    if j > 0:
        list_sorted.append(j)
    else:
        pass

print(list_sorted)

int[] arr = {-1,5,3,-2,4};
        for(int i = 0; i < arr.length; i++) {
            for(int j =i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("작은 수 부터 출력:");
        for(int a = 0; a < 5; a++) {
            System.out.println(arr[a]);
        }

    }
``````{.java}
int[] arr = {-1,5,3,-2,4};
        for(int i = 0; i < arr.length; i++) {
            for(int j =i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("작은 수 부터 출력:");
        for(int a = 0; a < 5; a++) {
            System.out.println(arr[a]);
        }

    }

a=[1,2,4,-1,-4,-2,5,-6,7]
c=[]
d=[]
for i in a:
    if i<0:
        c.append(i)
    else:
        d.append(i)
print(c+d)   

def Special_sort(L):
    L1 = []
    L2 = []
    for i in L:
        if i>0:
            L2.append(i)
        elif i<0:
            L1.append(i)
    return L1+L2

way1 : way2가 반복문을 2번 수행해야 하므로, 성능 상의 이점을 위해 for문을 1번만 사용하는 방향으로 코딩해보았습니다.

way2 : 다른 분들께서도 풀이하신 음수부와 양수부를 합하는 방식의 코딩입니다.

# way1
lst = [-1, 1, 3, -2, 2]
n = 0
for i in range(len(lst)):
    if lst[i]<0:
        tmp = lst[i]
        del lst[i]
        lst.insert(n, tmp)
        n += 1
lst

# way2
[i for i in lst if i<0] + [i for i in lst if i>=0]

InputArr = input("정수를 입력하시오: ")
IntArr = [int(a) for a in InputArr.split()]

for i in IntArr:
    if i < 0:
        c = 0
        for j in range(IntArr.index(i),0,-1):
            c += 1
            if IntArr[j-1] < 0:
                IntArr.insert(j,i)
                IntArr.pop(c+1)
print(IntArr)

a = [-1, 1, 3, -2, 2]

minus = [ x for x in a if x<0 ]
plus = [ x for x in a if x>0 ]

print(minus+plus)

# special sort.py

nums=map(int,input().split())

nums_pos=[]
nums_neg=[]

for i in nums:
    if i>=0:
        nums_pos.append(i)
    else:
        nums_neg.append(i)

print(nums_neg+nums_pos)

start = [-1,1,3,-2,2]
minus = []
plus = []
for i in start:
    if i < 0:
        minus.append(i)
    else:
        plus.append(i)

result = minus + plus
print(result)

import random n=int(input('n : ')) minus=0 a=[] for i in range(n): a.append(random.randint(-9,9)) print('question:',end=' ') for i in a: print(i,end=' ') for i in range(n): if a[i]<0: minus+=1 for j in range(i,minus-1,-1): a[j],a[j-1]=a[j-1],a[j] else: continue print('ans: ',end='') for k in a: print(k,end=' ')

package test0423;

public class MainClass {

public static void main(String[] args) {
    int[] arr = {-1, 1, 3, -2, 2};
    int temp;
    int c = 0;
    int[] ar_result = new int[5];

    for (int i = 0 ; i < arr.length; i++) {
        if(arr[i] < 0) {
            ar_result[c] = arr[i];
            c++;
        }
    }
    for (int i = 0 ; i < arr.length; i++) {
        if(arr[i] > 0) {
            ar_result[c] = arr[i];
            c++;
        }
    }
    for (int i = 0; i < arr.length; i ++) {
        System.out.print(ar_result[i]+ " ");
    }
}

}

# Suppose the given array's name is "Integer"
number = list(Integer)
def special_sort(x):
    pos = []
    neg = []
    for num in x:
        if num < 0:
            neg.append(num)
        else:
            pos.append(num)
    result = neg + pos
    return result

print(result)

num_series= list(map(int,input().split()))

num_minus=[] num_plus=[]

for i in num_series: if i<0: num_minus.append(i) else: num_plus.append(i)

num_series.clear()

for i in num_minus: num_series.append(i)

for i in num_plus: num_series.append(i)

print(num_series)

원소를 추가, 삭제, 붙이는 데에 있어서 벡터보다 리스트가 빠를것이라고 판단하여 리스트를 사용하였습니다.

#include <iostream>
#include <list>
using namespace std;

int main()
{
    list<int> lst ={ -1, -2, 1, 3, 2};
    list<int> pos_lst;
    for(auto iter = lst.begin(); iter != lst.end();)
    {
        if(*iter > 0)
        {
            pos_lst.push_back(*iter);
            iter = lst.erase(iter);
        }
        else
            iter++;
    }
    lst.insert(lst.end(), pos_lst.begin(), pos_lst.end());

    for(auto iter = lst.begin(); iter != lst.end();iter++)
    {
        cout << *iter << ' ';
    }
    cout << endl;
    return 0;

}

a = "-1 1 3 -2 2".split()
b = [i for i in a if int(i)<0]
c = [j for j in a if int(j)>0]
print(b+c)

처음에 받는 자료형이 문자형이라서 출력도 문자형으로 이루어 질 수 있도록 해보았습니다. 아직 부족하기에, 추가로 개선할만한 부분이 있다면 가르쳐 주시면 감사하겠습니다.

list =input("Plz enter the Array :")
tmpt = ''
Tmpt = ''
Array = list.split()
for i in range(len(Array)):
    Num = int(Array[i])
    if Num < 0:
        tmpt = tmpt + ' ' + Array[i]
    else: Tmpt = Tmpt + ' ' + Array[i]
SArray = tmpt + ' ' + Tmpt
print(SArray)   

파이썬 3.7.2

ex = [-1, 1, 3, -2, 2]
ex_1 = []
ex_2 = []
for x in ex:
    if x < 0:
        ex_1.append(x)
    if x > 0:
        ex_2.append(x)
ex = ex_1 + ex_2
print(ex)

data = list(map(int, input("N개의 정수를 입력하세요: ").split()))

negative = []
positive = []
for i in data:
    if i > 0:
        positive.append(i)
    else:
        negative.append(i)

negative.extend(positive)

print(negative)

n = "-1 1 3 -2 2"
list1 = list(n.split())
print(list1)
x = len(list1)

poslist = []
neglist = []
zerolist = []

while x != 0:
    integer = int(list1.pop(-x))
    if integer > 0:
        poslist.append(integer)
        x -=1
        continue
    if integer < 0:
        neglist.append(integer)
        x -=1
        continue
    if integer == 0:
        x-=1
        zerolist.append(integer)
        continue

final = neglist + zerolist + poslist
print(final)

import random

arrfin = []
#일단 n개의 리스트를 만들자
arr = []
n = int(input("How many? : "))

for i in range(n):
    b = random.randint(-10,10)
    while arr.count(b) > 0:
        b = random.randint(-10,10)
    arr.append(b)
print(arr)

arrmin = []
arrplus = []

for j in arr:
    if j < 0:
        arrmin.append(j)
    elif j > 0:
        arrplus.append(j)
    else:
        pass

print(arrmin)
print(arrplus)
#Result
if arr.count(0) == 1:
    arrfin = arrmin + [0] + arrplus
else:
    arrfin = arrmin + arrplus

print("Final array is here")
print(arrfin)

c = input("양의 정수나 음의 정수를 한 칸 씩 띄어 배열하세요: ")
d = c.split(' ')
print(d)

a = []
b = []

for i in d:
    if int(i) < 0:
        a.append(i)
    else :
        b.append(i)

print(a+b)

시작한지 얼마 되지 않아서 이해 쉬운 방법으로 하나하나 해보고 있습니다.

Python 3.6

numbers = [-1, -9, 10, 0, 1, -77, 100, 0, 0, -63, 3, -2, 2, 0]
numbers_plus = []
numbers_minus = []
zero_count = 0  # 0이 포함될 경우 -심지어 여럿일 경우도 산정한다


for i, number in enumerate(numbers):
    if number > 0:
        numbers_plus.append(numbers[i])
    elif number < 0:
        numbers_minus.append(numbers[i])
    else:
        zero_count += 1

for count in range(zero_count):
    numbers_minus.append(0)

print(numbers_minus + numbers_plus)

output: [-1, -9, -77, -63, -2, 0, 0, 0, 0, 10, 1, 100, 3, 2]

num_list = [-1, 1, 3, -2, 2]
list1 = []
list2 = []

for i in range(0, len(num_list)):
    if num_list[i] < 0:
        list1.append(num_list[i])
    elif num_list[i] > 0:
        list2.append(num_list[i])


print(list1 + list2)

data = [-1, 1, 3, -2, 2]

r1, r2 = [], []

for i in data:
    if i < 0:
        r1.append(i)
    else:
        r2.append(i)

result = r1 + r2

print(result)

public class ArrayTest {

    public static void main(String[] args) {
        int[] arr = {-1, 1, 3, -2, 2};
        int[] result = divide(arr);

        for(int val: result) {
            System.out.print(val+ " ");
        }
    }

    private static int[] divide(int[] arr) {
        int[] result = new int[arr.length];
        int idx = 0;
        for(int i=0; i<arr.length; i++) {
            if(arr[i]< 0) 
                result[idx++] = arr[i];
        }

        for(int i=0; i<arr.length; i++) {
            if(arr[i] > 0) 
                result[idx++] = arr[i];
        }
        return result;
    }

}

nums = "2 1 3 -2 -1 -3"

list_nums = nums.split(" ") print(list_nums)

posi = [i1 for i in list_nums if int(i) > 0] nega = [i1 for i in list_nums if int(i) < 0]

print(nega+posi)

정렬 알고리즘을 써볼까, 리스트의 삽입 위치를 조정해서 한꺼번에 돌게 할까, 생각해봤는데 그냥 두 리스트에 나눠 집어넣고 병합하는 게 복잡도도 그렇게 차이 안 나고 읽기 좋아 보이네요.

int main()
{
    int* arr = new int[5]{ -1, 1, 3, -2, 2 };
    list<int> negativeList;
    list<int> positiveList;

    for (int i = 0; i < 5; ++i)
    {
        if (arr[i] < 0)
            negativeList.push_back(arr[i]);
        else
            positiveList.push_back(arr[i]);
    }

    delete[] arr;

    negativeList.insert(negativeList.end(), positiveList.begin(), positiveList.end());

    for (list<int>::iterator iter = negativeList.begin(); iter != negativeList.end(); ++iter)
    {
        cout << *iter << ", ";
    }
    cout << endl;


    return 0;
}

def specialSort(data):
    plist = []; mlist = []; zlist = []; result = []
    for i in range(len(data)):
        if data[i] < 0:
            mlist.append(data[i])
        elif data[i] > 0:
            plist.append(data[i])
        else:
            zlist.append(data[i])
    if mlist:
        for j in range(len(mlist)):
            result.append(mlist[j])
    if zlist:
        for j in range(len(zlist)):
            result.append(zlist[j])
    if plist:
        for j in range(len(plist)):
            result.append(plist[j])
    return result

print(specialSort([-1, 1, 3, -2, 2]))

negative = []
positive = []
numbers = input()
numList = numbers.split(" ")
for i in range(0, len(numList)):
    if int(numList[i]) >= 0:
        positive.append(int(numList[i]))
    else:
        negative.append(int(numList[i]))

print(negative + positive)

python

L = [int(x) for x in input('Enter numbers : ').split()]
for i in L :
    if i < 0 : print(i, end = ' ')
for i in L :
    if i > 0 : print(i, end = ' ')

list = [-1,1,3,-2,2]
temp = []
for i in list:
    if i<0:
        temp.append(i)
    else:
        continue
for j in list:
    if j>0:
        temp.append(j)
    else:
        continue

temp

origin_list=[-1,1,3,-2,2]
minus_list=[]
plus_list=[]
final_list=[]
for i in origin_list:
    if i<0:
        minus_list.append(i)
    else:
        plus_list.append(i)
final_list=minus_list+plus_list
print(final_list)

파이썬

def S_sort(*nums):
    sort = list(nums)
    x = 0
    t = 1
    while True:
        if sort[x] > 0 :
            a = sort[x]
            del(sort[x])
            sort.append(a)
            x -= 1
        elif sort[x]< 0:
            pass
        x += 1
        t += 1
        if t > len(sort):
            return sort
            brake

a = (-1, 1, 3, -2, 2)
pos = []
neg = []
for i in a:
    if i > 0:
        pos.append(i)
    else:
        neg.append(i)
print(neg + pos)

lst=[-1,1,3,-2,2]
def c(lst):
    lstt=[]
    lsttt=[]
    for i in lst:
        if i>0:
            lstt.append(i)
        else:
            lsttt.append(i)
    q=lsttt+lstt
    return q
print(c(lst))

nums = [-1, 1, 3, -2, 2]

lMinus = list(filter(lambda x : x < 0, nums))
lPlus = list(filter(lambda x : x > 0, nums))
lZero = list(filter(lambda x : x == 0, nums))
lResult = lMinus.copy()
lResult.extend(lZero)
lResult.extend(lPlus)
print(lResult)

num_list = [-1, 1, 3, -2, 2]
major = []
minor = []
for n in num_list:
    if n < 0:
        minor.append(n)
    else:
        major.append(n)

for i in major:
    minor.append(i)

print(minor)

a = list(map(int, input().split()))   # 원하는 숫자 배열을 입력 
b = []
c = []
for i in range(len(a)):
    if a[i] < 0:
        b.append(a[i])
    else:
        c.append(a[i])
print(b+c)

list=[-1,2,4,3,6,-5,-6,-3,7]
plus=[]
minus=[]
for i in list:
    if i>=0:
        plus.append(i)
    else:
        minus.append(i)

result=minus+plus
print(result)

alist=[]
blist=[]

def formation(number):
    for x in number :
        if x < 0 :
            alist.append(x)
        else :
            blist.append(x)
    alist.sort()
    result = alist + blist
    print(result)

formation([-10,-100,-1000,-1005,-10000,-10003,-3,2,6,-5,7,2,-2,-1,3])

// n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다. 이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다.
// 정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다. 또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[]  Number = new int[] {-1,1,3,-2,2};
        int[] NewNumber = new int[Number.length];
        int i=0;
        int n=0;

        while(true) 
        {
            if(Number[i]<0)
            {
                NewNumber[n]=Number[i];
                n++;
            }
            i++;
            if(i>=Number.length)
            {
                break;
            }   
        }
        i=0;
        while(true) 
        {
            if(Number[i]>0)
            {
                NewNumber[n]=Number[i];
                n++;
            }
            i++;
            if(i>=Number.length)
            {
                break;
            }   
        }
        System.out.print("원래 배열 : ");
        for(int a=0; a<Number.length; a++)
        {
            System.out.print(Number[a]);
        }
        System.out.print("\n"+"정렬한 배열 : ");
        for(int b=0; b<NewNumber.length; b++)
        {
            System.out.print(NewNumber[b]);
        }

    }

}

Python 3.7

filter 사용

a = list(map(int, input().split(" ")))
print(" ".join(list(map(str, filter(lambda x: x < 0, a)))), " ".join(list(map(str, filter(lambda x: x > 0, a)))))

리스트 컴프리헨션 사용

a = list(map(int, input().split(" ")))
print(" ".join(list(map(str,[x for x in a if x < 0])))," ".join(list(map(str,[x for x in a if x > 0]))))

Input
-1 1 3 -2 2
Output
-1 -2 1 3 2

n = [-1,1,3,-2,2]
n_1 = list()
n_2 = list()
for i in n:
    if i>=0:
        n_2.append(i)
    else:
        n_1.append(i)
res = n_1+n_2
print(res)

#! python3

def sort(numbers):
    neg = []
    pos = []
    for num in numbers:
        if num < 0:
            neg.append(num)
        else:
            pos.append(num)
    return neg + pos

numbers = [-1, 1, 3, -2, 2]
print(sort(numbers))

sorting_array=[1,-1,-2,-4,4,6,2] new_sorting_array=[]

for a in sorting_array: if a<0: new_sorting_array.append(a) for a in sorting_array: if a >=0: new_sorting_array.append(a) print(new_sorting_array)

 static void Main(string[] args)
        {

            int [] NumberArray = { -1, 1, 3, -2, 2 };
            ArrayList NegativeArray = new ArrayList();
            ArrayList PositiveArray = new ArrayList();

            //음수 구하기
            var ResultNegative = from NegativeNumber in NumberArray
                                 where NegativeNumber < 0
                                 select NegativeNumber;

            foreach (int Number in ResultNegative)
            {
                NegativeArray.Add(Number);
            }


            //양수 구하기
            var ResultPositive = from PositiveNumber in NumberArray
                                 where PositiveNumber > 0
                                 select PositiveNumber;

            foreach (int Number in ResultPositive)
            {
                PositiveArray.Add(Number);
            }

            //출력
            for (int i = 0; i < NegativeArray.Count; i++)
            {
                Console.Write(NegativeArray[i]+" "); 
            }

            for (int i = 0; i < PositiveArray.Count; i++)
            {
                Console.Write(PositiveArray[i]+" ");
            }

        }

X = list(map(int, input().split()))
Y = []
for i in range(len(X)):
    if X[i] < 0:
        Y.append(X[i])
for i in range(len(X)):
    if X[i] > 0:
        Y.append(X[i])
for y in Y:
    print(y, "", end="")

public static void main(String[] args) {

        int[] a = {-1, 1, 3, -2, 2};

        for(int i=0; i<a.length; i++) {
            for(int j=0; j<a.length-1; j++) {
                if(a[j]>0 && a[j+1]<0) {
                    int b = a[j];
                    a[j] = a[j+1];
                    a[j+1] = b;
                }
            }
        }
        for(int i=0; i<a.length; i++) {
            String str = (i==a.length-1)?"":", ";
            System.out.print(a[i]+str);
        }

    }

import random

# -100 ~ 100 랜덤값 n개 생성
def random_int (n):
    nlist = []
    for i in range(0, n):
        nlist.append(random.choice(range(-100, 100)))
    return nlist

# 음의 정수, 양의 정수 분리
def seper_integer (numbers):
    negative, positive = ([], [])
    for number in numbers:
        negative.append(number) if number < 0 else positive.append(number)
    return (negative, positive)

# 입력받은 정수 개수만큼 랜덤값 생성
rlist = random_int(int(input("정수 개수 : ")))

# 음의 정수, 양의 정수 분리
(nint, pint) = seper_integer(rlist)
print("전체 정수 :", rlist)
print("음의 정수 :", nint)
print("양의 정수 :", pint)

#include <stdio.h>

int main(void)
{
    int arr[] = {1, 2, -3, 4, -5, -6};
    int len = 0, i = 0, j = 0;
    int temp = 0;
    len = sizeof(arr) / sizeof(int);

    for (i = 0; i < len; i++)
    {
        for (j = 0; j < len - 1; j++)
        {
            if (arr[j] < 0)
                continue;
            else if (arr[j + 1] < 0)
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
            else
                continue;
        }
    }

    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);

    return 0;
}

PHP

$arr = [-1, 1, 3, -2, 2];
$var = [];
foreach ($arr as $n) {
    $var[$n < 0 ? '-' : '+'][] = $n;
}
$result = array_merge($var['-'], $var['+']);
$result = implode(' ', $result);
print_r($result); // -1 -2 1 3 2

setting = [-1, 1, 3, -2, 2] a = [] b = [] for i in setting: if i < 0 : a += [i] else: b += [i] print(a+b)

package ex;

public class ex04 {
    public static void main(String[] args) {
        int[] list = {-1, 1, 3, -2, 2};
        for (int i = 0; i<list.length; i++) {
            if(list[i]<0) System.out.print(list[i] + " ");
        }
        for (int i = 0; i<list.length; i++) {
            if(list[i]>0) System.out.print(list[i] + " ");
        }
    }
}

list = [-1,1,3,-2,2]

alist=[x for x in list if x<0]
blist=[x for x in list if x>0]

clist = alist+blist

print(clist)

nums=input('Enter the number array: ')
l=list(map(int,nums.split(' ')))
a=[]

for n in l:
    if n<0: a.append(n); l.remove(n)

for n in a+l:
    print(n, end=' ')

#special sort
numlist = [-1, 1, 3, -2, 2]
pos=[]
neg=[]
for num in numlist:
    if num < 0:
        neg.append(num)
    else:
        pos.append(num)
pos.sort()
neg.sort()
neg.reverse()
list = neg + pos
print("ans:",list)

n = input("The delimiter is \" \".\ninput :").split(" ")
sei, fu = [], []
for k in n :
    if int(k) >= 0 :
        sei.append(int(k))
    else :
        fu.append(int(k))
print(fu + sei)

결과

The delimiter is " ".

input :-1 2 4 -4 8 -9 88 2 -45 [-1, -4, -9, -45, 2, 4, 8, 88, 2]

input_arr = map(int,input('Enter some integer : ').split(' '))

temp_pos = []
temp_neg = []

for num in input_arr:
    if num > 0:
        temp_pos.append(num)
    else:
        temp_neg.append(num)

result = temp_neg + temp_pos
print(result)

def Array(data):
    negative = []
    positive = []
    sum = []
    for i in data:
        if i < 0:
            negative.append(i)
        else :
            positive.append(i)
    sum = negative + positive
    print(sum)            
Array([-1,1,3,-2,2])

Python 3.7.4

La = input('수를 입력하세요(빈칸 구분):').split(" ")

La_re = []

for i in La:
    if int(i)<0: La_re.insert(0,i)
    else: La_re.append(i)

print(" ".join(La_re))

import java.util.Scanner;

public class SortQuiz {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int ans[] = {-1, 1, 3, -2, 2};
        int sw = 0;
        int count = 0;
        int temp = 0;

        for(int i = 0; i < ans.length; i++) {
            for(int j = 0; j < ans.length - i; j++) {
                if(ans[i] > 0 && ans[i+j] < 0) {
                    temp = ans[i];
                    ans[i] = ans[i + j];
                    ans[i + j] = temp;

                    sw = 1;
                    count = (i + j) - i;
                }               
            }
            if(sw == 1) {
                for(int j = i + 1; j < ans.length - count; j++) {
                    temp = ans[j];
                    ans[j] = ans[j + 1];
                    ans[j + 1] = temp;
                }
                sw = 0;
            }
        }
        for(int i = 0; i < ans.length; i++) 
            System.out.print(ans[i]);
    }
}

알고리즘 허접은 for문을 1번 더 사용 합니다... 흑흑

python 3

data = [-1, 1, 3, -2, 2]

negative = []
positive = []
for d in data:
  if d < 0:
    negative.append(d)
  else:
    positive.append(d)

ans = [*negative, *positive]
print(ans)

출력: [-1, -2, 1, 3, 2]

def sort(origin_list):
    return sorted(list(filter(lambda x:x<0,origin_list)),key=lambda x:abs(x)) 
           + sorted(list(filter(lambda x:x>0,origin_list)))

내포없이 필터 및 람다로 음수만 절대값으로 정렬 + 양수만 단순 정렬해서 리스트끼리 병합했습니다.

문제풀이

https://wikidocs.net/32#filter , 내장함수 filter

a = [-1,1,3,-2,2]

m = list(filter(lambda x: x<0, a))
n = list(filter(lambda x: x>0, a))

result = m+n

result

package practiceLv1;

import java.util.*;

public class SpecialSort {

    public static void main(String[] args) {
        System.out.println("n개의 정수를 가진 배열을 입력하시오. : ");
        Scanner scan = new Scanner(System.in);
        String[] numbers_list = null;

        numbers_list = scan.nextLine().split(" ");

        for(String sort : numbers_list) if( sort.startsWith("-") ) System.out.print(sort + " ");
        for(String sort : numbers_list) if( !sort.startsWith("-") ) System.out.print(sort + " ");
    }
}

nums = [-1, 1, 3, -2, 2]

plus = []
minus = []

for num in nums:
    if num > 0:
        plus.append(num)
    else:
        minus.append(num)
print minus+plus

ex = (-1, 1, 3, -2, 2) ans = ()

for i in ex: if i < 0: ans = ans + (i,)

for x in ex: if x > 0: ans = ans + (x,)

print(ans)

package CodeDojang;

import java.util.Arrays;
import java.util.ArrayList;
import java.util.Scanner;

public class StrangeNumbers {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ArrayList<String> underZero = new ArrayList<String>();          //음수값 저장할 공간
        ArrayList<String> overZero = new ArrayList<String>();           //양수값 저장할 공간
        Scanner sc = new Scanner(System.in);                            //수를 입력기위한 스캐너

        System.out.print("숫자를 입력하세요 : ");
        String[] strNum = sc.nextLine().split(" ");                     //받은수 배열로 정리

        //음수 양수 필터링
        for(int i = 0; i<strNum.length;i++) {
            if(Integer.parseInt(strNum[i])<0) {
                underZero.add(strNum[i]);               
            }else if(Integer.parseInt(strNum[i])>=0) {
                overZero.add(strNum[i]);
            }
        }
        //출력 후 [,] 제거
        System.out.println(underZero.toString().replace("[", "").replace("]", "")
                +   ", "  + overZero.toString().replace("[", "").replace("]", ""));
    }
}

def specialorder(a):
    k = list()
    j = list()

    for i in a:
        if i < 0:
            k.append(i)

        if i > 0:
            j.append(i)

    newlist = k + j

    return newlist

v = [-1,1,3,-2,2]

specialorder(v)

number=input().split(' ')
neg=[]
pos=[]
for i in range(len(number)):
  num = number[i]
  if '-' in num:
    neg.append(num)
  else:
    pos.append(num)
print(neg+pos)

파이썬의 경우 input입력값이 str이므로 정수변환 없이 음수의 '-'를 포함한 숫자로 나눌 수 있다고 생각했습니다.

numbers = '-1 1 3 -2 2'
number_list = numbers.split()

ind_cnt = 0
for n in number_list:
    if int(n) < 0:
        print('%s 는 음수' % n)
        number_list.pop(number_list.index(n))
        number_list.insert(ind_cnt, n)
    else:
        pass

print(number_list)

파이썬으로 작성해보았습니다.

ar = [-1,1,3,-2,2]
print [i for i in ar if i lt 0] + [i for i in ar if i gt 0]

파이썬 3.6 입니다

def special_sort(lst):
    negatives = []

    for i in lst:
        if i < 0:
            lst.remove(i)
            negatives.append(i)
    return negatives + lst

print(special_sort([-1, 1, 3, -2, 2]))

파이썬 초보자 답 추가합니다.

def new_sort(lists):
    p_list = []
    n_list = []
    for i in lists:
        if i >= 0 : 
            p_list.append(i)
        else: 
            n_list.append(i)
    return n_list + p_list

파이썬입니다.

list = [-1, 1, 3, -2, 2]

def ans(list):
  return [i for i in list if i < 0] + [i for i in list if i >= 0]

print(ans(list))

import re

a = '-1 1 3 -2 2'

m1=re.findall('(-\d)',a)

m2=re.findall(' (\d)',a)

ans=(m1+m2)

' '.join(ans)

from random import randint as r
n1 = r(1, 10)
n2 = r(1, 10)
n3 = r(1, 10)
n4 = r(1, 10)
n5 = r(1, 10)
num = [n1, n2, n3, n4, n5]
def special_sort(num):
        minus = []
        plus = []
        for x in num:
                if x < 0:
                        minus.append(x)
                else:
                        plus.append(x)

list = minus + plus
print(list)

l=list(map(int,input("연속된 숫자를 입력하십시오: ").split(","))) #-1,1,3,-2,2
print("l =",l)
ml=[]
pl=[]
for n in l:
    if n<0:
        ml.append(n)
    else:
        pl.append(n)
ml.extend(pl)
print(ml)

def par_sorting():

    a = input()

    b = a.split()

    c = [int(i) for i in b]

    tem_negative = []
    tem_positive = []

    for i in c:
        if i < 0:
            tem_negative.append(i)
        else:
            tem_positive.append(i)

    final = tem_negative + tem_positive

    return final

l1 = [-1,1,3,-2,2]
print([x for x in l1 if x < 0] + [x for x in l1 if x >= 0])

c언어로 구현했습니다. 지적 환영합니다

#include <stdio.h>

int main()
{
    int a[5] = {-1, 1, 3, -2, 2};
    int b[5];
    int i, j;

    j = 0;
    for (i = 0; i < 5; i++)
        if (a[i] < 0) {
            b[j] = a[i];
            j++;
        }

    for (i = 0; i < 5; i++)
        if (a[i] >= 0) {
            b[j] = a[i];
            j++;
        }

    for (i = 0; i < 5; i++)
        printf("%3d", b[i]);
}

numLst = [-1,1,3,-2,2]
tmpLst = []

for i in numLst:
    if i<0:
        tmpLst.append(i)

for i in numLst:
    if i >= 0:
        tmpLst.append(i)

print(tmpLst)

m = [-1, 1, 3, -2, 2]

a = []

b = []

for i in m:
    if i < 0:
        a.append(i)
    else:
        b.append(i)

n = a+b

print(n)

string = "-1 1 3 -2 2"
#tmplist1 = list(string) # 뭐 string.split() 같은 것들이 아니다. 아 근데 이러면 -까지 분리가 되네. 입력을 그냥 띄어쓰기로 받는걸로 하자
tmplist1 = string.split(" ") # ['-1', '1', '3', '-2', '2']
print(tmplist1)

tmplist2 = []
tmplist3 = []
tmplist4 = []

for i in tmplist1:
    if "-" in i: # -가 안에 요소로 있기만 하면 !!!
        tmplist2.append(i)
    else :
        tmplist3.append(i)

tmplist4 = tmplist2 + tmplist3
print(tmplist4)

파이썬입니다.

입력이 문자열의 형태로 들어온다고 가정하고 작성했습니다.

line = input().split()

neg = []
pos = []

for i in line:
    if i[0] == '-': neg.append(int(i))
    else: pos.append(int(i))


pos.sort()
neg.sort(reverse=True)
neg.extend(pos)

print(neg)

a =[-1, 5, -5, 2, 3, -4, -2, 1, -3, 4]
print([i for i in a if i < 0]+[ i for i in a if i >=0])

Nlist, Ndecimal, Nint = input().split(), list(), list()
for i in range(len(Nlist)):
    if int(Nlist[i]) < 0:Ndecimal.append(int(Nlist[i]))
    if int(Nlist[i]) >= 0:Nint.append(int(Nlist[i]))
print(Ndecimal + Nint)

num=map(int,input().split())

minus=[]
plus=[]

for i in num:
    if i<0:
        minus.append(i)
    else:
        plus.append(i)

print(minus+plus)

a = input()

A = list(a.split(" "))

result = [] for i in A: i = int(i) result.append(i)

A_a = list(filter(lambda x:x<0, result)) A_b = list(filter(lambda x:x>0, result))

print(A_a + A_b)

array = input('n개의 정수를 가진 배열을 입력하시오:').split(' ')
def negPos(array):
    return [int(i) for i in array if i[0] == '-'] + [int(i) for i in array if i[0] != '-']

numberlist = [-1,1,3,-2,2,-5,4,6,-6]

list = []
minus = 0
plus = 0
for i in numberlist:
    if i < 0:
        list.insert(minus, i)
        minus += 1
    if i >= 0:
        list.insert(minus+plus, i)
        plus += 1

print(list)

print("정수의 배열을 입력해주세요. 각각의 정수는 띄어쓰기로 구분합니다.")

nums = input().split(" ")
num_list = []
pos_list = []
neg_list = []

for num in nums:
    num = int(num)
    num_list.append(num)
# print(num_list)

for num in num_list:
    if num >= 0:
        pos_list.append(str(num))
    else:
        neg_list.append(str(num))

list_arranged = neg_list + pos_list
num_arranged = " ".join(list_arranged)

print("정렬된 결과입니다.")
print(num_arranged)

def special_sort(input):
    output=[x for x in input if x <0] +[x for x in input if x>=0]
    return output

a=special_sort([-1, 1, 3, -2, 2 ])
print(a)

>>[-1, -2, 1, 3, 2]

파이썬입니다

문제만 보면 굉장히 복잡할거라 생각했는데 막상 코드를 쓰다 보니...간단하네요ㅎㅎ N열 배열은 사용자 입력을 받는 방식으로 만들어 봤습니다.

import sys

def isNumber(num):
    try:
        float(num)
        return True
    except ValueError:
        return False

array_Num = []

while True:
    num = input('Input number: ')
    if isNumber(num):
        array_Num.append(int(num))
    elif num == 'end':
        break
    else:
        print('Wrong input. Only number allowed\n')

array_Minus = []
array_Plus = []

for num in array_Num:
    if num >= 0:
        array_Plus.append(num)
    else:
        array_Minus.append(num)

array_Num = array_Minus + array_Plus
print(array_Num)

파이선 3.8

array = [-1, 1, 3, -2, 2]
result = []
for i in range(len(array)):
    if array[i] < 0:
        result.append(array[i])
for i in range(len(array)):
    if array[i] > 0:
        result.append(array[i])
print(result)

class Program
    {


        static void Main(string[] args)
        {
            int[] arr = { -1, 1, 3, -2, 2 };
            List<int> P_list = new List<int>();
            List<int> M_list = new List<int>();
            for (int i = 0; i < arr.Length; i++)
            {
                if (i > 0) P_list.Add(arr[i]);
                else M_list.Add(arr[i]);
            }
            P_list.Sort();
            M_list.Sort();
            for (int j =0; j<P_list.Count; j++)
                M_list.Add(P_list[j]);
            for (int k = 0; k < M_list.Count; k++)
                Console.Write(" {0}",M_list[k]);            
        }
    }  

파이썬으로 작성됨

data = "-1 1 3 -2 2 5".split(" ")

minus = []
plus = []
ans = []

for i in range(0, len(data)):
    if int(data[i]) < 0:
        minus.append(data[i])
    else:
        plus.append(data[i])

ans.extend(minus)
ans.extend(plus)

print("예 %s ans: %s" % (" ".join(data), " ".join(ans)))

numbers = [-1,1,3,-2,2]
pos =[]
neg =[]
for number in numbers:
    if number > 0:
        pos.append(number)
    elif number <0:
        neg.append(number)

newnum = neg+pos

print("정렬결과:",newnum)

listA = [-1, 1, 3, -2, 2]
listB = []

for i in listA:
    if i < 0:
        listB.append(i)
for i in listA:
    if i > 0:
        listB.append(i)

print(listB)

wholelist = input("enter the numbers  ").split(' ')
minus = list()
plus = list()
for x in range(len(wholelist)):
    if int(wholelist[x]) >= 0:
        plus.append(wholelist[x])
    else:
        minus.append(wholelist[x])
print(minus + plus)

def specialSort(l1):
    result1 = []
    result2 = []
    for i in l1:
        if i < 0:
            result1.append(i)
        elif i >= 0:
            result2.append(i)
    return result1 + result2


print(specialSort([-1, 1, 3, -2, 2]))

input_list = input().split() input_list = list(map(int, input_list)) mylist1 = [] mylist2= [] for i in range(len(input_list)): if input_list[i] < 0: mylist1.append(input_list[i]) else: mylist2.append(input_list[i]) mylist1 = mylist1 + mylist2 print(mylist1)

만들어 보았습니다.

def sort_number(q):
    return ([i for i in q if i<0] + [i for i in q if i>=0])

print(sort_number([-1,0,1,2,3,-4]))

list_a = [-1, 1, 3,-2, 2] sorted_list_positive = [] sorted_list_negative = []

for i in list_a: if i < 0: sorted_list_negative.append(i) else: sorted_list_positive.append(i)

print(sorted_list_negative+sorted_list_positive)

a = [-1, 1, 3, -2, 2]
a1 = []
a2 = []
for i in a:
    if i < 0:
        a1.append(i)
    elif i > 0:
        a2.append(i)
print(a1+a2)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


void main()
{
    int list[5] = { -1, 1, 3, -2, 2 };

    int i, j, temp;
    i = 0;

    for (j = i + 1; j < 5; j++)
    {
        if (list[j] < 0)
        {
            if (list[i] >= 0)
            {
                temp = list[j];
                list[j] = list[i];
                list[i] = temp;
                i = i - 2;
                j = j - 2;
            }
        }
        i++;
    }
    for (i = 0; i < 5; i++)
    {
        printf("%d ", list[i]);
    }
}

number = [-1, 1, 3, -2, 2, 4, 0, -7, 2, 3, 4, -5]
a = []
b = []
c = []
for i in number:
    if i < 0:
        a.append(i)
    elif i == 0:
        b.append(i)
    else:
        c.append(i)

print(a,b,c)

#입력: a = -1 1 3 -2 2
#출력: -1 -2 1 3 2
#함수: while을 이용하여 a[0]부터 끝까지 체크하여 음수면 a에 양수면 b에 추가시킨 후 합친다


num = "-1,1,3,-2,2"
num = num.split(",")
print(num)
a=[]
b=[]
k=0
while True:
    if k>=len(num):break
    if int(num[k])<0:
        a.append(num[k])
    elif int(num[k])>=0:
        b.append(num[k])
    k+=1
print(" ".join(a+b))

n = (-6, -5, 3, -8, 8, 1)
def arrange(n):
    result, temp = [], []
    for i in n:
        if i < 0:
            result.append(i)
        if i > 0:
            temp.append(i)
    print(result+temp)

arrange(n)

#include <iostream>
#include <vector>;
using namespace std;

int main() {    
    int arr[] = { -1,1,3,-2,2,-4 };
    int size = sizeof(arr) / sizeof(int);

    for (int i = 0; i < size; i++)
        cout << "arr[" << i << "]:" << arr[i] << " ";
    cout << endl;

    vector<int> v;

    for (int i = 0; i < size; i++)
        if (arr[i] < 0) { v.push_back(arr[i]); }

    for (int i = 0; i < size; i++)
        if (arr[i] >= 0) { v.push_back(arr[i]); }

    for (int i = 0; i < v.size(); i++)
        arr[i] = v[i];

    for (int i = 0; i < size; i++)
        cout << "arr[" << i << "]:" << arr[i] << " ";
    cout << endl;
}

_num = [-1,1,3,-2,2,7,-5,9]
_sort = []

for i in _num:
    if i < 0:
        _sort.append(i)
for i in _num:
    if i > 0:
        _sort.append(i)

print(_sort)

파이썬

a="-1 1 3 -2 2"
a=a.split()

result = list() # 음수만 담자
result1=list() #양수만 담자

for i in range(len(a)):
    if int(a[i]) < 0 : 
        result.append(a[i])
    else :
        result1.append(a[i])

print(result+result1)

def do(s):
  minus = []
  plus = []

  for x in s:
    if x < 0:
      minus.append(x)
    else:
      plus.append(x)

  minus.extend(plus)
  return minus

print(do([-1 , 1,3,-2,2]))

#입력을 받는대신 배열n을 랜덤으로 생성하였습니다

from random import *
n=[]
for i in range (randint(6,11)):
    n.append(randint(-10,10))
print ('Input=',n)

for j in range (len(n)-1):
    for i in range (len(n)-1):
        if (n[i]>=0 and n[i+1]<0):
            temp=n[i+1]
            n[i+1]=n[i]
            n[i]=temp
print ('Output=',n)

num = [-1, 1, 3, -2, 2]

a = []
b = []

for i in num :
    if i < 0 :
        a.append(i)

    if i >= 0 :
        b. append(i)


print(a+b)

어떻게 해야하나 싶다가 다른분것을 보면 아하... 하게 되네요 음과 양의 리스트 2개를 만들고 리스트를 for문을 돌면서 각각의 리스트에 추가후 마지막에 음의 리스트 + 양의 리스트 형태로 정렬하는 방식인데 저는 장황하네요...

def func_list(ori_list):
    plus_list, minus_list = [], []
    for i in  ori_list:
        if i >= 0:
            plus_list.append(i)
        else:
            minus_list.append(i)
    return minus_list + plus_list

n_list = [-1, 1, 3, -2 , 2]
print(func_list(n_list))

arr = [5,4,-3,3,-3,-6,5,-4,-7,3] #[-3,-3,-6,-4,-7,5,4,3,5,3] exp = [] list=[] minus=[] for i,x in enumerate(arr): if x>0: order = i #2 break

for i,x in enumerate(arr): if i>order: if x<0: list.append(i)

list.reverse()#음수값 뺴오기 위해 리버스

for x in list: #음수값 제거 minus.append(arr.pop(x))

for x in minus: arr.insert(order,x)

print(arr)

list(filter(lambda x : x<0, [-1,1,3,-2,2])) + list(filter(lambda x : x>=0, [-1,1,3-2,2]))

list_tmp=[-1,1,3,-2,2]
print(sorted(list_tmp))

li=[-1,3,-2,5,4,7,9,-6,-4,-17,45]

lin=[]
lip=[]
lit=[]

for n in range(len(li)):
    if li[n]<0:
        lin.append(li[n])

    else :
        lip.append(li[n])


lit=lin+lip
print(lit)

arrayData=[-1,1,3,-2,2]
firstPlusLocation=0
locationCount=0
temp=0
for arrayValue in arrayData:
    if arrayData[firstPlusLocation]<0:
        for count in range(firstPlusLocation,len(arrayData)):
            if arrayData[count]>0:
                firstPlusLocation=count
                break
    if firstPlusLocation < locationCount:
        if arrayValue<0:
            for pushcount in range(locationCount,firstPlusLocation,-1):
                tmp=arrayData[pushcount-1]
                arrayData[pushcount-1]=arrayData[pushcount]
                arrayData[pushcount]=tmp                
    locationCount+=1
print(arrayData)  

파이썬으로 음수가 가야할 양수의 위치를 감시하는 for문과 음수가 발견되엇을때 그걸로 한칸씩 이동하는 for문으로 작성했습니다.

def array(s):
    Lst = s.split(',')
    n_num = [] #음수
    p_num = [] #양수
    z_num = [] #0
    for i in Lst:
        if int(i) < 0:
            n_num.append(i)
        elif int(i) > 0:
            p_num.append(i)
        else:
            z_num.append(i)

    result = n_num + z_num + p_num
    print(','.join(result))



array('-1, 1, 3, -2, 2')

for x in b:
    if int(x)<0:
        c.append(x)
    if int(x)==0:
        d.append(x)
    if int(x)>0:
        e.append(x)
list_a=c+d+e


f=""
for y in list_a:
    f+=" "+y
print(f[0:])

```{.python} list_a=[-1,1,3,-2,2] list_b=[] for i in range(len(list_a)): if list_a[i]<0: list_b.append(list_a[i]) for i in range(len(list_a)): if list_a[i]>0: list_b.append(list_a[i])

print(list_b)

```list_a=[-1,1,3,-2,2] list_b=[] for i in range(len(list_a)): if list_a[i]<0: list_b.append(list_a[i]) for i in range(len(list_a)): if list_a[i]>0: list_b.append(list_a[i])

print(list_b)

파이썬

a = [-3, 3, -1, 10, 2, 6, -10, -20, -5, 4, -56, 1] #임의의 배열
b = [] #음수 list
c = [] #양수 list
for i in a:
    if i < 0:
        b.append(i)
    else:
        c.append(i)
d = b + c
print(d)

l = [-1, 1, 3, -2, 2]
print([i for i in l if i < 0]+[i for i in l if i >= 0])

data=np.random.randint(-10,10,8)

lis=[] for i in range(len(data)): if data[i]<0: lis.append(data[i]) for i in range(len(data)): if data[i]==0: lis.append(data[i])

for i in range(len(data)): if data[i]>0: lis.append(data[i]) print(lis)

int main(void) {
    int arr[5]; int i;
    for (i = 0; i < 5; i++) {
        puts("입력:");
        scanf("%d", &arr[i]);
    }
    int ps=0, ms=0;
    for (i = 0; i < 5; i++) {
        if (arr[i] >= 0)
            ps++;
        else if (arr[i] < 0)
            ms++;
    }
    int* brr = malloc(sizeof(int) * ms);
    int* crr = malloc(sizeof(int) * ps);
    int j = 0; int k = 0;
    int temp1,temp2;
    for (i = 0; i < 5; i++) {
        if (arr[i] < 0) {
            temp1 = arr[i];
            brr[j] = temp1;
            j++;
        }
        else if(arr[i] >= 0) {
            temp2 = arr[i];
            crr[k] = arr[i];
            k++;
        }
    }
    for (i = 0; i < ms; i++) {
        printf("%d ", brr[i]);
    }
    for (i = 0; i < ps; i++) {
        printf("%d ", crr[i]);
    }
}

c로 풀어봤습니다 제 수준을 보니 좀더 공부해야겠습니다.

# Special Sort

input1 = input("원하는 숫자를 입력하세요.")

input1 = input1.split(" ")

minus = []
plus = []

for i in input1:
    if int(i) >= 0:
        plus.append(i)
    else:
        minus.append(i)

print(minus + plus)

파이썬으로 작성해 봤습니다.

input_num = input("input number list : ").split(",")
list_num = [int(x) for x in input_num]

def minus(list):
    minus = [x for x in list if x < 0]
    return minus

def plus(list):
    plus = [x for x in list if x > 0]
    return plus


print(minus(list_num)+plus(list_num))

import java.util.ArrayList;

public class Q028 {

    public static void main(String[] args) {
        int[] ex = { -1, 1, 3, -2, 2 };
        int[] ans = new int[ex.length];
        ArrayList<Integer> minus = new ArrayList<Integer>();
        ArrayList<Integer> plus = new ArrayList<Integer>();

//      음수와 양수를 각각 분리해서 리스트에 추가
        for (int i = 0; i < ex.length; i++) {
            if (ex[i] < 0)
                minus.add(ex[i]);
            else
                plus.add(ex[i]);
        }

        for (int i = 0; i < minus.size(); i++)
            ans[i] = minus.get(i);
        for (int i = minus.size(); i < ex.length; i++)
            ans[i] = plus.get(i - minus.size());
    }
}

java

def special_sort(l):
    return [x for x in l if x < 0] + [x for x in l if x == 0] + [x for x in l if x > 0]

ans = [-1,1,3,-2,2]
i = 0
ans_neg = []
ans_pos = []

while i < len(ans):
    if ans[i] < 0:        
        ans_neg.append(ans[i])
        i += 1
    elif ans[i] > 0:
        ans_pos.append(ans[i])
        i += 1
    else:
        i += 1


print(ans_neg+ans_pos)

```{.python} ns = "-1 1 3 -2 2".split() int_ns = list(map(int,ns)) # int_ns = [int(n) for n in ns]

print(int_ns) listns = []

for n in int_ns: if n < 0: listns.append(n)

for n in int_ns: if n > 0: listns.append(n)

print(listns)

listns2 = []

minus_int = [listns2.append(n) for n in int_ns if n < 0]

plus_int = [listns2.append(n) for n in int_ns if n > 0]

print(listns2)

```기본 for문으로 사용하였고, 리스트 안에 있는 str 숫자를 int로 바꾸는 법을 몰라서 이건 검색해서 찾아 공부하여 풀어내었습니다 ㅜ

a = input('숫자를 여러개 입력하세요: ').split()

b = []
c = []

for i in a:
    if int(i) < 0:
        b.append(i)
    else:
        c.append(i)

print(b + c)

#파이썬
numberList = [-1,1,3,-2,2]

def sort(numberList):
    return [x for x in numberList if(x < 0)] + [x for x in numberList if(x >= 0)]

print(sort(numberList))

_list = sorted([-1, 1, 3, -2, 2])
result = []

for item in _list:
    if item < 0:
        result.insert(0, item)
    else:
        result.append(item)

print(result)

파이썬3입니다. for, if 코드를 한줄로 줄이는 것을 연습하고 있습니다. minus, plus 리스트 만드는 코드 두줄을 한줄로 줄이려면 어떻게 해야될까요?

import random as r
n = [r.randint(-300,300) for _ in range(r.randint(10,20))]
print(f'The original list is {n}')
minus = [n[i] for i in range(len(n)) if n[i]<0]
plus = [n[i] for i in range(len(n)) if n[i]>=0]
n = minus + plus
print(f'The special sorted list is {n}')

nunbers = list(map(int,input().split()))
blank1 = []
blank2 = []

for i in range(len(nunbers)):
    if nunbers[i]< 0:
        blank1.append(nunbers[i])
    elif nunbers[i]>= 0:
        blank2.append(nunbers[i])

specialrange = blank1 + blank2
print(specialrange)

arr = [-1, 1, 3, -2, 2]
for i in arr:
    if i < 0 :
        print(i)
for i in arr:
    if i > 0 :
        print(i)

package codingdojang;

public class example005_SpecialSort {

    public static void main(String[] args) {

        int[] intArr = {-1,1,3,-2,2,-3,4};


        for (int i = 0; i < intArr.length; i++) {
            if (intArr[i]<0) {
                for (int j = 0; j < i; j++) {
                    if(intArr[j]>0) {
                        int temp = intArr[i];
                        for (int k = i; k > j ; k--) {
                            intArr[k]=intArr[k-1];
                        }
                        intArr[j]=temp;
                        break;
                    }
                }
            }
        }
        for (int i = 0; i < intArr.length; i++) {
            System.out.print(intArr[i]);            
        }
    }
}

파이썬

array = [-8, -3, -9, 5, 6, -9, -1, 9, 3, 1, 5, -8]
minus = [x for x in array if x < 0]
plus = [x for x in array if x > 0]

print(minus + plus)

파이썬 3.7

a=[-1,1,3,-2,2] a1=[] a2=[] for i in range(len(a)): if a[i]>=0: a1.append(a[i]) else: a2.append(a[i]) a3=a2+a1 print(a3)

#include <iostream>
#include <stdio.h>
#define MAX_COUNT 5
using namespace std;

void BubbleSort(int arr[], int size) {
    int i, j, temp = 0;

    for (i = 0; i < size - 1; i++) {
        for (j = 0; j < size - 1 - i; j++) {
            if (arr[j + 1] <= 0) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main()
{
    int data[MAX_COUNT] = { -1, 1, 3, -2, 2 };
    int i;

    BubbleSort(data, MAX_COUNT);

    printf("ans : ");
    for (i = 0; i < MAX_COUNT; i++) printf("%d ", data[i]);
    return 0;
}

C++ BUBBLE

잘하신 분들 것 참고해서 안보고 작성했습니다.

# 구글 문제

list = [-1, -5, 4, 1]

def sort_this(list) :
    final_ans = []
    temp_1 = []
    temp_2 = []
    for i in list:
        if i < 0 :
            temp_1.append(i)
        else :
            temp_2.append(i)
    final_ans = temp_1 + temp_2
    return final_ans

print(sort_this(list))

input = [-1, 1, 3, -2, 2]

minus = [ v for v in input if v < 0]
plus = [ v for v in input if v > 0]
minus.sort(reverse=True)
# plus.sort()
output = minus + plus
# print(minus)
# print(plus)
print(output)

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func printlist(funclist []string) {
    for i := 0; i < len(funclist); i++ {
        fmt.Print(funclist[i])
        fmt.Print(" ")
    }
}
func main() {
    var N string
    fmt.Scanf("%s", &N)
    M := strings.Split(N, ",")
    uplist := []string{}
    underlist := []string{}
    for i := 0; i < len(M); i++ {
        var check int
        check, _ = strconv.Atoi(M[i])
        if check >= 0 {
            uplist = append(uplist, M[i])
        }
        if check < 0 {
            underlist = append(underlist, M[i])
        }
    }
    printlist(underlist)
    printlist(uplist)
}

public class NoTitle {
public static void main(String[] args) {
    int[] a = new int[]{-1, 1, 3, -2, 2};
    int[] b = new int[5];
    int x=0;
    for(int i=0; i<5; i++){
        if(a[i]<0){
            b[x]=a[i];
            x++;
        }
    }
    for(int i=0; i<5; i++){
        if(a[i]>0){
            b[x]=a[i];
            x++;
        }
    }
    for(int i=0; i<5; i++){
     System.out.print(b[i]);
}

}
}

  public static int[] mySort(int[] arr) {
        int temp=0;
        boolean flag=true;
        int startNum=1;
        while(flag) {
            for(int i=startNum;i<arr.length;i++) {
                if(arr[i]<0 && arr[i-1]>0) {
                    temp=arr[i];
                    arr[i]=arr[i-1];
                    arr[i-1]=temp;
                }
            }
            startNum++;
            if(startNum==arr.length-1) {
                flag=false;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] arr= new int[] {-1,1,3,-2,2};
        System.out.println(Arrays.toString(mySort(arr)));
    }

num= input("Enter a numberline: ").split()
num=[int(x) for x in num]
num1=[num[i] for i in range(len(num)) if num[i]<0]
num1.reverse()
[num.remove(p) for p in num1]
[num.insert(0,i) for i in num1]
print(num)

a = [] b = [] c = [] for i in range(5) : a.append(int(input("입력 ="))) for i in a : if i < 0 : b.append(i) else : c.append(i) print(b+c){.python} a = [] b = [] c = [] for i in range(5) : a.append(int(input("입력 ="))) for i in a : if i < 0 : b.append(i) else : c.append(i) print(b+c)

package Lv_1;
/*
import java.util.ArrayList;

public class special_Sort {

    public special_Sort() {}
    ArrayList<Integer> list = new ArrayList<Integer>();

    public void change() {
        for(int i=1; i<list.size(); i++) {
            if(list.get(i)<0) {
                for(int j=(i-1); j>=0; j--) {
                    if(list.get(j)<0) {
                        list.add(j+1, list.get(i));
                        list.remove(i+1);
                        break;
                    }
                }
            }
        }
    }
    public static void main(String args[]) {
        //-1 1 3 -2 2 //-1 -2 1 3 -2 2 // -1 -2 1 3 2
        special_Sort st = new special_Sort();
        st.list.add(-1); st.list.add(1); st.list.add(3); st.list.add(-2); st.list.add(2);
        System.out.println(st.list);
        st.change();
        System.out.println(st.list);
    }
}

알고리즘 일단 안쓰고

#include <iostream>
using namespace std;
/*n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다.
이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다.

정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다.
또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.
예. -1 1 3 -2 2 ans: -1 -2 1 3 2. */

int main()
{
    int size=0;
    int data = 0;
    int a[100];
    cout << "숫자 몇개 입력하실?" << endl;
    cin >> size;
    cout << "숫자 입력하세용" << endl;

    for (int i = 0; i < size; i++)
    {
        cin >> a[i];
    }

    for (int i = 0; i < size; i++)
    {
        for (int y = 0; y < size - 1; y++)
        {
            if (a[y] > 0 && a[y + 1] < 0) 
            {
                data = a[y];
                a[y] = a[y + 1];
                a[y + 1] = data;
            }
        }
    }

    for (int i = 0; i < size; i++)
    {
        cout << a[i] << " ";
    }

}

벡터가 더 효율적인거 같음

#include <iostream>
using namespace std;
/*n개의 정수를 가진 배열이 있다. 이 배열은 양의정수와 음의 정수를 모두 가지고 있다.
이제 당신은 이 배열을 좀 특별한 방법으로 정렬해야 한다.

정렬이 되고 난 후, 음의 정수는 앞쪽에 양의정수는 뒷쪽에 있어야 한다.
또한 양의정수와 음의정수의 순서에는 변함이 없어야 한다.
예. -1 1 3 -2 2 ans: -1 -2 1 3 2. */
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> a, positive, negative;
    int number, size;
    cout << "몇개?";
    cin >> size;
    for (int i = 0; i < size; i++)
    {
        cin >> number;
        a.push_back(number);
    }
    for (int i = 0; i < size; i++)
    {
        if (a[i] > 0)
        {
            positive.push_back(a[i]);
        }
        else
            negative.push_back(a[i]);
    }

    for (int i = 0; i < negative.size(); i++)
        cout << negative[i] << " ";
    for (int i = 0; i < positive.size(); i++)
        cout << positive[i] << " ";
    return 0;
}

import java.util.ArrayList;
import java.util.Arrays;

public class a {
    public static void main(String[] args){
        int[] num = {-1,1,3,-2,2};
        ArrayList<Integer> pos = new ArrayList<Integer>();
        ArrayList<Integer> zer = new ArrayList<Integer>();
        ArrayList<Integer> neg = new ArrayList<Integer>();
        for(int i=0;i<num.length;i++){
            if(num[i]>0){
                pos.add(num[i]);
            } else if(num[i]==0){
                zer.add(num[i]);
            } else{
                neg.add(num[i]);
            }
        }
        StringBuilder sb = new StringBuilder();
        for (Integer s : neg)
        {
            sb.append(s);
            sb.append("\t");
        }
        for (Integer s : zer)
        {
            sb.append(s);
            sb.append("\t");
        }
        for (Integer s : pos)
        {
            sb.append(s);
            sb.append("\t");
        }
        System.out.println(sb.toString());
    }
}

def spsort(a):
    indices = []
    subindices =[]
    for i in a:
        if i < 0 :
            indices.append(a.index(i))
        else:
            subindices.append(a.index(i))
    c = [a[i] for i in indices] + [a[i] for i in subindices]
    return c

import java.util.*;

public class SpecialSort {

    public static void main(String[] args) {

        Scanner kb = new Scanner(System.in);
        List<Integer> list = new ArrayList<Integer>();

        System.out.print("입력할 정수의 개수 : ");
        int n = kb.nextInt();
        System.out.print("정수 입력 : ");
        for(int i = 0 ; i < n ; ++i)
            list.add(kb.nextInt());

        for(int i = n-1 ; i > 0 ; --i) {
            for(int j = 0 ; j < i ; ++j) {
                if((list.get(j) >= 0) && (list.get(j+1) < 0) ) {
                    int tmp = list.get(j);
                    list.set(j, list.get(j+1));
                    list.set(j+1, tmp);
                }
            }
        }
        Iterator it = list.iterator();

        while(it.hasNext()) {
            System.out.print(it.next()+" ");
        }

    }

}

numbers = "-1 1 3 -2 2"
list_numbers = numbers.split()
minus = []
plus = []
for number in list_numbers:
    if int(number) > 0:
        plus.append(number)
    elif int(number) < 0:
        minus.append(number)

result = minus + plus
print("ans: ", end="")

i = 0
while i < len(result):
    print(result[i], end=" ")
    i += 1

numbers = input("숫자들을 입력하세요>>> ")
numlist = numbers.split()
minuslist = [ ]
pluslist = [ ]
for i in numlist:
    i = int(i)
    if i < 0:
        minuslist.append(i)
    else:
        pluslist.append(i)

newnumlist = minuslist + pluslist
print(newnumlist)

package example01;

public class Google {
//배열 오름차순 스왑하는 법 이용해서 풀엇습니다.
    public static void main(String[] args) {
        int a[]= {-1,1,3,-2,2,-3,-2,-1};

        for(int i=0;i<a.length;i++) {
            for(int j=i+1;j<a.length;j++) {
                if(a[i]>a[j]&&a[j]<0) {
                    int temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
            }
        }
        for(int i=0;i<a.length;i++) {   
            System.out.print(a[i]+" ");
        }
    }

}

def run(alist):
    minus = [x for x in alist if x < 0]
    plus = [x for x in alist if x >= 0]
    return minus + plus

data = [-1, 1, 3, -2, 2]
print(run(data))

#include <stdio.h>
#include <stdlib.h>

int main(){

int arr[7]={-4,11,-7,1,-6,3,2};

int n,i,temp;

int size=sizeof(arr)/sizeof(int);

for(n=0;n<=size;n++)
{
    for(i=0;i<=size;i++)
    {
        if(arr[i]>=0 && arr[i+1]<0)
        {
            temp=arr[i+1];
            arr[i+1]=arr[i];
            arr[i]=temp;
        }
    }
}
for(i=0;i<=6;i++)
    printf("%d ",arr[i]);

return 0;

}

c언어 사용- 배열 입력하는 것은 차후에

import java.util.*;
public class test4 {
    public static void main(String[] args) {
        int[] input = {-1,1,3,-2,2};
        ArrayList<Integer> array_minus = new ArrayList<>();
        ArrayList<Integer> array_plus = new ArrayList<>();

        for(int a = 0; a< input.length; a++) {
            if(input[a] < 0 ) {
                array_minus.add(input[a]);
            } else {
                array_plus.add(input[a]);
            }
        }

        for(int a = 0; a< array_minus.size(); a++) {
            System.out.print(array_minus.get(a)+",") ;
        }
        for(int a = 0; a< array_plus.size(); a++) {
            System.out.print(array_plus.get(a)+",") ;
        }
    }
}

0은 일단 양의정수라고 치고 풀었는데 맞나요?

array=[-1,1,3,-2,2]
array1=[]
array2=[]
for i in array:
    if i<0:
        array1.append(i)
    else:
        array2.append(i)

array=array1+array2
print(array)

int[] arr = { -1, 1, 3, -2, 2 };
        boolean lo;

        do {
            lo = false;
            int temp = 0;
            for (int i = 0; i < arr.length - 1; i++) {

                    if (arr[i] >= 0 && arr[i+1] <= 0) {
                        temp = arr[i];
                        arr[i] = arr[i+1];
                        arr[i+1] = temp;
                        lo = true;

                }
            }
        } while(lo);

        for(int a : arr) {
            System.out.println(a);
        }

n = input("numlist: ")

def ss(n) _p = [] _m = [] for p in n: if p > 0: _p.append(p) elif p < 0: _m.append(p) sortnum = _m + _p print(sortnum)

negativeNumbers=[]
positiveNumbers=[]


numbers=[-1,1,3,-2,2]
for x in numbers:
    if x<0:
        negativeNumbers.append(x)
    else:
        positiveNumbers.append(x)

sortedNumbers=negativeNumbers+positiveNumbers

plus=''
for x in sortedNumbers:
    plus+=str(x)
    plus+=' '
print(plus)

public class solution {

    public static void main(String[] args) {

    int[] list = new int[] {-1, 1, 3, 2, -2};
    for(int i = 0; i < list.length-1; i++) {
        for(int j = 0; j < list.length-1-i; j++) {
            if(list[j] > 0 && list[j+1] < 0) {
                int k = list[j];
                list[j] = list[j+1];
                list[j+1] = k;
            }
        }
    }
        for(int k : list) {
            System.out.print(k + " ");
        }
    }
}

input = [-1,1,3,-2,2]
m = []
p = []

for i in range(len(input)) :
    if input[i] < 0 :
        m.append(input[i])
    elif input[i] > 0 :
        p.append(input[i])
print(m + p)

n=[-1,1,3,-2,2,-3]
a=[i for i in n if i<0]
b=[j for j in n if j>0]
print(a+b)

arr = [-11, -9, 12, 15, -1, 2, 1, 5, -3, -7, 8, -2, 7, 4, 0]

a = [x for x in arr if x < 0]

b = [x for x in arr if x >= 0]

a.sort(reverse=True)

b.sort()

new_arr = a + b

print(new_arr)

nums = [-1,1,3,-2,2]

negatives = []
positives = []

for num in nums:
    if num < 0:
        negatives.append(num)
    elif num >= 0:
        positives.append(num)

result = negatives + positives
print(result)

#include <iostream>
using namespace std;

int main() {
    int intArray[] = { -1,1,3,-2,2,-5 };

    for (int i = 0; i < sizeof(intArray) / sizeof(int); i++) {
        int key = intArray[i];
        if (key < 0) {
            int j;
            for (j = i - 1; j >= 0 && intArray[j]>0; j--) {
                intArray[j + 1] = intArray[j];
            }
            intArray[j + 1] = key;
        }
    }

    for (int i = 0; i < sizeof(intArray)/sizeof(int); i++)
        cout << intArray[i] << " ";

    return 0;
}

namespace _62일차_10월02일
{        
    class MainApp
    {        
        static void Main(string[] args)
        {
            int[] Array_int = new int[] { -1, 1, 3, -2, 2 };
            List<int> Temp = new List<int>();
            for(int i = 0; i < Array_int.Length; i++)
            {
                if (Array_int[i] < 0)
                {
                    Temp.Add(Array_int[i]);
                }
            }
            for(int j = 0; j < Array_int.Length; j++)
            {
                if (Array_int[j] >= 0)
                {
                    Temp.Add(Array_int[j]);
                }
            }

            foreach (var Result in Temp)
            {
                Console.Write($"{Result} ");
            }

        }
    }
}