24.04.26 금 TIL(Today I Learned)

TIL(Today I Learned)

: 매일 저녁, 하루를 마무리하며 작성 !
: ⭕ 지식 위주, 학습한 것을 노트 정리한다고 생각하고 작성하면서 머리 속 흩어져있는 지식들을 정리 !

Java 문법 종합반

4주차 : 예외처리, 제네릭-----------------------

- 문제 수습하기 (예외처리)

1. 오류 및 예외에 대한 이해

• 프로그램이 직면하는 문제 상황들
  아무리 좋은 프로그래머라도 모든 것을 컨트롤할 수는 없다. 완벽한 프로그램이란 것은 없을뿐더러, 완벽한 프로그램도 제어하지 못하는 문제는 발생

• 오류(Error) vs 예외(Exception)
  오류(Error)는 일반적으로 회복이 불가능한 문제
  예외(Exception)는 일반적으로 회복이 가능한 문제

• 예외의 종류
  • 컴파일 에러(예외) : .java 파일을 .class 파일로 컴파일할 때 발생하는 에러
  • 런타임 에러(예외) : 문법적인 오류는 아니라서, 컴파일은 잘 되었지만 “프로그램”이 실행 도중 맞닥뜨리게 되는 예외
  • 확인된 예외 : 컴파일 시점에 확인하는 예외
  • 미확인된 예외 : 런타임 시점에 확인되는 예외

2. 예외 발생과 try-catch, finally 문

• 예외 처리의 흐름

• 예외 정의하기

class OurBadException extends Exception {
	public OurBadException() {
		super("위험한 행동을 하면 예외처리를 꼭 해야합니다!");
	}
}

• throw, throws

class OurClass {
    private final Boolean just = true;
		
		// 신규 문법 throws!
    public void thisMethodIsDangerous() throws OurBadException {
        if (just) {
						// 신규 문법 throw!
            throw new OurBadException();
        }
    }
}

• handing

public class StudyException {
    public static void main(String[] args) {
        OurClass ourClass = new OurClass();

        try {
            // 1. 위험한 메소드의 실행을 "시도" 해 봅니다.
            // "시도" 해보는 코드가 들어가는 블럭입니다.
            ourClass.thisMethodIsDangerous();
        } catch (OurBadException e) {
            // 2. 예외가 발생하면, "잡아서" handling 합니다.
            // 예외가 발생하는경우 "handling" 하는 코드가 들어가는 블럭입니다.
						// 즉 try 블럭 내의 구문을 실행하다가 예외가 발생하면
						// 예외가 발생한 줄에서 바로 코드 실행을 멈추고
						// 여기 있는 catch 블럭 내의 코드가 실행됩니다.
            System.out.println(e.getMessage());
        } finally {
            // 3. 예외의 발생 여부와 상관없이, 실행시켜야 하는 코드가 들어갑니다.
            // 무조건 실행되는 코드가 들어가는 블럭입니다.
            System.out.println("우리는 방금 예외를 handling 했습니다!");
        }

    }
}

1. 위험 감지하기
2. 위험을 감지했다면, try-catch(finally) 키워드 이용

3. 예외 클래스 구조 이해

• 오류 및 예외에 대한 이해 다시 보기

• 자바의 모든 것은 "객체"

• Throwable Class

• 에러 구현체들
  

class OurBadException extends Exception {
	public OurBadException() {
		super("위험한 행동을 하면 예외처리를 꼭 해야합니다!");
	}
}

4. Chained Exception, 실제 예외 처리하는 방법

• 연결된 예외 (Chained Exception)
  initCause() : 지정한 예외를 원인 예외로 등록하는 메소드
  getCause() : 원인 예외를 반환하는 메소드

• 실제로 예외 처리

// 예외 복구하기
public String getDataFromAnotherServer(String dataPath) {
		try {
				return anotherServerClient.getData(dataPath).toString();
		} catch (GetDataException e) {
				return defaultData;
		}
}

// 예외 처리 회피하기
public void someMethod() throws Exception { ... }

public void someIrresponsibleMethod() throws Exception {
		this.someMethod();
}

// 예외 전환하기
public void someMethod() throws IOException { ... }

public void someResponsibleMethod() throws MoreSpecificException {
		try {
			this.someMethod();
		} catch (IOException e) {
			throw new MoreSpecificException(e.getMessage());
		}
}

- 타입 더 유연하게 다루기 (제네릭)

1. Generic 알아보기

