반응형

1. 문제 번호 2738번


 

 

 

2. 문제 풀이 

 

 

 

한줄 평가

 - 기본에 충실하게 !!! 

 

 

 

문제를 먼저 정확히 파악

 

 - 두 행렬 A,B 가 있을때, 두 행렬 n*m을 더하는 프로그램 작성

  ( 오른손으로 왼쪽부터 오른쪽으로 부채를 그리면서 "행~렬 !!" 외치면서 외우면 잘 외워짐 ㅋㅋㅋㅋ

    가로는 행이고 세로는 열이니깐 : )  

 )

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

 

 

  1.  

 

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int h = Integer.parseInt(st.nextToken());
        int l = Integer.parseInt(st.nextToken());

        int[][] a = new int [h][l];
        int[][] b = new int [h][l];
        
        for(int i = 0; i < h; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < l; j++){
                a[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for(int i = 0; i < h; i++){
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < l; j++){
                b[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for(int i = 0; i < h; i++){
            for(int j = 0; j < l; j++){
                System.out.print(a[i][j] + b[i][j]);
                System.out.print(" ");
            }
            System.out.println();
        }
        
    }
}

 

 

 

- 실패 소스코드 -

 

 


4. 추가 개념

 

 

 

 

 

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 



728x90
반응형
반응형

1. 문제 번호 25206번


 

 

 

2. 문제 풀이

 

 

 

한줄 평가

 - 

 

 

 

문제를 먼저 정확히 파악

 

 - (학점 * 등급별 점수) / 학점

예시 ) 자바 프로그래밍 3.0 학점 A+, 파이썬 3.0 C0  

         ( (3.0*4.5)+(3.0*2.0) ) / 6 

         = 평균 3.25 

 

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

 

 

  1. Map 에 등급별 점수를 리스트
  2. 한 줄 입력시 누적하며 값들을 저장
  3. 총 계산 후 출력

 

 

 

난 이런게 더 쉽다..ㅠㅠㅜㅜ

어제 연인과 이런 대화를 했다. 모든건 상대적이고, 각자의 장단점이 다 다르다.

나에게는 지독하게 어려운게 누군가에는 당연하고 쉬울수도.. 😊

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Map<String, Double> gradeScoreMap = new HashMap<>();

        String[] grade = {"A+", "A0", "B+", "B0", "C+", "C0", "D+", "D0", "F"};
        Double[] gradeScore = {4.5, 4.0, 3.5, 3.0, 2.5, 2.0, 1.5, 1.0, 0.0};

        for (int i = 0; i < grade.length; i++) {
            gradeScoreMap.put(grade[i], gradeScore[i]);
        }

        String inputLine;

        double totalCredits = 0.0;
        double totalWeightedScores = 0.0;

        while ((inputLine = br.readLine()) != null) {
            String[] inputAry = inputLine.split(" ");
            double credits = Double.parseDouble(inputAry[1]);
            String gradeReceived = inputAry[2];

            if (!gradeReceived.equals("P")) {
                totalCredits += credits;
                if (gradeScoreMap.containsKey(gradeReceived)) {
                    totalWeightedScores += credits * gradeScoreMap.get(gradeReceived);
                }
            }
        }

        System.out.printf("%.6f%n", totalWeightedScores / totalCredits);
    }
}

 

 

 

- 실패 소스코드 -


더보기
import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        Map<String,Double> gradeScoreMap = new HashMap<>();
        
        String [] grade = {"A+","A0","B+","B0","C+","C0","D+","D0","F"};
        Double [] gradeScore = {4.5,4.0,3.5,3.0,2.5,2.0,1.5,1.0,0.0};

        for(int i = 0; i < grade.length; i++){
            gradeScoreMap.put(grade[i],gradeScore[i]);
        }

        String inputLine = null;

        int subjectCnt = 0;
        Double subjectCredit = 0.00; //학점
        Double subjectScore  = 0.00; //학점*등급점수
        
        while((inputLine=br.readLine())!=null){
            String [] inputAry = inputLine.split(" ");
            for(int i = 0; i < inputAry.length ; i++){
                subjectCnt += 1;
                subjectCredit += Double.valueOf(inputAry[1]);
                
                if(gradeScoreMap.containsKey(inputAry[2])){
                    subjectScore += Double.valueOf(inputAry[1]) * gradeScoreMap.get(inputAry[2]);
                };
                
            }
        }

        System.out.println((subjectScore)/subjectCredit);
        

        
    }
}

 

 


