while (true)

kotlin enum method

3COLORED — Sun, 19 Sep 2021 19:28:05 +0900

// jdk 1.7 style
enum class Formula {
    POWER {
        override fun calculate(n: Long): Long {
            return n * n;
        }

        // unwanted method
        override fun calculate(n: Long, m: Long): Double {
            return 0.0
        }
    },
    GAUSE {
        override fun calculate(n: Long): Long {
            return (1 + n) * (n / 2)
        }

        // unwanted method
        override fun calculate(n: Long, m: Long): Double {
            return 0.0
        }
    },
    PYTHAGORAS {
        override fun calculate(n: Long, m: Long): Double {
            return sqrt((calculate(n) + calculate(m)).toDouble())
        }

        // unwanted method
        override fun calculate(n: Long): Long {
            return 0
        }
    };
    abstract fun calculate(n: Long): Long // implements POWER, GAUSE
    abstract fun calculate(n: Long, m: Long): Double // implements PYTHAGORAS
}

위의 코드는 불필요한 메서드까지 구현해야하는 단점이 있으므로 불편합니다.

// jdk 8 style
import java.util.function.BiFunction
import java.util.function.Function
import kotlin.math.sqrt

enum class Formula {
    POWER(Function<Long, Long> { n: Long -> n * n }),
    GAUSE(Function<Long, Long> { n: Long -> (1 + n) * (n / 2) }),
    PYTHAGORAS(BiFunction { n: Long, m: Long -> sqrt((POWER.calculate(n) + POWER.calculate(m)).toDouble()) });

    private lateinit var expression: Function<Long, Long>
    private lateinit var pythagoras: BiFunction<Long, Long, Double>

    constructor(expression: Function<Long, Long>) {
        this.expression = expression
    }

    constructor(pythagoras: BiFunction<Long, Long, Double>) {
        this.pythagoras = pythagoras
    }

    fun calculate(value: Long): Long {
        return expression.apply(value)
    }

    fun calculate(a: Long, b: Long): Double {
        return pythagoras.apply(a, b)
    }
}

위의 방식으로 구현하면 함수형 스타일로, 불필요한 메서드까지 구현해야하는 불편함 없이 사용할 수 있습니다.

disable typescript duck typing (타입스크립트 덕타이핑 제한)

3COLORED — Thu, 29 Jul 2021 06:42:41 +0900

interface Point2D {
  norminal: Point2D;
  x: number;
  y: number;
}

interface Point3D {
  norminal: Point3D;
  x: number;
  y: number;
  z: number;
}

type Nominal<T> = T;

const point2D = <Nominal<Point2D>> { x: 16, y: 24 };
const point3D = <Nominal<Point3D>> { x: 39, y: 7, z: 12 };

interface DisableDuckTyping<T extends Point2D> extends Point2D {  readonly norminal: T;  }
  
type p2dType = DisableDuckTyping<Point2D>;
type p3dType = DisableDuckTyping<Point3D>;

const p2d = (1 as never as p2dType);
const p3d = (2 as never as p3dType); 

// then

function iTakePoint2D(point: p3dType) { 
    console.log(point.x, point.y);
}

iTakePoint2D(point2D); // error: iTakePoint2D parameter type mismatch
iTakePoint2D(point3D); // point type is p3dType, so it works.

java 슈퍼 타입 토큰을 활용한 map 및 list 구현

3COLORED — Thu, 29 Jul 2021 05:31:19 +0900

package com.company.SuperTypeToken;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import org.junit.Test;
import org.junit.jupiter.api.DisplayName;
import org.springframework.core.ResolvableType;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;

