स्ट्रिंग टू बिट ट्रांज़िशन

10

कार्य

एक या एक से अधिक ASCII वर्णों के इनपुट स्ट्रिंग को देखते हुए, जो कोडपॉइंट्स 0 और 128 (अनन्य) के बीच हैं, निम्नलिखित करें:

  1. प्रत्येक वर्ण को उसके 7-बिट ASCII कोड में बदलें (यदि ASCII कोड 7 बिट्स से कम है, तो अग्रणी शून्य बिट्स डालें)
  2. सभी बिट्स को मिलाएं (यह 7*nबिट्स में परिणाम है जहां nवर्णों की संख्या है)
  3. इस बिटस्ट्रीम में प्रत्येक बिट के लिए, 1 प्रिंट करें यदि वह पिछले बिट से अलग है, और 0 प्रिंट करें अन्यथा। पहला आउटपुट बिट हमेशा 1 होता है।

उदाहरण

इनपुट:

Hi

आउटपुट:

11011001011101

स्पष्टीकरण:

स्ट्रिंग "हाय" में ASCII कोड हैं

72 105

जो बिट्स में हैं:

1001000 1101001

और संक्रमण बिट्स संकेतक:

11011001011101

यह कोड गोल्फ है। सबसे कम बाइट गिनती जीत।

परीक्षण के मामलों

टेस्ट केस 1:

Hello World!
110110010101110011010101101010110001110000111110000110000001011101101010101100110001

टेस्ट केस 2:

%% COMMENT %%
1110111111011111100001100010010100001010110101011010011101010011111110011000001101111110111

टेस्ट केस 3 (लुइस मेंडो का श्रेय):

##
11100101110010

MATL में 9 बाइट्स के साथ सबसे कम समाधान के लिए लुइस मेंडो को बधाई!

code-golf  string  bitwise 
— justhalf
स्रोत
2
सुझाए गए परीक्षण मामले ##(अग्रणी 0बिट; कुछ जवाब वर्तमान में उस वजह से विफल हो जाते हैं)
— लुइस मेंडो
4
यह मैनचेस्टर एन्कोडिंग चुनौती का एक डुप्लिकेट कैसे है? क्या मैं कुछ भूल रहा हूँ?
— गैस्ट्रोपनर
2
दूसरी चुनौती बिट्स के इनपुट स्ट्रीम को एक डबल-रेट आउटपुट स्ट्रीम में परिवर्तित करने के लिए कहती है, जिसमें प्रत्येक इनपुट '1' का अनुवाद '01' और प्रत्येक इनपुट '0' का अनुवाद '10' में किया जाता है । तो मेरी राय में धोखा नहीं है। यदि बड़ी संख्या में लोग @ गैस्ट्रोपनर की टिप्पणी को ऊपर उठाते हैं तो मैं अन-ड्यू (या उस क्षमता वाला कोई अन्य उपयोगकर्ता) कर सकता हूं
— लुइस मेंडू
1
@ शैगी: दोनों परीक्षण मामलों में एक स्थान शामिल है, जिसमें केवल एक बिट सेट है, और 7 वें नहीं। इसलिए मुझे नहीं लगता कि समस्या कथन की गारंटी है कि प्रत्येक एएससीआई कोड की लंबाई 7 बिट्स होगी।
— पुनरावर्ती
1
@SmileAndNod दूसरे विचार पर, मुझे लगता है कि आपको खाली स्ट्रिंग को संभालने की आवश्यकता नहीं है।
— २१:४ 'पर

जवाबों:

4

MATL , 9 बाइट्स

Hj7&B!hdg

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

व्याख्या

H     % Push 2
j     % Read line of input, unevaluated
7&B   % Convert to binary with 7 bits. Gives a 7-column matrix
!     % Transpose
h     % Concatenate horiontally. The matrix is read in column-major order
d     % Consecutive differences
g     % Convert to logical. Implicitly display
— लुइस मेंडो
स्रोत
1
यह अब तक का सबसे छोटा है। +1। यह मज़ेदार है कि इसमें अंतर्निहित अंतर हो।
— 19
4

जाप -P , 11 बाइट्स

इस तथ्य का लाभ उठाता है कि 0जब कोई गणितीय प्रदर्शन करने की कोशिश कर रहा है या इस मामले में बिटवाइज़ ऑपरेशन कर रहा है, तो रिक्त स्थान को जावास्क्रिप्ट में ज़ब्त किया जा सकता है।

