答案链-数字的正数除数


13

这个挑战已经正式结束,导致的胜利小麦向导,共有7分的答案。任何其他答案都是欢迎的,但它不会影响对此挑战的公认答案,也不会影响获胜者。


任务:

打印输入的所有正数除数x

输入:

单个数字x,即应计算其正因数的数字(以10为底)。

输出:

的所有正除数x。任何格式是允许的,其中包括\n,;和空格作为分隔符,只要它是可以理解的。输出也可以是整数或字符串数​​组(例如:)[1, 2, 3, 5, 30]。您可以将除数输出到您的语言中的stdout,console或等效语言,也可以将它们从函数返回


规则

  • 用户可能不会连续回答两次
  • 除了答案2之外,您的答案最多可以从上一个答案中删除,添加或替换15个字符(空格不计算在内),答案2可以“转换”多达20个字符来开始操作
  • 不允许以已经有答案的编程语言发布答案,但该语言的版本完全不同(例如:如果我在中发布答案Python 2.7,则可以使用提交Python 3,但不能使用Python 2.6)。
  • 不允许出现标准漏洞
  • 由于这个挑战,您不允许使用内置函数来获取除数
  • 必须在问题的标题中包含答案的编号和语言名称,以及上一个答案更改的字符数

计分

一旦事情解决,提交次数最多的用户将获胜。如果出现平局,则在其中一个答案中得分最高的用户将获胜。如果分数也相等,则提交时间最久(得分最高的答案)最久的用户将被宣布为获胜者。

注意: “解决” <=> 7自提交上一个答案以来已经过去了3天


例子:

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

或满足上述条件的任何其他等效输出。


最后说明:如果按最旧的答案排序,则此问题更好。我将在Python 2.7中发布第一个答案,因此您应根据该答案发布第二个答案。祝好运并玩得开心点!


排行榜:

此列表可能已过时,可以随意编辑:

1)小麦向导[电流组长🏆] 7分的答案 - 的Python 1.605AB1E实际上德尔| M |吨WSF脑高射炮Lenguage

2)莱利(Riley):3个回答 - 认真地讲CJam2sable

3)乔纳森·艾伦:2分的答案 - Python 3中果冻

3) ETHproductions:2个答案 - JaptPyth

3) Mistah菲金斯:2个答案 - Befunge-98脑高射炮经典

6)瑞克:1个答案 - MATL

6) dzaima:1分的答案 - SOGL 0.8.2

6) LegionMammal978:1个答案 - 空白

6)尼克·克利福德(Nick Clifford):1个答案 - 欧姆

6)琳:1个答案 - GolfScript

6) MickyT:1个答案 - Cubix影院

距离计算器

您可以使用此代码段来计算两个条目之间的距离:

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}
<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>


15个可以使用,但是10个是标准配置。我会说保持在15岁,因为这比大多数难度都要大。
Rɪᴋᴇʀ

2
希望您不要介意,但我在帖子底部添加了一个距离计算器
摘要

2
走向
脑力劳动的

6
重要提示:请编辑当你提交,所以它更容易维护。该排行榜
Xcoder先生

2
看到人们将Python的答案带到Brain-Flak,并进行了出色的协作,真是太棒了,从广泛传播的语言到有史以来最晦涩的编程语言之一。感谢所有实现它的人!现在我真的很想知道这个挑战会发生什么,因为DjMcMayhem对此给予了很大的帮助。
Xcoder先生17年

Answers:


12

答案20,脑力激荡,11

我想花时间感谢为这一目标做出贡献的每个人:

  • Riley,20个字节

  • LegionMammal,15个字节

  • ETHproductions,11个字节

  • Lynn,1个字节

以下用户无法直接贡献字节,但以其他方式提供了帮助:

  • Mistah Figgins

  • DJMcMayhem

  • 费瑟姆

感谢大家使这一切成为可能!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

在线尝试!


6
最后,Brain Flak!感谢所有帮助实现这一目标的人!恭喜Wheat Wizard成为迄今为止答案最多的用户,并为解决这一挑战付出了巨大的精力和时间!
Xcoder先生17年

7

答案3:MATL,距离15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

2
MATL %使其很难继续下去。祝其他人好运,我真的希望这个挑战不会在这里“消亡”!
Xcoder先生17年

这不是使用内置的吗?
乔纳森·艾伦

