_{Obraz mojego szkicowania tego wyzwania z moimi zaawansowanymi umiejętnościami rysowania.}

tło

Wojny Stickman miały miejsce dawno temu, kiedy dominujący gatunek Ziemi został zrobiony tylko z patyków. Historycy żałują, że w tamtym czasie nie było malarzy ani aparatów, moglibyśmy użyć zdjęć tej wojny w dzisiejszych książkach historycznych. Właśnie tam przydają się twoje moce kodujące. Stickmenów można bardzo łatwo wyciągnąć, a historykom udało się znaleźć dane o tym, ilu stickmenów stoczyło wojny¹. Teraz musisz odtworzyć obraz z chwili tuż przed wybuchem wojny!

Oto odważni stickmani biorący udział w wojnie:

  O /
| / | \ /
| |
 / \ Swordsman

 OA
/ | \ |
 | |
/ \ | Włócznik

   . 
 . ” *.
 „O *  
„\ | /.
. | *
„./ \ *. Mag

 O
/ | \
 |
/ \ Wieśniak

 O
/ | \
/ \ Dziecko

Wejście

Otrzymuj za pośrednictwem standardowego lub równoważnego przedstawienia każdego stickmana, który pojawił się po każdej stronie pola bitwy. Na przykład, jeśli dwóch Mieczników walczyło po prawej stronie i dwóch włóczników po lewej stronie, twój wkład może być {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]lub a "WW", "SS".

Wynik

Reprezentacja każdego odważnego stickmana na polu bitwy, zgodnie z poniższymi zasadami. Może być pokazany na standardowym ekranie lub zapisany w pliku, niezależnie od tego, co kołysze twoją łódź.

Zasady

1. Po lewej stronie znajdą się wszystkie stickmeny z pierwszej tablicy / łańcucha / obiektu otrzymanego przez twój program.
2. Ci stickmen muszą wyglądać dokładnie tak, jak pokazano wcześniej w tym pytaniu.
3. Kolejność lewej armii musi być Infants Villagers Mages Swordsmen Spearmen.
4. Armia po prawej stronie będzie zachowywać się tak samo, ale z postaciami i porządkiem dublowanym.
5. Każdy stickman będzie oddzielony 1 spacją.
6. Każda klasa będzie oddzielona 3 spacjami.
7. Armie zostaną rozdzielone 8 polami.
8. Ponieważ stickmen nie lata, musisz narysować ziemię za pomocą minusów -.
9. Ziemia musi kończyć się na tej samej kolumnie, na której kończy się ostatni stickman prawej armii.

Przykład

Załóżmy, że mój program przewiduje dwie tablice o długości 5 i każdą wartość w tablicy reprezentuje w porządku, Infants Villagers Mages Swordsmen Spearmen.

Dane wejściowe: [1,1,2,3,1] [0,0,1,1,1]

               . . .
             . ” *. . ” *. . * ”.
       O 'O *' O * O / O / O / OAAO \ O * O ' 
 O / | \ '\ | /. „\ | /. | / | \ / | / | \ / | / | \ / / | \ | | / | \ \ / | \ | . \ | / ”
/ | \ | . | *. | * | | | | | | | | | | | | * | .
/ \ / \ './ \ *. „./ \ *. / \ / \ / \ / \ | | / \ / \. * / \ '.
-------------------------------------------------- -------------------------------------

Uwagi końcowe

Pamiętaj, że obowiązują standardowe luki i że mag jest całkowicie asymetryczny tylko dlatego.

Rezultatem najbardziej uprzywilejowanej odpowiedzi będzie „okładka” tego wyzwania. Najkrótsza odpowiedź do końca miesiąca (31.08.2014) zostanie wybrana jako zwycięzca.

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.

¹ Potrzebne cytat

JavaScript (E6) 336 344 356 369 424 478 522 570

Edycja 6 Ostatnia edycja była błędna. Naprawiono błąd i skrócono. To wszystko, co mam nadzieję.

