Dessinez les guerres Stickman

19


Photo de moi qui rédige ce défi avec mes compétences avancées en dessin.

Contexte

Les guerres Stickman se sont produites il y a longtemps, lorsque l'espèce dominante de la Terre n'était constituée que de bâtons. Les historiens regrettent le fait qu'il n'y avait pas de peintres ou d'appareils photo à l'époque, nous pourrions utiliser quelques images de cette guerre dans les livres d'histoire d'aujourd'hui. C'est là que vos pouvoirs de codage deviennent utiles. Les stickmen sont très facilement dessinés et les historiens ont réussi à trouver des données sur le nombre de stickmen qui ont mené les guerres¹. À vous maintenant de recréer une image du moment juste avant le début de la guerre!

Voici les braves stickmen impliqués dans la guerre:

  O /
| / | \ /
| |
 / \ Swordsman

 OA
/ | \ |
 | |
/ \ | Lancier

   . 
 . ' *.
 «O *  
'\ | /.
. | *
«./ \ *. mage

 O
/ | \
 |
/ \ Villageois

 O
/ | \
/ \ Bébé

Contribution

Recevez via stdin ou équivalent une représentation de chaque stickman apparu de chaque côté du champ de bataille. Par exemple, si deux épéistes se sont battus sur le côté droit et deux lanciers sur le côté gauche, votre entrée peut être {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]ou a "WW", "SS".

Production

Une représentation de tous les braves stickmen sur un champ de bataille, selon les règles ci-dessous. Il peut être affiché sur stdout ou enregistré dans un fichier, tout ce qui bouge votre bateau.

Règles

  1. Sur le côté gauche se trouvent tous les stickmen du premier tableau / chaîne / objet que votre programme a reçu.
  2. Ces stickmen doivent ressembler exactement à ceux montrés précédemment sur cette question.
  3. L'ordre de l'armée de gauche doit être Infants Villagers Mages Swordsmen Spearmen.
  4. L'armée de droite se comportera de la même façon, mais avec les personnages et l'ordre en miroir.
  5. Chaque stickman sera séparé par 1 espace.
  6. Chaque classe sera séparée par 3 espaces.
  7. Les armées seront séparées par 8 espaces.
  8. Étant donné que les stickmen ne volent pas, vous devez dessiner le sol à l'aide de tirets moins -.
  9. Le terrain doit se terminer sur la même colonne que le dernier stickman de l'armée de droite se termine.

Exemple

Supposons que mon programme attend deux tableaux de longueur 5 et que chaque valeur du tableau représente, dans l'ordre Infants Villagers Mages Swordsmen Spearmen,.

Entrée: [1,1,2,3,1] [0,0,1,1,1]

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

Considérations finales

Veuillez noter que les failles standard s'appliquent et que le mage est complètement asymétrique juste parce que.

Le résultat de la réponse la plus votée sera «l'image de couverture» de ce défi. La réponse la plus courte d'ici la fin du mois (31/08/2014) sera sélectionnée comme gagnante.

C'est le , donc le code le plus court, en octets, gagne.


¹Citation nécessaire

William Barbosa
la source
7
"le mage est complètement asymétrique juste parce que" ... tics ... tu devais juste le faire, n'est-ce pas? : P
Poignée de porte
4
@Doorknob ¯ \ _ (ツ) _ / ¯
William Barbosa
Est une fonction ok avec 2 arguments de tableau ou vous avez besoin d'une analyse d'entrée à partir d'une chaîne?
edc65
TIL sur les scores excessifs. Les langues avec unicode peuvent-elles utiliser des tirets à la place, s'il vous plaît?
John Dvorak
1
Il manque une colonne entre le villageois et le mage. Une représentation comme celle-ci IVMMWWWS SWMserait-elle également dans la limite de «tout ce qui peut vous aider»?
Martin Ender

Réponses:

7

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

Edit 6 Le dernier montage était buggé. Correction d'un bug et raccourci. C'est tout ce que j'espère.

Edit 5 Enfin trouvé un moyen de se débarrasser de multiplier par 23 - m'a dérangé depuis le début. Plus un autre changement à l'entrée (@William crie quand c'est trop). Maintenant, la fonction attend un paramètre de tableau, contenant 2 sous-réseaux. Sans ce changement, c'est 349 - toujours une amélioration

Edit 4 Rasé quelques octets de plus et un petit changement au format d'entrée. Avec le nouveau format d'entrée, une classe manquante est représentée comme un élément de tableau vide. Donc D([1,,2,3,1],[,3,1,1,2])au lieu de D([1,0,2,3,1],[0,3,1,1,2]). Je pense qu'il obéit toujours aux règles.

Edit 3 Golfed more. Aucune modification de l'algorithme, mais abusant de beaucoup de fonctions array.map et locales pour éviter les boucles.

Modifier la compression de 2 cordes, la bonne façon ...

Edit Ajout d'une compression de chaîne, beaucoup de travail et pas beaucoup gagné. Maintenant, les stickmen miroir sont générés à partir d'un modèle, non stockés.

A fait quelques essais, la première fois. Pour être joué au golf. NB Kolmogorow-business doit encore être abordé.

Testez dans la console FireFox. Changez 'return' avec Add 'alert (...)' pour avoir une instruction de sortie (bien que ce ne soit pas du tout utile)

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

Production

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

Golfed 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 (modifier 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
}

Code non golfé (1ère 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
}
edc65
la source
4

Python 362 353

Edit: la suppression d'une boucle for et l'utilisation de l'instruction exec ont permis d'économiser 9 octets

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)

Contribution:

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

Production:

   .       .                                                   .       .         
 .' *.   .' *.                                               .* '.   .* '.       
 ' o *   ' o *      o  /    o A        A o  A o    \  o      * o '   * o '       
