Wondershare EdrawMind
마인드 맵 갤러리 C 언어 질문 16-20
- 2
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)에 대한 마인드 맵입니다.
C 언어 질문 16-20
- 곤충학
이것은 곤충학에 대한 마인드 맵으로, 곤충의 생태와 형태, 생식 및 발달, 곤충과 인간의 관계를 연구하는 과학입니다. 그것의 연구 대상은 곤충으로, 가장 다양하고 가장 많은 수의 동물이며 생물학적 세계에서 가장 널리 분포되어 있습니다.
- 자녀의 내부 동기 부여를 개발하는 방법 기업가를위한 실용 가이드
이것은 어린이의 내부 동기를 육성하는 방법에 대한 마인드 맵입니다. 기업가를위한 실용적인 가이드, 주요 내용 : 요약, 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;
}