728x90

-개발환경-

IDE : Eclipse IDE for Java Developers Version: 2020-03 (4.15.0)

공부 자료 :  www.inflearn.com/course/%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%9E%90%EB%B0%94/lecture/22652

-문제-

날마다의 온도모음 리스트가 주어 진다. 그 리스트를 통해 당신은 더 따뜻한 날까지 몇일을 기다려야하는지
알수 있다, 각각의 날에 대해 몇일을 기다리면 온도가 더 따뜻해지는지를 리스트로 반환하라.
적합한 날이 없다면 , 0을 넣어 반환하라.

 

ex)
T = [73, 74, 75, 71, 69, 72, 76, 73], 
your output should be [1, 1, 4, 2, 1, 1, 0, 0].

 

Note) 측정온도의 갯수는 [1,30000] 이다.
온도의 범위는 [30,100] 이며 정수이다. 

 

-접근법-

 

윗 개념 + 

for 문을 이용하여 nums 원소에 하나씩 접근할 시 , 문제해결을 위해서

반드시 역행하는 순서가 필요하게 되므로 스택을 이용.

 

 

-DailyTemperature.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
57
58
59
60
61
package codingTest;
 
import java.util.Stack;
 
public class DailyTemperature  {
 
    public static void main(String[] args) {
        int[] nums= {73,74,75,71,69,72,76,73};
        int[] res = solve(nums);
        
        //outPut
        for(int i : res) {
            System.out.print(i+" ");
        }
    }
    public static int[] solve(int[] temper) {
        //1. ds
        Stack<Integer> stack=new Stack<>();
        int[] result=new int[temper.length];
        
        //2. for,while + algo
        for(int i=0; i<temper.length;i++) {
            System.out.println("==================================");
            System.out.println("temper(온도): "+temper[i]);//test
 
            while(!stack.isEmpty() && temper[stack.peek()] <temper[i]  ) {
                //====================test begin=======================
                Stack<Integer> stemp=new Stack<>();//test
                stemp=(Stack<Integer>) stack.clone();//test
                System.out.print("맨 위-> 맨아래 순 stack: ");
                while(!stemp.isEmpty()) {//test while
                    System.out.print(stemp.pop()+" ");
                }
                System.out.println();//test
                //====================test end=======================
                
                
                int index=stack.pop();
 
                //====================test begin=======================
                System.out.println("i : "+i+" index : "+index);//test
                //====================test end=======================
                
                result[index]= i-index; 
                
                //====================test begin=======================
                stemp=(Stack<Integer>) stack.clone();//test
                System.out.print("맨 위-> 맨아래 순 stack: ");//test
                while(!stemp.isEmpty()) {//test while
                    System.out.print(stemp.pop()+" ");
                }
                System.out.println();//test
                //====================test end=======================
                
            }
            stack.push(i);
        }
        return result;
    }
}
 
cs
더보기

-Description

18 : 온도의 인덱스를 값으로 하는 stack 생성
19 : 결과를 담을 result 배열 생성
26 : 스택에 데이터가 있고  ,    온도[스택의 꼭대기 값] <  온도[i] 을 만족하면 반복문 수행
38 : index에 스택의 peek 데이터 삽입, 그리고 pop.
44 : 접근법 이미지에서 설명한 내용
56 : for 문 내부의 끝에서 stack 온도 i를 삽입 
58 : 배열 result 반환

점검을 위한 명령문 결과 출력

 

개념이해가 어려워서 직접 데이터의 흐름에 따라 아래와 같이 작성해보았다.

의사코드 + 수행과정1

 

수행과정2

 

수행과정3

 

-추가개념-

Stack
//필요선언문
import java.util.Stack;

//객체생성
Stack<지네릭스> stack=new Stack<>()

//관련함수
stack.isEmpty() // 비어있으면 true반환 그외엔 false반환

stack.pop() // 꼭대기값을 pop함과 동시에 데이터 반환
stack.peek() // 단순 꼭대기 값을 반환
stack.push(값); // 값을 stack에 삽입 

 

