예전부터 iOS 개발을 배우고 싶었는데 (그 핑계로 맥북까지 산) 상황이 여의치 않아 이제서야 하나씩 배워보고자 한다.

이 시리즈는 iOS 개발을 한 번도 해보지 않은 현역 개발자의 iOS 개발 공부 여정을 담았다.

1. 환경설정

• 제일 먼저 Create a new Xcode project를 눌러 새로운 프로젝트를 생성해준다.

• 우선 나는 앱 개발을 하고 싶기에 App을 선택해주었다.

• 참고로 제일 상단에 iOS를 클릭하면 다양한 Application들이 나오는데, 그중에서 iMessage App이나 Sticker Pack App이 있었다.
• 이렇게 iMessage를 보낼 때 쓰일 수 있는 App인가보다 (이렇게 게임까지 가능한지는 몰랐다...!)

• 이제 여기에 필요한 내용을 넣어준다.
• Organization Identifier의 경우에는 보통 회사의 도메인을 거꾸로 쓴다고 한다.

• 그러면 어디에 프로젝트를 저장할지 결정해야 하는데, 나는 일단 혼자 공부하는 거라 Git repository를 생성하지는 않았다 (Source Control 박스 uncheck)

• 그러면 이렇게 개발할 수 있는 프로젝트가 생성된다.

2. 화면 구성

1) Content View

• 제일 먼저 Content View에서는 내가 짠 코드가 실제로 디바이스에서는 어떻게 보이는지 확인할 수 있다.

• 참고로 전체 화면 오른쪽 상단에 위와 같은 아이콘이 있는데

  • 두 번째 아이콘: 화면 구성을 바꿀 수 있다 (Canvas를 uncheck하면 Content View가 사라진다)
  • 세 번째 아이콘: 현재 화면 구성대로 똑같은 화면을 더 추가한다

• Content View의 오른쪽 하단에 보면 이러한 아이콘이 있는데

  • (-)기호: 디바이스 크기를 줄인다
  • (1)기호: 느낌상 1배율로 보여주는 것 같은데 확실하지 않다
  • (□)기호: 화면에 꽉차게 보여준다
  • (+)기호: 디바이스 크기를 늘린다

• Content View의 왼쪽 하단에 보면 이러한 아이콘들이 있는데

  • 첫 번째 아이콘: 기본적으로 보여지는 화면
  • 두 번째 아이콘: 디바이스에서 각 요소를 클릭해서 속성을 확인하거나 바꿀 수 있다
  • 세 번째 아이콘: -Color Scheme Variants: Light모드와 Dark모드를 한눈에 볼 수 있다 -Orientation Variants: 디바이스를 돌렸을 때 모습까지도 한눈에 볼 수 있다 -Dynamic Type Variants: 다양한 디바이스 모습을 한눈에 볼 수 있다

2) Navigator

• 프로젝트가 생성되면 자동으로 만들어지는 파일들을 한눈에 볼 수 있다.

• 구성

  • Assets: 앱에 들어갈 색깔, 이미지 등을 설정할 수 있다
  • ContentView: 위에서 설명한 미리보기다
  • SampleTests: 기능적인 테스트를 하는 용도인 것 같다 (나중에 공부해볼 것)
  • SampleUITests: UI 테스트를 하는 용도인 것 같다 (나중에 공부해볼 것)

• ContentView 파일을 선택한다
• 오른쪽 상단에 + 아이콘을 누르면 다양한 요소들을 선택할 수 있는데
• 그 중에서 원하는 아이콘을 선택해 코드로 드래그를 해준다
• 그러면 이렇게 버튼이 추가된다
• 이런 식으로 UI 요소를 추가할 수 있는 것 같다! (상당히 편리한듯🤔)

다음 번에는 UI 작업을 해보겠다🔜

주차장 https://www.acmicpc.net/problem/5464

✔️ 문제에 나와있는 대로 구현하면 됨 ✔️ 차가 빠질 때 요금 산정

#include <iostream>
#include <queue>

#define MAXN 100
#define MAXM 2001

using namespace std;

int N, M;
bool isTaken[MAXN + 10];
int parkingFee[MAXN + 10];
int carsWeight[MAXM + 10];
int parkingPlace[MAXM + 10];

int getParkingPlace()
{
    for (int i = 1; i <= N; i++)
    {
        if (!isTaken[i])
        {
            return i;
        }
    }
    return 0;
}

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

    cin >> N >> M;
    for (int i = 1; i <= N; i++)
    {
        cin >> parkingFee[i];
    }

    for (int i = 1; i <= M; i++)
    {
        cin >> carsWeight[i];
    }

    int total = 0;
    queue<int> waitingQ;
    for (int i = 0; i < 2 * M; i++)
    {
        int input;
        cin >> input;
        if (input > 0)
        {
            int place = getParkingPlace();
            if (place != 0)
            {
                parkingPlace[input] = place;
                isTaken[place] = true;
            }
            else
            {
                waitingQ.push(input);
            }
        }
        else
        {
            int carNum = (-1) * input;
            int place = parkingPlace[carNum];
            total += parkingFee[place] * carsWeight[carNum];
            parkingPlace[carNum] = 0;
            isTaken[place] = false;

            if (!waitingQ.empty())
            {
                parkingPlace[waitingQ.front()] = place;
                isTaken[place] = true;
                waitingQ.pop();
            }
        }
    }
    cout << total;
    return 0;
}

