IPv4

스프링 강의를 듣던 중 테스트 코드부분에서 아래의 1번으로 2번 테스트 코드의 차이점이 무엇인가에 대한 의문점이 생겼습니다.

// 1.
assertThat(member.getName()).isEqualTo(result.getName());

// 2. 
Assertions.assertThat(member.getName()).isEqualTo(result);

그래서 위 두 코드의 차이점을 알아보고 싶었습니다.

ㅇ 테스트 코드란?

: 오류가 났을 때 기대값과 실제 값을 둘 다 보여줘서 어떤 부분이 틀렸는지 명확히 보여줘 오류 찾는 시간을 단축시킨다.

 - @Test : 테스트 대상 메서드를 지정

 - @Test ( timeout = 밀리초 ) : 테스트 메소드 수행시간을 제한

 - @Ignore : 해당 메서드의 테스트가 진행되지 않도록 지정

 - @BeforeEach : 모든 @Test메서드 실행 전에 실행되는 메서드를 지정 어노테이션

 - @AfterEach : 모든 @Test메서드의 실행이 끝난 후 실행되는 메서드 지정 어노트에션

 - @BeforeAll / @AfterAll : 해당 테스트 클래스가 실행될 때 / 실행 끝났을 때 딱 한번 수행되는 테스트 코드 지정 어노테이션

ㅇ 두 테스트 코드의 설명

1. assertThat( actual ).isEqualTo( expected )

: org.junit.Assert.assertThat 클래스

: actual - 실제 값, expected - 내가 기대한 값

2. Assertions.assertThat()

: org.assertj.core.api.Assertions 클래스

: assertThat으로 비교할 대상을 설정하고 isEqualTo()로 사용자가 생각하는 값을 비교한 뒤 그게 맞는지 검사하는 테스트

ㅇ 차이점

1. assertThat( actual , Matcher )

 -  actual 인자 : 검증 대상을 넣음

 - Matcher 인자 : 로직을 주입받아 검증 단계 수행

 이 부분에서 Matcher 를 개발자가 직접 구현하는 것은 비효율적이고, 이 부분에서 오류가 발생할 수 있습니다.

오류가 발생하면 테스트는 실패하는데 외부 요인에 영향을 받는 것은 좋은 테스트가 아닙니다.

문제점 1) 자동완성

: allOf, graterThan, lessThan 등 메서드를 미리 import 해놓지 않으면 자동 완성해주지 못하기 때문에

공식 문서를 찾거나 이름을 외워서 작성해야 합니다.

문제점 2) Assetions 분류 ( Matcher )

: hamcrest에 구현된 matcher를 사용해야하는데 여러 타입의 matcher가 함께 있으니 내가 원하는 타입의

matcher 찾기가 불편합니다.

문제점 3) 확장성

: 추가된 조건도 같이 검증하기 위해선 allOf 라는 메소드로 기존 조건을 묶어줘야하는데 이는 가독성이 좋지 않습니다.

* hamcrest matcher 란?

https://tjdwns4537.tistory.com/38

2. Assertions

: 이러한 문제점 세가지를 해결한게 org.assertj.core.api.Assertions 에서 제공하는 assertThat입니다.

필요한 메서드를 검색해서 import 해야하는 번거로움도 없고, 가독성도 좋습니다.

 * 결론

: org.assertj.core.api.Assertions 에서 제공하는 Assetions 로 테스트를 진행하도록 하자.

 * 그 외 테스트 코드



1) Assertions.assertThat().isInstanceOf()

: assertThat - 테스트할 대상, isInstanceOf - 앞의 테스트대상의 인스턴스인가? 라고 묻는 것으로

  앞에 자식이 될 요소, 뒤를 부모가 될 요소를 넣는다. 즉, 참조나 상속을 받고있는지 묻는 것이다.




 * org.junit.jupiter.api.Assertions.assertThrows 클래스를 사용

2) Assertions.assertThrows(에러클래스,에러발생)

: 일부러 오류를 발생시키는 테스트 코드이다. 이는 예외로 들어와서 오류가 제대로 나오는지 테스트하기 위함이다.

: assertThrows의 첫번째 인자 - 에러, 두번째 인자 - 에러 발생 요소

: 제대로 에러가 뜨면 True를 반환

ㅇ Matcher 클래스

: Matcher 클래스는 대상 문자읠 패턴을 해석하고 주어진 패턴과 일치하는지 판별할 때 주로 사용됩니다.

입력 값으로는 CharSequence라는 새로운 인터페이스가 주로 사용되는데, 다양한 형태의 입력 데이트로부터 문자 단위의 매칭 기능을

지원 받을 수 있습니다.

ㅇ Matcher 클래스 주요 메서드

→ matches() : 대상 문자열과 패턴이 일치할 경우 true 반환합니다.
→ find() : 대상 문자열과 패턴이 일치하는 경우 true를 반환하고, 그 위치로 이동합니다.
→ find(int start) : start위치 이후부터 매칭검색을 수행합니다.
→ start() : 매칭되는 문자열 시작위치 반환합니다.
→ start(int group) : 지정된 그룹이 매칭되는 시작위치 반환합니다.
→ end() : 매칭되는  문자열 끝 다음 문자위치 반환합니다.
→ end(int group) : 지정되 그룹이 매칭되는 끝 다음 문자위치 반환합니다.
→ group() : 매칭된 부분을 반환합니다.
→ group(int group) : 매칭된 부분중 group번 그룹핑 매칭부분 반환합니다. 
→ groupCount() : 패턴내 그룹핑한(괄호지정) 전체 갯수를 반환합니다.

ㅇ Hamcrest

: 소프트웨어 테스트를 위한 framework

