संतुलित शून्य-एक एन्कोडिंग

13

कार्य

एक स्ट्रिंग को एनकोड करें जिसमें पूरी तरह से अपरकेस अल्फाबेट्स ( A-Z) केवल ज़ीरो और लोगों का उपयोग करके, अपनी खुद की पसंदीदा स्कीम का उपयोग करके हो। लेकिन नियम इतना आसान नहीं है!

नियम

  1. आपके प्रोग्राम / फ़ंक्शन को सही ढंग से लंबाई 8 के किसी भी वैध इनपुट स्ट्रिंग को संभालना चाहिए ।
  2. सभी इनपुट के लिए परिणाम की लंबाई समान होनी चाहिए।
  3. अलग-अलग इनपुट के लिए परिणाम अलग-अलग होने चाहिए।
  4. परिणाम यथासंभव कम होने चाहिए।
  5. परिणाम शून्य-एक संतुलित होना चाहिए (शून्य की तरह लोगों की संख्या )। उन्हें बराबर (यानी पूरी तरह संतुलित) नहीं होना है, लेकिन आपके स्कोर को इसके लिए दंडित किया जाएगा।

आपको कोई प्रोग्राम / फ़ंक्शन प्रदान नहीं करना है जो आपके एन्कोडिंग को डिकोड करता है।

इनपुट और आउटपुट

  • आप इसके बजाय 26 अलग मुद्रण योग्य ASCII वर्णों के किसी भी सेट को स्वीकार करने का निर्णय ले सकते हैं A-Z।
  • आप के बजाय और मुद्रण योग्य ASCII वर्णों की किसी भी जोड़ी को आउटपुट करने का निर्णय ले सकते हैं ।01
  • आपको बिट स्ट्रिंग के बजाय पूर्णांक आउटपुट करने की अनुमति नहीं है , क्योंकि इसमें अग्रणी शून्य हो सकता है और यह स्पष्ट नहीं है कि क्या आप वास्तव में नियम 2 से मिले हैं।
  • यदि आप डिफ़ॉल्ट ( A-Zइनपुट और 01आउटपुट) से विचलन करने का निर्णय लेते हैं , तो आपको अपने सबमिशन में इनपुट / आउटपुट कैरेक्टर सेट को निर्दिष्ट करना होगा।

स्कोरिंग

  • बेस स्कोर: कोड आकार, या 1 यदि आपका कार्यक्रम खाली होता है।
  • दंड
    • लंबाई के लिए जुर्माना: गुणा 1.5 ** (encoded length - 42)
    • छोटे होने के लिए कोई बोनस नहीं है; 42 वर्णमाला आकार 26 के साथ 8-लंबाई के तार के पूरी तरह से संतुलित एन्कोडिंग के लिए न्यूनतम लंबाई है।
    • असंतुलित होने के लिए दंड: क्रमशः, प्रत्येक आउटपुट में 1 और 0 की संख्या को गुणा और 2 ** max(abs(ones - zeros) for every valid input of length 8)कहाँ किया जाता है।oneszeros
    • आपके सबमिशन को या तो सबसे खराब स्थिति का उदाहरण (इनपुट / आउटपुट) दिखाना होगा या पेनल्टी वैल्यू पर सैद्धांतिक स्पष्टीकरण देना होगा।
  • सबसे कम स्कोर जीतता है।

उदाहरण प्रस्तुत करना

Hypothetical esolang, 0 बाइट्स, स्कोर 74733.8906

यहाँ एक काल्पनिक गढ़ है, जहाँ एक खाली प्रोग्राम बाइनरी में इनपुट के सभी ASCII कोडों को प्रिंट करता है।

उदाहरण के लिए, यदि आप AAAAAAAAइनपुट के रूप में देते हैं , तो प्रोग्राम 1000001पंक्ति में 8 बार प्रिंट होगा , अर्थात 10000011000001100000110000011000001100000110000011000001।

इनपुट वर्णमाला को चुना जाता है CEFGIJKLMNQRSTUVXYZabcdefh। इस तरह, सभी वर्ण बाइनरी में सात अंकों में बदल जाते हैं, और शून्य-एक मायने रखता है केवल एक प्रति चार (वे सभी तीन 1 है और चार 0 या इसके विपरीत जब बाइनरी में बदल जाते हैं)।

आउटपुट की लंबाई हमेशा 56 होती है, और सबसे खराब स्थिति असंतुलित होती है जैसे इनपुट्स पर CCCCCCCC, जहां शून्य लोगों की तुलना में 8 गुना अधिक दिखाई देते हैं।

