New 병아리 개발자

*C언어 함수(심화)

// 문제 : 입력받은 숫자가 10이라고 할때 1부터 10 사이에 존재하는 모든 소수를 출력하는 함수 구현
#include <stdio.h>
#pragma warning (disable: 4996)

// 소수 판별함수
int is_prime_number(int number) {
  if ( number <= 1 ) {
    return 0;
  }

  for ( int i = 2; i < number; i++ ) {
    if ( number % i == 0 ) {
      // 리턴을 하면 함수가 그 즉시 종료
      return 0;
    }
  }

  return 1;
}

// 입력된 숫자 범위 내 숫자 확인 및 소수 판별함수에 전달하여 값 호출
void print_1_to_n_prime_numbers(int num) {
  for ( int i = 1; i <= num; i++ ) {
    if ( is_prime_number(i) ) {
      printf("%d\n", i);
    }
  }
}

int main(void) {
  print_1_to_n_prime_numbers(100);
  return 0;
}



// 문제 : 1부터 n 사이의 수 중에서 소수의 개수 반환하는 함수 `get_1_to_n_prime_numbers_count` 구현.
#include <stdio.h>
#pragma warning (disable: 4996)

// 소수 판별 함수
int is_prime_number(int number) {
  if ( number <= 1 ) {
    return 0;
  }

  for ( int i = 2; i < number; i++ ) {
    if ( number % i == 0 ) {
      // 리턴을 하면 함수가 그 즉시 종료
      return 0;
    }
  }

  return 1;
}

// 1부터 n 사이의 수 중에서 소수의 개수 반환하는 함수
int get_1_to_n_prime_numbers_count(int n) {
  int count = 0;

  for(int i = 1; i <= n; i++) {
    if(is_prime_number(i)) {
      count++;
    }
  }

  return count;
}

int main() {
  int count;
  int number;

  number = 1000;
  count = get_1_to_n_prime_numbers_count(number);
  printf("1부터 %d사이에 존재하는 소수의 개수 : %d개\n", number, count);
  // 출력 => 1부터 1000사이에 존재하는 소수의 개수 : 168개

  number = 2000;
  count = get_1_to_n_prime_numbers_count(number);
  printf("1부터 %d사이에 존재하는 소수의 개수 : %d개\n", number, count);
  // 출력 => 1부터 2000사이에 존재하는 소수의 개수 : 303개

  return 0;
}



// 문제 : 1부터 n 사이의 수 중에서 소수의 합을 반환하는 함수 `get_1_to_n_prime_numbers_sum` 구현
#include <stdio.h>
#pragma warning (disable: 4996)

// 소수 판별함수
int is_prime_number(int number) {
  if ( number <= 1 ) {
    return 0;
  }

  for ( int i = 2; i < number; i++ ) {
    if ( number % i == 0 ) {
      // 리턴을 하면 함수가 그 즉시 종료
      return 0;
    }
  }

  return 1;
}

// 1부터 n 사이의 수 중에서 소수의 개수 반환하는 함수
int get_1_to_n_prime_numbers_sum(int n) {
  // 구현
  int sum = 0;

  for ( int i = 0; i <= n; i++ ) {
    if(is_prime_number(i)) {
      sum += i;
    }
  }

  return sum;
}

int main() {
  int sum;
  int number;

  number = 1000;
  sum = get_1_to_n_prime_numbers_sum(number);
  printf("1부터 %d사이에 존재하는 소수의 개수 : %d개\n", number, sum);
  // 출력 => 1부터 1000사이에 존재하는 소수의 합 : 76127

  number = 2000;
  sum = get_1_to_n_prime_numbers_sum(number);
  printf("1부터 %d사이에 존재하는 소수의 개수 : %d개\n", number, sum);
  // 출력 => 1부터 2000사이에 존재하는 소수의 합 : 277050

  return 0;
}



// 문제 : 3가지 다른 방법으로 a부터 z까지 출력하는 함수 구현
// 힌트 : 사실 C언어에서 'a'는 따로 존재하지 않는다. 'a'는 사실 97의 또 다른 이름이다.
// 힌트 : C언어에서 'a'는 97과 완전히 같은 뜻이다.
// 힌트 : C언어에서 'b'는 98과 완전히 같은 뜻이다.
#include <stdio.h>
#pragma warning (disable: 4996)

