text:
Opposite of the digital root!
Also known as the [analog root]
(Opposite of the digital root!) ;)
The digital root of a number is the continuous summation of its digits until it is a single digit, for example, the digital root of 89456 is calculated like this:
8 + 9 + 4 + 5 + 6 = 32
3 + 2 = 5
The digital root of 89456 is 5.
Given a digit as input via STDIN, print/return all of the possible two digit numbers that have that digital root. If you need it to, it can include itself, e.g. 05
These are all of the possible inputs and outputs:
(You get to choose whether or not to include the leading zero for the digit itself)
I/O
0 => 0 or 00 or nothing
1 => 01 and/or 1, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91 - Make sure that 1 does not return 100
2 => 02 and/or 2, 11, 20, 29, 38, 47, 56, 65, 74, 83, 92
3 => 03 and/or 3, 12, 21, 30, 39, 48, 57, 66, 75, 84, 93
4 => 04 and/or 4, 13, 22, 31, 40, 49, 58, 67, 76, 85, 94
5 => 05 and/or 5, 14, 23, 32, 41, 50 ,59, 68, 77, 86, 95
6 => 06 and/or 6, 15, 24, 33, 42, 51, 60, 69, 78, 87, 96
7 => 07 and/or 7, 16, 25, 34, 43, 52, 61, 70, 79, 88, 97
8 => 08 and/or 8, 17, 26, 35, 44, 53, 62, 71, 80, 89, 98
9 => 09 and/or 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99
No standard loopholes, and it's code-golf, so the shortest answer in bytes wins.

Congrats to Heeby Jeeby Man on his amazing 46 byte brain-flak answer!

does the number itself count as a two digit number? (05)?

Inverse challenge

What should the output be for 0? And again, in a case like this where there are only 10 possible inputs, it would be of great benefit to supply the outputs in your challenge.

Your decision on how to handle zero invalidates many of the answers that were posted. It would be considerate to let the participants know you have made a decision.

@FryAmTheEggman I just updated the post

is the opposite of a digital root an analog root?

Why should 0 return 0, that is not a 2 digits number (the same for all other 9 digits)

@edc65 You're right, I'm not sure exactly what I was thinking. I will modify the req.

Must 1 and 01 both be included (for input 1)?

@user202729 no, you get to choose

Pyke, 6 bytes
ITV
9+

Try it here!
ITV\n9+ - if input: (don't print anything for 0 case)
 TV\n9+ -  repeat 10 times:
   \n   -    print ^
     9+ -   ^ += 9

JavaScript (ES6), 27 31 30 bytes
Returns 0 for 0 or an array of solutions otherwise.
n=>n&&[...1e9+''].map(_=>n+=9)

Demo

let f =

n=>n&&[...1e9+''].map(_=>n+=9)

for(n = 0; n < 10; n++) {
  console.log(n, JSON.stringify(f(n)));
}

A downvote without any comment doesn't help much to improve the answer...

To some it might be unclear which part is the actual codegolfed function, and which part is a demonstration. It might be a good idea to just put the function itself straight below the JavaScript line.

@DavidMulder Thanks for the suggestion. That's actually the way I answer most of the time. Updated.

Nice solution! Sorry for dragging up an old solution but could you drop the + to save another byte? Though it would not work with stdin string that way I suppose.

@CraigAyre I'm not sure where this + came from... Updated. Thanks!

05AB1E, 13 12 9 bytes
-3 bytes thanks to Adnan
тL<ʒSOSOQ

Try it online!
Explanation
тL<ʒSOSOQ   Main link. Argument n
тL<         List from 1 to 100, then decrement to get 0 to 99
   ʒ        Filter
    SOSO    Sum of all chars, twice
        Q   Compare to input

I think you can replace the infinite loop by SOSO, since the number will never be bigger than 99.

@Adnan Don't think, I assure you he can.

@Adnan Thanks, modified it.

тL< isn't really shorter than plain 99Ý. ;)

@EriktheOutgolfer Well, I was probably trying to hard to save a byte there ;D

Main "link"? Since when 05AB1E has links? It's not Jelly.

Jelly, 8 bytes
11Ḷ×9+ȧ@

Try it online!
Different algorithm than my other answer.

Brain-Flak, 46 bytes
{((()()()()()){}){(({}[()])<(({}{}[]))>)}}{}{}

Try it online!
Explanation
This answer uses an idea from Megatom's answer namely using the stack height as the difference between the loop counter and the increment.   Like previous answers this answer has a large outer loop to catch all the zeros.  Inside the loop we push 10 to act as a counter, we then start another nested loop.  In this loop we decrement the counter by 1
({}[()])

Then we pop the top two items, which are the counter and the last item we calculated.  We add these to the stack height in order to counter balance the decrementation, we then push this twice, once for output and once so that it can be consumed to calculate the next result.  Pushing things twice means we accidentally push an additional value which needs to be removed at the end of execution.
The reason this just barely beats Megatom is Megatom's answer is forced to get its stack heights while the last result is still on the stack.  This means they are forced to use a rather expensive [()] to decrease the total by one.  By moving the duplicate to the end of the loop I am able to avoid having to use [()] at the cost of an additional {} at the very end of the program.  If Megatom were to use this strategy his answer would look like:
{<>((()()()()()){}){((({}[()])<>{}[]))<>}}<>{}

also 46 bytes.
Brain-Flak, 52 bytes
{((()()()()()){}){({}[()]<(({})((()()())){}{})>)}}{}

Try it online!
Explanation
The main outerloop makes a special case for input of zero.  If zero is input we jump over the entire loop, pop zero and then output nothing.  Otherwise we enter the loop.  Here we push loop 10 times each time adding 9 to the top of the stack, keeping old values.  Since 9 preserves digital sums this will get us the next value.  Once the loop has expired we use the zero it generated to exit the loop which is then popped by the {} at the end.
Brain-Flak, 56 bytes
{([(((()()())){}{})]){({}()<(({})<(({}{}))>)>)}}{}({}{})

Try it online!
Explanation
This version works very similarly to the last one, except we loop 9 times instead of 10 leaving out the original value.  In order to do this we have to rearrange the way we handle memory a bit.  All of the bytes we might have saved using this method get put into cleanup.

The 46 doesn’t preserve the original number :(

@JoKing Yeah, it just does the 2 digit cases.  Which I think is kind of the intention of the question, so that makes me pretty happy.

Nice Job! You earned the bounty.

Haskell, 21 bytes
f takes an integer and returns a list of integers.
f d=[d,d+9..99^0^0^d]

Try it online!

Starts with the digit d and generates the range with every 9th number up to a bound of 99, except for the tricky case of 0.
To stop early for 0, uses that the power 0^d==1 for 0 and ==0 for all other digits. Thus 99^0^0^d gives 1 for 0 but 99 for anything else.

Python 2, 29 bytes
lambda n:n and range(n,100,9)

Try it online!

Brachylog, 12 bytes
0g|g{t+₉}ᵃ¹⁰

Try it online!
Explanation
0g               Input = 0, Output = [0]
  |              Or
   g{   }ᵃ¹⁰     Accumulate 10 times, starting with [Input]
     t+₉         Take the last element, add 9

Bash, 31 27 bytes
seq $1 9 $(($1?99:0))|xargs

Try it online!
previous
eval echo {$1..$(($1?99:0))..9}

how does one find the man pages / bash help / ?  about "{x..y..z}" ? what is it called?

found it: in man page, search [^.]..[^.]  : brace expansion: (...) A sequence expression takes the form {x..y[..incr]}, where x and y are either integers or single characters, and incr, an optional increment, is  an  integer.   (...) When the increment is supplied, it is used as the difference between each term.  The default increment is 1 or -1 as appropriate.

Dyalog APL, 15 bytes
{(×⍵)/+\⍵,10⍴9}

How?
⍵,10⍴9 - concatenate input with 10 9s (⍵ 9 9 9 9 9 9 9 9 9 9).
+\ - cumulative sum.
(×⍵)/ - expand signum times - where signum gives 1 for 1-9 and 0 for 0.
Try it online!
Dyalog APL, 24 bytes
{⍵/⍨⎕=(⍵≠0)×1+9|⍵-1}⍳100

Requires ⎕IO←0.
How?
                      ⍳100  ⍝ 0 .. 99
              1+9|⍵-1      ⍝ digit sum (⍵-1 mod 9 + 1)
        (⍵≠0)×             ⍝ edge case for 0
     ⎕=                    ⍝ equals to the input
 ⍵/⍨                       ⍝ compress with the range

Brain-Flak, 48 bytes
{<>((()()()()()){}){(({}[()])<>[][()]({}))<>}}<>

Try it online!
I may add an explanation later.

Brilliant! I tried combining the +9 with the length to make a counter, but I never thought of doing it the other way around

It's not over yet :P

Actually, 18 bytes
╗2╤DR⌠╜-9@%Y⌡░╜;)I

Try it online!
Explanation:
╗2╤DR⌠╜-9@%Y⌡░╜;)I
╗                   save input to register 0
 2╤DR               range(1, 100)
     ⌠╜-9@%Y⌡░      elements in range where function returns truthy:
      ╜-              subtract from input
        9@%           mod 9
           Y          is equal to 0
              ╜;)   push a copy of the input on the top and the bottom of the stack
                 I  if input is truthy, return the filtered range, else return the input (special-cases 0)

@FryAmTheEggman Fixed.

