找出以n结尾，可被n整除且其数字总和为n的最小正整数

33

全部在标题中...

以一个正整数作为输入n>=12，...进行标题说明的操作。

是的，这是在OEIS A187924上。

一些测试案例 

12 -> 912  
13 -> 11713  
14 -> 6314  
15 -> 915  
16 -> 3616  
17 -> 15317  
18 -> 918  
19 -> 17119 
20 -> 9920  
40 -> 1999840   
100-> 99999999999100

这是代码高尔夫球。以字节为单位的最短代码胜出！

code-golf  integer 
— 用户名
source
评论不作进一步讨论；此对话已转移至聊天。
— Martin Ender
结束部分聊天内容：我对OEIS的编辑证明，只有11个数字是唯一没有解决方案的数字。
— 与Orjan约翰森

Answers:

19

Befunge，81个字节

&>00p0v<!%g0<
v%"d":_>1+:0^
>00g->#^_:0v
0g10g-#^_.@1>
>0p:55+/\:v>
^1+g01%+55_$^

在线尝试！

至少可以处理n = 70，此后一些值将在大多数实现中开始溢出堆栈单元大小，而在没有实现的情况下，将花费很长时间，因此不值得等待找出。

考虑到这些限制，我们甚至不用费力尝试处理大于99 的n值，这意味着我们可以通过简单地将100与n进行模数比较来更轻松地测试n的值是否以n结尾。

以下是该代码的更详细细分。

Source code with execution paths highlighted

*从标准输入中读取n并保存在内存中。
*将测试值v初始化为0并开始主循环，将v向前递增。
*测试是否v%n == 0，如果不返回主循环的开始。
*测试是否v%100 == n，如果不返回主循环的开始。
*总结在数字v通过反复加入v模10和除以v通过10.
*测试如果该总和等于Ñ，如果不是返回到主循环的开始。
*否则输出v并退出。

— 詹姆斯·霍尔德尼斯
source
12

05AB1E，14个字节

