Answers:
+/@:*(3 5,.1 3&)&1 0
将向量[1 0]
与矩阵[[3 5] [1 3]]
n
时间相乘。
@algorithmshark节省了2个字节。
用法与测试:
(+/@:*(3 5,.1 3&)&1 0) 5
1968 880
(+/@:*(3 5,.1 3&)&1 0) every i.6
1 0
3 1
14 6
72 32
376 168
1968 880
+/ .*(3 5,:1 3&)&1 0
。
(+/@:*&(3 5,.1 3)&1 0)
行得通(+/@:*&1 0&(3 5,.1 3))
呢?第二个债券是否应正确结合而第一个债券不能互换?
&
进行供电/循环,因此您可以在供电期间修改左侧输入(与正常的右侧修改相反)。
u,+*3sGyeG+sGyeGQ,1Z
u
通常减少的值在此处用作应用重复循环。更新功能是G
-> ,+*3sGyeG+sGyeG
,其中G
是2个元组。该函数将转换为3*sum(G) + 2*G[1], sum(G) + 2*G[1]
。s
是sum
,y
是*2
。
5W×U++Ḥ
2Bdz¡
5W×U++Ḥ Helper link. Argument: [a, b]
5W Yield [5].
×U Multiply it by the reverse of [a, b]. This yields [5b, a].
+ Hook; add the argument to the result. This yields [a + 5b, a + b].
+Ḥ Fork; add the doubled argument ([2a, 2b]) to the result.
This yields [3a + 5b, a + 3b].
2Bdz¡ Main link. Argument: n
2B Convert 2 to binary, yielding [1, 0].
¡ Repeat:
Ç Apply the helper link...
³ n times.
Nest[{{3,5},{1,3}}.#&,{1,0},#]&
0X{_2$3*+@5*@3*+}li*p
0X " Stack: [ 0 1 ] ";
li{ " Do int(input()) times: ";
_2$ " Stack: [ a b ] -> [ a b b a ] ";
3*+ " Stack: [ a b b a ] -> [ a b (b+3a) ] ";
@5*@3* " Stack: [ a b (b+3a) ] -> [ (b+3a) 5a 3b ] ";
+ " Stack: [ (b+3a) 5a 3b ] -> [ (b+3a) (5a+3b) ] ";
}* " ";
p " Print topmost stack item plus linefeed. ";
" Print remaining stack item (implicit). ";
我正在对二项式进行递归求值:(x + y)^ n =(x + y)(x + y)^ {n-1}
新增(由于@ edc65)
F=n=>{for(i=y=0,x=1;i++<n;)[x,y]=[3*x+5*y,x+3*y];return[x,y]}
旧
F=n=>{for(i=y=0,x=1;i<n;i++)[x,y]=[3*x+5*y,x+3*y];return [x,y]}
F=n=>{for(i=y=0,x=1;i++<n;)[x,y]=[3*x+5*y,x+3*y];return[x,y]}
n=>[...Array(n)].map(_=>[x,y]=[3*x+5*y,x+3*y],y=0,x=1)[n-1]
相同长度
g(n){int i,a[2]={1,0},b[2];for(i=0;i<n;i++)*b=*a*3+5*a[1],b[1]=*a+3*b[1],*a=*b,a[1]=b[1];printf("%d,%d",*a,a[1]);}
这无聊地实现了矩阵乘法。238字节解决方案提供了更多乐趣(引用:“超赞”),别无所求!
f(n){int p[2][n+3],i,j,k=0,a[2]={0};for(j=0;j<n+3;j++)p[0][j]=0;*p[1]=0;(*p)[1]=1;for(j=0;j<n;j++,k=!k)for(i=1;i<n+3;i++)p[!k][i]=p[k][i-1]+p[k][i];for(i=1;i<n+2;i++)a[!(i%2)]+=p[k][i]*pow(3,n+1-i)*pow(5,(i-1)/2);printf("%d,%d",*a,a[1]);}
拆解:
g(n){
int i,a[2]={1,0},b[2];
for(i=0;i<n;i++)
*b=3**a+5*a[1],b[1]=*a+3*b[1],*a=*b,a[1]=b[1];
printf("%d,%d",*a,a[1]);
}
这可能会缩短一点。在线尝试测试程序!
函数采用一个参数。
_mul[(3 5;1 3)]/[;1 0]
_mul
是矩阵乘法,因此我们用矩阵对其进行咖喱处理(3 5;1 3)
,然后使用功能幂副词打它:f/[n;x]
适用f
于x
,n
时间。再次,我们用起始向量咖喱1 0
。
_mul[2 2#3 5 1]/[;1 0] 5
1968 880
f:_mul[2 2#3 5 1]/[;1 0]
f'!8 /each result from 0 to 7 inclusive
(1 0
3 1
14 6
72 32
376 168
1968 880
10304 4608
53952 24128)
这在Kona中不起作用,因为由于某些原因f/[n;x]
未正确实现。仅n f/x
语法有效,因此最短的修复为{x _mul[(3 5;1 3)]/1 0}
23个字符。
C / C ++ 89字节
void g(int n,long&a,long&b){if(n){long j,k;g(n-1,j,k);a=3*j+5*k;b=j+3*k;}else{a=1;b=0;}}
格式:
void g(int n, long&a, long&b) {
if (n) {
long j, k;
g(n - 1, j, k);
a = 3 * j + 5 * k;
b = j + 3 * k;
} else {
a = 1;
b = 0;
}}
相同的概念:
void get(int n, long &a, long& b) {
if (n == 0) {
a = 1;
b = 0;
return;
}
long j, k;
get(n - 1, j, k);
a = 3 * j + 5 * k;
b = j + 3 * k;
}
测试台:
#include <iostream>
using namespace std;
int main() {
long a, b;
for (int i = 0; i < 55; i++) {
g(i, a, b);
cout << i << "-> " << a << ' ' << b << endl;
}
return 0;
}
输出:
0-> 1 0
1-> 3 1
2-> 14 6
3-> 72 32
4-> 376 168
5-> 1968 880
6-> 10304 4608
7-> 53952 24128
8-> 282496 126336
9-> 1479168 661504
10-> 7745024 3463680
11-> 40553472 18136064
12-> 212340736 94961664
13-> 1111830528 497225728
14-> 5821620224 2603507712
15-> 30482399232 13632143360
16-> 159607914496 71378829312
17-> 835717890048 373744402432
18-> 4375875682304 1956951097344
19-> 22912382533632 10246728974336
20-> 119970792472576 53652569456640
21-> 628175224700928 280928500842496
22-> 3289168178315264 1470960727228416
23-> 17222308171087872 7702050360000512
24-> 90177176313266176 40328459251089408
25-> 472173825195245568 211162554066534400
26-> 2472334245918408704 1105661487394848768
f:{:[x;*(1;0)*_mul/x#,2 2#3 1 5;1 0]}
要么
f:{:[x;*(1;0)*_mul/x#,(3 1;5 3);1 0]}
他们都是同一回事。
w=5**0.5;a=(3+w)**int(input())//2+1;print(a,a//w)
尽管在我的机器上,这只能给出范围内输入的正确答案0 <= n <= 18
。
这实现了封闭式公式
w = 5 ** 0.5
u = 3 + w
v = 3 - w
a = (u ** n + v ** n) / 2
b = (u ** n - v ** n) / (2 * w)
并利用了v ** n
零件很小的事实,并且可以通过舍入而不是直接计算来进行计算。
C 71字节(带有预初始化变量的60个字节)
打高尔夫球的范围还可以,但是只是为了证明C不必“太可怕了”。
f(int n,int*a){for(*a=1,a[1]=0;n--;a[1]=*a+3*a[1],*a=(5*a[1]+4**a)/3);}
如果将a中的值初始化为{1,0},我们会做得更好。
f(int n,int*a){for(;n--;a[1]=*a+3*a[1],*a=(5*a[1]+4**a)/3);}
迭代地使用映射a-> 3a + 5b,b-> a + 3b,但通过从b的新值计算a来避免临时变量。
a[*a=1]=0
而不是*a=1,a[1]=0
[3 5;1 3]**input('')*[1;0]
是26个字节,而不是41个字节