C言語

2018.04.01

2^i ・3^j ・5^k(i,j,kは非負整数)という形で表せる正の整数

100個以前に変数がオーバーフローします。

/*
2^i ・3^j ・5^k(i,j,kは非負整数)という形で表せる正の整数を
小さい順に100個求めるc言語のプログラムを作成してください。
*/
#include <stdio.h>
#include <math.h>

long getNum(int i, int j, int k){
    if(i<=0 || j<=0 || k<=0){
        return -1;
    }
    return (long)(pow(2, i) * pow(3, j) * pow(5, k));
}

#define SIZE 100

typedef struct Num_ {
    long long n;
    int i;
    int j;
    int k;
} Num;

void cntUpNum(Num *a, int cnt, int i, int j, int k){
    a[cnt].n = getNum(i, j, k);
    a[cnt].i = i;
    a[cnt].j = j;
    a[cnt].k = k;
}

void disp(Num *a, int size){
    for(int i=0; i<size; i++){
        printf("%lld = 2^%d x 3^%d x 5^%d\n", a[i].n, a[i].i, a[i].j, a[i].k);
    }
}

int main(void){
    Num a[SIZE];
    int i, j, k, cnt = 0;
    i = j = k = 1;

    while(1){
        cntUpNum(a, cnt++, i  , j  , k  );
        cntUpNum(a, cnt++, i+1, j  , k  );
        cntUpNum(a, cnt++, i  , j+1, k  );
        if(SIZE <= cnt){
            break;
        }
        cntUpNum(a, cnt++, i  , j  , k+1);
        cntUpNum(a, cnt++, i+1, j+1, k  );
        cntUpNum(a, cnt++, i+1, j  , k+1);
        cntUpNum(a, cnt++, i  , j+1, k+1);
        i++;
        j++;
        k++;
    }
    
    disp(a, SIZE);
}

2^i ・3^j ・5^k(i,j,kは非負整数)という形で表せる正の整数を

小さい順に100個求めるc言語のプログラムを作成してください。

#include <stdio.h>

#include <math.h>

long getNum(int i, int j, int k){

if(i<=0 || j<=0 || k<=0){

return -1;

}

return (long)(pow(2, i) * pow(3, j) * pow(5, k));

}

#define SIZE 100

typedef struct Num_ {

long long n;

int i;

int j;

int k;

} Num;

void cntUpNum(Num *a, int cnt, int i, int j, int k){

a[cnt].n = getNum(i, j, k);

a[cnt].i = i;

a[cnt].j = j;

a[cnt].k = k;

}

