简单任务解决三次

15

您应该用一种语言编写3个程序和/或功能。

所有这些程序都应解决相同的任务，但它们都应提供不同（但有效）的输出。（即，对于每对程序，它们都应该是一些输入，这些输入会生成不同（但有效）的输出编号集。）

任务

  • 您得到一个n大于1 的整数
  • 您应该返回或输出n 不同的正整数，并且它们都不能被整除n。
  • 数字的顺序无关紧要，数字的排列也不视为不同的输出。

有效的三元组程序，其中包含一些input => output配对：

program A:
    2 => 5 9
    4 => 5 6 9 10
    5 => 2 4 8 7 1

program B:
    2 => 1 11
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

program C (differs only in one number from program B):
    2 => 1 13
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

计分

  • 您的分数是这三个程序或功能的长度之和。
  • 分数越低越好。
  • 如果您的程序/功能共享代码，则共享的代码应计入使用该代码的每个程序的长度。
code-golf  number  arithmetic  number-theory 
— Randomra
source
1
是否每个程序都必须能够从其自己的文件中运行而没有任何包含，还是这些程序可以依赖于仅计数一次的某个共享模块/库？
— quintopia，2015年
@quintopia程序/功能不应共享代码。如果是这样，则共享代码应计入使用该代码的所有程序的长度。
— randomra

Answers:

4

Pyth，17 16字节

5个字节：

^LhQQ

输出：

2: [1, 3]
3: [1, 4, 16]
4: [1, 5, 25, 125]

6个字节：

mh*QdQ

输出：

2: [1, 3]
3: [1, 4, 7]
4: [1, 5, 9, 13]

5个字节：

|RhQQ

输出：

2: [3, 1]
3: [4, 1, 2]
4: [5, 1, 2, 3]

替代版本，按升序排列： -ShQQ

— 伊萨格
source
1
哦 我喜欢第三种方案。
— quintopia，2015年
@isaacg哦，对不起
— Maltysen
8

J，16个字节

功能1，5字节

p:^i.

功能2，6个字节

+p:^i.

功能3，5字节

>:^i.

怎么运行的

功能1

p:^i.     Right argument: y

   i.     Compute (0 ... y-1).
p:        Compute P, the prime at index y (zero-indexed).
  ^       Return all powers P^e, where e belongs to (0 ... y-1).

由于P为素数且P> y，因此y无法除以P e。

功能2

+p:^i.    Right argument: y

 p:^i.    As before.
+         Add y to all results.

如果y除以P e + y，它将也除以P e + y-y = P e。

功能3

>:^i.     Right argument: y

   i.     Compute (0 ... y-1).
>:        Compute y+1.
  ^       Return all powers (y+1)^e, where e belongs to (0 ... y-1).

如果y除以（y + 1）e，则y的一些质因数Q将必须除以（y + 1）e。

但是，然后Q将除以y和y + 1，因此y +1-y = 1。

— 丹尼斯
source
3

Dyalog APL，16 17字节

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳
— 小鱼
source
2

Vitsy，54个字节

程式：

V1V \ [DV * 1 + N''O1 +]
V2V \ [DV * 1 + N''O1 +]
V3V \ [DV * 1 + N''O1 +]

输出：

2 => 3 7
4 => 5 9 13 17
5 => 6 11 16 21 26
2 => 5 7
4 => 9 13 17 21
5 => 11 16 21 26 31
2 => 7 9
4 => 13 17 21 25 
5 => 16 21 26 31 36

工作原理（使用第一个程序作为解释）：

V1V \ [DV * 1 + N''O1 +]
V将隐式输入捕获为最终的全局变量。
 1将一个推入堆栈以备后用。
  V \ []在方括号中输入时间。
     D复制堆栈的顶层项目。
      V将全局变量推入堆栈。
       * 1 +相乘，然后加1。这使其不可分割。
          N''O输出数字，后跟一个空格。
               1+在堆栈中剩余的数字上加一个。

在线尝试！

— 艾迪生·克鲁普（Addison Crump）
source
2

Perl，79岁

一个字符添加到每个程序，因为这需要-n标志。

for$a(0..$_-1){say$_*$a+1}
for$a(1..$_){say$_*$a+1}
for$a(2..$_+1){say$_*$a+1}

非常坦率的。

— 门把手
source
2

Mathematica，12 + 12 + 12 = 36个字节

# Range@#-1&
# Range@#+1&
#^Range@#+1&

测试：

# Range@#-1&[10]
(* -> {9, 19, 29, 39, 49, 59, 69, 79, 89, 99} *)
# Range@#+1&[10]
(* -> {11, 21, 31, 41, 51, 61, 71, 81, 91, 101} *)
#^Range@#+1&[10]
(* -> {11, 101, 1001, 10001, 100001, 1000001, 10000001, 100000001, 1000000001, 10000000001} *)
— 军团哺乳动物978
source
您能否添加一些示例输出？
— 圣保罗Ebermann
2

