算法编织-母亲节


11

任务:

您的任务是创建一个程序,当给定一定数量的股线和编织层的迭代次数时,该程序将告诉每个股线的去向。规则如下:

  • 股数始终为奇数,介于3到6000之间(含)
  • 当您开始时,这些股将被分成2个(几乎)相等的束,left和和rightleft当您开始时,它会多一束。

输入7:

/ / / / \ \ \
1 2 3 4 5 6 7
  • 每次迭代时,具有更多线束的一侧的最外面的线束将放置在面向相反方向的中心。中心定义为相对的股线之间:////middle\\\

输入7的1次迭代(链1已移至中心):

/ / / \ \ \ \
2 3 4 1 5 6 7

例:

输入:

3 4

计算方式:

1 2 3
 \
2 1 3
   /
2 3 1
 \
3 2 1
   /
3 1 2

输出:

3 1 2

规则:

  • 您不需要显示钢绞线方向的斜线,只需显示数字即可。
  • 您只需要在最后一次迭代后显示数字。
  • 您的输出将是这些链的以空格分隔的ID
  • 输入将采用以下形式: strands [space] iterations
  • 股数将始终为奇数,且3 <= x <= 6000
  • 这是,因此最短的代码获胜!

3
是不是3到5999,因为6000不是奇数,所以您不会有“最多6000”的数字?
kitcar2000 2014年

所以输出11 2将是2345611178910
马丁·恩德2014年

1
@Howard您的提交破坏了我的更改
TheDoctor 2014年

1
@TheDoctor我的答案在您更改之前就已经存在。
霍华德

1
我认为您的榜样应该读懂123 -> 213 -> 231 -> 321 -> 312
霍华德

Answers:


6

GolfScript,33个字符

~\),(@{:^1$[=]:y-.,2//y*^~}*;' '*

输入必须在stdin上提供。

示例(您可以在线进行测试):

> 7 1
2 3 4 1 5 6 7

> 3 4
3 1 2

> 11 2
2 3 4 5 6 11 1 7 8 9 10

6

Python:179 240个,152个字符

一,179

对于N链和i迭代,此答案使用O(1)空间和O(N)时间。我只计算每个链的最终位置,而不会迭代中间位置!

大编辑:通过将条件条件更改为布尔代数来寻找答案。我还对它的工作原理作了详尽的解释。TL; DR:公式化模式,模除。

from sys import *
N,i=map(int,stdin.readline().split())
h,t=N/2,3*N
f=lambda p:(p>N)*(t/2-(p&-2))+p/2+1
for s in xrange(N):print f((2*s+1+(s>h)*(t-4*s-2)+i*(N+1-N*(s!=h)))%(2*N)),

现在是152

这是更合理的打高尔夫球的蟒蛇。(编辑:感谢Alex Thornton从165到152的编辑)

from sys import*;l=map;r=range;n,m=l(int,stdin.readline().split());b=r(1,n+1)
for k in r(m):v=b.pop((0,n-1)[k%2]);b.insert(n/2,v)
print' '.join(l(str,b)

如果您有兴趣的话,可以将它进一步降低到151:pastebin.com/1pbwax6s
Alex Thornton

简单的更改,但非常有效。谢谢!
错误

我认为您可以通过删除lv变量并将其更改insert为slice分配来进一步削减它。
user2357112支持Monica 2014年

我敢肯定高尔夫球会缩短。老实说,我只是希望对第一个发表评论!
错误

无论如何,我写了一个解释并更新了帖子:)
–rongu

2

Python 2(109)/ Python 3(121)

Python 2

s,n=map(int,raw_input().split())
b=range(s)
for i in range(n):b[s/2:s/2]=[b.pop(0-i%2)]
for x in b:print x+1,

Python 3

s,n=map(int,input().split())
b=list(range(s))
for i in range(n):b[s//2:s//2]=[b.pop(0-i%2)]
for x in b:print(x+1,end=' ')

该代码必须已被Python 2贿赂,以展示其在Python 3上的高尔夫优势:范围是列表,四舍五入到一个整数,打印不开始换行。奇怪的0-i%2是因为-i%2评估为(-i)%2

有可能比迭代更有效的方法,即直接计算每个最终结果。编织操作的周期为2 * s,因此不会那么复杂。


2

红宝石,105岁

只是很多设置操作。推,弹出,后退和移动!我尝试不将输入转换为整数,但添加了大约20个字符。

n,i=$*.map(&:to_i)
f=l=(1..n).to_a
t=r=l.pop(n/2).reverse
i.times{f,t=t<<f.shift,f}
$><<(l+r.reverse)*' '

lrleftright)是“线程”队列。right是反向的,所以我们开始从外面拉。

tftofrom)开始为rightleft,分别,但我们去我们不断交换他们,所以我们总是能从却将最后的“线” from,并把它推到tof,t=t<<f.shift,f)。这样可以节省大量空间。

然后,我们right在最后重新反转。

变更日志:

2.2 105哦,是的,地图可以触发

2.1 108实际上,只是将事物翻转为操纵的一部分。

2.0 116不要使用该临时数组。而是使用两个指针变量,我们可以操纵并保持重新指向。然后只显示结束

1.0 123最初的想法


0

Java,270个字符

打高尔夫球:

import java.util.*;class B{public static void main(String[] a){int n=Integer.valueOf(a[0]),t=Integer.valueOf(a[1]),i=0;List<Integer> r=new ArrayList<Integer>();for(;i<n;i++){r.add(i+1);}for(i=0;i<t;i++){int k=i%2==0?0:n-1;r.add(n/2,r.remove(k));}System.out.println(r);}}

未打高尔夫球:

import java.util.*;
public class Braid {
    public static void main(String[] args) {
        int num = Integer.valueOf(args[0]);
        int iterations = Integer.valueOf(args[1]);

        //populate array
        List<Integer> arr = new ArrayList<Integer>();
        for (int i=0; i < num; i++) {
            arr.add(i+1);
        }
        for (int i=0; i < iterations; i++) {
            int index = i%2==0?0:num-1; 
            arr.add(num/2, arr.remove(index));
        }
        System.out.println(arr);
    }
}

在线运行

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.