import static java.util.stream.Collectors.toList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class SuperTypeTokenTest {

    @EqualsAndHashCode
    static class TypeSafeMap {
        private final Map<Type, Object> map = new HashMap<>();

        <T> void put(TypeReference<T> tr, T value) {
            map.put(tr.type, value);
        }

        // explicit type casting is perfectly safe.
        @SuppressWarnings("unchecked")
        <T> T get(TypeReference<T> tr) {
            if (tr.type instanceof Class<?>) return ((Class<T>) tr.type).cast(map.get(tr.type));
            else return ((Class<T>)((ParameterizedType)tr.type).getRawType()).cast(map.get(tr.type));
        }
        
        public int size() { return map.size(); }
        public void clear() { map.clear(); }
        public boolean isEmpty() { return map.isEmpty(); }
        public boolean containsKey(Object key) { return map.containsKey(key); }
        public <T> T remove(T key) { return (T) map.remove(key); }
        public boolean containsValue(Object value) { return map.containsValue(value); }
        public Set<Type> keySet() { return map.keySet(); }

    }

    static class TypeSafeList implements Iterable<TypeSafeList.Types<?>> {

        @Override
        public Iterator<Types<?>> iterator() {
            return list.iterator();
        }

        @ToString @EqualsAndHashCode
        static class Types<T> {
            private Type type;
            private T data;

            public Type getType() { return type; }
            public T getData() { return data; }
            boolean isSameTypeWith(Type rtype) { return rtype.equals(getType()); }
        }

        private final List<Types<?>> list = new ArrayList<>();

        <T> void add(TypeReference<T> tr, T data) {
            Types<T> types = new Types<>();
            types.type = tr.type;
            types.data = data;
            list.add(types);
        }

        /**
         * @param <T> tr.type
         * @param tr 타입안정성을 위해 사용된 슈퍼 타입토큰
         * @return  tr.type 에 해당하는 모든 값을 list 에서 찾아내어 리스트로 모아서 반환
         */
        // explicit type casting is perfectly safe.
        @SuppressWarnings("unchecked")
        <T> List<T> getValues(TypeReference<T> tr) {
            if (tr.type instanceof Class<?>)
                return (List<T>) list.stream().filter(e -> e.type.equals(tr.type)).map(e -> e.data).collect(toList());
            else
                return (List<T>) ((Class<T>)((ParameterizedType)tr.type).getRawType()).cast(list.stream().filter(e -> e.type.equals(tr.type)).map(e -> e.data).collect(toList()));
        }

        Type getType(int index) {
            return list.get(index).getType();
        }

        // only one value contains in list. list is immutable.
        List<?> getValue(int index) {
            return List.of(list.get(index).getData());
        }

        public int size() {
            return list.size();
        }

        public List<Types<?>> getList() {
            return list;
        }
    }

    // T does not used in this class directly, but indirectly (getGenericSuperclass()) uses.
    abstract static class TypeReference<T> {
        final Type type;

        public TypeReference() {
            Type sType = this.getClass().getGenericSuperclass();
            if (sType instanceof ParameterizedType) {
                this.type = ((ParameterizedType) sType).getActualTypeArguments()[0];
            } else {
                throw new RuntimeException();
            }
        }

    }

    enum Grade { VIP, VVIP }
    @ToString @Getter @EqualsAndHashCode
    static class User {
        private final String name;
        private final Integer age;
        private Grade grade;

        public User(String name, Integer age) {
            this.name = name;
            this.age = age;
            this.grade = Grade.VIP;
        }
        public User setGrade(Grade grade) { this.grade = grade; return this; }
    }

    @Test
    @DisplayName("타입 안정성을 지닌 다수의 데이터타입을 가지는 해시맵이 구현되었는지 검증 테스트")
    public void typeSafeMapTest() {

        // given
        TypeSafeMap m = new TypeSafeMap();

        // when
        m.put(new TypeReference<String>(){}, "String");
        m.put(new TypeReference<Integer>(){}, 1);
        m.put(new TypeReference<List<Integer>>(){}, List.of(1,2,3));
        m.put(new TypeReference<List<String>>(){}, List.of("a", "b", "c"));

        // then
        assertThat(m.get(new TypeReference<String>(){})).isEqualTo("String");
        assertThat(m.get(new TypeReference<Integer>(){})).isEqualTo(1);
        assertThat(m.get(new TypeReference<List<Integer>>(){})).isEqualTo(List.of(1,2,3));
        assertThat(m.get(new TypeReference<List<String>>(){})).isEqualTo(List.of("a","b","c"));
    }

    @Test
    @DisplayName("스프링이 지원하는 ResolvableType 을 이용한 다양한 타입에 대한 접근이 가능한지에 대하여 검증")
    public void testResolvableType() {
        ResolvableType rt = ResolvableType.forInstance(new TypeReference<List<Map<Set<Integer>, List<String>>>>() {});

        assertThat(rt.getSuperType().getGenerics().length).isEqualTo(1);
        assertThat(rt.getSuperType().getNested(1).toString()).isEqualTo("com.company.SuperTypeToken.SuperTypeTokenTest$TypeReference<java.util.List<java.util.Map<java.util.Set<java.lang.Integer>, " +
                                                                            "java.util.List<java.lang.String>>>>");
        assertThat(rt.getSuperType().getNested(2).toString()).isEqualTo("java.util.List<java.util.Map<java.util.Set<java.lang.Integer>, java.util.List<java.lang.String>>>");
        assertThat(rt.getSuperType().getNested(3).toString()).isEqualTo("java.util.Map<java.util.Set<java.lang.Integer>, java.util.List<java.lang.String>>");
        assertThat(rt.getSuperType().getNested(4).toString()).isEqualTo("java.util.List<java.lang.String>");
        assertThat(rt.getSuperType().getNested(5).toString()).isEqualTo("java.lang.String");
        assertThat(rt.getSuperType().getNested(6).toString()).isEqualTo("?");
        assertThat(rt.getSuperType().getNested(7).toString()).isEqualTo("?");
        assertThat(rt.getSuperType().getNested(8).toString()).isEqualTo("?");
        assertThat(rt.getSuperType().getNested(9).toString()).isEqualTo("?");
    }

    @Test
    @DisplayName("typeSafeMap validate value")
    public void typeSafeMapTest2() {
        // given
        TypeSafeMap typeSafeMap = new TypeSafeMap() {};

        // when
        typeSafeMap.put(new TypeReference<>(){},List.of("One"));
        typeSafeMap.put(new TypeReference<>(){},12.0);
        typeSafeMap.put(new TypeReference<>(){},List.of(Set.of(1, 2, 3)));

        // then
        assertThat(typeSafeMap.get(new TypeReference<List<String>>() {})).isEqualTo(List.of("One"));
        assertThat(typeSafeMap.get(new TypeReference<Double>() {})).isEqualTo(12.0);
        assertThat(typeSafeMap.get(new TypeReference<List<Set<Integer>>>() {})).isEqualTo(List.of(Set.of(1, 2, 3)));

        // after check
        // typeSafeMap.map.forEach((k, v) -> System.out.println(k + " : " + v));
    }


    @Test
    @DisplayName("TypeSafeList 에 들어간 타입 중 특정 타입 값들을 모두 리스트로 꺼내어 타입과 값을 검증함, getValues(TypeReference tr) 사용")
    public void typeSafeListTest() {

        // given
        TypeSafeList typeSafeList = new TypeSafeList();

        // when
        typeSafeList.add(new TypeReference<Integer>() {}, 4934);
        typeSafeList.add(new TypeReference<List<Double>>() {}, List.of(13.0, 50.2));
        typeSafeList.add(new TypeReference<List<Map<Integer, String>>>() {}, List.of(Map.of(42, "the answer to the 'ultimate question of life, the universe, and everything.'")));
        typeSafeList.add(new TypeReference<User>(){}, new User("charlie", 17));
        typeSafeList.add(new TypeReference<User>(){}, new User("mark", 31));

        // then
        assertThat(typeSafeList.getValues(new TypeReference<Integer>(){})).isEqualTo(List.of(4934));
        typeSafeList.add(new TypeReference<Integer>() {}, 2391);
        assertThat(typeSafeList.getValues(new TypeReference<Integer>(){})).isEqualTo(List.of(4934, 2391));
        assertThat(typeSafeList.getValues(new TypeReference<String>(){})).isEqualTo(Collections.emptyList());
        assertThat(typeSafeList.getValues(new TypeReference<List<Double>>(){})).isEqualTo(List.of(List.of(13.0, 50.2)));
        typeSafeList.add(new TypeReference<List<Double>>(){}, List.of(543.23, 705.06));
        assertThat(typeSafeList.getValues(new TypeReference<List<Double>>(){})).isEqualTo(List.of(List.of(13.0, 50.2), List.of(543.23, 705.06)));
        assertThat(typeSafeList.getValues(new TypeReference<User>(){}).get(0).getName()).isEqualTo("charlie");
        assertThat(typeSafeList.getValues(new TypeReference<List<Map<Integer, String>>>(){}).get(0).get(0).get(42)).isEqualTo("the answer to the 'ultimate question of life, the universe, and everything.'");
        assertThat(typeSafeList.getValues(new TypeReference<User>(){}).get(0).setGrade(Grade.VVIP).getGrade()).isEqualTo(Grade.VVIP);
        /**
         *  after check
         *  print all list elements in typeSafeList
         *  typeSafeList.list.stream().forEach((v) -> System.out.println(v + " "));
         */
    }

    @Test
    @DisplayName("TypeSafeList에 담긴 타입들을 검증함, getType(int index) 사용")
    public void typeSafeListTest2() {
        // given
        TypeSafeList typeSafeList = new TypeSafeList();
        // given for compare using typeReference
        ResolvableType listDoubleRT = ResolvableType.forInstance(new TypeReference<List<Double>>() {});
        ResolvableType listMapRT = ResolvableType.forInstance(new TypeReference<List<Map<Integer, String>>>() {});

        // when
        typeSafeList.add(new TypeReference<Integer>() {}, 4934);
        typeSafeList.add(new TypeReference<List<Double>>() {}, List.of(13.0, 50.2));
        typeSafeList.add(new TypeReference<List<Map<Integer, String>>>() {}, List.of(Map.of(42, "the answer to the 'ultimate question of life, the universe, and everything.'")));
        typeSafeList.add(new TypeReference<User>(){}, new User("charlie", 17));
        typeSafeList.add(new TypeReference<User>(){}, new User("mark", 34));

        assertThat(typeSafeList.getType(0)).isEqualTo(Integer.class);
        assertThat(typeSafeList.getType(1)).isEqualTo(listDoubleRT.getSuperType().getNested(2).getType());
        assertThat(typeSafeList.getType(2)).isEqualTo(listMapRT.getSuperType().getNested(2).getType());
        assertThat(typeSafeList.getType(3)).isEqualTo(User.class);
        assertThat(typeSafeList.getType(4)).isEqualTo(User.class);
    }

    @Test
    @DisplayName("TypeSafeList에 담긴 값 하나를 꺼내어 검증함, getValue(int value) 사용")
    public void typeSafeListTest3() {
        // given
        TypeSafeList tslist = new TypeSafeList();
        // given for compare using typeReference
        ResolvableType listDoubleRT = ResolvableType.forInstance(new TypeReference<List<Double>>() {});
        ResolvableType listMapRT = ResolvableType.forInstance(new TypeReference<List<Map<Integer, String>>>() {});

        // when
        tslist.add(new TypeReference<Integer>() {}, 4934);
        tslist.add(new TypeReference<List<Double>>() {}, List.of(13.0, 50.2));
        tslist.add(new TypeReference<List<Map<Integer, String>>>() {}, List.of(Map.of(42, "the answer to the 'ultimate question of life, the universe, and everything.'")));
        tslist.add(new TypeReference<User>(){}, new User("charlie", 17));
        tslist.add(new TypeReference<User>(){}, new User("mark", 34));

        assertThat(tslist.getValue(0).get(0)).isEqualTo(4934);
        assertThat(tslist.getValue(1).get(0)).isEqualTo(List.of(13.0, 50.2));
        assertThat(tslist.getValue(2).get(0)).isEqualTo(List.of(Map.of(42, "the answer to the 'ultimate question of life, the universe, and everything.'")));
        assertThat(tslist.getValue(3).get(0)).isEqualTo(new User("charlie", 17));
        assertThat(tslist.getValue(4).get(0)).isNotEqualTo(new User("charlie", 17));
    }

    @Test
    @DisplayName("TypeSafeList foreach type validation")
    public void typeSafeListTest4() {
        // given
        TypeSafeList typeSafeList = new TypeSafeList();

        // when
        typeSafeList.add(new TypeReference<Integer>() {}, 4934);
        typeSafeList.add(new TypeReference<List<Double>>() {}, List.of(13.0, 50.2));
        typeSafeList.add(new TypeReference<List<Map<Integer, String>>>() {}, List.of(Map.of(42, "the answer to the 'ultimate question of life, the universe, and everything.'")));
        typeSafeList.add(new TypeReference<User>(){}, new User("charlie", 17));
        typeSafeList.add(new TypeReference<User>(){}, new User("mark", 34));

        for(int i = 0; i < typeSafeList.size(); i++) {
            assertTrue(typeSafeList.getList().get(i).isSameTypeWith(typeSafeList.getType(i)));
        }

        for(var i : typeSafeList) {
            System.out.println(i.getData());
        }
    }
}

