यह बटन क्या करता है?

Question

वर्तमान में मेरे काम पर हम एक नई इमारत में चले गए। यह कला का राज्य माना जाता है और इसमें स्वचालित रोशनी, स्वचालित रोल-डाउन शटर, और अब इस शहर में सबसे अधिक पर्यावरण के अनुकूल इमारत के रूप में जाना जाता है।
हालाँकि, यह वास्तव में अच्छी तरह से काम नहीं करता है .. रोल-डाउन शटर कभी-कभी बादल के दिनों और ऊपर नीचे जाते हैं जब सूरज चमकने लगता है, और रोशनी कभी-कभी बारी बारी से और हर 5-10 पर बारी-बारी से डिस्को प्रभाव का कारण बनती है मिनट। इसके अलावा, हमारे पास इन रोल-डाउन शटर को नियंत्रित करने का कोई मैनुअल तरीका नहीं है, न ही तापमान, लेकिन हमारे पास रोशनी के लिए रिमोट नहीं है।
हालांकि ये निर्देश बिना किसी निर्देश पुस्तिका के आए और 20 बटन से कम के सभी प्रकार के सामानों को छोड़कर जो आप चाहते हैं, को छोड़कर।

PS: मैंने यह चुनौती 1.5 महीने पहले सैंडबॉक्स में लिखी थी। वर्तमान में हम, थोड़े, जानते हैं कि कैसे काम करता है ..
इस इमारत के बारे में एक बड़ा फायदा, यह 30+ डिग्री सेल्सीस से बाहर है, लेकिन इसके अंदर हर समय एक ही 21 कमरे का तापमान रहता है।

तो, यह परिचय था, और रोशनी के लिए रिमोट कंट्रोल ने इस चुनौती को प्रेरित किया।

चुनौती:

मान लें कि हमारे पास शुरू में एक दीपक है:

L

फिर हम सभी प्रकार के बटन धक्का देते हैं और बाद में दीपक की स्थिति का उत्पादन करते हैं।

हम दीपक के लिए रिमोट कंट्रोल के विभिन्न कार्यों के लिए निम्नलिखित नंबरों का उपयोग करते हैं। जब उस संख्या के सामने माइनस सिंबल होता है, तो हम इसके विपरीत करते हैं।

• 1= पर; -1= बंद।
• 2= शक्ति में 25% की वृद्धि; -2= कमी (मंद) शक्ति 25%।
• 3= 50% तक फैला हुआ; -3= कमी 50% तक फैल गई।
• 4 = प्रकाश के प्रकार को टॉगल करना।

तो, यह सब बहुत अस्पष्ट है, तो चलिए गहराई में जाते हैं कि प्रत्येक चीज़ का क्या अर्थ है:

तो, -1(OFF) बहुत स्पष्ट है, और 1प्रारंभिक ON-State (50% के लिए 2और 50% 3) के लिए जाएगा:

   //
  //
L ====
  \\
   \\

2और -2प्रकाश कितनी दूर यात्रा करता है ( ==प्रत्येक 25% के लिए जोड़ा जाता है):

0% (equal to a light bulb that is OFF)
L

25%
L ==

50%
L ====

75%
L ======

100%
L ========

3और -3प्रकाश कितनी दूर तक फैला है:

0%:
L ====

50%:
   //
  //
L ====
  \\
   \\

100%:
|| //
||//
L ====
||\\
|| \\

