चुनौती

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

आप दो प्रोग्राम / फ़ंक्शन लिखेंगे , जिसे एनकोडर और डिकोडर के रूप में संदर्भित किया जाएगा ।

एनकोडर

इनपुट: सीमा में एक पूर्णांक । $n$ $[0,2^{31}-1]$
आउटपुट: ASCII वर्णों का एक स्ट्रिंग (जरूरी नहीं कि मुद्रण योग्य हो)। $s$

डिकोडर

इनपुट: एक यादृच्छिक क्रमपरिवर्तन स्ट्रिंग के । $s'$ $s$
आउटपुट: पूर्णांक । $n$

स्कोरिंग

चलो होना अधिकतम लंबाई की के सभी संभव मूल्यों भर में । यदि एनकोडर गैर-नियतात्मक रूप से कार्य करता है (जिसे अनुमति दी गई है, तो नीचे देखें), तो की अधिकतम लंबाई होगी जो कि हो सकती है (संभवतः )। $A$ $s$ $n$ $A$ $s$ $\infty$

चलो $L_E$ हो की लंबाई एनकोडर बाइट्स और में $L_D$ की लंबाई डिकोडर बाइट में।

फिर आपका स्कोर $A\cdot(L_E+L_D)$ ।

सबसे कम अंक जमा करने पर विजय को सम्मानित किया जाता है ।

समय सीमा

एनकोडर और डिकोडर दोनों के निष्पादन समय पर 1 मिनट के लिए कुछ हद तक मनमानी समय सीमा है (यानी का एक मान )। $n$

लक्ष्य समाधान से बचना है जो कुछ गुणों के साथ सभी दृश्यों की गणना करके एन्कोडिंग को बल प्रदान करता है। यदि आपका समाधान इससे कुछ अधिक चतुर है, तो यह सबसे अधिक संभावना है कि समय की कमी के अनुकूल होगा और इसे वैध माना जाएगा। इसी तरह, यदि यह कुछ बेतरतीब ढंग से चयनित मूल्यों के लिए TIO पर काम करता है तो इसे वैध माना जाएगा। अन्यथा मैं इसे अपनी मशीन पर परीक्षण करूंगा, लेकिन ध्यान दें कि यदि आपका समाधान शुद्ध ब्रूट-बल है तो यह लगभग निश्चित रूप से विफल हो जाएगा। $n$

नियम

एनकोडर और डिकोडर में लिखा होना चाहिए एक ही भाषा ।
डिकोडर चाहिए उत्पादन सही पूर्णांक $n$ हर संभव परिवर्तन के लिए $s'$ स्ट्रिंग के $s$ द्वारा दिया एनकोडर ।
एनकोडर और डिकोडर कर रहे हैं नहीं करने की अनुमति दी जानकारी साझा (वैश्विक चर या फ़ाइलों के माध्यम से जैसे) किसी भी तरह से।
के उत्पादन में एनकोडर की जरूरत नहीं हो नियतात्मक (जो है, एक ही इनपुट $n$ यदि विभिन्न उत्पादन तार का उत्पादन हो सकता एनकोडर कई बार चलाया जाता है), लेकिन डिकोडर हमेशा सही पूर्णांक लगता है चाहिए $n$ ।
एनकोडर और डिकोडर लेने के लिए और पूर्णांक वापस आ सकते हैं $n$ में किसी भी सुविधाजनक तरीका (जैसे यदि $n=14$ यह ठीक है इनपुट होने के लिए 14, "14"या [1,4])।
एनकोडर हो सकता है उत्पादन स्ट्रिंग $s$ द्वारा या तो मुद्रण पर stdout या द्वारा लौट रहे एक स्ट्रिंग, एक सूची / सरणी पात्रों में से या किसी सूची / रेंज में पूर्णांकों की सरणी $[0,127]$ ; ध्यान दें कि डिकोडर का क्रमपरिवर्तन इनपुट के रूप में प्राप्त होगा $s$ रूप से वापस लौटे एनकोडर , तो यह स्ट्रिंग को स्वीकार करना चाहिए $s'$ में एक ही प्रारूप के रूप में $s$ ।
मानक खामियों को मना किया जाता है।
यदि संभव हो, तो यह बताएं कि आपका कोड कैसे काम करता है और आपके द्वारा दावा किया गया स्कोर सही क्यों है।

उदाहरण

मान लें $n=14$ ।

एनकोडर प्राप्त करता है 14इनपुट के रूप में। यह उत्पादन हो सकता है "qwerty"।

डिकोडर का क्रमपरिवर्तन प्राप्त करता है "qwerty"उदाहरण के लिए, के रूप में इनपुट "tweyqr"। इसका आउटपुट 14(किसी भी सुविधाजनक प्रारूप में) होना चाहिए ।

एनकोडर लौटे किया जा सकता था [113,119,101,114,116,121]और साथ ही, जिस स्थिति में डिकोडर प्राप्त होता है (उदाहरण के लिए) [116,119,101,121,113,114]।

ध्यान दें कि एनकोडर द्वारा लौटाए गए स्ट्रिंग में गैर-मुद्रण योग्य ASCII वर्ण (लेकिन हमेशा सीमा में [0x00, ..., 0x7F]) शामिल हो सकते हैं।

— Delfad0r
स्रोत

निश्चित रूप से उत्पादन की लंबाई अनंत नहीं हो सकती है, आप एक अनंत स्ट्रिंग को

— हिला

@ H.PWiz नहीं, यह नहीं हो सकता है, लेकिन अगर एनकोडर गैर-नियतात्मक है तो

— लिन्ब अनबाउंड

"एनकोडर और डिकोडर को किसी भी तरह से जानकारी साझा करने की अनुमति नहीं है" क्या इसमें सहायक कार्य शामिल हैं? यानी एक कस्टम फ़ंक्शन जो एन फैक्टोरियल प्लस थ्री (यादृच्छिक उदाहरण) की गणना करता है

— pizzapants184

क्या हमारा एनकोडर खाली स्ट्रिंग / सूची वापस कर सकता है?

— pizzapants184

2

@ क्रॉपेब हां, अब तक के नियम कहते हैं कि आपको दो बार बाइट्स गिनना चाहिए। मुझे दो समान कार्यक्रमों के साथ एक प्रस्तुतिकरण देखने में बहुत दिलचस्पी है, हालांकि।

— Delfad0r

12

जेली , (17 बाइट्स + 18 बाइट्स) × लंबाई 6 = 210 अंक

b36μỤỤ + × 3μŒ¿b3U + S

एस: 3_J
S% 3Uḅ3œ? Çḅ36

इसे ऑनलाइन आज़माएं! (या अतिरिक्त डिबग जानकारी के साथ)

बताई गई जीत की स्थिति पर लक्षित इस चुनौती को हल करने के लिए जाने के बाद, मुझे लगा कि काल्पनिक वैकल्पिक जीत की स्थिति के लिए जाना दिलचस्प होगा: कोड-गोल्फ ने आउटपुट के लिए न्यूनतम संभव अधिकतम लंबाई दी।

व्याख्या

एन्कोडिंग

एन्कोडिंग में पहला कदम इनपुट का आधार 36 ( b36) के रूप में प्रतिनिधित्व करना है । 36 ⁶ = 2176782336> 2147483647, इसलिए परिणाम में सबसे अधिक 6 अंक होंगे, जिनमें से प्रत्येक 0–35 की सीमा में है।

