개요

 이전 게시글 홈 네트워크 구성기와 같이 라우터와 스위치가 늘어남에 따라 주변기기가 너무 많아진 탓에 이를 하나로 정리할 수 있는 수단이 필요하게 되었다. 서버랙 구매를 위해 자료를 찾아보았으나 필자는 자취생으로 너무 오버스펙인 것 같아 리빙박스에 홈 네트워크를 이전한 내용을 다음과 같이 공유한다.

홈 네트워크 구성기가 궁굼한 독자가 있다면 다음 게시글을 참고하면 될 것 같다.

현재의 네트워크 구성과 장비

 홈 네트워크 구성도와 같이 필자는 라우터 두대 스위치 세대를 포함해 다양한 네트워크 장비를 이용중이다. 해당 장비들의 특징은 발열이 크지 않고 가까이 위치해 랜 케이블 연결이 원활해야하며 전원 공급이 안정적이어야 한다는 점이다. 이에 따라 필자는 적당한 크기의 리빙 박스에 이 장비들을 모아두고 관리하고자 한다.

네트워크 장비 정리를 위한 재료

 네트워크 박스를 만들어 홈 네트워크 장비를 한 공간에서 관리하는 것을 목표로 하고 있다. 여기에 들어간 재료의 목록은 다음과 같다.

리빙박스 선정 : 13,890원 x 1 = 13,890원

 리빙 박스의 경우 다음 링크의 상품을 이용하였다. 네트워크 장비의 경우 발열이 적긴 하나 바람이 원활히 오갈 수 있어야한다. 하지만, 타공 리빙박스의 경우 별도로 구매할 수 있는 경로가 없으므로 접이식 리빙 박스를 활용해 접히는 부분의 틈새를 통한 공기 흐름과 손잡이 부분의 쿨러 설치를 통해 쿨링 효과를 얻어보고자 한다.

쿨러 선정 : 12,500원 x 2 = 25,000원

 쿨러의 경우 다음 링크의 상품을 이용하였다. 네트워크 장비의 특성상 24시간 구동을 목표로 하며 쿨러 또한 이와 같다. 이에 따라 쿨러는 소음을 최대한 적게 발생시키며 쿨링 효과를 가져갈 수 있는 60mm USB 팬으로 선택하였다.

쿨러 전원 공급 선정 : 3,380 x 1 = 3,380원

 전원 공급의 경우 USB 팬이므로 다음과 같이 저렴한 2구 충전기를 선택하였다.

멀티탭 선정 : 16,900 x 2 = 33,800원

 각 네트워크 장비의 안정적인 전원 공급과 안정성을 위해 스윗홈 개별 스위치 통합 절전형 멀티탭을 구매하였다. 해당 제품의 경우 16A 250V, 2800W의 전체 사용량을 가지므로 홈 네트워크 장비의 부하를 충분히 견딜 수 있었다.

정리 케이블 선정 : 2,900 x 1 = 2,900원

 네트워크 장비에 꽃히는 UTP 케이블과 각 장비의 전원선을 원활히 정리해주기 위해 케이블 타이를 알아보았다. 하지만, 네트워크 장비의 특성상 UTP 케이블은 언제든지 바꿔 꽃을 수 있음에 따라 벨크로 케이블 타이를 구매하였다.

네트워크 박스 구성 사진

결과

 기존 50도를 넘나들던 네트워크 장비들의 온도가 리빙 박스에 담아두고 쿨러만 설치해줬을 뿐인데 40도 선상에서 유지된다. 생각 이상으로 UTP 케이블이 많아져 관리하기 어려웠는데 미관에도 편의상에도 참 괜찮은 선택이었던 것 같다.

개요

 필자는 IT 기기가 늘어남에 따라 다양한 장비에서 균등한 인터넷 속도를 보장 받고 싶었으며 상호 간섭을 최소화 하고 싶었다. 이에 따라 다음과 같이 라우터 한개만 사용하던 네트워크 망을 세부적으로 나누어 관리를 해보고자 한다.

