369게임

#include <stdio.h>

int solution(int order) {
    int res = 0;
    
    while(order)
    {
        int num = order % 10;
        if(num == 3 || num == 6 || num == 9)
            res++;
        order /= 10;
    }
    
    return res;
}

가위 바위 보

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

int analyzer(int n)
{
    if(n == '2')
        return '0';
    if(n == '0')
        return '5';
    
    return '2';
}

char* solution(const char* rsp) {
    int rsp_len = strlen(rsp);
    char* answer = (char*)malloc(rsp_len * sizeof(char));
    int i = -1;
    
    while(++i < rsp_len)
        answer[i] = analyzer(rsp[i]);
    answer[i] = '\0';
    
    return answer;
}

대문자와 소문자

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

char* solution(const char* my_string) {
    int string_len = strlen(my_string);
    int index = -1;
    
    char* answer = (char*)malloc((string_len + 1) * sizeof(char));
    if (answer == NULL)
        return NULL;
    
    while(++index < string_len)
    {
        if(my_string[index] >= 'A' && my_string[index] <= 'Z')
            answer[index] = my_string[index] + 32;
        else
            answer[index] = my_string[index] - 32;
    }
    answer[index + 1] = '\0';
        
    return answer;
}

문자열 정렬하기 (1)

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

int* solution(const char* my_string) {
    int str_len = strlen(my_string);
    int num_len = 0;
    int idx = -1;
    
    for(int i = 0; i < str_len; i++)
        if(my_string[i] >= '0' && my_string[i] <= '9')
            num_len++;
    
    int* answer = (int*)malloc(num_len * sizeof(int));
    if(answer == NULL)
        return NULL;
    
    for(int i = 0; i < str_len; i++)
        if(my_string[i] >= '0' && my_string[i] <= '9')
            answer[++idx] = my_string[i] - 48;
    
    for(int i = 0; i < num_len; i++)
        for(int j = 0; j < num_len; j++)
            if(answer[i] < answer[j])
            {
                char temp = answer[i];
                answer[i] = answer[j];
                answer[j] = temp;
            }
    
    return answer;
}

문자열 정렬하기 (2)

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

char* solution(const char* my_string) {
    int str_len = strlen(my_string);
    char* answer = (char*)malloc((str_len + 1) * sizeof(char));
    if(answer == NULL)
        return NULL;
    answer[str_len] = '\0';
    
    for(int i = 0; i < str_len; i++)
    {
        answer[i] = my_string[i];
        if(my_string[i] >= 'A' && my_string[i] <= 'Z')
            answer[i] = my_string[i] + 32;
    }
    
    for(int i = 0; i < str_len; i++)
        for(int j = 0; j < str_len; j++)
            if(answer[i] < answer[j])
            {
                char temp = answer[i];
                answer[i] = answer[j];
                answer[j] = temp;
            }
    
    return answer;
}

배열 회전시키기

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

int* solution(int numbers[], size_t numbers_len, const char* direction) {
    int* answer = (int*)malloc(numbers_len * sizeof(int));
    if(answer == NULL)
        return NULL;
    
    if(!strcmp(direction, "right"))
    {
        for(int i = 1; i < numbers_len; i++)
            answer[i] = numbers[i - 1];
        answer[0] = numbers[numbers_len - 1];
    }
    else
    {
        for(int i = 0; i < numbers_len - 1; i++)
            answer[i] = numbers[i + 1];
        answer[numbers_len - 1] = numbers[0];
    }
    
    return answer;
}

암호 해독

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

char* solution(const char* cipher, int code) {
    int cipher_len = strlen(cipher);
    int cipher_idx = code - 1;
    int index = -1;
    
    char* answer = (char*)malloc((cipher_len / code + 1) * sizeof(char));
    if (answer == NULL)
        return NULL;
    
    while(cipher_idx < cipher_len)
    {
        answer[++index] = cipher[cipher_idx];
        cipher_idx += code;
    }
    answer[index + 1] = '\0';
    
    return answer;
}

약수 구하기

#include <stdio.h>