-마침글-

브루트 포스 방식으로 스택문제에 접근하면 낭패를 볼 수 있다고 생각하게 되었다.

스택만의 유형에 익숙해질 필요가 있다.

 

인용

'21년이전 > 자바-Algorithm' 카테고리의 다른 글

TwoSum  (0) 2021.03.22
MoveZeros  (0) 2021.03.21
MeetingRoom  (0) 2021.03.20
728x90

-개발환경-

IDE : Eclipse IDE for Java Developers Version: 2020-03 (4.15.0)

공부 자료 :  www.inflearn.com/course/%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%9E%90%EB%B0%94/lecture/22652

-문제-

정수모임배열이 주어질 때, 두 숫자의 합이 target이 되는 두숫자의 모임들을 리턴하시오.

 

ex)

Given nums = [2, 8, 11, 14], target = 16, Because nums[0] + nums[3] = 2 + 14 = 16

return [1, 4].

 

-접근법-

예로 , Array = {2,8,11,14}; 가 있을 때,


1) Array Index 0 부터 끝까지 for 돌리면서,  
target -(Array 각각의 값) 을 Key로 설정 그리고 value는 Array의 인덱스로 설정.


2) Map(Array 각각의 값)=value가 이미 존재하면 그것은 two sum에 적합하므로
Array에 해당하는 인덱스와 value가 쌍으로 정답이됨

-TwoSum.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
package codingTest;
 
import java.util.HashMap;
import java.util.Map;
 
public class TwoSum {
 
    public static void main(String[] args) {
        TwoSum a = new TwoSum();
 
        //TestCase1
        int[] nums= {2,8,11,14};
        int target = 16;
        
        int[] result = a.solve(nums,target);
        //Output
        for(int i: result) {
            System.out.print(i + " ");
        }
    }
    public int[] solve(int[] nums, int target) {
        //1. DataStructure
        int[] result= new int[2];
        Map<Integer,Integer> map =new HashMap<>();
        
        //2. for
        for(int i=0;i<nums.length;i++) {
            
            if(map.containsKey(nums[i])) { 
                int value = map.get(nums[i]);
                result[0]=value+1;
                result[1]=i+1;
            }else {
                map.put(target-nums[i], i);
            }
                
        }
    
        return result;
    }
}
 
cs
더보기

-Description

24 : Map객체를 생성한다.
29 : map 에 해당 인자값이 있는지 (bool) 여부 판단 
30~32 : if문이 만족하였으므로 , 목표로하는 두 값을 찾음.  각각의 값에 +1 씩해서 인덱스를 숫자로 표현.
34 : map에 key 값으로 target-nums[i] , value로 i를 삽입

27~37 : for 문의 계샨과정

-추가개념-

Map,HashMap
Map은 인터페이스이고 , 이를 구현한 것들중 하나가 HashMap클래스이다. 
(etc  HashMap이외에도  LinkedHashMap, TreeMap 이 존재)

 

-가져오기
import java.util.HashMap;
import java.util.Map;

 

-선언
Map<Integer,Integer> map =new HashMap<>();

 

-사용함수
map.put(key,value); // map에 데이터 삽입
             // 넣을 key가 map에 이미 존재한다면 value로 교체됨
map.get(key); // value값 추출
     // key가 존재하지 않을시 null을 가져옴
map.containsKey(key); //key 값이 map에 존재하는지 확인 (boolean 반환)
map.remove(key); // map에서 key 값을 삭제한후 value를 반환
          // 해당 key가 존재 하지 않으면 null 반환
map.size(); // map의 묶음수 출력
map.clear(); // map의 모든 내용제거
map.keySet(); // map의 모든 key를 Set<Integer>형식으로 반환(순서는 랜덤)
map.values(); // map의 모든 values를 Collection<Integer> 형식으로 반환(순서는 랜덤)
map.entrySet(); // map의 모든 key,value를 Map.Entry<Integer, Integer>형식으로 반환(순서는 랜덤)
// entrySet() 사용ex)
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() +"-" + entry.getValue());
        }

 

