_{Hình ảnh tôi phác thảo thử thách này với các kỹ năng vẽ nâng cao của tôi.}

Lý lịch

Các cuộc chiến tranh Stickman đã xảy ra từ lâu, khi các loài thống trị của Trái đất không có gì ngoài gậy. Các nhà sử học rất tiếc rằng không có họa sĩ hay máy ảnh nào trước đó, chúng ta có thể sử dụng một số hình ảnh về cuộc chiến đó trong sách lịch sử ngày nay. Đó là nơi sức mạnh mã hóa của bạn trở nên hữu ích. Stickmen rất dễ bị lôi cuốn và các nhà sử học đã tìm được một số dữ liệu về việc có bao nhiêu stickmen đã chiến đấu trong các cuộc chiến¹. Bây giờ tùy thuộc vào bạn để tạo lại một hình ảnh của khoảnh khắc ngay trước khi chiến tranh bắt đầu!

Dưới đây là những nhân vật dũng cảm tham gia vào cuộc chiến:

  Ô /
| / | \ /
| |
 / \ Người đánh kiếm

 Viêm khớp
/ | \ |
 | |
/ \ | Spearman

   . 
 . ' *.
 'O *  
'\ | /.
. | *
'./ \ *. Pháp sư

 Ôi
/ | \
 |
/ \ Dân làng

 Ôi
/ | \
/ \ Trẻ sơ sinh

Đầu vào

Nhận thông qua stdin hoặc tương đương một đại diện của mỗi stickman xuất hiện ở mỗi bên của chiến trường. Ví dụ, nếu hai Swordmen chiến đấu ở phía bên phải và hai spearmen ở phía bên trái, đầu vào của bạn có thể được {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]hoặc một "WW", "SS".

Đầu ra

Một đại diện của mỗi stickmen dũng cảm trong một chiến trường, theo các quy tắc dưới đây. Nó có thể được hiển thị trên thiết bị xuất chuẩn hoặc lưu vào một tập tin, bất cứ điều gì làm rung chuyển thuyền của bạn.

Quy tắc

1. Ở phía bên trái sẽ là mỗi stickmen của mảng / chuỗi / đối tượng đầu tiên mà chương trình của bạn nhận được.
2. Những stickmen phải trông giống hệt như những người được hiển thị trước câu hỏi này.
3. Thứ tự của quân đội bên trái phải được Infants Villagers Mages Swordsmen Spearmen.
4. Quân đội bên phải sẽ hành xử giống nhau, nhưng với các nhân vật và trật tự được nhân đôi.
5. Mỗi stickman sẽ được phân tách bằng 1 khoảng trắng.
6. Mỗi lớp sẽ được ngăn cách bởi 3 khoảng trắng.
7. Quân đội sẽ được ngăn cách bởi 8 khoảng trống.
8. Vì stickmen không bay, bạn phải vẽ mặt đất bằng cách sử dụng dấu gạch nối -.
9. Mặt đất phải kết thúc trên cùng một cột, gậy cuối cùng của quân đội bên phải kết thúc.

Thí dụ

Giả sử chương trình của tôi mong đợi hai mảng có độ dài 5 và mỗi giá trị trong mảng đại diện theo thứ tự , Infants Villagers Mages Swordsmen Spearmen.

Đầu vào: [1,1,2,3,1] [0,0,1,1,1]

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

Cân nhắc cuối cùng

Xin lưu ý rằng sơ hở tiêu chuẩn áp dụng và pháp sư hoàn toàn không đối xứng chỉ vì.

Kết quả của hầu hết các câu trả lời được đánh giá cao sẽ là "ảnh bìa" của thử thách này. Câu trả lời ngắn nhất vào cuối tháng (31/08/2014) sẽ được chọn là người chiến thắng.

Đây là mã golf , vì vậy mã ngắn nhất, tính bằng byte, sẽ thắng.

Ucation Cần thiết

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

Chỉnh sửa 6 Chỉnh sửa cuối cùng là lỗi. Sửa lỗi và rút ngắn. Đó là tất cả những gì tôi hy vọng.

Chỉnh sửa 5 Cuối cùng cũng tìm được cách thoát khỏi bội số của 23 - làm phiền tôi từ đầu. Thêm một thay đổi khác cho đầu vào (@William hét lên khi quá nhiều). Bây giờ hàm mong đợi một tham số mảng, chứa 2 tập con. Không có thay đổi này, đó là 349 - vẫn là một cải tiến

Chỉnh sửa 4 Đã cạo thêm một số byte và thay đổi một chút sang định dạng đầu vào. Với định dạng đầu vào mới, một lớp bị thiếu được biểu diễn dưới dạng một phần tử mảng trống. Vì vậy, D([1,,2,3,1],[,3,1,1,2])thay vì D([1,0,2,3,1],[0,3,1,1,2]). Tôi nghĩ rằng nó vẫn tuân thủ các quy tắc.

Chỉnh sửa 3 Golf thêm. Không có thay đổi đối với thuật toán, nhưng lạm dụng rất nhiều hàm Array.map và cục bộ để tránh các vòng lặp.

