プログラマ専用SNS ミクプラ

コード:

cp_table = MakeHashtable();
cp = NextCP();
while (cp != NULL) {
    if (cp in cp_table) {
        cp_table[cp]++;
        free(cp);
    } else {
        cp_table.put(cp, 1);
    }
    cp = NextCP();
}

コード:

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

#define HASH_SIZE  997
#define BUF_SIZE   1000
#define DATA_SIZE  500

typedef struct CP {
    int *data;
    int size;
    int count;
    struct CP *next;
} CP;

CP *alloc_cp(int *data, int size)
{
    CP *cp = malloc(sizeof(CP));
    cp->data = malloc(sizeof(int) * size);
    memcpy(cp->data, data, sizeof(int) * size);
    cp->size = size;
    cp->count = 1;
    cp->next = NULL;
    return cp;
}

int comp(const CP *cp, int *data, int size)
{
    int i;
    if (cp->size != size) return 1;
    for (i = 0; i < size; i++)
        if (cp->data[i] != data[i]) return 1;
    return 0;
}

void add(CP **hash_table, int hash, int *data, int size)
{
    CP **p = &hash_table[hash];
    for (; *p && comp(*p, data, size); p = &(*p)->next) ;
    if (*p)
        (*p )->count++;
    else
        *p = alloc_cp(data, size);
}

void print(CP **hash_table, int size)
{
    int i, j;
    CP *cp;
    for (i = 0; i < size; i++) {
        for (cp = hash_table[i]; cp; cp = cp->next) {
            printf("hash=%3d: count=%3d:", i, cp->count);
            for (j = 0; j < cp->size; j++) printf(" %d", cp->data[j]);
            printf("\n");
        }
    }
}

int main()
{
    CP *hash_table[HASH_SIZE] = { 0 };
    char buf[BUF_SIZE];
    int data[DATA_SIZE];
    while (fgets(buf, sizeof buf, stdin)) {
        char *p = buf, *q;
        int i, hash = 0;
        for (i = 0; i < DATA_SIZE; i++) {
            data[i] = (int) strtol(p, &q, 10);
            if (p == q) break;
            hash += data[i];
            p = q;
        }
        add(hash_table, hash % HASH_SIZE, data, i);
    }
    print(hash_table, HASH_SIZE);
    return 0;
}

コード:

1 3 5 7 8 12
1 2 3 4 7 8 10 12
1 3 5 7 9 12
1 3 5 7 8 12
1 4 6 7 9 10 12
1 4 5 8 9 10 12

コード:

hash= 36: count=  2: 1 3 5 7 8 12
hash= 37: count=  1: 1 3 5 7 9 12
hash= 47: count=  1: 1 2 3 4 7 8 10 12
hash= 49: count=  1: 1 4 6 7 9 10 12
hash= 49: count=  1: 1 4 5 8 9 10 12

コード:

               +------+
hash_table[35] | NULL |          +--> 1 3 5 7 8 12
               +------+   +------|-----------------------------+
hash_table[36] |   *----->| data:*, size:6, count:2, next:NULL |
               +------+   +------------------------------------+
hash_table[37] |   *----->| data:*, size:6, count:1, next:NULL |
               +------+   +------|-----------------------------+
hash_table[38] | NULL |          +--> 1 3 5 7 9 12
               +------+
               | NULL |          +--> 1 2 3 4 7 8 10 12
               +------+   +------|-----------------------------+
hash_table[47] |   *----->| data:*, size:8, count:1, next:NULL |
               +------+   +------------------------------------+
hash_table[48] | NULL |          
               +------+   +------------------------------------+    +------------------------------------+
hash_table[49] |   *----->| data:*, size:7, count:1, next: *------> | data:*, size:7, count:1, next:NULL |
               +------+   +------+-----------------------------+    +------|-----------------------------+
hash_table[50] | NULL |          +--> 1 4 6 7 9 10 12                      +--> 1 4 5 8 9 10 12
               +------+

コード:

#include <stdio.h>
#include <stdlib.h>
 
#define HASH_SIZE  997
#define BUF_SIZE   1000
#define DATA_SIZE  500
 
