a = [4,1,3,2,6,5,8,11] #자연수 List
hol = []   #홀수 list
chack = [] # 짝수 list
result = [] # 최종 결과

for i in a: #홀수와 짝수 구분하기
    if i%2 ==0:
        chack.append(i)
    else:
        hol.append(i)

hol.sort() #홀수 오름차순 정렬
chack.sort(reverse=True) #짝수 내림차순 정렬

for i in range(int(len(a)/2)): # 홀수 짝수 합치기.
    result.append(hol[i])
    result.append(chack[i])
print(result)

파이썬 공부하고 있는 초보자 입니다. 이렇게 풀어봤습니다.

sample_input = "413265"
odd = [int(x) for x in sample_input if int(x)%2==1]
even = [int(x) for x in sample_input if int(x)%2==0]

sample_output=[]
for i in range(3):
    sample_output.append(sorted(odd)[i])
    sample_output.append(sorted(even, reverse=True)[i])
print(sample_output)

from itertools import chain

nums = [4, 1, 3, 2, 6, 5]
even = sorted([x for x in nums if x % 2 == 0], reverse=True)
odd = sorted([x for x in nums if x % 2 == 1])
print(*chain(*zip(odd, even)))

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

public class numberSort {
// 숫자 배열을 정렬하기 예를들어 홀짝 순으로 정렬하고
//  홀수는 오름차순 짝수는 내림 차순으로 정렬하기
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //짝수 담는 배열
        ArrayList<Integer> oddNumber = new ArrayList<Integer>();
        //홀수 담는 배열
        ArrayList<Integer> notOddNumber = new ArrayList<Integer>();

        //배열 에 넣을 데이터 입력받기
        while (true) {
            System.out.print("배열에 넣을 정수를 입력하세요(999입력시 프로그램 종료) : ");
            int inputNumber = scanner.nextInt();
            scanner.nextLine(); // 엔터 버퍼 방지용
            if (inputNumber == 999) {
                break;
            }
            if(oddNumber.contains(inputNumber) || notOddNumber.contains(inputNumber) ) {
                System.out.println("중복!");
            }else {
                if (inputNumber % 2 == 0) {
                    oddNumber.add(inputNumber);
                } else {
                    notOddNumber.add(inputNumber);
                }
            }
        }

        // 배열 정렬
        notOddNumber.sort(Comparator.naturalOrder());
        oddNumber.sort(Comparator.reverseOrder());
        int index = 1;

        //두 배열 합치기
        for (int i = 0; i < oddNumber.size(); i ++ ) {
            if(index >= notOddNumber.size()) {
                notOddNumber.add(oddNumber.get(i));
            }else {
                notOddNumber.add(index, oddNumber.get(i));
            }
            index+=2;

        }
        // 배열 출력
        System.out.println(notOddNumber);
    }
}
if 를 너무 많이 썼네요..

public class Sorting {

    // constructor
    public Sorting(int[] sampleData) {
        partition(sampleData);
        ascendingOrderIt(sampleData);
        descendingOrderIt(sampleData);
        toInteger(sampleData);
    }

    // 홀, 짝 sorting
    public int[] partition(int[] sampleData) {
        return partition(0, sampleData);
    }
    private int[] partition(int i, int[] sampleData) {
        if(!(sampleData[i]%2==1 && sampleData[i+1]%2==0)) {
            swapData(i, i+1, sampleData);
        }
        if(i+2==sampleData.length)
            return sampleData;
        return partition(i+2, sampleData);
    }

    // 홀수 Sort - ascending order 
    public int[] ascendingOrderIt(int[] sampleData) {
        for(int i=0; i<sampleData.length; i++) {
            for(int j=i+2; j<sampleData.length;j++) {
                if(sampleData[i]>sampleData[j])
                    swapData(i, j, sampleData);
                j=j+1;
            }
            i=i+1;
        }
        return sampleData;
    }

    // 짝수 Sort - descending order
    public int[] descendingOrderIt(int[] sampleData) {
        for(int i=1; i<sampleData.length; i++) {
            for(int j=i+2; j<sampleData.length; j++) {
                if(sampleData[i]<sampleData[j]) 
                    swapData(i, j, sampleData);
                j=j+1;
            }
            i=i+1;
        }
        return sampleData;
    }

    // data swap
    private void swapData(int i, int j, int[] sampleData) {
        int temp = sampleData[i];
        sampleData[i]=sampleData[j];
        sampleData[j]=temp;
    }

    // print result
    public void toInteger(int[] sampleData) {
        for(int i=0; i<sampleData.length; i++)
            System.out.print(sampleData[i]+", ");
    }

    public static void main(String[] args) {
        int[] sampleData =  {3, 4, 5, 2, 6, 1, 7, 10};
        new Sorting(sampleData); // 생성자 호출
    }

}

sample_input = [4,1,3,2,6,5] #주어진 값
a = [] #홀수 리스트
b = [] #짝수 리스트
result = [] #결과 리스트

sample_input.sort() #Sample 리스트를 오름차순으로 전체 정렬

for num in sample_input: #홀수와 짝수 나누기
    if num %2 != 0: #주어진값이 홀수 일 경우 홀수 리스트 추가
        a.append(num) 
    elif num%2 == 0: #주어진 값이 짝수 일 경우 짝수 리스트 추가
        b.append(num)