• 제네릭의 효용
  (1) 제네릭의 효용은 타입 언어에서 “중복되거나 필요 없는 코드를 줄여주는 것”
  (2) 두 번째 제네릭의 효용은 그러면서도 타입 안정성을 해치지 않는 것

• Step 1. 타입 언어에서의 중복되거나 필요 없는 코드?
  우리는 타입을 지정해 줘야 하는 언어를 사용 > 똑같은 로직을 수행하는 함수를 타입을 지정해야 한다는 이유로 세 차례나 구현

• Step 2. 타입 안정성을 해치지 않는 것?
  이런 류의 해결 방법이 있지 않을까?

public class Generic {
    public Object plusReturnFunction(Object a,Object b) { ... }
}

• 제네릭 문법

// 1.
public class Generic<T> {
		// 2.
    private T t;
    // 3.
    public T get() {
        return this.t;
    }

    public void set(T t) {
        this.t = t;
    }

    public static void main(String[] args) {
				// 4.
        Generic<String> stringGeneric = new Generic<>();
				// 5.
        stringGeneric.set("Hello World");
				
        String tValueTurnOutWithString = stringGeneric.get();

        System.out.println(tValueTurnOutWithString);
    }
}

2. Generic 문법 자세히 살펴보기

• 제네릭 용어 정리

public class Generic<T> { ... }

Generic<String> stringGeneric = new Generic<>();

// 제네릭을 사용한 클래스를 제네릭 클래스
// 제네릭에서 <>사이에 들어가는 변수명 T는 타입 변수
// Generic 클래스를 원시 타입

• 제네릭의 제한
  (1) 객체의 static 멤버에 사용할 수 x
  (2) 제네릭 배열을 생성할 수 x

• 제네릭 문법

(1) 다수의 타입 변수를 사용

public class Generic<T, U, E> {
    public E multiTypeMethod(T t, U u) { ... }
}


Generic<Long, Integer, String> instance = new Generic();
instance.multiTypeMethod(longVal, intVal);

(2) 다형성 즉 상속과 타입의 관계는 그대로 적용 : 대표적으로 부모 클래스로 제네릭 타입 변수를 지정하고, 그 안에 자식 클래스를 넘기는 것은 잘 동작

(3) 와일드카드를 통해 제네릭의 제한을 구체적으로

public class ParkingLot<T extends Car> { ... }

ParkingLot<BMW> bmwParkingLot = new ParkingLot();
ParkingLot<Iphone> iphoneParkingLot = new ParkingLog(); // error!

(4) 메서드를 스코프로 제네릭을 별도로 선언

// 또는 ..
static <T> void sort(List<T> list, Comparator<? super T> c) { ... }


public class Generic<T, U, E> {
		// Generic<T,U,E> 의 T와 아래의 T는 이름만 같을뿐 다른 변수
    static <T> void sort(List<T> list, Comparator<? super T> c) { ... }
}

3. Collection 다시보기

• 자료구조? : 컴퓨터 공학과에서 배우는 가장 핵심적인 과목으로 자료구조와 알고리즘

• List, 배열 예시
  리스트는 추상적 자료구조, 순서를 가지고, 일렬로 나열한 원소들의 모임
  “추상적” 자료구조인 리스트는 개념적으로 보통 다음 연산들을 지원

배열은 프로그래밍 언어에서 지원하는 자료형 또는 컴퓨터공학에서 사용하는 자료구조의 하나, 배열은 순서를 가지고, 일렬로 특정한 메모리 공간에 나열되어 있기 때문에 특별 !

• 제네릭과 함께 List 코드

// 실제 java.util의 List 코드
public interface List<E> extends Collection<E> {
		int size();
    boolean isEmpty();
		...
		boolean addAll(Collection<? extends E> c);
		boolean add(E e);
		...
}

• Collection
  

4. Wrapper 객체
   

Integer num = new Integer(17);  // Boxing
int n = num.intValue(); // UnBoxing

Character ch = 'X'; // AutoBoxing
char c = ch; // AutoUnBoxing

---

5주차 : 쓰레드, 람다, 스트림, Optional-----------------------

- 일꾼 (쓰레드)

1. 프로세스와 쓰레드

• 프로세스는 “실행 중인 프로그램”을 의미

• 프로세스가 작업 중인 프로그램에서 실행 요청이 들어오면 쓰레드(일꾼)을 만들어 명령을 처리
  
  

2. 멀티 쓰레드

