任务描述

在数论中，Carmichael的函数 λ取正整数  Ñ并返回最小正整数ķ使得ķ的每个整数次幂互质到Ñ等于1个模Ñ。

给定正整数n，您的解决方案必须计算λ（n）。以字节为单位的最短代码获胜。

从理论上讲，您的程序应该可以为任意大的输入工作，但是并不需要高效。

提示

所有λ（n）的序列为OEIS A002322。

非高尔夫的Python实现看起来像

from fractions import gcd

def carmichael(n):
    coprimes = [x for x in range(1, n) if gcd(x, n) == 1]
    k = 1
    while not all(pow(x, k, n) == 1 for x in coprimes):
        k += 1
    return k

（在Python中，pow(A, B, C)有效地进行计算pow(A, B) % C。）

测试用例

Input    Output
1        1
2        1
3        2
10       4
35       12
101      100
530      52
3010     84
6511     3056
10000    500

Mathematica，16个字节

CarmichaelLambda

好...

Python，76 73 67字节

f=lambda n,k=1:1-any(a**-~k*~-a**k%n for a in range(n))or-~f(n,k+1)

在线尝试！

通过返回True而不是1可以保存另一个字节。

替代实施

使用相同的方法，@feersum还有以下实现，它不使用列表推导。

f=lambda n,k=1,a=1:a/n or(a**-~k*~-a**k%n<1)*f(n,k,a+1)or-~f(n,k+1)

请注意，此实现需要O（^nλ（n））时间。效率可以大大提高，而实际上将分数降低到66个字节，但是该函数将为输入2返回True。

f=lambda n,k=1,a=1:a/n or~-a**k*a**-~k%n<1==f(n,k,a+1)or-~f(n,k+1)

背景

定义和符号

所有使用的变量将表示整数；n，k和α表示正整数；和p会表示了积极的总理。

一个| b如果b是整除一个，即，如果有q使得B = QA。

一个≡B（MOD M）如果一个和b具有相同的残基模米，即，如果M | a-b。

λ（N）是最小ķ使得一个^ķ ≡1（MOD N） -即，使得N | 一个^ķ - 1 -对于所有一个是互质Ñ。

F（N）是最小ķ使得一个^{2K + 1} ≡一个^{K + 1}（MOD N） -即，使得N | a ^{k + 1}（a ^k -1） –对于所有a。

λ（n）≤f（n）

修复n并将a设为n的互质。

根据f的定义，n | a ^f（n）+1（a ^f（n） -1）。由于一个和ñ没有一个共同的主要因素，无论是做一个^F（N）+1和ñ，这意味着N | 一个^f（n） -1。

由于λ（n）是最小整数k，因此n | n 对于与n互质的所有整数a 的^k -1，得出λ（n）≤f（n）。

λ（n）= f（n）

由于我们已经建立了不等式λ（n）≤f（n），因此足以验证k =λ（n）满足定义f的条件，即n | 一个^{λ（n）的1}（一个^λ（N） - 1）对于所有一个。为此，我们将建立p ^α | 一个^{λ（n）的1}（一个^λ（N） - 1）每当p ^α | n。

λ（k）| λ（n）每当k | Ñ（源），因此（A ^λ（k）的 - 1）（一个^{λ（N）-λ（k）的} +一个^{λ（N）-2λ（K）} +⋯+一个^λ（k）的 + 1）=一^λ（N） - 1，因此，一个^λ（k）的 - 1 | 一个^λ（N） - 1 | 一个^{λ（n）的1}（一个^λ（N） - 1） 。

如果一个和p ^α是互质，通过定义λ和上述中，p ^α | 一个^{λ（P α）} - 1 | 根据需要跟随一个^λ（n）+1（^aλ（n） -1）。

如果α= 0，则一^{λ（n）的1}（一个^λ（N） - 1）= 0，这是通过所有整数整除。

最后，我们必须考虑这样的情况一和p ^α都有一个共同的主要因素。由于p为素数，这意味着P | 一个。卡迈克尔定理确定，如果p> 2或α<3，则λ（^pα）=（p-1）^pα-1，否则，λ（^pα）= ^pα-2。在所有情况下，λ（^pα）≥pα ^- 2≥2α ^-2 >α-2。

因此，λ（N）+ 1≥λ（P ^α）+ 1>α - 1，因此λ（N）+ 1≥α和p ^α | p ^λ（N）+1 | 一个^λ（N）+1 | 一个^{λ（n）的1}（一个^λ（N） - 1） 。这样就完成了证明。