-추가
HashMap이외의  LinkedHashMap,TreeMap 은 순서라는 특징을 가진다.
LinkedHashMap은 입력된 순서대로 데이터가 출력되는 특징
TreeMap은 입력된 key의 정렬순으로 데이터가 출력되는 특징

 

-마침글-

인용

wikidocs.net/208#containskey

'21년이전 > 자바-Algorithm' 카테고리의 다른 글

DailyTemperature  (0) 2021.03.24
MoveZeros  (0) 2021.03.21
MeetingRoom  (0) 2021.03.20
728x90

-개발환경-

IDE : Eclipse IDE for Java Developers Version: 2020-03 (4.15.0)

공부 자료 :  www.inflearn.com/course/%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%9E%90%EB%B0%94/lecture/22652

-문제-

- 배열 num을 감안할 때 0이 아닌 요소의 상대적인 순서를 유지하면서 모든 0을 끝으로 이동시키는 함수를 작성하십시오.

 

ex)

Input : [0,3,2,0,8,5] Output : [3,2,8,5,0,0]

 

-접근법-

풀이법1
num의  앞부터 하나씩 접근하는 반복문에서
0이아닌것을 어레이리스트에 더해줌(빅오 N)
NUM.length - 어레이리스트.length  = 0의갯수
어레이리스트에 0의갯수만큼 추가해줌
총빅오(N)

풀이법2
1. 배열 nums(자기자신)에  0이 아닌 값을 차례로 맨앞부터 넣어준다.(index 이용)
2. 기억된 index부터 0을 넣어준다.

 

풀이법2가 더 빠르고 ,공간복잡도도 작다.

-MoveZeros.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
package codingTest;
 
public class MoveZeros {
 
    public static void main(String[] args) {
        // Testcase1
        int[] nums= {0,3,2,0,8,5};
        
        //Procedure
        int index=0;
        for(int i=0; i<nums.length;i++) {
            if(nums[i]!=0) {
                nums[index]=nums[i];
                index++;
            }
        }
        while(index<nums.length) {
            nums[index]=0;
            index++;
        }
        //Output
        for(int i=0; i<nums.length;i++) {
            System.out.println(nums[i]);
        }
    }
 
}
 
cs

 

더보기

-Description

11~16 :  배열 nums(자기자신)에  0이 아닌 값을 차례로 맨앞부터 넣어준다.(index 이용)

11~16 반복문을 거친후의 index 값


17~20 : 기억된 index부터 0을 넣어준다.

 

-추가개념-

-마침글-

인용

'21년이전 > 자바-Algorithm' 카테고리의 다른 글

DailyTemperature  (0) 2021.03.24
TwoSum  (0) 2021.03.22
MeetingRoom  (0) 2021.03.20
728x90

-개발환경-

IDE : Eclipse IDE for Java Developers Version: 2020-03 (4.15.0)

공부 자료 :  www.inflearn.com/course/%EC%BD%94%EB%94%A9%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%9E%90%EB%B0%94/lecture/22652

-문제-

 [[s1,e1],[s2,e2],...] (si < ei) 와 같이 , 시작과 끝의 시간으로 구성된 회의시간 배열이 주어졌을때 ,
한 사람이 모든 회의에 참여할 수 있는지 여부를 bool 로 리턴하시오.

 

ex)

Input: [[0,30],[5,10],[15,20]]
Output: false
Input: [[7,10],[2,4]]
Output: true

 

-접근법-

주어진 [startTime,endTime] 모음 배열들이 서로 겹치는지 확인하여야 한다.

1. brute force 방식으로

n-1 + n-2 n-3 ... +n-(n-1) =n*(n-1)+ ((n-1)(n-2)) /2  = (n-1)(n+(n-2)/2)  =

거의 n**2 형태만큼의 반복횟수로 확인하여도 되고,

 

2. startTime 을 기준으로 배열을  오름정렬한다.

정렬되었다면 나름 시작 시간 기준으로 오름정렬이 된 것이고,