int* solution(int n) {
    int cnt = 0;
    int idx = 0;
    
    for(int i = 1; i <= n; i++)
        if(n % i == 0)
            cnt++;
    
    int* answer = (int*)malloc(cnt * sizeof(int));
    if(answer == NULL)
        return NULL;
    
    for(int i = 1; i <= n; i++)
        if(n % i == 0)
            answer[idx++] = i;
    
    return answer;
}

외계행성의 나이

#include <stdio.h>

char* solution(int age) {
    int length = 0;
    int temp = age;
    int idx = -1;
    
    while(temp)
    {
        temp /= 10;
        length++;
    }
    
    char* answer = (char*)malloc((length + 1) * sizeof(char));
    if(answer == NULL)
        return NULL;
    
    while(++idx < length)
    {
        answer[idx] = age % 10 + 97;
        age /= 10;
    }
    answer[idx] = '\0';
    
    for (int i = 0; i < length / 2; i++)
    {
        int temp = answer[i];
        answer[i] = answer[length - i - 1];
        answer[length - i - 1] = temp;
    }
    
    return answer;
}

인덱스 바꾸기

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

char* solution(const char* my_string, int num1, int num2) {
    int str_len = strlen(my_string);
    
    char* answer = (char*)malloc((str_len + 1) * sizeof(char));
    if(answer == NULL)
        return NULL;
    
    strcpy(answer, my_string);
    char temp = answer[num1];
    answer[num1] = answer[num2];
    answer[num2] = temp;
    
    return answer;
}

중복된 문자 제거

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

int checker(char str[], char c)
{
    for(int idx = 0; idx < strlen(str); idx++)
        if(str[idx] == c)
            return 0;
    return 1;
}

char* solution(const char* my_string) {
    char* answer = (char*)malloc(strlen(my_string) * sizeof(char));
    int ans = -1;
    
    answer[++ans] = my_string[0];
    for(int idx = 1; idx < strlen(my_string) + 1; idx++)
    {
        if(checker(answer, my_string[idx]))
            answer[++ans] = my_string[idx];
        answer[ans + 1] = '\0';
    }
    answer[ans] = '\0';
    
    return answer;
}

직삼각형 출력하기

#include <stdio.h>

int main(void) {
    int n;
    scanf("%d", &n);
    
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<i+1; j++)
            printf("*");
        printf("\n");
    }
    
    return 0;
}

최댓값 만들기 (2)

#include <stdio.h>

int solution(int numbers[], size_t numbers_len) {
    int answer = numbers[0] * numbers[1];
    
    for (int i = 0; i < numbers_len; i++)
        for(int j = 0; j < numbers_len; j++)
            if(numbers[i] * numbers[j] > answer && i != j)
                answer = numbers[i] * numbers[j];
    
    return answer;
}

합성수 찾기

#include <stdio.h>

int composite(int n)
{
    int cnt = 0;
    
    for(int i = 1; i <= n; i++)
        if(n % i == 0)
            cnt++;
    
    return cnt;
}

int solution(int n) {
    int res = 0;
    int idx = 0;
    
    while(++idx <= n)
        if(composite(idx) > 2)
            res++;
    
    return res;
}

n의 배수 고르기

#include <stdio.h>

int counter(int n, int numlist[], int numlist_len)
{
    int index = -1;
    int count = 0;
    
    while(++index < numlist_len)
        if(!(numlist[index] % n))
            count++;
    
    return count;
}

int* solution(int n, int numlist[], size_t numlist_len) {
    int* answer = (int*)malloc(counter(n, numlist, numlist_len) * sizeof(int));
    int index = -1;
    int space = -1;
    
    while(++index < numlist_len)
        if(!(numlist[index] % n))
            answer[++space] = numlist[index];
    
    return answer;
}

https://github.com/JenSeop/Programmers-ICT/tree/main/Chap.04

모음 제거

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

int is_aeiou(char alpha)
{
    if(alpha == 'a' || alpha == 'e' || alpha == 'i' || alpha == 'o' || alpha == 'u')
        return 1;
    return 0;
}

char* solution(const char* my_string) {
    int length = strlen(my_string);
    char* answer = (char*)malloc(length * sizeof(char));
    int space = -1;
    int index = -1;
    
    while(++index < length + 1)
        if(!is_aeiou(my_string[index]))
            answer[++space] = my_string[index];
    answer[space] = '\0';
    
    return answer;
}

