Görev:

Senin görevin, bir dizi ip ve bir örgünün yineleme sayısı verildiğinde, her ipin nereye gittiğini söyleyecek bir program oluşturmaktır. Kurallar aşağıdaki gibidir:

• Tellerin sayısı her zaman garip olacak ve 3 ile 6000 arasında (dahil)
• Başladığınızda, teller 2 (neredeyse) eşit demete bölünecektir, leftve right. leftEğer başladığınızda bir daha telini sahip olacaktır.

7 girişi için:

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

• Her iterasyon, daha fazla iplikçikli yanın en dıştaki ipliği, merkeze ters yöne bakacak şekilde yerleştirilecektir. Merkezi ters bakan kolları arasında aşağıdaki gibi tanımlanır: ////middle\\\.

1 giriş 7 tekrarı (tel 1 merkeze taşındı):

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

Misal:

Giriş:

3 4

hesaplamalar:

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

Çıktı:

3 1 2

Kurallar:

• Şerit yönü için eğik çizgileri, yalnızca sayıları görüntülemenize gerek yoktur.
• Numaraları yalnızca son yinelemeden sonra görüntülemeniz gerekir.
• Çıktınız ipliklerin alanla sınırlı kimlikleri olacaktır
• Girdi şu şekilde olacaktır: strands [space] iterations
• Tellerin sayısı her zaman garip olacaktır ve 3 <= x <= 6000
• Bu kod golf , bu yüzden en kısa kod kazanır!

GolfScript, 33 karakter

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

Giriş stdin üzerinde sağlanmalıdır.

Örnekler ( çevrimiçi test edebilirsiniz ):

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

İlk olarak, 179

İçin Nipliklerini ve itekrarlamalar, bu cevabı kullanır O(1)uzay ve O(N)zaman. Her bir ipin son konumunu hesaplıyorum, asla ara konumlar üzerinde tekrarlamıyorum!

büyük düzenleme: boolean cebiri koşullarını değiştirerek bu cevabı golf etti. Ayrıca nasıl çalıştığına dair uzun bir açıklama da yazdım . TL; DR: formül modelleri, modulo bölünmesi.

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

Şimdi 152

Bu daha makul golfçü python. (değiştir: 165'ten 152'ye kadar düzenleme için Alex Thornton'a teşekkürler)

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

Python 2'ye göre golf avantajlarını göstermek için kod Python 2 tarafından rüşvet verilmelidir: listeler olan aralıklar, bir int'e bölünen yuvarlama, bir satırsonu başlatmayan baskı. Tuhaf 0-i%2çünkü olarak -i%2değerlendirir (-i)%2.

Muhtemelen yinelemekten daha etkili bir yaklaşım vardır, yani her bir nihai sonucu doğrudan hesaplamak. Örgü işleminin süresi 2 * s'dir, bu yüzden bu kadar karmaşık olamaz.

Yakut, 105

Sadece çok fazla manipülasyon. Push, pop, ters ve shift! Girişleri tamsayıya dönüştürmemeye çalıştım, ancak yaklaşık 20 karakter ekledi.

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

lve r( leftve right) "evre" kuyruklarıdır. righttersine çevrilir, böylece dışarıdan çekmeye başlarız.

tve f( tove from) sırasıyla rightve olarak başlayın left, ancak gittikçe onları değiştirmeye devam ediyoruz, böylece her zaman son "iş parçacığını" fromkaydırıp to( f,t=t<<f.shift,f) öğesine itebiliriz . Bu çok fazla alan kazandırır.

Sonra rightsonunda geri geri dönüyoruz.

Değişiklikler:

2.2 105 oh evet, harita bir süreç alabilir

2.1 108 Ve aslında, sadece manipülasyonun bir parçası olarak işleri çevirin.

2.0 116 bu geçici diziyi kullanmaz. Bunun yerine, iki işaretçi değişkeni kullanabiliriz. Sonra sadece sonu göster

1.0 123 ilk fikir

Java, 270 karakter

golfed:

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

un-golfed:

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

Çevrimiçi çalıştırın