: 기존의 matchers 클래스를 통해 코드의 조건을 확인 할 수 있음

: JUnit 에서 Hamcrest matcher를 사용하려면 assertThat 문 뒤에 하나 또는 여러 개의 matchers 를 사용한다.

: Spring boot 에서 사용하기 위해선 dependenct 를 추가해줘야 한다.

ㅇ Hamcrest matcher 모음

allOf - matches if all matchers match (short circuits)
anyOf - matches if any matchers match (short circuits)
not - matches if the wrapped matcher doesn’t match and vice
equalTo - test object equality using the equals method
is - decorator for equalTo to improve readability
hasToString - test Object.toString
instanceOf, isCompatibleType - test type
notNullValue, nullValue - test for null
sameInstance - test object identity
hasEntry, hasKey, hasValue - test a map contains an entry, key or value
hasItem, hasItems - test a collection contains elements
hasItemInArray - test an array contains an element
closeTo - test floating point values are close to a given value
greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo
equalToIgnoringCase - test string equality ignoring case
equalToIgnoringWhiteSpace - test string equality ignoring differences in runs of whitespace
containsString, endsWith, startsWith - test string matching

* 참조 : http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/Matchers.html

ㅇ Optinal 이란?

- 값이 있을 수도, 없을 수도 있는 객체이다. 

- 원소를 최대 1개 가질 수 있는 불변 Collection 이다.

- null 에 대한 처리를 안전하게 할 수 있게 해준다.

 * Optional 을 리턴하는 메서드에서는 null을 리턴해서는 안된다. ( Optional 취지와 맞지 않기 때문이다. )

ㅇ 왜 Optional 을 사용하는가?

 : 검사 예외와 취지가 비슷하다. 즉 반환값이 있을 수도 있고, 없을 수도 있음을 API 사용자에게 명확히 알려준다.

만약 기존 로직처럼 사용하여 비검사 예외를 던지거나 null 을 반환하는 경우

 => 사용자가 그 사실을 인지못해 런타임에서 예상치 못한 장애로 발전할 수 있음

검사 예외 ( checked Exception ) 을 던지는 경우

 => 사용자 코드에서는 try-catch 구문을 통해 예외처리하는 로직을 추가해야하는데,

      비슷하게 메서드가 Optional 을 반환한다면 클라이언트는 값을 받지 못했을 때의 취할 행동을 선택해야한다.

ㅇ Optinal 기본값을 설정하는 방법

String lastWord = max(words).orElse("단어 없음..");

 : 값을 받지 못했을 때에 단어 없음이라는 행동이 선택된다.

ㅇ Optional 메서드

1) Optional.empty()

 - 내부 값이 비어있는 Optional 객체 반환

2) Optional.of(T value)

 - 내부 값이 value 인 Optional 객체 반환

 - 만약 value가 null인 경우 NPE 발생 ( NullPointerException )

3) Optional.ofNullable(T value)

 - 가장 자주 쓰이는 Optional 생성 방법

 - value 가 null 이면, empty Optional 을 반환하고 값이 있으면 Optional.of 로 생성한다.

ㅇ 폼 태그의 역할

 : 입력된 데이터를 한 번에 서버로 전송하고, 전송한 데이터는 웹 서버가 처리하며, 결과에 따른 웹페이지를 보여줍니다.

ㅇ 폼 태그 동작 방법

1) 폼 내용 입력 후 제출

2) 모든 데이터를 웹 서버로 보내고 데이터 처리를 위해 웹 프로그램으로 넘김

3) 웹 프로그램은 데이터 처리 후 결과에 따른 HTML 페이지를 웹 서버에 보냄

4) 웹 서버는 받은 HTML 페이지를 브라우저에 전송

ㅇ 폼 태그 속성

: name, action, method, target 등의 폼 속성이 있는데, 전송할 때 어디로 보낼지에 대한 방법을 정합니다.

1) action : 폼을 전송할 서버 쪽 스크립트 파일을 지정 ( 즉, 어디로 보낼지를 지정해주는 것입니다. )

2) name : 폼을 식별하기 위한 이름을 지정

3) accept-charset : 폼 전송에 사용할 문자 인코딩을 지정

4) target : action에서 지정한 스크립트 파일을 현재 창이 아닌 다른 위치에 열도록 지정

5) method : 폼을 서버에 전송할 http 메소드를 정함 ( GET or POST )

ex.

<form action="/login/new" method="post">

ㅇ GET / POST

1) GET : 폼 데이터를 URL 끝에 붙여서 눈에 보이게 보내지는 것

 -> 보안적으로 취약하여 지정된 리소스에서 데이터를 읽을 때만 주로 사용

2) POST : 내부적으로 보냄으로써 눈에 보이지 않음

 -> 지정된 리소스에서 데이터를 처리할 경우 쓰기,수정,삭제할 때 사용

ㅇ <input> 태그

: 사용자가 다양하게 폼 태그에 입력할 수 있는 공간을 만들어 줍니다.

속성에는 type, readonly, maxlength 등이 있습니다.

1) type : 태그 모양을 다양하게 변경 가능

 - text / radio / checkbox / password / button / hidden / submit / reset 등

2) name : 태그 이름을 지정

3) readonly : 태그 읽기 전용

4) maxlength : 해당 태그 최대 글자 수 지정

5) required : 해당 태그가 필수태그로 지정됩니다. 필수 태그를 입력하지않고 submit 하면 에러 출력

6) placeholder : 태그에 입력할 값에 대한 힌트 줍니다.

ㅇ 자세한 예제를 살펴보자

- html

<div class ="contatiner">
        <form action="/new" method="post">
            <div class="form-group">
                <label for="name"> 이름</label>
                <input type="text" id="name" name="name" placeholder="이름 입력하세요">
            </div>
            <button type="submit"> 등록 </button>
        </form>
    </div>