문자열 뒤집기

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

char* solution(const char* my_string) {
    int str_length = strlen(my_string);
    char* answer = (char*)malloc(str_length*sizeof(char));
    int index = -1;
    
    while(++index < str_length)
        answer[index] = my_string[str_length-index-1];
    answer[index] = '\0';
    
    return answer;
}

문자열안에 문자열

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

int solution(const char* str1, const char* str2) {
    if(strstr(str1, str2))
        return 1;
    
    return 2;
}

배열 뒤집기

#include <stdio.h>

int* solution(int num_list[], size_t num_list_len) {
    int* answer = (int*)malloc(num_list_len * sizeof(int));
    int length = num_list_len;
    
    while(num_list_len--)
        answer[length-num_list_len-1] = num_list[num_list_len];
    
    return answer;
}

배열 원소의 길이

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

int* solution(const char* strlist[], size_t strlist_len) {
    int* answer = (int*)malloc(strlist_len * sizeof(int));
    int index = -1;
    
    while(++index < strlist_len)
        answer[index] = strlen(strlist[index]);
    
    return answer;
}

배열 자르기

#include <stdio.h>

int* solution(int numbers[], size_t numbers_len, int num1, int num2) {
    int length = num2-num1+1;
    int* answer = (int*)malloc(length * sizeof(int));
    int index = -1;
    
    while(++index < length)
        answer[index] = numbers[index + num1];
    
    return answer;
}

삼각형의 완성조건 (1)

#include <stdio.h>

int solution(int sides[], size_t sides_len) {
    if(sides[0] + sides[1] > sides[2] &&
      sides[0] + sides[2] > sides[1] &&
      sides[1] + sides[2] > sides[0])
        return 1;
    return 2;
}

세균 증식

#include <stdio.h>

int solution(int n, int t) {
    while(t--)
        n = n * 2;
    
    return n;
}

아이스 아메리카노

#include <stdio.h>

int* solution(int money) {
    int* answer = (int*)malloc(2 * sizeof(int));
    
    answer[0] = money / 5500;
    answer[1] = money % 5500;
    
    return answer;
}

자릿수 더하기

#include <stdio.h>

int solution(int n) {
    int res = 0;
    
    while(n)
    {
        res += n % 10;
        n /= 10;
    }
    
    return res;
}

점의 위치 구하기

#include <stdio.h>

int solution(int dot[], size_t dot_len) {
    if(dot[1] > 0)
    {
        if(dot[0] > 0)
            return 1;
        return 2;
    }
    else
        if(dot[0] > 0)
            return 4;
    return 3;
}

짝수 홀수 개수

#include <stdio.h>

int solution(int dot[], size_t dot_len) {
    if(dot[1] > 0)
    {
        if(dot[0] > 0)
            return 1;
        return 2;
    }
    else
        if(dot[0] > 0)
            return 4;
    return 3;
}

최댓값 만들기 (1)

#include <stdio.h>

int solution(int numbers[], size_t numbers_len) {
    int max = 0;
    
    for(int i=0; i<numbers_len; i++)
        for(int j=0; j<i+1; j++)
            if(i!=j)
                if(numbers[i]*numbers[j] > max)
                    max = numbers[i]*numbers[j];
    
    return max;
}

특정 문자 제거하기

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

char* solution(const char* my_string, const char* letter) {
    int length = strlen(my_string);
    char* answer = (char*)malloc((length-1) * sizeof(char));
    int i = -1;
    int j = -1;
    
    while(++i < length)
        if(my_string[i] != *letter)
            answer[++j] = my_string[i];
    answer[j + 1] = '\0';
    
    return answer;
}

https://github.com/JenSeop/Programmers-ICT/tree/main/Chap.03

가장 큰 수 찾기

#include <stdio.h>

int* solution(int arr[], size_t arr_len) {
    int* res = (int*)malloc(2 * sizeof(int));
    int arr_i = -1;
    res[0] = 0;
    
    while(++arr_i < arr_len)
        if(arr[arr_i] > res[0])
        {
            res[0] = arr[arr_i];
            res[1] = arr_i;
        }
    
    return res;
}

문자 반복 출력하기

#include <stdio.h>

