क्या यह 2048 का बोर्ड अच्छा है?

26

यह मेरा पहला सवाल है, इसलिए टिप्पणियों में किसी भी सुझाव की सराहना की जाएगी! धन्यवाद ;)

परिचय

के लिए एक बहुत ही सामान्य रणनीति 2048 खेल है कभी नीचे स्वाइप । यह शीर्ष पर सभी बड़ी संख्याएँ, और निचले हिस्से में निचले स्थान रखता है। इसलिए, यदि आप इस रणनीति को सही ढंग से लागू करते हैं, तो आपका बोर्ड हमेशा निम्नलिखित पैटर्न से मेल खाएगा:

/ आपके कार्य के लिए जाँच करने का पैटर्न

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

आई / ओ

इनपुट को किसी भी उपयुक्त तरीके से लिया जा सकता है, उदाहरण के लिए 4 सरणियों की एक सरणी, प्रत्येक में 4 संख्याएं या 16 संख्याओं की एक सरणी होती है। कुल में, यह हमेशा 16 नंबर होगा, 4x4 बोर्ड का प्रतिनिधित्व करना। आउटपुट का एक सत्य मूल्य होना चाहिए इनपुट "अच्छा 2048-बोर्ड" है, और एक मिथ्या मूल्य अन्यथा।

उदाहरण

Truthy:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 |  8 |
|-------------------|
|  4 |    | 32 |  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|


|-------------------|
| 16 | 128| 64 | 32 |
|-------------------|
|  8 | 128| 32 |  8 |
|-------------------|
|  4 | 16 |  8 |  2 |
|-------------------|
|  4 |    |    |    |
|-------------------|

Falsy:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 | 16 |
|-------------------|
| 32 |    | 128|  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|


|-------------------|
| 16 | 128| 64 | 32 |
|-------------------|
|  8 |  32|    |  8 |
|-------------------|
|  4 | 16 |  8 |  2 |
|-------------------|
|  4 |    |    |    |
|-------------------|

ध्यान दें

दूसरा मिथ्या परीक्षण मामले को देखें: जब कहीं एक खाली मान (या 0) है और तब भी जब इसका मूल्य उस मूल्य से होता है जो अंतिम गैर-शून्य संख्या से अधिक है, तो यह गलत होना चाहिए, क्योंकि अगला मान शून्य 0 से अधिक होगा, जो इसे अमान्य बनाता है।

सौभाग्य!

code-golf  decision-problem  matrix  board-game  sliding-puzzle 
— dv02
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— मार्टिन एंडर

जवाबों:

16

हास्केल , 21 बाइट्स

all$scanr1 max>>=(==)

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

0 के रूप में रिक्त स्थान के साथ, स्तंभों की एक सूची लेता है।

— XNOR
स्रोत
के लिए गलत आउटपुट देता है [[16,8,4,0],[16,0,4,4],[16,4,4,4],[16,4,4,4]]।
— जोनाथन एलन
@JonathanAllan यह गलत होना चाहिए जैसा कि आपका दूसरा कॉलम है, [16,0,4,4] जो मोनोटोनिक नहीं है। या क्या मैं कुछ न कुछ भूल रहा हूं?
— मैं
0 एक खाली सेल के लिए आपका प्लेसहोल्डर है, जिसका मान 0. नहीं है
— जोनाथन एलन
2
@Iwanttomakegames कि टिप्पणी आपके लिए थी ("अपने" को "" "से बदलें")।
— जोनाथन एलन
@JonathanAllan मुझे सभी भ्रम के लिए खेद है, लेकिन 0 वास्तव में होना चाहिए, जबकि एक खाली सेल का प्रतिनिधित्व करते हुए, मान 0 के रूप में गिना जाता है। खाली कोशिकाओं को '0' के समान माना जाना चाहिए।
— DV02
9

APL (Dyalog) , 7 4 बाइट्स

तर्क के रूप में रिक्त स्थान के लिए 0 का उपयोग करके 4-बाय -4 मैट्रिक्स लेता है।

⊢≡⌊⍀

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

