기존 노트북이었던 한성 TFG-13S의 갑갑한 화면에서 벗어나고 싶어 구매했습니다.

램 8GB 추가하고, SSD 512GB로 교체했습니다.

<장점>

1. CPU 일단, CPU가 좋습니다. 웹은 몰라도 앱은 CPU 안좋으면 속터지죠. 근데 intel 12세대 i5-H면 말다했죠.

2. 디스플레이 16:10비율로 16인치인데, 게다가 논글레어입니다! OLED 색감 좋다해도 개발하는데 자기 얼굴 반사되면 좋을게 없죠. 눈 피로도도 올라가고요. 생각보다 논글 품질 괜찮습니다. 사진 보면 vsc 기준 글자 사이즈 19인데도 화면에 많이 들어가죠 ㅎㅎ NSTC 45이지만, 코딩만 한다면 색재현율이 필요 없죠. 이전 노트북과 비교했을 때 유튜브나 영화볼 때 뭐가 다른지 모르겠습니다.(이전 놑북도 NSTC 45였을거 같은.. 쿨럭)

3. 확장성 8GB 온보드, 하나 더 확장 가능합니다.

4. 발열 및 팬 균형잡힌 모드로 할 땐 전혀 소리가 들리지 않습니다. 발열관리도 준수합니다.

5. 지문 인식 WIindow11 들어갈 때마다 비번 쳐야하는 거 짜증나더군요. 근데 얘는 지문인식 들어있어서 갤럭시처럼 손만 대면 로긴 됩니다. 너무 편하고, 보안도 안심이 됩니다.

<단점>

1. SSD, RAM 기본 장착 장점이자 단점. 원래 있는 사람 교체해서 가성비 극강으로 할 수 있다. SSD 256GB는 프로그램 몇개 깖면 금방이죠. RAM 8GB도 느리고, 프로그램 많이 못띄워서 불편합니다. 정확힌 모르지만, SSD 512GB, RAM 8GB 합해서 싼걸로 6만원 안에서 사서 교체 및 추가 하면 될겁니다.

2. 무게

3. 9kg로 이전 노트북인 1.35kg보다(13.5인치)는 확실히 묵직하더군요. 이정도는 가격대와 16인치라는 점을 생각하면 감당해야 할 것 같습니다.

4. 충전 PD 충전 안됩니다. 가격대 생각하고 감안했습니다.

4. 스피커 베이스 라인 아쉽습니다. 외부 스피커 사용합니다.

종합적으로 저에겐 너무나 만족스러운 노트북이고, 이가격이면 다른 초보 개발자에게도 추천할 것 같습니다.

https://pdi-mz-support.zendesk.com/hc/ko/articles/360058069971--Gmail-%EC%88%98%EC%8B%A0%EB%90%98%EB%8A%94-%EB%A9%94%EC%9D%BC-%EC%9E%90%EB%8F%99-%EC%A0%84%EB%8B%AC-Forwarding-%EC%84%A4%EC%A0%95%ED%95%98%EA%B8%B0

위의 1단계를 완료하고

렌더트리를 형성하기 위해 두가지가 필요하다.

• DOM(Document Object Model) – HTML 요소들의 구조화된 표현
• CSSOM(Cascading Style Sheets Object Model) – 요소들과 연관된 스타일 정보의 구조화된 표현

참고문헌

https://wit.nts-corp.com/2019/02/14/5522#comment-16442

INSTALL_FAILED_INSUFFICIENT_STORAGE 라길래 emulator 종료시킨 후에 다시 실행해보고 했는데도 안된다.

ADB exited with exit code 1에 집중해서 cmd 창에 flutter upgrade를 해준다.

https://stackoverflow.com/questions/57000915/error-adb-exited-with-exit-code-1-performing-streamed-install

https://flutter-ko.dev/docs/development/tools/sdk/

다운그레이드?

3096903c8923608d3c1ccf8058a29c31a2bfbc53 C:\Users\yuleg\libraries\flutter

