Aufgabe:

Ihre Aufgabe ist es, ein Programm zu erstellen, das bei einer bestimmten Anzahl von Strängen und Iterationen eines Geflechts anzeigt, wohin jeder Strang führt. Die Regeln lauten wie folgt:

• Die Anzahl der Stränge ist immer ungerade und liegt zwischen 3 und 6000 (einschließlich).
• Wenn Sie beginnen, werden die Stränge in 2 (fast) gleiche Bündel unterteilt, das leftund das right. Der leftwird einen weiteren Strang haben, wenn Sie anfangen.

Für eine Eingabe von 7:

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

• Bei jeder Iteration wird der äußerste Strang der Seite mit mehr Strängen in die Mitte in die entgegengesetzte Richtung gelegt. Das Zentrum ist definiert als zwischen gegenüberliegenden gegenüberliegenden Strängen : ////middle\\\.

1 Iteration von Eingabe 7 (Strang 1 wurde in die Mitte verschoben):

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

Beispiel:

Eingang:

3 4

Berechnungen:

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

Ausgabe:

3 1 2

Regeln:

• Sie müssen nicht die Schrägstriche für die Strangrichtung anzeigen, sondern nur die Zahlen.
• Sie müssen die Zahlen erst nach der letzten Iteration anzeigen.
• Ihre Ausgabe besteht aus durch Leerzeichen getrennten IDs der Stränge
• Die Eingabe erfolgt in folgender Form: strands [space] iterations
• Die Anzahl der Stränge ist immer ungerade und 3 <= x <= 6000
• Dies ist Code-Golf , also gewinnt der kürzeste Code!

GolfScript, 33 Zeichen

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

Die Eingabe muss auf stdin erfolgen.

Beispiele (Sie können online testen ):

> 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 Zeichen

Erstens die 179

Für NStränge und iIterationen verwendet diese Antwort O(1)Raum und O(N)Zeit. Ich berechne einfach die Endposition jedes Strangs und iteriere nie über die Zwischenpositionen!

Big Edit: Golfen Sie diese Antwort, indem Sie die Bedingungen in Boolesche Algebra ändern. Ich habe auch eine ausführliche Erklärung geschrieben, wie es funktioniert. TL; DR: Formelmuster, Modulo-Division.

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

Nun die 152

Dies ist vernünftiger Golf Python. (bearbeiten: danke an Alex Thornton für die Bearbeitung von 165 auf 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=' ')

Der Code muss von Python 2 bestochen worden sein, um seine Golfvorteile gegenüber Python 3 zu demonstrieren: Bereiche sind Listen, Aufrundung auf ein Int, Druck ohne Beginn einer neuen Zeile. Das seltsame 0-i%2ist, weil -i%2bewertet als (-i)%2.

Es gibt wahrscheinlich einen effizienteren Ansatz als das Iterieren, nämlich jedes Endergebnis direkt zu berechnen. Der Flechtvorgang hat eine Periode von 2 * s, daher kann es nicht so kompliziert sein.

Ruby, 105

Nur viel Set-Manipulation. Push, Pop, Reverse und Shift! Ich habe versucht, Eingaben nicht in Ganzzahlen umzuwandeln, aber es wurden ungefähr 20 Zeichen hinzugefügt.

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

lund r( leftund right) sind die "Thread" -Warteschlangen. rightist umgekehrt, also fangen wir an, von außen zu ziehen.

tund f( tound from) beginnt , wie rightund leftjeweils, aber wie wir gehen wir immer wieder tauschen sie so können wir immer den letzten „Faden“ von verschieben fromund drücken Sie sich auf to( f,t=t<<f.shift,f). Das spart viel Platz.

Dann kehren wir rightam Ende einfach um.

Änderungsprotokoll:

2.2 105 oh yeah, map kann einen proc nehmen

2.1 108 Und tatsächlich drehen Sie die Dinge einfach als Teil der Manipulation um.

2.0 116 nicht , dass die temporäre Array. Verwenden Sie stattdessen zwei Zeigervariablen, die wir manipulieren und immer wieder neu zeigen können. Dann nur das Ende anzeigen

1.0 123 erste Idee

Java, 270 Zeichen

Golf:

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

ohne Golf:

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

Online ausführen