Decode the string

Question

This is my first challenge on ppcg!

Input

A string consisting of two different ascii characters. For example

ABAABBAAAAAABBAAABAABBAABA

Challenge

The task is to decode this string following these rules:

1. Skip the first two characters
2. Split the rest of the string into groups of 8 characters
3. In each group, replace each character with 0 if that character is the same as the first character of the original string, and with 1 otherwise
4. Now each group represents a byte. Convert each group to character from byte char code
5. Concatenate all characters

Example

Let's decode the above string.

 AB  AABBAAAA  AABBAAAB  AABBAABA
 ^^     ^         ^         ^
 |      |         |         |
 |      \---------|---------/
 |                |
Skip      Convert to binary

Notice that A is the first character in the original string and B is the second. Therefore, replace each A with 0 and each B with 1. Now we obtain:

00110000  00110001  00110010

which is [0x30, 0x31, 0x32] in binary. These values represent characters ["0", "1", "2"] respectively, so the final output should be 012.

Scoring

This is, of course, code-golf, which means make your code as short as possible. Score is measured in bytes.

Constraints and IO format

Standard rules apply. Here are some additional rules:

• You can assume valid input
  • Input string consists of exactly two different characters
  • The first two characters are different
  • The minimal length of the input string is 2 characters
  • The length will always give 2 modulo 8
• You can assume the string will always consist only of printable ASCII characters
  • Both in the input and in the decoded string
• Leading and trailing whitespace are allowed in the output (everything that matches /\s*/)

Answer 1

C++, 181 Bytes (VS 2017)

#include<iostream>
int main(int,char**a){int c=7;uint8_t b=0;for(int i=2;a[1][i]!='\0';++i,--c){if(a[1][i]!=a[1][0]){b|=(1<<c);}if(c==0){std::cout<<static_cast<char>(b);c=8;b=0;}}}

Formatted, with better variable names and comments:

#include <iostream>

int main(int argc, char* argv[])
{
  int counter = 7;
  uint8_t byte = 0;

  // Loop until input string is fully read
  for (int i = 2; argv[1][i] != '\0'; ++i, --counter)
  {
    if (argv[1][i] != argv[1][0])
    {
      byte |= (1 << counter); // Shift 2^counter into the current byte
    }

    if (counter == 0)
    {
      std::cout << static_cast<char>(byte); // 
      counter = 8;
      byte = 0;
    }
  }
}

Answer 2

K4, 22 21 bytes

Solution:

"c"$2/:'0N 8#?/0 2_x:

Example:

q)k)"c"$2/:'0N 8#?/0 2_x:"ABAABBAAAAAABBAAABAABBAABA"
"012"

Explanation:

Evaluated right-to-left:

"c"$2/:'0N 8#?/0 2_x: / the solution
                  x:  / save input as x
               0 2_   / cut x at 0 and 2nd index
             ?/       / lookup (?) over (/)
        0N 8#         / reshape into 8-long rows
    2/:'              / decode (/:) each (') from base 2
"c"$                  / cast to character

Notes:

• -1 byte thanks to ngn!

Answer 3

Charcoal, 17 bytes

Ｆ⪪Ｅ✂θ²Ｌθ¹⌕θι⁸℅↨ι²

Try it online! Link is to verbose version of code. Explanation:

   ✂θ²Ｌθ¹           Slice first two characters from input
  Ｅ      ⌕θι        Replace each character with its index in the input
 ⪪          ⁸       Split into groups of 8
Ｆ                   Loop over each group
              ↨ι²   Convert from binary
             ℅      Convert from code to character
                    Implicitly print

Answer 4

Jelly, 8 bytes

ṫ3nḢs8ḄỌ

Try it online!

ṫ3nḢs8ḄỌ
ṫ3        All but first two characters...
  n       does not equal...
   Ḣ      the first character.
    s8    Split into groups of 8.
      Ḅ   Convert from binary (vectorizes).
       Ọ  chr() (vectorizes).

Answer 5

Jelly, 7 bytes

ḢnḊs8ḄỌ

Try it online!

Who needs ṫ (tail)?

Coincidentally Because there is only one way to do it, the 4 last bytes are identical to dylnan's answer.

---

Actually there is another way, providing there are no leading NUL bytes in the output:

Jelly, 7 bytes

ḢnḊḄb⁹Ọ

Try it online!

Answer 6

Perl 6, 59 bytes

{/(..)(.**8)*/;$1>>.trans(~$0=>"01")>>.parse-base(2)>>.chr}

Try it online!

Matches the pattern first, then uses a transliteration to 01 and parses the number.