- MemberController.java

    @GetMapping("/new")
    public String New() {
        return "/Login/memberNew";
    }

    @PostMapping("/new")
    public String create(Form form) {
        Member member = new Member();
        member.setName(form.getName());
        return "redirect:/";
    }

 - [ form action = "/new" method ="post" ] , <input name="name"> 구동과정

1) 이 태그를 보면 form 에 사용자가 값을 입력하고 등록 버튼 누름

2) 그 값은 input name = "name" 을 통해 Form 클래스 내부에 있는 name 객체와 매칭이 되면서

     Form 클래스의 name 에 값이 들어감

2) /new 라는 주소를 post 해줌

3) controller 에서 PostMapping 을 통해 form 의 name 데이터를 받고 데이터 저장을 하든 뭘 하든 가공 처리를 한다.

4) 해야할 처리가 다 끝나면 이동할 주소를 return 해준다.

문제 : 클릭안되는 화살표 폴더가 push됨

이유:

해당 폴더안에서도 push 를 하다보니 .git 파일이 해당 폴더 내부에도 존재해서 발생하는것 때문이였습니다.

1) 해당 폴더 내부로 디렉터리를 옮긴 다음, rm -rf .git

2) git rm --cached . -rf 로 스테이지 파일을 제거

3) add ~ commit ~ push 를 다시 해준다.

4) 해결 완료

* 참조한 블로그

https://zzang9ha.tistory.com/346

발생 오류:

- 현상태 : Repository 에 수정된 부분을 업로드하려는 상황

1. 커밋 후 푸쉬

2. Everything up-to-date 라고 뜨고 아무것도 업데이트되지 않음.

방법1. git clean -f

: untracked file 에 .git ignore 과 같은 파일이 있어 이 부분 때문에 오류가 발생하는가 해서 clean 후 재시도했지만 해결 안됨

방법2. 프로젝트 파일 전체를 묶어서 하나의 폴더에 넣고 해당 폴더를 커밋 후 푸쉬

: untracked file 이 갑자기 엄청 많아지는 이 부분에 대해 알고 넘어가야할것 같다.

https://tjdwns4537.tistory.com/33

즉, Untrack 에 나와있던 파일들을 봤을 때 .git 이 있는 디렉터리에서 git 명령어를 사용하는게 아니라

다른 경로에서 사용해서 발생한 어이없는 실수입니다....

다시 원했던 경로로 가서 git init 부터 천천히 해보겠습니다.

방법 3. 소스코드/리소스 파일들을 하나의 폴더에 모아서 git init 부터 다시해준다.

 > 아래와 같은 오류가 발생

error: failed to push some refs to ~~

- 발생 이유 : 

github 내에 local에 없는 파일이 있고, 내 파일을 push 하면 발생하는 오류입니다.

즉, github에 README.txt 파일을 업로드 해놓고 새로운 폴더하나만 떵그러니 업데이트하려고하니 발생하는 오류입니다.

[ 해결 방법 ]

 - git pull origin master --allow-unrelated-histories

: 저장소와 로컬 저장소의 병합을 허용한다는 의미입니다.

아마 제가 윈도우로 레퍼지스토리를 만들고, 맥북으로 pull 을 받으려고 해서 발생하는 문제인것 같은데

 - fatal: refusing to merge unrelated histories  

위와 같은 오류가 발생하였습니다.

그래서 병합해주는 명령어를 통해서 pull 을 하니 강제로 push 해주는 방법이 아닌 방식으로 해결 가능하였습니다...

다시 push 해주니 정상 작동완료 ㅠㅠ

참조했던 블로그입니다 !!

https://iambeginnerdeveloper.tistory.com/entry/github-%EC%97%90%EB%9F%AC-%ED%95%B4%EA%B2%B0%ED%95%98%EA%B8%B0-error-failed-to-push-some-refs-to-warning-LF-will-be-replaced-by-CRLF-in-%EA%B0%95%EC%A0%9C-push-%ED%95%98%EC%A7%80%EB%A7%88%EC%84%B8%EC%9A%94%EC%A0%9C%EB%B0%9C

ㅇ GIT 의 디렉토리

: GIT 프로젝트 디렉터리에는 .git 을 포함하여 많은 파일이 존재한 것입니다.

GIT 디렉터리는 GIT 프로젝트에서 작업한 수많은 정보와 버전들에 대한 데이터를 저장하는 데이터베이스로,

그 외 데이터들은 깃 디렉터리에서 특정 버전의 데이터들을 checkout한 것입니다.

이때, checkout하여 가져온 버젼의 파일들로 프로젝트 작업을 수행하며, 이 checkout 파일들이 존재하는 곳을

워킹트리 또는 워킹 디렉터리라고 부릅니다.

ㅇ GIT 의 세가지 영역

1) 워킹 디렉터리 : 프로젝트를 진행하는 실제 작업공간으로 개발 소스/자원들이 존재하며 이 파일을 수정,추가합니다.

2) Staging Area : 워킹 디렉터리에서 작업한 내역을 Git디렉터리로 커밋하기 위해 커밋 대상 목록으로 담아두는 장바구니 목록 영역

-> git add 명령어가 된 상태

3) Git 디렉터리 : 실제 .git 이라는 이름의 디렉터리이며, 여러 버전의 커밋 데이터와 Git 프로젝트 정보를 담고있는 핵심 디렉터리

-> git commit 된 상태

ㅇ Git 프로젝트 파일 상태

: 각각의 파일들이 어떤 상태인지 분류하여 관리합니다.

1) Untracked / Tracked 상태

