면접관이 저런 문제를 낸 이유는 면접 참여자가 효율적인 시간복잡도를 갖는 알고리즘을 제시하거나, 본인의 코드가 다른 사람이 짠 코드보다 왜 좋은지를 물어보려고 하려고 한게 아닐까요? 이유에 대한 설명없이 코드만 무작정 올리시니 갑갑하네요. 원문 링크가 봐도 내 알고리즘이 nlogn이나 n^2이다 혹은 내 알고리즘이 더 효율적이다 하고 있는데.. 푸는게 중요한게아니라 본인 알고리즘을 설득하는 과정이 중요한거 같네요. 다른 질문에 비해 쓸데없이 답변이 많은걸 보면 나 이런 문법, 혹은 이렇게 생각없이 풀줄안다 자랑하는 거 같기도 하구여.

펄입니다

my@a=qw(a1 a2 a3 a4 a5 b1 b2 b3 b4 b5);for(0..@a/2-1){push@b,($a[$_],$a[$_+@a/2])}print"@b\n"

파이썬 2.7

l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']

l1 = l[:len(l)/2]
l2 = l[len(l)/2:]

result = []
for i1, i2 in zip(l1,l2):
    result.extend([i1, i2])

print result

[a1, a2, a3 ... , an, b1, b2, b3, ... , bn]에서 b1은 n 번째 원소입니다. 이 b1 을 버블정렬처럼 앞에 있는 원소랑 바꿔서 앞으로 옮겨서 a1 뒤로 옮깁니다. 목표 인덱스는 다음과 같습니다. b1 (n) -> 1 b2 (n + 1) -> 3 b3 (n + 2) -> 5

def do(xs):
    n = len(xs) // 2
    for i in range(n, n*2):
        for j in range(i, (i-n)*2+1, -1):
            xs[j], xs[j-1] = xs[j-1], xs[j]

a = [1, 2, 3, 4, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17]
print(a)
do(a)
print(a)

아래는 좀 반칙같지만, 파이썬의 슬라이스 대입은 in-place로 처리된다고 합니다.

파이썬문서

def do(a):
    n = len(a) // 2
    a[:n*2:2], a[1:2*n:2] = a[:n], a[n:]

a = [1, 2, 3, 4, 5, 6, 7, 11, 12, 13, 14, 15, 16, 17]
do(a)
print(a)

R로 풀어봤어요

amazon=function(v){
    b=vector()
    for(i in seq(1, length(v), by=2)) b[c(i,i+1)]=v[c(i+1, i+length(v)+1)/2]
    b
}

실행

amazon(c("a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"))
    [1] "a1" "b1" "a2" "b2" "a3" "b3" "a4" "b4" "a5" "b5"

빈 벡터를 생성하고 새로 생성한 벡터의 원소 두개씩을 주어진 벡터에서 추출하는 것으로 풀었어요

파이썬 3.2.5 기준입니다.

amazon = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"]
amazon_final = []
index = amazon.index("b1")

for i in range(index):
    amazon_final.append(amazon[i])
    amazon_final.append(amazon[index+i])

print(amazon_final)

Python

def Sort(a):
    return int(a[1:])*1000+ord(a[0])
def Amazon(list):
    print(sorted(list, key=Sort ))

list = ['a1','a2','a3','a4','a10','a11','b1','b2','b3','b4','b10','b11']
Amazon(list)

자바요...ㅎㅎ

String[] arr = new String[]{"a1","a2","a3","a4","b1","b2","b3","b4"};

    public static void main(String[] args)
    {
        main ma = new main();
        ma.sortAlphabet();
    }

    public void sortAlphabet()
    {
         int s = arr.length;
            int c = s / 2;
            for (int i = c; i < s; i++) {
                int m = s - i;
                int t = i;
                while (m > 1) {
                    String v = arr[t];
                    arr[t] = arr[t - 1];
                    arr[t - 1] = v;
                    m--;
                    t--;
                }
            }
            System.out.println(Arrays.toString(arr));
    }

(defn amazon [& lst]
  (let [half (quot (count lst) 2)
        fore (take half lst)
        back (drop half lst)]
    (interleave fore back)))

Clojure 코드입니다.

설명

시퀀스를 앞의 반(take half lst)과 뒤의 반(drop half lst)으로 나누고

나눠진 두 시퀀스의 원소들을 차례대로 교차 배치(interleave %1 %2)하였습니다.

테스트

=> (amazon)
()

=> (amazon :a1 :b1)
(:a1 :b1)

=> (amazon :a1 :a2 :b1 :b2)
(:a1 :b1 :a2 :b2)

=> (amazon :a1 :a2 :a3 :a4 :a5 :a6 :b1 :b2 :b3 :b4 :b5 :b6)
(:a1 :b1 :a2 :b2 :a3 :b3 :a4 :b4 :a5 :b5 :a6 :b6)

answer=[]
for i, j in zip(amazon[:len(amazon)/2], amazon[len(amazon)/2:]):
   answer.append(i)
   answer.append(j)

python으로 풀었습니다.

answer라는 비어 있는 리스트를 만든 다음에, amazon을 반반 나누어 루프를 이용해 answer 라는 리스트에 하나씩 넣는 방법으로 하였습니다.

Java로 간단하게 해봤습니다

//바꾸기전 배열:Before[], 바꾼후 배열 : After[]
int L=Before.length, l=L/2, i; //Before 배열크기는 짝수라는 가정 하에
String[] After=new String[L];
for(i=0;i<l;i++){
    After[i*2]=Before[i];
    After[i*2+1]=Before[l+i];
}

