Compito:

Il tuo compito è quello di creare un programma che, quando viene dato un numero di trefoli e un numero di iterazioni di una treccia, dirà dove va ogni filo. Le regole sono le seguenti:

• Il numero di trefoli sarà sempre dispari e compreso tra 3 e 6000 (incluso)
• Quando inizi, i fili saranno divisi in 2 (quasi) gruppi uguali, il lefte il right. L' leftavrà un altro filone quando si inizia.

Per un input di 7:

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

• Ogni iterazione, il filo più esterno del lato con più fili verrà messo al centro rivolto nella direzione opposta. Il centro è definito come fra i fili affacciate opposte: ////middle\\\.

1 iterazione dell'ingresso 7 (il filo 1 è stato spostato al centro):

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

Esempio:

Ingresso:

3 4

calcoli:

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

Produzione:

3 1 2

Regole:

• Non è necessario visualizzare le barre per la direzione del filo, solo i numeri.
• Devi solo visualizzare i numeri dopo l'ultima iterazione.
• Il tuo output sarà un id delimitato da spazi dei filamenti
• L'input sarà nella forma: strands [space] iterations
• Il numero di trefoli sarà sempre dispari e 3 <= x <= 6000
• Questo è code-golf , quindi vince il codice più corto!

GolfScript, 33 caratteri

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

L'input deve essere fornito su stdin.

Esempi (puoi testare 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 caratteri

Innanzitutto, il 179

Per i Nfili e le iiterazioni, questa risposta utilizza O(1)spazio e O(N)tempo. Calcolo semplicemente la posizione finale di ciascun filo, senza mai scorrere le posizioni intermedie!

modifica grande: risolto questa risposta cambiando i condizionali in algebra booleana. Ho anche scritto una lunga spiegazione di come funziona. TL; DR: schemi formulaici, divisione 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)),

Ora il 152

Questo è il pitone più ragionevolmente golfato. (modifica: grazie ad Alex Thornton per la modifica da 165 a 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=' ')

Il codice deve essere stato corrotto da Python 2 per mostrare i suoi vantaggi del golf rispetto a Python 3: le gamme sono liste, la divisione viene arrotondata per difetto a un int, la stampa non inizia una nuova riga. Lo strano 0-i%2è perché -i%2valuta come (-i)%2.

Probabilmente esiste un approccio più efficiente dell'iterazione, vale a dire calcolare direttamente ogni risultato finale. L'operazione di intrecciatura ha un periodo di 2 * s, quindi non può essere così complicata.

Ruby, 105

Solo un sacco di manipolazione del set. Spingi, fai scoppiare, inverti e sposta! Ho provato a non convertire gli input in numeri interi, ma ha aggiunto circa 20 caratteri.

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

le r( lefte right) sono le code "thread". rightè invertito, quindi iniziamo a tirare dall'esterno.

te f( toe from) iniziare come righte left, rispettivamente, ma mentre procediamo continuiamo a scambiarli in modo da poter sempre spostare l'ultimo "thread" da frome spingerlo a to( f,t=t<<f.shift,f). Ciò consente di risparmiare MOLTO spazio.

Quindi alla fine torniamo indietro right.

changelog:

2.2 105 oh sì, la mappa può richiedere un proc

2.1 108 E in realtà, capovolgi le cose come parte della manipolazione.

2.0 116 non usa quell'array temporaneo. Usa invece due variabili puntatore che possiamo manipolare e continuare a reindirizzare. Quindi visualizzare solo la fine

1.0 123 idea iniziale

Java, 270 caratteri

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

ONU-giocato a 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);
    }
}

Corri online