टॉगल, प्रिंट, दोहराएं

Question

यह चुनौती अनियोजित एसोलंग पाडा से काफी हद तक प्रेरित है ।

8 बिट्स की एक सरणी पर विचार करें, जो शून्य से आरंभिक है। हम मनमाने तार को छापने के लिए एक बहुत ही न्यूनतम निर्देश सेट करेंगे। दो निर्देश हैं, दोनों एक पैरामीटर लेते हैं Nजो कि एक बिट का सूचकांक है:

• t Nके लिए टी oggle: इस बिट का मान बदल जाता है N।
• p Nके लिए पी प्रिंट करें: एक बाइट के रूप में व्याख्या इस सब 8 बिट्स, बिट से शुरू Nऔर अंत के आसपास लपेटन । इस बाइट के अनुरूप चरित्र को STDOUT में मुद्रित किया जाता है।

आइए एक उदाहरण देखें। हम छापना चाहते हैं :=। इस प्रकार हम इसे प्राप्त करते हैं (0-आधारित बिट सूचकांक):

t 2    [0 0 1 0 0 0 0 0]
t 3    [0 0 1 1 0 0 0 0]
t 4    [0 0 1 1 1 0 0 0]
t 6    [0 0 1 1 1 0 1 0]
p 0    [0 0 1 1 1 0 1 0] == 58 == ':'
t 5    [0 0 1 1 1 1 1 0]
t 6    [0 0 1 1 1 1 0 0]
t 7    [0 0 1 1 1 1 0 1]
p 0    [0 0 1 1 1 1 0 1] == 61 == '='

लेकिन इसके बजाय, हम चक्रीय सुविधा का उपयोग कर सकते हैं pऔर दो निर्देशों को बचा सकते हैं:

t 2    [0 0 1 0 0 0 0 0]
t 3    [0 0 1 1 0 0 0 0]
t 4    [0 0 1 1 1 0 0 0]
t 6    [0 0 1 1 1 0 1 0]
p 0    [0 0 1 1 1 0 1 0] == 58 == ':'
t 1    [0 1 1 1 1 0 1 0]
p 7    [0 1 1 1 1 0 1 0] == [0 0 1 1 1 1 0 1] == 61 == '='
                      ^

तो p 7बस पहले के बजाय अंतिम बिट से बाइट मान पढ़ना शुरू कर देता है।

चुनौती

मुद्रण योग्य ASCII वर्ण (0x20 से 0x7E, समावेशी) की एक गैर-रिक्त स्ट्रिंग को देखते हुए, उपरोक्त सिस्टम के साथ उस स्ट्रिंग को मुद्रित करने के लिए निर्देशों की एक इष्टतम सूची (निर्देश के अनुसार एक पंक्ति) का उत्पादन करें। यदि कई इष्टतम समाधान हैं (जो लगभग हमेशा मामला होगा), उनमें से केवल एक को उत्पन्न करें।

आप बिट्स के लिए 0-आधारित और 1-आधारित अनुक्रमण के बीच चयन कर सकते हैं, लेकिन कृपया अपनी पसंद बताएं।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं। यदि आप परिणाम को STDOUT में प्रिंट नहीं करते हैं, तो यह अभी भी एक एकल नईलाइन-पृथक स्ट्रिंग होनी चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

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

प्रत्येक परीक्षण मामला एक एकल पंक्ति है जिसमें इनपुट स्ट्रिंग होती है, उसके बाद निर्देशों की इष्टतम संख्या, एक संभव समाधान होता है।

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

?
7 instructions
t 2
t 3
t 4
t 5
t 6
t 7
p 0

:=
7 instructions
t 2
t 3
t 4
t 6
p 0
t 1
p 7

0123456789
26 instructions
t 2
t 3
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0
t 5
t 6
t 7
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0
t 2
t 3
p 3
t 2
p 3

9876543210
28 instructions
t 2
t 3
t 4
t 7
p 0
t 7
p 0
t 0
t 7
p 5
t 4
p 5
t 0
t 5
p 0
t 7
p 0
t 5
t 6
t 7
p 0
t 7
p 0
t 6
t 7
p 0
t 7
p 0

Hello, World!
39 instructions
t 1
t 4
p 0
t 3
t 7
p 2
t 1
t 6
p 2
p 2
t 0
t 1
p 2
t 0
t 1
t 3
p 2
t 6
t 7
p 2
t 0
t 2
t 6
t 7
p 1
t 0
t 1
t 5
p 0
t 2
t 7
p 3
t 2
t 6
p 0
t 4
p 0
t 1
p 3

