_{รูปภาพของฉันร่างความท้าทายนี้ด้วยทักษะการวาดขั้นสูงของฉัน}

พื้นหลัง

สงคราม Stickman เกิดขึ้นนานมาแล้วเมื่อเผ่าพันธุ์ที่โดดเด่นของโลกไม่ได้ทำอะไรเลยนอกจากเกาะติด นักประวัติศาสตร์รู้สึกเสียใจที่ไม่มีช่างทาสีหรือกล้องถ่ายรูปมาก่อนเราสามารถใช้ภาพบางส่วนของสงครามในหนังสือประวัติศาสตร์ของวันนี้ นั่นคือสิ่งที่พลังการเข้ารหัสของคุณมีประโยชน์ Stickmen นั้นถูกดึงออกมาได้ง่ายมากและนักประวัติศาสตร์ก็สามารถค้นหาข้อมูลบางอย่างเกี่ยวกับจำนวนของ stickmen ที่ต่อสู้กับสงคราม ตอนนี้ก็ขึ้นอยู่กับคุณแล้วที่จะสร้างภาพของช่วงเวลาที่เหมาะสมก่อนที่สงครามจะเริ่มขึ้น!

นี่คือ stickmen ผู้กล้าหาญที่เกี่ยวข้องในสงคราม:

  โอ
| / | \ /
| |
 / \ Swordsman

 โอเอ
/ | \ |
 | |
/ \ | พลหอก

   . 
 .' * * * *
 'O *  
'\ | /
. | * * * *
'./ \ * นักเวทย์

 O
/ | \
 |
/ \ Villager

 O
/ | \
/ \ ทารก

อินพุต

รับจาก stdin หรือเทียบเท่าเป็นตัวแทนของ stickman ทุกคนที่ปรากฏในแต่ละด้านของสนามรบ ตัวอย่างเช่นถ้าสอง swordmen ต่อสู้บนด้านขวาและสองหอกทางด้านซ้ายเข้าของคุณสามารถ{Sword: 2}, {Spear: 2}, หรือ[2,0,0,0,0], [0,2,0,0,0]"WW", "SS"

เอาท์พุต

การเป็นตัวแทนของ stickmen ที่กล้าหาญทุกคนในสนามรบตามกฎด้านล่าง มันสามารถแสดงใน stdout หรือบันทึกเป็นไฟล์ไม่ว่าจะเป็นหินของเรือ

กฎระเบียบ

1. ทางด้านซ้ายจะเป็น stickmen ของ array / string / object ตัวแรกที่โปรแกรมของคุณได้รับ
2. Stickmen เหล่านั้นจะต้องดูเหมือนที่แสดงก่อนหน้านี้ในคำถามนี้
3. Infants Villagers Mages Swordsmen Spearmenคำสั่งของกองทัพด้านซ้ายต้อง
4. กองทัพฝั่งขวาจะทำตัวเหมือนกัน แต่กับตัวละครและคำสั่งสะท้อน
5. stickman แต่ละคนจะถูกคั่นด้วย 1 ช่องว่าง
6. แต่ละชั้นจะถูกคั่นด้วย 3 ช่องว่าง
7. กองทัพจะถูกคั่นด้วย 8 ช่องว่าง
8. ตั้งแต่ stickmen -ไม่ได้บินคุณต้องวาดพื้นดินโดยใช้ยัติภังค์
9. พื้นดินจะต้องจบลงในคอลัมน์เดียวกับที่ stickman คนสุดท้ายของกองทัพที่ถูกต้องจะจบลง

ตัวอย่าง

สมมติว่าโปรแกรมของฉันคาดว่าสองอาร์เรย์ที่มีความยาว 5 Infants Villagers Mages Swordsmen Spearmenและความคุ้มค่าในอาร์เรย์แต่ละตัวแทนในการสั่งซื้อ

อินพุต: [1,1,2,3,1] [0,0,1,1,1]

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

ข้อพิจารณาสุดท้าย

โปรดทราบว่าช่องว่างมาตรฐานใช้และผู้วิเศษไม่สมดุลอย่างสมบูรณ์เพียงเพราะ