CJam，8 + 8 + 8 = 24字节

{,:)))+}
{_,f*:)}
{)_(,f#}

这是三个未命名的函数，它们期望n位于堆栈上，并在其位置保留一个整数列表。我不确定这是否是最佳选择，但稍后我将不得不寻找更短的解决方案。

测试套件。

结果：

{,:)))+}
2 => [1 3]
3 => [1 2 4]
4 => [1 2 3 5]
5 => [1 2 3 4 6]

{_,f*:)}
2 => [1 3]
3 => [1 4 7]
4 => [1 5 9 13]
5 => [1 6 11 16 21]

{)_(,f#}
2 => [1 3]
3 => [1 4 16]
4 => [1 5 25 125]
5 => [1 6 36 216 1296]

第一个也可以用作

{_),:)^}

要么

{_(,+:)}
— 马丁·恩德
source
您的结果显示，当n = 2时，所有三个都给出相同的输出
— Sparr 2015年
@Sparr允许。查看挑战中的示例。唯一的要求是它们计算不同的函数，而不是每个输入都具有不同的结果。
— 马丁·恩德
嗯，他们在某些输入上必须有不同的结果。那就是我的误读。
— Sparr 2015年
2

Python 2，79字节

lambda n:range(1,n*n,n)
lambda n:range(1,2*n*n,2*n)
lambda n:range(1,3*n*n,3*n)

这开始于三个匿名函数1和由每个计数n, 2*n, 3*n的n条款。

— 异或
source
1

认真地，20个字节

,;r*1+

,;R*1+

,;R1+*1+

是的，这不是最佳选择...

— 小鱼
source
1

Par，16字节

此处描述的自定义编码每个字符仅使用一个字节。

✶″{*↑                   ## 3 => (0 1 2) => (0 3 6)  => (1 4 7)
✶″U{ⁿ↑                  ## 3 => (1 2 3) => (3 9 27) => (4 10 28)
✶U¡↑◄                   ## 3 => (1 2 3) =>             (1 2 4)

产出

2 => (1 3)
3 => (1 4 7)
4 => (1 5 9 13)
5 => (1 6 11 16 21)

2 => (3 5)
3 => (4 10 28)
4 => (5 17 65 257)
5 => (6 26 126 626 3126)

2 => (1 3)
3 => (1 2 4)
4 => (1 2 3 5)
5 => (1 2 3 4 6)
— p
source
1

Haskell，54个字节

f n=n+1:[1..n-1]
g n=5*n+1:[1..n-1]
h n=9*n+1:[1..n-1]

这三个功能非常简单，因此...

— Arjanen
source
1

八度，11 + 13 + 13 = 37字节

@(a)1:a:a^2
@(a)a-1:a:a^2
@(a)(1:a)*a+1
— Alephalpha
source
1

Python 2，125个字节

N=input();print[i*N+1for i in range(N)]
N=input();print[i*N+1for i in range(1,N+1)]
N=input();print[i*N+1for i in range(2,N+2)]

这里的每一行都是一个完整的程序。我心中最明显的解决方案。

编辑 @ Sherlock9保存了两个字节。

— 昆托
source
1

哈斯克尔，50岁

f n=n+1:[1..n-1]
f n=1:[n+1..2*n-1]
f n=[1,n+1..n^2]

例子：

 f1 5=[6,1,2,3,4]
 f2 5=[1,6,7,8,9]
 f3 5=[1,6,11,16,21]
— 骄傲的哈斯克勒
source
0

Golfscript，50 51 57字节

曾经是quintopia的Python代码的Golfscript版本。每个功能都可以n实现。

{.,{1$*)}%\;}:f;    i*n+1 for i in range(n)
{.,{)1$*)}%\;}:g;   i*n+1 for i in range(1,n+1)
{.,{1$)\?}%\;}:h;   (n+1)**i for i in range(n)
— 夏洛克9
source
0

TI-Basic（TI-84 Plus CE），总共55 40字节

PRGM:C 12 bytes
    seq(AnsX+1,X,1,Ans

PRGM:B 14 bytes
    seq(AnsX+1,X,2,Ans+1

PRGM:C 14 bytes
    seq(AnsX+1,X,3,Ans+2

简单，类似于这里的许多其他答案，每个答案都显示范围（N）中X的数字（X + A）N + 1的列表，其中A是哪个程序（1、2或3）。

旧解决方案（55字节）：

PRGM:C 17 bytes
    Prompt N
    For(X,1,N
    Disp XN+1
    End

PRGM:B 19 bytes
    Prompt N
    For(X,2,N+1
    Disp XN+1
    End

PRGM:C 19 bytes
    Prompt N
    For(X,3,N+2
    Disp XN+1
    End

简单，类似于这里的许多其他答案，每个答案都显示范围（N）中X的数字（X + A）N + 1，其中A是哪个程序（1、2或3）。

— 比萨184
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.