[JAVA] 코딩테스트 유용한 코드 모음

[JAVA] 코딩테스트 유용한 코드 모음

 

 

형변환

- 형변환 정리 (String과 Stringbuilder/buffer는 똑같이 쓰이는 듯)

// int -> String
String str = String.valueOf(n);

// String -> int
int temp = Integer.parseInt(str);

// int -> char
char value_char  = (char) value_int;
char value_char = Character.forDigit(value_int , radix); // radix = 진수

// char -> int
int myInt = Character.getNumericValue(myChar);
int myInt = myChar - '0';

// long -> String
String str = String.valueOf(n);

// String -> long
long temp = Long.parselong(str);

// char -> String
String temp = String.valueOf(char);

// String -> char
char temp = str.charAt(i);

---

Math

- 제곱, 제곱근

if(Math.pow((int)Math.sqrt(n),2) == n) {
            return (int)Math.pow(Math.sqrt(n)+1,2);
            }

- 최솟값 최댓값

class Solution {
    public String solution(String s) {
        String answer = "";
        
        String[] numbers = s.split(" ");
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        
        for(int i = 0; i < numbers.length; i++){
            int number = Integer.parseInt(numbers[i]);
            
            min = Math.min(min, number);
            max = Math.max(max, number);
        }

        answer = min+ " " +max;
        return answer;
    }
}

---

Stirng

- index

char charAtIdx6 = str.charAt(6);
String stringAtIdx6 = Character.toString(characterAtIdx6)

-  substring

String str = "abcdefghijklmn";
String piece1 = str.substring(3);    // 3이후 전부
String piece2 = str.substring(3,7);  // 3~6
String piece3 = str.substring(3,4);  // 3하나

- 문자열 비교 : myString.equals(yourString)

String str1 = "Hello";
String str2 = "World";
String str3 = "Hello";

str1.equals(str2);  // false
str1.equals(str3);  // true

 

- toString(), valueOf() 차이

toString() :            null 값을 형 변환 시 NullPointerException(NPE)이 발생 / Object의 값이 String이 아니여도 출력
String.valueOf() : 파라미터로 null이 오면 "null"이라는 문자열을 출력

 

- char 숫자 문자 확인

Character.isDigit(a);          // 숫자 확인
Character.isLetter(a);         // 문자 확인
Character.isLetterOrDigit(a);  // 영어or숫자 확인

- 숫자 확인

for (int i=0;i<s.length();i++) {
            if (s.charAt(i) < '0' || s.charAt(i) > '9')
        }

- 알파벳 확인

for (int i=0;i<s.length();i++) {
            if (s.charAt(i) >= 'a' || s.charAt(i) <= 'z') 
        }

- contains

String str = "Character";
System.out.println(str.contains("h"));    // true false

- upper & lowercase

// String
String txt = "Hello World";
txt.toUpperCase();
txt.toLowerCase();

// char
Character.toUpperCase('a');
Character.toLowerCase('a');

- check upper & lowercase

// String
isStringUpperCase(strValue1);
isStringLowerCase(strValue1);

// char
Character.isUpperCase(myChar);
Character.isLowerCase(myChar);

- replace, replaceAll(1번링크), replaceFirst(2번링크)

  String result1 = str.replace("abc", "왕");
  String result2 = str.replaceAll("[abc]", "왕");
  String result3 = str.replaceFirst("abc", "왕);

관련 정규식 https://denodo1.tistory.com/216

 

- String, Array 관련

import java.util.*;
class Solution {
	public long solution(long n) {
		String[] list = String.valueOf(n).split(""); 
		Arrays.sort(list);  // 배열 정렬

		StringBuilder sb = new StringBuilder();
		for (String aList : list) sb.append(aList);       

		return Long.parseLong(sb.reverse().toString());
	}
}

* StringBuilder / StringBuffer : 새로운 문자열 객체를 계속 저장하는 기존 부하가 큰 String(불변) 방식과 다르게 기존 데이터에 더하는 방식

차이 : StringBuffer는 공통 메소드가 동기화되므로, 멀티 쓰레드 환경에서는 StringBuffer를 사용!

 

StringBuilder/Buffer 메서드 정리

sb.append(값)               // StringBuffer, StringBuilder 뒤에 값을 붙인다
sb.insert(인덱스, 값)         // 특정 인덱스부터 값을 삽입한다
sb.delete(인덱스, 인덱스)      // 특정 인덱스부터 인덱스까지 값을 삭제한다
sb.indexOf(값)              // 값이 어느 인덱스에 들어있는지 확인한다
sb.substring(인덱스, 인덱스)   // 인덱스부터 인덱스까지 값을 잘라온다
sb.length()                 // 길이 확인
sb.replace(인덱스, 인덱스, 값)  // 인덱스부터 인덱스까지 값으로 변경
sb.reverse()                // 글자 순서를 뒤집는다

 

* String의 concat (문자열 이어붙이기) 도 있지만 새로 객체 생성하는 방식임

String strSample1 = "Hello";
String strSample2 = "World";
String result1 = strSample1 + strSample2;
String result2 = strSample1.concat(strSample2);

* 반면에 StringBuilder의 append

StringBuilder result3 = new StringBuilder();
result3.append(strSample1);
result3.append(strSample2);

*

String->StringBuilder 변환

StringBuilder -> String 변환

StringBuilder sb = new StringBuilder(newStr); // String -> StringBuilder
String str = newSb.toString();                // StringBuilder -> String

 

참고 코드

import java.util.*;

class Solution {
    public String solution(String s) {
        String answer = "";
        char[] chararr = s.toCharArray();
        Arrays.sort(chararr);
        
        String newStr = String.valueOf(chararr);
        
        StringBuilder sb = new StringBuilder(newStr);
        answer = sb.reverse().toString();
        return answer;
    }
}

---

배열

- 선언

1) 일반 배열

