हाल ही में मैंने डिफी गेम्स के बारे में एक सवाल पोस्ट किया है जो अनुत्तरित हो गया है। यह ठीक है, यह सवाल वास्तव में कठिन है, लेकिन मैं डिफी के खेल के बारे में एक आसान सवाल करना चाहूंगा ताकि हम गेंद को घुमा सकें।

कैसे काम करता है

फाइंड डिफिटी गेम्स से नकल की

डिफ्फी गेम इस प्रकार काम करता है: आप गैर-नकारात्मक पूर्णांकों की सूची से शुरू करते हैं, इस उदाहरण में हम उपयोग करेंगे

3 4 5 8

फिर आप आसन्न संख्याओं के बीच पूर्ण अंतर लेते हैं

 (8)  3   4   5   8
    5   1   1   3

फिर आप दोहराते हैं। आप तब तक दोहराते हैं जब तक आपको एहसास नहीं हो जाता है कि आपने लूप में प्रवेश किया है। और फिर आम तौर पर खेल शुरू से फिर से शुरू होता है।

अधिकांश खेल सभी शून्य के एक तार में समाप्त होते हैं, जिसे एक खो राज्य माना जाता है, लेकिन एक दुर्लभ कुछ खेल बड़े छोरों में फंस जाते हैं।

कार्य

एक डिफई गेम की शुरुआती स्थिति को देखते हुए यह निर्धारित किया जाता है कि गेम अंततः सभी शून्य की स्थिति तक पहुंचता है या नहीं। आपको दो राज्यों में से प्रत्येक के लिए एक ट्रू या फाल्सी मूल्य का उत्पादन करना चाहिए। जो मेल खाती है जिससे कोई फर्क नहीं पड़ता।

लक्ष्य अपने स्रोत में बाइट्स की संख्या को कम करना है।

— गेहूं का जादूगर
स्रोत

1

कार्य शब्द का अर्थ लगता है कि कोई भी खेल जो सभी शून्य की स्थिति तक नहीं पहुंचता है, इसलिए आवधिक है। इससे पहले, आवधिक को दोहराए गए अनुक्रम में प्रारंभिक अवस्था सहित परिभाषित किया गया है। क्या इसका मतलब यह है कि कोई भी क्रम अंततः सभी शून्य या प्रारंभिक अवस्था तक पहुँच जाता है?

— ट्राइकोप्लाक्स

3

नहीं: किसी भी गैर-आवधिक राज्य के परिणाम में एक सकारात्मक निरंतरता जोड़ना एक ऐसी स्थिति है जो न तो स्वयं वापस आती है और न ही सभी शून्य पर जाती है। उदाहरण के लिए, 1 1 0आवधिक है, इसलिए 42 42 41ऐसी स्थिति है।

— ग्रेग मार्टिन

3

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

— ग्रेग मार्टिन

2

मैंने एक आंशिक लक्षण वर्णन साबित किया है: यदि सूची की लंबाई nविषम है, तो खेल शून्य तक नहीं जाता है जब तक कि सभी संख्याएं समान न हों। यदि लंबाई 2 की शक्ति है, तो यह हमेशा शून्य हो जाती है।

— xnor

3

शून्य तक पहुंचने के लिए कई चरणों की एक सीमा: nतत्वों और अधिकतम के साथ एक सूची mअधिकांश n * bit_length(m)चरणों में होती है। तो, n*mयह भी एक ऊपरी बाध्य है। एक मजबूत ऊपरी सीमा है t(n) * bit_length(m), जहां t(n)2 की सबसे बड़ी शक्ति है जो इसका एक कारक है n।

— xnor

27

अजगर, 6 बाइट्स

suaV+e

परीक्षण सूट

यह कार्यक्रम बहुत ही सराहनीय है। 0 (मिथ्या) का अर्थ है सभी शून्य, कुछ और (सत्य) का अर्थ है सभी शून्य नहीं।

यह काम किस प्रकार करता है:

suaV+e
suaV+eGGGQ    Variable introduction.
 u       Q    Apply the following function repeatedly to its previous result,
              starting with the input. Stop when a value occurs which has
              occurred before.
  aV          Take the absolute differences between elements at the same indices of
        G     The previous list and
    +eGG      The previous list with its last element prepended.
s             The repeated value is returned. Sum its entries. This is zero (falsy)
              if and only if the entries are all zero.