4. 추가 개념

'double' vs 'Double'

기본 데이터 타입(primitive type) vs 객체 데이터 타입 (Wrapper Class)
기본 메모리 타입이 메모리,성능 측면에서 효율적
객체 데이터 타입은 'null' 값을 가질 수 있다.

'Double.parseDouble(String)' -> 기본 데이터 타입 Convert
'Double.valueOf(String)' -> 객체 데이터 타입 Convert  

 

'.equals' vs '=='

'==' 객체에서는 동일 주소를 비교
'.equals' 는 객체 타입에서 값을 비교

 

 

 

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

 

728x90
반응형
반응형

1. 문제 번호 1316번


 

 

 

2. 문제 풀이 (한줄 평가)

 - 핵심은 n 과 n-1을 비교하여야 연속됌을 판단할 수 있음  

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

문제를 먼저 정확히 파악 

new          -> 모두 단어가 1번 사용됌

vvba         -> 모두 단어가 1번 사용됌 (v 연속적인 단어는 인정)

aba           -> a가 연속적이지 않고 2번 사용됌 (X)

bbab         -> b가 연속적이였지만 끝에 사용되어 2번 사용됌(X)

abbbbba   -> (X)

 

  1. 첫 번째 방법 
    1. 각 영 단어 26개 배열에 True,False를 넣어둔다.
    2. 단어(abbbba)의 첫 번째 index는 해당 단어는 사용되었으니 True
    3. 단어(abbbba)의 두 번째 index와 첫 번째 index를 비교하여 값이 동일하면 pass / 다르면 해당 단어에 True
    4. 단어(abbbba)의 여섯 번째 index와 다섯 번째 index를 비교하여 값이 다르니 해당 단어에 True
      1. 근데 이미 a는 True가 있으니 이것은 그룹 단어가 아니다. !!! 
  2. 두 번째 방법
    1. 단어(abbbba)의 중복을 제거한 문자를 추출
    2. 중복 제거한 문자의 index를 전체 뽑는다.
    3. index값이 인접한 값인지 recursive하여 확인

 

 

여전히 어렵다...정답비율이 이렇게 높아...?