• 싱글 쓰레드 : 프로세스 안에서 하나의 쓰레드만 실행되는 것

• 멀티 쓰레드 : 프로세스 안에서 여러 개의 쓰레드가 실행되는 것
  - 멀티 쓰레드 장점 : 여러 개의 쓰레드(실행 흐름)을 통해 여러 개의 작업을 동시에 할 수 있어서 성능 향상, 스택을 제외한 모든 영역에서 메모리를 공유하기 때문에 자원을 보다 효율적으로 사용, 응답 쓰레드와 작업 쓰레드를 분리하여 빠르게 응답
  - 멀티 쓰레드 단점 : 동기화 문제가 발생, 교착 상태(데드락)이 발생

3. Thread 와 Runnable

• Thread

public class TestThread extends Thread {
				@Override
				public void run() {
							// 쓰레드 수행작업
				}
}

...

TestThread thread = new TestThread(); // 쓰레드 생성
thread.start() // 쓰레드 실행

• Runnable

public class TestRunnable implements Runnable {
				@Override
				public void run() {
							// 쓰레드 수행작업 
				}
}

...

Runnable run = new TestRunnable();
Thread thread = new Thread(run); // 쓰레드 생성

thread.start(); // 쓰레드 실행

• 람다식

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> {
            int sum = 0;
            for (int i = 0; i < 50; i++) {
                sum += i;
                System.out.println(sum);
            }
            System.out.println(Thread.currentThread().getName() + " 최종 합 : " + sum);
        };

        Thread thread1 = new Thread(task);
        thread1.setName("thread1");
        Thread thread2 = new Thread(task);
        thread2.setName("thread2");

        thread1.start();
        thread2.start();
    }
}

4. 데몬 쓰레드와 사용자 쓰레드

• 데몬 쓰레드

public class Main {
    public static void main(String[] args) {
        Runnable demon = () -> {
            for (int i = 0; i < 1000000; i++) {
                System.out.println("demon");
            }
        };

        Thread thread = new Thread(demon);
        thread.setDaemon(true); // true로 설정시 데몬스레드로 실행됨

        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("task");
        }
    }
}

• 사용자 쓰레드 : 보이는 곳(foregorund)에서 실행되는 높은 우선순위를 가진 쓰레드

5. 쓰레드 우선순위와 쓰레드 그룹

• 쓰레드 우선순위

Thread thread1 = new Thread(task1);
thread1.setPriority(8);

int threadPriority = thread1.getPriority();
System.out.println("threadPriority = " + threadPriority);

• 쓰레드 그룹

// ThreadGroup 클래스로 객체를 만듭니다.
ThreadGroup group1 = new ThreadGroup("Group1");

// Thread 객체 생성시 첫번째 매개변수로 넣어줍니다.
// Thread(ThreadGroup group, Runnable target, String name)
Thread thread1 = new Thread(group1, task, "Thread 1");

// Thread에 ThreadGroup 이 할당된것을 확인할 수 있습니다.
System.out.println("Group of thread1 : " + thread1.getThreadGroup().getName());


// ThreadGroup 클래스로 객체를 만듭니다.
ThreadGroup group1 = new ThreadGroup("Group1");

// Thread 객체 생성시 첫번째 매개변수로 넣어줍니다.
// Thread(ThreadGroup group, Runnable target, String name)
Thread thread1 = new Thread(group1, task, "Thread 1");
Thread thread2 = new Thread(group1, task, "Thread 2");

// interrupt()는 일시정지 상태인 쓰레드를 실행대기 상태로 만듭니다.
group1.interrupt();

6. 쓰레드 상태와 제어

• 쓰레드 상태
  
  
  

• 쓰레드 제어
  

sleep(), interrupt(), join(), yield(), synchronized, wait(), notify(), Lock, Condition

- 모던 자바 알아보기 (람다, 스트림, Optional)

1. 모던 자바? : 자바 8 변경점 알아보기

• 함수형 프로그래밍의 아이디어와 문법을 자바 8에서 지원
• 함수형 프로그래밍의 아이디어인 (함수를 값으로 다루거나, 다른 함수에 넘길 수 있다)와 같은 일들이 가능
• 함수형 프로그래밍의 문법인 익명 함수 문법을 지원
• 스트림이라는 컬렉션의 흐름과 같은 것을 지원
• 스트림 기능의 지원으로 우리는 더 간결하고, 유연하고, 성능 좋은 코드를 작성

