K-hidden算法代码（python,c++,c#）

K-hidden算法

 

输入：长度为m的二进制串x（m<10000）;

输出：x的负数据库NDB

实现K-hidden算法，由x生成NDB，要求对二进制串输入具有普适性

python代码：

import random as rd

NDBs = []

# 输入隐藏串
print('请输入隐藏串：')
s = input().strip()

# 验证隐藏串的格式
while s[0] != "1":
    print('输入隐藏串错误，应该以1开头，请重新输入：')
    s = input().strip()

m = len(s)
print("隐藏串s的长度是{}".format(m))

# 输入常量K
print("请输入常量K(K<隐藏串长度m)")
K = int(input())
while K >= m:
    print("K超过隐藏串长度，请重新输入常量K：")
    K = int(input())

print("请输入控制NDB的大小参数r(推荐6.5)")
r = float(input())

print("请输入概率参数,长度为{}，请保证所有概率和为1".format(K))
p = list(map(float, input().split()))

print("二进制串为{}, 串长为{}\n常量K为{}, 控制参数r为{}\n概率参数为{}".format(s, m, K, r, p))

# NDB总数
N = int(float(m) * r)
print("NDB中的记录总数为{}".format(N))

# 生成Q
Q = [sum(p[:i+1]) for i in range(K)]

ndbs = 0
count_dic = dict()
while ndbs < N:
    rnd = rd.random()
    for i in range(1, K + 1):
        if Q[i - 1] <= rnd < Q[i]:
            place = set(rd.sample(list(range(m)), K))
            dif_place = set(range(m)) - place

            # 生成负数据库数据
            elem = ''.join(['*' if sc in dif_place else s[sc] for sc in range(m)])

            NDBs.append(elem)
            break
    ndbs += 1
    print("记录第{}条数据".format(ndbs))

print(NDBs)

# 将负数据库写入文件
with open("ndbs.txt", "w") as f:
    for data in NDBs:
        f.write(data + '\n')

 

c++代码：

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstdlib>
#include <ctime>
#include <algorithm>

using namespace std;

int main() {
    vector<string> NDBs;
    string s;

    // 输入隐藏串
    cout << "请输入隐藏串：" << endl;
    getline(cin, s);

    // 验证隐藏串的格式
    while (s[0] != '1') {
        cout << "输入隐藏串错误，应该以1开头，请重新输入：" << endl;
        getline(cin, s);
    }

    int m = s.length();
    cout << "隐藏串s的长度是" << m << endl;

    // 输入常量K
    int K;
    cout << "请输入常量K(K<隐藏串长度m)：" << endl;
    cin >> K;
    while (K >= m) {
        cout << "K超过隐藏串长度，请重新输入常量K：" << endl;
        cin >> K;
    }

    cout << "请输入控制NDB的大小参数r(推荐6.5)：" << endl;
    float r;
    cin >> r;

    cout << "请输入概率参数,长度为" << K << "，请保证所有概率和为1：" << endl;
    vector<float> p(K);
    for (int i = 0; i < K; i++) {
        cin >> p[i];
    }

    cout << "二进制串为" << s << ", 串长为" << m << endl;
    cout << "常量K为" << K << ", 控制参数r为" << r << endl;
    cout << "概率参数为";
    for (int i = 0; i < K; i++) {
        cout << p[i] << " ";
    }
    cout << endl;

    // NDB总数
    int N = static_cast<int>(m * r);
    cout << "NDB中的记录总数为" << N << endl;

    // 生成Q
    vector<float> Q(K);
    float sum = 0;
    for (int i = 0; i < K; i++) {
        sum += p[i];
        Q[i] = sum;
    }

    int ndbs = 0;
    srand(time(0));
    while (ndbs < N) {
        float rnd = static_cast<float>(rand()) / RAND_MAX;
        for (int i = 1; i <= K; i++) {
            if (Q[i - 1] <= rnd && rnd < Q[i]) {
                vector<int> place(m);
                for (int j = 0; j < m; j++) {
                    place[j] = j;
                }
                for (int j = 0; j < K; j++) {
                    int index = rand() % m;
                    swap(place[index], place[m - 1 - j]);
                }

                vector<int> dif_place(m - K);
                int index = 0;
                for (int j = 0; j < m; j++) {
                    bool flag = false;
                    for (int k = 0; k < K; k++) {
                        if (place[k] == j) {
                            flag = true;
                            break;
                        }
                    }
                    if (!flag) {
                        dif_place[index] = j;
                        index++;
                    }
                }

                // 生成负数据库数据
                string elem = "";
                for (int j = 0; j < m; j++) {
                    if (find(dif_place.begin(), dif_place.end(), j) != dif_place.end()) {
                        elem += "*";
                    } else {
                        elem += s[j];
                    }
                }

                NDBs.push_back(elem);
                break;
            }
        }
        ndbs += 1;
        cout << "记录第" << ndbs << "条数据" << endl;
    }

    // 将负数据库写入文件
    ofstream file("ndbs.txt");
    if (!file) {
        cout << "无法打开文件" << endl;
        return 0;
    }

    for (int i = 0; i < NDBs.size(); i++) {
        file << NDBs[i] << endl;
    }
    file.close();

    return 0;
}

 

