बिटस्ट्रिंग भौतिकी

Question

पृष्ठभूमि

हां, बिटस्ट्रिंग भौतिकी एक वास्तविक चीज है । यह विचार भौतिकी के एक नए सिद्धांत का निर्माण करने के लिए है, केवल एक बिट के तार का उपयोग करके जो एक संभाव्य नियम के तहत विकसित होता है ... या कुछ और। इसके बारे में कुछ कागजात पढ़ने के बावजूद, मैं अभी भी बहुत उलझन में हूँ। हालांकि, बिटस्ट्रिंग ब्रह्मांड एक अच्छा सा कोड गोल्फ बनाता है।

प्रोग्राम यूनिवर्स

बिटस्ट्रिंग भौतिकी एक तथाकथित कार्यक्रम ब्रह्मांड में होती है । ब्रह्मांड के विकास के प्रत्येक चरण में, Lकुछ लंबाई के बिटस्ट्रिंग्स की एक सीमित सूची है k, [10,11]जहां दो-तत्व सूची के साथ शुरू होता है k = 2। एक टाइमस्टेप को निम्नानुसार संसाधित किया जाता है (पायथन-जैसे स्यूडोकोड में)।

A := random element of L
B := random element of L
if A == B:
    for each C in L:
        append a random bit to C
else:
    append the bitwise XOR of A and B to L

सभी यादृच्छिक विकल्प समान रूप से यादृच्छिक और एक दूसरे से स्वतंत्र होते हैं।

उदाहरण

4 चरणों का एक उदाहरण विकास निम्नलिखित की तरह लग सकता है। प्रारंभिक सूची से शुरू करें L:

10
11

हम यादृच्छिक रूप से चुनते हैं A := 10और B := 10, जो एक ही पंक्ति हैं, जिसका अर्थ है कि हमें प्रत्येक स्ट्रिंग को Lयादृच्छिक बिट के साथ विस्तारित करने की आवश्यकता है :

101
110

अगला, हम चुनते हैं A := 101और B := 110, क्योंकि वे समान नहीं हैं, हम उनके XOR को इसमें जोड़ते हैं L:

101
110
011

फिर, हम चुनें A := 011और B := 110, और फिर से उनके XOR संलग्न:

101
110
011
101

अंत में, हम चुनते हैं A := 101(अंतिम पंक्ति) और B := 101(पहली पंक्ति), जो बराबर हैं, इसलिए हम यादृच्छिक बिट्स के साथ विस्तार करते हैं:

1010
1100
0111
1010

काम

आपका काम tइनपुट के रूप में एक नॉनवेजेटिव पूर्णांक लेना है , tटाइमस्टेप्स के लिए प्रोग्राम ब्रह्मांड का अनुकरण करें , और परिणामी सूची को वापस करें या प्रिंट करें L। ध्यान दें कि t = 0प्रारंभिक सूची में परिणाम [10,11]। आप Lपूर्णांकों की सूची, बूलियन मूल्यों की सूची या तार की सूची के रूप में आउटपुट कर सकते हैं; यदि आउटपुट STDOUT में जाता है, तो आप कुछ उचित प्रारूप में बिटस्ट्रिंग्स को प्रति पंक्ति एक प्रिंट कर सकते हैं। बिटस्ट्रिंग्स का क्रम महत्वपूर्ण है; विशेष रूप से, प्रारंभिक सूची नहीं किया जा सकता [11,10], [01,11]या ऐसा कुछ। दोनों फ़ंक्शन और पूर्ण कार्यक्रम स्वीकार्य हैं, मानक खामियों को अस्वीकार कर दिया जाता है, और सबसे कम बाइट गिनती जीतती है।

Comments

क्या हम बिट स्ट्रिंग की लंबाई को सीमित कर सकते हैं (अर्थात: क्या मैं 32 बिट संख्या और बिट संचालन का उपयोग कर सकता हूं)?

— edc65

