精华内容
下载资源
问答
  • Up 主真的就手算挖币了。 手算一轮(32 字节)用时 16 分 45 秒,一次比特币哈希是 64 字节重复 64 轮。也就是手工哈希速率 0.67 hash/天,大概一天可以挖出 0.000004 枚 btc(当前价值1.4元人民币)。 当然这...

    最近网上流传一张图,有人提到了解比特币算法,挖币无非就是在解一条方程,想要手工算哈希,挖比特币。

    那么真的可以手工算 Hash 挖比特币吗?有一位Up 主真的就手算挖币了。

    手算一轮(32 字节)用时 16 分 45 秒,一次比特币哈希是 64 字节重复 64 轮。也就是手工哈希速率 0.67 hash/天,大概一天可以挖出 0.000004 枚 btc(当前价值1.4元人民币)。

    当然这个博主计算能力还是可以的,但是手工计算可没有人给你发区块奖励哦~
    在这里插入图片描述

    其实现在比特币挖币获取越来越简单了,比特币通过矿机计算能力运算获取比特币,全网统一把矿机中的算.力集中整合到一块,挖出来的比特币 根据你提供的算.力 统一分配!一部手机就可以操作。
    在这里插入图片描述

    展开全文
  • 运用的哈希的算法,将每一的值计算成一个哈希值,再将m段的字符串哈希值存在map中与m比较,然后再去掉子串最前面的L长度的哈希值,加上子串后L长度的哈希值,以此类推。 #include <bits/stdc++.h> using ...

    题目链接

    题意:

    给定数字L、M以及字符串S,问S有多少长度为L*M的子串满足分成M段L长度的字符串并且每段不完全相同。

    思路:

    运用的哈希的算法,将每一位的值计算成一个哈希值,再将m段的字符串哈希值存在map中与m比较,然后再去掉子串最前面的L长度的哈希值,加上子串后L长度的哈希值,以此类推。
    #include <bits/stdc++.h>
    using namespace std;
    
    #define ull unsigned long long
    const int N = 1e5+10;
    const int seed = 31;
    char s[N];
    ull base[N];
    ull h[N];
    
    ull Hash(int l, int r)
    {
    	return h[r] - h[l-1]*base[r-l+1];
    }
    
    int main()
    {		
    	base[0] = 1;
    	for(int i = 1; i < N; i++) {
    		base[i] = base[i-1]*seed; 
    	}
    	int l, m;
    	while(~scanf("%d %d", &m, &l)){
    		scanf("%s", s+1);
    		int len = strlen(s+1);
    		for(int i = 1; i <= len; i++) {
    			h[i] = h[i-1]*seed+s[i]-'a';
    		}
    		int ans = 0;
    		for(int i = 1; i <= l && i + l*m <= len; i++) {
    			map<ull,int>cc;
    			for(int j = i; j <= i+l*m-1; j += l) {
    				ull x = Hash(j,j+l-1);
    				cc[x]++;
    			}
    			if((int)cc.size()==m) {
    				ans++;
    			}
    			for(int j = i + l*m; j + l - 1 <= len; j += l) {
    				ull x = Hash(j,j + l-1);
    				cc[x]++;
    				x = Hash(j-l*m,j-l*m+l-1);
    				cc[x]--;
    				if(cc[x]==0) cc.erase(x);
    				if((int)cc.size()==m) {
    					ans++;
    				}
    			}
    		}
    		printf("%d\n", ans);
    	}
    	return 0;
    }
    
    展开全文
  • 题意 对一个极长的数组进性N次操作,操作四种。 初始指针指向0,所有数组元素都是0. 两种操作左右移动指针。 两种操作加减指针指向的元素。...定义pre(i,j)pre(i,j)pre(i,j)表示第i次操作后,数组前j哈希值。(假

    https://atcoder.jp/contests/arc099/tasks/arc099_d?lang=en

    题意

    对一个极长的数组进性N次操作,操作有四种。

    初始指针指向0,所有数组元素都是0.

    两种操作左右移动指针。

    两种操作加减指针指向的元素。

    问有多少子区间的操作,【单独执行】的结果,等于所有操作执行的结果。

    思路

    因为实际操作的数组长度和n有关,顶多25000。并且数字种类不会很多,可以考虑哈希。

    定义pre(i,j)pre(i,j)表示第i次操作后,数组前j位的哈希值。(假设数组长度是M)

    整个数组在第i次操作后的哈希值可以这样计算:
    h(i)=pre(i,M)=j=0M1A[i][j](Base)j h(i) = pre(i, M) = \sum_{j = 0}^{M - 1} A[i][j] * (Base)^j
    实际上我们不需要遍历数组来得到pre(i,M)pre(i, M),写出公式是为了方便下面理解,为方便直接记作h(i)h(i)

    定于sign(i)sign(i)表示第i次操作的符号:
    $$

    \begin{equation}
    sign(i)=\left{
    \begin{aligned}
    0 & , \ S_i \ is \ < or \ > \
    1 & , \ S_i \ is \ + \
    -1 & , \ S_i \ is \ -
    \end{aligned}
    \right.
    \end{equation}
    $$
    定义p(i)p(i)表示第i次操作以后,当前的下标。

    由于每次操作至多使得一个数字+1,并且我们知道每次改变的位置。

    根据第一个公式,可以列出h(i)h(i)的递推式:
    h(i)=h(i1)+sign(i)×(Base)p(i)h(i)=h(0)+k=1isign(k)×(Base)p(k) h(i) = h(i - 1) + sign(i) \times (Base)^{p(i)} \\ h(i) = h(0) + \sum_{k = 1}^{i} sign(k) \times (Base)^{p(k)}
    可以发现,每一步操作以后的哈希值,是一种类似前缀和的形式。

    那么可以容易联想到整个问题要求统计的条件就是:
    [h(R)h(L1)==h(N)] [h(R) - h(L - 1) == h(N)]
    但这样是不对的。因为题目还有一个隐含的条件是【单独执行】。

    【单独执行】意味着, 你取出来的操作区间,也要从p(0)p(0)开始移动指针。

    但显然,h(R)h(L1)h(R) - h(L - 1)这个区间的操作结果,是从p(L1)p(L - 1)开始的。

    那么需要考虑的就是,如何让这个区间所有操作的相对位置,都偏移到和从p(0)p(0)等价。

    这就可以借助幂的性质:
    [h(R)h(L1)(Base)p(L1)p(0)==h(N)] [\frac{h(R) - h(L - 1)}{(Base)^{p(L - 1) - p(0)}} == h(N)]
    可以这样理解:h(i)h(i)就是一堆幂的和,指数代表了这些操作的位置,那只要每个幂的指数都减去一个偏移量,就相当于所有操作都偏移过去了。

    于是我们可以把问题转化成统计:
    [h(R)==h(N)×(Base)p(L1)p(0)+h(L1)]r=1Nl=0r1[h(r)==h(N)×(Base)p(l)p(0)+h(l)] \sum \sum [h(R) == h(N) \times (Base)^{p(L - 1) - p(0)} + h(L - 1)] \\ \sum_{r = 1}^{N} \sum_{l = 0}^{r - 1} [h(r) == h(N) \times (Base)^{p(l) - p(0)} + h(l)]
    这一步可以用map去统计。

    负数下标如何处理

    p(i)p(i) 很容易变成负的,那么我的处理就是再记一个逆元数组q[i]

    因为就算指数是负数的,也不影响我们最初哈希值的定义(取模意义下):
    h(i)=pre(i,M)=j=0M1A[i][j](Base)j h(i) = pre(i, M) = \sum_{j = 0}^{M - 1} A[i][j] * (Base)^j
    可以看我代码中对这个做了讨论,把对应的逆元取出来即可。

    inline ll bpow(int i, int j) {
        if (i < 0) {
            return q[-i][j];
        } else {
            return b[i][j];
        }
    }
    

    为什么单哈希不够

    假设数组每个数h[i]在理想状态下,出错的概率是:1MOD\frac{1}{MOD}

    那么全部正确的概率是:(11MOD)N(1 - \frac{1}{MOD})^N

    代入N=250000 MOD = 1e9+7, 算出概率是:99.975%

    看上去很高,只有0.024%+的概率至少出现一个数字出错。

    而这是基于假设出错概率XMOD\frac{X}{MOD} 中X=1的时候,实际情况很难那么理想。

    如果X = 250(比较坏的时候,实际我觉得可能是10左右),算出概率就下降很多了:93.941%

    这是还没有考虑80多组测试样例的单组正确率。

    我们考虑X = 10, 跑50组大样例,正确率:88.25%

    所以得双哈希降低出错率。

    代码

    #define fi first
    #define se second
    
    using pii = pair<ll, ll>;
    const ll base[2] = {1000003ll, 1000033ll};
    const ll mod[2] = {1000000007ll, 1000000009ll};
    ll b[MAXN][2];
    ll q[MAXN][2];
    
    void make_base(int size) {
        b[0][0] = 1;
        b[0][1] = 1;
        for (int i = 1; i <= size; ++i) {
            b[i][0] = b[i - 1][0] * base[0] % mod[0];
            b[i][1] = b[i - 1][1] * base[1] % mod[1];
        }
        q[1][0] = 486802543; //inv(b[1][0], mod[0]);
        q[1][1] = 224303600; //inv(b[1][1], mod[1]);
        for (int i = 2; i <= size; ++i) {
            q[i][0] = q[i - 1][0] * q[1][0] % mod[0];
            q[i][1] = q[i - 1][1] * q[1][1] % mod[1];
        }
    }
    
    int n;
    char s[MAXN];
    int p[MAXN];
    pii h[MAXN];
    map<pii, ll> cnt;
    
    inline ll bpow(int i, int j) {
        if (i < 0) {
            return q[-i][j];
        } else {
            return b[i][j];
        }
    }
    
    void addop(int i, int sign) {
        h[i].fi = (h[i].fi + mod[0] + sign * bpow(p[i], 0)) % mod[0];
        h[i].se = (h[i].se + mod[1] + sign * bpow(p[i], 1)) % mod[1];
    }
    
    void solve(int kaseId = -1) {
        cin >> n >> (s + 1);
        make_base(n);
        p[0] = 0;
        h[0] = {0, 0};
    
        for (int i = 1; i <= n; ++i) {
            p[i] = p[i - 1];
            h[i] = h[i - 1];
            if (s[i] == '<') p[i] = p[i] - 1;
            if (s[i] == '>') p[i] = p[i] + 1;
            if (s[i] == '+') addop(i, 1);
            if (s[i] == '-') addop(i, -1);
        }
    
        ll ans = 0;
        cnt[h[n]] = 1;
        for (int i = 1; i <= n; ++i) {
            if (cnt.count(pii(h[i])) > 0) ans += cnt[pii(h[i])];
            ll v1 = (h[n].fi * bpow(p[i] - p[0], 0) + h[i].fi) % mod[0];
            ll v2 = (h[n].se * bpow(p[i] - p[0], 1) + h[i].se) % mod[1];
            cnt[pii(v1, v2)]++;
        }
        cout << ans << endl;
    }
    
    展开全文
  • 51Nod - 1682 哈希 + 乱搞

    2017-02-14 12:05:35
    数定义为所有值从小到大排序后排在正中间的那个数,如果值有偶数个,通常取最中间的两个数值的平均数作为中数。 现在有n个数,每个数都是独一无二的,求出每个数在多少个包含其的区间中是中数。 ...

    题意:

    中位数定义为所有值从小到大排序后排在正中间的那个数,如果值有偶数个,通常取最中间的两个数值的平均数作为中位数。

    现在有n个数,每个数都是独一无二的,求出每个数在多少个包含其的区间中是中位数。


    Input
    第一行一个数n(n<=8000)
    第二行n个数,0<=每个数<=10^9
    Output
    N个数,依次表示第i个数在多少包含其的区间中是中位数。
    Input示例
    5
    1 2 3 4 5
    Output示例
    1 2 3 2 1

    思路:

    弄清楚一点,如果x是这个区间的中位数,那说明该区间内有一半的数比x大,有一半的数比x小。
    对于每个数x,我们先存下x左边的区间内大于x的数与小于x的数的差的出现次数,然后再看x右边的数,遍历到某个位置时大于x的数-小于x的数的个数的差为y,那么这半个区间只要和之前存下来的大小数差为-y的区间组合,就可以保证x是该区间的中位数,之前已经记录下x左边差为-y的各有多少个,然后右边查询即可。

    代码:

    #include <cstdio>
    #include <cstring>
    #include <cstdlib>
    #include <algorithm>
    using namespace std;
    typedef long long ll;
    const int MAXN = 8005;
    
    int a[MAXN], Hash[MAXN * 2], ans[MAXN];
    
    int main() {
    	int n;
    	scanf("%d", &n);
    	for (int i = 1; i <= n; i++)
    		scanf("%d", &a[i]);
    	for (int i = 1; i <= n; i++) {
    		int cnt = 0;
    		memset(Hash, 0, sizeof(Hash));
    		for (int j = i; j >= 1; j--) {
    			if (a[j] > a[i]) ++cnt;
    			if (a[j] < a[i]) --cnt;
    			//printf("%d : %d\n", i, cnt);
    			Hash[8000 + cnt]++;
    		}
    		cnt = 0;
    		for (int j = i; j <= n; j++) {
    			if (a[j] > a[i]) --cnt;
    			if (a[j] < a[i]) ++cnt;
    			ans[i] += Hash[8000 + cnt];
    		}
    	}
    	for (int i = 1; i <= n; i++)
    		printf("%d%c", ans[i], i == n ? '\n' : ' ');
    	return 0;
    }
    


    展开全文
  • 如果 s 串和 t 串从第一到第 x 是相同的,那么再看 t 串从 x + 1 开始和 s 串的前缀最多有多少相同长度,那么 ans 就可以加上多少。 比较字符串我们可以用哈希值来做,查找最长的相同长度可以用二分法。 代码 ...
  • 位图和字符串是放在一起的,有等价来看,就看你是用字节操作当字符串认还是操作当来看,当来看...只要登录了就给打个标记,几月几日登录过,一年统计有多少个1就可以 了 链接2号库 把userid为1的用户记录...
  • 题目大意对于一个字符集大小为C的字符串P,我们可以将任意两种字符在P中的位置进行互换,例如P=abcba,我们交换a,b就变为bacab...解题思路每个为与前一个相同颜色的位置差,对这个哈希即可判断是否同构,特殊处理
  • BTC-挖矿难度调整

    2021-02-23 20:02:51
    比特币所使用的哈希算法是SHA-256这个产生的哈希值256的所以整个的输出空间是2的256次方个可能的取值,调整这个比例通俗的说就是这个哈希值前面要有多少个0比如说256个哈希值要合法的区块要求算出来的哈希前面要有
  • 调整比例通俗地来说就是,哈希值前面有多少个零,假如是256哈希值,要是合法的区块,前面至少有70个零,这只是通俗的说法。严格的话,还是按照定义去看这个问题。 挖矿难度跟目标域值成反比 difficulty_1_...
  • 要定义某一个前缀的哈希值,只要把字符串看成是一个PPP进制的数,那么每一的ASCII码就表示这一的数字是多少。那么上面的例子的字符串哈希值(即对应的十进制的数值)为: a×P4+b×P3+c×P2
  • 题解:首先双哈希存下来,枚举删除哪一,枚举每一个字符串删除后的哈希值,对哈希值排序之后看有多少个相同的,每组大小为n的相同字符串集对答案的贡献为$C_n^2$ #include <cstdio> #include <...
  • python OpenCV 图片相似度 5种算法

    万次阅读 多人点赞 2019-05-17 15:28:34
    哈希算法、差值哈希算法和感知哈希算法都是值越小,相似度越高,取值为0-64,即汉明距离中,64的hash值有多少不同。 三直方图和单通道直方图的值为0-1,值越大,相似度越高。 源代码如下: import cv2 import...
  • bzoj3555[Ctsc2014]企鹅QQ

    2019-09-24 19:48:07
    求出第i个字符串前j个字符的哈希值hs[i][j],然后枚举去掉所有字符串的第几,将去掉后的字符串的哈希值用hs数组直接算出,排序后检查没有相同的计入答案。 代码: 1 #include <cstdio> 2 #i...
  • 1.opencv常见的图像对比有5种,分别的理解是:值哈希算法、差值哈希算法和感知哈希算法都是值越小,相似度越高,取值为0-64,即汉明距离中,64的hash值有多少不同。 三直方图和单通道直方图的值为0-1,值越大,...
  • 无论哈希表中有多少数据,增删操作的时间复杂度都为O(1),相当于无须查找,直接定位对其操作。 (2)利用for循环遍历range(len(s)),此时i的范围为0到len(s)-1 (3)若数字不是最后一,且左小右大
  • stream-lib流式计算库

    2021-01-24 19:08:39
    HyperLogLog会计算每一个成员二进制位有多少个零,如果零的最大个数是n,则唯一数量就是2^n。算法中有两个关键点,首先,成员的必须是服从正态分布的,这一点可以通过哈希函数实现。stream-lib使用的是...
  • 以太坊中的Gas以及其设计原理

    千次阅读 2017-07-10 22:57:24
    计算一个Keccak256加密哈希值,每次计算散列时将需要30个气体,加上每256的6个气体的成本 数据被散列 可以通过Ethereum平台上的交易或合同执行的每个操作都需要一定数量的gas,与需要较少计算资源的操作相比,更多...
  • 定义二维数组huo[1000][1024],前者指第几位,后者是哈希的思想,若huo[x][y]=2则表示最右边的数为第x位时,异或为y的出现了两次,需要再定义一个hash数组,来保存前面出现的所有情况,再找有多少位的时候,用hash...
  • 小Q与进位制 - 分治FFT

    2018-09-12 18:35:10
    题目大意:有一种进制,第i的进位是baseibaseibase_i,然后现在给你一个数字a,问有多少数字不超过a,保证a有n且最高不为0,n≤120000n≤120000n\le120000。 题解:答案是:∑ni=1ai∏j≤ibj∑i=1nai∏j≤...
  • 题目地址:HDU 4901 这题没想到最后竟然可以做出来。。。。 这题用了两次DP,先从前往后求一次异或的。再从后往前求一次与运算的。...1:求异或的时候,定义二维数组huo[1000][1024],前者指...再找有多少位的时候,...
  • 图片相似度识别

    热门讨论 2013-03-06 13:36:24
    得到指纹以后,就可以对比不同的图片,看看64位中有多少位是不一样的。在理论上,这等同于计算"汉明距离"(Hammingdistance)。如果不相同的数据位不超过5,就说明两张图片很相似;如果大于10,就说明这是两张不同的...
  • JDK1.8 HashMap中hash的底层源码 今天面试问到了,HashMap中hash的实现方式,我开始一愣,hash不是自己都可以重写吗,我怎么知道,hash的实现方式。...JDK1.8只进行一次右移16异或运算,因为四次没有必要,而且
  • // 得到指纹以后,就可以对比不同的图片,看看64位中有多少位是不一样的。 return hashCode.toString(); } public static void main(String args[]){ String srcFile = "E:\\src.jpg"; ...
  • RFID数据流近似去重

    2015-10-06 23:50:24
    在下图中,k=3,且两个哈希函数选中同一个位置(从左边数第五)。 在判断a是否属于这个集合时,我们对a应用k次哈希函数,如果所有hi(a)的位置都是1(1≤i≤k),那么我们就认为a是集合中的元素,否则就认为a不是...
  • 8.3 一个函数可以有多少个参数? 8.4 什么是内部函数? 8.5 如果一个函数没有返回值,是否需要加入return语句? 8.6 怎样把数组作为参数传递给函数? 8.7 在程序退出main()函数之后,还有可能执行一部分...
  • C语言编程要点

    2017-09-18 00:10:37
    8.3. 一个函数可以有多少个参数? 130 8.4. 什么是内部函数? 131 8.5. 如果一个函数没有返回值,是否需要加入return语句? 132 8.6. 怎样把数组作为参数传递给函数? 133 8.7. 在程序退出main()函数之后,还有可能执行...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

哈希值有多少位