text:
Finite tilings in one dimension
The purpose of this challenge is to determine if a collection of one-dimensonal pieces can be tiled to form a finite continuous chunk.
A piece is a non-empty, finite sequence of zeros and ones that starts and ends with a one. Some possible pieces are 1, 101, 1111, 1100101.
Tiling means arranging the pieces so that a single contiguous block of ones is formed. A one from one piece can occupy the place of a zero, but not of a one, from another piece.
Equivalently, if we view a one as being "solid material" and a zero as a "hole", the pieces should fit so as to form a single stretch, without leaving any holes.
To form a tiling, pieces can only be shifted along their one-dimensional space. (They cannot be split, or reflected). Each piece is used exactly once.
Examples
The three pieces 101, 11, 101 can be tiled as shown in the following, where each piece is represented with the required shift:
  101
11
   101

so the obtained tiling is
111111

As a second example, the pieces 11011 and 1001101 cannot be tiled. In particular, the shift
 11011
1001101

is not valid because there are two ones that collide; and
11011
  1001101

is not valid because the result would contain a zero.
Additional rules
The input is a collection of one or more pieces. Any reasonable format is allowed; for example:

A list of strings, where each string can contain two different, consistent characters;
Several arrays, where each array contains the positions of ones for a piece;
A list of (odd) integers such the binary representation of each number defines a piece.

The output should be a truthy value if a tiling is possible, and a falsy value otherwise. Output values need not be consistent; that is, they can be different for different inputs.
Programs or functions are allowed, in any programming language. Standard loopholes are forbidden.
Shortest code in bytes wins.
Test cases
Each input is on a different line
Truthy
1
111
1, 1
11, 111, 1111
101, 11, 1
101, 11, 101
10001, 11001, 10001
100001, 1001, 1011
10010001, 1001, 1001, 101
10110101, 11001, 100001, 1
110111, 100001, 11, 101
1001101, 110111, 1, 11, 1

Falsy
101
101, 11
1, 1001
1011, 1011
11011, 1001101
1001, 11011, 1000001
1001, 11011, 1000001, 10101

Related

The infinite version of this problem might be interesting as well (i.e. whether a set of tiles can completely fill the 1D line without overlaps). Then stuff like 101101 would be truthy, even though no finite number of them result in a contiguous block.

Jelly, 15 bytes
+"FṢIP
FSṗLç€ċ1

Takes a list of indices and returns a positive integer (truthy) or 0 (falsy).
Try it online! or verify most test cases.

JavaScript (ES6), 74 73 70 bytes
Takes input as an array of 32-bit integers. Returns a boolean.
f=([n,...a],x)=>n?[...f+''].some(_=>n&&!(x&n)&f(a,x|n,n<<=1)):!(x&-~x)

Or 66 bytes with inverted truthy/falsy values:
f=([n,...a],x)=>n?[...Array(32)].every(_=>x&n|f(a,x|n,n*=2)):x&-~x

Test cases

f=([n,...a],x)=>n?[...f+''].some(_=>n&&!(x&n)&f(a,x|n,n<<=1)):!(x&-~x)

console.log('[Truthy]')
console.log(f([0b1]))
console.log(f([0b111]))
console.log(f([0b1,0b1]))
console.log(f([0b11,0b111,0b1111]))
console.log(f([0b101,0b11,0b1]))
console.log(f([0b101,0b11,0b101]))
console.log(f([0b10001,0b11001,0b10001]))
console.log(f([0b100001,0b1001,0b1011]))
console.log(f([0b10010001,0b1001,0b1001,0b101]))
console.log(f([0b10110101,0b11001,0b100001,0b1]))
console.log(f([0b110111,0b100001,0b11,0b101]))
console.log(f([0b1001101,0b110111,0b1,0b11,0b1]))

console.log('[Falsy]')
console.log(f([0b101]))
console.log(f([0b101,0b11]))
console.log(f([0b1,0b1001]))
console.log(f([0b1011,0b1011]))
console.log(f([0b11011,0b1001101]))
console.log(f([0b1001,0b11011,0b1000001]))
console.log(f([0b1001,0b11011,0b1000001,0b10101]))

How?
f = (                       // f = recursive function taking:
  [n, ...a],                //   n = next integer, a = array of remaining integers
  x                         //   x = solution bitmask, initially undefined
) =>                        //
  n ?                       // if n is defined:
    [... f + ''].some(_ =>  //   iterate 32+ times:
      n &&                  //     if n is not zero:
        !(x & n)            //       if x and n have some bits in common,
        &                   //       force invalidation of the following result
        f(                  //       do a recursive call with:
          a,                //         the remaining integers
          x | n,            //         the updated bitmask
          n <<= 1           //         and update n for the next iteration
        )                   //       end of recursive call
    )                       //   end of some()
  :                         // else (all integers have been processed):
    !(x & -~x)              //   check that x is a continuous chunk of 1's

Husk, 16 bytes
V§=OŀF×+ṠṀṪ+oŀṁ▲

Takes a list of lists of 1-based indices.
Try it online!
Explanation
V§=OŀF×+ṠṀṪ+oŀṁ▲  Implicit input, say x=[[1,3],[1]]
              ṁ▲  Sum of maxima: 4
            oŀ    Lowered range: r=[0,1,2,3]
        ṠṀ        For each list in x,
          Ṫ+      create addition table with r: [[[1,3],[2,4],[3,5],[4,6]],
                                                 [[1],[2],[3],[4]]]
     F×+          Reduce by concatenating all combinations: [[1,3,1],[1,3,2],...,[4,6,4]]
V                 1-based index of first list y
    ŀ             whose list of 1-based indices [1,2,...,length(y)]
 §=               is equal to
   O              y sorted: 2

Jelly, 16 bytes
FLḶ0ẋ;þ⁸ŒpS€P€1e

A monadic link taking a list of lists of ones and zeros returning either 1 (truthy) or 0 (falsey).
Try it online! or see a test-suite (shortened - first 6 falseys followed by first eight truthys since the length four ones take too long to include due to the use of the Cartesian product).
How?
FLḶ0ẋ;þ⁸ŒpS€P€1e - Link: list of lists, tiles
F                - flatten (the list of tiles into a single list)
 L               - length (gets the total number of 1s and zeros in the tiles)
  Ḷ              - lowered range = [0,1,2,...,that-1] (how many zeros to try to prepend)
   0             - literal zero
    ẋ            - repeat = [[],[0],[0,0],...[0,0,...,0]] (the zeros to prepend)
       ⁸         - chain's left argument, tiles
      þ          - outer product with:
     ;           -   concatenation (make a list of all of the zero-prepended versions)

        Œp       - Cartesian product (all ways that could be chosen, including man
                 -   redundant ones like prepending n-1 zeros to every tile)
          S€     - sum €ach (good yielding list of only ones)
            P€   - product of €ach (good yielding 1, others yielding 0 or >1)
              1  - literal one
               e - exists in that? (1 if so 0 if not)

Jelly, 16 bytes
FLḶ0ẋ;þµŒpSP$€1e

Try it online!
-1 byte thanks to Mr. Xcoder
I developed this completely independently of Jonathan Allan but now looking at his is exactly the same:

Python 2, 159 bytes
lambda x:g([0]*sum(map(sum,x)),x)
g=lambda z,x:x and any(g([a|x[0][j-l]if-1<j-l<len(x[0])else a for j,a in enumerate(z)],x[1:])for l in range(len(z)))or all(z)

Try it online!

153 bytes

J, 74 bytes
f=:3 :'*+/1=*/"1+/"2(l{."1 b)|.~"1 0"_ 1>,{($,y)#<i.l=:+/+/b=:>,.&.":&.>y'

I might try to make it tacit later, but for now it's an explicit verb. I'll explain the ungolfed version. It takes a list of boxed integers and returns 1 (truthy) or 0 (falsy).
This will be my test case, a list of boxed integers:
   ]a=:100001; 1001; 1011
┌──────┬────┬────┐
│100001│1001│1011│
└──────┴────┴────┘
b is the rectangular array from the input, binary digits. Shorter numbers are padded
with trailing zeroes:
   ]b =: > ,. &. ": &.> a   NB. Unbox each number, convert it to a list of digits
1 0 0 0 0 1
1 0 0 1 0 0
1 0 1 1 0 0

l is the total number of 1s in the array:
   ]l=: +/ +/ b             NB. add up all rows, find the sum of the resulting row)
7

r contains all possible offsets needed for rotations of each row:
   r=: > , { ($,a) # < i.l  NB. a catalogue of all triplets (in this case, the list
has 3 items) containing the offsets from 0 to l:
0 0 0
0 0 1
0 0 2
0 0 3
0 0 4
 ...
6 6 3
6 6 4
6 6 5
6 6 6

