Tarea:

Su tarea es crear un programa que, cuando se le da un número de hilos y el número de iteraciones de una trenza, dirá a dónde va cada hilo. Las reglas son las siguientes:

• El número de hilos siempre será impar, y entre 3 y 6000 (inclusive)
• Cuando comience, los hilos se dividirán en 2 (casi) grupos iguales, el lefty el right. El lefttendrá una hebra más cuando se inicia.

Para una entrada de 7:

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

• Cada iteración, el filamento más externo del lado con más filamentos se colocará en el centro mirando hacia la dirección opuesta. El centro se define como entre las hebras que enfrenta opuestos: ////middle\\\.

1 iteración de la entrada 7 (el filamento 1 se movió al centro):

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

Ejemplo:

Entrada:

3 4

Computaciones:

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

Salida:

3 1 2

Reglas:

• No necesita mostrar las barras para la dirección del filamento, solo los números.
• Solo necesita mostrar los números después de la última iteración.
• Su salida será identificadores delimitados por espacios de los hilos
• La entrada tendrá la forma: strands [space] iterations
• El número de hilos siempre será impar, y 3 <= x <= 6000
• Este es el código de golf , por lo que gana el código más corto.

GolfScript, 33 caracteres

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

La entrada se debe proporcionar en stdin.

Ejemplos (puede probar en línea ):

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

Primero, el 179

Para Nhilos e iiteraciones, esta respuesta usa O(1)espacio y O(N)tiempo. Simplemente calculo la posición final de cada capítulo, ¡nunca iterando sobre las posiciones intermedias!

gran edición: jugó esta respuesta cambiando los condicionales a álgebra booleana. También escribí una larga explicación de cómo funciona. TL; DR: patrones formulados, división de módulo.

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

Ahora el 152

Esta es una pitón más razonablemente golfizada. (editar: gracias a Alex Thornton por editar de 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=' ')

El código debe haber sido sobornado por Python 2 para mostrar sus ventajas de golf sobre Python 3: los rangos son listas, el redondeo de división a int, la impresión no comienza una nueva línea. Lo extraño 0-i%2es porque se -i%2evalúa como (-i)%2.

Probablemente haya un enfoque más eficiente que iterar, es decir, calcular cada resultado final directamente. La operación de trenzado tiene un período de 2 * s, por lo que no puede ser tan complicado.

Ruby, 105

Solo mucha manipulación de sets. ¡Empuje, haga estallar, retroceda y cambie! Intenté no convertir entradas a enteros, pero agregó unos 20 caracteres.

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

ly r( lefty right) son las colas de "hilo". rightse invierte, así que comenzamos a tirar desde afuera.

ty f( toy from) comienzan como righty left, respectivamente, pero a medida que avanzamos seguimos intercambiándolos para que siempre podamos cambiar el último "hilo" fromy empujarlo a to( f,t=t<<f.shift,f). Esto ahorra MUCHO espacio.

Luego, revertimos rightal final.

Registro de cambios:

2.2 105 oh sí, el mapa puede tomar un proceso

2.1 108 Y en realidad, simplemente voltear las cosas como parte de la manipulación.

2.0 116 no usan esa matriz temporal. En su lugar, use dos variables de puntero que podamos manipular y seguir apuntando. Entonces solo muestra el final

1.0 123 idea inicial

Java, 270 caracteres

golfizado:

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

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

Correr en línea