Not: Bu zorluğun ilk yarısı Martin Ender'in önceki zorluğu olan Visualize Bit Weaving'ten geliyor .

Ezoterik programlama dili kötülüğü , "dokuma" olarak adlandırdığı bayt değerleri üzerinde ilginç bir işleme sahiptir.

Temel olarak baytın sekiz bitinin permütasyonudur (desen simetrik olduğu için hangi uçtan saymaya başladığımız önemli değildir):

• Bit 0, bit 2'ye taşınır
• Bit 1, bit 0'a taşınır
• Bit 2, bit 4'e taşınır
• Bit 3, bit 1'e taşınır
• Bit 4, bit 6'ya taşınır
• Bit 5, bit 3'e taşınır
• Bit 6, bit 7'ye taşınır
• Bit 7, bit 5'e taşınır

Kolaylık için, burada permütasyonun diğer üç temsili. Bir döngü olarak:

(02467531)

Bir eşleme olarak:

57361402 -> 76543210 -> 64725031

Ve eşleme çiftlerinin bir listesi olarak:

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

8Dokumalardan sonra , bayt esasen sıfırlanır.

Örneğin, dizi dokuma 10011101(olup 157temel 10) üretecek 01110110(ki 118temel 10).

Giriş

Yalnızca 256geçerli girdiler vardır, yani arasındaki 0ve 255kapsayıcı tüm tamsayılar . Bu herhangi bir bazda alınabilir, ancak tutarlı olmalı ve seçtiğiniz taban on baz değilse belirtmeniz gerekir.

Sen may not sıfır-pad cihazın girişleri.

Çıktı

Bit dokumasının sonucunu, herhangi bir bazda, on değilse de tutarlı ve belirtilmiş olması gerekir.

Sen olabilir sıfır-pad sizin çıkışları.

İlgili: Görsel Dokuma Bit Dokuma

Python 2.7, 44 -> 36 bayt

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

Kötülük, 3 karakter

rew

Çevrimiçi deneyin!

Giriş taban 256'dadır (örn. ASCII), örneğin 63 rakamını girmek için ASCII 63'ü girin ?.

Açıklama:

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

Bu yüzden hile gibi hissediyor.

CJam, 15 12 bayt

3 bayt tasarruf için FryAmTheEggman'a teşekkürler.

l8Te[m!6532=

Taban 2'de giriş. Ayrıca taban 2'de, sıfırlarla 8 bite doldurulmuş olarak çıktı.

Burada test edin.

açıklama

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].

MATL , 14 bayt

&8B[2K1B3D5C])

Giriş ondalık. Çıktı sıfır dolgulu ikili.

Çevrimiçi deneyin!

açıklama

&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

Jöle, 11 bayt

+⁹BḊŒ!6533ị

Martin CJam cevabının çevirisi. Burada deneyin.

+⁹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.

JavaScript (ES6), 30 bayt

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

J, 12 bayt

