Tarefa

Dada uma sequência de entrada de um ou mais caracteres ASCII cujos pontos de código estão entre 0 e 128 (exclusivo), faça o seguinte:

1. Converta cada caractere em seu código ASCII de 7 bits (se o código ASCII for menor que 7 bits, coloque os zero bits iniciais)
2. Concatenar todos os bits (isso resulta em 7*nbits, onde né o número de caracteres)
3. Para cada bit nesse fluxo de bits, imprima 1 se for diferente do bit anterior e imprima 0 caso contrário. O primeiro bit de saída é sempre 1.

Exemplo

Entrada:

Hi

Resultado:

11011001011101

Explicação:

A cadeia "Hi" possui os códigos ASCII

72 105

que em bits são:

1001000 1101001

E os indicadores de bits de transição:

11011001011101

Isso é código de golfe. O menor número de bytes vence.

Casos de teste

Caso de teste 1:

Hello World!
110110010101110011010101101010110001110000111110000110000001011101101010101100110001

Caso de teste 2:

%% COMMENT %%
1110111111011111100001100010010100001010110101011010011101010011111110011000001101111110111

Caso de teste 3 (crédito a Luis Mendo):

##
11100101110010

Parabéns a Luis Mendo pela solução mais curta com 9 bytes em MATL!

MATL , 9 bytes

Hj7&B!hdg

Experimente online!

Explicação

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 bytes

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

Experimente online!

Japt -P , 11 bytes

Aproveita o fato de que os espaços podem ser coagidos para 0 no JavaScript ao tentar executar uma operação matemática ou, nesse caso, bit a bit nele.

c_¤ù7Ãä^ i1

Experimente ou execute todos os casos de teste

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 bytes

1q{i2b7Te[}%e__(;.^);

Experimente online!

Explicação

Mostrando a pilha com uma entrada de amostra de 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

Para verificar se um bit é diferente do bit anterior, criamos um vetor (elemento a elemento) xor entre a matriz de bits e a matriz de bits sem o primeiro elemento. Também removemos o último bit do resultado, porque ele é sempre o último bit da matriz mais longa inalterado.

APL (Dyalog Unicode) , 16 bytes ^SBCS

Programa completo. Solicita a string do stdin.

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

Experimente online!

⍞ solicitação de entrada ("uma cotação em um console")

11⎕DR¨ altere cada caractere para bit-booleano D ata R ePresentation

1↓¨ solte o primeiro bit de cada

∊ ε nlist (achatar)

2≠/ diferença pareada

1, Anexar um

Gelatina , 12 bytes

O+Ø⁷BḊ€FIA1;

Experimente online!

Carvão , 25 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

⭆θ◧⍘℅鲦⁷←

Converta todos os caracteres em binários e preencha-os com um comprimento de 7 e imprima-os, mas deixe o cursor sobre o último dígito.

Ｗⅈ

Repita até que o cursor esteja sobre o primeiro dígito.

←Ｉ﹪⍘ＫＤ²←01 ²

Calcule se os dígitos são diferentes e substitua cada dígito pela diferença.

1

Sobrescreva o primeiro dígito com a 1.

PowerShell , 73 56 49 bytes

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

Experimente online!

-17 bytes graças a mazzy :)

Ruby -p , 68 57 bytes

-11 bytes roubando descaradamente o método usado por solução Python da xnor .

l=1
gsub(/./){l=l<<7|$&.ord}
$_=?1+(l^l/2).to_s(2)[2..-1]

Experimente online!

Solução original:

gsub(/./){'%07b'%$&.ord}
l=p
gsub(/./){b=$&.ord-48;r=l ?l^b:1;l=b;r}

Experimente online!

Oitava , 36 30 bytes

Correção graças a Luis Mendo

-2 bytes graças a Sanchises

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

Experimente online!

Python 2 , 104 bytes

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]

Experimente online!

Uma rápida facada.

Dardo , 213 168 bytes

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

One-liner anterior

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

Experimente online!

Essa verbosidade e falta de ins fáceis de construir estão realmente matando essa. Ainda conseguiu puxar um forro embora.

• -45 bytes por não usar um liner e um loop for

Stax , 13 12 bytes

ìEÖâU₧(~¬8IE

Execute e depure

Se for garantido que todos os caracteres de entrada tenham o sétimo bit definido, como algumas respostas supõem, isso pode ser feito em 10 bytes

Kotlin , 182 bytes

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)

Experimente online!

Espero poder melhorar isso em breve, sinto que deve haver alguns pontos a melhorar, mas não consigo pensar agora