ผลลัพธ์ของคำตอบที่ถูกโหวตมากที่สุดคือ "ภาพหน้าปก" ของการท้าทายนี้ คำตอบที่สั้นที่สุดภายในสิ้นเดือน (08/31/2557) จะถูกเลือกให้เป็นผู้ชนะ

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดเป็นไบต์ชนะ

¹ต้องการการอ้างอิง

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

แก้ไข 6ครั้งล่าสุดเป็นบั๊กกี้ แก้ไขบั๊กและทำให้สั้นลง นั่นคือทั้งหมดที่ฉันหวัง

แก้ไข 5ในที่สุดก็พบวิธีที่จะกำจัดการคูณด้วย 23 - รบกวนฉันตั้งแต่เริ่มต้น บวกกับการเปลี่ยนแปลงอินพุตอีกครั้ง (@William ตะโกนเมื่อมันมากเกินไป) ตอนนี้ฟังก์ชั่นคาดว่าหนึ่งพารามิเตอร์อาร์เรย์ที่มี 2 subarrays หากไม่มีการเปลี่ยนแปลงนี้ก็คือ 349 - ยังคงมีการปรับปรุง

แก้ไข 4โกนบางไบต์และเปลี่ยนรูปแบบการป้อนข้อมูลเล็กน้อย ด้วยรูปแบบอินพุตใหม่คลาสที่หายไปจะถูกแสดงเป็นองค์ประกอบอาร์เรย์ว่าง ดังนั้นD([1,,2,3,1],[,3,1,1,2])D([1,0,2,3,1],[0,3,1,1,2])แทนที่จะ ฉันคิดว่ามันยังคงปฏิบัติตามกฎ

แก้ไข 3 Golfed เพิ่มเติม ไม่มีการเปลี่ยนแปลงอัลกอริธึม แต่ใช้ array.map และฟังก์ชั่นภายในอย่างไม่เหมาะสมเพื่อหลีกเลี่ยงการวนซ้ำ

แก้ไข 2บีบอัดสายทางที่ถูกต้อง ...

แก้ไขเพิ่มการบีบอัดสตริงการทำงานมากและไม่ได้รับมาก ตอนนี้ stickmen มิเรอร์ถูกสร้างขึ้นจากแม่แบบไม่ได้จัดเก็บ

ลองสองสามครั้งแล้วทำงานครั้งแรก ที่จะตีกอล์ฟ NB Kolmogorow ธุรกิจยังคงได้รับการจัดการ

ทดสอบในคอนโซล FireFox เปลี่ยน 'คืน' ด้วยการเพิ่ม 'การแจ้งเตือน (... )' เพื่อให้มีคำสั่งเอาท์พุท (แม้ว่าจะไม่มีประโยชน์เลย)

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

เอาท์พุต

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

รหัส Golfed

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

รหัส (แก้ไข 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
}

รหัสที่ไม่ได้รับการตอบกลับ (เวอร์ชั่น 1)

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

แก้ไข:การลบหนึ่ง for-loop และใช้คำสั่ง exec บันทึก 9 ไบต์

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)

การป้อนข้อมูล:

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

เอาท์พุท:

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

C, 418 414

อินพุตตัวอย่าง:

stickwar.exe IVMMWWWS SWM

ตัวอย่างผลลัพธ์:

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

รหัส Golfed (linebreaks มีไว้เพื่อให้อ่านได้เท่านั้นควรเป็นรหัสยาวหนึ่งบรรทัด):

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

ความกว้างสูงสุดของสนามรบคือ 999 (ฉันสามารถบันทึกได้ 2 ตัวอักษรโดย จำกัด ไว้ที่ 99) ฉันใช้โครงสร้างการควบคุม 1 ไบต์ต่ออักขระเอาต์พุต (ไม่ใช่ที่ว่าง) วาดภาพตัวเลขจากล่างขึ้นบน

• 1 บิตสำหรับพิกัด y (ทั้ง "พัก" หรือ "ขึ้น")
• 3 บิตสำหรับการกระจัด x พิกัด (0 ... 4)
• ถ่าน 3 บิตสำหรับเอาท์พุทถ่าน (โชคดีมีเพียง 8 ตัวอักษรที่แตกต่างกัน)