इसलिए, इस सबमिशन का स्कोर है 1.5 ** (56 - 42) * 2 ** 8 == 74733.8906।

string  code-challenge  balanced-string  encode 
— bubbler
स्रोत
सैंडबॉक्स: codegolf.meta.stackexchange.com/a/14908/78410
— Bubbler
क्या मैं अपने काल्पनिक एसोलैंग का उपयोग कर सकता हूं जिसमें खाली प्रोग्राम अक्षर एनकोडेड 26-एरी में एक नंबर एन को स्वीकार करता है और योग 21 के एन-वें संभावित 42-बिट अनुक्रम को आउटपुट करता है?
— ngn
@ng - क्या आपकी काल्पनिक भाषा हमारे स्वीकृत मानदंडों को पूरा करती है ? - EDIT आह इनपुट हमेशा [AZ] है - मुझे लगता है कि यह काफी आसान है ... :)
— जोनाथन एलन
1
क्या हम लोगों और शून्य की सूची तैयार कर सकते हैं या इसके लिए एक तार होना चाहिए?
— डेनिस
1
पूरा सवाल "असंतुलित नहीं होना चाहिए, 42 अंकों में होना चाहिए, जो वास्तविक समय की देखभाल करते हैं"
— l4m2

जवाबों:

4

स्टैक्स , 11 बाइट्स, 0 पेनल्टी, स्कोर 11

यह प्रोग्राम [0-9A-P]इनपुट के लिए और [01]आउटपुट के लिए उपयोग करता है ।

ö■▄←·ï↨≡⌐╠H

इसे ऑनलाइन चलाएं और डीबग करें - प्रारंभ करने के लिए रन बटन पर क्लिक करें। पहले चार परीक्षण मामले मिलीसेकंड में चलते हैं। सेकंड में पांचवां। सहस्राब्दी में छठा।

इस कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व यह है।

A$21*,26|bD|N

यह |Nनिर्देश पर भारी पड़ा है , जो एक सरणी के बाद के क्रमचय को प्राप्त करता है।

A$21*           "10" repeated 21 times
     ,26|b      get input and decode it as a base 26 number
          D|N    ... that many times get the next lexicographic permutation

सभी आउटपुट प्रारंभिक स्ट्रिंग के क्रमपरिवर्तन हैं। इसमें 21 शून्य हैं और 21 हैं। इसलिए, सभी आउटपुट 42 वर्ण हैं, और पूरी तरह से संतुलित हैं।

— पुनरावर्ती
स्रोत
3

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

O_65ḅ26ị2Ḷ¤x21¤Œ!Q¤

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

व्याख्या

O_65ḅ26ị2Ḷ¤x21¤Œ!Q¤  Main Link
O                    Take the character code of each character
 _65                 Subtract 65 (the code of "A")
    ḅ26              Convert to base 26
       ị             Get the <left-arg>th element of:
        2Ḷ¤x21¤Œ!Q¤  All balanced strings of length 42:
        2Ḷ           range(2) == [0, 1]
           x21       stretch 21 ([0, 0, ..., 0, 1, 1, ..., 1])
               Œ!    all permutations
                 Q   deduplicate
— HyperNeutrino
स्रोत
E x p l a n a t i o n?
— 4
@EsolangingFruit जोड़ा गया
— हाइपरन्यूट्रिनो
3

पायथ, 20 19 14 बाइट्स, मैक्स डिफ: 0, लंबाई: 64, स्कोर: 149636.5528 142154.7251 104745.5869