과거의 네트워크 구성

 필자의 과거 네트워크 구성도는 위의 그림과 같다. ipTIME A2004MU 유/무선 라우터를 기반으로 무선 WiFi를 통해 휴대폰, 아이패드, 맥북 등이 인터넷을 사용중이며, 유선 연결을 통해 ipTIME NAS가 1G 2회선을, 작업용 컴퓨터가 1G 1회선을, 웹 서버가 1G 1회선을 사용하고 있었다. 해당 구성은 통상적으로 가정에서 가장 많이 사용하는 네트워크 구성이지만, 유선 망과 무선 망을 동시에 사용함으로써 라우터의 부하도 늘어날 뿐만 아니라 유선과 무선을 동시에 사용할 때 네트워크 속도에 제약사항을 많이 느꼈다.

 이에 따라 유선 망과 무선망을 분리하는 라우터를 추가하고 스위치를 통해 적절히 각 장비의 회선을 분리해주기로 하였다.

현재의 네트워크 구성

 필자의 현재 네트워크 구성도는 위의 그림과 같다. 설명은 ISP HCN 1G Ethernet을 기반으로 하향식으로 설명을 이어가겠다.

라우터 분리

 기존 ISP HCN 1G Ethernet으로 부터의 이더넷의 모든 부하는 ipTIME A2004MU 1G 라우터가 감당하고 있었다. 하지만 ipTIME T5004 2G유선 라우터를 추가하여 유선과 무선의 망 분리를 진행하였다.

스위치 분리 및 웹 서버

 차후 글에서 설명을 이어갈 웹 서버의 경우 ipTIME H8005, ipTIME H8008의 스위치와 1G 4port NIC 세장을 통해 총 12G의 이더넷 대역폭을 보장해주었다. NIC 두장은 클라이언트의 원활한 접속을 위해 스위치를 통해 분리를 진행하였으며,  NIC 한장은 관리 사용자인 필자의 원활한 데이터 이동을 위해 ipTIME H8008 스위치를 통해 작업용 컴퓨터와 NAS등을 같은 망에 연결해주었다.

홈 네트워크 구성 결과

ISP

1G Ethernet

무선

iphone (13 mini) : 430Mbps 3ms

ipad (mini 6) : 490Mbps 4ms

macbook (m2) : 320Mbps 3ms

유선

웹 서버 : 783Mbps 1ms

작업용 컴퓨터 : 810Mbps 1ms

네트워크 스토리지 : 1G (측정 불가)

결과

무선의 경우 라우터 변경으로 속도가 상승할 여지가 있지만 평균 350Mbps 3ms의 속도가 보장되었으며, 유선의 경우 800Mbps 1ms의 속도가 보장되었다.

(네트워크 기본 지식을 다시 한번 복기할 수 있는 좋은 기회가 된 것 같다.)

소요 비용

1. ipTIME 유선 공유기 T5004, 1개 : 43,330원

2. ipTIME H8008-IGMP 스위치, 1개 : 24,480원

3. ipTIME H8005 스위치, 2개 : 26,800

4. 엠비에프 CAT.6 UTP 랜 케이블, 18개 : 21,420원

5. 코드웨이 CAT.8 UTP 랜 케이블, 1개 : 11,450원

총합 : 127,480원

날짜 비교하기

#include <stdio.h>

int solution(int d1[], size_t d1_l, int d2[], size_t d2_l) {
    return (d1[0] < d2[0]) || (d1[0] == d2[0]) && (d1[1] < d2[1]) || (d1[1] == d2[1]) && (d1[2] < d2[2] ? 1 : 0);
}

뒤에서 5등 위로

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

int* solution(int num[], size_t num_len) {
    int* res = (int*)malloc((num_len - 5) * sizeof(int));
    
    for(int i = 0; i < num_len; i++)
        for(int j = 0; j < num_len - i - 1; j++)
            if(num[j] > num[j + 1])
            {
                int temp = num[j];
                num[j] = num[j + 1];
                num[j + 1] = temp;
            }
    
    for(int i = 0; i < num_len - 5; i++)
        res[i] = num[i + 5];
    
    return res;
}