손으로 움직이기 전 규칙이나 반례, 설계부터 긴 시간을 들여서 고민하고 손 코딩하고 움직여야겠다..😊

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int inputCnt = Integer.parseInt(br.readLine());
        int groupWordCnt = 0;

        for(int i = 0; i < inputCnt; i++){
            String inputLine = br.readLine();
            boolean [] alphabet = new boolean[26];
//            Arrays.fill(alphabet,false);
            boolean isGroupWord = true;
            
            for(int j = 0; j < inputLine.length(); j++){
                char currentChar = inputLine.charAt(j);
                
                if (j > 0 && alphabet[currentChar-'a'] && currentChar != inputLine.charAt(j-1)){
                    isGroupWord = false;
                    break;    
                }
                alphabet[currentChar-'a'] = true;
            }
            if(isGroupWord){
                groupWordCnt++;    
            }
        }
        System.out.println(groupWordCnt);

    }
}

 

 

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int inputCnt = Integer.parseInt(br.readLine());
        int groupWordCnt = 0;

        for (int i = 0; i < inputCnt; i++){
            String inputLine = br.readLine();
            String dis_inputLine = "";
            
            Map<Character,List<Integer>> indexesMap = new HashMap<>();

            /* 방법 1. 중복제거 */
            for(int j = 0; j < inputLine.length(); j++){
                if(inputLine.indexOf(inputLine.charAt(j)) == j ){
                    dis_inputLine += inputLine.charAt(j);
                }
            }
            /* 방법 2. 중복제거 */
            // Set<Character> set = new HashSet<>();
            // for (int j = 0; j < inputLine.length(); j++){
            //     char c = inputLine.charAt(j);

            //     if (!set.contains(c)){
            //         dis_inputLine += c;
            //     }
            // }

            /* 방법 1. 포함여부 확인 */
            inputLine.contains(dis_inputLine);
            /* 방법 1. 일치여부 확인 */
            inputLine.equals(dis_inputLine);
            
            /*방법 3. 중복 제거 후 HashMap Insert */
            // for(int j = 0; j < inputLine.length(); j++){
            //     if(inputLine.indexOf(inputLine.charAt(j)) == j ){
            //         indexesMap.put(inputLine.charAt(j),new ArrayList<>());
            //     }
            // }
            
            /* 중복을 제거한 key를 삽입 */
            for (int j = 0; j < dis_inputLine.length(); j++){
                indexesMap.put(dis_inputLine.charAt(j), new ArrayList<>());
            }
            /* 
            a : 1,2,3 b : 4,5,6 
            중복을 제거한 Key와 기존의 데이터를 비교하여 
            포함되는 index 삽입 
            */
            for (int j = 0; j < inputLine.length(); j++){
                char currentChar = inputLine.charAt(j);
                if(indexesMap.containsKey(currentChar)){
                    indexesMap.get(currentChar).add(j);
                }
            }
            
            
            // Set<String> keySet = indexesMap.keySet();
            // char[] keyAry = keySet.toCharArray(new Character[0]);
            
            //또는 for(char c : keyAry) 가능
            for(char c : dis_inputLine.toCharArray()){ 
                List<Integer> indexes = indexesMap.get(c);
                if(isConsecutive(indexes)){
                    groupWordCnt +=1;
                } else {
                    groupWordCnt = 0;
                }
            }
            System.out.println(groupWordCnt);

        }

    }
    public static boolean isConsecutive(List<Integer> indexes){
        for (int i = 1; i < indexes.size(); i++){
            if(indexes.get(i) != indexes.get(i-1) +1 ){
                return false;
            }
        }
        return true;
    }
}

 

 

- 실패 소스코드 -




4. 추가 개념

 

 

 

 

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

728x90
반응형
반응형

1. 문제 번호 2941번


 

 

 

2. 문제 풀이 

 

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

 1. 어렵다...

     replace할까? 까지 생각했는데 어떻게 리스트화해서 replace하지? 라고 생각하다가 포기

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        
        String[] croatianAlphabets = { "c=", "c-", "dz=", "d-", "lj", "nj", "s=", "z=" };

        for (String alphabet : croatianAlphabets){
            input = input.replace(alphabet," ");
        }

        /***************************************************************
        
         * Content         : '.' vs '()' 
                             
                             '.' 연산자는 객체의 필드나 메서드에 접근할 때 사용
                             즉 특정 객체의 멤버에 접근하거나 메서드를 호출할 때 사용
                             
                             input.length() : input 객체의 length() 메서드에 접근하여 호출
                             System.out.print() : System클래스의 out 필드에 접근, println 메서드를 호출

                             '()' 괄호는 메서드를 호출할 때 사용
                             
        
        ****************************************************************/
        System.out.println(input.length());
    }
}

 

 

 

 

- 실패 소스코드 -




4. 추가 개념

 

 

' . ' vs ' ( ) '


' . '  연산자
객체의 필드나 메서드에 접근할 때 사용
(※즉 특정 객체의 멤버에 접근하거나 메서드를 호출할 때 사용)


' ( ) ' 연산자
메서드를 호출할 때 사용

String.length()   : String 객체의 length() 메서드에 접근하여 호출
System.out.print() : System클래스의 out필드 접근, print 메서드 호출

 

 

Q.  inputLine.length() 에서 inputLine에 메소드 length()를 안만들었는데 어떻게 되지..?

A.  String Class에서 Java 표준 라이브러리에 포함되어 있기 때문에 사용 가능하다. (음..당연한 이야기 이지만 의문을 가져야 보이지 )


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