b가 시작하는 위치를 감지해서 작동 하는 방식 입니다.

        String[] arr = new String[] {"a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};
        String[] after = new String[arr.length];

        int m = 1;
        int idx1 = 0;
        int idx2 = 0;
        for(int i =0; i<arr.length;++i) {
            if('b' == arr[i].charAt(0)) {
                idx2 = i; break;
            } 
        }

        for(int i =0; i<arr.length;++i) {
            if(1 == m) {
                after[i] = arr[idx1];
                idx1++;
            } else {
                after[i] = arr[idx2];
                idx2++;
            }
            m = (m==1)?0:1;
        }

list_1=['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
listlen=len(list_1)
halflen=int(listlen/2)

list_a=list_1[0:halflen]
list_b=list_1[halflen:listlen]
list_result=[]

for i in range(0,halflen):
    list_result.append(list_a[i])
    list_result.append(list_b[i])

print(list_result)

public String[] amazon(String[] arr){
        String[] result = new String[arr.length];
        int aIdx=0, bIdx=arr.length/2;
        int idx=0;
        int flag=0;
        while( bIdx < arr.length ){
            switch(flag){
            case 0:
                result[idx++] = arr[aIdx++];
                flag=1;
                break;
            case 1:
                result[idx++] = arr[bIdx++];
                flag=0;
                break;
            default:
                break;
            }
        }
        return result;
    }

다른 분들의 풀이를 보아하니 참 신기하군요 ㅠ

def grpsrt(lst):
    q1 = []
    q2 = []
    result = []
    for i in range(len(lst)):
        if i < len(lst)/2:
            q1.append(lst[i])
        else:
            q2.append(lst[i])
    for j in range(len(q1)):
        result.append(q1[j])
        result.append(q2[j])

    print result

a = ['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
grpsrt(a)

public class ArraySortForAmazon {

    // Char로 뒤에 숫자만 가져와서 버블 소트로 정렬 및 구현하였습니다.
    public static void main(String args[]){
        String[] a = {"a1", "a2", "a3", "a4", "a5", "a6", "b1", "b2", "b3", "b4", "b5", "b6"};
        String temp = "";
        List<String> list = new ArrayList<String>();

        for(int i=0; i<a.length; i++){
            char c = a[i].charAt(1);
            for(int j=1; j< (a.length - 1); j++){
                if(a[j-1].charAt(1) > a[j].charAt(1)){
                    temp = a[j-1];
                    a[j-1] = a[j];
                    a[j] = temp;
                }

            }
        }

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

c++11 / sort 방식

#include <sstream>
#include <iostream>
#include <vector>
#include <algorithm>

class ID {
public:
  ID(const std::string& str) {
    std::stringstream ss(str);
    ss >> alphabet_ >> number_;
  }
  char alphabet() const {return alphabet_;}
  int number() const {return number_;}
  bool operator<(const ID& rhs) const {
    if (number_ != rhs.number()) {
      return number_ < rhs.number();
    } else {
      return alphabet_ < rhs.alphabet();
    }
  }
private:
  char alphabet_;
  int number_;
};

std::ostream& operator<<(std::ostream& out, const ID& id) {
  return out << id.alphabet() << id.number();
}

class IDList {
public:
  IDList(const std::vector<std::string>& v) {
    for (auto x : v) v_.push_back(ID(x));
  }
  IDList& Sort() {
    std::sort(v_.begin(), v_.end());
    return *this;
  }
  const std::vector<ID>& v() const {return v_;}
private:
  std::vector<ID> v_;
};

std::ostream& operator<<(std::ostream& out, const IDList& list) {
  for (auto x : list.v()) out << x << " ";
  return out;
}

int main() {
  std::cout << IDList({"a1", "a2", "a3", "b1", "b2", "b3"}).Sort() << std::endl;
  return 0;
}

실행

$ g++ amazon.cpp -std=c++11 && ./a.out
a1 b1 a2 b2 a3 b3

python 3.4 입니다.

import unittest

def merge_lists(a, b):
    c = []
    for i in range(len(a)):
        c.append(a[i])
        c.append(b[i])
    return c

def merge_lists2(a, b):
    c = []
    for i, j in zip(a, b):
        c.append(i)
        c.append(j)
    return c

class TestMergeList(unittest.TestCase):
    def test_merge_lists(self):
        self.assertEqual(merge_lists([1], [2]), [1, 2])
        self.assertEqual(merge_lists([1, 2, 3], [4, 5, 6]), [1, 4, 2, 5, 3, 6])

    def test_merge_lists2(self):
        self.assertEqual(merge_lists2([1], [2]), [1, 2])
        self.assertEqual(merge_lists2([1, 2, 3], [4, 5, 6]), [1, 4, 2, 5, 3, 6])

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

#include <iostream>
using namespace std;

int main()
{
    char chArr[] = { 'a', 'b', 'c', 'd', 'e', '1', '2', '3', '4', '5' };
    int arr_size = end(chArr) - begin(chArr);
    char *resArr = (char *)malloc(sizeof(char)*arr_size);
    int a_index = 1, b_Index = arr_size / 2;

    for (int i = 0; i < arr_size; i++)
    {       
        if (i % 2 == 0)
        {
            if (i == 0)
                resArr[i] = chArr[i];               
            else
            {
                resArr[i] = chArr[a_index];
                a_index++;
            }
        }
        else
        {
            resArr[i] = chArr[b_Index];
            b_Index++;
        }
    }

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

    free(resArr);
    return 0;
}

C++ 이에요

파이썬 3.4 입니다.

input_list = ['a1','a2','a3','a4','b1','b2','b3','b4']
pos = input_list.index('b1')
output_list = []

for x in range(pos):
    output_list.append(input_list[x])
    output_list.append(input_list[x+pos])

print(output_list)

// C# 입니다.
using System;
using System.Collections.Generic;

class Program
{
    static string[] input = new string[] { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5" };

    static void Main()
    {
        List<string> output = new List<string>();
        for (var i = 0; i < input.Length / 2; i++)
        {
            output.Add(input[i]);
            output.Add(input[i + input.Length / 2]);
        }
        foreach (var outputStr in output)
        {
            Console.Write(outputStr + "  ");
        }
        Console.WriteLine("");
    }
}

파이썬입니다.

def transform(aList):
    return sum([list(x) for x in zip(aList[:len(aList)//2], aList[len(aList)//2:])], [])

print transform([1,2,3,4,5,6])

def transform(array)
  half = array.size / 2
  array.take(half).zip(array.drop(half)).flatten
end

def transform(array)
  array.group_by.with_index{|_,i|i%2}.map(&:last).flatten
end

문제 원문에 "in-place"라는 조건이 있네요. array size에 비례해서 추가적인 memory를 사용하지 않고 풀어야 되니 생각만큼 쉽지는 않은 듯.

원문 댓글의 풀이 중, 가운데부터 점차로 두 숫자를 swap해나가는 알고리즘이 참 기발하길래 그대로 따라서 C++로 아래와 같이 구현해봤습니다. interleave 함수가 핵심입니다.

#include <iostream>

using namespace std;

void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

void interleave(int* array, const int n)
{
    // swap pairs incrementally from the middle
    for (int i=n-1, numSwap=1; i>0; --i, ++numSwap)
        for (int j=0; j<numSwap; ++j)
            swap(array[i+2*j], array[i+2*j+1]);
}

int main(int argc, char* argv[])
{
    const int K_N = 10;
    int ab[2 * K_N] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};

    interleave(ab, K_N);

    // 제대로 섞였는지 확인.
    for (int i=0; i<2*K_N; ++i)
        cout << ab[i] << " ";
    cout << endl;

    return 0;
}

python 입니다. 문제를 제대로 이해했는지 모르겠네요.

import unittest

def func(l, new=[]):
  a = l[:len(l)/2]
  b = l[len(l)/2:]

  for i in range(len(l)/2):
    new.append(a[i]); new.append(b[i])
  return new 

class Test(unittest.TestCase):
  def test1(self):
    self.assertEqual([1,6,2,7,3,8,4,9,5,0], func([1,2,3,4,5,6,7,8,9,0]))

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

coding by python beginner

l1 = ['a1', 'a2', 'a3', 'a4', 'b1', 'b2', 'b3', 'b4']
rs = []; half = int( len(l1) / 2 )
for i in range( half ): rs.extend( ( l1[i], l1[i + half] ) )
print(rs)

Scala

def f(arr:Array[String]) = {
    val n = arr.size / 2
    val left = arr.slice(0, n)
    val right = arr.slice(n, 2 * n)
    for(i <- 0 until n) {
        arr.update(2 * i, left(i))
        arr.update(2 * i + 1, right(i))
    }
    arr
}

배열을 n개씩 둘로 나누고, 짝수번째 인덱스는 왼쪽 배열, 홀수번째 인덱스는 오른쪽 배열의 원소가 들어가도록 했습니다.

scala로 구현했습니다.

def convert[T](xs: List[T]): List[T] = {
    def fn(as: List[T], bs: List[T], acc: List[T]): List[T] = {
        if(as.isEmpty) {
            acc.reverse
        } else {
            fn(as.tail, bs.tail, bs.head :: as.head :: acc)
        }
    }

    val (as, bs) = xs.splitAt(xs.size / 2)

    fn(as, bs, Nil)
}


println(convert(List(1,2,3,4,5,6,7,8,9,10)))

Using python 개인적으로 두 개를 짜봤는데 후자가 더 빠른것 같네용..

a = ["a1","a2","a3","a4","a5","a6","a7","a8","a9","a10","b1","b2","b3","b4","b5","b6","b7","b8","b9","b10"]


def abSort(a):
    l = 0
    d = []
    b = [x for x in a if x[0]=='a']
    c = [x for x in a if x[0]=='b']
    for i in range(len(b)):
        d.append(b[i])
        d.append(c[i])
    print d

def abSort2(a):
    l = 0
    idx2 = int(len(a)/2)
    for i in range(idx2,len(a)):
        for j in range(len(a)-2):
            if a[j][1:]==a[i][1:]:
                a.insert(j+1, a[i])
                a.pop(i+1)
    print a

#데이터
array = []
new = []
index = 0

#처리
def makearray(n):
    for k in range(n):
        array.append("a"+str(k+1))
    for k in range(n):
        array.append("b"+str(k+1))
    global index                   
    index = n

def ssort(src):
    for k in range(index):
        new.append(src[k])
        new.append(src[index+k])


#입출력
makearray(15)
ssort(array)
print(new)

416.py

inputs=["a1","a2","a3","a4","b1","b2","b3","b4"] ans=[] n=len(inputs)/2 for x in range(n): ans.append(inputs[x]) ans.append(inputs[x+n]) print ans

swap문제로 풀진 않았어요 일단 결과만.. 흠흠

C#으로 작성했습니다. O(n^2) 입니다.

using System.Collections.Generic;

        public void Intervene(List<int> inputs, int n)
        {
            var middle = n/2;
            for (int i = 1; i < middle; i++)
                for (int j = 0; j < i; j++)
                    Swap(inputs, middle - i + 2*j, middle - i + 2*j + 1);
        }

        public void Swap(List<int> inputs, int x, int y)
        {
            var temp = inputs[x];
            inputs[x] = inputs[y];
            inputs[y] = temp;
        }

    Sub main()
        Dim sb As New Text.StringBuilder
        Dim n As Integer = Val(Console.ReadLine)
        Dim arr As New List(Of String)

        '// n만큼 배열 생성
        For i As Integer = 1 To n
            arr.Add("a" & i)
        Next
        For i As Integer = 1 To n
            arr.Add("b" & i)
        Next

        '// 정렬
        arr = arr.OrderBy(Function(d As String) d).OrderBy(Function(d As String) CInt(d(1).ToString)).ToList

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

        Console.ReadLine()
    End Sub

정렬을 두번합니다. a 또는 b에 대하여 정렬 후 숫자에 대해 정렬을 합니다.

    static int getIndx(String str)
    {
        int indx = 0;
        if (str.charAt(0) == 'a')
            indx = 2 * ((str.charAt(1) - '0') - 1);
        else
            indx = 2 * (str.charAt(1) - '0') - 1;

        return indx;
    }


static void exce29()
    {
        String[] input = { "a1", "a2", "a3", "a4", "a5", "a6", "b1", "b2", "b3", "b4", "b5", "b6" };
        String[] output = new String[input.length];

        for (int i = 0; i < input.length / 2; i++)
        {
            output[2 * i] = String.format("a%d", i + 1);
            output[2 * i + 1] = String.format("b%d", i + 1);
        }

        System.out.println("input");
        for (int i = 0; i < input.length; i++)
            System.out.printf("%s ", input[i]);
        System.out.println("\noutput");
        for (int i = 0; i < output.length; i++)
        {
            System.out.printf("%s ", output[i]);
        }
        int cnt = 0;
        int indx = 0;

        while (cnt < input.length)
        {
            if(indx != getIndx(input[indx]))
            {
                int to = getIndx(input[indx]);
                String temp = input[indx];
                input[indx] = input[to];
                input[to] = temp;
            }
            else
                indx++;

            cnt++;
        }
        System.out.println("\noutput");
        for (int i = 0; i < input.length; i++)
            System.out.printf("%s ", input[i]);
    }

주어진 문제에 의하면 [a1,a2,a3...,an,b1,b2...bn] 이기때문에 a,b의 갯수 모두 n개씩 입니다. 출력용 배열을 새로 하나 만들어서 거기에 값을 넣는 식으로 했는데... 문제의 바꾸시오 부분이 아무래도 신경쓰여서 바꾸는 방법으로 하는것도 구현했습니다. 문제에서 a,b의 갯수가 같다고 제시되어있기때문에 해당 문자열이 있어야 할 자리를 알 수 있습니다. 문자열을 이용해서 있어야 할 자리를 알아내고, 있어야 할 자리로 넣어주는 작업은 n번만 하면 정렬이 끝납니다. 따라서 O(n)입니다.

alist = []; blist = []

inte = input()
inte = int(inte)

for i in range(0, inte):
    alist.append(str("a" + str(i+1)))
    blist.append(str("b" + str(i+1)))

totallist = alist + blist
print(totallist)
print(inte)
print(len(totallist))
temp = []
for ii in range(0, inte):
    temp.append(totallist[ii])
    temp.append(totallist[ii+int(inte)])

print(temp)

임의의 'n'값을 입력받아서 먼저 제시된 문제에 따르는 리스트를 2개(an항, bn항의 집합 각각) 만들고, 그것을 합쳐서 문제의 리스트를 구성했습니다. 그런 다음 다시 새로운 빈 리스트에, 그 원소들을 엇갈려서(ai, bi항을 넣을 수 있도록, k=n/2라 할 때 매 i회차마다 통합 리스트의 i번 항과 i+k번 항을 빼내도록 하여) 옮겨넣도록 하였습니다.

amazon     :: [a] -> [[a]]
amazon xs  = [ [a1] ++ [a2] | (a1,a2) <- zip (take half xs) (drop half xs) ]
              where half = (length xs) `div` 2

• python으로 작성했습니다. 전 정렬문제로 이해했습니다. (다른분들 풀이보니 대체로 절반나눠 합치는 해법이네요)

l=['a1','a2','a3','a4','b1','b2','b3','b4','c1','c2','c3','c4'] # -> a1,b1,c1,a2,b2...

def getAlphaDigit(s):
    print s
    for idx,c in enumerate(s):
        if c.isdigit():
            return s[:idx],int(s[idx:])

def digitFirstSort(a1,b2): 
    if a1[1]==b2[1]:
        return ord(a1[0])-ord(b2[0])
    else:
        return a1[1]-b2[1]


l.sort(cmp=digitFirstSort,key=getAlphaDigit)

print l

def arrange(p):
    return sum([[a,b] for a,b in  zip( p[:len(p)/2],p[len(p)/2:] )],[])

strng = raw_input("input a list of coordinates, divided by commas only:")
lst=strng.split(',')
nwlst = []
blst = lst[len(lst)/2:len(lst)]
lst = lst[0:(len(lst)/2)]
for i in range(len(lst)):
    nwlst.append(lst[i])
    nwlst.append(blst[i])
print nwlst

an 이랑 bn 이 아니라 an bm 이었으면 더 복잡할 뻔 했네요

Ruby

제약조건 확인 전에 풀었던 방법들도 첨부합니다.

# 짧게
transform = ->a { a.shift(a.size/2).zip(a).flatten }

# 가운데 지점부터 n-1회 스왑
swap = ->arr { arr.each_slice(2).map {|a,b|a,b=b,a}.flatten }
transform = ->a,n=a.size/2 { (1...n).each{|i|a[n-i,i*2]=swap[a[n-i,i*2]]}; a}

# 가운데 지점부터 n-1회 스왑. in-place 버전
transform = ->a,n=a.size/2 { (1...n).each {|i| (0...i).each{|j|x=n-i+2*j;a[x],a[x+1]=a[x+1],a[x]} }; a }

Test

expect(transform[%w(a b c 1 2 3)]).to eq %w(a 1 b 2 c 3)

def change(li):return(list(li[divmod(x,2)[0]] if x%2 == 0 else li[divmod(x,2)[0]+len(li)//2] for x in range(len(li))))

파이썬 3.5.1입니다.

파이썬3.4입니다. 하나의 저장소를 써야한다는 조건 뜻을 잘 모르겠지만, 변수를 더 만들지 말라는 뜻인거같아 한줄에 이어붙였지만 가독성은 떨어지네요.

from itertools import *
def make(n):
    '배열을 만든다'
    return ['a' + str(i) for i in range(1, n + 1)] + \
            ['b' + str(i) for i in range(1, n + 1)]
s = make(8) #[a1, a2, ... a8, b1, b2, ... b8]
#a = s[:len(s) // 2] #[a1, a2, ... a8]
#b = s[len(s) // 2:] #[b1, b2, ... b8]
#c = list(zip(a, b)) #[(a1, b1), (a2, b2), ... (a8, b8)]

print([x for x in chain.from_iterable(list(zip(s[:len(s) // 2], s[len(s) // 2:])))])

2016-10-20
소트에서 key를 이용하니 무척 간단해지네요^^

q = ['a1', 'a2', 'a3', 'b1', 'b2', 'b3']

print(sorted(q, key=lambda k: int(k[1:])))

C로 작성했고 추가적인 메모리공간을 사용하지 않았습니다.

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

#define NUM 20

int main(int argc, char *argv[])
{
    char array[NUM][8] = {"a1", "a2", "a3", "b1", "b2", "b3"};
    int i;
    int pos = 0;

    for(i = 0; i < NUM; i++)
    {
        if(strcmp("b1", array[i]) == 0)
        {
            break;
        }
    }

    pos = i * 2;
    for(i = 1; i < pos; i++)
    {
        if(i % 2 == 0)
        {
            sprintf(array[i], "a%d", i/2 + 1);
        }
        else
        {
            sprintf(array[i], "b%d", i/2 + 1);
        }
    }

    for(i = 0; i < pos; i++)
    {
        printf("%s ", array[i]);
    }
    printf("\n");
    return 0;
}

a=["a1","a2","a3","a4","an","b1","b2","bn"]
for i in range(len(a)):
    a.append(a[0][1]+a[0][0])
    a.pop(0)
a.sort()
for i in range(len(a)):
    a.append(a[0][1] + a[0][0])
    a.pop(0)
print(a)

저장소를 하나 사용하라는 말이 for 도 사용하면 안되는 것인지 몰라서 일단 사용해봅니다.

example = ['a1', 'a2', 'a3', 'a4', 'a5', 'b1', 'b2', 'b3', 'b4', 'b5']

print(list(mods[::-1] for mods in sorted(list( exs[::-1] for exs in example))))

Python입니다. 숫자를 문자보다 우선한다는 것에 착안하여 순서를 앞뒤로 바꾸고, 순서정렬을 한뒤 다시 문자의 앞뒤룰 바꾸었습니다.

# Amazon Problem My Code

original = ['a1', 'a2', 'a3', 'a4', 'an', 'b1', 'b2', 'b3', 'b4', 'bn']
tempA = original[:int(len(original) / 2)]
tempB = original[int(len(original) / 2):]
result = []
for i in tempA:
    result.append(i)
    result.append(tempB[int(len(result) / 2)])
print(result)

제 알고리즘은 두 개의 tempA list를 생성해서 기존 list를 middle을 중심으로 나누고 차례대로 합쳐서 완성한 결과이다. 아주 단순한 divide and conquer 라고 할 수 있다. 복잡도는 n이다. 하지만 풀고 나서 원문을 보니 기존 memory만 이용해야 한다는 조건때문에 틀렸다고 생각한다. 또한 다른 분의 글을 읽고 느낀점으로도 단순히 코드를 이용해서 풀 생각만을 하는 것이 아니라 자신의 알고리즘을 이용해서 설득을 시키라는 부분이 매우 인상적이었다. 차근차근 다른 분드르이 좋은 부분들을 습득해서 좀 더 나은 개발자가 되도록 노력해 보려고 합니다.

#include <iostream>
#include <string>
#include <vector>
using namespace std;
void main()
{
    string input[] = { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5" };
    int size = _countof(input);
    vector <string> output;
    for (int i = 0; i < size / 2; i++)
    {
        output.push_back(input[i]);
        output.push_back(input[i + (size / 2)]);
    }
    for (int i = 0; i < output.size(); i++)
    {
        cout << output[i] << " " << endl;
    }
}

Python3 입니다. reduce를 사용하면 더 깔끔해질것 같네요. 주어진 데이터는 A타입이 n개, B타입이 n개로 같으니까 바로 2로 나누면 될것 같네요.

a = ["a1","a2","a3","a4","b1","b2","b3","b4"]
r=[]
for a,b in zip(a[:len(a)//2],a[len(a)//2:]):
  r += [a,b]
print(r)

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

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

            //기대 결과 {1,6,2,7,3,8,4,9,5,10}
            AmazonSort(arr);

        }

        static void AmazonSort(int [] _arr)
        {
            int length = _arr.Length;

            int frontIndex = 1; //swap할 인덱스
            for(int i = (length / 2); i < length; i++)
            {
                int insert = _arr[i]; //삽입할 값 빼내고

                for(int j = i; j > frontIndex; j--)
                {
                    _arr[j] = _arr[j - 1];
                }
                _arr[frontIndex] = insert;
                frontIndex = frontIndex + 2;
            }
        }
    }
}

파이썬 코드입니다. a따로 b따로 리스트에 저장해서 반복문을 이용해 하나하나 받아낼 생각을 했으나... 댓글에 중요한 조건이 있더라구요. 그래서 고민하다가 직접 써봐야할 것 같아서 이동 규칙을 적어봤습니다. 그랬더니 0~n-1번째에 있는 ak들은 index가 두배가 되어 이동하고, n~2n-1번째에 있는 bk들은 index가 x라면 (x-1)/2 + n의 index로 이동하더라구요

튜플로 a,b = b,a와 같이 한번에 이동하는 것이 가능하다는 것에 착안하여 리스트로도 될까해봤더니 되기에, list comprehension에 if/else를 접목해봤습니다.

def Sort_in_Place(n):
    n = [n[x//2] if x%2==0 else n[(x-1)//2 + (len(n)+1)//2]
         for x in range(len(n))]
    return n

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

a들의 위치가 변경될 대마다 a들의 위치를 저장하고 저장된 위치를 바탕으로 sorting

public class ArrSort {
    public static void main(String args[]) {
        int n;
        String arr1[] = {"a1", "a2", "a3","a4","a5", "b1", "b2", "b3","b4","b5"};
        String arr2[] = {"a1", "a2", "a3","a4","a5","a6", "b1", "b2", "b3","b4","b5","b6"};
        String arr3[] = {"a1", "a2", "a3","a4","a5","a6","a7", "b1", "b2", "b3","b4","b5","b6","b7"};
        String arr4[] = {"a1", "a2", "a3","a4","a5","a6","a7","a8", "b1", "b2", "b3","b4","b5","b6","b7","b8"};
        String out[];

        n=10;
        out = sort(arr1, n);
        for(int i=0;i<n;i++)
            System.out.print(out[i]+" ");
        System.out.println();
        n=12;
        out = sort(arr2, n);
        for(int i=0;i<n;i++)
            System.out.print(out[i]+" ");
        System.out.println();
        n=14;
        out = sort(arr3, n);
        for(int i=0;i<n;i++)
            System.out.print(out[i]+" ");
        System.out.println();
        n=16;
        out = sort(arr4, n);
        for(int i=0;i<n;i++)
            System.out.print(out[i]+" ");
        System.out.println();

    }

    static String[] sort(String arr[], int n) {
        int val = n/2;
        int loc[] = new int[n/2+1]; //6
        int index1 = 2;
        int index2 = 2;
        for(int i=1;i<n-2;i++) {
            val=i/2+n/2;
            if(i%2 == 0) {
                val = loc[index2];
                loc[index2] = 0;
                index2++;
            }
            if(i<n/2) {
                loc[index1] = val;
                index1++;
            } else {
                for(int j=2; j<=n/2;j++) {
                    if(loc[j] == i) {
                        loc[j] = val;  
                    }
                }
            }           
            String temp;    
            temp = arr[i];
            arr[i] = arr[val];
            arr[val] = temp;
        }
        return arr;
    }
}

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

using namespace std;



int main(void)
{
    string saTmp[] = { "a1", "a2", "a3", "a4", "b1", "b2", "b3", "b4" };
    string Temp;
    int k = 0;
    int saTmpsize = sizeof(saTmp) / sizeof(saTmp[0]);
    char a[2] = { 0, };

    //a1 a2 a3 a4 b1 b2 b3 b4
    for (int i = 0; i < saTmpsize; i++) {
        cout << saTmp[i] << " ";
    }
    cout << endl;

    for (int n = 1; n <= saTmpsize / 2; n++) {
        _itoa(n, a, 10);    //n을 문자로 바꿈 '1' '2' '3' '4'
        for (int i = 0; i < saTmpsize; i++) {
            //saTmp[0  ~ saTmpsize(7)].find('1'~'4') 순차적으로 앞에서부터 찾는 문자가 있으면
            if (saTmp[i].find(a[0]) != string::npos) {
                if (k != i) {   //k 와 i 가같으면 스왑할 필요가 없음
                    //SWAP 
                    Temp = saTmp[k];
                    saTmp[k] = saTmp[i];
                    saTmp[i] = Temp;
                }
                k++;
            }
        }
    }
    //a1 b1 a2 b2 a3 b3 a4 b4
    for (int i = 0; i < saTmpsize; i++) {
        cout << saTmp[i] << " ";
    }

    system("pause");
    return 0;
}

lst = ['a1','a2','a3','b1','b2','b3']
cnt = 1
for i in range(len(lst)):
    if (i+1) % 2 == 1:
        lst[i] = 'a'+str(cnt)
    else:
        lst[i] = 'b'+str(cnt)
        cnt += 1
print(lst)

#딱 한줄로 짜보았습니다 
#I love Python!
#python 2.7.xx
question = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"]


print sum(zip(question,question[:len(question)]),()) # core logic

$input  = array('a1','a2','a3','a4','a5','b1','b2','b3','b4','b5');
foreach($input as $val){
    $input[substr($val,0,1)][substr($val,1)] = $val;
}
foreach($input['a'] as $key => $val){
    $input['sum'][] = $input['a'][$key];
    $input['sum'][] = $input['b'][$key];
}
print_r($input['sum']);

이거.. 문제를 잘못 가져오신거 같은데...

배열이 아니구요 정확히는 링크드 리스트입니다. Recursive로 구현하시는 문제에요.

def hap(a,b):
    return [x[y] for x in [[a[x],b[x]] for x in range(len(a))] for y in range(2)]
print(hap(input().split(' '),input().split(' ')))

#### 2017.01.25 D-393 ####

으하~ 짜논코드있는데 입력장소 쓰지 말라해서 다시 생각해서 짰습니다..

자바로 풀었어요... package codingDojang;

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

    //[a1,a2,a3...,an,b1,b2...bn]
    //[a1,b1,a2,b2.....an,bn]

    //초기셋팅
    int num = 10; // 숫자범위설정
    int index = 1;
    int real_index = 0;

    String[] args1 = new String[(num*2)+1];
    String s = "a";
    System.out.print("[");
    while((num*2) >= index) {

        if(num < index) {
            s = "b";
        }

        if(index == num + 1) {
            index = 1;
        }

        args1[real_index] = s + index;

        System.out.print(args1[real_index]);

        if(s == "b" && (num) == index) {
            break;
        } else {
            ++index;
            ++real_index;
            System.out.print(",");
        }

    }
    System.out.print("]");

    //다시 담음
    String[] args2 = new String[(num*2)+1];
    for (int i = 0; i < (args1.length)/2; i++) {

        args2[i*2] = args1[i];
        args2[(i*2) + 1] = args1[num+i];
    }

    //재정렬---> 결과
    System.out.print("[");
    for (int i = 0; i < args2.length-1; i++) {
        if(i > 0 && i < args2.length) {
            System.out.print(",");
        }
        System.out.print(args2[i]);

    }
    System.out.print("]");
}

}

import java.util.Arrays;

public class Amazon {

    //static String[]l = new String[]{"a1", "b1"};
    //static String[] l = new String[]{"a1", "a2", "b1", "b2"};
    //static String[] l = new String[]{"a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};
    static String[] l = {"a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8"};

    public static void main(String[] args) {
        int s = l.length;
        int c = s / 2;
        for (int i = c; i < s; i++) {
            int m = s - i;
            int t = i;
            while (m > 1) {
                String v = l[t];
                l[t] = l[t - 1];
                l[t - 1] = v;
                m--;
                t--;
            }
        }
        System.out.println(Arrays.toString(l));
    }
}

#include<stdio.h>

#define SIZE 8

void Swap(int* a,int* b)
{
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}

int main(void)
{
    int arr[SIZE];
    int i,j,k;

    for(i=0;i<SIZE;i++){
        arr[i]=i;
    }

    k=SIZE/2;
    for(i=SIZE/2-1;i>0;i--)
    {
        for(j=i;j<k;j+=2)
        {
            printf("%d %d %d\n",i,j,k);
            Swap(&arr[j],&arr[j+1]);
        }
        k++;
    }

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

    return 0;
}

C로 작성한 코드며, 추가적인 메모리는 사용안했습니다.

public class Amazon {

    public static void main(String[] args) {
        String input[] = {"1","2","3","4","5","11","12","13","14","15"};
        List result = new ArrayList<String>();

        int ABvalueStep = input.length/2;

        for(int i=0; i<ABvalueStep; i++){
            result.add(input[i]);
            result.add(input[i+ABvalueStep]);
        }//emd for

    }//end main
}//end AmazonClass

class Ideone
{
    public static void main (String[] args)
    {
         String[] arr = new String[] {"a1", "a2", "a3", "a4", "a5", "a6","b1", "b2", "b3", "b4", "b5","b6"};
         String[] result = new String[arr.length];

         for (int i =1;i<(arr.length/2)+1;i++){
            result[2*i-2]=arr[i-1];
            result[2*i-1]=arr[i+arr.length/2-1];
         }

    }
}

lst=["a1","a2","a3","b1","b2","b3"]

nst=[]
for i in range(1, (len(lst)//2)+1) :
    nst.append(lst[i-1] +',' + lst[len(lst)//2+i-1])
k=[",".join(nst)]
print(k)

일단, 주어진 입력 list 외의 저장소를 쓰지 않는 조건으로 풀었습니다.

makelist 는 n 이 주어졌을 때 list 만드는 함수이니 신경 안써도 되고요.

소트의 원리는 이렇습니다.

a1  a2  a3  a4  a5  b1  b2  b3  b4  b5
인 경우에 b1 을 제자리에 놓으려면

index = 1인 a2 부터 index = n + 1 b1 까지의 sublist 를 가지고
[a2, a3, a4, a5, b1] => [b1, a2, a3, a4, a5] 하면 되겠죠

아래와 같이 swap 을 진행하면 됩니다.
[a2, a3, a4, a5, b1] => a2 와 b1 => [b1, a3, a4, a5, a2]
[b1, a3, a4, a5, a2] => a3 와 a2 => [b1, a2, a4, a5, a3]
[b1, a2, a4, a5, a3] => a4 와 a3 => [b1, a2, a3, a5, a4]
[b1, a2, a3, a5, a4] => a5 와 a4 => [b1, a2, a3, a4, a5]

이렇게 하면 
a1  a2  a3  a4  a5  b1  b2  b3  b4  b5 가
a1  b1  a2  a3  a4  a5  b2  b3  b4  b5 로 바뀝니다.

그 다음에는 계속 반복하면 되지요.
[a3  a4  a5  b2] => [b2 a3  a4  a5] 하면 되겠습니다. 
같은 방법을 쓰면 되요

처음 인덱스는 2씩 늘어나고 (1, 3, 5 ...) 마지막 인덱스는 1씩 늘어납니다.
그래서 복잡도는...

어쨌든, in-place storage 를 이용해서 풀어봤습니다.

javascript(ES6)

var makelist = n => Array.from(Array(n), (v, i) => `a${i + 1}`).concat(Array.from(Array(n), (v, i) => `b${i + 1}`));

var amazonsort = function(list) {
    var n = list.length / 2;
    for (let i = 1; i < n; i++) {
        for (let j = i * 2 - 1; j < n + i; j++) {
            [list[j], list[n + i - 1]] = [list[n + i - 1], list[j]];
        }
    }
    return list;
}

var list = makelist(10);
console.log(amazonsort(list));

arr=['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
strarr="".join(arr)
num_a=0
num_b=int(12/2)
length=len(arr)
for i in range(length):
    arr.append(arr[num_a])
    arr.append(arr[num_b])
    num_a+=1
    num_b+=1
    if num_a>=num_b:
        break
del arr[:length]
del arr[length:]
print(arr)

#include <iostream>
#include <string>

using namespace std;

int main() {
    int count = 0;
    int number = 1;
    string array[10] = {"a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};

    cout << "변경 전: ";
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++) {
        cout << array[i] << " ";
    }
    cout << endl;


    for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++) {
        if (array[i].find("a") == 0)
            count++;
        else
            break;
    }
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++) {
        array[i] = "a";
        array[i++].append(to_string(number));
        array[i] = "b";
        array[i].append(to_string(number++));
    }
    cout << "변경 후: ";
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++) {
        cout << array[i] << " ";
    }
    return 0;
}

변경 전: a1 a2 a3 a4 a5 b1 b2 b3 b4 b5 
변경 후: a1 b1 a2 b2 a3 b3 a4 b4 a5 b5

Python3

in-place 입니다.

insertion sort와 유사합니다.

list 내부 구현이 어떤지 모르겠는데 배열이라 생각하면 O(n^2)입니다.

O(n)이나 O(nlogn)은...어렵네요-_-;

def arrange(lst, N):
    for i in range(1, N+1):
        bi = lst.pop(i+N-1)
        lst.insert(i*2-1, bi)

    return lst

l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']
num = list(set([x[-1] for x in l]))
num.sort()
string = list(set([x[0] for x in l]))
L = []
for i in range(1,len(num)+1):
    for s in string:
        L.append(s+str(i))

print L       

def anbn_pattern(a) :  # type(a) == list
    numberlist = []
    result = []

    for i in range(0, len(a)) :
        numberlist.append(int(a[i][1]))

    for n in range(1, max(numberlist) + 1) :
        result.append('a' + str(n))
        result.append('b' + str(n))

    return result

숫자부분만을 따로 모아서 그 중 최댓값을 추출합니다. 그 최댓값을 바탕으로 a1, b1, a2, b2, ... 의 리스트를 새로 작성합니다.

[Python 3.6]

inputArr = ["a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"]
resultArr = []
for pair in zip(inputArr[:int(len(inputArr)/2)], inputArr[int(len(inputArr)/2):]): resultArr += pair
print(resultArr)

lst = ['a1','a2','a3','b1','b2','b3']
a_arr = [x for x in lst if x[0] == 'a']
b_arr = [x for x in lst if x[0] == 'b']
result = []
for idx, str in enumerate(a_arr) :
    result.append(a_arr[idx])
    result.append(b_arr[idx])
print(result)

list = ['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
result = []
Len = int(len(list)/2)
for i in range(Len):
    result.append(list[i])
    result.append(list[Len + i])
print(result)

# python 3.6
inp = ["a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"]
lst_a = inp[:int(len(inp) / 2)]
lst_b = inp[int(len(inp) / 2):]
rst = [val for tup in zip(lst_a, lst_b) for val in tup]
print(rst)

자바 입니다.

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

        String[] arr = {"a1","a2","a3","a4","b1","b2","b3","b4"};

        List<String> list = replace_Arr(arr);
        for(String tmp: list){
            System.out.print(tmp+" ");
        }

    }

    //입력받은 배열을 b가 나오는 시점을 기준으로 2개의 배열로 나눠서
    //새 배열에 숫자가 1부터인걸로 담아서 리턴하는 함수.
    static List<String> replace_Arr(String[] arr){
        int idx=0;
        String temp = "";

        List<String> list = new ArrayList<String>();
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();

        for(int i=0;i<arr.length;i++){
            temp += arr[i];
        }
        idx = temp.indexOf("b");


        for(int i=0;i<(idx)/2;i++){
            list1.add(arr[i]);
        }
        for(int i=(idx)/2;i<arr.length;i++){
            list2.add(arr[i]);
        }

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

        return list;
    }
}

package codingdojang;

public class ex29 {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String arr[] = {"a1","a2","a3","b1","b2","b3"};
    String result[] = new String[arr.length];

    int count = 0;
    for(int i=0; i<arr.length/2; i++) {
        result[count] = arr[i];
        count += 2;
    }

    count = 1;
    for(int j=arr.length/2; j<arr.length; j++) {
        result[count] = arr[j];
        count += 2;
    }


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

}

public class ex29 {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String arr[] = {"a1","a2","a3","b1","b2","b3"};
    String result[] = new String[arr.length];

    int count = 0;
    for(int i=0; i<arr.length/2; i++) {
        result[count] = arr[i];
        count += 2;
    }

    count = 1;
    for(int j=arr.length/2; j<arr.length; j++) {
        result[count] = arr[j];
        count += 2;
    }


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

}

public class MixSwap {
    public static void main(String[] args) {
        String[] str = { "a1", "a2", "a3", "a4", "b1", "b2", "b3", "b4" }; 
        System.out.println(Arrays.toString(solution(str)));
    }

    public static String[] solution(String [] arr){
        int l = arr.length;
        String[] mix = new String[l];
        for(int i = 0; i < l; i+=2){
            mix[i] = arr[i/2];
        }
        for(int i = 1; i < l; i+=2){
            mix[i] = arr[(i/2)+(l/2)];
        }

        return mix;
    }
}

array=["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"] result=[]

a=len(array)//2

for i in range(a): result.append(array[i]) result.append(array[i+a])

print(result)

lst = ['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6']

while lst[-1] != lst[-1]:
    lst.insert(int(lst[-1][1:]), lst[-1])
    del lst[-1]

print(lst)

n = 10
c = [ ('A' + str(x)) for x in range(1,n)] + [ ('B' + str(x)) for x in range(1,n)]

r = []
for x,y in zip(c[:int(len(c)/2)] , c[int(len(c)/2):]) :
    r.append(x)
    r.append(y)

print(r)

x = ["a1","a2","a3","b1","b2","b3"]
y1 = list(filter(lambda x :x[0] =="a",x))
y2 = list(filter(lambda x :x[0] =="b",x))
result =[]
for y1,y2 in zip(y1,y2):
    result.append(y1)
    result.append(y2)
print(result)

```{.java} import java.util.Arrays; import java.util.Scanner; public class amazonTest { public static void main(String[] args) { System.out.println("this is amazon's test, enter the size."); Scanner s = new Scanner(System.in); String[] arr1; String[] arr2; int size = s.nextInt(); s.close(); arr1 = new String[size]; arr2 = new String[size];

    for (int i=0; i<size; i++) {
        arr1[i]="a"+(i+1);
        arr2[i]="b"+(i+1);
    }

    String[] arr3 = new String[size*2];
    for(int i=0; i<size*2; i++) {
        if(i<size) {
            arr3[i]=arr1[i];
        }
        if(i>=size && i<size*2) {
            arr3[i]=arr2[i-size];
        }
    }
    //System.out.println(Arrays.toString(arr3));

    for(int i=0; i<size*2; i++) {
        for(int j=i; j<size*2; j++) {
            if(arr3[j].charAt(1)<arr3[i].charAt(1)) {
                String temp;
                temp = arr3[j];
                arr3[j] = arr3[i];
                arr3[i] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(arr3));

}

}

input = 'a1,a2,a3,an,b1,b2,b3,bn'.split(',')
i = len(input) // 2
output = []
for j in range(i):
    output = output + [input[j]] + [input[i+j]]
print(output)

파이썬으로 작성했습니다. 댓글에 추가적인 저장장소를 사용하지 않아야 한다고해서 pop을 이용해 삭제하고 insert로 다시 삽입하는 방식으로 코드를 작성해 보았습니다. 추가적으로 배열의 형태는 항상 문제에 제시된 형태로만 주어진다고 가정했습니다.

mylist=['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
my_len=int(len(mylist)/2)
idx=1
while my_len<len(mylist):
    mylist.insert(idx,mylist.pop(my_len))
    idx+=2
    my_len+=1
print(mylist)

파이썬 3.6

"""
아이디어>
 1) 리스트를 n개씩 나누어 2개의 리스트를 만들고.
 2) 각 리스트 동일 첫 요소부터 동일 인덱스 요소값을 묶어
 3) 해당 요소값만 차례대로 새로운 리스트에 추가한다.
"""

data = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']

def array_arange(data):
    new_data =[]
    list_a = data[:5]
    list_b = data[5:]
    for i in zip(list_a,list_b):
        new_data.extend(i)
    print(new_data)

if __name__ == "__main__":
    array_arange(data)

* 결과값
['a1', 'b1', 'a2', 'b2', 'a3', 'b3', 'a4', 'b4', 'a5', 'b5']

r로 풀었습니다.

```{r}
v<-c("a1","a2","a3","a4","a5","b1","b2","b3","b4","b5")
u<-NULL
for(i in 1:length(v)){
  if(i%%2==1){
    u[i]<-v[(i+1)/2]
  }else{
    u[i]<-v[i/2+(length(v))/2]
  }
}

u

```

package sortStringAndInteger;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SortStringAndInteger {

    private String[] sort(String[] str) {
        ArrayList<String> list = new ArrayList<String>();

        Arrays.sort(str);

        List<String> result = Stream.of(str).filter(m -> m.contains(Character.toString(str[0].charAt(0))))
                .collect(Collectors.toList());

        for (int i = 0; i < result.size(); i++) {
            list.add(str[i]);

            for (int j = i + 1; j < str.length; j++) {
                if (Integer.valueOf(str[i].charAt(0)) < Integer.valueOf(str[j].charAt(0))
                        && Character.getNumericValue(str[i].charAt(1)) == Character.getNumericValue(str[j].charAt(1))) {
                    list.add(str[j]);

                }
            }

        }

        return list.toArray(new String[list.size()]);
    }

    private String[] insert(String[] str, int i, int j) {
        String temp = str[j];

        for (int k = j; k > i; k--)
            str[k] = str[k - 1];

        str[i + 1] = temp;

        return str;
    }

    private String[] sort2(String[] str) {

        for (int i = 0; i < str.length - 1; i++) {
            for (int j = i + 1; j < str.length - 1; j++) {
                if (str[i].charAt(1) == str[j].charAt(1))
                    str = insert(str, i, j);
            }
        }

        return str;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        SortStringAndInteger ssai = new SortStringAndInteger();

        System.out.println(Arrays.toString(ssai
                .sort(new String[] { "c1", "b1", "b2", "b3", "a1", "a2", "d4", "a3", "a4", "a5", "b4", "b5", "c3" })));
        System.out.println();

        System.out.println(Arrays
                .toString(ssai.sort2(new String[] { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5" })));
    }

}

def change(a):
    b = len(a)
    for i in range(int(b/2)):
        a.insert(2*i+1, a[int(b/2)+2*i])
    a = a[:b]
    return a
print(change(input().split(' ')))

그다지 만족 스러운 코드가 나오지는 않았네요; 각 문자열을 뒤집은 다음 정렬하고 다시 뒤집는 방법을 썻습니다.

using System;
using System.Collections.Generic;

namespace CSharp_Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr = { "a1", "a2", "a3", "b1", "b2", "b3" };
            List<string> list = new List<string>();
            //문자열 뒤집기
            for (int i = 0; i < arr.Length; i++)
            {
                string temp = "";

                for (int j = arr[i].Length - 1; j >= 0; j--)
                {
                    temp += arr[i].Substring(j, 1);
                }

                list.Add(temp);
            }

            //정렬
            list.Sort();

            //문자열 뒤집기
            for(int i = 0; i < arr.Length; i++)
            {
                string temp = "";

                for (int j = arr[i].Length - 1; j >= 0; j--)
                {
                    temp += list[i].Substring(j, 1);
                }
                arr[i] = temp;
            }

            //출력
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write("{0} ", arr[i]);
            }
        }
    }
}

import org.junit.Test;

import java.util.Arrays;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining;

public class Codingdojang {
    @Test
    public void arrayTest() throws Exception {
        assertThat(transformArray(new String[]{"a1", "a2", "a3", "b1", "b2", "b3"}),
                   arrayContaining("a1", "b1", "a2", "b2", "a3", "b3"));
        assertThat(transformArray(new String[]{"a1", "a2", "a3", "a4", "b1", "b2", "b3", "b4"}),
                   arrayContaining("a1", "b1", "a2", "b2", "a3", "b3", "a4", "b4"));
    }

    private String[] transformArray(String[] arr) {
        if (arr.length % 2 != 0) {
            throw new IllegalArgumentException("배열은 반드시 짝수여야 합니다. input:" + Arrays.toString(arr));
        }

        int middle = arr.length / 2;
        String[] newArr = new String[arr.length];

        for (int writeIdx = 0, readIdx=0; readIdx < middle; readIdx++, writeIdx+=2) {
            newArr[writeIdx] = arr[readIdx];
            newArr[writeIdx + 1] = arr[readIdx + middle];
        }

        return newArr;
    }
}

def resort(a):
    print([a[i//2+((len(a)//2)*((-1)**(i%2+1))+(len(a)//2))//2 ] for i in range(len(a))])

#include <stdio.h>

int main() {
    int size;

    printf("수열의 길이를 입력하시오\n");
    scanf_s("%d", &size);
    if (size % 2 != 0) {
        printf("잘못 입력하셨습니다.\n");
        return 0;
    }
    int *a = malloc(sizeof(int) * size);
    int *re= malloc(sizeof(int) * size);
    for (int i = 0; i < size; i++) {
        printf("수열을 입력하시오. %d번째 성분 : ", i+1);
        scanf_s("%d", a + i);
    }
        for (int i = 0; i < size; i++) {
        re[i * 2 > size - 1 ? i*2 - size+1 : i * 2] = a[i];
    }
    for (int i = 0; i < size; i++) printf("%d", re[i]);
    printf("\n");



    free(a);
    free(re);
    return 0;
}

파이썬 3.6으로 풀었습니다. 다른 분들 코드에 비해서 간단해서 이렇게 푸는 것이 맞는지 의구심이 드네요.

input_list = ['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
result = sorted(input_list, key = lambda num: num[1])
print(result)

package main

import (
    "fmt"
)

func main() {
    var input []string
    input = []string{"a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"}
    fmt.Println(divideSlice(input))
}

func divideSlice(s []string) []string {
    l := len(s) / 2
    rst := []string{}
    for idx := 0; idx < l; idx++ {
        rst = append(rst, s[idx], s[l+idx])
    }
    return rst
}

k = ['a1', 'a2', 'a3', 'a4', 'b1', 'b2', 'b3', 'b4']
n = 4
for i in range(n-1):
    print(k)
    k.insert(i*2 + 1, k[n+i])
    k.pop(n+i)
print(k)

Swift입니다. 코멘트에도 있고 원 문제에도 in-place라는 말이 있어서, 다른 Array를 이용하지 않고, Swap을 통해서 해결했습니다. 배열에 20개의 항목이 있으면 Swap은 45번이 일어납니다.

import Foundation

var array = [1,2,3,4,5,6,7,8,9,10,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

print("Input  => ", array)

for i in (array.count / 2)..<array.count {
    for j in 0..<(array.count - i - 1) {
        count += 1
        array.swapAt(i - j, i - j - 1 )
    }
}

print("output => ", array)

def change(li):
    return [list(zip([li[x] for x in range(int(len(li)/2))], [li[y + int(len(li)/2)] for y in range(int(len(li)/2))]))[z//2][z%2] for z in range(len(li))]

Python 3인데 너무 복잡하고 가독성 떨어지네요

    class Program
    {
        static void Main(string[] args)
        {
            //[a1,a2,a3...,an,b1,b2...bn]
            //다음과 같은 형태로 바꾸시오
            //[a1,b1,a2,b2.....an,bn]

            string[] array1 = { "a1", "a2", "a3", "a4", "b1", "b2", "b3", "b4" };

            string[] array2 = new string[array1.Length];

            int nIndex1 = array1.Length / 2;
            int nIndex2 = 0;
            int nComma = 0;

            for (int i = 0; i < array1.Length /2; i++)
            {
                if (i % 2 == 0)
                {
                    array2[nIndex2++] = array1[i];
                    array2[nIndex2++] = array1[nIndex1 + i];
                }
                else
                {
                    array2[nIndex2++] = array1[i];
                    array2[nIndex2++] = array1[nIndex1 + i];
                }
            }

            foreach (var item in array2)
            {
                if (array2.Length - 1 == nComma)
                    Console.Write("{0}", item);
                else
                    Console.Write("{0}, ", item);

                nComma++;
            }
            Console.WriteLine();
        }
    }

  let list = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"]

  for (let i = 0; i < (list.length/2); i++) {
    list.splice(((list.length/2)- i),0, list.pop())
  }
  console.log(list)

library(dplyr)
library(stringr)
x <- c('a1', 'a2', 'a3', 'b1', 'b2', 'b3')
x.unique <- x %>% lapply(function(x) x %>% strsplit('') %>% unlist) %>% unlist %>% unique
x.alpha <- x.unique[!str_detect(x.unique, '\\d')]
x.number <- x.unique[str_detect(x.unique, '\\d')]

expand.grid(x.alpha, x.number, stringsAsFactors = F) %>% 
  t %>% 
    apply(2, function(x) paste(x, collapse = ''))
[1] "a1" "b1" "a2" "b2" "a3" "b3"

dplyr을 chaining을 위한 패키지입니다. stringr은 텍스트 처리를 위한 패키지입니다. expand.grid 이용을 위해 조합을 만들었습니다. expand.grid 위의 코드는 (a,b), (1,2,3)으로 뽑아내기 위한 부분입니다.

// 자바입니다
  public static void main(String[] args) throws Exception { 
        String[] str = {"a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};
        String[] newStr = new String[str.length];

        int a = 0;
        int b = 1;
        for (int i=0; i<str.length; i++) {
            if(str[i].startsWith("a")) { 
                newStr[a] = str[i];
                a += 2;
            }
            if(str[i].startsWith("b")) { 
                newStr[b] = str[i];
                b += 2;
            }
        }
        System.out.println(Arrays.toString(newStr));
    } 

public class arr{
 public static void main(String[] args){
  String arr[] = {"a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"};
  String arr2[] = new String [arr.length];
  for(int i=0;i<arr.length/2;i++){
   arr2[2*i] = arr[i]; 
   arr2[2*i+1] = arr[arr.length/2 +i];
  System.out.print(arr2[2*i] + " " + arr2[2*i+1] + " ");
  }
 }
}

in-place라고 해서 다시 풀어 봤습니다. 배열의 가운데 부터 앞으로 차례대로 옮겼습니다. 시간 복잡도는 (n/2 * n/2)로 O(n^2) 입니다.

   def amazon(arr:Array[Int]):List[Int] = {
      var j = arr.length/2
      for(i <- 1 until arr.length by 2){
        val temp = arr(j)
        (j until i by -1).foreach{
          v => arr(v) = arr(v - 1)
        }
        j += 1
        arr(i) = temp
      }
      arr.toList
    }
    println(amazon(Array(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)))
  }

def amazon(mylist):
    return sorted(mylist,key=lambda a : a[1])


print(amazon(["a1","a2","a3","b1","b2","b3"]))

public class OrderingArrayRun {

    public static void main(String[] args) {

        String[] input = {"a1", "a2", "a3", "b1", "b2", "b3"};

        String temp="";
        for ( int i=0 ; i < input.length-1 ; i++ ) {
            for ( int k=0 ; k < input.length-1-i ; k++ ) {
                if(Integer.parseInt(input[k].substring(1)) > Integer.parseInt(input[k+1].substring(1)) ) {
                    temp = input[k+1];
                    input[k+1] = input[k];
                    input[k]=temp;
                }
            }
        }

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

    }

}

def amazon(arr):
    n = int(len(arr)/2)
    for i in range(2*n-1,n-1,-1):
        arr.insert(i-n+1, arr.pop())
    return arr

print(amazon(['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']))

'''
아래 방법이 가장 간단하고 성능도 nlogn
'''

l = [...]
print(sorted(l, key=lambda k: int(k[1:])))

'''
최선의 알고리즘은 아니지만 제 초등생 아들이 생각해낸 sorting 방법.
양측의 마지막 것만 남겨두고 중간 것을 바꿔치기하는 방식. (n-1)/2 + (n-2)/2 +... 1 의 성능.

a1  a2  a3  a4  a5  b1  b2  b3  b4  b5   
a1  b1  b2  b3  b4  a2  a3  a4  a5  b5   -> 양쪽 a1, b5 만 남겨두고 a 와 b 위치교환
a1  b1  a2  a3  a4  b2  b3  b4  a5  b5   -> 양쪽 a1,b1, a5,b5 만 남겨두고 위치교환
a1  b1  a2  b2  b3  a3  a4  b4  a5  b5
a1  b1  a2  b2  a3  b3  a4  b4  a5  b5
'''

a=["a1","a2","a3","b1","b2","b3"]
b=[]
for i in range(int(len(a)/2)):
    b.append(a[i])
    b.append(a[i+int(len(a)/2)])

print(b)

C#

using System;
using System.Linq;

namespace CD029
{
    class Program
    {
        static void Main()
        {
            string[] input = { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5" };

            int len = input.Length / 2;
            var result = input.Take(len).Zip(input.Skip(len), (x, y) => new string[] { x, y }).SelectMany(e => e);

            Console.WriteLine(string.Join(", ", result));
        }
    }
}

input_list = list(input().split(','))
mid_idx = len(input_list)//2
result=[]
for i in range(mid_idx):
    result.append(input_list[i])
    result.append(input_list[i+mid_idx])
print(result)

s=['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'a10', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8','b9', 'b10']
s1 = []
s2 = []
s_prt =[]
s1_pos = int(len(s)/2)

for i in range(0,s1_pos):
    s1.append(s[i])

for j in range(s1_pos,int(len(s))):
    s2.append(s[j])

for index, k in enumerate(s1):
    s_prt.append(s1[index])
    s_prt.append(s2[index])

print(s_prt)

def sorting(list):
    ans = []
    n=int(len(list)/2)
    print(n)
    x = list[:n]
    y = list[n:]
    for i in range(0,n):
        ans= ans+[x[i]]+[y[i]]
    return(ans)

print(sorting(['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']))

a=['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']
r=len(a)//2
for x in range(r):
    a.insert(x+x+1,a[r+x+x])
for x in range(r):
    a.pop()

마지막에 리스트 없애려고 pop을 사용하였는데 뭔가 깔끔하지 않네요. :/

import java.util.ArrayList;
import java.util.Arrays;

public class KimSanghyeop {

    public static void main(String args[])
    {
        ArrayList<String> al = new ArrayList<String> (Arrays.asList("a1","a2","a3","ab","ac","an","b1","b2","b3","bb","bc","bn"));
        ArrayList<String> res = new ArrayList<String>();

        char[] str = {'a','1'};

        String temp="";

        for(str[1]='1';str[1]<='n';str[1]++)
        {
            for(str[0]='a';str[0]<='b';str[0]++)
            {
                temp = String.valueOf(str);

                for(int f1=0;f1<al.size();f1++)
                {
                    if(al.get(f1).equals(temp))
                    {


                        res.add(temp);
                        al.remove(f1);
                        break;
                    }
                }
            }
        }

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

N=int(input('N값 입력 :'))
a=['a'+str(i) for i in range(1,N)]
b=['b'+str(i) for i in range(1,N)]

result = []
for i, j in zip(a,b):
    result.extend([i, j])
print(result)

# Ary = 짝수 개의 원소를 갖는 배열
Ary = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

half = int(len(Ary)/2)

for i in range(1, half+1):
    Ary = Ary[:(2*i-1)] + Ary[-half+i-1:-half+i] + Ary[(2*i-1):]
Ary = Ary[ :-half]

print(Ary)

출력 : [1, 2, 3, 4, 5, 6, 7, 8, 9]

#include<iostream>
#include<map>
#include<utility>
using namespace std;



int main(void)
{
    char c; int n;
    cout << "어디까지?";
    cin >> n; cin.ignore();
    multimap<int, char>mp; multimap<int, char>::iterator mtr;
    for (int i = 1; i < n+1; i++)
    {
        cout << "첫번째알파벳>>";
        cin >> c;
        mp.insert(make_pair(i, c));
        cout << "두번째알파벳>>";
        cin.clear();
        cin >> c;
        mp.insert(make_pair(i, c));
    }
    for (mtr = mp.begin(); mtr != mp.end(); mtr++)
    {
        cout << mtr->second << mtr->first << " ";
    }

}

함수를 쓰고 싶었지만 함수도 하나의 저장공간이라 생각해 쓰지않았습니다.

우선 배열의 길이는 무조건 짝수가 되기 때문에 int() 함수를 쓰지않았습니다.

그리고 입력을 보면 a와 b의 n의 개수가 동일하기 때문에 따로 index가 필요 없고요.

zip함수를 써서 묶은 다음 원래 배열에 그대로 더해 길이가 길이3/2 가 되므로

추가된 배열에 길이/3지점부터 출력하도록 했습니다.

ab = ['a1','a2','a3','a4','b1','b2','b3','b4']
ab = list(x for x in zip(ab[0:len(ab)//2],ab[len(ab)//2:]))
for x in ab[:len(ab)]:
    ab += x
print(ab[len(ab)//3:])

n = int(input('n의 값을 입력하세요:'))
L = ['a%d' %i for i in range(1, n+1)] + ['b%d' %i for i in range(1, n+1)]
print(L)

for i in range(n, 2*n):
    while L[i][1] != L[i-1][1]:
        L[i-1], L[i] = L[i], L[i-1]
        i -= 1
print(L)

using System;
using System.Collections;
using System.Collections.Generic;

namespace ydwConsoleTest
{
    class Program
    {
        public static String ReverseString(string str)
        {
            char[] ch = str.ToCharArray();

            for(int i = 0; i < ch.Length / 2; i++)
            {
                char temp = ch[i];
                ch[i] = ch[ch.Length - i - 1];
                ch[ch.Length - i - 1] = temp;
            }
            str = "";
            for (int i = 0; i < ch.Length; i++)
                str += ch[i];

            return str;
        }
        public static void Main(string[] args)
        {
            String[] arr = { "a1", "a2", "a3", "b1", "b2", "b3", "c1", "c2", "c3" };

            List<string> list = new List<string>();

            for (int i = 0; i < arr.Length; i++)
            {
                list.Add(ReverseString(arr[i]).ToString());
            }

            list.Sort();
            for (int i = 0; i < list.Count; i++)
            {
                arr[i] = list[i];
                arr[i] = ReverseString(arr[i]);
                Console.Write(arr[i] + " ");
            }
        }
    }
}

def amazon(lst):
    answer = []
    new =[]
    for i in lst:
        new.append((i[1],i[0]))
    for i in sorted(new):
        answer.append(i[1]+i[0])
    return answer

a=[]
for i in range(1,101,1):
    t = 'a'+ str(i)
    a.append(t)

for i in range(1,101,1):
    t = 'b'+ str(i)
    a.append(t)
print(a)

b = []
for i in a:
    if( 0 == i.find('b')):
        b.append(i);


c = []
for i in range(0,100,1):
    c.append(a[i])
    c.append(b[i])

print(c)

def shuffleArray(a):
    n = int(len(a)/2)
    i = 0
    shuffled = list()
    while (i < n):
        shuffled.append(a[i])
        shuffled.append(a[i+n])
        i += 1

    print(shuffled)

import re
p, q = re.compile("(?P<D>\D)(?P<d>\d)"), re.compile("(?P<dd>\d)(?P<DD>\D)")
k = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"] #입력
for i in range(0, len(k)) :
    k[i] = p.sub('\g<2>\g<1>', k[i])  #숫자랑 영어를 뒤바꿉니다
k.sort()                              #정렬합니다
for m in range(0, len(k)) :
    k[m] = q.sub('\g<2>\g<1>', k[m])  #영어랑 숫자를 다시 뒤바꿉니다
print(k)

'should be in-place'이라는 표현이 몰라서 최대한 메모리 느낌 나는건 안 쓰려고 했는데 ㅠㅠ...어렵네요

결과 ['a1', 'b1', 'a2', 'b2', 'a3', 'b3', 'a4', 'b4', 'a5', 'b5']

#include <iostream>
#include <cstring>
using namespace std;

void printfString(int* x,int n){
    for(int i=0; i<n;i++){
        cout<<x[i]<<" ";
    }
    cout<<endl;
}

int main(){
    int n;
    cin>>n;

    int a[n];
    memset(a,0,sizeof(a));
    int b[n];
    memset(b,0,sizeof(b));

    for(int i=0;i<n;i++){
        a[i]=i;
        b[i]=i;
    }

    printfString(a,n);
    printfString(b,n);

    int str[n*2];
    for(int i=0;i<n;i++){
        str[i]=a[i];
        str[n+i]=b[i];
    }

    printfString(str,n*2);

    for(int i=0;i<n;i++){
        str[i*2]=a[i];
        str[i*2+1]=b[i];
    }

    printfString(str,n*2);
}

자바로 했구요. 인덱스 2번째값만 가져와서 버블정렬한뒤, 알파벳 순서대로 한번더 정렬했습니다.

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

public class AmazonBubbleSort { public static void main(String[] args) { String[] str = { "F0", "A1", "B1", "C1", "A2", "B2", "B3", "C3", "E7", "D5", "D4"}; String temp = "";
List list = new ArrayList();

    //인덱스 2번째값만 가져와서 버블정렬
    for (int i = 0; i < str.length; i++) {
        //System.out.print(str[i]);
        char c = str[i].charAt(1);          
        System.out.print(c);            
        for (int j = 0; j < str.length-1; j++) {
            if (str[j].charAt(1) > str[j+1].charAt(1) ) {
                temp = str[j];
                str[j] = str[j+1];
                str[j+1] = temp;
            }
        }
    }
    System.out.println();
    for (int i = 0; i < str.length; i++) {
        list.add(str[i]);
    }
    //알파펫 순서대로 한번더 정렬
    //Collections.sort(list);   
    list.sort(String::compareToIgnoreCase);     
    System.out.println(list);
}

}

파이썬3입니다.

우선 n을 입력으로 받아서 an bn을 가지는 리스트를 작성했습니다. (리스트 이름은 x)

n = int(input())

# 리스트 생성

x = []
for i in range(2 * n):
    if len(x) < n:
        x.append('a{}'.format(i + 1))
    else:
        x.append('b{}'.format(i + 1 - n))

중요한 건 이 뒷부분이겠지요. 풀이방법이 여러가지가 있을 것 같아서 제걸 올립니다.

--- 첫번째 풀이 --- y라는 다른 리스트를 만들어서 x의 요소를 받았습니다.

y = []
for i in range(n):
    y.append(x[i])
    y.append(x[i + n])

x = y.copy()
del y

print(x)

--- 두번째 풀이 --- 이 풀이는 sort를 이용하여 숫자를 기준으로 정렬하는 방법입니다. 코드 길이로 보면 가장 짧군요

x.sort(key=lambda num: int(num[1]))

--- 세번째 풀이 --- 이 풀이는 x의 요소를 replace를 이용하여 순서를 바꾸는 방법입니다. 이거는 분명히 최적화 하는 알고리즘이 있을거 같은데 저는 몰라서 무작정 했습니다.

일단은 중앙의 두 원소를 바꾸고 바꾼 원소를 제자리에 가져다 놓습니다 그런 다음에 완성이 되지 않으면 다시 중앙의 원소를 바꾸고.. 이런 식으로 반복합니다.

이렇게 하면 총 시행 횟수가 n(n-1)/2가 됩니다. n제곱 정도니까 더 낮출 필요가 있겠네요

def change(li, a, b):  # list, a, b를 받아 리스트의 a번째 원소와 b번째 원소를 바꾼다
    temp = li[a]
    li[a] = li[b]
    li[b] = temp


for i in range((2 * n + 1) // 4):
    for j in range(n - 1 - 2 * i):
        if j == 0:
            change(x, n - 1, n)
            continue
        change(x, n - j, n - 1 - j)
        change(x, n - 1 + j, n + j)

print(x)

첫번째 풀이(an,bn까지를 그냥 제가 임의로 정해서 했습니다.)

lst=["a1","a2","a3","a5","b1","b2","b3","b4","b5","c1","c2","c3","c4"]

for i in range(len(lst)):
    lst[i]=lst[i][::-1] #요소 문자열 뒤집기 1a, 2a, 3a, ......, 1b, 2b, 3b, .....
rlst=sorted(lst) #1a, 1b, 1c,.....
for i in range(len(rlst)):
    rlst[i]=rlst[i][::-1] #a1,b1,c1,....b4,c4,a5

print(rlst) #['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'a3', 'b3', 'c3', 'b4', 'c4', 'a5', 'b5']

그러나 위의 풀이 문자열 뒤집기 방식을 사용했기 때문에 리스트에 a10이나 b11같은 2자리 숫자가 문자 뒤에 있으면 같은 방법으로 정렬할 시에 a10,b11,a1,b1,c1.....순으로 정렬되는 문제점이 있음.

두번째 풀이(a11,b13,c15와 같은 문자들도 있을 때 정렬하기)

lst2=["a1","a2","a3","a4","a5","a6","a7","a8","a11","a12","b1","b2","b3","b4","b5","b6","b7","b9","b10","b12","c1","c2","c3","c4","c5","c13"]
elst=[] #a11, a12, b12,.... 와 같은 문자 뒤에 숫자가 2개 있는 것들을 받기 위한 빈 리스트
for i in range(len(lst2)):
    lst2[i]=lst2[i][::-1]
    if len(lst2[i])>=3: #글자의 길이가 3이상(a11,b12,....)이면 빈 리스트에 추가
        elst.append(lst2[i])
rlst2=sorted(lst2)
for i in range(len(rlst2)):
    rlst2[i]=rlst2[i][::-1]
for lt in sorted(rlst2): #a1,b1,c1....으로 정렬한 리스트에 아직 a11, b12 같은 것이 순서가 뒤죽박죽인 채 있므로 제거
    if len(lt)>=3:
        rlst2.remove(lt)
elst2=sorted(elst)
for i in range(len(elst2)): #11a, 21b로 받은 빈 리스트를 정렬
    elst2[i]=elst2[i][::-1] #a11, b12, .....

print(rlst2+elst2) #['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'a3', 'b3', 'c3', 'a4', 'b4', 'c4', 'a5', 'b5', 'c5', 'a6', 'b6', 'a7', 'b7', 'a8', 'b9', 'b10', 'a11', 'a12', 'b12', 'c13']

두번째 풀이는 사실 첫번째 풀이와 비교해서 별거 없는데 코드 줄만 많고 난잡해보이네요...

# 배열을 array에 입력 받는다.
array = ["a1", "a2", "a3", "a4", "b1", "b2", "b3", "b4"]

# b가 시작 되는 배열의 중간 값을 구한다.
b_start = int(len(array)/2)

# 추가적 저장 공간을 제공하지 않는 것이 조건임으로
# array에서 pop을 해줌으로써 제거함과 동시에 array의 i의 위치에 insert 한다.
i = 1
while b_start < len(array):
    array.insert(i, array.pop(b_start))
    i += 2
    b_start += 1

print(array)

tmp = ['a1','a2','a3','a4','b1','b2','b3','b4']

print(sorted(tmp,key = lambda x: x[1]))

#[a1, a2, a3..., an, b1, b2...bn]과 같은 형태 만들기
def Amazone(n):
    l = ['a'+str(i) for i in range(1, n+1)] 
    l += ['b'+str(i) for i in range(1, n+2)]
    print('Before:', l)
#형태 바꾸기
    for i in range(n):
        l.insert(n-1+i,l.pop(0))
    print('After:', l)

python으로 풀었습니다.

파이썬

ll = ["a1","a2","a3","a4","a5","b1","b2","b3","b4","b5"]

ld = {}
k = ''
ld_e = []
ini_l = []
for i in range(len(ll)):
    k = ll[i][1]
    ini_l = []
    ld_e = ld.get(k, ini_l)
    ld_e.append(ll[i])
    ld[k] = ld_e
# print(ll)
# print(ld)

all_list = []
for key, value in ld.items():
    for v in value:
        all_list.append(v)

print(all_list)

#include <iostream>
#include <vector>
#include <string>
using namespace std;
/*
다음과 같은 형태의 배열을
[a1,a2,a3...,an,b1,b2...bn]

다음과 같은 형태로 바꾸시오
[a1,b1,a2,b2.....an,bn]
*/

void Func(int n) {
    vector<string> va;
    vector<string> vb;

    for (int i = 1; i <= n; i++) {
        va.push_back("a" + to_string(i));
        vb.push_back("b" + to_string(i));
    }

    string* arr = new string[va.size() + vb.size()];
    int idx = 0;

    for (int i = 0; i < va.size(); i++)
        arr[idx++] = va[i];


    for (int i = 0; i < va.size(); i++)
        arr[idx++] = vb[i];
    cout << "==================변경전========================" << endl;
    cout << "arr[] = { ";
        for (int i = 0; i < va.size() + vb.size(); i++) {
            if (i == va.size() + vb.size() - 1) { cout << arr[i] << " }" << endl; }
            else { cout << arr[i] << " ,"; }
    }

    idx = 0;
    for (int i = 0; i < va.size(); i++) {
        arr[idx++] = va[i];
        arr[idx++] = vb[i];
    }
    cout << "==================변경후========================" << endl;
    cout << "arr[] = { ";
    for (int i = 0; i < va.size() + vb.size(); i++) {
        if (i == va.size() + vb.size() - 1) { cout << arr[i] << " }" << endl; }
        else { cout << arr[i] << " ,"; }
    }

    delete[] arr;
    cout << endl;
}

int main() {
    Func(4);
    Func(10);
}

#파이썬
def arranging(a):
    print('\nInput=',a)
    i=0
    while i<int(len(a)/2):
        a.insert((2*i)+1,a[i+int(len(a)/2)])
        del a[i+int(len(a)/2)+1]
        i+=1
    print('Output=',a)

x=[1,2,3,4,5,6,7,8,9,10]
arranging(x)
x=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
arranging(x)
x=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
arranging(x)

arr_one=['a1','a2','a3','a4','a5','a6','a7','b1','b2','b3','b4','b5','b6','b7']
LEN=int(len(arr_one)/2)
print(LEN)
for i in range(LEN):
    arr_one.insert(2*i+1,arr_one.pop(LEN+i))
print(arr_one)

def amazon(l):
    amazon_list = []
    for n, i in enumerate(range(int(len(l)/2), len(l))):
        amazon_list.append(l[n])
        amazon_list.append(l[i])
    print(amazon_list)

if __name__ == '__main__':
    l = ['a1', 'a2', 'a3', 'a4', 'a5', 'b1', 'b2', 'b3', 'b4', 'b5']
    amazon(l)

절반쪼개서 슬라이딩하는 방식으로 풀었습니다.

'''
다음과 같은 형태의 배열을

[a1,a2,a3...,an,b1,b2...bn]

다음과 같은 형태로 바꾸시오

[a1,b1,a2,b2.....an,bn]
'''

input = [a+str(b) for a in "ab" for b in range(1,10)]
# input : ['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9']
print(input)

n = len(input)
input[0::2], input[1::2] = input[0:n//2], input[n//2:]

print(input)
# output : ['a1', 'b1', 'a2', 'b2', 'a3', 'b3', 'a4', 'b4', 'a5', 'b5', 'a6', 'b6', 'a7', 'b7', 'a8', 'b8', 'a9', 'b9']

파이썬입니다.

lista = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']
newlist = [0]*len(lista)
for i in range(int(len(lista)/2)):
    newlist[2*i] = lista[i]
    newlist[2*i+1] = lista[int(len(lista)/2)+i]
print(newlist)

given_list = ['a1', 'a2', 'a3', 'a4', 'a5', 'b1', 'b2', 'b3', 'b4', 'b5']
ans_list =[]
for i in range(int((len(given_list)+2)/2)) :
    for k in given_list :
        if str(i) in k :
            ans_list.append(k)
print(ans_list)

N = ['a1','a2','a3','a4','a5','a6','b1','b2','b3','b4','b5','b6']
main,check = [],0
for i in range(len(N)):
    if N[i][0] == 'a':
        main.append(N[i])
        check += 1
    else:
        main.insert((i - check)*2+1,N[i])
print(main)

N = ["a1","a2","a3","a4","b1","b2","b3","b4"]
for i in range(int(len(N)/2)):
    print(N[i] + " " + N[i+int(len(N)/2)],end=" ")

print(sum([(N[i] + " " + N[i+int(len(N)/2)]).split() for i in range(int(len(N)/2))], []))

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<string> N = { "a1","a2","a3","a4","a5","a6","b1","b2","b3","b4","b5","b6" };
    vector<string>main = {};
    int check = 0;
    for (int i = 0; i < N.size(); ++i) {
        if (N[i][0] == 'a') {
            main.push_back(N[i]);
            check++;
        }
        else {
            main.emplace(main.begin() + (((i - check) * 2) + 1), N[i]);
        }
    }
    for (int i = 0; i < main.size()-1; ++i) {
        cout << main[i] << ", ";
    }
    cout << main[main.size()-1] << endl;
}

#include <iostream>
#include <vector>

using namespace std;

int main() {
    ios::sync_with_stdio();
    vector<string> N{ "a1","a2","a3","b1","b2","b3" };
    for (int i = 0; i < (N.size() / 2); ++i) {
        cout << N[i] << " " << N[i + (N.size() / 2)] << " ";
    }
    cout << endl;
}

q = ['a1','a2','a3','b1','b2','b3']

a = sorted(q, key=lambda x: x[1])

a = ['a1','a2','a3','a4','b1','b2','b3','b4']
n = int((a[-1][-1]))

for i in range(n):
    a.insert(2*i+1,a[i+4])
    del a[i+5]

print(a)

s=['a1','a2','b2','a5','b1','b3','b7','a8','b9']

list1=[] list2=[]

for i in s: list1.append(i[::-1])

list1.sort()

for j in list1: list2.append(j[::-1])

print(list2)

def reOrder(input_s):
    l1 = input_s[:int(len(input_s)/2)]
    l2 = input_s[int(len(input_s)/2):]

    result=[]

    for x,y in zip(l1,l2):
        result.extend([x,y])
    return result

A=['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']
n=int(len(A)/2)
B=list(zip(A[:n], A[n:]))
result=[]
for i in range(n):
    result += list(B[i])
print(result)

numlist = ["a1","a2","a3","a4","b1","b2","b3","b4"]
sortlist = []
alist = [x for x in numlist if x[0] == "a"]
blist = [x for x in numlist if x[0] == "b"]
for i in range(0, len(alist)):
    sortlist.extend([alist[i], blist[i]])
print(sortlist)

arr1=['a'+str(i)for i in range(1,100)]
arr2=['b'+str(i)for i in range(1,100)]
arr = arr1+arr2

for k in range(int(len(arr)/2)):
    arr.insert((2*k+1),arr.pop(int(len(arr)/2)+k))

print(arr)

n = 99 일떄 를 예를 들어 짜봤습니다. 배열 중간값의 다음 값을 pop으로 추출해, 2k+1번째(1,3,5,7,9.....) index에 insert하는 방식을 생각 해봤어요~

import pandas as pd
n= 25
li = ['a'+str(x) for x in range(1,n+1)] + ['b'+str(x) for x in range(1,n+1)]

df = pd.DataFrame(li)
df.columns = ['original']
df['chr'] = df['original'].str[0]
df['num'] = df['original'].str[1:]
df['tt'] = df['num']+df['chr']
df.sort_values(['tt'])

df['num2'] = df['tt'].str[:-1]
df['chr2'] = df['tt'].str[-1]
df['tt2'] = df['chr2']+df['num2']

re_li = list(df['tt2'])

re_li

amazon_matrix = ['a1', 'a2', 'a3', 'a4', 'b1', 'b2', 'b3', 'b4']
from math import floor
for i in range(floor(len(amazon_matrix)/2)):
    amazon_matrix.insert(i*2+1, amazon_matrix[i + floor(len(amazon_matrix)/2)])
    del amazon_matrix[i-4]
print(amazon_matrix)

추가 저장공간을 안만드는 쪽으로 구성했습니다.

>>> l = ['a1','a2','a3','a4','a10','a11','b1','b2','b3','b4','b10','b11']
>>> print(sorted(l, key=lambda x: int(x[1:])))
['a1', 'b1', 'a2', 'b2', 'a3', 'b3', 'a4', 'b4', 'a10', 'b10', 'a11', 'b11']

a=['a1','a2','a3','a4','b1','b2','b3','b4']
#저장할 empty list 선언
aj=[]
bj=[]
result=[]
for k in a:
    if k[0]=='a':
       aj.append(k) # a로 시작하는 원소들 저장
    else:
       bj.append(k) # b로 시작하는 원소들 저장
result_tem=list(zip(aj,bj)) # zip 하무로 교차 쌍 list 생성

for i in range(len(result_tem)): # for 문으로 쌍으로 되어 있는 원소를 list로 배열
    result.append(result_tem[i][0])
    result.append(result_tem[i][1])

# 좀 더 간단한 방법이 있을 것 같은데 아쉽네요.
# 다른 분들 code를 보고 참고해서 나중에 한번 더 coding해 보아야 겠습니다.

파이썬입니다. 코드 길이가 짧긴 하나 잘한 건지는 모르겠네요

List = [1,2,3,4,5,6,1,2,3,4,5,6]
i = 1
List1 = []
while i < 7:
    List1.append(List[i-1])
    List1.append(List[(len(List)//2)+i-1])
    i = i+1

print(List1)

item_array=input()
print(item_array)
list_alphabet=list()
list_number=list()
string_alphabet=''
string_number=''
for a in item_array:
    if a>='a' and a<='z':
        string_alphabet=string_alphabet+a
    elif string_alphabet!='':
        list_alphabet.append(string_alphabet)
        string_alphabet=''
for a in item_array:
    if a>='0' and a<='9':
        string_number=string_number+a
    elif string_number!='':
        list_number.append(string_number)
        string_number=''
if string_number!='':
    list_number.append(string_number)
print(list_alphabet)
print(list_number)
base_number=1
list_string_alphabet_number=list()
while True:
    for a in range(len(list_number)):
        if base_number==int(list_number[a]):
            list_string_alphabet_number.append(list_alphabet[a]+list_number[a])
    base_number=base_number+1
    for b in range(len(list_number)):
        if base_number<=int(list_number[b]):
            check='under'
            break
        else:
            check='over'
    if check=='over':
        break
print('['+','.join(list_string_alphabet_number)+']')

l = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']

def reverse_list(l: list):
  l_new = []
  for el in l:
    el_list = list(el)
    el_list.reverse()
    el = ''.join(el_list)
    l_new.append(el)
  return l_new

l = reverse_list(l)
l.sort()
l = reverse_list(l)
print(l)

pa = ['a1','a2','a3','a4','a5','b1','b2','b3','b4','b5']

n = len(pa)//2
result = []
for i in range(n):
    result.extend([pa[i], pa[i+n]])

print(result)

python 3.8
- 문제에 충실하게 배열 인덱스를 위한 i이외에 추가적인 저장장소를 사용하지 않고 작성해 보았습니다. 

arr = ["a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"]
for i in range(int(len(arr)/2)):
    arr.insert(i*2+1, arr.pop(i+int(len(arr)/2)))

print(arr)