⌊⍀ ऊर्ध्वाधर संचयी न्यूनतम है

≡ के समान

⊢ बिना तर्क के?

— एडम
स्रोत
अद्भुत गोल्फ! (मुझे उम्मीद थी कि किसी ऐसे व्यक्ति से जो द्युलोग के लिए काम करता है और लंबे समय तक एपीएल प्रोग्राम किया है)। और, हां, मेरे पास बहुत सारे एपीएल प्रतीक हैं, हालांकि वे एपीएल प्रतीक नहीं हैं। अल्फा, Iota, ओमेगा सभी ग्रीक हैं, तकनीकी रूप से एपीएल नहीं। एक-चरित्र आदेशों के बारे में सोचते हुए वे सबसे पहले दिमाग में आए। 3. मैं वेतन वृद्धि और वेतन वृद्धि जेली है, क्योंकि यह पहली बार दिमाग में आया था। (बस आपको सूचित करने के लिए, मुझे चैट से निलंबित कर दिया गया है, इसलिए यहां प्रतिक्रिया।)
— Zacharý
7

जेली , 4 बाइट्स

Ṣ€U⁼

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

कॉलम की एक सरणी के रूप में इनपुट। मनमाने आकार के ग्रिड के साथ काम करता है।

— HyperNeutrino
स्रोत
एक खाली सेल का प्रतिनिधित्व क्या है? (उदा। द्वितीय फाल्सी टेस्ट केस का तीसरा भाग) - "कुल मिलाकर यह हमेशा 16 नंबर होगा"। यदि आप उन्हें पहले फ़िल्टर करते हैं तो यह शून्य के साथ काम करेगा।
— जोनाथन एलन
@JonathanAllan चश्मा के अनुसार, मुझे लगता है कि यह भी मान्य है
— हाइपरन्यूट्रीनो
फिर भी यह अब मेरे बजाय परीक्षण के मामले में लौटाया गया सुझाव विफल हो जाएगा । 01
— जोनाथन एलन
@JonathanAllan आप जेली में कैसे फ़िल्टर करते हैं ।_ मुझे उम्मीद है कि यह काम करेगा लेकिन ḟ0काम नहीं करता है
— HyperNeutrino
1
@DirtyDev यह ठीक है, हम यहां चुनौतियों का आनंद लेने और नए उपयोगकर्ताओं को इस जगह पर जाने में मदद करने के लिए हैं :) मुझे आशा है कि आप समुदाय का आनंद ले रहे हैं
— HyperNeutrino
6

आर (+ pryr), 23 बाइट्स

pryr::f(all(diff(x))<1)

जो फ़ंक्शन का मूल्यांकन करता है

function (x) 
all(diff(x)) < 1

जो इनपुट के रूप में एक मैट्रिक्स लेता है:

     [,1] [,2] [,3] [,4]
[1,]   16    0   64    8
[2,]    8    0   32    8
[3,]    4    0   32    2
[4,]    2    0    0    0

जब एक मैट्रिक्स दिया जाता है, diffस्वचालित रूप से पंक्तियों के भीतर अंतर की गणना करता है (आश्चर्यजनक रूप से। मुझे इस सुविधा का पता नहीं था जब तक कि मैंने इस चुनौती के लिए प्रयास नहीं किया)।

     [,1] [,2] [,3] [,4]
[1,]   -8    0  -32    0
[2,]   -4    0    0   -6
[3,]   -2    0  -32   -2

इनमें से कोई भी मूल्य एक अच्छे बोर्ड में 1 या अधिक नहीं हो सकता है, इसलिए हम मैट्रिक्स के मूल्यों का पालन करते <1हैं और देखते हैं all।

     [,1] [,2] [,3] [,4]
[1,] TRUE TRUE TRUE TRUE
[2,] TRUE TRUE TRUE TRUE
[3,] TRUE TRUE TRUE TRUE

[1] TRUE
— JAD
स्रोत
5

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

x=>''+x==x.map(v=>v.sort((x,y)=>y-x))

इसे इस तरह से कॉल करें:

