DouKaku?

(defun make-amida (list)
  (unless (equal list '(0))
    (let ((n (1- (length list))))
      (nconc (make-amida (remove n list))
             (loop for x from (1- n) downto (position n list) collect x)))))

(defun print-amida (x result)
  (let ((n (1- (length result))))
    (format t "~{~D~^ ~}~&" (loop for x from 0 to n collect x))
    (dolist (i x)
      (let ((str (format nil "~V@{| ~}|" n t)))
        (setf (aref str (+ i i 1)) #\-)
        (write-line str)))
    (format t "~{~D~^ ~}~&" result)))

(let ((list '(3 5 2 4 0 1)))
  (print-amida (make-amida list) list))

import std.stdio;
import std.string;

void amidaSort(uint[] origList){
    auto sortedList = origList.dup.sort;
    auto tmpList = origList.dup;
    auto amidaRowProto = cast(char[])repeat("| ", origList.length)[0..($ - 1)];
    string[] amida;
    while(tmpList != sortedList){
        for(uint start; start <= 1; start++){
            uint[] swap;
            for(uint i = start; i < tmpList.length - 1; i += 2){
                if(tmpList[i] > tmpList[i + 1]){
                    swap ~= i;
                    auto tmp = tmpList[i + 1];
                    tmpList[i + 1] = tmpList[i];
                    tmpList[i] = tmp;
                }
            }
            if(swap.length){
                auto amidaRow = amidaRowProto.dup;
                foreach(i; swap){
                    amidaRow[(i * 2) + 1] = '-';
                }
                amida ~= cast(string)amidaRow;
            }
        }
    }
    string[] s;
    foreach(n; sortedList){
        s ~= toString(n);
    }
    string[] o;
    foreach(n; origList){
        o ~= toString(n);
    }
    if(!amida.length){
        amida ~= cast(string)amidaRowProto.dup;
    }
    writefln((s.join(" ") ~ amida.reverse ~ o.join(" ")).join("\n"));
}

void main(){
    amidaSort([3, 5, 2, 4, 0, 1]);
}

using System;
using System.Collections.Generic;
static class Program {
    static void Main() {
        List<string> data = new List<String>(new string[]{"3", "5", "2", "4", "0", "1"});
        Console.WriteLine(String.Join(" ", data.ToArray()));
        Console.WriteLine(String.Join("\n", AmidaSort(data)));
        Console.WriteLine(String.Join(" ", data.ToArray()));
    }
    static string[] AmidaSort<T>(List<T> data) where T: IComparable {
        List<string> result = new List<string>();
        for(int i = 0; i < data.Count - 1; i++){
            for(int j = data.Count - 1; i < j; j--){
                if(data[j].CompareTo(data[j - 1]) < 0) {
                    result.Add(Swap(data, j - 1));
                }
            }
        }
        return result.ToArray();
    }
    static string Swap<T>(List<T> data, int index) where T: IComparable {
        T temp = data[index];
        data[index] = data[index + 1];
        data[index + 1] = temp;
        string[] amida = new string[data.Count - 1];
        for(int i = 0; i < amida.Length; i++) {
            amida[i] = i == index ? "-" : " ";
        }
        return "|" + String.Join("|", amida) + "|";
    }
}

def ins(pos, amida, n)
  idx = amida.size
  amida.reverse_each do |row|
    break if row[pos,1] == '-' ||
      pos-2 > 0 && row[pos-2,1] == '-' ||
      pos+2 < row.size && row[pos+2,1] == '-'
    idx -= 1
  end
  if idx == amida.size
    amida.push(Array.new(n, '|').join(' '))
  end
  amida[idx][pos] = '-'
end

def make_amida(goal)
  n = goal.size
  amida = []
  cur = Array.new(n) {|i| i}
  puts cur.join(' ')
  for i in 0...n
    j = cur.index(goal[i])
    while j > i
      cur[j], cur[j-1] = cur[j-1], cur[j]
      ins(2*j-1, amida, n)
      j -= 1
    end
  end
  puts amida
  puts goal.join(' ')
end

make_amida [3, 5, 2, 4, 0, 1]

let comb n =
    let rec comb1 mask cost acc = function
        | 0 -> if cost = 0 then acc else (mask, cost) :: acc
        | x ->
            let acc = comb2 (mask lor x) (cost+1) acc (x lsr 1) in
                      comb1  mask         cost    acc (x lsr 1)
    and comb2 mask cost acc = function
        | 0 -> (mask, cost) :: acc
        | x -> comb1 mask cost acc (x lsr 1) in
    comb1 0 0 [] (1 lsl (n - 2))

let apply mask cost (state, (c1, c2)) =
    let rec apply' prev mask = function
        | []    -> [ prev ]
        | head :: tail ->
            if (mask land 1)=1 then head :: apply' prev (mask lsr 1) tail
                               else prev :: apply' head (mask lsr 1) tail in
    (match state with
    | []       -> []
    | hd :: tl -> apply' hd mask tl), (c1 + 1, c2 + cost)

let drawamida mask n =
    let rec amida s mask = function
        | 0 -> s
        | x -> if (mask land 1) = 0 then amida (s ^ " |") (mask lsr 1) (x-1)
                                    else amida (s ^ "-|") (mask lsr 1) (x-1) in
    amida "|" mask (n - 1)

let rec equal arg1 arg2 = match arg1, arg2 with
    | [], []                -> true
    | h1 :: t1, h2 :: t2    -> if h1 <> h2 then false else equal t1 t2
    | _, _                  -> false

let solve targetstate options limitcost initstate =
    let rec loop target options best current =
        let bestsoln, bestcost  = best in
        let curstate, curoption, cursoln, curcost = current in
        let costcomp (c1, c2) (m1, m2) = c1 >= m1 ||  c2 >= m2 in
        if (costcomp curcost bestcost) then best else (
            if equal target curstate then cursoln, curcost else (
                match curoption with
                    | []       -> best
                    | (mask, cost) :: tl ->
                        let newstate, newcost = apply mask cost (curstate, curcost) in
                        let best =  loop target options best (newstate, options, (mask :: cursoln), newcost) in
                                    loop target options best (curstate, tl, cursoln, curcost)
            )
        ) in
    loop targetstate options ([], limitcost) (initstate, options, [], (0, 0))

let main target =
    let rec prt = function | [] -> print_endline "" | hd :: tl -> let _ = Printf.printf "%d " hd in prt tl in
    let rec seq n   = function [] -> [] | _ :: tl -> n :: (seq (n+1) tl) in
    let len         = List.length target in
    let start       = seq 0 target in
    let _           = prt start in
    let best, (c,d) = solve target (comb len) (len, len * len) start in
    let rec prt2 n  = function [] -> () | hd :: tl -> (print_endline (drawamida hd n); prt2 n tl) in
    let _           = prt2 len (List.rev best) in
    let _           = prt target  in
    Printf.printf "Height=%d, Lines=%d\n" c d

let _ = main [ 3; 5; 2; 4; 0; 1]

(define (amida-sort1 state)
  (define (loop prev lis acc strs skip)
    (cond ((null? lis)
           (values (reverse (cons prev acc))
                   (reverse strs)))
          ((or skip (< prev (car lis)))
           (loop (car lis) (cdr lis) (cons prev acc)
                 (cons " " strs) #f))
          ((> prev (car lis))
           (loop prev (cdr lis) (cons (car lis) acc)
                 (cons "-" strs) #t))
          (else
           (error "must not happen"))))
  (loop (car state) (cdr state) '() '() #f))

(define (amida-sort final-state)
  (define (loop state strs)
    (cond ((apply < state) strs)
          (else
           (receive (state1 strs1) (amida-sort1 state)
             (loop state1 (cons strs1 strs))))))
  (loop final-state '()))

(define (make-amidakuji strs-list)
  (define (line strs)
    (string-append "|" (string-join strs "|") "|"))
  (string-join (map line strs-list) "\n"))

(define (amida final-state)
  (define (numbers->line nums)
    (string-join (map number->string nums) " "))
  (let ((start (numbers->line (iota (length final-state))))
        (end   (numbers->line final-state)))
    (print start)
    (print (make-amidakuji (amida-sort final-state)))
    (print end)))

let solve options unittest costfunc limitcost ((initstate, initcost, initsoln) as initcontext) =
    let rec loop ((bestcost, bestsoln) as best) ((curstate, curcost, cursoln) as current) = function
        | []            -> best
        | func :: tail  -> (match costfunc curcost bestcost, unittest curstate with
            | true, _   -> best
            | _,   true -> curcost, cursoln
            | _,   _    -> let best = loop best current tail in loop best (func current) options
        ) in
    loop (limitcost, initsoln) initcontext options

let comb n =
    let apply mask cost (state, (c1, c2), soln) =
        let rec apply' prev mask = function
            | []    -> [ prev ]
            | head :: tail ->
                if (mask land 1)=1 then head :: apply' prev (mask lsr 1) tail
                                   else prev :: apply' head (mask lsr 1) tail in
        (match state with
        | []       -> []
        | hd :: tl -> apply' hd mask tl), (c1 + 1, c2 + cost), (mask :: soln) in

    let rec comb1 mask cost acc = function
        | 0 -> if cost = 0 then acc else (apply mask cost) :: acc
        | x ->
            let acc = comb2 (mask lor x) (cost+1) acc (x lsr 1) in
                      comb1  mask         cost    acc (x lsr 1)
    and comb2 mask cost acc = function
        | 0 -> (apply mask cost) :: acc
        | x -> comb1 mask cost acc (x lsr 1) in
    comb1 0 0 [] (1 lsl (n - 2))

let main target =
    let drawamida mask n =
        let rec amida s mask = function
            | 0 -> s
            | x -> if (mask land 1) = 0 then amida (s ^ " |") (mask lsr 1) (x-1)
                                        else amida (s ^ "-|") (mask lsr 1) (x-1) in
        amida "|" mask (n - 1) in

    let rec equal arg1 arg2 = match arg1, arg2 with
        | [], []            -> true
        | h1 :: t1, h2 :: t2-> if h1 <> h2 then false else equal t1 t2
        | _, _              -> false in

    let rec prt = function
        | []        -> print_newline ()
        | hd :: tl  -> (Printf.printf "%d " hd; prt tl) in

    let rec prt2 n = function
        | []       -> ()
        | hd :: tl -> let _ = prt2 n tl in print_endline (drawamida hd n) in

    let start =
        let rec seq n = function
            | [] -> []
            | _  :: tl -> n :: (seq (n+1) tl) in
        seq 0 target in

    let costfunc (c1, c2) (m1, m2) = c1 > m1 || c2 > m2 in

    let len         = List.length target in
    let (c,d), best = solve (comb len) (equal target) costfunc (len+1, len * len) (start, (0, 0), []) in
    let _ = prt start       in
    let _ = prt2 len best   in
    let _ = prt target      in
    Printf.printf "Height=%d, Lines=%d\n" c d

let _ = main [ 5; 4; 3; 2; 1; 0]

import java.util.*;

public class Sample {
    public static void main(String[] args) {
        int[] sequence = new int[args.length];
        List<String> amida = new ArrayList<String>();
        String seed = "";
        String nums = "";
        for (int i = 0; i < args.length; i++) {
            sequence[i] = Integer.parseInt(args[i]);
            seed = seed + "| ";
            nums = nums + args[i] + " ";
        }
        amida.add(nums);
        boolean change;
        do {
            StringBuilder am = new StringBuilder(seed);
            change = false;
            for (int i = 0; i < sequence.length - 1; i++) {
                if (sequence[i] > sequence[i + 1]) {
                    int a = sequence[i];
                    sequence[i] = sequence[i + 1];
                    sequence[i + 1] = a;
                    change = true;
                    am.setCharAt(2 * i + 1, '-');
                    i++;
                }
            }
            if (change)
                amida.add(am.toString());
        } while (change);
        nums = "";
        for (int i = 0; i < sequence.length; i++)
            nums = nums + Integer.toString(sequence[i]) + " ";
        amida.add(nums);
        Collections.reverse(amida);
        for (String s : amida) {
            System.out.println(s);
        }
    }
}

my @current = @ARGV;
my @maze = ();
my $done = 0;
until($done)
{
  my $row = [1..(@ARGV-1)];
  $done = 1;
  for(my $i=0;$i< @current - 1;$i++)
    {
      next if $current[$i] < $current[$i+1];
      $row->[$i]=0;
      @current[$i,$i+1] = @current[$i+1,$i];
      $done = 0;
      $i++;
    }
  @maze = ($row, @maze) unless $done;
}
print join(" ",@current),"\n",
      join("\n",map{"|".join("|",map{$_?' ':'-'}@$_)."|"}@maze),"\n",
      join(" ",@ARGV),"\n";
__END__
@m=@A=@ARGV;@M=();for(;;){@r=(1..(@A-1));$f=1;for($i=0;$i<@A-1;$i++){next if$A[
$i]<$A[$i+1];$f=$r[$i++]=0;@A[$i,$i-1]=@A[$i-1,$i]}last if$f;@M=([@r],@M)}print
join"\n",join(" ",@A),(map"|".join("|",map$_?' ':'-',@$_)."|",@M),join" ",@m

| goal amida isNeighbor |
goal := #(3 5 2 4 0 1).
amida := OrderedCollection with: ((goal asString allButFirst: 2) allButLast).
isNeighbor := false.
[goal isSorted] whileFalse: [
    amida addFirst: (String streamContents: [:ss |
        1 to: goal size - 1 do: [:idx |
            ss nextPutAll: (
                (isNeighbor not and: [(goal at: idx) > (goal at: idx + 1)])
                    ifTrue:[
                        goal swap: idx with: idx + 1.
                        isNeighbor := true.
                        '|-']
                    ifFalse: [
                        isNeighbor := false.
                        '| '])].
        ss nextPut: $|])].
amida addFirst: ((goal asString allButFirst: 2) allButLast).
World findATranscript: nil.
amida do: [:line | Transcript cr; show: line]

"=>
0 1 2 3 4 5
| |-| | | |
|-| |-| |-|
| |-| |-| |
|-| |-| |-|
| |-| |-| |
3 5 2 4 0 1 "

window.onload = function()
{
  var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  var b = [3, 9, 4, 1, 5, 0, 2, 6, 8, 7];
  var pre = document.createElement("pre");
  var text = document.createTextNode(a.join(" ") + "\r" + amida(a, b) + b.join(" "));
  pre.appendChild(text);
  document.body.appendChild(pre);
}

function amida(startArray, endArray) {

 //配列のコピー
  var copyArray = startArray.concat();
  var ixStart = 0;
  var ixEnd = copyArray.length - 1;
  var amidaText = "";
  var amidas = [];
  for(var ix = 0; ix < ixEnd; ix++)
    amidas[ix] = " ";

 //交換開始
  while(ixStart < ixEnd) {
    var head = endArray[ixStart];
    var tail = endArray[ixEnd];
    for(var ix = ixStart; ix <= ixEnd; ix++) {
      if(head == copyArray[ix]) {
        if(ix == ixStart)
          ixStart++;
         else
          changeArray(ix - 1, ix);
      }

      if(tail == copyArray[ix]) {
        if(ix == ixEnd)
          ixEnd--;
         else
          changeArray(ix, ix + 1);
      }
    }
  }

  return amidaText;

 //要素交換関数
  function changeArray(x, y) {
    var refuge = copyArray[x];
    copyArray[x] = copyArray[y];
    copyArray[y] = refuge;

    amidas[x] = "-";
    amidaText += "|" + amidas.join("|") + "|\r";
    amidas[x] = " ";
  }
}

<?php
function CreateAmida($org)
{
    if (!ctype_alnum($org) ||
        count(array_unique(str_split($org))) != count(str_split($org))) {
        return NULL;
    }
    $bridge_num = strlen($org)-1;
    $p = $org;
    $step = array();
    while (1) {
        $chg = FALSE;
        $step_buf = array_fill(0, $bridge_num, ' ');
        for ($i = 0; $i < $bridge_num; $i++) {
            if ($p[$i] > $p[$i+1]) {
                $sub = array($p[$i]=>$p[$i+1], $p[$i+1]=>$p[$i]);
                $p = strtr($p, $sub);
                $step_buf[$i] = '-';
                $i++;
                $chg = TRUE;
            }
        }
        if ($chg) {
            $step[] = '|'.implode('|', $step_buf).'|';
        } else {
            break;
        }
    }
    $res = implode(' ', str_split($p))."\n";
    $res .= implode("\n", array_reverse($step))."\n";
    $res .= implode(' ', str_split($org))."\n";
    return $res;
}
?>

module Main
    where

combine :: [a] -> ([a], [b]) -> ([a], [b])
combine xs1 (xs2, is) = (xs1 ++ xs2, is)

bPath :: [Int] -> Int -> [Int] -> ([Int], [Int])
bPath []       _ is = ([], is)
bPath [x]      _ is = ([x], is)
bPath (a:b:xs) i is
    | a <= b    = combine [a]    $ bPath (b:xs) (i + 1) is
    | otherwise = combine [b, a] $ bPath xs     (i + 2) (i:is)

bSort :: [Int] -> [[Int]] -> ([Int], [[Int]])
bSort xs iss = recurse
    where
        (xs', is) = bPath xs 0 []
        recurse 
            | null is   = (xs', iss)
            | otherwise = bSort xs' ([is] ++ iss)

dumpRow :: Int -> [Int] -> IO()
dumpRow n xs = putStrLn $ " |" ++ dumpRowInner n 0 xs
    where
        dumpRowInner :: Int -> Int -> [Int] -> String
        dumpRowInner n i xs
            | n == i + 1 = ""
            | elem i xs  = "-|" ++ dumpRowInner n (i + 1) xs
            | otherwise  = " |" ++ dumpRowInner n (i + 1) xs

dumpAmida :: Int -> [[Int]] -> IO()
dumpAmida n [] = return ()
dumpAmida n (x:xs) = do
    dumpRow n x
    dumpAmida n xs

main :: IO()
main = do
    putStrLn $ show goal
    dumpAmida (length lst) ops
    putStrLn $ show lst
    where
        lst = [3, 5, 2, 4, 0, 1]
        (goal, ops) = bSort lst []

[0,1,2,3,4,5]
 | |-| | | |
 |-| |-| |-|
 | |-| |-| |
 |-| |-| |-|
 | |-| |-| |
[3,5,2,4,0,1]

%!PS
/Data (352401) def

/MaxStringLength 100 def
/Log [] def

/Append { % String1 String2 Append NewString  / Depend on MaxStringLength
    exch
    MaxStringLength string dup dup
    0 5 -1 roll dup length 4 1 roll putinterval
    4 -1 roll dup length 2 index add 4 1 roll putinterval
    0 exch getinterval
} def

/Swap { % String/Array N0 N1 Swap -
    2 copy                % String N0 N1 N0 N1
    4 index exch get      % 
    exch 4 index exch get exch % String N0 N1 V0 V1
    4 index 4 -2 roll put put
} def

/Sort {
    /AmidaData exch def
    /InitialData AmidaData 100 string copy def
    /N AmidaData length def
    0 1 N 1 sub {
        /Line () def
        /Change false def
        dup
        dup 2 mod 0 ne {
            /Line Line (| ) Append def
        } if
        2 mod 2 N 2 sub {
            dup
            AmidaData exch 2 getinterval dup 0 get exch 1 get
            gt {
                AmidaData exch dup 1 add Swap
                /Line Line (|-| ) Append def
                /Change true def
            } {
                pop
                /Line Line (| | ) Append def
            } ifelse
        } for
        N sub 2 mod 0 ne {(|)}{()} ifelse Line exch Append /Line exch def
        Change { /Log [ Log aload pop Line ] def } if
    } for

    0 1 InitialData length 1 sub { InitialData exch 1 getinterval print ( ) print } for () =
    Log { = } forall
    0 1 AmidaData length 1 sub { AmidaData exch 1 getinterval print ( ) print } for  () =
} def

Data Sort

-- http://ja.doukaku.org/109/
import List(intersperse,sort,unfoldr)
import System(getArgs)

main = do
  a:_ <- getArgs
  let goal = (read a :: [Int])
  putStrLn $ show_amida goal $ resolve goal

resolve :: [Int] -> [[Int]]
resolve q = unfoldr b_sort q
    where 
      b_sort q | null ops = Nothing
               | otherwise = Just (ops,next_q)
          where
            (next_q,ops) = f 0 q [] []
            f n (a:b:rest) q' ops | a > b = f (n+2) rest (a:b:q') (n:ops)
                                  | otherwise = f (n+1) (b:rest) (a:q') ops
            f _ r q' ops = (reverse q' ++ r,ops)

show_amida :: [Int] -> [[Int]] -> String
show_amida q result = join "\n" ([header (sort q)] ++ body ++ [header q])
    where
      join a ls = concat (intersperse a ls)
      header = (join " ") . (map show)
      body = reverse $ map make_line result
      make_line bars = "|" ++ line ++ "|"
          where
            line = join "|" $ 
                   map (\n->if elem n bars then "-" else " ") [0..(length q-2)]

#include <stdio.h>
#include <stdlib.h>

void amida(int data[], int num);

int main (int argc, char *argv[])
{
    int data[argc-1];
    int i;

    if(argc < 3){
        printf("error!! : Too few input data!\n");
    }
    else{
        for(i=0; i<argc-1; i++){
            data[i] = atoi(argv[i+1]);
            printf("%d ",i);
        }
        puts("");

        amida(data,argc-1);

        for(i=0; i<argc-1; i++){
            printf("%s ", argv[i+1]);
        }
    }
    return 0;
}
    
void amida(int data[], int num){

    int i, j, temp;
    int max=num, level=0, hyflag=0;
    char hyphen[max][num];

    for(i=0; i<max; i++){
        for(j=0; j<num; j++){
            hyphen[i][j] = ' ';
        }

        if(i%2 == 0){
            for(j=0; j<num; j+=2){
                if(data[j] > data[j+1]){
                    temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                    hyphen[level][j] = '-';
                    hyflag = 1;
                }
            }
        }
        else{
            for(j=1; j<num-1; j+=2){
                if(data[j] > data[j+1]){
                    temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                    hyphen[level][j] = '-';
                    hyflag = 1;
                }
            }
        }
        if(hyflag != 0){
            level++;
            hyflag = 0;
        }
    }
    for(level--; level>=0; level--){
        for(i=0; i<num-1; i++){
            printf("|%c",hyphen[level][i]);
            
        }
        puts("|");
    }
}

class CGhostLeg(g:List[Int]) {
    val    s:List[Int] = g.sort { (a,b) => a < b }
    var    p:List[List[Boolean]] = List()
    def create:CGhostLeg = {
        def _calc(c:List[Int],r:Tuple2[List[Int],List[Boolean]]):Tuple2[List[Int],List[Boolean]] = c match {
                case List() => r
                case h::List() => (r._1+h,r._2)
                case h::t => h.compare(t.head) match {
                        case p if p > 0 => _calc(c.slice(2).asInstanceOf[List[Int]],(r._1+c.apply(1)+h,r._2+true++(t match { case h::List() => List(); case _ => List(false) })))
                        case _ => _calc(t,(r._1+h,r._2+false))
                    }
                case _ => r
            }
        def _step(c:List[Int]):Unit = {
            val    n = _calc(c,(List(),List()))
            p = n._2::p
            if (!n._1.zip(s).filter { d => d._1 != d._2 }.isEmpty) _step(n._1)
        }
        _step(g)
        this
    }
    def print:Unit = {
        def _join(d:String,l:List[String]):String = l.head + l.tail.foldLeft("") { (s,e) => s + d + e }
        println(_join(" ",s.map { e => e.toString }))
        p.foreach { l =>
            println(_join("|",""::(l.map { e => e match { case true => "-"; case _ => " " } })+""))
        }
        println(_join(" ",g.map { e => e.toString }))
    }
}

object GhostLeg {
    def main(args:Array[String]):Unit = {
        try {
            var    g:List[Int] = args.length match {
                case 0 => List(3,5,2,4,0,1)
                case _ => args.toList.map { s => s.toInt }
            }
            (new CGhostLeg(g)).create.print
        } catch {
            case e => e.printStackTrace
        }
    }
}