위키원
오현서
104.28.249.215 (토론)님의 2024년 10월 16일 (수) 17:28 판
- include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}#include <stdio.h>
- include <stdlib.h>
- include <time.h>
- define NUM_DICE 6
// 주사위를 던지는 함수 int rollDice() {
return rand() % 6 + 1; // 1에서 6까지의 랜덤한 숫자 반환
}
// 주사위 합을 계산하는 함수 int calculateSum(int rolls[]) {
int sum = 0;
for (int i = 0; i < NUM_DICE; i++) {
sum += rolls[i];
}
return sum;
}
int main() {
int userSum = 0, computerSum = 0;
int userRolls[NUM_DICE], computerRolls[NUM_DICE];
srand(time(NULL)); // 랜덤 시드 초기화
printf("주사위 게임에 오신 것을 환영합니다!\n");
// 사용자 주사위 던지기
printf("사용자의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
userRolls[i] = rollDice();
printf("%d ", userRolls[i]);
}
printf("\n");
// 사용자의 합 계산
userSum = calculateSum(userRolls);
printf("사용자의 합: %d\n", userSum);
// 컴퓨터 주사위 던지기
printf("컴퓨터의 주사위 결과: ");
for (int i = 0; i < NUM_DICE; i++) {
computerRolls[i] = rollDice();
printf("%d ", computerRolls[i]);
}
printf("\n");
// 컴퓨터의 합 계산
computerSum = calculateSum(computerRolls);
printf("컴퓨터의 합: %d\n", computerSum);
// 결과 출력
if (userSum > computerSum) {
printf("축하합니다! 사용자가 이겼습니다!\n");
} else if (userSum < computerSum) {
printf("아쉽지만, 컴퓨터가 이겼습니다. 다음에 다시 도전하세요!\n");
} else {
printf("비겼습니다! 다음 기회에 다시 도전하세요!\n");
}
return 0;
}
