我用Python写了下面的两个函数:
def recur_tet(b, n):
if n == 1:
return(b)
else:
return(b ** recur_tet(b, n - 1))
def iter_tet(b, n):
ans = 1
for i in range(n):
ans = b ** ans
return(ans)
而且,令人惊讶的是,递归版本的速度要快一些:
python3> %timeit recur_tet(2,4)
1 µs ± 12.5 ns per loop
我是Python的新手--我来自matlab。我正在尝试编译这段代码:
import numpy as np
from scipy import sparse
n=3
dim=2^n
sx = np.array([[0,1],[1,0]])
sy = np.array([[0,-1j],[1j,0]])
sz = np.array([[1,0],[0,-1]])
ssx= sparse.csr_matrix(sx)
ssy= sparse.csr_matrix(sy)
ssz= sparse.csr_matrix(sz)
expon1=np.zeros((n,n))
for i in
这个代码是从leetcode得到的。
class Solution(object):
def myPow(self, x, n):
if n == 0:
return 1
if n == -1:
return 1 / x
return self.myPow(x * x, n / 2) * ([1, x][n % 2])
此代码用于实现poe(x, n),在Python中这意味着x**n。
我想知道为什么它可以实现pow(x, n)。
看上去没道理..。
我明白
if n ==
用R语言给出了一个问题,以求递推关系x(n) = 2*x(n-1) - x(n-2)的第30项,其中x(1) =0和x(2) = 1。我知道答案是29来自数学推论。但作为R的新手,我对如何在这里工作有点困惑。以下是我的代码:
loop <- function(n){
a <- 0
b <- 1
for (i in 1:30){
a <- b
b <- 2*b - a
}
return(a)
}
loop(30)
结果,我得到了1,这是远远不够的。
如果您想知道为什么这看起来像Python-ish,到目前为止,我只接触过Pyth
请用简单的语言和详细的解释来解释我如何并行化解密函数循环并使循环更快。
import math
def gcd(m,n):
if n==0:
return m
else:
return gcd(n,m%n)
def encrypt(ascii_initial, e, n):
ascii_final = []
for i in ascii_initial:
C1= pow(i,e)
C=C1%n
print("value of C is:",C)
编写函数电源的两个版本,第一个版本使用两个整数参数m和n,并返回值m^n。
请注意,m和n都可以是任意整数(正或非正)。函数的第二个版本称为(cpower ),它是curried版本。
注:如果m和n都为零,则应引发异常。
fun power(m,n) = if n=0 then 1 else m * power(m,n-1);
fun cpower (m,n) : int =
if n = 0 then 1 else
if n >= 0 then power(m,n) else
if n < 0 then 1/power(m,n) else m * cp
下面是代码
import java.math.BigInteger;
public class RecursionTest2
{
public static BigInteger fact(int n)
{
System.out.println(n);
BigInteger ans = BigInteger.ONE;
if (n > 0) {
ans = BigInteger.valueOf(n);
ans = ans.multiply(fact(n-1));
}
System.out.println(ans);
我有这个reverse算法的实现:
function reverse(a) {
let left = 0;
let right = a.length - 1;
while (left < right) {
let tmp = a[left];
a[left] = a[right];
a[right] = tmp;
left += 1;
right -= 1;
}
return a;
}
对于任何n元素数组,循环都会运行n/2次。但是我到处读到reverse算法的复
我在Julia中的代码,几乎和Python代码(见下文)相同,运行在4.6 s中,Python版本运行在2.4 S中,显然还有很多改进的余地。
function Problem12()
#=
The sequence of triangle numbers is generated by adding the natural
numbers. So the 7th triangle number would be:
1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.
The first ten terms would be:
1,
我有下面这段代码,我知道它的复杂度是n*(log2(n))^2,但是我不明白为什么前两个循环的复杂度都是log2(n)。有人能给我解释一下为什么吗?谢谢。
for (int i = n; i>0; i/=2) {
for (int j = 1; j < n; j*=2) {
for (int k = 0; k < n; k+=2) {
... // constant time number of operation
}
}
}
幂等意味着将一个操作执行N次,得到相同的结果
作者提到“这只适用于结果,而不是资源本身”。结果和资源之间的区别是什么?
例如,假设PUT with body "hello“将消息资源更新为"hello”。然后加上“再见”将其更新为“再见”。这里我们有2个PUT,结果不一样,一次资源值是"hello“,第二次是”再见“。
我读过,它被接受的回应似乎是说它必须以相同的值放入(例如,在一个幂等的行中放入"hello“两次,而不是一般的PUT方法)。
我用python (n,k,mod)得到自然数的幂和,但没有得到完美的时间复杂度。我所用的
mod = 10**9+9
total = 0
for i in range(2, n):
x = pow(i, k, mod)
total += x
total = total%mod
return total
你能提出任何解决幂和的算法吗?
( 1^k + 2^k + 3^k + 4^k .... n^k ) mod 1000000009
其中k在1到1000之间,n属于自然数1。
我正在使用numpy数组和python列表的元素能力。为什么numpy操作有10000个循环?
In [1]: a = np.arange(1000)
In [2]: %timeit a**5
10000 loops, best of 3: 77.8 µs per loop
In [3]: b = range(1000)
In [4]: %timeit [i**5 for i in b]
1000 loops, best of 3: 1.64 ms per loop
这段代码是用Python 3编写的,我正在试图找到第10001个素数。
#10001st prime number
mylist=[]
def prime_index(n):
for i in range(99**99):
for x in range(2, int(i**1/2)):
if i % x == 0:
return False
return True
mylist.append(i)
n=int(n+1)
print(my
对于python,我使用random.randint(0,1)随机生成0或1。这是相当慢的,因为我需要做大约十亿次。有没有更快的方法?
total=0
n=1000000000
for x in range(n):
money=2
while True:
x=random.randint(0,1)
if x==1:
break
if x==0:
money*=2
continue
total+=money
print(total/n)
我正在尝试实现一个,我很困惑为什么中型数字(~7位)需要这么长时间(> 20秒)。我最终发现下面这行代码是问题的根源:
x = a**d % n
(其中a、d和n都是相似但不相等的中型数字,**是求幂运算符,%是模运算符)
然后,我尝试用以下代码替换它:
x = pow(a, d, n)
相比之下,它几乎是瞬间发生的。
对于上下文,以下是原始函数:
from random import randint
def primalityTest(n, k):
if n < 2:
return False
if n % 2 == 0:
ret
当e趋向于(1+1/n)^n的无穷大时,我正在做一个家庭作业来计算(1+1/n)^n。我知道这是一种非常愚蠢的计算方法,但我必须这样做。
我应该测试我的结果,其值不超过n = 10 ^20。
然而,我的程序在10^7上由于内存错误而死,我不太清楚原因。这是我的密码:
def pow(n):
p = (1.0 + 1.0/n)
for _ in range(1,n+1):
p = p * (1.0 + 1.0/n)
return p
def e(k):
print 'e with k =', k, 'is', pow(10**k)
m