怎么运行的

尽管f（n）和λ（n）的定义考虑了a的所有可能值，但足以测试[0，...，n-1]中的值。

当F（N，K）被调用时，它计算一个^{K + 1}（一个^ķ - 1）％N为的所有值一个在该范围内，这是0，当且仅当N | a ^{k + 1}（a ^k -1）。

如果所有计算的残差均为零，则k =λ（n）并any返回False，因此f（n，k）返回1。

另一方面，当k <λ（n）时，1-any(...)将返回0，因此f以递增的值k递归调用。前导-~使f（n，k + 1）的返回值递增，因此对于[1，...，λ（n）-1中的每个整数，我们将1加到f（n，λ（n））= 1一次]。因此，最终结果为λ（n）。

没有内置的Mathematica，58 57字节

感谢Martin Ender发现错误，然后为我保存了修复它所需的字节！

感谢Miles节省1个字节！（对我来说好像是2）

内建函数很好...但是对于那些想要在不使用暴力的情况下实现它的人来说，这是Carmichael函数的公式：

LCM@@(EulerPhi[#^#2]/If[#==2<#2,2,1]&@@@FactorInteger@#)&

如果p是素数，则Carmichael函数λ（p ^ r）等于φ（p ^ r）=（p-1）* p ^（r-1），除非 p = 2和r≥3，在这种情况下一半，即2 ^（r-2）。

并且如果n的素数功率因式分解等于p1 ^ r1 * p2 ^ r2 * ...，则λ（n）等于{λ（p1 ^ r1），λ（p2 ^ r2），.. }。

运行时比首先考虑整数要多一刻。

认为有害的模板，246个字节

Fun<Ap<Fun<If<Eq<A<2>,T>,A<1>,And<Eq<Ap<Fun<If<A<1>,Ap<A<0>,Rem<A<2>,A<1>>,A<1>>,A<2>>>,A<1,1>,A<2>>,T>,Sub<Ap<Fun<Rem<If<A<1>,Mul<A<2,1>,Ap<A<0>,Sub<A<1>,T>>>,T>,A<1,2>>>,A<1>>,T>>,Ap<A<0>,Add<A<1>,T>,A<1,1>>,Ap<A<0>,A<1>,Sub<A<2>,T>>>>,T,A<1>>>

未命名的函数（不是有命名函数）。

这是我的一个被遗忘的方法，由C ++编译器实例化模板解释。在默认的最大模板深度为的情况下g++，它可以执行λ（35），但不能执行λ（101）（惰性评估会使情况更糟）。

Haskell，57 56字节

f n=[k|k<-[1..],and[mod(m^k)n<2|m<-[1..n],gcd m n<2]]!!0

果冻，2个字节

Æc

谢谢你的内置@Lynn

Pyth- 19 18 17字节

@TheBikingViking节省了一个字节。

挺直蛮力。

f!sm*t.^dTQq1iQdQ

在这里在线尝试。

红宝石， 59 56个字节

->x{a=1..x
a.detect{|k|a.all?{|y|x.gcd(y)>1||y**k%x<2}}}

J，28 27字节

[:*./@(5&p:%2^0=8&|)2^/@p:]

Carmichael函数为λ（n），上位函数为φ（n）。

如果p = 2且k > 2否则使用φ（p ^k）= λ（p ^k）=φ（p ^k）/ 2的定义。然后，对于一般的n = p ₁ ^{k ₁} p ₂ ^{k ₂} ⋯ p _i ^{k _i}，λ（n）= LCM [λ（p ₁ ^{k ₁}）λ（p ₂ ^{k ₂}）⋯λ（p _i ^{k _i}）] 。

用法

用于格式化多个输入/输出的额外命令。

   f =: [:*./@(5&p:%2^0=8&|)2^/@p:]
   f 530
52
   (,.f"0) 1 2 3 10 35 101 530 3010 6511 10000
    1    1
    2    1
    3    2
   10    4
   35   12
  101  100
  530   52
 3010   84
 6511 3056
10000  500

说明

[:*./@(5&p:%2^0=8&|)2^/@p:]  Input: integer n
                          ]  Identity function, get n
                    2   p:   Get a table of prime/exponent values for n
                     ^/@     Raise each prime to its exponent to get the prime powers of n
[:    (            )         Operate on the prime powers
                8&|            Take each modulo 8
              0=               Test if its equal to 0, 1 if true else 0
            2^                 Raise 2 to the power of each
       5&p:                    Apply the totient function to each prime power
           %                   Divide it by the powers of 2
  *./@                       Reduce using LCM and return

其实30 28 25 19 26字节

Carmichael函数（λ(n)其中n = p_0**k_0 * p_1**k_1 * ... * p_a**k_a）定义为划分λ(p_i**k_i)为的最大素幂的的最小公倍数（LCM）。给定除质数为之外的所有质数幂，我们使用Carmichael函数等效于Euler totient函数Euler 。对于特殊情况下在那里，我们只是检查，如果分成2如果它确实在节目的开始，和鸿沟。p_i**k_in2λ(n) == φ(n)φ(n)2**kk ≥ 32**3 = 8n

不幸的是，实际上目前还没有内置LCM，所以我制作了蛮力的LCM。欢迎打高尔夫球。在线尝试！

;7&Yu@\w`iⁿ▒`M╗2`╜@♀%ΣY`╓N

开球

         Implicit input n.
;        Duplicate n.
7&       n&7 == n%8.
Yu       Logical NOT and increment. If n%8 == 0, return 2. Else, return 1.
@\       Integer divide n by 2 if n%8==0, by 1 otherwise.
          Thus, we have dealt with the special case where p_i == 2 and e_i >= 3.
w        Full prime factorization of n as a list of [prime, exponent] lists.
`...`M   Map the following function over the prime factorization.
  i        Flatten the array, pushing exponent, then prime to the stack.
  ⁿ▒       totient(pow(prime, exponent)).
╗        Save that list of totients in register 0.
2`...`╓  Get the first two values of n where the following function f(n) is truthy.
         Those two numbers will be 0 and our LCM.
  ╜@       Push the list in register 0 and swap with our n.
  ♀%       Get n mod (every number in the list)
  Σ        Sum the modulos. This sum will be 0, if and only if this number is 0 or LCM.
  Y        Logical NOT, so that we only get a truthy if the sum of modulos is 0.
N        Grab the second number, our LCM. Implicit return.

的JavaScript（ES6），143个 135字节

编辑：由于尼尔节省了8个字节

使用函数式编程的实现。

n=>(A=[...Array(n).keys()]).find(k=>k&&!c.some(c=>A.slice(0,k).reduce(y=>y*c%n,1)-1),c=A.filter(x=>(g=(x,y)=>x?g(y%x,x):y)(x,n)==1))||1

取消评论

n =>                                          // Given a positive integer n:
  (A = [...Array(n).keys()])                  // Build A = [0 ... n-1].
  .find(k =>                                  // Try to find k in [1 ... n-1] such as
    k && !c.some(c =>                         // for each coprime c: c^k ≡ 1 (mod n).
      A.slice(0, k).reduce(y =>               // We use reduce() to compute
        y * c % n, 1                          // c^k mod n.
      ) - 1                                   // Compare it with 1.
    ),                                        // The list of coprimes is precomputed
    c = A.filter(x =>                         // before the find() loop is executed:
      (                                       // for each x in [0 ... n-1], keep
        g = (x, y) => x ? g(y % x, x) : y     // only integers that verify:
      )(x, n) == 1                            // gcd(x, n) = 1
    )                                         // (computed recursively)
  ) || 1                                      // Default result is 1 (for n = 1)

演示版

尽管它确实适用于6511和10000，但由于它运行缓慢，因此我不会在此处包括它们。

let f =
n=>(A=[...Array(n).keys()]).find(k=>k&&!c.some(c=>A.slice(0,k).reduce(y=>y*c%n,1)-1),c=A.filter(x=>(g=(x,y)=>x?g(y%x,x):y)(x,n)==1))||1

console.log(f(1));     // 1
console.log(f(2));     // 1
console.log(f(3));     // 2
console.log(f(10));    // 4
console.log(f(35));    // 12
console.log(f(101));   // 100
console.log(f(530));   // 52
console.log(f(3010));  // 84

Ruby，101 86 91 90字节

我的实际答案的一个Ruby端口。欢迎打高尔夫球。

编辑： -4字节从删除，a但+9字节从修复1返回的错误nil。-1字节感谢Cyoce。

require'prime'
->n{((n%8<1?n/2:n).prime_division<<[2,1]).map{|x,y|x**~-y*~-x}.reduce :lcm}

开球

require 'prime'
def carmichael(n)
  if n%8 < 1
    n /= 2
  end
  a = []
  n.prime_division.do each |x,y|
    a << x**(y-1)*(x-1)
  end
  return a.reduce :lcm
end

JavaScript（ES 2016）149

将Python参考实现移植到JS。js中缺少一些花哨的Pyhton内置函数，例如gcd和pow，并且ES 6中的数组理解不是标准的。这在Firefox中有效。

n=>eval('for(g=(a,b)=>b?g(b,a%b):a,p=(a,b,c)=>eval("for(r=1;b--;)r=r*a%c"),c=[for(_ of Array(i=n))if(g(i--,n)<2)i+1],k=1;c.some(x=>p(x,k,n)-1);)++k')

少打高尔夫球

n=>{
  g=(a,b)=>b?g(b,a%b):a
  p=(a,b,c)=>{ 
    for(r=1;b--;)
      r=r*a%c
    return r
  }
  c=[for(_ of Array(i=n)) if(g(i--,n)<2) i+1]
  for(k=1;c.some(x=>p(x,k,n)-1);)
    ++k
  return k
} 

Java 209 207 202 194 192字节

代码（96字节）：

n->{for(int x,k=1,a;;k++){for(a=1,x=0;++x<=n&&a<2;)a=g(x,n)<2?p(x,k,n):1;if(a<2||n<2)return k;}}

额外功能（96字节）：

int g(int a,int b){return b<1?a:g(b,a%b);}int p(int n,int p,int m){return p<2?n:n*p(n,p-1,m)%m;}

测试和取消高尔夫

import java.util.Arrays;
import java.util.function.IntUnaryOperator;

public class Main2 {

  static int g(int a,int b) { // recursive gcd
    return b < 1
        ? a
        : g(b,a%b);
  }

  static int p(int n, int p, int m) { // recursive modpow
    return p < 2
      ? n
      : n * p(n, p - 1, m) % m;
  }

  public static void main(String[] args) {

    IntUnaryOperator f = n -> {
      for(int x,k=1,a;;k++) { // for each k
        for(a=1,x=0;++x<=n&&a<2;) // for each x
          a=g(x,n)<2?p(x,k,n):1; // compute modpow(x,k,n) if g(x,n)
        if(a<2||n<2) // if all modpow(x,k,n)=1. Also check for weird result for n=1.
          return k;
      }
    };

    Arrays.stream(new int[]{1, 2, 3, 10, 35, 101, 530, 3010, 6511, 10000})
        .map(f)
        .forEach(System.out::println);
  }
}

笔记

• 使用的a是一个int比，如果我不得不使用更短的boolean执行我的测试。
• 是的，对于valueOf所有新BigInteger功能而言，它比创建单独的函数要短（有5个，而ONE常量是免费赠品）。
• 算法与@Master_ex的算法不同，因此它不只是打高尔夫球。同样，这种算法的效率要低得多gcd，因为对于相同的值一次又一次地计算。

刮胡子

1. 209-> 207字节：
   • if(...)a=...; -> a=...?...:1;
   • a==1 -> a<2
2. 207-> 202字节
   • 摆脱了BigInteger被打高尔夫球gcd和modPow进行int。
3. 202-> 194字节
   • 循环modPow->递归
4. 194-> 192字节
   • ==1-> <2（似乎适用于所有测试用例，其他数字则不知道。）

Java8 38 19 + 287 295 253 248 241 = 325 333 272 267 260个字节

BigInteger B(int i){return new BigInteger(""+i);}int c(int...k){int n=k[0];for(k[0]=1;n>1&!java.util.stream.IntStream.range(0,n).filter(i->B(n).gcd(B(i)).equals(B(1))).allMatch(x->B(x).modPow(B(k[0]),B(n)).equals(B(1)));k[0]++);return k[0];}

导入，19字节

import java.math.*;

说明

这是直接的实现。互素数是在中计算的Set p，每个人的k次方用于检查它是否等于1模n。

BigInteger由于精度问题，我不得不使用它。

用法

public static void main(String[] args) {
    Carmichael c = new Carmichael();
    System.out.println(c.c(3)); // prints 2
}

不打高尔夫球

// returns the BigInteger representation of the given interger
BigInteger B(int i) {
    return new BigInteger(""+i);
}
// for a given integer it returns the result of the carmichael function again as interger
// so the return value cannot be larger
int c(int... k) {
    int n = k[0];
    // iterate k[0] until for all co-primes this is true: (x^n) mod n == 1, if n==1 skip the loop
    for (k[0]=1;n > 1 && !java.util.stream.IntStream.range(0, n)
                .filter(i -> B(n).gcd(B(i)).equals(B(1)))
                .allMatch(x -> B((int) x).modPow(B(k[0]), B(n)).equals(B(1)));k[0]++);
    return k[0];
}

任何有关打高尔夫球的建议都欢迎:-)

更新资料

• 功能之外没有任何元素可以保持状态
• 遵循OlivierGrégoire的建议，并从中保存了1个字节 B()
• 删除了k()方法和p（互素）Set。
• 删除不需要的强制转换为int。
• 添加了varags，并使用for代替while。

Java中，165个163 158 152 143字节

int l(int n){int k=1,x,a,b,t,d=1;for(;d>0;)for(d=x=0;++x<n;d=a<2&t>1?k++:d){for(a=x,b=n;b>0;b=a%b,a=t)t=b;for(t=b=1;b++<=k;t=t*x%n);}return k;}

我的C实现的另一个端口。

在Ideone上尝试

C ++，208200149144140134字节

[](int n){int k=1,x,a,b,t,d=1;for(;d;)for(d=x=0;++x<n;d=a<2&t>1?k++:d){for(a=x,b=n;t=b;a=t)b=a%b;for(t=1,b=k;b--;t=t*x%n);}return k;};

我的C实现的移植。

在Ideone上尝试

拍框218字节

(λ(n)(let((fl #f)(cl(for/list((i n) #:when(coprime? n i))i)))(for/sum((k(range 1 n))#:break fl)(set! fl #t)
(for((i(length cl))#:break(not fl))(when(not(= 1(modulo(expt(list-ref cl i)k)n)))(set! fl #f)))(if fl k 0))))

非高尔夫版本：

(require math)
(define f
  (λ(n)
    (let ((fl #f)
          (cl (for/list ((i n) #:when (coprime? n i))
                i)))
             (for/sum ((k (range 1 n)) #:break fl)
               (set! fl #t)
               (for ((i (length cl)) #:break (not fl))
                 (when (not (= 1 (modulo (expt (list-ref cl i) k) n)))
                   (set! fl #f)))
               (if fl k 0)))))

测试：

(f 2) 
(f 3)
(f 10)
(f 35)
(f 101)
(f 530)
(f 3010)
(f 6511)
(f 10000)

输出：

1
2
4
12
100
52
84
3056
500

C，278276272265265243140134125字节

k,x,a,b,t,d;l(n){for(k=d=1;d;)for(d=x=0;++x<n;d=a<2&t>1?k++:d){for(a=x,b=n;t=b;a=t)b=a%b;for(t=1,b=k;b--;t=t*x%n);}return k;}

这使用了缓慢的模块化幂运算算法，过于频繁地计算GCD，而不再泄漏内存！

取消高尔夫：

int gcd( int a, int b ) {
  int t;
  while( b ) {
    t = b;
    b = a%b;
    a = t;
  }
  return a;
}
int pw(int a,int b,int c){
  int t=1;
  for( int e=0; e<b; e++ ) {
    t=(t*a)%c;
  }
  return t;
}
int carmichael(int n) {
  int k = 1;
  for( ;; ) {
    int done = 1;
    for( int x=1; x<n; x++ ) {
      if( gcd(x,n)==1 && pw(x,k,n) != 1 ) {
        done = 0;
        k++;
      }
    }
    if( done ) break;
  }
  return k;
}

在Ideone上尝试

公理129字节

c(n)==(r:=[x for x in 1..n|gcd(x,n)=1];(v,k):=(1,1);repeat(for a in r repeat(v:=powmod(a,k,n);v~=1=>break);v<=1=>break;k:=k+1);k)

少打高尔夫球

cml(n)==
 r:=[x for x in 1..n|gcd(x,n)=1];(v,k):=(1,1)
 repeat 
   for a in r repeat(v:=powmod(a,k,n);v~=1=>break)
   v<=1=>break
   k:=k+1
 k

结果

(3) -> [i,c(i)] for i in [1,2,3,10,35,101,530,3010,6511,10000]
   Compiling function c with type PositiveInteger -> PositiveInteger

   (3)
   [[1,1], [2,1], [3,2], [10,4], [35,12], [101,100], [530,52], [3010,84],
    [6511,3056], [10000,500]]
                                             Type: Tuple List PositiveInteger