इस साइट पर हम ऊष्मप्रवैगिकी के नियमों का पालन करते हैं!

Question

और विशेष रूप से दूसरा कानून : समय के साथ एक अलग प्रणाली की एन्ट्रापी बढ़ जाती है ।

इस चुनौती के लिए,

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

चुनौती

आपके प्रोग्राम को एक गैर-रिक्त स्ट्रिंग का उत्पादन करना चाहिए जब एक ही भाषा में प्रोग्राम के रूप में निष्पादित किया जाता है, तो पिछले एक की तुलना में अधिक एन्ट्रॉपी के साथ एक स्ट्रिंग का उत्पादन होता है। वास्तव में इस निष्पादित-आउटपुट प्रक्रिया को पुनरावृत्त करने के लिए एन्ट्रापी मूल्यों का सख्ती से बढ़ते क्रम का उत्पादन करना चाहिए ।

स्ट्रिंग्स में कोई भी यूनिकोड 9.0 वर्ण हो सकते हैं । तार का अनुक्रम नियतात्मक होना चाहिए (यादृच्छिक के विपरीत)।

एन्ट्रापी एक दिया स्ट्रिंग के लिए इस प्रकार परिभाषित किया जाएगा। स्ट्रिंग में इसके अनूठे पात्रों और उनकी घटनाओं की संख्या की पहचान करें। आवृत्ति पी _मैं की मैं मई के अद्वितीय चरित्र है कि चरित्र स्ट्रिंग की लंबाई से विभाजित की पुनरावृत्ति की संख्या है। एन्ट्रापी तो है

जहां स्ट्रिंग के सभी अनूठे अक्षर खत्म हो गए हैं। तकनीकी रूप से, यह स्ट्रिंग में देखे गए आवृत्तियों द्वारा दिए गए वितरण के साथ असतत यादृच्छिक चर के एन्ट्रापी से मेल खाती है ।

चलो एच _{कश्मीर} निरूपित स्ट्रिंग द्वारा उत्पादित की एन्ट्रापी कश्मीर वें कार्यक्रम, और एच ₀ निरूपित प्रारंभिक कार्यक्रम के कोड की एन्ट्रापी। इसके अलावा, L ₀ वर्णों में प्रारंभिक कार्यक्रम की लंबाई को निरूपित करें। अनुक्रम { एच _के } चुनौती की आवश्यकताओं के अनुसार एकरस है, और बाध्य है (क्योंकि मौजूदा वर्णों की संख्या परिमित है)। इसलिए यह एक सीमा होती है, एच _∞ ।

स्कोर एक प्रस्तुत करने के लिए किया जाएगा ( एच _∞ - एच ₀ ) / एल ₀ :

• अंश, H _∞ - H ₀ , यह दर्शाता है कि आपका कोड किस सीमा तक अनंत समय अवधि में एन्ट्रापी बढ़ाने के नियम का "पालन" करता है।
• डोनोनिमेटर, एल ₀ , वर्णों में प्रारंभिक कोड की लंबाई है (बाइट्स में नहीं)।

उच्चतम स्कोर के साथ कोड जीतता है । टाई को जल्द से जल्द जमा करने / संपादित करने के पक्ष में हल किया जाएगा।

एक स्ट्रिंग की एन्ट्रॉपी की गणना करने के लिए, आप इस पोस्ट के अंत में जावास्क्रिप्ट स्निपेट ( @flawr के सौजन्य से और @ डेनिस और @ETHproductions द्वारा सुधार के साथ ) का उपयोग कर सकते हैं ।

यदि आपके विशिष्ट मामले में H _∞ की सीमा प्राप्त करना मुश्किल है, तो आप स्कोर की गणना करने के लिए H _{20 का} उपयोग कर सकते हैं , (इसलिए आप ₂₀ ( H ₂₀ - H ₀ ) / L ₀ ) की गणना करेंगे । लेकिन किसी भी मामले में, एन्ट्रापी के अनंत अनुक्रम को सख्ती से बढ़ाना चाहिए।

कृपया एक स्पष्टीकरण या संक्षिप्त प्रमाण शामिल करें कि एंट्रॉपी का क्रम बढ़ रहा है, अगर यह स्पष्ट नहीं है।

उदाहरण

एक काल्पनिक भाषा में, उस कोड पर विचार करें aabcab, जो चलाने पर स्ट्रिंग का cdefghउत्पादन करता है cdefghi, जो चलाने पर उत्पादन करता है , जो ...

मूल कोड के अद्वितीय वर्ण हैं a, bऔर c, संबंधित आवृत्तियों 3/6, 2/6 और 1/6 के साथ। इसकी एन्ट्रापी 1.4591 है। यह H _{0 है} ।