Edytuj 5 W końcu znalazłem sposób na pozbycie się pomnożenia przez 23 - od samego początku niepokoiłem się. Plus kolejna zmiana na wejściu (@William krzyknie, gdy będzie za dużo). Teraz funkcja oczekuje jednego parametru tablicy zawierającego 2 podcienie. Bez tej zmiany jest to 349 - wciąż poprawa

Edycja 4 Ogolono trochę więcej bajtów i małą zmianę formatu wejściowego. W nowym formacie wejściowym brakująca klasa jest reprezentowana jako pusty element tablicy. Więc D([1,,2,3,1],[,3,1,1,2])zamiast D([1,0,2,3,1],[0,3,1,1,2]). Myślę, że nadal przestrzega zasad.

Edytuj 3 Gra w golfa więcej. Brak zmian w algorytmie, ale nadużywanie dużej ilości array.map i funkcji lokalnych w celu uniknięcia pętli.

Edytuj kompresję 2 ciągów, właściwą drogę ...

Edytuj Dodano kompresję napisów, dużo pracy i niewiele zyskane. Teraz stickmen lustrzane są generowane z szablonu, a nie przechowywane.

Wykonałem kilka prób, najpierw uruchomionych. Do gry w golfa. NB Kołmogorow-biznes wciąż do rozwiązania.

Testuj w konsoli FireFox. Zmień „return” , dodając alert „Dodaj” (...), aby mieć instrukcję wyjściową (choć w ogóle nie jest przydatna)

console.log(D([[1,,2,3,1],[,3,1,1,2]]))

Wynik

         .       .                                                                 .                 
       .' *.   .' *.                                                             .* '.               
       ' O *   ' O *      O  /   O  /   O  /    O A        A O  A O    \  O      * O '     O   O   O 
 O    ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\ |/|\    \/|\|   . \|/ '   /|\ /|\ /|\
/|\   .  |  * .  |  *   | |    | |    | |       | |        | |  | |       | |   *  |  .    |   |   | 
/ \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \ |/ \     / \    .*/ \.'   / \ / \ / \
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Kod do gry w golfa

D=a=>
  (J=v=>v.join(''))((l=[r=n=' ',3,6,13,19,23]).map(_=>f=(F=f=>J(a[f].map((c,q)=>
  ("9.299.' *.87O2' O *3O21 O A O 1|0' 0|1 .|1|01 1|0|1|0 | .2|2*| |4| |1 01 0'.1 0*. 1 021 0|"[R='replace'](/[2-9]/g,x=>n.repeat(x))
   .slice(l[q]-r,l[q+1]-r)[R](/\d/g,x=>'\\/'[x^f])+n).repeat(c)+n+n
  ))+n)(0)+J([...F(1)].reverse(r-=23))+'\n'))+f[R](/./g,'¯')

Kod (edycja 2)

D=(a,b)=>{
  F=(s,f)=>(s=s[R](/\d/g,x=>'/\\'[x^f]),f?s:[...s].reverse().join('')),
  v="9.299.' *.87O2' O *3O21 O A O 1|0' 0|1 .|1|01 1|0|1|0 | .2|2*| |4| |1 01 0'.1 0*. 1 021 0|"
    [R='replace'](/\d/g,x=>x>1?' '.repeat(x):x),
  l=[0,3,6,13,19,23];
  for(o='',r=0;v[r];r+=23,f=F(z,1)+'  '+F(w,0),o+=f+'\n',f=f[R](/./g,'¯'))
    for(z=w=p='';p<10;++p)
      if(c=(p<5?a:b)[q=p%5])x=(v.slice(r+l[q],r+l[q+1])+' ').repeat(c)+'  ',p<5?z+=x:w+=x
  return o+f
}

Kod bez golfa (1. wersja)

