Tarefa:

Sua tarefa é criar um programa que, quando for fornecido um número de fios e um número de iterações de uma trança, dirá aonde cada fio vai. As regras são as seguintes:

• O número de fios será sempre ímpar e entre 3 e 6000 (inclusive)
• Quando você inicia, os fios são divididos em 2 (quase) cachos iguais, oe lefto right. O leftterá mais um fio quando você iniciar.

Para uma entrada de 7:

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

• A cada iteração, o fio mais externo do lado com mais fios será colocado no centro, na direção oposta. O centro é definida como entre cadeias opostas de frente para: ////middle\\\.

1 iteração da entrada 7 (a linha 1 foi movida para o centro):

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

Exemplo:

Entrada:

3 4

Computações:

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

Resultado:

3 1 2

Regras:

• Você não precisa exibir as barras para a direção do fio, apenas os números.
• Você só precisa exibir os números após a última iteração.
• Sua saída será identificações dos fios delimitadas por espaço
• A entrada estará no formato: strands [space] iterations
• O número de fios será sempre ímpar e 3 <= x <= 6000
• Isso é código-golfe , então o código mais curto vence!

GolfScript, 33 caracteres

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

A entrada deve ser fornecida no stdin.

Exemplos (você pode testar 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 caracteres

Primeiro, o 179

Para Nvertentes e iiterações, esta resposta usa O(1)espaço e O(N)tempo. Simplesmente calculo a posição final de cada fio, nunca repetindo as posições intermediárias!

grande edição: alterou esta resposta com a alteração de condições para álgebra booleana. Também escrevi uma longa explicação de como funciona. TL; DR: padrões de fórmula, divisão de módulos.

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

Agora o 152

Este é um python mais razoavelmente golfe. (editar: agradecimentos a Alex Thornton pela edição 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=' ')

O código deve ter sido subornado pelo Python 2 para mostrar suas vantagens de golfe em relação ao Python 3: intervalos sendo listas, divisão arredondada para int, impressão não iniciando uma nova linha. O estranho 0-i%2é porque -i%2avalia como (-i)%2.

Provavelmente existe uma abordagem mais eficiente do que a iteração, ou seja, computar cada resultado final diretamente. A operação de trança tem um período de 2 * s, por isso não pode ser tão complicado.

Ruby, 105

Apenas muita manipulação de cenários. Empurre, pop, reverter e mudar! Tentei não converter entradas em números inteiros, mas adicionei cerca de 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)*' '

le r( lefte right) são as filas "encadeadas". righté invertida, então começamos a puxar por fora.

te f( toe from) começam como righte left, respectivamente, mas à medida que avançamos, continuamos trocando-os para que possamos sempre mudar o último "encadeamento" de frome pressioná-lo para to( f,t=t<<f.shift,f). Isso economiza muito espaço.

Então nós apenas revertemos rightno final.

Changelog:

2,2 105 oh sim, o mapa pode levar um proc

2.1 108 E, na verdade, basta inverter as coisas como parte da manipulação.

2.0 116 não usa essa matriz temporária. Em vez disso, use duas variáveis ​​de ponteiro que podemos manipular e continuar apontando novamente. Em seguida, apenas exiba o final

1.0 123 ideia inicial

Java, 270 caracteres

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

sem golfe:

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

Executar online