문자열 정수의 합

#include <stdio.h>

int solution(const char* num) {
    int res = 0;
    
    for(int idx = 0; num[idx]; idx++)
        res += num[idx] - 48;
    
    return res;
}

문자열이 몇 번 등장하는지 세기

#include <stdio.h>
#include <string.h>

int solution(const char* str, const char* pat) {
    int res = 0;
    
    for(int idx = 0; str[idx]; idx++)
    {
        int pdx = 0;
        if(str[idx] == pat[0])
            for(pdx; pat[pdx]; pdx++)
                if(str[idx + pdx] != pat[pdx])
                    break;
        if(pdx == strlen(pat))
            res++;
    }
    
    return res;
}

배열의 길이에 따라 다른 연산하기

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

#define OEC(l) ((l) % 2 == 0 ? 1 : 0)
#define ODD(i, n) ((i) % 2 != 0 ? n : 0)
#define EVE(i, n) ((i) % 2 == 0 ? n : 0)

int* solution(int arr[], size_t len, int n) {
    int* res = (int*)malloc(len * sizeof(int));
    
    for(int idx = 0; idx < len; idx++)
    {
        res[idx] = arr[idx];
        if(!OEC(len)) res[idx] = arr[idx] + EVE(idx, n);
        if(OEC(len)) res[idx] = arr[idx] + ODD(idx, n);
    }
    
    return res;
}

배열의 원소 삭제하기

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

int* solution(int a[], size_t a_len, int d[], size_t d_len) {
    int r_len = 0;
    
    for(int idx = 0; idx < a_len; idx++)
        for(int ddx = 0; ddx < d_len; ddx++)
            if(a[idx] == d[ddx])
            {
                a[idx] = 0;
                r_len++;
            }
    
    int* res = (int*)malloc((a_len - r_len) * sizeof(int));
    int rdx = 0;
    
    for(int idx = 0; idx < a_len; idx++)
        if(a[idx])
            res[rdx++] = a[idx];
    
    return res;
}

배열의 원소만큼 추가하기

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

int res_len(int arr[], int len)
{
    int res = 0;
    
    for(int idx = 0; idx < len; idx++)
        res += arr[idx];
    
    return res;
}

int* solution(int arr[], size_t arr_len) {
    int* res = (int*)malloc(res_len(arr, arr_len) * sizeof(int));
    int rpc = 0;
    
    for(int idx = 0; idx < arr_len; idx++)
        for(int rdx = 0; rdx < arr[idx]; rdx++)
            res[rpc++] = arr[idx];
    
    return res;
}

조건에 맞게 수열 변환하기 2

#include <stdio.h>

#define CAL(n) ((n) >= 50 ? ((n) % 2 == 0 ? (n / 2) : (n)) : ((n) % 2 ? (n * 2 + 1) : (n)))

int solution(int arr[], size_t arr_len) {
    int res = 0;
    
    while(1)
    {
        int bef = 0, aft = 0;
        for(int idx = 0; idx < arr_len; idx++)
        {
            bef += arr[idx];
            arr[idx] = CAL(arr[idx]);
            aft += arr[idx];
        }
        if ((bef - aft) == 0) break;
        res++;
    }
    
    return res;
}

조건에 맞게 수열 변환하기 3

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

int* solution(int arr[], size_t len, int k) {
    int* res = (int*)malloc(len * sizeof(int));
    
    for(int idx = 0; idx < len; idx++)
        res[idx] = (k % 2) ? (arr[idx] * k) : (arr[idx] + k);
    
    return res;
}

주사위 게임 1

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

#define POW(a, b) ((a) * (a) + (b) * (b))

int solution(int a, int b) {
    if(a % 2 && b % 2)
        return POW(a, b);
    if((a % 2 && b % 2 == 0) || (a % 2 == 0 && b % 2))
        return 2 * (a + b);
    return abs(a - b);
}