(नोट: जब 2और 3दोनों 100% पर हैं, तो आपके पास यह अवस्था होगी:

||   //
||  //
|| //
||//
L ========
||\\
|| \\
||  \\
||   \\

4 प्रकाश के प्रकार को टॉगल करना है।

Default:
  //
L ==
  \\

After toggling (note the single space before '/' instead of two):
 /
L --
 \

इनपुट:

आपको संभावित बटन-प्रेस वाला एक इनपुट प्राप्त होगा। उदाहरण के लिए:

12-34

आउटपुट:

इनपुट के सभी बटन उप-अनुक्रमिक दबाए जाने के बाद प्रकाश लैंप की स्थिति। तो ऊपर दिए गए उदाहरण इनपुट के साथ, हमारे पास निम्न आउटपुट हैं:

L ------

चुनौती नियम:

• इनपुट में केवल 1234-(और -पहले कभी नहीं 4) शामिल है।
• आप कभी भी 0% से नीचे या 100% से ऊपर नहीं जा सकते हैं। यदि इन सीमाओं से परे कोई संख्या बढ़ती / घटती है तो आप इसे अनदेखा कर सकते हैं।
• जब दीपक बंद हो जाता है, तो आप किसी भी कार्रवाई को अनदेखा कर सकते हैं और जब फिर से चालू किया जाता है तो यह प्रारंभिक ओएन-स्टेट (दोनों 2और 3, और डिफ़ॉल्ट 4) के लिए 50% पर वापस सेट हो जाता है । उदाहरण के लिए: 12-1-341बस ऊपर उल्लेखित प्रारंभिक ओएन-स्टेट प्रिंट करेगा। (टीआईपी: आप 1इनपुट के अंतिम से पहले सब कुछ अनदेखा कर सकते हैं - छोड़कर -1।)
• प्रकाश की लंबाई या एक एकल अनुगामी नई रेखा के बराबर रिक्त स्थान अनुगामी है। हालांकि अतिरिक्त अनावश्यक नई लाइनें जोड़ना नहीं है।
• आपको एकल स्ट्रिंग के बजाय पूर्णांक की सूची के रूप में इनपुट लेने की अनुमति है। तो इसके बजाय 12-34, आप [1,2,-3,4]इनपुट के रूप में हो सकते हैं ।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स वर्जित हैं।
• यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
• इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामलों:

12-34
L ------

12-1-341
   //
  //
L ====
  \\
   \\

14-3224333-2
||  //
|| //
||//
L ======
||\\
|| \\
||  \\

142-1-314-3-322
L --------

1324-2-3
  /
 /
L ----
 \
  \

134
| /
|/
L ----
|\
| \

1-2-2-214-3-3-3
L ----

Comments

इसके लिए आउटपुट क्या है 134?

— पुरकाकूदरी

@ Pietu1998 मैंने परीक्षण मामले को जोड़ा है (और टॉगल के बाद रिक्त स्थान के बारे में कुछ चीजें तय की हैं 4)। पूछने के लिए धन्यवाद।

— केविन क्रूज़सेन

मुझे नहीं लगता कि तीसरे परीक्षण के मामले के लिए प्रसार सही है।

— पुरकाकूदरी

यदि दीपक चालू होता है और 1दबाया जाता है, तो क्या पैरामीटर रीसेट होते हैं?

— पुरकाकूदरी

इस मौसम में आपका कार्यालय 21º है? मुझे ऐसा लगता है कि आप ईर्ष्या से बाहर निकले हैं।

— नील

Answer 1

पायथन 2, 221 बाइट्स

for b in[-1]+input():exec["p=b>0;d=2;s=1;t=2","d+=b/2*(-2<d+b<6)","s+=b/3*(-3<s+b<5)","t=3-t"][abs(b)-1]
i=c=(s>0)*d*p
q='print" |"[s/2]*t+" "*i+t*%r;'
exec('i-=1;'+q%'/')*c
print"L "+" -="[t]*2*d*p
exec(q%'\\'+'i+=1;')*c

यह घाव मेरी अपेक्षा से अधिक लंबा है। पहली पंक्ति दीपक की स्थिति की गणना करती है, बाकी छपाई को लागू करती है।

सरणी फॉर्म में इनपुट STDIN के माध्यम से दिया जाता है।

आइडोन पर परीक्षण के मामलों को देखें

Answer 2

आर, 323 320 बाइट्स

    z=scan();a=c=1;b=d=2;for(i in 1:sum(1|z)){s=sign(y<-z[i]);switch(y/s,b<-d<-2*(c<-a<-y),b<-b+s,c<-c+s,d<-2-d);b=min(b,4);c=min(c,2);b=b*(b>0);c=c*(c>0)}
    s="/";v=if(c>1)"|"else" ";for(i in a*b:-b){if(i)cat(v,if(d)v,rep(" ",abs(i)-1),s,if(d)s,"\n",sep="")else{cat("L ",if(d)rep("==",b)else rep("--",b),"\n",sep="");s="\\"}}

Ungolfed:

z=scan()

इनपुट की एक पंक्ति पढ़ता है (पूर्णांक रिक्त स्थान के साथ अलग हो जाता है)

a=c=1;b=d=2

शुरुआती चर (ऑन-नेस), बी (चमक), सी (चौड़ाई), डी (बीम प्रकार)। dया तो शून्य या दो है, जिसका अर्थ है कि हम कॉल कर सकते हैं (डी) बाद में एक लंबे समय के बजाय अगर (डी> 1) या इसी तरह के और बाइट्स के एक जोड़े को बचाने के।

while(any(z|1))

लिखने का एक गोल्फ-वाई तरीका while(length(z))जहां z एक पूर्णांक वेक्टर है।

शेष पहली पंक्ति एक switchबयान के माध्यम से इनपुट को संभालती है । दूसरी पंक्ति प्रिंट करती है।

यह संभव है कि कुछ के <-साथ प्रतिस्थापित किया जा सकता है =, लेकिन मुझे लगता है कि आप लेक्सिकल स्कूपिंग द्वारा जीवित खाए जाते हैं ...

यह भी ध्यान दें कि आर में, बैकस्लैश से बचने की आवश्यकता है।

c*(c>0)लिखने का एक गोल्फ-वाई तरीका है max(c,0)जो एक चरित्र को बचाता है।

यदि प्रकाश चालू नहीं है, तो चूंकि *पहले की तुलना में कम पूर्वता है :, for(i in a*b:-b)लूप केवल खत्म हो जाता है 0:0।

अपडेट करें; पहली पंक्ति में लूप को एक के साथ बदलकर 3 बाइट्स को बचाया गया (इसके बजाय)। ध्यान दें कि या 1:sum(1|z)से कम वर्ण हैं । ज्यादातर मामलों में काम करेगा, लेकिन तब नहीं जब लंबाई एक की हो। दिया गया समाधान लंबाई शून्य के इनपुट के लिए काम नहीं करेगा लेकिन मुझे उम्मीद है कि प्रतियोगिता के दायरे से बाहर है।1:length(z)seq_along(z)seq(z)z

Answer 3

कोटलिन , 445 बाइट्स

मेरा पहला कोटलिन गोल्फ, जावा से 38 बाइट्स कम :)

