我正在研究一个简单的函数,给定一个输入n,返回n个Fibonacci的数字.
int main(){
int n = 0;
int counter = 1;
int f1, f2, f3 = 1;
printf("Insert an integer bigger than 0:\n");
scanf("%i", &n);
printf("%i", f1);
while(counter <= n){
f3 = f1 + f2;
printf("%i\n", f3);
f1 = f2;
f2 = f3;
counter = counter + 1;
}
return 0;
}
令人惊讶的是,每次运行程序时,该函数都会返回不同的结果.此外,这些数字远远大于/小于任何可能的结果.
最有可能的是,我遗漏了一些明显的东西,但我无法解释这种行为.
我定义了一个XOR运算符:
let (.||.) x y = (x || y) && not(x && y)
这样
true .||. true
true .||. false
做回false和true分别.
根据Hansen和Rischel的说法,&&运营商的优先级高于||运营商(以及.||.运营商.因此,为什么
true .||. true && false
true .||. false && true
做回false并true分别？结果似乎是由(true .||. true) && false而不是预期产生的
true .||. (true && false).
我构建了一个简单的函数,给定一个列表,返回一个列表列表.每个单独的清单都必须订购.例如:
subOrd [4;4;10;20;5;30;6;10] --> [[4;4;10;20];[5;30];[6;10]]
subOrd [5;6;4;3;2;1] --> [[5;6];[4];[3];[2];[1]]
我这是我目前的解决方案,除了详细信息外,它的效果非常好:
let rec subOrd (l1: int list) :int list list =
let rec aux2 (l2: int list) (l3: int list) :int list=
match l2 with
| [] -> []
| [x] -> [x]
| x0::(x1::_ as xs) when x0 > x1 -> x0::l3
| x0::(x1::_ as xs) when x0 <= x1 -> (x0::l3)@(aux xs l3)
match l1 with
| [] -> []
| x::xs -> (aux2 l1 [])::subOrd xs
它重复xs …
我正在学习如何将递归应用于数组.
例如,我通常以这种方式读取数组:
void read_array(int *a, int n){
int i;
for(i = 0; i < n; ++i)
scanf("%d", &a[i]);
return;
}
我想以递归方式读取数组.我写了以下函数:
void read_array(int *a, int n){
int i = n - 1;
if (n < 0)
return;
else{
if(scanf("%d", &a[n - 1 - i]) == 1){
read_array(a, n - 1);
return;
}
}
}
它编译,但在运行时会产生分段错误错误.它让我感到困惑,因为函数考虑了一个0应该阻止它的基础案例.
在C中,我将用循环解决问题.为了表达这个想法,例如:
void foo(int x){
while(x > 0){
printf("%d", x % 10);
x /= 10;
}
}
使用F#,我无法使函数返回单个值.我试过了:
let reverse =
let aux =
fun x ->
x % 10
let rec aux2 =
fun x ->
if x = 0 then 0
else aux2(aux(x / 10))
aux2 n
但它总是返回基本情况0.
我无法超越这种方法,其中递归结果通过操作维护,并且无法单独报告(根据可能的理解):
let reverse2 =
let rec aux =
fun x ->
if x = 0 then 0
else (x % 10) + aux (x / 10) // The operation …我正在尝试创建一个1000个元素数组.每个元素的范围应该在0到99之间.我首先尝试重现这个教学实例,实际上,我无法正确理解:
#include <stdio.h>
#include <stdlib.h>
#define DIM 1000
int myVect[DIM];
int i;
int main(){
randomize(); /? Initialize randomize*/
for (i =0; i < DIM ; i ++)
myVect[i] = random(100);
return 0;
}
在编译时,我得到了error,warning和note.
warning: implicit declaration of function ‘randomize’ (1)
error: too many arguments to function ‘random’ (2)
/usr/include/stdlib.h:282:17: note: declared here (3)
我从两个帖子中找到了资源:
不幸的是,由于我的经验不足,我无法理解我发布的教学实例的含义.
(1)在哪个图书馆randomize？我一直无法找到答案.
(2)Random不应该有参数.因此,为什么在它的例子中100,因为它应该确定随机数的范围？
(3)本说明是否表明random申报地点？
感谢您的耐心等待.
我使用 SpaceVim 作为 Java IDE，只是为了好玩。在配置ISP 时，一个很好的可以充分享受许多 IDE 的典型功能，我发现以下基于 Windows 的步骤：
[[layers]]
name = "lsp"
filetypes = [
"java"
]
[layers.override_cmd]
java = [
"java",
"-Declipse.application=org.eclipse.jdt.ls.core.id1",
"-Dosgi.bundles.defaultStartLevel=4",
"-Declipse.product=org.eclipse.jdt.ls.core.product",
"-Dlog.protocol=true",
"-Dlog.level=NONE",
"-noverify",
"-Xmx1G",
"-jar",
"D:\\dev\\jdt-language-server-latest\\plugins\\org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar",
"-configuration",
"D:\\dev\\jdt-language-server-latest\\config_win",
"-data",
"C:\\Users\\Administrator\\.cache\\javalsp"
]
我如何在 linux 上翻译它？除了为标志config_linux，我显然不能找到D:\\...，C:\\...在我的系统等价，也没有一个文件夹，例如jdt-language-server-latest。从Eclipse专用页面，我无法推断出相关信息。可能是因为我经验不足。提前感谢您的任何提示。
抛硬币.成功,你赢了100,否则你输了50.你会继续玩,直到你的口袋里有钱a.如何a存储任何迭代的值？
a <- 100
while (a > 0) {
if (rbinom(1, 1, 0.5) == 1) {
a <- a + 100
} else {
a <- a - 50
}
}
作为最终结果,当while循环结束时,我希望能够查看a每次迭代的值,而不仅仅是最终结果.我查阅了关于计算迭代次数的帖子,但我无法将其应用于此案例.
列表的每个节点与数据一起保存后继节点的地址。这就是为什么递归可以很好地工作的原因，例如下面的示例：它接受输入，例如123456，然后将其打印为列表6 -> 5 -> 4 -> 3 -> 2 -> 1 -> NULL.
/* Structure types ----------------------------------------------*/
typedef int data;
struct list_element {
int data;
struct list_element *next;
};
typedef struct list_element ELEM;
typedef ELEM *LINK;
/* Recursive list create and list print---------------*/
LINK create_list(int n) {
if (n == 0) {
return NULL;
}
else {
LINK head = (LINK) malloc(sizeof(ELEM));
head -> data = n % 10;
head -> next = create_list(n / …