직무:

당신의 임무는 여러 가닥과 브레이드의 반복 횟수가 주어지면 각 가닥이 어디로 가는지를 알려주는 프로그램을 만드는 것입니다. 규칙은 다음과 같습니다.

• 스트랜드의 수는 항상 홀수이며 3에서 6000 사이입니다 (포함).
• 시작하면 스트랜드는 2 (거의) 동일한 묶음, left및 로 나뉩니다 right. 은 left당신이 시작할 때 또 하나의 가닥을해야합니다.

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
• 이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

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

파이썬 : 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

이것은 더 합리적으로 골프 파이썬입니다. (편집 : 165에서 152까지 편집 한 Alex Thornton에게 감사드립니다)

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)

파이썬 2 (109) / 파이썬 3 (121)

파이썬 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,

파이썬 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=' ')

코드는 파이썬 3에 비해 골프의 장점을 보여주기 위해 파이썬 2에 의해 뇌물을 받았습니다. 이상은 0-i%2로 -i%2평가 되기 때문 (-i)%2입니다.

각 최종 결과를 직접 계산하는 것보다 반복하는 것보다 더 효율적인 방법이있을 것입니다. 꼬기 작업의주기는 2 * s이므로 복잡 할 수 없습니다.

루비, 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)*' '

l및 r( left및 right)는 "스레드"대기열입니다. right우리는 외부에서 당기기 시작합니다.

t과 f( to와 from) 시작으로 right하고 left, 각각, 그러나 우리는 우리가 항상에서 마지막 "스레드를"전환 할 수 있도록 우리가 그들을 스와핑 계속 이동로 from와에 밀어 넣습니다 to( f,t=t<<f.shift,f). 이것은 많은 공간을 절약합니다.

그런 다음 우리 right는 마지막에 다시 반전 합니다.

변경 로그:

2.2 105 아 그래,지도는 절차를 취할 수있다

2.1 108 그리고 실제로는 조작의 일부로 물건을 뒤집습니다.

2.0 116 은 해당 임시 배열을 사용하지 않습니다. 대신 우리가 조작하고 계속 다시 지정할 수있는 두 개의 포인터 변수를 사용하십시오. 그런 다음 끝만 표시

1.0 123 초기 아이디어

자바, 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);
    }
}

온라인으로 실행