fun f(z:IntArray)={var a=1<0;var b=2;var c=1;var d=a
z.map{when(it){1->{a=1>0;b=2;c=1;d=!a}-1->a=1<0;2->if(b<4)b+=1;-2->if(b>0)b-=1;3->if(c<2)c+=1;-3->if(c>0)c-=1;4->d=!d}}
var r="";val l=if(c>1)if(d)"|" else "||" else if(d)" " else "  "
if(c>0)for(i in b downTo 1)r+="${l+" ".repeat(i-1)+if(d)"/" else "//"}\n"
r+="L ${(if(d)"--" else "==").repeat(b)}\n"
if(c>0)for(i in 1..b)r+=l+" ".repeat(i-1)+"${if(d)"\\" else "\\\\"}\n"
if(a)r else "L"}()

सफेद-स्थान और परीक्षणों के साथ:

fun f(z: IntArray) = {
    var a = false // ON / OFF
    var b = 2 // Strength [0,4]
    var c = 1 // Spread [0,2]
    var d = a // Type

    // Find state to print
    z.map {
        when (it) {
            1 -> {
                a = true
                b = 2
                c = 1
                d = !a
            }
            -1 -> a = false
            2 -> if (b < 4) b += 1
            -2 -> if (b > 0) b -= 1
            3 -> if (c < 2) c += 1
            -3 -> if (c > 0) c -= 1
            4 -> d = !d
        }
    }

    var r = ""
    val l = if (c > 1) if (d) "|" else "||"
    else if (d) " " else "  "

    // Print state
    if (c > 0) for (i in b downTo 1) {
        r += "${l + " ".repeat(i - 1) + if (d) "/" else "//"}\n"
    }
    r += "L ${(if (d) "--" else "==").repeat(b)}\n"
    if (c > 0) for (i in 1..b) {
        r += "${l + " ".repeat(i - 1) + if (d) "\\" else "\\\\"}\n"
    }

    /* return */ if (a) r else "L"
}()