c语言代码：

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

#define MAX_SIZE 10000

int main() {
    char** NDBs;
    char s[MAX_SIZE];

    // 输入隐藏串
    printf("请输入隐藏串：\n");
    fgets(s, MAX_SIZE, stdin);

    // 验证隐藏串的格式
    while (s[0] != '1') {
        printf("输入隐藏串错误，应该以1开头，请重新输入：\n");
        fgets(s, MAX_SIZE, stdin);
    }

    int m = strlen(s);
    printf("隐藏串s的长度是%d\n", m);

    // 输入常量K
    int K;
    printf("请输入常量K(K<隐藏串长度m)：\n");
    scanf("%d", &K);
    while (K >= m) {
        printf("K超过隐藏串长度，请重新输入常量K：\n");
        scanf("%d", &K);
    }

    printf("请输入控制NDB的大小参数r(推荐6.5)：\n");
    float r;
    scanf("%f", &r);

    printf("请输入概率参数,长度为%d，请保证所有概率和为1：\n", K);
    float p[K];
    for (int i = 0; i < K; i++) {
        scanf("%f", &p[i]);
    }

    printf("二进制串为%s, 串长为%d\n常量K为%d, 控制参数r为%.2f\n概率参数为\n", s, m, K, r);
    for (int i = 0; i < K; i++) {
        printf("%.2f ", p[i]);
    }
    printf("\n");

    // NDB总数
    int N = (int)(m * r);
    printf("NDB中的记录总数为%d\n", N);

    // 生成Q
    float Q[K];
    float sum = 0;
    for (int i = 0; i < K; i++) {
        sum += p[i];
        Q[i] = sum;
    }

    int ndbs = 0;
    int count_dic[MAX_SIZE] = {0};
    srand(time(0));

    NDBs = (char**)malloc(N * sizeof(char*));
    for (int i = 0; i < N; i++) {
        NDBs[i] = (char*)malloc((m + 1) * sizeof(char));
    }

    while (ndbs < N) {
        float rnd = (float)rand() / RAND_MAX;
        for (int i = 0; i < K; i++) {
            if (Q[i - 1] <= rnd && rnd < Q[i]) {
                int place[K];
                for (int j = 0; j < m; j++) {
                    place[j] = j;
                }
                for (int j = 0; j < K; j++) {
                    int index = rand() % m;
                    int temp = place[index];
                    place[index] = place[m - 1 - j];
                    place[m - 1 - j] = temp;
                }

                int dif_place[m - K];
                int index = 0;
                for (int j = 0; j < m; j++) {
                    int flag = 0;
                    for (int k = 0; k < K; k++) {
                        if (place[k] == j) {
                            flag = 1;
                            break;
                        }
                    }
                    if (!flag) {
                        dif_place[index] = j;
                        index++;
                    }
                }

                // 生成负数据库数据
                char elem[MAX_SIZE];
                for (int j = 0; j < m; j++) {
                    if (dif_place[j] == 1) {
                        elem[j] = '*';
                    } else {
                        elem[j] = s[j];
                    }
                }
                elem[m] = '\0';

                strcpy(NDBs[ndbs], elem);
                break;
            }
        }
        ndbs += 1;
        printf("记录第%d条数据\n", ndbs);
    }

    // 将负数据库写入文件
    FILE *file = fopen("ndbs.txt", "w");
    if (file == NULL) {
        printf("无法打开文件\n");
        return 0;
    }

    for (int i = 0; i < N; i++) {
        fprintf(file, "%s\n", NDBs[i]);
    }
    fclose(file);

    for (int i = 0; i < N; i++) {
        free(NDBs[i]);
    }
    free(NDBs);

    return 0;
}