Завдання

З огляду на рядок введення одного або декількох символів 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

Вітаю Луїса Мендо за найкоротше рішення з 9 байтами в MATL!

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

Python 2 , 58 байт

n=1
for c in input():n=n<<7|ord(c)
print'1'+bin(n^n/2)[4:]

Спробуйте в Інтернеті!

Japt -P , 11 байт

Користується тим, що пробіли можна примушувати до 0JavaScript, намагаючись виконувати математичну або, у цьому випадку, побітну операцію над нею.

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

CJam , 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

Щоб побачити, чи біт відрізняється від попереднього біта, ми робимо вектор (x-мудрий) xor між бітовим масивом і бітовим масивом без першого елемента. Ми також видаляємо останній біт результату, оскільки це завжди останній біт довшого масиву без змін.

APL (Dyalog Unicode) , 16 байт ^SBCS

Повна програма. Підказки для рядка від stdin.

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

Спробуйте в Інтернеті!

⍞ запит на введення ("цитата в консолі")

11⎕DR¨ змінити кожен символ битового булевої D ата R epresentation

1↓¨ скиньте перший шматочок з кожного

∊ ϵ nlist (згладити)

2≠/ попарна різниця

1, подати один

Желе , 12 байт

O+Ø⁷BḊ€FIA1;

Спробуйте в Інтернеті!

Вугілля деревне , 25 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

⭆θ◧⍘℅鲦⁷←

Перетворіть усі символи у двійкові та накладіть їх на довжину 7, а потім надрукуйте їх, але залиште курсор над останньою цифрою.

Ｗⅈ

Повторіть, доки курсор не перевищить першу цифру.

←Ｉ﹪⍘ＫＤ²←01 ²

Обчисліть, чи відрізняються цифри, і перепишіть кожну цифру з різницею.

1

Перепишіть першу цифру а 1.

PowerShell , 73 56 49 байт

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

Спробуйте в Інтернеті!

-17 байт завдяки mazzy :)

Рубі -p , 68 57 байт

-11 байт, безсоромно вкравши метод, який використовується рішенням Python 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}

Спробуйте в Інтернеті!

Октава , 36 30 байт

Виправити завдяки Луїсу Мендо

-2 байти завдяки Sanchises

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

Спробуйте в Інтернеті!

Python 2 , 104 байти

lambda w:reduce(lambda(A,P),C:(A+'10'[P==C],C),bin(reduce(lambda a,c:a*128+ord(c),w,1))[3:],('','x'))[0]

Спробуйте в Інтернеті!

Швидкий удар у неї.

Дарт , 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 байт, не використовуючи один вкладиш і не використовуючи цикл

Стакс , 13 12 байт

ìEÖâU₧(~¬8IE

Запустіть і налагоджуйте його

Якщо гарантовано, що всі вхідні символи мають 7-й бітовий набір, як передбачають деякі відповіді, це можна зробити в 10 байт

Котлін , 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)

Спробуйте в Інтернеті!

Сподіваюсь, я скоро вдається покращити це, я відчуваю, що повинні бути певні місця для покращення, але я не можу зараз думати

Perl 5 -p , 60 байт

s/./sprintf'%07b',ord$&/ge;s/.(?=(.))/0|$&^$1/ge;s/^/1/;chop

Спробуйте в Інтернеті!

C (gcc (MinGW)), 90 байт

Потрібен компілятор itoa().

n[9],b,c;f(char*s){for(b=*s<64;c=*s++;printf("%07s",itoa((c^c/2)&127,n,2)))c|=b<<7,b=c&1;}

Рубін -p , 50 байт

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

Спробуйте в Інтернеті!

Пояснення

Перший рядок, такий же, як відповідь Ink Ink :

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.

В Ruby ви можете використовувати інтерполяцію в Regexp литералов, наприклад /Hello #{name}/, і для змінних , які починаються з $або @ви можете опустити фігурні дужки, так що якщо , наприклад , $&є "0"те grawlixy /#$&$/стає /0$/.

К (нг / к) , 9 13 байт

Рішення:

~=':,/(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-бітних символів

Emojicode , 263 байт

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