@ edc65 नहीं, स्ट्रिंग्स की लंबाई मनमाने ढंग से उच्च हो सकती है।

— जर्गब

@ edc65 32 से अधिक बिट्स प्राप्त करने के लिए अपेक्षित समय और मेमोरी की आवश्यकताएं खगोलीय हैं, लेकिन यह तब से ठीक है जब से हम एक ब्रह्मांड का अनुकरण कर रहे हैं। ;)

— जर्बद

क्या यह बिट-स्ट्रिंग फिजिक्स एक क्रिप्टो आइडिया है? मैंने पूरे कागज को नहीं पढ़ा है, लेकिन वाक्यांश हमने बिट-स्ट्रिंग भौतिकी का उपयोग किया है ताकि एक सिद्धांत प्रदान किया जा सके जिसमें सन्निकटन hbar c / e2 = 22 - 1 + 23 - 1 + 27 - 1 = 137 का अर्थ समझ में आता है एक कंप्यूटर एल्गोरिथ्म और सूचना सिद्धांत मुझे एक बिट के रूप में ... संख्यात्मक।

— xebtl

@xebtl यह मुझे भी पागल लगता है। मुझे याद है कि कहीं-कहीं एल्गोरिदम का औचित्य पढ़ना है, और यह भौतिकी की तुलना में खराब छद्म-दर्शन की तरह लग रहा था। इसके अलावा, एल्गोरिथ्म का आपका वर्णन मेरे संस्करण से मेल खाता है, हो सकता है कि मैं आपको किसी तरह से गलत समझ रहा हूं।

— जर्गब

Answer 1

पायथ, 27 26 बाइट्स

u?+RO2GqFKmOG2aGxVFKQ*]1U2

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

                              implicit: Q = input number
                     *]1U2    the initial list [[1,0], [1,1]]
u                   Q         reduce, apply the following expression Q times to G = ^
          mOG2                  take two random elements of G
         K                      store in K
       qF                       check if they are equal
 ?                              if they are equal:
  +RO2G                           append randomly a 0 or 1 to each element of G
                                else:
              aG                  append to G
                xVFK              the xor of the elements in K

Comments

xVFKके बराबर है xMK।

— ईसैक

@isaacg नहीं, समान बाइट काउंट के xVFKबराबर है xMCK।

— जकुबे

Answer 2

CJam, 42 40 38 37 बाइट्स

Sp3000 द्वारा 1 बाइट बचाई गई।

B2b2/q~{:L_]:mR_~#L@~.^a+L{2mr+}%?}*p

व्याख्या

आधार -2 नंबर के रूप में प्रारंभिक स्थिति बनाएं:

B2b e# Push the the binary representation of 11: [1 0 1 1]
2/  e# Split into chunks of 2 to get [[1 0] [1 1]]

और फिर मुख्य लूप का प्रदर्शन करें और परिणाम को अंत में प्रिंट करें:

q~       e# Read and eval input t.
{        e# Run this block t times.
  :L     e#   Store the current universe in L.
  _]     e#   Copy it and wrap both copies in an array.
  :mR    e#   Pick a random element from each copy.
  _~     e#   Duplicate those two elements, and unwrap them.
  #      e#   Find the second element in the first. If they are equal, it will be found at
         e#   index 0, being falsy. If they are unequal, it will not be found, giving
         e#   -1, which is truthy.

         e#   We'll now compute both possible universes for the next step and then select
         e#   the right one based on this index. First, we'll build the one where they were
         e#   not equal.

  L@~    e#   Push L, pull up the other copy of the selected elements and unwrap it.
  .^     e#   Take the bitwise XOR.
  a+     e#   Append this element to L.

  L      e#   Push L again.
  {      e#   Map this block onto the elements in L.
    2mr+ e#     Append 0 or 1 at random. 
  }%     
  ?      e#   Select the correct follow-up universe.
}*
p        e# Pretty-print the final universe.

इसका परीक्षण यहां करें।

Answer 3

जूलिया, 141 129 बाइट्स

