반응형

배운것 

1. stream 연습~~

- stream은  util에서 퉁치면 안되고 따로 import 해줘야한다.

import java.util.*;
import java.util.stream.*;

 

- distinct() 사용

요소의 중복을 제거.

리턴 타입 : Stream, IntStream, LongStream, DoubleStream 

public class DistinctExample {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 3}; // int[] 배열

        // int[]에서 중복을 제거하고 List<Integer>로 변환
        List<Integer> distinctList = Arrays.stream(nums) // int[]에서 IntStream으로 변환
            .distinct() // 중복 제거
            .boxed() // int를 Integer로 변환
            .collect(Collectors.toList()); // List<Integer>로 수집

        System.out.println(distinctList); // [1, 2, 3] 출력
    }
}

 

- filter() 사용

매개값으로 주어진 Predicate가 true를 리턴하는 요소만 필터링

List<String> nameList = reportList
                                .stream()
                                .filter(rep -> rep.startsWith(id+" "))
                                .map(repp -> repp.split(" ")[1])
                                .collect(Collectors.toList());

 

- count() 사용

요소 개수 반환 

리턴타입 : long

long cnt = nameList
                .stream()
                .filter(reportee -> reporteeCount.getOrDefault(reportee,0) >= k)
                .count();

 

 

2. startsWith(), endsWith()  사용해봄

써본적이 없는데 써봤다.

boolean startsWith(String str)
boolean endsWith(String str)

 

 

두번째 다른방법으로 풀기

다른사람 답안을 보면서 따라해봤다.

제일 오래걸린 시간 : 테스트3 (6000.64ms, 555MB)

뭐야 더오래걸림

report 길이가  1 ~ 200,000 인데 아무리 중복을 제거했어도 두번돌아서 그런가

import java.util.*;
import java.util.stream.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        //1. report에서 중복을 제거
        List<String> reportList = Arrays.stream(report)
            .distinct()
            .collect(Collectors.toList());
        
        //2. id별로 신고당한 횟수를 누적한다.
        HashMap<String,Integer> reporteeCount = new HashMap<>();
        for(String rep : reportList){
            String reportee = rep.split(" ")[1];
            int cnt = reporteeCount.getOrDefault(reportee,0);
            reporteeCount.put(reportee,cnt+1);
        }
        
        //3. id 돌면서 메일 횟수 카운트
        int[] answer = new int[id_list.length];
        answer = Arrays.stream(id_list)
            .mapToInt(id ->{ //id별 처리
                //사용자가 신고한 리스트
                List<String> nameList = reportList
                                .stream()
                                .filter(rep -> rep.startsWith(id+" ")) //비슷한 이름 방지
                                .map(repp -> repp.split(" ")[1])
                                .collect(Collectors.toList());
                
                //사용자가 신고한 리스트에서 k 가 넘는 요소의 개수 산출
                long cnt = nameList.stream()
                                    .filter(reportee -> reporteeCount.getOrDefault(reportee,0) >= k)
                                    .count();
                return (int)cnt;
                }).toArray();

        return answer;  
    }  
}

 

 

 

 

첫번째 풀었던 것

제일 오래걸린시간 : 테스트21 (311.44ms, 164MB)

import java.util.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        HashMap<String,Set<String>> reporterList = new HashMap<>();
        for(String rep : report){
            String reporter = rep.split(" ")[0]; //신고한사람 muzi
            String reportee = rep.split(" ")[1]; //신고당한사람 frodo
            
            //ID당 유저가 신고한 ID들
            Set<String> temp = reporterList.getOrDefault(reporter,new HashSet<String>());
            temp.add(reportee);
            reporterList.put(reporter,temp);        
        }
        
        //신고당한 id별로 횟수 정리
        HashMap<String,Integer> reporteeCount = new HashMap<>();
        Collection<Set<String>> reportees = reporterList.values();
        //ArrayList<String> bannedIds = new ArrayList<>(); //정지된 id
        for(Set<String> list : reportees){
            for(String name : list){
                int cnt = reporteeCount.getOrDefault(name,0);
                reporteeCount.put(name,cnt+1);
                //if(cnt >= k) bannedIds.add(name);
            }
        }
        
        int[] answer = new int[id_list.length];
        //정지된 신고 리스트 id가 정지되었나 검사
        for(int i=0; i<id_list.length;i++){
            String id = id_list[i];
            Set<String> reportList = reporterList.getOrDefault(id,new HashSet<String>());
            int mailCnt = 0;
            //신고 리스트에 있는 아이디가 정지되었나 검사
            for(String reportee : reportList){
                if(reporteeCount.getOrDefault(reportee,0) >= k ){
                    mailCnt += 1;
                }
            }
            answer[i] = mailCnt;
        }
        
      
        return answer;
    }
    

    

}

