挑战

给定一个整数，n作为输入where 36 >= n >= 2，输出base中有多少个Lynch-Bell数字n。

输出必须以10为底。

林奇贝尔数字

在以下情况下，数字是Lynch-Bell数字：

• 其所有数字都是唯一的（无重复数字）
• 该数字可被其每个数字整除
• 它不包含零作为其数字之一

因为所有数字都必须是唯一的，并且每个基数中都有一组有限的单位数字，所以林奇-贝尔数字是有限的。

例如，在基数2中，只有一个Lynch-Bell号码1，因为所有其他号码要么重复数字，要么包含0。

例子

Input > Output
2 > 1
3 > 2
4 > 6
5 > 10
6 > 10
7 > 75
8 > 144
9 > 487
10 > 548

Mathematica Online在10以上的内存不足。您可以使用以下代码生成自己的代码：

Do[Print[i," > ",Count[Join@@Permutations/@Rest@Subsets@Range[#-1],x_/;And@@(x\[Divides]FromDigits[x,#])]&[i]],{i,10,36,1}]

获奖

以字节为单位的最短代码获胜。

果冻，13个字节

Q⁼g
*`Ṗ©bç"®S

在线尝试！

另一个O（n ⁿ）解。

说明

Q⁼g  Helper link. Input: digits (LHS), integer (RHS)
Q    Unique (digits)
 ⁼   Match
  g  GCD between each digit and the integer

*`Ṗ©bç"®S  Main link. Input: integer n
*`         Compute n^n
  Ṗ        Pop, forms the range [1, n^n-1]
   ©       Store previous result in register
    b      Convert each integer to base n
     ç"    Call the helper link, vectorized, with
       ®   The register's value
        S  Sum

果冻，15字节

*ḃ€’Q€Qḍḅ¥€⁸Ạ€S

在线尝试！

复杂性。O(nn)

Java中，222个 212 190字节

-10字节感谢Herman

-22字节感谢Kevin

import java.util.*;a->{int c=0,i=1;A:for(;i<Math.pow(a,a);i++){Set g=new HashSet();for(char b:a.toString(i).toCharArray())if(!g.add(b)|b<49||i%a.parseInt(b+"",a)>0)continue A;c++;}return c;}

取消高尔夫：

a -> {
    int count = 0;
    OUTER:
    for (int i = 1; i < Math.pow(a, a); i++) {
        Set<Character> found = new HashSet<>();
        for (char b : Integer.toString(i, a).toCharArray()) {
            if (!found.add(b) || b == 48 || i % Integer.parseInt(b + "", a) != 0) {
                continue OUTER;
            }
        }
        count++;
    }
    return count;
}

在线尝试！

大量时变得非常慢。

Perl 6的，86个 84 77字节

-2字节感谢Ramillies

->\n{n-1+grep {.Set==$_&&.reduce(* *n+*)%%.all},map {|[X] (1..^n)xx$_},2..^n}

在线尝试！

在TIO上适用于n = 8。

实际上，24个字节

;╗DR⌠╜DR╨i⌡M⌠;╜@¿♀%ΣY⌡MΣ

在线尝试！

说明

该程序包括两个主要部分：排列生成和Lynch-Bell测试。因此，为了更清楚起见，此解释将分别查看每个部分。

产生排列

输入：（中n的整数[2, 36]）

输出：的所有部分和全部置换[1, n-1]（包含[1, n-1]，长度为的无重复值的序列[1, n-1]）

;╗DR⌠╜DR╨i⌡M
;╗            store a copy of n in register 0
  DR          range(1, n)
    ⌠╜DR╨i⌡M  do the following for each element k in range:
     ╜DR        range(1, n)
        ╨       k-permutations of [1, n-1]
         i      flatten

林奇贝尔测试

输入：n基数列表，以基数列表n表示

输出：以基数计的林奇·贝尔数 n

⌠;╜@¿♀%ΣY⌡MΣ
⌠;╜@¿♀%ΣY⌡M   for each base-n digit list a:
 ;╜             duplicate a, push n
   @¿           convert a from base-n to decimal
     ♀%         modulo a with each of its base-n digits
       Σ        sum
        Y       boolean negation (1 if all modulo results are 0, else 0)
           Σ  sum (count the 1s in the resultant list)

Mathematica，82 79 76字节

Count[Join@@Permutations/@Subsets@Range[#-1],x_/;x==x~FromDigits~#~GCD~x]-1&

05AB1E，22字节

mLIBε0KÙ}ÙvyIöySIö%O_O

在线尝试！

O_O 终于奏效时也是我的脸

<ÝIBJ0Kæ¦Ù€œ˜ 速度比我在实际答案中生成数字的方式快，但是随机停止大于7的工作（没有明显的原因？）

说明

mLIBε0KÙ}ÙvyIöySIö%O_O # (input = i)
m                      # Push i^i
 L                     # ...and get a range from one to this value
  IB                   # Map every element to their base i representation
    ε   }              # Map every element to ...
     0K                 # Itself without 0s
       Ù                # ...and only unique digits
         Ù             # Uniquify the resulting list
          v            # For each element...
           yIö          # Push it converted to base 10
              ySIö      # Push every digit of it converted to base 10 in a list
                  %     # Calculate the modulo for each digit
                   O    # Sum all results together
                    _   # Negate: Returns 0 for every positive number and 1 for 0
                     O  # Sum with the rest of the stack (Basically counting all Lynch-Bell-Numbers)
                       # Implicit print

Perl 5中，80 76个字节（75 + -p）

$\+=!grep$_?$;%$_|$|{0,$_}++:1,@@until($@[$}++]+=1)%=$_ and++$;,$}=$}==$_}{

滥用$;乐趣和利润。输入超时> 8。

编辑：通过合并两个循环-4字节。

红宝石，80 65字节

->n{(1..n**n).count{|i|(d=i.digits n)-[0]==d|d&&d.sum{|j|i%j}<1}}

在线尝试！

多亏了GB的-15个字节。

Japt -x，25 19字节

-6个字节，感谢Shaggy

pU õìU ËeDâ f myDìU

在线尝试！

Python 3中，204个 174字节

lambda x,r=range,i=chain:sum(0**any(int(''.join(map(str,y)),x)%z for z in y)for y in i(*map(permutations,i(*[combinations(r(1,x),e)for e in r(x)]))))-1
from itertools import*

在线尝试！

对于范围（1，n）的幂集的每个元素的每个排列（无零，唯一），将数字字符串转换为以n为底的数字。对所有可被每个数字整除的数求和，由于幂集生成空集而将其减去1。

-30个字节，感谢@ovs！

Haskell，117个字节

f n=sum[1|x<-id=<<[mapM(\_->[1..n-1])[0..m]|m<-[0..n]],all(\y->[mod(sum(zipWith((*).(n^))[0..]x))y|c<-x,c==y]==[0])x]

在线尝试！在n=7超时之前可以在TIO上工作。

Perl 5，108 +1（-p）= 109字节

while(@a<$_){$r=%k=@a=();for($t=++$i;$t;$t=int$t/$_){push@a,$t%$_}$r||=!$_||$i%$_||$k{$_}++for@a;$r||$\++}}{

在线尝试！

是猪 不知道它是否会在不超时的情况下在基于TIO的基础上做更多的事情。

C＃（Visual C＃交互式编译器），144字节

n=>{int j,i,p;for(j=i=0;i++<~0UL;){p=i;var a=new List<int>();for(;p>0;p/=n)a.Add(p%n);j+=a.All(c=>c>0&&i%c<1&a.Count(x=>x==c)<2)?1:0;}return j;}

遍历从0到的所有数字ulong.MaxValue，并选择指定基数中属于Lynch-Bell的数字。尽管~0UL将for循环中的部件设置为较小的值，也要花很长时间才能运行，即使将它设置为2，也可以在一分钟之内在TIO上获得多达7个输入的输出。

在线尝试！