sm@S.{.p*`T4xG

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

[a-z]अपरकेस के बजाय लोअर केस अल्फाबेट ( ) का उपयोग करता है । 2 बाइट्स की कीमत पर, के Gसाथ बदलकर अपरकेस का उपयोग कर सकते हैं rG1।

मैं हाइपरन्यूट्रिनो के पायथन 3 के उत्तर का बेहतर स्कोर के लिए अनुवाद कर सकता था , लेकिन स्पष्ट रूप से, मुझे ऐसा उत्तर चाहिए जो वास्तव में काम करता हो।

— hakr14
स्रोत
2

पायथन 2 , 779 645 बाइट्स, मैक्स (डिफ) = 0, लंबाई = 48, स्कोर = 7346.95

def f(s):
 a,b=0,""
 for i in s:a=a*26+ord(i)-65
 a+=56*252**4
 for i in range(5):b=bin((int("4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33",36)>>a%252*10)&1023)[2:].rjust(10,"0")+b;a/=252
 return b[2:]

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

मैजिक नंबर 4lnk28t9vtqgfrpfda9uyfrjhcjwjvno6aec2nwegi0g4mnublc05dher8fjm4s5gh55lu87a4itmc74t6tozcsfdbxkg82frwljy0wam1jht98g2j0bma021v5d48pwq0fklv0n1ltrxft1fpk5gt5mx5fj4p2mjqqpvcylt1xayxf1iwdmyoxgfvl7oui1oo6147bm9rqpqut9ns8hhjc77t3pqy48otovrsm1t4mmleumspkuef66ma1vi0l4mtkwaeeizuvvds9fro3vhc0mrn6ox17rdpk7xw747qf28934u5jci5q1qj81i7dyf7rf0x7hb19xm93xhxsgh4w8ifs6fhynsddbo9j938ewfvhjlbpiz50n5hanmno6c89blyx50e89z7vjq2ho2r2u2wwyu4q18kv4fi1nhmfbgjbnkdayr5kblaped4fo5u97bi9a67d89irxa0r9cinmnohfgjmh5fhkcr33(बेस 36 में), या इसके दशमलव समतुल्य 382136276621246556626597379364678993894472503063952720559883124988542417847157286833446006767955087631166943136913765901237281892296575754126024183763829277879554548743231384272055945084065681774297483130020386641869860456147616177702938121538230311395513497506285733567467605871232294046704309941152721616618474501854355102646152223338484615876165254236449912858255665248186687952137487016925761633237335983620006273901509768720506129789443353730706676483647298576692613113269388239830925662977837917272690235355742330377154505179476767457756888107428475384947712227312747517748632498691058764154580934614231152483398774630508576533263098942260213967880819240793990219283490212843120923539516962682466148372296338428497778127570401190309339992457562121354271, 5 0s और 5 1s के सभी 252 परिक्रमणों को कूटबद्ध करता है ।

एल्गोरिथ्म पहले इसे आधार -26 नंबर के रूप A-Zमें परिवर्तित करता है 0-25और फिर जोड़ता है 56*252**4।

फिर, संख्या को 5-अंकीय आधार -252 संख्या में बदल दिया जाता है, और 5 0s और 5 1s के संगत क्रमांकन के साथ प्रतिस्थापित किया जाता है ।

उसके बाद, पहले 2 बिट्स को हटा दें, जो होने की गारंटी है 01। फिर हमने स्ट्रिंग को 48-बिट स्ट्रिंग में एन्कोड किया है, जिसमें बिल्कुल 24 0एस और 24 1एस शामिल हैं।

— शायरु असकोतो
स्रोत
बहुत यकीन है कि दंड को गुणा करना होगा (अर्थात, आपका स्कोर 7346.953125)।
— हाइपरन्यूट्रिनो
@ हेपर न्युट्रीनो ओह, हालांकि मैं इसके अलावा हूँ; पी संपादित
— शायरु असाकोतो
2

जावास्क्रिप्ट (ईएस 8), स्कोर 22186.623779296875

f=
s=>s.replace(/./g,(c,i)=>(i%2*127^c.charCodeAt()).toString(2).padStart(7,0))
<input oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

यहां तक ​​कि लंबाई इनपुट के लिए, हमेशा शून्य और लोगों के 3.5 * आउटपुट होते हैं, इसलिए यह केवल 1.5 ** 14 जुर्माना का भुगतान करता है। समर्थित वर्ण '+-.3569:<GKMNSUVYZ\cefijlqrtx:।

— नील
स्रोत
2

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

42ɠO%ḅ26ịœcH$ạ‘Ṭ

उपयोग +,-./0123456789:;<=>?@ABCDइनपुट के लिए है और लोगों और शून्य की सूची देता है।

यह स्मृति में 538,257,874,440 संयोजनों की सूची बनाने का प्रयास करता है, इसलिए आपको इसे चलाने के लिए बड़ी मात्रा में RAM की आवश्यकता होगी ...

इसे ऑनलाइन आज़माएं!(परीक्षण योग्य; इनपुट लंबाई 3, आउटपुट लंबाई 18)

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

42ɠO%ḅ26ịœcH$ạ‘Ṭ  Main link. No arguments.

42                Set the argument and the return value to 42.
  ɠ               Read one line from STDIN.
   O              Ordinal; map ['+', ..., 'D'] to [43, ..., 69].
    %             Take the code points modulo 42, mapping [43, ..., 69] to
                  [1, ..., 26].
     ḅ26          Convert the result from base 26 to integer.
            $     Combine the two links to the left into a monadic chain.
           H          Halve; yield 21.
         œc           Generate all 21-combinations of [1, ..., 42].
                  There are 538,257,874,440 of these combinations. The first
                  269,128,937,220 begin with a 1.
        ị         Retrieve the combination at the index to the left.
                  [26, 26, 26, 26, 26, 26, 26, 26] in bijective base 26 equals
                  217,180,147,158 in decimal, so the retrieved combination will
                  begin with a 1.
              ‘   Increment; yield 43.
             ạ    Absolute difference; map [1, ..., 42] to [42, ..., 1].
                  The combination now begins with a 42.
               Ṭ  Untruth; turn the combination into a Boolean list, with 1's
                  at the specified indices and 0's elsewhere.
                  Since the maximum of the combination is 42, this list will have
                  exactly 42 items, 21 of which will be 1's.
— डेनिस
स्रोत
2

पायथन 3 , 985 135 बाइट्स, मैक्स डिफ 0, लंबाई 42, स्कोर 135

lambda s:C(int(s,26),21,20)
B=lambda x,y:y<1or-~x*B(x+1,y-1)//y
def C(n,o,z):p=B(o,z);x=n>=p;return z+1and[x]+C(n-p*x,o-x,z-1+x)or[1]*o

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

बब्बलर के सौजन्य से

अघोषित कोड:

import math

def binomial(x, y):
    return math.factorial(x) // math.factorial(y) // math.factorial(x - y)

def string_to_int(input_str):
    result = 0
    for i in range(0,8):
        result += (ord(input_str[i])-65)%26 * pow(26,i)
    return result

def counting_function(target, ones, zeros):
    if zeros > 0:
        position = binomial(ones+zeros-1,zeros-1)
    else:
        position = 1
    if target > position:
        if ones > 0:
            print("1", end='')
            ones -= 1
            counting_function(target-position,ones,zeros)
    else:
        if zeros > 0:
            print("0", end='')
            zeros -= 1
            counting_function(target,ones,zeros)
        elif ones > 0:
            print("1", end='')
            ones -= 1
            counting_function(target,ones,zeros)

input_str = input("Input string (A-Z): ")
input_int = string_to_int(input_str)+1
target = input_int
ones = 21
zeros = 21
counting_function(target, ones, zeros)
print("")

चूंकि अन्य दृष्टिकोण काफी अक्षम हैं, इसलिए मैंने एक समय-इष्टतम बनाने की कोशिश की है। यह एन-बिट्स एनकोडिंग में क्लीली ओ (एन) है, जो कि बड़ा-ओ इष्टतम है।

संकेत: इस एक के लिए पास्कल के त्रिकोण के बारे में सोचने की कोशिश करें ( यह चित्र यह बताता है)

नमूना आउटपुट:

Input:  AAAAAAAA
Output: 000000000000000000000111111111111111111111

 

Input:  ZZZZZZZZ
Output: 011001000000011010011000111010110110111110

निष्पादन समय: <0.013 s (सभी इनपुट के लिए लगभग स्थिर)

— असली
स्रोत
1
— बब्बलर
@ बब्लर अतुल्य, मैंने इसे हासिल करने के लिए कौशल हासिल नहीं किया
— रियल
लेकिन आपको अपने स्कोर को कम करने के लिए कुछ प्रयास करने चाहिए। सभी प्रस्तुतियाँ स्कोर को अनुकूलित करने के लिए एक गंभीर प्रयास करना चाहिए, अन्यथा यह अमान्य है।
— user202729
@ user202729 मैंने बब्बलर के संस्करण में तब बदलाव किया है, जिसे कम से कम किया गया है। मैंने अपने स्कोर को कम करने का प्रयास किया, हालांकि कोड आकार के माध्यम से नहीं।
— रियल
बाद के बिंदु के बारे में ... सही है।
— user202729
2

पर्ल 5 , 55 बाइट्स, अधिकतम अंतर 0, लंबाई 42, स्कोर 56 55

यह काम करता है, लेकिन एक लंबा लेकिन उल्लेखनीय समय लगेगा ( ZZZZZZZZमेरे कंप्यूटर पर 2.5 दिन लगते हैं)। मेमोरी कोई समस्या नहीं है।

उपयोग A-Zइनपुट और के रूप में 1और Aएन्कोडिंग पात्रों के रूप में। वे हमेशा पूरी तरह से संतुलित होते हैं। 26^7 = 80318101768 वर्णों से कम स्ट्रिंग का प्रतिनिधित्व करने वाले पहले संतुलित संयोजनों को छोड़ देता है, लेकिन यह ठीक है क्योंकि 538257874440उपलब्ध हैं और मैं उपयोग करता हूं 208827064575और208827064575 + 8031810176 < 538257874440 ।

हालांकि यह वास्तव में लक्ष्य संयोजन तक "मायने रखता है" जो बहुत लंबा समय लेगा। इसीलिए TIO लिंक में मैंने केवल एक बहुत छोटी इनपुट स्ट्रिंग (जो समर्थित भी है) का उपयोग किया है ताकि यह प्रदर्शित हो सके कि आउटपुट सही है। AAAAAATIO बार आउट होने से पहले थोड़ा अधिक काम करेगा । ZZZZZZZZलगभग 26^3 = 17576धीमा होना चाहिए ।

#!/usr/bin/perl -ap
$_=1x21 .($i=A)x21;s/(A*)(1*)1A/$2$1A1/ until"@F"eq$i++

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

डिकोडर लगभग समान है:

#!/usr/bin/perl -ap
$_=1x21 .($\=A)x21;s/(A*)(1*)1A/$2$1A1/,$\++until"@F"eq$_}{

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

— टन हास्पेल
स्रोत
1

> <> , 75 बाइट्स, मैक्स डिफ 0, लंबाई 42, स्कोर 75

0i:0(?v'A'-$dd+*+!
.")1+.\1+:0$:2%:}:@-2,@+$bl"
[ab+-?\$:?vv~3
~~]>n<v$-1<>

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

मेले चेतावनी, यह एक बहुत ही ले जाएगा बहुत बहुत भी तुच्छ के लिए पूरा करने के लिए लंबे समय के AAAAAAAAमामले। एक काउंटर के प्रत्येक बाइनरी अभ्यावेदन के माध्यम से चलता है जब तक कि (इनपुट के आधार 26 प्रतिनिधित्व) वें बाइनरी संख्या 21 1एस के साथ नहीं पहुंच जाती है। यदि आप कुछ हद तक कार्यक्रम का परीक्षण करना चाहते हैं, तो आप ab+तीसरी पंक्ति को बदल सकते हैं 1जिसके साथ केवल एक एकल के साथ nth बाइनरी नंबर वापस आ जाएगा 1, ऑनलाइन प्रयास करें!

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

पायथन 3 , 75 बाइट्स, मैक्स डिफ 0, लंबाई 42, स्कोर 112

lambda s:sorted({*permutations("01"*21)})[int(s,26)]
from itertools import*

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

यह केवल स्मृति की कमी के कारण सिद्धांत में काम करता है। कर रहे हैं 538257874440विशिष्ट संतुलित शून्य से एक लंबाई 42 और के तार 208827064575संभव आदानों, इसलिए संभव outputs के कुछ उपयोग नहीं किया जाएगा।

-37 बाइट्स की बदौलत @recursive

— HyperNeutrino
स्रोत
यदि आप अपने इनपुट वर्ण सेट को बदलते हैं तो आप int(s,26)अपने सूचकांक मूल्य के लिए उपयोग कर सकते हैं sum(...)।
— पुनश्चर्या
@recursive को unprintables की आवश्यकता होगी। कि पहले से ही की कोशिश की
— हायपरनेउर्टिनो
Unprintables? यह उपयोग करता है [0-9A-P], है ना? मेरी मशीन पर,int("123ABC",26) == 12855114
— पुनरावर्ती
@recursive अरे हाँ तुम सही आइडल हो जो मैं सोच रहा था। धन्यवाद!
— हाइपरनेट्रिनो
1

सी ++, 146 बाइट्स, 42 अधिकतम, 0 असंतुलित, स्कोर 146

#include<algorithm>
long long i,s;int f(char*I,char*O){for(O[i=42]=s=0;i--;i<8?s=s*26+I[i]:0)O[i]=i%2|48;for(;s--;)std::next_permutation(O,O+42);}

किसी भी निरंतर 26 चार के लिए काम करता है, लेकिन चेतावनी यह एक अस्वीकार्य समय चलाता है

— l4m2
स्रोत
ऐसा लगता है कि आपको खाली सरणी की आवश्यकता है इसके अलावा पास किया जा रहा है। मुझे नहीं लगता कि यह मान्य है। / आप जीसीसी उपयोग कर रहे हैं आप की जगह ले सकता #include<algorithm>साथ #import<regex>।
— user202729
मैं इसे बदल दूंगा जब GCC आउटपुट के रूप में दिए गए पॉइंटर का उपयोग बंद करने का फैसला करता है
— l4m2
... इतना है कि उत्पादन के लिए सूचक? तब मान्य लगता है। लेकिन आपको स्पष्ट रूप से इनपुट / आउटपुट प्रारूप का उल्लेख करना चाहिए।
— user202729
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.