커피 심부름

#include <stdio.h>
#include <string.h>

#define AME(n) ((n) ? 4500 : 0)
#define CAF(n) ((n) ? 5000 : 0)

int solution(const char* order[], size_t order_len) {
    int res = 0;
    
    for(int idx = 0; idx < order_len; idx++)
        res += AME(strstr(order[idx], "ame")) + CAF(strstr(order[idx], "caf")) + AME(strstr(order[idx], "any"));
    
    return res;
}

콜라츠 수열 만들기

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

#define COL(n) ((n) % 2 ? 3 * n + 1 : n / 2) 

int* solution(int n) {
    int* res = (int*)malloc((n - 3) * sizeof(int));
    
    res[0] = n;
    for(int idx = 1; n != 1; idx++)
    {
        n = COL(n);
        res[idx] = n;
    }
    
    return res;
}

X 사이의 개수

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

int res_len(char* str)
{
    int res = 1;
    
    for(int idx = 0; idx < strlen(str); idx++)
        if(str[idx] == 'x')
            res++;
    
    return res;
}

int* solution(const char* str) {
    int* res = (int*)calloc(res_len(str), sizeof(int));
    int rdx = 0;
    
    for(int idx = 0; idx < strlen(str); idx++)
    {
        if(str[idx] != 'x') res[rdx]++;
        else rdx++;
    }

    return res;
}

https://github.com/JenSeop/Programmers-C/tree/main/Chap.09

0 떼기

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

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    int rdx = 0;
    int flg = 0;
    
    for(int idx = 0; idx < strlen(str); idx++)
    {
        if(str[idx] != 48)
            flg = 1;
        if(flg)
            res[rdx++] = str[idx];
    }
    res[rdx] = NULL;
    
    return res;
}

1로 만들기

#include <stdio.h>

#define CAL(n) ((n) % 2 == 0 ? (n) / 2 : ((n) - 1) / 2)

int solution(int num[], size_t len) {
    int res = 0;
    
    for(int idx = 0; idx < len; idx++)
        for(;num[idx];res++)
            num[idx] = CAL(num[idx]);
    
    return res - len;
}

간단한 식 계산하기

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

#define SIG(c) (((c) == '+' || (c) == '-' || (c) == '*') ? 1 : 0)
#define STP(c) ((c) == '+' ? 1 : (c) == '-' ? -1 : (c) == '*' ? 0 : 0)

int sig_find(char* str)
{
    for(int idx = 0; str[idx]; idx++)
        if(SIG(str[idx]))
            return idx;
    return 0;
}

int solution(const char* str) {
    int sig_spc = sig_find(str);
    int sig_flg = STP(str[sig_spc]);
    char* left[sig_spc];
    char* right[sig_spc];
    
    strncpy(left, str, sig_spc);
    left[sig_spc - 1] = NULL;
    strncpy(right, str + sig_spc + 2, strlen(str));
    right[sig_spc - 1] = NULL;
    
    if(sig_flg)
        return atoi(left) + atoi(right) * sig_flg;
    else
        return atoi(left) * atoi(right);
    return 0;
}

문자열 바꿔서 찾기

#include <stdio.h>
#include <string.h>

#define TRS(c) ((c) == 65 ? 66 : 65)

int solution(const char* str, const char* pat) {
    char *cpy = str;
    
    for(int idx = 0; cpy[idx]; idx++)
        cpy[idx] = TRS(cpy[idx]);
    
    return strstr(cpy, pat) ? 1 : 0;
}

문자열을 정수로 변환하기

#include <stdio.h>

int solution(const char* str) {
    int res = str[0] - 48;
    
    for(int idx = 1; idx < strlen(str); idx++)
        res = (res * 10) + str[idx] - 48;
    
    return res;
}

배열 만들기 1

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

