접근지정자, getter, setter

접근지정자

기본 public = 모든 파일 접근 가능

언더스코어를 붙이면 private = 해당 파일만 접근 가능 (클래스 x)

class Animal{
    String _name;
}

class Test {
    void play(){
        Animal a2 = Animal();
        a2._name = "원숭이"; // 같은 파일이기에 접근 가능
    }
}
main(){
    // new 생략 가능
    Animal a1 = Animal();
    a1._name = "호랑이"; // 같은 파일이기에 접근 가능
}

생성자, getter, setter

생성자

car.dart

class Car{
    String _name; //private

    // 초기화 생성자
    Car(this._name){}

    // 초기 생성자 필요없을때
    Car.origin()

    // getter
    String getName(){
        return _name;
    }
}

main.dart

import 'cart.dart';

main(){
    // private에 접근하기위해 초기화 생성자 필요
    Car c = Car("아반떼");
    // 초기 생성자 없이 불러오기
    Car c2 = Car.origin();
}

getter

car.dart

class Car{
    String _name; //private

    // 초기화 생성자
    Car(this._name){}

    // getter
    String getName(){
        return _name;
    }
    // getter 축약
    String get name{
        return _name;
    }
}

main.dart

import 'cart.dart';

main(){
    // private에 접근하기위해 초기화 생성자 필요
    Car c = Car("아반떼");
    // 호출
    // getter 축약법
    print(c.name); 
}

setter

car.dart

class Car{
    String _name; //private

    // 초기화 생성자
    Car(this._name){}

    //setter
    setName(String value){
        _name = value;
    }
    //setter 축약법
    set name(String value){
        _name = value;
    }
}

main.dart

import 'cart.dart';

main(){
    Car c = Car();
    // setter 축약법
    c.name = '아반떼';
}

참고

https://www.youtube.com/watch?v=mdjp2knKMeg&list=PL93mKxaRDidGEaUXprXqhNvSW02xCjLZI&index=15

클래스 특징

클래스

1. dart의 모든 것들은 1급 객체이다.
2. class는 여러가지 데이터를 저장할 수 있다.

class Dog{
    var name = "초롱이";
    var age = 2;
    void sound(){
        print("멍");
    }
}

3. class는 메모리에 뜨지 않는다.
4. class는 개발자가 메모리에 직접 올려야 한다. (new연산자)

main() {
    Dog d1 = new Dog(); // new 됐다는 것은 메모리에 로드 됐다는 뜻(인스턴스화)
    Dog d2 = new Dog();
}

Cascade 연산자

class User{
    var id;
    var name;
    var phone;
}
main() {
    User u = new User()
    ..id = 1
    ..name = '홍길동'
    ..phone = '123456'

    u.name = '홍길동'; //위와 동일

}

오버로딩 대체

class User{
    var id;
    var name;
    var phone;

    // 생성자로 초기화
    User(){
        id = 2;
    }

    // 오버로딩 불가능
    User(var name){

    } // 에러

    // 오버로딩 대체해서 이름 있는 생성자
    User().second(){
        id = 3;
        name = '임꺽정';
        phone = '4321432';
    }
}
main() {
    User u = new User()
    ..id = 1
    ..name = '홍길동'
    ..phone = '123456'

    u.name = '홍길동'; //위와 동일

    //이름있는 생성자 호출
    User u2 = new User.second();

}

참고

https://www.youtube.com/watch?v=1IafJ4Lg2fM&list=PL93mKxaRDidGEaUXprXqhNvSW02xCjLZI&index=14

final 과 const 차이

final

한번 값을 대입하면 변경할 수 없다.

실행 중에 값이 결정

final String choose = "볶음밥";

void main(){
    print(choose)
    choose = "짬뽕"; // 에러
}

const

한번 값을 대입하면 변경할 수 없다.

컴파일 할 때 값이 결정된다.

const String choose = "볶음밥";

void main(){
    print(choose)
    choose = "짬뽕"; // 에러
}

예시

어떤 프로그램이 실행될 때 시간에 대한 로그 남기고 싶음

var log = DateTime.now()
final var log = DateTime.now()

const var log = DateTime.now() // 에러

언제 실행될지 모르니 실행 중 값이 결정되는 final은 오류가 안나지만 컴파일할 때 값이 결정되는 const는 오류

참고

https://www.youtube.com/watch?v=QV_yNEay5qo&list=PL93mKxaRDidGEaUXprXqhNvSW02xCjLZI&index=13

반복문과 깊은 복사

반복문

기본 for 문

var list = [1, 2, 3, 4];

for(var i=0; i<list.length; i++){

print(list[i]);

}

for in 문

• 배열의 끝까지 돌 때 사용

for(var e in list){

print(e);

}

forEach 문 ( 권장 x )

• for in 문과 동일

list.forEach((e) => print(e));



list.forEach((e) {

print(e);

});

배열 복사

얕은 복사 ( 주소 복사 )

• list[0] = 1 일때 얕은 복사 후 list[0]을 10으로 바꾸면 newLIst[0]도 10으로 바뀜
• 같은 공간을 참조하고 있기 때문