// 선언과 동시에 배열 크기 할당
int[] arr = new int[5];
String[] arr = new String[5];

2) ArrayList 

ArrayList list = new ArrayList();//타입 미설정 Object로 선언된다.
ArrayList<Student> members = new ArrayList<Student>();//타입설정 Student객체만 사용가능
ArrayList<Integer> num = new ArrayList<Integer>();//타입설정 int타입만 사용가능
ArrayList<Integer> num2 = new ArrayList<>();//new에서 타입 파라미터 생략가능
ArrayList<Integer> num3 = new ArrayList<Integer>(10);//초기 용량(capacity)지정
ArrayList<Integer> list2 = new ArrayList<Integer>(Arrays.asList(1,2,3));//생성시 값추가

 

- 요소 출력

1) 일반 배열 : Arrays.toString(arr)

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

2) ArrayList : Iterator로 출력!

Iterator iter = list.iterator();             //Iterator 선언 
while(iter.hasNext()){                       //다음값이 있는지 체크
    System.out.println(iter.next());         //값 출력
}

 

- 인덱스로 요소 얻어오기

1) 일반 배열 : 배열[인덱스]

2) ArrayList : 어레이리스트.get(인덱스)

 

- 요소로 인덱스 얻어오기

1) 일반배열

Arrays.asList(array).contains(value);

2) ArrayList

myList.indexOf("~") // 없으면 -1;

 

- 요소 추가

1) 일반 배열

  <a> 새로운 배열 =  Arrays.copyOf(배열, 추가할길이); 후 추가된 인덱스에 값 저장

String[] arr = {"a", "b", "c"};

String[] newArr = Arrays.copyOf(arr, arr.length + 2);

newArr[arr.length + 0] = "d";
newArr[arr.length + 1] = "e";

  <b> 추가된 길이만큼의 새 배열 선언 후 System.arraycopy(원래 배열, 0, 새로운 배열, 0, 배열길이);

String[] arr = {"a", "b", "c"};

String[] newArr = new String[arr.length + 2];
System.arraycopy(arr, 0, newArr, 0, arr.length);

newArr[arr.length + 0] = "d";
newArr[arr.length + 1] = "e";

  <c> ArrayList 선언 후 list.add 메서드를 통해 값 저장하고 |  새로운 배열 = list.toArray(new String[0]); 다시 배열로 만들어준다.

String[] arr = {"a", "b", "c"};

List<String> list = new ArrayList<>(Arrays.asList(arr));

list.add("d");
list.add("e");

String[] newArr = list.toArray(new String[0]);

특정 위치에 추가

fruits.add(0, "apple");

- 요소 삭제

ArrayList

// index 1 삭제
list.remove(1);

참고: https://hianna.tistory.com/564#:~:text=ArrayList%EC%9D%98%20remove()%20%EB%A9%94%EC%86%8C%EB%93%9C,ArrayList%EC%97%90%EC%84%9C%20%EC%82%AD%EC%A0%9C%ED%95%A0%20%EC%88%98%20%EC%9E%88%EC%8A%B5%EB%8B%88%EB%8B%A4.&text=remove()%20%EB%A9%94%EC%86%8C%EB%93%9C%EC%9D%98%20%ED%8C%8C%EB%9D%BC%EB%AF%B8%ED%84%B0,%EC%9D%98%20%EA%B0%92%EC%9D%B4%20%EC%82%AD%EC%A0%9C%EB%90%A9%EB%8B%88%EB%8B%A4. 

 

- 요소 포함

list.contains("hello"); // boolean 반환

 

- 길이/사이즈

1) 일반 배열   : arr.length  (  주의 String이 str.length()   ) 