b.sort(reverse = True)   #짝수만 내림차순으로 변경
while a or b : #홀수리스트 또는 짝수 리스트가 없을때까지 반복
    mark01 = a.pop(0) #mark01에 홀수 리스트 제일 앞에 있는 값을 추가 후 홀수 리스트에서는 삭제
    mark02 = b.pop(0) #mark02에 짝수 리스트 제일 앞에 있는 값을 추가 후 짝수 리스트에서는 삭제
    result.append(mark01) #결과 리스트에 mark01 값 추가
    result.append(mark02) #결과 리스트에 mark02 값 추가

print(result) #결과 리스트 출력

public static void main(String[] args){

 int[] input = {4 ,1 ,3 ,2 ,6 ,5};
       // 오름차순으로 정렬
         for(int i=0; i< input.length ; i++){
            for(int j = i+1; j < input.length ; j++){
                int sub; 
                if(input[i] > input[j]){
                     sub = input[i]; 
                     input[i] = input[j];
                     input[j] = sub;
                 }

             }

         }
         System.out.println();
       // 짝수만 내림차순으로 정렬
         for(int i=1; i< input.length ; i+=2){
                for(int j = i+2; j < input.length ; j+=2){
                    int sub; 
                    if(input[i] < input[j]){
                         sub = input[i]; 
                         input[i] = input[j];
                         input[j] = sub;
                     }

                 }

          }
         // 출력
         for(int i =0; i < input.length ; i++) {
             System.out.print(input[i]);
         }

}

num_list = [4, 1, 3, 2, 6, 5]
h_list = []
j_list = []
hj_list = []

for i in num_list:
    if i % 2 == 0:
        j_list.append(i)
    else:
        h_list.append(i)

h_list.sort()
j_list.sort(reverse=True)

for i in range(3):
    hj_list.append(h_list[i])
    hj_list.append(j_list[i])

print(hj_list)

input_list = [4, 1, 3, 2, 6, 5]

odd = [x for x in input_list if x%2 == 1]
even = [x for x in input_list if x%2 == 0]

result = [y for y in zip(sorted(odd), sorted(even, reverse=True))]
final = list(sum(result,()))
print(final)

N = list(map(int,input().split()))
N.sort()
result = []
for i in range(len(N)):
    if (N[i] % 2 == 1):
        result.append(N[i])
    elif (len(N)%2 == 0):
        result.append(N[len(N)-i])
    else:
        result.append(N[len(N)-(i+1)])
print(result)

package justStudying;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class test1_20210816 {

    public static void solution(int[] input) {

        Queue<Integer> h = new PriorityQueue<>();
        Queue<Integer> z = new PriorityQueue<>(new Comparator<Integer>() { 
            public int compare(Integer o1, Integer o2) {
                // TODO Auto-generated method stub
                return o2 - o1;
            }
        });

        ArrayList<Integer> ans = new ArrayList<>();


        for(int i=0; i<input.length; i++) {
            if(input[i]%2 == 0) {
                z.add(input[i]);
            }else {
                h.add(input[i]);
            }
        }

        while(!h.isEmpty()) {
            ans.add(h.poll());
            ans.add(z.poll());
        }

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

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] sol = {4,1,3,2,6,5};
        solution(sol);
    }

}

Python 3

import itertools


def sort_list(alist: list):
    evens = [i for i in alist if i % 2 == 0]
    evens.sort(reverse=True)
    odds = [i for i in alist if i % 2 == 1]
    odds.sort(reverse=False)

    if len(evens) != len(odds):
        raise ValueError("짝수와 홀수의 개수가 같지 않습니다.")

    return list(itertools.chain(*zip(odds, evens)))


if __name__ == '__main__':
    args = [4, 1, 3, 2, 6, 5]
    print(sort_list(args))

n = input("").split(" ")
evenlist = [ int(x) for x in n if int(x) % 2 == 0]
oddlist =  [ int(x) for x in n if int(x) % 2 != 0]
evenlist.sort(reverse= True)
oddlist.sort()
if len(evenlist) == len(oddlist) :
    i = 0
    while i < len(evenlist):
        print(oddlist[i],evenlist[i],end=" ")
        i += 1
else :
    print("Error")

num_list = range(1,101)

odd_list = []
even_list = []
final_list = []
for i in num_list:
    if i % 2 == 0:
        even_list.append(i)
    elif i % 2 == 1:
        odd_list.append(i)
odd_list.sort()
even_list.sort(reverse=True)

for i in range(len(odd_list)):
    final_list.append(odd_list[i])
    final_list.append(even_list[i])

print(final_list)

def number_sort(lst):
    hol = []
    jjack = []
    result = []

    for i in lst:
        if i % 2 == 1:
            hol.append(i)
        else:
            jjack.append(i)

    hol.sort()
    jjack.sort(reverse=True)

    for i in range(int(len(lst)/2)):
        result.append(hol[i])
        result.append(jjack[i])

    return result

number_list = input("숫자 리스트를 입력해주세요.")

number = number_list.split(" ")
numbers = []

# 정수형으로 변환

