标签: greatest-common-divisor

我正在尝试使用y-combinator在scala中定义gcd:

object Main {
  def y[A,B]( f : (A => B) => A => B ) : A => B = f(y(f))
  def gcd = y[(Int,Int),Int]( (g) => (x,y) => if (x == 0) y else g(y % x, x) )
}

但我收到一个错误:

Main.scala:3: error: type mismatch;                                                  
 found   : (Int, Int) => Int                                                               
 required: (Int, Int) => Int                                                               
    def gcd = y[(Int,Int),Int]( (g) => (x :Int,y :Int) => if (x == 0) y else g(y % x, x) ) 
                                                       ^ …

我试图做一个程序,将评估3个号码(基地)的最大公约数,和如果GCD base1和base2,base2和base3,和base3和base1都等于1,则evaulate的基地指数范围.基本上,我需要做的是弄清楚他们的GCD是否等于1,然后计算数字到权力.这是它的样子:

bases = 150
powers = 150
base1 = all numbers 1-bases
base2 = all numbers 1-bases
base3 = all numbers 1-bases
if the GCD of all combinations = 1
    do base1^all numbers 3-powers
    do base2^all numbers 3-powers
    do base2^all numbers 3-powers
    then store all of those in an array

现在,我尝试使用可怕的for循环,但它非常慢,我不认为它是一个解决方案.只有当基数和功率为10或更低时,它才能快速起作用.如何在不使用for循环的情况下执行此操作？或者,如果我必须使用for循环,我如何减少使用的数量？我能计算出3个GCD组合中的数字是1吗？for我试过的循环如下:

for i = 1:numbers
    for j = 1:numbers
        for …

如何以最快的方式找到{1,2,...,n}的LCM,其中0 < n < 10001.一种方法是计算n!/ gcd(1,2,.....,n)但这可能很慢,因为测试用例的数量是t <501,输出应该是LCM(n!)%1000000007

代码相同的是:

#include<bits/stdc++.h>
using namespace std;
#define p 1000000007;
int fact[10001] = {1};
int gcd[10001] = {1};

int main()
{
    int i, j;
    for( i = 2;i < 10001; i++){
        fact[i] = ( i * fact[i-1]) % p;
    }
    for(i=2 ;i < 10001; i++){
        gcd[i] =__gcd( gcd[i-1], i );
    }

    int t;
    cin >> t;

    while( t-- ) …

我在Interview Bit上解决了时间复杂度问题,如下图所示.

给出的答案是?(theta)(logn),我无法掌握登录术语如何到达此计划的时间复杂性.

有人可以解释一下logn的答案是什么？

给定一个正数数组。我想将数组拆分为2个不同的子集，以使它们的gcd（最大公约数）的总和最大。

数组示例：{6,7,6,7}。

答案：两个必需的子集是：{6,6}和{7,7}; 它们各自的gcd是6和7，它们的sum = 6+7=13；这是最大可能的gcd总和。

GCD：的GCD {8,12}是{4}作为图4是其将8以及12中的最大数目。

注意：gcd(X)=X如果子集仅包含一个元素。

我的方法：通过暴力破解，找到数组的所有可能子序列，然后找到最大和，但是如果输入大小大于30个数字，则此方法不起作用。我正在寻找一种更有效的方法。

额外：任何输入数字的最大大小为10 ^ 9，时间限制：-1s似乎不错，输入大小可能高达10 ^ 5

int lcm_old(int a, int b) {
    int n;
    for(n=1;;n++)
        if(n%a == 0 && n%b == 0)
            return n;  
}

int lcm(int a,int b)  {
    int n = 0;
    __asm {
lstart:
        inc n;
        mov eax, n;
        mov edx, 0;
        idiv a;
        mov eax, 0;
        cmp eax, edx;
        jne lstart;
        mov eax, n;
        mov edx, 0;
        idiv b;
        mov eax, 0;
        cmp eax, edx;
        jnz lstart;
    }
    return n;
}

我试图用我自己的函数(底部)击败/匹配顶部函数的代码.您有什么想法可以优化我的日常工作吗？

PS.这只是为了好玩.

我想为数字列表计算gcd。但是我不知道我的代码有什么问题。

A = [12, 24, 27, 30, 36]


def Greatest_Common_Divisor(A):
    for c in A:
        while int(c) > 0:
            if int(c) > 12:
                c = int(c) % 12
            else:
                return 12 % int(c)
    print Greatest_Common_Divisor(A)

我正在尝试创建一个处理非常大的数字的gcd函数.因此,到目前为止我尝试的任何事情都会导致错误.例如 :

fun gcd(a : Int.toLarge, b : Int.toLarge): Int.toLarge =
  if   b = 0
  then a
  else gcd(b, a mod b)` 

给我以下错误:

Error:unbound type constructor : toLarge in path Int.toLarge

有人可以给我一些建议,我的程序的其余部分似乎工作正常.先感谢您 !

作为练习，我尝试自己编写此代码，但是我被卡住了，不知道代码中的错误在哪里。

module Hf where

--sumSquaresTo :: Integer -> Integer
--sumSquaresTo x = sum [ n^2 | n <- [1..x] ]

divides a b = b `mod` a == 0

divisors a = [n | n <- [1..a], n `divides` a ]


lnko :: Integer -> Integer -> Integer
lnko a b = [n | n <- [1..max(a b)], (n `divides` a) && (n `divides` b) ]

GHCI输出：

error:
    * Couldn't match expected type `Integer'
                  with actual type `[a0 -> a0]' …

我有一个由 M 个整数组成的数组。我必须找到所有可能的整数 K（假设至少有 1 K），使得：

1) K > 1
2) arr[0]%K = arr[1]%K = arr[2]%K = ... = arr[M-1]%K 

这个问题的最佳算法是什么？