स्टिकमैन युद्धों ड्रा

Question

_{मेरे चित्र ने मेरे उन्नत ड्राइंग कौशल के साथ इस चुनौती का प्रारूपण किया है।}

पृष्ठभूमि

स्टिकमैन युद्ध बहुत पहले हुआ था, जब पृथ्वी की प्रमुख प्रजाति कुछ और नहीं बल्कि लाठी से बनी थी। इतिहासकारों को इस तथ्य पर अफसोस है कि उस समय कोई चित्रकार या कैमरा नहीं था, हम आज के इतिहास की किताबों में उस युद्ध की कुछ तस्वीरों का उपयोग कर सकते हैं। यहीं से आपकी कोडिंग शक्तियां उपयोगी हो जाती हैं। स्टिकमैन को बहुत आसानी से आकर्षित किया जाता है और इतिहासकारों ने कुछ आंकड़ों को खोजने में कामयाबी हासिल की कि कितने स्टिकमैन युद्ध लड़ते हैं। अब यह युद्ध शुरू होने से ठीक पहले की छवि को फिर से बनाने के लिए आपके ऊपर है!

यहाँ युद्ध में शामिल बहादुर खिलाड़ी हैं:

  ओ /
| / | \ /
| |
 / \ _ तलवारबाज

 OA
/ | \ |
 | |
/ \ / | भाला धारण करनेवाला सिपाही

   । 
 । ' *।
 'ओ *  
'\ _ /।
। | *
'./ \ _ दाना

 हे
/ | \
 |
/ \ _ ग्रामीण

 हे
/ | \
/ \ शिशु

इनपुट

युद्ध के मैदान के प्रत्येक पक्ष में दिखाई देने वाले हर छड़ी के प्रतिनिधित्व के माध्यम से प्राप्त करें। उदाहरण के लिए, यदि दो swordmen बाईं ओर दो spearmen सही ओर से लड़ा और, आपके इनपुट हो सकता है {Sword: 2}, {Spear: 2}, [2,0,0,0,0], [0,2,0,0,0]या एक "WW", "SS"।

उत्पादन

नीचे दिए गए नियमों के अनुसार, एक युद्ध क्षेत्र में हर बहादुर स्टिकमैन का प्रतिनिधित्व। यह स्टडआउट पर दिखाया जा सकता है या किसी फ़ाइल पर सहेजा जा सकता है, जो भी आपकी नाव को हिलाता है।

नियम

1. बाईं ओर आपके प्रोग्राम को प्राप्त पहले सरणी / स्ट्रिंग / ऑब्जेक्ट के प्रत्येक स्टिकमैन होंगे।
2. उन स्टिकमैन को इस प्रश्न पर पहले दिखाए गए लोगों की तरह दिखना चाहिए।
3. बाईं ओर की सेना का आदेश होना चाहिए Infants Villagers Mages Swordsmen Spearmen।
4. दाईं ओर की सेना केवल एक ही व्यवहार करेगी, लेकिन पात्रों और आदेश के साथ आईना।
5. प्रत्येक स्टिकमैन को 1 स्थान से अलग किया जाएगा।
6. प्रत्येक वर्ग को 3 स्थानों से अलग किया जाएगा।
7. सेनाओं को 8 स्थानों से अलग किया जाएगा।
8. चूंकि स्टिकमैन नहीं उड़ते हैं, इसलिए आपको हाइफ़न-मिन्यूज़ का उपयोग करके जमीन को खींचना चाहिए -।
9. जमीन को उसी स्तंभ पर समाप्त होना चाहिए, जो सही सेना के अंतिम स्टिकमैन पर है।

उदाहरण

मान लें कि मेरा कार्यक्रम 5 की लंबाई के साथ दो सरणियों की अपेक्षा करता है और सरणी में प्रत्येक मान क्रम में प्रदर्शित होता है Infants Villagers Mages Swordsmen Spearmen।

इनपुट: [१,१,२,३,१] [०,०,१,१,१]

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

अंतिम विचार