for i in number:
    numbers.append(int(i))

# 정렬 후 짝수와 홀수로 나누기

numbers.sort()

ones = []
twos = []


for i in range(0, len(numbers)):
    if i % 2 == 0:
        ones.append(numbers[i])
    else:
        twos.append(numbers[i])
result = []

twos.reverse()

print(numbers)
print(ones, twos)

for i in range(0, len(ones)):
    result.append(ones[i])
    result.append(twos[i])

print(result)

data = [4,1,3,2,6,5]
ord = []
even = []
outt = []
for i in data:
    if i % 2 == 0:
        even.append(i)
    else:
        ord.append(i)
even.sort()
even.reverse()
ord.sort()

for i in range(3):
    outt.append(ord[i])
    outt.append(even[i])
print(outt)

inp = [4, 1, 3, 2, 6, 5]
ev = sorted([i  for i in inp if i%2 == 0 ], reverse = True) # 짝수
od = sorted([j  for j in inp if j%2 != 0 ]) # 홀수
print(  sum([list(k) for k in zip(od, ev)], [])  ) # 합치기

파이썬입니다.

sample = [4, 1, 3, 2, 6, 5]

odds = [i for i in sample if i % 2 == 1]
even = [i for i in sample if i % 2 == 0]

odds.sort()
even.sort()
even.reverse()

new = []
while odds != [] and even != []:

    i = odds.pop(0)
    j = even.pop(0)

    new.append(i)
    new.append(j)

for i in new:
    print(i, end=" ")

a = [4 ,1 ,3 ,2 ,6 ,5] # 주어진 값
on = [] # 홀수 리스트
en = [] # 짝수 리스트
an = [] # 정답 

for c in a:
    if c%2 ==0: #짝수 홀수 구분
        en.append(c)
    else:
        on.append(c)

en.reverse()#내림 차순
on.sort()#올림차순

for i in range(0,int(len(a)/2)): #홀수와 짝수의 갯수가 같아서 len 사용
    an.append(on[i])
    an.append(en[i])

print(an)

def sort_number(lis):
    l=list(zip(sorted([i for i in lis if i%2==1]),sorted([i for i in lis if i%2==0],reverse=True)))
    return [l[i][j] for i in range(len(l)) for j in range(2)]
print(sort_number([4,1,3,2,6,5]))

a = list(map(int,(input().split())))
even = []
odd = []
for i in a:
    if i%2==0:
        even.append(i)
    elif i%2==1:
        odd.append(i)
