_{고급 그리기 기술로이 도전 과제를 작성하는 그림.}

배경

스틱맨 전쟁은 오래 전에 지구의 지배적 인 종들이 막대기로만 만들어 졌을 때 일어났습니다. 역사가들은 당시 화가나 카메라가 없었다는 사실을 후회하며, 오늘날의 역사 책에서 그 전쟁의 일부 그림을 사용할 수 있습니다. 그것이 바로 코딩 능력이 유용한 곳입니다. Stickmen은 매우 쉽게 끌 수 있으며 역사가들은 얼마나 많은 Stickmen이 전쟁에 참전했는지에 대한 데이터를 찾을 수있었습니다 ¹. 이제 전쟁이 시작되기 직전의 이미지를 재현하는 것은 당신에게 달려 있습니다!

다음은 전쟁에 관련된 용감한 스틱맨입니다.

  오 /
| / | \ /
| |
 / \ 검객

 OA
/ | \ |
 | |
/ \ | 창병

   . 
 . ' *.
 'O *  
'\ | /.
. | *
'./ \ *. 마술사

 영형
/ | \
 |
마을 주민

 영형
/ | \
유아

입력

전장의 양쪽에 등장하는 모든 스틱맨을 stdin 또는 이와 동등한 표현으로받습니다. 예를 들어, 두 명의 검객이 오른쪽에서 싸웠고 두 명의 창병이 왼쪽에서 싸운 경우 입력은 {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]또는 일 수 있습니다 "WW", "SS".

산출

아래 규칙에 따라 전장에서 모든 용감한 스틱맨을 나타냅니다. 보트를 흔들 때마다 stdout에 표시되거나 파일로 저장할 수 있습니다.

규칙

1. 왼쪽에는 프로그램이받은 첫 번째 배열 / 문자열 / 객체의 모든 stickmen이 있습니다.
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 / | \ '\ | /. '\ | /. | / | \ / | / | \ / | / | \ / / | \ | | / | \ \ / | \ | . \ | / '
/ | \ | . | *. | * | | | | | | | | | | | | * | .
/ \ / \ './ \ *. './ \ *. / \ / \ / \ / \ | | / \ / \. * / \ '.
-------------------------------------------------- -------------------------------------

최종 고려 사항

표준 허점이 적용 되고 마법사는 단지 비대칭 적이라는 점에 유의하십시오 .

가장 많이 답한 답변의 결과는이 도전의 "표지 이미지"입니다. 월말까지 가장 짧은 답변 (2014 년 8 월 31 일)이 승자로 선정됩니다.

이것은 code-golf 이므로 가장 짧은 코드 (바이트)가 이깁니다.

¹ 인용 필요

자바 스크립트 (E6) 336344335669424478522570

편집 6 마지막 편집은 버그였습니다. 버그 수정 및 단축. 그게 내가 바라는 전부입니다.

편집 5 마지막으로 23을 곱하는 방법을 찾았습니다. 처음부터 나를 귀찮게했습니다. 또한 입력에 대한 또 다른 변경 (@William은 너무 많을 때 소리칩니다). 이제 함수는 2 개의 하위 배열을 포함하는 하나의 배열 매개 변수를 예상합니다. 이 변경없이 349입니다-여전히 개선

편집 4 더 많은 바이트를 면도하고 입력 형식을 약간 변경했습니다. 새로운 입력 형식에서는 누락 된 클래스가 빈 배열 요소로 표시됩니다. 그래서 D([1,,2,3,1],[,3,1,1,2])대신 D([1,0,2,3,1],[0,3,1,1,2]). 나는 그것이 여전히 규칙을 준수한다고 생각합니다.

3 골프 더 편집 . 알고리즘은 변경되지 않지만 루프를 피하기 위해 많은 array.map 및 로컬 함수를 남용합니다.

올바른 방법으로 2 문자열 압축 편집 ...

편집 문자열 압축, 많은 작업 및 많은 이익을 추가했습니다. 이제 미러 stickmen이 저장되지 않고 템플릿에서 생성됩니다.

먼저 몇 번 시도해 보았습니다. 골프하기. NB Kolmogorow 비즈니스는 여전히 해결해야 할 과제입니다.

FireFox 콘솔에서 테스트하십시오 . 출력문 을 갖도록 Add 'alert (...)'로 'return'을 변경하십시오 (아직 유용하지는 않음).

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

골프 코드

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
}

Ungolfed 코드 (첫 번째 버전)

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
}

파이썬 362 353

편집 : 하나의 for 루프를 제거하고 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 / | \ '\ | /. '\ | /. | / | \ / | / | \ / | / | \ / / | \ | | / | \ \ / | \ | . \ | / '
/ | \ | . | *. | * | | | | | | | | | | | | * | .
/ \ / \ './ \ *. './ \ *. / \ / \ / \ / \ | | / \ / \. * / \ '.
-------------------------------------------------- --------------------------------------

골프 코드 (줄 바꿈은 가독성을위한 것이며 긴 코드 줄이어야 함) :

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입니다 (99 자로 제한하여 2자를 절약 할 수 있습니다). 출력 문자 당 1 바이트 (공백이 아닌)의 제어 구조를 사용하여 아래에서 위로 그림을 그렸습니다.

• y 좌표의 경우 1 비트 ( "stay"또는 "go up")
• x 좌표 변위의 경우 3 비트 (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

Ungolfed 코드 :

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

하스켈, 556

입력 형식

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

주문 : [유아, 주민, 마법사, 검객, 스피어 맨], [Spearman, Swordsman, 마법사, 주민, 유아]

샘플 출력

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

언 골프

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)

하스켈 ( 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로 전화 하십시오 2 3 1 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 ""

하스켈, 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

멋진 도전! 나는 그것을 조금 더 아래로 골프 수 있습니다. 기본적으로 그림 열을 현명하게 저장하여 서로 쉽게 추가 할 수 있으며 StringHaskell 's를 사용하여 s 의 전체 배열을 뒤집습니다 transpose.

입력 형식은 ([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
| |           /|\ /|\ /|\ /|\ /|\
 / \          / \ / \ / \ / \ / \
---------------------------------

파이썬 ( 612 , 522 , 460,440 )

• Rev1 : 기본 압축 및 base64 인코딩
• 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])])

파이썬 (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])])