我用C、Perl和Python编写了一个简单的程序,它将一个变量递增到10亿。我没有想到不同的语言之间会有太大的差异,但我非常惊讶地看到了一个巨大的差异。这些程序简单地数到10亿:
在c中:
int main() {
int c = 0;
while (c < 1000000000) {
c++;
}
}
在Perl中:
#! /usr/bin/env perl
use strict;
use warnings;
my $x = 0;
while ($x < 1000000000) {
$x++;
}
在Python中:
#!/usr/bin/env
我在玩C的基本sintax时,我想出了下面的代码:
#include <stdio.h>
int main() {
int a = 1000;
int b = 0;
while (a > b) {
a++;
b++;
}
puts("Loop ended");
}
令人难以置信的是,这个程序输出Loop ended,即使a总是比b大,不管我增加了多少:我的意思是1001 >1等于2481298241 > 2481297241。
请解释一下为什么会有这样奇怪的行为。
假设我们有N个数字(整数,浮点数,任何你想要的),并且想要找到它们的算术平均值。最简单的方法是将所有值相加,然后除以值的数量:
def simple_mean(array[N]): # pseudocode
sum = 0
for i = 1 to N
sum += array[i]
return sum / N
它工作得很好,但需要大整数。如果我们不想要大整数,并且我们可以接受舍入误差,并且N是2的幂,我们可以使用‘分而治之’:((a+b)/2 + (c+d)/2)/2 = (a+b+c+d)/4,((a+b+c+d)/4 + (e+f+g+h)/4)/
我正在尝试调试这段代码,并从中学到一点。我知道它为i生成了3个唯一的值,但是为什么sum的值会变得这么大呢?
如果我运行并调试它,它就会变成这样。它保持更改,因为值是随机选择的。
i = 6 i = 26 i = 38
test_num = 274945015872
输出: 100000000000100000000000000000001000000
为什么test_num 274945015872的值?然后使用此值生成39-bit二进制字符串。比如怎么做?
有人能解释一下吗?
这里是代码:
test_num = sum(1<<i for i in random.sample(r
好的,所以我正在尝试解决这个问题:
利用我对c的了解,我想出了下面的代码:
#include <stdio.h>
#include <conio.h>
long double factorial(int);
int main()
{
long double num[100], fact[100];
int i = 0, ex;
scanf("%d", &ex);
for ( i = 0; i < ex; i++ )
{
scanf("%lf", &num[i]
我有一个程序,如下所示,对所有操作都是一样的。它开始显示这个菜单:
Enter + for add
Enter - for subtract
Enter * for multiplicaiton
Enter ! for factorial
Enter the operation you want:
在这里,我们可以键入一个操作并单击enter。例如,如果我们键入"+“,就会得到:
Enter the number of elements to add:
我们可以选择任何数字,例如2,来和两个元素。该项目要求:
Please enter 2 numbers, one at a t
#include <stdio.h>
int add(int a, int b)
{
int c =a+b;
return c;
}
int main()
{
int a=20,b=45;
int (*p)(int , int);
p=&add;
printf("%d\n%d\n%d\n\n",*add,&add,add);
printf("%d\n%d\n%d\n\n"
我是C++的新手,对于下面的代码,我对C++的行为感到困惑:
#include <iostream>
void hello(unsigned int x, unsigned int y){
std::cout<<x<<std::endl;
std::cout<<y<<std::endl;
std::cout<<x+y<<std::endl;
}
int main(){
int a = -1;
int b = 3;
hello(a,b);
return 1
为什么在添加两个数字时,java将字节或短数据类型转换为int?
byte a = 10;
byte b = 20;
byte c = a + b; // Compile Time Error
byte c = (byte) a + b; //Should do typecasting
10 + 20 = 30,字节可以容纳til 127,那么为什么它要转换为int类型呢?
我注意到,在Visual中,将double添加到long long时会出现精度错误。例如:
long long a = 44981600439878676;
double b = 234567890;
a += b;
A的结果是44981600674446560,但应该是44981600674446566。x32和x64都会发生这种情况。
但是,以下内容返回正确的值:
long long a = 44981600439878676;
double b = 234567890;
a += (long long)b;
我在反汇编中注意到,在第一个没有显式强制转换的情况下,
0116A892 ca
我用C写了这个函数。
这两种说法等同吗?
void dot_prod(float *A, int m, float *B, float *C) {
int i, j, z, k;
for (i = 0; i < m; i++) {
for (j = 0; j < m; j++) {
for (k = 0; k < m; k++) {
C[i * m + k] += A[i * m + j] * B[m * j + k];
//*(C + i * m + k)
public class Container {
private int value;
public Container(int value){
this.value=value;
}
public int getValue(){
return this.value;
}
public int sum(Container c){
return this.value+c.getValue();
}
public void main(){
Container c1=ne
在这种情况下:
float a = 0.99999f;
int b = 1000;
int c = a + b;
结果是c = 1001。我发现发生这种情况是因为b被转换成浮点(特定于iOS),那么a + b对于1000.9999没有足够的精度,并且(为什么?)被舍入到更高的值。如果a是0.999f,我们得到c = 1000 -理论上正确的行为。
所以我的问题是,为什么浮点数四舍五入到更高的值?在哪里描述这种行为(或约定)?
我在iPhone模拟器,AppleLLVM4.2编译器上测试了这一点。
这个问题在许多情况下都得到了很大的讨论。当我搜索和阅读一些帖子时。我被后面的帖子弄糊涂了。
以下是最初的问题。
unsigned int u = 1234;
int i = -5678;
unsigned int result = u + i;
答案只是引用了"6.3.1.8通常的算术转换“点3,即,
否则,如果具有无符号整数类型的操作数的秩大于或等于另一个操作数类型的秩,则带符号整数类型的操作数转换为无符号整数类型的操作数类型。
但是,如果我的理解是正确的,那么整数提升应该在考虑到“通常的算术转换”之后,在之前进行。
这方面的规则是
如果int可以表示原始类型的所有值,则
在C中,你可以执行一个简单的:
int a = b + c;
现在,如果a大于2^32 (或者可能是2^31+1),您可以将代码更改为:
long a = b + c;
或
unsigned long a = b + c;
但是你将如何实现加法,比如:
bigint a = b + c;
其中bigint是用于存储和计算大整数(数百位数长度的数字)的某种类/类型定义/结构。如果你只是想用标准的手写小数方法将数字相加,你可以在等式中做无限长的数字。但是回到计算机科学,如何使用二进制、高效的方法来进行无限长的计算(假设有足够的RAM可用)
更重要的是,有没有一种不会太慢的方法呢?