"오현서"의 두 판 사이의 차이

위키원
이동: 둘러보기, 검색
잔글 (104.28.249.213(토론)의 편집을 Asadal의 마지막 판으로 되돌림)
1번째 줄: 1번째 줄:
−
[[파일:오현서.jpg|썸네일|300픽셀|'''오현서''']]
+
#include <stdio.h>
−
[[파일:한국전자통신연구원 글자.png|썸네일|300픽셀|'''[[한국전자통신연구원]]'''(ETRI)]]
+
#include <stdlib.h>
 +
#include <time.h>
  
−
'''오현서'''는 정보통신을 포함한 광범위한 디지털 혁신기술을 연구개발하는 '''[[한국전자통신연구원]]'''(ETRI)의 책임연구원이다. [[연세대학교]](Yonsei University) 전자공학 박사를 취득하였다. 1982년부터 전자통신연구원에서 V2X 통신기술연구책임자로 근무하고 있다. [[한국ITS학회]] 부회장과 TTA ITS·차량·철도 프로젝트 그룹의 의장 자리를 역임하고 있다.
+
#define NUM_DICE 6
  
−
== 같이 보기 ==
+
// 주사위를 던지는 함수
−
* [[한국전자통신연구원]]
+
int rollDice() {
−
* [[대구 국제 미래자동차엑스포 2020]]
+
    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;
 +
}

2024년 10월 16일 (수) 17:28 판

  1. include <stdio.h>
  2. include <stdlib.h>
  3. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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>

  1. include <stdlib.h>
  2. include <time.h>
  1. 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;

}

원본 주소 "http://wiki1.kr/index.php?title=오현서&oldid=778917"