void print_a_to_z_v1() {

  printf("abcdefghijklmnopqrstuvwxyz\n");

}

void print_a_to_z_v2() {
  
  for ( int i = 97; i < 97 + 26; i++ ) {
    printf("%c", i);
  }
  printf("\n");

}

void print_a_to_z_v3() {
  
  for ( int i = 'a'; i <= 'z'; i++ ) {
    printf("%c", i);
  }
  printf("\n");

}

int main(void) {
  printf("== 정답 v1 ==\n");
  print_a_to_z_v1();
  printf("== 정답 v2 ==\n");
  print_a_to_z_v2();
  printf("== 정답 v3 ==\n");
  print_a_to_z_v3();

  return 0;
}



// 문제 : n부터 m 사이에 존재하는 정수의 합을 반환하는 함수를 만들어주세요.
#include <stdio.h>
#pragma warning (disable: 4996)

int print_n_to_m_number_sum(int a, int b) {

  int sum = 0;

  for ( int i = a; i <= b; i++ ) {
    sum += i;
  }

  return sum;
}

int main(void) {
  printf("1부터 10사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,10));
  printf("1부터 50사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,50));
  printf("1부터 100사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,100));
  return 0;
}



// 문제 : n부터 m 사이에 존재하는 소수의 합을 반환하는 함수를 만들어주세요.
#include <stdio.h>
#pragma warning (disable: 4996)

int is_prime_number(int number) {

  if ( number <= 1 ) {
    return 0;
  }

  for ( int i = 2; i < number; i++ ) {
    if ( number % i == 0 ) {
      return 0;
    }
  }
  
  return 1;
}

int print_n_to_m_number_sum(int a, int b) {

  int sum = 0;

  for ( int i = a; i <= b; i++ ) {
    if(is_prime_number(i)) {
      sum += i;
    }
  }

  return sum;
}

int main(void) {
  printf("1부터 10사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,10));
  printf("1부터 50사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,50));
  printf("1부터 100사이에 존재하는 정수의 합 : %d\n", print_n_to_m_number_sum(1,100));
  return 0;
}



// 문제 : 별찍기(직사각형)
#include <stdio.h>
#pragma warning (disable: 4996)

void print_rect(int a, int b) {
  printf("== a = %d, b = %d ==\n", a, b);

  for ( int i = 1; i <= b; i++ ) {
    for ( int k = 1; k <= a; k++ ) {
      printf("*");
    }
    printf("\n");
  } 

}

int main(void) {
  print_rect(3, 5);
  // 출력
  /*
  ***
  ***
  ***
  ***
  ***
  */

  print_rect(5, 2);
  // 출력
  /*
  *****
  *****
  */

  print_rect(10, 3);
  // 출력
  /*
  **********
  **********
  **********
  */

  return 0;
}



// 문제 : 별찍기(삼각형)
#include <stdio.h>
#pragma warning (disable: 4996)

void print_tri(int num) {

  for( int i = 1; i <= num; i++ ) {
    for ( int k = 1; k <= i; k++ ) {
      printf("*");
    }
    printf("\n");
  }

}

int main(void) {
  print_tri(3);
  // 출력
  /*
  *
  **
  ***
  */

  print_tri(5);
  // 출력
  /*
  *
  **
  ***
  ****
  *****
  */

  print_tri(7);
  // 출력
  /*
  *
  **
  ***
  ****
  *****
  ******
  *******
  */

  return 0;
}



// 문제 : 별찍기(삼각형 - 심화)
#include <stdio.h>
#pragma warning (disable: 4996)

void print_tri(int num) {
  printf("num : %d 일때\n", num);
  for( int i = 1; i <= num; i++ ) {
    for( int k = num; k >= 1; k-- ) {
      if( k <= i ) {
        printf("*");
      } else {
        printf(" ");
      }
    }
    printf("\n");
  }
  

}

int main(void) {
  print_tri(3);
  // 출력
  /*
    *
   **
  ***
  */

  print_tri(5);
  // 출력
  /*
      *
     **
    ***
   ****
  *****
  */

  print_tri(7);
  // 출력
  /*
        *
       **
      ***
     ****
    *****
   ******
  *******
  */

  return 0;
}



// 문제 : 양의정수 제곱근을 반환하는 함수를 구현해주세요.
// 조건 : 양의 정수 제곱근이 없다면 -1을 리턴
#include <stdio.h>
#pragma warning (disable: 4996)

int get_sqrt(int num) {

  for ( int i = 1; i <= num; i++ ) {
    if( i * i == num ) {
      printf("%d", i);
      return i;
    }
  }

  return -1;
}

int main(void) {
  int rs;
  int num;

  num = 4;
  rs = get_sqrt(num);
  printf("%d의 제곱근은 %d 입니다.\n", num, rs);
  // 출력 => 4의 제곱곤은 2 입니다.

  num = 5;
  rs = get_sqrt(num);
  printf("%d의 제곱근은 %d 입니다.\n", num, rs);
  // 출력 => 5의 제곱곤은 -1 입니다.

  num = 6;
  rs = get_sqrt(num);
  printf("%d의 제곱근은 %d 입니다.\n", num, rs);
  // 출력 => 6의 제곱곤은 -1 입니다.

  num = 9;
  rs = get_sqrt(num);
  printf("%d의 제곱근은 %d 입니다.\n", num, rs);
  // 출력 => 9의 제곱곤은 3 입니다.

  return 0;
}

*C언어 함수관련

1. 함수 생성
#include <stdio.h>
#pragma warning (disable: 4996)

void sol() {

}

int main(void) {
  sol();

  return 0;
}



2. 함수 (매개변수)
#include <stdio.h>
#pragma warning (disable: 4996)

void sol1(int num) {
  
}
void sol2(float num) {

}

int main(void) {
  sol1(10);
  sol2(5.5);

  return 0;
}



3. 함수(복수개의 매개변수)
#include <stdio.h>
#pragma warning (disable: 4996)

void sol1(int num, char a, float num2) {

}

void sol2(float a, int b) {
  
}

int main(void) {
  sol1(10, 'k', 23.5);
  sol2(5.5, 11);

  return 0;
}



4. 함수(매개변수, 리턴)
#include <stdio.h>
#pragma warning (disable: 4996)

int sol1(int a, char b, double c) {
  return 0;
}

char sol2(double a, int b) {
  return 'a';
}

long sol3() {
  return 1;
}

double sol4() {
  return 5.5;
}

int main(void) {
  int i = sol1(10, 'k', 23.5);
  char c = sol2(5.5, 11);
  long l = sol3();
  double d = sol4();

  return 0;
}



// 문제 : 함수 응용(4칙연산 구현)
#include <stdio.h>
#pragma warning (disable: 4996)

int add(int a, int b) {
  return a + b;
}
int minus(int a, int b) {
  return a - b;
}
int multiply(int a, int b) {
  return a * b;
}
int divide(int a, int b) {
  return a / b;
}
double divide2(int a, int b) {
  return a / (double)b;
}
int mod(int a, int b) {
  return a % b;
}

int main(void) {
  int a = 0;

  a = add(10, 20);
  printf("두 수의 합 : %d\n", a);
  // 출력 => 두 수의 합 : 30

  a = minus(10, 20);
  printf("두 수의 차 : %d\n", a);
  // 출력 => 두 수의 합 : -10

  a = multiply(10, 20);
  printf("두 수의 곱 : %d\n", a);
  // 출력 => 두 수의 곱 : 200

  a = divide(40, 20);
  printf("두 수를 나눈 몫 : %d\n", a);
  // 출력 => 두 수를 나눈 몫 : 2

  double b = divide2(39, 5);
  printf("두 수를 나눈 몫 : %f\n", b);
  // 출력 => 두 수를 나눈 몫 : 7.800000

  a = mod(40, 3);
  printf("두 수를 나눈 나머지 : %d\n", a);
  // 출력 => 두 수를 나눈 나머지 : 1

  return 0;
}



// 문제 : 입력받은 정수가 짝수인지 아닌지 판별해주는 함수 구현

#include <stdio.h>

int is_even(int a) {
  
  if( a % 2 == 0) {
    return 1;
  } else {
    return 0;
  }
  
}

int main(void) {
  printf("10은(는) 짝수인가요? : %d\n", is_even(10));
  printf("11은(는) 짝수인가요? : %d\n", is_even(11));
  return 0;
}



// 문제 : 입력받은 정수가 3의 배수인지 알려주는 함수 구현
#include <stdio.h>
#pragma warning (disable: 4996)

int is_3_multiple(int a) {
  return a % 3 == 0;
}

int main(void) {
  printf("10은(는) 3의 배수인가요? : %d\n", is_3_multiple(10));
  printf("12은(는) 3의 배수인가요? : %d\n", is_3_multiple(12));

  return 0;
}



// 문제 : 입력받은 정수가 100보다 큰지 알려주는 함수 구현
#include <stdio.h>

int is_bigger_than_100(int a) {
  return a > 100;
}



// 문제 : 입력받은 정수가 100보다 크고 200보다 작은지 알려주는 함수 구현
#include <stdio.h>

int is_bigger_than_100_and_less_than_200(int a) {
  return a > 100 && a < 200;
}

int main(void) {
  printf("128은(는) 100보다 크고 200보다 작습니다. : %d\n", is_bigger_than_100_and_less_than_200(128));
  printf("28은(는) 100보다 크고 200보다 작습니다. : %d\n", is_bigger_than_100_and_less_than_200(28));
  return 0;
}

int main(void) {
  printf("128은(는) 100보다 큽니다. : %d\n", is_bigger_than_100(128));
  printf("28은(는) 100보다 큽니다. : %d\n", is_bigger_than_100(28));
  return 0;
}



// 문제 : 입력받은 정수의 모든 약수를 화면에 출력해주는 함수 구현
#include <stdio.h>

void print_divisors(int a) {
  for(int i = 1; i <= a; i++) {
    if(a % i == 0) {
      printf("%d\n", i);
    }
  }
}

int main(void) {
  
  print_divisors(1000);

  return 0;
}



// 문제 : 입력받은 정수의 모든 약수의 합을 리턴하는 함수 구현
#include <stdio.h>
int get_divisor_sum(int num) {
  int sum = 0;

  for ( int i = 1; i <= num; i++ ) {
    if ( num % i == 0 ) {
      sum += i;
    }
  }

  return sum;
}

int main(void) {
  int sum;

  sum = get_divisor_sum(1000);
  printf("1000의 모든 약수의 합 : %d\n", sum);

  sum = get_divisor_sum(100);
  printf("100의 모든 약수의 합 : %d\n", sum);

  return 0;
}



// 문제 : 입력받은 정수가 소수인지 알려주는 함수 구현
( 소수 : 1과 자기자신을 약수로 갖는 수 ,( 1은 소수가 아니다 ))
#include <stdio.h>
#pragma warning (disable: 4996)

int is_prime_number(int a) {

  if( a <= 1 ) {
    return 0;
  } 

  int count = 0;

  for ( int i = 2; i <= a; i++) {
    if ( a % i == 0 ) {
      count++;
    }
  }

  if(count == 1) {
    return 1;
  } else {
    return 0;
  }
}

int main(void) {
  printf("10이 소수인가요? : %d\n", is_prime_number(10)); //0 - 1 2 5 10
  printf("5 가 소수인지 체크 : %d\n", is_prime_number(5)); //1 - 1 5
  printf("6 이 소수인지 체크 : %d\n", is_prime_number(6)); //0 - 1 2 3 6
  printf("7 이 소수인지 체크 : %d\n", is_prime_number(7)); //1 - 1 7
  printf("8 이 소수인지 체크 : %d\n", is_prime_number(8)); //0 - 1 2 4 8
  printf("9 가 소수인지 체크 : %d\n", is_prime_number(9)); //0 - 1 2 3 3 9
  printf("10 이 소수인지 체크 : %d\n", is_prime_number(10)); //0 - 1 2 5 10
  return 0;
}



// 문제 : 입력받은 숫자가 10이라고 할때 1부터 10 사이에 존재하는 모든 소수를 출력하는 함수 구현
#include <stdio.h>
#pragma warning (disable: 4996)

int is_prime_number(int a) {

  if(a <= 1) {
    return 0;
  }

  for ( int i = 2; i < a; i++ ) {
    if ( a % i == 0 ) {
      return 0;
    }
  }
  return 1;
}

void print_1_to_n_prime_numbers(int a) {

  for (int i = 1; i <= a; i++) {
    if(is_prime_number(i)) {
      printf("%d\n", i);
    }
  } 
}


int main(void) {
  print_1_to_n_prime_numbers(10);
  return 0;
}

*C언어 이중반복문 (while)

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {

  int i = 1;


  while ( i <= 5 ) {

    int k = 1;

    printf("==== i값 : %d\n", i);

    while ( k <= 3) {

      printf("k값 : %d\n", k);

      k++;
    
    }

    i++;
  }

  return 0;
}

*이중 while문 / for문 이용한 구구단 출력

// 문제 : 이중 while문을 사용해서 구구단 2~8단 출력

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {
  
  int dan = 2;

  while ( dan <= 9 ) {
    
    int i = 1;

    printf("== %d단 ==\n", dan);

    while ( i <= 9 ) {

      printf("%d * %d = %d\n", dan, i, dan * i);

      i++;
    }
    
    dan++;
  } 

  return 0;
}



// 문제 : 이중 for문을 사용해서 구구단 2~8단 출력
#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {
  
  for ( int dan = 2; dan <= 9; dan++ ) {
    printf("== %d단 ==\n", dan);
    for ( int i = 1; i <= 9; i++ ) {
      printf("%d * %d = %d\n", dan, i, dan * i);
    }
  }

  return 0;
}

*1부터 100까지 / 40부터 255까지 합 출력

// 문제 : 1부터 100까지의 합을 출력해주세요.

#include <stdio.h>
#pragma warning (disable:4996)

int main(void) {
	
	int sum = 0;
	
	for ( int i = 0; i <= 100; i++) {
		sum += i;
	}
	
	printf("sum : %d", sum);

	return 0;
}



// 문제 : 40부터 255까지의 합을 출력해주세요.

#include <stdio.h>

#pragma warning (disable: 4996)


void sol1() {
  int sum = 0;
  for (int i = 40; i <= 255; i++) {
    sum += i;
  }
  printf("40~255 합계 sum : %d", sum);
}

int main(void) {

  sol1();
  
  return 0;
}

*1부터 100까지 / 1부터 200 까지 숫자 중 짝수의 합 출력

// 문제 : 1부터 100까지의 짝수의 합을 출력해주세요

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {

  int sum = 0;

  for ( int i = 1; i <= 100; i++ ) {
    // 짝수인지 체크
    if( i % 2 == 0) {
      sum+= i;
    }
  }

  printf("1~100까지의 수 중 짝수의 합 : %d", sum);

  return 0;
}



// 문제 : 1부터 200까지의 짝수의 합을 출력해주세요

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {

  int sum = 0;

  for ( int i = 1; i <= 200; i++ ) {
    // 짝수인지 체크
    if( i % 2 == 0) {
      sum+= i;
    }
  }

  printf("1~100까지의 수 중 짝수의 합 : %d", sum);

  return 0;
}

*음수 200부터 100사이의 짝수 중에서 3의 배수가 아닌 수의 합 출력

// 문제 : 음수 200부터 100사이의 짝수 중에서 3의 배수가 아닌 수의 합을 출력해주세요.

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {
  
  int sum = 0;

  for(int i = - 200; i <= 100; i++) {
    if( i % 2 == 0 && i % 3 != 0) {
      sum += i;
    }
  }

  printf("sum : %d", sum);


  return 0;
}

*1000의 약수 출력

// 문제 : 1000의 모든 약수 출력하기

#include <stdio.h>

#pragma warning (disable: 4996)

int main(void) {

  for (int i = 1; i <= 1000; i++) {
    if ( 1000 % i == 0) {
      printf("%d\n", i);
    }
  }

  return 0;
}