: 워킹 디렉터리에 있는 여러 파일들을 Git 추적 관리 여부에 따라 각각 크게 두 가지 상태로 나눌 수 있습니다.

- Tracked : Git 이 해당 파일을 추적/관리하는 상태

            => 최소 한번 git add 되거나, Commit 된 상태

- Untracked : 아직 Git 이 해당 파일을 추적 및 관리하지 않는 상태로 디렉터리에 존재하는 파일이더라도

                      Git이 관리하는 파일은 아니라는 의미입니다.

           => 즉, 파일이 수정,삭제되어도 Git에서 신경 안쓰며 복구가 불가능합니다. 대신 불필요한 파일들을 커밋하게 되는 경우를 방지 가능

2) Unmodified / Modified 상태 ( Tracked 상태에만 가능 )

 : 파일의 변경 여부에 따른 상태로 나눈 경우입니다. 변경 발생 기준은 파일이 Stage 또는 Commit 된 시점 이후로 변경되었는지 입니다.

3) Stage 상태

: Untracked 파일 / Modified 상태인 파일을 Staging Area 에 내역을 등록하지 않은 상태입니다.

* 참조한 블로그입니다.

https://dololak.tistory.com/304

    <link rel="stylesheet" th:href="@{/css/MyStyle.css}"/>

부트스트랩을 이용해 게시판을 만들던 중 CSS 파일들이 적용안되는 문제가 발생했습니다.

CDN 경로로 설정하면 되는데 파일을 다운받아서 적용시키면 안되는 오류 였습니다.

기존 문제. 

Resources/css

Resources/js

이 두 폴더를 따로 만들어서 적용시킨 것이 문제였습니다.

인텔리제이가 Run 될 때, static 폴더를 접근해서 구동시키니 static 폴더 아래에 css/ , js/ 폴더를 만들어서 경로를 설정해줘야하는데

이를 생각하지 못해서 삽질을 하고 있던 것입니다.

만약 저와 같이 부트스트랩 활용 또는 CSS 파일이 적용이 안된다면 아래 사진처럼 따라 해보시길 권장드립니다.

 (1) HTML 에 링크걸어준 부분

    <link rel="stylesheet" th:href="@{/css/MyStyle.css}"/>

(2) CSS , JS 폴더 경로들

package practice;

import java.util.Scanner;

public class Main{
    static public String mArr[];
    static public int mCnt=0; //자식클래스가 쓰기 위한 저역 변수
    static private int mN;
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

        int max = sc.nextInt();

        mArr = new String[max];

        stack stk = new stack();

        for(int i=0; i<max; i++){
            String tmp = sc.next();
            stk.push(tmp);
        }
        mCnt--;
        for(int i=0; i<max; i++){
            stk.pop();
        }
    }
}

package practice;

public class stack extends Main { //자식클래스
    public void push(String input) {
        try{
            mArr[mCnt] = input;
            System.out.println("입장: " + mArr[mCnt++]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }
    }

    public void pop(){
        try{
            System.out.println("퇴장: " + mArr[mCnt--]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }
    }
}

package practice;

import java.util.Scanner;

// .idea 폴더 : 프로젝트의 구조 정보 등 프로젝트 관련 메타데이터가 들어 있음
// iml 파일 : 인텔리제이 모듈 구성에 대해 xml 형태로 기술해 놓은 파일
// @override: 상속을 받아서 메서드를 만들때 모든 메서드는 같은걸 상속받게되는데 이때 맘에 들지않는 것을 내가 원하는대로 재정의하겠다는 의미

/*
static : 이미 객체화 되어 바로 사용가능
non-static : 아직 객체화되지 않아 new 키워드를 통해 생성한 후 사용 가능
 */

/*
Scanner(System.in) : Scanner 를 통해 값을 입력받음
-> sc.nextInt / sc.next / sc.nextLine 과 같이 응용하여 사용한다
*/
/*
 static : 그냥 정적 변수로 static protecd 로 선언되므로 다른 클래스에서 불러올 수 없다
 static public : 다른 클래스에서 불러올 수 있는 정적변수
*/
/*
throw : Exception 을 발생시킬때 사용하는 키워드
throws : 메소드를 정의할 때 사용하며, 이 메소드에서 발생할 수 있는 Exception 을 명시적으로 정의할 때 사용합니다.
*/
/*
 - 에러 : 1.개발자가 해결할 수 없는 오류
         2.하드웨어의 잘못된 동작 또는 고장으로 인한 오류
         3. 에러 발생하여 프로그램 종료
         4. 정상상태로 돌아갈 수 없음
 - 예외 : 1.개발자가 해결할 수 있는 오류
         2.사용자의 잘못된 조작이나 코딩 오류
         3.예외 처리 추가하면 정상 실행 상태로 돌아갈 수 있음
 */
/*
if-else : 모든 예외상황을 예측하고 있어야한다.
try-catch : try구문에서 예외가 Throw 되면 그 즉시 블럭이 종료되고, catch 블럭으로 제어가 이동됨 ( try: 블럭 )
 */
/*
try{} catch{} : try에서 예외가 발생하면 Catch 블록의 참조변수로 전달한다.
 -> 하나의 try 에 여러 catch가 있을 수 있지만 동시에 발생하지는 않음
 -> 예외 발생 여부와 상관없이 무조건 살행해야하는 문장이 있다면 finally를 사용
  ex. try{ } catch{ } catch{ } finally{" 무조건 실행 "}
 */
/*
ArrayIndexOutOfBoundsException : 배열의 범위를 벗어난 인덱스 사용시 발생
NumberFormatException : 메소드의 인수를 숫자로 바꿀 수 없을때 발생
ArithmeticException : 인수가 0일 때 나눌 수 없으므로 발생
 */
/*
throws : 메소드에서 발생한 메소드를 내부에서 처리하기 어려울 때 사용해서 던져줌 ( 말 그대로 throw 해줌 )
         단, 메소드에 선언한 예외보다 더 괌범위한 검사형 예외를 던질 수는 없음
EX.
public void method(){
    try{
        method2();
    }catch(ClassNotFoundException e){
        System.out.println("클래스가 존재하지 않음");
    }
}
public void method2() throw ClassNotFoundException {
    Class clazz = Class.forName("java.lang.String2");
}
 */
public class Main {
    static int[] mArr;
    static int mN,mFront=0,mTail=0;

    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        mN = input.nextInt();
        mArr = new int[mN];

        Main enq = new Main();
        Main deq = new Main();
        /*
        enqueue 와 dequeue 가 전역 메소드로 선언된것이 아니기 때문에
        각 함수를 클래스에 객체화 시켜서 선언하였다.
        전역 메소드를 안쓰는 이유는 그 메소드를 추적하기 힘들어지기 때문에 미리 전역메소드를 안쓰는 식으로 연습하는 것이다.
         */

        for(int i=0; i<mN; i++){
            int enq_num = input.nextInt();
            enq.enqueue(enq_num);
        }

        for(int i=0; i<mN; i++){
            System.out.println(deq.dequeue());
        }
    }

    public void enqueue(int num){
        try{
            mArr[mTail] = num;
            System.out.println("enqueue: "+ mArr[mTail++]);
        } catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e); // e만 출력해줘도 예외 처리를 해줘야한다는 것을 알려준다.
        }
    }

    public int dequeue(){
        try{
            int outnum = mArr[mFront];
            for(int i=0; i<mTail-1;i++){
                mArr[i] = mArr[i+1];
            }
            mTail--;
            return outnum;
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
            return 0;
        }
    }
}