int* solution(int n, int k) {
    int* res = (int*)malloc((n / k) * sizeof(int));
    
    for(int idx = 0; idx < (n / k); idx++)
        res[idx] = (idx + 1) * k;
    
    return res;
}

부분 문자열

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

int solution(const char* str1, const char* str2) {
    return (bool)strstr(str2, str1);
}

부분 문자열인지 확인하기

#include <stdio.h>
#include <string.h>

int solution(const char* str1, const char* str2) {
    return strstr(str1, str2) ? 1 : 0;
}

원하는 문자열 찾기

#include <stdio.h>

#define alp(c) ((c) < 91 ? (c + 32) : (c))

int solution(const char* str, const char* pat) {
    int flg = 0;
    
    for(int idx = 0; idx < strlen(str); idx++)
    {
        if(alp(str[idx]) == alp(pat[flg]))
            flg++;
        else
            flg = 0;
        if(flg == strlen(pat))
            return 1;
    }       
    return 0;
}

카운트 다운

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

int* solution(int start, int end) {
    int* res = (int*)malloc((start - end) * sizeof(int));
    int rdx = 0;
    
    for(start; start >= end; start--)
        res[rdx++] = start;
    
    return res;
}

특정한 문자를 대문자로 바꾸기

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

#define TRS(c, t) ((c) == (t) ? (c - 32) : (c))

char* solution(const char* str, const char* t) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    
    for(int idx = 0; idx < strlen(str); idx++)
        res[idx] = TRS(str[idx], t[0]);
    res[strlen(str)] = NULL;
    
    return res;
}

홀수 vs 짝수

#include <stdio.h>

#define EORO(n) ((n) % 2 == 0 ? 1 : 0)

int solution(int num[], size_t len) {
    int res = 0, eve = 0, odd = 0;
    
    for(int idx = 0; idx < len; idx++)
    {
        if(EORO(idx + 1)) eve += num[idx];
        else odd += num[idx];
    }
    
    return eve > odd ? eve : odd;
}

A 강조하기

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

#define TRS(c) ((c) == 97 ? -32 : (c) < 91 && (c) > 65 ? 32 : 0)

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    
    for(int idx = 0; idx < strlen(str); idx++)
        res[idx] = str[idx] + TRS(str[idx]);
    res[strlen(str)] = NULL;
    
    return res;
}

l로 만들기

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

#define TRS(c) ((c) < 108 ? 108 : (c))

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    
    for(int idx = 0; idx < strlen(str); idx++)
        res[idx] = TRS(str[idx]);
    res[strlen(str)] = NULL;
    
    return res;
}

n보다 커질 때까지 더하기

#include <stdio.h>

#define CHK(res, num) ((res) > (num) ? 0 : 1)

int solution(int num[], size_t num_len, int n) {
    int res = 0;
    
    for(int idx = 0; CHK(res, n); idx++)
        res += num[idx];
    
    return res;
}

rny_string

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

int m_counter(char* str)
{
    int cnt = 0;
    
    for(int idx = 0; idx < strlen(str); idx++)
        if(str[idx] == 'm')
            cnt++;
    
    return cnt;
}

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + m_counter(str) + 1) * sizeof(char));
    int spc = 0;
    
    for(int idx = 0; idx < strlen(str); idx++)
    {
        if(str[idx] == 'm')
        {
            res[idx + spc] = 'r';
            res[idx + spc + 1] = 'n';
            spc++;
        }
        else
            res[idx + spc] = str[idx];
    }
    res[strlen(str) + m_counter(str)] = NULL;
        
    return res;
}

https://github.com/JenSeop/Programmers-C/tree/main/Chap.08

가까운 1 찾기

#include <stdio.h>

int solution(int arr[], size_t len, int idx) {
    for (int i = 0; i < len; i++)
        if(arr[i] && i >= idx)
            return i;
    return -1;
}

길이에 따른 연산

#include <stdio.h>

int sum_all(int num[], int len)
{
    int res = 0;
    
    for(int idx = 0; idx < len; idx++)
        res += num[idx];
    
    return res;
}