색종이 https://www.acmicpc.net/problem/2563

✔️ 색종이의 영역을 배열에 표시 (True: 색종이 있음, False: 색종이 없음)

#include <iostream>

#define MAX 100

using namespace std;

bool paper[MAX + 10][MAX + 10];
int N;

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

    cin >> N;
    while (N--)
    {
        int x, y;
        cin >> x >> y;
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                paper[y + i][x + j] = true;
            }
        }
    }

    int ans = 0;
    for (int i = 0; i < 100; i++)
    {
        for (int j = 0; j < 100; j++)
        {
            if (paper[i][j])
            {
                ans++;
            }
        }
    }

    cout << ans;
    return 0;
}

코딩테스트 연습 - 가장 큰 수 https://school.programmers.co.kr/learn/courses/30/lessons/42746

✔️ 정렬을 해야 하는 배열의 길이가 최대 100,000이므로 시간 복잡도가 O(N^2)인 정렬을 쓰면 안된다. ✔️ C++ 라이브러리 중에 <algorithm>의 sort 함수를 사용하면 시간 복잡도가 O(NlogN)이다. ✔️ 입력으로 주어지는 배열에는 같은 숫자가 중복해서 들어갈 수 있다. ✔️ 입력으로 주어지는 배열에 다 0만 있다면 답은 0이 되어야 한다. (0000… 아님!)

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

bool compare(int num1, int num2)
{
    string str1 = to_string(num1);
    string str2 = to_string(num2);

    string temp1 = "";
    temp1 += str1;
    temp1 += str2;

    string temp2 = "";
    temp2 += str2;
    temp2 += str1;

    int len = str1.length() + str2.length();

    for (int i = 0; i < len; i++)
    {
        if (temp1[i] > temp2[i])
        {
            return true;
        }
        else if (temp1[i] < temp2[i])
        {
            return false;
        }
    }

    return false;
}

string solution(vector<int> numbers) {
    string answer = "";

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

    for (int i = 0; i < numbers.size(); i++)
    {
        if (answer == "0" && numbers[i] == 0)
        {
            answer = "0";
        }
        else
        {
           answer += to_string(numbers[i]); 
        }
    }

    return answer;
}

• build.gradle (Module)에 아래 코드 추가

android {
        ...
        viewBinding {
            enabled = true
        }
    }

2. 사용

• MainActivity.kt에 아래 코드 추가
  • 해당하는 xml 파일에 따라서 이름이 바뀜 (e.g. activity_main.xml -> ActivityMainBinding)

    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        binding.apply {
            btnSubmit.setOnClickListener {
                val name = etName.text.toString()
                tvMessage.text = "Hello! $name"
                etName.setText("")
            }
        }
    }

3. findViewById에 비해 좋은점

① View를 직접 참조하기 때문에 유효하지 않은 View ID로 인해 null 포인터 예외가 발생할 위험이 없음

② 각 바인딩 클래스에 있는 필드의 유형이 XML 파일에서 참조하는 뷰와 일치하므로 클래스 변환 예외가 발생할 위험이 없음

[공식 문서 참고]

1. 뷰 결합

앱 개발을 하다 보면, count 변수를 증가시키는 것과 같은 기능이 필요할 때가 있다. 그러나 화면을 회전시키면 수명 주기때문에 다시 데이터가 초기화된다. 이와 같이 _화면 회전과 같이 구성을 변경할 때도 데이터를 유지_하기 위해 쓰이는 개념이 ViewModel 클래스이다.

1. 필요한 개념

① UI 컨트롤러

User interface (UI) controllers serve as a connection between your UI and any business logic in your application that controls, or is instructed by, that UI. ➡ UI와 비즈니스 로직 사이를 연결해주는 역할

② ViewModel

• 액티비티나 프래그먼트의 데이터를 관리하는 클래스
• 화면 전환이 이루어진 경우, 새로운 인스턴스 owner가 기존에 존재하던 ViewModel에 연결
• LiveData의 형태로 액티비티/프래그먼트의 정보 저장 및 전송

③ LiveData

• 관찰 가능한 데이터 홀더 클래스
• Observer 객체에 UI를 업데이트

2. 구현

1) LiveData 없이 수동으로 업데이트

① ViewModel 클래스 생성 (MainActivityModel.kt)

class MainActivitylModel : ViewModel() {
    var count = 0

    fun updateCount() {
        count++
    }
}

② 액티비티에서 ViewModel 사용

class MainActivity : AppCompatActivity() {
    var count = 0
    private lateinit var viewModel: MainActivitylModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // this는 owner를 의미한다.
        viewModel = ViewModelProvider(this).get(MainActivitylModel::class.java)

        val textView = findViewById<TextView>(R.id.tvCount)
        val button = findViewById<Button>(R.id.btnCount)

        textView.text = viewModel.count.toString()

        button.setOnClickListener {
            viewModel.updateCount()
            textView.text = viewModel.count.toString()
        }
    }
}

