Desenhe as Guerras Stickman

19


Foto minha esboçando esse desafio com minhas habilidades avançadas de desenho.

fundo

As guerras de Stickman aconteceram há muito tempo, quando as espécies dominantes da Terra eram feitas de nada além de gravetos. Os historiadores lamentam o fato de que não havia pintores ou câmeras naquela época, poderíamos usar algumas fotos dessa guerra nos livros de história de hoje. É aí que seus poderes de codificação se tornam úteis. Os stickmen são muito fáceis de desenhar e os historiadores conseguiram encontrar alguns dados sobre quantos stickmen travaram as guerras¹. Agora cabe a você recriar uma imagem do momento antes do início da guerra!

Aqui estão os corajosos stickmen envolvidos na guerra:

  O /
| / | \ /
| |
 / \ Espadachim

 OA
/ | \ |
 | |
/ \ | Lanceiro

   . 
 . ' *
 'O *  
'\ | /.
. | *
'./ \ *. Mago

 O
/ | \
 |
/ \ Aldeão

 O
/ | \
/ \ Infant

Entrada

Receba via stdin ou equivalente uma representação de cada stickman que apareceu em cada lado do campo de batalha. Por exemplo, se dois espadachins lutaram no lado direito e dois lanceiros no lado esquerdo, sua entrada pode ser {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]ou a "WW", "SS".

Resultado

Uma representação de todos os bravos homens de pau em um campo de batalha, de acordo com as regras abaixo. Ele pode ser mostrado no stdout ou salvo em um arquivo, o que quer que seja do seu interesse.

Regras

  1. No lado esquerdo, estarão todos os stickmen do primeiro array / string / objeto que seu programa recebeu.
  2. Esses stickmen devem se parecer exatamente com os mostrados anteriormente nesta questão.
  3. A ordem do exército do lado esquerdo deve ser Infants Villagers Mages Swordsmen Spearmen.
  4. O exército do lado direito se comportará da mesma forma, mas com os personagens e a ordem espelhados.
  5. Cada stickman será separado por 1 espaço.
  6. Cada aula será separada por 3 espaços.
  7. Os exércitos serão separados por 8 espaços.
  8. Como stickmen não voa, você deve desenhar o solo usando hífen-menos -.
  9. O chão deve terminar na mesma coluna que termina o último stickman do exército certo.

Exemplo

Vamos supor que meu programa espere duas matrizes com comprimento 5 e cada valor na matriz represente, em ordem Infants Villagers Mages Swordsmen Spearmen,.

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

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

Considerações finais

Observe que as brechas padrão se aplicam e que o mago é completamente assimétrico apenas porque.

O resultado da resposta mais votada será a "imagem de capa" desse desafio. A resposta mais curta até o final do mês (31/08/2014) será selecionada como vencedora.

Isso é , então o código mais curto, em bytes, vence.


ItationCitação necessária

William Barbosa
fonte
7
"o mago é completamente assimétrico só porque" ... estremece ... você só precisava , não é? : P
Maçaneta da porta
4
@Dorknob ¯ \ _ (ツ) _ / ¯
William Barbosa
Ok é uma função com 2 argumentos de matriz ou é necessário analisar a entrada de uma string?
precisa saber é
Até sobre overscores. Os idiomas desafiados por unicode podem usar hífens, por favor?
John Dvorak
11
Falta uma coluna entre o aldeão e o mago. Também uma representação como IVMMWWWS SWMestaria dentro do limite de "qualquer coisa que o ajude"?
Martin Ender

Respostas:

7

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

Editar 6 A última edição foi com erros. Correção de bug e encurtado. É tudo o que espero.

Editar 5 Finalmente encontrei uma maneira de me livrar da multiplicação por 23 - me incomodou desde o início. Mais uma alteração na entrada (@William grita quando é demais). Agora, a função espera um parâmetro de matriz, contendo 2 sub-matrizes. Sem essa mudança, é 349 - ainda uma melhoria

Editar 4 Raspou mais alguns bytes e uma pequena alteração no formato de entrada. Com o novo formato de entrada, uma classe ausente é representada como um elemento vazio da matriz. Então, ao D([1,,2,3,1],[,3,1,1,2])invés de D([1,0,2,3,1],[0,3,1,1,2]). Eu acho que ainda obedece as regras.

Editar 3 Golfeou mais. Nenhuma alteração no algoritmo, mas abusando de muitas funções array.map e locais para evitar loops.

Editar compressão de 2 cordas, do jeito certo ...

Editar Compactação de string adicionada, muito trabalho e pouco ganho. Agora, os stickmen de espelho são gerados a partir de um modelo, não armazenados.

Fez algumas tentativas, primeiro a correr. Para ser jogado golfe. NB Kolmogorow-business ainda não foi abordado.

Teste no console do FireFox. Altere 'return' com Add 'alert (...)' para ter uma declaração de saída (embora não seja útil)

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

Resultado

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

Código de golfe

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

Código (editar 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
}

Código não destruído (1ª versão)

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
}
edc65
fonte
4

Python 362 353

Editar: remover um loop for e usar a instrução exec salvou 9 bytes

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)

Entrada:

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

