Уявіть наступні діаграми як набори вертикальних перехресних труб.

1 2    1 2    1 2 3 4
\ /    \ /    \ / \ /
 X      |      |   |
/ \    / \    / \ / \
2 1    1 2   |   X   |
              \ / \ /
               X   X
              / \ / \
              3 1 4 2

На крайній лівій схемі курсор 1і 2ковзайте вниз по відповідних нахилах, перехрещуйтесь у напрямку Xта виходьте на протилежні сторони, звідки вони починалися.

Це ж ідея в середній діаграмі, але |означає, що шляхи не перетинаються, тому нічого не змінюється.

Найправіша діаграма показує більш складну маршрутизацію трубки, яка перестановляється 1 2 3 4в 3 1 4 2.

Мета

Ваша мета в цьому виклику гольфу з кодом полягає в тому, щоб скласти ці "діаграми маршрутизації трубки" з урахуванням перестановки, такі як 3 1 4 2. Виграє найкоротша програма в байтах.

Деталі

1. Введення походить від stdin як будь-яка перестановка чисел від 1 до n, розділених пробілами, де n - ціле число. Ви можете припустити, що всі дані добре сформовані.

2. Вихід діаграми маршрутизації йде до stdout.

   • "Випадання" чисел від 1 до n для того, щоб у верхній частині діаграми повинно призвести до введення перестановки внизу. (Верхній і нижній завжди шари косої риси.)
   • Діаграма не повинна бути оптимально малою. Це може бути стільки рівнів, скільки необхідно, доки це правильно.
   • Діаграма повинна містити лише символи \/ X|, а також нові рядки (без цифр).
   • |завжди слід використовувати на самих віддалених перехрестях, оскільки використання Xне має сенсу.
   • Кілька провідних або кінцевих пробілів добре, якщо діаграма все правильно викладена.

Приклади

Вхід 3 1 4 2може створити (те саме, що вище)

 \ / \ /
  |   | 
 / \ / \
|   X   |
 \ / \ /
  X   X 
 / \ / \

Вхід 1може призвести

 \
  |
 /
|
 \
  |
 /

Вхід 3 2 1може призвести

 \ / \
  X   |
 / \ /
|   X
 \ / \
  X   |
 / \ /

Вхід 2 1 3 4 6 5може призвести

\ / \ / \ /
 X   |   X
/ \ / \ / \

Пітон 2, 218 219 220 222 224 227 243 247 252 259 261 264

l=map(int,raw_input().split())
f=n=len(l)
o=s=n*' \ /'
while f+n%2:
 f-=1;i=f+n&1;a=s[2*i:][:2*n]+'\n|   '[::2-i]
 while~i>-n:a+='|X'[l[i+1]<l[i]]+'   ';l[i:i+2]=sorted(l[i:i+2]);i+=2
 o=a+f%2*'|'+'\n'+o
print o[:-2*n]

Я взяв дещо інший підхід: я вважаю, що потрібні свопи для сортування введення, а потім вертикально інвертовані, щоб отримати свопи, необхідні для перетворення відсортованого списку на вхід. Як додатковий бонус цього підходу, він може приймати довільний перелік чисел і надати перестановковому шляху перетворення сорту входу на вхід.

Приклад:

$ python sort_path.py <<< '3 1 4 5 9 2 6 8 7'
 \ / \ / \ / \ / \
  |   |   |   |   |
 / \ / \ / \ / \ /
|   |   |   |   |   
 \ / \ / \ / \ / \
  |   |   |   |   |
 / \ / \ / \ / \ /
|   |   |   |   |   
 \ / \ / \ / \ / \
  |   |   |   |   |
 / \ / \ / \ / \ /
|   X   |   |   X   
 \ / \ / \ / \ / \
  |   X   |   X   |
 / \ / \ / \ / \ /
|   |   X   X   |   
 \ / \ / \ / \ / \
  X   |   X   |   |
 / \ / \ / \ / \ /
|   |   |   |   X   
 \ / \ / \ / \ / \

Покращення:

264 -> 261: перемикається зовнішня петля від часу на час.

261 -> 259: Використовується f%2замість (c^m), тому що в арифметичних операторах пітона вищий пріоритет, ніж бітові оператори.

259 -> 252: перемикається внутрішня петля з часу на час. Комбіновані iта cзмінні.

252 -> 247: Змінено збірку, потім зворотну, щоб просто побудувати у зворотному порядку.

247 -> 243: Додані нові рядки вручну, замість використання приєднання.

243 -> 227: Прийнятий метод grc генерації косої лінії (спасибі GRC!) Та додано s.

227 -> 224: Переміщення похилої лінії повороту до внутрішнього циклу, щоб видалити a %4і зберегти символ за допомогою розширеного нарізання.

224 -> 222: Видалено m.

222 -> 220: f%2+n%2->f+n&1

220 -> 219: | 1<n-1|-> |~i>-n|(видалено провідний простір)

219 -> 218: Комбінована ініціалізація з oі sі перемістила шматок до кінця.

Пітона, 290