अगला, हम इसे एक प्रतिनिधित्व में बदलते हैं जिसमें 6 अलग-अलग अंक होते हैं। इसके लिए कई संभावित एल्गोरिदम हैं, लेकिन यहां इस्तेमाल किया गया है 1 को सबसे छोटे अंक, 2 को दूसरे-सबसे छोटे, 3 को तीसरे-सबसे छोटे, और इसी तरह से जोड़ना है। इसका मतलब यह है कि यदि दो अंक समान थे, तो उनमें से एक को मनमाने ढंग से छोटा माना जाएगा, और इस तरह वे अलग हो जाएंगे; और जाहिर है, यह एल्गोरिथ्म एक ही बनने के लिए दो अलग-अलग अंकों का कारण नहीं बन सकता है। जेली में इसका प्रतिनिधित्व करने के लिए, हम Ụसॉर्ट किए गए अनुक्रमों की सूची प्राप्त करने के लिए ("मूल्यों द्वारा अनुक्रमित अनुक्रमित") का उपयोग करते हैं; Ụफिर से पलटना कि, प्रभावी ढंग से मूल के प्रत्येक तत्व को क्रमबद्ध क्रम में उसकी स्थिति के लिए मैप करना; तथाµ…+नई सूची में मूल जोड़ने के लिए। परिणाम 1-41 रेंज (न्यूनतम 0 + 1, अधिकतम 35 + 6) में छह अलग-अलग अंकों के रूप में इनपुट संख्या का प्रतिनिधित्व है ।

फिर हमने इसे अभी तक एक और रूप में विभाजित किया है: 1-41 रेंज में अंकों की एक क्रमबद्ध सूची, 1 से 720 तक की संख्या के साथ-साथ यह भी दर्शाता है कि 720 में से कौन सा संभावित क्रमांक अंक में थे ( Œ¿और Ṣक्रमपरिवर्तन संख्या को निकालें और क्रमबद्ध करें। क्रमशः सूची।)

अंत में, हम संख्या को 1 से 720 तक आधार 3 ( b3) में परिवर्तित करते हैं , इसे रिवर्स करते हैं ( U), और छह बेस 3 अंकों और छह 1-41 अंकों को एनकोड करते हुए उन्हें रिवर्स ASMOD (वैल्यू) का उपयोग करते हुए एक एकल ASCII वर्ण में पैक करते हैं चरित्र मॉड 3 आधार 3 अंक है, 3 से विभाजित मूल्य 1-41 अंक है)। परिणामों की संभावित सीमा (1 × 3) + 0 = 3 न्यूनतम पर है, और (41 × 3) + 2 = 125 अधिकतम, हमारे ASCII रेंज के भीतर फिटिंग है। पैकिंग के माध्यम से किया जाता है ×3और +, µयह सुनिश्चित करने के लिए एक अतिरिक्त के साथ कि प्रत्येक कमांड सही बिट डेटा पर संचालित होता है। (यहां एक गोल्फिंग ट्रिक है, जिसमें हम क्रमचय हटाने से पहले गुणन को 3 से करते हैं; एक समूह वर्ण पर बाइट खर्च करने की आवश्यकता को बचाता है।)

संयोग से, आधार 3 नंबर को उलटने का कारण यह है कि इसमें 1-41 नंबर से कम अंक हो सकते हैं। (इसमें अधिक नहीं हो सकता है; सबसे छोटी संख्या जिसके लिए n !> 3 ⁿ थोड़ा ऊपर 6. है) जेली प्रभावी रूप से ट्रेलिंग शून्य को सम्मिलित करता है जब उन्हें जोड़ने के लिए अलग-अलग लंबाई के दो नंबर जोड़ते हैं; अनुगामी शून्य संख्या की व्याख्या को प्रभावित करेगा, लेकिन अग्रणी शून्य नहीं होगा, इसलिए इसका उपयोग यह सुनिश्चित करने के लिए किया जाता है कि अतिरिक्त शून्य कहीं खत्म हो जाए जो हमारे उत्तर को गड़बड़ नहीं करेगा।

डिकोडिंग

डिकोडिंग में पहला कदम दो नंबर (आधार 3 नंबर और 1–41 नंबर) को निकालना है। हम उनके अंकों को क्रमशः विभाजन ( :3) और मोडुलो ( %3) के साथ आसानी से प्राप्त कर सकते हैं, लेकिन यह कैसे जानें कि वे किस क्रम में थे? ठीक है, 1–41 नंबर में क्रमबद्ध क्रम में अपने अंक थे, और दो नंबरों के संबंधित पदों में अंक एक ही वर्ण में संग्रहीत किए गए थे; इस प्रकार, हम यह पता लगा सकते हैं कि 1-41 नंबर के अंकों को किस क्रम में (उनके सापेक्ष मूल्यों को देखकर) फेरबदल किया गया है और पता है कि आधार -3 नंबर के अंकों को उसी तरह से फेरबदल किया गया होगा। वास्तव में, क्योंकि हमारे ASCII एन्कोडिंग के वर्ण वैसे ही क्रमबद्ध हैं जैसे कि 1-41 संख्या के अंक (ये सभी अलग-अलग थे और वे आधार संख्या 3 की तुलना में अधिक महत्वपूर्ण हैं),Ṣ। तो दोनों अर्क के साथ शुरू होता है Ṣ, उसके बाद %3या :3उपयुक्त के रूप में।

जबकि 1-41 नंबर के अंक अभी भी क्रमबद्ध क्रम में हैं, हमारे पास आधार 36 के 0–35 अंकों पर वापस जाने के लिए एक बहुत ही सुविधाजनक / सुव्यवस्थित तरीका है; बस पहले से 1 घटाएं, दूसरे से 2, तीसरे से 3 और इसी तरह। जेली में, हम ऐसा कर सकते हैं _J("घटाना सूचकांक")।

इस बीच, डिकोड की दूसरी शाखा में, हम आधार 3 संख्या के अंकों को वापस ऑर्डर में वापस लाते हैं ( U), और इसे आधार 3 के साथ क्रमचय सूचकांक में बदल देते हैं ḅ3।

फिर हम दो शाखाओं को जोड़ सकते हैं œ?Ç; œ?इसका अर्थ है "परमिट इस क्रमांक सूचकांक को दिया गया", और Çइसका अर्थ है "ऊपर की रेखा को लागू करने का परिणाम", अर्थात यह जेली को एक ही इनपुट पर दोनों लाइनों को अलग-अलग चलाने के लिए कहता है।

अब हमारे पास मूल संख्या के आधार 36 (आधार _J) के कारण और मूल क्रम में ( œ?) के कारण अंक हैं , इसलिए हम बस ḅ36आधार 36 को एक पूर्णांक में बदलने के लिए कर सकते हैं ।

टीका

टीआईओ! उपरोक्त लिंक 312699167 का उपयोग करता है जो एन्कोड करने की संख्या के रूप में है। बेस 36 में यह संख्या है [5, 6, 6, 8, 7, 35], और इस प्रकार एन्कोडिंग के सभी पहलुओं को दिखाता है: 35 परीक्षणों में हमारे पास मौजूद 0-127 रेंज की सीमा है; डुप्लिकेट 6 s मूल बेस 36 में समान अंकों के संकल्प का परीक्षण करता है; और तथ्य यह है कि अंक लगभग (लेकिन काफी नहीं) क्रमबद्ध हैं इसका मतलब है कि क्रमचय संख्या बहुत कम है, यह आधार संख्या 36 की तुलना में कई कम अंक देता है, और इस तरह इसे मूल में जोड़ने से पहले इसे उलटने की आवश्यकता दिखाता है।