Mathematica, 25 bytes
If[#==0,0,Range[#,99,9]]&

works for 0

Doesn't work for 0. This also wouldn't include numbers whose digits add up to a number greater than 9. (e.g. 9 wouldn't have 99 in the output).

I see what you mean. Do you inspect only "my" codes? cause many codes here don't work for 0...

Welp, I tend to focus on Mathematica code because that's the language I know best. Didn't mean to target you or anything. I apologize if it seemed like it.

all fixed and working

What? No builtin?

PHP, 41 Bytes
prints underscore separated values
for(;100>$a=&$argn;$a+=$a?9:ERA)echo$a._;

ERA is the shortest constant in PHP with the value 131116. You can replace it with the boring alternative 100 or end the program with die
Online Version

Jelly, 12 bytes
⁵²Ḷµ,³%9EµÐf

Try it online!
How It Works
⁵²Ḷµ,³%9EµÐf
⁵             - literal 10
 ²            - square
  R           - lowered range: 0 to 99 inclusive.
   µ     µÐf  - filter based on:
    ,³          - element and input
      %9        - mod 9
        E       - are equal

When I use 1 as an argument it also gives out 100, which is not two digit

This doesn't split the 0 and 9 cases.

This still doesn't work for 0

Brain-Flak, 54 52 bytes
{<>((((()()())){}{})()){({}<(({})<>({}))><>[()])}}<>

Try it online!
My first foray with Brain-Flak, and I think I've done pretty well. Anyone with more experience have advice?
How It Works:
{ Don't do anything if input is 0
  <>((((()()())){}{})()) Switch to other stack and add 9 and 10
                         10 is the counter, 9 is to add to the current num
  { While counter
     (
       {} Pop the counter
       <(({})<>({}))> Get a copy of the 9, switch to the other stack and add it to a copy of the top of it. Use <...> to make it return 0
       <>[()] Switch to the other stack and decrement the counter
     )
  }
}<> Switch to the stack with the values on it

Good job! Welcome to Brain-Flak.

Jelly, 12 bytes
ȷ2ḶDS$ÐL⁼¥Ðf

Try it online!

PHP, 35
print_r(range($argn,!!$argn*99,9));

Creates the range [$argn, 100) with a step of 9 as array and prints it. If the input is 0 it creates the range [0,0] => array(0).

Python, 48 51 bytes
3 bytes saved thanks to @WheatWizard
lambda n:[x for x in range(100)if~-n==~-x%9or x==n]

try ~-x instead of (x-1)

still with @WheatWizard's tip, remove the space in if ~-x%9

Now you can do ~-n==~-x%9or x==n to save a byte

This gives a 0 for 9

I need to ask a silly question... I'd like to run this. How do I get this code to run? There are some constructs here I'm learning about (mainly the ~ operator)

R, 23 bytes
pryr::f(x+0:(10*!!x)*9)

Try it online!
The TIO link uses function(x) instead of pryr::f, since TIO doesn't have the pryr package installed.

Pyke, 6 bytes (old version)
Working commit
TXU#sq

Explanation:
TX     -   10**2
  U    -  range(^)
   #   - filter(^)
    s  -   digital_root(^)
     q -  ^==input

C (gcc), 55 bytes
f() need not actually be called with any argument; the n is just there instead of outside the function to save a byte.
f(n){for(scanf("%d",&n);n&&n<100;n+=9)printf("%d ",n);}

Try it online!

You can save 2 bytes by putting the printf inside the loop header: Try it online!

@DLosc myeah, but then it starts one number too late.

The wording could be clearer, but the question does allow starting at (e.g.) 10 instead of 1: "... all of the possible two digit numbers that have that digital root. If you need it to, it can include [the single-digit number] itself, e.g. 05." In other words, including the single-digit number in the output is permitted but not required.

Ruby, 25 bytes
->a{[*a.step(99,9)]*a|[]}

Try it online!

Charcoal, 14 11 bytes
Ｉ∧Ｎ⁺Ｉθ×⁹…¹¹

Try it online! Link is to verbose version of code. Edit: Saved 2 bytes by not printing anything for zero input and 1 byte by using vectorising operations 3 bytes thanks to @ASCII-only. Explanation:
         ¹¹ Literal 11
        …   Range
       ⁹    Literal 9
      ×     Vector multiply
     θ      (First) input
    Ｉ       Cast to number
   ⁺        Vector add
  Ｎ         Input digit as a number
 ∧          Logical AND
Ｉ           Cast to string
            Implicitly print on separate lines

11 bytes?

i think i just found an alternative that prints 0, here

Pyt, 11 bytes
?56+ř⁻9*+:;

Try it online!
?               implicit input; if input is truthy:
 56+            push 11
    ř⁻          řangify; decrement
      9*        multiply by 9
        +       add input
         :;     otherwise, do nothing; implicit print

Vyxal H, 6 bytes
ʁ'∑∑?=

Try it Online!
Port of kalsowerus's 05AB1E answer.
A port of Kip the Malamute's Pyt answer would be 8 bytes:
:[11ʁ9*+

Try it Online!
Explanation
ʁ'∑∑?=  # H flag pushes 100
ʁ'      # Filter range(100) by:
  ∑∑    #  Digit sum twice
    ?=  #  Equals the input

:[11ʁ9*+  # Implicit input
:         # Duplicate
 [        # If input is not 0:
  11ʁ     #  Push range(11)
     9*   #  Multiply by 9
       +  #  Add to input
          # (Otherwise, do nothing)

"Make sure that 1 does not return 100"

@DominicvanEssen fixed. That was just Vyxal implicitly converting 100 to a 1-based range instead of a 0-based range.

Julia 0.6, 18 bytes
I use a ternary to catch the 0 case, and a range n:9:99 to create the numbers. In julia a range is an AbstractVector and can be used in place of an actual Vector of numbers in most cases, but it will just print as 1:9:91 which doesn't satisfy the challenge, so I wrap it in [_;] to collect the contents into a Vector.

n->n>0?[n:9:99;]:0

Try it online!

Perl 5, 25 + 1 (-n) = 26 bytes
say;!$_||($_+=9)>99||redo

Try it online!

Clojure, 38 bytes
(defn f[n](if(pos? n)(range n 100 9)))

or as anonymous function which is 29 bytes

(#(if(pos? %)(range % 100 9))n)

Try it online!
thanks @steadybox

The output when n=9 is missing the last number, 99. Try it online! Also, you can save a byte by removing the space between f[n] and (if(....

Clojure, 33 bytes
(fn[n](if(> n 0)(range n 100 9)))

Thunno D, \$ 7 \log_{256}(96) \approx \$ 5.76 bytes
?11R9*+

Attempt This Online!
Port of Kip the Malamute's Pyt answer.
Thunno H, \$ 8 \log_{256}(96) \approx \$ 6.58 bytes
gdSdSA$=

Attempt This Online!
Port of kalsowerus's 05AB1E answer.
Explanations
?11R9*+  # D flag duplicates input
?        # If input is not 0:
 11R     #  Push range(11)
    9*   #  Multiply by 9
      +  #  Add to input
         # (Otherwise, do nothing)

gdSdSA$=  # H flag pushes 100
g         # Filter range(100) by:
 dSdS     #  Digit sum twice
     A$=  #  Equals the input

Perl 5, 62 bytes
sub x{$f=$_[0];@x=("0$f",$f);push@x,map$f+$_*10,(1..9)if$f;@x}

There's bound to be a shorter way

Gol><>, 12 bytes
I:ZhbF:N9+|;

Try it online!
How it works
I:ZhbF:N9+|;

I             Take input as number
 :            Duplicate
  Z           Pop and skip one if nonzero
   h          If zero, print the top as number and halt
              Otherwise...
    bF....|   Repeat these commands 11 times
      :N      Print top as number, with newline
        9+    Add 9
           ;  Halt


text:
The Take-back counting algorithm
Kids who are learning how to count often know runs of numbers, but can't seem to put those runs together properly.
For example, they might say:
1,2,3,4,7,8,9,10

Sometimes kids will realize that they skipped some numbers, and go back:
1,2,3,4,7,8,5,6,7,8,9,10

This is clearly the superior pattern.  We need to identify them.
To identify these lists:

We identify the minimum M and the maximum N of the list

We step through the list.  If the current number is greater than or equal to any member of the list to its right, then we remove the current number.

Iff the remaining list contains all numbers from M to N, then we return a truthy value.

You can assume your input list will contain at least 1 element.  You can assume that all integers will be non-negative.
Test cases:
Truthy:
0
10
0 0 0
1 0 1
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 0 1 2 3
0 1 2 3 4 5 5
0 1 1 2 2 3
0 3 6 1 4 7 2 5 8 3 4 5 6 7 8
1 3 5 7 2 3 4 5 6 7
5 6 0 1 2 3 6 7 4 5 6 7
5 6 7 8
5 5 6 7 8
4 6 7 8 3 4 5 6 7 8

Falsy:
1 0
4 3 2 1
1 2 3 7 8 9
0 1 2 3 1 3
0 1 2 3 1 3 4
0 1 2 3 1 3 2 4
0 1 2 3 1 3 2 4 3
1 3 5 7 2 4 6 8
0 1 2 1 3 4 5 6
4 5 6 3 4 5

This is code-golf, so make your answers as short as possible!

Not very clear: should [0,1,2,3,4,5,4,3,2,1] be considered true or false?

@GB False.  When you are on the second element, you would remove it on step 2 (because there's another 1 later down the line).  You'd also remove every other element (except for the last 1), so you'd end up with 0 1, which is not 0 1 2 3 4 5

05AB1E, 5 bytes
I am not 100% certain this works, but it passes all test cases and I couldn't find any situation where it fails.
Ú¥1QP

Try it online!
Ú¥1QP   Main link. Argument a
Ú       Reverse uniquify a, keeps only last occurence of each element
 ¥      Get all deltas - all 1 if ascending list
  1Q    Compare all deltas to 1
    P   Product of all results

7 bytes, in fact

@val No, 05AB1E uses a custom encoding, 05AB1E.

Ruby, 59 54 41 bytes
->a{a.reverse|[]==[*a.max.downto(a.min)]}

Try it online!

Jelly, 10 9 bytes
ṀrṂɓṚ«\Q⁼

Try it online!
How it works
ṀrṂɓṚ«\Q⁼  Main link. Argument: A (array)

Ṁ          Yield the maximum of A.
  Ṃ        Yield the minimum of A.
 r         Yield R := [max(A), ... min(A).
   ɓ       Begin a new chain. Left argument: A. Right argument: R
    Ṛ      Reverse A.
     «\    Take the cumulative minimum.
       Q   Unique; deduplicate the results.
        ⁼  Compare the result with R.

Interesting, is ɓ a relatively new feature?

Yes, it's from a pull request by Jonathan Allan.

Aha, 13 days ago. Hadn't seen it used yet though (maybe you or Jonathan have and I just missed it).

The real interesting part here is «\ in my opinion though.

Python 2, 81 bytes
x=input();r=m=[]
for n in x[::-1]:r=[n][:n<m]+r;m=r[0]
print r==range(m,max(x)+1)

Try it online!

PHP, 148 130 bytes

-18 bytes, thanks @Christoph
$a=explode(' ',$argn);$b=range(min($a),max($a));foreach($a as$i=>&$k)for(;++$i<count($a);)$k<$a[$i]?:$k=-1;echo!array_diff($b,$a);

Try it online!

Ok a lot to comment here: $argn is always a string foreach doesn't work on it. You could use $argv to get an array as input but beware that it always contains the filename as first element. You use $m and $n only once so you can save a lot of bytes creating $b earlier: $b=range(min($a),max($a));. The cast (bool) is completly unnecessary. if($k>=$a[$s])$a[$i]=null; to $k<$a[$s]?:$a[$i]=-1;. Using reference we can do this: foreach($a as$i=>&$k) (+1 byte) and $a[$i] to $k(-4 byte). Moreover that lets us drop $s=$i because we can iterate over $idirectly now.

The result looks like this $a=$argn;$b=range(min($a),max($a));foreach($a as$i=>&$k)for(;++$i<count($a);)$k<$a[$i]?:$k=-1;echo!array_diff($b,$a); (117 bytes). But it still uses $argn in the wrong way. $a=explode(' ',$argn); would fix this for 13 additional bytes.

@Christoph Thanks for the help, I'm rather new to golfing.

No problem ! Always nice to find a new PHP golfer I hope to see more of you :) either Titus, Jörg or me are always there to help !

@Christoph Why not using $_GET as Input array? In this case there is no need to use explode additonal -6 Bytes for using not the $b variable

@JörgHülsermann some nice ideas: <?$b=$a=$_GET;foreach($a as$i=>&$k)for(;++$i<count($a);)$k<$a[$i]?:$k=-1;echo!array_diff(range(min($b),max($b)),$a); 116 bytes. We still gotta copy $_GET twice because $a is modified.

@Christoph Would <?$b=$a=$_GET;foreach($a as$i=>&$k)for(;~$c=$a[++$i];)$k<$c?:$k=-1;echo!array_diff(range(min($b),max($b)),$a); not work ?

@JörgHülsermann when testing on my server $_GET values are strings (and we need to give the numbers as e.g. 0=1&1=2&2=4) and I get a fatal Unsupported operand types.

@Christoph Okay In this case we need a Version under 7.1 and we use ´a&instead of~` Try it online!

@Christoph any Idea to golfed this under 100? <?foreach($g=$_GET as$v)($p=array_slice($g,++$k))&&$v>=min($p)?:$r[]=$v;echo$r==range($r[0],max($g)); M.E. you can get it Try it online!

@JörgHülsermann You should post the last one as your own answer because you have changed so much from my original version.

Take it as Gift. See it as our Teamwork. In the past there was always the case that for example Titus or Christoph helps me to improve my posts. Now I can help them sometimes or in this case you

Java 8, 264 262 bytes
import java.util.*;l->{int m=Collections.max(l),n=Collections.min(l),i=0,q;for(;i<(q=l.size());i++)if(l.subList(i+1,q).size()>0&&l.get(i)>=Collections.min(l.subList(i+1,q)))l.remove(i--);for(i=0;n<=m;)if(i<l.size()&&l.get(i++)==n)n++;else return 0>1;return 1>0;}

Explanation:
Try it here.
import java.util.*;                 // Import for Collections

l->{                                // Method with integer-ArrayList parameter and boolean return-type
  int m=Collections.max(l),         //  Max of the list
      n=Collections.min(l),         //  Min of the list
      i=0,q;                        //  Two temp integers
  for(;i<(q=l.size());i++)          //  Loop (1) over the list
    if(l.subList(i+1,q).size()>0    //   If the sublist right of the current item is not empty
    &&l.get(i)>=Collections.min(l.subList(i+1,q)))
                                    //   and if the current item is larger or equal to the lowest value of this sublist
      l.remove(i--);                //    Remove the current item from the main list
                                    //  End of loop (1) (implicit / single-line body)
  for(i=0;n<=m;)                    //  Loop (2) from min to max
    if(i<l.size()                   //   If the current item doesn't exceed the list's size
    &&l.get(i++)==n)                //   and the items are in order so far
      n++;                          //    Go to the next item
    else                            //   Else:
      return 0>1;//false            //    Return false
                                    //  End of loop (2) (implicit / single-line body)
  return 1>0;//true                 //  Return true
}                                   // End of method

R, 88 85 bytes
y=NULL;for(i in x<-scan())if(all(i<x[-(1:(F<-F+1))]))y=c(y,i);all(min(x):max(x)%in%y)

This can probably be golfed down further. Loops over the elements of x, checks if all upcoming values are bigger, and only then keeps that element. After the loop it creates a sequence from min(x) to max(x), and checks with %in% if all values are included in the pruned version of x.

By porting Dennis' answer we could get down to 53 bytes. function(n)all(unique(cummin(rev(n)))==max(n):min(n))

JavaScript (ES6), 60 bytes
s=>(o={},s.reverse().every((n,i)=>!i|o[n+1]|o[n]&&(o[n]=1)))

Ungolfed:
s=>(
  o={},
  s.reverse().every((n,i)=>
    !i|o[n+1]|o[n]&&(o[n]=1)
  )
)

This is a simpler algorithm:
Iterate the array in reverse, and make sure each number (except the first) is one less than or equal to a number already seen.
Snippet:

f=

s=>(o={},s.reverse().every((n,i)=>!i|o[n+1]|o[n]&&(o[n]=1)))

console.log('Truthy');
console.log(f([0]))
console.log(f([10]))
console.log(f([0,0,0]))
console.log(f([1,0,1]))
console.log(f([0,1,2,3,4,5,6,7,8,9,10]))
console.log(f([0,1,2,3,0,1,2,3]))
console.log(f([0,1,2,3,4,5,5]))
console.log(f([0,1,1,2,2,3]))
console.log(f([0,3,6,1,4,7,2,5,8,3,4,5,6,7,8]))
console.log(f([1,3,5,7,2,3,4,5,6,7]))
console.log(f([5,6,0,1,2,3,6,7,4,5,6,7]))
console.log(f([5,6,7,8]))
console.log(f([5,5,6,7,8]))
console.log(f([4,6,7,8,3,4,5,6,7,8]))

console.log('Falsy');
console.log(f([1,0]))
console.log(f([4,3,2,1]))
console.log(f([1,2,3,7,8,9]))
console.log(f([0,1,2,3,1,3]))
console.log(f([0,1,2,3,1,3,4]))
console.log(f([0,1,2,3,1,3,2,4]))
console.log(f([0,1,2,3,1,3,2,4,3]))
console.log(f([1,3,5,7,2,4,6,8]))
console.log(f([0,1,2,1,3,4,5,6]))
console.log(f([4,5,6,3,4,5]))

Haskell, 62 bytes
g(a:b)=[a|all(a<)b]++g b
g a=a
f x=g x==[minimum x..maximum x]

Try it online!
A direct implementation of the definition where g removes the elements if they are >= than the the elements to its right.

C#, 69 bytes
s=>s.Where((e,i)=>s.Skip(i+1).All(r=>e<r)).Count()==s.Max()-s.Min()+1

In short:
s = input (s)equence
take from s element where all items after this one (skip (I)ndex + 1 items), current value is higher
count these, and see if the amount left is equal to the amount expected ((max)imum value minus (min)imum) amount of numbers
Try it online!

@MDXF Do you want to welcome him?

@StanStrum did i misunderstand the rules? is my english too messy? i -am- posting for the first time...

No, no! It's a privilege to welcome a newcomer to PPCG, and I was asking him if he'd wanted to say hi to you

Looks like the privilege is to the both of you. Thanks, people ^^

This is a great first answer, hope you have fun in your future of PPCG!

JavaScript (ES6), 82 73 72 70 bytes
Returns a boolean.
a=>a.filter((x,i)=>k-=a.every(y=>~i--<0|y>x,m=x>m?x:m),m=k=0)[0]+~m==k

How?
We iterate on each element x of the input array a, keeping track of the maximum encountered value m and the number -k of values that are not greater than or equal to any member to their right. By definition, valid values appear in strictly ascending order.
We use filter() rather than map(), so that all elements get filtered out until k turns negative. This allows us to isolate the first valid element, which is also guaranteed to be the minimum value of the array.
Finally, we test whether minimum - (maximum + 1) == -number_of_valid_elements:
a.filter(...)[0] + ~m == k

Test cases

let f =

a=>a.filter((x,i)=>k-=a.every(y=>~i--<0|y>x,m=x>m?x:m),m=k=0)[0]+~m==k

console.log('[Truthy]');
console.log(f([0]));
console.log(f([10]));
console.log(f([0,0,0,]));
console.log(f([1,0,1]));
console.log(f([0,1,2,3,4,5,6,7,8,9,10]));
console.log(f([0,1,2,3,0,1,2,3]));
console.log(f([0,1,2,3,4,5,5]));
console.log(f([0,1,1,2,2,3]));
console.log(f([0,3,6,1,4,7,2,5,8,3,4,5,6,7,8]));
console.log(f([1,3,5,7,2,3,4,5,6,7]));
console.log(f([5,6,0,1,2,3,6,7,4,5,6,7]));
console.log(f([5,6,7,8]));
console.log(f([5,5,6,7,8]));
console.log(f([4,6,7,8,3,4,5,6,7,8]));

console.log('[Falsy]');
console.log(f([1,0]));
console.log(f([4,3,2,1]));
console.log(f([1,2,3,7,8,9]));
console.log(f([0,1,2,3,1,3]));
console.log(f([0,1,2,3,1,3,4]));
console.log(f([0,1,2,3,1,3,2,4]));
console.log(f([0,1,2,3,1,3,2,4,3]));
console.log(f([1,3,5,7,2,4,6,8]));
console.log(f([0,1,2,1,3,4,5,6]));
console.log(f([4,5,6,3,4,5]));

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Print your system's logo
This is a throwback challenge. You will choose an old computer system and an old language created for that system.
The challenge
Pick an old computer system that was made before the year 2000. In a programming language that was created to run on that system, print said system's logo.
Example systems, their languages, and their logos:

Atari ST - GFA BASIC - Atari logo
Apple ][ - Applesoft BASIC - Full logo or Apple only
IBM PC - IBM COMMAND.COM or BASIC-80 - IBM logo

The rules

You may not download the logo/icon from the internet or read it from the filesystem.
You must use graphics to print the logo - no ASCII art.
The icon's size must be at least 20 pixels by 20 pixels.
Your program will not take any input and will clear the screen, print the logo, and exit normally.
If the logo includes colors, your program must print the logo in the same colors, unless your system does not have a color display.
The computer must not shut down.
Your system must have a logo.
If the logo includes text (e.g. the Apple ][ in the Apple logo), you only need to print the image part (e.g. the actual colored Apple).

The winner
As with code-golf, the submission with the least bytes wins!

Let us continue this discussion in chat.

GFA BASIC on Atari ST, 27 bytes
This is a manually edited source code in .LST format. It contains unprintable characters: [SO] and [SI] stand for ASCII characters #14 and #15 respectively. Both lines ends with CR.
DEFTEXT,,,32
TEXT0,28,"[SO][SI]"

This will draw a 28x26 Atari logo, which is part of the Atari ST system font.

I've cropped the output to the logo in the corner and Google's Search by image thinks it's a keyboard. While I'd consider this a flaw of the challenge spec rather than your answer, it still means that your answer doesn't comply with the current state of the rules.

Applesoft BASIC on the Apple ][, 365 361 bytes
1GR:POKE-16302,0:I=0:O=15:P=1:Q=1:FORY=7TO47:I=I-1:IF(I<=0)THENI=7:READC:COLOR=C
2IF(Y<21)THENO=O-((21-Y)/12):GOTO4
3O=O+P-1:P=P*Q:Q=Q+0.002
4HLINO,39-O ATY:NEXT:DATA12,13,9,1,3,6:COLOR=0:HLIN16,22 AT7:HLIN18,20 AT8:HLIN16,22 AT47:HLIN18,20 AT46:VLIN14,34 AT32:VLIN15,33AT 31:VLIN16,32 AT30:VLIN18,30 AT29:VLIN22,26 AT28:COLOR=12:FORA=0TO3:VLINA,A+4 AT22-A:NEXT

Output and actual logo:

According to your own rules, this is invalid, as Google's Search by image fails to identify it as an Apple logo.

@Dennis Crud... yet it's clearly the logo. So I need a better validity check than that. Any suggestions?

I don't; fuzzy image comparison is hard. While a human observer might see what you're going for, the colors are wrong that the original logo doesn't consist of huge pixels.

@Dennis Well not necessarily a better image comparison than Google's Search by Image, that's more or less the best out there IME. I mean a better validity check as in a clear description of the boundaries between a valid submission and an invalid one - to prevent people from printing a big red box and saying  "It looks like the Apple logo without my glasses on" and complete-cheat submissions like that.

You won't get an objective validity criterion unless the test can be performed by a computer.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Generate Tiny Text
Challenge
Your program needs to take an input of a string, where the string has only letters, no special characters, no numbers, and no accents (they look all weird).
Then, your program should output a superscript version.
Example
Input: hello world
Output: ʰᵉᶫᶫᵒ ʷᵒʳᶫᵈ
Test Cases
hello - ʰᵉᶫᶫᵒ
code - ᶜᵒᵈᵉ
golf - ᵍᵒᶫᶠ
asdf - ᵃˢᵈᶠ
qwerty - ᑫʷᵉʳᵗʸ
abcdefghijklmnopqrstuvwxyz - ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ

Help
If you need help understanding check out this website, it's a translator:
http://txtn.us/tiny-text
Code Golf
This is a code golf, so the shortest code wins!
Good luck!
Edits
Edit #1: There will be no caps, since I just realized they look weird.

Will they be all lowercase?

Related

@BetaDecay They're related but this is superscript

@BetaDecay Oops, sorry.

@ASCII-only I changed my mind, see edit, all lowercase.

tr is tr, and changing the second argument from small caps to superscript doesn't make a fundamentally different question.

"output superscript version" - output where? If I am not mistaken, there is no even such a thing as unicode latin superscript letters. If so this does not make sense for text output, and should be tagged graphical-output or browser.

Also in your examples I see letters I, L, N, as caps and q as normal size, so it does not work in Firefox.

@MikhailV it's unicode: https://en.wikipedia.org/wiki/Unicode_subscripts_and_superscripts

yes that's what I am saying " the Unicode standard contains superscript and subscript versions of a subset of Latin ... these characters come from different ranges, they may not be of the same size and position, depending on the typeface" So there is no standard latin superscript in unicode.

@MikhailV but it's still in unicode

JavaScript (ES6), 10 bytes
s=>s.sup()

It should be noted that the sup() method has been deprecated so this solution may not work in all browsers nor is it guaranteed to continue working in future releases of browsers that do currently support it. Tested and confirmed to work in Chrome v58.

Try it

f=
s=>s.sup()
o.innerHTML=(i.value="Hello!")+": "+f(i.value)
oninput=_=>o.innerHTML=i.value+": "+f(i.value)
*{font-family:arial,sans-serif}
<input id=i>

Can you add a code snippet try me thing?

@NoahCristino, Snippet added.

@Shaggy That's weird, when I converted something like: CAPSLOCK@^&@^& with the website, I get: ᶜᴬᴾˢᴸᴼᶜᴷ@^﹠@^﹠, but with your it works right.

@Shaggy Yeah, that's probably it

Deprecated, but still works with all major browsers so gets my vote:  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/sup

@RickHitchcock: Yep, was editing that point into my answer as you were commenting.

PHP+HTML, 17 Bytes
<?=$_GET[0];

Doesn't this still display normal characters, in a superscript size and position?

<?=$_GET[0];

@L3viathan Yes and the input is limited to letters

How is it limited to letters?

@Shaggy The OP says Your program needs to take an input of a string, where the string has only letters, no special characters, no numbers, and no accents (they look all weird).

Ah, I thought you were implying that your code stripped out non-letter characters - I couldn't see how it was possibly doing that! :D

@JörgHülsermann The input is letters, but the output is (in my understanding) supposed to be superscript characters (e.g. U+1D43 for a), not just look like them.

@Shaggy Yes it do the same that your JS answer do

@L3viathan If your understanding is right there are two other invalid answers from Shaggy and Kevin Cruijssen

Mathematica, 13 bytes
#~Style~Tiny&

Java 8 (AWT / Swing), 79 bytes
s->new java.awt.Frame(){{add(new javax.swing.JLabel(""+s));show();}}

Unfortunately there is no reliable online compiler available for Java GUI, so no TIO-link.
Java 8 (Console), 123 117 bytes
s->{for(int x:s.toCharArray())System.out.print("ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ".charAt(x-97));}

Try it here.

Do you need the  tag?

@Shaggy Unfortunately yes, I've already tried without it when I posted the answer. Without it just outputs sometext literally. It will probably enable html if it sees the  text in the JLabel.

Pyth, 75 bytes (30 chars)
XwG"ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ

Try it!


text:
Find a binary needle in a decimal haystack
The challenge
You're given:

a non-empty, unsorted list h of positive integers (the haystack)
a positive integer n (the needle)

Your task is to return the list of all unique decimal concatenations of permutations of h whose binary representation contains the binary representation of n.
Examples

h = [ 1, 2, 3 ]
n = 65

There's only one matching concatenation, so the expected output is [321].
h = [ 1, 2, 3 ]
n = 7
This time, there are three concatenations which contain the binary pattern 111. The expected output is [123, 231, 312].
h = [ 12, 3 ]
n = 7
Only two permutations are available and both are matching. The expected output is [123, 312].
h = [ 1, 2, 2 ]
n = 15
The only matching concatenation is 122 (1111010 in binary, which contains 1111), so the expected output is [122]. Note that two permutations actually lead to 122 but you are not allowed to output [122, 122].

Clarifications and rules

You may take the needle as an integer (65), a string representing a decimal value ("65") or a string representing a binary value ("1000001").
You may take the haystack as a native array/object/set of integers ([11,12,13]), a native array/object/set of strings representing decimal values (["11","12","13"]), or a delimited string of decimal values ("11 12 13" or "11,12,13"). You may also opt for a variant using arrays of digits (like [[1,1],[1,2],[1,3]]).
The output must follow one of the formats described above for the haystack, but not necessarily the same one.
You're not supposed to handle haystacks whose highest decimal concatenation is greater than the highest representable unsigned integer in your language.
Apart from that, your code should theoretically support any input -- assuming it's given enough time and memory.
This is SPARTA! code-golf, so the shortest answer in bytes win!

Test cases
Haystack             | Needle   | Output
---------------------+----------+-----------------------------------
[ 1, 2, 3 ]          | 65       | [ 321 ]
[ 1, 2, 3 ]          | 7        | [ 123, 231, 312 ]
[ 12, 3 ]            | 7        | [ 123, 312 ]
[ 1, 2, 2 ]          | 15       | [ 122 ]
[ 1, 2 ]             | 7        | []
[ 12, 34, 56 ]       | 21       | [ 125634, 341256, 345612, 563412 ]
[ 1, 2, 3, 4, 5 ]    | 511      | [ 53241 ]
[ 1, 3, 5, 7, 9 ]    | 593      | [ 37519, 51793, 75913, 75931 ]
[ 11, 12, 13, 14 ]   | 12141311 | [ 12141311 ]
[ 1, 2, 1, 2, 1, 2 ] | 1015     | [ 221112 ]

My solution's output is like set([(1, 2, 2)]). Is it valid or should I get rid of  set?

@DeadPossum Yes, it's valid.

Can the haystack input be a single string ("123")? In some languages a string is the same as an array of chars, so I think it would makes sense

@LuisMendo It can't because ["12","3"] and ["1","23"] are two distinct haystacks.

@Arnauld Ah, I thought they were digits. Thanks

So, given your reply to Possum, would an array of arrays be valid output? e.g., [[1,2,3],[3,1,2]] for the 3rd test case.

@Shaggy Yes, that would work.

Can we return an array with NULL values for the permutations that do not comply? Like [[], [], [], [3, 2, 1], [], []] for the first test case?

@JarkoDubbeldam I would say no. That would quickly lead to very large outputs.

it looks like the test case [12,34,56] outputs [] for 21. Either that, or the 05AB1E answer is wrong.

05AB1E, 10 8 bytes
Takes the needle in binary to save 1 byte.
-2 bytes thanks to Emigna
œJÙʒbŒIå

Try it online!
œJÙʒbŒIå   Arguments: a, n
œJÙ        Get all unique permutations of a
   ʒ       Filter: Keep if following code returns true
    b      Convert to binary
     Œ     Get all substrings
      Iå   Check if substrings contain n
           Implicit output of filtered list

œJÙʒbŒIå should work as well.

@Emigna Thanks, that saves 2 bytes :)

Python 2, 90 bytes
-3 bytes thanks to @Gábor Fekete
Try it online
Takes as input array of strings, representing ints from hay and string, representing needle in binary
from itertools import*
lambda H,N:{i for i in permutations(H)if N in bin(int(''.join(i)))}

Writing {...} instead of set(...) saves 3 bytes.

@GáborFekete I always forget, that {} is set :D Thanks

I believe this fails on H=['1'], N='0'.

Oh, wait, the input is required to be positive.

Java 10, 320 312 305 297 292 bytes
import java.util.*;Set s=new HashSet();l->n->{Long q=0;p(l,0);for(var x:s)if(q.toString(q.decode(x+""),2).contains(n))System.out.println(x);}void p(List l,int k){int i=k,x=l.size();for(Collections C=null;i<x;p(l,k+1),C.swap(l,k,i++))C.swap(l,i,k);if(k>x-2)s.add((l+"").replaceAll("\\D",""));}

Input as List & binary-String, output as Strings on new-lines.
Explanation:
Try it here.
import java.util.*;           // Required import for Set, HashSet, List, and Collections

Set s=new HashSet();          // Class-level Set

l->n->{                       // Method (1) with List and String parameters and no return-type
  Long q=0;                   //  Number-object is required for two static method-calls below
  p(l,0);                     //  Determine all permutations of given list and put it in the Set
  for(var x:s)                //  Loop over these permutations
    if(q.toString(q.decode(x+""),2)
                              //   If the binary String of the current permutation
        .contains(n))         //   contains the binary String of the input integer
      System.out.println(x);} //    Print this permutation

void p(List l,int k){         // Method (2) with List and integer parameters and no return-type
  int i=k,x=l.size();         //  Two temp integers
  for(Collections C;          //  Collections-object is required for two static method-calls below
      i<x                     //  Loop `i` in the range [`k`, list-size)
      ;                       //    After every iteration:
       p(l,k+1),              //     Do a recursive-call to this method with `k+1`
       Collections.swap(l,k,i++))
                              //     And swap the items at indices `k` and `i` back
    Collections.swap(l,i,k);  //   Swap the items at indices `i` and `k`
  if(k>x-2)                   //  If `k` is now equal to the size of the list - 1
    s.add((l+"").replaceAll("\\D",""));}
                              //   Add this permutation to the Set

Personally I'd put l->n->{... after void p(... as the lambda is the answer to the prompt and the function is required setup for the lambda to work. Consensus on "function expressions" is something like "the last 'expression' of your submission can be a 'function expression' if when stored to a variable it meets the requirements of a function answer" IIRC. But that's just a formatting issue, and a subjective one at that.

@CAD97 I had no idea the order mattered. Last time I posted a Java 8 answer with two methods I used void because it was shorter than a second lambda and the multiple .apply. Haven't checked it for this answer (i.e. void p(List l,int k) & 2x p(l,0) versus (l,k)-> & 2x p.apply(l,0)). Hmm.. second one seems to be 1 byte shorter in this case. But you say rules state you are only allowed to have one lambda method? Still a bit confused why it has to be the last one. Personally I always post my answers in this order: imports; class-fields; main-method/lambda; other methods.

again, it's mostly opinion, I'd want someone more experienced to chime in before really saying one way or the other. However, I know this to be true: If you need to call a method (e.g. recursive or as a helper), it needs to have a name. But as for ordering, it doesn't really matter as it doesn't change the byte count. But I order as imports;helper methods;lambda

@CAD97 Ah of course, so it would be void p(List l,int k) & 2x f(l,0); versus f=(l,p)-> & 2x p.apply(l,0); instead (which means the current version is 1 byte shorter). As for the order, I'll just stick with this since I've done so with all my answers, and it also makes sense to me personally to start with the main method in the explanation, and then the helper method(s) if there are any.

and unfortunately you can't just do f=(lambda) in Java, it's java.util.function.BiConsumer<List,Integer>f=(l,p)->{...}

Japt, 15 14 13 12 10 bytes
Takes the haystack as an array of integers and the needle as a binary string. Outputs an array of integer strings.
á m¬f_°¤øV

Saved a byte thanks to ETHproductions

Try it

Explanation
á m¬â f_°¤øV
              :Implicit input of array U=haystack and string V=needle
á             :Unique permutations of U
  m           :Map
   ¬          :  Join to a string
    f_        :Filter
      °       :  Postfix increment current element to cast it to an integer
       ¤      :  Convert to base-2 string
        øV    :  Does that contain V?
              :Implicit output of resulting array

Very nice, about what I would have done. ®¬nÃ saves a byte on the mapping. (I'd also move â to the middle of the program to get rid of the second Ã; doesn't save any bytes, but it's a little more efficient and looks slightly better)

Aha, thanks, @ETHproductions - I was so focused on seeing if I could shave any bytes off by outputting each number as an array I missed that simple change to the mapping. The â was a quick fix tacked on the end when Arnauld pointed that I'd forgotten to remove the duplicates from the final array but, you're right, removing the duplicates before running the filter would be more efficient.

Ruby, 61 59 bytes
->a,n{a.permutation.select{|s|"%b"%s.join=~/#{"%b"%n}/}|[]}

Try it online!
Cool feature of the day: I didn't know I could output the binary representation of a string containing a number.
Example:
puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 bytes
Takes needle as a binary string.
(h,n,S=new Set,p=(a,m='')=>a.length?a.map((_,i)=>p(A=[...a],m+A.splice(i,1))):S.add(+m),_=p(h))=>[...S].filter(d=>~d.toString(2).indexOf(n))

f=
(h,n,S=new Set,p=(a,m='')=>a.length?a.map((_,i)=>p(A=[...a],m+A.splice(i,1))):S.add(+m),_=p(h))=>[...S].filter(d=>~d.toString(2).indexOf(n))

console.log( f([1, 2, 3], (65).toString(2)) )
console.log( f([12, 34, 56], (21).toString(2)) )

Brachylog, 15 bytes
{hpc.ḃs~ḃ~t?∧}ᵘ

Try it online!
Explanation
{            }ᵘ    Find all unique outputs, given [h, n], of:
 hpc.                The Output is the concatenation of a permutation of h
    .ḃs              Take a substring of the binary representation of the Output
       ~ḃ            Convert it back to a decimal number
         ~t?∧        This decimal number must me n

Mathematica, 170 156 bytes
(t={};l=Length;v=IntegerDigits;j=v[#2, 2];s=FromDigits/@Flatten/@v@Permutations@#1;Table[If[l@SequenceCases[v[s[[i]],2],j]>0,t~AppendTo~s[[i]]],{i,l@s}];t)&

input

[{12, 34, 56}, 21]

output

{125634, 341256, 345612, 563412}

There's a whitespace at v[#2, 2].

CJam, 23 22 21 19 bytes
{e!{si2b1$2b#)},\;}

This is a block that takes inputs n h on the stack and leaves the output as an array on the stack.
Explanation:
                   e# Stack:                      | 65 [1 2 3]
e!                 e# Unique Permutations:        | 65 [[1 2 3] [1 3 2] [2 1 3] [2 3 1] [3 1 2] [3 2 1]]
  {                e# Filter where block is true: | 65 [3 2 1]
   s               e#   Convert to string:        | 65 "321"
    i              e#   Convert to int:           | 65 321
     2b            e#   Convert to binary:        | 65 [1 0 1 0 0 0 0 0 1]
       1$          e#   Copy behind:              | 65 [1 0 1 0 0 0 0 0 1] 65
         2b        e#   Convert to binary:        | 65 [1 0 1 0 0 0 0 0 1] [1 0 0 0 0 0 1]
           #       e#   Find array in another:    | 65 2
            )      e#   Increment:                | 65 3
             },    e# End filter                  | 65 [321]
               \;  e# Delete back:                | [321]

R, 114 bytes
pryr::f(plyr::l_ply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste(y,collapse=""))))cat(y,"\n")))

Uses a bunch of packages. pryr::f() automatically creates a function, taking p, a string of the binary pattern to look for, and x, a vector with the other input as input. combinat::permn creates all permutations of x. R.utils::intToBin is a nice and wordy version to convert a numeric (or character representation of a numeric) to a binary number, already conveniently stored as a character. So applying this over all the permutations and outputting them if the binary string p is contained in the binary version of the concatenation. An explicit newline is printed, because otherwise the output would be 12 56 3456 34 1234 56 1234 12 56.
plyr's l_ply is used to surpress outputting a null list, besides the regular output. If output like this is allowed:
3 2 1
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Then we can save few bytes by using lapply instead:
108 bytes:
pryr::f(lapply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste(y,collapse=""))))cat(y,"\n")))

If output like this is allowed:
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Then we can do it even shorter:
101 bytes:
pryr::f(lapply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste0(y,collapse=""))))y))

Not allowed.

Perl 6, 69 bytes
{set @^a.permutations».join.grep(*.fmt('%b').contains($^b.base(2)))}

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
The strange attraction of the logistic map
The purpose of the challenge is to approximately plot the attractor of the logistic map as a function of its parameter r (also called bifurcation diagram), or a subregion of it. The appearance of the graph can be seen in the following image from Wikipedia:

Background
The logistic map is a mathematical function that takes an input xk and maps it to an output xk+1 defined as
             xk+1 = r xk (1−xk)
where r is the parameter of the map, assumed to lie in the interval [0, 4].
Given r in [0,4], and an initial value x0 in the interval [0,1], it is interesting to repeatedly apply the function for a large number N of iterations, producing a final value xN. Note that xN will necessarily lie in [0,1] too.
As an example, consider r = 3.2, N = 1000. The initial value x0 = 0.01 gives x1000 = 0.5130. For x0 = 0.02 the result is x0 = 0.7995. For any other initial values x0 the final values x1000 are extremely close to either 0.5130 or 0.7995. This is seen in the graph as the height of the two lines at horizontal position r = 3.2.
This does not mean that for r = 3.2 each sequence converges to one of those two values. In fact, for the two initial values considered above, the sequences are (note the oscillating behaviour):
             x0 = 0.01, ..., x1000 = 0.5130, x1001 = 0.7995, x1002 = 0.5130, ...
             x0 = 0.02, ..., x1000 = 0.7995, x1001 = 0.5130, x1002 = 0.7995, ...
What is true is that for sufficiently large N, and for almost all initial values x0, the term xN will be close to one of the elements of the set {0.5130, 0.7995}. This set is called the attractor for this specific r.
For other values of the parameter r the size of the atractor set, or its elements, will change. The graph plots the elements in the attractor for each r.
The attractor for a specific r can be estimated by

testing a wide range of initial values x0;
letting the system evolve for a large number N of iterations; and
taking note of the final values xN that are obtained.

The challenge
Inputs

N: number of iterations.
r1, r2 and s. These define the set R of values of r, namely R = {r1, r1 + s, r1 + 2 s, ..., r2}.

Procedure
The set X of initial values x0 is fixed: X = {0.01, 0.02, ..., 0,99}. Optionally, 0 and 1 may also be included in X.
For each r in R and each x0 in X, iterate the logistic map N times to produce xN. Record the obtained tuples (r, xN).
Output
Plot each tuple (r, xN) as a point in the plane with r as horizontal axis and xN as vertical axis. Output should be graphic (not ASCII art).
Additional rules

The indicated procedure defines the required result, but is not enforced. Any other procedure that procudes the same set of (r, xN) tuples can be used.
Input is flexible as usual.
Floating point errors won't be held against the answerer.
Graphic output is required, in any of the accepted formats. In particular, output may be displayed on screen, or a graphics file may be produced, or an array of RGB values may be output. If outputting a file or an array, please post an example of what it looks like when displayed.
Graphics may be vector or raster. For raster graphics, the size of the image should be at least 400×400 pixels.
Each point should be shown as a single pixel, or as a mark with size of the order of one pixel (otherwise the graph quickly gets cluttered).
Axis range should be [0,4] for r (horizontal axis) and [0,1] for xN (vertical axis); or it may be smaller as long as it includes all obtained points.
Axis scales are arbitrary. In particular, the scale need not be the same for both axes.
Grid lines, axis labels, colors and similar elements are acceptable, but not required.
Shortest code in bytes wins.

Test cases
Click on each image for a high-resolution version.
N = 1000; r1 = 2.4; r2 = 4; s = 0.001;

N = 2000; r1 = 3.4; r2 = 3.8; s = 0.0002;

N = 10000; r1 = 3.56; r2 = 3.59; s = 0.00002;

Acknowledgment
Thanks to @FryAmTheEggman and @AndrasDeak for their helpful comments while the challenge was in the sandbox.

What no python solution?!

@Lembik I have a reference implementation in Python (and in Matlab), but I don't want to answer myself

You are allowed to answer your own  questions on  PPCG (perhaps surprisingly).

@Lembik I know, but I'd rather have others' answers

MATL, 32 30 28 27 bytes
4 bytes saved thanks to @Luis
3$:0:.01:1!i:"tU-y*]'.'3$XG

The input format is r1, s, r2, and N
Try it at MATL Online

Explanation
        % Implicitly grab the first three inputs
3$:     % Take these three inputs and create the array [r1, r1+s, ...]
0:.01:1 % [0, 0.01, 0.02, ... 1]
!       % Transpose this array
i       % Implicitly grab the input, N
:"      % For each iteration
  tU    % Duplicate and square the X matrix
  -     % Subtract from the X matrix (X - X^2) == x * (1 - x)
  y     % Make a copy of R array
  *     % Multiply the R array by the (X - X^2) matrix to yield the new X matrix
]       % End of for loop
'.'    % Push the string literal '.' to the stack (specifies that we want
        % dots as markers)
3$XG    % Call the 3-input version of PLOT to create the dot plot

Mathematica, 65 bytes
Graphics@Table[Point@{r,Nest[r#(1-#)&,x,#]},{x,0,1,.01},{r,##2}]&

Pure function taking the arguments N, r1, r2, s in that order. Nest[r#(1-#)&,x,N] iterates the logistic function r#(1-#)& a total of N times starting at x; here the first argument to the function (#) is the N in question; Point@{r,...} produces a Point that Graphics will be happy to plot. Table[...,{x,0,1,.01},{r,##2}] creates a whole bunch of these points, with the x value running from 0 to 1 in increments of .01; the ##2 in {r,##2} denotes all of the original function arguments starting from the second one, and so {r,##2} expands to {r,r1,r2,s} which correctly sets the range and increment for r.
Sample output, on the second test case: the input
Graphics@Table[Point@{r,Nest[r#(1-#)&,x,#]},{x,0,1,.01},{r,##2}]&[2000,3.4,3.8,0.0002]

yields the graphics below.

59 bytes ListPlot@Table[{r,Nest[r#(1-#)&,x,#]},{x,0,1,.01},{r,##2}]&

I've clarified in the challenge that the indicated procedure is meant to define the required result, but the procedure itself is not enforced. You can use any other procedure that gives the same result. Sorry if that wasn't clear at first

Not a problem, we have several good answers!

Aren't you going to use those -6 bytes. Do you think that somathing is wrong with this solution?

Oh I thought your answer was the posting of (a version of) the code from your comment....

Mathematica, 65 bytes
I used some of Greg Martin's tricks and this is my version without using Graphics
ListPlot@Table[{r,NestList[#(1-#)r&,.5,#][[-i]]},{i,99},{r,##2}]&

input

[1000, 2.4, 4, 0.001]

output

input

[2000, 3.4, 3.8, 0.0002]

output

First answer that chooses to avoid initial values 0 or 1 (and the x = 0 line they generate) :-)

You should add an explanation of what your code does, since it doesn't actually follow the specified procedure. The OP can decide whether the accurate-looking result justifies the alternate method.

The specified procedure is not enforced. Anything that gives the same result, by any other means, is allowed (I'll clarify that). Regardless of this, I'm curious to see the explanation

The points that you need to plot for every r, exist already in every "Nest". this is original code and it was my first approach (a while ago) on plotting this diagram.

@Luis Mendo I have an even shorter version (which makes a record for mathematica).58 bytes but you must enter only 3 inputs [N,r1,r2].It takes time but it works.Plot[Table[NestList[#(1-#)r&,.5,#][[-i]],{i,99}],{r,##2}]&

So the step s would be fixed? It would not be valid then

no it is not. the step changes into the nest

I don't get what you mean by "nest". Anyway, if you don't take the step as input, how can the code take the step into account?

"Plot" in mathimatica takes automatically a tiny step... Like when you plot sin(x),{x,0,2pi} on the Reals. This automatic tiny step gives me the extra bytes in my second code.Problem is the step is very small and it takes much time

TI-Basic, 85 bytes
Prompt P,Q,S,N
P→Xmin:Q→Xmax
0→Ymin:1→Ymax
For(W,.01,1,.01
For(R,P,Q,S
W→X
For(U,1,N
R*X*(1-X→X
End
Pt-On(R,X
End
End

A complete TI-Basic program which takes input in the order r1,r2,s,N and then shows the output in real time on the graph screen. Note that this tends to be incredibly slow.
Here is an incomplete sample output generated after about 2.5 hours for the input 3,4,0.01,100:

You don't need the * signs.

ProcessingJS, 125 123 120 bytes
Thanks to Kritixi Lithos for saving 3 bytes.
var f(n,q,r,s){size(4e3,1e3);for(i=0;i<1;i+=.01)for(p=q;p<=r;p+=s){x=i;for(j=0;j<n;j++)x*=p-p*x;point(p*1e3,1e3-x*1e3)}}

Try it online! Call using f(N, r_1, r_2, s);

I think you can replace void with var because it's ProcessingJS

And x*=p*(1-x) can become x*=p-p*x

By rearranging the for-loop, I get var f(n,q,r,s){size(4e3,1e3);for(i=0;i<1;i+=.01)for(p=q;x=i,p<=r;point(p*1e3,1e3-x*1e3),p+=s)for(j=0;j<n;j++)x*=p-p*x;} at 119 bytes

GEL, 158 bytes
`(N,r,t,s)=(LinePlotWindow=[r,t,0,1];for i=r to t by s do(p=.;for w=0to 1by 0.01do(x=w;for a=0to N do(x=i*x*(1-x););p=[p;q=[i,x]];);LinePlotDrawPoints(p);););

It may not be the shortest, but it draws in real time, although it can be incredibly slow with huge inputs. Anyways, this is an anonymous function which takes input in the format (N,r1,r2,s) and outputs the plot in a new window. Note that this must be run with the GNOME version of Genius.

R, 159 147 bytes
pryr::f({plot(NA,xlim=c(a,b),ylim=0:1);q=function(r,n,x=1:99/100){for(i in 1:n)x=r*x*(1-x);x};for(i in seq(a,b,s))points(rep(i,99),q(i,n),cex=.1)})

Which productes the function
function (a, b, n, s)
{
    plot(NA, xlim = c(a, b), ylim = 0:1)
    q = function(r, n, x = 1:99/100) {
        for (i in 1:n) x = r * x * (1 - x)
        x
    }
    for (i in seq(a, b, s)) points(rep(i, 99), q(i, n), cex = 0.1)
}

plot(NA,...) creates an empty canvas that has the correct dimensions. q is the function that does the iterating. It takes a value of r, and then does n iterations for all starting points between 0.01 and 0.99. It then returns the resulting vector.
The for-loop applies the function q to the sequence a to b with step s. Instead of returning the values, it adds them as points to the plot. If the attraction point is one value, all the points would just overlap and show as one point. cex=.1 is a necessary addition to make the points as small as possible.


text:
Fizz Buzz to Text
Introduction
I don't particularly know where the fizz buzz trend came from. It might just be a meme or something, but it is somewhat popular.
Challenge
Your job today is to convert Fizz Buzz into binary (0, 1) respectively, and convert that binary to text. Pretty standard stuff.
How does that work?
FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz would translate into 01101000 01101001 then that would translate into "hi"
Constraints

Input is Fizz Buzz in a binary standpoint (see examples below.)
Output must be text.
You can assume the FizzBuzz input is right.
This is code-golf, shortest bytes win.

Input

FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz

Output
"hi!"

Meme? This is a primary (elementary) school game

Can we not take spaces in the input?

The only space allowed in the input is the space between letters in the word.

Can we not take that space though? I can save three bytes if I don't have to input that space.

No. @HyperNeutrino

So every 8 bits make up one character? Will the first bit always be 0?

8 bits per character. As for the first bit being 0, yes.

Can we output an array of individual characters?

No, full string.

Incidentally, this actually has nothing to do with the game of FizzBuzz, that has been around much longer than the internet has.

I think by calling it a meme just made it a meme. Thanks for your contribution.

FizzBuzz enjoys a lot of currency on Stack Exchange in part because Joel (one of the founders) had a blog post referencing another blog which talked about using it as a low barrier to entry problem for programming applicants.

@dmckee the "another blog" that Joel references is Jeff Atwood's, the other founder of Stackoverflow.

C, 59 bytes
i;f(char*s){while(*s&3?*s&9||(i+=i+*s%5):putchar(i),*s++);}

Magic numbers, magic numbers everywhere!
(Also, C shorter than Python, JS, PHP, and Ruby? Unheard of!)
This is a function that takes a string as input and outputs to STDOUT.
Walkthrough
The basic structure is:
i;           // initialize an integer i to 0
f(char*s){
while(...);  // run the stuff inside until it becomes 0
}

Here, the "stuff inside" is a bunch of code followed by ,*s++, where the comma operater returns only the value of its second argument. Hence, this will run through the string and set *s to every character, including the trailing NUL byte (since postfix ++ returns the previous value), before exiting.
Let's take a look at the rest:
*s&3?*s&9||(i+=i+*s%5):putchar(i)

Peeling away the ternary and short circuiting ||, this can be expanded to
if (*s & 3) {
    if (!(*s & 9)) {
        i += i + *s % 5;
    }
} else {
    putchar(i);
}

Where do these magic numbers come from? Here are the binary representations of all the characters involved:
F  70  01000110
B  66  01000010
i  105 01101001
z  122 01111010
u  117 01110101
   32  00100000
\0 0   00000000

First, we need to separate space and NUL from the rest of the characters. The way this algorithm works, it keeps an accumulator of the "current" number, and prints it whenever it reaches a space or the end of the string (i.e. '\0'). By noticing that ' ' and '\0' are the only characters to not have any of the two least significant bits set, we can bitwise AND the character with 0b11 to get zero if the character is space or NUL and nonzero otherwise.
Digging deeper, in the first "if" branch, we now have a character that's one of FBizu. I chose only to update the accumulator on Fs and Bs, so I needed some way to filter out the izus. Conveniently, F and B both have only the second, third, or seventh least significant bits set, and all the other numbers have at least one other bit set. In fact, they all have either the first or fourth least significant bit. Hence, we can bitwise AND with 0b00001001, which is 9, which will yield 0 for F and B and nonzero otherwise.
Once we've determined that we have an F or B, we can map them to 0 and 1 respectively by taking their modulus 5, because F is 70 and B is 66. Then the snippet
i += i + *s % 5;

is just a golfy way of saying
i = (i * 2) + (*s % 5);

which can also be expressed as
i = (i << 1) | (*s % 5);

which inserts the new bit at the least significant position and shifts everything else over 1.
"But wait!" you might protest. "After you print i, when does it ever get reset back to 0?" Well, putchar casts its argument to an unsigned char, which just so happens to be 8 bits in size. That means everything past the 8th least significant bit (i.e. the junk from previous iterations) is thrown away, and we don't need to worry about it.
Thanks to @ETHproductions for suggesting to replace 57 with 9, saving a byte!

Nice trick with the putchar.

This is reeeeeally awesome. C did right!

Speaking of doing things right, this is, in my not-so-humble opinion, how a code-golf answer should be done. You post a clever, insightful solution, accompanied by a complete, well-written explanation that actually teaches people something about the language that might be useful in other, more practical circumstances.

@CodyGray Exactly this. One of the reasons that Code Golf isn't on the top of my SE that I visit frequently is because a lot of answers are just "here's the code". While that's cool for people who are very familiar with the languages, it just looks like noise to me. I like to see the explanations like here because it reveals the method, which I would think most people find a lot more interesting than the code itself. Just my two cents...

Very nice bithack, but you count your bits from MSB(left) to LSB(right)?  IMO the only sane way to count bits in an 8-bit byte (or a 128-bit SIMD vector, or whatever) is from LSB=bit 0 to MSB=bit 7.

Also, calling this function a second time continues the sequence, instead of starting a new one, because i lives in static storage.  I guess you can call that a feature: lets you work in chunks instead of being limited to strings that fit in memory :P

@PeterCordes You've got a point. Fixed that :P As for your second comment, there will be no observable effect if the function has been run before for the same reason as that mentioned in the second to last paragraph.

@Doorknob: oh right, that's true if the input has 8 "bits" before the first space.  I guess your function is assuming groups of 8 anyway, since it doesn't reset i after printing.  The question doesn't mention that case, so presumably it doesn't need to be handled.  (But if it did, there's a question of whether to treat the whole thing as a bitstring like you do, or whether each space-separated group should be padded out to become the low bits of a full byte.)

Jelly, 9 bytes
Ḳm€4O%5ḄỌ

Try it online!

Oh smart, flattening it was unnecessary. Nice.

@HyperNeutrino Note the comment I've made on yours, I've used a slightly different algorithm so as to avoid duping (even though technically allowed I don't like it).

@downvoter: did you test this at all before drive-by downvoting?

Python 3, 169 101 93 91 85 81 bytes
lambda s,j="".join:j(chr(int(j('01'[b<"C"])for b in c[::4]),2))for c in s.split())

Try it online!
Explanation:
lambda s,j="".join:  # Create a lambda function
    j(  # call "".join, adds characters together with nothing in between
        chr(  # character by int
            int(  # string to int
                j(  # "".join again
                    '01'[b<"C"]  # 1 or 0, based on what character we get
                    for b in c[::4]  # For every first of 4 characters
                ),
                2)  # Base 2
        )
        for c in s.split()  # for every group of Fizz and Buzz with any whitespace character after it
    )

That was fast. +1

I did something similar to this a while ago, it was just a matter of copy-paste and change it to FizzBuzz :P

Oh that explains. :P But you got outgolfed ;_;

Outgolfed by about 70-150 bytes

you can insert the print inside the list

Outgolfed again - Try it online! (89 bytes)

Whoops, did it again, 85 bytes this time with a lambda function

81 bytes

Bash + coreutils, 61 50 bytes
(-11 bytes thanks to Doorknob!)
tr -d izu<<<$1|tr FB 01|dc -e'2i?[aPz0<k]dskx'|rev

Try it online!

You can replace the sed with tr FB 01|tr -d izu to save 11 bytes.

JavaScript (ES6), 80 79 bytes

let f =

s=>`${s} `.replace(/.{4} ?/g,m=>m[s=s*2|m<'F',4]?String.fromCharCode(s&255):'')

console.log(f("FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"))

Very nice. I tried and failed to come up with something shorter, though there are several alternate 80-byte solutions using .replace(/..zz/g,, '0b'+, etc.

@ETHproductions Getting rid of n allows to reach 79. Sadly, this requires an extra space to be added to the input. Hence the rather costly \${s} ` `.

Japt, 26 24 19 17 bytes
¸®ë4 ®c u5Ãn2 dÃq

Try it online!
Saved 2 bytes thanks to @Shaggy & 2 bytes thanks to @ETHproductions
Explanation
input: "FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"

¸®                // ["FizzBuzzBuzzFizzBuzzFizzFizzFizz","FizzBuzzBuzzFizzBuzzFizzFizzBuzz","FizzFizzBuzzFizzFizzFizzFizzBuzz"]
  ë4              // ["FBBFBFFF","FBBFBFFB","FFBFFFFB"]
     ®c           // [[70,66,66,70,66,70,70,70],[70,66,66,70,66,70,70,66],[70,70,66,70,70,70,70,66]]
        u5Ã       // ["01101000","01101001","00100001"]
           n2     // [104,105,33]
              d   // ["h","i","!"]
               Ãq // "hi!"

You can replace the 2 }) with Ã. There's definitely more to be saved than that but I can't quite get it working on my phone.

Very nice, thanks for using Japt! You can save a couple bytes by replacing ò4...q n2 with ë4...n2 (ë4 does the same thing as ò4, except returning only the first item; strangely, it doesn't seem to be documented)

@ETHproductions Thanks for making Japt!

Finally got around to that shorter version - only took 3 years! https://codegolf.stackexchange.com/a/211146/58974

Ruby, 65 63 60 bytes
->s{s.split.map{|x|x.gsub(/..../){$&.ord%5}.to_i(2).chr}*''}

This is an anonymous proc that takes input and gives output as a string.
->s{
s.split            # split on whitespace
.map{|x|           # for each word as x,
  x.gsub(/..../){  # replace each sequence of four characters with
    $&.ord%5       # the ASCII value of the first character, mod 5
                   # F is 70, B is 66, so this yields 0 for Fizz and 1 for Buzz
  }.to_i(2)        # interpret as a binary number
  .chr             # the character with this ASCII value
}*''               # join on empty string
}

JavaScript (ES6), 95 88 85 81 bytes
s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))

4 bytes saved thanks to ETHproductions.

Try it

f=
s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value="FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz")
*{font-family:sans-serif}
<input id=i><p id=o>

I believe + is shorter than parseInt

I think +(m[0]<"F") could be shortened to m<"F"|0

Python 2, 90 83 82 81 bytes
-1 byte thanks to totallyhuman
-1 byte thanks to Martmists
-1 byte thanks to Jonathan Frech

lambda x:''.join(chr(int(`[+(l<'D')for l in b[::4]]`[1::3],2))for b in x.split())

Try it online!

Sans a byte.

you can save a byte by turning *1 for into *1for

Since you use *1 to convert from boolean to integer, you can save a byte by using a +: (l<'D')*1for can be +(l<'D')for.

Perl 5, 33 Bytes
print(pack'B*',<>=~y/FB -z/01/dr)

Replaces 'F' and 'B' in the input with 0 and 1 respectively, and deletes the other characters. It then uses perl's pack function to turn this bit string into ASCII characters.

Wow this is golfed down to about half the size of my Perl 5 attempt. Kudos.

I believe you could make this considerably shorter using the -p0 command line option (which would save you <>=~r for input, and allow you to use $_= rather than print()). Depending on how you want to handle newlines, you might not even need the 0. (Even if you want to avoid command line option penalties, say is shorter than print.)

@Chris Not mine, faubiguy's. But thanks. ;)

@DavidConrad My bad haha.

You definitely don't need the 0 either. Just use the -p flag and $_=pack'B*',y/FB -z/01/dr for your program lowers your score to 26 bytes.

Octave, 59 57 53 bytes
@(s)['',bi2de(flip(reshape(s(65<s&s<71)<70,8,[]))')']

This doesn't work on TIO, since the communication toolbox is not implemented. It works fine if you copy-paste it to Octave-online. It's not even close to be working code in MATLAB.
Managed to save two bytes by transposing the matrix after flipping it, instead of the other way around.
Explanation:
@(s)             % Anonymous function that takes a string as input
    ['',<code>]  % Implicitly convert the result of <code> to its ASCII-characters

Let's start in the middle of <code>:
s(65<s&s<71)      % Takes the elements of the input string that are between 66 and 70 (B and F)
                  % This gives a string FBBFFBBFBBBFFFBF...
s(65<s&s<71)<70   % Converts the resulting string into true and false, where F becomes false.
                  % Transformation: FBBFFB -> [0, 1, 1, 0, 0, 1]

Let's call the resulting boolean (binary) vector for t.
reshape(t,8,[])       % Convert the list of 1 and 0 into a matrix with 8 rows, one for each bit
flip(reshape(t,8,[])) % Flip the matrix vertically, since bi2de reads the bits from the wrong end
flip(reshape(t,8,[]))' % Transpose it, so that we have 8 columns, and one row per character
bi2de(.....)'          % Convert the result decimal values and transpose it so that it's horizontal

Whitespace, 123 bytes
Visible representation:
SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

Unobfuscated program:
    push  0
loop:
    dup
    push  0
    dup
    ichr
    get
    push  32
    sub
    dup
    jz    space
    push  38
    sub
    jz    fizz
    push  1
    add
fizz:
    push  0
    dup
    dup
    ichr
    ichr
    ichr
    add
    jmp   loop
space:
    swap
    pchr
    jmp   loop

There's nothing particularly odd about the implementation, the only real golfing is in some strange reuse of temporaries as well as not caring about the unbounded stack growth to skim down some more bytes.

Perl 5, 28 bytes+4 bytes for flags=32 bytes
Run with the flags -040pE
$_=chr oct"0b".y/FB -z/01/dr

-040 sets the record separator to a space so that perl sees each group of FizzBuzzes as a separate line, then loops over those lines, changing F to 0, B to 1, deleting everything else, then converting to binary and from there to ascii.

Jelly, 9 bytes
Ḳm€4=”BḄỌ

Try it online!
Ḳm€4=”BḄỌ  Main Link
Ḳ          Split on spaces
  €        Map
 m 4       Take every fourth letter (F and B)
    =”B    Check if each letter is equal to B (gives the binary representation)
       Ḅ   Binary -> Integer
        Ọ  Unord; gives chr(i)

-3 bytes thanks to Erik the Outgolfer

Let us continue this discussion in chat.

PHP, 67 Bytes
Limited to 8 letters

<?=hex2bin(dechex(bindec(strtr($argn,[Fizz=>0,Buzz=>1," "=>""]))));

Try it online!
PHP, 77 Bytes
foreach(explode(" ",strtr($argn,[Fizz=>0,Buzz=>1]))as$v)echo chr(bindec($v));

Try it online!

q/kdb+, 41 40 37 33 bytes
Solution:
{10h$0b sv'66=vs[" ";x][;4*(!)8]}

Example:
q){10h$0b sv'66=vs[" ";x][;4*(!)8]}"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
"hi!"

Explanation:
Split the input string on " " to give distinct lists of FizzBuzz..., index into each of these lists at the first character (ie 0 4 8 ... 28). Return boolean list determined by whether each character is "B" (ASCII 66). Convert these lists to base 10, and then cast result to string.
{10h$0b sv'66=vs[" ";x][;4*til 8]} / ungolfed solution
{                                } / lambda function with x as implicit input
              vs[" ";x]            / split (vs) input (x) on space (" ")
                           til 8   / til 8, the range 0..7 inclusive
                         4*        / vectorised multiplication, 0 1 2 3 => 0 4 8 12
                       [;       ]  / index the 2nd level at these indices (0, 4, 8 ... 28)
           66=                     / 66 is ASCII B, 66="FBBFBFFF" -> 01101000b
     0b sv'                        / join (sv) each row back with 0b (converts from binary)
 10h$                              / cast to ASCII (0x686921 -> "hi!")

Brain-Flak, 107 bytes
{(((((()()()()){}){}){})({}[{}])()())((){[()](<{}>)}{}<>)<>{(<{}{}{}{}>)<>({}({}){})<>}{}}<>{({}<>)<>}<>

Try it online!
+3 bytes for the -c flag.
Explanation
{                                        For each character in input:
 (((((()()()()){}){}){})({}[{}])()())    Push 32-n and 66-n
 ((){[()](<{}>)}{}<>)<>                  If character is B, push 1 on second stack.  Otherwise, push 0
 {                                       If character is not space:
  (<{}{}{}{}>)                           Burn 3 additional characters
  <>({}({}){})<>                         Multiply current byte by 2 and add previously pushed bit
 }                                       (otherwise, the pushed 0 becomes the new current byte)
 {}                                      Remove character from input
}
<>{({}<>)<>}<>                           Reverse stack for output

JavaScript ES6 - 98 bytes
too many bytes, but at least readable
Defined as function it is 98 bytes
let s=>s.replace(/(F)|(B)|./g,(c,F,B)=>B?1:F?0:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

test:
"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
.replace(/(F)|(B)|./g,(c,F,B)=>F?0:B?1:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

Explanation:
/(F)|(B)|./

Matches the F and B letters and anything else as Groups
(c,F,B)=>F?0:B?1:''

is a Function that captures the groups , returns a 0 for F and 1 for B , or ''
c is the character matched
F and B are now Parameters!
the 3rd . group is ommitted as parameter
F and B are undefined when the 3rd group is matched
B is undefined when group F is matched
The resulting 0100.. etc string
is cut in slices of 8 bytes
.replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

and processed as 0b binary string

Welcome to PPCG! The objective of this challenge is to provide a program or function translating arbitrary FizzBuzz strings. I don' know much JavaScript, but a valid function submission might be s=>s.replace( .... Also please do include a byte count in the Header of your answer.

I cleaned up some of your code formatting for you. Also, you don't need the let, anonymous functions are acceptable.

Haskell, 72 bytes
(>>= \w->toEnum(foldl1((+).(2*))[mod(fromEnum c)5|c<-w,c<'a']):"").words

Try it online!
How it works
            words      -- split input string into words at spaces
(>>=      )            -- map the function to each word and flatten the resulting
                       -- list of strings into a single string
   \w->                -- for each word w
       [  |c<-w,c<'a'] -- take chars c that are less than 'a' (i.e. B and F)
     mod(fromEnum c)5  -- take ascii value of c modulus 5, i.e. convert to bit value
    foldl1((+).(2*))   -- convert list of bit to int
  toEnum(   ):""       -- convert ascii to char.  :"" forces toEnum to be of type String
                       -- now we have a list of single char strings, e.g. ["h","i","!"]

shortC, 35 bytes
i;AW*@&3?*@&9||(i+=i+*s%5):Pi),*s++

Conversions in this program:

A - int main(int argc, char **argv){
W - while(
@ - argv
P - putchar(
Auto-inserted );}

Heavily based off of Doorknob's answer.

APL (Dyalog Classic), 17 bytes
{82⎕DR'B'=⍵∩'BF'}

Explanation
           ⍵∩'BF'    cut, removes all but 'BF' from ⍵
       'B'=          equals 'B' turns it into binary stream
 82⎕DR              converts into character stream

Try it online!

Japt -P, 9 bytes
Or 8 bytes if input can be lowercase.
¸Ën"FB" d

Try it
¸Ën"FB" d     :Implicit input of string
¸             :Split on spaces
 Ë            :Map
  n"FB"       :  Convert from base "FB" to decimal, ignoring all other characters
        d     :  Get the character at that codepoint
              :Implicitly join and output

05AB1E, 15 bytes
#vy„FBÃS'BQ2βçJ

Try it online!

Google Sheets, 94 bytes
=ArrayFormula(JOIN("",CHAR(BIN2DEC(SPLIT(SUBSTITUTE(SUBSTITUTE(A1,"Fizz",0),"Buzz",1)," ")))))

I'm not familiar with FizzBuzz binary but it seems that they're delineated by spaces so this formula relies on that. The logic is pretty simple:

Replace Fizz with 0 and Buzz with 1
Split the result into an array using a space as a delimiter
Convert each element from binary to decimal
Replace each element with its ASCII equivalent
Join each element without a delimiter

Java 8, 117 115 bytes
s->{for(String x:s.split(" "))System.out.print((char)Long.parseLong(x.replace("Fizz","0").replace("Buzz","1"),2));}

I doubt you can do a lot of the fancy regex replacements in Java like most other answers, mainly because you can't do anything with the captured capture-groups in Java-regexes.. (I.e. "$1".charAt(...) or "$1".replace(...) aren't possible for example.)
Explanation:
Try it here.
s->{                          // Method with String parameter and no return-type
  for(String x:s.split(" "))  //  Loop over the input split by spaces:
    System.out.print(         //   Print:
     (char)                   //    Each character
     Long.parseLong(          //    after we've converted each binary-String to a long
      x.replace("Fizz","0").replace("Buzz","1")
                              //    after we've replaced the Fizz/Buzz to 0/1
     ,2));
}                             // End of method

J, 20 bytes
a.{~_8#.\2-.~'FB'i.]

Try it online!