typedef struct CP {
    int *data;
    int size;
    int count;
    struct CP *next;
} CP;
 
CP *alloc_cp(const int *data, int size)
{
    CP *cp = malloc(sizeof(CP));
    cp->data = malloc(sizeof(int) * size);
    memcpy(cp->data, data, sizeof(int) * size);
    cp->size = size;
    cp->count = 1;
    cp->next = NULL;
    return cp;
}
 
int comp(const CP *cp, const int *data, int size)
{
    int i;
    if (cp->size != size) return 1;
    for (i = 0; i < size; i++)
        if (cp->data[i] != data[i]) return 1;
    return 0;
}
 
int hash(const int *data, int size)
{
    int val = 0, i;
    for (i = 0; i < size; i++)
        val = val * 9 + data[i];
    return val % HASH_SIZE;
}

void add(CP **hash_table, int *data, int size)
{
    CP **p = &hash_table[hash(data, size)];
    while (*p && comp(*p, data, size)) p = &(*p)->next;
    if (*p)
        (*p)->count++;
    else
        *p = alloc_cp(data, size);
}
 
void print(CP **hash_table, int size)
{
    int i, j;
    CP *cp;
    for (i = 0; i < size; i++) {
        for (cp = hash_table[i]; cp; cp = cp->next) {
            printf("hash=%3d: count=%3d:", i, cp->count);
            for (j = 0; j < cp->size; j++) printf(" %d", cp->data[j]);
            printf("\n");
        }
    }
}
 
int main()
{
    CP *hash_table[HASH_SIZE] = { 0 };
    char buf[BUF_SIZE];
    int data[DATA_SIZE];
    while (fgets(buf, sizeof buf, stdin)) {
        char *p = buf, *q;
        int i;
        for (i = 0; i < DATA_SIZE; i++) {
            data[i] = (int) strtol(p, &q, 10);
            if (p == q) break;
            p = q;
        }
        add(hash_table, data, i);
    }
    print(hash_table, HASH_SIZE);
    return 0;
}

コード:

1 3 5 7 8 12
1 2 3 4 7 8 10 12
1 3 5 7 9 12
1 3 5 7 8 12
1 4 6 7 9 10 12
1 4 5 8 9 10 12
1 2 3 4
1 4 5

コード:

hash=122: count=  1: 1 4 5
hash=277: count=  2: 1 3 5 7 8 12
hash=286: count=  1: 1 3 5 7 9 12
hash=314: count=  1: 1 2 3 4 7 8 10 12
hash=382: count=  1: 1 4 6 7 9 10 12
hash=532: count=  1: 1 4 5 8 9 10 12
hash=922: count=  1: 1 2 3 4

コード:

int hash(const int *data, int size)
{
    unsigned int val = 0, i;
    for (i = 0; i < size; i++)
        val = val * 9 + data[i];
    return val % HASH_SIZE;
}

コード:

$ gcc -o hash hash.c

$ ./hash
123
145
123
123
^D
hash=123: count=  3: 123
hash=145: count=  1: 145

$ cat >data.txt
123
145
168
^D

$ ./hash <data.txt
hash=123: count=  1: 123
hash=145: count=  1: 145
hash=168: count=  1: 168

$ ./hash <data.txt >result.txt

$ cat result.txt
hash=123: count=  1: 123
hash=145: count=  1: 145
hash=168: count=  1: 168

$ ls -l
total 22
-rw-r--r-- 1 kazuma None    12 Oct 31 02:24 data.txt
-rw-r--r-- 1 kazuma None  1786 Oct 31 02:24 hash.c
-rwxr-xr-x 1 kazuma None 14508 Oct 31 02:25 hash.exe
-rw-r--r-- 1 kazuma None    75 Oct 31 02:27 result.txt

$

コード:

$ ./hash
1 2 3
1 4 5
1 2 3
1 2 3
^D
hash=102: count=  3: 1 2 3
hash=122: count=  1: 1 4 5

$

コード:

                | NULL |     struct CP
                +------+     +-----------+  +------+------+------+