มี 5 ออฟเซ็ตในโครงสร้างการควบคุม

บิตที่ไม่ชัดเจนอื่น ๆ :

• รหัสf%27%5แปลอักขระVWSMIเป็นตัวเลข0, 1, 2, 3, 4
• รหัสจะt*3%12%5+4คำนวณความกว้างของ stickman ของประเภทt
• รหัสt^3|~o||(s=d[5]+p,*s--=46,*s=39)บัญชีสำหรับความไม่สมดุลด้านซ้าย / ขวา
• ฉันใช้ความจริงที่ว่าargc=3เพื่อสร้างธง1และทิศทางการวาด-1

รหัสไม่ได้รับการตอบกลับ:

#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

รูปแบบอินพุต

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

คำสั่ง: [ทารก, Villager, Mage, Swordsman, Spearman], [Spearman, Swordsman, Mage, Villager, ทารก]

ตัวอย่างผลลัพธ์

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

รหัส

(?)=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 ไบต์)

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

โทรกับ./stickmanwars 1 2 3 3 4 -1 3 2 4 1 0 4 2 1 -1 หมายถึงตัวคั่นสำหรับสองอาร์เรย์ ฉันหวังว่าไม่เป็นไร

ความท้าทายครั้งแรกของฉันเกี่ยวกับการเล่นกอล์ฟและเป็นครั้งแรกที่ฉันใช้ Haskell สำหรับการสมัครจริงหลังจากที่ฉันได้เรียนในภาคเรียนที่มหาวิทยาลัยของฉัน อาจไม่ได้ใกล้เคียงกับการเป็นทางออกที่ดีที่สุดหรือสั้นที่สุด แต่ฉันสนุกที่จะสร้างมันขึ้นมาและมันก็เป็นการออกกำลังกายที่ดี :) คำติชมและคำติชมเป็นที่นิยมอย่างมาก

ดึงมันออกมาจากสิ่งนี้:

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

ความท้าทายที่ยอดเยี่ยม! ฉันอาจจะสามารถเล่นกอล์ฟที่มากขึ้นอีกเล็กน้อย โดยทั่วไปฉันกำลังจัดเก็บคอลัมน์ตัวเลขอย่างชาญฉลาดเพื่อให้ฉันสามารถผนวกพวกเขาเข้าด้วยกันได้อย่างง่ายดายจากนั้นจึงพลิกอาร์เรย์ทั้งหมดของString s arround ใช้ของ transposeHaskell

รูปแบบการป้อนข้อมูลคือ ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

นี่คือตัวอย่างจาก 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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

และนี่คือภาพที่ฉันชอบเกี่ยวกับการฆ่าตัวตายในช่วงยุคที่สอง!

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


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

Python ( 612 , 522 , 460 , 440)

• Rev1: การบีบอัดพื้นฐานและการเข้ารหัสพื้นฐาน 64
• Rev2: ลบการบีบอัด / เข้ารหัส; เล็กลง
• Rev3: การลดจำนวนไบต์เพิ่มเติมโดยการทำอินไลน์
• Rev4: นำการกลับรายการที่ไม่จำเป็นออกในกองทัพที่ 2; เปลี่ยนนักดาบและหอกให้ตรงกับสเป็ค

"เส้น" แต่ละเส้นถูกตัดแต่งด้วยการบุด้านขวาและสิ่งนี้จะถูกเพิ่มเข้ามาใหม่เมื่อทำการสร้างใหม่

ฉันย้อนกลับ stickmen ในการเข้ารหัสภายในของฉันเพราะมันช่วยให้ฉันต้องย้อนกลับพวกเขาเป็นรายบุคคลเมื่อแสดงผลพวกเขาในรหัส

วิ่งตัวอย่าง:

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

รหัส:

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)

นักแก้ปัญหาที่แตกต่างจากคนก่อนหน้าของฉัน; อีกต่อไป แต่ทำงานได้มากขึ้น

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

รหัส:

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