2014년 10월 15일 수요일

[AlgoSpot] FIX

  • Collection의 sort 메소드를 이용하여 쉽게 정렬하고 이를 이용하여 정리를 하고 비교하는 방식으로 하였습니다.


 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
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class FIX {

    public static void main(String[] args) {
     Scanner sc = new Scanner(System.in);
  int cases = sc.nextInt();
  while (cases-- > 0) {
   int times = sc.nextInt();
   ArrayList<integer> Q = new ArrayList<integer>();
   for(int i=0;times&gt;i;i++)
    Q.add(sc.nextInt());
   ArrayList<integer> copy_Q = new ArrayList<integer>(Q);
   Collections.sort(Q);
   int count = 0;
   for(int i = 0;times&gt;i;i++)
    if(Q.get(i)==copy_Q.get(i))
     count++;
   
   System.out.println(count);
  }
    }
}




  • 취준생의 공부 정리 방입니다. algospot 게시물에서 문제 풀이에 대한 포스팅은 언제나 환영이라는 글을 보았기에 정리겸, 공부겸 겸사겸사 문제풀이를 올립니다. 저작권에 문제 있을시 자삭하겠습니다.
  • 엉터리일수도(아마도 대부분) 느리기도 하지만 풀었다는 것에 의의를 두고 있습니다.

[AlgoSpot] WEEKLYCALENDAR

  • 주일달력 만들기 입니다.
  • 요일을 인식하여 인덱스로 반환하는 부분을 if문이나 삼항연산사로 실험해보았으나 해쉬맵을 이용하는 방법이 조금이나마 빨랐습니다.
  • 요일을 입력받아 요일에 해당하는 위치를 인덱스로 반환하여 for문으로 출력할때에 정확한 위치에 나오도록 하였습니다.




 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
31
32
import java.util.HashMap;
import java.util.Scanner;

public class WEEKLYCALENDAR {