कृपया ध्यान दें कि मानक खामियां लागू होती हैं और यह कि दाना पूरी तरह से सिर्फ इसलिए विषम है।

अधिकांश उत्क्रमित उत्तर का परिणाम इस चुनौती का "आवरण चित्र" होगा। महीने के अंत तक (08/31/2014) सबसे छोटा जवाब विजेता के रूप में चुना जाएगा।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड, जीत है।

---

¹Citation की जरूरत है

Comments

"दाना पूरी तरह से असममित है क्योंकि" ... चिकोटी ... आपको बस करना था , नहीं? : पी

— दरवाज़े

@Doorknob ¯ \ _ (_) _ /

— William

2 सरणी तर्क के साथ एक फ़ंक्शन ठीक है या आपको स्ट्रिंग से इनपुट पार्सिंग की आवश्यकता है?

— edc65

ओवरसीज के बारे में टीआईएल। क्या यूनिकोड-चुनौती दी गई भाषाओं के बजाय डैश का उपयोग कर सकते हैं, कृपया?

— जॉन ड्वोरक

ग्रामीण और दाना के बीच एक कॉलम गायब है। इसके अलावा एक प्रतिनिधित्व IVMMWWWS SWM"कुछ भी है जो आपकी मदद करता है" की सीमा के भीतर होगा?

— मार्टिन एंडर

Answer 1

जावास्क्रिप्ट (E6) 336 344 356 369 424 478 522 570

संपादित करें 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 गोल्फ। एल्गोरिथ्म में कोई बदलाव नहीं, लेकिन लूप से बचने के लिए बहुत सारे अरैम्प और स्थानीय कार्यों का दुरुपयोग।

संपादित करें 2 स्ट्रिंग संपीड़न, सही तरीका ...

संपादित करें जोड़ा गया स्ट्रिंग संपीड़न, बहुत काम और बहुत ज्यादा नहीं प्राप्त की। अब दर्पण स्टिकर एक टेम्पलेट से उत्पन्न होते हैं, संग्रहीत नहीं होते हैं।

कुछ कोशिश की, पहले दौड़ रहा था। गोल्फ होना। एनबी कोलमोगोरो-व्यापार अभी भी निपटने के लिए।

फ़ायरफ़ॉक्स कंसोल में टेस्ट । आउटपुट स्टेटमेंट के लिए 'अलर्ट' (...) के साथ 'वापसी' बदलें (यद्यपि यह उपयोगी नहीं है)

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
}

Answer 2

अजगर 362 353

संपादित करें: एक फॉर-लूप को हटाने और निष्पादन स्टेटमेंट का उपयोग करके 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 
.  |  * .  |  *   | |       | |        | |  | |       | |   *  |  . *  |  .   /|\
'./ \*. './ \*.    / \     / \|        |/ \ |/ \     / \    .*/ \.' .*/ \.'   / \
---------------------------------------------------------------------------------

Comments

नोट किया गया आप लोअरकेस ओस् का उपयोग करते हैं।

— phord

Answer 3

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 बिट (या तो "रहना" या "ऊपर जाना")
• एक्स-समन्वय विस्थापन के लिए 3 बिट्स (0 ... 4)
• आउटपुट चार के लिए 3 बिट्स (सौभाग्य से, केवल 8 अलग-अलग चार्ट हैं)

नियंत्रण संरचना में 5 ऑफसेट हैं।

कुछ अन्य अस्पष्ट बिट्स:

• कोड f%27%5वर्णों VWSMIका संख्याओं में अनुवाद करता है0, 1, 2, 3, 4
• कोड t*3%12%5+4प्रकार के स्टिकमैन की चौड़ाई की गणना करता है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);
    }
}

Comments

आप गोल्फ संस्करण में शामिल क्यों नहीं हो पा रहे हैं? *aअल्पविराम को अल्पविराम के बाद भी क्यों नहीं बदला जाए ? यह एक चेतावनी से छुटकारा दिलाता है और बाइट्स की समान संख्या होती है।

— Fsmv