//사용자 누적 신고 횟수 k번 이상시 
//동일 유저에 대한 신고 횟수 중복제거 어떻게
//신고자에게 메일

//1. report 돌면서 id별로 누구를 신고했는지 정리(중복x) HashMap<String,Set<>>;
    //예 "muzi" <frodo, apeach>
//2. HashMap 돌면서 id별 신고당한 누적횟수 정리 HashMap, 3회 이상인경우 arraylist에 추가
    //예 "muzi", 3   ["muzi","frodo"]
//3. id list 돌면서 신고list꺼내서 배열에 있는지 확인하여 메일 횟수 ++

 

 

 

반응형
반응형

조건에 맞는걸 중간부터 찾으려고 했음 -> 넘 어려움

배열이 주어지면 배열을 앞에나 뒤부터 순회하는게 젤 나은듯

import java.util.*;

class Solution {
    public int solution(int[] citations) {
        int h = citations.length;
        Arrays.sort(citations);
        
        /*배열 순회하기
        for(int c : citations){
            if(c >= h){
                return h;
            }else{
                h -= 1;
            }
        }
        return h;
        */
        
        //길이기준 순회
        int index = 0;
        for(int i=h;i>0;i--){
            if(citations[index] >= i){
                return i;
            }else{
                index +=1;
            }
        }
        return 0;

    }
}
//,0,0]
//h=3 index=0;
//h=2 index 1;
//h=1

//길이 7 
//[1,2,3,5,6,7,8]
//뒤에부터 
//h = 7 일때 index[0] 1 의 값이 7이상이냐? 
//h = 6 일때 index[1] 2 의 값이 6이상이냐?
//h = 5 일때 index[2] 3 의 값이 5 이상이냐?
//h= 4 일때 index[3] 5의 값이 4 이상이냐? -> h반환

//index[0] 일때 h=len index[]의 값이 h 이상이냐?
//index[1]일때 h= len-1

//배열 -> 배열기준순회
반응형
반응형

개선할점

- 반복문 쓸 때 길이조건 변수 헷갈리지 말고 제대로 좀 넣어야한다.

- char 타입데이터에 int 더하면 int 나오니까 (char) 형변환 

class Solution {
    public String solution(String s, String skip, int index) {
        StringBuilder result = new StringBuilder();
        for(int i=0;i<s.length();i++){
           result.append(getAlphabet(s.charAt(i),skip,index));
        }
        return result.toString();
    }
    
    //index만큼 뒤에 있는 알파벳 찾기. skip에 있는거 빼고.
    public String getAlphabet(char c, String skip, int index){ 
        int count = 0 ;
        char standardChar = c; //standardChar = 'x' , count 4 
        while(true){
            char nextChar = standardChar == 'z' ?  'a' : (char)(standardChar + 1);//y
            standardChar = nextChar; //y
            //skip에 없으면
            if(skip.indexOf(Character.toString(nextChar)) == -1){
                count += 1;
            }
            
            if(count == index){
                break;
            }
        }
        
        return Character.toString(standardChar);
    }
}



//charAt(i) 문자 +1반복.. count index만큼 채울때까지..
//기준문자는 계속 바꾼다 
//문자가 z라면.. a로바꾸고..
반응형
반응형

개선할점

HashMap 초기화 하지 않고 put 메서드 호출하려 하면 nullPointException 나므로 조심.

메서드 나누니까 편하긴 하다

import java.util.*;
class Solution {
    String mainHand;
    int[] leftPosition = {1,4};
    int[] rightPosition = {3,4};
    HashMap<Integer,int[]> phone = new HashMap<>();
    