D=(a,b)=>{
  v="         .                .                    .' *.            .* '.               O  ' O *   O  / O A * O ' \\  O  A O  O /|\\' \\|/ .|/|\\/ /|\\|. \\|/ ' \\/|\\||/|\\/|\\ | .  |  *| |    | |*  |  .   | || | / \\/ \\'./ \\*. / \\  / \\|.*/ \\'.  / \\ |/ \\"
  l=[0,3,6,13,19,23,30,36,40]
  o=''
  for(r=0;r<6;++r)
  {
    z=w=''
    for(p=0;p<10;p++)
    {
      c=a[p]||b[p-5];
      if (c)
      {
        q = p<7 ? p%5 : p-2
        x = (v.slice(r*40+l[q],r*40+l[q+1])+' ').repeat(c)
        if (p<5) 
          z+=x+'  ';
        else 
          w=x+'  '+w
      }
    }
    f = z + '     ' + w
    o += f + '\n'
    f = '¯'.repeat(f.length-3)
  }
  return o+f
}

Python 362 353

Edycja: Usunięcie jednej pętli for i użycie instrukcji exec pozwoliło zaoszczędzić 9 bajtów

z,x,t,j=" ",input(),str.replace,0
w=0,3,6,13,19,23
a=9*z+"."+20*z+".' *."+15*z+"o  ' o *   o  a o A o a|b' b|a .|a|ba a|b|a|b | .  |  *| |    | |a ba b'.a b*. a b  a b|"
exec"b=''\nfor c in 0,1:b+=z*8*c+t(t('   '.join([z.join([a[w[k]+j:w[k+1]+j]]*v)for k,v in enumerate(x[c])if v])[::1-2*c],'a','\/'[c<1]),'b','\/'[c])\nprint b;j+=23;"*6
print'-'*len(b)

Wejście:

[0,0,2,1,1],[1,0,2,1,2]

Wynik:

   .       .                                                   .       .         
 .' *.   .' *.                                               .* '.   .* '.       
 ' o *   ' o *      o  /    o A        A o  A o    \  o      * o '   * o '       
' \|/ . ' \|/ .   |/|\/    /|\|        |/|\ |/|\    \/|\|   . \|/ ' . \|/ '    o 
.  |  * .  |  *   | |       | |        | |  | |       | |   *  |  . *  |  .   /|\
'./ \*. './ \*.    / \     / \|        |/ \ |/ \     / \    .*/ \.' .*/ \.'   / \
---------------------------------------------------------------------------------

C 418 414

Przykładowe dane wejściowe:

stickwar.exe IVMMWWWS SWM

Przykładowe dane wyjściowe:

               . . .   
             . ” *. . ” *. . * ”.
       O 'O *' O * O / O / O / OAAO \ O * O ' 
 O / | \ '\ | /. „\ | /. | / | \ / | / | \ / | / | \ / / | \ | | / | \ \ / | \ | . \ | / ”
/ | \ | . | *. | * | | | | | | | | | | | | * | .
/ \ / \ './ \ *. „./ \ *. / \ / \ / \ / \ | | / \ / \. * / \ '.
-------------------------------------------------- --------------------------------------

Kod w golfa (podziały linii służą wyłącznie do odczytu; powinna to być jedna długa linia kodu):

char d[8][999],*s,*a;p,f,t,x,y,c,l;main(o,g)char**g;{for(memset(d,32,6993);o-=
2,a=*++g;p+=3)for(;f=*a;f^*++a?p+=2:0){t=f%27%5;l=t*3%12%5+4;p+=l&o;y=6;for(s=
"(A(21;\0(A2:B(212;F\08A*B*0210KP\0-70A47/RT-A20G=CD?5D7_\0(A:(21;"+"V3'? "[t]
-32;c=*s++;)c&8?x=0*--y:0,x+=c/16-2,c^=o-1&&!(c&6),d[y][p+o*x]="/\\|O*'A."[c&7
];t^3|~o||(s=d[5]+p,*s--=46,*s=39);p+=l&-o;}memset(d[6],45,p-=4);for(y=0;*(s=d
[y++]);s[p]=0,puts(s));}

Maksymalna szerokość pola bitwy to 999 (mogłem zaoszczędzić 2 znaki, ograniczając je do 99). Użyłem struktury kontrolnej 1 bajta na znak wyjściowy (spacja), rysując liczby od dołu do góry.

