小编Pau*_*kin的帖子

我最近遇到了以下问题:我们给出一个整数的整数序列x_i (x_i < 2^60),n (n < 10^5)一个整数S (S < 2^60)找到最小的整数a,以便以下成立:

.

例如:

x = [1, 2, 5, 10, 50, 100]
S = 242

可能的解决方案a是21,23,37,39,但最小的是21.

(1^21) + (2^21) + (5^21) + (10^21) + (50^21) + (100^21)
= 20 + 23 + 16 + 31 + 39 + 113 
= 242

Golang中如何通过另一个值的reflect.Type来转换值类型可能是这样的：

func  Scan(value interface{}, b string) error {
    converted := value.(reflect.TypeOf(b)) // do as "value.(string)"
    return nil
}

如何在 golang 中正确地做到这一点？

我认为在ISO/IEC 9899:TC3 C标准的第6.2.6.2节中描述整数类型的符号位有错误

对于有符号整数类型,对象表示的位应分为三组:值位,填充位和符号位.不需要任何填充位; 应该只有一个符号位.作为值位的每个位应具有与相应无符号类型的对象表示中的相同位相同的值(如果有符号类型中有M个值位且无符号类型中有N,则M≤N).如果符号位为零,则不应影响结果值.如果符号位为1,则应以下列方式之一修改该值:

• 符号位0的相应值被否定(符号和幅度);
• 符号位的值为 - (2 ^ N)(二进制补码);
• 符号位的值为 - (2 ^ N - 1)(补码)

在上一节中,N被定义为有符号类型中的值位数,但这里是无符号类型中的值位数.

以signed char每字节8位和2位补码为例,这表示符号位的值为 - (2 ^ 8)= -256而不是 - (2 ^ 7)= -128.

我认为标准应该在初始段落中切换M和N,或者更改符号位的定义以使用M:

• 符号位的值为 - (2 ^ M)(二进制补码);
• 符号位的值为 - (2 ^ M - 1)(补码)

我错过了什么,或者这是一个错误？

我最近试图找出导致C 语言和同族其他语言中块（复合语句）使用大括号的原因。

认为像数组的方括号或括号来改变运算符优先级似乎来自用于这些事物的数学 符号，所以这对我来说是有意义的。分号也很有意义，它的作用是将相关的句子与独立的子句分开，它的作用与 C 中的类似。

但我找不到与花括号类似的东西：它们用于数学中的集合，并且在某种程度上相似的是它们在乐谱（合奏五线谱）中的使用，其中它们用于指示所有五线谱上的音乐是同时播放（不完全相同的用法，但我认为它比它们在数学中的集合更接近）。

另外，我想知道 C 是否实际上是第一个引入这种块语法的语言，或者它只是普及了它？

我正在尝试计算nCr模p,其中p是素数.

我尝试过的一种方法是计算n!/(r!*(nr)!)模p使用乘法反转,但当r或n -r大于或等于p时,这会失败,因为因子则是零模p并且反转不存在.

什么方法适用于所有情况,而不仅仅是在存在乘法反转的情况下？