var newList = list; // 주소 복사

깊은 복사 ( 배열 복사 )

• map
• 반복해서 값을 리턴해주는데 값을 연산해서 리턴 가능

var mapList = list.map((e) => e + 1 );

깊은 복사 ( 스프레드 연산자 )

• 연산 불가능
• 그러나 삽입할때 유용

var spreadList = [...list];

var spreadList = [10, ...list, 100];

필터링 후 깊은 복사

• true 가 리턴된 값만 리스트에 넣음

var filterList = list.where((e) => e == 2);

정리

기본 반복 : 일반 for 문, for in 문

반복 후 리턴 : map

반복 후 어떤 값을 걸러내고 싶을 때 : where

값 변경 시에 깊은 복사 → 주소가 달라야 플러터나 리액트에서 그림을 다시 그림

참고

https://www.youtube.com/watch?v=s8xUCD0IxIo&list=PL93mKxaRDidGEaUXprXqhNvSW02xCjLZI&index=11

익명함수와 화살표 함수

익명함수

dart는 리턴타입 정의 안해도 됨

dart는 메서드가 1급 객체이기 때문에 Function 타입 변수에 저장할 수 있음

Function 타입 뿐만 아니라 var, dynamic 에도 가능

변수이기 때문에 세미콜론으로 닫아줘야함

Function greet = bye() {
    print("bye");
};

위에서 Function 변수의 이름 greet으로 메서드를 찾아갈 것이기 때문에 bye라는 함수 명이 필요가 없음

Function greet = () {
    print("bye");
};

( ){ ... }; 부분이 익명 함수

화살표함수

함수가 가지고 있는 내부 스택(코드블럭 == 중괄호{ } 부분) 한줄일때 화살표 함수 사용

Function add = () {
    return 1+1;
}

int add() => 1+1; // return 키워드 생략 가능

정리

일반 메서드

int sum(){
    return 10;
}

익명함수를 저장하는 변수

• 일반 메서드를 익명 함수로 변경해서 변수에 저장
• 변수의 타입에 함수를 저장할 것이라면 Function(Type), var(Type), dynamic(Type)

Function sum2 = () {
    return 10;
}

화살표함수

• 일반 메서드를 생성할때 한줄 밖에 안된다면 그냥 { }와 return을 생략하고 => 화살표 사용

int sum3() => 10;

화살표 함수를 저장하는 변수

Function sum4 = () => 10;

참고

https://www.youtube.com/watch?v=S170Po5mino&list=PL93mKxaRDidGEaUXprXqhNvSW02xCjLZI&index=9

정렬 알고리즘

정렬

데이터를 특정한 기준에 따라 순서대로 정렬

선택 정렬

가장 작은 데이터를 선택해 맨 앞에 있는 데이터와 바꾸는 것을 반복

array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

for i in range(len(array)):
    min_index = i # 가장 작은 원소의 인덱스
    for j in range(i+1, len(array)):
        if array[min_index] > array[j]:
            min_index = j
    array[i], array[min_index] = array[min_index], array[i] # 스와프

삽입 정렬

처리되지 않은 데이터를 하나씩 골라 적절한 위치에 삽입

array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

for i in range(1, len(array)):
    for j in range(i, 0, -1): # 인덱스 i 부터 1까지 1씩 감소하며 반복
        if array[j] < array[j-1]: # 한칸씩 왼쪽으로 이동
            array[j], array[j-1] = array[j-1], array[j]
        else: # 자기보다 작은 데이터를 만나면 그 위치에서 멈춤
            break

퀵 정렬

기준 데이터를 설정하고 그 기준보다 큰 데이터와 작은 데이터의 위치를 바꾸는 방법

1. 첫번째 데이터를 기준으로
2. 왼쪽에서 기준 보다 작은 수 선택
3. 오른쪽에서 기준 보다 큰 수 선택
4. 선택된 수 서로 위치 변경
5. 2~3 반복하며 범위가 겹칠때 작은 수와 기준 위치 변경 ( 분할 )
6. 바뀐 기준을 기준으로 왼쪽 묶음과 오른쪽 묶음으로 나눠 1~5를 재귀적으로 반복

array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

def quick_sort(array, start, end):
    if start >= end: # 원소가 1개인 경우 종료
        return
    pivot = start # pivot는 첫번째 원소
    left = start + 1
    right = end
    while(left <= right):
        # pivot보다 큰 데이터를 찾을 때까지 반복
        while(left <= end and array[left] <= array[pivot]):
            left += 1
        # pivot보다 작은 데이터를 찾을때까지 반복
        while(right > start and array[right] >= array[pivot]):
            right -= 1
        if(left > right): # 엇갈렸다면 작은 데이터와 pivot을 교체
            array[right], array[pivot] = array[pivot], array[right]
        else:
            array[left], array[right] = array[right], array[left]
    # 분할 이후 왼쪽 부분과 오른쪽 부분에서 각각 정렬 수행
    quick_sort(array, start, right -1)
    quick_sort(array, right + 1, end)