hash_table[136] l   * ------>| data:  *---->|   1  |   3  |  28  |
                +------+     | size:  3  |  +------+------+------+
                | NULL |     | count: 1  |
                +------+     | next:  *  |
                | NULL |     +--------|--+
                +------+              V
                | NULL |     +-----------+  +------+------+------+
                             | data:  *---->|   1  |   4  |  19  |
                             | size:  3  |  +------+------+------+
                             | count: 1  |
                             | next:  *  |
                             +--------|--+
                                      V
                             +-----------+  +------+------+------+
                             | data:  *---->|   1  |   5  |  10  |
                             | size:  3  |  +------+------+------+
                             | count: 1  |
                             | next: NULL|
                             +-----------+

コード:

#include <stdio.h>
#include <stdlib.h>
 
#define HASH_SIZE  997　　　//　ハッシュのエントリ数を決めている
#define BUF_SIZE   1000　　　//　ここで何を宣言しているのかが分かりません　
#define DATA_SIZE  500　　　　//　数列の最大サイズ　
 
typedef struct CP {               // 構造体CPの定義　
    int *data;　　　　　　　　　　　//数列の中身　　　　　　　　　　
    int size;　　　　　　　　　　　　//数列のサイズ
    int count;　　　　　　　　　　　//同じ数列が出現した回数
    struct CP *next;　//同エントリ内に複数CPを格納する際に連結させる
} CP;
 
CP *alloc_cp(const int *data, int size)　//上の構造体の初期設定
{
    CP *cp = malloc(sizeof(CP));
    cp->data = malloc(sizeof(int) * size);
    memcpy(cp->data, data, sizeof(int) * size);
    cp->size = size;
    cp->count = 1;
    cp->next = NULL;
    return cp;
}
 
int comp(const CP *cp, const int *data, int size) //新しく求められたCPを既出のCPと比較している。等しくないときに１を返す。


{
    int i;
    if (cp->size != size) return 1;　//左辺と右辺、どちらが新しいCPでどちらが既出のCPなのでしょうか？またここで、既出のsize全ての種類に対して比較を行っているのでしょうか？
   

 for (i = 0; i < size; i++)
        if (cp->data[i] != data[i]) return 1;//上と同じく、どちらが既出のdataでどちらが新しく求めたCPか分かりません。また、既出の全てのdata[i]と比較を行っているのでしょうか？
  

  return 0;
}
 
int hash(const int *data, int size)　//hash値の計算
{
    int val = 0, i;
    for (i = 0; i < size; i++)
        val = val * 9 + data[i];
    return val % HASH_SIZE;
}
 
void add(CP **hash_table, int *data, int size)
{
    CP **p = &hash_table[hash(data, size)];　//hash(data, size)で求めたハッシュ値を添字とするハッシュテーブルのアドレスを**pとする。


    while (*p && comp(*p, data, size)) p = &(*p)->next;　//ここの部分が分かりません。*pは何を示しているのでしょうか？下で(*p)->count++とあるところから、新しく求められた数列を示す為のポインタなのではないかと思いました。また、whileの中で何をしているのかよく分かりません。



    if (*p)　　　//これはどのような状態なのでしょうか？下から推測すると同じ数列が現れたかどうかという条件文ではないかと思うのですが、なぜそのような意味を持つのか分かりません。



  (*p)->count++;　　//同じ数列が現れたのでインクリメント
   

 else
        *p = alloc_cp(data, size);　//新しい種類の数列だったので、新しく追加する。


}
 