even.sort()
even.sort(reverse=True)
odd.sort()
if len(even)==len(odd):
    for j in range(len(a)//2):
        print(odd[j], end= ' ')
        print(even[j], end = ' ')
    print()
else:
    print("홀수와 짝수의 개수가 다르다")

num='4 1 3 2 6 5'
num=num.split(' ')
num_odd=[]
num_even=[]
for i in range(0,len(num)):
    num[i]=int(num[i])
    if num[i]%2==0:
        num_even.append((num[i]))
    else:
        num_odd.append((num[i]))

if len(num_odd)==len(num_even):
    num_even.sort(reverse=True)        
    num_odd.sort()  

    for i in range (len(num_odd)):    
        print (num_odd[i], end =' ')
        print (num_even[i], end =' ')
else:
    print ('홀짝 갯수 안맞음')

#codingdojing_odd even sort

num_list = input().split()
odd_list = []
even_list = []

for i in num_list:
    try:
        if int(i)%2 == 0:
            even_list.append(int(i))
        else:
            odd_list.append(int(i))
    except:
        print('input error', i)

odd_list.sort()
even_list.sort(reverse=True)
result = []

if len(even_list) == len(odd_list):
    for x, y in zip(odd_list, even_list):
        result.extend((x,y))
else:
    result = None

print(result)

a = [4,1,3,2,6,5]

odd = []
even = []

for element in a:
  if element%2 == 0:
    even.append(element)
  else:
    odd.append(element)

if len(even) != len(odd):
  print("STOP")
else:
  odd = sorted(odd)
  even = sorted(even, reverse=True)

  new = []

  for i in range(len(a)):
    if i%2 == 0:
      new.append(odd[int(i/2)])
    else:
      new.append(even[int(i/2)])

  print(new)

def sort_list(x):
    B = [0]*len(x)
    i = 0
    x.sort()
    for a in x:
        if a % 2 == 1:
            B[i] = a
            i += 2
    i = 1
    x.reverse()
    for a in x:
        if a % 2 == 0:
            B[i] = a
            i += 2
    print(B)

자바스크립트로 작성하였습니다.

자연수의 리스트가 조건에 맞게 주어진다는것이 랜덤하게 생성된다는건지 잘 몰라서 생략하고 홀수와 짝수의 정렬 로직만 구현하였습니다.

배열과 sort 함수를 이용하면 쉽게 해결할 수 있습니다.

var arr = [4,1,3,2,6,5]
var odd = []
var even = []
var result = []

for(let i of arr) {
    if(i%2 === 0) even.push(i)
    else odd.push(i)
}

odd.sort((a,b) => a-b);    //홀수의 오름차순 정렬
even.sort((a,b) => b-a);    //짝수의 내림차순 정렬

for(let j in even) {
    result.push(odd[j]);
    result.push(even[j]);
}

console.log(result);

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


int compare(const void* a, const void* b, const int is_descending);
void print_array(int* array);

int main(void)
{
    int input;
    int i = 0, j = 0, length = 0;
    int arr[100], answer[100];

    while (scanf("%d", &input) != EOF)
    {
        arr[length] = input;
        length += 1;
    } 
    arr[length] = EOF;
    answer[length] = EOF;

    qsort(arr, length, sizeof(arr[0]), compare, 0);

    int odd_idx = 0, even_idx = length - 2;
    for (i = 0; i < length; i++)
    {
        if (arr[i] % 2 != 0)
        {
            answer[odd_idx] = arr[i];
            odd_idx += 2;
        }
        else
        {
            answer[even_idx] = arr[i];
            even_idx -= 2;
        }
    }

    while (answer[j] != EOF)
    {
        printf("%d ", answer[j]);
        j += 1;
    }

    return 0;
}

int compare(const void* a, const void* b, const int is_descending)
{
    int out;

    if (*(int*)a < *(int*)b)
    {
        out = (is_descending == 0) ? -1 : 1;
    }
    else if (*(int*)a > *(int*)b)
    {
        out = (is_descending == 0) ? 1 : -1;
    }
    else
    {
        out = 0;
    }

    return out;
}

lst = list(map(int, input().split()))
odd = []
even = []
for i in lst:
    if i%2 == 1:
        odd.append(i)
    else:
        even.append(i)
odd.sort()
even.sort(reverse=True)
sorted_lst = []
while odd or even:
    mark_1 = odd.pop(0)
    mark_2 = even.pop(0)
    sorted_lst.append(mark_1)
    sorted_lst.append(mark_2)
print(*sorted_lst)

natural_list = [4, 1, 3, 2, 6, 5]
even_list = []
odd_list = []
sorted_list = []


for i in range(len(natural_list)):
    if natural_list[i] % 2 == 1:
        odd_list.append(natural_list[i])
    else:
        even_list.append(natural_list[i])


n = 0
while n < int(len(natural_list)/2):
    sorted_list.append(odd_list[n])
    sorted_list.append(even_list[n])
    n = n + 1

print(sorted_list)

while True:
    sample_input = input("똑같은 갯수의 홀수와 짝수를 입력하세요!! 공백으로 띄워주세요.")
    input_num_list = [int(x) for x in sample_input.split()]
    if len(input_num_list)%2==0:
        even_check_list = [1 if x%2==0 else 0 for x in input_num_list]
        if sum(even_check_list) == (len(input_num_list)/2):
            break

odd_list = []
even_list = []

for idx, check in enumerate(even_check_list):
    if check == 1:
        even_list.append(input_num_list[idx])
    else:
        odd_list.append(input_num_list[idx])

even_list.sort(reverse=True)
odd_list.sort()

out_num_list = []

for i in range(len(odd_list)):
    out_num_list.append(odd_list[i])
    out_num_list.append(even_list[i])

for number in out_num_list:
    print("{} ".format(number), end="")

Odd=sorted([x for x in L if x&1])
Even=sorted([x for x in L if x%2==0],reverse=True)
res=[j for i in zip(Odd,Even) for j in i]
print(res)

numbers = [4,1,3,2,6,5]
result = [sorted([x for x in numbers if x%2==1])[i//2] if i%2==0 else sorted([x for x in numbers if x%2==0],reverse=True)[i//2] for i in range(len(numbers))]

print(result)

def even (arr):
    n=0
    for i in arr:
        if i%2==0:
            n+=1
    return n

def odd (arr):
    n=0
    for i in arr:
        if i%2!=0:
            n+=1
    return n

while True:
    arr = list(map(int,str(input("자연수 리스트 입력하시오(짝.홀수 개수가 같도록)")).split(" ")))
    if even(arr) == odd(arr):
        break

def fun (arr):
    ev_arr=[]
    od_arr=[]
    result=[]
    for i in arr:
        if i%2==0:
            ev_arr.append(i)
        else:
            od_arr.append(i)
    ev_arr.sort()
    ev_arr.reverse()
    od_arr.sort()
    for k in range(len(ev_arr)):
        result.append(od_arr[k])
        result.append(ev_arr[k])
    return result

print(fun(arr))

// Rust

// 입력배열을 오름차순으로 정렬하면 [홀수, 짝수, 홀수, 짝수,...] 되고,

// 짝수들만 위치를 바꿔주면 됩니다.

fn sort_odd_even() {

let mut input = [4, 1, 3, 2, 6, 5];
input.sort();

let l = input.len();
let mut result = input;
(0..l/2).for_each(|i| result[l-1-i*2] = input[i * 2 + 1]);

println!("{:?}", result);

}

a = map(int,input().split())
odd = []
even = []
result=[]
for i in a:
    if i%2!=0:
        odd.append(i)
    else:
        even.append(i)
odd.sort()
even.sort(reverse=True)

for i in range(len(odd)) :
    result.append(odd[i])
    result.append(even[i])
print(result)

package org.javaturotials.ex;
import java.util.*;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {    
        while(true) {
        Scanner sc =  new Scanner(System.in);
        String str = sc.nextLine();
        String[] arr = str.split(" ");
        int jc = 0;
        int hc = 0;
        int cv=0;
        for(int i=0; i<arr.length; i++) {
            if(Integer.valueOf(arr[i])%2==0) {jc++;}
            else {hc++;}
            cv++;
        }
        if(cv%2==0 && jc==hc) {
        ArrayList<Integer> h_arr = new ArrayList<Integer>(arr.length/2);
        ArrayList<Integer> j_arr = new ArrayList<Integer>(arr.length/2);
        for(int i=0; i<arr.length; i++) {
        if((Integer.valueOf(arr[i]))%2==0) {
            j_arr.add(Integer.valueOf(arr[i]));
        }
        else {h_arr.add(Integer.valueOf(arr[i]));
        }
        }
        h_arr.sort(Comparator.naturalOrder());
        j_arr.sort(Comparator.reverseOrder());

        for(int i=0; i<h_arr.size(); i++) {
            System.out.print(h_arr.get(i) + " ");
            System.out.print(j_arr.get(i) + " ");
        }
        System.out.println("\n");
        }
        }
    }
}

inp = '4 1 3 2 6 5'
numbers = inp.split(' ')
odd, even = [],[]

for num in numbers:
    if int(num)%2 == 0:
        even.append(num)
    else:
        odd.append(num)

for i in range(3):
    print(sorted(odd)[i], end=' ')
    print(sorted(even, reverse=True)[i], end=' ')    

using System;
using System.Collections.Generic;

namespace FirstProgram
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> num = new List<int>();
            List<int> odd = new List<int>();
            List<int> even = new List<int>();

            while (odd.Count==0)
            {
                Console.Write("홀수와 짝수의 개수가 같은 배열을 입력하세요 : ");
                string input = Console.ReadLine();
                string[] input_n = input.Split(' ');

                foreach (var n in input_n)
                {
                    int number = Convert.ToInt32(n);
                    num.Add(number);
                }

                for (int i = 0; i < num.Count; i++)
                {
                    if (num[i] % 2 == 1)
                        odd.Add(num[i]);
                    else
                        even.Add(num[i]);
                }

                Console.WriteLine(odd.Count + " " + even.Count);

                if(odd.Count != even.Count)
                {
                    Console.WriteLine("홀수와 짝수의 개수가 같지 않습니다.");
                    num.Clear();
                    odd.Clear();
                    even.Clear();
                }

            }
            odd.Sort();
            even.Sort();
            even.Reverse();

            for (int i = 0; i < odd.Count; i++)
            {
                Console.Write(odd[i] + " ");
                Console.Write(even[i] + " ");
            }
        }
    }
}