728x90
반응형
반응형

 

 

 

Collection Framework Hierarchy in java

 

 

 목차 

1. Map 키워드 설명
  1.1. HashMap
  1.2. HashTable
  1.3. LinkedHashTable
  1.4. TreeMap설명

2. HashMap 사용법
   2.1 선언
   2.2 CRUD
   2.3 출력 및 참고 메소드

3. HashTable 사용법
   3.1 선언
   3.2 CRUD
   3.3 출력 및 참고 메소드

4. LinkedHashTable 사용법
   4.1 선언
   4.2 CRUD
   4.3 출력 및 참고 메소드

5. TreeMap 사용법
   5.1 선언
   5.2 CRUD
   5.3 출력 및 참고 메소드

 

Interface, Class

  • 인터페이스란 직접 인스턴스를 구성할 수 없으며 Class와 같은 구체적인 클래스로 인스턴스를 생성 해야함.

 

Extends, Implements

  • -

 Map 키워드 설명 

  •  Map
    • Map은 Interface 로 <Key, Value>를 으로 저장하고 관리하는 데이터 구조
    • Key는 저장 순서를 보장하지 않고 중복도 허용하지 않는다. (=Set 과 동일)
    • <Key,Value> 모두 객체로 사용
    • Map 인터페이스는 범용적이라서, 구체적인 구현 클래스를 나중에 변경 가능
    • Map은 직접 인스턴스를 생성할 수 없다.
    • 주요 클래스는 HashTable, LinkedHashTable, HashMap, TreeMap

 

/* Map 유연성 및 의존성을 낮춰준다.  */ 
Map<Character, Integer> alphabetCount = new HashMap<Character, Integer>();

/* HashMap 구체화  */ 
HashMap<String, Object> alphabetCount = new HashMap<String, Object>();

/* 내가 선호하는 방법 */ 
Map<String, Object> alphabetCount = new HashMap<>();

 

 


 

  • HashMap
    • 데이터의 추가,삭제,검색속도가 빠르고 순서가 중요하지 않는 경우에 사용
    • 해시 충돌이 발생할 우려 존재 (추후 정리)
    • <Key, Value>가 바로 매핑되지 않고 해시 키를 해시코드로 변환하여 데이터를 저장하고 검색
    • 멀티스레드 환경에서 부적합 ( HashTable이 적합)
      • 동시에 HashMap을 건드리면 Key-value값이 문제가 된다.

 


 

  • HashTable
    • <Key, Value>가 바로 매핑되지 않고 해시 함수를 통해 해시 값을 생성하여 주소값처럼 사용해 검색에 용이하게 만듬
    • 멀티스레드 환경에서 적합 ( HashMap이 부적합 )
      • 동시에 HashMap을 건드리면 Key-value값이 문제가 된다.
    • 동기화를 보장

 


  • LinkedHashTable
    • 데이터의 추가된 순서를 보존하고자 할때 사용

 

 


 

  • TreeMap
    • 순서가 중요하고 정렬된 데이터 유지 필요시 사용 
    • Key를 기준으로 정렬이 되어 있다. (binary search tree) 
      • 정렬 기준은 이진 트리 기반
        • 이진트리란
          • 2가지의 길 밖에 없으니 크면 오른쪽 작으면 왼쪽 으로 움직여 자리를 찾아가는 기법
          • 장점은 추가,제거에 속도가 빠르다.

 


 HashMap 사용법 

Step1.선언

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

Map<Object,Object> map = new HashMap<>(); 
Map<Object,Object> map = new HashMap<>(10);//초기 용량(capacity)지정

Map<Object,Object> map = new HashMap<>(map);


Map<Object,Object> map = new HashMap<>(10, 0.7f);//초기 capacity,load factor지정

Map<Object,Object> map = new HashMap<String,String>(){{//초기값 지정
    put("a","b");
}};
더보기

/*
 * Method  : HashMap()
 * Explain : HashMap객체 생성
 */
HashMap<String,Integer> map = new HashMap<String, Integer>();
Map<String, Integer>    map = new HashMap<String, Integer>();