int mul_all(int num[], int len)
{
    int res = 1;
    
    for(int idx = 0; idx < len; idx++)
        res *= num[idx];
    
    return res;
}

int solution(int num[], size_t len) {
    if(len > 10)
        return sum_all(num, len);
    return mul_all(num, len);
}

대문자로 바꾸기

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

#define TRS(c) ((c) > 96 && (c) < 123 ? -32 : 0)

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    
    for(int idx = 0; idx < strlen(str); idx++)
        res[idx] = str[idx] + TRS(str[idx]);
    res[strlen(str)] = '\0';
    
    return res;
}

문자 개수 세기

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

int* solution(const char* str) {
    int* res = (int*)calloc(52, sizeof(int));
    
    while(*str)
    {
        if(*str >= 'A' && *str <= 'Z')
            res[*str - 'A']++;
        else
            res[*str - 'A' - 6]++;
        str++;
    }
        
    return res;
}

문자열로 변환

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

char* solution(int n) {
    char* res = (char*)malloc(6 * sizeof(char));
    int rdx = 0;
    int lst[5] = {0, };
    int ldx = 0;
    
    while(n)
    {
        lst[ldx++] = n % 10;
        n /= 10;
    }
    
    for(int idx = ldx - 1; idx >= 0; idx--)
        res[rdx++] = lst[idx] + 48;
    res[ldx] = NULL;
    
    return res;
}

배열 비교하기

#include <stdio.h>

#define COMP(x, y) ((x) > (y) ? 1 : (x) < (y) ? -1 : (x) == (y) ? 0 : 0)

int sum(int arr[], int len)
{
    int res = 0;
    
    for(int idx = 0; idx < len; idx++)
        res += arr[idx];
    
    return res;
}

int solution(int arr1[], size_t arr1_len, int arr2[], size_t arr2_len) {
    if(arr1_len - arr2_len)
        return COMP(arr1_len, arr2_len);
    return COMP(sum(arr1, arr1_len), sum(arr2, arr2_len));
}

세로 읽기

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

char* solution(const char* str, int rows, int cols) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    int spc = 0;
    
    for(int idx = cols - 1; idx < strlen(str); idx += rows)
        res[spc++] = str[idx];
    res[spc] = NULL;
    
    return res;
}

소문자로 바꾸기

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

#define LOW(n) ((n) < 91 ? (n + 32) : (n))

char* solution(const char* str) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    
    for(int idx = 0; idx < strlen(str); idx++)
        res[idx] = LOW(str[idx]);
    res[strlen(str)] = NULL;
    
    return res;
}

수 조작하기 1

#include <stdio.h>

#define CONTROL(x) ((x == 'w') ? 1 : (x == 's') ? -1 : (x == 'd') ? 10 : (x == 'a') ? -10 : 0)

int solution(int n, const char* control) {
    for(int idx = 0; idx < strlen(control); idx++)
        n += CONTROL(control[idx]);
    return n;
}

수 조작하기 2

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

char* solution(int log[], size_t len) {
    char* res = (char*)malloc((len) * sizeof(char));
    int spc = 0;
    
    for (int idx = 1; idx < len; idx++)
    {
        int diff = log[idx] - log[idx - 1];
        switch(diff)
        {
            case -10: res[spc++] = 'a'; break;
            case -1: res[spc++] = 's'; break;
            case 1: res[spc++] = 'w'; break;
            case 10: res[spc++] = 'd'; break;
        }
    }
    res[spc] = NULL;
    
    return res;
}

정수 부분

#include <stdio.h>

int solution(double flo) {
    return (int)flo;
}

정수 찾기

#include <stdio.h>

int solution(int num[], size_t len, int n) {
    for(int idx = 0; idx < len; idx++)
        if(num[idx] == n)
            return 1;
    return 0;
}

첫 번째로 나오는 음수

#include <stdio.h>

int solution(int num[], size_t len) {
    for(int idx = 0; idx < len; idx++)
        if(num[idx] < 0)
            return idx;
    return -1;
}