int* solution(int arr[], size_t arr_len) {
    int* res = (int*)malloc(2 * sizeof(int));
    int arr_i = -1;
    res[0] = 0;
    
    while(++arr_i < arr_len)
        if(arr[arr_i] > res[0])
        {
            res[0] = arr[arr_i];
            res[1] = arr_i;
        }
    
    return res;
}

배열 두배 만들기

#include <stdio.h>

int* solution(int numbers[], size_t numbers_len) {
    int* res = (int*)malloc(numbers_len * sizeof(int));
    int i = -1;
    
    while(++i < numbers_len)
        res[i]=numbers[i]*2;
    
    return res;
}

배열의 유사도

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

int solution(const char* s1[], size_t s1_len, const char* s2[], size_t s2_len) {
    int s1_i = -1;
    int s2_i = -1;
    int cnt = 0;
    
    while(++s1_i < s1_len)
    {
        s2_i = -1;
        while(++s2_i < s2_len)
            if(!strcmp(s1[s1_i], s2[s2_i]))
            {
                cnt++;
                break;
            }
    }
    
    return cnt;
}

분수의 덧셈

#include <stdio.h>

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int* solution(int numer1, int denom1, int numer2, int denom2) {
    int *res = (int*)malloc(2 * sizeof(int));
    int mom = denom1 * denom2;
    int son = numer1 * (mom/denom1) + numer2 * (mom/denom2);
    int div = gcd(son, mom);
    
    res[0] = son/div;
    res[1] = mom/div;
            
    return res;
}

숫자 찾기

#include <stdio.h>

int solution(int num, int k) {
    int arr[7] = {-1};
    int org = num;
    int len = 1;
    int i = -1;
    
    while(num/=10)
        len++;
    
    while(++i < len)
    {
        arr[i] = org % 10;
        org /= 10;
    }
    
    i = len;
    while(--i > -1)
        if(arr[i] == k)
            return len - i;
    
    return -1;
}

옷가게 할인 받기

#include <stdio.h>

int solution(int price) {
    if(price >= 100000)
    {
        if(price >= 500000)
            return price * 0.8;
        if(price >= 300000)
            return price * 0.9;
        
        return price * 0.95;    
    }
    
    return price;
}

주사위의 개수

#include <stdio.h>

int solution(int box[], size_t box_len, int n) {
    return (box[0]/n) * (box[1]/n) * (box[2]/n);
}

짝수는 싫어요

#include <stdio.h>

int* solution(int n) {
    int len = (n+1)/2;
    int *res = (int*)malloc(len * sizeof(int));
    int i = -1;
    int j = 1;
    
    while(++i < len)
    {
        res[i] = j;
        j += 2;
    }
    
    
    return res;
}

최빈값 구하기

#include <stdio.h>

int solution(int array[], size_t array_len) {
    int cnt[1000] = {0};
    int max = 0;
    int res = -1;

    for (size_t i = 0; i < array_len; i++) {
        cnt[array[i]]++;
    }

    for (int i = 0; i < 1000; i++) {
        if (cnt[i] > max) {
            max = cnt[i];
            res = i;
        } else if (cnt[i] == max && max != 0) {
            res = -1;
        }
    }

    return res;
}

치킨 쿠폰

#include <stdio.h>

int solution(int chicken) {
    int res = 0;
    
    while(chicken/10)
    {
        res += chicken/10;
        chicken = chicken/10 + chicken%10;
    }
    
    return res;
}

피자 나눠 먹기 (1)

#include <stdio.h>

int solution(int n) {
    return (n+6)/7;
}

피자 나눠 먹기 (2)

#include <stdio.h>

int solution(int n) {
    int pizza = 0;
    
    while(++pizza)
        if((6*pizza)%n==0)
            return pizza;
}

피자 나눠 먹기 (3)

#include <stdio.h>

int solution(int slice, int n) {
    return (n+slice-1)/slice;
}

https://github.com/JenSeop/Programmers-ICT/tree/main/Chap.02

두수의 합

#include <stdio.h>

#define MIN -50000
#define MAX 50000

int solution(int num1, int num2) {
    if ((num1>=MIN && num1<=MAX)&&(num2>=MIN && num2<=MAX))
        return num1+num2;
}