    public String solution(int[] numbers, String hand) {
        mainHand = hand.equals("right")? "R" : "L";
        phone.put(1,new int[]{1,1});
        phone.put(2,new int[]{2,1});
        phone.put(3,new int[]{3,1});
        phone.put(4,new int[]{1,2});
        phone.put(5,new int[]{2,2});
        phone.put(6,new int[]{3,2});
        phone.put(7,new int[]{1,3});
        phone.put(8,new int[]{2,3});
        phone.put(9,new int[]{3,3});
        phone.put(0,new int[]{2,4});
        
        StringBuilder answer = new StringBuilder();
        for(int i=0;i<numbers.length;i++){
            answer.append(getHand(numbers[i]));
        }
       
        return answer.toString();
    }
    
    
    //어느 손으로 누를지 계산 -> 현재위치 이동하기
    public String getHand(int num){
        String leftOrRight = switch(num){
                case 1,4,7 -> "L";
                case 3,6,9 -> "R";
                case 2,5,8,0 -> whenMiddle(num);
                default -> mainHand;
        };
        //손 이동하기 
        makePosition(num,leftOrRight);
        
        return leftOrRight;
    }
        
    //가운데일때 어느손으로 누를지 계산
    public String whenMiddle(int num){
        int[] numPosition = phone.get(num);
        int leftHandDistance = Math.abs(leftPosition[0]-numPosition[0])
                            + Math.abs(leftPosition[1]-numPosition[1]);
        int rightHandDistance = Math.abs(rightPosition[0]-numPosition[0])
                            + Math.abs(rightPosition[1]-numPosition[1]);
    
        if(leftHandDistance == rightHandDistance){
            return mainHand;
        }else if(leftHandDistance  < rightHandDistance){
            return "L";
        }else{
            return "R";
        }
    }
    
    //현재위치 이동하기    //누를 숫자   //누를 손
    public void makePosition(int num, String whatHand){
        if(whatHand.equals("L")){
            leftPosition = phone.get(num);
        }else{
            rightPosition = phone.get(num);
        }
    }
}

//현재위치 [1,3],[2,4]이렇게
//현재위치 lefthand=4   1->1, 4->2, 7->3, *->4
//현재위치 righthand=4  3->1, 6->2, 9->3, #->4
//숫자가 1,4,7이면 -> L 
//숫자가 3,6,9이면 -> R 
//숫자가 2,5,8,0이면 2->1, 5->2, 8->3, 0->4 로 해서 가까운걸로 같으면 hand 참고
//가운데 누르고 난뒤
반응형
반응형

틀린 이유

1. substring(start, end) 인덱스 헷갈림

//i부터 맨뒤까지 모두 자르기
str.substring(i);
str.substring(i,str.length);

//end보다 하나 전까지 가져옴

2. 오류파악 String index out of range: 0 

-> index0 도 없다는건 길이가 0이라는것. substring 결과의 길이가 0일때의 케이스 고려를 안 함

반응형
반응형

배열 정렬

Arrays.sort();

배열 비교

Arrays.mismatch();

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        Arrays.sort(participant);
        Arrays.sort(completion);
        int mismatchIndex = Arrays.mismatch(participant,completion);
        return participant[mismatchIndex];
        
    }
}

 

다른방법

맵의 key-value에 접근하는법

Set<Map.Entry<String, Integer>> entrySet = map.entrySet();

 

맵의 모든 key 가져오기

 Set<String> keys = map.keySet();

 

맵의 모든 value 가져오기

Collection<String> values = map.values();

 

 

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        HashMap<String,Integer> particimap = new HashMap<>();
        for(String name : participant){
            int cnt = particimap.getOrDefault(name,0);
            particimap.put(name,++cnt);
        }
        
        for(String name : completion){
            int cnt = particimap.get(name);
            particimap.put(name,--cnt);
        }
        
        return particimap.entrySet()
            .stream()
            .filter(entry -> entry.getValue() >0)
            .map(Map.Entry::getKey)
            .findFirst()
            .orElse("없음");
    }
}

 

 

반응형

'코딩 관련 > 코딩문제풀기' 카테고리의 다른 글