sort example not using printf

3COLORED — Sat, 12 Dec 2020 23:58:11 +0900

#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include "functionPointer.h"

#define SIZE(array) sizeof(array) / sizeof(int)

bool descending(int x, int y)
{
    return (x < y);
}

bool ascending(int x, int y)
{
    return (x > y);
}

void swap(int *x, int *y)
{
    int temp;

    temp = *x;
    *x = *y;
    *y = temp;
}
void ft_putchar(char *str)
{
    while (*str)
        write(1, str++, 1);
}

int ft_len(char *str)
{
    int i;

    i = 0;
    while (str[i])
        i++;

    return (i);
}

char *ft_reverse(char *str)
{
    int i;
    int size;
    char temp;

    size = ft_len(str);
    i = 0;
    while (i < size / 2)
    {
        temp = str[i];
        str[i] = str[size - i - 1];
        str[size - i - 1] = temp;
        i++;
    }
    return (str);
}

void sort(int *array, int size, bool (*comparisonFnc)(int, int))
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - i - 1; j++)
        {
            if (comparisonFnc(array[j], array[j + 1]))
                swap(&array[j], &array[j + 1]);
        }
    }
};

int ft_size(int integer)
{
    int i;

    i = 0;
    while (integer > 0)
    {
        integer /= 10;
        i++;
    }
    return (i);
}