/*
 * Method  : HashMap(int initlalCapacity)
 * Explain : 초기 용량
 */
Map<Object,Object> map = new HashMap<>(); 
Map<Object,Object> map = new HashMap<>(10);//초기 용량(capacity)지정

/*
 * Method  : HashMap(Map m) 
 * Explain : Map에 저장된 모든 요소를 포함하는 HashMap을 생성. 
 */
Map<Object,Object> map = new HashMap<>(map);

/*
 * Method  : HashMap(int initlalCapacity, float loadFactory) 
 * Explain : loadFactory 은 해시맵의 버킷 비율이 값만큼 채워지면 리사이징 작업을 해 해시 충돌 최소화.
   로드 팩터를 높이면 메모리 사용량은 줄지만, 충돌 가능성이 높다.
 */
Map<Object,Object> map = new HashMap<>(10, 0.7f);//초기 capacity,load factor지정


Map<Object,Object> map = new HashMap<String,String>(){{//초기값 지정
    put("a","b");
}};

 

Step2. CRUD 

Map<String, Integer> map = new HashMap<String, Integer>();
 
map.put("A", 1);
map.put("B", 1);

map.put("A", 100); //최종값으로 업데이트
map.put("A", map.get("A") -99); //업데이트 방법
map.replace("A",50); 

map.get("A");

map.remove("A");

map.clear();

 

더보기

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

/*
 * Method  : Object put(Object Key, Object Value)
 * Explain : 값 생성 및 업데이트
 */
 
map.put("A", 1);
map.put("B", 1);

map.put("A", 100); //최종값으로 업데이트
map.put("A", map.get("A") -99); //업데이트 방법
map.replace("A",50); 


/*
 * Method  : Object get(Object Key)
 * Explain : 값 읽기
 */

map.get("A");


/*
 * Method  : Object remove(Object Key)
 * Explain : 값 삭제
 */

map.remove("A");

/*
 * Method  : void clear()
 * Explain : 객체 모두 삭제
 */

map.clear();

Step3.  그외 참조할 코드 

map.size();
map.isEmpty(); 

map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

boolean containsKey(Object Key)
boolean containsValue(Object Value)
map.containsKey("B"); //true
map.containsValue(4); //false

 

값 출력은 entrySet(), KeySet(), Iterator 등

Iterator은 자바의 컬렉션 프레임 워크에서 컬렉션에 저장되어 있는 요소들을 읽어오는 방법을 표준화 한 것
/******전체 출력*******/
/*
    KeySet() 활용
    HashMap에 저장된 모든 키를 Set으로 반환한다.
*/
Set<String> keyset = map.keySet(); 
System.out.println(keyset); // [A,B,C]

/*
    entrySet() 활용
    HashMap에 저장된 <Key,Value>값을 Entry(키,값을 결합)의 형태로 Set에 저장하여 반환
    Map.Entry<> 로 entrySet()이 반환하는 key,Value를 갖는 하나의 객체로 얻을 수 있다.
    전환 과정을 학습하기 위해서 번거롭게 한거임
*/
Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); 
for (Map.Entry<String, Integer> entry : entrySet) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}
/* 단순하게 */
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

/******요소 값 출력*******/
/*
    keySet() 활용
*/
for (String key : map.keySet()) {
    System.out.println(key + "=" + map.get(key));
}

/*
    entrySet() 활용
*/
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

/*
    keySet() 활용
*/
for (String key : map.keySet()) { 
    System.out.println(key + "=" + map.get(key));
}



// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
Iterator<String> keys = map.keySet().iterator();
while (keys.hasNext()) {
    String key = keys.next();
    System.out.println(key + "=" + map.get(key));
}

//HashMap에 넣은 key,Value를 Set에 넣고 iterator에 값으로 Set 정보를 넣는다.
//Interator itr = map.entrySet().interator() 와 같다.
Set<Map.Entry<String, Integer>> set = map.entrySet();
Iterator<Map.Entry<String, Integer>> itr = set.iterator();
while (itr.hasNext()) {
    Map.Entry<String, Integer> e = itr.next();
    System.out.println(e.getKey() + " : " + e.getValue());
}
/* 단순하게 */
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}