fun main(args: Array<String>) {
    println(f(intArrayOf(1, 2, -3, 4)))
    println(f(intArrayOf(1, 2, -1, -3, 4, 1)))
    println(f(intArrayOf(1, 4, -3, 2, 2, 4, 3, 3, 3, -2)))
    println(f(intArrayOf(1, 4, 2, -1, -3, 1, 4, -3, -3, 2, 2)))
    println(f(intArrayOf(1, 3, 2, 4, -2, -3)))
    println(f(intArrayOf(1, 3, 4)))
    println(f(intArrayOf(1, -2, -2, -2, 1, 4, -3, -3, -3)))
}

दिलचस्प बात यह है कि सामान्य रूप से फ़ंक्शन printया returnबनाए गए स्ट्रिंग को परिभाषित करने के बजाय , यह फ़ंक्शन असाइनमेंट ( fun f() =एक मूल्यांकन लंबो का है) का उपयोग करने के लिए छोटा था (क्या यह विवरण समझ में आता है?)।

^{_{मैं बस एसई उचित कोटलिन वाक्यविन्यास पर प्रकाश डाला गया था}}

Answer 4

जावा 8, 484 483 452 446 440 बाइट्स

z->{int a=1,b=2,c=1,d=0,j,k;for(int i:z){d=i==1?0:i>3?1-d:d;a=i*i==1?i:a;b+=i==1?2-b:i==2&b<4?1:i==-2&b>0?-1:0;c+=i==1?1-c:i==3&c<2?1:i==-3&c>0?-1:0;}String t=d<1?"=":"-",q=d<1?"//":"/",x=d<1?"\\\\":"\\",n="\n",y=" ",w=d<1?y+y:y,g=c>1?d<1?"||":"|":w,r="";if(c>0)for(r+=g,j=b;j-->0;r+=q+n+(j>0?c>1?g:w:""))for(k=j;k-->0;r+=y);for(r+="L ",j=b;j-->0;r+=t+t);r+=n;if(c>0)for(r+=g;++j<b;r+=x+n+(j<b-1?g:""))for(k=j;k-->0;r+=y);return a>0?r:"L";}

अंत में .. ठीक है, मेरी अपनी चुनौती मेरी अपेक्षा से थोड़ी कठिन है ..; पी

यह पूरी तरह से अलग दृष्टिकोण का उपयोग करके संदेह के बिना हो सकता है .. मैं अब पहले निर्धारित करता हूं कि क्या करना है, और फिर इसे प्रिंट करें। मुद्रण वास्तव में इस चुनौती का सबसे कठिन है, इम्हो।

-6 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

z->{                          // Method with integer-array parameter and String return-type
  int a=1,                    //  ON/OFF flag, initially ON
      b=2,                    //  Strength, initially 50%
      c=1,                    //  Spread, initially 50%
      d=0,                    //  Type of light, initially two lines
      j,k;                    //  Index-integers
  for(int i:z){               //  Loop over the input-array
    d=i==1?0:i>3?1-d:d;       //   Determine the new type of light
    a=i*i==1?i:a;             //   Determine if the light is ON/OFF
    b+=i==1?2-b:i==2&b<4?1:i==-2&b>0?-1:0;
                              //   Determine the new strength
    c+=i==1?1-c:i==3&c<2?1:i==-3&c>0?-1:0;}
                              //   Determine the new spread
  String t=d<1?"=":"-",       //  Horizontal light symbol
         q=d<1?"//":"/",      //  Upper diagonal light symbol
         x=d<1?"\\\\":"\\",   //  Bottom diagonal light symbol
         n="\n",              //  New-line
         y=" ",               //  Space
         w=d<1?y+y:y,         //  One or two spaces?
         g=c>1?d<1?"||":"|":w,//  Space(s) or vertical light symbol(s)?
         r="";                //  Result String, starting empty
  if(c>0)                     //  Do we have spread >0%?
    for(r+=g,j=b;j-->0;r+=q+n+(j>0?c>1?g:w:""))for(k=j;k-->0;r+=y);
                              //   Create upper light part
  r+="L ";                    //  Light-bulb
  for(j=b;j-->0;r+=t+t);      //  Horizontal light next to the light-bulb
  r+=n;
  if(c>0)                     //  Do we have spread >0%?
    for(r+=g;++j<b;r+=x+n+(j<b-1?g:""))for(k=j;k-->0;r+=y);
                              //   Create bottom light part
  return a>0?                 //  Is the light turned ON?
             r                //   Return the created result-String
            :                 //  Else:
             "L";}            //   Return just "L"