|-------------------|
| 16 |    | 64 |  8 |
|-------------------|
|  8 |    | 32 |  8 |
|-------------------|
|  4 |    | 32 |  2 |
|-------------------|
|  2 |    |    |    |
|-------------------|

f([[8,8,2,0],[64,32,32,0],[0,0,0,0],[16,8,4,2]])

फ़ायरफ़ॉक्स, क्रोम, जावास्क्रिप्ट शेल और, Node.js. पर परीक्षण किया गया

— TSH
स्रोत
आप परिणाम को स्ट्रिंग में क्यों बदलते हैं? ( ''+)
— जकार्इ
@ Zacharý sortउत्परिवर्तनीय विधि है, जो सरणी को बदल देगी। पहले स्ट्रिंग में कनवर्ट करने से सरणी की एक प्रति बच जाएगी। स्ट्रिंग में परिवर्तित करना संदर्भ के बजाय (स्ट्रिंग) मान के बराबर संचालन कार्य करता है।
— tsh
4

सी # (.NET कोर) , 71 बाइट्स

i=>{for(int n=3;++n<i.Length;)if(i[n]>i[n-4])return false;return true;}

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

बोरिंग तरीका है। एक लीनियर ऐरे में चपटे इनपुट की अपेक्षा करता है।

वैकल्पिक रूप से स्पष्ट रूप से निषिद्ध तरीका:

i=>{for(int n=3;i[++n]<=i[n-4];);}

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

सही इंगित करने के लिए एक IndexOutOfBoundsException फेंकता है, सामान्य रूप से गलत इंगित करने के लिए समाप्त होता है। मैंने एक ऐसे संस्करण की कोशिश की, जिसमें अपवाद / सत्य / झूठ के अपवाद से रूपांतरण शामिल था, लेकिन यह नियमित संस्करण के रूप में लंबे समय तक समाप्त हो गया।

— कामिल दकरी
स्रोत
4

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

v=>!v.some((x,i)=>i%4&&x>v[i-1])

पहले कॉलम वाले एकल एरे में पास करके कॉल करें, उसके बाद दूसरा, तीसरा और 4 वां।

प्रत्येक कॉलम के पहले नंबर को छोड़कर प्रत्येक संख्या को पिछली संख्या की तुलना में करता है और यदि सभी सत्य हैं तो वापस लौटता है।

परीक्षा

f=v=>!v.some((x,i)=>i%4&&x>v[i-1])

f([16,8,4,2,0,0,0,0,64,32,32,0,8,8,2,0])
f([16,8,4,4,128,128,16,0,64,32,8,0,32,8,2,0])
f([16,8,32,2,0,0,0,0,64,32,128,0,8,16,2,0])
f([16,8,4,4,128,32,16,0,64,0,8,0,32,8,2,0])

संपादित करें: टीशर्ट के लिए धन्यवाद 2 बाइट्स सहेजे गए

— Grax32
स्रोत
कुछ बूलियन ट्रांसफ़ॉर्म के बाद:v=>!v.some((x,i)=>i%4&&x>v[i-1])
— tsh
3

हास्केल , 28 बाइट्स

all$and.(zipWith(>=)=<<tail)

वहाँ भी

all$(==)=<<sort

15 बाइट्स के साथ लेकिन इसे import Data.Listकेवल प्रील्यूड के साथ काम करने की आवश्यकता होती है । वैकल्पिक रूप से,

all$(==)=<<Data.List.sort

GHCI में 25 बाइट्स के साथ काम करता है।

— Bergi
स्रोत
3

गैया , 3 6 बाइट्स

+3 बाइट्स क्योंकि जाहिर तौर पर मुझे नहीं पता था कि मेरी भाषा कैसे काम करती है

ọ¦_ẏ⁇!

यह एक फ़ंक्शन है जो कॉलम की एक सूची को स्वीकार करता है और परिणाम को स्टैक पर छोड़ देता है।

कुछ अन्य 6 बाइट समाधान सहित मौजूद हैं 0+¦o¦ẏऔर ọ¦_ẏ¦ỵ।

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

व्याख्या