2) ArrayList : list.size()

 

- 정렬

 

1) 일반 배열

int[] arr = {1, 26, 17, 25, 99, 44, 303};

Arrays.sort(arr);                             // 오름차순
Arrays.sort(tmp, Comparator.reverseOrder());  // 내림차순

 

예술)

import java.util.*;

class Solution {
  public String[] solution(String[] files) {

		Arrays.sort(files, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				
				String h1 = o1.split("[0-9]")[0];
				String h2 = o2.split("[0-9]")[0];
				
				int result = h1.toLowerCase().compareTo(h2.toLowerCase());

				if ( result == 0 ) {					
					// 문자열이 같은 경우 숫자를 비교한다.
					result = findNum(o1,h1)-findNum(o2,h2);
				}
				return result;
			}
		});
		return files;
  }
    
 private int findNum( String s, String h ) {		
		s = s.replace(h, "");		
		String result ="";		
		for( char c : s.toCharArray()) {
			if( Character.isDigit(c) && result.length() < 5 ) {
				result+=c;
			}else
				break;
		}
		return Integer.valueOf(result);
	}    
}

compareto 설명)https://mine-it-record.tistory.com/133

2) ArrayList

// 오름차순으로 정렬
Collections.sort(list);

// 내림차순으로 정렬
Collections.sort(list, Collections.reverseOrder());

// 대소문자 구분없이 오름차순
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

// 대소문자 구분없이 내림차순
Collections.sort(list, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER) );

 

- 변환 :    [ ArrayList -> 배열]     /      [배열 -> ArrayList]  

1) List -> 배열 (List의 toArray 사용)

String[] array = myList.toArray(new String[myList.size()]);

2) 배열 -> List (Array의 Arrays.asList 사용)

ArrayList<String> arrayList = new ArrayList<>(Arrays.asList(myArray));

* 주의 : Object 자료형일때만 변환 가능한듯

 

- 변환2 [String ->char 배열]  /   [char 배열 -> String]

1) String -> char 배열 : toCharArray 사용

char[] ch = phone_number.toCharArray();

2) char배열 -> String : valueOf(배열) 사용 

String newString = String.valueOf(ch);

 

---

HashMap

Map<String, Integer> hm = new HashMap<>();

- put

hm.put(key, value)

- getOrDefault

hm.getOrDefault(key, default)

-get

value = map.get(key)

- remove(key)

 

- put & getOrDefault

for (String p : participant) {
	hm.put(p, hm.getOrDefault(p, 0)+1);
}

- containsKey(key), containsValue(val)

 

- keySet & get

for (String key : hm.keySet()) {
	if (hm.get(key) != 0) {
    	answer = key;
        break;
    }
}

- 정렬  : https://codechacha.com/ko/java-sort-map/

https://ponyozzang.tistory.com/404

 

예시

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

class Solution {
    public int solution(String[][] clothes) {
        int answer = 1; //곱셈을 위해 1로 선언
        HashMap<String, Integer> clothesMap = new HashMap<String, Integer>();
        //map 구하기
        for(int i =0; i<clothes.length; i++){
        	//의상종류, 갯수
            clothesMap.put(clothes[i][1], clothesMap.getOrDefault(clothes[i][1], 0)+1);
        }
        //조합
        Set<String> keySet = clothesMap.keySet(); //의상종류.
        
        for(String key : keySet) {
        	answer *= clothesMap.get(key)+1; 
        }
        return answer-1; //아무것도 안입는 경우의 수 제거
    }
}

---

날짜

String str = "2020-10-10 10:10:10";
DateTimeFormatter fm = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDate local_date = LocalDate.parse(str, fm);

LocalDate date1 = LocalDate.of(2022, 1, 1);
LocalDate date2 = LocalDate.of(2022, 2, 1);
int result = date1.compareTo(date2);

System.out.println(result);

 

---

편리

- for문 돌면서 요소 쉽게 가져오기 

for(int item : arr) {
            if(item % divisor == 0) {
                lst1.add(item);
            }
        }

---

https://hbase.tistory.com/160

[Java] 정규표현식 사용법 및 예제 - Pattern, Matcher

자바 정규표현식 정리

 

-Greedy 

=> 최소의 개수를 정하는 경우 : 정렬 후 마지막 시간/위치를 기준으로 priority queue로 비교해주기

=> 개수는 정해져있고 최소의 값(차이)을 정하는 경우 : 차이를 순서대로 정렬해서 더해줌

---

중요한 예제 (프로그래머스 - 튜플)

import java.util.*;