@JonathanAllan不,绝对不是。除数的内置值为Z\。这里的相关代码是:tGw\~)(我在聊天中写的,不是内置的)
James

事实上,没有内置的
Xcoder先生

1
@JonathanAllan 桌子可能有点混乱。Z\而不是\“除数”。在最后三列的标题为前缀(XY,或Z)。\本身就是第一列,即“ mod”
Luis Mendo

7

答案7,杰普,15岁

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

在线尝试!

更改#b∫I:b;\?tò f!vU(10分),并通过更改~(()((()<>))(5分)添加了更多Brain-Flak代码。我相信我们正在努力的代码是

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

说明

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

6

答案8,05AB1E,14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

在线尝试!

说明

幸运的是,05AB1E具有内置的Python解释器(种类繁多)。为了使这种运行我们推

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

作为堆栈顶部的字符串。我们必须在这里使用字符串文字而不是注释,因为05AB1E确实不喜欢其Python代码中的注释。我们还必须摆脱"原始代码中的,因为它会导致字符串过早结束。

推入字符串后,我们.e将其作为python代码执行。

为脑力激荡而努力

我能够添加5个额外的角色来实现Brain-Flak答案。我本来可以加6,但是我忘了空格不计入分数。

到目前为止,我们有:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

6

答案13,Pyth,15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

在线尝试!

说明

因此,我对Pyth的了解不多,但是我所知道的是源代码是一棵树的形式,每个命令的右边都带有特定数量的参数。我编写的除数程序的树如下所示:

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Q是输入。f有两个参数,F并且A,返回的项目TA哪里F(T)返回truthy值。在这种情况下,F是一个函数,该函数返回的逻辑非Q%T,并且ASQ,它创建range [1...Q]。这有过滤以只整数的效果T[1...Q]哪里Q%T == 0

为了避免解析其余代码,将整个程序包装在一个字符串中,然后|Q"...返回和的逻辑或Q。由于Q始终为正,因此始终为真,因此总是从逻辑或返回。


为脑力激荡而努力