— isaacg
स्रोत

6

thats एक सौम्य समाधान

— मार्टिन Vissers

14

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

1>Max@Nest[Abs[#-RotateLeft@#]&,#,Max[1+#]^Tr[1^#]]&

शुद्ध समारोह इनपुट और लौटने के रूप में गैर नकारात्मक पूर्णांकों की एक सूची ले रही है Trueया False।

Abs[#-RotateLeft@#]&एक ऐसा फंक्शन है जो डिफरेंट गेम के एक राउंड को अंजाम देता है। (तकनीकी रूप से यह होना चाहिए RotateRight, लेकिन अंतिम उत्तर अप्रभावित है, और हे, मुफ्त बाइट।) इसलिए Nest[...,#,R]निष्पादित करता हैR डिफरेंट गेम के दौर को , और फिर 1>Max@पता लगाता है कि क्या परिणाम सभी शून्य है।

हमें कैसे पता चलेगा कि कितने अलग-अलग गेम राउंड Rकरने हैं? यदि mइनपुट में सबसे बड़ा मूल्य है, तो ध्यान दें कि हम कभी भी पूर्णांक का उत्पादन नहीं करेंगे mचाहे हम कितने भी राउंड करें। lसभी द्वारा विभाजित किए गए गैर-पूर्णांक की लंबाई की सूची की कुल संख्या mहै (m+1)^l। इसलिए यदि हम (m+1)^lडिफरेंट गेम के दौर को अंजाम देते हैं, तो हम गारंटी देते हैं कि तब तक दो बार कुछ सूची देखी जा सकती है, और इस तरह यह गेम के आवधिक भाग में होगा। विशेष रूप से, खेल सभी शून्य में समाप्त होता है यदि और केवल अगर (m+1)^lखेल के राउंड का परिणाम सभी शून्य सूची है। वह अभिव्यक्ति है जो Max[1+#]^Tr[1^#]गणना करती है।

— ग्रेग मार्टिन
स्रोत

6

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

Ṁ‘*L
ṙ1ạ
ÇÑ¡Ṁ

आउटपुट 0 (फाल्सी) यदि सभी शून्य स्थिति तक पहुंच जाएगा, अन्यथा एक सत्य मान (एक सकारात्मक पूर्णांक) वापस आ जाता है।

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

पहले ग्रेग मार्टिन द्वारा किए गए अवलोकन का उपयोग करता है कि सरणी के भीतर संख्या कभी भी डोमेन को नहीं छोड़ सकती [0, m] जहां m इनपुट में अधिकतम तत्व है, इसलिए प्रदर्शन (m + 1) ^l राउंड जहां l इनपुट की लंबाई होगी पर्याप्त।

कैसे?

Ṁ‘*L - Link 1, number of rounds to perform: list a
Ṁ    - maximum of a
 ‘   - incremented
   L - length of a
  *  - exponentiate

ṙ1ạ - Link 2, perform a round: list x
ṙ1  - rotate x left by 1
  ạ - absolute difference (vectorises) with x

ÇÑ¡Ṁ - Main link: list a
  ¡  - repeat:
Ç    -     the last link (2) as a monad
 Ñ   -     the next link (1) as a monad times
   Ṁ - return the maximum of the resulting list

— जोनाथन एलन
स्रोत

यह xnor बाध्य के साथ सुधार किया जा सकता है ?

— गेहूं जादूगर

@HeatWizard मुझे लगता है कि यह एक बाइट खर्च होगा। (जब तक वे अद्वितीय नहीं हैं, तब तक सभी परिणाम एकत्र करके एक छोटी विधि प्राप्त करना संभव हो सकता है, लेकिन मुझे यह नहीं मिला है)।

— जोनाथन एलन

2

PHP, 144 बाइट्स

सभी शून्य और सच्चे के लिए किसी भी पूर्णांक मान के लिए 0 प्रिंट करें

<?for($r[]=$_GET[0];!$t;){$e=end($r);$e[]=$e[$c=0];for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]);$t=in_array($n,$r);$r[]=$n;}echo max($n);

ऑनलाइन संस्करण

विस्तारित

for($r[]=$_GET;!$t;){
    $e=end($r);  # copy last array
    $e[]=$e[$c=0]; # add the first item as last item
    for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]); # make new array
    $t=in_array($n,$r); # is new array in result array
    $r[]=$n; # add the new array
}
echo max($n); # Output max of last array