[프로그래머스] 키패드 누르기  (0) 2024.10.09
[프로그래머스] 문자열 나누기  (0) 2024.10.06
[프로그래머스] 숫자 짝꿍  (0) 2024.10.04
[JAVA] 9012번 괄호  (0) 2023.03.13
[JAVA] 너의 평점은  (0) 2023.03.12
반응형

개선사항

1. 두 정수 비교시 for문 보다는 Math.min() 사용하기

2. String 에서 문자 하나 추출시 substring(i,i-1) 보다는 charAt() 사용하기

3. char 을 정수형으로 변환

//1.'0'빼기. '0'의 ASCII값 : 48
int text1 = '1';
int num1 = text1 - '0';

//2. Character.getNumericValue() 
int text2 = '1';
int num2 = Character.getNumericValue(text2);
반응형

'코딩 관련 > 코딩문제풀기' 카테고리의 다른 글

[프로그래머스] 문자열 나누기  (0) 2024.10.06
[프로그래머스] 완주하지 못한 선수  (0) 2024.10.04
[JAVA] 9012번 괄호  (0) 2023.03.13
[JAVA] 너의 평점은  (0) 2023.03.12
[JAVA] 그룹 단어 체커  (0) 2023.03.12
반응형

https://www.acmicpc.net/problem/9012

import java.util.Scanner;
import java.util.Stack;

public class MyClass {
    public static void main(String args[]) throws Exception {
        Scanner sc = new Scanner(System.in);
        int testcase = Integer.parseInt(sc.nextLine()); //case 수

	for(int i = 1; i <= testcase ; i++){
            String line = sc.nextLine();
            Stack<Character> stack = new Stack<>();
                for(int c = 0;c<line.length();c++){
                    //여는 괄호
                    if('(' == line.charAt(c)){
                       stack.push(line.charAt(c));
                    }else{
                    //닫는괄호
                        if(stack.empty()){
                            System.out.println("NO");
                            break;
                        }else{
                            stack.pop();
                        }
                       
                    }
                    
                    if(c==line.length()-1){
                        if (stack.empty()) {
			                System.out.println("YES");
	                   	}else{
	                   	    System.out.println("NO");
	                   	}
                    }
                    
                }
              
        }
    }
}

 

* 학습내용

1. String과 char의 비교

- char은 ''를 사용

- String은 ""를 사용

- str.equals(String.valueOf(ch))

- 그냥 '' == ch 해서 char끼리 비교하자...

 

2. Stack 타입 변수 사용

- 스택 선언하기 :  Stack<> stack = new Stack<>();

- push(), pop(), empty()

 

3. 메모리 사용 영역

JVM이 시작되면 JVM은 운영체제에서 할당받은 메모리 영역을 다음과 같이 세부 영역으로 구분해서 사용한다.

1) Method 영역

- 클래스별로 런타임 상수풀, 필드 데이터, 메소드 데이터, 메소드 코드, 생성자 코드 등을 분류하여 저장한다.

2) Heap 영역

- 객체와 배열이 생성되는 영역

- 생성된 객체/배열을 참조하는 변수나 필드가 없다면 Garbage Collector를 실행시켜 힙 영역에서 자동으로 제거한다.

3) JVM Stack 영역

- 각 스레드가 시작될 때 할당된다.

- 메소드를 호출할 때마다 프레임(메소드의 변수 및 기타 부가정보로 이루어짐)을 push 하고 메소드가 종료되면 pop 하는 동작을 수행함.

- 프레임 내부에는 로컬 변수 스택이 있는데, 최초로 변수에 값이 저장될 때 생성됨.

- 기본 타입 변수는 스택영역에 직접 값을 가짐

- 참조 타입 변수는 값이 아니라 객체 주소를 가짐.

반응형
반응형

https://www.acmicpc.net/problem/25206

 

25206번: 너의 평점은

인하대학교 컴퓨터공학과를 졸업하기 위해서는, 전공평점이 3.3 이상이거나 졸업고사를 통과해야 한다. 그런데 아뿔싸, 치훈이는 깜빡하고 졸업고사를 응시하지 않았다는 사실을 깨달았다! 치

www.acmicpc.net

 

import java.util.Scanner;
import java.util.HashMap;