2) LiveData를 사용해서 자동으로 업데이트

① ViewModel 클래스 생성 (MainActivityModel.kt)

class MainActivitylModel : ViewModel() {
    var count = MutableLiveData<Int>()

    init {
        count.value = 0
    }

    fun updateCount() {
        // value로 접근해야 한다.
        count.value = (count.value)?.plus(1)
    }
}

② 액티비티에서 ViewModel 사용

class MainActivity : AppCompatActivity() {
    var count = 0
    private lateinit var viewModel: MainActivitylModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        viewModel = ViewModelProvider(this).get(MainActivitylModel::class.java)

        val textView = findViewById<TextView>(R.id.tvCount)
        val button = findViewById<Button>(R.id.btnCount)

        // 값을 자동으로 업데이트 해준다.
        viewModel.count.observe(this, Observer {
            textView.text = it.toString()
        })

        button.setOnClickListener {
            viewModel.updateCount()
        }
    }
}

3. 수명 주기

• 액티비티가 끝날 때까지 메모리에 유지
• 프래그먼트가 분리될 때까지 메모리에 유지
• 위 그림을 보면, 화면 전환이 되면서 onDestroy가 실행되어도 ViewModel은 아직 유지되는 것을 볼 수 있다.

[공식 문서 참고]

1. ViewModel 개요
2. ViewModel
3. LiveData 개요

[유투브 강의 참고]

Android Development(Kotlin) Full Course For Beginners 2022

1) Primary Constructor

• class를 정의할 때 사용
• 사용 예시

class Person constructor(firstName: String) { /*...*/ }

• 만약 annotation이나 visibility modifier가 없으면 constructor 키워드 생략 가능

class Person(firstName: String) { /*...*/ }

• 생성자 안에 초기화 코드를 넣을 수 없으므로 초기화 코드는 init 블록에 작성 필요

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)

    init {
        println("First initializer block that prints $name")
    }

    val secondProperty = "Second property: ${name.length}".also(::println)

    init {
        println("Second initializer block that prints ${name.length}")
    }
}

📌 init 블록은 클래스가 생성되면 가장 먼저 실행된다.

2) Secondary Constructors

• constructor 키워드 필요
• this 키워드를 통해 Primary Constructor에 delegate 필요 (Primary Constructor가 없어도 암시적으로 delegate 가능)
• 사용 예시

class Person(val pets: MutableList<Pet> = mutableListOf())

class Pet {
    constructor(owner: Person) {
        owner.pets.add(this) // adds this pet to the list of its owner's pets
    }
}

클래스 인스턴스 생성

• 코틀린에서는 new 키워드 사용 X
• constructor를 콜해서 인스턴스 생성 (아래 코드 참고)

val invoice = Invoice()

val customer = Customer("Joe Smith")

수명 주기 콜백

1. onCreate()

• Activity를 생성할 때 실행
• 전체 수명 주기 동안 한 번만 발생
• 뒤이어 onStart()와 onResume()이 연달아 실행

2. onStart()

• UI를 관리하는 코드를 초기화

3. onResume()

• 해당 Activity가 foreground에 표시
• 다른 Activity로 이동하거나, 기기 화면이 꺼지면 onPause() 실행

4. onPause()

• 해당 Activity가 foreground에 있지 않을 때 실행

5. onStop()

• 다른 Activity가 화면 전체를 차지할 때 실행

6. onDestroy()

• 사용자가 Activity를 닫을 때 실행 / 화면을 회전할 때 실행 (= 일시적으로 Activity 소멸)

실제 사용 예시

MainActivity와 SecondActivity가 있다고 하자. 수명 주기 콜백을 다 override해서 로그를 찍어보면 다음과 같다.

1) MainActivity 실행

MainActivity : OnCreate MainActivity : OnStart MainActivity : OnResume

2) SecondActivity로 이동

MainActivity : OnPause SecondActivity : OnCreate SecondActivity : OnStart SecondActivity : OnResume MainActivity : OnStop

3) MainActivity로 돌아가기

SecondActivity : OnPause MainActivity : OnRestart MainActivity : OnStart MainActivity : OnResume SecondActivity : OnStop SecondActivity : OnDestroy

📌 onRestart()는 Activity가 정지된 후(onStop()) 다시 시작하기 전에 호출

4) MainActivity에서 화면 회전

MainActivity : OnPause MainActivity : OnStop MainActivity : OnDestroy MainActivity : OnCreate MainActivity : OnStart MainActivity : OnResume

[공식 문서 참고]

1. 활동 수명 주기에 관한 이해

형식은 다음과 같다. Log.i(tag, message)

// 실제 사용 예시
Log.i("MYTAG", "MainActivity : OnCreate")

그리고 실제로 Android Studio 하단에 Logcat을 클릭한 뒤, Info로 설정 -> 돋보기가 있는 입력창에 TAG 이름 입력을 하면 내가 보고 싶은 Log만 볼 수 있다.

이외에도 다양한 로그 클래스들이 있다. Log.e(String, String) (오류, Error) Log.w(String, String) (경고, Warn) Log.i(String, String) (정보, Info) Log.d(String, String) (디버그, Debug) Log.v(String, String) (상세, Verbose)