t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A=L[rand(r)];B=L[rand(r)];A==B?for j=r L[j]=[L[j],rand(0:1)]end:push!(L,A$B)end;L)

कुछ भी चालाक नहीं। एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को इनपुट के रूप में स्वीकार करता है और सरणियों की एक सरणी देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=t->...।

असंगठित + स्पष्टीकरण:

function f(t)
    # Start with L0
    L = Any[[1,0], [1,1]]

    # Repeat for t steps
    for i = 1:t
        # Store the range of the indices of L
        r = 1:length(L)

        # Select 2 random elements
        A = L[rand(r)]
        B = L[rand(r)]

        if A == B
            # Append a random bit to each element of L
            for j = r
                L[j] = [L[j], rand(0:1)]
            end
        else
            # Append the XOR of A and B to L
            push!(L, A $ B)
        end
    end

    # Return the updated list
    L
end

उदाहरण:

julia> f(4)
4-element Array{Any,1}:
 [1,0,1,0]
 [1,1,1,1]
 [0,1,1,0]
 [0,1,0,0]

julia> f(3)
3-element Array{Any,1}:
 [1,0,1,1]
 [1,1,1,0]
 [0,1,0,1]

एमएल को धन्यवाद दिया 12 बाइट्स बचाए!

Comments

आप इसे 133 अक्षरों में बदल सकते हैं यदि आप ternay ऑपरेटर का उपयोग करते हैं, तो इसके बजाय / और यदि आप बदलते हैं A=something;B=something else to A,B=something,something else:t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A,B=L[rand(r)],L[rand(r)];A==B?(for j=r L[j]=[L[j],rand(0:1)]end):(push!(L,A$B))end;L)

— ML

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

— एलेक्स ए।

आपका स्वागत है। ओह समझा। हां, कोष्ठक आवश्यक नहीं हैं।

— एमएल

Answer 4

अजगर 2, 141

मैंने कुछ अलग तरीके आजमाए, लेकिन मुझे जो सबसे अच्छा मिला वह अपेक्षाकृत सीधा था। 15 वर्णों के लिए @ Sp3000 या तो धन्यवाद (और मुझे अस्तित्व के बारे में सिखाने के लिए int.__xor__)।

from random import*
L=[[1,0],[1,1]];C=choice
exec"A=C(L);B=C(L);L=[L+[map(int.__xor__,A,B)],[x+[C([1,0])]for x in L]][A==B];"*input()
print L

Comments

यहाँ 141: लिंक है

— Sp3000

Answer 5

अजगर 2, 127 122

फार्म '0b1'आदि के अजगर बिट स्ट्रिंग मान रहे हैं:

from random import*
C=choice
L=[2,3]
exec"x=C(L)^C(L);L=L+[x]if x else[a*2+C([0,1])for a in L];"*input()
print map(bin,L)

यहाँ केवल हल्के बारीकियों का उपयोग इस तथ्य का उपयोग है कि XOR (A, B) = 0 iff A = B।

संलग्नक forलूप को छोटा करने के लिए @ Sp300 का धन्यवाद

Comments

टिप्पणियों पर एक नज़र डालते हुए, मुझे लगता है कि प्रमुख शून्य को संरक्षित करने की आवश्यकता है

— Sp3000

मैं अभी इस जवाब का परीक्षण नहीं कर सकता, लेकिन अगर यह अग्रणी शून्य को संरक्षित नहीं करता है, तो यह दुर्भाग्य से गलत है।

— जर्गब

Answer 6

अजगर, ३४