— जार्ग हुल्सरमैन
स्रोत

1

array_push? पर क्यों ?

— क्रिस्टोफ

1

$_GETइनपुट के रूप में उपयोग करने पर भी आपको यह मान लेना चाहिए कि इसमें एक स्ट्रिंग है।

— क्रिस्टोफ़

1

@Christoph ?0[0]=1&0[1]=1&0[2]=0या ?0[]=1&0[]=1&0[]=0स्ट्रिंग्स की एक सरणी है लेकिन यह कोई फर्क नहीं पड़ता। लेकिन आप सही हैं कि मैं इसे छोटा ?0=1&1=1&2=0नहीं कर सका, क्योंकि मुझे यकीन नहीं है कि आपको या टाइटस को इसे कम करने के बेहतर तरीके मिलेंगे।

— जोर्ग हल्सरमन

1

array_push($e,$e[$c=0]);बस के रूप में बिल्कुल वैसा ही है $e[]=$e[$c=0];और आप पहले से ही वाक्यविन्यास का उपयोग करते हैं ( $r[]=$n)। आप पहले से ही उपयोग करते हैं maxअब तो आप भी बदलना चाहिए end($r)साथ $nक्योंकि $nहै हमेशा के बराबर end($r)जब गूंज निष्पादित किया जाता है।

— क्रिस्टोफ़

@Christoph ऐसा लगता है कि कल मेरा दिन नहीं था। धन्यवाद। आप मुझे सुझाव अनुभाग में एक नई प्रविष्टि के लिए मेरे विचार पर लाए हैं

— जोर्ग ह्यूल्सरमैन

2

आर (3.3.1), 87 बाइट्स

सभी शून्य में समाप्त होने वाले खेल के लिए शून्य, और अन्यथा एक सकारात्मक संख्या।

z=scan();sum(Reduce(function(x,y)abs(diff(c(x,x[1]))),rep(list(z),max(z+1)^length(z))))

ग्रेग मार्टिन द्वारा एक ही तथ्य का लाभ उठाता है और बिल्टिन-इन का उपयोग डिफिरेक्ट-आईएनजी करता है

— ग्यूसेप
स्रोत

बशर्ते कि xnor की सीमा सही हो (टिप्पणियों से), यह अधिकतम (z) * लंबाई (z) का उपयोग करके दो बाइट्स छोटा हो सकता है, लेकिन मैं शुद्धता के बारे में आश्वस्त नहीं हूं

— Giuseppe

1

रोड़ा , 80 बाइट्स

f l...{x=[{peek a;[_];[a]}()|slide 2|abs _-_];[sum(x)=0]if[x in l]else{x|f*l+x}}

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

Ungolfed:

function f(l...) { /* function f, variadic arguments */
    x := [ /* x is a list of */
        { /* duplicate the first element of the stream to the last position */
            peek a /* read the first element of the stream */
            [_]    /* pull all values and push them */
            [a]    /* push a */
        }() |
        slide(2) | /* duplicate every element except first and last */
        abs(_-_)   /* calculate the difference of every pair */
    ]
    /* If we have already encountered x */
    if [ x in l ] do
        return sum(x) = 0 /* Check if x contains only zeroes */
    else
        x | f(*l+x) /* Call f again, with x appended to l */
    done
}

— fergusq
स्रोत

1

05AB1E , 13 बाइट्स

1 को लौटाता है अगर यह शून्य और 0 में समाप्त होता है ।

Z¹g*F¤¸ì¥Ä}_P

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

व्याख्या

राउंड के ऊपरी भाग का उपयोग करता है: टिप्पणी अनुभाग में xnormax(input)*len(input) द्वारा समझाया गया है ।

Z              # get max(input)
 ¹g            # get length of input
   *           # multiply
    F          # that many times do:
     ¤         # get the last value of the current list (originally input)
      ¸        # wrap it
       ì       # prepend to the list
        ¥      # calculate deltas
         Ä     # calculate absolute values
          }    # end loop
           _   # negate each (turns 0 into 1 and everything else to 0)
            P  # calculate product

— Emigna
स्रोत

1

जे, 22 बाइट्स

