बज़बी बर्कले रोबोट होके पोके

कार्य

एक बसबे बर्कले नंबर की शैली में होके पोके (या कोकी, यदि आप चाहें तो) के गीतों पर नाचने वाले रोबोटों की एक पंक्ति का चित्रण करते हुए ASCII कला एनीमेशन बनाने के लिए एक कार्यक्रम या फ़ंक्शन लिखें!

उदाहरण आउटपुट

इनपुट

तीन तर्क स्वीकार करते हैं (मान्य माना जाता है):

एन = पंक्ति में रोबोट की संख्या (न्यूनतम = 6)

बी = मिलीसेकंड में एक "बीट" की अवधि (न्यूनतम = 10)

डी = लगातार रोबोट के बीच एमएस में देरी (न्यूनतम = 0)

(ऊपर दिए गए उदाहरण आउटपुट में: N = 8, B = 380, C = 75)

विशेष विवरण

एन रोबोट को एक मंच पर एक पंक्ति में दिखाया गया है।
"कविता" से पाठ की एक पंक्ति को मंच के नीचे एक समय पर दिखाया गया है (1 वर्ण के भीतर केंद्रित है, और उद्धरण चिह्नों में संलग्न है।)
रोबोट प्रत्येक पंक्ति के लिए क्रियाएं करते हैं क्योंकि यह दिखाया गया है जब तक कि कविता को 5 बार दोहराया नहीं गया है।
ASCII वर्णों के सेट का उपयोग करके रोबोट का चित्रण करके एक क्रिया का प्रदर्शन किया जाता है और अगली क्रिया करने से पहले एक निर्दिष्ट अवधि की प्रतीक्षा की जाती है। एक क्रिया की अवधि को "बीट्स" में मापा जाता है। 1 बीट की अवधि कई मिलीसेकंड, बी है ।
पहला रोबोट पंक्ति के पाठ प्रदर्शित होने पर तुरंत प्रत्येक पंक्ति के लिए क्रिया करना शुरू कर देता है।
प्रत्येक बाद वाला रोबोट अपने कार्यों को शुरू करने में देरी करता है जब तक कि विशिष्ट समय ( D ) तक रोबोट अपने दाएं (आपके बाएं!) अपने कार्यों को शुरू नहीं करता है।
रोबोट के "एंटीना" का प्रतिनिधित्व करने वाले ASCII पात्रों द्वारा रोबोट के चित्रण अलग-अलग होते हैं, जिनमें से 5 संभावित प्रकार होते हैं, जो प्रोग्राम चलने पर हर बार बेतरतीब ढंग से वितरित होते हैं।
प्रत्येक प्रकार के एंटीना का उपयोग कम से कम एक रोबोट द्वारा किया जाना चाहिए, लेकिन 3 अन्य से कम रोबोटों द्वारा अलग किए गए किसी भी रोबोट पर एक ही प्रकार दिखाई नहीं देना चाहिए। किसी भी दो प्रकार के एंटीना की मात्रा 1 से अधिक नहीं हो सकती है (उदाहरण 1xType_4 और 3xType_5 3-1> 1 के बाद से अवैध है)

श्लोक और कार्य

पूरे कविता को 5 बार, 1 लाइन एक बार में दोहराया जाता है ...

Line  Text                            Action/Beats, 
----  -----------------------------   ------------------------------------
1     You put your ? in               ??/4
2     You take your ? out             AA/4
3     You put your ? in               ??/4
4     And you shake it all about      AA/1, ??/1, AA/1, ??/1
5     You do the Hokey Pokey and...   
      ...you turn yourself around     AA/1, H[1-7]/1
6     That's what it's all about!     AA/4, ZZ/4

कविता के प्रत्येक पुनरावृत्ति (आर) के लिए, स्थानापन्न? तथा ??...

R   ?=           ??=
--  -----------  ---
1.  right foot   RF 
2.  left foot    LF
3.  right hand   RH
4.  left hand    LH
5.  whole self   WS