Answer 5

बैच, 552 बाइट्स

@echo off
for %%a in (1 %*) do call:l %%a
set/aw*=o,l*=o
if %w% gtr 0 for /l %%a in (%l%,-1,1)do call:w %%a /
set s=----
if %t%==1 set s=====
call echo L %%s:~-%l%%%%%s:~-%l%%%
if %w% gtr 0 for /l %%a in (1,1,%l%)do call:w %%a \
exit/b
:w
set v= 
set u=%2
if %w%==2 set v=l
if %t%==1 set u=%2%2&set v=%v%%v%
set s=    
call set s=%%s:~-%1%%
echo %v:l=^|%%s:~1%%u%
exit/b
:l
if %1==1 set/ao=w=t=1,l=2
if %1==-1 set/ao=0
if %1==2 set/al+=1-l/4
if %1==-2 set/al-=!!l
if %1==3 set/aw+=1-w/2
if %1==-3 set/aw-=!!w
if %1==4 set/at^=1

नोट: set v=एक अनुगामी स्थान set s=होता है और तीन होते हैं। यह वास्तव में अजीब था, क्योंकि आप आसानी से |बैच में एक चर संख्या को प्रिंट नहीं कर सकते हैं , इसलिए आपको एक प्लेसहोल्डर का उपयोग करना होगा और इसे इको स्टेटमेंट में बदलना होगा।

Answer 6

05AB1E , 106 बाइट्स

“/|= 
L“•Wθ¨S9ƒTª»þúÙ•6вèJ¶¡sŽ8ÃS«1¡θΣÄ}.γÄ}ODd*©н8‚ß8αF樚NÈi¨]R®θ8Öi"||//="2ô…|/-S:}®Ås3/©_iθ}®i'|ð:}».∊

पूर्णांकों की सूची के रूप में इनपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

“/|= 
L“               # Push string "/|=\nL"
  •Wθ¨S9ƒTª»þúÙ• # Push compressed integer 9569494169631511496055972036
   6в            # Converted to Base-6 as list: [5,3,2,2,2,2,2,2,2,2,4,1,1,0,0,4,1,1,3,0,0,4,1,1,3,3,0,0,4,1,1,3,3,3,0,0]
     è           # Index each into the string
      J          # Join everything together

अब हमारे पास स्ट्रिंग है:

L ========
||//
|| //
||  //
||   //

फिर ठीक:

¶¡               # Split it by newlines: ["L ========","||//","|| //","||  //","||   //"]
s                # Swap to take the (implicit) input-list
 Ž8Ã             # Push compressed integer 2234
    S            # Converted to a list of digits: [2,2,3,4]
     «           # Append it at the end of the input-list
                 #  i.e. [4,3,3,2,1,3,2,4,-2,-3] → [4,3,3,2,1,3,2,4,-2,-3,2,2,3,4]
 1¡              # Then split on 1
                 #  i.e. [4,3,3,2,1,3,2,4,-2,-3,2,2,3,4]
                 #   → [[4,3,3,2],[3,2,4,-2,-3,2,2,3,4]]
   θ             # Only leave the last inner list
                 #  i.e. [[4,3,3,2],[3,2,4,-2,-3,2,2,3,4]] → [3,2,4,-2,-3,2,2,3,4]
    ΣÄ}          # Sort on the absolute value
                 #  i.e. [3,2,4,-2,-3,2,2,3,4] → [2,-2,2,2,3,-3,3,4,4]
       .γÄ}      # Then group by absolute value
                 #  i.e. [2,-2,2,2,3,-3,3,4,4] → [[2,-2,2,2],[3,-3,3],[4,4]]
           O     # Then take the sum of each group
                 #  i.e. [[2,-2,2,2],[3,-3,3],[4,4]] → [4,3,8]
            Dd   # Duplicate it, and check for each if it's non-negative (>= 0)
                 #  i.e. [4,3,8] → [1,1,1]
              *  # Multiply the two lists
                 #  i.e. [4,3,8] and [1,1,1] → [4,3,8]
               © # And store the result in the register (without popping)