n 번째 원소부터

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

int* solution(int num[], size_t len, int n) {
    int* res = (int*)malloc((len - (n - 1)) * sizeof(int));
    int spc = 0;
    
    for(int idx = n - 1; idx < len; idx++)
        res[spc++] = num[idx];
    
    return res;
}

n 번째 원소까지

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

int* solution(int num[], size_t len, int n) {
    int* res = (int*)malloc(n * sizeof(int));
    
    for(int idx = 0; idx < n; idx++)
        res[idx] = num[idx];
    
    return res;
}

qr code

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

#define QR(q, r, c) ((c) % (q) == (r))

char* solution(int q, int r, const char* code) {
    char* res = (char*)malloc((strlen(code) + 1) * sizeof(char));
    int rdx = 0;
    
    for(int idx = 0; idx < strlen(code); idx++)
        if(QR(q, r, idx))
            res[rdx++] = code[idx];
    res[rdx] = NULL;
    
    return res;
}

https://github.com/JenSeop/Programmers-C/tree/main/Chap.07

7의 개수

#include <stdio.h>

#define TARGET 7

int counter(int n)
{
    int cnt = 0;
    
    while(n)
    {
        if(n % 10 == 7)
            cnt++;
        n /= 10;
    }
    
    return cnt;
}

int solution(int arr[], size_t len) {
    int res = 0;
    int idx = -1;
    
    while(++idx < len)
        if(counter(arr[idx]))
            res += counter(arr[idx]);
            
    return res;
}

가까운 수

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

int solution(int arr[], size_t len, int n) {
    int res = arr[0];
    int min_diff = abs(arr[0] - n);
    
    for (int i = 1; i < len; i++)
    {
        int diff = abs(arr[i] - n);
        if(diff < min_diff || (diff == min_diff && arr[i] < res))
        {
            res = arr[i];
            min_diff = diff;
        }
    }
    
    return res;
}

간단한 논리 연산

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

#define CJT(x, y) ((x) || (y))
#define ITS(x, y) ((x) && (y))

bool solution(bool x1, bool x2, bool x3, bool x4) {
    return (ITS(CJT(x1, x2), CJT(x3, x4)));
}

구슬을 나누는 경우의 수

#include <stdio.h>

int solution(int balls, int share) {
    if (share == 0 || balls == share)
        return 1;
    else
        return solution(balls - 1, share - 1) + solution(balls - 1, share);
}

글자 이어 붙여 문자열 만들기

#include <stdio.h>

char* solution(const char* str, int idx_lst[], size_t idx_lst_len) {
    char* res = (char*)malloc((idx_lst_len + 1) * sizeof(char));
    
    for(int idx = 0; idx < idx_lst_len; idx++)
        res[idx] = str[idx_lst[idx]];
    res[idx_lst_len] = NULL;
    
    return res;
}

등차수열의 특정한 항만 더하기

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

int solution(int a, int d, bool inc[], size_t inc_len) {
    int res = 0;
    
    for(int idx = 0; idx < inc_len; idx++)
        if(inc[idx])
            res += (a + d * idx);
    
    return res;
}

마지막 두 원소

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

#define CHK(lst, bef) ((lst) > (bef) ? (lst - bef) : (lst * 2))

int* solution(int num[], size_t len) {
    int* res = (int*)malloc((len + 1) * sizeof(int));
    
    for(int idx = 0; idx < len; idx++)
        res[idx] = num[idx];
    res[len] = CHK(num[len - 1], num[len - 2]);
    
    return res;
}

모스 부호

#include <stdio.h>
#include <string.h>

char* cutter(const char* let, int st, int ed) {
    char* cut = (char*)malloc((ed + 1) * sizeof(char));
    
    strncpy(cut, let + st, ed);
    cut[ed] = NULL;
    
    return cut;
}