char *ft_itoa(int integer)
{
    int nbr;
    bool negative;
    char *result;
    int i;

    negative = false;
    nbr = integer;
    if (nbr < 0)
    {
        nbr = -nbr;
        negative = true;
    }
    result = (char *)malloc(sizeof(char) * ft_size(nbr) + 2);

    i = 0;
    while (nbr > 0)
    {
        result[i++] = (nbr % 10) + 48;
        nbr /= 10;
    }
    if (negative)
        result[i++] = '-';
    result[i] = '\0';
    result = ft_reverse(result);
    return (result);
}

void ft_print_result(int *arr, int size)
{
    for (int i = 0; i < size; i++)
    {
        ft_putchar(ft_itoa(arr[i]));
        ft_putchar(" ");
    }
    ft_putchar("\n");
}

int main(void)
{
    int arr[10] = {10, 2, 8, 6, 1, -3, 4, 7, 5, 9};
    int size;
    size = SIZE(arr);
    sort(arr, size, descending);
    ft_print_result(arr, size);
    sort(arr, size, ascending);
    ft_print_result(arr, size);
    return (0);
}

void sort(int* array, int size, bool (*comparisonFnc)(int, int));
bool descending(int x, int y);
bool ascending(int x, int y); 
void swap(int *x, int *y);

은행 계좌 관리 프로그램 ver 1.1

3COLORED — Thu, 3 Sep 2020 19:25:43 +0900