https://unodev.tistory.com/14

결론은 이거시었다!!

https://daldalhanstory.tistory.com/140

프로젝트 다시 시작할 필요도 없고, 에뮬레이터 안에 있는 데이터만 골라서 직접 삭제하면 됐다. (그전에 실행중인 에뮬레이터 삭제하고) userdata-qemu.img.qcow2 이 파일 삭제하면 된다.

또 안되네..

android/build.gradle에서 최신버전으로 바꿔봐도 안된다.

결국 해결책

안되면 아예 프로젝트 새로 파고, 그전꺼 에뮬레이터랑 에뮬 데이터 지우고.

새로운 시도?

terminal에서 flutter clean 실행하고 다시 run

파일 강제로 삭제하기

procexp64로 ctrl+f 검색해서 qemu로 실행되고 있는 거 kill process 해야 avd에서 실행중인 파일들 종료된다.

우리들은 데이터가 산재한 세상에 살고 있다. 인터넷 기록은 로그로 남고, 우리들 자신의 개인정보가담긴 정보들이 디지털화 되어 어딘가에 저장되어 있다. 그런데, 이러한 데이터는 개인의 정보이기 때문에 직원들이 함부로 열람하거나, 보안 문제로 유출된다면 큰 문제가 생긴다. 따라서, 데이터를 익명화하여 해당 데이터가 특정인 누구에게 귀속되어있는지 알기 힘들게 해야 한다. 이러한 과정을 비식별화라고 한다.

문제는 비식별화 데이터를 보고 누구인지 다시 인식하는 ‘재식별화’가 생각보다 어렵지 않다. 예컨대, 94년 4월 생 남자 김길용씨가 어제 3시 39분에 샘빛한의원에 방문하고, 오늘 4시 15분에 히어로마트에서 우유를 구매했다. 이러한 데이터를 9095년생 남자 id 19203이 어제 36시에 죽전에 위치한 한의원 방문, 오늘 36시에 죽전에 위치한 마트에 방문했다고 하자. 비식별화 작업을 통해 바로 데이터를 식별하긴 어려워졌지만, 만약 이 중 일부의 원본 데이터를 갖고 있다면 이야기는 달라질 수 있다. 예컨대, 죽전에 위치한 의원 원본 데이터를 갖고 있고, ‘9095년생 남자 어제 36시에 죽전에 위치한 한의원 방문’이라는 비식별화된 데이터를 입수했다고 가정하자. 보유한 비식별 데이터에 해당하는 사람의 수를 추리고, 이러한 비식별화된 데이터가 34개 정도 있다면 id19203을 ‘김길용’씨로 특정가능하다. 따라서, 그의 주민번호도 이름과 매칭시켜 악용될 수 있다.

따라서, 이 책에서 다룬 비식별화 뿐 아니라 안전한 다자간 연산(secure multiparty computation)과 동형 암호(homomorphic encryption) 기술로도 진보해야할 것이다.

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

Open-Closed Principle 소프트웨어 개체(클래스, 모듈, 함수 등등)는 확장에 대해 열려 있어야 하고, 수정에 대해서는 닫혀 있어야 한다.

구현 객체를 변경 할 때 클라이언트 코드(interface부)를 변경해야하면 안된다.

DIP

Dependency Inversion Principle 추상화에 의존해야지, 구체화에 의존하면 안된다. 클라이언트가 구현 클래스에 의존하지 말고, 인터페이스에 의존하도록 설계해야 한다.

MemberServiceImpl 파일

private final MemberRepository memberRepository = new MemoryMemberRepository();

• MemoryMemberRepository()라는 구현체에 의존한다.(DIP 위배)

• 따라서, 이 구현체를 다른 구현체로 바꿀 때 클라이언트 쪽 파일인 'MemberServiceImpl 파일'을 수정해야 한다.(OCP 위배)

해결 방법

추후 추가