def g(o,u=1):
 s=['|']*o
 for i in range(o,n-1,2):v=r[i+1]in a[:a.index(r[i])]*u;s+=['|X'[v]];r[i:i+2]=r[i:i+2][::1-2*v]
 print'  '*(1-o)+'   '.join(s+['|']*(o^n%2))*u+'\n'*u+(' / \\'*n)[2*o:][:n*2]
a=map(int,raw_input().split())
n=len(a)
r=range(1,n+1)
o=1
g(1,0)
g(0)
while r!=a:g(o);o^=1

Я пішов на досить базовий підхід, але виявилося трохи довше, ніж я сподівався. Він розглядає список парами і вирішує, замінити чи не кожну пару. Це повторюється для кожного пересічного рядка, поки список не відповідає вхідному.

Приклад:

$ python path.py
5 3 8 1 4 9 2 7 6
 \ / \ / \ / \ / \
  |   |   |   X   |
 / \ / \ / \ / \ /
|   X   X   X   X
 \ / \ / \ / \ / \
  X   X   X   X   |
 / \ / \ / \ / \ /
|   X   X   |   X
 \ / \ / \ / \ / \
  X   X   X   |   |
 / \ / \ / \ / \ /
|   |   |   X   |
 \ / \ / \ / \ / \

HTML JavaScript, 553 419

Дякую @izlin та @TomHart за вказівку на мої помилки.

p=prompt();b=p.split(" "),l=b.length,d=l%2,o="",s=["","","\\/"],n="\n",a=[];for(i=0;i<l;i++){a[b[i]-1]=i+1;s[1]+=" "+s[2][i%2];s[0]+=" "+s[2][(i+1)%2];o+=" "+(i+1)}s[1]+=n,s[0]+=n;o+=n+s[1];f=1,g=2;do{var c="";for(var i=(f=f?0:1);i<l-1;i+=2)if(a[i]>a[i+1]){c+="  x ";g=2;t=a[i];a[i]=a[i+1];a[i+1]=t;}else c+="  | ";if(g==2){o+=(d?(f?"| "+c:c+"  |"):(f?"| "+c+"  |":c))+n;o+=(s[f]);}}while(--g);o+=" "+p;alert(o);

Перевірте тут: http://goo.gl/NRsXEj

Javascript - 395

378, якщо я не друкую цифри на своєму виході, але це виглядає набагато краще і покращує читабельність.
Тестуйте це тут . (з версією, що не має волі) версія для

гольфу:

a=prompt(),n=a.split(" "),l=n.length,k=[],s="",i=1;for(j=0;j<l;j++){k[n[j]-1]=j+1;s+=" "+(j+1)}s+="\n";while(i++){for(j=0;j<l;j++)s+=i%2?j%2?" \\":" /":j%2?" /":" \\";for(z=0,y=0;z<l-1;z++)if(k[z]>k[z+1])y=1;if(y==0&&i!=2)break;s+="\n";for(m=i%2;m<l;m+=2){s+=i%2&&m==1?"|":"";if(k[m]>k[m+1]){[k[m],k[m+1]]=[k[m+1],k[m]];s+=i%2?"   X":"  X "}else{s+=i%2?"   |":"  | "}}s+="\n"}s+="\n "+a;alert(s)

Пояснення

Спочатку я підмножую введення з номером індексу і змінюю перший рядок з результатами. Наприклад

3 1 4 2
v v v v substitude with
1 2 3 4

so the first line will become:
1 2 3 4
v v v v
2 4 1 3

sorting 1,2,3,4 to 3,1,4,2 is equivalent to 2,4,1,3 to 1,2,3,4

За допомогою цієї заміни я можу використовувати алгоритм сортування бульбашок для сортування 2,4,1,3 до 1,2,3,4, і графік буде найкоротшим, який ми шукаємо.
Якщо у вас є ідеї, як я можу зробити код меншим, просто прокоментуйте :)

Приклад

input: 3 4 2 1 7 5 6
output:
 1 2 3 4 5 6 7
 \ / \ / \ / \
  X   |   |   | 
 / \ / \ / \ /
|   X   |   X
 \ / \ / \ / \
  X   X   X   | 
 / \ / \ / \ /
|   X   |   |
 \ / \ / \ / \
 3 4 2 1 7 5 6

Кобра - 334 344 356 360

class P
    def main
        a,o,n=CobraCore.commandLineArgs[1:],['/','\\'],0
        c,l=a.count,a.sorted
        while (n+=1)%2or l<>a
            p,d='',(~n%4+4)//3
            for i in n%2*(c+1-c%2),p,o=p+o[1]+' ',[o.pop]+o
            for i in 1+d:c-n%2*c:2
                z=if(l[:i]<>a[:i],1,0)
                l.swap(i-z,i)
                p+=' ['|X'[z]]  '
            print[['','| '][d]+[p,p+'|'][d^c%2],p][n%2][:c*2]

Це працює, переміщуючи кожен елемент на місце, починаючи зліва. Завдяки цьому, вона часто виводитиме смішно велику (хоча все ще правильну) мапу шляху.

Приклади:

3 1 4 2

\ / \ / 
 X   X  
/ \ / \ 
|  X  |
\ / \ / 
 X   X  
/ \ / \ 
|  X  |
\ / \ / 
 X   X  
/ \ / \ 
|  X  |
\ / \ /