📍 상세 로그는 앱으로 컴파일하면 안된다. 그리고 오류, 경고, 정보 로그는 런타임에 컴파일이 된 후 사라지지 않는다.

Log.d를 사용하는 것이 더 좋을 것 같다.

[공식 문서 참고]

1. Logcat을 이용한 로그 작성 및 보기

코딩테스트 연습 - 다리를 지나는 트럭 https://programmers.co.kr/learn/courses/30/lessons/42583

✔️ 다리를 건너는 트럭을 위한 큐(crossing_queue) & 대기 트럭을 위한 큐(waiting_queue) 사용 ✔️ 최대 적재량 제한때문에 다른 트럭이 다리 위로 못 올라갈 경우, crossing_queue에 0을 push해서 트럭이 움직이는 것을 표현 ✔️ 대기 트럭이 하나도 없으면 crossing_queue에 -1을 push해서 종결 조건 만들어주기

#include <string>
#include <vector>
#include <queue>

using namespace std;

int solution(int bridge_length, int weight, vector<int> truck_weights) {
    int answer = 0;

    queue<int> waiting_queue;
    for (int i = 0; i < truck_weights.size(); i++)
    {
        waiting_queue.push(truck_weights[i]);
    }

    queue<int> crossing_queue;
    int cur_weight = 0;
    while (1)
    {
        if (!crossing_queue.empty() && crossing_queue.front() == -1 && waiting_queue.empty())
        {
            break;
        }

        while (crossing_queue.size() < bridge_length)
        {
            answer++;

            if (waiting_queue.empty())
            {
                crossing_queue.push(-1);
            }
            else
            {
                if (cur_weight + waiting_queue.front() <= weight)
                {
                    cur_weight += waiting_queue.front();
                    crossing_queue.push(waiting_queue.front());
                    waiting_queue.pop();
                }
                else
                {
                    crossing_queue.push(0);
                }
            }
        }
        cur_weight -= crossing_queue.front();
        crossing_queue.pop();
    }

    answer++;
    return answer;
}

Spring 공식문서에 의하면,

In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC (Inversion of Control) container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. -> Spring IoC에 의해 관리되며, 애플리케이션의 중추를 이루는 객체

📍 Spring IoC (Inversion of Control)? A process in which an object defines its dependencies without creating them -> 어떤 객체가 의존성을 직접 생성하지 않고도 정의할 수 있는 과정

Bean을 등록할 때는 싱글톤 (유일하게 하나만 등록해서 공유함) -> 같은 Bean이면 모두 같은 인스턴스

2. 코드로 보는 Bean

1) Spring Boot 프로젝트 시작

• @SpringBootApplication: 해당 패키지에 있는 모든 Bean 탐색 (@ComponentScan 사용)

@SpringBootApplication
public class BasicBeansApplication {
    public static void main(String[] args) {
        SpringApplication.run(BasicBeansApplication.class, args);

        // 생성되는 모든 Bean들을 보고 싶다면 아래처럼
        // ApplicationContext apc = SpringApplication.run(BasicBeansApplication.class, args);
        // for (String s : apc.getBeanDefinitionNames()) {
        //      System.out.pringln(s);
        // }
    }
}

결과 화면은 아래와 같다.

2) 새로운 Bean 생성

• at(@) annotation 사용

• @Component: 이걸 선언하면 Bean으로 인식되고, @ComponentScan에 의해 인식됨

  • 이름을 지정해주고 싶다면, @Component(value="mycomponent")
  • 개발자가 직접 작성한 클래스를 Bean으로 등록하려 할 때 사용
  • 하위 어노테이션: @Service, @Controller, @Repository
  • 사용 예시는 아래 코드 참고

@Component
public class Customer {
    private String name;
    private Address address;

    public Customer(String name, Address, address) {
        this.name = name;
        this.address = address;
    }

    // getter, setter 생략
}

• @Bean

  • 이름을 지정해주고 싶다면, @Bean(name="myBean")
  • 개발자가 직접 제어할 수 없는 외부 라이브러리를 Bean으로 등록하려 할 때 사용
  • 사용 예시는 아래 코드 참고

@SpringBootApplication
public class BasicBeansApplication {
    public static void main(String[] args) {
        SpringApplication.run(BasicBeansApplication.class, args);
    }
}

// 이렇게 Bean으로 등록을 해놓으면, 원할 때에 String이 초기화됨
@Bean
public String getName() {
    return "Jeanine";
}

📍 아래와 같이 @Service, @Repository 없이 직접 Bean 등록을 할 수 있다. (Config 파일은 @SpringBootApplication이 정의되어 있는 파일과 같은 위치에 생성)

@Configuration
public class SpringConfig {

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }
}

3) Bean 의존성 주입

• @Autowired

  • 클래스 안에서 다른 클래스로 정의된 Bean을 사용하고 싶을 때 선언
  • 객체가 여러 개라면 @Qualifier("Bean이름")를 선언
  • 사용 예시는 아래 코드 참고

@Component(value="addressbean")
public class Address {
}

@Component
public class Customer {
    private String name;

    @Qualifier("addressbean")
    @Autowired
    private Address address;

    // 아래는 생략
}