void disp(Num *a, int size){

for(int i=0; i<size; i++){

printf("%lld = 2^%d x 3^%d x 5^%d\n", a[i].n, a[i].i, a[i].j, a[i].k);

}

int main(void){

Num a[SIZE];

int i, j, k, cnt = 0;

i = j = k = 1;

while(1){

cntUpNum(a, cnt++, i , j , k );

cntUpNum(a, cnt++, i+1, j , k );

cntUpNum(a, cnt++, i , j+1, k );

if(SIZE <= cnt){

break;

}

cntUpNum(a, cnt++, i , j , k+1);

cntUpNum(a, cnt++, i+1, j+1, k );

cntUpNum(a, cnt++, i+1, j , k+1);

cntUpNum(a, cnt++, i , j+1, k+1);

i++;

j++;

k++;

}

disp(a, SIZE);

}

30 = 2^1 x 3^1 x 5^1
60 = 2^2 x 3^1 x 5^1
90 = 2^1 x 3^2 x 5^1
150 = 2^1 x 3^1 x 5^2
180 = 2^2 x 3^2 x 5^1
300 = 2^2 x 3^1 x 5^2
450 = 2^1 x 3^2 x 5^2
900 = 2^2 x 3^2 x 5^2
1800 = 2^3 x 3^2 x 5^2
2700 = 2^2 x 3^3 x 5^2
4500 = 2^2 x 3^2 x 5^3
5400 = 2^3 x 3^3 x 5^2
9000 = 2^3 x 3^2 x 5^3
13500 = 2^2 x 3^3 x 5^3
27000 = 2^3 x 3^3 x 5^3
54000 = 2^4 x 3^3 x 5^3
81000 = 2^3 x 3^4 x 5^3
135000 = 2^3 x 3^3 x 5^4
162000 = 2^4 x 3^4 x 5^3
270000 = 2^4 x 3^3 x 5^4
405000 = 2^3 x 3^4 x 5^4
810000 = 2^4 x 3^4 x 5^4
1620000 = 2^5 x 3^4 x 5^4
2430000 = 2^4 x 3^5 x 5^4
4050000 = 2^4 x 3^4 x 5^5
4860000 = 2^5 x 3^5 x 5^4
8100000 = 2^5 x 3^4 x 5^5
12150000 = 2^4 x 3^5 x 5^5
24300000 = 2^5 x 3^5 x 5^5
48600000 = 2^6 x 3^5 x 5^5
72900000 = 2^5 x 3^6 x 5^5
121500000 = 2^5 x 3^5 x 5^6
145800000 = 2^6 x 3^6 x 5^5
243000000 = 2^6 x 3^5 x 5^6
364500000 = 2^5 x 3^6 x 5^6
729000000 = 2^6 x 3^6 x 5^6
1458000000 = 2^7 x 3^6 x 5^6
2187000000 = 2^6 x 3^7 x 5^6
3645000000 = 2^6 x 3^6 x 5^7
4374000000 = 2^7 x 3^7 x 5^6
7290000000 = 2^7 x 3^6 x 5^7
10935000000 = 2^6 x 3^7 x 5^7
21870000000 = 2^7 x 3^7 x 5^7
43740000000 = 2^8 x 3^7 x 5^7
65610000000 = 2^7 x 3^8 x 5^7
109350000000 = 2^7 x 3^7 x 5^8
131220000000 = 2^8 x 3^8 x 5^7
218700000000 = 2^8 x 3^7 x 5^8
328050000000 = 2^7 x 3^8 x 5^8
656100000000 = 2^8 x 3^8 x 5^8
1312200000000 = 2^9 x 3^8 x 5^8
1968300000000 = 2^8 x 3^9 x 5^8
3280500000000 = 2^8 x 3^8 x 5^9
3936600000000 = 2^9 x 3^9 x 5^8
6561000000000 = 2^9 x 3^8 x 5^9
9841500000000 = 2^8 x 3^9 x 5^9
19683000000000 = 2^9 x 3^9 x 5^9
39366000000000 = 2^10 x 3^9 x 5^9
59049000000000 = 2^9 x 3^10 x 5^9
98415000000000 = 2^9 x 3^9 x 5^10
118098000000000 = 2^10 x 3^10 x 5^9
196830000000000 = 2^10 x 3^9 x 5^10
295245000000000 = 2^9 x 3^10 x 5^10
590490000000000 = 2^10 x 3^10 x 5^10
1180980000000000 = 2^11 x 3^10 x 5^10
1771470000000000 = 2^10 x 3^11 x 5^10
2952450000000000 = 2^10 x 3^10 x 5^11
3542940000000000 = 2^11 x 3^11 x 5^10
5904900000000000 = 2^11 x 3^10 x 5^11
8857350000000000 = 2^10 x 3^11 x 5^11
17714700000000000 = 2^11 x 3^11 x 5^11
35429400000000000 = 2^12 x 3^11 x 5^11
53144100000000000 = 2^11 x 3^12 x 5^11
88573500000000000 = 2^11 x 3^11 x 5^12
106288200000000000 = 2^12 x 3^12 x 5^11
177147000000000000 = 2^12 x 3^11 x 5^12
265720500000000000 = 2^11 x 3^12 x 5^12
531441000000000000 = 2^12 x 3^12 x 5^12
1062882000000000000 = 2^13 x 3^12 x 5^12
1594323000000000000 = 2^12 x 3^13 x 5^12
2657205000000000000 = 2^12 x 3^12 x 5^13
3188646000000000000 = 2^13 x 3^13 x 5^12
5314410000000000000 = 2^13 x 3^12 x 5^13
7971615000000000000 = 2^12 x 3^13 x 5^13
-9223372036854775808 = 2^13 x 3^13 x 5^13
-9223372036854775808 = 2^14 x 3^13 x 5^13
-9223372036854775808 = 2^13 x 3^14 x 5^13
-9223372036854775808 = 2^13 x 3^13 x 5^14
-9223372036854775808 = 2^14 x 3^14 x 5^13
-9223372036854775808 = 2^14 x 3^13 x 5^14
-9223372036854775808 = 2^13 x 3^14 x 5^14
-9223372036854775808 = 2^14 x 3^14 x 5^14
-9223372036854775808 = 2^15 x 3^14 x 5^14
-9223372036854775808 = 2^14 x 3^15 x 5^14
-9223372036854775808 = 2^14 x 3^14 x 5^15
-9223372036854775808 = 2^15 x 3^15 x 5^14
-9223372036854775808 = 2^15 x 3^14 x 5^15
-9223372036854775808 = 2^14 x 3^15 x 5^15
-9223372036854775808 = 2^15 x 3^15 x 5^15
-9223372036854775808 = 2^16 x 3^15 x 5^15

100

30 = 2^1 x 3^1 x 5^1

60 = 2^2 x 3^1 x 5^1

90 = 2^1 x 3^2 x 5^1

150 = 2^1 x 3^1 x 5^2

180 = 2^2 x 3^2 x 5^1

300 = 2^2 x 3^1 x 5^2

450 = 2^1 x 3^2 x 5^2

900 = 2^2 x 3^2 x 5^2

1800 = 2^3 x 3^2 x 5^2

2700 = 2^2 x 3^3 x 5^2

4500 = 2^2 x 3^2 x 5^3

5400 = 2^3 x 3^3 x 5^2

9000 = 2^3 x 3^2 x 5^3

13500 = 2^2 x 3^3 x 5^3

27000 = 2^3 x 3^3 x 5^3

54000 = 2^4 x 3^3 x 5^3

81000 = 2^3 x 3^4 x 5^3

135000 = 2^3 x 3^3 x 5^4

162000 = 2^4 x 3^4 x 5^3

270000 = 2^4 x 3^3 x 5^4

405000 = 2^3 x 3^4 x 5^4

810000 = 2^4 x 3^4 x 5^4

1620000 = 2^5 x 3^4 x 5^4

2430000 = 2^4 x 3^5 x 5^4

4050000 = 2^4 x 3^4 x 5^5

4860000 = 2^5 x 3^5 x 5^4

8100000 = 2^5 x 3^4 x 5^5

12150000 = 2^4 x 3^5 x 5^5

24300000 = 2^5 x 3^5 x 5^5

48600000 = 2^6 x 3^5 x 5^5

72900000 = 2^5 x 3^6 x 5^5

121500000 = 2^5 x 3^5 x 5^6

145800000 = 2^6 x 3^6 x 5^5

243000000 = 2^6 x 3^5 x 5^6

364500000 = 2^5 x 3^6 x 5^6

729000000 = 2^6 x 3^6 x 5^6

1458000000 = 2^7 x 3^6 x 5^6

2187000000 = 2^6 x 3^7 x 5^6

3645000000 = 2^6 x 3^6 x 5^7

4374000000 = 2^7 x 3^7 x 5^6

7290000000 = 2^7 x 3^6 x 5^7

10935000000 = 2^6 x 3^7 x 5^7

21870000000 = 2^7 x 3^7 x 5^7

43740000000 = 2^8 x 3^7 x 5^7

65610000000 = 2^7 x 3^8 x 5^7

109350000000 = 2^7 x 3^7 x 5^8

131220000000 = 2^8 x 3^8 x 5^7

218700000000 = 2^8 x 3^7 x 5^8

328050000000 = 2^7 x 3^8 x 5^8

656100000000 = 2^8 x 3^8 x 5^8

1312200000000 = 2^9 x 3^8 x 5^8

1968300000000 = 2^8 x 3^9 x 5^8

3280500000000 = 2^8 x 3^8 x 5^9

3936600000000 = 2^9 x 3^9 x 5^8

6561000000000 = 2^9 x 3^8 x 5^9

9841500000000 = 2^8 x 3^9 x 5^9

19683000000000 = 2^9 x 3^9 x 5^9

39366000000000 = 2^10 x 3^9 x 5^9

59049000000000 = 2^9 x 3^10 x 5^9

98415000000000 = 2^9 x 3^9 x 5^10

118098000000000 = 2^10 x 3^10 x 5^9

196830000000000 = 2^10 x 3^9 x 5^10

295245000000000 = 2^9 x 3^10 x 5^10

590490000000000 = 2^10 x 3^10 x 5^10

1180980000000000 = 2^11 x 3^10 x 5^10

1771470000000000 = 2^10 x 3^11 x 5^10

2952450000000000 = 2^10 x 3^10 x 5^11

3542940000000000 = 2^11 x 3^11 x 5^10

5904900000000000 = 2^11 x 3^10 x 5^11

8857350000000000 = 2^10 x 3^11 x 5^11

17714700000000000 = 2^11 x 3^11 x 5^11

35429400000000000 = 2^12 x 3^11 x 5^11

53144100000000000 = 2^11 x 3^12 x 5^11

88573500000000000 = 2^11 x 3^11 x 5^12

106288200000000000 = 2^12 x 3^12 x 5^11

177147000000000000 = 2^12 x 3^11 x 5^12

265720500000000000 = 2^11 x 3^12 x 5^12

531441000000000000 = 2^12 x 3^12 x 5^12

1062882000000000000 = 2^13 x 3^12 x 5^12

1594323000000000000 = 2^12 x 3^13 x 5^12

2657205000000000000 = 2^12 x 3^12 x 5^13

3188646000000000000 = 2^13 x 3^13 x 5^12

5314410000000000000 = 2^13 x 3^12 x 5^13

7971615000000000000 = 2^12 x 3^13 x 5^13

-9223372036854775808 = 2^13 x 3^13 x 5^13

-9223372036854775808 = 2^14 x 3^13 x 5^13

-9223372036854775808 = 2^13 x 3^14 x 5^13

-9223372036854775808 = 2^13 x 3^13 x 5^14

-9223372036854775808 = 2^14 x 3^14 x 5^13

-9223372036854775808 = 2^14 x 3^13 x 5^14

-9223372036854775808 = 2^13 x 3^14 x 5^14

-9223372036854775808 = 2^14 x 3^14 x 5^14

-9223372036854775808 = 2^15 x 3^14 x 5^14

-9223372036854775808 = 2^14 x 3^15 x 5^14

-9223372036854775808 = 2^14 x 3^14 x 5^15

-9223372036854775808 = 2^15 x 3^15 x 5^14

-9223372036854775808 = 2^15 x 3^14 x 5^15

-9223372036854775808 = 2^14 x 3^15 x 5^15

-9223372036854775808 = 2^15 x 3^15 x 5^15

-9223372036854775808 = 2^16 x 3^15 x 5^15

2018.04.01

完全数を求めるプログラム

/*
1000以下の完全数を求めるc言語のプログラムを作成してください。
完全数とは、その数自身を除く約数の合計が同じ値になる整数です。
例えば、6の約数は1,2,3,6で、6=1+2+3となるので、6は完全数です。
*/
#include <stdio.h>

int sumOfAllFactors(int n){
    if(n<=0){
        return 0;
    }
    /* nは1以上 */
    int half = n / 2;
    int sum = 0;
    for(int i=1; i<=half; i++){
        if(n%i == 0){
            /* iはnの約数 */
            sum += i;
        }
    }
    return sum;
}

int isCompleteNumber(int n){
    if(n<=0){
        return 0;
    }
    if(sumOfAllFactors(n) == n){
        // その数自身を除く約数の合計が同じ値になる
        return 1;
    }else{
        return 0;
    }
}

// n以下の完全数を全て出力
void dispCompleteNumber_underNorN(int n){
    if(n<=0){
        return;
    }
    printf("%d以下の完全数 : ", n);
    for(int i=0; i<=n; i++){
        if(isCompleteNumber(i)){
            printf("%d ", i);
        }
    }
    printf("\n");
}

int main(void){
    dispCompleteNumber_underNorN(100);
    dispCompleteNumber_underNorN(1000);
    dispCompleteNumber_underNorN(10000);
}

1000以下の完全数を求めるc言語のプログラムを作成してください。

完全数とは、その数自身を除く約数の合計が同じ値になる整数です。

例えば、6の約数は1,2,3,6で、6=1+2+3となるので、6は完全数です。

#include <stdio.h>

int sumOfAllFactors(int n){

if(n<=0){

return 0;

}

/* nは1以上 */

int half = n / 2;

int sum = 0;

for(int i=1; i<=half; i++){

if(n%i == 0){

/* iはnの約数 */

sum += i;

}

return sum;

}

int isCompleteNumber(int n){

if(n<=0){

return 0;

}

if(sumOfAllFactors(n) == n){

// その数自身を除く約数の合計が同じ値になる

return 1;

}else{

return 0;

}

// n以下の完全数を全て出力

void dispCompleteNumber_underNorN(int n){

if(n<=0){

return;

}

printf("%d以下の完全数 : ", n);

for(int i=0; i<=n; i++){

if(isCompleteNumber(i)){

printf("%d ", i);

}

printf("\n");

}

int main(void){

dispCompleteNumber_underNorN(100);

dispCompleteNumber_underNorN(1000);

dispCompleteNumber_underNorN(10000);

}

100以下の完全数 : 6 28 
1000以下の完全数 : 6 28 496 
10000以下の完全数 : 6 28 496 8128

100以下の完全数 : 6 28

1000以下の完全数 : 6 28 496

10000以下の完全数 : 6 28 496 8128

2018.03.29

関数ポインタを引数に渡す

こんなの使ってるのみたことない。

#include <stdio.h>
void increment(int *x){
    (*x)++;
}

void pint(int n){
    printf("%d\n", n);
}

void caller(int arg, void (*inc)(int)){
    inc(arg);
}

int main(void){
    int x = 199;
    
    pint(x);

    int called = increment;
    
    caller(&x, called);
    
    pint(x);
}

#include <stdio.h>

void increment(int *x){

(*x)++;

}

void pint(int n){

printf("%d\n", n);

}

void caller(int arg, void (*inc)(int)){

inc(arg);

}

int main(void){

int x = 199;

pint(x);

int called = increment;

caller(&x, called);

pint(x);

}

199
200

199

200

2018.03.27

c言語で神経衰弱

#include <stdio.h>

char a[10];
char gained[10];
int pend = -1;

void disp(int pend1, int pend2){
    int i;
    for(i=0; i<10; i++){
        if(i==5){
            printf("\n");
        }
        if(gained[i]){
            printf(" | %c| ", a[i]);
        }else if((pend1 == i) || (pend2 == i)){
            printf(" |>%c| ", a[i]);
        }else{
            printf(" |%2d| ", i+1);
        }
    }
    printf("\n");
    printf("\n");
}


void init(){
    a[0] = 'a';
    a[1] = 'b';
    a[2] = 'c';
    a[3] = 'd';
    a[4] = 'e';
    a[5] = 'e';
    a[6] = 'a';
    a[7] = 'b';
    a[8] = 'c';
    a[9] = 'd';

    int i;
    for(i=0; i<10; i++){
        gained[i] = 0;
    }
}

void init_chose(){
    pend = -1;
}

int isValidPair(int first, int second){
    if((first != second) && (a[first] == a[second])){
        return 1;
    }
    return 0;
}

int isFinish(){
    int i;
    for(i=0; i<10; i++){
        if(1 != gained[i]){
            return 0;
        }
    }
    return 1;
}

int main(void){
    // Your code here!
    init();
    int input = -1;
    while(1){
        disp(pend, -1);

        printf("カードを選んでください (1〜10):");
        scanf("%d", &input);

        if(input<1 || 10<input){
            printf("無効な値です\n");
            continue;
        }
        input--;
        
        if(gained[input]){
            printf("すでに取得しています\n");
            continue;
        }
        
        if(pend != -1){
            if(isValidPair(pend, input)){
                // 一致
                printf("当たりです\n");
                gained[pend] = 1;
                gained[input] = 1;
                if(isFinish()){
                    disp(-1, -1);
                    break;
                }
            }else{
                // 不一致
                disp(pend, input);
                printf("外れです\n");
            }
            pend = -1;
        }else{
            pend = input;
        }
    }

    return 0;    
}

100

101

102

103

104

105

106

107

108

#include <stdio.h>

char a[10];

char gained[10];

int pend = -1;

void disp(int pend1, int pend2){

int i;

for(i=0; i<10; i++){

if(i==5){

printf("\n");

}

if(gained[i]){

printf(" | %c| ", a[i]);

}else if((pend1 == i) || (pend2 == i)){

printf(" |>%c| ", a[i]);

}else{

printf(" |%2d| ", i+1);

}

printf("\n");

}

void init(){

a[0] = 'a';

a[1] = 'b';

a[2] = 'c';

a[3] = 'd';

a[4] = 'e';

a[5] = 'e';

a[6] = 'a';

a[7] = 'b';

a[8] = 'c';

a[9] = 'd';

int i;

for(i=0; i<10; i++){

gained[i] = 0;

}

void init_chose(){

pend = -1;

}

int isValidPair(int first, int second){

if((first != second) && (a[first] == a[second])){

return 1;

}

return 0;

}

int isFinish(){

int i;

for(i=0; i<10; i++){

if(1 != gained[i]){

return 0;

}

return 1;

}

int main(void){

// Your code here!

init();

int input = -1;

while(1){

disp(pend, -1);

printf("カードを選んでください (1〜10):");

scanf("%d", &input);

if(input<1 || 10<input){

printf("無効な値です\n");

continue;

}

input--;

if(gained[input]){

printf("すでに取得しています\n");

continue;

}

if(pend != -1){

if(isValidPair(pend, input)){

// 一致

printf("当たりです\n");

gained[pend] = 1;

gained[input] = 1;

if(isFinish()){

disp(-1, -1);

break;

}

}else{

// 不一致

disp(pend, input);

printf("外れです\n");

}

pend = -1;

}else{

pend = input;

}

return 0;

}

2018.03.20

c言語のランダム生成器

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void init(){
    srand(time(NULL));
}
double getRandomDouble(){
    return rand() * 1.0 / RAND_MAX;
}
int getRandomInt(int min, int max){
    if(max < min){
        return max;
    }
    double d = getRandomDouble();
    int randomOffset = (int)(d * (max - min + 1));
    return min + randomOffset;
}
int main(){
    init();
    int n;
    int intMin = -3;
    int intMax = 7;
    int times = 10000;
    int min = 0;
    int max = 0;
    for(int i=0; i<times; i++){
        n = getRandomInt(intMin, intMax);
        if(n < min){
            min = n;
        }
        if(max < n){
            max = n;
        }
    }
    printf("max = %d\n", max);
    printf("min = %d\n", min);
}

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void init(){

srand(time(NULL));

}

double getRandomDouble(){

return rand() * 1.0 / RAND_MAX;

}

int getRandomInt(int min, int max){

if(max < min){

return max;

}

double d = getRandomDouble();

int randomOffset = (int)(d * (max - min + 1));

return min + randomOffset;

}

int main(){

init();

int n;

int intMin = -3;

int intMax = 7;

int times = 10000;

int min = 0;

int max = 0;

for(int i=0; i<times; i++){

n = getRandomInt(intMin, intMax);

if(n < min){

min = n;

}

if(max < n){

max = n;

}

printf("max = %d\n", max);

printf("min = %d\n", min);

}

max = 7
min = -3

1 2	max = 7 min = -3

2018.03.16

底の円の半径r(メートル), 円錐の高さh(メートル)の円錐の表面積

#include <stdio.h>
#include <math.h>

#define PI 3.14159265

// 底の円の半径r(メートル), 円錐の高さh(メートル)
double getSurfaceAreaOfCone(double r, double h){
    double S = PI * r * (r + sqrt(pow(r, 2) + pow(h, 2)));
    return S;
}

int main(void){
    double r = 3;
    double h = 4;
    double S = getSurfaceAreaOfCone(r, h);
    
    printf("底の円の半径%.2f[m]、高さ%.2f[m]の円錐の表面積は%.2f[m^2]",
        r, h, S, S/PI
    );
}

#include <stdio.h>

#include <math.h>

#define PI 3.14159265

// 底の円の半径r(メートル), 円錐の高さh(メートル)

double getSurfaceAreaOfCone(double r, double h){

double S = PI * r * (r + sqrt(pow(r, 2) + pow(h, 2)));

return S;

}

int main(void){

double r = 3;

double h = 4;

double S = getSurfaceAreaOfCone(r, h);

printf("底の円の半径%.2f[m]、高さ%.2f[m]の円錐の表面積は%.2f[m^2]",

r, h, S, S/PI

);

}

底の円の半径3.00[m]、高さ4.00[m]の円錐の表面積は75.40[m^2]

1	底の円の半径3.00[m]、高さ4.00[m]の円錐の表面積は75.40[m^2]

2018.03.16

成功率5%のことに1回でも成功する確率が80%以上になるのは、何回挑戦した時か

#include <stdio.h>
#include <math.h>

/**
 * 任意の整数を底とする対数を計算する
 * y = log a x
 * @param[in] base 底 a
 * @param[in] antilog 真数 x
 */
double logn(double base, double antilog) {
    return log(antilog) / log((double)base);
}

/**
 * 成功率5%のことに1回でも成功する確率が80%以上になるのは、何回挑戦した時か
 */
int main(void){
    
    int p = 5;      // 成功率
    int q = 80;     // 目標成功率
    
    double l = 1.0 - p/100.0;
    double r = 1.0 - q/100.0;
    
    int cnt = 1;
    double ll = l;
    
    while(1){
        cnt++;
        ll *= l;
        if(ll <= r){
            break;
        }
    }
    
    double n = cnt - 1;
    double offset = 0.0000001;
    while(1){
        n += offset;
        if(pow(l, n) < r){
            break;
        }
    }
    printf("計算解 : %f 回\n", n);

    double a = l;
    double x = r;
    double ans = logn(a, x);
    printf("解析解 : %f 回\n", ans);
    
}

#include <stdio.h>

#include <math.h>

/**

* 任意の整数を底とする対数を計算する

* y = log a x

* @param[in] base 底 a

* @param[in] antilog 真数 x

double logn(double base, double antilog) {

return log(antilog) / log((double)base);

}

/**

* 成功率5%のことに1回でも成功する確率が80%以上になるのは、何回挑戦した時か

int main(void){

int p = 5; // 成功率

int q = 80; // 目標成功率

double l = 1.0 - p/100.0;

double r = 1.0 - q/100.0;

int cnt = 1;

double ll = l;

while(1){

cnt++;

ll *= l;

if(ll <= r){

break;

}

double n = cnt - 1;

double offset = 0.0000001;

while(1){

n += offset;

if(pow(l, n) < r){

break;

}

printf("計算解 : %f 回\n", n);

double a = l;

double x = r;

double ans = logn(a, x);

printf("解析解 : %f 回\n", ans);

}

計算解 : 31.377160 回
解析解 : 31.377160 回

1 2	計算解 : 31.377160 回解析解 : 31.377160 回

2018.03.16

素数判定高速化

素数判定の高速化に挑戦

〜判定の流れ〜
(nが素数ならtrueを返す)
nが1以下ならfalse
nが2または3ならtrue
nが2の倍数ならfalse
nの平方根を整数で取得(5なら2, 10なら3)
nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse
上記すべて回避したらtrue

〜判定の流れ〜

(nが素数ならtrueを返す)

nが1以下ならfalse

nが2または3ならtrue

nが2の倍数ならfalse

nの平方根を整数で取得(5なら2, 10なら3)

nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse

上記すべて回避したらtrue

高速化できた。現状、ユズノハ史上最速の素数判定。

#include <stdio.h>
#include <math.h>
#include <time.h>
 
/*
〜判定の流れ〜
(nが素数ならtrueを返す)
nが1以下ならfalse
nが2または3ならtrue
nが2の倍数ならfalse
nの平方根を整数で取得(5なら2, 10なら3)
nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse
上記すべて回避したらtrue
*/ 
int isPrime_new(int n){
    // nが1以下ならfalse
    if(n<=1){
        return 0;
    }
    // nが2または3ならtrue
    if(2==n || 3==n){
        return 1;
    }
    // nが2の倍数ならfalse
    if(0==n%2){
        return 0;
    }
    // nの平方根を整数で取得(5なら2, 10なら3)
    int square_root = (int)sqrt(n);
    // nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse
    for(int i=3; i<=square_root; i+=2){
        if(0==n%i){
            return 0;
        }
    }
    // 上記すべて回避したらtrue
    return 1;
}

/* 高速化前の素数判定アルゴリズム */
int isPrime_old(int n){
    if(n<=1){
        return 0;
    }
    if(2==n){
        return 1;
    }
    int square_root = (int)sqrt(n);
    for(int i=2; i<=square_root; i++){
        if(0==n%i){
            return 0;
        }
    }
    return 1;
}
 
int getTimeSpanNanoSec(struct timespec tsStart, struct timespec tsEnd){
    int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;
    int sec = tsEnd.tv_sec - tsStart.tv_sec;
    if(0 < sec){
        nsec += sec * 1000000000;
    }
    return nsec;
}
 
void dispTimeForPrimeSearch_old(int n){
    printf("(OLD) ");
    
    int cnt = 0;
    struct timespec tsStart, tsEnd;
 
    timespec_get(&tsStart, TIME_UTC);
    for(int i=-5; i<=n; i++){
        if(isPrime_old(i)){
            cnt++;
        }
    }
    timespec_get(&tsEnd, TIME_UTC);
 
    int nsec = getTimeSpanNanoSec(tsStart, tsEnd);
 
    printf("%d以下の素数の数 : %d個\t", n, cnt);
    printf("所要時間 %f ミリ秒\n", nsec / 1000000.0);
}
 
void dispTimeForPrimeSearch_new(int n){
    printf("(NEW) ");
    
    int cnt = 0;
    struct timespec tsStart, tsEnd;
 
    timespec_get(&tsStart, TIME_UTC);
    for(int i=-5; i<=n; i++){
        if(isPrime_new(i)){ // landmark
            cnt++;
        }
    }
    timespec_get(&tsEnd, TIME_UTC);
 
    int nsec = getTimeSpanNanoSec(tsStart, tsEnd);
 
    printf("%d以下の素数の数 : %d個\t", n, cnt);
    printf("所要時間 %f ミリ秒\n", nsec / 1000000.0);
}
 
int main(){
    int n = 1000000; // n以下の素数
    dispTimeForPrimeSearch_new(n);
    dispTimeForPrimeSearch_old(n);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

#include <stdio.h>

#include <math.h>

#include <time.h>

〜判定の流れ〜

(nが素数ならtrueを返す)

nが1以下ならfalse

nが2または3ならtrue

nが2の倍数ならfalse

nの平方根を整数で取得(5なら2, 10なら3)

nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse

上記すべて回避したらtrue

int isPrime_new(int n){

// nが1以下ならfalse

if(n<=1){

return 0;

}

// nが2または3ならtrue

if(2==n || 3==n){

return 1;

}

// nが2の倍数ならfalse

if(0==n%2){

return 0;

}

// nの平方根を整数で取得(5なら2, 10なら3)

int square_root = (int)sqrt(n);

// nがnの平方根以下の、3以上の奇数(3,5,7,9,11,...)で1回でも割れたらfalse

for(int i=3; i<=square_root; i+=2){

if(0==n%i){

return 0;

}

// 上記すべて回避したらtrue

return 1;

}

/* 高速化前の素数判定アルゴリズム */

int isPrime_old(int n){

if(n<=1){

return 0;

}

if(2==n){

return 1;

}

int square_root = (int)sqrt(n);

for(int i=2; i<=square_root; i++){

if(0==n%i){

return 0;

}

return 1;

}

int getTimeSpanNanoSec(struct timespec tsStart, struct timespec tsEnd){

int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;

int sec = tsEnd.tv_sec - tsStart.tv_sec;

if(0 < sec){

nsec += sec * 1000000000;

}

return nsec;

}

void dispTimeForPrimeSearch_old(int n){

printf("(OLD) ");

int cnt = 0;

struct timespec tsStart, tsEnd;

timespec_get(&tsStart, TIME_UTC);

for(int i=-5; i<=n; i++){

if(isPrime_old(i)){

cnt++;

}

timespec_get(&tsEnd, TIME_UTC);

int nsec = getTimeSpanNanoSec(tsStart, tsEnd);

printf("%d以下の素数の数 : %d個\t", n, cnt);

printf("所要時間 %f ミリ秒\n", nsec / 1000000.0);

}

void dispTimeForPrimeSearch_new(int n){

printf("(NEW) ");

int cnt = 0;

struct timespec tsStart, tsEnd;

timespec_get(&tsStart, TIME_UTC);

for(int i=-5; i<=n; i++){

if(isPrime_new(i)){ // landmark

cnt++;

}

timespec_get(&tsEnd, TIME_UTC);

int nsec = getTimeSpanNanoSec(tsStart, tsEnd);

printf("%d以下の素数の数 : %d個\t", n, cnt);

printf("所要時間 %f ミリ秒\n", nsec / 1000000.0);

}

int main(){

int n = 1000000; // n以下の素数

dispTimeForPrimeSearch_new(n);

dispTimeForPrimeSearch_old(n);

return 0;

}

(NEW) 1000000以下の素数の数 : 78498個	所要時間 105.270360 ミリ秒
(OLD) 1000000以下の素数の数 : 78498個	所要時間 224.728172 ミリ秒

1 2	(NEW) 1000000以下の素数の数 : 78498個所要時間 105.270360 ミリ秒 (OLD) 1000000以下の素数の数 : 78498個所要時間 224.728172 ミリ秒

2018.03.16

c言語でナノ秒時間測定

    int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;
    int secSpan = tsEnd.tv_sec - tsStart.tv_sec;
    if(0 < secSpan){
        nsec += secSpan * 1000000000;
    }

int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;

int secSpan = tsEnd.tv_sec - tsStart.tv_sec;

if(0 < secSpan){

nsec += secSpan * 1000000000;

}

がポイント

#include <stdio.h>
#include <math.h>
#include <time.h>
// int timespec_get (struct timespec *ts, int base)

int isPrime(int n){
    if(n<=1){
        return 0;
    }
    if(2==n || 3==n){
        return 1;
    }
    int square_root = (int)sqrt(n);
    for(int i=2; i<=square_root; i++){
        if(0==n%i){
            return 0;
        }
    }
    return 1;
}

int dispIsPrime(int n){
    printf("%dは", n);
    if(isPrime(n)){
        printf(" ... 素数");
    }
    printf("\n");
        
}

/*
1000000万以下の素数の個数を算出するアルゴリズムの速度を求める
*/
int main(){
    struct timespec tsStart, tsEnd;
    timespec_get(&tsStart, TIME_UTC);
    

    int n = 1000000;
    int cnt = 0;
    for(int i=-5; i<=n; i++){
        if(isPrime(i)){
            cnt++;
        }
    }
    
    printf("%d以下の素数の数 : %d\n", n, cnt);
    timespec_get(&tsEnd, TIME_UTC);

    printf("%ld %09ld\n", tsStart.tv_sec, tsStart.tv_nsec);
    printf("%ld %09ld\n", tsEnd.tv_sec, tsEnd.tv_nsec);

    int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;
    int secSpan = tsEnd.tv_sec - tsStart.tv_sec;
    if(0 < secSpan){
        nsec += secSpan * 1000000000;
    }
    
    printf("所要時間 %d ナノ秒\n", nsec);
}

#include <stdio.h>

#include <math.h>

#include <time.h>

// int timespec_get (struct timespec *ts, int base)

int isPrime(int n){

if(n<=1){

return 0;

}

if(2==n || 3==n){

return 1;

}

int square_root = (int)sqrt(n);

for(int i=2; i<=square_root; i++){

if(0==n%i){

return 0;

}

return 1;

}

int dispIsPrime(int n){

printf("%dは", n);

if(isPrime(n)){

printf(" ... 素数");

}

printf("\n");

}

1000000万以下の素数の個数を算出するアルゴリズムの速度を求める

int main(){

struct timespec tsStart, tsEnd;

timespec_get(&tsStart, TIME_UTC);

int n = 1000000;

int cnt = 0;

for(int i=-5; i<=n; i++){

if(isPrime(i)){

cnt++;

}

printf("%d以下の素数の数 : %d\n", n, cnt);

timespec_get(&tsEnd, TIME_UTC);

printf("%ld %09ld\n", tsStart.tv_sec, tsStart.tv_nsec);

printf("%ld %09ld\n", tsEnd.tv_sec, tsEnd.tv_nsec);

int nsec = tsEnd.tv_nsec - tsStart.tv_nsec;

int secSpan = tsEnd.tv_sec - tsStart.tv_sec;

if(0 < secSpan){

nsec += secSpan * 1000000000;

}

printf("所要時間 %d ナノ秒\n", nsec);

}

1000000以下の素数の数 : 78498
1521134295 797056797
1521134296 022770585
所要時間 225713788 ナノ秒

1000000以下の素数の数 : 78498

1521134295 797056797

1521134296 022770585

所要時間 225713788 ナノ秒

2018.01.22

c言語でクイックソート

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void dispArrayLine(int a[], int length, int dispTotal){
    int total = 0;
    for(int i=0; i<length; i++){
        total += a[i];
        printf("%d", a[i]);
        if(i!=length-1){
            printf(" ");
        }else{
            if(dispTotal){
                printf(" : %d", total);
            }
            printf("\n");
        }
    }
}

void dispArrayList(int a[], int length){
    for(int i=0; i<length; i++){
        printf("[%d] : %d\n", i, a[i]);
    }
}

void resetArray(int a[], int length){
    for(int i=0; i<length; i++){
        a[i] = 0;
    }
}

void init(){
    srand((unsigned)time(NULL));
}

double getRandomDouble(){
    return (double)rand() / RAND_MAX;
}

int getRandomInt(int min, int max){
    double d = getRandomDouble();
    int randomOffset = d * (max - min + 1);
    return min + randomOffset;
}

void setRandomIntForArray(int a[], int length, int min, int max){
    for(int i=0; i<length; i++){
        a[i] = getRandomInt(min, max);
    }
}

int getPivot(int a, int b, int c){
    if(a > b){
        if(b > c){
            return b;
        }else{
            return a > c ? c : a ;
        }
    }else{
        if(a > c){
            return a;
        }else{
            return b > c ? c : b ;
        }
    }
}

int getMax(int a, int b, int c){
    if(a > b){
        return a > c ? a : c ;
    }else{
        return b > c ? b : c ;
    }
}

int getMin(int a, int b, int c){
    if(a < b){
        return a < c ? a : c ;
    }else{
        return b < c ? b : c ;
    }
}

void swap(int a[], int l, int r){
    int t = a[l];
    a[l] = a[r];
    a[r] = t;
}

void quicksort_core(int a[], int length, int left, int right){
    if(right <= left){
        return;
    }
    int l = left;
    int r = right;
    int p = getPivot(a[l], a[l+1], a[r]);
    while(1){
        while(a[l]<p){
            l++;
        }
        while(p<a[r]){
            r--;
        }
        if(r<=l){
            break;
        }
        swap(a, l, r);
        l++;
        r--;
    }
    quicksort_core(a, length, left, l-1);
    quicksort_core(a, length, r+1, right);
}

void quicksort(int a[], int length){
    int left = 0;
    int right = length-1;
    quicksort_core(a, length, left, right);
}

int main(void){
    init();
    int length = 30;
    int a[length];
    int min = -9;
    int max = 9;
    setRandomIntForArray(a, length, min, max);
    dispArrayLine(a, length, 1);
    quicksort(a, length);
    dispArrayLine(a, length, 1);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void dispArrayLine(int a[], int length, int dispTotal){

int total = 0;

for(int i=0; i<length; i++){

total += a[i];

printf("%d", a[i]);

if(i!=length-1){

printf(" ");

}else{

if(dispTotal){

printf(" : %d", total);

}

printf("\n");

}

void dispArrayList(int a[], int length){

for(int i=0; i<length; i++){

printf("[%d] : %d\n", i, a[i]);

}

void resetArray(int a[], int length){

for(int i=0; i<length; i++){

a[i] = 0;

}

void init(){

srand((unsigned)time(NULL));

}

double getRandomDouble(){

return (double)rand() / RAND_MAX;

}

int getRandomInt(int min, int max){

double d = getRandomDouble();

int randomOffset = d * (max - min + 1);

return min + randomOffset;

}

void setRandomIntForArray(int a[], int length, int min, int max){

for(int i=0; i<length; i++){

a[i] = getRandomInt(min, max);

}

int getPivot(int a, int b, int c){

if(a > b){

if(b > c){

return b;

}else{

return a > c ? c : a ;

}

}else{

if(a > c){

return a;

}else{

return b > c ? c : b ;

}

int getMax(int a, int b, int c){

if(a > b){

return a > c ? a : c ;

}else{

return b > c ? b : c ;

}

int getMin(int a, int b, int c){

if(a < b){

return a < c ? a : c ;

}else{

return b < c ? b : c ;

}

void swap(int a[], int l, int r){

int t = a[l];

a[l] = a[r];

a[r] = t;

}

void quicksort_core(int a[], int length, int left, int right){

if(right <= left){

return;

}

int l = left;

int r = right;

int p = getPivot(a[l], a[l+1], a[r]);

while(1){

while(a[l]<p){

l++;

}

while(p<a[r]){

r--;

}

if(r<=l){

break;

}

swap(a, l, r);

l++;

r--;

}

quicksort_core(a, length, left, l-1);

quicksort_core(a, length, r+1, right);

}

void quicksort(int a[], int length){

int left = 0;

int right = length-1;

quicksort_core(a, length, left, right);

}

int main(void){

init();

int length = 30;

int a[length];

int min = -9;

int max = 9;

setRandomIntForArray(a, length, min, max);

dispArrayLine(a, length, 1);

quicksort(a, length);

dispArrayLine(a, length, 1);

return 0;

}

123

C言語

2^i ・3^j ・5^k(i,j,kは非負整数)という形で表せる正の整数

完全数を求めるプログラム

関数ポインタを引数に渡す

c言語で神経衰弱

c言語のランダム生成器

底の円の半径r(メートル), 円錐の高さh(メートル)の円錐の表面積

成功率5%のことに1回でも成功する確率が80%以上になるのは、何回挑戦した時か

素数判定高速化

c言語でナノ秒時間測定

c言語でクイックソート

最近の投稿

サイトマップ

カテゴリー

アーカイブ

人気の投稿とページ

Twitter