गोल्फ बिट बुनाई

Question

नोट: इस चुनौती का पहला भाग मार्टिन एंडर की पिछली चुनौती, विज़ुअलाइज़ बिट वीविंग से आता है ।

गूढ़ प्रोग्रामिंग भाषा बुराई का बाइट मूल्यों पर एक दिलचस्प ऑपरेशन है जिसे वह "बुनाई" कहता है।

यह अनिवार्य रूप से बाइट के आठ बिट्स का क्रमपरिवर्तन है (इससे कोई फर्क नहीं पड़ता कि हम किस गिनती से शुरू करते हैं, क्योंकि पैटर्न सममित है):

• बिट 0 को बिट 2 में ले जाया जाता है
• बिट 1 को बिट 0 में ले जाया जाता है
• बिट 2 को बिट 4 में ले जाया जाता है
• बिट 3 को बिट 1 में ले जाया जाता है
• बिट 4 को बिट 6 में ले जाया जाता है
• बिट 5 को बिट 3 में ले जाया जाता है
• बिट 6 को बिट 7 में ले जाया जाता है
• बिट 7 को बिट 5 में ले जाया जाता है

सुविधा के लिए, यहां क्रमपरिवर्तन के तीन अन्य प्रतिनिधित्व हैं। एक चक्र के रूप में:

(02467531)

मानचित्रण के रूप में:

57361402 -> 76543210 -> 64725031

और मानचित्रण के जोड़े की सूची के रूप में:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

8बुनाई के बाद , बाइट अनिवार्य रूप से रीसेट हो जाती है।

उदाहरण के लिए, संख्या बुनाई 10011101(जो कि 157आधार 10 में है) का उत्पादन होगा 01110110(जो 118आधार 10 में है)।

इनपुट

केवल 256मान्य इनपुट होते हैं , अर्थात् सभी पूर्णांकों के बीच 0और 255समावेशी। यह किसी भी आधार में लिया जा सकता है, लेकिन यह सुसंगत होना चाहिए और यदि आपने जो आधार चुना है वह आधार दस नहीं है तो आपको इसे निर्दिष्ट करना होगा।

आप अपने इनपुट को शून्य-पैड नहीं कर सकते हैं।

उत्पादन

आपको किसी भी आधार में बिट बुनाई के परिणाम का उत्पादन करना चाहिए, जो कि आधार और निरंतर होना चाहिए यदि आधार दस नहीं है।

आप अपने आउटपुट को शून्य-पैड कर सकते हैं।

---

संबंधित: विज़ुअलाइज़िंग बिट वीविंग

Comments

मजेदार तथ्य: यह वह चुनौती है जिसे मैं मूल रूप से पोस्ट करना चाहता था। फिर मैंने क्रमांकन की कल्पना करने के लिए ASCII कला को आकर्षित किया, और फिर Sp3000 ने सुझाव दिया कि प्रतिपादन एक बेहतर चुनौती देगा। ;)

— मार्टिन एंडर

क्या आउटपुट बेस इनपुट बेस से अलग हो सकता है? जब आप "सुसंगत" कहते हैं तो मैं समझता हूं कि "एक ही आधार में हर संभव इनपुट" के रूप में

— लुइस मेंडो

मुझे लगता है कि एक चक्र के रूप में प्रतिनिधित्व मैपिंग प्रतिनिधित्व से अधिक उपयोगी होगा।

— mbomb007

मुझे कहना है कि ASCII कला निश्चित रूप से अधिक मजेदार है।

— पागल

यह वास्तव में कुछ और परीक्षण मामलों का उपयोग कर सकता है।

— जेम्स

Answer 1

पायथन 2.7, 44 -> 36 बाइट्स

lambda x:x/4&42|x*2&128|x*4&84|x/2&1

Comments

शानदार पहला जवाब, पीपीसीजी में आपका स्वागत है! :)

— मार्टिन एंडर

अगर आप शिफ्टिंग के बाद और मास्क |की जगह इस्तेमाल करते हैं तो आप कोष्ठकों को हटाकर 8 बाइट शेव कर सकते हैं। +