package stack;

import java.util.Scanner;

// .idea 폴더 : 프로젝트의 구조 정보 등 프로젝트 관련 메타데이터가 들어 있음
// iml 파일 : 인텔리제이 모듈 구성에 대해 xml 형태로 기술해 놓은 파일
// @override: 상속을 받아서 메서드를 만들때 모든 메서드는 같은걸 상속받게되는데 이때 맘에 들지않는 것을 내가 원하는대로 재정의하겠다는 의미

/*
static : 이미 객체화 되어 바로 사용가능
non-static : 아직 객체화되지 않아 new 키워드를 통해 생성한 후 사용 가능
 */

public class Main {

    static int[] arr;
    static int count,incnt;

    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        count = input.nextInt(); // 입력받은 값을 INT 로 받겠다는 의미 ( next(), nextByte(), nextFloat(), nextLine() 등이 존재 )

        arr = new int[count]; // 초기값 0으로 할당됨

        incnt = 0;

        push(5);
        push(1);
        push(3);
        push(9);

        for(int i=0; i<incnt; i++){
            System.out.print(arr[i]+" ");
        }

        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());
    }

    public static void push(int input){
        if(incnt == count){
            System.out.println("스택이 초과하였습니다.\n");
            throw new SecurityException();
        }else{
            arr[incnt++] = input;
        }
    }

    /*
    throw : 에러를 고의로 발생시킴
    throws : 자신을 호출한 상위 메소드로 에러를 던지는 역할
     */
    public static int pop(){
        if(incnt <= 0){
            System.out.println("빈 스택입니다.");
            throw new SecurityException();
        }
        return arr[incnt--];
    }
}

ㅇ 폰켓몬 문제 :
n 마리의 폰켓몬 중에 n/2 마리를 가질 수 있음.
각 폰켓몬에는 종류에 따라 번호가 붙어있음 -> 같은 종류의 폰켓몬은 같은 번호를 가짐.
ex. 4마리의 폰켓몬 : [3 , 1 , 2 , 3] 이 될 수 있는 거임. 따라서 위 종류에서 1,4번 폰켓몬을 선택하는 것이 아닌 이상
    최대  2 개 종류의 폰켓몬을 가질 수 있음.


- 원하는 결과
: n 마리 중 N/2 마리를 선택하는데 최대 종류를 가질 수 있는 수를 찾는 것


- 주어진 변수
1) nums : n 마리 폰켓몬의 종류 번호가 담긴 배열


- 제한사항
1) nums 는 1차원 배열
2) nums 의 길이는 1 ~ 10,000 중에서 짝수이다.
3) 폰켓몬의 종류 번호는 1 ~ 200,000
4) 가장 많은 종류의 폰켓몬을 선택하는 방법이 여러가지라도 그 최대값만 return 하면 됨




- ArrayList 를 사용
1) list.contains()  :  list에 인자로 전달받은 객체가 있는지 없는 확인

2) List<Integer> 을 통해 정수 리스트를 생성

3) nums[0] 의 시작 주소에 담긴 데이터를 리스트에 넣어줌

4) list.size() 와 nums.length 를 통해 크기 비교 후 결과값을 반환해줌

import java.util.*;

class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        List<Integer> list = new ArrayList<>();
        list.add(nums[0]); // nums 배열의 주소를 list 연결리스트로 복사해줌

        for(int i=1; i<nums.length; i++){
            if(!list.contains(nums[i])){
                list.add(nums[i]);
            }
        }

        answer = list.size() > nums.length/2 ? nums.length/2 : list.size();

        return answer;
    }
}

ㅇ 문제
: 도둑이 들어 일부 학생이 체육복을 도난 당함 -> 여벌 체육복이 있는 학생이 이들에게 빌려줌.
학생들의 번호는 체격 순으로 매겨져 있음 -> 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있음.
이 문제의 핵심은 체육복이 없으면 수업을 못 듣기때문에 최대한 많은 학생이 빌릴 수 있도록 하는 것.