н                # Now take the first value (the strength)
                 #  i.e. [4,3,8] → 4
 8‚              # Pair it with 8
                 #  i.e. 4 → [4,8]
   ß             # Pop and push the minimum of the two
                 #  i.e. [4,8] → 4
    8α           # And then calculate the absolute difference with 8
                 #  i.e. 4 → 4
      F          # Loop that many times:
       ć         #  Extract the head of the string-list
                 #   i.e. ["L ========","||//","|| //","||  //","||   //"] → "L ========"
        ¨        #  Remove the last character
                 #   i.e. "L ========" → "L ======="
         š       #  And prepend it back to the list again
                 #   i.e. ["||//","|| //","||  //","||   //"] and "L ======="
                 #    → ["L =======","||//","|| //","||  //","||   //"]
       NÈi       #  And if the loop-index is even:
          ¨      #   Also remove the last item of the string-list
                 #    i.e. ["L =======","||//","|| //","||  //","||   //"]
                 #     → ["L =======","||//","|| //","||  //"]
      ]          # Close both the if and loop
                 #  i.e. ["L ========","||//","|| //","||  //","||   //"] and 4
                 #   → ["L ====","||//","|| //"]
       R         # Then reverse the list
                 #  i.e. ["L ====","||//","|| //"] → ["|| //","||//","L ===="]
®                # Push the list from the register again
 θ               # Now take the last value (the toggle)
                 #  i.e. [4,3,8] → 8
  8Öi         }  # If it's divisible by 8:
                 #  i.e. 8 → 1 (truthy)
     "||//="     # Push string "||//="
            2ô   # Split into parts of size 2: ["||","//","="]
     …|/-        # Push string "|/-"
         S       # Split into characters: ["|","/","-"]
     :           # And replace all of them in the string-list
                 #  i.e. ["|| //","||//","L ===="] → ["| /","|/","L ----"]
®                # Push the list from the register again
 Ås              # Now take the middle value (the spread)
                 #  i.e. [4,3,8] → 3
   3/            # Divide it by 3
                 #  i.e. 3 → 1
     ©           # Store it in the register (without popping)
      _i }       # If it's exactly 0:
                 #   i.e. 1 → 0 (falsey)
        θ        #  Only leave the last value of the string-list
     ®i    }     # If it's exactly 1 instead:
                 #   i.e. 1 → 1 (truthy)
       '|ð:     '#  Replace all "|" with spaces " "
                 #   i.e. ["| /","|/","L ----"] → ["  /"," /","L ----"]
»                # Then join the string-list by newlines
                 #  i.e. ["  /"," /","L ----"] → "  /\n /\nL ----"
 .∊              # And finally intersect mirror everything vertically
                 # (which automatically converts the slashes)
                 #  i.e. "  /\n /\nL ----" → "  /\n /\nL ----\n \\n  \"
                 # (And output the result implicitly)

(वर्गों मेरा यह 05AB1E टिप देखें कितना बड़ा पूर्णांक संपीड़ित करने के लिए? और संपीड़ित पूर्णांक सूचियों कैसे? ) को समझने के लिए क्यों •Wθ¨S9ƒTª»þúÙ•6вहै [5,3,2,2,2,2,2,2,2,2,4,1,1,0,0,4,1,1,3,0,0,4,1,1,3,3,0,0,4,1,1,3,3,3,0,0]; और Ž8Ãहै 2234।