— पेलमेल

चूंकि आप नए हैं, मैं बताता हूँ कि आप अपने गोल्फ को बेहतर बनाने के लिए @ PellMell का सुझाव ले सकते हैं और फिर <strike></strike>प्रगति को इंगित करने के लिए अपने पुराने बाइट स्कोर का उपयोग कर सकते हैं :-)

— Insane

पार किया 44 अभी भी नियमित 44 है। :(

— जेम्स

Answer 2

बुराई, 3 वर्ण

rew

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

इनपुट बेस 256 में है, (जैसे ASCII), उदाहरण के लिए अंक 63 दर्ज करने के लिए, ASCII 63 दर्ज करें जो कि है ?।

स्पष्टीकरण:

r          #Read a character
 e         #Weave it
  w        #Display it

यह तो धोखा तरह लगता है।

Comments

ASCII बेस 256 नहीं है, यह बेस 128 है। क्या ऑर्डिनल्स 128-255 के लिए एन्कोडिंग का उपयोग किया जाता है? संपादित करें: ऐसा लगता है कि यह सिस्टम एन्कोडिंग का उपयोग करता है।

— Mego

Answer 3

सीजाम, 15 12 बाइट्स

3 बाइट बचाने के लिए FryAmTheEggman को धन्यवाद।

l8Te[m!6532=

बेस 2 में इनपुट। बेस 2 में आउटपुट, शून्य के साथ 8 बिट्स तक गद्देदार।

इसका परीक्षण यहां करें।

व्याख्या

l      e# Read the input.
8Te[   e# Left-pad it to 8 elements with zeros.
m!     e# Generate all permutations (with duplicates, i.e. treating equal elements
       e# in different positions distinctly).
6532=  e# Select the 6533rd, which happens to permute the elements like [1 3 0 5 2 7 4 6].

Answer 4

MATL , 14 बाइट्स

&8B[2K1B3D5C])

इनपुट दशमलव में है। आउटपुट शून्य-गद्देदार बाइनरी है।

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

व्याख्या

&8B         % Take input number implicitly. Convert to binary array with 8 digits
[2K1B3D5C]  % Push array [2 4 1 6 3 8 5 7]
)           % Index first array with second array. Implicitly display

Answer 5

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

+⁹BḊŒ!6533ị

मार्टिन के सीजेएम उत्तर का अनुवाद। इसे यहाँ आज़माएँ।

+⁹BḊ          Translate (x+256) to binary and chop off the MSB.
              This essentially zero-pads the list to 8 bits.
    Œ!        Generate all permutations of this list.
      6533ị   Index the 6533rd one.

Comments

मुझे जीरो पैडिंग ट्रिक पसंद है। सुरुचिपूर्ण।

— ट्राइकोप्लाक्स

Answer 6

जावास्क्रिप्ट (ईएस 6), 30 बाइट्स

f=n=>n*4&84|n*2&128|n/2&1|n/4&42

Comments

पूर्वता का अच्छा दुरुपयोग!

— लीक नून

निश्चित रूप से पूर्वता इस तरह से काम करने के लिए डिज़ाइन की गई थी! यह थोड़ा बदलाव के साथ भी काम करेगा, लेकिन वे लंबे समय तक हैं।

— नील

Answer 7

जे, 12 बाइट्स

6532 A._8&{.

पर्मुटेशन A.इंडेक्स के साथ पर्मेट बिलिन का उपयोग करता है 6532जो बिट- वियर ऑपरेशन से मेल खाता है।

प्रयोग

इनपुट बाइनरी अंकों की एक सूची है। आउटपुट 8 बाइनरी अंकों की शून्य-गद्देदार सूची है।

   f =: 6532 A._8&{.
   f 1 0 0 1 1 1 0 1
0 1 1 1 0 1 1 0
   f 1 1 1 0 1 1 0
1 1 0 1 1 0 0 1

व्याख्या

6532 A._8&{.  Input: s
       _8&{.  Takes the list 8 values from the list, filling with zeros at the front
              if the length(s) is less than 8
6532          The permutation index for bit-weaving
     A.       permute the list of digits by that index and return

Answer 8

रेटिना , 39 बाइट्स

+`^(?!.{8})
0
(.)(.)
$2$1
\B(.)(.)
$2$1

बेस 2 में इनपुट और आउटपुट, आउटपुट बाएं-पैडेड है।

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

व्याख्या

+`^(?!.{8})
0

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

अब वास्तविक क्रमपरिवर्तन के लिए। सीधे-सीधे समाधान यह है:

(.)(.)(.)(.)(.)(.)(.)(.)
$2$4$1$6$3$8$5$7

हालांकि यह दर्दनाक रूप से लंबा और निरर्थक है। मुझे पर्मुटेशन का एक अलग सूत्रीकरण मिला जो रेटिना में लागू करने के लिए बहुत आसान है ( Xआसन्न बिट्स की एक स्वैप का प्रतिनिधित्व करता है):

1 2 3 4 5 6 7 8
 X   X   X   X
2 1 4 3 6 5 8 7
   X   X   X
2 4 1 6 3 8 5 7

अब इसे लागू करना बहुत आसान है:

(.)(.)
$2$1

यह बस दो वर्णों से मेल खाता है और उन्हें स्वैप करता है। चूंकि मैच ओवरलैप नहीं होते हैं, इसलिए यह सभी चार जोड़े स्वैप करता है।

\B(.)(.)
$2$1

अब हम फिर से वही काम करना चाहते हैं, लेकिन हम पहले चरित्र को छोड़ना चाहते हैं। ऐसा करने का सबसे आसान तरीका यह है कि मैच एक शब्द सीमा के साथ शुरू न हो \B।

Answer 9

x86 मशीन कोड, 20 बाइट्स

हेक्स में:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

यह AL रजिस्टर के माध्यम से इनपुट और रिटर्न परिणाम लेने वाली एक प्रक्रिया है

disassembly

89 c2                   mov    edx,eax
24 55                   and    al,0x55  ;Clear odd bits
c1 e0 02                shl    eax,0x2  ;Shift left, bit 6 goes to AH...
d0 e0                   shl    al,1     ;...and doesn't affected by this shift
d1 e8                   shr    eax,1    ;Shift bits to their's target positions
80 e2 aa                and    dl,0xaa  ;Clear even bits
c0 ea 02                shr    dl,0x2   ;Shift right, bit 1 goes to CF
11 d0                   adc    eax,edx  ;EAX=EAX+EDX+CF
c3                      ret

Answer 10

सी (असुरक्षित मैक्रो), 39 बाइट्स

#define w(v)v*4&84|v*2&128|v/2&1|v/4&42

सी (फ़ंक्शन), 41 बाइट्स

w(v){return v*4&84|v*2&128|v/2&1|v/4&42;}

सी (पूर्ण कार्यक्रम), 59 बाइट्स

main(v){scanf("%d",&v);return v*4&84|v*2&128|v/2&1|v/4&42;}

(एक्जिट कोड के माध्यम से रिटर्न, इसलिए इनवॉइस echo "157" | ./weave;echo $?)

सी (मानकों-पूर्ण पूर्ण कार्यक्रम), 86 बाइट्स

#include<stdio.h>
int main(){int v;scanf("%d",&v);return v*4&84|v*2&128|v/2&1|v/4&42;}

सी (मानक-कंपाइलर पूर्ण प्रोग्राम जिसमें कोई संकलक चेतावनी नहीं है), 95 बाइट्स

#include<stdio.h>
int main(){int v;scanf("%d",&v);return (v*4&84)|(v*2&128)|(v/2&1)|(v/4&42);}

सी (मानकों के अनुरूप पूर्ण प्रोग्राम जिसमें कोई संकलक चेतावनी नहीं है जो तर्कों या स्टडिन से पढ़ सकता है और इसमें त्रुटि / श्रेणी की जाँच शामिल है), 262 बाइट्स

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(int v,char**p){v=v<2?isatty(0)&&puts("Value?"),scanf("%d",&v)?v:-1:strtol(p[1],p,10);exit(*p==p[1]||v&255^v?fprintf(stderr,"Invalid value\n"):!printf("%d\n",(v*4&84)|(v*2&128)|(v/2&1)|(v/4&42)));}

टूट - फूट

बहुत अधिक मौजूदा उत्तरों के रूप में बहुत समान है: बिट का उपयोग करके <<2( *4), <<1( *2), >>1( /2) और >>2( /4) का उपयोग करके सभी बिट्स को स्थानांतरित करें , फिर |यह सब एक साथ।

बाकी बॉयलर-प्लेट के विभिन्न स्वादों के अलावा कुछ नहीं है।

Answer 11

गणितज्ञ, 34 बाइट्स

PadLeft[#,8][[{2,4,1,6,3,8,5,7}]]&

अनाम फ़ंक्शन। बाइनरी अंकों की एक सूची लेता है, और 8 बाइनरी अंकों की एक गद्देदार सूची को आउटपुट करता है।

Answer 12

PowerShell v2 +, 34 बाइट्स

("{0:D8}"-f$args)[1,3,0,5,2,7,4,6]

@ LegionMammal978 के उत्तर का अनुवाद । पूरा कार्यक्रम। एक बाइनरी नंबर के रूप में कमांड-लाइन तर्क के माध्यम से इनपुट लेता है, एक बाइनरी सरणी, शून्य-गद्देदार के रूप में आउटपुट करता है।

"{0:D8}"-fभाग का उपयोग करता है कि मानक अंक प्रारूप तार पहले जोड़ें करने के लिए 0इनपुट करने के लिए $args। चूंकि -fऑपरेटर एक सरणी को इनपुट के रूप में लेने का समर्थन करता है, और हमने स्पष्ट रूप से पहले तत्व का उपयोग करने के लिए कहा है {0:, हमें सामान्य रूप से करने की आवश्यकता नहीं है $args[0]। हम उस स्ट्रिंग को पैरेंस में एनकैप्सुलेट करते हैं, फिर [1,3,0,5,2,7,4,6]बुनाई के साथ इसे इंडेक्स करते हैं । परिणामी सरणी को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

उदाहरण

( .ToString()किसी सरणी के लिए डिफ़ॉल्ट में विभाजक होता है `n, इसीलिए आउटपुट को यहाँ अलग किया जाता है)

PS C:\Tools\Scripts\golfing> .\golf-bit-weaving.ps1 10011101
0
1
1
1
0
1
1
0

PS C:\Tools\Scripts\golfing> .\golf-bit-weaving.ps1 1111
0
0
0
1
0
1
1
1

Answer 13

मतलाब, 49 48 44 बाइट्स

s=sprintf('%08s',input(''));s('24163857'-48)

बाइनरी मान के स्ट्रिंग के रूप में इनपुट लेता है। आउटपुट गद्देदार। 4 बाइट्स @Lendo मेंडू के लिए धन्यवाद बचा लिया।

स्पष्टीकरण:

input('')             -- takes input
s=sprintf('%08s',...) -- pads with zeros to obtain 8 digits
s('24163857'-48)      -- takes positions [2 4 1 6 3 8 5 7] from s (48 is code for '0')

Answer 14

वी , 17 बाइट्स

8é0$7hd|òxplò2|@q

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

यह बाइनरी में इनपुट और आउटपुट लेता है। अधिकांश बाइट गिनती 0 के साथ गद्दी से आती है। यदि पेडिंग इनपुट की अनुमति थी, तो हम कर सकते हैं:

òxplò2|@q

वर्णों की अदला-बदली की विधि के लिए मार्टिन के समाधान के लिए धन्यवाद :

1 2 3 4 5 6 7 8
 X   X   X   X
2 1 4 3 6 5 8 7
   X   X   X
2 4 1 6 3 8 5 7

स्पष्टीकरण:

8é0                 "Insert 8 '0' characters
   $                "Move to the end of the current line
    7h              "Move 7 characters back
      d|            "Delete until the first character
        ò   ò       "Recursively:
         xp         "Swap 2 characters
           l        "And move to the right
             2|     "Move to the second column
               @q   "And repeat our last recursive command.

Answer 15

05AB1E, 14 12 बाइट्स

žz+b¦œ6532èJ

व्याख्या

žz+b¦           # convert to binary padded with 0's to 8 digits
     œ6532è     # get the 6532th permutation of the binary number
           J    # join and implicitly print

इनपुट बेस 10 में है।
आउटपुट बेस 2 में है।

मार्टिनएंडर के सीजेम उत्तर से क्रमचय चाल उधार लेता है

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

Answer 16

पायथ, 19 अक्षर

s[@z1.it%2tzP%2z@z6

इनपुट और आउटपुट बेस 2 हैं।

एक अजगर विशेषज्ञ से दूर, लेकिन चूंकि किसी और ने इसके साथ जवाब नहीं दिया है फिर भी मैंने इसे एक शॉट दिया।

स्पष्टीकरण:

s[                # combine the 3 parts to a collection and then join them
  @z1             # bit 1 goes to bit 0
  .i              # interleave the next two collections
    t%2tz         # bits 3,5,7; t is used before z to offset the index by 1
    P%2z          # bits 0,2,4
  @z6             # bit 6 goes to bit 7

Comments

यह अमान्य है क्योंकि इसने शून्य-गद्देदार इनपुट ग्रहण किया है।

— लीके नन

Answer 17

भूलभुलैया , 27 26 बाइट्स

_1@
&,)}}}=}}=}}=}!{!!{{!"

बेस में इनपुट और आउटपुट 2. आउटपुट गद्देदार है।

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

Answer 18

यूजीएल , 50 बाइट्स

cuuRir/r/r/r/r/r/r/%@@%@@%@@%@@@%@@%@@%@@@oooooooo

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

2 से बार-बार डिव-मॉड, और फिर उन्हें सही क्रम में लाने के लिए %स्वैप और @रोल करें।

बेस-दस में इनपुट, बेस-दो में आउटपुट।

Answer 19

vi, 27 बाइट्स

8I0<ESC>$7hc0lxp<ESC>l"qd0xp3@q03@q

जहां <ESC>पलायन चरित्र का प्रतिनिधित्व करता है। I / O बाइनरी में है, आउटपुट पैडेड है। 24 बाइट्स विम में:

8I0<ESC>$7hd0xpqqlxpq2@q03@q

Comments

<ESC>इसके चारों ओर backticks की जरूरत है। मैं संपादित करता हूँ, लेकिन मैं बदलने के लिए 4 और बाइट्स का पता नहीं लगा सकता ...

— जो

@SirBidenXVII धन्यवाद, निश्चित।

— नील

Answer 20

दरअसल, 27 बाइट्स

'08*+7~@tñiWi┐W13052746k♂└Σ

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

यह प्रोग्राम बाइनरी स्ट्रिंग के रूप में इनपुट और आउटपुट करता है (आउटपुट शून्य-पैडेड है 8 बिट्स)।

स्पष्टीकरण:

'08*+7~@tñiWi┐W13052746k♂└Σ
'08*+                        prepend 8 zeroes
     7~@t                    last 8 characters (a[:~7])
         ñi                  enumerate, flatten
           Wi┐W              for each (i, v) pair: push v to register i
               13052746k     push [1,3,0,5,2,7,4,6] (the permutation order, zero-indexed)
                        ♂└   for each value: push the value in that register
                          Σ  concatenate the strings

Answer 21

जावास्क्रिप्ट, 98 बाइट्स

बेस -2 में इनपुट को एक स्ट्रिंग के रूप में लिया जाता है, आउटपुट भी स्ट्रिंग के रूप में बेस -2 है

n=>(n.length<8?n="0".repeat(8-n.length)+n:0,a="13052746",t=n,n.split``.map((e,i)=>t[a[i]]).join``)