The quick brown fox jumps over the lazy dog.
150 instructions
t 1
t 3
t 5
p 0
t 1
t 2
p 1
t 1
t 3
t 7
p 0
t 1
t 5
t 7
p 0
t 1
t 3
t 7
p 0
t 5
p 0
t 3
t 4
t 5
p 0
t 4
t 6
p 0
t 4
p 0
t 1
t 4
t 6
t 7
p 0
t 1
t 6
p 0
t 3
p 0
t 0
t 5
p 4
t 0
t 7
p 0
t 1
p 1
t 3
t 5
t 6
t 7
p 0
t 1
t 5
t 6
p 0
t 4
t 7
p 0
t 1
t 2
p 3
t 5
t 6
t 7
p 2
t 1
t 2
t 6
p 0
t 0
p 7
t 0
t 7
p 5
t 3
t 4
t 6
t 7
p 0
t 6
t 7
p 0
t 1
t 3
t 6
t 7
p 0
t 1
t 4
t 5
t 6
t 7
p 0
t 4
p 4
t 6
p 0
t 1
t 6
p 4
t 5
t 6
t 7
p 0
t 1
t 3
t 5
p 0
t 1
p 1
t 1
t 3
t 7
p 0
t 1
t 5
t 7
p 0
t 1
t 4
t 5
p 0
t 1
p 3
t 3
t 7
p 1
t 1
t 5
p 0
t 1
t 3
t 4
t 7
p 0
t 1
t 5
p 0
t 4
t 6
t 7
p 0
t 4
p 0
t 1
t 4
t 7
p 0

इस CJam संदर्भ कार्यान्वयन के साथ परीक्षण मामले उत्पन्न हुए थे ।

Answer 1

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

U]8*l{i2b8Ue[8,{1$m>2$.^:+}$0=_@m>@1$.^ee{~{"t "op}{;}?}/"p "o\p}/;

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

स्पष्टीकरण:

U]8*    Build start bit array [0 0 0 0 0 0 0 0].
l       Get input.
{       Start loop over input characters.
  i       Convert character to integer.
  2b      Convert to binary array.
  8Ue[    Pad to 8 entries with leading 0.
  8,      Generate list of possible rotation amounts.
  {       Start of sort function block.
    1$      Get bit array of character.
    m>      Rotate by rotation amount.
    2$      Get previous bit array.
    .^      Element-wise xor to get different bits.
    :+      Add elements in result to get count of different bits.
  }$      Sort possible rotations by count of different bits.
  0=      Get first rotation amount in sorted list, which is the one with the
          one that results in the smallest count of different bits.
  _       Copy count. Will use original for "p" output later.
  @       Get the character bit array to top of stack.
  m>      Rotate it, to get optimal rotated bit array.
  @       Get previous bit array to top of stack.
  1$      Copy rotated bit array, will need the original as starting point
          for next character.
  .^      Element-wise xor to get different bits.
  ee      Enumerate array to get pairs of index and bit value.
  {       Loop over bits.
    ~       Unpack index bit pair.
    {       Start of if block for bit value.
      "t "o   Output "t ".
      p  Output index and newline.
    }       End of if block.
    {       Start of else block.
      ;       Pop the index value.
    }?      End of ternary if.
  }/      End loop over bits.
  "p "o   Output "p ".
  \       Swap rotation amount to top.
  p       Print rotation amount and newline.
}/      End loop over input characters.
;       Ppp current bit array off stack to prevent extra output.

Answer 2

रूबी, १1१

->w{s=[0]*8
w.chars.flat_map{|c|z=0..7
*m,i=z.map{|j|z.select{|k|s[k]!=z.map{|i|c.ord[i]}.rotate(j)[k]}<<j}.min_by &:size
m.map{|m|s[m]=1-s[m];"t #{7-m}"}+["p #{i}"]}*?\n}

एक रूबी फ़ंक्शन जो संदर्भ कार्यान्वयन का केवल दोगुना है। :)

इसे ऑनलाइन आज़माएं: http://ideone.com/ysYyFP

यह कार्यक्रम बहुत कठिन है: यह 0 से सेट 8 बिट्स के साथ शुरू होता है और पात्रों के माध्यम से पुनरावृत्त होता है। प्रत्येक चरण में, यह वर्तमान स्थिति से एक राज्य के लिए सबसे छोटा रास्ता लेता है जो चरित्र को मुद्रित करने की अनुमति देगा। यह निर्दिष्ट प्रारूप में एक स्ट्रिंग देता है।

कार्यक्रम का प्रारंभिक (कम गोल्फ वाला) संस्करण यहां उपलब्ध है ।

Answer 3

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

अभी भी बहुत कुछ गोल्फ के लिए है।

0]8*q{i2b8Te[8,\fm>:X\_@\f.=::+_$W=#:YX=_@.{=M['tSUN]?U):U;}o0:U;['pSYN]o}/;

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