Zadanie:

Twoim zadaniem jest stworzenie programu, który, biorąc pod uwagę liczbę nici i liczbę iteracji warkocza, powie, gdzie idzie każda nić. Zasady są następujące:

• Liczba pasm będzie zawsze nieparzysta i będzie wynosić od 3 do 6000 (włącznie)
• Kiedy zaczniesz, nici zostaną podzielone na 2 (prawie) równe pęczki, leftoraz right. leftBędzie miał jeszcze jedną nić po uruchomieniu.

Dla wejścia 7:

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

• Podczas każdej iteracji najbardziej zewnętrzna część boku z większą liczbą pasm zostanie umieszczona na środku w kierunku przeciwnym. Środek jest zdefiniowany między przeciwnych nici przeciwległych: ////middle\\\.

1 iteracja wejścia 7 (nić 1 została przesunięta na środek):

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

Przykład:

Wejście:

3 4

Obliczenia:

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

Wynik:

3 1 2

Zasady:

• Nie trzeba wyświetlać ukośników dla kierunku nici, tylko liczby.
• Musisz tylko wyświetlić liczby po ostatniej iteracji.
• Twój wynik to rozdzielone spacjami identyfikatory pasm
• Dane wejściowe będą miały postać: strands [space] iterations
• Liczba pasm zawsze będzie nieparzysta, a 3 <= x <= 6000
• To jest kod-golf , więc wygrywa najkrótszy kod!

GolfScript, 33 znaki

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

Dane wejściowe należy podać na standardowym wejściu.

Przykłady (możesz przetestować online ):

> 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

Python: 179 240 , 152 znaków

Po pierwsze, 179

W przypadku Nnici i iiteracji ta odpowiedź wykorzystuje O(1)przestrzeń i O(N)czas. Po prostu obliczam pozycję końcową każdego pasma, nigdy nie iterując po pozycjach pośrednich!

duża edycja: przejrzałem tę odpowiedź, zmieniając warunkową na algebrę logiczną. Napisałem też obszerne wyjaśnienie, jak to działa. TL; DR: wzory formalne, podział modulo.

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)),

Teraz 152

To jest bardziej rozsądny golfowy python. (edycja: dzięki Alexowi Thorntonowi za edycję od 165 do 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)

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=' ')

Kod musiał zostać przekupiony przez Python 2, aby pokazać zalety gry w golfa w porównaniu do Pythona 3: zakresy są listami, podział zaokrągla w dół do liczby całkowitej, druk nie rozpoczyna nowej linii. Dziwne 0-i%2jest, ponieważ -i%2ocenia jako (-i)%2.

Prawdopodobnie istnieje bardziej wydajne podejście niż iteracja, a mianowicie bezpośrednie obliczanie każdego wyniku końcowego. Operacja oplatania ma okres 2 * s, więc nie może być tak skomplikowana.

Ruby, 105

Po prostu dużo manipulacji zestawem. Pchaj, pop, cofaj i przesuwaj! Próbowałem nie konwertować danych wejściowych na liczby całkowite, ale dodało to około 20 znaków.

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)*' '

li r(left i right) są kolejkami „wątkowymi”. rightjest odwrócony, więc zaczynamy ciągnąć z zewnątrz.

toraz f( toi from) zacząć jako rightileft , ale w miarę upływu czasu wymieniamy je, dzięki czemu zawsze możemy przesunąć ostatni „wątek” fromi przesunąć go do to( f,t=t<<f.shift,f). To oszczędza dużo miejsca.

Następnie po prostu cofamy rightna końcu.

Dziennik zmian:

2.2 105 o tak, mapa może zająć proc

2.1 108 I właściwie, po prostu przerzucaj rzeczy w ramach manipulacji.

2.0 116 nie używają tej tymczasowej tablicy. Zamiast tego użyj dwóch zmiennych wskaźnikowych, którymi możemy manipulować i ciągle przekierowywać. Następnie wyświetl tylko koniec

1.0 123 wstępny pomysł

Java, 270 znaków

grał w golfa:

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);}}

bez golfa:

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);
    }
}

Uruchom online