int find_ed(const char* let, int st)
{
    int idx = 1;
    
    let += st;
    while(let++)
    {
        if(*let == ' ')
            return idx;
        idx++;
    }
    
    return 0;
}

int match_morse(char* str)
{
    char* morse[] = {
        ".-","-...","-.-.","-..",".","..-.","--.","....","..",
        ".---","-.-",".-..","--","-.","---",".--.","--.-",".-.",
        "...","-","..-","...-",".--","-..-","-.--","--.."
        };
    
    for(int idx = 0; idx < 26; idx++)
        if(!strcmp(morse[idx], str))
            return idx + 97;
    
    return 0;
}

char* solution(const char* let) {
    char* res = (char*)malloc(strlen(let) * sizeof(char));
    int idx = -1;
    
    for(int st = 0; st < strlen(let); st += find_ed(let, st) + 1)
        res[++idx] = match_morse(cutter(let, st, find_ed(let, st)));
    res[++idx] = NULL;
    
    return res;
}

문자열 뒤집기

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

char* solution(const char* str, int s, int e) {
    char* res = (char*)malloc((strlen(str) + 1) * sizeof(char));
    int idx = s;
    
    strcpy(res, str);
    for(e; e >= s; e--)
        res[idx++] = str[e];
    res[strlen(str)] = NULL;
    
    return res;
}

문자열 뒤의 n글자

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

char* solution(const char* str, int n) {
    char* res = (char*)malloc((n + 1) * sizeof(char));
    int spc = 0;
    
    for(int idx = strlen(str) - n; idx < strlen(str); idx++)
        res[spc++] = str[idx];
    res[n] = '\0';
    
    return res;
}

문자열 앞의 n글자

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

char* solution(const char* str, int n) {
    char* res = (char*)malloc((n + 1) * sizeof(char));
    
    for(int idx = 0; idx < n; idx++)
        res[idx] = str[idx];
    res[n] = NULL;
    
    return res;
}

부분 문자열 이어 붙여 문자열 만들기

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

char* solution(const char* str[], size_t str_len, int** spc, size_t spc_row, size_t spc_col) {
    char* res = (char*)malloc((str_len * spc_row * spc_col + 1) * sizeof(char));
    int rdx = 0;
    
    for(int sdx = 0; sdx < str_len; sdx++)
        for(int pdx = spc[sdx][0]; pdx <= spc[sdx][1]; pdx++)
            res[rdx++] = str[sdx][pdx];
    res[rdx] = '\0';
    
    return res;
}

원소들의 곱과 합

#include <stdio.h>
#include <math.h>

int sum_pow_idx(int num[], int len)
{
    int res = 0;
    
    for(int idx = 0; idx < len; idx++)
        res += num[idx];
    
    return pow(res, 2);
}

int mul_all_idx(int num[], int len)
{
    int res = 1;
    
    for(int idx = 0; idx < len; idx++)
        res *= num[idx];
    
    return res;
}

int solution(int num[], size_t len) {
    if(mul_all_idx(num,len) < sum_pow_idx(num,len))
        return 1;
    return 0;
}

이어 붙인 수

#include <stdio.h>

#define EVE(n) ((n) % 2 == 0 ? n : 0)
#define ODD(n) ((n) % 2 != 0 ? n : 0)
#define MOV(n) ((n) ? 10 : 1)

int solution(int num[], size_t len) {
    int eve = 0, odd = 0;
    
    for(int idx = 0; idx < len; idx++)
    {
        eve = eve * MOV(EVE(num[idx])) + EVE(num[idx]);
        odd = odd * MOV(ODD(num[idx])) + ODD(num[idx]);
    }
    
    return eve + odd;
}

카운트 업

#include <stdio.h>

int* solution(int s_num, int e_num) {
    int* res = (int*)malloc((e_num - s_num + 1) * sizeof(int));
    int idx = 0;
    
    for (s_num; s_num <= e_num; s_num++)
        res[idx++] = s_num;
    
    return res;
}

https://github.com/JenSeop/Programmers-C/tree/main/Chap.06