सी में "निहित घोषणा" नियम है ; यह उस पर भरोसा करने के लिए असुरक्षित है, लेकिन यह अभ्यास में काम करता है इसलिए यह गोल्फिंग में बहुत मानक है। अर्ध-बृहदान्त्र के लिए: मैं अभिव्यक्ति का उपयोग f=*aरोक स्थिति के रूप में करता हूं ; संकलक शिकायत कर सकते हैं लेकिन मेरा मतलब है। मैं इसे हटा नहीं सकता क्योंकि for-लूप सिंटैक्स में दो अर्धविराम होने चाहिए ।

— अनातोलीगैस

Answer 4

हास्केल, 556

इनपुट प्रारूप

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

आदेश: [शिशु, ग्रामीण, दाना, तलवारबाज, भाला], [भाला, तलवारबाज, दाना, ग्रामीण, शिशु]

नमूना आउटपुट

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

Comments

मैंने परीक्षण नहीं किया, लेकिन अपने नमूना आउटपुट के अनुसार आप दाईं ओर के पात्रों को दर्पण करना भूल गए थे

— विलियम बारबोसा

@WilliamBarbosa पूरी तरह से अलग समाधान के साथ फिक्स्ड।

— रे

Answer 5

हास्केल ( 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 2 4 1 0 4 2 1 4 1 0 4 2 1 । -1 दो सरणियों के लिए सीमांकक को चिह्नित करता है। मुझे उम्मीद है कि ठीक है।

ठीक है, मेरी पहली कोड गोल्फ चुनौती और पहली बार जब मैंने अपने विश्वविद्यालय में यह सेमेस्टर सीखा है, तब मैंने वास्तविक एप्लिकेशन के लिए हैस्केल का उपयोग किया है। शायद सबसे अच्छा या सबसे छोटा समाधान होने के करीब भी नहीं है, लेकिन मुझे इसे बनाने में मज़ा आया और यह एक अच्छा व्यायाम था :) आलोचना और प्रतिक्रिया की बहुत सराहना की जाती है।

इसे इस से बाहर निकाला:

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 ""

Comments

कोष्ठक के चारों ओर रिक्त स्थान आवश्यक नहीं है। जो आपको बहुत बचाने के लिए लगता है।

— रे

ठीक है, मुझे 3 बाइट्स बचाए, thx :)

— Ke Vin

नहीं, और भी बहुत कुछ।

— रे

आप सही हैं, मुझे अभी बहुत कुछ मिला है।

— के विन

Answer 6

हास्केल, 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हास्केल का उपयोग करके एस के चारों ओर के पूरे सरणी को फ्लिप कर दूं transpose।

इनपुट प्रारूप है ([Infants,Villagers,Mages,Swordsmen,Spearmen],[Infants,Villagers,Mages,Swordsmen,Spearmen])

यहाँ ओपी से उदाहरण है:

>>>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
| |           /|\ /|\ /|\ /|\ /|\
 / \          / \ / \ / \ / \ / \
---------------------------------

Answer 7

अजगर ( 612 , 522) , 460 , 440)

• Rev1: रुडिमेंट्री कम्प्रेशन और बेस 64-एन्कोडिंग
• Rev2: हटाए गए संपीड़न / एन्कोडिंग; छोटा हो गया
• Rev3: inlining द्वारा अधिक बाइट गिनती में कमी
• Rev4: 2 सेना पर अनावश्यक इनपुट प्रत्यावर्तन को हटा दिया गया; कल्पना करने के लिए तलवारबाज और भाला फेंक दिया

प्रत्येक "लाइन" को राइट-पेडिंग की छंटनी की जाती है, और पुनर्निर्माण करते समय इसे वापस जोड़ा जाता है।

मैंने अपने आंतरिक एन्कोडिंग में स्टिकर को पूर्व-उलट कर दिया क्योंकि इससे मुझे कोड में उन्हें प्रस्तुत करते समय उन्हें व्यक्तिगत रूप से उलटने से बचाया।

नमूना रन:

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

Answer 8

पायथन (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])])