3. 정리

Spring에서 Bean이란 Spring 컨테이너에 의해 관리되는 클래스의 인스턴스

참고:

• @Bean 어노테이션과 @Component 어노테이션(DI) - 2
• Spring ultimate basics: What are Spring Beans and what is the Spring Container?

그리디(Greedy)란? 지금 가장 최적인 답을 근시안적으로 택하는 알고리즘

Greedy를 푸는 과정

1. 관찰을 통해 탐색 범위를 줄이는 방법을 고안한다.
2. 탐색 범위를 줄여도 올바른 결과를 낸다는 강한 믿음을 가진다.
3. 믿음을 가지고 구현해서 문제를 통과한다.

코딩테스트에서의 추천 전략

Case 1

거의 똑같은 문제를 풀어봤거나 간단한 문제여서 나의 그리디 풀이를 100% 확신한다. -> 짜서 제출해보고, 틀리면 빠르게 손절 (멘탈이 흔들려도 다음 문제로 Go)

Case 2

100% 확신은 없지만 맞는 것 같은 그리디 풀이를 찾았다. -> 일단은 넘어가고 다른 문제를 풀 게 없거나 종료가 20-40분 남은 시점에 코딩 시작

💡 사실 그리디 문제가 아닌데 그리디라고 착각하는 경우가 더 많으니 안되면 넘어가는 전략!

연습 문제

1. 11047번: 동전 0 (링크)

2. 1931번: 회의실배정 (링크)

• 명제: 현재 시간이 t라고 할 때, 시작 시간이 t 이상인 모든 회의 중에서 가장 먼저 끝나는 회의를 택하는 것이 최적해이다.
• _귀류법_으로 증명
  • 현재 시간이 t라고 할 때, 시작 시간이 t 이상인 모든 회의 중에서 가장 먼저 끝나는 회의(A)가 아닌 다른 회의(B)를 택했을 때 더 많은 회의를 배정할 수 있다고 가정
    • 회의 A를 택했을 때 적어도 회의 B를 택했을 때만큼의 회의는 진행할 수 있다는 게 보장
    • 가정이 모순

귀류법이란? 어떤 명제가 참임을 증명하려 할 때 그 명제의 결론을 부정함으로써 가정(假定) 또는 공리(公理) 등이 모순됨을 보여 간접적으로 그 결론이 성립한다는 것을 증명하는 방법

3. 2217번: 로프 (링크)

• 명제: 각 로프가 버틸 수 있는 최대 중량의 최솟값 * 로프의 개수가 정답이다.

코딩테스트 연습 - 짝지어 제거하기 https://programmers.co.kr/learn/courses/30/lessons/12973

✔️ 짝을 찾는 거니까 _스택_을 이용해서 짝을 바로 삭제해버리기

#include <iostream>
#include <string>
#include <stack>

using namespace std;

int solution(string s)
{
    int answer = -1;

    // [실행] 버튼을 누르면 출력 값을 볼 수 있습니다.
    cout << "Hello Cpp" << endl;

    stack<char> stack_str;
    for (int i = 0; i < s.size(); i++)
    {
        if (stack_str.empty())
        {
            stack_str.push(s[i]);
        }
        else
        {
            if (stack_str.top() == s[i])
            {
                stack_str.pop();
            }
            else
            {
                stack_str.push(s[i]);
            }
        }
    }

    if (stack_str.empty())
    {
        answer = 1;
    }
    else
    {
        answer = 0;
    }

    return answer;
}

코딩테스트 연습 - 프린터 https://programmers.co.kr/learn/courses/30/lessons/42587

✔️ 인쇄 대기목록은 queue 사용 ✔️ 인쇄 대기목록의 가장 높은 중요도 체크하는 방법: 변수 따로 빼서 queue 순회하며 체크

#include <string>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

int solution(vector<int> priorities, int location) {
    int answer = 0;

    queue<int> waiting;
    for (int i = 0; i < priorities.size(); i++)
    {
        waiting.push(i);
    }

    int cnt = 1;
    while (1)
    {
        int front = waiting.front();
        waiting.pop();

        int sz = waiting.size();
        int max_priority = -1;
        for (int i = 0; i < sz; i++)
        {
            int cur = waiting.front();
            waiting.pop();
            max_priority = max(max_priority, priorities[cur]);
            waiting.push(cur);
        }

        if (priorities[front] < max_priority)
        {
            waiting.push(front);
        }
        else
        {
            if (front == location)
            {
                answer = cnt;
                break;
            }
            cnt++;
        }
    }

    return answer;
}

• 컨트롤러: 웹 MVC의 컨트롤러 역할
• 서비스: 핵심 비즈니스 로직 구현
• 리포지토리: 데이터베이스에 접근, 도메인 객체를 DB에 저장하고 관리
• 도메인: 비즈니스 도메인 객체 (e.g. 회원, 주문, 쿠폰 등 주로 데이터베이스에 저장하고 관리됨)

1. 비즈니스 요구사항 정리

• 아직 데이터 저장소가 선정되지 않아, 인터페이스로 구현 클래스를 변경할 수 있도록 설계

2. 도메인 생성

• 위와 같이 domain 패키지에 Member 클래스 생성