स्ट्रिंग cdefghकी तुलना में अधिक एन्ट्रापी है aabcab। हम इसे कंप्यूटिंग के बिना जान सकते हैं क्योंकि किसी वर्ण की संख्या के लिए एन्ट्रापी को अधिकतम किया जाता है जब सभी आवृत्तियाँ समान होती हैं। दरअसल, एन्ट्रापी एच ₁ 2.5850 है।

cdefghiपिछले एक की तुलना में स्ट्रिंग में फिर से अधिक एन्ट्रॉपी है। हम अब कंप्यूटिंग के बिना कर सकते हैं क्योंकि गैर-मौजूदा चरित्र को जोड़ने से हमेशा एन्ट्रापी बढ़ती है। दरअसल, एच ₂ 2.8074 है।

यदि अगली स्ट्रिंग थी 42तो श्रृंखला अमान्य होगी, क्योंकि H _{3 1} होगा, 2.8074 से छोटा।

अगर, दूसरे हाथ पर, अनुक्रम सीमा के साथ बढ़ रही है एन्ट्रापी के तार के उत्पादन पर चला गया एच _∞ = 3, स्कोर होगा (3-1.4597) / 6 = 0,2567।

स्वीकृतियाँ

करने के लिए धन्यवाद

• @xnor ने चुनौती को बेहतर बनाने में मदद के लिए, और विशेष रूप से मुझे यह समझाने के लिए कि पुनरावृत्त निष्पादन से प्राप्त एंट्रोपी बढ़ाने की अनंत श्रृंखलाएं वास्तव में संभव हैं;

• कई सुझावों के लिए @flawr , जिसमें स्कोर फ़ंक्शन को संशोधित करना और बहुत उपयोगी स्निपेट लिखना शामिल है;

• @ स्कोर फ़ंक्शन की पिछली परिभाषा में एक आवश्यक कमी को इंगित करने के लिए;

• @ जावास्क्रिप्ट स्निपेट में सुधार के लिए डेनिस ;

• स्निपेट में एक और सुधार के लिए @ETHproductions ;

• @PeterTaylor एन्ट्रापी की परिभाषा में सुधार के लिए।

एन्ट्रापी की गणना के लिए स्निपेट

function calculateEntropy() {
  var input = document.getElementById("input").value; // fetch input as string
  if (/[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)|([^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/.test(input)) {
    document.getElementById("output").innerHTML = " invalid (unmatched surrogates)";
    return;
  }
  var charArray = input.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^]/g);
  var frequency = {};
  for (var ind in charArray) {
    frequency[charArray[ind]] = 0;
  }
  var total = 0;
  for (var ind in charArray) {
    frequency[charArray[ind]] ++;
    total++;
  }
  var entropy = 0;
  for (var key in frequency) {
    var p = frequency[key] / total;
    entropy -= p * Math.log2(p);
  }
  document.getElementById("output").innerHTML = " " + entropy;
};

<button type="button" onClick="javascript:calculateEntropy();">calculate</button>Entropy: <span id="output">NaN</span> 
<br/>
<textarea id="input">asdf asdf</textarea>

Comments

"इस साइट पर हम ऊष्मप्रवैगिकी के नियमों का पालन करते हैं!" [उद्धरण वांछित]

— TuxCrafting

यहाँ स्रोत है :-)

— लुइस मेंडू

मैं उम्मीद कर रहा था कि प्रश्न "हॉट" नेटवर्क प्रश्नों के बारे में होगा।

— mbomb007

मैं सोच रहा था ... क्या यह वास्तव में सख्ती से एन्ट्रापी को बढ़ाने के लिए संभव है? यदि मैं आउटपुट को इसके अहस्ताक्षरित बाइनरी रूप में लेता हूं, तो यह मूल रूप से पूर्णांक [0,255] में पूर्णांक का अनुक्रम है। यदि सभी वर्ण भिन्न होते हैं, तो एंट्रोपी इष्टतम होती है (केवल एक धारणा), क्या इसका अर्थ यह नहीं होगा कि सबसे बड़ी एन्ट्रॉपी वाला स्ट्रिंग 256 बाइट्स लंबा है? यह अनंत होने से बहुत दूर है। या मेरी धारणा गलत है।

— 16

@ स्थायी उस स्ट्रिंग की एक प्रति अपने आप में संलग्न करें और एंट्रोपी समान होगी। फिर एक चार को हटा दें और यह थोड़ा छोटा होगा। प्रक्रिया को उल्टा करें और आपने एन्ट्रापी बढ़ा दी है। यदि आप अधिकतम एन्ट्रापी तक कभी नहीं पहुंचने का प्रबंधन करते हैं, तो आप हमेशा के लिए बढ़ते रह सकते हैं

— लुइस मेंडू

Answer 1

जेली, 0.68220949

“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v⁵

एच ₉₀ = 19.779597644909596802, एच ₀ = 4.088779347361360882, एल ₀ = 23

मैंने एच _{90 की} गणना करने के लिए लंबे डबल्स का इस्तेमाल किया । डबल सटीक फ़्लोट्स ने गलत सूचना दी कि एच ₄₇ <एच ₄₆

