生成星期一号码

35

在这个问题上，由Gamow定义的星期一数字是正整数N，具有以下三个属性：

  • N的十进制表示形式不包含数字0
  • N的十进制表示形式两次不包含任何数字
  • N可被以十进制表示形式出现的每个数字D整除

请注意，这些在OEIS中也称为Lynch-Bell编号。

例子：

  • 15是一个星期一数字，因为它可以被1和整除，5并且满足其他两个条件
  • 16不能，因为它不能被整除6。
  • 该数字22不是，因为尽管它满足条件1和3，但没有满足条件2。

这是让您入门的前25个星期一数字的列表（共有548个）：

1 2 3 4 5 6 7 8 9 12 15 24 36 48 124 126 128 132 135 135 162 168 175 184 216 248

这里的挑战是编写最短的代码来生成星期一数字的完整序列，范围从1到9867312（在该问题上证明是最大的可能）。

您的代码应不带输入，而输出应为STDOUT或同等格式，并选择分隔符。所有常用的代码高尔夫球规则均适用，并且禁止标准漏洞。

排行榜

显示代码段

code-golf  number  sequence 
— AdmBorkBork
source
5
— FryAmTheEggman
1
也称为Lynch-Bell数字。
— Geobits，2015年
@Geobits谢谢-由于某些原因，我在OEIS上找不到它。
— AdmBorkBork 2015年
8
您应该昨天就发布了此挑战...
— mbomb007'9
2
@ mbomb007我本来应该-直到今天早上才看到Gamow的问题！
— AdmBorkBork 2015年

Answers:

1

果冻，8字节

ȷ7Dg⁼QƲƇ

不到八分钟即可在本地运行。

在线尝试！（已修改以查找六位数或更少的数字）

怎么运行的

ȷ7Dg⁼QƲƇ  Main link. No arguments.

ȷ7        Set the return value to 10**7.
       Ƈ  Comb; promote 10**7 to [1, ..., 10**7], then keep only those n in the range
          for which the link to the left returns a truthy value.
      Ʋ     Combine the four links to the left into a monadic chain.
  D           Decimal; yield n's digit array in base 10.
   g          Take the GCD of each digit and n.
     Q        Yield the unique digits of n.
    ⁼         Test both results for equality.
— 丹尼斯
source
16

Python 2，85个字节

print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]

打印列表。

我基本上是将我对先前挑战的两个答案结合在一起：

感谢xsot通过更好地组合条件节省了1个字节。

— 异或
source
您可以保存一个字节：print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]
— xsot
11

Perl，61个 47字节

46字节代码+ 1字节命令行参数。

/(.).*\1|0/||1*s/./$_%$&/rge||print for 1..1e7

用法：

perl -l entry.pl

说明

/(.).*\1|0/ 如果被测数字包含重复字符或0，则返回1

s/./$_%$&/rge用被测数字％的值替换每个数字。例如15-> 00、16-> 04（因为16％6 = 4）。这意味着任何可被其所有数字整除的输入都将由全0组成，否则它将包含一个数字> 0。为了将其视为一个数字，我们用* 1表示，这意味着如果被测试的所有数字都可以被其所有数字整除，则该数字将返回0。

通过将这两个语句和打印内容用“或”分隔，如果前两个条件中的任何一个返回> 0，则条件匹配，并且表达式的后续部分将不求值。当且仅当先前两个条件都为0时，才执行打印。该-l标志确保在每次打印后添加新行。

— Jarmex
source
非常好。您可以通过将其设置为Perl 5.10并使用say而不是print+ 来节省一些字节-l：-)
— xebtl
谢谢你的建议！我以为首先say 需要一个明确的声明？
— Jarmex 2015年
@Jarmex我可能在这里开始了免费use feature 'say'或use 5.012免费服用的传统-我每次提及时都会提到这一点，而且从未有人挑战过它。我见过其他一些人也这样做:)
— 霍布斯（Hobbs）2015年
2
@hobbs 关于meta的回答说：“到目前为止，关于SO的共识是，“-M5.010在需要时是免费的””。
— xebtl
2
使用map并将say其降低到43：在线尝试！
— Xcali，
10

佩斯22 21