我想我在审查其他人的代码方面相当不错......但我不知所措.这来自Doom3 Math库.我相信自从Quake 1以来,这可能存在于GPL中.请注意,这确实引用了math.h. 我猜有一些方法,这实际上计算余弦......但我无法弄明白.谁解释一下？

    ID_INLINE float idMath::Cos16( float a ) {
    float s, d;

    if ( ( a < 0.0f ) || ( a >= TWO_PI ) ) {
        a -= floorf( a / TWO_PI ) * TWO_PI;
    }
#if 1
    if ( a < PI ) {
        if ( a > HALF_PI ) {
            a = PI - a;
            d = -1.0f;
        } else {
            d = 1.0f;
        }
    } else {
        if ( a > PI + HALF_PI …

我想创建一对如pair(string, int).我知道在go中没有对类型,我也知道切片只能保存相同的数据类型.

我怎么能这样做？

在从地图中删除项目之前,我是否先放锁？

package main

import ( 
    "errors"
    "sync"
    "time"
)

type A struct {
    Error error
}

func (a *A) Job() {
//    ... more job
}

var l sync.RWMutex

func generate() {
    l.Lock()
    values["key1"] = A{}
    l.Unlock()
    l.Lock()
    values["key2"] = A{}
    values["key3"] = A{}
    l.Unlock()
 //   ...
    l.Lock()
    values["key1919"] = A{Error: errors.New("oh...")}
    l.Unlock()
 //   ...
    l.Lock()
    values["key99999999999"] = A{}
    l.Unlock()
}

var values map[string]A

func main() {
    values = make(map[string]A)
    go generate()

    for {
        l.RLock()
        for key, value := range …

输入：

k-> number of lists
m->modulo
Constraints
1<=k<=7
1<=M<=1000
1<=Magnitude of elements in list<=10*9
1<=Elements in each list<=7
` 

这段代码负责最大化从列表(x1^2 + x2^2 + ...) % m中x1, x2, ...选择的位置X1, X2, ...

k,m=map(int,input().split())
Sum=0
s=[]
for _ in range(k):
    s.append(max(map(int,input().split())))
    Sum+=int(s[_])**2
print(Sum%m)

例如，如果输入是：

3 1000
2 5 4
3 7 8 9 
5 5 7 8 9 10 

输出将为 206，因为选择每个列表中的最高元素，对该元素求平方，求和并使用以下命令执行模运算m

所以，那就是(5^2+9^2+10^2)%1000=206

如果我提供类似的输入，

3 998
6 67828645 425092764 242723908 669696211 501122842 438815206
4 625649397 295060482 262686951 …

如果散列表包含N个不同的项,并且没有重载,则N个项的散列必须具有大约lg(N)位,否则太多项将获得相同的散列值.

但是哈希表查找通常被认为平均花费O(1)时间.

在O(1)时间内不可能生成lg(N)位,因此散列表复杂性的标准结果是错误的.

我的推理有什么问题？

我编写的代码旨在打印出地图中的键和值.

kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
    fmt.Println("%s -> %s\n", k, v)
}

我期待输出为:

a -> apple
b -> banana

但输出实际上是:

%s -> %s
a apple
%s -> %s
b banana

我正在尝试使用java来解决Fibonacci,但是我的代码需要很长时间才能使用大数字.

问题描述任务.给定一个整数,找到thFibonacci数的最后一位数 (that is, mod 10).

Input Format. The input consists of a single integer .

Constraints. 0 ? ? 10?.

输出格式.输出最后一位数.

我的代码:

public class FibonacciLastDigit {

private static int getFibonacciLastDigitNaive(int n) {
    if (n <= 1) {
        return n;
    }
    BigInteger first = BigInteger.ZERO;
    BigInteger second = BigInteger.ONE;
    BigInteger temp;

    for (int i = 1; i < n; i++) {
        temp = first.add(second);
        first = second;
        second = temp;
    }
    return second.mod(BigInteger.TEN).intValue();
}

public static void …

当使用 gcc 和最大优化（GCC 11.1.0，gcc -std=c11 -O3）编译这两个片段时，我希望获得完全相同的可执行文件，因为%2和&1操作是等效的。objdump但是，在用 反汇编之后，两个目标文件有所不同。输出如下所示。

和

int main(int argc, char **argv){
   return argc & 1;
}

0000000000001020 <main>:
    1020:       89 f8                   mov    %edi,%eax
    1022:       83 e0 01                and    $0x1,%eax
    1025:       c3                      ret    
    1026:       66 2e 0f 1f 84 00 00    cs nopw 0x0(%rax,%rax,1) 

模数

0000000000001020 <main>:
    1020:       89 f8                   mov    %edi,%eax
    1022:       83 e0 01                and    $0x1,%eax
    1025:       c3                      ret    
    1026:       66 2e 0f 1f 84 …