क्रियाएँ और ASCII पैटर्न

प्रत्येक लेबल की गई कार्रवाई को 8 ASCII प्रतीकों की 5 लाइनों द्वारा दर्शाया गया है।
प्रत्येक क्रिया का प्रतिनिधित्व इस प्रकार है ...

1 |   12     12        12    12        12     12      12   
2 |  ['']   ['']      ['']  ['']      ['']   ['']   \[*-] 
3 | └[__]┘ └[__]┘    └[__]┘┌[__]┘    └[__]┐ ┌[__]┐   [__]\ 
4 |   ||     /<        >\    <\        />    /  \     /|
5 |--------------------------------------------------------
  |\__AA__/\__RF__/\__LF__/\__RH__/\__LH__/\__WS__/\__ZZ__/ 

1 |   12     12_     34_      34      _34     _12     12    
2 |  ['']    [" ]    [ _]    [__]    [_ ]    [ "]    ['']
3 | >[__]<   [_<]    [<.]   <[..]>   [.>]    [>_]   <[__]>
4 |   ||      |\      ||      /|      ||      |\      ||
5 |--------------------------------------------------------
  |\__H1__/\__H2__/\__H3__/\__H4__/\__H5__/\__H6__/\__H7__/

पंक्ति 1 में, प्रत्येक एंटीना प्रकार के लिए संबंधित चिह्न के साथ "1-4" को बदलें ...

1 | 1234 1234 1234 1234 1234 
  | \/\/ |┌┐| )||( |||| ┐/\┌ <-- Symbols 1-4 for...
  | 1    2    3    4    5    <-- ...antenna types 1-5

उत्पादन

जब भी दृश्य की सामग्री किसी भी तरह से बदलती है, तो पूरे दृश्य को कम से कम एक बार तुरंत प्रस्तुत किया जाना चाहिए। (यानी रोबोट की क्रियाओं के बीच देरी का कारण> 0 है, आउटपुट को प्रति कार्य N बार से कम नहीं किया जा सकता है )।

आदर्श रूप से, एक एनीमेशन के लिए प्रत्येक अद्यतन प्रदान करने से पहले कंसोल या समकक्ष आउटपुट क्षेत्र को साफ कर दिया जाता है। कंसोल को खाली करने में असमर्थ भाषाओं को प्रदान करने के लिए, आउटपुट को निरंतर स्ट्रीम में भी प्रस्तुत किया जा सकता है, ऊपर वर्णित समान आवश्यकता के अधीन।

स्कोरिंग

विजेता प्रत्येक भाषा में सबसे छोटा कार्यक्रम है, साथ ही साथ सबसे छोटा भी।

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

अपवाद 2 CSS या प्रभावी रूप से समान साधन का उपयोग विशेष रूप से न्यूनतम आवश्यकताओं से परे आउटपुट स्टाइल करने के उद्देश्य के लिए किया जाता है जो कुल बाइट्स की ओर नहीं गिना जाता है। उदाहरण के लिए *{color:blue;text-align:center;}केवल 32-10 = 22 बाइट्स के रूप में गिना जाता है क्योंकि color:blue;किसी भी विनिर्देश को पूरा करने के लिए सेवा नहीं है, जबकि केंद्रित पाठ निर्दिष्ट है।

मेटा

टीआरएस -80 डांसिंग दानव , एंड्रॉइड निम , और निश्चित रूप से बुस्बी बर्कले (और नहीं, मैं ऐसा बूढ़ा नहीं हूं ) से प्रेरित होकर ।

code-golf ascii-art animation

— ऊबड़
स्रोत

महान ... आखिरी चीज जो मुझे चाहिए, इससे पहले कि मैं थक गया हूं मेरा ध्यान खींचने के लिए एक चुनौती है। क्या शीर्ष पर टैग आवश्यक हैं?

— मैट

@ मैट, अच्छी तरह से पूरी चुनौती सख्ती से "आवश्यक" नहीं है, लेकिन मैंने डुप्लिकेट टैग हटा दिए हैं। ;-)