    public static void main(String[] args) {
     int end_day[] = {31,28,31,30,31,30,31,31,30,31,30,31};
     HashMap<string integer=""> days= new HashMap<string integer="">();
     days.put("Sunday", 1);
     days.put("Monday", 2);
     days.put("Tuesday", 3);
     days.put("Wednesday", 4);
     days.put("Thursday", 5);
     days.put("Friday", 6);
     days.put("Saturday", 7);
     Scanner sc = new Scanner(System.in);
  int cases = sc.nextInt();
  while (cases-- &gt; 0) {
   int month = sc.nextInt();
   int last_month = month==1?11:month-2;
   int day = sc.nextInt();
   String week = sc.next();
   int index = days.get(week);
   int weeks[] = new int[7];
            for(int i=1;7&gt;=i;i++){
                int print = day-index+i&lt;1 data-blogger-escaped-day-index="" data-blogger-escaped-end_day="" data-blogger-escaped-i="" data-blogger-escaped-last_month=""&gt;end_day[month-1]?day-index+i-end_day[month-1]:day-index+i);
                weeks[i-1]=print;
            }
   System.out.println(weeks[0]+" "+weeks[1]+" "+weeks[2]+" "+weeks[3]+" "+weeks[4]+" "+weeks[5]+" "+weeks[6]);
  }
    }
}

  • 취준생의 공부 정리 방입니다. algospot 게시물에서 문제 풀이에 대한 포스팅은 언제나 환영이라는 글을 보았기에 정리겸, 공부겸 겸사겸사 문제풀이를 올립니다. 저작권에 문제 있을시 자삭하겠습니다.
  • 엉터리일수도(아마도 대부분) 느리기도 하지만 풀었다는 것에 의의를 두고 있습니다.
  • [AlgoSpot] HammingCode

    • 단순 해밍코드 구현입니다. 이문제에서는 7 4 해밍코드 구현입니다.



     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import java.util.Scanner;
    
    public class HAMMINGCODE {
    
        public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      int cases = sc.nextInt();
      while (cases-- &gt; 0) {
       String sInput = sc.next();
       char[] cInput = sInput.toCharArray();
       int iParity = (cInput[0]^cInput[2]^cInput[4]^cInput[6])*1+(cInput[1]^cInput[2]^cInput[5]^cInput[6])*2+(cInput[3]^cInput[4]^cInput[5]^cInput[6])*4;
       if(iParity != 0){
        cInput[iParity-1] = cInput[iParity-1]=='0'?'1':'0';
       }
       char[] output = new char[]{cInput[2],cInput[4],cInput[5],cInput[6]};
       System.out.println(output);
      }
        }
    }
    

  • 취준생의 공부 정리 방입니다. algospot 게시물에서 문제 풀이에 대한 포스팅은 언제나 환영이라는 글을 보았기에 정리겸, 공부겸 겸사겸사 문제풀이를 올립니다. 저작권에 문제 있을시 자삭하겠습니다.
  • 엉터리일수도(아마도 대부분) 느리기도 하지만 풀었다는 것에 의의를 두고 있습니다.
  • 2014년 10월 8일 수요일

    [자료구조, Java] Insertion Sort(삽입 정렬)

    Insertion Sort(삽입 정렬)

    출처 : 위키백과
    • 시간복잡도 : O(n^2)
    • 앞에서 부터 차례대로 이미 정렬된 배열 부분과 비교하여, 알맞는 대소관계의 위치에 위치하여 정렬
    • 장점 : 쉬운 구현
    • 단점 : 배열이 길어질수록 
    java 구현

     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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    public class Insertion_Sort {
     //난수 생성 메소드
     public int[] make_rnd(int size){
      //중복값 제거를 위하여 Set으로 값 관리
      Set rnd = new HashSet();
      int rnd_list[] = new int[size];
      for(int i = 0;size>i;i++){
       //1~99사이의 난수값 생성
       int tmp = (int) (Math.random() * 99)+1;
       rnd.add(tmp);
       //중복값 생성시 다시 생성
       if (rnd.size() == i + 1)
        i--;
       else
        rnd_list[i]=tmp;
      }
      System.out.println("원본 배열 생성");
      array_print(rnd_list, size);
      return rnd_list;
     }
     
     //배열 출력 메소드
     public void array_print(int rnd_list[],int size){
      System.out.print("[ ");
      for(int i=0;size>i;i++){
       System.out.print(rnd_list[i]+ " ");
      }
      System.out.println("]");
     }
     
     
     public static void main(String args[]){
      int size = 10;
      Insertion_Sort sort= new Insertion_Sort();
      int rnd_list[] = sort.make_rnd(size);
      
      //버블정렬 i = 차수
      for (int i = 1; size > i; i++) {
       //j비교 위치
       for (int j = 0; i > j; j++) {
        //2개 값 비교하여 정렬
        if(rnd_list[j]>rnd_list[i]){
         int tmp[] = new int[size];
         System.arraycopy(rnd_list, 0, tmp, 0, j);
         tmp[j]=rnd_list[i];
         System.arraycopy(rnd_list, j, tmp, j+1, i-j);
         System.arraycopy(rnd_list, i+1, tmp, i+1, size-(i+1));
         rnd_list = tmp;
         break;
        }
       }
       System.out.println(i+"차 정렬");
       sort.array_print(rnd_list, size);
      }
     }
    }
    
    원본 배열 생성 [ 64 95 54 82 18 69 43 7 68 29 ]
    1차 정렬 [ 64 95 54 82 18 69 43 7 68 29 ]
    2차 정렬 [ 54 64 95 82 18 69 43 7 68 29 ]
    3차 정렬 [ 54 64 82 95 18 69 43 7 68 29 ]
    4차 정렬 [ 18 54 64 82 95 69 43 7 68 29 ]
    5차 정렬 [ 18 54 64 69 82 95 43 7 68 29 ]
    6차 정렬 [ 18 43 54 64 69 82 95 7 68 29 ]
    7차 정렬 [ 7 18 43 54 64 69 82 95 68 29 ]
    8차 정렬 [ 7 18 43 54 64 68 69 82 95 29 ]
    9차 정렬 [ 7 18 29 43 54 64 68 69 82 95 ]

    2014년 10월 7일 화요일

    [자료구조, Java] BuubleSort

    Bubble Sort(버블 정렬)
    출처 : 위키백과
    • 시간복잡도 : O(n^2)
    • 인접한 두 인자(즉, 2개씩) 비교해가며 반복하여 정렬
    • 장점 : 쉬운 구현
    • 단점 : 느리다.
    java 구현
     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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    public class Bubble_Sort {
     //난수 생성 메소드
     public int[] make_rnd(int size){
      //중복값 제거를 위하여 Set으로 값 관리
      Set rnd = new HashSet();
      int rnd_list[] = new int[size];
      for(int i = 0;size>i;i++){
       //1~99사이의 난수값 생성
       int tmp = (int) (Math.random() * 99)+1;
       rnd.add(tmp);
       //중복값 생성시 다시 생성
       if (rnd.size() == i + 1)
        i--;
       else
        rnd_list[i]=tmp;
      }
      System.out.println("원본 배열 생성");
      array_print(rnd_list, size);
      return rnd_list;
     }
     
     //배열 출력 메소드
     public void array_print(int rnd_list[],int size){
      System.out.print("[ ");
      for(int i=0;size>i;i++){
       System.out.print(rnd_list[i]+ " ");
      }
      System.out.println("]");
     }
     
     
     public static void main(String args[]){
      int size = 10;
      Bubble_Sort sort= new Bubble_Sort();
      int rnd_list[] = sort.make_rnd(size);
      
      //버블정렬 i = 차수
      for (int i = 0; size - 1 > i; i++) {
       //j비교 위치
       for (int j = 0; size - 1 > j; j++) {
        //2개 값 비교하여 정렬
        if (rnd_list[j] > rnd_list[j + 1]) {
         int tmp = rnd_list[j + 1];
         rnd_list[j + 1] = rnd_list[j];
         rnd_list[j] = tmp;
        }
       }
       System.out.println(i+1+"차 정렬");
       sort.array_print(rnd_list, size);
      }
     }
    }
    
     
    원본 배열 생성
    [ 89 31 19 63 55 59 97 5 61 94 ]
    1차 정렬
    [ 31 19 63 55 59 89 5 61 94 97 ]
    2차 정렬
    [ 19 31 55 59 63 5 61 89 94 97 ]
    3차 정렬
    [ 19 31 55 59 5 61 63 89 94 97 ]
    4차 정렬
    [ 19 31 55 5 59 61 63 89 94 97 ]
    5차 정렬
    [ 19 31 5 55 59 61 63 89 94 97 ]
    6차 정렬
    [ 19 5 31 55 59 61 63 89 94 97 ]
    7차 정렬
    [ 5 19 31 55 59 61 63 89 94 97 ]
    8차 정렬
    [ 5 19 31 55 59 61 63 89 94 97 ]
    9차 정렬
    [ 5 19 31 55 59 61 63 89 94 97 ]
    

    [자료구조] 정렬 - 작성중

    Bubble Sort(버블 정렬)
    출처 : 위키백과
    • 시간복잡도 : O(n^2)
    • 인접한 두 인자(즉, 2개씩) 비교해가며 반복하여 정렬
    • 장점 : 쉬운 구현
    • 단점 : 느리다.
    Insertion Sort(삽입 정렬)

    출처 : 위키백과
    • 시간복잡도 : O(n^2)
    • 앞에서 부터 차례대로 이미 정렬된 배열 부분과 비교하여, 알맞는 대소관계의 위치에 위치하여 정렬
    • 장점 : 쉬운 구현
    • 단점 : 배열이 길어질수록 

    Bucket Sort(버킷 정렬)
    • 인자들을 조건에 따라 분류를 하고 조건에 맞게 순서대로 정렬
    • 시간복잡도, 장,단점
      • 조건 마다 시간복잡도, 장단점 등이 다르기 때문에 정의 할수 없다.
    Merge Sort(합병 정렬,분할 정렬)
    • 인자들을 비슷한 크기로 나눠 비교하며 정렬
      • 2-Way Merge Sort -> 2개씩 나눠 정렬
    • 장점 : 큰 데이터 처리시 적은 RAM으로 나눠 정렬 가능
    Radix Sort(기수정렬)
    • 시간복잡도 : O(dn), d는 인자들중 가장 큰 자릿수
    • 낮은 자리수부터 비교해 가며 정렬
    • 장점 : 정렬속도가 매우 빠르다
    • 단점 : 메모리 크기가 많이 든다.