_{Bild von mir, wie ich diese Herausforderung mit meinen fortgeschrittenen Zeichenfähigkeiten entwerfe.}

Hintergrund

Die Stickman-Kriege ereigneten sich vor langer Zeit, als die dominierende Spezies der Erde nur aus Stöcken bestand. Historiker bedauern, dass es damals weder Maler noch Kameras gab. Wir könnten einige Bilder dieses Krieges in den heutigen Geschichtsbüchern verwenden. Hier werden Ihre Codierungsfähigkeiten nützlich. Strichmännchen lassen sich sehr leicht zeichnen, und Historiker konnten einige Daten darüber finden, wie viele Strichmännchen die Kriege geführt hatten¹. Jetzt liegt es an Ihnen, ein Bild des Augenblicks vor Kriegsbeginn zu erstellen!

Hier sind die mutigen Strichmännchen, die in den Krieg verwickelt sind:

  O /
| / | \ /
| |
 / \ Schwertkämpfer

 OA
/ | \ |
 | |
/ \ | Spearman

   . 
 . ' *.
 'O *  
'\ | /.
. | *
'./ \ *. Magier

 O
/ | \
 |
/ \ Dorfbewohner

 O
/ | \
/ \ Infant

Eingang

Erhalte über stdin oder ein Äquivalent eine Darstellung von jedem Stockmann, der auf jeder Seite des Schlachtfeldes erschien. Wenn zum Beispiel zwei Schwertkämpfer auf der rechten Seite und zwei Speermänner auf der linken Seite gekämpft haben, können Sie Folgendes eingeben {Sword: 2}, {Spear: 2}: [2,0,0,0,0], [0,2,0,0,0]oder a "WW", "SS".

Ausgabe

Eine Darstellung aller tapferen Strichmännchen auf einem Schlachtfeld gemäß den folgenden Regeln. Es kann auf stdout angezeigt oder in einer Datei gespeichert werden, unabhängig davon, was Ihr Boot bewegt.

Regeln

1. Auf der linken Seite werden alle Stickmen des ersten Arrays / Strings / Objekts angezeigt, das Ihr Programm erhalten hat.
2. Diese Strichmännchen müssen genau so aussehen wie die, die zuvor in dieser Frage gezeigt wurden.
3. Die Reihenfolge der linken Armee muss sein Infants Villagers Mages Swordsmen Spearmen.
4. Die Armee der rechten Seite wird sich genauso verhalten, nur dass die Charaktere und die Reihenfolge gespiegelt sind.
5. Jeder Strichmännchen wird durch 1 Leerzeichen getrennt.
6. Jede Klasse wird durch 3 Leerzeichen getrennt.
7. Die Armeen werden durch 8 Felder getrennt.
8. Da Strichmännchen nicht fliegen, müssen Sie den Boden mit Bindestrichen zeichnen -.
9. Der Boden muss auf derselben Säule enden, auf der der letzte Stockmann der rechten Armee endet.

Beispiel

Nehmen wir an, mein Programm erwartet zwei Arrays mit der Länge 5 und jeder Wert im Array repräsentiert in der Reihenfolge Infants Villagers Mages Swordsmen Spearmen.

Eingabe: [1,1,2,3,1] [0,0,1,1,1]

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

Schlussbetrachtungen

Bitte beachte, dass Standardlücken gelten und der Magier nur deshalb völlig asymmetrisch ist.

Das Ergebnis der am besten bewerteten Antwort wird das "Titelbild" dieser Herausforderung sein. Die kürzeste Antwort bis zum Ende des Monats (31.08.2014) wird als Gewinner ausgewählt.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

¹Zitat erforderlich

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

Änderung 6 Die letzte Änderung war fehlerhaft. Bugfix und verkürzt. Das ist alles was ich hoffe.

Edit 5 Endlich einen Weg gefunden, um die Multiplikation mit 23 loszuwerden - hat mich von Anfang an gestört. Plus eine weitere Änderung am Eingang (@William schreien, wenn es zu viel ist). Jetzt erwartet die Funktion einen Array-Parameter, der 2 Subarrays enthält. Ohne diese Änderung ist es 349 - immer noch eine Verbesserung

Edit 4 Rasiert noch ein paar Bytes und etwas Änderung am Eingabeformat. Mit dem neuen Eingabeformat wird eine fehlende Klasse als leeres Arrayelement dargestellt. Also D([1,,2,3,1],[,3,1,1,2])statt D([1,0,2,3,1],[0,3,1,1,2]). Ich denke, es gehorcht immer noch den Regeln.

Bearbeiten Sie 3 Golf mehr. Keine Änderungen am Algorithmus, aber Missbrauch vieler array.map- und lokaler Funktionen, um Schleifen zu vermeiden.