public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        
        HashMap<String,Double> pointMap = new HashMap<String,Double>();
        pointMap.put("A+",4.5);
        pointMap.put("A0",4.0);
        pointMap.put("B+",3.5);
        pointMap.put("B0",3.0);
        pointMap.put("C+",2.5);
        pointMap.put("C0",2.0);
        pointMap.put("D+",1.5);
        pointMap.put("D0",1.0);
        pointMap.put("F",0.0);
        
        int creditSum=0; //이수학점  총합
        Double scoreSum=0.0; //합산점수
        
        while(sc.hasNextLine()){
            String line = sc.nextLine();
            Scanner lineScanner = new Scanner(line);
            //과목명은 패스
            lineScanner.next();
            
            Double credit = Double.parseDouble(lineScanner.next());
            String score =  lineScanner.next();
            
            Double point=0.0;
            
            //P 과목은 패스
            if(!"P".equals(score)){
                point = pointMap.get(score);
                //System.out.println("합산할 점수 : " + point * credit);
                scoreSum += point * credit;
                creditSum += credit;
            }
            
            lineScanner.close();
        }
        
        //System.out.println("이수학점 총합 : " + creditSum);
        //System.out.println("합산 점수 : " + scoreSum);
        if(creditSum == 0){//합산점수가 0인경우 평점 0.0 출력
            System.out.println("0.000000");
        }else{
            System.out.printf("%.6f",scoreSum/creditSum);
        }
        
    }
}

처음에 F인 과목까지 계산에서 제외해버려서 자꾸 틀렸다고 나왔었다..

P인 과목만 제외고 F점수는 포함

문제를 잘 이해해야겠다 ㅠ.,ㅠ

 

* 학습내용

1.  nextLine() : "\n" 개행문자도 입력 받는다.

next()다음에 nextLine()을 하면 개행문자가 들어간다.

hasNextLine도 마찬가지.

 

2. lineScanner() : 한 줄 입력받기. 처음 써봤다.

 

반응형

'코딩 관련 > 코딩문제풀기' 카테고리의 다른 글

[프로그래머스] 숫자 짝꿍  (0) 2024.10.04
[JAVA] 9012번 괄호  (0) 2023.03.13
[JAVA] 그룹 단어 체커  (0) 2023.03.12
[JAVA] 크로아티아 알파벳  (0) 2023.03.11
[JAVA] 직사각형에서 탈출  (0) 2023.03.09
반응형

https://www.acmicpc.net/problem/1316

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;

public class MyClass {
    public static void main(String args[]) {
      Scanner sc = new Scanner(System.in);
      int line = sc.nextInt();
      int cnt = 0 ; //그룹문자 카운트
      sc.nextLine(); //개행문자 때문에 넣음
       
      for(int l =1; l <= line ; l ++ ){
          String str = sc.nextLine();
          List<String> list = new ArrayList<String>();
          
          for(int i =0; i<str.length() ;i++){
              String now = str.substring(i,i+1);
              //리스트에 있는 경우 : 앞에서 문자를 넣었음
              if(list.contains(now)){
                  String before = str.substring(i-1,i);
                  //이미 있는 문자인데 현재문자 바로 앞이 다른 문자인 경우 -> 그룹단어 아님
                  if(!before.equals(now)){
                      break;
                  }
              //리스트에 없는 경우 : 처음 나온 문자
              }else{
                  list.add(now);
              }
              
              //그룹단어 검사 마지막 문자인 경우 -> 그룹단어이므로 카운트 
              if(i+1==str.length()){
                  cnt+=1;
              }
          }
          
      }
      System.out.println(cnt);
    }
}

 

* 학습내용

1. nextInt() : 사용자 입력의 가장 마지막 개행문자(엔터, newline)를 제거하지 않는다.

nextInt() 후에 바로 nextLine()을 사용하면 개행문자를 입력받게 된다.

 

2. charAt()

다음에는 substring말고 charAt을 쓰자

반응형

'코딩 관련 > 코딩문제풀기' 카테고리의 다른 글

[JAVA] 9012번 괄호  (0) 2023.03.13
[JAVA] 너의 평점은  (0) 2023.03.12
[JAVA] 크로아티아 알파벳  (0) 2023.03.11
[JAVA] 직사각형에서 탈출  (0) 2023.03.09
[JAVA] 4344번 평균은 넘겠지 문제  (0) 2023.03.09

+ Recent posts