u?+RO`TGqJOGKOG+Gsm`s!dqVJKQ[`T`11

प्रत्येक पुनरावृत्ति को लागू करने के लिए उपयोग कम करता है। मैं समझाता हूँ जब मैं गोल्फ कर रहा हूँ।

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

Answer 7

के, 46 53 46 बाइट्स

{x{:[~/t:2?x;{x,*1?2}'x;x,,,/~=/t]}/(1 0;1 1)}

आकार का एक अच्छा हिस्सा (लगभग 7 बाइट्स) इस तथ्य के लिए है कि के के पास कोई xorऑपरेटर नहीं है, इसलिए मुझे खुद को लागू करना पड़ा। मूल रूप से, मैंने स्ट्रिंग्स की एक सूची का उपयोग किया, इसके बाद एहसास हुआ कि यह पागलपनपूर्ण था। तो अब मैं फिर से 7 बाइट्स काट देता हूँ!

पहले:

{x{:[~/t:2?x;{x,*$1?2}'x;x,,,/$~=/(0$')'t]}/$:'10 11}

@ जॉन ने टिप्पणियों में बताया कि प्रारंभिक स्थिति को हार्डकोड किया जाना था, जिसकी लागत 7 अतिरिक्त बाइट्स थी। : /

Comments

समस्या युक्ति के बारे में मेरा पठन यह है कि आपको हमेशा हार्डकोड "ब्रह्मांड" से शुरू करना चाहिए (1 0;1 1)- आपका प्रोग्राम इसे इनपुट के रूप में स्वीकार करता है।

— जॉनई

@ जॉन तय। हालाँकि, इसमें कोई गारंटी नहीं है कि यह काम करेगा क्योंकि मैंने परिवर्तनों का परीक्षण नहीं किया था; मैंने आपके

— ओके उत्तर

के रूप में अच्छी तरह से काम करने के लिए लगता है Kona।

— जॉनई

Answer 8

जावास्क्रिप्ट ( ईएस 6 ) 152

एक फ़ंक्शन, स्ट्रिंग्स का उपयोग करना (संख्याओं के साथ यह कम होना चाहिए, लेकिन जावास्क्रिप्ट बिट संचालन में 32 बिट पूर्णांक तक सीमित हैं)।

नीचे दिए गए स्निपेट का उपयोग करके फ़ायरफ़ॉक्स में टेस्ट करें।

F=(t,L=['10','11'],l=2,R=n=>Math.random()*n|0,a=L[R(l)],b=L[R(l)])=>
   t--?a==b
     ?F(t,L.map(x=>x+R(2)),l)
     :F(t,L,L.push([...a].map((x,p)=>x^b[p]).join('')))
  :L
  
test=_=>O.innerHTML=F(+I.value).join('\n')

#I{width:3em}

<input id=I value=10><button onclick=test()>-></button><pre id=O></pre>

Answer 9

के, 45 41 38 बाइट्स

{x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}

मेरे उत्तर की संरचना काफी हद तक @ kirbyfan64sos से मिलती-जुलती है, लेकिन स्ट्रिंग्स के बजाय मैंने 1/0 वैक्टर का इस्तेमाल किया और मैं :[ ; ; ]सूची में शामिल करने के बजाय सशर्त ( ) की आवश्यकता से बचता हूं ।

कुछ रन:

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0 0
 1 1 1 1
 0 1 1 1)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 0 0)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 1 0)

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

प्रारंभिक ब्रह्मांड के निर्माण के लिए अधिक कॉम्पैक्ट तरीके से चार बाइट्स सहेजे गए:

1,'!2     / new
(1 0;1 1) / old

EDIT2:

मैं भूल गया कि "चयन" एक सूची को उसके सही तर्क के रूप में ले सकता है:

  2?"abcd"
"dc"
  2?"abcd"
"cc"
  2?"abcd"
"ca"

इसलिए मैं इसका हिस्सा आसान कर सकता हूं। क्रेडिट जहां इसकी वजह है, इससे पहले किर्बी को यह ट्रिक मिली।

2?x    / new
x@2?#x / old

Comments

डांग, कभी-कभी मुझे लगता है कि मैं के को जानता हूं, फिर मैं आपके जवाब देखता हूं ...: ओ

— kirbyfan64sos

मुझे लगता है कि यह समाधान निश्चित रूप से एक टीम प्रयास के रूप में गिना जाता है!

— जॉनई

Answer 10

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

यह लंबे समय की तरह है।

a=[[1,0],[1,1]];for(b=prompt();b--;)if(c=a.length,d=a[c*Math.random()|0],e=a[c*Math.random()|0],d+""==e+"")for(f=0;f<c;f++)a[f].push(2*Math.random()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}alert(a.join("\n"));

Comments

क्लोजर कंपाइलर ने इसे 8 बाइट बचाकर कंप्रेस्ड किया।

— गुस्तावो रोड्रिग्स

216 बाइट्स:, for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{for(h=0,g=[];h<d.length;)g.push(d[h]^e[h++]);a.push(g)}}alert(a.join("\n"))समय का वांछित आउटपुट 3/5 पैदा करता है।

— इस्माईल मिगुएल

217 बाइट्स:, for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}}alert(a.join("\n"))समय का 90% काम करता है।