//entrySet().iterator()
Iterator<Entry<Integer, String>> entries = map.entrySet().iterator();
while(entries.hasNext()){
    Map.Entry<String, Integer> entry = entries.next();
    System.out.println(entry.getKey() + " : " + entry.getValue());
}
		
//keySet().iterator()
Iterator<String> keys = map.keySet().iterator();
while(keys.hasNext()){
    String key = keys.next();
    System.out.println(key + " : " + map.get(key));
}

 

 

 

 

 

 

 

TreeMap<Integer, String> tm = new TreeMap<Integer, String>();

// put() 메소드를 이용한 요소의 저장
tm.put(30, "삼십");
tm.put(10, "십");
tm.put(40, "사십");
tm.put(20, "이십");

// Enhanced for 문과 get() 메소드를 이용한 요소의 출력
System.out.println("맵에 저장된 키들의 집합 : " + tm.keySet());
for (Integer key : tm.keySet()) {
    System.out.println(String.format("키 : %s, 값 : %s", key, tm.get(key)));
}

// remove() 메소드를 이용한 요소의 제거
tm.remove(40);

// iterator() 메소드와 get() 메소드를 이용한 요소의 출력
Iterator<Integer> keys = tm.keySet().iterator();
while (keys.hasNext()) {
    Integer key = keys.next();
    System.out.println(String.format("키 : %s, 값 : %s", key, tm.get(key)));
}

// replace() 메소드를 이용한 요소의 수정
tm.replace(20, "twenty");


// size() 메소드를 이용한 요소의 총 개수
tm.size();

 

 

 

728x90
반응형
반응형

1. 문제 번호 1157번


 

 

 

2. 문제 풀이 

 

 

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

  1. HashMap
    1. 대문자로 치환
    2. 각 문자별로 개수를 확인하여 HashMap에 저장
    3. 최대값 추출하여 표현
      1. 최대값 추출은 반복문을 통한 방법
      2. Java Stream API를 사용

 

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new  InputStreamReader(System.in ));

        String inputLine = br.readLine().toUpperCase();
        int inputSize = inputLine.length();
        Map<Character, Integer> alphabetCnt = new HashMap<>(); //Map 인터페이스는 키와 값 모두 객체

        for(int i = 0; i < inputSize; i++){
            char currentChar = inputLine.charAt(i);
            if(alphabetCnt.containsKey(currentChar)){
                alphabetCnt.put(currentChar, alphabetCnt.get(currentChar) + 1);
            } else {
                alphabetCnt.put(currentChar, 1);
            }

            //indexOf 처음나오는 index찾기
            // if (inputLine.indexOf(inputLine.charAt(i)) != i) {
            // }
        }

        char maxChar = ' ';
        int  maxValue = 0; 
        boolean hasMultipleMax = false;

        for(Map.Entry<Character, Integer> entry : alphabetCnt.entrySet()){
            int count = entry.getValue();
            if(maxValue < count){
                maxValue = count;
                maxChar  = entry.getKey();
                hasMultipleMax = false;
            } else if (maxValue == count){
                hasMultipleMax = true;
            }
            
        }
        
        System.out.print( hasMultipleMax==true ? "?" : maxChar );
    }
}

 

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new  InputStreamReader(System.in ));

        String inputLine = br.readLine().toUpperCase();
        int inputSize = inputLine.length();
        Map<Character, Integer> alphabetCnt = new HashMap<>(); //Map 인터페이스는 키와 값 모두 객체

        for(int i = 0; i < inputSize; i++){
            char currentChar = inputLine.charAt(i);
            if(alphabetCnt.containsKey(currentChar)){
                alphabetCnt.put(currentChar, alphabetCnt.get(currentChar) + 1);
            } else {
                alphabetCnt.put(currentChar, 1);
            }
        }

        Optional<Map.Entry<Character, Integer>> maxEntry = alphabetCnt.entrySet().stream()
                .max(Map.Entry.comparingByValue());

        if(maxEntry.isPresent()){
            Map.Entry<Character, Integer> entry = maxEntry.get();
            long count = alphabetCnt.entrySet().stream()
                    .filter(e -> e.getValue().equals(entry.getValue()))
                    .count();

            if(count > 1){
                System.out.println("?");
            } else {
                System.out.println(entry.getKey());
            }
        }
        
        System.out.print( hasMultipleMax==true ? "?" : maxChar );
    }
}

 

 