package hello.hellospring.domain;

public class Member {

    private Long id; // 회원 아이디
    private String name; // 회원 이름

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3. 리포지토리 생성

• 위와 같이 repository 패키지에 MemberRepository 인터페이스와 MemoryMemberRepository 클래스 생성

1) 인터페이스

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.List;
import java.util.Optional;

public interface MemberRepository {
    Member save(Member member); // 회원 정보 저장
    Optional<Member> findById(Long id); // 회원 아이디로 조회
    Optional<Member> findByName(String name); // 회원 이름으로 조회
    List<Member> findAll(); // 회원 정보를 리스트로 반환
}

• Optional의 경우에는 null 값 처리할 때 유용 (참고)

2) 구현 클래스

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {

    // 실무에서는 동시성 문제때문에 ConcurrentHashMap, AtomicLong을 사용하는 경우가 많음
    private static Map<Long, Member> store = new HashMap<>();
    private static long sequence = 0L;

    @Override
    public Member save(Member member) {
        member.setId(++sequence);
        store.put(member.getId(), member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        return Optional.ofNullable(store.get(id));
    }

    @Override
    public Optional<Member> findByName(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }

    @Override
    public List<Member> findAll() {
        // 실무에서는 loop 돌리기 편하게 리스트를 많이 씀
        return new ArrayList<>(store.values());
    }

    public void clearStore() {
        store.clear();
    }
}

4. 리포지토리 테스트

• main 메소드나 컨트롤러로 기능을 실행하면 실행하는 데 오래 걸리고, 반복 실행하기 어렵고, 여러 테스트를 한번에 실행하기 어려움
• JUnit을 사용하자

  간단한 junit 테스트 방법 IntelliJ https://log-laboratory.tistory.com/203

• 위와 같이 test 폴더에 repository 패키지를 만들고, 테스트 클래스 생성

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

class MemoryMemberRepositoryTest {

    MemoryMemberRepository repository = new MemoryMemberRepository();

    @AfterEach
    public void afterEach() {
        // 각 테스트가 실행되는 순서를 지정할 수 없으므로 순서에 대한 의존성을 없애기 위함
        // 이전 테스트의 결과가 다음 테스트에 영향을 미칠 수 있으므로 데이터 삭제 필요
        repository.clearStore();
    }

    @Test
    public void save() {
        Member member = new Member();
        member.setName("spring");
        repository.save(member);

        Member result = repository.findById(member.getId()).get();

        assertThat(member).isEqualTo(result);
    }

    @Test
    public void getByName() {
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();

        assertThat(result).isEqualTo(member1);
    }

    @Test
    public void findAll() {
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        List<Member> result = repository.findAll();

        assertThat(result.size()).isEqualTo(2);
    }
}

5. 서비스 개발

• 서비스 개발 관련된 코드에서 네이밍은 최대한 '비즈니스 용어'를 사용할 것
• 위와 같이 service 패키지에 MemberService 클래스 생성

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;

import java.util.List;
import java.util.Optional;

public class MemberService {
    private final MemberRepository memberRepository = new MemoryMemberRepository();

    public Long join(Member member) {
        // 같은 이름이 있는 중복 회원 X
        validateDuplicateMember(member);

        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m -> {
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
    }

    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById((memberId));
    }
}

• private final과 private static final 참고

6. 서비스 테스트

• 서비스 클래스에 커서를 두고 Ctrl + Shift + T를 누르면 테스트 코드 자동 생성
• 위와 같이 test 폴더에 자동으로 생성됨
• 테스트 코드에서 함수명은 한글로 바꿔도 됨
• 빌드할 때 테스트 코드는 포함되지 않음
• 테스트 코드는 given, when, then 구조로 작성하면 좋음

package hello.hellospring.service;

import hello.hellospring.domain.Member;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;

import hello.hellospring.repository.MemoryMemberRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;

    @BeforeEach
    public void beforeEach() {
        // 테스트를 실행할 때마다 독립적으로 생성
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }

    @AfterEach
    public void afterEach() {
        memberRepository.clearStore();
    }

    @Test
    void join() {
        /* given */
        Member member = new Member();
        member.setName("hello");

        /* when */
        Long saveId = memberService.join(member);

        /* then */
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    public void duplicateException() {
        /* given */
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        /* when */
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        // 두 번째 인자를 실행하여 첫 번째 인자의 예외 타입이 나오는지 확인

        /* then */
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

• 테스트 코드 작성할 때는 예외처리가 잘 되는지 확인하는 게 더 중요!

• MemberService.java 파일을 아래와 같이 수정

    private final MemberRepository memberRepository;
  
    public MemberService(MemberRepository memberRepository) {
        // 외부에서 생성
        this.memberRepository = memberRepository;
    }

참고: [인프런] 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 (김영한)

코딩테스트 연습 - 행렬 테두리 회전하기 https://programmers.co.kr/learn/courses/30/lessons/77485?language=cpp

✔️ 시작점의 원소를 미리 저장해두기 ✔️ 회전하는 방향의 '반대 방향'으로 탐색하면서 2차원 배열 갱신 ✔️ 아이디어 참고용(링크)

#include <string>
#include <vector>
#include <algorithm>

#define MAX 101

using namespace std;

int board[MAX][MAX];
int dirRow[4] = {0, -1, 0, 1}; // 동북서남
int dirCol[4] = {1, 0, -1, 0};

vector<int> solution(int rows, int columns, vector<vector<int>> queries) {
    vector<int> answer;
    for (int i = 1; i <= rows; i++)
    {
        for (int j = 1; j <= columns; j++)
        {
            board[i][j] = (i - 1) * columns + j;
        }
    }

    for (int i = 0; i < queries.size(); i++)
    {
        int x1 = queries[i][0];
        int y1 = queries[i][1];
        int x2 = queries[i][2];
        int y2 = queries[i][3];

        int sz = (x2 - x1 + y2 - y1) * 2;

        int dir = 2;
        int curRow = x1;
        int curCol = y1;

        vector<int> v;
        int temp = board[curRow][curCol];
        for (int j = 0; j < sz; j++)
        {
            if (curRow == x1 && curCol == y1 || curRow == x2 && curCol == y1 || curRow == x2 && curCol == y2 || curRow == x1 && curCol == y2)
            {
                dir = (dir + 1) % 4; 
            }

            if (j == sz - 1)
            {
                v.push_back(temp);
                board[curRow][curCol] = temp;
            }
            else
            {
                int nextRow = curRow + dirRow[dir];
                int nextCol = curCol + dirCol[dir];
                v.push_back(board[nextRow][nextCol]);
                board[curRow][curCol] = board[nextRow][nextCol];
                curRow = nextRow;
                curCol = nextCol;
            }
        }
        sort(v.begin(), v.end());
        answer.push_back(v[0]);
    }
    return answer;
}

1) 웹 서버와 WAS의 개념 이해 2) 스프링(Spring), 스프링 부트(Spring Boot)란? 개념 정리

Spring이란? 자바 기반의 웹 어플리케이션을 만들 수 있는 프레임워크

1. 프로젝트 환경설정

1) spring initializr에서 생성