ọ¦      Deltas of each column
  _     Flatten
   ẏ⁇   Keep only positive numbers
     !  Negate (is it empty?)
— बिजनेस कैट
स्रोत
Downvote नहीं किया जा सकता है, लेकिन एक ऑपरेटर भाषा के बाद चुनौती पोस्ट किया गया निष्पक्ष यह के अनुसार डिफ़ॉल्ट रूप से मना किया जा रहा है me.Also प्रतीत नहीं होता है करने के लिए जोड़ा का उपयोग कर इस ।
— सिनेस्की
@Cinaski हम उस नियम से दूर चले गए हैं, जैसा कि यहाँ देखा गया है । किसी भी तरह से, मेरे वैकल्पिक समाधान केवल उन ऑपरेटरों का उपयोग करते हैं जो निश्चित रूप से चुनौती से पहले मौजूद थे।
— बिजनेस कैट
मैं इसे केवल उन अन्य लोगों में से एक में बदल दूँगा
— बिजनेस कैट
कोई बात नहीं, मुझे उस नए नियम की जानकारी नहीं थी।
— १४:
3

टीआई-बेसिक, 25 बाइट्स

Ans में 4x4 मैट्रिक्स के रूप में इनपुट लेता है।

For(R,1,3
*row+(-1,Ans,R+1,R
End
Ans=abs(Ans

व्याख्या

For(R,1,3             Loop from row 1 to 3.

*row+(-1,Ans,R+1,R    Multiply row R+1 by -1 and add it to row R in-place.
                      Effectively, this subtracts row R+1 from row R.

End                   Now the first 3 rows contain the row differences,
                      and the 4th row is non-negative assuming valid input.

Ans=abs(Ans           Check whether every element in the matrix is equal to its
                      absolute value, or in other words, contains no negative values.
— calc84maniac
स्रोत
2

हास्केल , 41 बाइट्स

f[x]=1>0
f(a:b:c)|a<b=1<0|1>0=f$b:c
all f

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

बिंदु-मुक्त फ़ंक्शन को परिभाषित करता है all f, जहां fयह निर्धारित करता है कि क्या कोई सूची सॉर्ट की गई है।

— गेहूं का जादूगर
स्रोत
डारन, यह 1 बाइट द्वारा पायथन को
— हराता है
@ हेपर न्युट्रीनो 21 तक xnor की धड़कन अजगर है।: पी
— गेहूं जादूगर
तुम भी परिभाषित कर सकते हैं fके रूप मेंf(a:b:c)=a>=b&&f(b:c)
— क्रिस्टियन Lupascu
2

जावास्क्रिप्ट (ईएस 6), 42 बाइट्स

स्तंभों की एक सरणी लेता है; (सत्य) नंबर देता है या false।

a=>a.every(c=>c.reduce((r,n)=>r&&n<=r&&n))

जावास्क्रिप्ट (ईएस 6), 54 47 बाइट्स

पहला प्रयास। स्तंभों की एक सरणी लेता है; रिटर्न trueया false।

a=>a.every(c=>c.slice(1).every((n,i)=>n<=c[i]))
— darrylyeo
स्रोत
खाली कोशिकाओं के लिए आप किस मूल्य की उम्मीद कर रहे हैं?
— अरनौलड
2

MATL , 4 बाइट्स

SGX=

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

पंक्तियों की एक सरणी के रूप में इनपुट, उल्टा।

S       % sort columns
GX=     % compare with input
        % true if arrays are numerically equal
        % (implicit) convert to string and display
— Cinaski
स्रोत
मामले हैं, जिनके truthy लौटना चाहिए जो की तरह स्तंभ तत्वों के बीच शून्य है के लिए काम नहीं करता इस उदाहरण के लिए।
— जोनाथन एलन
आप सही हैं, मैं एक समाधान पर काम कर रहा हूं। BTW मैं केवल एक खाली कोशिकाओं के साथ समस्या नहीं कर रहा हूँ;)
— Cinaski
हां, मैं उसे देखने में सक्षम हूं। मैंने इसके लिए एक टेस्ट केस भी सुझाया। पिंग जब तय हो गया है और आप मुझ से एक upvote मिलेगा :)
— जोनाथन एलन
@JonathanAllan प्रतीक्षा करें, जिन्होंने कहा था कि स्तंभ तत्वों के बीच शून्य होने पर इसे सच लौटना चाहिए? मेरे दूसरे झूठे परीक्षण के मामले को देखें, एक खाली सेल / एक 0 जिसके बाद उच्च मूल्य अमान्य होता है।
— DV02
@DirtyDev FYI मूल रूप से दिए गए शब्द और इसकी समझदार व्याख्या के साथ, आपका दूसरा गलत मामला अभी भी गलत होगा; यह सिर्फ मेरा सुझाया गया टेस्ट केस सत्य होगा।
— जोनाथन एलन
2

डायलॉग एपीएल, 21 19 15 बाइट्स

∧/{⍵≡⍵[⍒⍵]}¨↓⍉⎕

इसे ऑनलाइन आज़माएं! (संशोधित तो यह tryapl में चलेगा)

एक 2 डी सरणी के रूप में इनपुट लेता है।

कैसे?

  • ⎕ इनपुट
  • ⍉ पक्षांतरित
  • ↓ 2 डी सरणी => 1 डी वेक्टर के 1 डी वेक्टर
  • { ... }¨इसे प्रत्येक सदस्य (तर्क ⍵) पर लागू करें :
    • ⍵[⍒⍵] ⍵ अवरोही क्रमबद्ध
    • ⍵≡ के साथ समानता ⍵
  • ∧/चाहे हर तत्व हो 1।
— जाकारी
स्रोत
— अड्म
2

जाप , 7 बाइट्स

इस एक के लिए कुछ अलग तरीकों की कोशिश की, लेकिन अंत में, सबसे कम मैं टीएस के जेएस समाधान का एक बंदरगाह होने के साथ समाप्त हो सकता है।

इनपुट के रूप में कॉलम की एक सरणी लेता है। 0यदि स्तंभ में कोई अन्य संख्याएँ नहीं हैं, तो रिक्त कक्ष को छोड़ा या छोड़ा जा सकता है ।

P+U¥®n§

झसे आज़माओ

व्याख्या

सरणी का निहित इनपुट U।

P+U

Uखाली स्ट्रिंग के साथ आगे बढ़ें , सरणी को स्ट्रिंग में परिवर्तित करें।

¥

समानता के लिए जाँच करें, जो दाहिने हाथ की ओर एक स्ट्रिंग के लिए जाती है, भी।

®

नक्शा खत्म U।

n§

nद्वारा क्रमबद्ध ( ) <=।

अनुमानित रूप से आउटपुट बूलियन परिणाम।

— झबरा
स्रोत
दूसरी को छोड़ देने की अच्छी व्यवस्था U। आप nnअंत में भी कर सकते हैं;)
— ETHproductions
मुझे यह जानकर आश्चर्य हुआ कि Uइस मामले में काम करने वाले दूसरे को छोड़ कर , @ETHproductions; मुझे लगा कि यह तभी काम करेगा जब चर केवल बाईं ओर की चीज हो ==। मुझे इसे भविष्य में उपयोग के लिए याद रखना होगा।
— झबरा
1

जावा 8, 69 बाइट्स

b->{for(int[]c:b)for(int i=0,f=1;i<3;)if(c[i]<c[++i])f=0;return f>0;}

खैर, इस लेखन के रूप में यह स्विफ्ट समाधान धड़कता है, इसलिए ऐसा है! एकदम सीधा। इनपुट पूर्णांक सरणियों का एक सरणी है, आंतरिक सरणियों को बोर्ड के स्तंभ (ऊपरी वर्ग पहले)। कास्ट किया Function<int[][], Boolean>।

— जेकब
स्रोत
1

मेरा , 66 62 20 बाइट्स (नॉनकमेटिंग)

ω⍉ω⍉A6ǵ'ƒ⇹(E8ǵ'ƒ⇹(Π←

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

यह गैर-प्रतिस्पर्धात्मक कारण है कि मैंने हाल ही में लागू किया है 8E (≡), जो एपीएल के बराबर है ≡।

कैसे?

  • ω⍉ पहली कमांड लाइन तर्क को ट्रांसपोज़ किया गया
  • ω⍉ पहली कमांड लाइन तर्क को ट्रांसपोज़ किया गया
  • A6ǵ'धक्का chr(0x6A)( ⍖कोडपेज में, जो नीचे उतरता है)
  • ƒ एक स्ट्रिंग के बजाय एक फ़ंक्शन के रूप में
  • ⇹ एक फ़ंक्शन को पुश करें जो प्रत्येक तर्क पर एक पॉपअप फ़ंक्शन को मैप करता है
  • ( लागू करें
  • E8ǵ'ƒ⇹( एक ही बात, को छोड़कर chr(0x8E), जो मैच कमांड ( ≡) है।
  • Π उत्पाद
  • ← कोई नई रेखा के साथ उत्पादन

हां, MY के बहुत सारे प्रतीक एपीएल के समान या समान हैं। स्पष्टीकरण यह है कि वे दिमाग में आए जब मुझे 1-चरित्र कमांड चाहिए था। (मुझे नहीं पता कि मैं टी का उपयोग क्यों नहीं करता था )

— जाकारी
स्रोत
0

गणितज्ञ, 27 बाइट्स

t=Thread;-t[Sort/@-t@#]==#&

स्पष्टीकरण:

  • Threadएक अजीब सामान्य ट्रांसपोज़ जैसा ऑपरेशन है जो मैट्रिक्स दिए जाने पर ट्रांज़ोज़ लेने के लिए होता है ।
  • t=Thread;मुझे बाइट्स को बचाने के लिए दो tबार के बजाय दो बार उपयोग करने देता है Thread।
  • Sort एक सूची क्रमबद्ध करें (बढ़ते क्रम में)।
  • Sort\@Sortव्यक्तिगत रूप से किसी सूची के प्रत्येक तत्व के लिए फ़ंक्शन को मैप करता है; जब एक मैट्रिक्स पर लागू किया जाता है, तो यह पंक्तियों को सॉर्ट करता है।
  • t@##मुख्य फ़ंक्शन के इनपुट में ट्रांसपोज़ फ़ंक्शन को लागू करता है।
  • - सभी प्रविष्टियों की नकारात्मक लेता है ताकि ट्रांसपोज़्ड मैट्रिक्स (मूल के कॉलम) की पंक्तियों को सॉर्ट करना उन्हें वांछित तरीके से सॉर्ट करें।
  • बाहरी -t[...]नकारात्मक और परिवर्तन को पूर्ववत् करता है, इसलिए हमने वास्तव में सबसे बड़े-से-छोटे स्तंभों को छाँटा था।
  • ==# यह देखने के लिए परीक्षण करता है कि क्या यह नया कॉलम-सॉर्ट किया गया मैट्रिक्स मूल इनपुट के बराबर है।
  • &#हमारे द्वारा परिभाषित इनपुट के साथ अनाम फ़ंक्शन को समाप्त करता है।

आप निम्न और क्लिक गियर की तरह कोड चिपकाकर वुल्फराम क्लाउड सैंडबॉक्स में इसे ऑनलाइन आज़मा सकते हैं -> "सेल का मूल्यांकन करें" या Shift + Enter या numpad को दबाकर दर्ज करें:

t=Thread;-t[Sort/@-t@#]==#&@{{16,128,64,32},{8,32,0,8},{4,16,8,2},{4,0,0,0}}

या सभी परीक्षण मामलों के लिए:

t=Thread;-t[Sort/@-t@#]==#&//Map[#,{{{16,0,64,8},{8,0,32,8},{4,0,32,2},{2,0,0,0}},{{16,128,64,32},{8,128,32,8},{4,16,8,2},{4,0,0,0}},{{16,0,64,8},{8,0,32,16},{32,0,128,2},{2,0,0,0}},{{16,128,64,32},{8,32,0,8},{4,16,8,2},{4,0,0,0}}}]&
— निशान।
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.