C#

nums = input().split(" ") #문자열 입력 및 공백으로 분리

even_nums = []
odd_nums = []#짝, 홀 리스트 선언

for num in nums:#전체 숫자 리스트의 원소중에서
    if int(num) % 2 == 0:#짝수라면
        even_nums.append(int(num))#짝수 리스트에 추가
    else:#아니라면
        odd_nums.append(int(num))#홀수 리스트에 추가

even_nums.sort(reverse=True)#짝수리스트 내림차순으로 정렬
odd_nums.sort()#홀수리스트 오름차순(기본)으로 정렬


for i in range(0,len(even_nums)):#짝수리스트의 길이(=홀수리스트의 길이)만큼
    print(odd_nums[i],end=" ")#끝은 공백문자로 홀수 리스트의 i번째 원소 출력
    print(even_nums[i],end=" ")#끝은 공백문자로 짝수 리스트의 i번째 원소 출력

예외처리 한 것입니다.

lst = list(map(int, input("숫자들을 입력하세요 \n").split()))

class NatNumError(Exception):
    pass
class SameCountError(Exception):
    pass

try:
    oddnum = []
    evennum = []
    for i in range(len(lst)):
        if lst[i] % 2 == 0: #짝수
            evennum.append(lst[i])
        else:
            oddnum.append(lst[i])
    if len(oddnum) != len(evennum):
        raise SameCountError
    for i in lst:
        if i <= 0:
            raise NatNumError
    evennum.sort()
    evennum.reverse()
    oddnum.sort()
    for i in range(len(evennum)):
        oddnum.insert(i*2+1, evennum[i])
    print(oddnum)

except NatNumError:
    print("자연수가 아닙니다.")
except SameCountError:
    print("홀수와 짝수의 갯수가 다릅니다.")

# 숫자정렬(홀-짝-홀-짝)
a=[1,6,7,3,4,10]

b=[]
c=[]
for i in a:
    if i %2:
        b.append(i)
    else: c.append(i)
print(b,"\n",c)

b.sort()  #sorted(b)
c.sort(reverse =True)
print(b,c)

d=[]
for i in range(len(b)):
    d.append(b[i])
    d.append(c[i])
print(d)

b = []
c = []
a = [4,1,3,2,6,5]
for i in range(6):
    if a[i] % 2 == 0:
        b.append(a[i])
    else :
        c.append(a[i])
c.sort()
b.sort(reverse = True)
for i in range(3):
    print(c[i],b[i], end= " ")