• 1 bit dla współrzędnej y („zostań” lub „idź w górę”)
• 3 bity dla przesunięcia współrzędnych x (0 ... 4)
• 3 bity dla wyjściowego znaku (na szczęście istnieje tylko 8 różnych znaków)

Struktura sterowania zawiera 5 przesunięć.

Niektóre inne niejasne bity:

• Kod f%27%5tłumaczy znaki VWSMIna liczby0, 1, 2, 3, 4
• Kod t*3%12%5+4oblicza szerokość typu stickmant
• Kod t^3|~o||(s=d[5]+p,*s--=46,*s=39)uwzględnia asymetrię lewo / prawo
• Używam tego, że argc=3do generowania flag kierunku rysowania 1i-1

Nieskluczony kod:

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

char k[] = "(A(21;\0(A2:B(212;F\08A*B*0210KP\0-70A47/RT-A20G=CD?5D7_\0(A:(21;";

char d[8][999], // data of the battlefield
*s, // control string
*a; // cmdline argument
p, // position in the battlefield
f, // figure (char)
t, // type of the figure (0...4)
x,y, // coordinates while drawing the stickman
c; // control char, specifying what to draw

main(o, g) char**g; // o means "orientation" (+1, then -1)
{
    freopen("out.txt", "w", stdout);
    memset(d, ' ', 6993);

    for (; o -= 2, a=*++g;)
    {
        for (; f=*a;)
        {
            t = f%27%5;

            if (o<0)
                p += t*3%12%5+4; // go to the next stickman

            y = 6;
            for (s=k+"V3'? "[t]-32; c = *s++;) // loop over the control
            {
                if (c & 8) // bit 3: next line; set x to 0
                    --y, x = 0;
                x += c / 16 - 2; // bits 6...4: x coordinate
                if (o == -1 && !(c & 6)) // mirror \ <-> /
                    c ^= 1;
                d[y][p + o * x] = "/\\|O*'A."[c & 7];
            }
            if (t == 3 && o<0) // fix the asymmetrical mage
            {
                s=d[5]+p;
                *s--='.';
                *s='\'';
            }

            if (o>0)
                p += t*3%12%5+4; // go to the next stickman
            if (f != *++a) // is next stickman of different type?
                p += 2;
        }
        p += 3; // separate the armies
    }

    p -= 4;
    memset(d[6], '-', p); // draw the ground

    for (y = 0; *(s=d[y++]); ) // print the battle field
    {
        s[p] = 0;
        puts(s);
    }
}

Haskell, 556

Format wejściowy

([1,1,2,3,1],[0,1,1,0,1])

Zamówienie: [Niemowlak, Wieśniak, Mag, Szermierz, Włócznik], [Włócznik, Szermierz, Mag, Wieśniak, Niemowlę]

Przykładowe dane wyjściowe

               .        .                                                       .      
             .' *.    .' *.                                                   .* '.    
       O     ' O *    ' O *       O  /   O  /   O  /    O A        \  O       * O '    
 O    /|\   ' \|/ .  ' \|/ .    |/|\/  |/|\/  |/|\/    /|\|         \/|\|    . \|/ '    O
/|\    |    .  |  *  .  |  *    | |    | |    | |       | |           | |    *  |  .   /|\
/ \   / \   './ \*.  './ \*.     / \    / \    / \     / \|          / \     .*/ \.'   / \
------------------------------------------------------------------------------------------

Kod

(?)=replicate
v=reverse
g=map
e=length
s=foldr1
p=zip[3,3,8,6,4]$g lines[" O\n/|\\\n/ \\"," O\n/|\\\n |\n/ \\","   . \n .' *.\n ' O *  \n' \\|/ .\n.  |  *\n'./ \\*.","  O  /\n|/|\\/\n| |\n / \\"," O A\n/|\\|\n | |\n/ \\|"]
r n x a=a++(n-e a)?x
x '\\'='/';x '/'='\\';x c=c
y(w,p)=(w,g(v.dropWhile(==' ').g x.r w ' ')p)
m n(a,p)(b,q)=(a+b+n,[r(a+n)' ' c++d|(c,d)<-zip(h p)(h q)])where h=v.r(max(e p)(e q))[].v
p%c|sum c==0=(0,[])|1<2=s(m 3)[s(m 1)$d?(p!!i)|(i,d)<-zip[0..]c,d>0]
f(w,p)=p++[w?'-']
main=interact((\(a,b)->unlines.f$m 8(p%a)((g y.v$p)%b)).read)