• 목적 class의 argument 접근제한자를 private으로 두어 class파일 내부에서만 접근 가능하도록 한다. 이를 main파일 에서 접근하기 위해서 get(), set()함수를 사용해야 한다.

• 역할 get(), set()함수의 접근 제한자는 public이기 때문에 main파일에서도 접근할 수 있다. get()은 저장, set()은 읽기의 역할을 한다.

• 사용 방법 먼저 main에서 obj를 생성한 다음, obj.getArgument()을 사용해서 private으로 보호되어있는 argument값을 가져온다.

  main 파일

  import kr.tpc.BookVO2;
  

public class TPC12 {

public static void main(String[] args) {
    BookVO2 b1=new BookVO2();

// System.out.println(b1.title); XXX // title은 private 이기 때문에 main파일에서 바로 접근(.을 통한 접근)이 불가능 하다. System.out.println(b1.getTitle()); // 이러면 초기화한 "제목"이 print된다.

    BookVO2 b2=new BookVO2("자바", 20000, "길벗", 790);
    System.out.print(b2.getTitle()+"\t");
    System.out.print(b2.getPrice());
}

}

## class 파일
```java
package kr.tpc;

public class BookVO2 {
    private String title;
    private int price;
    private String company;
    private int page;

    public BookVO2() {
        this.title="제목";
        this.price=00000;
        this.company="출판사";
        this.page=000;
    }

    public BookVO2(String title, int price, String company, int page) {
        this.title=title;
        this.price=price;
        this.company=company;
        this.page=page;
    }

//  getter & setter
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }
}

Output

제목
자바    20000

여기선 main 파일에서 b1, b2 객체를 생성한 다음, b1.getTitle() b2.getTitle() 등으로 값을 가져왔다.

• 객체를 생성할 때 사용되는 메서드
• 객체 생성 후 객체의 초기화를 하는 역할 수행
• 특징
  • 클래스 이름과 동이한 메서드
  • 메서드의 return type이 없다(void 아님)
  • public 접근 권한을 가진다.(단, private 생성자도 있음)
  • 생성자가 없을 때는 기본 생성자가 만들어 진다. 기본 생성자는 public BookVO2() {}

main 부

import kr.tpc.BookVO2;

public class TPC12 {

    public static void main(String[] args) {
        BookVO2 b1=new BookVO2();

        BookVO2 b2=new BookVO2("자바", 20000, "길벗", 790);
        System.out.print(b2.title+"\t");
        System.out.print(b2.price+"\t");
        System.out.print(b2.company+"\t");
        System.out.println(b2.page);
    }
}

class 부

package kr.tpc;

public class BookVO2 {
    public String title;
    public int price;
    public String company;
    public int page;
    // default constructor method(원래는 생략)


    // 객체지향에서는 함수의 이름이 같아도 argument의 개수 or type이 다르면 서로 다른 함수로 인식해서 error가 발생하지 않는다.
    // default constructor method

    // # 1
    public BookVO2() {
        this.title="제목";
        this.price=00000;
        this.company="출판사";
        this.page=000;
    } // 앞에 내용들은 없어도 된다.
    //warn 생성자가 하나 만들어져 있으면 default 생성자는 자동으로 만들어지지 않는다!!!!
    //그렇기 때문에 바로 위에 constructor method 만드는 작업 해줘야 한다

    // # 2
    // constructor method의 Overloading
    public BookVO2(String title, int price, String company, int page) {
        // 초기화 작업
        this.title=title;
        this.price=price;
        this.company=company;
        this.page=page;
    }

}

#1은 b1에, #2는 b2에 대응된다. #1, #2가 모두 없을 경우(아무런 생성자가 없을 때), public BookVO2() {}라는 기본생성자가 생성된다.

#1이 있으면 b1이 돌아가고 #2가 있으면 b2가 돌아간다.

개발자들이 갖고 있으면 좋은 자격증으로 SQLD를 꼽고 실제로 요즘 시험을 미리 신청해야하고, 다들 많이 보는 '노랑이'책이 동난다는 이야기가 많이 들린다. 개발자가 아니어도 많이 따는 '컴퓨터활용능력시험(컴활)'을 생각해보면 '단순히 SQLD를 따기만 하면 괜찮은가?'라는 생각이 들었다.

컴활을 따고나서 이를 활용하지 않는다면, 금방 엑셀 사용방법을 까먹게 될 것이다. 역시 지식은 활용해야 자신의 것으로 체화할 수 있고, 몸이 기억하게 된다. 노랑이 책은 SQLD를 빠르게 따기엔 최적의 책일 수 있지만, 거기에는 실제 데이터를 활용해보는 코너는 별로 없는 것으로 안다.

반면, 이 책은 공공데이터를 활용해서 실제로 데이터를 다루는 것으로 시작한다. 시험을 위한 '지식 주입'이 아닌, 프로젝트를 하기 위한 '기초 지식'을 쌓는 느낌이다. 훨씬 거부감이 덜하고, 실증적이어서 귀에 쏙쏙 박힌다.

아직 스터디 초반이라 뒤에 자세한 내용까지는 보지 못했지만, 데이터 모델링에 대한 이해를 한 챕터를 할애해서 자세하게 설명해주는 부분이 있어 든든했다. 맨 처음 오라클을 깔 때 자바 버전이 달라서인지 오류나는 부분이 있었는데, 한빛미디어에서 제공한 파일을 다운받아서 하니 호환성 문제도 해결할 수 있어서 좋았다.

SQLD를 따면서 실질적으로 활용할 수 있는 능력을 기르고 싶다면 이 책으로 스터디를 진행하는 걸 강추한다!!

http://www.yes24.com/Product/Goods/103967164

"한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

2) 상속 - 부모 클래스의 변수와 메소드를 자식 클래스가 물려 받아서 쓸 수 있는 것

3) 다형성 - 같은 코드가 다른 행위를 하는 것을 말한다 OverRiding OverLoading 참고 : 링크텍스트

# 17:33~17:53
# 풀리긴 하는데 메모리 초과

# 위아래 번갈아서 하고 합의 최솟값 구하면 되는거 아닌가?
# 이차원 행렬로 1로 채우고 행의 합 구하면 될듯.
import sys
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline

# 종유석 세우기
def solution():
  for i in range(n):
    hight=bar[i]
    if i%2==0:
      for j in range(hight):
        cave[(h-1)-j][i]=1
    else:
      for j in range(hight):
        cave[j][i]=1
  # 파괴할 거 구하기
  destroy_sum=[]
  for i in range(h):
    tmp=sum(cave[i]) # 각 행의 합
    destroy_sum.append(tmp)
  min_v=min(destroy_sum)

  #최소 격파할 값 총 몇개나 있는지
  cnt=0
  for x in destroy_sum:
    if x==min_v:
      cnt+=1
  print(min_v, cnt)



if __name__=="__main__":
  n, h=map(int, input().split())
  cave=[[0]*n for _ in range(h)]
  bar=[]
  for _ in range(n):
    bar.append(int(input().rstrip()))
  solution()

내 풀이2 > 시간 초과

# 17:33~17:53
# 풀리긴 하는데 시간 초과

# 위아래 번갈아서 하고 합의 최솟값 구하면 되는거 아닌가?
# 이차원 행렬로 1로 채우고 행의 합 구하면 될듯.
import sys
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline

# 종유석 세우기
def solution():
  destroy_sum=[] # 개똥벌레(행)마다 destroy해야할 개수 > 0번부터 h-1까지. 위에서부터.
  for i in range(h): # 몇번째 개똥벌레(행)
    tmp=0
    for j in range(n):
      hight=bar[j]
      if j%2==0:
        if hight>=(i+1):
          tmp+=1
      else:
        if h-hight<=i:
          tmp+=1
    destroy_sum.append(tmp)
  # 파괴할 거 구하기

  min_v=min(destroy_sum)

  #최소 격파할 값 총 몇개나 있는지
  cnt=0
  for x in destroy_sum:
    if x==min_v:
      cnt+=1
  print(min_v, cnt)



if __name__=="__main__":
  n, h=map(int, input().split())
  bar=[]
  for _ in range(n):
    bar.append(int(input().rstrip()))
  solution()

문제점

곧이 곧대로 이차원 배열 만들어서 풀면 메모리 초과, 그렇다고 이차원 배열 만들지 않고 일일이 사이즈 비교하면 시간초과.

시간초과 예상

(2 ≤ N ≤ 200,000, 2 ≤ H ≤ 500,000) 그럼 N>= 100,000으로 볼 수 있다.

1초당 다음과 같다.

그럼 시간 복잡도가 최대 O(N)이어야 하는데, 여기서는 O(N²) 이므로 시간초과 될 것이다.

모범답안

# 모범답안
import sys
input = sys.stdin.readline

n, h = map(int, input().split(" "))

# 누적합 이용
lines = [0] * h

for i in range(n):
    high = int(input())
    # 석순
    if i % 2 == 0:
        lines[h - high] += 1
    # 종유석
    else:
        lines[0] += 1
        lines[high] -= 1

# 누적합
for i in range(1, h):
    lines[i] += lines[i - 1]

# 최소값 체크 및 최소값 갯수 체크
count = 0
low = min(lines)
for i in lines:
    if i == low:
        count += 1

print(low, count)

풀이

시작 부분과 끝부분을 lines에 +=1 과 -=1로 표시한다. 누적합을 할 때 밑에서부터 하기 때문에, 1) 홀수일 땐 아래서부터 시작하니까 lines[0]+=1; lines[high]-=1로 처음과 끝 부분을 표시한다. 2) 짝수일 땐 어차피 마지막까지(맨 위까지) 막대기가 존재하니까 lines[high-h]+=1로 더해주고 만다. 그래서 lines[i] += lines[i - 1]로 누적합을 하면 겹쳐져 있는 송판 개수가 나온다.

idea

송판 부수기 같은 이미지: 일일이 다 계산하지 말고, 처음과 끝 부분을 일차원 배열에 +=1과 -=1로 표시해서 누적합해주자.

모범답안 보고 수정한 내 풀이

# 모범답안 보고 수정한 내 풀이
import sys
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline

# 증가하는 곳, 감소하는 곳 체크
def solution():
  cave=[0]*h
  for i in range(n):
    high=bar[i]
    if i%2==0:
      cave[h-high]+=1
    else:
      cave[0]+=1
      cave[high]-=1
  # 누적합 구하기
  for i in range(h-1):
    cave[i+1]+=cave[i]

  # 최소값과 그 빈도 구하기
  min_v=min(cave)
  cnt=0
  for x in cave:
    if x==min_v:
      cnt+=1
  print(min_v, cnt)

if __name__=="__main__":
  n, h=map(int, input().split())
  bar=[]
  for _ in range(n):
    bar.append(int(input().rstrip()))
  solution()

main 부분

import kr.tpc.BookVO2;

public class TPC12 {

    public static void main(String[] args) {
        BookVO2 b1=new BookVO2();

        BookVO2 b2=new BookVO2("자바", 20000, "길벗", 790);
        System.out.print(b2.title+"\t");
        System.out.print(b2.price+"\t");
        System.out.print(b2.company+"\t");
        System.out.println(b2.page);
    }
}

class로 객체 modeling한 부분

package kr.tpc;

public class BookVO2 {
    public String title;
    public int price;
    public String company;
    public int page;
    // default constructor method(원래는 생략)


    // 객체지향에서는 함수의 이름이 같아도 argument의 개수 or type이 다르면 서로 다른 함수로 인식해서 error가 발생하지 않는다.
    // default constructor method
    public BookVO2() {
//        this.title="제목";
//        this.price=00000;
//        this.company="출판사";
//        this.page=000;
    } // 앞에 내용들은 없어도 된다.
    //warn 생성자가 하나 만들어져 있으면 default 생성자는 자동으로 만들어지지 않는다!!!!
    //그렇기 때문에 바로 위에 constructor method 만드는 작업 해줘야 한다.

    // constructor method의 Overloading
    public BookVO2(String title, int price, String company, int page) {
        // 초기화 작업
        this.title=title;
        this.price=price;
        this.company=company;
        this.page=page;
    }

}

b1, b2가 모두 있을 땐 BookVO2()가 두 번 서로 다르게 사용되기 때문에 overloading이된다. 이 때 overloading을 위해 class에서 public BookVO2(String title, int price, String company, int page)를 정의하게 된다. 이로 인해 자동을 생성되던 default constructor는 생성되지 않는다.

따라서 BookVO2(), 즉 b1=new BookVO2()를 사용하기 위해서는 BookVO2()를 인위적으로 초기화하는 부분이 필요하다. 그래서 class 안에 public BookVO2() {}이 필요하다. 이게 없으면 main에서 b2=new BookVO2("자바", 20000, "길벗", 790);는 잘 실행되지만, b1=new BookVO2()는 실행되지 않아 error가 발생한다.

참고 : overloading을 하는 이유

java는 객체지향언어이기 때문에 다양한 method를 class로 만들어 확인한다. 이 때 여러가지 타입의 데이터를 주고 받거나, 비슷한 기능을 하는 것을 하나의 method name으로 만들어 활용할 수 있다. 예컨데 println()으로 int, String, float 등 여러가지 datatype을 출력할 수 있다. 이를 위해 println()이라는 이름으로 서로 다른 datatype을 argument로 갖는 method를 겹친다. 효용은 method를 사용할 때와 만들때 모두 간편해진다는 것이다.

Overloading의 정적 바인딩

• 제기될 수 있는 problem parameter의 타입에 따라 class 내부 method가 갈라져 있다보니 어떤 method에 해당하는지 일일이 찾아야 할 것이다. searching할 때 시간이 걸려 속도가 느려지지 않을까?

• solution : 정적 바인딩 컴파일 할 때 method마다 다른 이름을 할당돼서 호출할 method가 미리 경정되어있다.

따라서 속도와는 관계 없다.

package kr.tpc;

public class calSum {
//    동작(method)으로만 이루어진 객체
//    이건 왜 없어도 잘 작동하나?
//    public calSum() {
//        
//    }

    public void calSum(float a, float b) {
        System.out.println(a+b);
    }
    public void calSum(int a, float b) {
        System.out.println(a+b);
    }
    public void calSum(float a, int b) {
        System.out.println(a+b);
    }
    public void calSum(int a, int b) {
        System.out.println(a+b);
    }
}

여기서 calSum은 컴파일 할 때 calSum_float_float, calSum_int_float... 등으로 서로 다르게 정적 바인딩 된다.

# 16:55~
# 바로
import sys
from collections import deque
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline

def Make_sum_board():
  for i in range(n):
    for j in range(n):
      # j=0일 때 예외처리
      if i==0 and j==0:
        sum_board[i][j]=board[i][j]
      elif j==0:
        sum_board[i][j]=sum_board[i-1][j]+board[i][j]
      else: # 첫번째 라인에서 이거 뭔가 안되는듯.
        if i==0:
           sum_board[i][j]=sum_board[i][j-1]+board[i][j]
        else:
          line_sum=sum_board[i-1][j]-sum_board[i-1][j-1]
          sum_board[i][j]=sum_board[i][j-1]+board[i][j]+line_sum

def Cumul_sum(x1, y1, x2, y2):
  #out of index 오류 방지
  ans=0
  a=sum_board[x2][y2]

  if x1==0:
    b1=0
  else:
    b1=sum_board[x1-1][y2]

  if y1==0:
    b2=0
  else:
    b2=sum_board[x2][y1-1]

  if b1==0 or b2==0:
    c=0
  else:
    c=sum_board[x1-1][y1-1]

  ans=a-b1-b2+c
  return ans


def solution():
  global ans
  # 총합 구하기
  Make_sum_board()

  # 구간합 구하기

  for i in range(m):
    arr=arr_range[i]
    # 인덱스화 하기 위해 -1
    ans_list[i]=Cumul_sum(arr[0]-1, arr[1]-1, arr[2]-1, arr[3]-1)

if __name__=="__main__":
  n, m=map(int, input().split())
  board=[]
  sum_board=[[False]*n for _ in range(n)]
  ans_list=[False]*m

  for _ in range(n):
    board.append(list(map(int, input().split())))
  arr_range=[]
  for _ in range(m):
    arr_range.append(list(map(int, input().split())))
  solution()
  for x in ans_list:
    print(x)

시간이 오래 걸린 이유

• Make_sum_board()와 Cumul_sum() 함수 모두 조건 검토, 예외 처리에 너무 많은 시간 낭비를 했다. 이를 해결하기 위해서는 합을 구한 board의 i, j에 대해서도 0이라는 완충지역을 두어서 예외사항을 최소화 해야 한다.
• 이걸 쉽게 알아보는 방법은 x=0일 경우, y=0일 경우 예외사항이 너무 많이 나오거나, 이 문제처럼 x1, y1, x2, y2 값을 줄 때 처음 번호를 1로 줄 때 알아차리고 0완충지역을 넣어서 간소화 해야 한다.

모범답안

# 모범 답안
# 아이디어는 비슷한 것 같은데 뭐가 차이나는거지?
import sys
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline


N,M = map(int,input().split())
D = [[0 for _ in range(N+1)]]
## 합 좌표 D 만들기
for i in range(1,N+1): # i, j는 합 넣을 곳(D)의 좌표. D[i][j]
    S=0
    d=[0]
    j=0
    for a in list(map(int,input().split())): #바로 읽으면서 이걸 사용해버린다. 어차피 내가 할 프로그래머스는 이렇게 하는 거 아니다.
        S+=a;j+=1
        # d=[0, 1, 3, 6, 10]
        d.append(D[i-1][j]+S)
    D.append(d) 

# 구간합 구하기
for _ in range(M):
    x1,y1,x2,y2=map(int,input().split())
    print(D[x2][y2]-D[x1-1][y2]-D[x2][y1-1]+D[x1-1][y1-1])

구간합 풀이 설명

a에서 b1, b2를 빼주고 겹치는 부분인 c를 다시 더해준다. 그러면 2, 2, 4, 4 인 부분의 구간합을 구할 수 있다.

모범답안 보고 고친 내 풀이

# 모범 답안 보고 수정한 내 답안
# 아이디어는 비슷한 것 같은데 뭐가 차이나는거지?
import sys
sys.stdin=open("input.txt", "r")
input=sys.stdin.readline

# 구간합 구하기
def CumulSum(D):
  for i in range(m):
    x1, y1, x2, y2=scope[i]
    print(D[x2][y2]-D[x1-1][y2]-D[x2][y1-1]+D[x1-1][y1-1])

# D만들기
def solution():
  D=[[0]*(n+1)] # D에 완충 넣어서 Cumul_sum에서 listOutOfRange error 피할 수 있도록.
  for i in range(1, n+1):
    d=[0]
    s=0 # 해당 행 누적합
    for j in range(1, n+1):
      s+=board[i-1][j-1]
      d.append(D[i-1][j]+s) #바로 위에 값이랑, 해당 board값이랑 더해줌.
    D.append(d)
  CumulSum(D)


if __name__=="__main__":
  n, m=map(int, input().split())
  board=[[] for _ in range(n)]
  scope=[[] for _ in range(m)]
  for i in range(n):
    board[i]=list(map(int, input().split()))
  for i in range(m):
    scope[i]=list(map(int, input().split()))
  solution()