Resultado:

   .       .                                                   .       .         
 .' *.   .' *.                                               .* '.   .* '.       
 ' o *   ' o *      o  /    o A        A o  A o    \  o      * o '   * o '       
' \|/ . ' \|/ .   |/|\/    /|\|        |/|\ |/|\    \/|\|   . \|/ ' . \|/ '    o 
.  |  * .  |  *   | |       | |        | |  | |       | |   *  |  . *  |  .   /|\
'./ \*. './ \*.    / \     / \|        |/ \ |/ \     / \    .*/ \.' .*/ \.'   / \
---------------------------------------------------------------------------------
Markuz
fonte
Notei que você usa O minúsculo.
phord
3

C, 418 414

Exemplo de entrada:

stickwar.exe IVMMWWWS SWM

Exemplo de saída:

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

Código de golfe (quebras de linha são apenas para facilitar a leitura; deve ser uma longa linha de código):

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

A largura máxima do campo de batalha é 999 (eu poderia salvar 2 caracteres limitando-o a 99). Usei uma estrutura de controle de 1 byte por caractere de saída (sem espaço), desenhando as figuras de baixo para cima.

  • 1 bit para a coordenada y ("permanecer" ou "subir")
  • 3 bits para deslocamento da coordenada x (0 ... 4)
  • 3 bits para o caractere de saída (felizmente, existem apenas 8 caracteres diferentes)

Existem 5 compensações na estrutura de controle.

Alguns outros bits obscuros:

  • O código f%27%5traduz os caracteres VWSMIem números0, 1, 2, 3, 4
  • O código t*3%12%5+4calcula a largura do stickman do tipot
  • O código é t^3|~o||(s=d[5]+p,*s--=46,*s=39)responsável pela assimetria esquerda / direita
  • Eu uso o fato de que argc=3 para gerar sinalizadores de direção de desenho 1e-1

Código não destruído:

#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);
    }
}
anatolyg
fonte
Por que você não pode ter as inclusões na versão golfed? Além disso, por que não mudar o ponto-e-vírgula depois *apara uma vírgula? Isso elimina um aviso e tem o mesmo número de bytes.
precisa saber é
11
C tem a regra "declaração implícita" ; não é seguro confiar nele, mas funciona na prática, por isso é bastante padrão no golfe. Quanto ao ponto e vírgula: uso a expressão f=*acomo condição de parada; compilador pode reclamar, mas eu quero dizer isso. Não consigo removê-lo porque deve haver dois pontos e vírgulas na forsintaxe -loop.
precisa saber é
2

Haskell, 556

Formato de entrada

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

Ordem: [Infante, Aldeão, Mago, Espadachim, Lanceiro], [Lanceiro, Espadachim, Mago, Aldeão, Infante]

Saída de amostra

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

Código

(?)=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)
Raio
fonte
11
Eu não testei, mas de acordo com o seu exemplo de saída que você esqueceu de espelhar os caracteres no lado direito
William Barbosa
@WilliamBarbosa Corrigido com uma solução totalmente diferente.
Ray
1

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

Ligue com ./stickmanwars 2 3 1 3 4 -1 3 2 4 1 0 4 2 1 . O -1 marca o delimitador para as duas matrizes. Espero que esteja tudo bem.

Bem, meu primeiro desafio de golfe com código e a primeira vez que usei o haskell para uma aplicação real depois que a aprendi neste semestre na minha universidade. Provavelmente nem mesmo perto de ser a melhor ou mais curta solução, mas eu me diverti criando e foi um bom exercício :) A crítica e o feedback são muito apreciados.

Golfed fora disso:

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 ""
Ke Vin
fonte
Espaços entre parênteses não são necessários. Isso parece lhe poupar muito.
Ray
ah bem, me salvou 3 bytes, thx :)
Ke Vin
Não, muito mais.
Ray
você está certo, eu tenho muito mais agora.
Ke Vin
0

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

Desafio legal! Talvez eu consiga jogar um pouco mais. Basicamente, estou armazenando as colunas das figuras de maneira que possa anexá-las uma à outra com facilidade e depois virar toda a matriz de Strings usando Haskell transpose.

O formato de entrada é ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

Aqui está o exemplo do 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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

E aqui está minha descrição favorita do infanticídio ritual infame durante a segunda era!

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


  O  /
|/|\/          O   O   O   O   O
| |           /|\ /|\ /|\ /|\ /|\
 / \          / \ / \ / \ / \ / \
---------------------------------
Flonk
fonte
0

Python ( 612 , 522 , 460 , 440)

  • Rev1: Compactação rudimentar e codificação base64
  • Rev2: Remoção de compressão / codificação; ficou menor
  • Rev3: Mais redução na contagem de bytes inlining
  • Rev4: Removida a reversão desnecessária de entrada no 2º exército; trocou espadachim e lanceiro para combinar com as especificações

Cada "linha" é recortada com o preenchimento à direita, e isso é adicionado novamente na reconstrução.

Eu pré-invertai os stickmen na minha codificação interna porque me salvou ter que revertê-los individualmente ao renderizá-los no código.

Exemplo de execução:

$ 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ódigo:

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])])
frase
fonte
0

Python (476)

Um solucionador diferente do meu anterior; mais, mas mais funcional.

$ 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ódigo:

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