난수 자릿수별 빈도 계산기

16진수 자릿수별 빈도 계산 in 64bit 환경

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
 
typedef struct number{
    unsigned int zero;
    unsigned int one;
    unsigned int two;
    unsigned int three;
    unsigned int four;
    unsigned int five;
    unsigned int six;
    unsigned int seven;
    unsigned int eight;
    unsigned int nine;
    unsigned int a;
    unsigned int b;
    unsigned int c;
    unsigned int d;
    unsigned int e;
    unsigned int f;
} num;
 
num ot;
 
int count(unsigned char n)
{
    switch(n){
    case 0:
        ot.zero++;
        return 0;
    case 1:
        ot.one++;
        return 1;
    case 2:
        ot.two++;
        return 2;
    case 3:
        ot.three++;
        return 3;
    case 4:
        ot.four++;
        return 4;
    case 5:
        ot.five++;
        return 5;
    case 6:
        ot.six++;
        return 6;
    case 7:
        ot.seven++;
        return 7;
    case 8:
        ot.eight++;
        return 8;
    case 9:
        ot.nine++;
        return 9;
    case 0xa:
        ot.a++;
        return 0xa;
    case 0xb:
        ot.b++;
        return 0xb;
    case 0xc:
        ot.c++;
        return 0xc;
    case 0xd:
        ot.d++;
        return 0xd;
    case 0xe:
        ot.e++;
        return 0xe;
    case 0xf:
        ot.f++;
        return 0xf;
    default:
        puts("error!");
        return -1;
    }
}
 
void calculation_square(unsigned long long number, unsigned int base)
{
    if(number)
    { 
        if(count(number % base) == -1)
            exit(-1);
 
        number /= base;
 
        calculation_square(number, base);
    }
}
 
void hex_result(void)
{
    puts("================================================");
    printf("zero : \t%u\n", ot.zero);
    printf("one : \t%u\n", ot.one);
    printf("two : \t%u\n", ot.two);
    printf("three : %u\n", ot.three);
    printf("four : \t%u\n", ot.four);
    printf("five : \t%u\n", ot.five);
    printf("six : \t%u\n", ot.six);
    printf("seven : %u\n", ot.seven);
    printf("eight : %u\n", ot.eight);
    printf("nine : \t%u\n", ot.nine);
    printf("A : \t%u\n", ot.a);
    printf("B : \t%u\n", ot.b);
    printf("C : \t%u\n", ot.c);
    printf("D : \t%u\n", ot.d);
    printf("E : \t%u\n", ot.e);
    printf("F : \t%u\n", ot.f);    
    puts("================================================");
}
 
void decimal_result(void)
{
    puts("================================================");
    printf("zero : \t%u\n", ot.zero);
    printf("one : \t%u\n", ot.one);
    printf("two : \t%u\n", ot.two);
    printf("three : %u\n", ot.three);
    printf("four : \t%u\n", ot.four);
    printf("five : \t%u\n", ot.five);
    printf("six : \t%u\n", ot.six);
    printf("seven : %u\n", ot.seven);
    printf("eight : %u\n", ot.eight);
    printf("nine : \t%u\n", ot.nine);   
    puts("================================================");
}
 
void octal_result(void)
{
    puts("================================================");
    printf("zero : \t%u\n", ot.zero);
    printf("one : \t%u\n", ot.one);
    printf("two : \t%u\n", ot.two);
    printf("three : %u\n", ot.three);
    printf("four : \t%u\n", ot.four);
    printf("five : \t%u\n", ot.five);
    printf("six : \t%u\n", ot.six);
    printf("seven : %u\n", ot.seven);  
    puts("================================================");
}
 
int main(int argc, char* argv[]){
    unsigned long long random = 0;
    unsigned int size, count_num, base;
    int i, fd;
 
    if(argc != 4){
        printf("usage : ./filename [size] [count] [base]\n");
        return 0;
    }
 
    size = strtoul(argv[1], 0, 10);
    base = strtoul(argv[3], 0, 10);
    count_num = strtoul(argv[2], 0, 10);
 
    if(size == 0) exit(-1);
    if((base != 8) && (base != 10) && (base != 16)) exit(-1);
 
    for(i=0; i<count_num; i++){
        fd = open("/dev/urandom", O_RDONLY);
        if(fd==-1) exit(-1);
 
        if(read(fd, &random, size)!=size) exit(-1);
        close(fd);
 
        printf("random = %llx\n", random);
 
        calculation_square(random, base);
        random = 0;
    }
 
    switch(base){
    case 8:
        octal_result();
        break;
    case 10:
        decimal_result();
        break;
    case 16:
        hex_result();
        break;
    default:
        break;
    }
 
    return 0;
}

- 난수 값에서 자릿수별로 숫자들이 총 몇 번 사용되었는지 계산하는 프로그램이다. 딱히 사용할 곳이 있긴 한가 싶다...

- base에 8진수, 10진수, 16진수를 입력하면 해당 진수에 맞춰 연산을 해준다. 

- size에는 읽어들일 난수의 바이트 크기를 넣으면 되고, count에는 총 몇 번 읽어들일 것인지이다. 필요한 기능은 추가적으로 변경하면 되겠다.

e.g.

일단은 제대로 돌아가지만, 매우 큰 난수 값의 경우 자료형을 변경해서 사용해야 할 것이다.