quick_sort(array, 0, len(array) -1)

• list comprehension 기법 사용

array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]

def quick_sort(array):
    # 리스트가 하나 이하의 원소만을 담고 있다면 종료
    if len(array) <= 1:
        return array
    pivot = array[0] # 피벗은 첫번째 원소
    tail = array[1:] # 피벗을 제외한 리스트

    left_side = [ x for x in tail if x <= pivot ] # 분할된 왼쪽 부분
    right_side = [ x for x in tail if x > pivot ] # 분할된 오른쪽 부분

    # 분할 이후 왼쪽 부분과 오른쪽 부분에서 각각 정렬을 수행하고 전체 리스트 반환
    return quick_sort(left_side) + [ pivot ] + quick_sort(right_side)

print(quick_sort(array))

계수 정렬

데이터의 크기 범위가 제한되어 정수 형태로 표현할 수 있을 때 사용

array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8, 0, 3, 1, 6, 2, 4, 8]

# 모든 범위를 포함하는 리스트 선언 (모든 값은 0으로 초기화)
count = [0] * (max(array)+1)

for i in range(len(array)):
    count[array[i]] += 1 # 각 데이터에 해당하는 인덱스의 값 증가

for i in range(len(count)): # 리스트에 기록된 정렬 정보 확인
    for j in range(count[i]):
        print(i, end=' ') # 띄어쓰기를 구분으로 등장한 횟수만큼 인덱스 출력

연습문제

두 배열의 원소 교체

• 동빈이는 두개의 배열 A와 B를 가지고 있습니다. 두 배열은 N개의 원소로 구성되어 있으며, 배열의 원소는 모두 자연수입니다.
• 동빈이는 최대 K번의 바꿔치기 연산을 수행할 수 있는데 바꿔치기 연산이란 배열 A에 있는 원소 하나와 배열 B에 있는 원소 하나를 골라서 두 원소를 서로 바꾸는 것을 말합니다
• 동빈이의 최종 목표는 배열 A의 모든 원소의 합이 최대가 되도록 하는 것입니다.
• N, K, 그리고 배열 A, B의 정보가 주어졌을 때, 최대 K번의 바꿔치기 연산을 수행하여 만들 수 있는 배열 A의 모든 원소의 합의 최댓값을 출력하는 프로그램을 작성하세요
• 예를 들어 N = 5, K = 3
  • 배열 A = [1, 2, 5, 4, 3]
  • 배열 B = [5, 5, 6, 6, 5]
• 이 경우 다음과 같이 3번의 연산 수행할 수 있습니다.
  • 연산 1) 배열 A의 원소 '1'과 배열 B의 원소 '6'을 바꾸기
  • 연산 2) 배열 A의 원소 '2'과 배열 B의 원소 '6'을 바꾸기
  • 연산 3) 배열 A의 원소 '3'과 배열 B의 원소 '5'을 바꾸기
• 세 번의 연산 이후 배열 A와 B는 다음과 같이 구성될 것입니다.
  • 배열 A = [6, 6, 5, 4, 5]
  • 배열 B = [3, 5, 1, 2, 5]
• 이때 배열 A의 모든 원소 합은 26이 되며 이보다 더 합을 크게 만들 수 없습니다.

입력조건

• 첫번째 줄에 N, K가 공백을 기준으로 구분되어 입력 ( 1 ≤ N ≤ 100,000 , 0 ≤ K ≤ N )
• 두번째 줄에 배열 A의 원소들이 공백을 기준으로 구분되어 입력됩니다. 모든 원소는 10,000,000보다 작은 자연수 입니다.
• 세번째 줄에 배열 B의 원소들이 공백을 기준으로 구분되어 입력됩니다. 모든 원소는 10,000,000보다 작은 자연수 입니다.

출력조건

• 최대 K번의 바꿔치기 연산을 수행하여 만들 수 있는 배열 A의 모든 원소의 합의 최댓값을 출력합니다.

입력예시

5 3

1 2 5 4 3

5 5 6 6 5

출력예시

26

문제 풀이

핵심아이디어

매번 배열 A에서 가장 작은 원소를 골라서, 배열 B에서 가장 큰 원소와 교체

n, k = map(int, input().split()) # n,k를 입력 받기
a = list(map(int, input().split())) # 배열 A
b = list(map(int, input().split())) # 배열 B

a.sort() # 배열 A 오름차순 정렬
b.sort(reverse=True) # 배열 B 내림차순 정렬

# 첫번째 인덱스부터 확인하며, 두 배열의 원소를 최대 K번 비교
for i in range(k):
    # A의 원소가 B의 원소보다 작은 경우
    if a[i] < b[i]:
        # 두 원소 교체
        a[i], b[i] = b[i], a[i]
    else: # A의 원소가 B의 원소보다 크거나 같을때 반복문을 탈출
        break

print(sum(a)) # 배열 A의 모든 원소의 합 출력

참고

[한빛미디어] 이것이 취업을 위한 코딩 테스트다 with 파이썬 (나동빈 저)