input1 = input()
inputlist = [x for x in input1.split()]

even, odd = [], []
for num in inputlist :
  num = int(num)
  if num%2 == 0 :
    even.append(num)
  else :
    odd.append(num)

if len(even) != len(odd) :
  quit()
else :
  even.sort() and odd.sort()
  odd.reverse()
  result = []
  for i in range(len(even)) :
    result.append(even[i])
    result.append(odd[i])
print(result)

import java.util.Arrays;
import java.util.Scanner ;
public class SortEvenandOdd {
    public static Scanner sc = new Scanner(System.in);

    public static int[] getNum(String num) {
        String[] numlist = num.split("\\s");
        int[] intnumlist = new int[numlist.length];
        for (int i = 0; i < numlist.length; i++) {
            intnumlist[i] = Integer.parseInt(numlist[i]);
        }
        return intnumlist;
    }

    public static int[][] evenandodd(int[] arr) {
        int[][] evenodd = new int[arr.length / 2][arr.length / 2];
        int[] even = new int[arr.length / 2];
        int[] odd = new int[arr.length / 2];
        int evencount = 0;
        int oddcount = 0;

        for (int j = 0; j < arr.length; j++) {
            if (arr[j] % 2 == 0) {
                even[evencount] = arr[j];
                evencount += 1;
            } else {
                odd[oddcount] = arr[j];
                oddcount += 1;
            }
        }
        if (even.length != odd.length) {
            System.exit(0);
        }
        Arrays.sort(even);
        Arrays.sort(odd);
        evenodd[0] = even;
        evenodd[1] = odd;
        return evenodd;
    }

    public static void main(String[] args) {
        String num = sc.nextLine();
        int[] arr = SortEvenandOdd.getNum(num);
        int[][] sort = SortEvenandOdd.evenandodd(arr);
        int[] result = new int[arr.length];
        int evencount = 0 ;
        int oddcount = sort[1].length - 1 ;
        for (int i = 0; i < result.length ; i++) {
            if (i%2 == 0) {
                result[i] = sort[0][evencount] ;
                evencount += 1 ;
                }
            else {
                result[i] = sort[1][oddcount] ;
                oddcount -= 1 ;
                }
            System.out.print(result[i]+"\t") ;
        }System.out.println();
    }
}

아직 자바는 익숙하지 않아서 코드가 많이 더러워요..

자바로 풀어봤습니다.

• 자연수만 입력합니다. (입력을 그만하고 싶으면 !을 입력)
• 홀수와 짝수의 갯수가 같지 않으면 다시 입력해야 합니다.

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

public class test {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        ArrayList<Integer> Numbers = new ArrayList<>();
        ArrayList<Integer> even = new ArrayList<>();
        ArrayList<Integer> odd = new ArrayList<>();

        int inputNumber, countEven=0, countOdd=0; 
        String inputData;

        // 리스트 입력
        while(true) {
            int breakvar = 1;
            while(breakvar>0) {
                System.out.print("자연수를 입력하시오.(단, 홀수와 짝수의 개수가 같음):");
                inputData = scan.next();

                if(inputData.equals("!")) {
                    breakvar=0;
                }else {
                    inputNumber = Integer.parseInt(inputData);

                    if(inputNumber<1) {
                        System.out.println("음수를 입력하셨습니다. 자연수를 입력하세요.");
                    }else {
                        Numbers.add(inputNumber);
                    }
                }
            }

            for(int i=0; i<Numbers.size(); i++){
                if(Numbers.get(i)%2 ==0) {
                    countEven++;
                }else {
                    countOdd++;
                }
            }

            if(countEven==countOdd) {
                break;
            }else {
                System.out.println("짝수와 홀수의 갯수가 같지 않습니다. 다시 입력하세요.");
                continue;
            }
        }

        // 홀수, 짝수 리스트에 저장
        int Number;
        for(int i=0; i<Numbers.size(); i++) {
            Number = Numbers.get(i);

            if(Number%2==0) {
                even.add(Number);
            }else {
                odd.add(Number);
            }
        }

        // sort
        even.sort(Comparator.reverseOrder());
        odd.sort(Comparator.naturalOrder());

        // 결과 출력
        Numbers.clear();
        for(int i=0; i<even.size(); i++) {
            Numbers.add(odd.get(i));
            Numbers.add(even.get(i));
        }

        System.out.println("Sorted Array : "+Numbers);

    }
}

data = [4, 1, 3, 2, 6, 5, 10, 8, 7, 9]

result = ['*'] * len(data)
odd, even = 0, -1

for i in sorted(data):
    if i % 2 == 1:
        result[odd] = i
        odd += 2
    else:
        result[even] = i
        even -= 2

print(result)