यह वास्तव में सुविधाजनक है कि यहां सभी स्थिरांक एक साथ कैसे फिट होते हैं। 36 ⁶ ही है बस पर्याप्त उच्च 2 फिट करने के लिए ³¹ , 3 ⁶ ही है बस पर्याप्त उच्च 6 फिट करने के लिए !, और (36 + 6) × 3 ही है बस पर्याप्त उच्च 128 संभावनाओं के अंदर हमारे पास फिट करने के लिए। (यहां अंतिम बाधा सबसे कम तंग है, क्योंकि हम 0-2 श्रेणी में वर्णों का उपयोग करने के लिए 1-अनुक्रमण के बजाय 0-अनुक्रमण का उपयोग कर सकते हैं। फिर भी, यह केवल 37 को आधार के रूप में उपयोग करने के लिए पर्याप्त जगह देगा। 36. की तुलना में)

— ais523
स्रोत

9

जेली , ( 4 3 बाइट्स + 6 5 बाइट्स) × लंबाई 8 = 80 64 अंक

b⁴Ä

ṢŻIḅ⁴

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

जेली , ( 2 1 बाइट + 4 3 बाइट्स) × लंबाई 10 = 60 40 अंक

ए

ṢŻI

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

व्याख्या

समाधान 1

यह अन्य उत्तरों में से अधिकांश से एक अलग एल्गोरिथ्म का उपयोग कर रहा है। हम हेक्साडेसिमल ( b⁴) में मान को एन्कोडिंग द्वारा शुरू करते हैं, अन्य उत्तरों के साथ, फिर एक संचयी योग ( Ä) लेते हैं । प्रत्येक इनपुट स्पष्ट रूप से एक अलग आउटपुट देगा (जैसा कि ये दोनों ऑपरेशन प्रतिवर्ती हैं), और यह देखते हुए कि हेक्साडेसिमल एन्कोडिंग में सबसे अधिक 8 अंक होंगे जिनका अधिकतम 7 (8-अंतिम अंक के लिए) और 15 (अंतिम से 7 वें के लिए) है अंतिम अंक), आउटपुट सूची में अधिकतम संख्या 7+ (7 × 15) = 112 होगी, जो प्रश्न द्वारा आवश्यक 127 से कम है। इसके अतिरिक्त, आउटपुट आवश्यक रूप से क्रमबद्ध क्रम में होगा, जिससे हम फेरबदल कर सकते हैं।

डिकोडर के लिए, हम पहले एक प्रकार ( Ṣ) के साथ फेरबदल को उल्टा करते हैं ; फिर एक शून्य ( Ż) और लगातार जोड़े के अंतर को ले कर संचयी योग को उल्टा करें ( I); फिर हेक्साडेसिमल ( ḅ⁴) से वापस कन्वर्ट करें ।

समाधान २

प्रश्न वास्तव में इनपुट को (संभवतः दशमलव) अंकों की सूची के रूप में लेने की अनुमति देता है, इसलिए हम बस आधार रूपांतरण को हटाकर "धोखा" दे सकते हैं; आउटपुट में उपयोग की जाने वाली अधिकतम संख्या 2 + (9 × 9) = 83 होगी (वास्तव में 82 क्योंकि 2999999999 सीमा से बाहर है, इसलिए सबसे खराब संभव इनपुट 1999999999 है)। परिणामी एन्कोडिंग इस समस्या के लिए एन्कोडिंग के रूप में बहुत भयानक है, लेकिन इसे उत्पन्न करने के लिए बहुत ही आकर्षक होने का लाभ है, जो एन्कोडिंग की क्रिया को आगे बढ़ाता है।

यह उत्तर इतना धोखा देने जैसा लगता है कि यह इस समस्या के लिए मेरा प्राथमिक समाधान नहीं है, लेकिन ऐसा लगता है कि यह जोड़ने लायक है क्योंकि यह तकनीकी रूप से नियमों का अनुपालन करता है और एक बेहतर स्कोर तैयार करता है।

टीका

लंबाई 8 से नीचे पाने के लिए मेरे पास कुछ एल्गोरिदम हैं, लेकिन ऐसा लगता है कि आप -9 बाइट्स (नॉन-चीटिंग) या ≤5 बाइट्स (चीटिंग) में लंबाई -7 एल्गोरिथ्म को लागू कर सकते हैं, इसलिए प्रश्न में स्कोरिंग द्वारा, संभावना यह करने के लिए सबसे अच्छा तरीका है। (मैं वैसे भी वैकल्पिक के लिए एक समाधान पर जा सकता हूं "एन्कोडिंग की लंबाई कम करें" चुनौती वैसे भी, हालांकि, सिर्फ मनोरंजन के लिए।)

कुछ समाधानों के विपरीत, यहां आधार के रूप में 16 का उपयोग महत्वपूर्ण नहीं है; वहाँ अन्य संख्या है कि लंबाई 8 समाधान (जैसे 18) के लिए काम करेंगे के बहुत सारे हैं। मैंने पहले समाधान के लिए 16 को सिर्फ इसलिए चुना क्योंकि जेली के पास प्रतिनिधित्व करने के लिए 1-बाइट तरीका है, और अन्य व्यवहार्य ठिकानों को कार्यक्रम से कई बाइट्स का उपयोग करने की आवश्यकता होगी। बेशक, दूसरे समाधान के लिए खामियों का फायदा उठाने के लिए आधार के रूप में 10 का उपयोग करने की आवश्यकता है।

कुछ नए जेली कमांडों को इंगित करने के लिए @ डेनिस का धन्यवाद जिसने इस एल्गोरिदम को लिखने के लिए भी परेशान किया।

— रीस ais523
स्रोत

3

Äके लिए छोटा है +\, के Żलिए छोटा है 0;।

— डेनिस

7

शेक्सपियर प्रोग्रामिंग भाषा , 10 * (264 + 494) = 8650 7910 7580

एनकोडर: 264 बाइट्स

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Be you nicer zero?You be the sum ofyou the product ofthe sum ofI a big big pig the sum ofa big big big big cat a big big pig.If soSpeak thy.Ford:You are the sum ofyou a cat.If soLet usAct I.

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

विकोडक: 494

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Is you nicer a pig?If soRemember you.If soLet usAct I.Scene V:.Ford:Remember I.Ajax:Recall.Is you worse the sum ofPage twice the sum ofa big big cat a cat?If soYou be the difference betweenyou Page.If soOpen heart.If notlet usScene V.Scene X:.Ford:Recall.Ajax:Be I nicer zero?If soRemember I.If soLet usScene X.[Exit Ajax][Enter Page]Ford:You be the sum ofyou twice twice the sum ofa big big cat a pig.Let usAct I.

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

यह एक बात थी।

एनकोडर प्रत्येक अंक को अंक के रूप में और अंक को बार के सूचकांक के रूप में बताता है। डिकोडर फोर्ड की मेमोरी में सभी इनपुट को स्टोर करता है और फिर एक काउंटर पर लूप करता है, आउटपुट करता है फिर काउंटर के मुकाबले प्रत्येक अंक को हटाता है * 12 + 10।

स्पष्टीकरण:

एनकोडर

,.Ajax,.Ford,.Act I:.Scene I:.      Boilerplate introducing the two characters
[Exeunt][Enter Ajax and Ford]       Enter the two characters Ajax and Ford
                                    Ford will be handling the input
                                    Ajax will be the counter