f&.{`T!f%T|vY.3`TS^T7

感谢Jakube精打细算了1个字节的不必要格式。

此CW对相关问题的答案大受启发。

我在这里粘贴了结果，从开始打印换行符开始到现在，它现在打印为pythonic列表。

我建议不要在线尝试，除非您使用的数字小于7。在此链接中，我将其设置为2。

从1到的过滤器10^7-1涵盖所有必需的值。如果此版本无法建立列表S^T7，则可能会导致内存错误，这与list(range(1,10**7))python 3 类似（但是，对我来说很好用）。如果是这样，您可以尝试：

.f&.{`Z.x!s%LZjZT0548

查找前548个星期一的数字。这也演示了另一种检查0数字中s的方法，而不是.3使用try-catch块来替换它们。此版本完全归功于Jakube。（请注意，对于在线解释器来说，这仍然要慢很多）

— 弗莱姆·埃格曼
source
1
这是一个不同的解决方案：.f&.{`Z.x!s%LZjZT0548它比while循环方法快了好几倍（4倍至5倍），而且长度也只有21个字节。
— Jakube 2015年
1
@Jakube Backticks的评论很痛苦，不是吗？：P非常感谢！
— FryAmTheEggman
嗯..您的解决方案似乎不起作用。.在您的TIO链接中，范围为100，它显示55, 66, 77, 88, 99，所有数字均为重复的数字
— 。–
1
@KevinCruijssen不幸的是，自从我发表这篇文章以来，Pyth已经更新了很多次，我找不到改变的地方。您可以在粘贴中看到，这显然曾经起作用过。我认为它可能 .{已被更改，因为将其替换{I似乎可行。
— FryAmTheEggman
@FryAmTheEggman啊，我还没看粘贴。确实已经快三年了，所以难怪事情可能会改变。在这种情况下为+1，因为粘贴可以证明其有效。:)
— Kevin Cruijssen
9

GS2，20 19个字节

gs2使用的字节范围很广，而不仅仅是可打印的ASCII字符。我将以十六进制形式展示我的解决方案。

17 7d 2f 24 65 f1 c8 24 d8 62 e9 65 f4 24 40 90 71 f3 54

这是一些解释。gs2是基于堆栈的语言，因此没有变量。（除了4个寄存器，我在这里使用其中之一）

17         # push constant 7
7d         # 10 raised to the power
2f         # create an array of numbers from 1 to n

    24     # get digits of number into array
    65     # calculate product of array
f1         # filter array by previous block of 2 instructions

    c8     # save top of stack to register a
    24     # get digits of number into array
        d8 # tuck register a under top of stack
        62 # boolean divisibility test 
    e9     # map array using previous block of 2 instructions
    65     # calculate product of array
f4         # filter array by previous block of 5 instructions 

    24     # get digits of number into array
    40     # duplicate top of stack
    90     # remove duplicates from array
    71     # test equality
f3         # filter array by previous block of 4 instructions
54         # show contents of array separated by line breaks
— 递归的
source
8

Python 3中，132个 128 114 111 104字节

i=0
while i<1e8:
 j=str(i)
 if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j):print(i)
 i+=1

有548个星期一号码。

— 扎克·盖茨
source
1
您能用1e8而不是用9**9吗？
— Dom Hastings 2015年
删除中的空格'0' not。另外，i%int(k)==0可能是i%int(k)<1吗？
— mbomb007
谢谢。我不是想把它重新加入。@ mbomb007
— Zach Gates
您可以使用j=`i`。
— mbomb007
其他-6次使用if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
— lirtosiast
7

APL，44 39 37字节

{0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)⍎¨⍕⍵:⍵⋄⍬}¨⍳1e7

取消高尔夫：

{
 x ← ⍎¨⍕⍵⋄                    ⍝ Define x to be a vector of the digits of ⍵
 0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)x:   ⍝ No zeros, all digits divide ⍵, all unique?
 ⍵⋄⍬                          ⍝ If so, return the input, otherwise null
}¨⍳1e7                        ⍝ Apply to the integers 1..1E7

感谢Moris Zucca，节省了7个字节！

— 亚历克斯·A
source
我爱APL。这就是为什么。
— Conor O'Brien
我认为您可以使用功能训练来打高尔夫球，节省5个字节：{0 = + /（⊢|∘⍵，0∘∊，⍴∘⊢≠⍴∘∪）x←⍎¨⍕⍵：⍵⋄⍬}¨⍳ 1e7
— 莫里斯·祖卡
@MorisZucca太好了，谢谢你的建议！
— Alex A.
我只是看到不再需要x←这种形式，所以又节省了2个字节！:-)
— 莫里斯·祖卡
@MorisZucca您是APL高尔夫球机！再次感谢！
— Alex A.
6

