홀수 정의
짝수 정의
홀수와 짝수 판단
const num
if(num % 2 == 0) return "짝수"
if(num % 2 == 1) return "홀수"
2진수를 8진수로 변환하기
정의
에라토스테네스의 체
// 소수 찾기
const isPrime = Array(N + 1).fill(true); // N까지의 소수를 찾는다.
isPrime[0] = isPrime[1] = false; // 0, 1은 소수 아님
for (let i = 2; i <= N; i++) {
if (!isPrime[i]) continue;
// 2+2, 2+2+2, 2+2+2+2 -> i의 배수 모두 지우기
for (let j = i + i; j <= N; j += i) {
isPrime[j] = false;
}
}
정의
특징
최대공약수 정의
최소공배수 정의
유클리드 호제법
const GCD = (a, b) => {
if (a % b == 0) return b;
else return GCD(b, a % b);
};
최대공약수(유클리드 호제법)를 이용해 최소공배수 찾기
const a, b = [6, 18];
const gcd = GCD(a, b);
const lcm = (a * b) / gcd
정의
풀이법
정의
규칙
// 간단 곱셈 테스트 코드 예시
public void testMultiplication() {
Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
}
// 에러1. Dollar 클래스 없음
class Dollar
// 에러2. 생성자 없음
Dollar(int amount){}
// 에러3. times(int) 메서드 없음
void times(int multiplier){}
// 에러4. amount 필드 없음
int amount
// 5와 2가 두 곳에 존재 (테스트에 있는 데이터와 코드에 있는 데이터 사이 = 테스트와 코드 사이에 존재하는 의존성)
int amount = 5 * 2;
int amount
void times(int multiplier) {
amount = 5 * 2;
}
// 5를 어디서 얻을 수 있을까?? 이건 생성자에서 넘어오는 값이니 amonut 변수에 저장
Dollar(int amount) {
this.amount = amount;
}
// amount 가져다 사용 가능
void times(int multiplier) {
amount = amount * 2;
}
// multiplier 의 값이 2이므로, 상수를 이 인자로 대체
void times(int multiplier) {
amount *= multiplier;
}
public void testMultiplication() { // 곱셈 테스트
Dollar five = new Dollar(5);
// [문제] times() 를 호출한 이후에 five 는 더 이상 5가 아니다. 그러면 새로운 객체를 반환하게 만들면 어떨까?
five.times(2);
assertEquals(10, product.amount);
five.times(3);
assertEquals(15, product.amount);
}
Dollar five = new Dollar(5);
// 메서드에 반환값이 없기 때문에 컴파일조차 되지 않는다.
Dollar product = five.times(2);
assertEquals(10, product.amount);
product = five.times(3);
assertEquals(15, product.amount);
// 아래 같이 수정해야 컴파일이 된다. 하지만 실행되지 않는다.
Dollar times(int multiplier) {
amount *= multiplier;
return null;
}
느낌(부작용에 대한 혐오감)을 테스트(하나의 Dollar 객체에 곱하기 두 번 수행)로 변환하는 것은 TDD의 일반적 주제// 빨간 막대
public void testEquality() {
assertTrue(new Dollar(5).equals(new Dollar(5)));
}
// 가짜로 구현
public boolean equals(Object object) {
return true;
}
public void testEquality() {
assertTrue(new Dollar(5).equals(new Dollar(5)));
assertFalse(new Dollar(5).equals(new Dollar(6)));
}
// 동치성 일반화 => Dollar 와 Dollar 를 직접 비교 가능
public boolean equals(Object object) {
Dollar dollar = (Dollar) object;
return amount == dollar.amount;
}
// 개념적으로 Dollar.times() 연산은 호출받은 객체의 값에 인자로 받은 곱수만큼 곱한 값을 갖는 Dollar 를 반환해야 함
// 하지만 테스트가 정확히 그것을 의미하지 않음
public void testMultiplication() {
Dollar five = new DOllar(5);
Dollar product = five.times(2);
assertEquals(10, product.amount); // Dollar 를 반환하지 않는 것을 의미하는 부분
product = five.times(3);
assertEquals(15, product.amount);
}
// 단언(assertion)을 Dollar와 Dollar를 비교하는 것으로 재작성
public void testMultiplication() {
Dollar five = new Dollar(5);
assertEquals(new Dollar(10), five.times(2));
assertEquals(new Dollar(15), five.times(3));
}
// 테스트를 고치고 나니 이제 Dollar의 amount 인스턴스 변수를 사용하는 코드는 Dollar 자신밖에 없어서, private 로 변경
// Dollar 객체와 비슷하게 작동하는 Franc 라는 객체
public void testFrancMultiplication() {
Franc five = new Franc(5);
assertEquals(new Franc(10), five.times(2));
assertEquals(new Franc(15), five.times(3));
}
// Dollar 코드를 복사해서 Dollar 를 Franc 로 변경
// 1. 테스트 작성
// 2. 컴파일되게 하기
// 3. 실패하는지 확인하기 위해 설명
// 4. 실행하게 만듦
// 5. 중복 제거
class Franc {
private int amount;
Franc(int amount) {
this.amount = amount;
}
Franc times(int multiplier) {
return new Franc(amount * multiplier);
}
public boolean equals(Object object) {
Franc franc = (Franc) object;
return amount == franc.amount;
}
}
// 중복이 엄청 많다. equals() 를 일반화하는 것부터 시작하자.
// !! 두 클래스의 공통 상위 클래스 찾기
// Money - Dollar, Franc
// Money 클래스가 공통의 equals 코드 갖게 하면 어떨까?
class Money
// Dollar 가 Money 를 상속
class Dollar extends Money {
private int amount;
}
// amount 인스턴스 변수를 Money 로 옮김
// 하위 클래스에서도 변수를 볼 수 있도록 가시성을 private 에서 protected 로 변경
class Money {
protected int amount;
}
class Dollar extends Money { }
// equals() 코드를 위(class Money)로 올리기
// 케스트(cast) 부분 변경 및 임시 변수 명칭 변경
// 이러면 이제 equals() 메서드를 Dollar 에서 Money 로 옮길 수 있다.
public boolean equals(Object object) {
Money money = (Money) object; // before : Money dollar = (Dollar) object;
return amount = money.amount;
}
// 테스트 작성 (Dollar 테스트 복사)
// 또 중복 존재 (두 줄이나 더!)
public void testEquality() {
assertTrue(new Dollar(5).equals(new Dollar(5)));
assertFalse(new Dollar(5).equals(new Dollar(6)));
assertTrue(new Franc(5).equals(new Franc(5)));
assertFalse(new Franc(5).equals(new Franc(6)));
}
// Money 상속 및 amount 필드 제거
class Franc extends Money {
private int amount;
}
class Franc extends Money { }
// Franc.equals() 는 Money.equals() 와 거의 비슷
// Franc 의 불필요한 코드 제거 (Money 로 옮김)
public boolean equals(Object object) {
Money money = (Money) object; // before : Money franc = (Franc) object;
return amount == money.amonut;
}
// Franc 과 Dollar 를 비교
public void testEquality() {
assertFalse(new Franc(5).equals(new Dollar(5)));
}
// 동치성 코드에서는 Dollar 가 Franc 과 비교되지 않는지 검사해야 함
// 두 객체의 클래스를 비교해서, 오직 금액과 클래스가 서로 동일할 때만 두 Money 가 서로 같은 것이다.
// 혼합된 통화 간의 연산에 대해 다루어야 함
public boolean equals(Object object) {
Money money = (Money) object;
return amount == money.amount && getClass().equals(money.getClass());
}
// 1. Product
public interface Animal {}
// 2. Concrete Product
public class Dog implements Animal {}
public class Cat implements Animal {}
// 3. Creator
public abstract class AnimalFactory {
public abstract Animal createAnimal();
}
// 4. Concrete Creator
public class DogFactory extends AnimalFactory {
public Animal createAnimal() {
return new Dog();
}
}
public class CatFactory extends AnimalFactory {
public Animal createAnimal() {
return new Cat();
}
}
// Client
public class Main {
public static void main(String[] args) {
AnimalFactory factory = new DogFactory(); // 팩토리 변경시 생성 객체 변경
Animal animal = factory.createAnimal();
}
}
Franc times(int multiplier) {
return new Franc(amount * multiplier);
}
Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
// 양쪽 모두 Money 반환하게 만들어 더 비슷하게 만들 수 있음
Money times(int multiplier) {
return new Franc(amount * multiplier);
}
Money times(int multiplier) {
return new Dollar(amount * multiplier);
}
// 테스트 코드
public void testMultiplication() {
Dollar five = Money.dollar(5);
assertEquals(new Dollar(10), five.times(2));
assertEquals(new Dollar(15), five.times(3));
}
// Money.dollar()
static Dollar dollar(int amount) {
return new Dollar(amount);
}
// Dollar 에 대한 참조가 사라지길 바라며 테스트 선언부 아래와 같이 변경
public void testMultiplication() {
Money five = Money.dollar(5);
assertEquals(new Dollar(10), five.times(2));
assertEquals(new Dollar(15), five.times(3));
}
// Money 에는 times() 정의되지 않아서, Money 를 추상 클래스로 변경 후 times() 선언
abstract class Money
abstract Money times(int multiplier);
// 팩토리 메서드 변경
static Money dollar(int amount) {
return new Dollar(amount);
}
// 테스트 코드에 팩토리 메서드 적용
public void testMultiplication() {
Money five = Money.dollar(5);
assertEquals(Money.dollar(10), five.times(2)); // 적용
assertEquals(Money.dollar(15), five.times(3)); // 적용
}
public void testEquality() {
assertTrue(Money.dollar(5).equals(Money.dollar(5))); // 적용
assertFalse(Money.dollar(5).equals(Money.dollar(6))); // 적용
assertTrue(new Franc(5).equals(new Franc(5)));
assertFalse(new Franc(5).equals(new Franc(6)));
assertFalse(new Franc(5).equals(Money.dollar(5))); // 적용
}
// Franc 도 팩토리 메서드 적용
static Money franc(int amount) {
return new Franc(amount);
}
public void testCurrency() {
assertEquals("USD", Money.dollar(1).currency());
assertEquals("CHF", Money.franc(1).currency());
}
// Money 에 currency() 메서드 선언 및 하위 클래스에 구현
// Money
abstract String currency();
// Franc
String currency() {
return "CHF";
}
// Dollar
String currency() {
return "USD";
}
// Franc
private String currency;
Franc(int amount) {
this.amount = amount;
currency = "CHF";
}
String currency() {
return currency;
}
// Dollar
private String currency;
Dollar(int amount) {
this.amount = amount;
currency = "USD";
}
String currency() {
return currency;
}
// Money
protected String currency;
String currency() {
return currency;
}
public class HelloJava {
public static void main(String[] args) {
System.out.println("Hello Java");
}
}
{} 블록을 사용해서 클래스, 메서드의 시작과 끝을 나타낸다.(){}[]public class HelloJava {
public static void main(String[] args) {
System.out.println("Hello Java");
}
}
{} 블록을 사용해서 클래스, 메서드의 시작과 끝을 나타낸다.(){}[][ ][ ][1][ ][ ])[ ][ ][1][ ][ ] => [ ][ ][ ][ ] 과 같이 1번 사람을 제외시킬 수 있고, 현재 위치에서 2번 사람을 4번째 위치에 넣으면 되는 것입니다.[ ][ ][ ][2] 처럼 넣게 될 것이고, 여기에 아까 1번 사람의 위치를 기억했다가 다시 넣으면 [ ][ ][1][ ][2] 과 같이 될 것입니다.const input = require("fs")
.readFileSync("/dev/stdin")
.toString()
.trim()
.split("\n");
const solution = (input) => {
const n = Number(input[0]);
const cntOfLeft = input[1].split(" ").map(Number);
const answer = Array.from({length: n}, () => -1);
for (let i = 1; i < n + 1; i++) {
// 왼쪽 키 큰 사람 수
let cnt = cntOfLeft[i - 1];
// 각 사람의 위치 구하기
let index = 0;
// 왼쪽 키 큰 사람 수가 0 인 경우
for (let j = 0; j < n + 1; j++) {
if (answer[j] === -1) break;
// 이미 위치한 사람 수 만큼 오른쪽으로 이동
index += 1;
}
// 왼쪽 키 큰 사람 수가 1 이상인 경우
while (cnt > 0) {
// 왼쪽 키 큰 사람 수 만큼 오른쪽으로 이동
index += 1;
// 이동한 위치에 사람이 있다면 cnt 감소되지 않게 처리
if (answer[index] !== -1) continue;
// 오른쪽으로 이동한 만큼 cnt 감소
cnt -= 1;
}
// 해당 위치에 사람 넣기
answer[index] = i;
}
return answer.join(" ");
};
console.log(solution(input));