सभी शून्य में समाप्त होने वाले पतित खेल के लिए रिटर्न 0(जो falseजे में प्रभावी रूप से है)। रिटर्न 1( true) यदि nth पुनरावृत्ति में एक गैर-शून्य संख्या है, जहां n सूची की लंबाई से गुणा किए गए मूल अनुक्रम में सबसे बड़े पूर्णांक के बराबर है। ग्रेग मार्टिन का जवाब देखें कि यह क्यों सच है।

*>./|&(-1&|.)^:(#*>./)

अनुवाद:

क्या संकेत है *
सबसे बड़े मूल्य का >./
जब आप निम्न के रूप में कई बार iterate ^:( )
सूची में सबसे बड़े मूल्य से #गुणा की गई सूची की लंबाई : *>./
- पूर्ण मान लें |& की
- सूची के बीच अंतर (- ) और के
- सूची को एक से घुमाया गया 1&|.

उदाहरण:

   *>./|&(-1&|.)^:(#*>./) 1 1 0
1
   *>./|&(-1&|.)^:(#*>./) 42 42 41
1
   *>./|&(-1&|.)^:(#*>./) 3 4 5 8
0
   *>./|&(-1&|.)^:(#*>./) 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 1
0

— डेन
स्रोत

1

यह ग्रेग मार्टिन का दावा नहीं है। हालाँकि, ऊपर की टिप्पणियों में xnor की सीमा बेहतर है (लेकिन अभी भी सबसे बड़ा पूर्णांक नहीं है)। सरलतम लंबाई के साथ सबसे बड़ा मूल्य गुणा करना है।

— अर्जन जोहान्सन

अच्छी पकड़। मैं पर्याप्त ध्यान नहीं दे रहा था। मैं हल ठीक कर दूंगा।

— डेन

1

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

f=(a,b=(Math.max(...a)+1)**(c=a.length))=>b?f(a.map((v,i)=>v-a[++i%c]),b-1):a.every(v=>!v)

व्याख्या

रिकर्सिव फ़ंक्शन जो स्वयं को काउंटर कहता है (जो सूची में अधिकतम मूल्य पर शुरू होता है प्लस सूची की लंबाई की शक्ति के लिए [ = (max + 1)**length]] शून्य नहीं है। प्रत्येक कॉल पर, काउंटर को घटा दिया जाता है, और जब यह शून्य को हिट करता है, तो सूची के सभी तत्वों को शून्य के खिलाफ जांचा जाता है। यदि वे सभी समान शून्य हैं, तो कार्यक्रम वापस आ जाता है true, और falseअन्यथा।

— ल्यूक
स्रोत

1

PHP, 123 115

for($a=$_GET,$b=[];!in_array($a,$b);){$b[]=$c=$a;$c[]=$c[0];foreach($a as$d=>&$e)$e=abs($e-$c[$d+1]);}echo!max($a);

HTTP के माध्यम से इनपुट लेना जैसे ?3&4&5&8कि कुछ बाइट्स बचाता है।

प्रिंट्स 1 अगर यह सभी शून्य तक पहुंचता है या अन्यथा कुछ भी नहीं।

for($e=$argv,$r=[];!in_array($e,$r);$q=$e[0]){$e[0]=end($e);$r[]=$e;foreach($e as$k=>&$q)$q=abs($q-$e[$k+1]);}echo!max($e);

कमांड लाइन के माध्यम से तर्कों की सूची लेता है। मुझे लग रहा है कि इसे और भी आगे बढ़ाया जा सकता है (@ टिट्स को देखते हुए)।

— क्रिस्टोफ
स्रोत

1

पायथन 3.6, 101 बाइट्स

def f(t):
 x={}
 while x.get(t,1):x[t]=0;t=(*(abs(a-b)for a,b in zip(t,t[1:]+t[:1])),)
 return any(t)

संख्याओं का एक गुच्छे लेता है और झूठा और शून्य में समाप्त हो जाता है, तो सही है यदि यह छूट जाता है।

— RootTwo
स्रोत

0

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

रिटर्न trueसभी शून्य में समाप्त होने वाले खेल के लिए , falseअन्यथा।

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

परीक्षा

कोड स्निपेट दिखाएं

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

console.log(f([3,4,5,8])); // ends in zeros
console.log(f([1,0,1]));   // does not end in zeros
console.log(f([7]));       // ends in zeros

Expand snippet

— Arnauld
स्रोत

क्या मेरा डिफी गेम पतित है?