2. 람다와 스트림 문법 살펴보기

• 람다와 스트림을 적용

import java.util.ArrayList;
import java.util.List;

public class LambdaAndStream {
    public static void main(String[] args) {
        ArrayList<Car> carsWantToPark = new ArrayList<>();
        ArrayList<Car> parkingLot = new ArrayList<>();

        Car car1 = new Car("Benz", "Class E", true, 0);
        Car car2 = new Car("BMW", "Series 7", false, 100);
        Car car3 = new Car("BMW", "X9", false, 0);
        Car car4 = new Car("Audi", "A7", true, 0);
        Car car5 = new Car("Hyundai", "Ionic 6", false, 10000);

        carsWantToPark.add(car1);
        carsWantToPark.add(car2);
        carsWantToPark.add(car3);
        carsWantToPark.add(car4);
        carsWantToPark.add(car5);

        parkingLot.addAll(parkingCarWithTicket(carsWantToPark));
        parkingLot.addAll(parkingCarWithMoney(carsWantToPark));


        for (Car car : parkingLot) {
            System.out.println("Parked Car : " + car.getCompany() + "-" + car.getModel());
        }


    }

    public static List<Car> parkingCarWithTicket(List<Car> carsWantToPark) {
        ArrayList<Car> cars = new ArrayList<>();
        
        for (Car car : carsWantToPark) {
            if (car.hasParkingTicket()) {
                cars.add(car);
            }
        }

        return cars;
    }

    public static List<Car> parkingCarWithMoney(List<Car> carsWantToPark) {
        ArrayList<Car> cars = new ArrayList<>();
        
        for (Car car : carsWantToPark) {
            if (!car.hasParkingTicket() && car.getParkingMoney() > 1000) {
                cars.add(car);
            }
        }
        
        return cars;
    }
}

class Car {
    private final String company; // 자동차 회사
    private final String model; // 자동차 모델

    private final boolean hasParkingTicket;
    private final int parkingMoney;

    public Car(String company, String model, boolean hasParkingTicket, int parkingMoney) {
        this.company = company;
        this.model = model;
        this.hasParkingTicket = hasParkingTicket;
        this.parkingMoney = parkingMoney;
    }

    public String getCompany() {
        return company;
    }

    public String getModel() {
        return model;
    }

    public boolean hasParkingTicket() {
        return hasParkingTicket;
    }

    public int getParkingMoney() {
        return parkingMoney;
    }
}

• 함수를 값으로 전달하기 : 함수형 인터페이스

// Car 클래스 내부에 두 메서드 구현

public static boolean hasTicket(Car car) {
        return car.hasParkingTicket;
}

public static boolean noTicketButMoney(Car car) {
        return !car.hasParkingTicket && car.getParkingMoney() > 1000;
}

// 함수형 인터페이스를 다음과 같이 정리
interface Predicate<T> {
    boolean test(T t);
}


//두 함수를 리팩토링
public static List<Car> parkingCarWithTicket(List<Car> carsWantToPark) {
        ArrayList<Car> cars = new ArrayList<>();

        for (Car car : carsWantToPark) {
            if (car.hasParkingTicket()) {
                cars.add(car);
            }
        }

        return cars;
  }

public static List<Car> parkingCarWithMoney(List<Car> carsWantToPark) {
    ArrayList<Car> cars = new ArrayList<>();

    for (Car car : carsWantToPark) {
        if (!car.hasParkingTicket() && car.getParkingMoney() > 1000) {
            cars.add(car);
        }
    }

    return cars;
}


// 새로운 함수
// 변경점 1 : Predicate<Car> 인터페이스를 타입 삼아 함수를 전달합니다!
public static List<Car> parkCars(List<Car> carsWantToPark, Predicate<Car> function) {
      List<Car> cars = new ArrayList<>();

      for (Car car : carsWantToPark) {
					// 변경점 2 : 전달된 함수는 다음과 같이 사용됩니다!
          if (function.test(car)) {
              cars.add(car);
          }
      }

      return cars;
  }

// 어떻게 사용하는지?
parkingLot.addAll(parkCars(carsWantToPark, Car::hasTicket));
parkingLot.addAll(parkCars(carsWantToPark, Car::noTicketButMoney));










// 함수를 값으로 전달 리팩토링 완료 코드
import java.util.ArrayList;
import java.util.List;