void print(CP **hash_table, int size)
{[code=c]

コード:

#include <stdio.h>
#include <stdlib.h>
 
#define HASH_SIZE  997    // ハッシュのエントリ数
#define BUF_SIZE   1000   // ここで何を宣言しているのかが分かりません　
  // 入力行バッファのサイズ。fgets により最大998文字 + '\n' + '\0' が入る
#define DATA_SIZE  500    //　数列の最大サイズ　
 
typedef struct CP {       // 構造体CPの定義　
    int *data;            // 数列の中身　　　　　　　　　　
    int size;             // 数列のサイズ
    int count;            // 同じ数列が出現した回数
    struct CP *next;      // 同エントリ内に複数CPを格納する際に連結させる
} CP;
 
CP *alloc_cp(const int *data, int size)  // 上の構造体の初期設定
{
    CP *cp = malloc(sizeof(CP));
    cp->data = malloc(sizeof(int) * size);
    memcpy(cp->data, data, sizeof(int) * size);
    cp->size = size;
    cp->count = 1;
    cp->next = NULL;
    return cp;
}
 
// ある一つの構造体 CP に記録されている数列と、新規入力の数列(data, size) を比較
int comp(const CP *cp, const int *data, int size)
{
    int i;
    if (cp->size != size)      // cp->size は既出、size は新規入力
        return 1;                  // サイズが不一致なので比較を終了
    for (i = 0; i < size; i++)        // 一つの数列全体を見ようとするが、
        if (cp->data[i] != data[i]) return 1; // 不一致が見つかると終了
    return 0;  // 数列全体が一致したので差ゼロを返す。
}
 
int hash(const int *data, int size)　// hash値の計算
{
    unsigned int val = 0, i;       // val が unsigned でないと、
    for (i = 0; i < size; i++)
        val = val * 9 + data[i];   // overflow で val が負になることがある
    return val % HASH_SIZE;
}
 
void add(CP **hash_table, int *data, int size)
{
    CP **p = &hash_table[hash(data, size)];
    // hash(data, size)で求めたハッシュ値を添字とするハッシュテーブルの
    // エントリのアドレスを p に入れることにより、p がエントリを指す。
    // *p はエントリであり、NULL であるか、あるいは最初の構造体 CP を指す。

    while (*p && comp(*p, data, size))
        p = &(*p)->next;
    // *p がある構造体を指していて、かつ、その構造体の持つ数列が新規入力の
    // 数列(data, size) と不一致なら、*p が次の構造体を指すようにする
    // *p が NULL なら、どの構造体も指していないのでループを抜ける。

    if (*p)  // *p がある構造体を指していれば (*p が NULL でなければ)
        (*p)->count++;  // 同じ数列が現れたのでインクリメント
    else
        *p = alloc_cp(data, size);　// 新しい種類の数列だったので、新規追加
}
 
void print(CP **hash_table, int size)
{
    int i, j;
    CP *cp;                      // cp はある構造体を指すポインタ
    for (i = 0; i < size; i++) {
        for (cp = hash_table[i]; cp; cp = cp->next) {
            // forループの継続条件は cp がある構造体を指していること。
            // すなわち、cp が NULL でないこと
            // cp を単独で書く代わりに cp != NULL または cp != 0 でも同じ
            printf("hash=%3d: count=%3d:", i, cp->count);
            for (j = 0; j < cp->size; j++) printf(" %d", cp->data[j]);
            printf("\n");
        }
    }
}
 
int main()
{
    CP *hash_table[HASH_SIZE] = { 0 };  // 全部の要素を NULL で初期化
    char buf[BUF_SIZE];     // 行入力バッファ
    int data[DATA_SIZE];
    while (fgets(buf, sizeof buf, stdin)) {
        char *p = buf, *q;  // p は buf の先頭の文字を指す
        int i;
        for (i = 0; i < DATA_SIZE; i++) {
            data[i] = (int) strtol(p, &q, 10);
            // p は buf 内のある文字を指す。
            // strtol は、p の指すところから始まる文字列を見て
            // 空白を読み飛ばし、数字の列(10進)を数値に変換して返す。
            // 数字でない文字のアドレスを q に返す。
            // 数値に変換できない場合、q には、元の p の値を返す。
            if (p == q) break; // 行末は数値に変換できないのでループ終了
            p = q;  // 次の数値を求めるために p を更新
        }
        add(hash_table, data, i);
    }
    print(hash_table, HASH_SIZE);
    return 0;
}

コード:

　
for(i=i;i>0;i--){
		printf("%ld\t",max_point -> pathlist[i]);
			
		}
		printf("%ld\n",max_point -> pathlist[0]);

コード:

　
for(i=i;i>0;i--){
		printf("あ%ld\t",max_point -> pathlist[i]);
			
		}
		printf("い%ld\n",max_point -> pathlist[0]);