Nie golfił

type Pic = (Int, [String])

pics :: [Pic]
pics = zip[3,3,8,6,4]$map lines[" O\n/|\\\n/ \\"," O\n/|\\\n |\n/ \\","   . \n .' *.\n ' O *  \n' \\|/ .\n.  |  *\n'./ \\*.","  O  /\n|/|\\/\n| |\n / \\"," O A\n/|\\|\n | |\n/ \\|"]

mirrorChar '\\' = '/'
mirrorChar '/' = '\\'
mirrorChar c = c

padL, padR :: Int -> a -> [a] -> [a]
padL n x a = replicate (n - length a) x ++ a
padR n x a = a ++ replicate (n - length a) x

mirrorPic :: Pic -> Pic
mirrorPic (w, pic) = (w, map (reverse . dropWhile (==' ') . map mirrorChar . padR w ' ') pic)

merge n (w1, pic1) (w2, pic2) =
  let h = max (length pic1) (length pic2)
  in (w1 + n + w2, [padR (w1 + n) ' ' line1 ++ line2 | (line1, line2) <- zip (padL h [] pic1) (padL h [] pic2)])

makeArmy :: [Pic] -> [Int] -> Pic
makeArmy pics counts | sum counts == 0 = (0, []) | otherwise = foldr1 (merge 3) [ foldr1 (merge 1) . replicate count $ pics !! i | (i, count) <- zip [0..] counts, count > 0]

addField :: Pic -> [String]
addField (w, pic) = pic ++ [replicate w '-']

main = do
  (counts1, counts2)<- return . read =<< getLine
  putStr . unlines . addField $ merge 8 (makeArmy pics counts1) (makeArmy (map mirrorPic . reverse $ pics) counts2)

Haskell ( 736 733 720 bajtów)

import System.Environment
import Data.List
a=1<2
h="   "
n="      "
o="    "
b (x:y)|x<0=[]|a=x:(b y)
c (x:y)|x>=0=c y|a=y
d [] _=[]
d (x:y)z|z/=x=[-5,x]++(d y x)|a=[x]++(d y x)
e x y|x< -5="        "|x<0=h|a=(([[h,h,"   .   ",n,o],[h,h," .' *. ",n,o],[h," o "," ' O * ","  O  /"," O A"],[" o ","/|\\", "' \\|/ .","|/|\\/ ","/|\\|"],["/|\\"," | ",".  |  *","| |   "," | |"],["/ \\","/ \\","'./ \\*."," / \\  ","/ \\|"]]!!(div z 5))!!(mod z 5))++" "where z=5*y+x
(§)=map
g=putStrLn
m=concat
main=do
    z<-getArgs
    let y=read§z::[Int]
    let w=sort(b y)
    let v=reverse(sort(c y))
    let u=(\(t,i)->(\s->e s i)§t)§(zip(take 6(cycle[((d w (w!!0))++[-9]++(d v (v!!0)))]))[0..5])
    mapM(\x->g(m x))u
    g(replicate(length(m(u!!0)))'-')

Zadzwoń za pomocą ./stickmanwars 2 3 1 3 4 -1 3 2 4 1 0 4 2 1 . -1 oznacza ogranicznik dla dwóch tablic. Mam nadzieję, że to w porządku.

Cóż, moje pierwsze wyzwanie golfowe i pierwszy raz użyłem haskell do prawdziwej aplikacji po tym, jak nauczyłem się go w tym semestrze na uniwersytecie. Prawdopodobnie nie jest to nawet najlepsze lub najkrótsze rozwiązanie, ale dobrze się bawiłem, tworząc je i było to dobre ćwiczenie :) Krytyka i opinie są bardzo mile widziane.