/*
 * @author  : Charlie Lee
 * @date    : 2020-09-03
 * @email   : find1086@gmail.com
 *
 * @info    : simple bank account manage program.
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

public class GenericBankingSystem {
    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static final Map<String, List<BankAccount>> accountsMap = new HashMap<>();
    private static final List<BankUser> userList = new ArrayList<>();

    private static Long accountId = 0L;
    private static final GenericBankingSystem bankSystem = GenericBankingSystem.getInstance();
    private GenericBankingSystem() {}
    public static GenericBankingSystem getInstance() {
        if(bankSystem == null) return new GenericBankingSystem();
        return bankSystem;
    }

    public static void main(String[] args) throws IOException {
        System.out.println("Welcome to Bank System.");
        bankSystem.run();
    }

    public void run() throws IOException {
        boolean flag = true;
        while(flag) {
            bankSystem.addAccount();
            System.out.print("successfully added. do you want to add more? (y/n) : ");
            String addmore = br.readLine().toLowerCase();
            if(!addmore.equals("y")) flag = false;
        }
        bankSystem.manageAccount();
    }

    private void addAccount() throws IOException {
        boolean flag = true;
        String accountNumber = "";
        while(flag) {
            System.out.println("type account number please.");
            accountNumber = validateFormat(br.readLine());
            if(accountNumber != null) flag = checkDuplicatedAccountNumber(accountNumber);
            else System.out.println("it seems not valid account number format.");
        }
        System.out.print("type username for adding this account : ");
        String username = br.readLine();
        BankUser user;
        if(!accountsMap.containsKey(username)) {
            user = new BankUser(username);
        } else {
            user = userList.stream()
                           .filter(name -> (name.getUsername()).equals(username))
                           .findFirst()
                           .orElse(null);
        }
        if(user != null) {
            user.addAccount(new BankAccount(++accountId, accountNumber));
            userList.add(user);
            accountsMap.put(username, user.getAccountList());
        } else {
            throw new Error("Unexpected Error! contact to the Administrator.");
        }
    }

    private String validateFormat(String text) {
        String koreanFormat = "^[0-9]{3,6}+[-]?[0-9]{2,6}+[-]?[0-9]{1,7}+([-]?[0-9]{1,7})?$";
        if(text.matches(koreanFormat)) return text;
        return null;
    }

    private boolean checkDuplicatedAccountNumber(String accountNumber) {
        boolean exist = bankSystem.findDuplicatedAccountNumer(accountNumber);
        if(exist) System.out.println("this number is already exist. try other please.");
        return exist;
    }

    private boolean findDuplicatedAccountNumer(String number) {
        if(userList.size() <= 0) return false;
        return userList.stream().anyMatch(user -> accountsMap.get(user.getUsername())
                                                                      .stream()
                                                                      .anyMatch(v -> (v.getAccountNumber()).equals(number)));
    }

    private void manageAccount() throws IOException {
        boolean flag = true;
        while (flag) {
            String name = chooseUserAccount();
            List<BankAccount> accountsOfanUser = accountsMap.get(name);
            bankSystem.printUserAccount(accountsOfanUser);
            // specify which account state change.
            BankAccount account = bankSystem.chooseOneAccount(accountsOfanUser);
            bankSystem.controlAccount(account);
            flag = bankSystem.continueToManage();
        }
    }

    private boolean continueToManage() throws IOException {
        System.out.println("would you like to return to select user? (y/n)");
        String value = br.readLine().toLowerCase();
        if (value.equals("n")) {
            System.out.println("would you like to go back selecting account menu ? (y/n) : ");
            value = br.readLine().toLowerCase();
            if(value.equals("n")) {
                System.out.println("would you like to go back first step? (y/n) : n will shut down program) : ");
                value = br.readLine().toLowerCase();
                if(value.equals("n")) {
                    System.out.println("okay. program will be shut down.");
                    br.close();
                } else {
                    System.out.println("Welcome back to account registration.");
                    bankSystem.run();
                }
            } else {
                bankSystem.manageAccount();
            }
            return false;
        }
        return true;
    }

    private BankAccount chooseOneAccount(List<BankAccount> accountsOfanUser) throws IOException {
        System.out.println("which account's balance do you want to change?");
        System.out.print("please choose number in [], not account number : ");
        int accountId = parseToInt(br.readLine()) - 1;
        return accountsOfanUser.get(accountId);
    }

    private void printUserAccount(List<BankAccount> accountsOfanUser) {
        System.out.println("The user has those accounts: ");
        for (int i = 1; i <= accountsOfanUser.size(); i++) {
            System.out.println("[" + i + "] " + accountsOfanUser.get(i - 1));
        }
    }

    private String chooseUserAccount() throws IOException {
        String name;
        do {
            System.out.println("::: user account list :::");
            Set<String> key = accountsMap.keySet();
            for (String o : key) {
                System.out.print(o + " ");
            }
            System.out.println("\nwhich users account do you want manage? : ");
            name = br.readLine();
        } while (!bankSystem.validateRegisteredUser(name));
        return name;
    }

    private boolean validateRegisteredUser(String name) {
        if (!accountsMap.containsKey(name)) {
            System.out.println("this user seems not registered yet.");
            return false;
        }
        return true;
    }

    private void controlAccount(BankAccount account) throws IOException {
        boolean changeMoneyProcess = true;
        int chooseNum;
        while (changeMoneyProcess) {
            System.out.println("what would you want to do? choose number please.");
            System.out.println("[1] deposit [2] withdraw [3] show money balance");
            chooseNum = parseToInt(br.readLine());
            switch (chooseNum) {
                case 1: {
                    System.out.println("how much money do you want to deposit ?");
                    account.depositMoney(parseToDouble(br.readLine()));
                    break;
                }
                case 2: {
                    System.out.println("how much money do you want to withdraw ?");
                    account.withdrawMoney(parseToDouble(br.readLine()));
                    break;
                }
                case 3:
                    break;
                default:
                    System.out.println("not service this number yet.");
            }
            System.out.printf("money balance : %5.2f\n", account.getMoney());
            changeMoneyProcess = wantToContinueChangeMoney();
        }
    }

    private boolean wantToContinueChangeMoney() throws IOException {
        System.out.println("would you want to continue changing money balance ? (y/n)");
        return !(br.readLine()).equals("n");
    }

    private static Integer parseToInt(String text) throws IOException {
        boolean isAbleToParseInt = false;
        int parsedInt = 0;
        while (!isAbleToParseInt) {
            try {
                parsedInt = Integer.parseInt(text);
                isAbleToParseInt = true;
            } catch (NumberFormatException nfe) {
                System.out.println("it seems not number! please check again.");
                text = br.readLine();
            }
        }
        return parsedInt;
    }

    private static Double parseToDouble(String text) throws IOException {
        boolean isAbleToParseDouble = false;
        double parsedDouble = 0;
        while (!isAbleToParseDouble) {
            try {
                parsedDouble = Double.parseDouble(text);
                isAbleToParseDouble = true;
            } catch (NumberFormatException nfe) {
                System.out.println("it seems not number! please check again.");
                text = br.readLine();
            }
        }
        return parsedDouble;
    }
}

class BankUser {
    private final String username;
    private final List<BankAccount> accountList = new ArrayList<>();

    public BankUser(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    public void addAccount(BankAccount account) {
        accountList.add(account);
    }

    public List<BankAccount> getAccountList() {
        return accountList;
    }

    @Override
    public String toString() {
        return "BankUser{" +
                "username='" + username + '\'' +
                ", accountList=" + accountList +
                '}';
    }
}

class BankAccount {
    private final long accountId;
    private final String accountNumber;
    private final LocalDateTime regDate;
    private double money;
    public BankAccount(long accountId, String accountNumber) {
        this.accountId = accountId;
        this.accountNumber = accountNumber;
        this.regDate = LocalDateTime.now();
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BankAccount)) return false;
        BankAccount that = (BankAccount) o;
        return accountId == that.accountId &&
                Double.compare(that.money, money) == 0 &&
                Objects.equals(accountNumber, that.accountNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(accountId, accountNumber, money);
    }

    @Override
    public String toString() {
        return  "accountNumber: " + accountNumber +
                "\n\tmoney: " + money +
                "\n\tregDate: " + regDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "\n";
    }

    public double getMoney() {
        return money;
    }

    public void depositMoney(double money) {
        this.money += money;
    }

    public void withdrawMoney(double money) {
        double temp = this.money -= money;
        if (temp < 0) {
            throw new Error("you can't withdraw that money.");
        }
        this.money = temp;
    }
}

// http://colorscripter.com/s/rcw1z3L
// http://colorscripter.com/s/rcw1z3L
// http://colorscripter.com/s/rcw1z3L

간단한 은행 계좌 관리 프로그램

3COLORED — Sun, 30 Aug 2020 12:05:19 +0900

/*
 * @author : Charlie Lee
 * @date   : 2020-08-31
 * @email  : find1086@gmail.com
 * @conf   : openJDK 11.0.2
 *
 * @comment: simple national bank account management program.
 *           UUID.randomUUID() logically equals account number in this program.
 * @to-do  : save data to RDB or some place.
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

enum BankList {
    AMERICA, INDIA, SINGAPORE, CHINA, KOREA
}

public class BankService {
    private final static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private final static Map<String, List<Account>> map = new HashMap<>();
    private final static List<User> users = new ArrayList<>();
    private static final BankService bankService = getInstance();
    private BankService() {}
    public static BankService getInstance() {
        if(bankService == null) return new BankService();
        return bankService;
    }

    private static Long accountId = 0L;

    public static void main(String[] args) throws IOException {
        runBankService();
    }

    public static void runBankService() throws IOException {
        createUsers();
        createAccounts();
        printInformation();
        manageAccount();
    }

    private static void createUsers() throws IOException {
        System.out.print("how many user you want to create? : ");
        int n = parseToInt(br.readLine());
        for (int i = 0; i < n; i++) {
            createUser();
        }
    }

    private static void createAccounts() throws IOException {
        System.out.print("how many account you want to create? : ");
        int m = parseToInt(br.readLine());
        for (User user : users) {
            for (int j = 0; j < m; j++) {
                createAccount(user);
            }
            System.out.println("complete creating account.");
        }
    }

    private static void createUser() throws IOException {
        System.out.print("type username to create: ");
        String username = br.readLine();
        users.add(new User(username));
    }

    private static void createAccount(User user) throws IOException {
        System.out.println("Which bank account would you like to create?");
        printBanksList();
        chooseBankName(user);
    }

    private static void printBanksList() {
        System.out.print("[ ");
        String banks = Arrays.stream(BankList.values())
                             .map(String::valueOf)
                             .collect(Collectors.joining(", "));
        System.out.print(banks);
        System.out.println(" ]");
    }

    private static void chooseBankName(User user) throws IOException {
        System.out.print("choose bankname you want to create: ");
        String src = (br.readLine()).toUpperCase();
        boolean isValidBankName = checkValidBankName(src);
        if (isValidBankName) {
            Account account = new Account(++accountId, src, String.valueOf(UUID.randomUUID()));
            checkDuplicateAccount(user, account);
            user.addAccount(account);
            map.put(user.getUsername(), user.getAccountList());
        } else {
            throw new Error("sorry. could not find bank in the list. please try later.");
        }
    }

    private static boolean checkValidBankName(String src) {
        for (BankList bank : BankList.values()) {
            if (src.equals(bank.toString())) return true;
        }
        return false;
    }

    private static void checkDuplicateAccount(User user, Account account) {
        if (map.isEmpty()) return;
        if (map.get(user.getUsername()) == null || map.get(user.getUsername()).size() <= 0) return;
        boolean check = findDuplicatedAccount(user, account);
        if (check) throw new Error("this account already exists. please check right account registration.");
    }

    private static boolean findDuplicatedAccount(User user, Account account) {
       return map.get(user.getUsername())
                 .stream()
                 .anyMatch(acc -> acc.equals(account));
    }

    private static void printInformation() {
        Set<String> key = map.keySet();
        for (User u : users) {
            for (Iterator<String> iterator = key.iterator(); iterator.hasNext(); ) {
                System.out.println("username: " + iterator.next() + ", account: " + map.get(u.getUsername()));
            }
        }
    }

    private static boolean validateRegisteredUser(String name) {
        if (!map.containsKey(name)) {
            System.out.println("this user seems not registered yet. check your query right please.");
            return false;
        }
        return true;
    }

    private static void manageAccount() throws IOException {
        boolean flag = true;
        while (flag) {
            String name = chooseUserAccount();
            List<Account> accountsOfanUser = map.get(name);
            printUserAccount(accountsOfanUser);
            // 4-1. specify which account state change.
            Account account = chooseOneAccount(accountsOfanUser);
            controlAccount(account);
            flag = continueToManage();
        }
    }

    private static boolean continueToManage() throws IOException {
        System.out.println("would you like to continue to manage account? (y/n)");
        String value = br.readLine();
        if (value.equals("n")) {
            System.out.println("okay. program will be shut down.");
            return false;
        }
        return true;
    }

    private static Account chooseOneAccount(List<Account> accountsOfanUser) throws IOException {
        System.out.println("which account's balance do you want to change?");
        System.out.print("please choose number in [], not account id : ");
        int accountId = parseToInt(br.readLine()) - 1;
        return accountsOfanUser.get(accountId);
    }

    private static void printUserAccount(List<Account> accountsOfanUser) {
        System.out.println("The user has : ");
        for (int i = 1; i <= accountsOfanUser.size(); i++) {
            System.out.println("[" + i + "] " + accountsOfanUser.get(i - 1));
        }
    }

    private static String chooseUserAccount() throws IOException {
        String name;
        do {
            System.out.println("::: user account list :::");
            Set<String> key = map.keySet();
            for (String o : key) {
                System.out.print(o + " ");
            }
            System.out.println("\nwhich users account do you want manage? : ");
            name = br.readLine();
        } while (!validateRegisteredUser(name));
        return name;
    }

    private static void controlAccount(Account account) throws IOException {
        boolean changeMoneyProcess = true;
        int chooseNum;
        while (changeMoneyProcess) {
            System.out.println("what would you want to do? choose number please.");
            System.out.println("[1] deposit [2] withdraw [3] show money balance");
            chooseNum = parseToInt(br.readLine());
            switch (chooseNum) {
                case 1: {
                    System.out.println("how much money do you want to deposit ?");
                    account.depositMoney(parseToDouble(br.readLine()));
                    break;
                }
                case 2: {
                    System.out.println("how much money do you want to withdraw ?");
                    account.withdrawMoney(parseToDouble(br.readLine()));
                    break;
                }
                case 3:
                    break;
                default:
                    System.out.println("not service this number yet.");
            }
            System.out.printf("money balance : %5.2f\n", account.getMoney());
            changeMoneyProcess = wantToContinueChangeMoney();
        }
    }

    private static Integer parseToInt(String text) throws IOException {
        boolean isAbleToParseInt = false;
        int parsedInt = 0;
        while (!isAbleToParseInt) {
            try {
                parsedInt = Integer.parseInt(text);
                isAbleToParseInt = true;
            } catch (NumberFormatException nfe) {
                System.out.println("it seems not number! please check again.");
                System.out.print("how many user you want to create? : ");
                text = br.readLine();
            }
        }
        return parsedInt;
    }

    private static Double parseToDouble(String text) throws IOException {
        boolean isAbleToParseDouble = false;
        double parsedDouble = 0;
        while (!isAbleToParseDouble) {
            try {
                parsedDouble = Double.parseDouble(text);
                isAbleToParseDouble = true;
            } catch (NumberFormatException nfe) {
                System.out.println("it seems not number! please check again.");
                System.out.print("how many user you want to create? : ");
                text = br.readLine();
            }
        }
        return parsedDouble;
    }

    private static boolean wantToContinueChangeMoney() throws IOException {
        System.out.println("would you want to continue changing money balance ? (y/n)");
        return !(br.readLine()).equals("n");
    }
}

class User {
    private final String username;
    private final List<Account> accountList;

    public User(String username) {
        this.username = username;
        accountList = new ArrayList<>();
    }

    public String getUsername() {
        return username;
    }

    public void addAccount(Account account) {
        accountList.add(account);
    }

    public List<Account> getAccountList() {
        return accountList;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", accountList=" + accountList +
                '}';
    }
}

class Account {
    private final Long id;
    private final String bankName;
    private final String accountNumber;
    private double money;

    public Account(Long id, String bankName, String accountNumber) {
        this.id = id;
        this.bankName = bankName;
        this.accountNumber = accountNumber;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Account)) return false;
        Account account = (Account) o;
        return Objects.equals(id, account.id) &&
                Objects.equals(bankName, account.bankName) &&
                Objects.equals(accountNumber, account.accountNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, bankName, accountNumber);
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", bankName='" + bankName + '\'' +
                ", accountNumber='" + accountNumber + '\'' +
                '}';
    }

    public double getMoney() {
        return money;
    }

    public void depositMoney(double money) {
        this.money += money;
    }

    public void withdrawMoney(double money) {
        if ((this.money -= money) < 0) {
            throw new Error("you can't withdraw that money.");
        }
        this.money -= money;
    }
}

//  http://colorscripter.com/s/YX09IfQ

Java enum 활용법

3COLORED — Wed, 29 Jul 2020 05:36:25 +0900

설명하기에 앞서..

이 포스팅은 본래 enum의 주 사용목적인

열거형 제한을 걸어 개발자의 실수를 막는다거나
인스턴스 생성 및 상속을 방지하여
상수값의 타입안정성 보장 등을
하기 위한 목적으로 작성된 것이 아님을 알려드립니다.

JAVA enum을 사용하여 코드가 단순해짐에 따라
가독성이 상승하는 효과만을 위해 쓰여졌습니다

따라서 이 글에서 언급될 코드들은
enum 사용없이 구현해도 상관없습니다.

자바의 enum은 다른 언어와 다르게 클래스 취급을 받기 때문에 생성자 선언을 통해 다양한 일을 할 수 있습니다.
이를테면 아래의 코드처럼 enum의 각 요소들의 생성자에 특정한 수학 공식을 미리 기입해둠으로 메서드처럼* 사용할 수 있습니다.

(실사용 코드는 글 맨 아래에 있습니다.)

//JAVA 8
public enum Calculator {

    POWER(n -> n * n), // n제곱
    GAUSE(n -> (1 + n) * (n / 2)), // 1부터 n까지 합산한 결과
    PYTHAGORAS((n, m) -> Math.sqrt(POWER.calculate(n) + POWER.calculate(m)));

    private Function<Long, Long> expression;
    private BiFunction<Long, Long, Double> pyhagoras;
    private Calculator(Function<Long, Long> expression) {
        this.expression = expression;
    }
    private Calculator(BiFunction<Long, Long, Double> pyhagoras) {
        this.pyhagoras = pyhagoras;
    }
    public long calculate(long value) {
        return expression.apply(value);
    }
    public double calculate(long a, long b) {
        return pyhagoras.apply(a, b);
    }
}

JAVA 8 미만의 버전에서는 람다 기능을 지원하지 않기 때문에

생성자(ABC(n, m) 등)내에서 유동적인 값의 계산이 불가능합니다.
예를 들어 POWER(3, 4) 는 요소로 선언가능하지만, POWER(n, m)는 요소로 올 수 없습니다.
아래의 코드를 참고하세요.

enum EnumPossible {
    ABC(3, 4);  // 선언 가능.
    EnumPossible(int n, int m) {} 
}

enum EnumImpossible {
    ABC(n, m); // 선언 불가능
    EnumImpossible(int n, int m) {}
}

따라서 JAVA 8 방식에서 사용된 방식과 동일하게 사용하려면 아래와 같이 작성할 수 있습니다.

그러나 코드에서도 알 수 있듯 각 enum 요소에서 구현되는 추상 메소드들에 대한 오버로딩이 사용될 경우

불필요한 메소드조차 강제로 구현해야하는 단점이 존재합니다.

//JAVA 7
enum Calculator7 {
    POWER7 {
        long calculate(long n) { return n * n; }
        double calculate(long value, long value2) { return 0; } // 불필요한 코드 구현을 강제당함
    },
    GAUSE7 {
        long calculate(long n) { return (1 + n) * (n / 2); }
        double calculate(long value, long value2) { return 0; } // // 불필요한 코드 구현을 강제당함
    },
    PYTHAGORAS7 {
        long calculate(long value) { return 0; } // 불필요한 코드 구현을 강제당함
        double calculate(long n, long m) {
            return Math.sqrt(POWER7.calculate(n) + POWER7.calculate(m));
        }
    };
    abstract long calculate(long value);
    abstract double calculate(long n, long m);
}

개발자의 실수를 유발할 수 있는 이런 치명적인 단점 때문에 enum에서의 추상메소드 사용기법이 추천되지 않았으나
JAVA 8부터 함수형 프로그래밍이 가능해짐에 따라 역량에 따라 활용도를 높일 수 있을 것입니다.

JAVA8, JAVA7 enum 사용 코드

class RunCalculator {
    public static void main(String[] args) {
        System.out.println("------------JAVA 8-------------");
        Calculator gause = Calculator.GAUSE;
        System.out.println(gause.calculate(100));

        Calculator pyhagoras = Calculator.PYTHAGORAS;
        System.out.println(pyhagoras.calculate(3, 4));

        System.out.println("------------JAVA 7-------------");

        Calculator7 gause7 = Calculator7.GAUSE7;
        System.out.println(gause7.calculate(100));
        Calculator7 pytagoras7 = Calculator7.PYTHAGORAS7;
        System.out.println(pytagoras7.calculate(3, 4));

    }
}

JAVA8 방식이든 JAVA7 방식이든 의도에 맞게 사용한다면
결과값은 아래와 같이 서로 동일하게 출력됩니다.

[전체코드]

import java.util.function.BiFunction;
import java.util.function.Function;

//JAVA 8
public enum Calculator {

POWER(n -> n * n), // n제곱
GAUSE(n -> (1 + n) * (n / 2)), // 1부터 n까지 합산한 결과
PYTHAGORAS((n, m) -> Math.sqrt(POWER.calculate(n) + POWER.calculate(m)));

private Function<Long, Long> expression;
private BiFunction<Long, Long, Double> pyhagoras;
private Calculator(Function<Long, Long> expression) {
this.expression = expression;
}
private Calculator(BiFunction<Long, Long, Double> pyhagoras) {
this.pyhagoras = pyhagoras;
}
public long calculate(long value) {
return expression.apply(value);
}
public double calculate(long a, long b) {
return pyhagoras.apply(a, b);
}
}

//JAVA 7
enum Calculator7 {
POWER7 {
long calculate(long n) { return n * n; }
double calculate(long value, long value2) { return 0; } // 불필요한 코드 구현을 강제당함
},
GAUSE7 {
long calculate(long n) { return (1 + n) * (n / 2); }
double calculate(long value, long value2) { return 0; } // // 불필요한 코드 구현을 강제당함
},
PYTHAGORAS7 {
long calculate(long value) { return 0; } // 불필요한 코드 구현을 강제당함
double calculate(long n, long m) {
return Math.sqrt(POWER7.calculate(n) + POWER7.calculate(m));
}
};

abstract long calculate(long value);
abstract double calculate(long n, long m);
}

class RunCalculator {
public static void main(String[] args) {
System.out.println("------------JAVA 8-------------");
Calculator gause = Calculator.GAUSE;
System.out.println(gause.calculate(100));

Calculator pyhagoras = Calculator.PYTHAGORAS;
System.out.println(pyhagoras.calculate(3, 4));

System.out.println("------------JAVA 7-------------");

Calculator7 gause7 = Calculator7.GAUSE7;
System.out.println(gause7.calculate(100));
Calculator7 pytagoras7 = Calculator7.PYTHAGORAS7;
System.out.println(pytagoras7.calculate(3, 4));

}
}

SQLD 1일차 연습 문제(데이터 모델의 이해, 엔터티)

3COLORED — Wed, 29 Jul 2020 03:42:08 +0900

DBGuide의 SQL 개발자 학습내용을 공부하며 개인적으로 정리한 문제들입니다.

출처: http://www.dbguide.net/db.dbcmd=view&boardUid=148179&boardConfigUid=9&categoryUid=216&boardIdx=132&boardStep=1

데이터 전문가 지식포털 DBGuide.net

엔터티 속성 관계 식별자 데이터 모델의 이해 1. 엔터티의 개념 데이터 모델을 이해할 때 가장 명확하게 이해해야 하는 개념 중에 하나가 바로 엔터티(Entity)이다. 이것은 우리말로 실체, 객체라��

www.dbguide.net

1장 데이터 모델의 이해, 엔터티

1. 데이터 모델링에 대해 잘못 설명한 것을 고르세요.

① 정보시스템을 구축하기 위한 데이터 관점의 업무 분석 기법

② 현실 세계의 데이터에 대해 약속된 표기법에 의해 표현하는 과정
③ 데이터베이스를 구축하기 위한 분석/설계의 과정
④ 단순한 현실 세계를 복잡화된 설계도로 표현하는 과정

2. 데이터 모델링의 올바른 순서를 고르세요.

① 개념적 - 논리적 – 물리적
② 개념적 - 물리적 - 논리적
③ 논리적 - 개념적 – 물리적
④ 물리적 - 개념적 – 논리적
⑤ 논리적 - 물리적 - 개념적

3. 엔터티에 대해 잘못 설명한 것을 고르세요.

① 사람, 장소, 물건, 사건, 개념 등의 명사에 해당된다.
② 정보를 저장할 수 있는 어떤 것
③ 업무상 관리가 필요한 관심사들을 일컫는다.
④ 인스턴스, 혹은 객체라고도 한다.

4.엔터티의 특징 중 잘못된 것을 고르세요.

① 반드시 해당 업무에서 필요하고 관리하고자 하는 정보여야 합니다.
② 반드시 속성(attribute)이 있어야 합니다.
③ 다른 엔터티와 최소 한 개 이상의 관계가 있어야 합니다.
④ 유일한 식별자에 의해 식별이 가능해야 합니다.
⑤ 반드시 인스턴스의 집합일 필요는 없습니다.

5.스키마에 대한 내용 중 잘못된 것을 두 개 고르세요.

① 외부 스키마는 모든 사용자 관점을 통합한 전체적인 하나의 관점으로 구성되어 있다.
② 개념 스키마는 View 단계 여러 개의 사용자 관점으로 구성되며,

개개 사용자 단계로서 개개 사용자나 응용프로그래머가 접근하는 DB 정의이다.
③ 내부스키마는 DB가 물리적으로 저장된 형식을 말한다.
④ 외부스키마는 사용자 관점이며, 접근하는 특성에 따른 스키마로 구성되어 있다.

[정답표]

1번: 정답 4
2번: 정답 1
3번: 정답 4
4번: 정답 5
5번: 정답 1, 2

프로그래머스 mysql 7day-SQL 있었는데요 없었습니다

3COLORED — Sat, 7 Sep 2019 01:17:02 +0900

SELECT a.ANIMAL_ID, a.NAME
FROM ANIMAL_INS a JOIN ANIMAL_OUTS b
ON a.ANIMAL_ID = b.ANIMAL_ID
WHERE a.DATETIME > ANY (SELECT b.DATETIME
                        FROM ANIMAL_OUTS
                       ) 
ORDER BY a.DATETIME

https://programmers.co.kr/learn/courses/30/lessons/59043

코딩테스트 연습 - 있었는데요 없었습니다 | 프로그래머스

ANIMAL_INS 테이블은 동물 보호소에 들어온 동물의 정보를 담은 테이블입니다. ANIMAL_INS 테이블 구조는 다음과 같으며, ANIMAL_ID, ANIMAL_TYPE, DATETIME, INTAKE_CONDITION, NAME, SEX_UPON_INTAKE는 각각 동물의 아이디, 생물 종, 보호 시작일, 보호 시작 시 상태, 이름, 성별 및 중성화 여부를 나타냅니다. NAME TYPE NULLABLE ANIMAL_ID VARCHAR(N) FALS

programmers.co.kr

https://programmers.co.kr/events/7day-sql

7daySQL 챌린지 | 프로그래머스

코딩테스트에 SQL문제 비중이 해마다 증가하는데, 어떻게 준비하면 좋을까요? 이제 프로그래머스에서 SQL 쿼리도 연습하세요!

programmers.co.kr

프로그래머스 mysql 7day-SQL 없어진 기록 찾기

3COLORED — Sat, 7 Sep 2019 01:16:15 +0900

SELECT b.ANIMAL_ID, b.NAME
FROM ANIMAL_INS a
RIGHT OUTER JOIN ANIMAL_OUTS AS b 
ON a.ANIMAL_ID = b.ANIMAL_ID
WHERE a.ANIMAL_ID IS NULL

https://programmers.co.kr/learn/courses/30/lessons/59042

코딩테스트 연습 - 없어진 기록 찾기 | 프로그래머스

programmers.co.kr

https://programmers.co.kr/events/7day-sql

7daySQL 챌린지 | 프로그래머스

코딩테스트에 SQL문제 비중이 해마다 증가하는데, 어떻게 준비하면 좋을까요? 이제 프로그래머스에서 SQL 쿼리도 연습하세요!

programmers.co.kr