• 위와 같이 설정해준다.
• Dependencies에도 Spring Web과 Thymeleaf를 추가해준다.
• 다 설정했으면 하단에 GENERATE 버튼을 클릭해 압축 파일을 다운로드한다.

2) IntelliJ에서 작업

• src/main/java/HelloSpringApplication.java 실행 후, localhost:8080에 들어가면 explicit mapping이 안 되어 있다고 뜰 것임

① 정적인 페이지 생성

• 아래와 같이 index.html 파일 생성 코드는 아래 참고

  <!DOCTYPE HTML>
  <html>
  <head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
  </head>
  <body>
  Hello
  <a href="/hello">hello</a>
  </body>
  </html>

② 컨트롤러 생성

• 아래와 같이 HelloController.java 파일 생성
• 코드는 아래 참고 (HelloSpringApplication.java)

  package hello.hellospring.controller;
  

import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping;

@Controller public class HelloController { @GetMapping("hello") public String hello(Model model) { model.addAttribute("data", "hello!!"); return "hello"; // hello 템플릿 파일을 알아서 찾아서 이동 } }

- 아래와 같이 hello.html(템플릿 파일) 생성
![](https://velog.velcdn.com/images/jieun_han/post/860b5b9c-a291-4da1-a942-2ddbc3a4785a/image.png)
- 코드는 아래 참고
```html
<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<p th:text="'안녕하세요. ' + ${data}"> 안녕하세요. 손님</p>
</body>
</html>

- data라는 key값에 hello!!!가 매핑
- <p> 태그 안에 있는 내용은 실제로 매핑이 일어나면 text에 있는 값으로 대체됨
 (<p> 태그 안에 있는 내용은 절대경로로 접근할 때 보이도록 하기 위함)

③ 실행 결과

localhost:8080

localhost:8080/hello

3) 빌드

• Ctrl + F9 또는 빌드 아이콘 클릭
• 성공적으로 빌드가 되면 아래와 같은 화면 확인 가능

2. 스프링 웹 개발 기초

• 웹 브라우저로부터 요청이 오면, AWS (e.g. Tomcat)가 Spring 컨테이너를 통해 컨트롤러가 있는지 확인 -> 없으면 정적인 콘텐츠 반환 -> 있으면 viewResolver가 Thymeleaf 템플릿 엔진 처리 -> 만약 @ResponseBody가 있다면 HttpMessageConverter가 처리 (JsonConverter, StringConverter)

1) 정적 콘텐츠 방식

• 서버 필요 X
• 파일을 그냥 웹 브라우저에 전달
• 2) - ① 내용 참고

2) MVC와 템플릿 엔진

• php와 같은 템플릿 엔진을 통해 HTML을 동적으로 바꿈
• 서버에서 좀 변경을 한 파일을 웹 브라우저에 전달
• 2) - ② 내용 참고
• 만약 파라미터를 추가하게 된다면, 주소창에도 파라미터를 명시해줘야 함
• 코드는 아래 참고 (HelloSpringApplication.java)

  package hello.hellospring.controller;
  

import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestParam;

@Controller public class HelloController { @GetMapping("hello-mvc") public String helloMvc(@RequestParam("name") String name, Model model) { // 파라미터 명시 model.addAttribute("name", name); return "hello-template"; } }

## 3) API
- json이라는 데이터 포맷으로 client에 데이터 전달
- 안드로이드, React 등 다양한 플랫폼 사이에서 통신할 때 사용
- 코드는 아래 참고 (HelloSpringApplication.java)
```java
package hello.hellospring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {    
    @GetMapping("hello-string")
    @ResponseBody // HTTP 통신의 body 부분에 직접 넣어주겠다는 의미
    public String helloString(@RequestParam("name") String name) {
        return "hello " + name;
    }

    @GetMapping("hello-api")
    @ResponseBody
    public Hello helloApi(@RequestParam("name") String name) {
        Hello hello = new Hello();
        hello.setName(name);
        return hello; // 객체로 (json 형식) 반환됨
    }
    static class Hello {
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

localhost:8080/hello-api?name=spring

참고: [인프런] 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 (김영한)

📍 androidx.room 이란? 안드로이드 앱 개발할 때 SQLite를 활용해 데이터베이스에 엑세스할 수 있도록 만들어주는 API (A Database Object Mapping library that makes it easy to access database on Android applications)

1. Room Entity Classes

• 데이터베이스의 row에 해당
• 한 Entity 당 하나의 테이블이 생성됨

  import androidx.room.ColumnInfo
  import androidx.room.Entity
  import androidx.room.PrimaryKey
  

@Entity data class History( @PrimaryKey val uid: Int?, @ColumnInfo(name = "expression") val expression: String?, @ColumnInfo(name = "result") val result: String? )

- data class 대신 public class를 사용해도 되지만, data class를 사용하는 게 좋을 것 같다. [[참고]](https://velog.io/@jonmad/Til.-kotlin-Data-class와-보일러-플레이트)
- PrimaryKey의 경우 자동생성도 가능
```kotlin
@Entity(tableName = "student_data_table")
data class Student(
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "student_id")
    var id: Int,
    @ColumnInfo(name = "student_name")
    var name: String,
    @ColumnInfo(name = "student_email")
    var email: String
)

2. DAO Interface

• Data Access Objects

• 데이터베이스에 접근할 수 있도록 하는 메소드 정의

  @Dao
  interface HistoryDao {
    @Query("SELECT * FROM history")
    fun getAll(): List<History>
  
    // 이렇게 하나씩 insert 할 수 있음
    @Insert
    fun insertHistory(history: History)
  
    @Query("DELETE FROM history")
    fun deleteAll()
  
    // 이렇게 하나씩 delete 할 수 있음
    @Delete
    fun delete(history: History)
  
    // 이렇게 조건을 추가할 수 있음
    @Query("SELECT * FROM history WHERE result LIKE :result")
    fun findByResult(result: String): List<History>
  
    @Query("SELECT * FROM history WHERE result LIKE :result LIMIT 1")
    fun findOneByResult(result: String): History
  }

3. Room Database Class

• 추상 클래스 사용
• 버전 명시 필요 (migration 코드)
• RoomDatabase를 extend

@Database(entities = [History::class], version = 1)
abstract class AppDatabase: RoomDatabase() {
    abstract fun historyDao(): HistoryDao
}

[공식 문서 참고]

1. Room 설명
2. androidx.room 설명

총 120분, 3문제 (알고리즘)

• 프로그래머스 환경
• 온라인 감독 O
• 구글링 불가
• 10:00~12:00 (접속은 09:30까지)

1번 구현, 조합 - 접근 방법에 있어서 조합을 선택하지 않을 수도 있는데, 필자는 조합 선택 (next_permutation 이용) - 1차원 배열 - 체감 난이도: 백준 실버 1

2번 구현? DP? - 문제를 이해하느라 시간이 많이 소요 -> 결국 풀지는 X - 배열의 길이의 최댓값과 각 원소의 최댓값이 상당히 컸음 -> 아마 구현으로만 풀면 히든 케이스에서 시간 초과가 나오지 않을까 추측 (DP 이용하면 좋을듯) - 체감 난이도: 백준 골드 4

3번 구현, 조합 - next_permutation 이용 - 2차원 배열 - 체감 난이도: 백준 골드 5

결론. 오랜만에 코테를 보는거라 약간 걱정됐는데 경험치가 쌓여서 2솔은 그래도 할 수 있었던 것 같다. 난이도는 3월에 본 KT 신입 개발자 공체 코테보다는 쉬웠다. 역시 '구현' 문제가 많이 나오는 것 같다. DP도 꾸준히 연습할 필요가 있음!

더하기 https://www.acmicpc.net/problem/10822

✔️ C++에서 문자열을 자를 때 가장 편리한 방법은 sstream 헤더를 사용하는 것

#include <iostream>
#include <string>
#include <vector>
#include <sstream>

using namespace std;

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

    string str;
    cin >> str;

    vector<string> numbers;
    stringstream ss(str);
    string temp;
    while (getline(ss, temp, ','))
    {
        numbers.push_back(temp);
    }

    long long result = 0;
    for (int i = 0; i < numbers.size(); i++)
    {
        result += stoll(numbers[i]);
    }

    cout << result;
    return 0;
}