我正在做:
Fibonacci序列中的每个新项都是通过添加前两个项来生成的。从1和2开始,头10个术语将是:
1、2、3、5、8、13、21、34、55、89、
求出序列中所有不超过400万的偶数项之和。
我的代码:
public class Two {
public static void main(String[] args) {
Two obj = new Two();
int sum = 0, i = 1;
while (obj.fibonacci(i) < 4000001) {
i
我正在研究一个问题:一个关于偶数斐波那契数之和的问题。
我的代码:
def Fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return Fibonacci(n-1) + Fibonacci(n-2)
list1 = [x for x in range(39)]
list2 = [i for i in list1 if Fibonacci(i) % 2 == 0]
通过打印和(List2)可以很容易地找到问题的解决方案。然而,我猜想,想出list
我最近使用两种数据结构初步比较了Dijkstra算法的运行时间,这两种数据结构是基于Java的PriorityQueue (如果我没有记错的话,它基于二进制堆)和斐波那契堆。我使用Java语言的currentTimeMillis()进行计算。我最终得到的结果非常有趣。这是我的一个测试用例的输出:
Running Dijkstra's with 8 nodes and 27 links
- Execution time with binary heap: 1 miliseconds
- Execution time with Fibonacci heap: 4 miliseconds
诚
我试图使用递归和BigInteger类将Lucas系列转换成代码,但设置基本情况时遇到了问题。这段代码正确地输出了Fibonacci序列,但是我试图获得的所有起始值,分别是N(0)和N(1)到2和1,都完全失败了。我已经搜索过帮助文件,但是没有发现任何东西使用BigIntegers完成,我需要它,因为我计划远远超过int限制。
import java.math.BigInteger;
public class LucasSeries {
private static BigInteger TWO = BigInteger.valueOf(2);
public static
所以我要做的是向用户询问一个数字,并找出它的fibonacci术语是什么。到目前为止,如果输入整数0 <=,则返回正确的fibonacci项。但是当我尝试使用负数时,我会得到一个错误。
代码:
public int fib(int n) {
if (n == 0 || n == 1 || n == -1) {
// if n is 1, 0 or -1
return Math.abs(n);
} else if (n < 0) {
// if n is negative
我已经用Java编程很长一段时间了,但它总是只是Android应用程序,而不是从静态的主方法开始。我想知道“标准”Java程序的约定,因为大多数时候,我调用的是非静态方法,这些方法显然不能通过main()方法直接完成。
下面是我编写的一个示例程序(只打印一个Fibonacci数字)。这是一个可以接受的解决办法吗?
public class MainClass {
public static void main(String[] args) {
new MainClass().mainProgram();
}
public void mainProgram() {
我正在尝试使用缓存来提高我的Fibonacci方法的性能。然而,即使计算斐波那契(40)也要花费大量的时间。
import java.util.Scanner;
public class FibWithCache {
public static void main(String args[]) {
System.out.println("Enter Fibonacci index: ");
Scanner sc = new Scanner(System.in);
int index = sc.nextInt();
我感兴趣的是Euler项目第二个问题的最短解决方案:甚至Java中的Fibonacci数。
Fibonacci序列中的每个新项都是通过添加前两个项来生成的。从1和2开始,前10项将是:1、2、3、5、8、13、21、34、55、89、.通过考虑Fibonacci序列中值不超过400万的项,找出偶数项的和。
我现在拥有的是:
public class fibonnaci {
public static void main(String[] args) {
int f=0,t=0,n=0,s=1;
for(;n<4000000;n=f+s){
我正在努力寻找斐波那契数列中不超过100的所有项。下面是我的代码:
fibonacci_sequence = [1,2]
index = fibonacci_sequence.length
# finding next term, term 3
# current index is 2
next_term = fibonacci_sequence[index - 2] + fibonacci_sequence[index - 1]
fibonacci_sequence.push(next_term)
index += 1
until next_term > 100 do
next
我在欧拉项目中遇到了的麻烦。目标是找到Fibonacci序列中值不超过400万的偶数值项的总和。由于某些原因,我一直得到0作为我的输出。我做错了什么?
total = 0
count = 0
term = 0
fibonacciMemo = {0:0, 1:1}
def main ():
term = fibonacci (count)
while (term <= 4000000):
if (term % 2 == 0):
total += term
count += 1
def fibonacci (n):
有人能看看我的java代码,并告诉我如何修复我的代码吗?问题如下。我非常感谢你的帮助:)
public class problem
{
public static void main (String args []){
int a = 0;
int b = 1;
problem();
}
public static int problem(){
int c = a + b;
if (c>10){
System.out.println(c);
我试着用经典的斐波纳契算法学习RecursiveTask类。该算法工作正常,直到斐波纳契数超过17000,然后抛出一个StackOverflowError。我不知道问题是线程的数量,还是我使用缓存来存储计算的数字。我知道有更好的算法来计算斐波纳契数,但这只是为了学习叉/连接体系结构及其局限性。较低的数字(例如,编号17800)所需的时间为153 ms,然后缓存大小为13 MB。
问:如何使用相同的算法使这个代码规模更好(以计算更高的数字)?
Fibonacci代码:
public class FibonacciTask extends RecursiveTask<BigInteger&g
例如,我可以定义一个递归Python lambda函数来计算斐波那契数列,如下所示:
fn = lambda z: fn(z-1)+fn(z-2) if z > 1 else z
但是,如果我尝试将其转换为Theano函数,Theano将不会接受fn,因为fn调用了布尔运算">“。所以这段代码崩溃了:
z = T.scalar('z')
fn = lambda z: fn(z-1)+fn(z-2) if z > 1 else z
fibby = theano.function([z], fn(z))
但是如果我将布尔运算符替换为theano.tenso
我正在使用JavaSE7 中的RecursiveTask测试斐波那契示例。
程序如下:
import java.util.concurrent.*;
public class testfuture{
public static void main(String[] args) {
System.out.println("Hello, World");
Fibonacci fib = new Fibonacci(10);
int result = fib.compute();
System.out.prin
我刚开始学习java,所以这已经困扰了我相当一段时间了。这是一个输出斐波纳契序列数字的程序。这里的目标是让程序只输出while循环的最后一行。我已经启动并运行了程序,只是想弄清楚如何只输出序列的最后一行是有困难的
示例输入/输出输入:5
输出: Fibonacci #3 is: 3 Fibonacci #4 is: 5 Fibonacci #5 is: 8
输出应该如下所示: Fibonacci #5是:8
import javax.swing.JOptionPane;
public class Fibonacci2 {
public static void main(String
从评论中我最感兴趣的是:
代码的性能
全面审查代码结构、样式规则和命名约定。
问题:2
通过考虑Fibonacci序列中值不超过400万的项,找出偶数项的和。
import math
import itertools
#----------------------------------------------------------------------------------
def calc_fibonacci_num(n):
"""Calculates the fibonacci number at the given index.
Argu
我有一个代码块,让用户输入斐波那契数。代码块:
numb_list = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55]
numb = int(input('Enter the next Fibonacci number >'))
while numb in numb_list and numb <= 50:
numb = int(input('Enter the next Fibonacci number >'))
if numb in numb_list:
我最近第一次读到了关于memoization的文章(我是一个菜鸟),我想尝试用memoization做一个斐波那契函数。这就是我尝试过的,但是任何超过1的值都会给我一个分割错误。如有任何帮助,我们不胜感激!
unsigned int fibonacci( unsigned int n )
{
vector<unsigned int> fibvector;
if ( n <= 1 )
return n;
if ( fibvector.size() >= n )
return fibvector[n];
uns
这是我为项目Euler #2编写的代码。问题是: Fibonacci序列中的每个新术语都是通过将前两个术语相加而生成的。从1和2开始,前10个术语将是:
1,2,3,5,8,13,21,34,55,89,...
通过考虑Fibonacci序列中值不超过400万的项,求出偶数值项的总和。
from functools import lru_cache
@lru_cache(maxsize=1000000)
def fibonacci_memo(input_value):
global value
fibonacci_cache = {}
if input_value in fib
我需要测量我的项目的时间(以纳秒为单位),但我不知道如何在我的程序中正确地实现它。我知道我需要用这样的方法:
long startTime = System.nanoTime();
...
long endTime = System.nanoTime();
long timeElapsed = endTime - startTime;
但是我不知道我要在哪里实现它,所以我的程序可以正常工作。这是我的代码:
import java.util.*;
public class fiboSeriesRec
{
public static void main(String[] args)
{
我正在学习Java,我创建了一个非常简单的服务器来计算Fibonacci数。服务器(FibonacciServer)创建一个负责计算序列的对象(Fibonacci),该对象实现一个接口(IFibonacci):
FibonacciServer.java:
package myrmifibonacciserver;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
public class FibonacciServer {
public st
我是D的新手,我在简单的测试中将它与Java进行了比较,并期望看到本地语言会更快(或者大致相同)。但在我用递归D进行的第一次测试中,它比Java慢得多(几乎是Java的两倍)。
Java (这是一个糟糕的java性能测试,但它只是一个简单的想法):
public static void main(String... args) {
long before = System.nanoTime();
System.out.println(fibonacci(40));
System.out.println(TimeUnit.NANOSECONDS.t
我一直在研究一个在程序集中编写递归函数的项目,它将计算斐波纳契数。首先,我使用了Java代码:
public class Fibonacci {
public static int fibonacci(int n)
{
if(n <= 1)
return n;
return fibonacci(n-1) + fibonacci(n-2);
}
这个递归函数工作得非常好。尽管在试图在程序集代码中实现它时,我没有得到预期的结果。经过一段时间的故障排除后,我用Java编写了(大致)等效的代码:
sta
我正在尝试使用C++来解决斐波纳契数,但是当输出数字限制与大数交叉时,我的代码显示为负数。
#include<stdio.h>
#include<iostream>
using namespace std;
int64_t get_fibonacci_last_digit_naive(int n)
{
int64_t a = 0, c, i;
int64_t b = 1;
if (n == 0)
return (a);
for (i = 2; i <= n; i++)
{
为了使用回忆录查找nth fibonacci数,我找到了一个在c++中使用c++的代码。
我试图在java中转换这段代码,但是它失败了。
代码( c++: )
#include <bits/stdc++.h>
typedef long long int ll;
map<ll, ll> mp;
ll M = 1000000007;
long long fibonacci(long long n) {
if (mp.count(n))return mp[n];
long long k=n/2;
if (n%2=
这是Euler项目问题2:
Fibonacci序列中的每个新项都是通过添加前两个项来生成的。从1和2开始,头10个术语将是:
1、2、3、5、8、13、21、34、55、89、
通过考虑Fibonacci序列中值不超过400万的项,找出偶数项的和。
一个可能的简单方法是:
def fib_even(n):
previous, current = 0, 1
sum_fib = 0
while current <= n:
previous, current = current, previous + current
if cur
程序本身运行良好。输入的每个值都返回正确的相应Fibonacci数。我还需要使用循环来计时递归函数和函数的执行时间。当我运行程序时,它只返回用户实际输入的时间,而不是运行函数所需的时间。我试着移动定时器,但我一直得到同样的结果。我希望返回递归计算fibonacci数所需的时间,以及使用循环计算fibonacci数所需的时间。
import java.util.Scanner;
public class FibNumbers {
public static void main(String[] args) {
int f;
我试图制造一个fibonacci数生成器,它在给定的数量上停止,但它通常会超过这个值。我做错了什么?
#Fibonacci number generator
a=0
b=1
print("Fibonacci number generator.")
stopNumber=input("How high do you want to go? If you want to go forever, put n.")
print(1)
while stopNumber=="n":
a=a+b
b=b+a
pr