뒤.startTime > 앞.endTime 이 만족된다면 정상적인것 ,  불만족시 false 리턴.

시간복잡도는 O(정렬+N-1)

 

-MeetingRooms.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
57
58
59
60
61
62
63
64
65
66
package codingTest;
 
import java.util.Arrays;
import java.util.Comparator;
 
 
class Interval{
    int start;
    int end;
    Interval(){
        this.start = 0;
        this.end =0;
    }
    Interval(int s, int e){
        this.start = s;
        this.end = e;
    }
}
public class MeetingRooms {
    public static void main(String[] args) {
        MeetingRooms a = new MeetingRooms();
        
        //Testcase 1 
        Interval in1=new Interval(15,20);
        Interval in2=new Interval(0,30);
        Interval in3=new Interval(5,10);
        Interval in4=new Interval(10,20);
        Interval in5=new Interval(2,24);
        Interval[] intervals = {in1,in2,in3,in4,in5};
        System.out.println(a.solve(intervals));//false
    
        //Testcase 2
        Interval in2_1=new Interval(7,10);
        Interval in2_2=new Interval(2,6);
        Interval[] intervals2 = {in2_1,in2_2};
        System.out.println(a.solve(intervals2));//true
        
    }
    
    public boolean solve(Interval[] intervals) {
        //오름차순정렬
        if(intervals==nullreturn false;
        Arrays.sort(intervals,Comp);
        
        //진위검사
        for(int i=1; i<intervals.length; i++) {
            if(intervals[i-1].end > intervals[i].start)
                return false;
        }
        return true;
    }
    
      Comparator<Interval> Comp = new Comparator<Interval>() { //Comparator을 구현하는익명객체 생성 
          public int compare(Interval o1, Interval o2) { 
              return o1.start-o2.start;  // 0 or 양수 리턴시 객체자리변경  ,    음수리턴시 자리변경x 
          };
      };
    
    
    public void print(Interval[] intervals) {
        for (int i =0; i<intervals.length; i++) {
            Interval in= intervals[i];
            System.out.println(in.start+" "+in.end);
        }
    }
}
cs
더보기

-Description

43 : Comp방식으로 정렬 , Arrays는 배열관련 유용한 클래스
46~50 : 접근법 2번 방식의  '뒤.startTime > 앞.endTime ' 적용
53~57: Interface Comparator을 구현하는 익명객체를 생성하여 compare메소드를 오버라이딩(오름차순적용)
60~65: 배열을 단순출력해주는 메소드

-추가개념-

객체의 정렬 기준을 명시하는데는 두가지 방법이 존재.
1. Interface Comparable을 구현 하는 방법
기본 정렬로 문제를 해결할 경우 이용
2. Interface Comparator을 구현 하는 방법(글에서 사용한 방법)
기본 정렬 기준과 다르게 구현하고 싶을때 이용

Compareator를 implements후 compare메소드를 오버라이딩 할시 유의사항.
public int compare(Interval o1, Interval o2) 에서 
- 기존에 o1 , o2(오름차순) 순서로 정렬할 것이라고 생각. 
- 만약 , compare 의 반환 값이 양수or 0이면 , 인자의 순서변경발생
- compare 의 반환 값이 음수이면 , 인자 순서 유지
- 위 3가지 개념을 이용해 사용자정의 정렬이 가능.


- ex) start를 기준으로 , 내림차순정렬을 만들어보자
 public int compare(Interval o1, Interval o2){
     if( o1.start < o2.start )
          return 0;
     else
          return -1;
}
같은 표현으로
 public int compare(Interval o1, Interval o2){
     if( o1.start > o2.start )
          return -1;
     else
          return 0;
}
-출력결과-
start 의 기존순서 : 15, 0, 5, 10, 2 
변경된 순서 : 15 , 10 , 5 ,2, 0 으로

 

-마침글-

인용

'21년이전 > 자바-Algorithm' 카테고리의 다른 글

DailyTemperature  (0) 2021.03.24
TwoSum  (0) 2021.03.22
MoveZeros  (0) 2021.03.21

+ Recent posts