마인드 맵 갤러리 C 언어 질문 16-20
이것은 C 언어의 16-20 질문에 대한 마인드 맵이며, 주요 내용에는 다음이 포함됩니다. , 18. C 언어 예제 - 판사 도약, 17. C 언어 예제 - 단제 2 차 방정식, 16. C 언어 예제 - 세 숫자 중 가장 큰 숫자를 판단합니다.
2025-02-13 20:37:16에 편집됨이것은 곤충학에 대한 마인드 맵으로, 곤충의 생태와 형태, 생식 및 발달, 곤충과 인간의 관계를 연구하는 과학입니다. 그것의 연구 대상은 곤충으로, 가장 다양하고 가장 많은 수의 동물이며 생물학적 세계에서 가장 널리 분포되어 있습니다.
이것은 어린이의 내부 동기를 육성하는 방법에 대한 마인드 맵입니다. 기업가를위한 실용적인 가이드, 주요 내용 : 요약, 7. 정서적 연결에주의를 기울이고, 과도한 스트레스를 피하십시오.
이것은 자동화 프로젝트 관리 템플릿, 주요 내용에 대한 마인드 맵입니다. 메모, 시나리오 예제, 템플릿 사용 지침, 프로젝트 설정 검토 단계 (What-Why-How), 디자인 검토 단계 (What-Why-How), 수요 분석 단계 (What-Why-How)에 대한 마인드 맵입니다.
이것은 곤충학에 대한 마인드 맵으로, 곤충의 생태와 형태, 생식 및 발달, 곤충과 인간의 관계를 연구하는 과학입니다. 그것의 연구 대상은 곤충으로, 가장 다양하고 가장 많은 수의 동물이며 생물학적 세계에서 가장 널리 분포되어 있습니다.
이것은 어린이의 내부 동기를 육성하는 방법에 대한 마인드 맵입니다. 기업가를위한 실용적인 가이드, 주요 내용 : 요약, 7. 정서적 연결에주의를 기울이고, 과도한 스트레스를 피하십시오.
이것은 자동화 프로젝트 관리 템플릿, 주요 내용에 대한 마인드 맵입니다. 메모, 시나리오 예제, 템플릿 사용 지침, 프로젝트 설정 검토 단계 (What-Why-How), 디자인 검토 단계 (What-Why-How), 수요 분석 단계 (What-Why-How)에 대한 마인드 맵입니다.
I —16-20
16. C 언어 예제 - 세 숫자 중 최대 숫자 결정
방법 1 : if -else 문을 사용하십시오. 이것은 조건부 문을 사용하여 세 숫자를 비교하는 가장 일반적이고 직접적인 방법입니다.
#include <stdio.h>
int main () {
int num1, num2, num3, max;
printf ( "세 개의 정수를 입력하십시오 :");
scanf ( " %d %d %d", & num1, & num2);
if (num1> = num2 && num1> = num3) {
max = num1;
}
else if (num2> = num1 && num2> = num3) {
max = num2;
}
또 다른 {
max = num3;
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 2 : 중첩 IF 문을 사용 하여이 방법은 중첩 된 IF 문을 통해 두 숫자를 점차 비교합니다.
#include <stdio.h>
int main () {
int num1, num2, num3, max;
printf ( "세 개의 정수를 입력하십시오 :");
scanf ( " %d %d %d", & num1, & num2);
if (num1> = num2) {
if (num1> = num3) {
max = num1;
}
또 다른 {
max = num3;
}
}
또 다른 {
if (num2> = num3) {
max = num2;
}
또 다른 {
max = num3;
}
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 3 : 함수를 사용하여 최대 숫자를 함수로 결정하는 논리를 캡슐화하여 코드를 더 명확하고 재사용 할 수 있도록합니다.
#include <stdio.h>
int findmax (int a, int b, int c) {
int max = a;
if (b> max) max = b;
if (c> max) max = c;
리턴 맥스;
}
int main () {
int num1, num2, num3;
printf ( "세 개의 정수를 입력하십시오 :");
scanf ( " %d %d %d", & num1, & num2);
int max = findmax (num1, num2, num3);
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 4 : 포인터와 배열이 메소드를 사용 하여이 메소드는 배열 및 포인터를 통해 코드를 단순화합니다.
#include <stdio.h>
int main () {
int num [3], max;
printf ( "세 개의 정수를 입력하십시오 :");
for (int i = 0; i <3; i) {
scanf ( "%d", & num [i]);
}
max = num [0];
for (int i = 1; i <3; i) {
if (num [i]> max) {
max = num [i];
}
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 5 : 3 점 연산자 사용 3 점 연산자는 간단한 조건부 판단을 처리하는 간결한 방법입니다.
#include <stdio.h>
int main () {
int num1, num2, num3, max;
printf ( "세 개의 정수를 입력하십시오 :");
scanf ( " %d %d %d", & num1, & num2);
max = (num1> = num2)?
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 6 : 표준 라이브러리 기능 FMAX를 사용하여 C 표준 라이브러리의 FMAX 기능을 사용하여 코드를 단순화하지만 FMAX 기능은 부동 소수점 번호에 적합합니다.
#include <stdio.h>
#include <math.h>
int main () {
이중 NUM1, NUM2, NUM3, MAX;
printf ( "세 숫자를 입력하십시오 :");
scanf ( " %lf %lf %lf", & num1, & num3);
max = fmax (num1, fmax (num2, num3));
printf ( "최대 숫자는 : %.2f \ n", max);
반환 0;
}
주기
방법 1 : for 루프 사용 입력을 읽고 for 루프를 통해 세 가지 숫자를 비교하는 가장 일반적이고 직접적인 방법입니다. */
#include <stdio.h>
int main () {
int num [3], max;
int i;
printf ( "세 개의 정수를 입력하십시오 :");
for (i = 0; i <3; i) {
scanf ( "%d", & num [i]);
}
// 첫 번째 숫자가 가장 큰 숫자라고 가정합니다.
max = num [0];
// 루프를 사용하여 다른 숫자를 비교하십시오
for (i = 1; i <3; i) {
if (num [i]> max) {
max = num [i];
}
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 2 : while 루프를 사용하여 입력을 읽고 while 루프를 통해 세 숫자를 비교하십시오.
#include <stdio.h>
int main () {
int num [3], max;
int i = 0;
printf ( "세 개의 정수를 입력하십시오 :");
while (i <3) {
scanf ( "%d", & num [i]);
나 ;
}
// 첫 번째 숫자가 가장 큰 숫자라고 가정합니다.
max = num [0];
// 루프를 사용하여 다른 숫자를 비교하십시오
i = 1;
while (i <3) {
if (num [i]> max) {
max = num [i];
}
나 ;
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 3 : do- while 루프를 사용하여 입력을 읽고 DO를 통해 3 개의 숫자를 비교합니다 - 루프.
#include <stdio.h>
int main () {
int num [3], max;
int i = 0;
printf ( "세 개의 정수를 입력하십시오 :");
하다 {
scanf ( "%d", & num [i]);
나 ;
} while (i <3);
// 첫 번째 숫자가 가장 큰 숫자라고 가정합니다.
max = num [0];
// 루프를 사용하여 다른 숫자를 비교하십시오
i = 1;
하다 {
if (num [i]> max) {
max = num [i];
}
나 ;
} while (i <3);
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
방법 4 : 중첩 루프 사용 (보다 복잡한 시나리오의 경우)이 간단한 예에서는 중첩 루프가 필요하지 않지만 완전성을 위해 중첩 된 루프의 예입니다. 중첩 루프는 종종 다차원 배열 처리와 같은보다 복잡한 시나리오를 처리하는 데 사용됩니다.
#include <stdio.h>
int main () {
int num [3], max;
int i, j;
printf ( "세 개의 정수를 입력하십시오 :");
for (i = 0; i <3; i) {
scanf ( "%d", & num [i]);
}
// 첫 번째 숫자가 가장 큰 숫자라고 가정합니다.
max = num [0];
// 중첩 루프를 사용한 다른 숫자 비교 (중첩 루프는이 간단한 예에서는 의미가 없습니다)
for (i = 1; i <3; i) {
for (j = i; j <3; j) {
if (num [j]> max) {
max = num [j];
}
}
}
printf ( "최대 숫자는 : %d \ n", max);
반환 0;
}
17. C 언어 예제 - 단일의 2 차 방정식
C 언어 방법 1에서 2 차 방정식을 해결하는 몇 가지 일반적인 방법 : 기본 방법 (실제 및 복잡한 뿌리 포함)
#include <stdio.h>
#include <math.h>
int main () {
Double A, B, C, 판별, Root1, Root2, RealPart, ImaginePart;
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
반환 0;
}
방법 2 : 기능 캡슐화 사용 기능에서 솔루션 루트의 논리를 캡슐화하여 코드를보다 모듈화하고 유지 관리하기 쉽게 만듭니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
이중 A, B, C;
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
반환 0;
}
방법 3 : 구조를 사용하여 결과를 저장하여 루트 결과를 저장하여 결과를보다 편리하게 만듭니다.
#include <stdio.h>
#include <math.h>
typedef struct {
더블 리얼 파트;
이중 ImagePart;
} complexRoot;
ComplexRoot SolveQuadratic (Double A, Double B, Double C) {
복잡한 루트;
이중 판별제;
판별제 = B * B -4 * A * C;
if (판별> 0) {
roots.realpart = (-B Sqrt (판별)) / (2 * a);
roots.imagpart = 0;
}
else if (판별 == 0) {
roots.realpart = -b / (2 * a);
roots.imagpart = 0;
}
또 다른 {
roots.realpart = -b / (2 * a);
roots.imagpart = sqrt (-discriminant) / (2 * a);
}
귀환 뿌리;
}
int main () {
이중 A, B, C;
복잡한 루트;
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
root = solvequadratic (a, b, c);
if (roots.imagpart == 0) {
if (roots.realpart == roots.imagpart) {
printf ( "방정식은 실제 루트를 가지고 있습니다 : %.2lf \ n", roots.realpart);
}
또 다른 {
printf ( "방정식에는 두 가지 불평등 한 실제 뿌리가 있습니다.
}
}
또 다른 {
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다 : %.2lf %.2lfi 및 %.2lf- %.2lfi \ n", roots.realpart, roots.imagpart, realpart, roots.realpart, roots.imagpart);
}
}
반환 0;
}
그러나 위의 코드는 구조를 다룰 때, 특히 실제 뿌리의 처리 부분에 대해 몇 가지 문제가 있습니다. 수정 된 버전은 다음과 같습니다.
#include <stdio.h>
#include <math.h>
typedef struct {
더블 리얼 파트;
이중 ImagePart;
} complexRoot;
ComplexRoot SolveQuadratic (Double A, Double B, Double C) {
복잡한 루트;
이중 판별 = B * B -4 * A * C;
if (판별> 0) {
roots.realpart = (-B Sqrt (판별)) / (2 * a);
roots.imagpart = 0;
복잡한 루트 루트 2;
root2.RealPart = (-B -SQRT (판별)) / (2 * a);
root2.imagpart = 0;
printf ( "방정식에는 두 가지 불평등 한 실제 뿌리가 있습니다.
}
else if (판별 == 0) {
roots.realpart = -b / (2 * a);
roots.imagpart = 0;
printf ( "방정식은 실제 루트를 가지고 있습니다 : %.2lf \ n", roots.realpart);
}
또 다른 {
roots.realpart = -b / (2 * a);
roots.imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다 : %.2lf %.2lfi 및 %.2lf- %.2lfi \ n", roots.realpart, roots.imagpart, realpart, roots.realpart, roots.imagpart);
}
귀환 뿌리;
}
int main () {
이중 A, B, C;
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
반환 0;
}
방법 4 : 포인터를 사용하여 결과를 전달하십시오. 포인터를 사용하여 루트 결과를 호출 함수로 전달하십시오.
#include <stdio.h>
#include <math.h>
void solvequadratic (이중 A, 이중 B, 이중 C, Double* Real1, Double* Imag1, Double* Real2, Double* Imag2) {
이중 판별 = B * B -4 * A * C;
if (판별> 0) {
* real1 = (-b sqrt (판별)) / (2 * a);
*imag1 = 0;
* real2 = (-b -sqrt (판별)) / (2 * a);
*imag2 = 0;
}
else if (판별 == 0) {
*real1 = *real2 = -b / (2 *a);
*imag1 = *imag2 = 0;
}
또 다른 {
*real1 = *real2 = -b / (2 *a);
* imag1 = sqrt (-discriminant) / (2 * a);
* imag2 = -sqrt (-discriminant) / (2 * a);
}
}
int main () {
Double A, B, C, Real1, Real1, Real2, Imagine2;
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c, & real1, & imag1, & real2, & imag2);
if (imag1 == 0 && imag2 == 0) {
if (real1 == real2) {
printf ( "방정식은 실제 루트를 갖습니다 : %.2lf \ n", real1);
}
또 다른 {
printf ( "방정식에는 두 가지 불평등 한 실제 뿌리가 있습니다 : %.2lf 및 %.2lf \ n", real1, real2);
}
}
또 다른 {
printf ( "방정식은 2 개의 컨쥬 게이트 된 복잡한 루트를 갖는다 : %.2lf %.2lfi 및 %.2lf- %.2lfi \ n", real1, imag1, real2, imag2);
}
}
반환 0;
}
주기
방법 1 : 사용 - 루프 사용 DO- 루프가 루프 본체를 적어도 한 번 실행 한 다음 조건에 따라 루프를 계속할 것인지 결정합니다. 이 접근법은 사용자가 하나 이상의 방정식 계수를 입력 해야하는 시나리오에 적합합니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
이중 A, B, C;
숯 선택;
하다 {
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
printf ( "당신은 방정식을 계속 해결합니까? (y/n) : \ n");
scanf ( " %c", & 선택);
} while (choice == 'y'|| 선택 == 'y');
반환 0;
}
방법 2 : while 루프를 사용하여 각 실행 전에 조건이 만족되는지 확인하십시오. 이 방법은 조건에 따라 루프를 계속할지 동적으로 결정 해야하는 시나리오에 적합합니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
이중 A, B, C;
숯 선택;
printf ( "방정식을 해결하기 시작합니까? (y/n) : \ n");
scanf ( " %c", & 선택);
while (선택 == 'y'|| 선택 == 'y') {
printf ( "단지 2 차 방정식의 계수 a, b, c : \ n"을 입력하십시오);
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
printf ( "당신은 방정식을 계속 해결합니까? (y/n) : \ n");
scanf ( " %c", & 선택);
}
반환 0;
}
방법 3 : 루프 수가 이미 알려진 시나리오의 루프 루프 사용. 이 방법은 사용자가 해결해야 할 방정식 수를 미리 알고있는 상황에 적합합니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
int n, i;
이중 A, B, C;
printf ( "해결할 단일 2 차 방정식의 수를 입력하십시오 : \ n");
scanf ( "%d", & n);
for (i = 0; i <n; i) {
printf ( "계수 a, b, c : \ n을 입력하십시오."
scanf ( " %lf %lf %lf", & a, & b, & c);
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
}
반환 0;
}
방법 4 : 파일의 계수를 읽고 파일에서 내용을 처리 할 수 있습니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
파일* 파일;
이중 A, B, C;
file = fopen ( "Depations.txt", "r");
if (file == null) {
printf ( "파일을 열 수 없습니다. \ n");
반환 1;
}
하다 {
if (fscanf (파일, " %lf %lf %lf %lf", & a, & b, & c)! = 3) {
브레이크; // 세 가지 계수를 읽지 않으면 루프가 종료됩니다.
}
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
} while (! feof (file)); // 파일 끝까지 계속 반복됩니다.
fclose (파일);
반환 0;
}
메소드 5 : while 루프를 사용하여 파일의 계수를 읽으십시오. 유사하게 while 루프를 사용하여 파일별로 계수를 읽을 수 있습니다.
#include <stdio.h>
#include <math.h>
void solvequadratic (Double A, Double B, Double C) {
이중 판별제, root1, root2, RealPart, ImagePart;
판별제 = B * B -4 * A * C;
if (판별> 0) {
root1 = (-b sqrt (판별)) / (2 * a);
root2 = (-B -SQRT (판별)) / (2 * a);
printf ( "방정식은 두 가지 불평등 한 실제 뿌리를 갖습니다 : %.2lf 및 %.2lf \ n", root1, root2);
}
else if (판별 == 0) {
root1 = root2 = -b / (2 * a);
printf ( "방정식은 실제 루트를 갖는다 : %.2lf \ n", root1);
}
또 다른 {
RealPart = -B / (2 * a);
imagpart = sqrt (-discriminant) / (2 * a);
printf ( "방정식에는 2 개의 공액 복합 뿌리가 있습니다.
}
}
int main () {
파일* 파일;
이중 A, B, C;
file = fopen ( "Depations.txt", "r");
if (file == null) {
printf ( "파일을 열 수 없습니다. \ n");
반환 1;
}
while (fscanf (파일, " %lf %lf %lf %lf", & a, & b, & c) == 3) {
if (a == 0) {
printf ( "이것은 2 차 방정식이 아닙니다. \ n");
}
또 다른 {
solvequadratic (a, b, c);
}
}
fclose (파일);
반환 0;
}
18. C 언어 사례 - 판사 도약 년
방법 1 : 표준 방법 이것은 도약 규칙에 따라 가장 일반적이고 표준적인 방법입니다.
#include <stdio.h>
int main () {
int 년;
// 사용자가 연도에 입장하도록 프롬프트합니다
printf ( "1 년을 입력하십시오 :");
scanf ( "%d", & 년);
// 도약 연도 여부를 결정합니다
if ((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0)) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
반환 0;
}
방법 2 : 중첩 된 IF 문을 사용 하여이 방법은 해당 연도가 점차적으로 결정됩니다.
#include <stdio.h>
int main () {
int 년;
// 사용자가 연도에 입장하도록 프롬프트합니다
printf ( "1 년을 입력하십시오 :");
scanf ( "%d", & 년);
// 도약 연도 여부를 결정합니다
if (년 % 4 == 0) {
if (Year % 100! = 0) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
if (Year % 400 == 0) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
}
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
반환 0;
}
방법 3 : 기능 캡슐화를 사용하면 기능에서 도약의 판단 논리를 캡슐화하여 코드를보다 모듈화하고 유지하기가 쉽습니다.
#include <stdio.h>
// 함수 선언
INT ISLEAPYEAR (int 년);
int main () {
int 년;
// 사용자가 연도에 입장하도록 프롬프트합니다
printf ( "1 년을 입력하십시오 :");
scanf ( "%d", & 년);
// 함수를 호출하고 결과를 출력합니다
if (isleapyear (년)) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
반환 0;
}
// 함수 정의
int isleapyear (int year) {
if ((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0)) {
반환 1; // 도약입니다
}
또 다른 {
반환 0; // 도약이 아닙니다
}
}
방법 4 : 3 개 항목 연산자를 사용하여 3 개 항목 연산자를 사용하여 코드를 단순화하십시오.
#include <stdio.h>
int main () {
int 년;
// 사용자가 연도에 입장하도록 프롬프트합니다
printf ( "1 년을 입력하십시오 :");
scanf ( "%d", & 년);
// Trigonometric 연산자를 사용하여 도약인지 여부를 결정합니다.
((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0))?
printf ( "%d는 도약 연도입니다. \ n", 해) :
printf ( "%d는 도약이 아닙니다. \ n", 해);
반환 0;
}
요약
위는 C 언어로 도약을 판단하는 몇 가지 일반적인 방법입니다. 각 방법에는 고유 한 특성이 있습니다.
표준 방법 : 조건부 명세서를 사용하여 주요 기능에서 직접 판단하십시오.
중첩 IF 진술 : 중첩 된 IF 진술을 통해 점차 심사.
함수 캡슐화 사용 : 함수에서 판단 로직을 캡슐화하여 코드를보다 모듈화하십시오.
삼두 운동 연산자 사용 : 조합 연산자를 사용하여 조건부 판단을 단순화하십시오.
주기
방법 1 : for 루프를 사용하십시오
#define _crt_secure_no_warnings
#include <stdio.h>
int main () {
int 연도, i, num;
// 사용자에게 판단 할 연도를 입력하라는 메시지
printf ( "판단 할 연도를 입력하십시오 :");
scanf ( "%d", & num);
// Loop for Loop을 사용하여 Leap Years를 여러 번 판단합니다.
for (i = 0; i <num; i) {
printf ( " %dth 년을 입력하십시오 :", i 1);
scanf ( "%d", & 년);
if ((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0)) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
}
반환 0;
}
방법 2 : 루프를 사용하십시오
#define _crt_secure_no_warnings
#include <stdio.h>
int main () {
int 연도, num, count = 0;
// 사용자에게 판단 할 연도를 입력하라는 메시지
printf ( "판단 할 연도를 입력하십시오 :");
scanf ( "%d", & num);
// while 루프를 사용하여 1 년을 여러 번 판단합니다.
while (count <num) {
printf ( " %d 번째 연도를 입력하십시오 :", count 1);
scanf ( "%d", & 년);
if ((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0)) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
세다 ;
}
반환 0;
}
방법 3 : 사용- 루프 사용
#define _crt_secure_no_warnings
#include <stdio.h>
int main () {
int 연도, num, count = 0;
// 사용자에게 판단 할 연도를 입력하라는 메시지
printf ( "판단 할 연도를 입력하십시오 :");
scanf ( "%d", & num);
// do-while 루프를 사용하여 여러 번 도약을 판단합니다.
하다 {
printf ( " %d 번째 연도를 입력하십시오 :", count 1);
scanf ( "%d", & 년);
if ((년 % 4 == 0 && 년 % 100! = 0) || (년 % 400 == 0)) {
printf ( "%d는 도약 연도입니다. \ n", 년);
}
또 다른 {
printf ( "%d는 도약이 아닙니다. \ n", 해);
}
세다 ;
} while (count <num);
반환 0;
}
19. C 언어 예제 - 판사 양수 숫자 음수 0
방법 1 : if -else 문을 사용하십시오
#include <stdio.h>
int main () {
int 번호;
// 사용자에게 정수를 입력하라고 프롬프트합니다
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
// 입력 정수가 양수, 음수인지 또는 0인지 결정
if (번호> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
else if (number <0) {
printf ( "이 숫자는 음수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
반환 0;
}
회의
방법 2 : 중첩 IF 문을 사용하십시오
#include <stdio.h>
int main () {
int 번호;
// 사용자에게 정수를 입력하라고 프롬프트합니다
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
// 입력 정수가 양수, 음수인지 또는 0인지 결정
if (number! = 0) {
if (번호> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 음수입니다. \ n");
}
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
반환 0;
}
회의
방법 3 : 3 배 연산자를 사용하십시오
#include <stdio.h>
int main () {
int 번호;
// 사용자에게 정수를 입력하라고 프롬프트합니다
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
// 3 배 연산자를 사용하여 입력 정수가 양수, 음수인지 또는 0인지 확인합니다.
(번호> 0)? printf ( "이 숫자는 양수입니다. \ n") :
(숫자 <0)? printf ( "이 숫자는 음수입니다. \ n") :
printf ( "이 숫자는 0입니다. \ n");
반환 0;
}
회의
방법 4 : 스위치 문 (유한 세트에 적용 가능) 사용이 방법은 양수, 음수 및 0을 직접 판단하는 데 적합하지 않지만 일부 해결 방법을 통해 구현할 수 있습니다. 일반적으로 스위치 명령문은 개별 유한 한 값 세트를 처리하는 데 더 적합합니다. 그러나 요구 사항을 충족시키기 위해 다음 방법을 채택 할 수 있습니다.
#include <stdio.h>
int main () {
int 번호;
// 사용자에게 정수를 입력하라고 프롬프트합니다
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
// 스위치 문을 사용하여 입력 정수가 양수, 음수인지 또는 0인지 확인하십시오.
스위치 (번호> 0) {
case 1:
printf ( "이 숫자는 양수입니다. \ n");
부서지다;
케이스 0 :
스위치 (번호 <0) {
case 1:
printf ( "이 숫자는 음수입니다. \ n");
부서지다;
케이스 0 :
printf ( "이 숫자는 0입니다. \ n");
부서지다;
}
부서지다;
}
반환 0;
}
회의
방법 5 : 기능을 사용합니다
#include <stdio.h>
void CheckNumber (int 번호) {
if (번호> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
else if (number <0) {
printf ( "이 숫자는 음수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
}
int main () {
int 번호;
// 사용자에게 정수를 입력하라고 프롬프트합니다
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
// 함수를 호출하여 입력 정수가 양수, 음수인지 또는 0인지 확인
체크 무늬 (번호);
반환 0;
}
주기
루프 중 :
#include <stdio.h>
int main () {
int 번호;
Char Choice = 'y';
while (선택 == 'y'|| 선택 == 'y') {
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
if (번호> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
else if (number <0) {
printf ( "이 숫자는 음수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
printf ( "입력이 계속됩니까? (y/n) :");
scanf ( " %c", & 선택);
}
반환 0;
}
나
#include <stdio.h>
int main () {
int a;
char b = 'y';
for (; (b == 'y'|| b == 'y');) {
scanf ( "%d", & a);
if (a> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
else if (a <0) {
printf ( "이 숫자는 음수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
printf ( "입력이 계속됩니까? (y/n) :");
scanf ( " %c", & b);
}
반환 0;
}
DO- - 루프 :
#include <stdio.h>
int main () {
int 번호;
숯 선택;
하다 {
printf ( "정수를 입력하십시오 :");
scanf ( "%d", & number);
if (번호> 0) {
printf ( "이 숫자는 양수입니다. \ n");
}
else if (number <0) {
printf ( "이 숫자는 음수입니다. \ n");
}
또 다른 {
printf ( "이 숫자는 0입니다. \ n");
}
printf ( "입력이 계속됩니까? (y/n) :");
scanf ( " %c", & 선택);
} while (choice == 'y'|| 선택 == 'y');
반환 0;
}
루프 용 :
#include <stdio.h>
int main () {
int count, 숫자;
// 사용자가 심판 할 정수 번호를 입력하라고 프롬프트합니다.
printf ( "판단 할 정수 수를 입력하십시오 :");
scanf ( "%d", & count);
// 루프를 사용하여 각 정수를 판단하십시오
for (int i = 0; i <count; i) {
printf ( " %d-th 정수를 입력하십시오 :", i 1);
scanf ( "%d", & number);
if (번호> 0) {
printf ( "%d는 양수. \ n", 숫자);
}
else if (number <0) {
printf ( "%d는 음수입니다. \ n", 숫자);
}
또 다른 {
printf ( "%d는 0. \ n", 숫자);
}
}
반환 0;
}
20. C 언어 사례 - 판사 편지
방법 1 : ISALPHA 함수 사용 ISALPHA는 <ctype.h> 헤더 파일에 위치한 C 표준 라이브러리의 함수입니다. 문자가 문자 (A -Z 또는 A -Z)인지 여부를 결정하는 데 사용됩니다.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// ISALPHA 함수를 사용하여 문자가 문자인지 확인
if (isalpha (ch)) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 2 : ASCII 코드 범위 사용 ASCII 코드 값을 확인하여 문자가 문자인지 확인할 수 있습니다.
#define _crt_secure_no_warnings
#include <stdio.h>
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// ASCII 코드 범위를 사용하여 문자가 문자인지 확인
if ((ch> = 'a'&& ch <= 'z') || (ch> = 'a'&& ch <= 'z')) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 3 : 조건부 표현식 및 Toupper 기능을 사용하여 문자를 대문자 형태로 변환 한 다음 ASCII 코드의 대문자 범위 내에 있는지 확인하십시오.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// toupper 함수를 사용하여 문자를 대문자 형식으로 변환 한 다음 문자인지 확인하십시오.
if (toupper (ch)> = 'a'&& toupper (ch) <= 'z') {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 4 : 비트 작동 사용이 방법은 비트 작업을 사용하여 문자가 문자인지 확인합니다. 비교적 복잡하지만이를 구현하는 흥미로운 방법으로 사용될 수 있습니다.
#include <stdio.h>
#define _crt_secure_no_warnings
int is_alpha (char ch) {
// 문자가 문자인지 결정하는 계산
return ((ch> = 'a'&& ch <= 'z') || (ch> = 'a'&& ch <= 'z'));
}
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// IS_ALPHA 함수를 사용하여 문자가 문자인지 확인
if (is_alpha (ch)) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
20. C 언어 사례 - 판사 편지
방법 1 : ISALPHA 함수 사용 ISALPHA는 <ctype.h> 헤더 파일에 위치한 C 표준 라이브러리의 함수입니다. 문자가 문자 (A -Z 또는 A -Z)인지 여부를 결정하는 데 사용됩니다.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// ISALPHA 함수를 사용하여 문자가 문자인지 확인
if (isalpha (ch)) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 2 : ASCII 코드 범위 사용 ASCII 코드 값을 확인하여 문자가 문자인지 확인할 수 있습니다.
#include <stdio.h>
#define _crt_secure_no_warnings
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// ASCII 코드 범위를 사용하여 문자가 문자인지 확인
if ((ch> = 'a'&& ch <= 'z') || (ch> = 'a'&& ch <= 'z')) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 3 : 조건부 표현식 및 Toupper 기능을 사용하여 문자를 대문자 형태로 변환 한 다음 ASCII 코드의 대문자 범위 내에 있는지 확인하십시오.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// toupper 함수를 사용하여 문자를 대문자 형식으로 변환 한 다음 문자인지 확인하십시오.
if (toupper (ch)> = 'a'&& toupper (ch) <= 'z') {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
방법 4 : 비트 작동 사용이 방법은 비트 작업을 사용하여 문자가 문자인지 확인합니다. 비교적 복잡하지만이를 구현하는 흥미로운 방법으로 사용될 수 있습니다.
#include <stdio.h>
#define _crt_secure_no_warnings
int is_alpha (char ch) {
// 문자가 문자인지 결정하는 계산
return ((ch> = 'a'&& ch <= 'z') || (ch> = 'a'&& ch <= 'z'));
}
int main () {
char ch;
// 사용자에게 문자를 입력하라는 메시지
printf ( "문자를 입력하십시오 :");
scanf ( "%c", & ch);
// IS_ALPHA 함수를 사용하여 문자가 문자인지 확인
if (is_alpha (ch)) {
printf ( "당신은 편지를 입력했습니다. \ n");
}
또 다른 {
printf ( "당신은 편지를 입력하지 않습니다. \ n");
}
반환 0;
}
요약
위의 네 가지 방법을 사용하여 문자가 문자인지를 결정할 수 있습니다. 각 방법에는 고유 한 특성이 있습니다.
ISALPHA 기능 : 간단하고 간단하며 이해하기 쉽고 모든 C 컴파일에 적합합니다.
ASCII 코드 범위 사용 : 문자의 ASCII 값을 직접 비교하여 추가 라이브러리 기능이 필요하지 않습니다.
Toupper 기능 사용 : 비교를 위해 문자를 통합 자본 형태로 변환하여 조건부 판단을 단순화하십시오.
비트 작업 사용 :이 방법은 더 복잡하지만 다른 사고 방식을 제공합니다.
이러한 방법은 특정 요구에 따라 선택하고 사용할 수 있습니다. 일반적으로 Isalpha 기능을 사용하는 것은 간단하고 유지 관리가 쉽기 때문에 가장 권장되는 방법입니다.
주기
1. 루프를 사용하십시오. 각 문자가 문자열의 문자인지 확인하려면 for loop을 사용할 수 있습니다.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char str [100];
printf ( "문자열을 입력하십시오 :");
scanf ( "%s", str);
for (int i = 0; str [i]! = '\ 0'; i) {
if (isalpha (str [i]) {
printf ( "문자 '%c'는 문자입니다. \ n", str [i]);
}
또 다른 {
printf ( "문자 '%c'는 문자가 아닙니다. \ n", str [i]);
}
}
반환 0;
}
2. while 루프를 사용하여 비슷하게, 각 문자가 문자열의 문자인지 여부를 결정하려면 while 루프를 사용할 수 있습니다.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char str [100];
printf ( "문자열을 입력하십시오 :");
scanf ( "%s", str);
int i = 0;
while (str [i]! = '\ 0') {
if (isalpha (str [i]) {
printf ( "문자 '%c'는 문자입니다. \ n", str [i]);
}
또 다른 {
printf ( "문자 '%c'는 문자가 아닙니다. \ n", str [i]);
}
나 ;
}
반환 0;
}
3. 사용 - 루프와 비슷하게 각 문자가 문자열의 문자인지 확인하려고한다고 가정하면 루프를 사용할 수 있습니다.
#include <stdio.h>
#include <ctype.h>
#define _crt_secure_no_warnings
int main () {
char str [100];
printf ( "문자열을 입력하십시오 :");
scanf ( "%s", str);
int i = 0;
하다 {
if (isalpha (str [i]) {
printf ( "문자 '%c'는 문자입니다. \ n", str [i]);
}
또 다른 {
printf ( "문자 '%c'는 문자가 아닙니다. \ n", str [i]);
}
나 ;
} while (str [i]! = '\ 0');
반환 0;
}