— बम्पी

मैंने इनपुट पैरामीटर 'D' के लिए अधिकतम सीमा हटा दी है। यह था "डी <बी / एन" यकीन है कि लाइन नीचे प्रत्येक रोबोट था कम से कम कार्रवाई करते हुए पहला रोबोट अभी भी यह प्रदर्शन कर रहा था (बहुत ज्यादा अराजकता से बचने के लिए) बनाने के लिए शुरू कर दिया है, लेकिन त्रुटि से, मेरे अपने उदाहरण है कि नियम तोड़ दिया, और यह वैसे भी ठीक लग रहा है इसलिए मैंने अधिकतम विलंब सीमा को हटा दिया है। उस देर से परिवर्तन के लिए क्षमा याचना।

— बंपी

मैंने CSS और इसी तरह स्कोरिंग पर अनुभाग अपडेट किया है।

— बम्पी

वह सबसे मनमोहक चीज है जिसे मैंने कभी देखा है।

— Wossname

जवाबों:

^{देवियों और सज्जनों, कृपया हमारे प्यारे का स्वागत करें}

फुल फ्रंटेंड-स्टैक डांस ग्रुप, 1,320 1,378 1,425 1,495 बाइट्स

^{जावास्क्रिप्ट: 1,195 बाइट्स | सीएसएस: 103 बाइट्स | HTML: 22 बाइट्स}

यह एक सुंदर चुनौती है। इसके कई विशेष मामले भी हैं। ओह लड़का, इतने सारे विशेष मामले। और उन एंटेना ...

यह हमेशा के लिए चलेगा और सभी कार्यों ( left foot, right footआदि) के पूरा होने के बाद पुनः आरंभ करेगा ।

आप इसे jsFiddle पर या नीचे दिए गए कोड स्निपेट चीज़ का उपयोग करके आज़मा सकते हैं:

t=setTimeout
c=l=a=i=0
_=(x,y,z)=>{if(!i)for(;++i<=x;q=~~(Math.random()*10))s.append(document.createElement('pre'))
for(i=l=0,c=a+1;i<33;)(i=>{t($=>{if(4==i){c=0
l=1}if(8==i){c=a+1
l=0}if(12==i|14==i){c=0
l=2}if(13==i|15==i)c=a+1
if(16==i){c=0
l=3}if(16<i&24>i)c=i-10
if(24==i){c=0
l=4}if(28==i)c=6
if(31<i){a=++a%5
_(x,y,z)}for(j=0;j<x;)(j=>{t($=>s.childNodes[j][h]=(-1<[1,3,8,9].indexOf(c)?'  ':2==c||4==c?'    ' :'   ')+(11==c||12==c?'_':'')+['\\/\\/','|┌┐|',')||(','||||','┐/\\┌'][(q+j)%4].substring($=8<c&12>c?2:0,$+2)+(8==c||9==c?'_':'')+'\n'+[`  ['']			   
 └[__]┘ 
   ||`,` ['']  
└[__]┘  
  /<`,`   ['']
  └[__]┘
    >\\`,` ['']
┌[__]┘
  <\\`,`   ['']
  └[__]┐
    />`,`  ['']
 ┌[__]┐
  /  \\`,` \\[*-]
  [__]\\
   <\\`,`  ['']
 >[__]<
   ||`,`  [" ]
  [_<]
   |\\`,`  [ _]
  [<.]
   ||`,`  [__]
 <[..]>
   /|`,`  [_ ]
  [.>]
   ||`,`  [ "]
  [>_]
   |\\`,`  ['']
 <[__]>
   ||`][c]+'\n-------',j*z)})(j++)
p[h='innerText']='"'+["You put your $ in","You take your $ out","And you shake it all about","You do the Hokey Pokey and you turn yourself around","That's what it's all about!"][l].replace('$',['right foot','left foot','right hand','left hand','whole self'][a])+'"'},i*y)})(i++)}