' \|/ . ' \|/ .   |/|\/    /|\|        |/|\ |/|\    \/|\|   . \|/ ' . \|/ '    o 
.  |  * .  |  *   | |       | |        | |  | |       | |   *  |  . *  |  .   /|\
'./ \*. './ \*.    / \     / \|        |/ \ |/ \     / \    .*/ \.' .*/ \.'   / \
---------------------------------------------------------------------------------
Markuz
la source
Vous avez remarqué que vous utilisez des O minuscules.
phord
3

C, 418 414

Exemple d'entrée:

stickwar.exe IVMMWWWS SWM

Exemple de sortie:

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

Code golfé (les sauts de ligne sont uniquement à des fins de lisibilité; il doit s'agir d'une longue ligne de code):

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

La largeur maximale du champ de bataille est de 999 (je pourrais enregistrer 2 caractères en le limitant à 99). J'ai utilisé une structure de contrôle de 1 octet par caractère de sortie (sans espace), en dessinant les chiffres de bas en haut.

  • 1 bit pour la coordonnée y ("rester" ou "monter")
  • 3 bits pour le déplacement en coordonnées x (0 ... 4)
  • 3 bits pour le caractère de sortie (heureusement, il n'y a que 8 caractères différents)

Il y a 5 décalages dans la structure de contrôle.

Quelques autres morceaux obscurs:

  • Le code f%27%5traduit les caractères VWSMIen chiffres0, 1, 2, 3, 4
  • Le code t*3%12%5+4calcule la largeur du stickman de typet
  • Le code t^3|~o||(s=d[5]+p,*s--=46,*s=39)explique l'asymétrie gauche / droite
  • J'utilise le fait que argc=3pour générer des drapeaux de direction de dessin 1et-1

Code non golfé:

#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
la source
Pourquoi êtes-vous en mesure de ne pas avoir les inclus dans la version golfée? Aussi pourquoi ne pas changer le point-virgule après *aen virgule? Cela supprime un avertissement et a le même nombre d'octets.
Fsmv
1
C a la règle de "déclaration implicite" ; il n'est pas sûr de s'y fier, mais cela fonctionne dans la pratique, donc c'est assez standard en golf. Quant au point-virgule: j'utilise l'expression f=*acomme condition d'arrêt; le compilateur peut se plaindre mais je le pense. Je ne peux pas le supprimer car il devrait y avoir deux points-virgules dans la forsyntaxe -loop.
anatolyg
2

Haskell, 556

Format d'entrée

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

Ordre: [Nourrisson, villageois, mage, épéiste, lancier], [Lancier, épéiste, mage, villageois, nourrisson]

Exemple de sortie

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

Non golfé

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)
Rayon
la source
1
Je n'ai pas testé, mais d'après votre exemple de sortie, vous avez oublié de refléter les caractères sur le côté droit
William Barbosa
@WilliamBarbosa Fixé avec une solution totalement différente.
Ray
1

Haskell ( 736 733 720 octets)

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

Appeler avec ./stickmanwars 2 3 1 3 4 -1 3 2 4 1 0 4 2 1 . Le -1 marque le délimiteur pour les deux tableaux. J'espère que ça va.

Eh bien, mon premier défi de golf de code et la première fois que j'ai utilisé haskell pour une vraie application après l'avoir appris ce semestre à mon université. Probablement même pas près d'être la meilleure ou la plus courte solution, mais je me suis amusé à la créer et c'était un bon exercice :) La critique et les commentaires sont très appréciés.

Golfé hors de cela:

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
la source
Les espaces entre parenthèses ne sont pas nécessaires. Cela semble vous faire économiser beaucoup.
Ray
ah d'accord, m'a sauvé 3 octets, merci :)
Ke Vin
Non, beaucoup plus.
Ray
vous avez raison, j'en ai beaucoup plus maintenant.
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

Défi cool! Je pourrais peut-être jouer un peu plus au golf. En gros, je stocke les chiffres dans la colonne afin de pouvoir les ajouter facilement, puis retourner tout le tableau de Strings à l'aide de Haskell transpose.

Le format d'entrée est ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

Voici l'exemple de l'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    /|\   ' \|/ . ' \|/ .   |/|\/  |/|\/  |/|\/    /|\|        |/|\    \/|\|   . \|/ '
/|\    |    .  |  * .  |  *   | |    | |    | |       | |        | |       | |   *  |  .
/ \   / \   './ \*. './ \*.    / \    / \    / \     / \|        |/ \     / \    .*/ \.'
----------------------------------------------------------------------------------------

Et voici ma représentation préférée de l'infâme infanticide rituel de la deuxième ère!

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


  O  /
|/|\/          O   O   O   O   O
| |           /|\ /|\ /|\ /|\ /|\
 / \          / \ / \ / \ / \ / \
---------------------------------
Flonk
la source
0

Python ( 612 , 522 , 460 , 440)

  • Rev1: compression rudimentaire et encodage base64
  • Rev2: Suppression de la compression / encodage; est devenu plus petit
  • Rev3: Plus de réduction du nombre d'octets en ligne
  • Rev4: Suppression de l'inversion d'entrée inutile sur la 2e armée; épéiste et lancier échangés pour correspondre aux spécifications

Chaque "ligne" est rognée de remplissage à droite, et celle-ci est ajoutée lors de la reconstruction.

J'ai pré-inversé les stickmen dans mon encodage interne car cela m'a évité d'avoir à les inverser individuellement lors du rendu dans le code.

Exemple d'exécution:

$ 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])])
phord
la source
0

Python (476)

Un solveur différent de mon précédent; plus long, mais plus fonctionnel.

$ 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])])
phord
la source