मिस्सी इलियट, एक्सकेसीडी और एएससीआईआई बाइट्स

9

निम्नलिखित XKCD हास्य से प्रेरित:

यहां छवि विवरण दर्ज करें

मिस्सी इलियट के "वर्क इट" में, कोरस का हिस्सा निम्नानुसार है:

Is it worth it, let me work it

I put my thing down, flip it and reverse it

ध्यान में रखते हुए, मैं निम्नलिखित कोड गोल्फ चुनौती का प्रस्ताव करता हूं:

ऐसा कोड बनाएँ, जो क्रम में हो:

  1. एसटीडीआईएन से 8-बिट एएससीआईआई इनपुट लेता है; उदाहरण के लिए n(हेक्स 6 ई या बिन 01101110)
  2. 1 बिट स्तर (मेरा मानना है कि यह एक बिटवाइज़ पारी नीचे कहा जाता है) नीचे परिवर्तन प्रत्येक बाइट के 8 बिट, जैसे 01101110हो जाता है 00110111( "मेरी बात नीचे रख");
  3. प्रत्येक बाइट के बिट्स उलट, जैसे 00110111हो जाता है 11001000( "यह फ्लिप");
  4. प्रत्येक बाइट के लिए बिट्स को उलट देता है, जैसे 11001000बन जाता है 00010011 ("इसे उल्टा करें");
  5. यदि बाइट का मान 32 से कम है, तो प्रदर्शन करें (95 + [byte value]), या दूसरे शब्दों में, (126-(31-[byte value]))बाइट पर ASCII में वापस कनवर्ट करने से पहले ... यदि बाइट का मूल्य अभी भी 32 से कम है, तो चरण 5 को दोहराएं
  6. यदि बाइट का मान 126 से अधिक है, तो ASCII पर वापस कनवर्ट करने से पहले बाइट पर ([byte value] - 95), प्रदर्शन करें , या दूसरे शब्दों में (32+([byte value]-127))... यदि मान अभी भी 126 से अधिक है, तो चरण 6 को दोहराएं।
  7. ASCII के रूप में नई परिवर्तित स्ट्रिंग प्रदर्शित करें।

कार्रवाई में इस कोड का एक उदाहरण:

(इनपुट, क्या यह इसके लायक है?)

workit missy ("मिस्सी" इनपुट होने के नाते, "वर्किट" फ़ंक्शन है)

अब पर्दे के पीछे ...

(मुझे यह काम करने दो ... बाइनरी में)

01101101 01101001 01110011 01110011 01111001

(मेरी बात नीचे रखो ... बिटवाइस)

00110110 00110100 00111001 00111001 00111100

(...पलट दो...)

11001001 11001011 11000110 11000110 11000011

(... और इसे उल्टा करें!)

10010011 11010011 01100011 01100011 11000011

(वापस दशमलव में परिवर्तित)

147 211 99 99 195

(आवश्यक गणित करें)

147-95 211-95 99 99 195-95 => 52 116 99 99 100

(ASCII और प्रदर्शन, आउटपुट पर वापस जाएं)

4tccd

नियम

  1. सबसे छोटा कोड जीतता है ... उतना ही सरल ...
  2. इनपुट फ़ंक्शन के माध्यम से, आपके द्वारा या आपके लिए जो भी काम करता है, तब तक हो सकता है, इसलिए जब तक आप नियम 1 "काम कर सकते हैं" आपके लिए ...);
  3. मैं रिवर्सलिबिलिटी के बाद नहीं हूं, इसलिए जब तक आप कोड बना सकते हैं जो मैंने इसे करने के लिए कहा है, मुझे खुशी होगी ...

शुभकामनाएँ!

code-golf  printable-ascii 
— WallyWest
स्रोत
3
क्या हमें परवाह है कि यह एक प्रतिवर्ती प्रक्रिया नहीं है? जब बिट शिफ्ट किया जाता है तो कम से कम महत्वपूर्ण बिट अनिवार्य रूप से दूर फेंक दिया जाता है।
— सेमिच
1
मुझे मिलता है 0 1 1 0 1 1 0 1और के 0 1 1 0 1 0 0 1लिएmi
— marinus
2
मैंने हमेशा आश्चर्यचकित किया कि वह गीत किस बारे में था ...
— 2
2
नियम ऐसा नहीं करते, वे करते हैं? उदाहरण के लिए: Pबाइट मूल्य में बदल जाता है 235और 95आपके साथ घटता है 140। फिर भी अप्राप्य है। या मुझे गलतफहमी है?
— डैरेन स्टोन
2
नियमों में फेरबदल से सावधान रहें। आपके पास बहुत से प्रस्तुत उत्तर हैं जो आपकी वर्तमान परिभाषा के अनुरूप हैं।
— डैरेन स्टोन

जवाबों:

5

एपीएल  50  45

⎕UCS n+95ׯ1++⌿126 31∘.≥n←2⊥⊖~(8/2)⊤⌊.5×⎕UCS⍞

कीबोर्ड पर इनपुट लेता है, जैसे:

      ⎕UCS n+95ׯ1++⌿126 31∘.≥n←2⊥⊖~(8/2)⊤⌊.5×⎕UCS⍞
