当前位置： /
游戏介绍：
《以撒的结合胎衣+》中很多玩家对于一些新的道具的功能还是不是很懂，基本上这个时候都需要查询图鉴，图鉴可以查询网页玩家整理的，但是这个比较麻烦，这里就提供一下游戏内查询的内置图鉴mod。
以撒的结合胎衣+mod使用方法
2.参考【】
以撒的结合胎衣简介
英文名称：The Binding of Isaac: Afterbirt+游戏译名：以撒的结合 后生游戏语言：英文开发厂商：Nicalis发行厂商：Nicalis发售日期：游戏容量：461M游戏类型：动作类
《以撒的结合 后生》是《以撒的结合》的扩展包，游戏以诡异的风格，简单的游戏方式，多变的道具和地图，容量非常小的游戏，但本作的可玩度非常高，本作还支持多人联机。此次扩展包加入了大量新元素，比如系难度日常任务以及高风险高回报的贪婪模式等。喜欢的朋友不妨试试看。
相关游戏：
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
官方中文版
游戏平台：
游戏类型：动作冒险
游戏版本：美版欧版中文版
游戏标签：
玩家评分：40
k73评分：42
版权所有 鄂ICP备号
K73电玩之家有人知道口袋妖怪mod怎么用神器宝贝图鉴和奖励箱探测仪吗？_minecraft吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0可签7级以上的吧50个
本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：1,358,561贴子：
有人知道口袋妖怪mod怎么用神器宝贝图鉴和奖励箱探测仪吗？
如题，百度说按右键使用但是并不能使用。
这是按照全国图鉴编号的...
如图，布满了岁月的痕迹...
创造神奇宝贝阿尔宙斯，...
之前重玩了遍，在啪啪模...
服务器名称：梦次元 服...
『魅蓝 5s』天猫首发，2.2元秒杀手机
贴吧热议榜
使用签名档&&
保存至快速回贴algorithm - finding a^b^c^... mod m - Stack Overflow
Join the Stack Overflow Community
Stack Overflow is a community of 6.7 million programmers, just like you, helping each other.
J it only takes a minute:
I would like to calculate:
abcd... mod m
Do you know any efficient way since this number is too big but a , b , c , ... and m fit in a simple 32-bit int.
Any Ideas?
This question is different from finding ab mod m. Please pay attention and don't post useless answers.
Also please note that abc is not same as (ab)c. The later is equal to abc. Exponentiation is right-associative.
Thank you! Alin Purcaru
4,19021544
user182513
The answer does not contain full formal mathematical proof of correctness. I assumed that it is unnecessary here. Besides, it would be very illegible on SO, (no MathJax for example).
I will use (just a little bit) specific
algorithm. It's not best option, but enough.
We want calculate a^x mod m. We will use function modpow(a,x,m). Described below.
If x is small enough (not exponential form or exists p^x | m) just calculate it and return
Split into primes and calculate p^x mod m separately for each prime, using modpow function
Calculate c' = gcd(p^x,m) and t' = totient(m/c')
Calculate w
= modpow(x.base, x.exponent, t') + t'
Save pow(p, w - log_p c', m) * c' in A table
Multiple all elements from A and return modulo m
Here pow should look like python's pow.
Main problem:
Because current best answer is about only special case gcd(a,m) = 1, and OP did not consider this assumption in question, I decided to write this answer. I will also use . Quoting wikipedia:
Euler's totient theorem:
If n and a are coprime positive integers, then
where φ(n) is .
The assumption numbers are co-primeis very important, as Nabb . So, firstly we need to ensure that the numbers are co-prime. (For greater clarity assume x = b^(c^...).) Because , where
we can factorize a, and separately calculate q1 = (p1^alpha)^x mod m,q2 = (p2^beta)^x mod m... and then calculate answer in easy way (q1 * q2 * q3 * ... mod m). Number has at most o(log a) prime factors, so we will be force to perform at most o(log a) calculations.
In fact we doesn't have to split to every prime factor of a (if not all occur in m with other exponents) and we can combine with same exponent, but it is not noteworthy by now.
Now take a look at (p^z)^x mod m problem, where p is prime. Notice some important observation:
If a,b are positive integers smaller than m and c is some positive integer and , then true is sentence .
Using the above observation, we can receive solution for actual problem. We can easily calculate gcd((p^z)^x, m). If x*z are big, it is number how many times we can divide m by p. Let m' = m /gcd((p^z)^x, m). (Notice (p^z)^x = p^(z*x).) Let c = gcd(p^(zx),m). Now we can easily (look below) calculate w = p^(zx - c) mod m' using Euler's theorem, because this numbers are co-prime! And after, using above observation, we can receive p^(zx) mod m. From above assumption wc mod m'c = p^(zx) mod m, so the answer for now is p^(zx) mod m = wc and w,c are easy to calculate.
Therefore we can easily calculate a^x mod m.
Calculate a^x mod m using Euler's theorem
Now assume a,m are co-prime. If we want calculate a^x mod m, we can calculate t = totient(m) and notice a^x mod m = a^(x mod t) mod m. It can be helpful, if x is big and we know only specific expression of x, like for example x = 7^200.
Look at example x = b^c. we can calculate t = totient(m) and x' = b^c mod t using
algorithm in Θ(log c) time. And after (using same algorithm) a^x' mod m, which is equal to solution.
If x = b^(c^(d^...) we will solve it recursively. Firstly calculate t1 = totient(m), after t2 = totient(t1) and so on. For example take x=b^(c^d). If t1=totient(m), a^x mod m = a^(b^(c^d) mod t1), and we are able to say b^(c^d) mod t1 = b^(c^d mod t2) mod t1, where t2 = totient(t1). everything we are calculating using exponentiation by squaring algorithm.
Note: If some totient isn't co-prime to exponent, it is necessary to use same trick, as in main problem (in fact, we should forget that it's exponent and recursively solve problem, like in main problem). In above example, if t2 isn't relatively prime with c, we have to use this trick.
Calculate φ(n)
Notice simple facts:
if gcd(a,b)=1, then φ(ab) = φ(a)*φ(b)
if p is prime φ(p^k)=(p-1)*p^(k-1)
Therefore we can factorize n (ak. n = p1^k1 * p2^k2 * ...) and separately calculate φ(p1^k1),φ(p2^k2),... using fact 2. Then combine this using fact 1. φ(n)=φ(p1^k1)*φ(p2^k2)*...
It is worth remembering that, if we will calculate totient repeatedly, we may want to use Sieve of Eratosthenes and save prime numbers in table. It will reduce the constant.
example: (it is correct, for the same reason as )
def totient(n) :
# n - unsigned int
result = 1
#prime numbers - 'iterator'
while p**2 &= n :
if(n%p == 0) :
result *= (p-1)
while(n%p == 0) : # * p^(k-1)
if n != 1 :
result *= (n-1)
return result
# in O(sqrt(n))
Case: abc mod m
Cause it's in fact doing the same thing many times, I believe this case will show you how to solve this generally.
Firstly, we have to split a into prime powers. Best representation will be pair &number,
exponent&.
std::vector&std::tuple&unsigned, unsigned&& split(unsigned n) {
std::vector&std::tuple&unsigned, unsigned&&
for(unsigned p = 2; p*p &= ++p) {
unsigned current = 0;
while(n % p == 0) {
current += 1;
if(current != 0)
result.emplace_back(p, current);
if(n != 1)
result.emplace_back(n, 1);
After split, we have to calculate (p^z)^(b^c) mod m=p^(z*(b^c)) mod m for every pair. Firstly we should check, if p^(z*(b^c)) | m. If, yes the answer is just (p^z)^(b^c), but it's possible only in case in which z,b,c are very small. I believe I don't have to show code example to it.
And finally if p^(z*b^c) & m we have to calculate the answer. Firstly, we have to calculate c' = gcd(m, p^(z*b^c)). After we are able to calculate t = totient(m'). and
(z*b^c - c' mod t). It's easy way to get an answer.
function modpow(p, z, b, c, m : integers) # (p^z)^(b^c) mod m
while m' % p == 0 :
# now m' = m / gcd((p^z)^(b^c), m)
t = totient(m')
exponent = z*(b^c)-c' mod t
return p^c' * (p^exponent mod m')
And below Python working example:
def modpow(p, z, b, c, m) : # (p^z)^(b^c) mod m
while m % p == 0 :
# m = m' now
t = totient(m)
exponent = ((pow(b,c,t)*z)%t + t - (cp%t))%t
# exponent = z*(b^c)-cp mod t
return pow(p, cp)*pow(p, exponent, m)
Using this function, we can easily calculate (p^z)^(b^c) mod m, after we just have to multiple all results (mod m), we can also calculate everything on an ongoing basis. Example below. (I hope I didn't make mistake, writing.) Only assumption, b,c are big enough (b^c & log(m) ak. each p^(z*b^k) doesn't divide m), it's simple check and I don't see point to make clutter by it.
def solve(a,b,c,m) : # split and solve
result = 1
while p**2 &= a :
while a % p == 0 :
# calculate z
if z != 0 :
modpow(p,z,b,c,m)
result %= m
if a != 1 :
# Possible last prime
result *= modpow(a, 1, b, c, m)
return result % m
Looks, like it works.
1,16121227
abc mod m = abc mod n mod m, where n = φ(m) .
If m is prime, then n = m-1.
Edit: as Nabb pointed out, this only holds if a is coprime to m. So you would have to check this first.
131k23255298
19.9k42877
Modular Exponentiation is a correct way to solve this problem, here's a little bit of hint:
To find abcd % m
You have to start with calculating
a % m, then ab % m, then abc % m and then abcd % m ... (you get the idea)
To find ab % m, you basically need two ideas: [Let B=floor(b/2)]
ab = (aB)2 if b is even OR ab = (aB)2*a if b is odd.
(X*Y)%m = ((X%m) * (Y%m)) % m
Therefore,
if b is even
ab % m = (aB % m)2 % m
or if b is odd
ab % m = (((aB % m)2) * (a % m)) % m
So if you knew the value of aB, you can calculate this value.
To find aB, apply similar approach, dividing B until you reach 1.
e.g. To calculate 1613 % 11:
1613 % 11 = (16 % 11)13 % 11 = 513 % 11
= (56 % 11) * (56 % 11) * (5 % 11) &---- (I)
To find 56 % 11:
56 % 11 = ((53 % 11) * (53 % 11)) % 11 &----(II)
To find 53%11:
53 % 11 = ((51 % 11) * (51 % 11) * (5 % 11)) % 11
= (((5 * 5) % 11) * 5) % 11 = ((25 % 11) * 5) % 11 = (3 * 5) % 11 = 15 % 11 = 4
Plugging this value to (II) gives
56 % 11 = (((4 * 4) % 11) * 5) % 11 = ((16 % 11) * 5) % 11 = (5 * 5) % 11 = 25 % 11 = 3
Plugging this value to (I) gives
513 % 11 = ((3 % 11) * (3 % 11) * 5) % 11 = ((9 % 11) * 5) % 11 = 45 % 11 = 4
This way 513 % 11 = 4
With this you can calculate anything of form a513 % 11 and so on...
Since for any relationship a=x^y, the relationship is invariant with respect to the numeric base you are using (base 2, base 6, base 16, etc).
Since the mod N operation is equivalent to extracting the least significant digit (LSD) in base N
Since the LSD of the result A in base N can only be affected by the LSD of X in base N, and not digits in higher places. (e.g. 34*56 = 30*50+30*6+50*4+4*5 = 10*(3+50+3*6+5*4)+4*6)
Therefore, from LSD(A)=LSD(X^Y) we can deduce
LSD(A)=LSD(LSD(X)^Y)
A mod N = ((X mod N) ^ Y) mod N
(X ^ Y) mod N = ((X mod N) ^ Y) mod N)
Therefore you can do the mod before each power step, which keeps your result in the range of integers.
This assumes a is not negative, and for any x^y, a^y & MAXINT
This answer answers the wrong question. (alex)
24.4k46690
Look at the behavior of A^X mod M as X increases. It must eventually go into a cycle. Suppose the cycle has length P and starts after N steps. Then X &= N implies A^X = A^(X+P) = A^(X%P + (-N)%P + N) (mod M). Therefore we can compute A^B^C by computing y=B^C, z = y & N ? y : y%P + (-N)%P + N, return A^z (mod m).
Notice that we can recursively apply this strategy up the power tree, because the derived equation either has an exponent & M or an exponent involving a smaller exponent tower with a smaller dividend.
The only question is if you can efficiently compute N and P given A and M. Notice that overestimating N is fine. We can just set N to M and things will work out. P is a bit harder. If A and M are different primes, then P=M-1. If A has all of M's prime factors, then we get stuck at 0 and P=1. I'll leave it as an exercise to figure that out, because I don't know how.
///Returns equivalent to list.reverse().aggregate(1, acc,item =& item^acc) % M
func PowerTowerMod(Link&int& list, int M, int upperB = M)
requires M & 0, upperB &= M
var X = list.Item
if list.Next == null: return X
var P = GetPeriodSomehow(base: X, mod: M)
var e = PowerTowerMod(list.Next, P, M)
if e^X & upperB then return e^X //todo: rewrite e^X & upperB so it doesn't blowup for large x
return ModPow(X, M + (e-M) % P, M)
10.6k23399
Tacet's answer is good, but there are substantial simplifications possible.
The powers of x, mod m, are preperiodic. If x is relatively prime to m, the powers of x are periodic, but even without that assumption, the part before the period is not long, at most the maximum of the exponents in the prime factorization of m, which is at most log_2 m. The length of the period divides phi(m), and in fact lambda(m), where lambda is , the maximum multiplicative order mod m. This can be significantly smaller than phi(m). Lambda(m) can be computed quickly from the prime factorization of m, just as phi(m) can. Lambda(m) is the GCD of lambda(p_i^e_i) over all prime powers p_i^e_i in the prime factorization of m, and for odd prime powers, lambda(p_i^e_i) = phi(p_i^e^i). lambda(2)=1, lamnda(4)=2, lambda(2^n)=2^(n-2) for larger powers of 2.
Define modPos(a,n) to be the representative of the congruence class of a in {0,1,..,n-1}. For nonnegative a, this is just a%n. For a negative, for some reason a%n is defined to be negative, so modPos(a,n) is (a%n)+n.
Define modMin(a,n,min) to be the least positive integer congruent to a mod n that is at least min. For a positive, you can compute this as min+modPos(a-min,n).
If b^c^... is smaller than log_2 m (and we can check whether this inequality holds by recursively taking logarithms), then we can simply compute a^b^c^... Otherwise, a^b^c^... mod m = a^modMin(b^c^..., lambda(m), [log_2 m])) mod m = a^modMin(b^c^... mod lambda(m), lambda(m),[log_2 m]).
For example, suppose we want to compute 2^3^4^5 mod 100. Note that 3^4^5 only has 489 digits, so this is doable by other methods, but it's big enough that you don't want to compute it directly. However, by the methods I gave here, you can compute 2^3^4^5 mod 100 by hand.
Since 3^4^5 > log_2 100,
2^3^4^5 mod 100
= 2^modMin(3^4^5,lambda(100),6) mod 100
= 2^modMin(3^4^5 mod lambda(100), lambda(100),6) mod 100
= 2^modMin(3^4^5 mod 20, 20,6) mod 100.
Let's compute 3^4^5 mod 20. Since 4^5 > log_2 20,
3^4^5 mod 20
= 3^modMin(4^5,lambda(20),4) mod 20
= 3^modMin(4^5 mod lambda(20),lambda(20),4) mod 20
= 3^modMin(4^5 mod 4, 4, 4) mod 20
= 3^modMin(0,4,4) mod 20
= 3^4 mod 20
= 81 mod 20
We can plug this into the previous calculation:
2^3^4^5 mod 100
= 2^modMin(3^4^5 mod 20, 20,6) mod 100
= 2^modMin(1,20,6) mod 100
= 2^21 mod 100
= 2097152 mod 100
Note that 2^(3^4^5 mod 20) mod 100 = 2^1 mod 100 = 2, which is not correct. You can't reduce down to the preperiodic part of the powers of the base.
Your Answer
Sign up or
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Post as a guest
By posting your answer, you agree to the
rev .25161
Stack Overflow works best with JavaScript enabled没有巴士通行证？！ 无法正常登陆？
登录中，请稍后...
您的当前位置：> >
> 以撒的结合:胎衣 内置道具图鉴MOD汉化整合下载
以撒的结合:胎衣 内置道具图鉴MOD汉化整合下载
时间： 16:55|来源：网络|作者：樱井
名称：以撒的结合胎衣道具图鉴MOD
英文：The Binding of Isaac: Rebirth
语言：中文 游戏类型：MOD
游戏大小：2.45 MB文件：.rar
最新下载《以撒的结合胎衣道具图鉴MOD》介绍
　　名称：以撒的结合:胎衣&内置道具图鉴mod 【汉化版】
　　运行环境：WinXP,WinVista,Win7,Win8.1,Win10
　　MOD说明：
　　此次更新的以撒的结合:胎衣内置道具图鉴mod是广大玩家所需要的内置图鉴说明框显示整合mod资源。在这样一款mod之中成功的将游戏原有内置图鉴说明方法进行了有建设性的大幅改动。是喜欢尝试新鲜的玩家快速上手游戏体验的绝佳实用工具。
　　《以撒的结合》是一款风格诡异、简单粗暴、道具与地图多变的小型游戏，虽然容量不大，但可玩性却是极高，多人联机更是让诸多基友夜不能寐。《以撒的结合：胎衣》是《以撒的结合》的扩展包，包括了大量的新元素，例如新的日常任务以及高风险高回报的&贪婪模式&。 & &
　　MOD版本：内置道具图鉴mod整合包
　　mod内容：
　　由玩家汉化的一款优化MOD，使用后将提供可直接在游戏中的图鉴内容，在道具和饰品旁边添加一个描述框，告诉玩家该道具的作用。
图鉴说明已经十分清楚了
　　使用mod可能会导致游戏娱乐性失衡!请谨慎使用!
　　使用说明：
　　1.解压缩
　　2.复制文件覆盖到游戏目录\resourcesac
　　3.开始游戏
　　相关推荐：
　　游戏截图：
游戏支持存档继承，延续重生获得的奖励
新增每日挑战，定时会刷新挑战任务
boss房构造有所改变，增加狭小房间的boss战
出现在第一关的机器，目前作用未知（刷新地图？）
魔法师boss火焰花环的形态会随机改变