2- String-Komprimierung richtig bearbeiten ...

Bearbeiten Zusätzliche Komprimierung der Zeichenfolge, viel Arbeit und wenig Gewinn. Nun werden die Mirror Stickmen aus einer Vorlage generiert, nicht gespeichert.

Ich habe ein paar Versuche gemacht, als ich anfing zu rennen. Golf spielen. NB Kolmogorow-Geschäft noch in Angriff genommen werden.

Test In FireFox - Konsole. Ändern Sie 'return' mit Add 'alert (...)', um eine Ausgabeanweisung zu erhalten (wenn auch überhaupt nicht nützlich).

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

Ausgabe

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

Golf Code

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

Code (bearbeiten 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
}

Ungolfed Code (1. Version)

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

Bearbeiten: Entfernen einer for-Schleife und Verwenden der Exec-Anweisung, 9 Bytes gespeichert

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)

Eingang:

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

Ausgabe:

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

C 418 414

Beispiel Eingabe:

stickwar.exe IVMMWWWS SWM

Beispielausgabe:

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

Golfed Code (Zeilenumbrüche dienen nur der Lesbarkeit; es sollte eine lange Codezeile sein):

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

Die maximale Breite des Schlachtfeldes beträgt 999 (ich könnte 2 Zeichen sparen, indem ich es auf 99 beschränke). Ich habe eine Kontrollstruktur von 1 Byte pro Ausgabezeichen (ohne Leerzeichen) verwendet und die Zahlen von unten nach oben gezeichnet.

• 1 Bit für y-Koordinate (entweder "bleiben" oder "steigen")
• 3 Bits für x-Koordinatenverschiebung (0 ... 4)
• 3 Bits für Ausgabezeichen (zum Glück gibt es nur 8 verschiedene Zeichen)

Es gibt 5 Offsets in der Kontrollstruktur.

Einige andere dunkle Teile:

• Der Code f%27%5übersetzt die Zeichen VWSMIin Zahlen0, 1, 2, 3, 4
• Der Code t*3%12%5+4berechnet die Breite des Stickman vom Typt
• Der Code t^3|~o||(s=d[5]+p,*s--=46,*s=39)berücksichtigt die Links / Rechts-Asymmetrie
• Ich nutze die Tatsache, argc=3um Zeichenrichtungsflags 1und zu generieren-1

Ungolfed-Code:

#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

Eingabeformat

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

Befehl: [Infant, Villager, Mage, Schwertkämpfer, Speermann], [Speermann, Schwertkämpfer, Magier, Dorfbewohner, Infant]

Beispielausgabe

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

Code

(?)=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)

Ungolfed

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

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

Rufen Sie mit ./stickmanwars 2 3 1 3 4 -1 3 2 4 1 0 4 2 1 an . Das -1 markiert das Trennzeichen für die beiden Arrays. Ich hoffe das ist okay.

Nun, meine erste Code-Golf-Herausforderung und das erste Mal, dass ich haskell für eine echte Anwendung verwendet habe, nachdem ich es in diesem Semester an meiner Universität gelernt habe. Wahrscheinlich nicht annähernd die beste oder kürzeste Lösung, aber ich hatte Spaß beim Erstellen und es war eine gute Übung :) Kritik und Feedback werden sehr geschätzt.

Golf daraus:

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

Coole Herausforderung! Ich könnte in der Lage sein, ein bisschen mehr Golf zu spielen. Grundsätzlich speichere ich die Zahlen spaltenweise, so dass ich sie leicht aneinander anhängen kann, und Stringdrehe dann die gesamte Reihe mit Haskells um transpose.

Das Eingabeformat ist ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

Hier ist das Beispiel aus dem OP:

>>>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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Und hier ist meine Lieblingsdarstellung des berüchtigten rituellen Kindermords in der zweiten Ära!

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


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

Python ( 612 , 522 , 460 , 440)

• Rev1: Rudimentäre Komprimierung und Base64-Codierung
• Rev2: Komprimierung / Kodierung entfernt; kleiner geworden
• Rev3: Mehr Reduzierung der Byteanzahl durch Inlining
• Rev4: Nicht benötigte Eingabeumkehr für die 2. Armee entfernt; Schwertkämpfer und Speerwerfer wurden getauscht, um der Spezifikation zu entsprechen

Jede "Zeile" wird von Rechtspolstern befreit, und dies wird bei der Rekonstruktion wieder hinzugefügt.

Ich habe die Stickmen in meiner internen Codierung vorab umgekehrt, da ich sie beim Rendern im Code nicht einzeln umkehren musste.

Probelauf:

$ 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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Code:

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)

Ein anderer Löser als mein vorheriger; länger, aber funktionaler.

$ 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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Code:

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