// let's dance (not included in the byte count – as if it would make any difference)
_(8, 400, 50)

*{text-align:center}x pre{display:inline-block;width:55px;text-align:left}pre{line-height:16px;margin:0

<x id=s></x><pre id=p>

स्निपेट का विस्तार करें

^{MacOS, Windows 10 और Ubuntu पर क्रोम और फ़ायरफ़ॉक्स में परीक्षण किया गया}

संपादित करता

सहेजे गए 70 बाइट्स अतिरिक्त कंटेनर एंटेना धारण करने के लिए को हटाने के द्वारा। बंपी को धन्यवाद । कुछ और व्हाट्सएप भी पाए, अब की अनावश्यक कैशिंग को createElementहटा दिया और लंबे एक्सेस को हटा दिया .firstChild।
47 बाइट्स सहेजे गए - बस एहसास हुआ कि मुझे वास्तव में कॉल करने की आवश्यकता नहीं है getElementById। यह भी documentअनावश्यक के कैशिंग बनाता है ।
सहेजा 4 बाइट की जगह ||और &&बिटवाइज़ साथ &और |। TheLethalCoder का धन्यवाद ।
सहेजे गए 54 बाइट्स छोटी बातों के बहुत सारे को सरल बनाकर और सीएसएस अनुकूलित करके।

— insertusernamehere
स्रोत

वाहवाही!!! फुल फ्रंटेंड-स्टैक डांस ग्रुप का एक हिट !! विशेष मामलों की राशि के लिए माफी; मैंने ऐन्टेना संयोजनों को विशेष रूप से कुंठित करने के लिए चुना, लेकिन बाकी के सभी प्रतीक एनीमेशन की सेवा में थे - मैंने इसे एसओ के रूप में योजना नहीं बनाई। अब, मुझे लगता है कि इस तरह के शानदार प्रदर्शन की आलोचना कर रहे हैं, लेकिन मुझे लगता है कि अंडरस्कोर / ऐन्टेना अजीब से बाहर हैं जब वे चारों ओर मुड़ते हैं (1 चरित्र बहुत बाईं ओर, संभवतः!) लेकिन जो भी हो - यह बहुत अच्छा है! मेरी चुनौती लेने के लिए धन्यवाद!

— बंपी

@ बम्पी धन्यवाद आप ठीक कह रहे हैं, मैंने कुछ मैजिक नंबर मिलाए। एंटेना अब पूरी तरह से क्रम में हैं। मैंने सभी आंकड़ों के लिए समान लाइन-ऊंचाई प्राप्त करने में भी कामयाबी हासिल की। वाकई एक मजेदार चुनौती।

— आवेषण

2 बजे नाचने वाले रोबोट के साथ आप क्या कहते हैं? कमाल है, बवाहा!

— बंपी

||और &&करने के लिए |और &?

— TheLethalCoder

@ लेथलॉकर बिल्कुल। आपका सुझाव पहले से ही स्रोत में है और संपादन में परिलक्षित होता है। बहुत बहुत धन्यवाद।

— आवेषण

अपवादों के बाद C #, 1188 1376 1382 बाइट्स

जमा:

namespace System.Threading{using S=String;void H(int n,int b,int d){Console.CursorVisible=false;int t,u=0,v=5,w,x,y,z;S[]i=",That's what it's all about!,,You do the Hokey Pokey and you turn yourself around,And you shake it all about,,You take? out,You put? in".Split(',');i[0]=i[1];i[2]=i[3];i[5]=i[7];for(b=b<d*n?0:b-d*n;v-->0;)for(w=32;w-->0;Thread.Sleep(b))for(t=u,z=0;z++<n;Thread.Sleep(d)){S s="",r=i[w/4].Replace("?"," your "+(v<1?"whole self":(v%2<1?"right ":"left ")+(v/3<1?"hand":"foot")));u="88880000765432109090999900009999"[w];u=u>56?9+v:u-48;for(y=4;y-->0;s+="\n")for(x=0;x<n;x++)s+=S.Format(@"{0}{0}   |\   {0}   /|   {0}   |\   {0}   /|{4} /  \{4}  />{4}<\{4}{4}>\{4}/<{4} └{1}┘  >{1}<   [_<]{4}[<.]   <[..]>   [.>]{4}[>_]   <{1}>   {1}\  ┌{1}┐   └{1}┐┌{1}┘{4}└{1}┘└{1}┘   {2}  {2}   ["" ]{4}[ _]{4}{1}{4}[_ ]{4}[ ""]   {2}  \[*-]   {2}   {2}{2}{4}{2}{2}  {3}{3}  12_{4} 34_{4}  34{4}  _34{4} _12  {3}{3}{3} {3} 12{4} {3} 12{4}", "   ||   ","[__]"," [''] ","   12   ","    ").Substring(y*14+(x<z?u:t)<<3,8).Replace("12",@"\/|┌)|||┐/".Substring(x%5*2,2)).Replace("34",@"\/┐||(||\┌".Substring(x%5*2,2));Console.Clear();Console.Write(s+new S('-',n*8)+"\n"+new S(' ',n*4-r.Length/2)+r);}}}

थोड़ा अच्छा स्वरूपण और एक निष्पादन कार्यक्रम में लिपटे:

namespace System.Threading{
    using S=String;

    //** Not counted towards score: execution wrapper
    class P{
        static void Main(S[]a){
            new P().H(int.Parse(a[0]),int.Parse(a[1]),int.Parse(a[2]));
        }
    //** End not counted towards score

        void H(int n,int b,int d){
            Console.CursorVisible=false;  // Not counted under exception 2
            int t,u=0,v=5,w,x,y,z;
            S[]i=",That's what it's all about!,,You do the Hokey Pokey and you turn yourself around,And you shake it all about,,You take? out,You put? in".Split(',');
            i[0]=i[1];
            i[2]=i[3];
            i[5]=i[7];
            for(b=b<d*n?0:b-d*n;v-->0;)
                for(w=32;w-->0;Thread.Sleep(b))
                    for(t=u,z=0;z++<n;Thread.Sleep(d)){
                        S s="",r=i[w/4].Replace("?"," your "+(v<1?"whole self":(v%2<1?"right ":"left ")+(v/3<1?"hand":"foot")));
                        u="88880000765432109090999900009999"[w];
                        u=u>56?9+v:u-48;
                        for(y=4;y-->0;s+="\n")
                            for(x=0;x<n;x++)
                                s+=S.Format(@"{0}{0}   |\   {0}   /|   {0}   |\   {0}   /|{4} /  \{4}  />{4}<\{4}{4}>\{4}/<{4} └{1}┘  >{1}<   [_<]{4}[<.]   <[..]>   [.>]{4}[>_]   <{1}>   {1}\  ┌{1}┐   └{1}┐┌{1}┘{4}└{1}┘└{1}┘   {2}  {2}   ["" ]{4}[ _]{4}{1}{4}[_ ]{4}[ ""]   {2}  \[*-]   {2}   {2}{2}{4}{2}{2}  {3}{3}  12_{4} 34_{4}  34{4}  _34{4} _12  {3}{3}{3} {3} 12{4} {3} 12{4}", "   ||   ","[__]"," [''] ","   12   ","    ").Substring(y*14+(x<z?u:t)<<3,8).Replace("12",@"\/|┌)|||┐/".Substring(x%5*2,2)).Replace("34",@"\/┐||(||\┌".Substring(x%5*2,2));
                        Console.Clear(); // Not counted under exception 1
                        Console.Write(s+new S('-',n*8)+"\n"+new S(' ',n*4-r.Length/2)+r);
                    }
        }
    } // Not counted towards score: end class
}

इसे ऑनलाइन आज़माएं!

इस लिंक पर जाएँ: tutorialspoint.com
में डिफ़ॉल्ट टर्म स्क्रीन के तल पर टैब, टाइप करें:
mono main.exe 8 400 40

संपादित करें 1

कुल मिलाकर 6 बाइट बचाने के string.Format(i,j)साथ प्रतिस्थापित i.Replace("?",j)।

संपादित करें 2

टिप्पणियों से सुझावों के साथ पूर्ण सुधार करें।

— हाथ-ए-खाना
स्रोत

वाह! कहीं इसे ऑनलाइन चलाने का एक आसान तरीका है?

— बंपी

@ बम्पी, जवाब में एक लिंक जोड़ा!

— हाथ-ई-फूड

@insertusernamehere एक अनाम फ़ंक्शन और कुछ मामूली गोल्फिंग के लिए संकलित करके मैंने इसे 1300 से कम कर दिया है।

— TheLethalCoder

@insertusernamehere, किया! तुम्हारी बारी! :

— हैंड-ई-फूड

@ TheLethalCoder, इसके लिए धन्यवाद! मुझे cएक छोटी सी बचत के लिए छुटकारा मिल गया । मुझे पता था कि मैं इससे बेहतर तरीका भूल गया हूं new string(c,n)। हालाँकि, अब जब मैंने अलियास किया है S=String, तब new S(c,n)भी कम है।

— हैंड-ई-फूड

जावास्क्रिप्ट, 948 बाइट्स

अपने खुद के सवाल का जवाब देने के लिए शायद खराब रूप, लेकिन फिर भी ...

पाठ को संपीड़ित करने के लिए सभी प्रकार के तरीकों की कोशिश की, लेकिन अधिकांश कुंजी + एल्गोरिथ्म के साथ मूल से अधिक समय तक समाप्त हो गए। मुझे यकीन है कि अभी भी इसे कम करने के लिए एक अधिक इष्टतम तरीका है, लेकिन मुझे कहीं न कहीं रेखा खींचनी होगी।

दिलचस्प बात यह है कि खोज में कुछ अन्य चुनौतियों के लिए एक या दो विचार मिले, जिन्हें मैं बाद में परिष्कृत और पोस्ट कर सकता हूं।

<pre id=O/>

f=(N,B,D)=>{Q=c=>(K={},k='~',[...c].map(v=>v<k?K[k=v]='':K[k]+=K[v]||v),K[k])
x=``,A=`//,||,)||(,,/`.split(',').sort(new Date)
r=new Array(N).fill(0),t=i=v=0,n=`\n`,T=setTimeout
C=_=>(w=Q(`ouhand t t's ake Y y all abtokey righlefwhole fooself ,${v+1},,1yr ${x[v*2]+x[v*2+1]}puintt,,Ashi,do the HPaturn yrarnd,,7,8,90123,Twi!,,6,`).split(',')[i++])<'A'?(r.map((_,m)=>T((a,b)=>R(r[N-a]=b),m*D,m,w)),i>22?(v++,i=0):0,v<3?T(C,B*(i<7||i>21?4:1)):0):C(t=w),R=_=>{for(o='',m=4;m--;o+=n){for(w=N;w--;)o+=Q(`┌┐└┘\\/||/${A[w%5]}   [__] [''] ||] _ __ _  [*-][" ][ _][_ ][ "] ┐ ┐><[_<] [<.]<[..]>[.>] [>_]<> /<></>/ //`).substr(r[w]*8+(3-m)*112,8)}
O.innerHTML=o+'-'.repeat(N*8)+' '.repeat(((N*8)-t.length)/2)+t}
C()}

( NB: 1-31 की सीमा में कुछ पात्र शामिल हैं जिनका प्रतिनिधित्व यहाँ पोस्ट करते समय थोड़ा अजीब है)

CodePen पर पूर्ण साइकेडेलिक नृत्य चक्र देखें !

— ऊबड़
स्रोत