Спробуйте його онлайн тут.

Безголівки:

🏁 🍇  💭 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.
    🍉
🍉

JavaScript (V8) , 150 95 байт

-55 дякує @dana

x=>[...[...x].reduce((a,c)=>a+c.charCodeAt(0).toString(2).padStart(7,0),"")].map(c=>x!=(x=c)|0)

Спробуйте в Інтернеті!

Python3.8 , 72 байти

Рішення:

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

Пояснення:

З тих пір, як Python 3.8 представив вирази призначення (а не стандартні заяви про призначення), я хотів використовувати їх у розумінні списку, який повинен запам'ятати останній елемент. Це не найкращий спосіб зробити це, але демонструє цікавий метод використання виразу призначення.

Код створює лямбда-функцію, яка бере необхідний аргумент, який є рядком для перетворення. При виклику функція діє наступним чином. Кожен символ у a перетворюється в його код символу, до якого додається 128 для роботи з 6-бітовими символами (двійкове представлення завжди буде 8 біт, і ми можемо відрізати перший біт). Це число перетворюється у двійкове та заголовок (0x), а початкове 1 із додавання 128 відсікається. Ці нові рядки потім з'єднуються в одну більшу рядок.

Для кожного символу в цьому новому рядку (який містить зв'язане 7-бітове подання тексту) перевіряється, чи символ такий, як попередній символ. Що відбувається з першим персонажем? Першим символом результату має бути завжди "1", тому ми просто повинні переконатися, що те, що є в останній змінній символів, не є ні "1", ні "0". Ми робимо це, використовуючи початковий параметр тепер, коли ми його більше не використовуємо. Це може бути проблемою, якщо початковий рядок був одним "0" (один "1" просто трапляється), але ми це ігноруємо.

Під час порівняння попередній символ оцінювався спочатку, тому коли ми використовуємо вираз призначення для встановлення попередньої змінної символів на поточний символ, це не впливає на оцінку виразів порівняння.

Порівняння створює True або False, які також можуть бути використані відповідно 1 або 0 у Python, тому вони використовуються для пошуку або "1", або "0" у рядку

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}] ""}}

Спробуйте в Інтернеті!

Використовується зсув за одним і ексклюзивним або для виявлення переходів. Переносить lsb поточного символу до msb наступного символу. Поєднує вихід для кожного символу, приєднуючись до списку, поверненого lmap.

Використовує лямбда з аргументами за замовчуванням для збереження байтів при ініціалізації та повторних командах.

В основному покладається на порядок експлуатації. Працює для порожнього рядка.

05AB1E (спадщина) , 12 байт

Çb7jð0:¥ÄJ1ì

Використовується застаріла версія 05AB1E, оскільки jнеявно з'єднує рядки разом, що вимагає явного Jпісля jнової версії 05AB1E.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

Ç             # 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)

Haskell , 137 байт

import Data.Char
b 0=[]
b n=odd n:b(n`div`2)
d x|x='1'|1<2='0'
c=('1':).map d.(zipWith(/=)<*>tail).concatMap(reverse.take 7.b.(+128).ord)

Спробуйте в Інтернеті!

Найбільшою проблемою тут є перетворення булів (результат XOR) в '0' / '1'.

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

Спробуйте в Інтернеті!

Я вважаю, що завдання потрібно уникати, але я не міг придумати жодного способу зробити це.

Оновлення:

• -4 байти завдяки movatica

PHP , 90 байт

for(;$c=ord($argn[$j++]);$o.=sprintf('%07b',$c));for(;($q=$o[$i++])>'';$p=$q)echo$p!=$q|0;

Спробуйте в Інтернеті!

C # (Visual C # Interactive Compiler) , 80 байт

s=>{for(int p,c=2,i=0;i<7*s.Length;Write(p==c?0:1))(p,c)=(c,1&s[i/7]>>6-i++%7);}

Спробуйте в Інтернеті!

JavaScript (V8) , 73 байти

s=>[...c=s.repeat(7)].map((_,i)=>(c=1&s.charCodeAt(i/7,p=c)>>6-i%7)!=p|0)

Спробуйте в Інтернеті!