int main(void){

    int i,l,j,odd,even,p;
    int a[6] = {4,1,3,2,6,5};
    int b[3],c[3],d[6];
    int na = sizeof(a) / sizeof(a[0]); 
    printf("배열a의 개수는 %d입니다.\n", na); //a 배열 총 갯수를 알려줌 

    odd = 0;
    even = 0;

    //for(i=1; i<na; i++)
        //if(a[i] > max) max = a[i];

    for(i=0; i<na; i++){

        if(a[i] % 2 == 0){

            b[odd] = a[i];
            odd += 1;

            for (l = 0; l < odd; l++) {
                for (j = 0; j < (odd - 1) - l; j++) {
                    if (b[j] < b[j + 1]) {  // 버블 정렬 사용
                        p = b[j];
                        b[j] = b[j + 1];
                        b[j + 1] = p;
                    }
                }
            }

        }
        else{

            c[even] = a[i];
            even += 1;

        }

    }

    for(i=0; i<3; i++){

        printf("a = %d\na = %d\n", c[i],b[i]);

    } 

}

a = input()

list_b = a.split()
list_b = list(map(int, list_b))
list_b.sort()

odd = []
fdd = []

for i in range(len(list_b)):
    if int(list_b[i]) % 2 == 0:
        odd.append(list_b[i])
    else:
        fdd.append(list_b[i])

for i in range(int(len(list_b) / 2)):
    print(odd[i], fdd[-i-1], end=" ")

x = [4,1,3,2,6,5]
odd = sorted([a for a in x if a%2 != 0])
even = sorted([b for b in x if b%2 == 0], reverse = True)
result = [odd[int(i/2)] if i%2 == 0 else even[int(i/2)] for i in range(len(x))]
print(result)

def num_sort_diff(num_mat):
    odd, even, result = [i for i in num_mat if int(i) % 2 == 1], [i for i in num_mat if int(i) % 2 == 0], [] # 홀수, 짝수, 결과
    if len(odd) != len(even): return
    odd.sort()
    even.sort(reverse=True)
    for i in range(len(odd)):
        result += [odd[i], even[i]]
    return result

num_mat = input('홀수와 짝수가 같은 자연수 리스트를 입력해주세요. ')
print(num_sort_diff(num_mat))

while True:
    입력숫자들 = list(map(int, input().split()))

    짝수 = [x for x in 입력숫자들 if x % 2 == 0]
    홀수 = [x for x in 입력숫자들 if x % 2 != 0]

    if len(짝수) == len(홀수):
        break
    else:
        print('짝수와 홀수의 개수가 같지 않습니다. 다시 입력하세요.')

결과 = []
for i in range(len(홀수)):
    결과.append(sorted(홀수)[i])
    결과.append(sorted(짝수, reverse=True)[i])

print(결과)

numbers = list(map(int, input().split()))

odds = []
evens = []
for i in numbers:
    if i%2:
        odds.append(i)
    else:
        evens.append(i)
odds.sort()
evens.sort(reverse=True)


for i, j in zip(odds, evens):
    print(i, j, end = ' ')

package sort.file;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

class data {
    ArrayList<String> list;
    ArrayList<String> dataa = new ArrayList<>();
    ArrayList<String> datab = new ArrayList<>();
    public data(ArrayList<String>datalist) {
        this.list = datalist;
    }


    public void arrange() {
        for (int y=0; y<(list.size()); y++) {
            int Stringint = Integer.parseInt(list.get(y));
            if (Stringint%2==0) {
                datab.add(list.get(y));
            } else {
                dataa.add(list.get(y));
            }
        }
    }

    public ArrayList<String> returna() {
        return dataa;
    }

    public ArrayList<String> returnb() {
        return datab;
    }
}




public class project {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("값: ");
        String a = scan.nextLine();
        a += " ";
        ArrayList<String> data = new ArrayList<>();
        int start = -1;
        for (int i=0; i<a.length(); i++) {
            char result = a.charAt(i);
            String re = String.valueOf(result);         
            if (isStringEmpty(re)) {
                start = i;
                System.out.println("catch!");
            } else {
                if ((i-start)==1 || (i-start) == -1) {
                    System.out.println("found!");
                    char reeee = a.charAt(start+2);
                    String reeeee = String.valueOf(reeee);  
                    if (isStringEmpty(reeeee)) {
                        char ree = a.charAt(start+1);
                        String reee = String.valueOf(ree);
                        data.add(reee);
                    } 
                } else {
                    String res = "";
                    System.out.println("sad....");
                    for (int t=0; t<(i-start); t++ ) {
                        char p = a.charAt(t+start+1);
                        String pp = String.valueOf(p);
                        res += pp;
                    char tt = a.charAt(t+start+2);
                    String ttt = String.valueOf(tt);
                    if (isStringEmpty(ttt)) {
                        data.add(res);
                    }

                    }
                }
            }

        }
        System.out.println(data);

        int lendata = data.size();

        ArrayList<String> numa = new ArrayList<>();
        ArrayList<String> numb = new ArrayList<>();
        data dataoutput = new data(data);
        dataoutput.arrange();
        numa = dataoutput.returna();
        numb = dataoutput.returnb();
        int size = numa.size();
        System.out.println(numa);
        System.out.println(numb);
        int [] numma = new int [numa.size()];
        int [] nummmb = new int [numb.size()];
        for (int q=0; q<numa.size(); q++) {
            numma[q] = Integer.parseInt(numa.get(q));
        }
        for (int i = 0; i<numb.size(); i++) {
            nummmb[i] = Integer.parseInt(numb.get(i));
        }
        Arrays.sort(numma);
        Arrays.sort(nummmb);
        int [] nummb = new int [nummmb.length];
        for (int pp = 0; pp<nummmb.length; pp++) {
            nummb[pp] = nummmb[nummmb.length-pp-1];
        }
        int [] resultlist = new int [lendata];
        for (int tt = 0; tt<lendata; tt++) {
            if ((tt%2)==0) {
                resultlist[tt] = numma[tt/2];
            } else {
                resultlist[tt] = nummb[((int) Math.floor(tt/2))];
            }
        }
        ArrayList<Integer> resultlistt = new ArrayList<Integer>();
        for (int o=0; o<lendata; o++) {
            resultlistt.add(resultlist[o]);
        }
        System.out.println(resultlistt);

    }

    static boolean isStringEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

}