두수의 차

#include <stdio.h>

int solution(int num1, int num2) {
    if ((num1>=0 && num1<=50000)&&(num2>=0 && num2<=50000))
      return num1 - num2;
}

두수의 곱

#include <stdio.h>

int solution(int num1, int num2) {
    if ((num1>=0 && num1<=100)&&(num2>=0 && num2<=100))
        return num1*num2;
    else
        return -1;
}

두수의 나눗셈

#include <stdio.h>

#define MIN 0
#define MAX 100

int solution(int num1, int num2) {
    int res = 1000 * (float)num1/num2;
    return res;
}

몫 구하기

#include <stdio.h>

int solution(int num1, int num2) {
    if ((num1>0 && num1<=100)&&(num2>0 && num2<=100))
        return num1/num2;
    else
        return -1;
}

각도기

#include <stdio.h>

int solution(int angle) {
    int calc = 180-angle;
    
    if (calc > 0)
    {
        if (calc < 90)
            return 3;
        else if (calc == 90)
            return 2;
        else
            return 1;
    }
    return 4;
}

개미 군단

#include <stdio.h>

int solution(int hp) {
    int ant1 = hp / 5;
    int ant2 = (hp - ant1 * 5) / 3;
    int ant3 = hp - ant1 * 5 - ant2 * 3;
    
    return ant1 + ant2 + ant3;
}

나이 출력

#include <stdio.h>

int solution(int age) {
    if(age>0 && age<=120)
        return 2023-age;
}

머쓱이보다 키큰사람

#include <stdio.h>

int solution(int array[], size_t array_len, int height) {
    int i=-1;
    int res=0;
    
    while(++i<=array_len-1)
        if(array[i]>height)
            res++;
    
    return res;
}

배열의 평균값

#include <stdio.h>

double solution(int numbers[], size_t numbers_len) {
    int i=-1;
    int res=0;
    
    while(++i <= numbers_len - 1)
        res+=numbers[i];
    
    return (double)res/i;
}

순서쌍의 개수

#include <stdio.h>

int solution(int n) {
    int i=0;
    int res=0;
    
    // 순서쌍 = 약수
    while(i++<=n)
        if(!(n%i))
            res++;
    
    return res;
}

숨어있는 숫자의 덧셈(1)

#include <stdio.h>

int solution(const char* my_string) {
    int i=-1;
    int res=0;
    
    while(my_string[++i])
        if(my_string[i] >= 48 && my_string[i] <= 57)
            res+=my_string[i]-48;
    
    return res;
}

숫자 비교하기

#include <stdio.h>

int solution(int num1, int num2) {
    if ((num1>=0 && num1<=10000)&&(num2>=0 && num2<=10000))
        if(num1 == num2)
            return 1;
    return -1;
}

양꼬치

#include <stdio.h>

int solution(int n, int k) {
    int bill = n * 12000 + k * 2000;
    
    if(n/10>=1)
        return bill - (int)(n/10)*2000;
    
    return bill;
}

제곱수 판별하기

#include <stdio.h>

int solution(int n) {
    int i = -1;
    
    while(++i <= n/2)
        if(i*i == n)
            return 1;
    
    return 2;
}

중복된 숫자개수

#include <stdio.h>

int solution(int array[], size_t array_len, int n) {
    int i=-1;
    int res=0;
    
    while(++i<array_len)
        if(array[i]==n)
            res++;
    
    return res;
}

중앙값 구하기

#include <stdio.h>

int solution(int array[], size_t array_len) {
    int i=-1;
    int j=-1;
    int swap=0;
    
    while(++i<array_len)
    {
        while(++j<array_len-1-i)
            if(array[j]>array[j+1])
            {
                swap = array[j];
                array[j] = array[j+1];
                array[j+1] = swap;
            }
        j=-1;
    }
    
    return array[array_len/2];
}

짝수의 합

#include <stdio.h>

int solution(int n) {
    int i=0;
    int res=0;
    
    while(++i <= n)
        if(!(i%2))
            res = res + i;
    return res;
}

편지

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

int solution(const char* message) {
    return strlen(message)*2;
}

https://github.com/JenSeop/Programmers-ICT/tree/main/Chap.01