c_¤ù7Ãä^ i1

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

c_¤ù7Ãä^ i1     :Implicit input of string
c_              :Map codepoints
  ¤             :  Convert to binary string
   ù7           :  Left pad with spaces to length 7
     Ã          :End map
      ä^        :XOR consecutive pairs
         i1     :Prepend 1
                :Implicitly join and output
— झबरा
स्रोत
7-बिट का मतलब है कि अगर यह 32 (अंतरिक्ष वर्ण के लिए) है, तो यह होगा 0100000। इसके अलावा% चरित्र (37) होगा0100101
— औचित्य
अब यह काम कर रहा है। +1
— 17-11 को
2

सीजेएम , 21 बाइट्स

1q{i2b7Te[}%e__(;.^);

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

व्याख्या

नमूना इनपुट के साथ स्टैक दिखाना 5:

1 q      e# Push 1 and then the whole input: 1 "5"
{
  i      e# Convert to its char code: 1 [53]
  2 b    e# Convert to binary: 1 [[1 1 0 1 0 1]]
  7 T e[ e# Left-pad with 0 to length 7: 1 [[0 1 1 0 1 0 1]]
} %      e# Map this block over every character in the string
e_       e# Flatten array: 1 [0 1 1 0 1 0 1]
_ ( ;    e# Duplicate array and remove its first element: 1 [0 1 1 0 1 0 1] [1 1 0 1 0 1]
. ^      e# Element-wise xor: 1 [1 0 1 1 1 1 1]
) ;      e# Remove and pop the last element of the array: 1 [1 0 1 1 1 1]
         e# Stack implicitly printed: 1101111

यह देखने के लिए कि क्या पिछले बिट से थोड़ा अलग है, हम पहले तत्व के बिना बिट सरणी और बिट सरणी के बीच एक वेक्टर (तत्व-वार) xor करते हैं। हम परिणाम के अंतिम बिट को भी हटाते हैं, क्योंकि यह हमेशा अपरिवर्तित लंबे अरै के अंतिम बिट होता है।

— NinjaBearMonkey
स्रोत
2

एपीएल (Dyalog यूनिकोड) , 16 बाइट्स SBCS

पूरा कार्यक्रम। स्टड से स्ट्रिंग के लिए संकेत।

1,2≠/∊1↓¨11⎕DR¨⍞

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

⍞ इनपुट के लिए संकेत ("कंसोल में एक उद्धरण")

11⎕DR¨ प्रत्येक चरित्र को बिट-बूलियन डी अता आर इलिकेशन में बदलें

1↓¨ प्रत्येक से पहली बिट ड्रॉप

∊ ϵ nlist (समतल)

2≠/ जोड़ीदार अंतर

1, किसी एक को रोकना

— एडम
स्रोत
2

चारकोल , 25 बाइट्स

⭆θ◧⍘℅鲦⁷←Ｗⅈ←Ｉ﹪⍘ＫＤ²←01 ²1

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

⭆θ◧⍘℅鲦⁷←

सभी वर्णों को बाइनरी में कनवर्ट करें और उन्हें 7 की लंबाई तक पैड करें और फिर उन्हें प्रिंट करें, लेकिन अंतिम अंक पर कर्सर छोड़ दें।

Ｗⅈ

कर्सर को पहले अंक से अधिक होने तक दोहराएं।

←Ｉ﹪⍘ＫＤ²←01 ²

गणना करें कि क्या अंक अलग-अलग हैं और प्रत्येक अंक को अंतर के साथ ओवरराइट करें।

1

के साथ पहला अंक ओवरराइट करें 1।

— नील
स्रोत
2

पॉवरशेल , 73 56 49 बाइट्स

$args|%{$b=+$_
6..0}|%{+($c-ne($c=($b-shr$_)%2))}

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

-17 बाइट्स mazzy के लिए धन्यवाद :)

— आंद्रेई ओडेगो
स्रोत
1
— माज़ी जूल
बहुत बढ़िया, आपको इसे स्वयं पोस्ट करना होगा।
— आंद्रेई ओडेगो
यह जवाब आपके लिए। मेरी राजकुमारी एक और महल में है :))))
— mazzy
1
@ माज़ी, कुछ और -7 बाइट्स :)
— आंद्रेई ओडेगो
भयानक और शानदार! 【'【
— माज़ी
2