पहला प्रोग्राम प्रिंट करता है

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v1010

जहां 100,000 और 1,000,000 के… बीच कोड बिंदु वाले सभी यूनिकोड वर्णों के लिए एक प्लेसहोल्डर के रूप में कार्य करता है । वास्तविक लंबाई 900,031 अक्षर है।

सेकंड प्रोग्राम प्रिंट करता है

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v101010

जो, बदले में, प्रिंट करता है

“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”
“…”
“ȷ6ȷ5rỌ,®Ṿ€ṁṾY⁾©v⁸⁵”©v10101010

आदि।

इन कार्यक्रमों में से कोई भी ऑनलाइन इंटरप्रेटर में काम नहीं करता है, जिसमें 100 केबी आउटपुट सीमा होती है। हालाँकि, यदि हम 0123456789उपरोक्त 900,000 यूनिकोड वर्णों के बजाय प्रिंट करने के कार्यक्रम को संशोधित करते हैं , तो आप इसे ऑनलाइन आज़मा सकते हैं !

Answer 2

MATLAB, 9.6923e-005 0.005950967872272

H0 =  2.7243140535197345, Hinf = 4.670280547752703, L0 = 327

यह नया संस्करण पहले "अवधारणा के प्रमाण" का एक उन्नत संस्करण है। इस संस्करण में मुझे पहली पुनरावृत्ति से एक महान स्कोर वृद्धि मिली है। यह पहले कार्यक्रम के आउटपुट "उड़ाने" द्वारा प्राप्त किया गया था, जिसे बाद के सभी लोगों द्वारा दोहराया गया है। फिर मैंने भी H0कोड के सबसे सामान्य प्रतीक को यथासंभव कई बार जोड़कर न्यूनतम खोजने की कोशिश की । (यह स्पष्ट रूप से एक सीमा थी, क्योंकि यह न केवल कम हो जाती है, H0बल्कि L0एक ही समय में बढ़ जाती है । आप कार्यक्रम के आकार के खिलाफ प्लॉट किए गए स्कोर के विकास को देख सकते हैं, जहां आकार केवल जोड़ने या हटाने से भिन्न होता है 1।) बाद में। पुनरावृत्तियों अभी भी नीचे पिछले संस्करण के बराबर हैं।

a=['ns}z2e1e1116k5;6111gE16:61kGe1116k6111gE16:6ek7;:61gg3E1g6:6ek7;:61gg3E1'];11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111;;disp(['[''',a+1,'''];',0,'a=[''',a,'''];',0,[a-10,']]);'],0,[a-10,']]);']]);

पुराना वर्जन:

H0 = 4.22764479010266, Hinf = 4.243346286312808, L0 = 162

निम्न कोड matlab quine से प्रेरित है । यह मूल रूप से केवल दो बार फिर से खुद को आउटपुट करता है । सुराग यह है कि किसी भी पुनरावृत्ति के लिए हमारे पास nकोड और n-1न्यूलाइन प्रतीकों की लाइनें हैं \n। इसलिए जैसा nकि अनंत के पास है, कोड की पंक्तियों के अनुपात में न्यूलाइन्स 1 तक पहुंचता है, और साथ ही यह गारंटी देता है कि हमारे पास एन्ट्रापी में एक सख्त नीरस वृद्धि है। इसका मतलब यह भी है कि हम आसानी Hinfसे शून्य-पीढ़ी पीढ़ी कोड को समान रूप से कई newlines के साथ कोड की लाइनों पर विचार करके गणना कर सकते हैं । (कौन सा व्यक्ति प्रयोगात्मक रूप से पुष्टि कर सकता है, क्योंकि यह काफी तेज़ी से परिवर्तित होता है।)

a=['ns}z2e1kGe1116k6111gE16;:61kGe1116k6111gE16;:6ek7;:61gg3E1g6;:6ek7;:61gg3E1'];
disp(['a=[''',a,'''];',10,'a=[''',a,'''];',10,[a-10,']]);'],10,[a-10,']]);']]);

Comments

बहुत अच्छा! आप कुछ जगह हासिल करेंगे 10द्वारा 0(उस के लिए और समायोजित करने के कोड के बाकी)? चार 0को मैटलैब

— लुइस मेंडो

सलाह के लिये धन्यवाद! मुझे इसे आजमाने की कोशिश करनी चाहिए, लेकिन मुझे लगता है कि कुछ अन्य सुधार हैं जो स्कोर को बहुत अधिक बढ़ाएंगे। यह सबसे पहले अवधारणा का प्रमाण होना चाहिए :)

— दोषपूर्ण

मैंने अब आपके सुझाव को अन्य सुधारों के एक समूह के साथ शामिल किया।

— त्रुटी

मुझे वह ऑप्टिमाइज़ेशन ग्राफ़ पसंद है :-)

— लुइस मेंडो