- 주어지는 변수
1) n : 전체 학생의 수
2) lost : 체육복을 도난당한 학생들의 번호가 담긴 배열 ( 앞 뒤 번호 확인 필요 )
3) reserve : 여벌의 체육복을 가진 학생들 ( lost 와 비교 필요 )


- 결과값 : 체육수업을 들을 수 있는 학생의 최댓값

   ex. 2 ,4 가 lost 이고 reverse 가 3 이면 최대는 4 ( 1,2,3,5 ) -> return 4


- 제한사항
1) 2 ~ 30 명
2) 도난 당한 학생의 수 : 1 ~ n 명 ( 중복되는 번호 없음 )
3) 여벌 체육복을 가져온 학생의 수 : 1 ~ n 명 ( 중복되는 번호 없음 ) 
4) 여벌 체육복을 가져온 학생이 체육복을 도난 당했을 수도 있습니다. 이때, 이 학생은 체육복을 하나만 도난당했다고 가정함.
   그러면 이 학생은 더 이상 체육복을 빌려줄 수 없음.

import java.util.Arrays;
class Solution {
    public int solution(int n, int[] lost, int[] reserve){
        int answer = n - lost.length;
        Arrays.sort(lost);
        Arrays.sort(reserve);

        for(int i=0; i<lost.length; i++){
            for(int j =0; j<reserve.length; j++){
                if(lost[i] == reserve[j]){
                    answer++;
                    lost[i] = -1;
                    reserve[j] = -1;
                    break;
                }
            }
        }

        for(int i=0; i<lost.length; i++){
            for(int j =0; j<reserve.length; j++){
                if(lost[i]-1 == reserve[j] || lost[i]+1 == reserve[j]){
                    answer++;
                    reserve[j] = -1;
                    break;
                }
            }
        }

        return answer;
    }
}

* Arrays 패키지를 사용안하니 마지막 문제가 풀리지 않았다. 아마 정렬되지 않은 배열이 예제로 있었기 때문이라고 생각한다.

ㅇ 로또의 최고 순위와 최저 순위

1위 : 6개 모두 일치
2위 : 5개 일치
3위 : 4개 일치
4위 : 3개 일치
5위 : 2개 일치
6위 : 그 외



- 해결해야 하는 것

1) 로또 번호가 낙서되어 알아 볼 수 없음
 -> 예상해서 확률을 만들어야함
 -> 알아볼 수 없는 번호를 0으로 표기


2) 당첨 번호 발표 후 자신이 구매했던 로또의 최고 순위와 최저 순위를 알아내야 함
  -> 순서는 상관없이 번호만 일치하면 됨




- 주어진 변수

1) lottos : 구매한 로또 번호를 담은 배열

2) win_nums : 당첨 번호를 담은 배열




- 제한사항

1) lottos 의 길이는 6 인 정수 배열
2) lottos 의 모든 원소는 0 ~ 45 정수
3) win_num 의 길이는 6 인 정수배열
4) win_num 의 모든 원소는 1 ~ 45 정수


- 결과 값
: 당첨 가능한 최고 순위와 최저 순위가 담긴 배열




- 해결 과정
1) 0 ~ 45 중 랜덤한 숫자를 lottos 에 입력받음
2) 1 ~ 45 중 랜덤한 숫자를 win_nums 에 입력받음
3) 0에 숫자를 넣었을때 win_nums 배열 수 중 최대 갯수가 중복되게 하는 수와
   중복이 최대가 되는 수를 찾는다.
4) 1~6위 중 최대와 최소를 찾는다.

class Solution{
	public int[] solution(int[] lottos,int[] win_nums){
		int cntR = 0;
        int cntZ = 0;

        for(int i : lottos){
            for(int j : win_nums){
                if(i==j) cntR++;
            }
            if(i == 0) cntZ++;
        }
        int upRes = 7 - (cntR + cntZ) > 6 ? 6 : 7 - (cntR + cntZ);

        int downRes = 7 - cntR > 6 ? 6 : 7 - cntR;

        int[] answer = {upRes,downRes};

        return answer;
    }
}

* 어려웠다. 다시 풀어보자

< 알아야하는 개념 >

1. 절대값 함수

    : stdlib 헤더에 있으며, abs ( value ) 를 하면 절대값을 출력해준다.

2. cout 으로 소수점 반올림 시키기

    : cout.precision(0) 하면 정수 부분만 출력이 된다.

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool compare(int a,int b){
    return a < b;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int n,temp,arr[8001]; // 음~양수 4000씩 = 8000
    int mx = -1,mode,count = 0;
    double sum = 0;

    vector <int> vec,mode_vec;

    for(int i=0; i<n; i++){
        arr[i] = 0;
    }

    cin >> n;

    for(int i=0; i<n; i++){
        cin >> temp;
        vec.push_back(temp);
        sum += temp;
        temp = (temp <= 0) ? abs(temp) : temp + 4000;
        arr[temp]++;
        if(arr[temp] > mx){
            mx = arr[temp];
            mode = temp;
        }
    }

    sort(vec.begin(),vec.end(),compare);

    for(int i=0; i<8001; i++){
        if(arr[i] == mx){
            mode = i;
            mode = (mode<4000) ? -mode : mode-4000;
            mode_vec.push_back(mode);
        }
    }

    sort(vec.begin(),vec.end(),compare);

    mode = (mode_vec.size() >= 2) ? mode_vec[1] : mode_vec[0];
    double eve = sum/double(n);
    cout.precision(0);
    cout << eve << endl;
    cout << vec[n/2] << endl;
    cout << mode << endl;
    cout << vec[vec.size()-1] - vec[0] << endl;

    return 0;
}