- 실패 소스코드 -




4. 추가 개념

 

HashMap

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

728x90
반응형

'알고리즘(BOJ) 문제풀이' 카테고리의 다른 글

[BOJ/백준] 심화_1316번  (0) 2024.05.18
[BOJ/백준] 심화_2941번  (0) 2024.05.18
[BOJ/백준] 심화_10988번  (0) 2024.05.17
[BOJ/백준] 심화_2444번  (0) 2024.05.17
[BOJ/백준] 1차원 심화_ 3003번  (0) 2024.05.16
반응형

1. 문제 번호 10988번


 

 

 

2. 문제 풀이 

 

/***************************************************************

 * Test   Data     : CABAA 
 * Expect Result   : False
 * Test   Result   : True
 * 
 * Cause           : 동일 변수에 데이터 초기화
 * Caution         : break를 신경쓰자

****************************************************************/
for(int i = 0; i < inputSize/2; i++){
    isTrue = (inputLine.charAt(i) == inputLine.charAt(inputSize-i-1) ? 1 : 0);
}


for(int i = 0; i < inputSize/2; i++){
    if( inputLine.charAt(i) != inputLine.charAt(inputSize-i-1)){
        isTrue = 0;
        break;
    }
}

 

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

 1. 초기화 주의 필요

 

 

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new  InputStreamReader(System.in ));
        StringBuilder sb = new StringBuilder();

        int n = Integer.parseInt(br.readLine());

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n-i; j++){
                sb.append(" ");
            }
            for(int j = 1; j <= 2*i-1; j++){
                sb.append("*");
            }
            sb.append("\n");
        }

        for(int i = n-1; i >= 1; i-- ){
            for(int j = 1; j <= n-i ; j++){
                sb.append(" ");
            }
            for(int j = 1; j <= 2*i-1; j++){
                sb.append("*");
            }
            sb.append("\n");
        }
        

        System.out.print(sb);
    }
}

 

 

 

 

- 실패 소스코드 -




4. 추가 개념

 

 

 

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

728x90
반응형
반응형

1. 문제 번호 2444번


 

 

 

2. 문제 풀이 

 - 절반 자르고 윗부분 아랫부분 나눠서 풀이

 

 

 

 

나의 문제풀이 방식 및 순서

 

 * 나의 다양한 학습이 우선이기 때문에 다양한 방법을 생각 *

 

 1. 나에게는 여태 어떤 문제보다 어려웠다..

    여전히 어렵고 답을 봐서 외워버렸지만 이렇게 사고하는게 쉽지 않다...

 


3. 소스 인증

 

import java.util.*;
import java.lang.*;
import java.io.*;

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new  InputStreamReader(System.in ));
        StringBuilder sb = new StringBuilder();

        int n = Integer.parseInt(br.readLine());

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n-i; j++){
                sb.append(" ");
            }
            for(int j = 1; j <= 2*i-1; j++){
                sb.append("*");
            }
            sb.append("\n");
        }

        for(int i = n-1; i >= 1; i-- ){
            for(int j = 1; j <= n-i ; j++){
                sb.append(" ");
            }
            for(int j = 1; j <= 2*i-1; j++){
                sb.append("*");
            }
            sb.append("\n");
        }
        

        System.out.print(sb);
    }
}

 

 

 

 

- 실패 소스코드 -




4. 추가 개념

 

 

 

 

 


5. 참조 블로그


 

불편함을 느끼실 경우 연락 주시면 곧 바로 삭제하도록 하겠습니다.

 


 

 

 

 

 

 

 

728x90
반응형

+ Recent posts