Grał w golfa z tego:

import System.Environment
import Data.List

layers = [
    ["   ", "   ",  "   .   ",  "      ",  "    "],
    ["   ", "   ",  " .' *. ",  "      ",  "    "],
    ["   ", " o ",  " ' O * ",  "  O  /",  " O A"],
    [" o ", "/|\\", "' \\|/ .", "|/|\\/ ", "/|\\|"],
    ["/|\\"," | ",  ".  |  *",  "| |   "," | |"],
    ["/ \\","/ \\", "'./ \\*.", " / \\  ","/ \\|"],
    ["¯¯¯", "¯¯¯",  "¯¯¯¯¯¯¯",  "¯¯¯¯¯¯", "¯¯¯¯"]]

getLeftSide :: [Int] -> [Int]
getLeftSide (x:xs) | x < 0 = []
                   | otherwise = x : (getLeftSide xs)

getRightSide :: [Int] -> [Int]
getRightSide (x:xs) | x >= 0 = getRightSide xs 
                    | otherwise = xs

addSpacing :: [Int] -> Int -> [Int]
addSpacing [] _ = []
addSpacing (x:xs) old | old /= x = [(-50),x] ++ (addSpacing xs x)
                      | otherwise = [x] ++ (addSpacing xs x)

getLayerStr :: Int -> Int -> String
getLayerStr item dimension | item < (-50) = "        "
getLayerStr item dimension | item < 0  = "   "
                           | otherwise = ((layers !! i) !! j) ++ " "
    where
        value = (item + (5 * dimension))
        i = div value 5
        j = mod value 5

main = do
    -- Read Arguments from command line
    a <- getArgs
    -- Convert command line arguments to Int array
    let args = map read a :: [Int]
    -- Get left side of the array and sort it
    let frstArray = sort $ getLeftSide args 
    -- Get right side of the array and sort it mirrored
    let scndArray = reverse $ sort $ getRightSide args
    -- Concat the two sides and put a delimiter in between them
    let finalArray = (addSpacing frstArray (frstArray !! 0)) ++ [-99] ++ (addSpacing scndArray (scndArray !! 0))
    -- Create the matrix by 
    -- 1. Duplicating the final array 6 times (one for each level)
    -- 2. Pair each of those 6 arrays with its level (= index)
    -- 3. Create a matrix like below:
    --
    -- 1  1  2  2  3  4  4  5 -  1  1  2  2  2  4
    -- 6  6  7  7  8  9  9 10 -  6  6  7  7  7  9
    -- 11 11 12 12 13 14 14 15 - 11 11 12 12 12 14
    -- 16 16 17 17 18 19 19 20 - 16 16 17 17 17 19
    -- 21 21 22 22 23 24 24 25 - 21 21 22 22 22 24
    -- 26 26 27 27 28 29 29 20 - 26 26 27 27 27 29
    --
    -- 4. Convert the newly calculated indices to their respective strings
    let matrix = map (\(list,i) -> map (\item -> getLayerStr item i) list) (zip (take 6 $ cycle [finalArray]) [0..5])
    -- Finaly output the matrix by concating the elements ...
    mapM (\x -> putStrLn (concat x)) matrix
    -- ... and print the ground level.
    putStrLn (replicate (length $ concat $ matrix !! 0) '¯')
    -- Exit with a new line
    putStrLn ""

Haskell, 450

import Data.List
s=["      -"]
c=["    //-":"   O| -":"    \\\\-":s,"   / /-":"  O|| -":"   \\ \\-":s,"   '.'-":" .'  .-":" ' \\ /-":". O|| -":" * / \\-":" .*  *-":"   .*.-":s,"   || -":"   / /-":"  O|| -":"   \\ \\-":"   /  -":"  /   -":s,"   / /-":"  O|| -":"   \\ \\-":"  A|||-":s]
m '\\'='/'
m '/'='\\'
m x=x
u[]=[]
u x=x++[s,s]
f x=zipWith replicate x c>>=concat.u
k(a,b)=unlines.transpose$f a++s++s++map(map$m)(reverse$f b)
main=interact$k.read