public class LambdaAndStream {
    public static void main(String[] args) {
        ArrayList<Car> carsWantToPark = new ArrayList<>();
        ArrayList<Car> parkingLot = new ArrayList<>();

        Car car1 = new Car("Benz", "Class E", true, 0);
        Car car2 = new Car("BMW", "Series 7", false, 100);
        Car car3 = new Car("BMW", "X9", false, 0);
        Car car4 = new Car("Audi", "A7", true, 0);
        Car car5 = new Car("Hyundai", "Ionic 6", false, 10000);

        carsWantToPark.add(car1);
        carsWantToPark.add(car2);
        carsWantToPark.add(car3);
        carsWantToPark.add(car4);
        carsWantToPark.add(car5);

        parkingLot.addAll(parkCars(carsWantToPark, Car::hasTicket));
        parkingLot.addAll(parkCars(carsWantToPark, Car::noTicketButMoney));


        for (Car car : parkingLot) {
            System.out.println("Parked Car : " + car.getCompany() + "-" + car.getModel());
        }


    }

    public static List<Car> parkCars(List<Car> carsWantToPark, Predicate<Car> function) {
        List<Car> cars = new ArrayList<>();

        for (Car car : carsWantToPark) {
            if (function.test(car)) {
                cars.add(car);
            }
        }

        return cars;
    }


}

class Car {
    private final String company; // 자동차 회사
    private final String model; // 자동차 모델

    private final boolean hasParkingTicket;
    private final int parkingMoney;

    public Car(String company, String model, boolean hasParkingTicket, int parkingMoney) {
        this.company = company;
        this.model = model;
        this.hasParkingTicket = hasParkingTicket;
        this.parkingMoney = parkingMoney;
    }

    public String getCompany() {
        return company;
    }

    public String getModel() {
        return model;
    }

    public boolean hasParkingTicket() {
        return hasParkingTicket;
    }

    public int getParkingMoney() {
        return parkingMoney;
    }

    public static boolean hasTicket(Car car) {
        return car.hasParkingTicket;
    }

    public static boolean noTicketButMoney(Car car) {
        return !car.hasParkingTicket && car.getParkingMoney() > 1000;
    }
}

interface Predicate<T> {
    boolean test(T t);
}

• 람다: 익명 함수로 함수 한 번 간단하게 사용

import java.util.ArrayList;
import java.util.List;

public class LambdaAndStream {
    public static void main(String[] args) {
        ArrayList<Car> carsWantToPark = new ArrayList<>();
        ArrayList<Car> parkingLot = new ArrayList<>();
        ArrayList<Car> weekendParkingLot = new ArrayList<>();

        Car car1 = new Car("Benz", "Class E", true, 0);
        Car car2 = new Car("BMW", "Series 7", false, 100);
        Car car3 = new Car("BMW", "X9", false, 0);
        Car car4 = new Car("Audi", "A7", true, 0);
        Car car5 = new Car("Hyundai", "Ionic 6", false, 10000);

        carsWantToPark.add(car1);
        carsWantToPark.add(car2);
        carsWantToPark.add(car3);
        carsWantToPark.add(car4);
        carsWantToPark.add(car5);

        parkingLot.addAll(parkCars(carsWantToPark, Car::hasTicket));
        parkingLot.addAll(parkCars(carsWantToPark, Car::noTicketButMoney));

        weekendParkingLot.addAll(parkCars(carsWantToPark, (Car car) -> car.hasParkingTicket() && car.getParkingMoney() > 1000));


        for (Car car : parkingLot) {
            System.out.println("Parked Car : " + car.getCompany() + "-" + car.getModel());
        }


    }

    public static List<Car> parkCars(List<Car> carsWantToPark, Predicate<Car> function) {
        List<Car> cars = new ArrayList<>();

        for (Car car : carsWantToPark) {
            if (function.test(car)) {
                cars.add(car);
            }
        }

        return cars;
    }


}

class Car {
    private final String company; // 자동차 회사
    private final String model; // 자동차 모델

    private final boolean hasParkingTicket;
    private final int parkingMoney;

    public Car(String company, String model, boolean hasParkingTicket, int parkingMoney) {
        this.company = company;
        this.model = model;
        this.hasParkingTicket = hasParkingTicket;
        this.parkingMoney = parkingMoney;
    }

    public String getCompany() {
        return company;
    }

    public String getModel() {
        return model;
    }

    public boolean hasParkingTicket() {
        return hasParkingTicket;
    }

    public int getParkingMoney() {
        return parkingMoney;
    }