6532 A._8&{.

Bit dokuması işlemine karşılık gelen A.permütasyon indeksi ile permute yerleşimini kullanır 6532.

kullanım

Girdi, ikili rakamların bir listesidir. Çıktı, 8 ikili basamaklı sıfır dolgulu bir listedir.

   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

açıklama

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

Retina , 39 bayt

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

Taban 2'de giriş ve çıkış, çıkış sol dolgulu.

Çevrimiçi deneyin!

açıklama

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

Bu, girdiyi sıfırlarla doldurur. +Dize değişen durana kadar bu aşama tekrarlandığını belirtir. İçinde 8 karakterden az olduğu sürece dizenin başlangıcıyla eşleşir ve 0bu konuma a ekler .

Şimdi gerçek permütasyon için. Basit çözüm şudur:

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

Ancak bu acı verici ve uzun sürelidir. Retina'da uygulanması çok daha kolay olan permütasyonun farklı bir formülasyonunu buldum X(bitişik bitlerin bir değişimini temsil eder):

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

Bunu uygulamak artık çok daha kolay:

(.)(.)
$2$1

Bu sadece iki karakterle eşleşir ve onları değiştirir. Maçlar örtüşmediğinden, bu dört çiftin hepsini değiştirir.

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

Şimdi aynı şeyi tekrar yapmak istiyoruz, ama ilk karakteri atlamak istiyoruz. Bunu yapmak için en kolay yolu maçı gerektiren etmektir gelmez bir kelime sınırında başlar \B.

x86 makine kodu, 20 bayt

Onaltılı olarak:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

AL kaydı yoluyla giriş ve sonuç döndürme prosedürüdür

sökme

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

C (güvenli olmayan makro), 39 bayt

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

C (işlev), 41 bayt

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

C (tam program), 59 bayt

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

(çıkış kodu ile döner, bu yüzden çağırın echo "157" | ./weave;echo $?)

C (standartlara uygun tam program), 86 bayt

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

C (derleyici uyarısı olmadan standartlara uygun tam program), 95 bayt

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

C (bağımsız değişkenlerden veya stdin'den okuyabilen ve hata / aralık denetimi içeren derleyici uyarıları olmayan standartlara uygun tam program), 262 bayt

#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)));}

Yıkmak

Bir çok mevcut cevapla hemen hemen aynı: <<2( *4), <<1( *2), >>1( /2) ve >>2( /4), sonra |hepsini bir araya getirerek tüm bitleri yerine kaydırın.

Gerisi, kazan plakasının farklı tatlarından başka bir şey değildir.

Mathematica, 34 bayt

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

Anonim işlev. İkili rakamların bir listesini alır ve 8 ikili rakamdan oluşan dolgulu bir liste çıkarır.

PowerShell v2 +, 34 bayt

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

@ LegionMammal978'in cevabının çevirisi . Tam program. Komut satırı argümanıyla girişi ikili sayı olarak alır, ikili dizi olarak çıkar, sıfır dolgulu.

Bölüm , girişin başına standart sayısal biçim dizeleri"{0:D8}"-f kullanır . Yana operatör destekleri girdi olarak bir dizi alarak ve biz açıkça ilk elemanını kullanmak söyledim , biz her zamanki yapmak gerekmez . Bu dizeyi parens içinde kapsülliyoruz, sonra dokuma ile dizine ekliyoruz . Ortaya çıkan dizi ardışık düzende bırakılır ve çıktı örtüktür.0$args-f{0:$args[0][1,3,0,5,2,7,4,6]

Örnekler

( .ToString()bir dizi için varsayılan olarak ayırıcı vardır `n, bu nedenle çıktı burada yeni satır ayrılır)

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

Matlab, 49 48 44 bayt

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

Girdiyi ikili değerlerin dizesi olarak alır. Çıktı dolgulu. @Luis Mendo sayesinde 4 bayt tasarruf edildi.

Açıklama:

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')

V , 17 bayt

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

Çevrimiçi deneyin!

Bu giriş ve çıkışı ikili olarak alır. Bayt sayısının çoğu, 0 ile doldurmaktan gelir. Girişe dolgu yapılmasına izin verildiyse, şunları yapabiliriz:

òxplò2|@q

Martin'in karakter değiştirme yöntemi için çözümü sayesinde , örneğin:

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

Açıklama:

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.

05AB1E, 14 12 bayt

žz+b¦œ6532èJ

açıklama

ž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

Giriş taban 10'da.
Çıkış taban 2'de.

MartinEnder'in CJam cevabından permütasyon hünerini ödünç aldı

Çevrimiçi deneyin

Pyth, 19 karakter

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

Giriş ve çıkış taban 2'dir.

Bir Pyth uzmanından uzak, ama henüz kimse cevap vermediğinden ben denedim.

Açıklama:

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

Labirent , 27 26 bayt

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

Taban 2'de giriş ve çıkış. Çıktı dolgulu.

Çevrimiçi deneyin!

UGL , 50 bayt

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

Çevrimiçi deneyin!

Art arda 2'ye bölün ve sonra onları doğru sırayla almak için %değiştirin ve @yuvarlayın.

Taban-on girişi, taban-iki çıkışı.

vi, 27 bayt

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

Burada <ESC>Escape karakterini temsil eder. I / O ikili, çıkış dolgulu. Vim'de 24 bayt:

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

Aslında 27 bayt

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

Çevrimiçi deneyin!

Bu program bir ikili dize olarak giriş ve çıkış yapar (çıkış 8 bite sıfır dolgulu).

Açıklama:

'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

JavaScript, 98 Bayt

Giriş base-2'de bir dize olarak alınır, çıktı da base-2'de bir dize olarak alınır

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``)