Perl 5 -p , 60 bytes

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

Experimente online!

C (gcc (MinGW)), 90 bytes

Requer um fornecimento de compilador 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;}

Ruby -p , 50 bytes

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

Experimente online!

Explicação

Primeira linha, igual à resposta da Value Ink :

gsub(/./){       $&    }   # Replace each character $&…
                   .ord    # …with its ASCII code…
                %          # …formatted as…
          "%07b"           # …binary digits padded to 7 places.

Segunda linha:

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.

No Ruby, você pode usar a interpolação em literais do Regexp, por exemplo /Hello #{name}/, e para variáveis ​​que começam com $ou @você pode omitir os chavetas, portanto, se eg $&for "0", o grawlixy /#$&$/se tornará /0$/.

K (ngn / k) , 9 13 bytes

Solução:

~=':,/(7#2)\'

Experimente online!

Explicação:

~=':,/(7#2)\' / the solution
           \' / convert each
      (   )   / do this together
       7#2    / 2 2 2 2 2 2 2
    ,/        / flatten
 =':          / equal to each-previous?
~             / not

Notas:

• +4 bytes para suportar cadeias consistindo apenas em caracteres de 6 bits

Emojicode , 263 bytes

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

Experimente online aqui.

Ungolfed:

🏁 🍇  💭 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 bytes

-55 graças a @dana

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

Experimente online!

Python3.8 , 72 bytes

Solução:

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

Explicação:

Desde que o Python 3.8 introduziu expressões de atribuição (em vez das instruções de atribuição padrão), eu queria usá-las em uma compreensão de lista que precisa lembrar o último item. Essa não é a melhor maneira de fazer isso, mas demonstra um método interessante de usar a expressão de atribuição.

O código cria uma função lambda que recebe o argumento necessário, que é a string a ser convertida. Quando chamada, a função prossegue da seguinte maneira. Todo caractere em a é convertido em seu código de caractere ao qual 128 é adicionado para lidar com caracteres de 6 bits (a representação binária sempre será de 8 bits e podemos cortar o primeiro bit). Esse número é convertido em binário e o cabeçalho (0x) e o 1 inicial da adição de 128 são cortados. Essas novas seqüências de caracteres são unidas em uma sequência maior.

Para cada caractere nessa nova seqüência de caracteres (que contém a representação concatenada de 7 bits do texto), é verificado se o caractere é igual ao caractere anterior. O que acontece com o primeiro personagem? O caractere do primeiro resultado sempre deve ser "1", portanto, apenas precisamos garantir que o que estiver na variável do último caractere não seja "1" nem "0". Fazemos isso reutilizando o parâmetro original agora que não o estamos mais usando. Isso pode ser um problema se a string original for um único "0" (um único "1" funciona), mas ignoraremos isso.

Durante a comparação, o caractere anterior foi avaliado primeiro; portanto, quando usamos a expressão de atribuição para definir a variável de caractere anterior para o caractere atual, isso não afeta a avaliação das expressões de comparação.

A comparação produz True ou False, que também pode ser usado como 1 ou 0, respectivamente, em Python, portanto, eles são usados ​​para procurar um "1" ou "0" em uma string

Tcl , 215 167 140 bytes

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

Experimente online!

Usa turno por um e exclusivo - ou para detectar transições. Carrega lsb do caractere atual para msb do próximo caractere. Combina a saída para cada caractere juntando-se à lista retornada pelo lmap.

Usa lambdas com argumentos padrão para salvar bytes na inicialização e comandos repetidos.

Depende muito da ordem de operação. Funciona para cadeia vazia.

05AB1E (herdado) , 12 bytes

Çb7jð0:¥ÄJ1ì

Usa a versão herdada de 05AB1E, pois june implicitamente as seqüências de caracteres, o que requer um explícito Japós o jna nova versão de 05AB1E.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

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)

Experimente online!

O maior problema aqui é converter booleanos (resultado do XOR) em '0' / '1'.

Python 3 , 88 84 bytes

l=2;s=''
for c in''.join(f'{ord(c):07b}'for c in input()):s+='01'[l!=c];l=c
print(s)

Experimente online!

Sinto que as tarefas devem ser evitáveis, mas não consegui pensar em nenhuma maneira de fazer isso.

Atualizar:

• -4 bytes graças à movatica

PHP , 90 bytes

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

Experimente online!

C # (compilador interativo do Visual C #) , 80 bytes

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

Experimente online!

JavaScript (V8) , 73 bytes

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

Experimente online!