    public static boolean hasTicket(Car car) {
        return car.hasParkingTicket;
    }

    public static boolean noTicketButMoney(Car car) {
        return !car.hasParkingTicket && car.getParkingMoney() > 1000;
    }
}

interface Predicate<T> {
    boolean test(T t);
}

• 스트림
  - 스트림의 특징 : 원본의 데이터를 변경 x, 일회용
  - 스트림과 거기에 구현되어 있는 메서드를 이용하면 다음과 같은 것들이 가능

  - 스트림을 사용하는 방법

  

List<Car> benzParkingLot =
								// carsWantToPark의 스트림값을 받아와서
                carsWantToPark.stream()
												// 거기 구현되어 있는 filter()메서드를 사용합니다.
												// filter메서드는 함수를 파라미터로 전달받습니다.
												// 여기서 함수는 제조사가 벤츠면 true를 반환하는 함수네요.
												// 필터 메서드는 이름처럼 false를 반환한 스트림의 원소들을 제거합니다.
                        .filter((Car car) -> car.getCompany().equals("Benz"))
												// 이 결과도 반환을 받아서 다시 리스트로 묶어줍니다.
                        .toList();

- 스트림 API

// forEach 
List<String> carNames = Arrays.asList("Series 6", "A9", "Ionic 6");

carNames.stream()
    .forEach(System.out::println);

// 결과 
// Series 6
// A9
// Ionic 6

// map()
carNames.stream()
	.map(name -> name.toUpperCase()).toList();

// 결과
// ["SERIES 6", "A9", "IONIC 6"]

3. Optional

• Java8에서는 Optional 클래스를 사용해 Null Pointer Exception을 방지
• Optional는 null이 올 수 있는 값을 감싸는 Wrapper 클래스
• Optional이 비어있더라도, 참조해도 Null Pointer Exception가 발생하지 x
  

// Optional 객체 사용하기 (값 받아오기)

Optional<String> carName = getCarNameFromDB();
// orElse() 를 통해 값을 받아옵니다, 파라미터로는 null인 경우 반환할 값을 적습니다.
String realCarName = carName.orElse("NoCar");

// 위는 예시코드고 실제는 보통 아래와 같이 사용하겠죠?
String carName = getCarNameFromDB().orElse("NoCar");

// orElseGet()이라는 메서드를 사용해서 값을 받아올 수 있습니다.
// 파라미터로는 없는 경우 실행될 함수를 전달합니다.
Car car = getCarNameFromDB().orElseGet(Car::new);

// 값이 없으면, 그 아래 로직을 수행하는데 큰 장애가 되는경우 에러를 발생시킬수도 있습니다.
Car car = getCarNameFromDB()
						.orElseThrow(() -> new CarNotFoundException("NO CAR!)

---

알고리즘 세션

1. 알고리즘에 대해서

2. 시간 복잡도

알고리즘이 문제를 얼마나 빠르게 해결했는지 평가하는 지표는 소요 시간입니다. 하지만 소요 시간은 알고리즘이 입력받는 값에 의해 결정되기 때문에 이 소요 시간과 입력값의 상관 관계를 표현하기 위한 시간 복잡도(Time complexity)라는 개념이 있습니다.

• Big-O 표기법

// 소요 시간은 n에 비례.
  maxScore: O(n)
maxScore(x[])
{
	max <- 0;
	
	for (i <- 0; i < x.length; i <- i+1) do {
		if (x[i] >= max) then {
			max <- x[i];
		}
	}
	
	return max;
}
                   
// 소요 시간은 n²에 비례.
  multiplyAllElements: O(n²)
multiplyAllElements(a[])
{
	sum <- 0;
	
	for (i <- 0; i < a.length-1; i <- i+1) do { 
		for (j <- 0; j < a.length-1; j <- j+1) do {
			sum <- sum + a[i] * a[j];
    }
	}
	
	return sum;
}
                   

---

알고리즘 코드카타

• 문제 설명
  정수 num1과 num2가 매개변수로 주어집니다. 두 수가 같으면 1 다르면 -1을 retrun하도록 solution 함수를 완성해주세요.
  
• 제한사항
  0 ≤ num1 ≤ 10,000
  0 ≤ num2 ≤ 10,000
  

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

int solution(int num1, int num2) {
    int answer = 0;
    if (num1 == num2){
        answer = 1;
    } else {
        answer = -1;
    }
    return answer;
}