한 자릿수만 가능합니다.

num_list = [4, 1, 3, 2, 6, 5]
sin_list = []
dou_list = []
result   = []

for i in num_list:
    if i % 2 == 0:      #짝수
        dou_list.append(i)
    else:               #홀수
        sin_list.append(i)

sin_list.sort()                     #홀수 정렬
dou_list.sort(reverse = True)       #짝수 역순 정렬

i = 0
while(1):
    if i > len(sin_list) and i > len(dou_list): #탈출 구분자
        break
    try:                            #짝수와 홀수 list 길이가 다를 수 있음. try처리
        result.append(sin_list[i])
    except:
        pass
    try:
        result.append(dou_list[i])
    except:
        pass
    i += 1

print(result)

ref = [4,1,3,2,6,5]
even = []
odd = []
ans = []
for i in range(len(ref)):
   if ref[i] % 2 == 0:
      even.append(ref[i])
   else:
      odd.append(ref[i])
odd.sort()
even.sort(reverse=True)
for j in range(len(odd)):
   ans.append(odd[j])
   ans.append(even[j])
print(ans)

a=input()
str_list = a.split()
odd_list = []; even_list = []; final_list = []

for num in str_list:
  if int(num)%2 == 0:
    even_list.append(int(num))
  else: 
    odd_list.append(int(num))

if len(odd_list) == len(even_list):
  odd_list.sort()  
  even_list.sort(reverse=True)
  for i in range(len(odd_list)):
    final_list.append(odd_list[i])
    final_list.append(even_list[i])
  print(final_list)
else:
  print("입력이 잘못되었습니다.")

inpt = list(map(int, input().split()))
inpt = sorted(inpt)
inp_Odd = inpt[0::2]
inp_Even = sorted(inpt[1::2], reverse=True)
print(inp_Even, inp_Odd)

outpt = []

for i in range(len(inpt)//2):
    outpt.append(inp_Odd[i])
    outpt.append(inp_Even[i])

print(outpt)

홀-짝으로 정리. 홀수는 오름차순, 착수는 내림차순

num = [4,1,3,2,6,5,8,11]
odd = sorted([n for n in num if n%2==1])
even = sorted([n for n in num if n%2==0], reverse = True)
if len(odd) == len(even):
    nested_list = list(zip(odd, even))
    flat_list = [item for sublist in nested_list for item in sublist]
    print(flat_list)
else:
    print('오류')

even, odd = [x for x in [4, 1, 3, 2, 6, 5] if x % 2 ==0 ], [x for x in [4, 1, 3, 2, 6, 5] if x % 2 ==1]    
print([i for x in zip(sorted(odd), sorted(even, reverse=True)) for i in x])

심플하게 2줄로 짜봤습니다.

a = list(map(int, input().split()))
odd = []
even = []
for i in range(6):
    if a[i]%2 == 0:
        even.append(a[i])
    else:
        odd.append(a[i])
odd.sort(reverse=False)
even.sort(reverse=True)
print(odd[0],even[0],odd[1],even[1],odd[2],even[2])

a = input("숫자를 입력하세요: ").split(" ")
b = []
c = []
d = []
for i in a:
  if int(i) % 2 == 0:
    b.append(i)
  else:
    c.append(i)
b.sort()
c.sort(reverse = True)

while len(b) >= 1 and len(c) >= 1:
  d.append(c.pop())
  d.append(b.pop())
print(d)

i = map(int, input().split()) odd = [] even = []

for x in i : if x%2 : odd.append(x) else : even.append(x)

odd = sorted(odd) even = sorted(even, reverse=True)

for i in range(len(odd)) : print(odd[i], even[i], end=' ')

a=[4,1,6,2,3,7,9,3,1,5,8]
b=[]
c=[]
for i in a:
    if i%2 :
        b.append(i)
    else:
        c.append(i)
b.sort()
c.sort(reverse=True)
n=0
while True:
    if n<len(b):
        print(b[n],end=" ")
    if n<len(c):
        print(c[n],end=" ")
    if  n==max(len(b),len(c)):
        break
    n=n+1

홀수 짝수 개수가 다른 경우도 만들어 봤어요.

sample = [4,1,3,2,6,5]
odd = [int(x) for x in sample if int(x)%2==1]
even = [int(x) for x in sample if int(x)%2==0]
sampleout = []

for i in range(int(len(sample)/2)):
  sampleout.append(sorted(odd)[i])
  sampleout.append(sorted(even, reverse=True)[i])

print(sampleout)