रूबी -p , 68 57 बाइट्स

-11 बाइट्स को बेशर्मी से xnor के पायथन सॉल्यूशन द्वारा उपयोग की जाने वाली विधि को चुराकर ।

l=1
gsub(/./){l=l<<7|$&.ord}
$_=?1+(l^l/2).to_s(2)[2..-1]

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

मूल समाधान:

gsub(/./){'%07b'%$&.ord}
l=p
gsub(/./){b=$&.ord-48;r=l ?l^b:1;l=b;r}

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

— मूल्य स्याही
स्रोत
2

ऑक्टेव , 36 30 बाइट्स

लुइस मेंडो के लिए धन्यवाद ठीक करें

-२ बाइट्स सांचेस को धन्यवाद 

@(a)[1;~~diff(de2bi(a,7)'(:))]

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

— समय सीमा समाप्त डेटा
स्रोत
आप शायद कुछ बाइट्स के साथ शेव कर सकते हैं de2bi।
— सैन जूस
@Sanchises से पहले मेरे लिए काम नहीं कर रहा था, लेकिन मैं एक और नज़र डालूंगा जब मैं कर सकता हूं
— डेटा
— Sanchises
1

डार्ट , 213 168 बाइट्स

f(s,{t,i}){t=s.runes.map((r)=>r.toRadixString(2).padLeft(7,'0')).join().split('').toList();for(i=t.length-1;i>0;i--)t[i]=t[i]==t[i-1]?'0':'1';t[0]='1';return t.join();}

पिछला एक-लाइनर

f(String s)=>'1'+s.runes.map((r)=>r.toRadixString(2).padLeft(7,'0')).join().split('').toList().reversed.reduce((p,e)=>p.substring(0,p.length-1)+(p[p.length-1]==e?'0':'1')+e).split('').reversed.join().substring(1);

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

यह वाचालता और आसान निर्मित इन्स की कमी वास्तव में इसे मार रही है। फिर भी एक लाइनर खींचने में कामयाब रहे।

  • -45 बाइट्स एक लाइनर का उपयोग न करके और लूप के लिए उपयोग करके
— Elcan
स्रोत
1

कोटलिन , 182 बाइट्स

var l='6'
fun f(b:String)=b.fold(""){t,i->t+"".a(i.toInt())}.map{if(l==it){l=it;0} else {l=it;1}}
fun String.a(v:Int):String=if(v<=0)"${this}0".reversed() else "${this}${v%2}".a(v/2)

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

उम्मीद है कि मैं जल्द ही इसमें सुधार कर सकता हूं, मुझे लगता है कि सुधार के लिए कुछ स्पॉट होने चाहिए लेकिन मैं अभी सोच नहीं सकता

— क्विन
स्रोत
1

रूबी -p , 50 बाइट्स

gsub(/./){"%07b"%$&.ord}
gsub(/./){$`=~/#$&$/?0:1}

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

व्याख्या

पहली पंक्ति, मान इंक के उत्तर के समान :

gsub(/./){       $&    }   # Replace each character $&…
                   .ord    # …with its ASCII code…
                %          # …formatted as…
          "%07b"           # …binary digits padded to 7 places.

दूसरी पंक्ति:

gsub(/./){      $&      }  # Replace each character $&…
          $`               # …if the text to its left…
            =~             # …matches…
              /#  $/       # …the Regexp /c$/ where "c" is the character…
                    ?0:1   # …with 0, or 1 otherwise.

रूबी में आप Regexp के शाब्दिक अर्थों में प्रक्षेप का उपयोग कर सकते हैं, उदाहरण के लिए /Hello #{name}/, और इसके साथ शुरू होने वाले चर के लिए $या @आप घुंघराले ब्रेसिज़ को छोड़ सकते हैं, इसलिए यदि उदाहरण $&है "0"तो ग्रैवलिक्स /#$&$/बन जाता है /0$/।

— जॉर्डन
स्रोत
1

के (ngn / k) , ९ १३ बाइट्स

समाधान:

~=':,/(7#2)\'

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

स्पष्टीकरण:

~=':,/(7#2)\' / the solution
           \' / convert each
      (   )   / do this together
       7#2    / 2 2 2 2 2 2 2
    ,/        / flatten
 =':          / equal to each-previous?
~             / not

टिप्पणियाँ:

  • +4 बाइट्स केवल 6-बिट वर्णों वाले स्ट्रिंग्स का समर्थन करने के लिए
— streetster
स्रोत
#उदाहरण के लिए इनपुट के लिए यह विफल प्रतीत होता है (आउटपुट में केवल 6 बिट्स हैं)
— लुइस मेंडो
@streetster, क्या आप निश्चित संस्करण पोस्ट करना चाहते हैं?
— १
1

इमोजीकोड , 263 बाइट्स

🏁🍇🔤🔤➡️🖍🆕s🔂b📇🆕🔡👂🏼❗️❗️🍇🍪s🔪🔡🔢b❗️➕128 2❗️1 7❗️🍪➡️🖍s🍉🔤?🔤➡️🖍🆕p🔂b s🍇↪️b🙌p🍇👄🔤0🔤❗️🍉🙅🍇👄🔤1🔤❗️🍉b➡️🖍p🍉🍉

इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

🏁 🍇  💭 Main code block
    🔤🔤 ➡️ 🖍 🆕 s  💭 Start with s as the empty string
    🔂 b 📇 🆕 🔡 👂🏼  💭 For each byte b in the input ...
    ❗️ ❗️ 🍇
        🍪 s  💭 ... append ...
           🔪 🔡 🔢 b ❗️ ➕ 128  💭 ... b + 128 (this gives the leading zero(s) in case the binary representation of b is shorter than 7 digits) ...

                 2  💭 ... in binary ...
              ❗️
              1 7  💭 ... without the leading one ...
           ❗️
        🍪
        ➡️ 🖍 s  💭 ... to s
    🍉
    🔤?🔤 ➡️ 🖍 🆕 p  💭 This will be used as the previous character, by assigning it neither 0 nor 1 we assure the first bit output is always a one
    🔂 b s 🍇  💭 For each character in s:
        ↪️ b 🙌 p 🍇  💭 If it is the same as the previous character ...
            👄 🔤0🔤 ❗️  💭 ... output a zero ...
        🍉 🙅 🍇  💭  ... else ...
            👄 🔤1🔤 ❗️ 💭 ... output a one
        🍉
        b ➡️ 🖍 p  💭 And the current character becomes the new previous character.
    🍉
🍉
— OOBalance
स्रोत
1

पायथन 3.8 , 72 बाइट्स

समाधान:

lambda a:["10"[a==(a:=x)]for x in"".join(bin(ord(i)+128)[3:]for i in a)]

स्पष्टीकरण:

जब से पायथन 3.8 ने असाइनमेंट एक्सप्रेशंस (मानक असाइनमेंट स्टेटमेंट्स के बजाय) पेश किए हैं, मैं उन्हें एक सूची समझ में उपयोग करना चाहता हूं जिसे अंतिम आइटम को याद रखने की आवश्यकता है। यह ऐसा करने का सबसे अच्छा तरीका नहीं है, लेकिन असाइनमेंट अभिव्यक्ति का उपयोग करने का एक दिलचस्प तरीका दर्शाता है।

कोड एक लंबो फ़ंक्शन बनाता है जो आवश्यक तर्क लेता है जो परिवर्तित करने के लिए स्ट्रिंग है। जब बुलाया जाता है, तो फ़ंक्शन निम्नानुसार होता है। प्रत्येक वर्ण को उसके वर्ण कोड में बदल दिया जाता है, जिसे 6-बिट पात्रों से निपटने के लिए 128 जोड़ा जाता है (बाइनरी प्रतिनिधित्व हमेशा 8 बिट होगा और हम पहले बिट को काट सकते हैं)। यह संख्या बाइनरी और हेडर (0x) में बदल जाती है और शुरुआती 1 को 128 जोड़ने से कटा हुआ है। ये नए तार फिर एक बड़ी स्ट्रिंग में शामिल हो जाते हैं।

इस नए स्ट्रिंग में प्रत्येक वर्ण के लिए (जिसमें पाठ का संक्षिप्त 7-बिट प्रतिनिधित्व है), यह जांचा जाता है कि क्या चरित्र पिछले चरित्र के समान है। पहले किरदार के साथ क्या होता है? पहला परिणाम चरित्र हमेशा "1" होना चाहिए, इसलिए हमें बस यह सुनिश्चित करना होगा कि जो भी अंतिम वर्ण चर में है, वह "1" या "0" नहीं है। हम मूल पैरामीटर को अब पुन: उपयोग करके ऐसा करते हैं कि हम अब इसका उपयोग नहीं कर रहे हैं। यह एक समस्या हो सकती है यदि मूल स्ट्रिंग एक एकल "0" (एक एकल "1" सिर्फ काम करने के लिए होती है) लेकिन हम इसे अनदेखा करेंगे।

तुलना के दौरान, पिछले चरित्र का मूल्यांकन पहले किया गया था, इसलिए जब हम असाइनमेंट एक्सप्रेशन का उपयोग कर पिछले कैरेक्टर वैरिएबल को वर्तमान कैरेक्टर पर सेट करते हैं, तो यह तुलना एक्सप्रेशन के मूल्यांकन को प्रभावित नहीं करता है।

तुलना या तो सही या गलत पैदा करती है जिसे क्रमशः पायथन में 1 या 0 के रूप में भी इस्तेमाल किया जा सकता है, इसलिए उनका उपयोग या तो एक "1" या "0" को एक स्ट्रिंग में देखने के लिए किया जाता है।

— infinityCoding
स्रोत
आप स्ट्रिंग प्रारूप शाब्दिक का उपयोग करके कुछ बाइट्स बचा सकते हैं: bin(ord(i)+128)[3:]->f"{ord(i):07b}"
— चलित
1

Tcl , 215 167 140 बाइट्स

{{s {B binary} {X ~$w/64}} {join [lmap c [split $s {}] {$B scan $c c w;$B scan [$B format i [expr 2*$w^$w^$X<<7]] B7 r;set X $w;set r}] ""}}

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

बदलाव का पता लगाने के लिए शिफ्ट-बाय-वन और एक्सक्लूसिव का उपयोग करता है। अगले चरित्र के msb के लिए वर्तमान चरित्र के lsb वहन करती है। लैम्प द्वारा लौटी सूची में शामिल होकर प्रत्येक वर्ण के लिए आउटपुट को जोड़ती है।

प्रारंभ और दोहराया आदेशों पर बाइट्स को बचाने के लिए डिफ़ॉल्ट तर्कों के साथ लैम्ब्डा का उपयोग करता है।

ऑपरेशन के आदेश पर बहुत निर्भर करता है। खाली स्ट्रिंग के लिए काम करता है।

— SmileAndNod
स्रोत
1

05AB1E (विरासत) , 12 बाइट्स

Çb7jð0:¥ÄJ1ì

05AB1E के विरासत संस्करण का उपयोग करता है, क्योंकि jअंतर्निहित रूप से तार एक साथ जुड़ते हैं, जिसे 05AB1E के नए संस्करण में स्पष्ट Jकरने के बाद की आवश्यकता होती है j।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Ç             # Convert the (implicit) input-string to a list of ASCII code-points
              #  i.e. "Hi#" → [72,105,35]
 b            # Convert each integer to a binary string
              #  → ["1001000","1101001","100011"]
  7j          # Prepend each with spaces to make them length 7,
              # and join everything together to a single string implicitly
              #  → "10010001101001 100011"
    ð0:       # Replace all those spaces with 0s
              #  → "100100011010010100011"
       ¥      # Get the deltas of each pair of 1s/0s
              #  → [-1,0,1,-1,0,0,1,0,-1,1,-1,0,1,-1,1,-1,0,0,1,0]
        Ä     # Get the absolute value of this
              #  → [1,0,1,1,0,0,1,0,1,1,1,0,1,1,1,1,0,0,1,0]
         J    # Join them all together
              #  → "10110010111011110010"
          1ì  # And prepend a 1
              #  → "110110010111011110010"
              # (after which the result is output implicitly)
— केविन क्रूज़सेन
स्रोत
1

पायथन 3 , 88 84 बाइट्स

l=2;s=''
for c in''.join(f'{ord(c):07b}'for c in input()):s+='01'[l!=c];l=c
print(s)

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

मुझे लगता है कि असाइनमेंट से बचना चाहिए, लेकिन ऐसा करने का कोई तरीका नहीं सोच सकता।

अपडेट करें:

— justhalf
स्रोत
1
— Movatica
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.