TI-BASIC，60 59字节

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(1,1+int(log(X->D
SortA(∟D
If X>9
If not(max(remainder(X,Ans+2Xnot(Ansmin(ΔList(∟D
Disp X
End

∟D是数字列表，它是使用数学和randIntNoRep(命令生成的（在1和之间的所有整数的随机排列1+int(log(X）。我使用一个稍微复杂的语句链来检查是否满足所有条件：

   min(ΔList(∟D        ;Zero if repeated digit, since ∟D was sorted ascending
Ans                    ;Multiplies the unsorted copy of ∟D by the minimum from above
                       ;(Lists are different dimensions; we can't elementwise AND)
                       ;Will contain a 0 if there's a 0 digit or a repeated digit
      not(             ;If there's a zero,
Ans+2X                 ;Add 2X to that pos. in the list, failing the test:

    max(remainder(X,   ;Zero iff all digits divide X and 2X wasn't added
not(

要使具有重复数字或零数字的数字失败，我用替换零2X，因为X它永远不会被整除2X。

对于特殊情况1〜9 （由于ΔList(一个元素列表错误），我使用If第四行中的语句跳过第五行中的检查，自动显示所有X≤9。

输出编号用换行符分隔。

— 小鱼
source
5

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigits分解n为一个数字列表i。
  • FreeQ[i,0] 检查列表中是否没有零。
  • Length[i]==Length[Union[i]] 检查是否没有重复的数字。
  • And@@(Divisible[n,#]&/@i)检查每个数字是否为的除数n。

{1、2、3、4、5、6、7、8、9、12、15、24、36、48、124、126、128、132、135、162、168、175、184、216、248 ，264，312，315，324，384，396，412，432，612，624，648，672，728，735，784，816，824，864，936，1236，1248，1296，1326，1362，1368 ，1395，1632，1692，1764，1824，1926，1935，1962，2136，2184，2196，2316，2364，2436，2916，3126，3162，3168，3195，3216，3264，3276，3492，3612，3624 ，3648，3816，3864，3915，3924，4128，4172，4236，4368，4392，4632，4872，4896，4932，4968，6132，6192，6312，6324，6384，6432，6912​​，6984，8136，8496 ，8736，9126，9135，9162，9216，9315，9324，9432，9612，9648，9864，12384，12648，12768，12864，13248，13824，13896，13968，14328，14728，14832，16248，16824，17248 ，18264，18432，18624，18936，19368，21384，21648，21784，21864，23184，24168，24816，26184，27384，28416，29736，31248，31824，31896，31968，32184，34128，36792，37128，37296，37926，38472，39168，39816，41328，41832，42168，42816，43128，43176，46128，46872，48216，48312，61248，61824，62184，64128，68712，72184，73164，73248，73416， 73962，78624，79128，79632，81264，81432，81624，81936，82416，84216，84312，84672，87192，89136，89712，91368，91476，91728，92736，93168，93816，98136，123648，123864，123984， 124368、126384、129384、132648、132864、132984、134928、136248、136824、138264、138624、139248、139824、142368、143928、146328、146832、148392、148632、149328、149832、162384、163248、163824、164 164832，167328，167832，168432，172368，183264，183624，184392，184632，186432，189432，192384，193248，193824，194328，194832，198432，213648，213864，213984，214368，216384，218736，219384，192648，193632 231864、231984、234168、234816、236184、238416、239184、241368、243168、243768、243816、247968、248136，248976、261384、263184、273168、281736、283416、284136、291384、293184、297864、312648、312864、312984、314928、316248、316824、318264、318624、319248、319824、321648、321864、321984、324168、324168 326184、328416、329184、341928、342168、342816、346128、348192、348216、348912、349128、361248、361824、361872、362184、364128、364728、367248、376824、381264、381624、382416、384192、384216、384192 391248、391824、392184、394128、412368、413928、416328、416832、418392、418632、419328、419832、421368、423168、423816、427896、428136、428736、431928、432168、432768、432816、436128、438192、438192 438912、439128、461328、461832、463128、468312、469728、478296、478632、481392、481632、482136、483192、483216、483672、483912、486312、489312、491328、491832、493128、498312、612384、613248、613248 613872、614328、614832、618432、621384、623184、623784，627984、631248、631824、632184、634128、634872、641328、641832、643128、648312、671328、671832、681432、684312、689472、732648、732816、742896、746928、762384、768432、783216、789264、796824， 813624、814392、814632、816432、819432、823416、824136、824376、831264、831624、832416、834192、834216、834912、836472、841392、841632、842136、843192、843216、843912、846312、849312、861432、864 873264、891432、894312、897624、912384、913248、913824、914328、914832、918432、921384、923184、927864、931248、931824、932184、934128、941328、941832、943128、948312、976248、978264、981432、914432 1289736，1293768，1369872，1372896，1376928，1382976，1679328，1679832，1687392，1738296，1823976，1863792，1876392，1923768，1936872，1982736，2137968，2138976、2189376，2317896、2789136、2793168、2819376、2831976 2937816、2978136、2983176，3186792、3187296、3196872、3271968、3297168、3298176、3617928、3678192、3712968、3768912、3796128、381672、3817296、3867192、3869712、3927168、3928176、6139728、6379128、6387192、6388972、6391728、6719328、6719832 6893712，6913872，6971328，6971832，7168392，7198632，7231896，7291368，7329168，7361928，7392168，7398216，7613928，7639128，7829136，7836192，7839216，7861392，7863912，7891632，7892136，7916328，7916832，7921368， 8163792、8176392、82919736、8312976、8367912、8617392、8731296、8796312、8912736、8973216、9163728、9176328、9176382、9182376、9231768、9237816、9273136、9283176、9613328、9617382、9677832、9787632、9723168、98713632 9812376，9867312}6387192、6389712、6391728、6719328、6719832、6731928、6893712、6913892、6971328、6971382、7168392、7392322、7231896、7291368、7329168、73613928、7392168、7398216、7613928、7639128、7892136、7893262、78939216、7892392、7893216 7891632，7892136，7916328，7916832，7921368，8123976，8163792，8176392，8219736，8312976，8367912，8617392，8731296，8796312，8912736，8973216，9163728，9176328，9176832，9182376，9231768，9237816，9278136328，9283176，96 9617832，9678312，9718632，9723168，9781632，9782136，9812376，9867312}6387192、6389712、6391728、6719328、6719832、6731928、6893712、6913892、6971328、6971382、7168392、7392322、7231896、7291368、7329168、73613928、7392168、7398216、7613928、7639128、7892136、7893262、78939216、7892392、7893216 7891632，7892136，7916328，7916832，7921368，8123976，8163792，8176392，8219736，8312976，8367912，8617392，8731296，8796312，8912736，8973216，9163728，9176328，9176832，9182376，9231768，9237816，9278136328，9283176，96 9617832，9678312，9718632，9723168，9781632，9782136，9812376，9867312}8796312，8912736，8973216，9163728，9176328，9176832、9182376、9231768、9237816、9278136、9283176、96131728、9678382、9678312、9718632、9723168、9781362、9782136、9812376、9867312}8796312，8912736，8973216，9163728，9176328，9176832、9182376、9231768、9237816、9278136、9283176、96131728、9678382、9678312、9718632、9723168、9781362、9782136、9812376、9867312}

Length[%]

548

— 戴维
source
我希望有数学中的一种方式，更少的字节来获得大量的，像9^9或1e8什么的
— FryAmTheEggman
我很惊讶Mathematica没有内置的;-)。不错的技巧，Union可以检查重复项。
— AdmBorkBork 2015年
@FryAmTheEggman，您对Mathematica允许9 ^ 9表示正确。但是那会不会返回超过548个星期一的数字？
— DavidC 2015年
正如问题中所说，星期一的数字不可能大于给定的上限。
— FryAmTheEggman
5

Haskell，77个字节

[x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

用法示例（前20个数字）：

take 20 $ [x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

[1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162]

工作原理：对1到9 ^ 9的所有数字进行迭代，并检查条件。当前数字x将转换为字符串表示形式（show x），以作为字符列表对其进行操作。

— 妮米
source
5

R，99个字节

for(n in 1:1e8){i=1:nchar(n);if(all(table(d<-(n%%10^i)%/%10^(i-1))<2)&!0%in%d&all(!n%%d))cat(n,"")}

略少打高尔夫球：

for(n in 1:1e8){
    i = 1:nchar(n)
    d = (n%%10^i)%/%10^(i-1) # Digits of n
    if(all(table(d)<2) # No digits is present more than once 
      & !0%in%d        # 0 is not one of the digits
      & all(!n%%d))    # All digits are divisors of n
    cat(n,"")
    }
— 浮游动物
source
5

Perl，90 75 70字节

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7
— 史蒂夫
source
1
啊，我错过了\ 1欺骗检查的窍门，很好。您可以同时使用语句修饰符和三元打印来节省更多吗？
— Dom Hastings 2015年
@DomHastings谢谢，现在您可以根据自己的建议打高尔夫球了
— Steve
不错，我想你可以节省一些的还有很多，因为你不需要^和$周围的0你grep，可以取代&&之前s/./用一个单一的&，我认为最后|0是不需要的（虽然只是测试先进1e3。 ..）。好吧，真正打败了我的分数！:)
— Dom Hastings
1
@DomHastings谢谢，打高尔夫球的技巧降低到70。
— 史蒂夫（Steve）2015年
摆脱grep（不必要的-模式匹配无需grep即可处理），然后将其余部分重新排列到地图中，从而进一步降低它的负担：在线尝试！
— Xcali
4

CJam，25个字节

1e7{_Ab__&0-_@=@@f%1b>},`

在线尝试。请注意，在线链接最多只能运行10,000个。如果您有足够的耐心，我不确定是否会在线完成。它尚未使用CJam的脱机版本进行测试，但我希望它会终止。

说明：

1e7     Upper limit.
{       Start filter loop.
  _Ab     Copy and convert to list of decimal digits.
  __&     Intersect list with itself to remove duplicates.
  0-      Remove zero.
  _       Make a copy of unique non-zero digits. Will use these as divisors.
  @=      Compare unique non-zero digits to all digits. Must be true for Monday numbers.
  @@      Rotate original number and list of non-zero digits to top.
  f%      Remainders of original number with all non-zero digits.
  1b      Sum up the remainders. Since they all must be zero for Monday numbers,
          their sum must be zero.
  >       Check that first part of condition was 1, and sum of remainders 0.
},      End filter loop.
`       Convert resulting list to string.
— 雷托·科拉迪（Reto Koradi）
source
4

C＃，230 227

自从我玩了一段时间以来，我可能忘记了一些减少字节数的技巧。当我想到它们时会有所改善...现在：

using System.Linq;class P{static void Main(){System.Console.Write(string.Join(",",Enumerable.Range(0,1<<24).Where(i=>{var s=i.ToString();return!s.Contains('0')&&s.Length==s.Distinct().Count()&&s.All(x=>i%(48-(int)x)==0);})));}}

取消高尔夫：

using System.Linq;
class P
{
    static void Main()
    {
        System.Console.Write(                                       //Output...
            string.Join(                                            //...all results...
                ",",                                                //...comma separated...
                Enumerable.Range(0, 1<<24)                          //...from 0 to 16777216...
                    .Where(i => {                                   //...where...
                        var s = i.ToString();                       //...the digits as char array (what we usually call a string)...
                        return !s.Contains('0')                     //...for which none of the digits is 0...
                            && s.Length == s.Distinct().Count()     //...and the number of distinct digits equals the total number of digits (e.g. all unique)...
                            && s.All(x => i % (48 - (int)x) == 0);  //...and the number is divisible by each of the digits (after 'ASCII-correction')
                    })
            )
        );
    }
}

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,312,728,735,784,816,824,864,612,624,648,672,728,735,784,816,824,864,936,136,12,48,1296,13,169,16,368,1,369,16,169 1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924， 4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216， 9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368， 21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328， 41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416，73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984， 124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328， 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648， 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864， 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248， 361824，361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368， 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192， 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872， 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416， 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312，897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872， 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983136 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,79213688 8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216，9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

— 罗比三世
source
（int）1e7可以是1 << 24吗？
— lirtosiast 2015年
@ThomasKwa是的，可以。确实。谢谢！
— RobIII
4

TI-BASIC，55 53字节

这是一个相对较小的编辑托马斯·夸的答案，但我提出它作为一个新的答案，因为我听说他已经把一个赏金在他的高尔夫球TI-BASIC的答案。

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(0,1+int(log(X->D
SortA(∟D
If not(sum(remainder(X,Ans+Xnot(Ansmin(ΔList(∟D
Disp X
End

我的主要更改是从randIntNoRep(1,到的randIntNoRep(0,意思是，现在每个生成的数字列表中都将为零。

number  |  randIntNoRep  |  digits  |  sorted
9       |  1,0           |  9,0     |  0,9
102     |  3,1,0,2       |  1,2,0,0 |  0,0,1,2

由于现在每组数字都为零，因此会影响余数之和。通常，余数的总和为0，但是现在，存在额外的零会导致我们的除数测试失败。
为了解决这个问题，我更改2Xnot(为Xnot(。2最初是在此处进行，以使测试在0处失败，但现在它在0处通过。但是，数字中仍为零的数字现在min(ΔList(∟D无论如何都为零（因为列表中存在2个或多个零），因此此更改不会导致任何额外的数字通过测试。

这种方法的好处是，由于现在从数字1-9产生“两位数”，因此该ΔList(函数不会产生错误，从而使我们摆脱了一位数字的特殊条件。

— 皮诺皮
source
4

05AB1E，30 22 21 18 14 13 12 9 字节

-9字节感谢@Enigma和@ Mr.Xcoder的帮助和鼓励。尽管您在我30岁时就已经有了一个12字节的解决方案，但还是感谢您让我自己弄清楚了这件事。从这个挑战中学到了很多关于05AB1E的知识！
-3个字节，感谢@Grimy

7°LʒÐÑÃÙQ

在线尝试（仅输出10 3以下的数字而不是10 7，以防止60秒后超时）。

说明：

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (truthy) remain:
    Ð      #  Triplicate the current number
     Ñ     #  Get the divisors of this number
           #   i.e. 128 → [1,2,4,8,16,32,64,128]
           #   i.e. 1210 → [1,2,5,10,11,22,55,110,121,242,605,1210]
      Ã    #  Only keep those digits/numbers in the original number (which is checked in
           #  order, so it will only keep the digits and ignores the later numbers)
           #   i.e. 128 → 128
           #   i.e. 1210 → 121
       Ù   #  Uniquify the number, removing any duplicated digits
           #   i.e. 128 → 128
           #   i.e. 121 → 12
        Q  #  Check if the number is unchanged after this
           #   i.e. 128 and 128 → 1 (truthy)
           #   i.e. 1210 and 12 → 0 (falsey)

以前的12字节版本（我的第一个05AB1E答案之一）：
注：仅适用于旧版本的05AB1E。

7°LʒÐSÖPsDÙQ*

在线尝试（仅输出10 3以下的数字而不是10 7，以防止60秒后超时）。

说明：

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (true) remain:
    Ð      #  Triplicate the current number N
     Ù     #  Remove all duplicated digits of the second N
           #   i.e. 1210 → 120
      Q    #  Check if the last two numbers are still the same (1 or 0 as result)
    *      #  Multiply this result with remaining third number from the triplication
     D     #  Duplicate this number, so we have two again
      S    #  Separate all the digits of the second one
           #   i.e. 128 → ['1', '2', '8']
       Ö   #  Check if (the second) N is divisible by each of its digits
           #   i.e. 128 and ['1', '2', '8'] → [1, 1, 1]
           #   (NOTE: If the number contains a '0', it won't error on division by 0,
           #          but instead return the number N itself in the list)
           #   i.e. 105 and ['1', '0', '5'] → [1, 105, 1]
        P  #  Take the product of this list (if the divisible test for one
           #  of the digits was 0, this will be 0 as well)
           #   i.e. [1, 1, 1] → 1
           #   i.e. [1, 105, 1] → 105 (only 1 is truthy in 05AB1E)
— 凯文·克鲁伊森
source
您的答案会打印出来297，这不是Lynch-Bell编号的顺序。
— Xcoder先生18年
@ Mr.Xcoder Sigh ..起初需要更长的时间来检查一个数字是否可以被其所有数字整除，但是发现存在这样的挑战。因此，这个答案似乎也是无效的。.在这里，您和Enigma谈论的是12-15字节的答案，而我的30字节的答案甚至都不起作用，大声笑。; p
— 凯文·克鲁伊森
1
9个字节：7°LʒÐÑÃÙQ
— 肮脏的
@Grimy我的第一个05AB1E答案之一。:)不错的方法！
— 凯文·克鲁伊森
3

朱莉娅88字节

print(join(filter(i->(d=digits(i);0∉d&&d==unique(d)&&all(j->i%j<1,d)),1:9867312)," "))

这只是将所有数字从1到最大的Lynch-Bell编号进行过滤，然后仅将其过滤为Lynch-Bell编号。

取消高尔夫：

lynch = filter(i -> (d = digits(i);
                     0 ∉ d &&
                     d == unique(d) &&
                     all(j -> i % j == 0, d)),
               1:9867312)

print(join(lynch, " "))
— 亚历克斯·A
source
3

Python 2，101字节

print[i for i in range(6**9)if'0'not in`i`and len(set(`i`))==len(`i`)and all(i%int(k)==0for k in`i`)]

您可以print在解释器中省略到96。使用6**9该字符是因为它是8位数字，而最大的星期一数字只有7位数字，9**9可能需要很长时间，而6 ** 9只需要大约10秒钟。

— 罗卡纳
source
正如几个问题所指出的，1e7比两个都短
— Holloway
@Trengot 1e7是一个浮点数，范围取整数。
— Rohcana 2015年
非常真实 没想到
— Holloway
3

Perl，97个字节

print+($n=$_,$/)x(!/0/&(y///c==grep{2>eval"$n=~y/$_//"}/./g)&&y///c==grep!($n%$_),/./g)for 1..1e7

需要一段时间才能运行，但会产生所需的输出，请更改1e3为一个更快的示例！

— 唐·黑斯廷斯
source
我目前无法尝试此方法，但是y///c==grep{2>eval"$n=~y/$_//"}/./g可以代替使用!/(.).*\1/吗？
— msh210 '18
@ msh210几乎可以肯定！我认为这将是我现在的默认设置，但是更改此设置最终只会使其更接近史蒂夫（Steve）或Jarmex的答案，而后者的答案要好得多！感谢您的关注！
— 唐·黑斯廷斯
3

MATLAB 100

o=49;for n=2:1e7 a=num2str(n);if all([diff(sort(a)) a~=48 ~mod(n,a-48)]) o=[o ',' a];end;end;disp(o)

并以更具可读性的格式：

o=49;  %1 is always in there, so add the ASCII value. This prevents there being a ',' prefixed.
for n=2:1e7 
    a=num2str(n);
    if (all([diff(sort(a)) a~=48 ~mod(n,a-48)]))
        o=[o ',' a];
    end
end
disp(o)

11×107

检查如下：

  1. 首先检查是否有重复项。通过对数组进行排序，如果任何连续数字之间的差为零，则存在重复项

    diff(sort(a))

  2. 检查是否有零。0的ASCII是48，因此我们检查所有数字是否均不等于该数字。

    a~=48

  3. 检查它是否可以被所有数字整除。我们检查除以每个数字时的余数（从ASCII转换为十进制，因此是-48）是否为零。

    ~mod(n,a-48)

最后，我们确保all()检查为真，如果是，则将其附加到逗号分隔的输出字符串中。

MATLAB没有STDOUT，因此我在末尾使用 disp()

此代码很慢！我仍在运行它，以确保它可以正确找到所有星期一的数字，但到目前为止看起来还不错。

更新：

代码运行完毕。它打印以下内容：

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824,1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924,4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216,9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368,21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328,41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984,124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328,164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648,231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864,312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248,361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368,423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192,483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872,641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416,824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872,1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176,3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928,6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976,8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

如果以该代码作为输入来运行此代码，则该代码：

nums = length(strsplit(stdout,','))

548。

— 汤姆·卡彭特
source
3

Ruby，79岁

?1.upto(?9*7){|s|a=s.chars;a.uniq!||a.any?{|x|x<?1||0<eval([s,x]*?%)}||puts(s)}

使用正则表达式更有趣但更长的解决方案：

?1.upto(?9*7){|s|s[/(.).*\1|[0#{(1..9).map{|*x|x*eval([s,x]*?%)}*''}]/]||puts(s)}

在每种情况下，我们都使用Ruby的能力来迭代字符串，就好像它们是十进制整数一样：?1.upto(?9*7)等效于1.upto(9999999).map(&:to_s).each。我们使用模运算符将字符串连接到每个非零数字，并评估结果以检查可除性。

额外的Ruby 1.8解决方案（需要-l标记才能正确输出）：

'1'.upto('9'*7){|$_|~/(.).*\1|[0#{(1..9).map{|*x|x*eval("#$_%#{x}")}}]/||print}

1.8允许块迭代器是全局变量。分配给$_使其成为字符串操作的隐式接收者。我们还可以更轻松地将数组插值到正则表达式中：在1.8中，/[#{[1,2]}]/计算为/[12]/。

— 历史学家
source
既然Ruby 2.4具有digits整数功能，您就可以从eval hack中保存字节，因为您不再使用字符串了！63个字节
— 价值墨水
3

点，25字节

Fa,t**7Ia#=UQa&0=$+a%^aPa

在自己的行上输出每个数字。该程序已经运行了大约10分钟，到目前为止已达到984312，但是我敢肯定它是正确的。（编辑：几个小时后...代码完成，生成了所有548个'em。）

这是Python风格的伪代码副本：

for a in range(10**7):
  if lengthEqual(a, set(a)) and 0 == sum(a%d for d in digits(a)):
    print(a)

在#=操作者通过长度的两个iterables进行比较。如果数量UNI Q在UE字符a是相同的字符数a时，不存在重复。

每个数字可除的校验来自我的一个Pip示例程序。我在看到较早的挑战后就写了它，但是没有将其发布在那儿，因为该语言比问题要新。否则，如果是8个字节，它将是该问题的胜出答案。以下是分步说明：

      ^a   Split num into an array of its digits
    a%     Take num mod each of those digits; if a digit is zero, the result will be nil
  $+       Sum the resulting list (note: summing a list containing nil results in nil!)
0=         Iff the sum equals 0, return 1 (true); otherwise (>0 or nil), return 0 (false)
— DLosc
source
这是一种非常简洁的语言！很高兴看到除了基于堆栈的高尔夫以外的其他东西。
— AdmBorkBork
1
@TimmyD如果您想观看基于非堆栈的高尔夫运动，通常会有相当多的Pyth。
— Reto Koradi 2015年
@RetoKoradi但是，如果您想使用infix运算符查看基于非堆栈的高尔夫，那么Pip适合您。; ^）
— DLosc 2015年
Couple hours later不考虑性能是件好事。
— Holloway 2015年
3

Javascript（ES6），106 90 83字节

孩子们，不要在家尝试这个；JS对使用正则表达式遍历从1到1千万的每个整数的每个数字的前景不满意。

for(i=0;i<1e7;i++)/(.).*\1|0/.test(i)||+`${i}`.replace(/./g,j=>i%j)||console.log(i)

true如果数字中包含重复的数字或零，则返回第一个正则表达式（@Jarmex的属性）。如果这证明false，到第二，它取代每个数字节目的举动j有i%j。如果所有数字都可将其整除，则结果全为零，在这种情况下，它将移至console.log(i)。

建议欢迎！

— ETH生产
source
3

JavaScript（ES6），76

/* Answer below. For testing purpose, redirect consoloe.log */ console.log=x=>document.write(x+' ')

for(i=0;i++<1e7;)/0|(.).*\1/.test(i)||[...i+''].some(d=>i%d)||console.log(i)
展开摘要

regexp测试0或重复的数字。然后检查digits数组，以寻找任何数字的非零模。

这是最大7位数的说明。

— edc65
source
3

Ruby，130个字节

...不算空格

编程新手，只想参加

c=0
(0..10**7).each do |x| 
  a=x.to_s.split('')
  c+=1 if !a.include?('0')&& a.uniq!.eql?(nil)&&a.all?{|y| x.modulo(y.to_i).zero?} 
end
p c
— skeezy_D
source
2
欢迎来到PPCG！查看其他一些Ruby技巧，以帮助缩短代码长度。
— AdmBorkBork
3

C，122字节

i,j,m,a;void f(){for(i=1;i<1e8;++i){for(m=0,j=i;j;j/=10){a=j%10;if(!a||m&(1<<a)||i%a)goto n;m|=1<<a;}printf("%d ",i);n:;}}

更漂亮：

i,j,m,a;
void f()
{
    for (i=1; i<1e8; ++i){
        for (m=0, j=i;  j;  j/=10) {
            a = j%10;
            if (!a || m&(1<<a) || i%a)
                goto n;
            m|=1<<a;
        }
        printf("%d ",i);
    n:;
    }
}

对于每位候选人i，我们a以小尾数顺序对其数字进行迭代，并在中对所看到的数字进行跟踪m。如果循环完成，则所有数字都是的因数，i我们看不到零或重复的数字，因此请打印出来，否则我们提早退出以继续外循环。

— 托比·斯皮特（Toby Speight）
source
对goto正在使用的命令好。
— Shaun Bebbers
2

CJam，34个字节

1e7{_:TAb___&=\{T\T)e|%}%:+!**},N*
— 林恩
source
2

Lua，129个字节

我避免使用字符串方法进行纯数字压缩，这似乎更快一些，并且可能还为我节省了一些字节。（我将测试该理论，但是与某些其他语言相比，Lua字符串处理相当冗长。）

for i=1,1e7 do t={[0]=1}j=i while j>0 do c=j%10 if t[c]or i%c>0 then break end t[c]=1 j=(j-c)/10 if j==0 then print(i)end end end
— ip脚与莫妮卡站在一起
source
2

gawk，99个字节

BEGIN{for(;8>(l=split(++i,a,_));printf f?f=_:i RS)for(j in a)f=i~0||i%(d=a[j])||i-d*10^(l-j)~d?1:f}

如果可以使用END代替，我可以将其减少到97 BEGIN，但是您必须按Ctrl-D才能开始实际的输出，表示没有输入。

如果我什么也没写代替BEGIN或END，我可以将其减少到94 ，但是您必须按下一次返回键才能启动它，这可以算作输入。

它只是遍历每个数字的位数并测试是否满足条件。

i〜0：数字包含“ 0”？->垃圾
i％（d = a [j]）：数字不能被当前数字整除吗？->垃圾
id * 10 ^（lj）〜d：我从数字中删除了当前数字
                  ：仍然包含吗？->垃圾

需要140秒才能终止我的Core 2 Duo。

— Cabbie407
source
2

果冻，11字节

9œ!ṖẎgḌ$ƑƇḌ

这使用了两周大的œ!原子。实际上足够快以在TIO上运行。

在线尝试！

怎么运行的

9œ!ṖẎgḌ$ƑƇḌ  Main link. No arguments.

9            Set the return value to 9.
   R         Pop; yield [1, ..., 8].
 œ!          Promote 9 to [1, ..., 9] and generate all permutations of length k,
             each k in the right argument [1, ..., 8].
    Ẏ        Tighten; dump all digit lists in a single array.
         Ƈ   Comb; keep only digit lists for which the link to the left returns 1.
        Ƒ      Fixed; return 1 iff calling the link to the left returns its argument.
       $         Combine the two links to the left into a monadic chain.
      Ḍ            Undecimal; convert the digit list into an integer.
     g             Take the GCD of each digit and the integer.
— 丹尼斯
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.