2021年07月15日 10:32

이준우

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); // 생성자 호출
 }
}

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

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

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

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

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

한 자릿수만 가능합니다.