Answer 7

C (gcc), 94 86 bytes (107 for leading whitespace)

Thanks to Jonathan Frech for saving 8 bytes!

f(s,v,i,j)char*s,*v;{for(v=++s,i=j=0;*++s;j&7||(putchar(i),i=0))i|=!(*s-*v)<<(--j&7);}

Try it online!

---

Original solution:

f(s,v,i,j)char*s,*v;{for(v=++s,i=j=0;*++s;){i|=!(*s-*v)<<(--j&7);if(!(j&7)){putchar(i);i=0;}}}

Try it online!

This assumes that main()'s stripping of whitespace is allowable. Otherwise, I got it to 107 bytes:

f(s,v,i,j)char*s,*v;{while(*s++<33);for(v=s,i=j=0;*++s;){i|=!(*s-*v)<<(--j&7);if(!(j&7)){putchar(i);i=0;}}}

Try it online!

Answer 8

C (tcc), 134 bytes

f(char*x){
    int a=*x,i,l=strlen(x);
    for(i=2;i<l;)
        x[i] = x[i++] - a ? 49 : 48;
    for(i=10;i<=l;i+=8)
        a=x[i],
        x[i]=0,
        putchar(strtol(x+i-8,0,2)),
        x[i]=a;
}

Try it online!

I am still trying to think of a better way than that ugly swap :P

Answer 9

Rust, 166 bytes

fn x(x:&str){for i in(2..x.len()-2).step_by(8){print!("{}",u8::from_str_radix(&x[i..i+8].chars().map(|c|(c as u8-17)as char).collect::<String>(),2).unwrap()as char)}}

Playground

Playground link because it requires nightly and tio seems to use stable.

Answer 10

Perl 6, 82 bytes 79 bytes

{.[2..*].map({+($^s ne.[0])}).rotor(8)».join».parse-base(2)».chr with .comb}

Shortened with help from Phil H (but his solution is still shorter, so go look at his one)

Try it online!

Answer 11

Coconut, 71 bytes

s->k(chr..int$(?,2)..k$(str..s.index),groupsof(8,s[2:]))
k=''.join..map

Try it online!

Answer 12

GolfScript, 24 bytes

1>(:x;8/{{x=}%2base}%''+

Try it online!

Explanation:

1>(:x;8/{{x=}%2base}%''+ Full program, implicit input.
                         Stack: "ABAABBAAAAAABBAAABAABBAABA"
1>                       Pop the first character (str[1:])
                         Stack: "BAABBAAAAAABBAAABAABBAABA"
  (:x;                   Pop the next character and assign it to x
                         Stack: "AABBAAAAAABBAAABAABBAABA"; x = 66
      8/                 Split into groups of 8
                         Stack: ["AABBAAAA" "AABBAAAB" "AABBAABA"]; x = 66
        {          }%    Map
                           Stack (first run): "AABBAAAA"; x = 66
         {  }%             Map again
                             Stack (first run): 65; x = 66
          x=                 Compare to x
                             Stack: 0; x = 66
                           Stack: [0 0 1 1 0 0 0 0]; x = 66
                           Well, actually, it is a string of 0 and 1 bytes.
              2base        Convert binary string to number
                           Stack: 48; x = 66
                         Stack: [48 49 50]; x = 66
                     ''+ Convert to string
                         Stack: "012"; x = 66
                         Implicit output

Answer 13

bash + bc + xxd, 87 bytes

a="${1:2:${#1}}"
b="${a//${1::1}/0}"
bc<<<"obase=16;ibase=2;${b//${1:1:1}/1}"|xxd -r -p

Usage:

bash foo.bash 'ABAABBAAAAAABBAAABAABBAABA'

Answer 14

Thunno 2 B, 9 bytes

Ḣsḣ8ẇQ2ȷḋ

Try it online!

Explanations

Ḣsḣ8ẇQ2ȷḋ  # Implicit input, converted to charcodes
Ḣ          # Extract the first character from the input
 sḣ        # And remove the next character from the rest
   8ẇ      # Split it into groups of eight
     Q     # For each: is it not equal to the first character
       ȷ   # For each inner list in this nested list:
      2 ḋ  # Convert it back from binary to decimal
           # Implicit output, converted to characters

Old:

2ɱ$2ỵ8ẇsȷbC  # Implicit input
2ɱ           # Take the first two characters
  $2ỵ        # And then push the rest of the string
     8ẇ      # Split it into groups of eight
       sȷb   # Convert each from base-(first two characters)
          C  # Convert to characters
             # Implicit output