((({})<>)){((({}[()] (({})(<>))      ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

真的很好奇,看看谁将会提交脑高射炮的答案,如果它发生..
Xcoder先生

我们越来越近了。我们应该在那里回答20(如果不是更早的话)
CalculatorFeline

好了,我们还有54个字符了……
ETHproductions

好吧,我们约一半了,这周围的回答第八条列出,所以我们要完成各地18
CalculatorFeline

6

答案16,GolfScript,15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

在线尝试!

我添加了~:␤),(;{␤\%!},p#,使用换行符作为变量名以适应大小限制,然后将整个程序压回一行以将其注释掉。这是距离14。然后,我在添加Brain-Flak {之前}printdiv

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

为脑力激荡而努力

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          ) {})}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

6

答案17,果酱,15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

在线尝试!

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

朝脑力奋战(30步之遥)

)({}((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{            )   )  {(          ) {})}{}
 (  (( {})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

我们实际上只有30公里。与其忽略多余的4个字符,而无需花费两个字符就可以转换)({}(((()({})((这个字符,这并不是我们所想到的确切程序,但在这种情况下()({})它们都是无操作的。
Ad Hoc Garf Hunter,2017年

@WheatWizard不错!我没有看实际的代码,只是通过问题中的距离检查器来运行它。
莱利

5

答案4- 果冻,4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

在线尝试!

相关代码:

Rḍ⁸T

)就解析器而言,这些行为是链接之间的中断(我相信)。

内建的将是ÆD,而不是创建从1到输入的范围,使用来R检查输入的可除性ḍ⁸,然后使用返回基于事实的基于索引的列表T


5

答案9,空白,15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

where <SPACES>由以下字符串替换,其中where T是0x09、0x0A LS0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

为了清楚起见,添加了文字换行符。请注意,规则仅指定非空白字符。不,不能帮助自己。

为脑力激荡而努力

我不知道之前发生了什么,所以现在我们有了:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

5

答案18,WSF,15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(这通过字符代码进行输入和输出)

说明

WSF本质上是头脑笨拙的,除了它使用空格而不是Brainfuck常用的一组运算符。这是反编译为Brainfuck的代码:

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

走向脑力激荡

由于WSF只是空白,因此我可以在Brain-Flak代码中再添加15个字符。这使我们与答案相距15,请随时发布。

()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})>  )  {(          ) {})}{}
()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

由于我不会自己发表Brain-flak答案,因此我想我要花点时间感谢为这一目标做出贡献的每个人:

  • Riley,16个字节

  • LegionMammal,15个字节

  • ETHproductions,11个字节

  • Lynn,1个字节

以下用户无法直接贡献字节,但以其他方式提供了帮助:

  • Mistah Figgins

感谢大家使这一切成为可能!


5

答案19,2sable,15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

在线尝试!

我删除了多余的空格,将之前存在的所有内容包装成字符串,然后:

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

5

答案21,Cubix,15

最终设法使它适合:)幸运的是,这是在Brain-Flak答案完成之后的,因为我想我会受阻。需要全部15个实施。

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

这映射到以下多维数据集

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

您可以在这里尝试它,但您需要将其粘贴。我怀疑某些特殊内容会导致永久链接出现问题。

该代码基本上超过2行。重要的部分是:

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )这将获取输入,交换堆栈的顶部(也可以使用0)并递增
% ?Get mod和test。如果0进行正向或下拉至重定向
; O N o删除mod结果并输出数字,然后换行
uU转到下面的行
按照执行
; - ! @顺序从堆栈中删除10,从输入中减去数字,测试,如果为零则终止
< ; u重定向目标以进行第一次测试。移除堆栈顶部(mod或减结果),然后将其调头以增加增量


4

答案6,Python 1.6,15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

我删除了%符号,并注释掉了第一行和最后一行的一些内容。仅此一项,就使我花了15分中的10分。但是我还没有完成。因为Python 1没有+=我不得不更换i+=1i=i+1花费我一个额外的3分。由于我还剩下2个,所以我也添加((了开头。我打算稍后在Brain-Flak中提交,我需要parens。


1
甚至在OP表示Python已完成操作后+1,但显然没有....
HyperNeutrino

4

答案10,欧姆,距离5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

... where <SPACES>空白答案中的那个可怕字符串替换。

答案有点厚脸皮,因为其他所有内容仅是未执行的操作。


这里有任何针对Brain-Flak的工作吗?
CalculatorFeline

@CalculatorFeline害怕。
Nick Clifford

太糟糕了。对Brainflak的10个字符!要是。
CalculatorFeline

4

答案12,认真,15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

在线尝试!

从唯一的区别其实答案是认真使用反引号标记一个函数,其中实际使用我们只是把多余的字符转换成字符串,然后弹出并丢弃。


努力奋斗

((({})<>)){((({}[()] ((  )   )       ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

+1使比赛更接近Brain-Flak。只是一个问题:您知道与“认真”非常相似的任何编程语言吗?
Xcoder先生17年

除了实际。
Xcoder先生17年

@ Mr.Xcoder我没用过。我只知道认真地是类似的,因为实际上只是认真地2.0版
Riley

4

答案14,Del | m | t,15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

在线尝试!

说明

我真的开始滥用这样一个事实,即空白不计入此处的差异。Del | m | t并不太在乎您使用什么字符,因此绝大多数代码是程序开头的一系列空格和回车符。代码的实际可见部分根本不执行。

这是转录成更“合理”方式的代码:

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

在线尝试!

它是如何在低层工作的

首先,我们O R ^ V 要在第一个循环上接受输入,并且在所有其他时间都作为空操作。

然后O,我们使用制作输入的副本,以备后用。

@ A K T调用存储在内存位置-1中的变量(在程序开始时为0)并将其A J递增。 O @ A K U将现在递增的值存储回内存位置-1,以供下一次循环使用。

N计算前一阵子的输入副本的mod,然后从内存中调用该值并将R其取反。

一起N R创建一个布尔值,该布尔值指示我们的输入是否可以被TOS整除。

我们使用将该布尔值的副本存储到内存空间-2,O @ B K U并使用调用存储空间-2的值@ A K T

我们将交换前两个元素Q以确保布尔值在最前面,如果使用true则输出值^ X

如果布尔值是假的,那么我们有一个需要消除的额外值,因此我们可以将存储在空间-2中的布尔值调用为,@ B K T如果为假,则弹出一个值R ^ P

我们用复制输入值,O并用减去存储器-1的值@ A K T K。如果为零,则退出R ^ _

最后,我们@ ^跳过下一个值。我们需要这样做是因为@代码的可见部分会产生一堆垃圾(实际上只是一个符号)。

一旦到达终点,它就会循环回到起点。

它如何在高水平上工作

基本思想是,我们有一个主要存储在内存位置-1的值,该值在每次循环时都会递增。如果该值除以我们的输入,我们将其输出,并且当两者相等时,我们将结束执行。

走向脑力激荡

因为空格不计入差额,所以我无需花费15分就可以更改代码,因此所有这些都投入了Brain-Flak代码中。

这是我们目前的地位。

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

每次提交答案时,请更新排行榜。
Xcoder先生17年

Brain-Flak答案只剩下39个字符!:)这意味着我们仍然需要至少3个答案...
HyperNeutrino

4

答案15,Befunge-98,15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

在线尝试!

(可能有很多不必要的空格,但是我现在不能打高尔夫球了)

我将全部15个用于Befunge程序,因此这次不改变Brain-flak。

我的主要策略是垂直发送IP,并使用空格从预先存在的代码中执行某些字符。

说明:

对Befunge程序重要的代码是:

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

等效于:

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line


3

答5 - SOGL 0.8.2,9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

说明:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

注意:解释器当前需要\n用替换,以便不将其计为输入,但是解析器本身认为两者可以互换。


3

答案11,实际上是15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

在线尝试!

说明

实际上有一个很好的内置函数可÷用于查找数字因子,但是我们不允许使用此类内置函数。

首先,将输入存储到寄存器中,以便将来不会受到任何损害。我使用来执行此操作,但我可以像使用其他可用命令一样轻松地使用它。

然后,粘贴我们已经拥有的代码(我删除了所有空白,因为使用它很烦人,我可以这样做,因为“空白不计算在内”)。幸运的是,当堆栈为空时,这没有做任何事情。

然后我们有程序的其余部分

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

努力奋斗

所有这些工作,我只能再多吃一顿。

((({})<>)){((({}   ] ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

您知道,如果将Brain-Flak代码括起来,则[]可以在其后加上Brainfcuk代码。可能会打开可能性。
CalculatorFeline

@CalculatorFeline我不认为我们这样做。Brain-Flak靠自己干什么就做不到。用脑力激荡投稿很难,但我认为Brain-Flak不会对其造成任何伤害。
Ad Hoc Garf Hunter

好吧,在此阶段进行Brainfuck计划将是个好主意。不能发送到Flak的字节可以放在其他计划中(例如BF,Syms或常规语言)。
CalculatorFeline

@CalculatorFeline问题是,几乎没有字节不能到达Brain-Flak。除非一门语言有一些关于parens的怪异规则(在这种情况下它可能已经不可用了),否则我们可以使用额外的字节来插入parens。
Ad Hoc Garf Hunter'Mar

为什么您的代码在数组之前输出额外的0?
Xcoder先生17年

3

23,Brain-Flak Classic,13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

最初,@ Wheat向导在答案22中发布了大脑易碎的经典代码:

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]{})           ><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[]  )>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

这是17个字符的折扣。但是,我能够通过简单地{})在建议的代码中向右移动来压缩它,以得到

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

仅关闭13个字符!因此,我要做的就是添加/删除括号以获取建议的代码。


我发布的原始代码有错字,现已修正。(谢谢@WheatWizard!



1

22,语言,15

Lenguage是一种逸出的语言,它只关心程序与内容无关的时间。因此,我们可以通过在最后一个程序中填充适当数量的空格来创建所需的任何语言程序。Lenguage被编译为Brainfuck,因此我们将重用我之前编写的Brainfuck程序

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

为了方便以后的回答,我对主程序进行了一些更改,但最终结果如下所示:

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

其中<SPACES>代表55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306空格字符。

我滥用空白不计数规则吗?也许。

迈向经典的Brain-Flak

我们已经拥有所有这些paren,所以我想我会朝着Brain-Flak Classic前进。

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

另一个目标...那是疯狂的。我喜欢!
Xcoder先生

那么,Brain-flak Classic的最上面一行是我们所拥有的,而最底层是我们所需要的?
MildlyMilquetoast

@MistahFiggins是
特设Garf Hunter,2017年

1
多田!Brain-Flak Classic离我更近了,因为我移动了一些
围裙
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.