[NI«ÐIÖsSOIQ*#

在线尝试！

说明

需要大前缀的解决方案将在TIO上超时

[                # start a loop
 NI«             # append input to current iteration number
    Ð            # triplicate
     IÖ          # is the first copy evenly divisible by input?
       sSOIQ     # is the digit sum of the second copy equal to the input?
            *    # multiply
             #   # if true, break loop
                 # output the third copy
— 艾米尼亚
source
好像05AB1E在作弊一样，因为它是如此的好。克服这一障碍的唯一方法是制作一种引用过去语言的编程“压缩”语言。我提交了ans = dic [1]大声笑
— 探路者
@Pathfinder：有几种语言可以始终击败05AB1E，因此我们仍然希望看到更短的语言：）
— Emigna
12

JavaScript（ES6），55 54字节

f=(s,p=0,a=p+s)=>a%s|eval([...a].join`+`)-s?f(s,p+1):a
<input type=number min=12 oninput=o.textContent=f(this.value)><pre id=o>
展开摘要

将输入作为字符串。需要具有尾递归支持的浏览器才能获得更大的结果。编辑：由于@Arnauld，节省了1个字节。

— 尼尔
source
eval([s,...a].join`-`)?也可以，尽管时间不短...
— ETHproductions
@Arnauld不，我只是忘记了我可以使用做到这一点||。
— 尼尔
8

Brachylog V2，12 10个字节

a₁.;A×?≜ẹ+

在线尝试！

这是一个函数提交，通过它来接受输入，.并通过来产生输出?（与常规约定相反；所有Brachylog函数正好具有两个自变量，可以作为输入或输出自变量，但该语言不强制使用任何特定的自变量）。在PPCG中，我们通常不认为参数使用约定有意义。

说明

此解决方案的早期版本有一个特殊情况（Ḋ|即“按字面意义上的返回数字”），但该问题显然表明您不必检查（感谢@DLosc捕获了此问题），因此我删除了它。（书面解决方案不适用于单个数字，因为Brachylog不会将1视为乘法中未知数的可能性，以防止无限循环；其乘法是任意对数的。）

因此，这个答案现在可以直接用于规范的直接翻译。从?（我们要查找的输出/数字； Brachylog谓词始终以隐式开头?）开始，我们a₁.断言它具有.（输入）作为后缀。然后;A×?意味着我们可以将×结果乘以（;A）来产生?（输出）。最后，ẹ+求和（+）的数字（ẹ））?，并且默认情况下，最终结果产生的每个Brachylog程序的末尾都有一个隐式断言.。因此，换句话说，该程序是“ .是的后缀?，.乘以是?，.是的数字总和?”，这非常接近原始程序的文字翻译。

该≜如要执行的数字和要求是必要的。我认为某些事情ẹ不喜欢未知的事物，因此≜告诉Brachylog对程序的那部分使用蛮力方法，而不是代数。

— 社区
source
6

Haskell，72个字节

f n=[x|x<-[n,n+lcm n(10^length(show n))..],sum[read[j]|j<-show x]==n]!!0

在线尝试！

请注意，找到的数字减去n必须是n和10 ^ length（n）的倍数。

受到Laikoni的启发，完全是人类

— 鱼线
source
欢迎光临本站！
— DJMcMayhem
3
变更lcm n(10^length(show n))到lcm(10^length(show n))n1个字节
— H.PWiz
6

爱丽丝，35字节

/o
\i@/!w?+.?~\ & /-$K..?\ L z $ /K

在线尝试！

说明

该程序在Cardinal（整数处理）和Ordinal（字符串处理）模式之间实现了很好的混合和交互。

十进制I / O的常见挑战框架主要在Cardinal模式下运行：

/o 
\i@/...

和实际的程序：

!     Store the input N on the tape.
      We'll use an implicit zero on top of the stack as our iterator variable X,
      which searches for the first valid result.
w     Store the current IP position on the return address stack. This marks
      the beginning of the main search loop. We can avoid the divisibility
      test by going up in increments of N. To check the other two 
      conditions, we'll use individual conditional loop ends that skip to 
      the next iteration. Only if both checks pass and all loop ends are 
      skipped will the search terminate.

  ?+    Increment the iterator X by N.
  .     Duplicate X.
  ?~    Put a copy of N underneath.
  \     Switch to Ordinal mode.
  &     Implicitly convert X to a string, then fold the next command over its
        characters, i.e. its digits. Here, "fold" means that each character
        is pushed to the stack in turn, followed by one execution of that
        next command.
  /     Switch back to Cardinal mode (this is not a command).
  -     Fold subtraction over the digits. This implicitly converts each 
        digit back to its numerical value and subtracts it from N. If the
        digit sum of X is equal to N, this will result in 0.
  $K    Jump back to the w if the digit sum of X isn't N.
  ..    Duplicate X twice.
  ?     Get a copy of N.
  \     Switch to Ordinal mode.
  L     Shortest common superstring. Implicitly converts X and N to strings
        and gives the shortest string that starts with X and ends with N. 
        This will be equal to X iff X already ends with N. Call this Y.
  z     Drop. If X contains Y, this deletes everything up to and including
        Y from X. This can only happen if they are equal, i.e. if X ended
        with N. Otherwise X remains unchanged.
  $     Skip the next command if the string is empty, i.e. if X ended with N.
  /     Switch back to Cardinal mode.
  K     Jump back to w if X didn't end with N.
— 马丁·恩德
source
5

的Java（OpenJDK的8） ，136个 110 103 92字节

-26感谢JollyJoker

-7再次感谢JollyJoker

-11感谢OliverGrégoire

a->{for(int i=a;!(""+a).endsWith(""+i)|i!=(""+a).chars().map(x->x-48).sum();a+=i);return a;}

在线尝试！

爱Java！可能是我使用的是效率低下的方法，但是没有内置的校验和功能，并且没有将字符串双重转换为String以检查数字结尾是否花费字节的信息...

取消高尔夫：

  a->{                                                       //input n (as integer)
      for (int i = a;                                        //initiate loop
           !("" + a).endsWith("" + i)                        //check if the calculated number ends with the input
           | i != ("" + a).chars().map(x -> x - 48).sum();   //check if the checksum is equal to the input
           a += i)                                           //for every iteration, increase i by the input to save checking for divisibility
        ;                                                    //empty loop body, as everything is calculated in the header
    return a;                                                //return number
}
— 卢卡·H
source
1
(""+i).endsWith(""+a)应该管用。
— JollyJoker
@JollyJoker太棒了，感谢您让我感到愚蠢：P
— Luca H
1
h n/=10而不是n=n/10。另外，i+=a在for循环中，因此您可以跳过除数检查。
— JollyJoker
@JollyJoker哇，我这样做是为了总和，但不是为了部门...谢谢，我会尽快添加它
— Luca H
1
92字节（使用API​​），比自己计算要短。另外，分号也不是字节数的一部分，因为例如可以将有效的lambda用作方法参数，然后就不需要该分号了。
— OlivierGrégoire17年
4

Mathematica，72个字节

(t=#;While[Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#,t+=#];t)&

@MartinEnder的-18个字节

在线尝试！

这是Martin Ender的另一个版本，
该方法可以达到n=40（超过默认迭代限制41个）

Mathematica，65个字节

#//.t_/;Mod[t,10^IntegerLength@#]!=#||Tr@IntegerDigits@t!=#:>t+#&

在线尝试！

— J42161217
source
3

Python 2，74个字节

该解决方案假定n <= sys.maxint。

n=x=input()
while sum(map(int,str(x)))-n*str(x).endswith(`n`):x+=n
print x

在线尝试！

— FlipTack
source
更换str(x)用x在背蜱两次以保存6个字节（你怎么逃背蜱内背蜱？）。
— Chas Brown
@ChasBrown `反斜杠在反引号内打勾。
— wvxvw
@ChasBrown否，因为要添加的长整数L可能会使算法混乱。
— FlipTack
3

C（gcc） 71 69字节，失败100

我尝试了很长时间和％1000，但超时

-2字节归功于稳定箱

s,i,j;f(n){for(j=0;s^n|j%100!=n;)for(s=0,i=j+=n;i;i/=10)s+=i%10;j=j;}

在线尝试

— 波尔卡王子
source
今天学习了一个新技巧，j * = 1 == return j技巧。好的代码。
— Michael Dorgan
stackoverflow.com/questions/2598084/… （返回最后一个数学运算。）
— Michael Dorgan
— PrincePolka
@Steadybox谢谢你，我会做到的
— PrincePolka
2

C＃（.NET Core），90 84 83 + 18 = 101字节

using System.Linq;
n=>{for(int i=n;!(""+n).EndsWith(""+i)|n%i>0|(""+n).Sum(c=>c-48)!=i;n++);return n;}

在线尝试！

  • 多亏了Emigna和我(""+n)在某些地方和n.ToString()其他地方书写的超凡能力，节省了6个字节。
— 查理
source
n=>{for(int i=n;n%100!=i|n%i>0|(""+n).Sum(c=>c-'0')!=i;n++);return n;}节省20个字节。
— Emigna '17
@Emigna为什么n%100？如果n>100呢？
— 查理
哦，是的，忽略那部分。那是用2位数输入进行测试的结果。mod必须为10 ^ len（input）。那可能不值得。
— Emigna
1

点，18字节

T!y%a&$+y=aY++i.ay

受Emigna答案启发的算法。在线尝试！

怎么运行的

                    a is 1st cmdline arg, i is 0, y is "" (implicit)
T                   Loop until
 !y%a&              y%a is 0 and
      $+y=a         sum of y is a:
            ++i      Increment i
           Y   .a    and yank (i concat a) into y
                 y  After the loop exits, autoprint y
— DLosc
source
1

JavaScript REPL（ES5），60 59字节

for(n=prompt(i=0);eval([].join.call(t=++i+n,'+'))-n|t%n;);t
— 平方米
source
@totallyhuman固定
— l4m2
在控制台中，它的输出没有alert（），所以我猜
— l4m2
0

Haskell，75个字节

f n=[x|x<-[0,n..],sum[read[d]|d<-show x]==n,mod x(10^length(show n))==n]!!0

在线尝试！

说明：

f n=[x|                                      ]!!0 -- Given input n, take the first x
       x<-[0,n..],                                -- which is a multiple of n,
                  sum[read[d]|d<-show x]==n,      -- has a digital sum of n
                  mod x(10^length(show n))==n     -- and ends in n.

我不知道“结尾n”部分是否可以缩短。我也尝试过show n`elem`scanr(:)""(show x)，但时间更长。

— 莱科尼
source
0

PowerShell，84字节

for($n=$i=$args[0];$i%$n-or$i-notmatch"$n$"-or([char[]]"$i"-join'+'|iex)-$n){$i++}$i

在线尝试！

结构简单，但命令冗长。在的TIO上超时n=100，但是如果我们显式设置i为close，它将正确输出。

for只要任何一个条件为真，这就是一个持续不断的简单循环。这三个条件是1）$i%$n，即，我们有余数；2）$i-notmatch"$n$"，即它不匹配最后两个数字；和3）([char[]]"$i"-join'+'|iex)-$n，即，相加后的数字不等于$n（此处通过简单的减法进行检查，因为非零值是真实的）。在循环内部，我们只是在递增$i。

因此，如果我们没有余数，则正则表达式匹配，并且数字相等，则所有三个条件都为$false，我们退出循环。结果，我们只能离开$i管道，而输出是隐式的。

— AdmBorkBork
source
0

PHP，73 + 1字节

while(array_sum(str_split($i+=$n=$argn))-$n|$i%10**strlen($n)-$n);echo$i;

与一起作为管道运行-R。

循环$i通过的倍数<input>，直到sum_of_digits-<input>和tail_of_i-$n是falsy; 然后打印i。

— 泰特斯
source
0

m4，210个字节

define(d,define)d(i,ifelse)d(s,`i($1,,0,`eval(substr($1,0,1)+s(substr($1,1)))')')d(k,`r($1,eval($2+1))')d(r,`i(s($2),$1,i(regexp($2,$1$),-1,`k($1,$2)',i(eval($2%$1),0,$2,`k($1,$2)')),`k($1,$2)')')d(f,`r($1,1)')

定义一个宏f来计算答案。它有点慢-很难做到-但我保证它可以工作。

我认为m4会很好，因为默认情况下它会将整数视为字符串，但这很糟糕。

— 程序人
source
0

Scala，120字节

def a(n:Int)={val b=math.pow(10,math.ceil(math.log10(n))).##;var c=b+n;while(c%n!=0||(0/:c.toString)(_+_-'0')!=n)c+=b;c}

这将一直有效到n = 70，之后整数将溢出。对于一个额外的字符，Int可以更改为Long并允许n > 100计算值。

这是略长的非高尔夫版本：

def golfSourceLong(n: Long): Long = {
  val delta = math.pow(10, math.ceil(math.log10(n))).toInt
  var current = delta + n
  while (current % n != 0 || current.toString.foldLeft(0)(_ + _ - '0') != n) {
    current += delta
  }
  current
}
— 马丁·图斯克维尤斯
source
0

R，115字节

function(n,d=nchar(n):1){while(sum(D<-F%/%10^((k=nchar(F)):1-1)%%10)-n|any(D[k-d+1]-n%/%10^(d-1)%%10)|F%%n)F=F+n
F}

在线尝试！

糟糕的R功能。递增F（从处开始0），n直到找到一个满足所需属性的值，然后返回该值。any在double表达式上使用会在每次循环迭代时发出警告，但不会影响正确性。

对于足够大的输入（n = 55或更高），在TIO上超时，但应在足够的时间/空间下正确计算解决方案。

— 朱塞佩
source
0

果冻，22 21字节

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#

在线尝试！

编辑：压缩到一行

说明

DS=³a³ḍaDṫ³DLC¤Ḍ=³ø1#
                  ø1#  Evaluate the condition before this and increment a counter until it is met then output the counter                     
D                      Digits of incremented variable as a list
 S                     Sum
  =³                   Equals argument of program?
    a                  Logical and
     ³ḍ                Does arg divide incremented variable?
       a               Logical and
        Dṫ     Ḍ       Last n digits of inc. var. where n is number of digits in program input
          ³DLC         1 - (number of digits of program input)
              ¤        Book ends above nilad
                =³     Equals program input?

这花了我很多时间写，因为我正在学习Jelly，但是现在我已经完成了，我感到非常满意。很长时间以来，我没有意识到我需要它，¤而我只是无法使其工作。查看[this] [1]解释清楚的代码有助于我达成协议。PPCG中的许多其他果冻答案也指导了我。

— Dylnan
source
0

Javascript，224个字节， function getNumber(x){if(x<12){return!1};const sumDigits=(x)=>x.toString().split('').map(Number).reduce((a,b)=>a+b,0);for(let i=2;i<9999;i++){if((x*i-x)%(Math.pow(10,x.toString().length))==0&&sumDigits(x*i)==x){return x*i}}} 非高尔夫：

function getNumber(x){
	if (x<12) {return false};
	const sumDigits = (x) => x.toString().split('').map(Number).reduce((a,b)=>a+b, 0);
	for (let i=2; i<9999; i++){
		if((x*i-x)%(Math.pow(10, x.toString().length))==0 && sumDigits(x*i)==x){
			return x*i;
}
}
}
展开摘要

用法：1. getNumber（12）2. getNumber（13）3. ....

— NTCG
source
我不太了解Javascript高尔夫，但是我敢肯定您应该缩短名称getNumber或sumDigits。
— 与Orjan约翰森
非常感谢，我不是要在这里赢球，只是想参加这个挑战：微笑：
— NTCG
0

J，37 33字节

+^:(((=1#."."0)*:(e.".\.))":)^:_~

在线尝试！

                                ~    A = N
+^:                          ^:_     while(...)A+=N; return A
   (                      ":)        A to string
   (((    "."0)          )  )        digits of A
   ((( 1#.    )          )  )        sum
   (((=       )          )  )        equals N
   ((            (e.".\.))  )        N is one of the suffixes of A-string
   ((          *:        )  )        not AND

在迭代计数器之前添加的速度快约5倍，但长5个字节：

(]+[((=1#.,.&.":)<:|),~&.":)^:_&1,&":]

在线尝试！

递增100，共27个字节：

(]+100*(=1#.,.&.":)<:|)^:_~

在线尝试！

— 皱眉蛙
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.