— इस्माईल मिगुएल

Answer 11

टी-एसक्यूएल (2012+), 1019

मुझे वास्तव में खेद है कि यह प्रतिस्पर्धी के पास कहीं नहीं है, लेकिन ईमानदार होने के लिए मुझे नहीं लगा कि मुझे यह काम करने के लिए मिल सकता है और मुझे एक बार इसे पोस्ट करना होगा। मैंने इसे थोड़ा सा गोल्फ करने की कोशिश की :)

बाइनरी / पूर्णांक रूपांतरणों को संभालने के लिए मुझे स्केलर फ़ंक्शंस (बाइट्स के 513) का एक जोड़ा बनाना था। Aपूर्णांक से थोड़ा स्ट्रिंग में जाता है। Bउल्टा करता है।

CREATE FUNCTION A(@ BIGINT)RETURNS VARCHAR(MAX)AS
BEGIN
DECLARE @S VARCHAR(MAX);
WITH R AS(SELECT @/2D,CAST(@%2 AS VARCHAR(MAX))M
UNION ALL
SELECT D/2,CAST(D%2 AS VARCHAR(MAX))+M
FROM R
WHERE D>0)SELECT @S=M FROM R WHERE D=0
RETURN @S
END
CREATE FUNCTION B(@ VARCHAR(MAX))RETURNS BIGINT AS
BEGIN
DECLARE @I BIGINT;
WITH R AS(SELECT CAST(RIGHT(@,1)AS BIGINT)I,1N,LEFT(@,LEN(@)-1)S
UNION ALL 
SELECT CAST(RIGHT(S,1)AS BIGINT)*POWER(2,N),N+1,LEFT(S,LEN(S)-1)
FROM R
WHERE S<>''
)SELECT @I=SUM(I)FROM R
RETURN @I
END

फिर प्रक्रिया है। @Cचरणों की संख्या है

DECLARE @C INT=9
DECLARE @ TABLE(S VARCHAR(MAX))
DECLARE @R VARCHAR(MAX)
INSERT @ VALUES('10'),('11')
WHILE(@C>=0)
BEGIN
SET @C-=1
SELECT @R=CASE WHEN MAX(S)=MIN(S)THEN''ELSE RIGHT(REPLICATE('0',99)+dbo.A(dbo.B(MAX(S))^dbo.B(MIN(S))),LEN(MAX(S)))END
FROM(SELECT TOP 2S,ROW_NUMBER()OVER(ORDER BY(SELECT\))N FROM @,(VALUES(1),(1),(1))D(D)ORDER BY RAND(CAST(NEWID()AS VARBINARY(50))))A
IF @R=''UPDATE @ SET S=CONCAT(S,ROUND(RAND(CAST(NEWID() AS VARBINARY(50))),0))
ELSE INSERT @ VALUES(@R)
END
SELECT * FROM @

दस हजार पुनरावृत्तियों में लगभग 2 मिनट लगे और 9991 पंक्तियाँ वापस आ गईं

1001001100110
1101001001110
0111100100101
1111100001011
1111001010011
0110101001101
...
1110101000100
1111011101100
1100001100010
0110010001001
1110100010100