< Vector 와 Array 의 차이점 >

Vector 는 삽입/삭제가 빈번하게 일어나는 곳에서 유리한 동적인 자료구조

Array 는 고정된 크기로 연속된 메모리를 가지고 있어 삽입/삭제가 빈번하지 않다면 Vector 보다 더 유리한 정적인 자료구조

< ios::sync_with_stdio(false);>

cin과 cout의 속도가 C의 입출력 속도에 비해 떨어지기 때문에 저 코드를 사용해 속도를 높이는 기능으로 사용한다.

하지만 C의 입출력 함수를 아예 못쓰게되서 사용할때 주의할 필요가 있다.

< cin.tie(NULL); cout.tie(NULL); >

입력과 출력을 여러 번 번갈아가며 반복해야 하는 경우 필수적으로 cin.tie(null); 코드를 추가하여 cout과 cin의 묶음을 풀어줘야 합니다.그래서 해당 코드를 통해 최적화를 시켜주는 것입니다.

#include <iostream>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int n,tmp;
    int arr[10001] = {0};

    cin >> n;

    for(int i=0; i<n; i++){
        cin >> tmp;
        arr[tmp] += 1; // 해당 숫자에 삽입
    }

    for(int i=1; i<= 10000; i++){
        for(int j = 0; j < arr[i]; j++)
            cout << i << "\n";
    }

    return 0;
}

< C++ STL ( sort ) >

- sort ( arr, arr+n ) : 오름차순 정렬

- sort ( arr, arr+n, desc ) : 내림차순 정렬 ( desc 함수를 구현해줘야함 )

내림차순 정렬

#include <iostream>
#include <algorithm>
using namespace std;

#define max 1000000

bool desc(int a,int b){
    return a > b;
}

int main(){
    int n,arr[max];
    cin >> n;

    for(int i=0; i<n; i++){
        cin >> arr[i];
    }

    sort(arr,arr+n,desc);

    for(int i=0; i<n; i++){
        cout << arr[i];
    }

    return 0;
}

- 오름차순 정렬 ( 정답 )

* 여기서 중요한 점은 endl 하면 시간초과이고, '\n' 은 정답이라는 것이다. 그 이유는 블로그에 설명을 해놨다.

https://blog.naver.com/PostView.naver?blogId=tjdwns4537&Redirect=View&logNo=222434654089&categoryNo=89&isAfterWrite=true&isMrblogPost=false&isHappyBeanLeverage=true&contentLength=13514

#include <iostream>
#include <algorithm>
using namespace std;

#define max 1000000

int main(){
    int n,arr[max];
    cin >> n;

    for(int i=0; i<n; i++){
        cin >> arr[i];
    }

    sort(arr,arr+n);

    for(int i=0; i<n; i++){
        cout << arr[i];
    }

    return 0;
}

< Pair > 과 start,second

헤더 :  utility 

개념 :

pair < [type1] [type2] > p    :    사용할 데이터타입 1,2 를 넣고 그 타입의 pair 클래스인 p 생성

p.first    :    p의 첫번째 인자를 반환

p.second    :    p의 두번째 인자를 반환

make_fair(변수1,변수2)    :    변수1,2가 들어간 pair 를 생성

operator 사용가능

sort 알고리즘으로 정렬 가능

#include <iostream>
#include <utility>
#include <algorithm>

using namespace std;

#define max 50

string board[max];

int wb_cnt(string WB[],int x,int y){
    int cnt = 0;
    for(int i=0; i<8; i++){
        for(int j=0; j<8; j++){
            if(board[x+i][y+j] != WB[i][j]) cnt++;
        }
    }
    return cnt;
}

int bw_cnt(string BW[],int x,int y){
    int cnt = 0;
    for(int i=0; i<8; i++){
        for(int j=0; j<8; j++){
            if(board[x+i][y+j] != BW[i][j]) cnt++;
        }
    }
    return cnt;
}

int main(){
    string WB[8] = {
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW"
    };
    string BW[8] = {
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB",
        "BWBWBWBW",
        "WBWBWBWB"
    };

    int MIN = 999999;
    int cnt,tmp;
    pair<int,int> p;
    cin >> p.first >> p.second;
    for(int i=0; i<p.first; i++){
        cin >> board[i];
    }

    for(int i=0; i+8 <= p.first; i++){
        for(int j=0; j+8 <= p.second; j++){
            // 8*8 크기로 짤라내기만 하면 되므로 +8을 해줌
            tmp = min(wb_cnt(WB,i,j),bw_cnt(BW,i,j));
            if(tmp < MIN) MIN = tmp;
        }
    }
    cout << MIN;
    return 0;
}

#include <iostream>
using namespace std;

class phy{
    int weight;
    int tall;
    int cnt;
    public:
    phy():weight(0),tall(0),cnt(1){}
    phy(int weight_,int tall_):weight(weight_),tall(tall_),cnt(1){}
    void input(int weight_,int tall_);
    void show();
    void compared(phy p[],int n);
};

void phy::compared(phy p[],int n){
    for(int i=0; i<n; i++){
        if((weight < p[i].weight) && (tall < p[i].tall)){
            cnt++;
        }
    }
}

void phy::show(){
    cout << cnt << " ";
}

int main(){
    int n,w,t;
    cin >> n;
    phy* person;
    person = new phy[n];
    for(int i=0; i<n; i++){
        cin >> w >> t;
        person[i] = phy(w,t);
    }
    for(int i=0; i<n; i++){
        person[i].compared(person,n);
    }
    for(int i=0; i<n; i++){
        person[i].show();
    }
    delete[] person;
    return 0;
}

#include <iostream>
using namespace std;