missy
4tccd
— मारीनस
स्रोत
मैं करने के लिए 45 अपने जवाब नीचे में सुधार की स्वतंत्रता ले लिया (संपादन लंबित हो।) यह मेरी अपनी के रूप में यह पोस्ट करने के लिए तुम्हारा से बहुत ज्यादा ले लिया
— Tobia
4

GolfScript 43 38 35

{2/~512+2base(;-1%2base-32+95%32+}%

स्पष्टीकरण: स्ट्रिंग में प्रत्येक वर्ण के लिए, हम निम्न कार्य करेंगे:

2/ # "Put your thing down": do integer division (accomplishing a bit shift).
~ # "Flip it": negate the bits of the integer.
512+ #make sure the binary form will have sufficient initial 0s (the extra initial 1 will be removed).
2base #convert string to value in base 2 (as an array)
(; #remove the initial 1 added by the 512 addition
-1% # "Reverse it": reverse the array
2base #convert back to base 10
-32+95%32+ #this does the equivalent of the subtraction/addition logic

उपयोग:

echo 'missy' | ruby golfscript.rb workit.gs
> 4tccd

पीटरटयूर की मदद के लिए धन्यवाद।

— बेन रीच
स्रोत
चतुर, और अब तक आप लीड में हैं!
— 5
मैं आमतौर पर पाता हूं कि आधार रूपांतरण करते समय अंकों की गारंटीकृत संख्या प्राप्त करने का सबसे अच्छा तरीका पहले से उपयुक्त मूल्य जोड़ना है। इसके बजाय Ie 2base{0\+.,9<}doहोगा 512+2base(;। यह भी ध्यान दें कि यदि इरादा केवल सही आउटपुट प्राप्त करने का है तो आप ऑपरेशंस को फिर से व्यवस्थित कर सकते हैं, इसलिए इसके बजाय {!}%आपको ~बेस कन्वर्जन से पहले इनपुट की आवश्यकता है (और फिर 512+साथ बदलें 511&)।
— पीटर टेलर
धन्यवाद @PeterTaylor - 512 चाल एकदम सही है! प्रश्न की भावना में, हालांकि, मुझे लगता है कि हमें उपेक्षा करने से पहले थोड़ा बदलाव करना चाहिए।
— बेन रीच
यदि आप 2/एक बिट शिफ्ट के रूप में गिनती करते हैं तो आप अभी भी बिट शिफ्ट कर सकते हैं, फिर ~, बेस कन्वर्ट ...
— पीटर टेलर
@PeterTaylor मुझे यह पसंद है! सहायता के लिए धन्यवाद।
— बेन रीच
3

के, 68 58

{"c"${$[a<32;95;a>126;-95;0]+a:6h$0b/:|~8#0b,0b\:x}'4h$'x}

।

k){"c"${$[a<32;95;a>126;-95;0]+a:6h$0b/:|~8#0b,0b\:x}'4h$'x}"missy"
"4tccd"
— tmartin
स्रोत
1

रूबी, 115

यह प्रविष्टि अक्षम्य रूप से लंबी है। तो मैं साथ जाऊंगा, "लेकिन आप इसे पढ़ सकते हैं!" :-P

$><<gets.chars.map{|c|c=(c.ord.to_s(2)[0..-2].tr('01','10').reverse+'11').to_i(2)
(c+(c<32?95:c>126?-95:0)).chr}*''

से पढ़ता है stdin:

missy
4tccd
— डैरेन स्टोन
स्रोत
1

पायथन 2.7, 106

एक और लंबा जवाब, लेकिन हे यह मेरी पहली कोशिश है:

for c in raw_input():x=sum(1<<7-i for i in range(8)if~ord(c)>>1+i&1);print'\b%c'%(x+95*((x<32)-(x>126))),

डैरेन स्टोन के नीचे संशोधित और जीआरसी की टिप्पणी नीचे ...

— Sinkingpoint
स्रोत
आप के बाद अंतरिक्ष छोड़ सकते हैं a:।
— डैरेन स्टोन
आप अपनी अंतिम chrअभिव्यक्ति को 1-चार बचत के लिए बदल सकते हैं chr(x-(95,(-95,0)[x>32])[x<126]):।
— डैरेन स्टोन
थोड़ा छोटा:print'\b%c'%(x+95*((x<32)-(x>126))),
— grc
1

पायथन 2.7 - 73 86

नियमों में परिवर्तन के लिए धन्यवाद मुझे बाइनरी और पूर्णांक हेरफेर का उपयोग करके यह सब करने का एक बहुत सरल तरीका मिला। यह एक अस्थायी चर की जरूरत नहीं द्वारा Quirlioms पर जगह बचाता है:

for i in input():print chr((int(bin(ord(i)>>1^255)[:1:-1],2)-32)%95+32),

> python workit.py
"missy"
4 t c c d
> python workit.py
"P Diddy"
- 9 \ t T T d

और स्पष्टीकरण के रूप में:

for i in input():  # Take an input, better quote it
                   # Is it worth it? Let me work it
  print chr(
    int(bin(
        ord(i)>>1  # Put my thing down by bitshifting it
             ^255  # XOR it with 255 to flip the bits and pad to 8 bits
        )[:1:-1]   # Then reverse it (but don't take the cruft
                   # python puts at the start of binary strings)
    ,2) 
    )-32)%95+32    # This pulls everything into the 32-126 range
  ),
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.