Chỉnh sửa nén 2 chuỗi, đúng cách ...

Chỉnh sửa Đã thêm nén chuỗi, rất nhiều công việc và không thu được nhiều. Bây giờ stickmen gương được tạo từ một mẫu, không được lưu trữ.

Thực hiện một vài lần thử, lần đầu tiên chạy. Được chơi golf. NB Kolmogorow-kinh doanh vẫn phải được giải quyết.

Kiểm tra trong bảng điều khiển FireFox. Thay đổi 'return' bằng Add 'alert (...)' để có câu lệnh đầu ra (mặc dù không hữu ích chút nào)

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

Đầu ra

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

Mã đánh gôn

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

Mã (chỉnh sửa 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
}

Mã Ungolfed (phiên bản 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
}

Con trăn 362 353

Chỉnh sửa: Xóa một vòng lặp for và sử dụng câu lệnh exec đã lưu 9 byte

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)

Đầu vào:

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

Đầu ra:

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

C, 418 414

Ví dụ đầu vào:

stickwar.exe IVMMWWWS SWM

Ví dụ đầu ra:

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

Mã đánh gôn (ngắt dòng chỉ để dễ đọc; nó phải là một dòng mã dài):

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

Độ rộng tối đa của chiến trường là 999 (tôi có thể lưu 2 ký tự bằng cách giới hạn ở mức 99). Tôi đã sử dụng cấu trúc điều khiển 1 byte cho mỗi ký tự đầu ra (không phải khoảng trắng), vẽ các số liệu từ dưới lên.

• 1 bit cho tọa độ y ("ở lại" hoặc "đi lên")
• 3 bit cho chuyển vị tọa độ x (0 ... 4)
• 3 bit cho char đầu ra (may mắn thay, chỉ có 8 ký tự khác nhau)

Có 5 điểm bù vào cấu trúc điều khiển.

Một số bit tối nghĩa khác:

• Mã f%27%5dịch các ký tự VWSMIthành số0, 1, 2, 3, 4
• Mã này t*3%12%5+4tính toán chiều rộng của stickman loạit
• Mã t^3|~o||(s=d[5]+p,*s--=46,*s=39)tài khoản cho sự bất đối xứng trái / phải
• Tôi sử dụng thực tế là argc=3để tạo cờ hướng vẽ 1và-1

Mã bị đánh cắp:

#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

Định dạng đầu vào

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

Lệnh: [Trẻ sơ sinh, Dân làng, Pháp sư, Kiếm sĩ, Spearman], [Spearman, Kiếm sĩ, Pháp sư, Dân làng, Trẻ sơ sinh]

Đầu ra mẫu

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

Mã

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

Bị đánh cắp

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

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

Gọi bằng ./stickmanwars 2 3 1 3 4 -1 3 2 4 1 0 4 2 1 . -1 đánh dấu dấu phân cách cho hai mảng. Tôi hy vọng điều đó là ổn.

Chà, thử thách chơi gôn mã đầu tiên của tôi và lần đầu tiên tôi sử dụng haskell cho một ứng dụng thực sự sau khi tôi học nó trong học kỳ này tại trường đại học của tôi. Có lẽ thậm chí không gần như là giải pháp tốt nhất hoặc ngắn nhất nhưng tôi rất vui khi tạo ra nó và đó là một bài tập tốt :) Phê bình và phản hồi được đánh giá cao.

Đánh gôn nó ra khỏi đây:

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

Thử thách thú vị! Tôi có thể chơi golf thêm một chút nữa. Về cơ bản, tôi đang lưu trữ các cột số liệu một cách khôn ngoan để tôi có thể nối chúng với nhau một cách dễ dàng, và sau đó lật toàn bộ mảng Stringarround bằng Haskell's transpose.

Định dạng đầu vào là ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

Dưới đây là ví dụ từ 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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Và đây là miêu tả yêu thích của tôi về nghi thức khét tiếng vô cùng trong thời đại thứ hai!

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


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

Con trăn ( 612 , 522 , 460 , 440)

• Rev1: Nén thô sơ và mã hóa cơ sở64
• Rev2: Loại bỏ nén / mã hóa; trở nên nhỏ hơn
• Rev3: Giảm số byte nhiều hơn bằng cách nội tuyến
• Rev4: Loại bỏ đảo ngược đầu vào không cần thiết trên quân đội 2; trao đổi kiếm sĩ và giáo viên để phù hợp với spec

Mỗi "dòng" được cắt bớt phần đệm bên phải và phần này được thêm lại khi xây dựng lại.

Tôi đã đảo ngược các stickmen trong mã hóa nội bộ của mình vì nó giúp tôi tiết kiệm được việc phải đảo ngược chúng khi hiển thị chúng trong mã.

Chạy mẫu:

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

Mã số:

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

Con trăn (476)

Một người giải khác với người trước của tôi; lâu hơn, nhưng nhiều chức năng hơn.

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

Mã số:

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