Fajne wyzwanie! Może uda mi się trochę pograć w golfa. Zasadniczo przechowuję kolumny z liczbami, aby łatwo je ze sobą połączyć, a następnie przerzucić całą tablicę za Stringpomocą Haskella transpose.

Format wejściowy to ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

Oto przykład z PO:

>>>echo ([1,1,2,3,1],[0,0,1,1,1]) | cg2
               .       .                                                            .
             .' *.   .' *.                                                        .* '.
       O     ' O *   ' O *      O  /   O  /   O  /    O A        A O    \  O      * O '
 O    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Oto moje ulubione przedstawienie niesławnego rytualnego dzieciobójstwa w drugiej erze!

>>>echo ([0,0,0,1,0],[5,0,0,0,0]) | cg2


  O  /
|/|\/          O   O   O   O   O
| |           /|\ /|\ /|\ /|\ /|\
 / \          / \ / \ / \ / \ / \
---------------------------------

Python ( 612 , 522 , 460 , 440)

• Rev1: Kompresja podstawowa i kodowanie base64
• Rev2: Usunięto kompresję / kodowanie; zmalał
• Rev3: Więcej redukcji liczby bajtów przez wstawianie
• Rev4: Usunięto niepotrzebne odwrócenie danych wejściowych w 2. armii; zamieniłem szermierza i włócznika na specyfikację

Każda „linia” jest obszywana prawym dopełnieniem i jest dodawana ponownie podczas rekonstrukcji.

Wcześniej odwróciłem stickmen w moim wewnętrznym kodowaniu, ponieważ zaoszczędziło mi to konieczności odwracania ich indywidualnie podczas renderowania ich w kodzie.

Przykładowy przebieg:

$ echo "[1,1,2,3,1],[0,0,1,1,1]"|python /tmp/g2.py 
               .       .                                                            .   
             .' *.   .' *.                                                        .* '. 
       O     ' O *   ' O *      O  /   O  /   O  /    O A        A O    \  O      * O ' 
 O    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Kod:

c=",,A O,|/|\\,| |,|/ \\,,,\\  O, \\/|\\|,   | |,  / \\,   .  , .* '., * O ',. \\|/ ',*  |  .,.*/ \\.',,, O,/|\\, |,/ \\,,,, O,/|\\,/ \\".split(',')
r=['']*6
for b in input():
    for e,f in '/$ \\/ $\\'.split():r=[x.replace(e,f)[::-1] for x in r]
    if r[0]:r=[x+'  ' for x in r]
    for n,a in enumerate(b[::-1]):
        m=c[n*6:n*6+6]
        if a:r=[x+'   '+(' '.join([y.ljust(max(map(len,m)))]*a)) for x,y in zip(r,m)] 
print '\n'.join(r+['-'*len(r[0])])

Python (476)

Inny solver od mojego poprzedniego; dłużej, ale bardziej funkcjonalnie.

$ echo "[1,1,2,3,1],[0,0,1,1,1]"|python g3.py
               .       .                                                            .   
             .' *.   .' *.                                                        .* '. 
       O     ' O *   ' O *      O  /   O  /   O  /    O A        A O    \  O      * O ' 
 O    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Kod:

c=",,A O,|L|R,| |,|L R,,,R  O, RL|R|,   | |,  L R,   .  , .* '., * O ',. R|L ',*  |  .,.*L R.',,, O,L|R, |,L R,,,, O,L|R,L R".split(',')+['']*12
s=[sum([[4-n,5]*a+[6] for n,a in enumerate(b) if a]+[[5]],[])[::-1] for b in input()]
t=[[''.join([c[a*6+n].ljust([4,6,7,3,3,1,2][a]) for a in x]) for x in s] for n in range(0,6)]
for d,e,f in 'RL/ LR\\'.split():t=[[x[0].replace(d,f),x[1].replace(e,f)] for x in t]
t=[x[0][::-1]+x[1] for x in t]
print '\n'.join(t+['-'*len(t[0])])