Ajax:Open mind.                     Set Ford to the next character of input
Be you nicer zero?                  Check if it is EOF
You be the sum of                   Set Ford to the sum of 
    you                             His original value (48 to 58)
    the product of                 
          the sum of               
              I                     Ajax's value
              a big big pig         Minus 4 (this handles the offset of 48)
          the sum of                Multiplied by
              a big big big big cat 2^4
              a big big pig.        + -2^2 = 12
                                    This essentially sets Ford to (F+12*(A-4))
If soSpeak thy.                      If not EOF, print Ford's value
Ford:You are the sum ofyou a cat.   Increment Ajax's value
If soLet usAct I.                   If not EOF, Repeat again.

डिकोडर

,.Ajax,.Ford,.Page,.Act I:.Scene I:.  Boilerplate introducing three characters
                                      Ajax is the spare stack
                                      Ford is the storage stack
                                      Puck is the counter, increasing by 12
[Exeunt][Enter Ajax and Ford]            Enter Ajax and Ford onto the stage
Ajax:Open mind.                          Get the next character of input
Is you nicer a pig?                      If not EOF
If soRemember you.                         Store the value in Ford's memory
If soLet usAct I.                          And repeat the loop
Scene V:.                                Otherwise move to the next scene
Ford:Remember I.                         Store Ford's value (initially -1 from EOF) in Ajax's memory
Ajax:Recall.                             Get the next value from Ford's memory
Is you worse the sum of                  Is the value smaller than
        Puck                                  Puck's value
        twice the sum ofa big big cat a cat?  + 10 ?
                                              i.e. is it the next digit?
If soYou be the difference betweenyou Puck.   If so, subtract Puck's value from Ford
If soOpen heart.                              And print Ford's value
If notlet usScene V.                     If that was not the digit, repeat
Scene X:.
Ford:Recall.                             Get the next value from Ajax's memory
Ajax:Be I nicer zero?                    Until the -1
If soRemember I.                         Returning the values to Ford's memory
If soLet us Scene X.                     Repeat until Ajax's memory is exhausted
[Exit Ajax][Enter Page]                  Swap Ajax and Page
Ford:You be the sum of                   Set Puck's value to
              you                        Puck +   
              twice twice the sum of     2*2*(
                           a big big cat      4
                           a pig.             -1) = 12
Let usAct I.                             And start from the beginning again, having removed one number

— मजाक कर रहा है
स्रोत

5

पायथन 2.7, 31 * (52 + 37) = 2759

एनकोडर ( 69 52 बाइट्स):

lambda n:[chr(i)if n&(1<<i)else""for i in range(32)]

विकोडक ( 41 37 बाइट्स):

lambda s:sum([1<<(ord(c))for c in s])

इनपुट संख्या में सभी गैर-शून्य बिट्स को एससीआई मानों के रूप में संग्रहीत करता है। एससीआई चरित्र का मान सेट बिट की स्थिति को संग्रहीत करता है। उदाहरण के लिए मान 'a' का मतलब होगा कि 97 वां बिट सेट है।

कुछ सुधार, @ Delfad0r के लिए धन्यवाद

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

— हेन वेसल्स
स्रोत

PPGC में आपका स्वागत है! आप ड्रॉप कर सकते हैं e = और d = शुरुआत में - अनाम प्रक्रियाएं पूरी तरह से ठीक हैं। यह भी ध्यान दें कि समस्या कथन स्पष्ट रूप से कहता है कि एनकोडर वर्णों के बजाय पूर्णांकों की सूची लौटा सकता है, इसलिए आप रूपांतरण पूर्णांक-> वर्ण-> पूर्णांक से बच सकते हैं। इसके अलावा, आप उपयोग कर सकते हैं n&(1<<i)के बजाय n&(1<<i)>0और 2 बाइट्स सहेजें। अंत में, i(127) के लिए ऊपरी सीमा बहुत अधिक है, 32 पर्याप्त है और 1 बाइट बचाता है।

— Delfad0r

1

कृपया समस्या कथन में स्कोरिंग सेक्शन के अनुसार अपना स्कोर बताएं ।

— डेलफ्रेड ० सिप

@ Delfad0r स्कोरिंग अभी सही है? और सुझावों के लिए धन्यवाद।

— हेन वेसल्स

मुझे लगता है कि स्कोर (52+37)*31=2759तब से सबसे लंबा है जब सभी 31 बिट सेट हैं।

— जोनाथन एलन

एनकोडर lambda n:[chr(i)*(n&1<<i>0)for i in range(32)]6 बाइट बचाने के लिए हो सकता है।

— mypetlion

5

स्टैक्स , स्कोर 8 × (10 + 9) = 152

एनकोडर, 10 बाइट्स

Ç·MÉJ'♀τ│½

इसे चलाएं और डीबग करें