m is the array after all possible rotations of the rows of b by the offsets in r.
But I first extend each row of b to the total length l:
   m=: r |."0 1"1 _ (l {."1 b)  NB. rotate the extended rows of b with offsets in r,
ranks adjusted

For example 14-th row of the offsets array applied to b:
    13{r
0 1 6
   13{m
1 0 0 0 0 1 0
0 0 1 0 0 0 1
0 1 0 1 1 0 0

Finally I add the rows for each permutation, take the product to check if it's all 1, and
check if there is any 1 in each permuted array.
   * +/ 1= */"1 +/"2 m
1

Try it online!


text:
Tips for golfing in QBasic
What general tips do you have for golfing in QBasic? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to QBasic (e.g. "remove comments" is not an answer).
Tips pertaining to the QB64 emulator are also welcome. It has some extra features that aren't in Microsoft QBasic.

I'm curious about your motivation. I haven't used QBASIC since my 10th grade programming class. Amazing how I saved directly to 1.44 floppy disks without any form of version control and (usually) avoided catastrophic failures.

@AndrewBrēza Motivation? The same as my motivation to golf in any language: for fun! I enjoy writing small programs in QBasic (though I wouldn't want to use it for anything serious). There's also the added bonus that it's got sound and graphics (both text and pixel) built in, which my preferred "real" language, Python, does not.

It's much easier to write graphical games in QBasic than in python.

If anyone wants to try graphical QBasic applications directly in the browser they could use this: https://github.com/nfriend/origins-host

Know your looping constructs
QBasic has several looping constructs: FOR ... NEXT, WHILE ... WEND, and DO ... LOOP. You can also use GOTO or (in some situations) RUN to loop.

FOR ... NEXT is pretty good at what it does. Unlike in Python, it's almost always shorter than the equivalent WHILE or GOTO loop, even when it gets a little fancier:
FOR i=1TO 19STEP 2:?i:NEXT
i=1:WHILE i<20:?i:i=i+2:WEND
i=1:9?i:i=i+2:IF i<20GOTO 9

Note that you don't need to repeat the variable name after NEXT, and you can eliminate space between numbers and most following keywords.
WHILE ... WEND is good for when you have a loop that might need to execute 0 times. But if you know the loop will execute at least once, GOTO might be one byte shorter:
WHILE n>1:n=n\2:WEND
1n=n\2:IF n>1GOTO 1

I only use DO ... LOOP for infinite loops (except where RUN can be used instead). While it costs the same number of characters as an unconditional GOTO, it's a little more intuitive to read. (Note that "infinite loop" can include loops that you break out of using a GOTO.) The DO WHILE/DO UNTIL/LOOP WHILE/LOOP UNTIL syntax is too verbose; you're better off using WHILE or GOTO as appropriate.
GOTO is, as mentioned above, the shortest general way to write a do/while loop. Use single-digit line numbers instead of labels. Note that when a GOTO is the only thing in the THEN part of an IF statement, there are two equally terse shortcut syntaxes available:
IF x>y GOTO 1
IF x>y THEN 1

GOTO can also be used to create more complicated control flows. The naysayers refer to this as "spaghetti code," but this is code golf: unreadability is almost a virtue! GOTO pride!
RUN is useful when you need to jump to a fixed place in the program and you don't need to keep any of the variables' values. RUN by itself will restart the program from the top; with a label or line number, it will restart at that line. I've mainly used it to create stateless infinite loops.

Divisibility testing
In programs that require you to test whether one integer is divisible by another, the obvious way is to use MOD:
x MOD 3=0

But a shorter way is to use integer division:
x\3=x/3

That is, x int-div 3 equals x float-div 3.
Note that both of these approaches will return 0 for falsey and -1 for truthy, so you may need to negate the result, or subtract it instead of adding.

If you need the opposite condition (i.e. x is not divisible by 3), the obvious approach is to use the not-equals operator:
x\3<>x/3

But if x is guaranteed to be nonnegative, we can save a byte. Integer division truncates the result, so it will always be less than or equal to float division. Therefore, we can write the condition as:
x\3<x/3

Similarly, if x is guaranteed to be negative, truncation increases the result, and we can write x\3>x/3. If you don't know the sign of x, you'll have to stick to <>.

Scanner abuse
As in a lot of languages, knowing which characters can and can't be removed is important.

Any space next to a symbol can be removed: IF""=a$THEN?0
Space can usually be removed between a digit and a letter occurring in that order: FOR i=1TO 10STEP 2. There are some differences between QBasic 1.1 (available at archive.org) and QB64:

QBasic 1.1 allows removal of space between any digit and a following letter. Furthermore, in print statements, it will infer a semicolon between consecutive values: ?123x becomes PRINT 123; x. The exceptions to the above are sequences like 1e2 and 1d+3, which are treated as scientific notation and expanded to 100! and 1000# (single- and double-precision, respectively).
QB64 is generally the same, but digits can't be followed by d, e, or f at all unless they are part of a well-formed scientific notation literal. (For example, you can't omit the space after the line number in 1 FOR or 9 END, like you can in QBasic proper.) It only infers semicolons in print statements if one of the expressions is a string literal: ?123"abc" works, but not ?TAB(5)123 or ?123x.

Speaking of semicolons, QBasic 1.1 adds a trailing semicolon to a PRINT statement that ends with a call to TAB or SPC. (QB64 does not.)
0 can be omitted before or after the decimal point (.1 or 1.), but not both (.).
ENDIF is equivalent to END IF.
The closing double quote of a string can be omitted at the end of a line.

endif actually works in QB64, see this answer

@wastl So it does. When I first tested it in QB64, I was using an older version in which it was a syntax error. Thanks for mentioning!

Use shortcuts for PRINT and REM
You can use ? instead of PRINT, and ' instead of REM (comment).
' might also come useful when polygloting with languages that support ' as a part of char or string syntax.

Know your input methods
QBasic has several ways to get user keyboard input: INPUT, LINE INPUT, INPUT$, and INKEY$.

INPUT is your standard multipurpose input statement. The program stops what it's doing, displays a cursor, and lets the user type some input, terminated by Enter. INPUT can read numbers or strings, and it can read multiple values comma-separated. You can specify a string as a prompt, you can go with the default question-mark prompt, and you can even (I just learned this tonight) suppress the prompt altogether. Some sample invocations:

INPUT x$,y
Uses the default ?  prompt and reads a string and a number, comma-separated.
INPUT"Name";n$
Prompts with Name?  and reads a string.
INPUT"x=",x
Prompts with x= (no question mark! note the comma in the syntax) and reads a number.
INPUT;"",s$
Suppresses the prompt (using the above comma syntax with an empty prompt string), reads a string, and does not move to the next line when the user hits enter (that's what the semicolon after INPUT does). For example, if you PRINT s$ immediately after this, your screen will look like User_inputUser_input.

One drawback of INPUT is that you can't read a string with a comma in it, since INPUT uses comma as a field separator. To read a single line of arbitrary (printable ASCII) characters, use LINE INPUT. It's got the same syntax options as INPUT, except it takes exactly one variable which must be a string variable. The other difference is that LINE INPUT does not display a prompt by default; if you want one, you'll have to specify it explicitly.
INPUT$(n) displays no prompt or cursor but simply waits until the user enters n characters, and then returns a string containing those characters. Unlike INPUT or LINE INPUT, the user doesn't need to press Enter afterwards, and in fact Enter can be one of the characters (it'll give ASCII character 13, known to C-like languages as \r).
Most often, this is useful as INPUT$(1), typically in a loop. INPUT$ is good in interactive programs where single keypresses do things. Unfortunately, it only works with keys that have ASCII codes; this includes things like Esc and Backspace, but not the arrow keys, Insert and Delete, and others.
Which is where INKEY$ comes in. It is similar to INPUT$(1) in that it returns the results of a single keypress1, but different in that:

INKEY$ takes no argument.
While INPUT$(n) halts execution until the user enters n characters, INKEY$ does not halt execution. If the user is currently pressing a key, INKEY$ returns a string representing that key; if not, it returns "". This means that if you want to use INKEY$ to get the next keypress, you have to wrap it in a busy-waiting loop:2
k$=""
WHILE""=k$
k$=INKEY$
WEND

Both INPUT$ and INKEY$ return ASCII characters for keys that correspond to ASCII characters (including control characters like escape, tab, and backspace). However, INKEY$ can also handle some keys that do not have ASCII codes. For these (saith the help file), "INKEY$ returns a 2-byte string made up of the null character (ASCII 0) and the keyboard scan code."
Clear as mud? Here's some examples. If you use the INKEY$ loop above to capture a keypress of the left arrow key, k$ will contain the string "␀K" (with the K representing scan code 75). For the right arrow, it's "␀M" (77). Page down is "␀Q" (81). F5 is "␀?" (63).
Still clear as mud? Yeah. It's not the most intuitive thing in the world. The help file has a table of scan codes, but I always just write a little program to print the results of INKEY$ and press a bunch of keys to find out what the right values are. Once you know which characters correspond to which keys, you can use RIGHT$(k$,1) and LEN(k$) to distinguish between all the different cases you may encounter.

Bottom line? INKEY$ is weird, but it's the only way to go if your program requires non-blocking input or needs to use the arrow keys.

1 Not including Shift, Ctrl, Alt, PrntScr, Caps Lock, and similar. Those don't count. :^P
2 The WHILE ... WEND idiom here is what I learned in my QBasic books. For golfing purposes, however, a GOTO loop is shorter.

PRINT (?) has some quirks
Numbers are printed with a leading and trailing space.
Printing adds a linebreak. This behaviour can be altered by adding a comma at the end of the statement to insert a tab instead, or a semi-colon to avoid any insertions.
It is not necessary to use + or ; between distinct expressions when printing, eg. ?1"x"s$ prints the number 1, with spaces on each side, the letter x and the contents of s$.
?"foo"
?"bar"
?10
?"foo",
?"bar"
?"foo";
?"bar"
?1CHR$(65)
?1" "CHR$(65)
?"A","B

Outputs
foo
bar
 10
foo           bar
foobar
 1 A
 1  A
A             B

Printing a linebreak can be done with just ?.

Specifically on printing numbers: a space is printed before the number iff it is nonnegative; otherwise, a minus sign - is printed there. A space is also printed after the number. The best way I've discovered to get rid of these spaces is PRINT USING--dunno if you want to add that to this answer or if it should be a separate answer.

Combine Next Statements
Next:Next:Next

May be condensed down to
Next k,j,i

where the iterators for the For loops are i,j, and k - in that order.
For example the below (69 Bytes)
Input n,m,o
For i=0To n
For j=0To m
For k=0To o
?i;j;k
Next
Next
Next

May be condensed down to 65 Bytes
Input n,m,o
For i=0To n
For j=0To m
For k=0To o
?i;j;k
Next k,j,i

And as far as how this impacts formatting and indentation, I think the best approach to handling this is left aligning the next statement with the outer most for statement. Eg.
Input n,m,o
For i=0To n
    For j=0To m
        For k=0To o
            ?i;j;k
Next k,j,i

In QBasic, it is customary to use the DIM statement to create variables, giving them a name and a type. However, this isn't mandatory, QBasic can also derive a type by the suffix of the variable's name. Since you can't declare and initialise a variable at the same time, it's often wise to skip the DIM in codegolf. Two snippets that are functionally identical*:
DIM a AS STRING: a = "example"
a$ = "example"

* Note that this does create two different variable names.
We can specify the type of the variable by adding $ to the end of a variable name for strings, ! for single precision numbers and % for doubles. Singles are assumed when no type is specified.
a$ = "Definitely a string"
b! = "Error!"

Note that this also holds for arrays. Usually, an array is defined as:
DIM a(20) AS STRING

But arrays also don't need to be DIMmed:
a$(2) = "QBasic 4 FUN!"

a$ is now an array for strings with 11 slots: from index 0 to and including index 10. This is done because QBasic has an option that allows both 0-based and 1-based indexing for arrays. A default array kind of supports both this way.
Remember the twenty-slot array we DIMmed above? That actually has 21 slots, because the same principle applies to both dimmed and non-dimmed arrays.

I never realised this applied to arrays too. Interesting.

LOCATE can be really powerful
The LOCATE statement allows you to place the cursor anywhere on the screen (within the usual 80x40 character space limits) and print something at that location. This answer to a challenge really shows this off (and is also combined with a lot of other tips from this topic).
The challenge asks us to output every character a user has pressed in a 16x6 grid. With LOCATE this is simply a matter of div and mod over the ASCII code (a in this code):
LOCATE a\16-1,1+2*(a MOD 16)

And then printing the character:
?CHR$(a)

Shortening IF statements
IF statements are rather expensive, and golfing them down can save a lot of bytes.
Consider the following (adapted from an answer by Erik the Outgolfer):
IF RND<.5THEN
x=x-1
a(i)=1
ELSE
y=y-1
a(i)=0
ENDIF

The first thing we can do is save the ENDIF by using a single-line IF statement:
IF RND<.5THEN x=x-1:a(i)=1ELSE y=y-1:a(i)=0

This works as long as you don't try to put it on the same line as anything else. In particular, if you have nested IF statements, only the innermost one can be one-lined.
But in this case, we can eliminate the IF entirely using math. Consider what we actually want:

If RND<.5 is true (-1), we want:

x to decrease by 1
y to stay the same
a(i) to become 1

Otherwise, if RND<.5 is false (0), we want:

x to stay the same
y to decrease by 1
a(i) to become 0

Now if we save the result of the conditional in a variable (r=RND<.5), we can calculate the new values of x, y, and a(i):

When r is -1, x=x-1; when r is 0, x=x+0.
When r is -1, y=y+0; when r is 0, y=y-1.
When r is -1, a(i)=1; when r is 0, a(i)=0.

So our final code looks like:
r=RND<.5
x=x+r
y=y-1-r
a(i)=-r

saving a whopping 20 bytes (40%) over the original version.

The math approach can be applied surprisingly often, but when there's a difference in logic between the two cases (e.g. when you need to input something in one case but not in the other), you will still need to use IF.

Sometimes, you should avoid arrays
Arrays in QBasic, when instantiated without DIM have only 11 slots. If a challenge requires more than 11 slots (or N slots, where N can be bigger than 11), you should DIM the array. Also, let's assume we want to populate this array with data:
DIM a$(12)
a$(0) = "Value 1"
a$(1) = "Value 2"
...

Even golfed, this can take up a lot of space. On such occasions, it might be cheaper in bytes to do this:
a$ = "value 1value 2"

Here, we place everything in 1 concatenated string. Later, we access it like so:
?MID$(a$,i*7,7)

For this approach, it is important that all values are of equal length. Take the longest value and pad out all the others:
a$="one  two  threefour "

You don't need to pad the last value, and you can even skip the closing quotes! If the challenge specifies that white-space is not allowed in the answer, use RTRIM$() to fix that.
You can see this technique in action here.

WRITE may be useful in place of PRINT
PRINT is usually the way you'll want to do output, since it's pretty flexible and has the ? shortcut. However, the WRITE command can save you bytes in specific situations:

When outputting a string, WRITE wraps it in double quotes ("). If you need output with double quotes, WRITE s$ is much shorter than ?CHR$(34);s$;CHR$(34). See, for example, the shortest known QBasic quine.
When outputting a number, WRITE does not add spaces before and after it like PRINT does. WRITE n is much shorter than ?MID$(STR$(n),2). See, for example, FizzBuzz in QB64.
When outputting multiple values, WRITE separates them with commas: WRITE 123,"abc" outputs 123,"abc". I can't think of a scenario where this would be useful, but that doesn't mean there isn't one.

Limitations of WRITE:

There is no way to output multiple values without a separator like with PRINT a;b.
There is no way to suppress the newline at the end of output. (You may be able to work around this with LOCATE, but that costs a lot of bytes.)

Sometimes, QBasic mangles inputs to functions. Abuse that!
There's a couple of functions that work on characters instead of strings, but there isn't a char datatype in QBasic, there is only the string ($) type. Take for instance the ASC() function, which returns the ASCII keycode for a character. If we would enter
PRINT ASC("lala")

only the first l would be considered by QBasic. This way, we don't have to bother with cutting a string down to length 1.
Another example comes from this question where the STRING$() function is used in one of the answers.

The STRING$ function takes two arguments, a number n and a string s$, and constructs a string consisting of n copies of the first character of s$
@DLosc, here

Note that QBasic, when offered a multi-char string and needing only one char, automatically takes the first char and ignores the rest.

Integer vs Ulong
Sometimes you can simply reduce 2 bytes by using this trick:
DIM r AS Integer

vs

DIM r AS Ulong

This works on most occassions.

source: Stack Exchange

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

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

sort: votes


text:
Reversed Engineered from Uniqueness (Cop's Thread)
Given the output of the cop's program (o), the byte-count (n) and the number of unique bytes (c) used, come up with a corresponding piece of code that is n bytes long with c unique bytes which matches the cop's output o.

This is the cops thread. Post solutions that are to-be-cracked here.
The robbers thread is located here.

Cops should post solutions like this:
#[Language], `n` Bytes, `c` Unique Bytes (c*n points) [Cracked](Link-To-Crack)

    [Output]

---

(Optional spoiler)

Rules

You may not take any input for your program.
The program must use at least 1 byte, but cannot exceed 255 bytes.
The output itself is also limited to 255 bytes.
The program must have consistent output results when executed multiple times.
If your submission is not cracked within 7 days, you may mark it as "safe".

When marking it safe, post the intended solution and score it as c*n.
Only mark an answer as "safe" if you really want the +15 for an accepted answer; it's more fun to see how long you can go.

Winning

The uncracked post with the lowest c*n score, wins the cop's thread.
This will be decided after 10 safe answers, or a few weeks.

Caveats

If you feel cocky, you may tell the user the algorithm using a spoiler tag.

Uncracked Submissions:

fetch("https://api.stackexchange.com/2.2/questions/147635/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!/^#.*cracked/im.test(i.body_markdown)).map(x=>{const matched = /^ ?#{1,3} ?(?:(?:(?:\[|)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:.*(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).reverse().forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});

Uncracked Submissions

Language	Author

@Arnauld ahhh... I had misspoken, they're both limited to 255.

Are functions allowed? (Provided that they return a string, I suppose.)

Presumably, the output has to be consistent when run? I.e. random generators are forbidden?

@cairdcoinheringaahing. OP has said: "The program must have consistent output results when executed multiple times."

Just a suggestion for future CnRs: challenges where the user can choose an arbitrary fixed output are quite problematic for CnRs because people can basically mash their keyboard (barring syntax restrictions) and post the result, because there's no need for the cop to understand what their program is actually doing. Otherwise, this is a neat challenge idea. :)

@MartinEnder I don't think such answers are going to last for long. ;-P first of all in Python ajd7g9hou2ig2og2 gives the same output as rokrgor9g9g49g4ujg49j as well as most keyboard mashes: nothing, and I think that's true for most languages out there (or for example Husk would give the type error output, etc.)

@EriktheOutgolfer As I said "barring syntax restrictions". The point wasn't that you actually post a random stream of characters, but a random valid program which you don't need to understand. And especially in many esolangs, it's very easy to write a program that outputs a decent amount of random garbage without having to understand what that program does.

Closely related with different rules.

To get the number of unique bytes from a file: sed -e 's/\(.\)/\1\n/g' < filename | sort | uniq | wc -l

Considering that this challenge has already more than 30 answers, I suggest adding a code snippet which lists uncracked submissions like in this post.

@ThePirateBay did I manage to do that correctly?

@MagicOctopusUrn. I fixed your script, please verify that it now works properly for all submissions.

@ThePirateBay AFAICT it seems good.

Haskell, 173 bytes, 8 unique, 1384 points, safe
"[tag:reverse_engineering]"

It looks like this answer wants to provide a relevant tag to the question, while using only 8 different bytes.
As usual, your solution should work by being pasted in the code block on TIO: Try it online!

Solution
'[':___':_'':_':':':__':__:__'':__:__':____:__:'_':__:___:_':_'_:___:__:__:__':_'_:___:_':']':[]
_:_:_'':_:_:_:__:_:_':_:_'_:_:_:_:_:___:_:_:_:__':____:___':_:__'':_=['_'..]

Yes, this is valid Haskell code: Try it online!
How it works
The underscore _ is used as a wild card in Haskell's pattern matching. ' is used for characters, e.g. 'a'. However, both _ and ' are also part of the allowed characters for identifier names (Within some restrictions, e.g. ' cannot occur at the beginning of the name.). Therefore __, _', _'_, _'' and so on are all valid identifier names. Using some more descriptive names, the above code becomes
'[':t:a:g:':':r:e:v:e:r:s:e:'_':e:n:g:i:n:e:e:r:i:n:g:']':[]
_:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_=['_'..]

The first line yields the string "[tag:reverse_engineering]" if each variable is assigned to the correct character. This assignment is achieved in the second line: ['_'..] yields the string "_`abcdefghijklmnopqrstuvwxyz{|}~ ... ", witch is matched on the pattern _:_:a:_:_:_:e:_:g:_:i:_:_:_:_:n:_:_:_:r:s:t:_:v:_ to get the desired assignment a='a', e='e' and so on.

Brain-Flak, 62 total bytes, 6 unique, 372 points, Cracked
Here is your output:
10993592

There is something special about this number but its not on the OEIS ;)
In case you are thinking of using a computer tool to solve this, you're out of luck, the integer golfer gets 110 bytes for this number:
(((((((((((((((((((((()()()()){}){}){}){({}[()])}{}()()){})){}{}())){}{})){}{}){}){}){}())){}{}){}()){}){}){})

Try it online!
You're going to have to do this one by hand.

Tips
Here are some tips, I will reveal more an more helpful tips over time.  Good luck!

 10993592 is the 97th term of a sequence on OEIS, but does not appear because only a few terms are included.

 My solution uses 3 loops, but they are not nested 3 levels deep.

My solution
((((((()()()){}){}){}){}){}())(({(({})[()])}{}){{({}[()])}{}})

Try it online!
This uses one of my favorite tricks, the code
(({(({})[()])}{}){{({}[()])}{}})

computes the nth term of A090809.  The full submission just pads the code with a 97 to make a large number.

I can't help but notice that 10, 993 and 592 are present in PI at the decimal range 43-63...  592 is present within the first 10 too. I have no idea whether Brain-Flak could achieve that in 62 bytes though...

ASCII mode or number mode?

@user202729 I used number mode, so I would believe that robbers would need to use that too.  I would be seriously surprised if this was possible in ASCII mode based on previous attempts, so it is probably not worth pursuing.

Marked as safe? Or do you want to let the robbers work for a few more days?

@user202729 I don't plan on marking this safe for a while.  I'll add some hints soon and probably offer up a small bounty for cracking it.  Until then crack away.

It is 6882th term of A258931 and 4848th term of A049020. It is actually on OEIS, but not displayed as a search result.

@ThePirateBay I don't think "which OEIS sequence it belongs to" is always useful information, consider how esoteric Brain-flak is. It's also an element of A000027, but that observation is also useless.

@user202729. Of course, being a part of some sequence may be a completely useless fact, but I was just correcting the statement that "10993592 is not on the OEIS".

Infinite bounty link for reference.

Cracked

Malbolge, 15 bytes, 13 unique, score 195. Safe!
Outputs:
PPCG

Safe! Intended code:
(&a`#""7[}4XE70

Try it online!

I'm certain of the procedure to crack this by building by brute force the program that outputs P and building on top of it another P, etc. Getting it to 15 probably takes advantage of the two Ps together.

Malbolge is evil. It's already too hard to write program in Malbolge, let alone crack a submission.

JavaScript (ES8), 103 bytes, 42 unique (4,326 points) [SAFE]
Output hexdump:
3E 6E 6D 08 33 7A 22 7D 6C 37 7B 36 61 7B 65 71 3A 37 26 7E 7B 7B 38 7B 7D 69 6A 2B 3D 70 74 07 6F 6C 66 7E 1A 2A 3C 37 2D 36 31 38 6A 78 33 62 30 1E 34 3D 66 7B 37 10 26 6A 6A 32 27 6F 2E 33 1B 30 1E 76 27 27 7E 18 6F 68 26 2D 76 6A 6D 6D 2F 2E 0A 3F 17 7D 2B 73 7A 17 38 62 3A 29 20 0C 61 24 21 27 10 2B 20 63 71 72 17 5D 5F 12 5B 02 14 59 17 5A 11 1E 1D 10 16 07 5F 5F 58 58 4B 18 48 4B 04 5F 06 12 16 14 4D 45 5D 5D 16 3A 1C 1D 11 16 1F 51 59 4E 4B 4C 3D 16 1C 0F 2E 46 0E 08 4B 4B 13 45 21 10 06 0E 11 3F 51 57 3E 00 54 5F 49 05 0E 07 5A 51 3E 08 01 25 10 0B 51 36 43 0B 34 1A 43 47 04 46 0E 55 05 00 06 01 40 33 0F 00 53 36 42 42 45 5F 3D 3A 38 74 39 74 71 71 2C 7C 60 38 38 76 63 44 7F 64 28 66 3E 24 7A 66 57 79 24 3C 3C 21 6A 36 27 30 77 7E 36 7E 2A 3E 29

The score is abnormally big, I know, but anyway I think this one may be interesting to crack. The program is a function which returns a string (just to avoid confusion, this is not REPL).
It shouldn't be too hard, I suppose, everything is about finding the pattern.
Solution
It seems that it was harded than I had thought, according to the fact that nobody had cracked it. I believed there may be multiple solutions which are easy to craft. Anyways, here is the intended solution:

 f=m=>[...m=f+f+f].map((a,p)=>p+1&256?'':String.fromCharCode((p&4?m[p^17]:a).charCodeAt^83^p*.3)).join

For some reason it is not displayed properly as code snippet. Here is the TIO link.

Marked as safe?

@user202729. I agree, maybe the puzzle was harder than I thought, so it is now marked as safe.

MATL, 6 bytes × 3 unique = 18 points. Cracked
1+0i 0+1i -1+0i 0-1i

Damn you, floating point arithmetic!

@StewieGriffin I see you are having fun :-D

By the way, i.^(0:3) doesn't give floating point inaccuracies in Octave, but J4:q^ does in MATL...

@StewieGriffin The difference arises because MATL's display function uses  num2str(..., '%.15g '). See for example here. But that doesn't happen for MATL running on Matlab. The conclusion is that num2str works slightly differently in Matlab and in Octave

Anyway, that doesn't affect this answer. The indicated output can be obtained with MATL running on Matlab and on Octave; and in particular on TIO

Yes, I didn't doubt that... It was just an observation :)

I thoght so, but just in case people might get confused :-)

cracked!

@Giuseppe Well done! :-)

Octave, 13 bytes, 5 unique characters, score: 65. Safe!
20085918935040000

This one shouldn't be too hard. If you don't want to jump in to the most difficult ones straight away it might be a nice first challenge :)
Note: When I read the question, I though it said: Output a number, not output a string. The output looks like this on TIO:
ans =    2.0086e+16

And will look like this if you have format long
ans =  20085918935040000

or you may print it like this:
printf('%i',ans)
20085918935040000

What I had, and explanation:
prod prodprod

Simple as that. =)
Explained:
Normally you'd write this as: prod('prodprod'), but Octave treats whatever comes after the function name as a string (array of characters). These are implicitly converted to their ASCII-values, and multiplied together.

Jelly, 7 bytes × 6 unique = 42 points, cracked
843606888284160000

Try it online!

8!×16!¤

cracked

Oh, haha I cracked it with a trailing zero by mistake!

@JonathanAllan Well, that's easily replaceable with ḷ, for example. Now it's too late I guess...

Well I cracked the same problem, with an unnecessary hurdle :p

@JonathanAllan Try to crack my new one if you'd like!

MATL, 11 bytes, 10 unique, 110 points. SAFE!
Output:
10803850202590

Just to "help" you one the way:
This is the product of:
[2, 5, 29, 89, 397, 499, 2113]

and it's one less than the 372884884433rd prime.

And here are some real tips. If it's not cracked in a few hours then I'll reveal the solution.

 - There's a q in there

 - There's a B in there

 - There's a ^ in there

 - There's a h in there

 - There's a t in there

The real code:

     9K^ZqsBthXB

Explanation:

 Push two numerals, 9 and K, and do exponentiation. Create a list of all primes below that number, and sum them. Convert to binary, duplicate the binary vector and concatenate it with itself. Convert back to decimal and output implicitly.

MATL, 4 bytes, 4 unique, 16 points. Cracked
Output:
1388289520800

What I had:

 1X%p

 This pushes the number 1, checks which class it is, then multiplies the ASCII-values of the resulting string 'double'.

Cracked

Java 8 (full program), 97 total bytes, 34 unique, 3298 points (Cracked by @RobertoGraham)
Output:
1.4241570377303032

NOTE: This is a full program. If functions in the form of ()-> are allowed instead:
Java 8 (lambda function), 40 total bytes, 18 unique, 720 points (Cracked by @user202729)
It's probably quite hard, but whatever.. It's not like Java is going to win anything with this amount of points anyway..

Hints:

 The intended code doesn't contain any single or double quotes. (The function returns a double.)
 The intended code doesn't contain any digits (0-9).

Intended solution:
Pretty funny (and impressive) how both given cracks are completely different than what I had in mind, but chapeau to both of the crackers!

 Function:  ()->Math.log(Math.hypot(Math.PI,Math.E))
 Full program: interface M{static void main(String[]a){System.out.print(Math.log(Math.hypot(Math.PI,Math.E)));}}

Why do you seem to have two programs, but only one output?

@Okx Because the second is a function.

@Okx As Erik mentioned, because they are both the same. The top as a program, bottom as a function. I'm still waiting for Arnauld's comment to be answered so I can remove one of the two..

So close, a straightforward printing of the string is the right length but two uniques too many :-) – actually, 1 if you don't count the newline…

@Kevin Nice try, though. :) I've added some hints, the code doesn't contain any single quotes, double quotes, or digits.

Probably Math.PI or Math.E, and some combination of the functions (sin, cos, tan, sqrt, cbrt, pow, log10, etc.) The only way I see feasible is to bruteforce through all possibilities.

Unintended solution (function) with correct counts

@user202729 hehe, nice. Feel free to post it in the Robbers thread, then I'll link to it as cracked. It may not be the intended solution, but yours is much more impressive tbh.

Mathematica, 8 bytes, 3 unique, 24 points Cracked
7448503425106854065710345345644475127957406351360000000

Cracked.

Haskell, 10 bytes, 3 unique, 30 points, cracked
2416508937

A nice number which contains every digit, though only 3 unique bytes are used.
The intended solution works by replacing the code part in the following TIO link:
Try it online!

Cracked!

@H.PWiz I didn't expect it to last long, but this was nevertheless very quick. I expected (or at least hoped) robbers would try arithmetic solutions first.

Octave, 4 bytes, 3 unique, 12 points: cracked
1.6776e-05

Lets see how fast this one goes.

Cracked

@LuisMendo that would be the one.

CJam, 15 bytes * 10 unique = 150 points
453630781352162854505467929721140132016201833205823402832306035643819420004950

Bad score, but hopefully will be hard to crack.
Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Double answered :P flagged to be removed

@Christopher2EZ4RTZ What do you mean? These are two separate answers with the same score breakdown, but different outputs.

Oh wow my bad. XD

Ahaha... you, sir, must be a cop that's 2 days from retirement forgetting the answer like that ;P

@MagicOctopusUrn Now I've retired, and have no interest in this anymore...

@EsolangingFruiteso im sorry, it was a lighthearted joke.

@MagicOctopusUrn I was intending to carry the joke on. I have no idea what this was supposed to be anymore. I remember one of these answers had to do with conversion to base 6 (although because of rounding errors in the JavaScript implementation, that wouldn't be obvious now), and one of them had to do with the Thue-Morse sequence.

CJam, 15 bytes * 10 unique = 150 points
355605126761554652609272416635107412217265861355621217687464016216276447790261274709847680

Note: At the moment I have forgotten what the answer is. As such, I will keep it open until either I or somebody else is able to crack it.

Jelly, 8 bytes, 2 unique, 8×2 = 16 points -- Safe!
-4.408500694095235e-05

(There are only 8,355,840 possible such programs so it should get cracked I guess.)
Get going at Try it online!
How?

 ⁽⁽°°°°°°
⁽⁽° is a base 250 literal yielding -27221
° converts from radians to degrees. Applying this five times:
-475.09607568537643
-8.291990784013993
-0.1447225407260702
-0.0025258848375215096
-4.408500694095235e-05

Nice! Originally I think some double-byte may be related here, but then I dismissed it. I also considered °, but didn't think about ⁾ and thought you have to stick with starting from 0.

@user202729 ⁽ is different from ⁾, they're not related in any way (except that they consume the two chars that follow).

@EriktheOutgolfer Sorry, I just mistyped the characters. I meant ⁽.

C (two's complement machine, sizeof(int) = 4), 76 bytes and 35 unique bytes for a score of 2660, Safe
Output:
10542949672924294967287429496729029742949672954294967287429496728808914294967289429496728742949672946944294967291429496728742949672914964294967294429496728742949672891980429496728842949672874294967295792

which is 203 bytes long.

#include<math.h>
main(){for(int
i=0;i<40;i++)printf("%u",(int)(cos(i)*10));}

Without the #include it won't work.

Can we use some compiler-specific features like in gcc?

@ThePirateBay: I didn't.

I found an interesting approach but I couldn't golf out the last byte, so I just post it here.
main(i){for(;42>i;printf("%u","eirwtlegowvnfemuwphejsno"[abs(24-i++)]-'n'));}

@ColeraSu Probably you can switch from lowercase to uppercase and change 'N' to 78 (char code of N).

@user202729 but it would not fit the restriction of 35 unique bytes.

@ColeraSu So probably try to shift it to 42 or to 44. EDIT: I see, the problem is with the printf.

Haskell, 29 bytes, 15 unique bytes, 435 points, cracked
"33333333333333333333333333333333333333333333334333333333333333333333333333"

This is a string containing 3 73 times, and a single sneaky 4.
The intended solution works by replacing the code part in the following TIO link: Try it online!
Edit: H.PWiz found a valid crack (which could even be golfed to 28 bytes), but not the intended solution.
Hints:

 No arithmetic needed.
 There exists a single-expression solution.

Cracked

Explode, 9 total bytes, 4 unique, 36 points
Output:
22k2Dk}D}

Note that the documentation does not completely align with the implementation for this language - I wrote this one day and haven't touched it since, so any bugs in implementation that may exist are now definitely features.
Also, I do not think this language is Turing-complete, so you could probably brute force it, but that's boring.
I'll give you a sizable bounty if you can automate reverse-engineering output into optimally short Explode code.

The score of your code is 36 right? The output would score 36 points too, so I'm just making sure it's not a mistake. :)

@StewieGriffin yep, because when I first read the question I misread it and thought the code had to be the same length as the output.

How short should "golfed Explode code" be?

@user202729 sorry, I should have explained - optimally short Explode code, since it's completely deterministic

But the problem is people may write brute-force code to found the output "in theory", but is impractical in practice.

@user202729 yes - I wouldn't call that reverse-engineering, personally. Maybe I should make this a main challenge.

But it is somewhat unclear as it currently stands.

PowerShell, 7 bytes, 5 unique = 35 points Cracked
Output:
1125899906842624

Perl 5, 31 Bytes, 18 Unique Bytes (558 points) -- safe
1.76295255109024e+180

Intended solution (Try it online!):
$_=1;for$=(1..111){$_*=$=}print

(this calculates the factorial of 111)

Japt, 5 bytes, 5 unique bytes (25 points) (Cracked by Scrooble)
Output: 3628801

Cracked

@Scrooble, not the intended solution but nicely done. Will update as cracked when I get back to a computer. I'm thinking now the 4 byte version I had might have been a bit trickier, may yet post it.

What was the intended solution?

Jelly, 3 bytes × 3 unique = 9 points, cracked
263409560461970212832400

Try it online!
Another attempt at Jelly, this time more challenging I hope.

ȷc⁵

cracked

@JonathanAllan With my intended solution this time :p I guess it was too easy to brute-force right? There were obviously only 2763520 possible solutions...and, ironically, you use the same function to calculate this number as well as the number to be cracked.

Jelly, 4 bytes, 4 unique, 4 × 4 = 16 points -- Safe!
121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880

Note that the output is 255 bytes long, right at the limit.
Yep, same score as my other (as yet uncracked) Jelly entry.
Get going at Try it online!
How?

 7ÆĊ⁺
7 is a literal seven
ÆĊ gets the nth Catalan number
 the 7th Catalan number is 429
⁺ repeats the previous atom
 the 429th Catalan number is 121713205122350539153771498803599196214022517709999123476340843193655114000078051089267404501704293755399249186132786797198080437408108773592830098754467315464894774875031495160099382422748898046431945143395996374011431649446848855993397955116462522798880.

My partial solution (very long)

72 bytes is a little long, yes. You could remove the spaces (62). Also you could use vectorised r between two code-page index lists and concatenate with another code-page index list to get it down to 35 bytes, but there are also still repeated bytes there and 35 >> 4... good luck!

Alice, 9 bytes x 8 unique = 72 points Cracked
KMOQSUWY[]_acegikmoqsuwusqomkigecegikmoqsuwy

Try it online!
This one should be funny to crack

Cracked

Haskell, 30 bytes, 17 unique, 510 points, cracked
"6666666444444455666666666566555533333334333333333"

The intended solution works by replacing the code part in the following TIO link: Try it online!
This uses the same approach as my previous answer, which was cracked using a different approach.
Some hints:

 No arithmetic needed. I have a single-expression solution.

Cracked

Haskell, 37 bytes, 20 unique, 740 points, safe
The answer is an expression whose result equals the string literal:
"4F\\DLE\\C\"S\\T \\\\DC$EO!RUr\\K\\SSS1\\%S\\\\AN\\D&CDI#3SSC\\\\\\E\\C\\YC\\USB2SNN\\ED'\""

(That is, when putStr’d, you’d get:)
4F\DLE\C"S\T \\DC$EO!RUr\K\SSS1\%S\\AN\D&CDI#3SSC\\\E\C\YC\USB2SNN\ED'"

Safe! Intended expression:
[show['\r'..]!!rem(w^7)77|w<-[7..77]]

Javascript, 11 Bytes, 7 Unique Bytes (77 points) (Cracked)
0.022522522522522525

 lambda function declaration included in byte count, function call is not.

This should be really easy.

Fixed cracked with the help of @Milk

Pyth, 7 bytes, 6 unique, 7*6=42 total score
312069475503262125385169244603150327250717758754411025379995130624544231547913731661607993843298516888546865336571981925596

Check out the Pyth tips thread for inspiration ;)

Jelly, 8 bytes * 6 unique = 48 (Cracked)

241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916

You can try to crack it here.

 Intended solution: 7ẋ²Ḍ²ẋ4S

Partial answer (repeating pattern)

@JonathanAllan Your crack is invalid, sorry (it doesn't print the correct result). You can see the difference here

@JonathanAllan Heh, tried to solve another challenge at the same time (look at the arguments! :P)

@JonathanAllan Nice, I added the intended solution in my answer too :D

Excel, 22 bytes, 16 unique, 352 points, Cracked
หนึ่งล้านห้าแสนสามหมื่นสองพันสี่ร้อยเก้าสิบห้าล้านห้าแสนสี่หมื่นแปดร้อยหกสิบห้าล้านแปดแสนเก้าหมื่นล้านล้านล้านล้านล้านล้านบาทถ้วน

This might not be very hard to crack but I get to use a function that I otherwise never get to use. Besides, the score won't win anything unless a lot of others get cracked.

cracked. Probably not your original code, but it works.

Vyxal, 4 bytes, 4 unique, score 16, Cracked by Aaron Miller
Output:
aaaabbabaabcbabccabcaabcdbabcdcabcddabcdaabcdebabcdecabcdedabcdeeabcdeaabcdefbabcdefcabcdefdabcdefeabcdeffabcdefaabcdefgbabcdefgcabcdefgdabcdefgeabcdefgfabcdefggabcdefgaabcdefghbabcdefghcabcdefghdabcdefgheabcdefghfabcdefghgabcdefghhabcdefghaabcdefghibabcdefghicabcdefghidabcdefghieabcdefghifabcdefghigabcdefghihabcdefghiiabcdefghiaabcdefghijbabcdefghijcabcdefghijdabcdefghijeabcdefghijfabcdefghijgabcdefghijhabcdefghijiabcdefghijjabcdefghijaabcdefghijkbabcdefghijkcabcdefghijkdabcdefghijkeabcdefghijkfabcdefghijkgabcdefghijkhabcdefghijkiabcdefghijkjabcdefghijkkabcdefghijkaabcdefghijklbabcdefghijklcabcdefghijkldabcdefghijkleabcdefghijklfabcdefghijklgabcdefghijklhabcdefghijkliabcdefghijkljabcdefghijklkabcdefghijkllabcdefghijklaabcdefghijklmbabcdefghijklmcabcdefghijklmdabcdefghijklmeabcdefghijklmfabcdefghijklmgabcdefghijklmhabcdefghijklmiabcdefghijklmjabcdefghijklmkabcdefghijklmlabcdefghijklmmabcdefghijklmaabcdefghijklmnbabcdefghijklmncabcdefghijklmndabcdefghijklmneabcdefghijklmnfabcdefghijklmngabcdefghijklmnhabcdefghijklmniabcdefghijklmnjabcdefghijklmnkabcdefghijklmnlabcdefghijklmnmabcdefghijklmnnabcdefghijklmnaabcdefghijklmnobabcdefghijklmnocabcdefghijklmnodabcdefghijklmnoeabcdefghijklmnofabcdefghijklmnogabcdefghijklmnohabcdefghijklmnoiabcdefghijklmnojabcdefghijklmnokabcdefghijklmnolabcdefghijklmnomabcdefghijklmnonabcdefghijklmnooabcdefghijklmnoaabcdefghijklmnopbabcdefghijklmnopcabcdefghijklmnopdabcdefghijklmnopeabcdefghijklmnopfabcdefghijklmnopgabcdefghijklmnophabcdefghijklmnopiabcdefghijklmnopjabcdefghijklmnopkabcdefghijklmnoplabcdefghijklmnopmabcdefghijklmnopnabcdefghijklmnopoabcdefghijklmnoppabcdefghijklmnopaabcdefghijklmnopqbabcdefghijklmnopqcabcdefghijklmnopqdabcdefghijklmnopqeabcdefghijklmnopqfabcdefghijklmnopqgabcdefghijklmnopqhabcdefghijklmnopqiabcdefghijklmnopqjabcdefghijklmnopqkabcdefghijklmnopqlabcdefghijklmnopqmabcdefghijklmnopqnabcdefghijklmnopqoabcdefghijklmnopqpabcdefghijklmnopqqabcdefghijklmnopqaabcdefghijklmnopqrbabcdefghijklmnopqrcabcdefghijklmnopqrdabcdefghijklmnopqreabcdefghijklmnopqrfabcdefghijklmnopqrgabcdefghijklmnopqrhabcdefghijklmnopqriabcdefghijklmnopqrjabcdefghijklmnopqrkabcdefghijklmnopqrlabcdefghijklmnopqrmabcdefghijklmnopqrnabcdefghijklmnopqroabcdefghijklmnopqrpabcdefghijklmnopqrqabcdefghijklmnopqrrabcdefghijklmnopqraabcdefghijklmnopqrsbabcdefghijklmnopqrscabcdefghijklmnopqrsdabcdefghijklmnopqrseabcdefghijklmnopqrsfabcdefghijklmnopqrsgabcdefghijklmnopqrshabcdefghijklmnopqrsiabcdefghijklmnopqrsjabcdefghijklmnopqrskabcdefghijklmnopqrslabcdefghijklmnopqrsmabcdefghijklmnopqrsnabcdefghijklmnopqrsoabcdefghijklmnopqrspabcdefghijklmnopqrsqabcdefghijklmnopqrsrabcdefghijklmnopqrssabcdefghijklmnopqrsaabcdefghijklmnopqrstbabcdefghijklmnopqrstcabcdefghijklmnopqrstdabcdefghijklmnopqrsteabcdefghijklmnopqrstfabcdefghijklmnopqrstgabcdefghijklmnopqrsthabcdefghijklmnopqrstiabcdefghijklmnopqrstjabcdefghijklmnopqrstkabcdefghijklmnopqrstlabcdefghijklmnopqrstmabcdefghijklmnopqrstnabcdefghijklmnopqrstoabcdefghijklmnopqrstpabcdefghijklmnopqrstqabcdefghijklmnopqrstrabcdefghijklmnopqrstsabcdefghijklmnopqrsttabcdefghijklmnopqrstaabcdefghijklmnopqrstubabcdefghijklmnopqrstucabcdefghijklmnopqrstudabcdefghijklmnopqrstueabcdefghijklmnopqrstufabcdefghijklmnopqrstugabcdefghijklmnopqrstuhabcdefghijklmnopqrstuiabcdefghijklmnopqrstujabcdefghijklmnopqrstukabcdefghijklmnopqrstulabcdefghijklmnopqrstumabcdefghijklmnopqrstunabcdefghijklmnopqrstuoabcdefghijklmnopqrstupabcdefghijklmnopqrstuqabcdefghijklmnopqrsturabcdefghijklmnopqrstusabcdefghijklmnopqrstutabcdefghijklmnopqrstuuabcdefghijklmnopqrstuaabcdefghijklmnopqrstuvbabcdefghijklmnopqrstuvcabcdefghijklmnopqrstuvdabcdefghijklmnopqrstuveabcdefghijklmnopqrstuvfabcdefghijklmnopqrstuvgabcdefghijklmnopqrstuvhabcdefghijklmnopqrstuviabcdefghijklmnopqrstuvjabcdefghijklmnopqrstuvkabcdefghijklmnopqrstuvlabcdefghijklmnopqrstuvmabcdefghijklmnopqrstuvnabcdefghijklmnopqrstuvoabcdefghijklmnopqrstuvpabcdefghijklmnopqrstuvqabcdefghijklmnopqrstuvrabcdefghijklmnopqrstuvsabcdefghijklmnopqrstuvtabcdefghijklmnopqrstuvuabcdefghijklmnopqrstuvvabcdefghijklmnopqrstuvaabcdefghijklmnopqrstuvwbabcdefghijklmnopqrstuvwcabcdefghijklmnopqrstuvwdabcdefghijklmnopqrstuvweabcdefghijklmnopqrstuvwfabcdefghijklmnopqrstuvwgabcdefghijklmnopqrstuvwhabcdefghijklmnopqrstuvwiabcdefghijklmnopqrstuvwjabcdefghijklmnopqrstuvwkabcdefghijklmnopqrstuvwlabcdefghijklmnopqrstuvwmabcdefghijklmnopqrstuvwnabcdefghijklmnopqrstuvwoabcdefghijklmnopqrstuvwpabcdefghijklmnopqrstuvwqabcdefghijklmnopqrstuvwrabcdefghijklmnopqrstuvwsabcdefghijklmnopqrstuvwtabcdefghijklmnopqrstuvwuabcdefghijklmnopqrstuvwvabcdefghijklmnopqrstuvwwabcdefghijklmnopqrstuvwaabcdefghijklmnopqrstuvwxbabcdefghijklmnopqrstuvwxcabcdefghijklmnopqrstuvwxdabcdefghijklmnopqrstuvwxeabcdefghijklmnopqrstuvwxfabcdefghijklmnopqrstuvwxgabcdefghijklmnopqrstuvwxhabcdefghijklmnopqrstuvwxiabcdefghijklmnopqrstuvwxjabcdefghijklmnopqrstuvwxkabcdefghijklmnopqrstuvwxlabcdefghijklmnopqrstuvwxmabcdefghijklmnopqrstuvwxnabcdefghijklmnopqrstuvwxoabcdefghijklmnopqrstuvwxpabcdefghijklmnopqrstuvwxqabcdefghijklmnopqrstuvwxrabcdefghijklmnopqrstuvwxsabcdefghijklmnopqrstuvwxtabcdefghijklmnopqrstuvwxuabcdefghijklmnopqrstuvwxvabcdefghijklmnopqrstuvwxwabcdefghijklmnopqrstuvwxxabcdefghijklmnopqrstuvwxaabcdefghijklmnopqrstuvwxybabcdefghijklmnopqrstuvwxycabcdefghijklmnopqrstuvwxydabcdefghijklmnopqrstuvwxyeabcdefghijklmnopqrstuvwxyfabcdefghijklmnopqrstuvwxygabcdefghijklmnopqrstuvwxyhabcdefghijklmnopqrstuvwxyiabcdefghijklmnopqrstuvwxyjabcdefghijklmnopqrstuvwxykabcdefghijklmnopqrstuvwxylabcdefghijklmnopqrstuvwxymabcdefghijklmnopqrstuvwxynabcdefghijklmnopqrstuvwxyoabcdefghijklmnopqrstuvwxypabcdefghijklmnopqrstuvwxyqabcdefghijklmnopqrstuvwxyrabcdefghijklmnopqrstuvwxysabcdefghijklmnopqrstuvwxytabcdefghijklmnopqrstuvwxyuabcdefghijklmnopqrstuvwxyvabcdefghijklmnopqrstuvwxywabcdefghijklmnopqrstuvwxyxabcdefghijklmnopqrstuvwxyyabcdefghijklmnopqrstuvwxyaabcdefghijklmnopqrstuvwxyzbabcdefghijklmnopqrstuvwxyzcabcdefghijklmnopqrstuvwxyzdabcdefghijklmnopqrstuvwxyzeabcdefghijklmnopqrstuvwxyzfabcdefghijklmnopqrstuvwxyzgabcdefghijklmnopqrstuvwxyzhabcdefghijklmnopqrstuvwxyziabcdefghijklmnopqrstuvwxyzjabcdefghijklmnopqrstuvwxyzkabcdefghijklmnopqrstuvwxyzlabcdefghijklmnopqrstuvwxyzmabcdefghijklmnopqrstuvwxyznabcdefghijklmnopqrstuvwxyzoabcdefghijklmnopqrstuvwxyzpabcdefghijklmnopqrstuvwxyzqabcdefghijklmnopqrstuvwxyzrabcdefghijklmnopqrstuvwxyzsabcdefghijklmnopqrstuvwxyztabcdefghijklmnopqrstuvwxyzuabcdefghijklmnopqrstuvwxyzvabcdefghijklmnopqrstuvwxyzwabcdefghijklmnopqrstuvwxyzxabcdefghijklmnopqrstuvwxyzyabcdefghijklmnopqrstuvwxyzzabcdefghijklmnopqrstuvwxyz

Only slightly evil :}

cracked

JavaScript (ES6), 35 bytes x 16 unique = 560 points - Safe!
Some kind of compromise between a reasonable size and an uncrackable algorithm (as it originally was meant to be ^^).
Expected output (255 bytes):
246913680357025702570358136924703692581470370360360370471582604715938260493827161505050505161728495173962851852963075208642087643221000001123457802570360483728396297532100123581594064200024727410136175571756954621413918119481621442132286383494753789149870

Intended solution

f=(x=0xff)=>--x&&(1/7/x+'')[7]+f(x)

O.innerText = f()
pre {
  white-space: pre-wrap;
  white-space: -moz-pre-wrap;
  word-wrap: break-word;
}

Unique characters: 0, 1, 7, f, =, (, x, ), >, -, &, /, +, ', [, ]

Near match, with some tweak may be done (Mathematica) (may be spoiler).

The function looks so weird... Probably not quadratic or polynomial, but I guess it's convex. The positive side grows much faster than the negative side. [Almost safe now]

Alice, 7 bytes, 6 unique, 42 points, safe
-10764@

Try it online!
Solution

 gZ/
@o@

Try it online!

g is the easiest way to get a decently big number onto the stack quickly, because it pops two implicit zeros from the stack and then reads the code point at that cell, which is 113 for g itself.

Z then packs 0 and 113 into a single integer, which is a good way to get an even bigger number. That number happens to be -10764.

 The number gets printed in Ordinal mode, but then we run into g again in Ordinal mode. The label Alice is looking for is just an empty string. It finds that immediately in the bottom left corner and extracts the @ as a string. When we hit o again, that @ is printed as well.

 Afterwards, the IP finds its way to the bottom right corner where the other @ terminates the program.

J, 8 Bytes x 6 Unique = 48 Points, Cracked
Output:
23 _0.677447j0.296961 _0.677447j_0.296961 0.125003j0.726137 0.125003j_0.726137 _0.379097j0.630438 _0.379097j_0.630438 0.518498j0.521654 0.518498j_0.521654

Hint:

 It has to do with primes

Explode, 24 total bytes, 7 unique, 168 points
Output:
\}AtAY)_)MqGq/Y,Y}AwA_)\)JqDq/Y,Y}AtA_)\)MqDq/Y,Y}AtA_)\)MqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb)\)JqDq2Y,YzAtAb3)yqobUPK>1,'zmhcVID?2% {na\WJ=83&ytobUPK>1,'zmhcVID?2% {na\WJ

Now that I've read the question correctly, you can truly see the output explode.

PHP, 16 Bytes, 10 Unique Bytes (160 points) -- Safe!
0.42516833158764

 Intended Solution (Try it online!)

<?=M_PI/M_E/M_E;

 Simply divides π by e twice.

Edit
As with ThePirateBay's answer, I marked this as safe before I saw the OP's edit about seeing how long you can go without being cracked. Sorry to any who wanted to attempt a crack.

Brainf**k, 220 bytes, 7 unique (1540 points), safe
Edit: Sorry that I counted the bytes wrong.
output (88 bytes)
rh3NY8C]'t/FS:\7pb5D?yc,G>A@OsWU_6x*gaRo)Hz-w.ul+T&IM
+[>[-]<[>+>+<<-]>>[<<+>>-]---<[>>>+<<<-]>>>[<<[<+>>+<-]>[<+>-]>-]<<<+]<[>>[-]<[-]<[>+>+<<-]>>[<<+>>-]++++++[-<------>]<->>>++++++[-<+++++[-<+++>]>]<<--[>>+<<<[->>>[-]<+<<]>>>[->+<]<[-<<+>>]<-<->]>>>[<<<<<.>>>>>-]<<<<<<]
 I didn't golf this too much. This is a sequence generated by linear congruential method, but just I output bytes between 37 and 124.

Safe? (char limit)

@user202729 Thanks for reminding me. I almost forgot this.

Python 2, 98 bytes, 30 unique, 2940 points
Output (249 bytes):
-K:&qLcVoJk`N8QS@JH5c`1]T92i_bS.bv<zZK3vI&(kH!6=NrQGTL&VE:j|g..UQC)yk>3IoNhpjc'h0.x'L!aajp;Ip}+BQ/I64Q`5ZBRwOfDtt|O,6b>>UvvTt#8"z0CzEHtiVJ{lR-QBbhdqQnKK@.7Q$RLbso]?gR=ZN2;f5vTh|1@dI.cQ|b;F=lKyFZpx(mBPrqhiw1:`LD>AI{.S;POHfTd[5d;T=`162Hc]=.m7?T_1O<Kty

Edit: I think this is going to be too hard so I'll give a hint
Edit: Slightly more informative hint

 seed(9)

><>, 16 Bytes * 11 Unique = 176 Points
Output:
; ;;;;;;;;   ;
;;;
;;;;;;;;;;;;;;;;;;; ;!;";#;$;%;&

Shouldn't be too hard.

x86 Assemble, 22 Bytes * 17 types = 374 points, safe for 3 months
00000000h: 80 8A 5E FA 59 DF 69 24 F9 73 DA 8C 50 A6 F1 60
00000010h: 93 E3 3E 87 7D 08 F6 14 9E 03 EE 96 4E 48 99 61
00000020h: 2E 7A 62 71 96 39 69 27 CF 8E F7 AE 1A 37 71 8F
00000030h: B0 52 6A 85 F3 04 47 D4 A5 F1 8E 64 D8 4E A6 C1
00000040h: 0E 1E 35 EB C6 E3 99 28 67 79 80 58 52 F5 BF E7
00000050h: 28 87 1C E7 96 5E CA 8E 63 DB 3C 59 73 11 E1 9C
00000060h: E1 1D 6A 77 6B CD 6B 41 64 EA D6 02 0B 3F 89 60
00000070h: B4 DF 90 C4 AD AA 35 D5 14 6F 47 DC 3A 31 48 B5
00000080h: 50 87 5A 4C 5D FC 07 70 4B 6A 2A 6D 87 32 7F CA
00000090h: AB EB 75 4B 7C 17 1E 7D 01 49 C3 99 AF 98 8A 59
000000a0h: 6A B1 A1 2C B4 08 5D 42 9F AA E0 04 10 38 DC 87
000000b0h: E8 CB 15 BE CE 52 5D 02 4C 3C C4 C3 FF

Answer:
00000000h: DB 06 01 01 B7 CD DD 17 D9 FE B4 02 8A 57 02 CD
00000010h: 21 FE C2 75 F1 C2

Hint: 1) output uses MOV AH, xx; MOV D?, xx; INT 21 which costs at least 6 bytes; 2) return may be RET, INT 20, INT 21, but at least 1 byte required; 3) x87 used

I suppose the header should say "machine code" instead of "assembly"?

maybe, though from the hint comment that can be inferred....

Python 2, 114 Bytes, 27 Unique (3078)
両寷動娯爅潟嗁琓偵桋斥獻曕檫垉哣抹妗惱畃

Function calls not counted, lambda expression counted.

Hint 1

 Pseudo-random number generator with Unicode output. Beware of the offsets ;)

Hint 2

 2 generators of the same kind but with different parameters are used alternatively, in the form of an+1 = f1(f2(an))

CJam, 5 bytes × 5 unique = 25 points, safe
1406563064942.4553

 J_#mq
 This code computes sqrt(1919).
 It could have been JJ_#mq for 20 points, but I didn't realize that until after I posted it.

CJam, 13 bytes * 10 unique = 130 points
819457164140982707422640583089002841689

brainfuck, 25 bytes * 7 unique = 175 points
 .KoÌEÚ/îXÉAÀFÓg¤Mý´r7Ö°yh^[_j|µÜ
?{¾Y±vãWÒTÝm¢Gó¦`!é¸kO:,%%,:Ok¸é!`¦óG¢mÝTÒWãv±Y¾{?
Üµ|j_[^hy°Ö7r´ýM¤gÓFÀAÉXî/ÚEÌoK.
This contains unprintables which will probably be mangled by SE, so here's the hexdump:
00000000: 0918 2e4b 6fc2 9ac3 8c05 45c2 8cc3 9a2f  ...Ko.....E..../
00000010: c28b c3ae 58c3 8941 c380 46c3 9367 02c2  ....X..A..F..g..
00000020: a44d c3bd c2b4 7237 03c3 96c2 b0c2 9179  .M....r7.......y
00000030: 685e 5b5f 6a7c c295 c2b5 c39c 0a3f 7bc2  h^[_j|.......?{.
00000040: be08 59c2 b110 76c3 a357 c392 54c3 9d6d  ..Y...v..W..T..m
00000050: 04c2 a247 c3b3 c2a6 6021 c3a9 c2b8 c28e  ...G....`!......
00000060: 6b4f 3a2c 2525 2c3a 4f6b c28e c2b8 c3a9  kO:,%%,:Ok......
00000070: 2160 c2a6 c3b3 47c2 a204 6dc3 9d54 c392  !`....G...m..T..
00000080: 57c3 a376 10c2 b159 08c2 be7b 3f0a c39c  W..v...Y...{?...
00000090: c2b5 c295 7c6a 5f5b 5e68 79c2 91c2 b0c3  ....|j_[^hy.....
000000a0: 9603 3772 c2b4 c3bd 4dc2 a402 67c3 9346  ..7r....M...g..F
000000b0: c380 41c3 8958 c3ae c28b 2fc3 9ac2 8c45  ..A..X..../....E
000000c0: 05c3 8cc2 9a6f 4b2e 1809 01              .....oK....

Jelly, 13 bytes, 5 unique, 65 points
Output is the following 21 bytes.
HCG, AhhsNeg3 Aarrghh

The optimized string compressor won't help you.

Jelly, 4 bytes, 4 unique, 16 points.
[1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0]

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

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


text:
Reversed Engineered from Uniqueness (Robber's Thread)
Given the output of the cop's program (o), the byte-count (n) and the number of unique bytes (c) used, come up with a corresponding piece of code that is n bytes long with c unique bytes which matches the cop's output o.

This is the robbers thread. Post solutions that you cracked here.
The COPS thread is located here.

Robbers should post solutions like this:
#[Language], `n` Bytes, `c` Unique Bytes (Cracked)[Original Link to Cop Thread]

    [Solution]

(Explanation)

Rules

You may not take any input for your program.
The program must use at least 1 byte, but cannot exceed 255 bytes.
The output itself is also limited to 255 bytes.
The program must have consistent output results when executed multiple times.
If your submission is not cracked within 7 days, you may mark it as "safe".

When marking it safe, post the intended solution and score it as c*n.

Winning

The uncracked post with the lowest c*n score, wins the cop's thread.
Whomever cracks the most wins the robbers thread, with earliest crack breaking the tie.
This will be decided after 10 safe answers, or a few weeks.

Caveats

If you feel cocky, you may tell the user the algorithm using a spoiler tag.

Note: Also, please remember to upvote cracks, they're usually the impressive part.

Haskell, 29 bytes, 15 unique, Laikoni
f<$>[1..74]
f 47='4'
f f1='3'

Try it online!
I previously had the two nearly solutions:
do;d<-[2..74];'3':['4'|d==47]    -- 29,16
do;d<-[-41..31];'3':['4'|d==4]   -- 30,15

ahh, Laikoni’s comment led me to think the answer needed to be a single expression… closest I got was ["34"!!(0^x^2)|x<-[-46..27]] (28, 18).

also, I had no idea you could place a semicolon right after do like that!

Yes, I had a space there for a long time before guessing it might be valid.

@Lynn Laikoni has claimed that the solution is a single expression in chat

MATL, 4 bytes, 4 unique bytes, Stewie Griffin
1X2p

Try it online!
Explanation
1X2   % Push predefined literal: string 'double'
p     % Product of array. For strings it uses code points. Implicit display

You know all the predefined literals... I don't... It wasn't exactly the same as I had, but it was of course the product of 'double'. :)

@StewieGriffin Ah, I see, so you used something like 1X%p. Actually I only know a few predefined literals. I brute-forced with 9:"@X1pD changing X and 1

Java 8, 97 Bytes, 34 Unique Bytes, Kevin Cruijssen
interface Fillerrrrrrrrrrr{static void main(String...a){System.out.println(1.4241570377303032);}}

Try it online!
Super innovative crack, spent hours on it

MATL, 6 bytes, 3 unique, Luis Mendo
FFFTZF

Try it online!
I immediately recognized the output
1+0i 0+1i -1+0i 0-1i

as the 4-th roots of unity, and I knew that the fft on [0 0 0 1] would result in this.
It took me quite a while to figure out that FFFT would push [0 0 0 1] and I'm still not sure how it works. EDIT: Luis Mendo explained that F and T are "sticky", so a sequence of F and T will automatically horzcat them together, hence, FFFT pushes [0 0 0 1].
This is expressed succinctly in the documentation (once I looked it up):

For logical row vectors the square brackets can be omitted; that is, the notation
  [T F T] or [TFT] can be simplified to TFT. A separator may be needed if a new
  logical array follows: TFT TT. But it’s not necessary in other cases: TFT3.5.

F and T are "sticky". So FFT defines a row vector [false, false, true]

@LuisMendo thank you, that is clear now.

Haskell, Laikoni
0x90090009

Try it online!
I feel like I got lucky here...

Wolfram Language (Mathematica), 8 bytes, 3 unique, Jenny_mathy
7!!!/77!

Try it online!
Breakdown: Factorial[7!!] / Factorial[77] where !! is double factorial.
First I notice the long sequence of 0 at the end so I guess it may be some kind of factorial. FactorInteger gives the largest factor 103, so I try n/103!, and get the next largest (negative) prime factor is 73. Tweaking the factors for some time gives 105!/77!, then I think "there are already 3 symbols 7, ! and /, so the way to create 105 must be from those symbols!". So I tried 7!! (which is one of a few things to try) and get 105 as the correct result.

JavaScript (ES6), Brian H.
Thanks @Milk for fixing the last trailing '5'

f=f=>1/44.4

console.log(f())

Unique characters: ., /, 1, 4, =, >, f

This one outputs the extra 5 at the end: _=_=>1/44.4

@milk That looks better indeed. Let me know if you'd like to post it and I'll delete this one.

That's cool, you can just update your post if you want. I got this from building off your crack.

said it was an easy one :p

Brain-Flak, 62 total bytes, 6 unique, Wheat Wizard
(((((((()()()){}){}){}){}){}){(({})[()])}{})({{()({}[()])}{}})

Try it online!

Good job! That's not what I had intended but it works!

Japt, 5 bytes, 5 unique bytes, Shaggy's submission
10l Ä

Try it online!
Simple enough: 3628801 is 10! (10l) plus one (Ä).

Jelly, 7 bytes, 6 unique, Erik the Outgolfer
- For some reason I started with a trailing zero in the result. Without it I would have given
8,16!PP
as a solution.

8,⁴!PP0

Try it online!
How?
8,⁴!PP0 - Main link of a program taking no arguments and no input
  ⁴     - literal sixteen
8       - literal eight
 ,      - pair = [8,16]
   !    - factorial (vectorises) = [8!, 16!] = [40320, 20922789888000]
    P   - product = 40320 × 20922789888000 = 843606888284160000
     P  - product (no effect) = 843606888284160000
      0 - literal zero (just gets printed)
        - leaving STDOUT displaying 8436068882841600000, as required

...8,⁴!’P for 6 bytes, 6 unique would have been much harder to crack since the result of 843585965494231681 (40319 × 2092278988799) does not look so factorial-based.

Alternative: 8µḤ!×!  (with trailing space)

Or 8,⁴!P with 2 trailing spaces (Or q or some other unimplemented byte)

Jelly, 3 bytes, 3 unique Erik the Outgolfer
ȷc⁵

Try it online!
How?
ȷc⁵ - Main link: no arguments, no input
ȷ   - literal one-thousand
  ⁵ - literal ten
 c  - choose (A.K.A. binomial coefficient) = 263409560461970212832400 as required.

PowerShell, 7 Bytes, 5 Unique Bytes, AdmBorkBork
1PB#---

Try it online!
The output 1125899906842624 is equal to 2^50 and 2^50 Bytes is equal to 1 Pebibyte.
The actual code is just 3 bytes, therefore I added a comment at the end.

Nice. I had thought tacking on a comment would toss people for a loop, but looks like I was wrong. :)

Excel, 22 bytes, 16 unique bytes, EngineerToast
A possible solution is:
=BAHTTEXT(2^(480-300))

The unique characters are =BAHTEX()^02348-.
I recognized that BAHTTEXT was used when seeing the output. By translating the output back from Thai to English, I was able to find the value of the number. I guessed it to be a power of 2, which it indeed is (namely 2180). The expression 480-300=180 was then constructed to make sure the solution contains 22 bytes with 16 unique.

Alice, 9 bytes, 8 unique bytes, Leo
/Yr@
\no/

Try it online!
Unfolded, this is nrYo@.
n  negate the implicit empty string: creates the string "Jabberwocky".
r  range expansion: produces a string that starts with J,
   goes up in ASCII order to w, down to c, and then up to y.
Y  separate this string into even and odd positions
o  output the even positions
@  terminate

Incidentally, the orientation of the mirrors in the first column is completely irrelevant, so this could easily be reduced to 7 unique bytes.

You're right about the mirrors! I've become too rusty with Alice :)

Haskell, Laikoni, 30 bytes, 17 unique
show.length.show=<<['\0'..'0']

Vyxal d, 4 bytes, 4 unique, cracks emanresu A's answer
ka¦²

Try it Online!

Nice! How did you get tins?

@emanresuA I saw every letter of the alphabet, so I knew there was ka, which by itself was half the program. Then I noticed that there was a pattern of a..., a... b..., a... b... c..., a... b... c... d..., etc., so I knew there was ¦, for prefixes. From there, the only thing I knew of that created that specific pattern was multiplying strings together, so I thought about *, e, and Π, before remembering that ² doesn't vectorise properly, and would multiply the strings instead of splitting them. It really just came down to knowing the quirks of the commands.

J, 8 bytes, 6 unique bytes, Bolce Bussiere
;p.p:i.9

Try it online!
Output:
23 _0.677447j0.296961 _0.677447j_0.296961 0.125003j0.726137 0.125003j_0.726137 _0.379097j0.630438 _0.379097j_0.630438 0.518498j0.521654 0.518498j_0.521654

The obvious hint is that, in the given output, complex numbers always appear as conjugate pairs. It made me suspect the p. verb, which converts between plain polynomial and multiplier-and-roots forms.
So I tried:
p. 23;(...those complex numbers)
   2 3 5 7.00001 11 13 17 19 23

Yes, my thought was correct. The list of primes is easy. Monadic ; flattens the list of boxed arrays to simple linear one. The resulting expression has two p's and two dots, so the byte count is perfect.

Octave, 4 bytes, 3 unique bytes, Tom Carpenter
j^7j

Try it online!

Jelly, 8 bytes, 6 unique, Mr. Xcoder
7x7²¤ḌḤ²

Try it online!
How?
7x7²¤ḌḤ² - Main link: no arguments & no input
7        - literal 7
    ¤    - nilad followed by link(s) as a nilad:
  7      -   literal 7
   ²     -   square -> 49
 x       - repeat elements -> [7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7]
     Ḍ   - convert from a decimal list -> 7777777777777777777777777777777777777777777777777
      Ḥ  - double -> 15555555555555555555555555555555555555555555555554
       ² - square -> 241975308641975308641975308641975308641975308641926913580246913580246913580246913580246913580246916
         - implicit print