int main(){
    int n,sum,value;
    cin >> n;
    for(int i=1; i<n; i++){
        sum = i;
        value = i;
        while(value){
            sum += value%10;
            value /= 10;
        }
        if(n == sum){
            cout << i;
            return 0;
        }
    }
    cout << "0";
    return 0;
}

#include <iostream>
using namespace std;

int main(){
    int card_num;
    int max_num = 0;
    int sum = 0, S_sum = 0;
    int arr[100]= {0,};
    cin >> card_num >> max_num;
    for(int i=0; i<card_num; i++){
        cin >> arr[i];
    }    
    for(int i=0; i<card_num-2; i++){
        for(int j=i+1; j<card_num-1; j++){
            for(int k=j+1; k<card_num; k++){
                sum = arr[i] + arr[j] + arr[k];
                if(sum <= max_num){
                    if(S_sum < sum){
                        S_sum = sum;
                    }
                }
            }
        }
    }

    cout << S_sum;
    return 0;
}

while 문을 사용하니 시간초과라고 뜬걸 보니 계산 문제이다.

낮에 올라가서 남은 높이, 밤에 내려간 것을 뺀 실제 올라간 높이 두 가지가 있다.

그러면 

남은 높이 / 올라간 높이

그리고 날짜는 1일부터 시작이므로

(V-A) / (A-B) + 1

이 식이 된다.

#include <iostream>
using namespace std;

int main(){
    int A,B,V;
    cin >> A >> B >> V;
    int res = 0;
    if((V-A)%(A-B) == 0) res = (V-A)/(A-B);
    else res = (V-A)/(A-B) + 1;
    cout << res+1;
    return 0;
}

#include <iostream>
using namespace std;
int main(){
    int n,tmp=1;
    cin >> n;
    
    int cnt = 1;
    while(1){
        tmp += (cnt-1)*6;
        if(tmp >= n) {
            cout << cnt;
            break;
        }
        else cnt++;
    }
    return 0;
}

N의 범위

1 -> 2 ~ 7 -> 8 ~ 19 -> 20 ~ 37 ...

그래서 끝번호를 비교해보면 1, 7, 19, 37 로 

x = x + ( i - 1) * 6 의 규칙을 가짐을 알 수 있다 ( i 는 1부터 증가하는 변수 )

#include <iostream>

using namespace std;

int main(){
    int x;
    int fix_cost; // 고정비용
    int cha_cost; // 가변비용
    int total_cost; // 총 비용
    cin >> fix_cost >> cha_cost >> total_cost;
    if((total_cost-cha_cost) == 0){
        cout << -1;
        return 0;
    }
    x = fix_cost / (total_cost-cha_cost) + 1;
    if(x < 0) cout << -1;
    else cout << x;

    return 0;
}

수식 : A + Bx < Cx

이를 x에 대해 정리하면,

A / (C-B) < x 이므로,

x 는 A/(C-B) + 1 이면된다

그리고 C-B 가 0일때는 -1를 출력하도록 하지않으면 런타임에러가 발생한다

#include <iostream>

using namespace std;

int main(){
    string s;
    int arr[26] = {3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,8,9,9,9,10,10,10,10}; //다이얼에 해당하는 값을 미리 할당
    cin >> s;

    int sum = 0;

    for(int i=0; i<s.length(); i++){
        int index = s[i] - 65; //s에 -65 해줌으로써 arr의 index에 접근 (A가 아스키코드 65부터 시작함 ~ z는 122)
        sum += arr[index]; //arr에 있는 값을 더해줌
    }

    cout << sum;
    
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

int main(){
    string s1,s2;
    char p1[1000] = {0},p2[1000] = {0};

    cin >> s1 >> s2;
    int cnt1=0, cnt2 =0;
    for(int i=s1.length()-1; i >=0; i--){
        p1[cnt1++] = s1[i];
        p2[cnt2++] = s2[i];
    }

    int T1 = stoi(p1);
    int T2 = stoi(p2);

    if(T1 > T2) cout <<T1;
    else cout << T2;

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

int main(){
    string s;
    getline(cin,s);

    if(s.empty()){
        cout << 0;
        return 0;
    }

    int cnt = 1;

    for(int i=0; i<s.length(); i++){
        if(s[i] == ' '){
            cnt++;    
        }
    }
    if(s[0] == ' ') cnt--;
    if(s[s.length()-1] == ' ') cnt--;
    cout << cnt;
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

int main(){
    string s;    
    cin >> s;

    int a[26]={0,};
    int max = 0;
    int cnt;
    int index;

    transform(s.begin(),s.end(),s.begin(),::toupper);

    for(int i=0; i<s.length(); i++){
        a[s[i] - 'A']++;
    }

    for(int i=0; i<26; i++){
        if(max < a[i]){
            max = a[i];
            cnt = 0;
            index = i;
        }
        if(max == a[i]){
            cnt++;
        }
    }

    if(cnt > 1) cout << "?";
    else cout << (char)(index + 'A');
    
    return 0;
}

#include <iostream>
using namespace std;

int main(){
    int T,R,len;
    string s;
    cin >> T;
    for(int i=0; i<T; i++){
        cin >> R;
        cin >> s;
        for(int j = 0; j < s.length(); j++){
            for(int k = 0; k < R; k++){
                cout << s[j];
            }
        }
        cout << endl;
    }


}

#include <iostream>

using namespace std;

void show(string arr){
    string check = "abcdefghijklmnopqrstuvwxyz";
    for(int i=0; i < check.length(); i++){
            if(arr.find(check[i]) == string::npos) cout << -1 << " ";
            else{
                cout << arr.find(check[i]) << " ";
                continue;
            }
    }
}


int main(){
    string arr;

    cin >> arr;

    show(arr);

    return 0;
}