Tâche:

Votre tâche consiste à créer un programme qui, lorsqu'il recevra un certain nombre de brins et le nombre d'itérations d'une tresse, indiquera où va chaque brin. Les règles sont les suivantes:

• Le nombre de brins sera toujours impair, et entre 3 et 6000 (inclus)
• Lorsque vous commencez, les brins seront divisés en 2 grappes (presque) égales, le leftet le right. Ils leftauront un brin de plus lorsque vous commencerez.

Pour une entrée de 7:

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

• À chaque itération, le brin le plus externe du côté avec plus de brins sera placé au centre face à la direction opposée. Le centre est défini comme étant entre des brins opposés face à : ////middle\\\.

1 itération de l'entrée 7 (le volet 1 a été déplacé vers le centre):

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

Exemple:

Contribution:

3 4

Calculs:

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

Production:

3 1 2

Règles:

• Vous n'avez pas besoin d'afficher les barres obliques pour la direction du brin, uniquement les nombres.
• Il vous suffit d'afficher les chiffres après la dernière itération.
• Votre sortie sera des identifiants à espace réduit des brins
• L'entrée se fera sous la forme: strands [space] iterations
• Le nombre de brins sera toujours impair et 3 <= x <= 6000
• C'est le code-golf , donc le code le plus court gagne!

GolfScript, 33 caractères

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

L'entrée doit être fournie sur stdin.

Exemples (vous pouvez tester en ligne ):

> 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 caractères

Tout d'abord, le 179

Pour les Nbrins et les iitérations, cette réponse utilise l' O(1)espace et le O(N)temps. Je calcule simplement la position finale de chaque brin, sans jamais répéter les positions intermédiaires!

Big Edit : joué cette réponse en changeant les conditions en algèbre booléenne. J'ai également écrit une longue explication de son fonctionnement. TL; DR: modèles de formule, division 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)),

Maintenant le 152

Il s'agit de python plus raisonnablement golfé. (edit: merci à Alex Thornton pour l'édition de 165 à 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=' ')

Le code doit avoir été soudoyé par Python 2 pour présenter ses avantages de golf sur Python 3: les plages étant des listes, la division arrondie à un int, l'impression ne commençant pas une nouvelle ligne. L'étrange 0-i%2est parce que -i%2évalue comme (-i)%2.

Il existe probablement une approche plus efficace que l'itération, à savoir le calcul direct de chaque résultat final. L'opération de tressage a une période de 2 *, donc ça ne peut pas être si compliqué.

Rubis, 105

Juste beaucoup de manipulation de décors. Poussez, éclatez, inversez et déplacez! J'ai essayé de ne pas convertir les entrées en nombres entiers, mais il a ajouté environ 20 caractères.

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

let r( leftet right) sont les files d'attente "thread". rightest inversé donc nous commençons à tirer de l'extérieur.

tet f( toet from) commencent respectivement par rightet left, mais au fur et à mesure , nous continuons à les échanger afin de toujours pouvoir déplacer le dernier "thread" de fromet le pousser vers to( f,t=t<<f.shift,f). Cela économise BEAUCOUP d'espace.

Ensuite, nous revenons juste rightà la fin.

Journal des modifications:

2.2 105 oh ouais, la carte peut prendre un proc

2.1 108 Et en fait, inversez simplement les choses dans le cadre de la manipulation.

2.0 116 n'utilise pas ce tableau temporaire. Utilisez plutôt deux variables de pointeur que nous pouvons manipuler et continuer à rediriger. N'affiche ensuite que la fin

1.0 123 idée initiale

Java, 270 caractères

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

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

Exécuter en ligne