Answer 12

पायथ - 37 बाइट्स

जाहिर है, बस psuedocode का अनुसरण करता है। शायद बहुत कुछ गोल्फ कर सकता है।

KPP^,1Z2VQ=K?m+dO1KqFJ,OKOKaKxVhJeJ;K

इसे यहाँ ऑनलाइन प्रयास करें ।

Comments

आप की जरूरत O2के बजाय O1। O1आप सीमा से एक यादृच्छिक संख्या देता हैU1 = [0] ।

— जकुबे

तो तुम हमेशा एक appending रहे हैं 0।

— जकुबे

Answer 13

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

Nest[If[Equal@@#,Map[#~Append~RandomInteger[]&],Append[BitXor@@#]]&[#~RandomChoice~2]@#&,{{1,0},{1,1}},#]&

Answer 14

पर्ल, 102

#!perl -p
@l=qw(10 11);$_=$l[rand@l]^$l[rand@l],$_|=y//0/cr,@l=/1/?(@l,$_):map{$_.~~rand 2}@l for 1..$_;$_="@l"

मुझे आजमाओ ।

Answer 15

आर, 186

L=list(0:1,c(1,1))
if(t>0)for(t in 1:t){A=sample(L,1)[[1]]
B=sample(L,1)[[1]]
if(all(A==B)){L=lapply(L,append,sample(0:1, 1))}else{L=c(L,list(as.numeric(xor(A,B))))}}
L

यहां कुछ भी जादुई नहीं है। tR कंसोल में मान दर्ज करें और स्क्रिप्ट चलाएँ। यह "गोल्फ" आर कोड के लिए कठिन है, लेकिन यहां एक अधिक पठनीय संस्करण है:

L <- list(0:1, c(1, 1))
if(t > 0) {
  for(t in 1:t) {
    A <- sample(L, 1)[[1]]
    B <- sample(L, 1)[[1]]
    if (all(A == B)) {
      L <- lapply(L, append, sample(0:1, 1))
    } else {
      L <- c(L,list(as.numeric(xor(A, B))))
    }
  }
}
L

Comments

आप sampleएक चर को असाइन करके कई वर्णों को सहेज सकते हैं । उदाहरण के लिए s=sample, फिर नमूने के बजाय एस का उपयोग करें। दुर्भाग्य से मुझे लगता lapplyहै कि सूची में सभी वस्तुओं में एक यादृच्छिक नमूना जोड़े जाने के साथ एक यादृच्छिक बिट को जोड़ने की आपकी विधि समाप्त हो जाएगी। lapply(L,function(x)append(x,sample(0:1,1)))काम करने के लिए प्रकट होता है, लेकिन एक कीमत पर। आप उसे बदल सकते हैं जिसके as.numericसाथ 1*कुछ वापस मिलना चाहिए।

— मिकट

दोनों बिंदुओं पर अच्छी पकड़ है, और एक अच्छा जबरदस्त चाल भी है

— शैडोअल्कर

इसके अलावा सिर्फ देखा कि आपकी गिनती बाहर है। मैं इसे 168 का उपयोग करते हुए इस

— MickyT

Answer 16

रूबी, 82

बहुत सीधे-सीधे बहुत आगे। अन्य गैर-गोल्फ भाषाओं की तुलना में, रूबी अपने बड़े मानक पुस्तकालय के साथ अच्छा करती है।

->t{l=[2,3]
t.times{a,b=l.sample 2
a.equal?(b)?l.map!{|x|x*2+rand(2)}:l<<(a^b)}
l}

नमूना उत्पादन के लिए t = 101010:

[9, 15, 6, 13, 5, 12, 10, 11, 5, 4, 15, 13, 2, 7, 11, 9, 3, 3, 8, 6, 3, 13, 13, 12, 10, 9, 2, 4, 14, 9, 9, 14, 15, 7, 10, 4, 10, 14, 13, 7, 15, 7]