class Solution {
    public int[] solution(String s) {
        
        String newString = s.replaceAll("[\\{\\}]", "");
        String newString2 = newString.replaceAll("[,]", " ");
        String strArr[] = newString.split(",");
        
        HashMap<String, Integer> hmap = new HashMap<String, Integer>();
        
        for(int i=0; i<strArr.length; i++){
            String tempStr = strArr[i];
            hmap.put(tempStr, hmap.getOrDefault(tempStr, 0)+1);
        }
        
        
        // Map.Entry 리스트 작성
		List<Map.Entry<String, Integer>> entList = new ArrayList<Map.Entry<String, Integer>>(hmap.entrySet());

		// 비교함수 Comparator를 사용하여 내림 차순으로 정렬
		Collections.sort(entList, new Comparator<Map.Entry<String, Integer>>() {
			// compare로 값을 비교
			public int compare(Map.Entry<String, Integer> obj1, Map.Entry<String, Integer> obj2)
			{
				// 내림 차순으로 정렬
				return obj2.getValue().compareTo(obj1.getValue());
			}
		});

        int[] answer = new int[entList.size()];
        int id = 0;
		// 결과 
		for(Map.Entry<String, Integer> entry : entList) {
			answer[id] = Integer.parseInt(entry.getKey());
            id++;
		}

        return answer;
    }
}

- replaceAll 정규식

- HashMap 정렬

---

자바 str1.startsWith(str2)

import java.util.Arrays;

class Solution {
    public boolean solution(String[] phoneBook) {
        // 1. phoneBook을 sorting한다.
        Arrays.sort(phoneBook);

        // 2. 1중 Loop을 돌며 앞 번호가 뒷 번호의 접두어인지 확인한다.
        for (int i = 0; i < phoneBook.length - 1; i++)
            if (phoneBook[i + 1].startsWith(phoneBook[i]))
                return false;
        
        // 3. 여기까지 오면 접두어가 없다는 것이다.
        return true;
    }
}

---

Priority Queue

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        Queue<Integer> list = new PriorityQueue<>(Collections.reverseOrder());

        // priority queue 생성
        for (int i : scoville) {
            pq.add(i);
        }

        while (true) {
            // 최소치를 넘은 경우 종료
            if (pq.peek() >= K) break;
			
            // 더 이상 섞을 수 없는 경우 -1 후 종료
            if (pq.size() == 1) {
                answer = -1;
                break;
            }
            
            // 2개를 뽑아 섞고 다시 삽입
            pq.add(pq.poll() + pq.poll() * 2);
            answer++;
        }
        
        return answer;
    }
}

사용법 : https://velog.io/@gillog/Java-Priority-Queue%EC%9A%B0%EC%84%A0-%EC%88%9C%EC%9C%84-%ED%81%90

---

조합 재귀함수로 구현 + Map.Entry 최대값 + ArrayList 정렬 (프로그래머스 메뉴 리뉴얼)

import java.util.*;
class Solution {
    
    static HashMap<String,Integer> map; 

    public static void combi(String ord, StringBuilder sb, int idx, int cnt, int cr){
       if(cnt == cr) {
           map.put(sb.toString(),map.getOrDefault(sb.toString(),0)+1);
           return;
        }
        
        for(int i = idx; i<ord.length(); i++){
            sb.append(ord.charAt(i));
            combi(ord,sb,i+1,cnt+1,cr);
            sb.delete(cnt,cnt+1);
        }
    }
    
    public ArrayList<String> solution(String[] orders, int[] course) {
        ArrayList<String> answer = new ArrayList<>();
        
        // 오름차순으로 변경
        for(int i =0;i<orders.length;i++){
            char[] charArr = orders[i].toCharArray();
            Arrays.sort(charArr);
            orders[i] = String.valueOf(charArr);
        }
        
        for(int cor : course){
            map = new HashMap<>();
            int max = Integer.MIN_VALUE;   
            for(String order : orders){
                StringBuilder sb = new StringBuilder(); 
                if(order.length() >= cor)
                    combi(order,sb,0,0,cor);                               
            }
            
            for(Map.Entry<String,Integer> entry : map.entrySet()){
                    max = Math.max(max,entry.getValue());
                   
            }
            for(Map.Entry<String,Integer> entry : map.entrySet()){
                    if(max >=2 && entry.getValue() == max)
                        answer.add(entry.getKey());
            }
        }
        Collections.sort(answer);
        
        return answer;
    }
}

 

 

Collections 배열 정렬 : https://www.daleseo.com/java-comparable-comparator/

 

 

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


Integer.parseInt(br.readLine());
StringTokenizer st = new StringTokenizer(br.readLine(), " ");

while(st.hasMoreTokens()){
  //nextToken()을 통해 띄어쓰기(" ")를 제거하고 남은 숫자를 스트링 형태에서 int로 형변환하여 arr에 저장. k++를 이용해 인덱스 증가
  aa = Integer.parseInt(st.nextToken());
}