16|E{i16*+m Full program, implicit input
16|E        Get hexadecimal digits
    {     m Map:
     i16*+    Add 16 * loop index
            Implicit output as string

एनकोडर एक बढ़ते क्रम में स्ट्रिंग को आउटपुट करता है।

डिकोडर, 9 बाइट्स

üL∟n╫k∞‼9

इसे चलाएं और डीबग करें

o{16%m16|E Full program, implicit input
o          Sort string
 {16%m     Module each element by 16
      16|E Interpret as array of hex digits

— wastl
स्रोत

5

05AB1E , 8 अधिकतम लंबाई * (8 + 7) बाइट्स = 120

एनकोडर (8)

hεHN16*+

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

विकोडक (7)

{16%hJH

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

के रूप में ही तकनीक का उपयोग करता wastl और जोनाथन ।

— मिस्टर एक्सकोडर
स्रोत

5

पायथन 3 , 8 * (45 + 38) = 664

एनकोडर (45 बाइट्स):

lambda n:[16*i+(n>>4*i)%16 for i in range(8)]

विकोडक (38 बाइट्स):

lambda l:sum(x%16<<x//16*4 for x in l)

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

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

1

आप "पहले" के लिए रिक्त स्थान निकाल सकते हैं, lambda l:sum(x%16<<x//16*4for x in l)ठीक काम करता है :)

— FatalError

4

यह काम नहीं करता। आउटपुट सादा ASCII नहीं है (सीमा 0..127 में)

— GB

2

@ मेरी गलती है। मैंने इसे अपने अंतिम संपादन से तोड़ दिया। अब लौटना

— कर्टिस बेचटेल

एनकोडर में 3 बाइट्स बचाएं: lambda n:[n>>4*i&15|i<<4for i in range(8)]और डिकोडर में 1: lambda l:sum(x%16<<x//16*4for x in l)632 के कुल स्कोर के लिए

— हारून

4

जावास्क्रिप्ट (ईएस 6), 8 * (40 + 32) = 576

एनकोडर एक सरणी का उत्पादन करता है $0$ $8$

एनकोडर (40 बाइट्स)

E=(n,k=0)=>n?[k|n&15,...E(n>>4,k+16)]:[]

विकोडक (32 बाइट्स)

s=>s.map(c=>s|=c%16<<(c/4&~3))|s

डेमो

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

कैसे?

इनपुट को 4 बिट्स के 8 ब्लॉक में विभाजित किया गया है और प्रत्येक ब्लॉक को 16 संभावित पात्रों में से 1 के साथ एन्कोड किया गया है। अंतिम ब्लॉक का सबसे महत्वपूर्ण बिट कभी सेट नहीं किया जाता है।

       3222222222211111111110000000000
bit:   0987654321098765432109876543210
       \_/\__/\__/\__/\__/\__/\__/\__/
block:  7  6   5   4   3   2   1   0

block #0 is encoded with char. 00 to 0F (NUL to SI)
block #1 is encoded with char. 10 to 1F (DLE to ES)
block #2 is encoded with char. 20 to 2F (' ' to '/')
block #3 is encoded with char. 30 to 3F ('0' to '?')
block #4 is encoded with char. 40 to 4F ('@' to 'O')
block #5 is encoded with char. 50 to 5F ('P' to '_')
block #6 is encoded with char. 60 to 6F ('`' to 'o')
block #7 is encoded with char. 70 to 77 ('p' to 'w')

— Arnauld
स्रोत

4

जेली , (8 + 9) बाइट्स * 8 अधिकतम लंबाई = 136

b⁴+J’Ɗ⁴¡

एनकोडर (पाद लेख स्पष्टता के लिए पायथन के रूप में सूची को प्रारूपित करता है)

Ṣ_J‘Ɗ⁴¡ḅ⁴

डिकोडर

यह सैद्धांतिक रूप से छह की अधिकतम लंबाई के लिए संभव है, क्या 22 बाइट्स या कम में किया जा सकता है?

यह पांच की अधिकतम लंबाई के साथ असंभव है $\sum_{i=0}^{i=5}\binom{127+i}{127}=321402081< 2^{31}-1$

कैसे?

जबसे $2^{31}-1$ 8 हेक्साडेसिमल अंकों ( 7fffffffया [7,15,15,15,15,15,15,15]) के रूप में एनकोडेबल है, फिर हम प्रत्येक हेक्स-डिजिट के शून्य-आधारित इंडेक्स को 16 से गुणा कर सकते हैं ताकि यह सुनिश्चित हो सके कि इस तरह का रूपांतरण हमेशा क्रमबद्ध क्रम में होता है, यहां तक कि सबसे सही मूल्य को सीमा में भी रखता है (यानी [7,15,15,15,15,15,15,15] + [0,16,32,48,64,80,96,112] = [7,31,47,63,79,95,111,127])। डिकोडिंग फिर इसी प्रक्रिया को उलट रहा है।

एनकोडर :

b⁴+J’Ɗ⁴¡ - Link: integer, n    e.g. 1234
 ⁴       - literal 16               16          
b        - convert to base          [4,13,2]
       ¡ - repeat...
      ⁴  - ...16 times:
     Ɗ   -   last 3 links as a monad:
   J     -     range of length        [1,2,3]     iter 2    iter 3    ...  iter 16
  +      -     add                    [5,15,5]   [5,16,7]   [5,17,9]  ...  [5,30,35]
    ’    -     decrement              [4,14,4]   [4,15,6]   [4,16,8]  ...  [4,29,34]
         -                                                                 [4,29,34]

विकोडक :

Ṣ_J‘Ɗ⁴¡ḅ⁴ - Link: list of integers   e.g. [29,34,4]
Ṣ         - sort                          [4,29,34]
      ¡   - repeat...
     ⁴    - ...16 times:
    Ɗ     -   last 3 links as a monad:
  J       -     range of length           [1,2,3]
 _        -     subtract                  [3,27,31]   [3,26,29]   [3,25,27]  ...  [3,12,1]
   ‘      -     increment                 [4,28,32]   [4,27,30]   [4,26,28]  ...  [4,13,2] 
        ⁴ - literal 16                    16
       ḅ  - from base                     1234

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

"हेक्साडेसिमल अंक", निश्चित। ("सादे हेक्साडेसिमल का उपयोग करने वाले अंक" लंबा है, और "अंक" अकेले दशमलव का अर्थ है।)

— एरिक आउटफोलर

मैंने इसे बदल दिया भले ही यह संदर्भ से स्पष्ट होना चाहिए था क्योंकि मैंने तुरंत हेक्स-अंकों को संदर्भित किया था।

— जोनाथन एलन

आपकी गणना एक से बंद है: 5 की अधिकतम लंबाई के साथ प्रतिस्थापन के साथ 321402081 संयोजन हैं, और 6.17 की अधिकतम लंबाई के साथ 7177979809

— एंडर्स केसोर्ग

@AndersKaseorg उफ़, तो यह है - तो यह 6 की अधिकतम लंबाई के साथ संभव है ... साथ खेलने के लिए 22 बाइट्स दे रहा है!

— जोनाथन एलन

4

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 31 * (472 + 383 379 344) = 26505 26381 25296

पिछला स्कोर: 16909322 * (246 + 217) = 7829016086

यह अभी भी बहुत अधिक है, लेकिन यह सबसे कम है जिसके बारे में मैं अभी सोच सकता हूं।

एनकोडर:

,.Ajax,.Ford,.Act I:.Scene I:.[Enter Ajax and Ford]Ajax:Remember a pig.Ford:Listen tothy.Scene V:.Ajax:Remember the remainder of the quotient betweenI a big cat.Ford:You be the quotient betweenyou a big cat.Be you nicer zero?If solet usScene V.Remember a pig.Scene X:.Ajax:Recall.Ford:Am I worse zero?If notremember I.If notlet usScene X.Ajax:You zero.Scene L:.Ford:Recall.Ajax:You be the sum ofyou a cat.Am I nicer zero?If sospeak thy.Am I worse zero?If notlet usScene L.

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

डिकोडर:

,.Ajax,.Ford,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:You cat.Ford:Open mind.Remember the sum ofyou I.Scene V:.Ajax:Am I nicer a cat?If soyou be twice you.Ford:If soyou be the sum ofyou a pig.If solet usScene V.[Exit Ford][Enter Page]Page:Recall.Ajax:Am I worse a cat?If notyou be the sum ofyou Ford.If notlet usAct I.Open heart

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

मूल रूप से, यदि स्ट्रिंग में ASCII कोड (n + 1) वाला वर्ण है, तो nth बाइनरी अंक सेट है।

— JosiahRyanW
स्रोत

डिकोडर के लिए 344 बाइट्स

— जो किंग

3

पायथन 3, (208 बाइट्स + 200 बाइट्स) * 6 लंबाई = 2448

इसे ऑनलाइन आज़माएं!(दोनों शामिल हैं, अतिरिक्त बाइट उनके बीच की नई रूपरेखा है)।

-4 बाइट्स (-24 स्कोर) खाली सूची का उपयोग करके (जिसमें 0 पर शुरू करने के लिए अधिक चीजों की अनुमति दी गई)

एनकोडर (208 बाइट्स)

def E(n,h=128):
    T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1
    d=l=0
    s=[]
    while n>=T(h,d):
        n-=T(h,d)
        d+=1
    for i in range(d):
        while n>=T(h-l,d+~i):
            n-=T(h-l,d+~i)
            l+=1
        s+=[l]
    return s

विकोडक (200 बाइट्स)

def D(s):
    T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1
    s.sort()
    l=0
    d=len(s)
    n=sum(T(128,D)for D in range(d))
    for i in s:
        for j in range(l,i):
            n+=T(128-j,d-1)
        l=i
        d-=1
    return n

टिप्पणियों:

कड़ाई से गैर-बढ़ती (यानी क्रमबद्ध) सूचियों के लिए फेरबदल दोषरहित हो सकता है।
समान लंबाई की सख्ती से गैर-बढ़ती संख्यात्मक सूचियों को पूरी तरह से आदेश दिया जा सकता है (जैसा कि वे पायथन में हैं)।
हम यह परिभाषित कर सकते हैं कि सभी क्रमबद्ध सूचियों का कुल क्रम बनाने के लिए सूचियों को पहले लंबाई के आधार पर क्रमबद्ध किया गया है।
अगर हम को परिभाषित है कि एक सूची में केवल मान्य मान से पूर्णांक हैं हम इन सूचियों का एक इंडेक्सेबल अनुक्रम फार्म कर सकते हैं 0करने के लिए 127समावेशी (यानी लंबाई के साथ वैध सूचियों की एक सीमित संख्या वहाँ मौजूद L)।

रणनीति:

एनकोडर: एक संख्या को देखते हुए N, खोजेंN वें को कड़ाई से गैर-बढ़ती सूची को मान्य करें।
विकोडक: (सूचीबद्ध) मान्य सूची को देखते हुए, इसे क्रमबद्ध करें और मान्य सूचियों के अनुक्रम में इसके सूचकांक को लौटाएं।

आम कोड स्पष्टीकरण:

T=lambda n,d:n*T(n+1,d-1)//d if d>1else d and n or 1
nवें -simplex संख्या की गणना करेंd
- के लिए d=0, हमेशा1
- के लिए d=1, n(लंबाई के साथ डॉट्स की एक पंक्ति में डॉट्स की संख्याn )
- के लिए d=2, $\sum_{i=1}^{n} i$ , (साइड लंबाई वाले डॉट्स के त्रिकोण में डॉट्स की संख्या n)
- के लिए d=3, $\sum_{j=1}^n \sum_{i=1}^{j} i$ , (पक्ष लंबाई के साथ डॉट्स के टेट्राहेड्रोन में डॉट्स की संख्या n)

एनकोडर स्पष्टीकरण:

def E(n,h=128): d=l=0, s=[]
nइनपुट नंबर है, h"उच्च मूल्य" है (अर्थात उच्चतम संख्या + 1 की अनुमति है), dलंबाई है जो आउटपुट होगा, sआउटपुट lहै, "कम मूल्य" है (0 पर शुरू, और बाद में समझाया गया)
while n>=T(h,d):, n-=T(h,d),d+=1
कर रहे हैं T(h,d)वैध length- dसूचियों, और हमारे गणना करता है, तो आसान है nसूची में एक सूचकांक रिश्तेदार है [0]*d(सूचकांक पर 0एक वास्तविक सूचकांक के बजाय), तो घटती nतदनुसार। यह dदिए गए के लिए सही होने के लिए (लंबाई) को भी समायोजित करता है n।
for i in range(d):
प्रभावी रूप से: " i+1सूची में वें नंबर के लिए"
- यह वह जगह है जहाँ मैं समझाता हूँ l, "कम मूल्य"
- एक संख्या को सूची में डाल दिए जाने के बाद, इससे कम संख्या को सूची में नहीं रखा जा सकता (इसे क्रमबद्ध रखने के लिए), इसलिए lअंतिम संख्या है जिसे सूची में जोड़ा गया था।
- while n>=T(h-l,d+~i):, n-=T(h-l,d+~i),i+=1
- यदि इस "अंक" पर nएन्कोड किया जाना बहुत बड़ा है l, तो nतदनुसार और वेतन वृद्धि को समायोजित करेंl
- s+=[l]
- nएक साथ सांकेतिक शब्दों में बदलनाl इस "अंक" पर।
- सबसे पहले, हमारे पास hविकल्प हैं कि हम "अंक" को आगे रखें, लेकिन एक बार जब हम "अंक" (जिसे सौंपा गया है l) में डालते हैं, तो हम h-lअगले "अंक" के लिए विकल्पों तक सीमित होते हैं ।
- पहले तो T(h,d)वैध सूचियाँ थीं , लेकिन हमने एक "अंक" जोड़ दिया है, जो "अंकों" lकी संख्या को कम कर रहा है d-1और मान्य अगले "अंकों" की संख्या को घटाता है h-l, इसलिए इसके बाद मान्य सूचियों की संख्याT(h-l,d-1)

विकोडक स्पष्टीकरण:

def D(s):, s.sort(), l=0,d=len(s)
s(फेरबदल) इनपुट सूची है, इसलिए s.sort()यह; l"कम मूल्य" है ( h"उच्च मूल्य" 128बाइट्स को बचाने के लिए कोड में केवल शाब्दिक है ), nआउटपुट संख्या dहै, लंबाई है।
n=sum(T(128,D)for D in range(d))
nके क्रम में बिंदु पर समायोजित करें[0]*length
for i in s:
प्रत्येक अंक के लिए:
- for j in range(l,i):, n+=T(128-j,d-1)
- nके क्रम में बिंदु पर समायोजित करें[...prevdigits, thisdigit, 0...]
  - l=i: "कम मूल्य" को सबसे हाल के अंक में सेट करें
  - d-=1: एक अंक का उपयोग करने के बाद से लंबाई में कमी
return n: nसभी अंकों के लिए समायोजित होने के बाद , यह सही संख्या है; इसे लौटा दो।

क्षमा करें यदि यह स्पष्ट नहीं है, लेकिन यहाँ मेरा मूल nongolfed डीबग संस्करण है इसे ऑनलाइन आज़माएं! , जो खाली सूची का उपयोग नहीं करता है, इसलिए इस संस्करण में प्रयुक्त सभी नंबरों से 1 बंद है

— pizzapants184
स्रोत

3

रूबी , (36 + 29 बाइट्स) * 8, स्कोर 520

एनकोड:

->n{(0..7).map{|x|(n>>x*=4)%16+x*4}}

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

डिकोड:

->a{a.sum{|x|x%16<<(x/4&28)}}

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

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

संख्या 4-बिट विखंडू और 3-बिट इंडेक्स का उपयोग करके एन्कोडेड है।

डिकोडर इनपुट ऐरे को लेता है और प्रत्येक नीब को फिर से अपनी जगह पर रखता है।

— जीबी
स्रोत

3

लकड़ी का कोयला , स्कोर 10 * (10 + 15) = 250।

दशमलव का उपयोग करता है; पिछले बेस 16-आधारित समाधान ने ~~328~~ ~~296~~ स्कोर किया 264 ।

गैर-वर्णों का उत्पादन कर सकता है। विशेष रूप से, चरित्र 10 चारकोल के इनपुट के लिए मुश्किल है।

एनकोडर, 10 बाइट्स:

⭆⮌Ｓ℅⁺Ｉι×χκ

इसे ऑनलाइन आज़माएं!लिंक कोड के वर्बोज़ संस्करण के लिए है।

विकोडक, 15 बाइट्स:

ＩΣＥＳ×﹪℅ιχＸχ÷℅ιχ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

पूर्णांक स्कोर ~~360~~ 296 (बेस 16, दशमलव स्कोर 310) की सूची का उपयोग करके संस्करण :

एनकोडर, 19 बाइट्स:

ＮθＩＥ⁸⁺﹪÷θＸ¹⁶ι¹⁶×¹⁶ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

विकोडक, 18 बाइट्स:

ＩΣＥＥ⁸Ｎ×﹪ι¹⁶Ｘ¹⁶÷ι¹⁶

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

मुद्रण योग्य वर्ण स्कोर 360 का उपयोग कर संस्करण ( आधार 16 में ~~416~~ ~~384~~ 368 था ):

एनकोडर, 19 बाइट्स:

⭆⮌Ｓ℅⁺Ｉι×χ⁺κ×⁵⊕×³÷κ⁵

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

विकोडक, 17 बाइट्स:

Ｆθ⊞υ⌈Φθ¬№υκ⭆υ﹪℅ιχ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

— नील
स्रोत

2

ब्रेकीलॉग , 17 + 18 बाइट्स * 8 लंबाई = 280

एनकोडर:

ḃ₁₆I∧7⟧₁;Iz₁~ḃ₁₆ᵐ

डिकोडर:

ḃ₁₆I∧7⟧₁;Iz₁~ḃ₁₆ᵐp

एक पी एन्कोडर के अंत में जोड़ा जा सकता है जिसका कोई प्रभाव नहीं है। डीकोडर आउटपुट के रूप में (फेरबदल) परिणाम डालकर चलाया जाता है और इनपुट में मूल संख्या प्राप्त करता है।

अगर वहाँ (ठीक से लागू किया गया) संचयी राशि का अनुमान है तो स्कोर 20 तक गिर सकता है

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

— Kroppeb
स्रोत

@ Delfad0r एन्कोडर में p जोड़ने से यह एन्कोडिंग और डिकोडिंग के लिए समान कोड होगा

— Kroppeb

2

05AB1E , स्कोर: (2 + 2 बाइट्स ) * 11 अधिकतम लंबाई = 44

एनकोडर (2) बाइट्स ):

.¥

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

डिकोडर (2 बाइट्स) ):

{¥

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

एनकोडर के इनपुट और डिकोडर के आउटपुट अंकों की एक सूची है।

पोर्ट @ ais523 की दूसरी जेली का जवाब ।

स्पष्टीकरण:

.¥    # Undelta (automatically prepends a 0)
      #  i.e. [3,0,4,7,8,2,0,1,9] → [0,3,3,7,14,22,24,24,25,34]

{     # Sort
      #  i.e. [14,7,22,25,24,3,0,24,34,3] → [0,3,3,7,14,22,24,24,25,34]
 ¥    # Deltas
      #  i.e. [0,3,3,7,14,22,24,24,25,34] → [3,0,4,7,8,2,0,1,9]

क्योंकि .¥उत्पादन के लिए शून्य को पूर्व निर्धारित करता है, आउटपुट की लंबाई इनपुट की लंबाई है + 1. चूंकि $2^{31}-1$ 10 अंकों की लंबाई है, आउटपुट की अधिकतम लंबाई 11 है।

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

2

गोल> <> , 8 * (14 + 13) = 216

एनकोडर यह ऑनलाइन कोशिश करो! , 14 बाइट्स:

I8FfPSD8*L+o|;

विकोडक यह ऑनलाइन कोशिश करो! , 13 बाइट्स:

iEh8SD4*2$X*+

चूंकि यह unprintable ascii वर्णों का उत्पादन कर सकता है, इस प्रकार डिकोडर के साथ खिलवाड़ करता है, अब आउटपुट / आइटम में संख्याओं का उपयोग करके एक संस्करण है:

एनकोडर यह ऑनलाइन कोशिश करो! , 14 बाइट्स:

I8FfPSD8*L+N|;

विकोडक यह ऑनलाइन कोशिश करो! , 13 बाइट्स:

IEh8SD4*2$X*+

एन्कोडिंग:

एन्कोडिंग दी गई संख्या को 8 x 4 बिट विखंडू में तोड़कर काम करती है। इन चंक्सों को फिर 3 बिट द्वारा स्थानांतरित किया जाता है और चंक के मूल स्थान को अंत में 0 और 7 के बीच की संख्या के रूप में जोड़ा जाता है। इस प्रकार एन्कोडिंग इस तरह दिखता है:

0AAAABBB
 |__|    -> the original part of the number
     |_| -> the position of the chunk inside the original number 0 = LSB and 7 = MSB

— Gegell
स्रोत

2

पर्ल 6 , 10 * (10 + 12) = 340 220

एनकोडर:

{^@_ Z~@_}

डिकोडर:

{.sort X%10}

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

एनकोडर फ़ंक्शन संख्या के 0-इंडेक्स के साथ प्रत्येक अंक को ज़िप करता है। फिर एनकोडर संख्या की सूची को सॉर्ट करता है और 10 से मोडुलो प्राप्त करता है, दूसरे शब्दों में संख्या का दूसरा अंक।

कुल 10 है, क्योंकि यह 2 ³¹ -1 की अधिकतम लंबाई है ।

— मजाक कर रहा है
स्रोत

1

हास्केल , 10 * (23 + 51) = 740

यहाँ एक कार्यक्रम है जो एनकोड करता है, फेरबदल करता है, डिकोड करता है और वैल्यूज़ को वेलिड करता है: इसे ऑनलाइन आज़माएँ!

एनकोडर, 23 बाइट्स

zipWith((+).(10*))[0..]

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

डिकोडर, 51 बाइट्स

map snd.sortOn fst.map(`divMod`10)
import Data.List

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

व्याख्या

चूंकि हमें इनपुट को दशमलव अंकों के रूप में उपयोग करने की अनुमति है, इसलिए हम इसका उपयोग करेंगे .. एनकोडर प्रत्येक अंक को मैप करता है 10*index + digit, जो यह नोट करता है कि सभी digits होंगे, [0..9]इसलिए हम ऊपर का उपयोग करके उल्टा कर सकते हैंdivMod । सूचकांकों और अंकों को बहाल करने के बाद केवल सूचकांकों द्वारा छंटनी और उनसे छुटकारा पाने की बात है।

समाधान के लिए मूल्यों के लिए काम करने की उम्मीद है $2^{31} - 1 = 2147483647$ जो कि 10 अंकों का होता है, इसलिए हमें प्राप्त होने वाला अधिकतम कोड-पॉइंट होगा $9 \cdot 9 = 81 < 128$ । प्रत्येक अंक को "वर्ण" में बदल दिया जाएगा, इसलिए हम अधिकतम 10 की लंबाई के साथ समाप्त हो जाएंगे।

— ბიმო
स्रोत

1

भूसी , 10 * (7 + 8) = 150

केवल अवलोकन के साथ मेरे हास्केल समाधान का सीधा बंदरगाह $10 \cdot 9 = 90 < 128$ (भूसी है N 1-आधारित है):

एनकोडर, 7 बाइट्स

zo+*10N

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

डिकोडर, 8 बाइट्स

m→Ö←m‰10

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

— ბიმო
स्रोत

1

एपीएल (डायलॉग यूनिकोड) , $L_E+L_D=36; A=8 \rightarrow 288$ ।

d←{16⊥n-16×⍳≢n←⍵[⍋⍵]}
e←(⊢+16×⍳∘≢)16⊥⍣¯1⊢

इसे ऑनलाइन आज़माएं!(असाइनमेंट और न्यूलाइन के लिए 5 अतिरिक्त बाइट्स शामिल हैं)।

उपयोग ⎕IO←0

किस तरह:

(⊢+16×⍳∘≢)16⊥⍣¯1⊢ ⍝ Encoder; input 1234
          16⊥⍣¯1⊢ ⍝ Convert input to base 16 → 4 13 2
      ⍳∘≢          ⍝ [0..length of the list-1] → 0 1 2
   16×             ⍝ times 16 → 0 16 32
 ⊢+                ⍝ plus the original list → 4 29 34

{16⊥n-16×⍳≢n←⍵[⍋⍵]} ⍝ Decoder; input ⍵ → 34 4 29
              [⍋⍵]  ⍝ Grade ⍵ up → 2 0 1
             ⍵      ⍝ Index ⍵ with that list → 4 29 34
           n←       ⍝ assign that to n
      16×⍳≢         ⍝ 16×[0..length(n)-1] → 0 16 32
    n-              ⍝ subtract that from n → 4 13 2
 16⊥                ⍝ Decode from base 16 → 1234

— जे। सल्ल
स्रोत

1

PHP, 8 * (44 + 53) = 776

एनकोडर, 44 बाइट्स:

for(;$n=&$argn;$n>>=4)echo$n&15|16*$i++," ";

प्रिंट अंतरिक्ष अलग पूर्णांकों की सूची। साथ पाइप के रूप में चलाएँ -nR।

4 डेटा बिट्स (निचला नीबल) और 3 वजन बिट्स (ऊपरी कुतरना) के साथ अधिकतम 8 बाइट्स।

सीधे शब्दों में कहें:
प्रत्येक हेक्स अंक को अपने चरित्र में रखें और अंक की स्थिति को संग्रहीत करने के लिए बाइट के ऊपरी आधे हिस्से का उपयोग करें।

उदाहरण:

1457893891( 0x56e5b203) में बदल जाएगी
0x03, 0x10, 0x22, 0x3b, 0x45, 0x5e, 0x66, 0x75
→3 16 34 59 69 94 102 117

डिकोडर, 53 बाइट्स:

while($i++<8)$n+=(15&$x=$argv[$i])<<($x>>4)*4;echo$n;

या

while($i++<8)$n+=(15&$x=$argv[$i])<<($x/4&~3);echo$n;

या

for(;$i<9;$x=$argv[++$i])$n+=$x%16<<($x/4&~3);echo$n;

कमांड लाइन तर्कों से पूर्णांक लें। साथ चलाना -nr।

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

— टाइटस
स्रोत

0

पायथन 2 , 10 * (68 + 54) = 1220

e=lambda n:"".join(chr(int(`i`+j))for i,j in enumerate(`n`)if j<'L')
d=lambda s:int("".join(`ord(c)%10`for c in sorted(s)))

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

संपादित करें: बिंदुओं के लिए जो किंग के लिए धन्यवाद - मुझे यकीन नहीं था कि मैं 32 से पीछे हटने की कोशिश कर रहा था।

प्रत्येक स्थान की स्थिति और मूल्य को एक ही वर्ण के रूप में बताता है, जिसकी शुरुआत ~~[स्थान] (स्थिति 0, मान 0)~~ NUL बाइट 0x0 से होती है।

डिकोड द्वारा:

स्ट्रिंग को छाँटना (पायथन वर्णों को उनके क्रमबद्ध मान द्वारा क्रमबद्ध करेगा)
प्रत्येक वर्ण को अपने क्रमिक मान में परिवर्तित करता है
प्रत्येक क्रमिक पूर्णांक का अंतिम अंक लेता है
पूर्णांकों को एक तार में जोड़ता है
सम्मिलित स्ट्रिंग को वापस एक इंट में परिवर्तित करता है

— Triggernometry
स्रोत

क्या आपको 32ऑफसेट की आवश्यकता है ? इसके अलावा, सही जगह पर , [-1]हो सकता %10है

— जो किंग

0

सी (जीसीसी) , 10 * 112 = 1120

c,i;e(i,s)char*s;{for(c=1;i;c+=10,i/=10)*s++=c+i%10;*s=0;}
d(char*s){for(i=0;c=*s++;i+=--c%10*pow(10,c/10));s=i;}

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

मेरे पास वैश्विक चर हैं, लेकिन वे वास्तव में दो कार्यों के बीच किसी भी जानकारी को पारित नहीं कर रहे हैं। के लिए परिवर्तनीय घोषणा cकोड लंबाई में मुझे 2 बाइट्स बचाने वाले दोनों कार्यों में उपयोग किया जाता है।

एक संस्करण जो केवल 3 5 बाइट के दंड के लिए मुद्रण योग्य ASCII का उपयोग करता है:

c,i;e(i,s)char*s;{for(c=32;i;c+=10,i/=10)*s++=c+i%10;*s=0;}
d(char*s){for(i=0;c=*s++;i+=(c-=32)%10*pow(10,c/10));s=i;}

70 अंक के सुधार के लिए @ceilingcat को धन्यवाद।

— GPS
स्रोत

एनकोड - शफल - डिकोड

चुनौती

एनकोडर

डिकोडर

स्कोरिंग

समय सीमा

नियम

उदाहरण

जेली , (17 बाइट्स + 18 बाइट्स) × लंबाई 6 = 210 अंक

व्याख्या

एन्कोडिंग

डिकोडिंग

टीका

जेली , ( 4 3 बाइट्स + 6 5 बाइट्स) × लंबाई 8 = 80 64 अंक

जेली , ( 2 1 बाइट + 4 3 बाइट्स) × लंबाई 10 = 60 40 अंक

व्याख्या

समाधान 1

समाधान २

टीका

शेक्सपियर प्रोग्रामिंग भाषा , 10 * (264 + 494) = 8650 7910 7580

एनकोडर: 264 बाइट्स

विकोडक: 494

स्पष्टीकरण:

एनकोडर

डिकोडर

पायथन 2.7, 31 * (52 + 37) = 2759

स्टैक्स , स्कोर 8 × (10 + 9) = 152

एनकोडर, 10 बाइट्स

डिकोडर, 9 बाइट्स

05AB1E , 8 अधिकतम लंबाई * (8 + 7) बाइट्स = 120

एनकोडर (8)

विकोडक (7)

पायथन 3 , 8 * (45 + 38) = 664

एनकोडर (45 बाइट्स):

विकोडक (38 बाइट्स):

जावास्क्रिप्ट (ईएस 6), 8 * (40 + 32) = 576

एनकोडर (40 बाइट्स)

विकोडक (32 बाइट्स)

डेमो

कैसे?

जेली , (8 + 9) बाइट्स * 8 अधिकतम लंबाई = 136

कैसे?

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 31 * (472 + 383 379 344) = 26505 26381 25296

पायथन 3, (208 बाइट्स + 200 बाइट्स) * 6 लंबाई = 2448

एनकोडर (208 बाइट्स)

विकोडक (200 बाइट्स)

रूबी , (36 + 29 बाइट्स) * 8, स्कोर 520

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

लकड़ी का कोयला , स्कोर 10 * (10 + 15) = 250।

ब्रेकीलॉग , 17 + 18 बाइट्स * 8 लंबाई = 280

एनकोडर:

डिकोडर:

05AB1E , स्कोर: (2 + 2 बाइट्स ) * 11 अधिकतम लंबाई = 44

गोल> <> , 8 * (14 + 13) = 216

एन्कोडिंग:

पर्ल 6 , 10 * (10 + 12) = 340 220

हास्केल , 10 * (23 + 51) = 740

एनकोडर, 23 बाइट्स

डिकोडर, 51 बाइट्स

व्याख्या

भूसी , 10 * (7 + 8) = 150

एनकोडर, 7 बाइट्स

डिकोडर, 8 बाइट्स

एपीएल (डायलॉग यूनिकोड) ,एलए+ लडी= 36 ; ए = 8 → 288एलए+एलडी=36;ए=8→288L_E+L_D=36; A=8 \rightarrow 288।

किस तरह:

PHP, 8 * (44 + 53) = 776

एनकोडर, 44 बाइट्स:

उदाहरण:

डिकोडर, 53 बाइट्स:

पायथन 2 , 10 * (68 + 54) = 1220

सी (जीसीसी) , 10 * 112 = 1120

एपीएल (डायलॉग यूनिकोड) , $L_E+L_D=36; A=8 \rightarrow 288$ ।