text:
A crowd of blank stares
Problem
Given no input write a program or a function that outputs or returns the following string:
(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)
Rules

Shortest program wins.
Trailing whitespace allowed.
Trailing newlines allowed.
Unused parameters for functions allowed.

Note: this string is the concatenation of substrings of (<>.<>): "(<" + "(<>" + "(<>." + ... + "(<>.<>)" + "<>.<>)" + ">.<>)" + ... + ">)"

This would've been a little less "hardcode all the text!" if it were a bigger crowd...

@totallyhuman Will think about it next time

SOGL V0.12, 12 bytes
pΙ2○3V?hG]‘Γ

Explanation:
pΙ2○3V?hG]‘   Push compressed string of the first half of the string (this is the kind of thing this compressor was made for)
           Γ  mirror, swap chars & palindromize with one character overlap

Try it Here!

Nice to see you have an online interpreter available now :)

How do you do this? Great work though!!

05AB1E, 16 bytes
"(<>.".∞ηJÀ24£.∞

Try it online!
Explanation
"(<>."             # push this string
                   # STACK: "(<>."
      .∞           # intersected mirror
                   # STACK: "(<>.<>)"
        η          # compute prefixes
         J         # join to string
                   # STACK: "((<(<>(<>.(<>.<(<>.<>(<>.<>)"
          À        # rotate left
           24£     # take the first 24 chars
                   # STACK: "(<(<>(<>.(<>.<(<>.<>(<>."
              .∞   # intersected mirror
                   # STACK: "(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"

Python 3, 49 bytes
for i in range(11):print(end='(<>.<>)'[i-12:i+2])

Try it online!

JS (Jsfuck), 10,614 bytes
Didn't have access to the website, had to figure this all out manually -.-
(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]

Explanation:
Most of the characters are relatively easy:
 For the brackets im executing
   ([]["fill"]+[])[13] // '('

   ([]["fill"]+[])[14] // ')'

The full stop is gotten by making js create a scientific notation number like
 1.1e+21
 And taking the dot character after converting to a string
The square brackets are harder, we have to execute the function to create an
 italic html object string and steal the angle brackets. The main trick in this is getting the 'c' for the word italics, which requires building up another function to take the c from 'function'
There's a lot of scope for improvement here, mostly on which functions are used to get the square brackets. I also recall an easier way to get the character 'c' if italics is better, but i'd have to look though my old files to find it

console.log( (!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])]
+(+[]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+!+[]]
+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[+!+[]+!+[]]+(![]+[])[+!+[]+!+[]]])[+!+[]+(+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+[])])

This looks overly-long even for JSFuck but +1 for the sheet effort of doing this manually.

I call BS on doing it manually. You had to have done something to automate generating that.

10660 bytes actually.

@PatrickRoberts I bet he figured it out manually and used the powers of ctrlc and v

@PatrickRoberts It's not a super difficult program, its just a case of understanding how to build up each character. As a basic example, the way to get a 't' character is to make an empty array '[]', cast to a number to make the number 0:  '+[]' and then apply the not operator to it to cast to a boolean true '!+[]'. Then cast to a string, by adding an empty array again and putting it in brackets to give us the string "true" '(!+[]+[])' and finally take the zeroth letter with '(!+[]+[])[+[]]'

Why do you need square brackets?

@CalculatorFeline what do you mean? Are you suggesting its possible for just the characters '()+!' to be turing complete then i'm not sure, but i'm much more familiar with the '!+' system

()+! isn't Turing complete because no literals exist. I meant why do you need to construct square brackets []?

@CalculatorFeline ah right yes I mean '<' and '>', not sure what the proper name is. maybe angle brackets

Correct. And yeah, <> seem quite hard to make D: Maybe you should try making a <u> element rather than an <i> element (u=([][[]]+[])[+[]])

@CalculatorFeline I'd need to build up the name of the function. Here i'm making the string function 'italics()'. Your comment did prompt me looking into shorter words, I think bold() may be easier to create

Forgot about that :P Also, what browser are you using? Chrome 58 doesn't have italics or bold.

@CalculatorFeline chrome version 58, italics seems to work ok here, just ran "a".italics() in the console
I have to go for today, i will speak more tomorrow

Oh, I thought it was a global function. Good to know. sup and sub seem like good candidates (hardest chars are p and b)

My semiautogenerated solution is 11846 bytes. Well, time to start golfing :P (Also, I'm using alert. Calculating with console.log now)

13169 bytes with console.log. Clearly not the way to go.

Wait a moment. Is this a function? Well, doesn't make much of a difference for me (~100 bytes)

@CalculatorFeline I'll see if I have a good solution for p or b written down in a notepad file somewhere to make sub or sup now

Also, now that you have access to the website (?), maybe you should take a look.

C# (Mono), 54 52 bytes
s=>"(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"

Try it online!
-2 bytes thanks to Kevin Cruijssen
RIP C#

I know the feeling (Java). But, you can save two bytes. The trailing ; isn't counted for lambda-answers. And () can be replaced with a single character (unused null object). Relevant meta post for the second.

@KevinCruijssen Yes I did specify unused function parameters allowed so s=> is perfectly fine.

-1: There was no effort done to golf the answer in any way.

@MechMK1 that's the point, it's quite literally as golfed as possible in C#. Literal output of the string is the tersest way to output this particular string in this particular language. See Erlantz's C# answer

@Skidsdev I still consider that it's against the spirit of Code Golf, boring to write and boring to read. I mean, my vote doesn't count because I don't actively participate, so don't worry about that. It's just my 2 cents, so to say.

Retina, 30 bytes

(<>.<>)
5`.
$&$'
7`.
$`$&
^.

Try it online!

um what even is this

V, 28 27 25 22 bytes
3? 4? bytes thanks to @KritixiLithos
i(<>.<>)òÙxlHÄ$xGòxÍî

Try it online!
i(<>.<>)                'insert (<>.<>)
         ò        ò      'recursively
          Ù              'duplicate this (bottom line) down
           x             'delete the first character
            l            'and break when there's only one character left
             H           'go to the top of the buffer
              Ä          'duplicate that line up
               $x        'delete the last character
                 G       'and go back to the bottom of the buffer
                   x     'delete the extra ) left by the loop
                    Íî   'and remove all newlines

You can replace hx with just X.

And dkHxògJ is 1 byte shorter than dkVHgJ0x.

Yeah DJ's Íî thing works too

I get i(<>.<>)òÙxlHÄ$xGòddÍî for 23

@KritixiLithos I literally JUST switched the lX for xl too :D

Charcoal, 18 17 bytes
Ｆ⁶…(<>.<>)⁺²ι‖ＢＯ⁷

Try it online! Link is to verbose version of code. Uses the new Slice operator.

Compression is also 17 bytes now :P

R, 42 bytes
cat(substring('(<>.<>)',-4:6,2:12),sep='')

Fairly simple program that takes advantage of the way substring works in R.  So substring('(<>.<>)',-4:6,2:12) produces the following vector
> substring('(<>.<>)',-4:6,2:12)
 [1] "(<"      "(<>"     "(<>."    "(<>.<"   "(<>.<>"  "(<>.<>)" "<>.<>)"  ">.<>)"
 [9] ".<>)"    "<>)"     ">)"

cat with an empty separator outputs it to STDOUT in the required format.
Try it online!

TrumpScript, 70 Bytes
I know, it's a boring solution.
say "(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"
America is great

Well done, nonetheless.

Brachylog, 14 bytes
"(<>.<>)"aᶠckb

Try it online!
"(<>.<>)"           #   string
         aᶠ         #       get all Affixes (pre- and suffixes)
           c        #       Concatenate
            kb      #       remove last (Knife) and first (Behead)

As of now the full face seems to get duplicated, but you can fix it by just changing the ᶠ into a ᵘ.

C (gcc), 59 57 bytes
2 4 bytes less than a simple puts() solution. There is sure to be some elegant recursive solution, but so far the overhead becomes too large at every attempt.
f(i){for(i=1;i++<12;)printf("%.*s",i,"(<>.<>)"+i/7*i%7);}

Try it online!

Brainfuck, 198 175 167 Bytes
I have never done a codegolf, so this is my first one. Feedback is highly appreciated.
++++[>+++++<-]>[>++>+++>+++>++>++[<]>-]>.>.<.>.>++.<<.>.>.>>++++++.<<<<.>.>.>>.<<<.<.>.>.>>.<<<.>.<<.>.>.>>.<<<.>.>+.<<.>.>>.<<<.>.>.<.>>.<<<.>.>.>.<<<.>.>.<<.>.>.<.>.

Try it online!
I went for the most obvious solution in my opinion. First, I set cells 1-5 to one of the letters "().<>". Then I just go to the right cells and output the character.
UPDATE: I changed the order in which the characters appear on the "tape" making the program way shorter and more efficient.
UPDATE 2: Just revisited my post after a while and realized, that using a shorter sequence for setting up the cells I could save some bytes.

Welcome to PPCG! :)

Nice, first answer, usually answers that are not immediately apparent how they work need an explanation but this challenge is pretty trivial so not really needed. But if you do a 1200 bytes brainfuck in the future just a simple explanation goes a long way.

I will be sure to do that in the future.

Ok, I added a short (and kinda bad) description of my code.

Charcoal, 20 bytes
Ａ(<>ι(<ιι.ι.<ι.ιι.‖Ｂ

Try it online!
Thanks to Destructible Lemon for noticing a pattern (-4).
AST:
Program
├Ａ: Assign
│├'(<>': String '(<>'
│└ι: Identifier ι
├Print
│└'(<': String '(<'
├Print
│└ι: Identifier ι
├Print
│└ι: Identifier ι
├Print
│└'.': String '.'
├Print
│└ι: Identifier ι
├Print
│└'.<': String '.<'
├Print
│└ι: Identifier ι
├Print
│└'.': String '.'
├Print
│└ι: Identifier ι
├Print
│└ι: Identifier ι
├Print
│└'.': String '.'
└‖Ｂ: Reflect butterfly
 └Multidirectional

What ‖Ｂ does is basically visually palindromize canvas.

Explanation please.

@CalculatorFeline Added AST as returned by -a.

Huh. That was more useful than I thought.

I think this would be clearer even if you just added that print is implicit with objects

@DestructibleLemon But the AST already has the Prints in there, not sure what you mean.

I know. it would just clarify why there are a bunch of print commands out of nowhere for someone who doesn't know the language

Wait a minute I got it wrong and this is bugged

@DestructibleLemon Basically the AST says that those Prints are implied by itself.

Ａ(<>.ι(<(<>ιι<ι<>ι‖Ｂ actually works

JavaScript, 47 bytes

g=(i=2)=>i>12?'':'(<>.<>)'.slice(i-14,i)+g(i+1)
f=(i=11)=>i?f(i-1)+'(<>.<>)'.slice(i-13,i+1):''

// Both of the above work and are the same size

document.write('<pre>Actual g(): ' + g() + '\nActual f(): ' + f() + '\nExpected:   (<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)</pre>');

Uses the same method as Rod's Python answer.

C (gcc), 61 bytes
I know this is lame but it's much shorter than my other solution...
f(){puts("(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)");}

C (gcc), 103 bytes
Here's a version where I'm trying to be somewhat tricky...
char*e="(<>.<>)<>.<>)>.<>).<>)<>)>)";f(i,n){for(n=2;n<8;n++)for(i=0;i<n;i++)putchar(e[i]);puts(&e[i]);}

C (gcc), 117 115 bytes
A recursive version that's fully tricky...
char*e="(<>.<>)";main(i,j){if(i<6){for(++i,j=0;j<i;putchar(e[j++]));main(i);}else if(i<12)printf(e+i++-6),main(i);}

Try it online!

Please also share your none-hardcoded solution. Despite being longer I'm sure it's much more interesting than this trivial one.

Mathematica 41 bytes
""<>"(<>.<>)"~StringDrop~i~Table~{i,-5,5}

A crowd of blank stares watching Batman in honor of Adam West...
C# (.NET Core), 393 bytes
s=>{string b="NanananaNanaBATMAN!NanaBATMAN!NANANanaBATMAN!NANAnanaNanaBATMAN!NANABATMAN!NanaBATMAN!NANABATMAN!naNABATMAN!NANABATMAN!naNANAnaNANABATMAN!naNANANABATMAN!naNABATMAN!naNANAnanaNA",r="",t;for(int i=0;i<176;)if(b[i]=='B'){r+="<>";i+=7;}else{t=b.Substring(i,4);if(t=="Nana")r+="(";else if(t=="nana")r+="<";else if(t=="NAna")r+=">";else if(t=="NANA")r+=".";else r+=")";i+=4;}return r;}

Try it online!

q, 29 bytes
raze"(<>.<>)"{(y-5)_x}/:(!)11
-2 bytes thanks to streetster
EDIT for explanation:
Language is right to left interpreted.
How it works
raze"(<>.<>)"{(y-5)_x}/:(!)11
                        (!)11 /yields indices [0-10], right parameter of function (y)
                      /:      /each right: loop right parameter of a dyadic function
             {       }        /function
    "(<>.<>)"                 /left parameter of function (x)
              (y-5)           /subtract 5 from y (indices)
                   _          /remove first y chars from x, or last y chars if negative
raze                          /flatten string output to produce the final string

An explanation here would be great.

You can remove the space before the _x for 1 byte, and change til 11 to (!)11 for another 1 byte saving = 2 bytes saved :)

@streetster great stuff :)

Haskell, 55 45 bytes
map take[2..7]++map drop[1..5]>>=($"(<>.<>)")

Try it online!
First Haskell answer to beat the hardcoded solution!
Explanation
The way this answer works is by building a list of functions to be applied to the string (<>.<>).  First we build the left and center with
map take[2..7]

which gives us all the prefixes from size two to seven.  Then we build the right with
map drop[1..5]

which gives us all the suffixes from size six to two.
Once we have the list of functions we use a monadic bind (>>=) which is just concatMap but shorter.  The function we concatmap with is ($"(<>.<>)") which applies the input to the string (<>.<>).
This makes the string.

Jelly, 22 bytes
1 byte thanks to Kritixi Lithos.
U;\UṚṖ
“(<>.<>)”;\ḊṖ,Ç

Try it online!

I think you can drop the µ

Java 8, 52 bytes
x->"(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"

Boring, but there isn't any way to make this shorter in Java.. Just initializing a temp String is already 11 bytes.. (String t="something";), and using substring a couple of times certainly costs too many bytes..
Shortest alternative to a literal return is probably this (58 bytes):
x->"(<(x(x.(x.<(x.x(x.x)x.x)>.x).x)x)>)".replace("x","<>")

Try it here.

Also works in JavaScript, using a "fat arrow" function (=>) if you want to add it.

@Shaggy Nah, you can keep your JavaScript answer if you want. The same applies to C# which also already has a separate answer.

Python 2, 57 bytes
print''.join("(<>.<>)"[max(0,n-5):n+2]for n in range(11))

I say it looks like a gang of owls peeking out behind their leader. Just saying.

MATL, 28 bytes
'(<>.<>)'XH5:"H7@-:)wh2M@+)h

Try it online!

Haskell, 95 bytes
import Data.List
import Control.Arrow
concat$tail$init$uncurry(++)$inits&&&tail.tails$"(<>.<>)"

This is far longer than the 49 bytes necessary for a string literal with the output, but the best I could do to utilise the structure. As usual, I love arrows, and inits &&& tails does produce a tuple of the list of leading substrings and the list of trailing substrings of the input. Then those two tuple elements are put together in one list by passing the tuple to ++, and that list is concatenated to one large string. The tail and init calls avoid duplicating the (<>.<>) in the middle (one generated by inits, the other by tails) and drop the unwanted parenthesis from the start and end, taking only substrings of length 2 or more into account.

Can you please add an explanation?

@CalculatorFeline Done

brainfuck, 245 210 bytes
Golfing in progress.
>++++++++[<+++++>-]>++++++[<++++++++++>-]>++++++[<++++++++++>-]<++>>++++++++[<+++++>-]<++++++<<<.>.<.>.>.<<.>.>.>.<<<.>.>.>.<<.<.>.>.>.<<.>.<<.>.>.>.<<.>.<<+.>.>.>.<<.>.<<.>>.>.<<.>.<<.>>>.<<.>.<<.>.>.<<.>>.<<.

Try it online!

Jelly, 18 bytes
“(<>.<>)”ḣJœ|ṫJ$ḊṖ

Try it online!
How it works
“(<>.<>)”ḣJœ|ṫJ$ḊṖ  Main link. No arguments.

“(<>.<>)”           Set the argument and return value to s := "(<>.<>)".
          J         Yield all indices of s, i.e., [1, 2, 3, 4, 5, 6, 7].
         ḣ          Dyadic head; yield s's prefixes of lengths 1 to 7.
               $    Combine the two links to the left into a chain.
              J         Indices; yield [1, 2, 3, 4, 5, 6, 7].
             ṫ          Dyadic tail; yield s's postfixes of lengths 1 to 7.
           œ|       Multiset union; concatenate the results to both sides,
                    discarding the copy of s. (s is both a prefix and a postfix.)
                Ḋ   Dequeue; remove the first prefix, i.e., "(".
                 Ṗ  Pop; remove the last postfix, i.e., ")".

C (clang), 62 61 bytes
main(n){while(write(++n<13,n/7*(n-7)+"(<>.<>)",n/7?14-n:n));}

This terminates only after timing out on TIO because the write to standard input fails, but it will terminate in a terminal. The program relies on a specific order of evaluation (undefined behavior) and won't work with, e.g., gcc.
Thanks to @Steadybox for an idea that saved a byte!
Try it online!
Verification
$ cat crowd.c
main(n){while(write(++n<12,n/7*(n-7)+"(<>.<>)",n/7?14-n:n));}
$ clang -o crowd crowd.c 2> /dev/null

$ ./crowd 0> /dev/null
(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)

Alternate version, 62 bytes
main(n){while(++n<13)write(1,n/7*(n-7)+"(<>.<>)",n/7?14-n:n);}

At the cost of one more byte, the solution becomes a lot more portable.
Try it online!

60 bytes as a function, but it's probably not reliable.

Nice!  58 bytes with recursion, but it breaks if the program is called with arguments.

@Dennis Yeah, the (< is missing there.

Jelly, 19 bytes
“(<>.<>)”µṖ¹Ƥ;¹ÐƤṖḊ

Try it online!

J, 30 25 24 Bytes
;}.}:~.(<\,<\.)'(<>.<>)'

Explanation later, I have a feeling I can golf this more...
Edit:
-5 6 Bytes thanks to @FrownyFrog :)
Explanation:
               '(<>.<>)'   | The face
       (   <\.)            | Apply box to the suffixes of '(<>.<>)': Gives '(<>.<>)', '<>.<>)' ... ')'
          ,                | Append to...
        <\                 | Box applied to the prefixes of '(<>.<>)'
 }.}:~.                    | Remove the extra '(<>.<>)', as well as '(' and ')' from the front and back
;                          | Join into one string

@FrownyFrog ...maybe.... :P

Python 2, 55 bytes
couldn't resist beating the current python 2 answer

print "(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"

Try it online!

Stax, 16 14 bytes
ü■_'σIHa¬ø·hÑè

Run and debug it at staxlang.xyz!
Unpacked (16 bytes) and explanation:
"(<>.":w|[D$3T:w
"(<>."              String literal                     (<>.
      :w            Palindromize, flipping (){}[]<>    (<>.<>)
        |[          Array of prefixes                  [ ( (< .. (<>.<>) ]
          D         Drop first                         [ (< (<> .. (<>.<>) ]
           $        Concatenate                        (<(<>(<>.(<>.<(<>.<>(<>.<>)
            3T      Drop last three                    (<(<>(<>.(<>.<(<>.<>(<>.
              :w    Palindromize, flipping (){}[]<>

Python 2, 54 bytes
f=lambda i=5:L*0**i or L[:-i]+f(i-1)+L[i:]
L='(<>.<>)'

Try it online!
Slight improvement on the leading Python 2 answer
Port of my Lenny's answer

Deadfish~, 278 bytes
{iiii}c{ii}c{dd}c{ii}ciic{dd}ddc{ii}ciic{d}ddddddcddddddc{ii}ciic{d}ddddddc{i}iiiic{dd}c{ii}ciic{d}ddddddc{i}iiiiciic{dd}ddc{ii}ciic{d}ddddddc{i}iiiiciic{dd}dc{ii}dciic{d}ddddddc{i}iiiiciic{dd}dc{ii}ic{d}ddddddc{i}iiiiciic{dd}dciiiiic{i}iiiiciic{dd}dc{ii}dciic{dd}dc{ii}ic{dd}dc

Try it online!

Retina, 39 bytes

(<(a(a.(a.<(a.a(abab>bba)>)
b
.a)
a
<>

Try it online!

C#, 104 bytes
string a="(<>.<>)",s="";for(int i=2,k=a.Length;i<k*2-1;i++){s+=(k>i)?a.Substring(0,i):a.Substring(i-k);}

Try it online!

t.Text? Do you perhaps mean another variable?

I think it would be shorter to... just do the entire string.

@LiefdeWen done

@LeakyNun Yeah C# doesn't fare well at all at most kolmogorov complexity questions

@LeakyNun just trying to give tips

@ErlantzCalvo instead of var a="...";var s="" do string a="...",s="" on 2 declarations it saves you 1 byte and on more declarations more bytes

@ErlantzCalvo instead of i<=a.Length do a.Length>i

@LiefdeWen edited, thanks!

you use a.Length three times so you can do in the for loop declaration: int i=2,k=a.Length and use k in the loop instead of a.Length

JavaScript (ES6), 52 bytes
Obvious solution; doesn't seem to be much room for any trickery here.

f=

_=>"(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)"

o.innerText=f()
<pre id=o>

I did some trickery!

@Artyer, so I saw, nicely done :)

Brainfuck, 489 bytes
++[------>+<]>---.[-->+++<]>.[--->++<]>.[-->+++<]>.++.--[--->++<]>.[-->+++<]>.++.[->+++++++++<]>.------.[-->+++<]>.++.[->+++++++++<]>.--[----->+<]>.[--->++<]>.[-->+++<]>.++.[->+++++++++<]>.--[----->+<]>.++.--[--->++<]>.[-->+++<]>.++.[->+++++++++<]>.--[----->+<]>.++.+[--->++<]>-.-[-->+++<]>.++.[->+++++++++<]>.--[----->+<]>.++.+[--->++<]>-.+[-->+++<]>-.[->+++++++++<]>.--[----->+<]>.++.+[--->++<]>-.+++++.--[----->+<]>.++.+[--->++<]>-.-[-->+++<]>.++.+[--->++<]>-.+[-->+++<]>-.+[--->++<]>-.

Japt, 41 25 bytes
"(<>.<>)"
¤£¯Ò°TÃ+U+¤£s°V

Test it

T-SQL, 54 bytes (the trivial solution)
PRINT'(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)'

I like this challenge, simple and yet so annoying.
I tried hard to find alternates, but nothing was shorter, due mostly due to the length of SQL keywords. Hmm, maybe I need to create GolfSQL with minimized keywords and other optimizations...
Here's my best attempt at a procedural solution (97 bytes golfed, presented here formatted):
DECLARE @ INT=-4, @o VARCHAR(99)=''
a:
    SET @o+=SUBSTRING('(<>.<>)',@,7)
    SET @+=1
IF @<7 GOTO a
PRINT @o

This works because SUBSTRING can take a negative start value, in which case it simply reduces the length.
Edit: Found a slightly shorter non-trivial solution (96 bytes):
SELECT STRING_AGG(SUBSTRING('(<>.<>)',number-4,7),'')FROM
spt_values WHERE TYPE='P'AND number<11

Only works on MS SQL Server, where the master database has a built-in system table called spt_values. This table (when filtered by WHERE TYPE='P') can be used as a number table to generate the values from -4 to 6.

Bubblegum, 24 bytes
0000000: d3 b0 d1 b0 b1 03 22 3d 10 b6 01 13 76 10 52 13  ......"=....v.R.
0000010: 42 82 09 10 06 b1 35 01                          B.....5.

Try it online!

Pyth, 29 bytes
K"(<>.<>)"s++m<KhdS5Km>hdK_S5

Try it here!

Perl 5, 75+1(-w) = 76 bytes
I'm unsure of how needed -w is, but it wasn't printing the output until I tried it.
for(-5..5){$l=-abs($_)+7;$o=$_>0?7-$l:0;$s.=substr"(<>.<>)",$o,$l;}print$s;

Try it online!
Ungolfed
for(-5..5){
  $l = -abs($_) + 7;
  $o = $_ > 0 ? 7 - $l : 0;
  $s .= substr "(<>.<>)", $o, $l;
}

Matlab, 74 68 65 bytes
function[m]=f,s='(<>.<>)';m=s;for i=2:6,m=[s(1:8-i),m,s(i:7)];end

Runs perfectly on Matlab and prints: (<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>). However, it prints on Octave. So the link is useless.
Try it Online!

Julia, 60 bytes
prod([("(<>.<>)"^2)[min(x,8):max(x,7)] for x in[9:13;1:6]])

I think there is a superfluous space in ] for

@JonathanFrech This is new, in Julia 1.0 it is needed. Julia had some potential but really seems to lack commitment to become a serious golfing language.

I do not know a lot about Julia, but TIO's Julia seems to be on version 0.4; the space does not appear necessary there.

PHP, 47 bytes
Needs a file with the Content-Type text/plain

(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)

Try it online!
PHP, 53 bytes
<?="(<(<>(<>.(<>.<(<>.<>(<>.<>)<>.<>)>.<>).<>)<>)>)";

Try it online!

The first one is also a valid echo program.

@CalculatorFeline No in the first example the PHP interpreter prints only the text. There is no start tag.  We must avoid to do this in a html file.

...Confused. Where did I mention HTML?

@CalculatorFeline Nowhere! You can not use echo in the first case

I suppose the correct language is cat.

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


text:
Surrounded and reversed
The task
In this challenge, your task is to determine whether some string occurs as a substring of a given string both surrounded by another string and reversed.
Your input is a non-empty string S of lowercase ASCII letters.
If there exist non-empty strings A and B such that the concatenation ABA and the reversal rev(B) are both contiguous substrings of S, then your output shall be a truthy value.
Otherwise, your output shall be a falsy value.
The two substrings may occur in any order, and they can even overlap.
However, it can be shown that in all truthy cases, you can either find non-overlapping substrings or a solution where B is a palindrome.
Example
Consider the input string S = zyxuxyzxuyx.
We choose A = xu and B = xyz, and then we can find the following substrings:
S      = zyxuxyzxuyx
ABA    =   xuxyzxu
rev(B) = zyx

The choice A = x and B = u would also be valid.
The correct output in this case is truthy.
Rules and scoring
You can write a full program or a function.
Standard loopholes are disallowed.
The lowest byte count wins.
Test cases
Truthy
sds
aaxyxaa
aaxyaaayx
hgygjgyygj
zyxuxyzxuyx
cgagciicgxcciac
iecgiieagcigaci
oilonnsilasionloiaammialn
abbccdeeaabccddbaacdbbaccdbaaeeccddb

Falsy
a
aaxyaa
jjygjhhyghj
abcaabbccaabca
egaacxiagxcaigx
lnsiiosilnmosaioollnoailm
cabbccabdcaddccabbddcaabbdcaddccaadcabbccaabbcadcc

Fun fact
One can construct arbitrarily long falsy strings using four distinct letters, but not using three letters.
The fourth falsy test case is the longest possible.

I think abcaabbccaabcaa is still falsy with three distinct letters.

@EriktheOutgolfer Choose A = caa and B = b, and look at the end of the string.

Oh...yeah I don't have much time to check while golfing...

Brachylog, 13 bytes
s↔B&sA,B,A~s?

Try it online!
How it works
s↔B&sA,B,A~s?
s              the input has substring temp
 ↔B            temp reversed is B
   &           and the input
    sA         has substring A
      ,B,A     A,B,A
          ~s?  is a substring of input

Ah right. I was wondering how you ensured that A was nonempty, but the s immediately after the & takes care of that.

Retina, 40 bytes
(.+)(.)+\1.*(?<=(?=(?<-2>\2)+(?(2)A)).*)

Try it online!
Big thanks to Martin for fixing a bug with the expression.
Matches ABA then the rest of the string. While doing this, it pushes B's characters onto a stack. Looks backwards over the whole string to find B in reverse order, by traversing forward again and popping characters off of the stack as it matches them ((?<-2>\2)+). Then it makes sure the stack is empty by trying to match a capital letter, which won't be in the input, if the stack still is full.

Ruby, 53 bytes
->s{s.scan(/(?=(.+)(.+)\1)/).any?{|a,b|s[b.reverse]}}

Fairly straightforward. The only real trick is the positive lookahead (?=...) in the regex, which is used to find all matches and not just non-overlapping ones.
Try it online!

PHP, 95 bytes
<?=($p=preg_match_all)('#(?=(.+)(.+)\1)#',$argn,$t)&&$p(strrev("#".join("|",$t[2])."#"),$argn);

Try it online!

Jelly, 21 bytes
Ḣ⁼Ṫȧ
ẆŒṖ€ẎÇÐfẎ€QUẇ€⁸Ṁ

Try it online!
Very inefficient.

source: Stack Exchange

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

sort: votes


text:
Make a lookup index
Given a string, return a table where the first column has the unique letters of the string in order of occurrence and subsequent columns list the indices of that letter in the string, using zero or one-based indexing. Horizontal whitespace does not matter, as long as the left-most column is vertically aligned. Indices must be in ascending order from left to right.
Examples
Using zero-based indexing and given "abracadabra", return
a 0 3 5 7 10
b 1 8
r 2 9
c 4
d 6

Using one-based indexing and given "3141592653589793238462643383279503", return:
3  1 10 16 18 25 26 28 34
1  2  4
4  3 20 24
5  5  9 11 32
9  6 13 15 31
2  7 17 22 29
6  8 21 23
8 12 19 27
7 14 30
0 33

Can I have leading spaces in the output?

Must the output format be strict?

@EriktheOutgolfer Yes. Added.

@LeakyNun No. Added.

Can the rows be unordered?

@Adám I meant if instead of abrcd I output abcdr for example, with the indices still corresponding to the correct letters.

@EriktheOutgolfer OP: in order of occurrence

Does this need to work for characters that aren't printable ascii? Are there any characters we can assume won't be in the string (particularly whitespace)?

APL (Dyalog), 4 bytes
,⌸

Try it online!
(⌸ is 3 bytes)
Uses 1-based indexing.
⌸ is the key operator. Here it behaves as a monadic operator. It applies the function ,, concatenate the left argument with the right argument, to each unique element in its right argument and the indices of that unique element in the original argument.

Hm, this needs an explanation :-)

@Adám I suspect this challenge had been tailored specifically for APL

@Uriel The other way around. I was looking at what APL can do neatly, and thought that this would make a good challenge.

I see 4 bytes there.

Haskell, 86 bytes
import Data.List
f s=unlines[x:concat[' ':show i|i<-[0..length s-1],s!!i==x]|x<-nub s]

Defines a function, f, which returns a String containing this output.
Try it online!
How?
import Data.List                                                            -- Imports Data.List. This contains the nub method which is necessary
f s =                                                                       -- Define a function, f, which takes one argument, s
            [                                               |x<-nub s]      -- Loop through nub s with the variable x. Nub removes duplicates from a list, in this case the input.
                     [          |i<-[0..length s-1]        ]                -- Go thourgh the list [0,1,2...] until the length of the input - 1. Basically a indexed for-loop
                                                   ,s!!i==x                 -- Filter out everything where the char at this index isn't x
                      ' ':show i                                            -- i as a string with a space before it
               concat                                                       -- Flatten the whole list
             x:                                                             -- Append x before it
     unlines                                                                -- Insert newlines between every element in the list and flatten it, effectively putting every element on it's own line

I don't think I've ever seen that comment format used for Haskell.

Your inner list comprehension can be shortened to [' ':show i|(i,c)<-zip[0..]s,c==x].

kdb+/q, 5 bytes
group

Builtins are fab
q)group"abracadabra"
a| 0 3 5 7 10
b| 1 8
r| 2 9
c| ,4
d| ,6

I usually golf in k, but the 2-byte k version (=:) doesn't format the output nicely
k)=:"abracadabra"
"abrcd"!(0 3 5 7 10;1 8;2 9;,4;,6)

The results are exactly the same, but the formatting is lost. To format, and to remove the return object, we actually pick up more bytes than the q version
k)f:{1@.Q.s x;} //11 bytes!
k)f"abracadabra"
a| 0 3 5 7 10
b| 1 8
r| 2 9
c| ,4
d| ,6

Hm, it returns a dictionary. Interesting.

MATL, 11 bytes
u"@0hG@=fVh

Output indices are 1-based.
Try it online!

Python, 96 bytes
def f(s,r=[]):
 for c in s:
  if c not in r:print(c,*(i for i,l in enumerate(s) if l==c));r+=[c]

try it online!

Jelly, 7 bytes
Q;"ĠṢ$G

Try it online!

Pyth, 13 bytes
jmj;+dxCdCMQ{

Try it online!

05AB1E, 14 bytes
ÙvSyQƶ0Ky¸ìðý,

Try it online!
Explanation
Ùv              # for each unique char y in input
  S             # split input into a list of chars
   yQ           # compare each to y for equality
     ƶ          # multiply each by its 1-based index
      0K        # remove zeroes
        y¸ì     # prepend y to the list of indices
           ðý,  # join by spaces and print

Mathematica, 85 bytes
using one-based indexing
(t=#;j=First/@t~StringPosition~#&/@(s=First/@Tally@Characters@t);Row[Column/@{s,j}])&

R, 80 77 bytes
function(s)for(i in (z=unique(s<-strsplit(s,'')[[1]])))cat(i,which(s==i),"
")

Try it online!
an anonymous function; prints the result 1-indexed with a trailing newline.

JavaScript (ES Draft), 77 bytes
s=>s.replace(/./g,(c,i)=>a[c]=(a[c]||c)+` `+i,a={})&&Object.values(a).join`
`

88 bytes in older browsers:

f=
s=>s.replace(/./g,(c,i)=>a[c]=(a[c]||c)+` `+i,a={})&&Object.keys(a).map(c=>a[c]).join`
`
<input oninput=o.textContent=f(this.value)><pre id=o>

PHP, 82 bytes
for(;~$c=$argn[$i];)$r[$c].=str_pad(++$i,5," ",0);foreach($r as$k=>$v)echo"$k$v
";

Try it online!

QBIC, 95 bytes
dim X(126)[_l;||i=asc(_sA,a,1|)┘X(i)=X(i)+@ `+!a$][_lA||_SA,b,1|i=asc(C)~X(i)<>D|?C,X(i)┘X(i)=@

Explanation
This copies significant parts of my answer on this challenge:
dim x(126)      Create an array of 126 elements (one for each ASCII element)
[_l;||          Read cmd line input, loop over its length
i=asc(_sA,a,1|) Read the next char's ascii value
┘               (Syntactic linebreak)
X(i)=           Set the value for this ascii-codepoint to
 X(i)             everything we've put in before
 +@ `             and a literal space
 +!a$             and the current (1-based) index cast as string
 ]              close the FOR loop
 [_lA||         Loop over the original string again (to preserve order of appearance)
 _SA,b,1|       Read 1 char, assign to C$ (note the capital S in the function call,
                this auto-creates C$ abd assigns it the value of the substring-call)
 i=asc(C)       Get the index in our storage array from C$'s ascii value
 ~X(i)<>D       IF the storage array holds data for i (<> D$, which we'll set to "" in a second),
 |?C,X(i)       THEN PRINT the character, followed by the indices saved for this char
 ┘              (Syntactic linebreak)
 X(i)=@         Clear out the data stored for C$
                @ declares a string lit, ` would close it and that gets auto-added at EOF,
                creating the literal @`, which gets assigned to D$

Sample run:
Command line: abracadabra
a              1 4 6 8 11
b              2 9
r              3 10
c              5
d              7

Python 3, 111 106 bytes
def q(f):
 d={a:[]for a in f}
 for a,b in enumerate(f):d[b]+=[a]
 [print(p,*d.pop(p))for p in f if p in d]

repl.it

C (clang), 176 bytes
G(S,V,c,g,i,H,L)char*S,*V;{for(V=malloc(8),H=strlen(S),c=g=-1;++g<H;){if(strchr(V,L=S[g]))continue;printf("%c ",V[c++]=L);for(i=-1;++i<H;printf(S[i]==L?"%d ":"",i));puts("");}}

Of course this is the longest answer here...
Try it online!

Where is the Java solution?

164 bytes

C#, 138 bytes
using System.Linq;s=>Console.Write(string.Join("\n",s.Distinct().Select(c=>c+string.Join("",s.Select((d,i)=>d==c?i:-1).Where(i=>i>-1)))));

F#, 120 bytes
let f s=s|>Seq.indexed|>Seq.groupBy(fun(a,b)->b)|>Seq.iter(fun(a,b)->
 printf"\n%c"a
 Seq.iter(fun(c,_)->printf"%i"c)b)

A more readable version:
let f s =
    s
    |> Seq.indexed
    |> Seq.groupBy (fun (idx, char) -> char)
    |> Seq.iter (fun (char, charIdxSeq) ->
         printf "\n%c" char
         Seq.iter (fun (idx, _) -> printf "%i" idx) charIdxSeq)

Seq.indexed creates a new sequence containing tuples which are composed of the original element and it's 0 based index in the original sequence.
The rest is fairly self explanatory which is never a good thing for golf!

Husk, 10 bytes
§mȯ§:;ms¥u

Try it online!
Note: Husk (or at least the command ¥) is newer than this challenge.
Explanation
§mȯ§:;ms¥u  Implicit input, say S = "ababbc".
         u  Remove duplicates: "abc"
§m          Map over this string:
             Argument is a character, say 'b'.
        ¥    1-based indices in S: [2,4,5]
      ms     Convert each to string: ["2","4","5"]
     ;       Wrap argument in a string: "b"
  ȯ§:        Prepend to list of index strings: ["b","2","4","5"]
            Result is a list of lists of strings
             [["a","1","3"],["b","2","4","5"],["c","6"]]
            Implicitly print, separating strings by spaces and lists by newlines.

J, 11 bytes
~.,.":@I.@=

Try it online!


text:
How do I exit Vim?
Vim is a great text editor for unix systems, but it's notorious for being difficult to exit.
Write a full program that will output :q to exit Vim. It should then read a single line of input, as it will then either be given a bash prompt, in which case the exit was successful, or an error, in which case there are unsaved changes.
The bash prompt will be this:
E37@vimmachine: /var/override)

While the error will be this:
E37: No write since last change (add ! to override)

Upon being given the bash prompt, the program's work is done, and it should not give any more output (except for whitespace).
Upon being given the error, your program should randomly (ie each possibility has a non-zero probability of being chosen) output :q!, to exit without saving, or :x, to save and exit.
This is code-golf so fewest bytes in each language wins!

I didn't know :x was a thing! I've always used :wq :)

What if my bash prompt is E37: No write since last change? That is, how can an algorithm distinguish a prompt from an error message?

@anatolyg it can't, but it also doesn't have to. The given prompt will always be the one above, that is E37@vimmachine: /var/override)

@Mayube Should there be a newline between ':q' and ':q!', or are we allowed to eliminate this?

@musicman523 nowhere in the spec does it say anything about requiring any newlines ;)

Can I use command-line args for the input line?

Why does the prompt end with a )?

The given prompt will always be the one above That should be stated in the challenge spec. As is, it says looks like this, which can mean any number of things.

This reminded me of the SO Blog Entry: Stack Overflow: Helping One Million Developers Exit Vim

Proposing to migrate to askubuntu! Probably it will get there even higher response '^.^

(joined golf for this comment, sheesh) @musicman523 NEVER use :x to exit vim. Someday you'll accidentally hit :X then random keys when you're confused. After you finally :wq you'll never see your file again.

@AaronMcMillin Welcome to PPCG! Let's continue this discussion in chat.

@AaronMcMillin I always save-and-exit with :x and I've never had a problem

@musicman523 I find that ZZ is by far the easiest way to save and exit vim.

Personally, I would do Ctrl+Z followed by kill -9 %%

Python 2, 66 bytes
Saved 3 bytes thanks to @Mr.Xcoder and 4 thanks to @Mayube!
from random import*
if'('in input(':q'):print choice([':x',':q!'])

Try it online!

If you switch to Python 2, you can save 1 bytes by using print  instead of print(). And you can take the input with quotes

@Mr.Xcoder Thanks, it actually saved me 3 bytes!

Yes, I didn't see you had 2 print statements

I gave this tip to totallyhuman so it's only fair I give it to you as well. You can remove print':q' altogether and change input() to input(':q')

@Mayube oh that's awesome, thank you!

the \n isn't necessary, the spec doesn't require a trailing newline

Ruby, 35 bytes
p:q
p %i(q! x)[rand 2]if/\(/=~gets

Try it online!

You can shave a byte by removing the space between p and :q ;)

awesome and weird! I didn't know that, thanks @ymbirtt

05AB1E, 19 bytes
„:q,'Nåi„:x…:q!‚.R,

Try it online!
„:q,                # Print the string ":q"
    'Nåi            # If N is in the input
        „:x         #   Push the string ":x"
           …:q!     #   Push the string ":q!"
               ‚    #   Wrap them into an array
                .R, #   Randomly print one of them

Vimscript, 45 41 bytes
ec"q"|exe"/("|ec["q!","x"][getpid()%2]

Shaved off 4 bytes by using getpid() to get a number. (Can anyone think of a shorter way to get a number that won't be the same everywhere, all the time?)
Assuming +3 bytes for invoking Vim with -c to run the above script and - to read input from stdin:
vim -c 'ec"q"|exe"/("|ec["q!","x"][reltime()[1]%2]' -

Python 2, 76 75 72 69 bytes
This answer has been out-golfed.
-1 byte thanks to Rod. -3 bytes thanks to Mayube. -3 bytes thanks to Artyer.
from random import*
print'::qx!'[random()>.5:('N'in input(':q'))*5:2]

Try it online!

This prints an extra newline where the challenge says it should not give any more output

@Mayube May we output a newline upon terminating? @Adám sure, that's fine

random()>.5 to save a byte

print'::qx!'[random()>.5:('N'in input(':q'))*5:2] saves three bytes

Ohh, that's clever. Thanks!

Does the randomness have to be uniformly distributed? If not, you could do random()>0, because there is a very very small chance that random() will return 0.

@Artyer You know what [0, 1) means, right? It means that zero is included because the range is zero-inclusive. https://stackoverflow.com/a/4396303/2415524 ...The easy way to remember it is that on a number line, closed dots are included, and open dots aren't. Brackets look closed, and parens look open.

@mbomb007 Huh. My mistake.

I have a 47 byte answer if we don't need uniform randomness.

@mbomb007 You don't need uniform randomness according to the challenge spec: each possibility has a non-zero probability of being chosen.

@mbomb007 Your suggestion of random()>0 brings about an interesting question. In mathematics, the probability of choosing any discrete quantity in a continuous range is 0 because, although it could at some point be chosen, there are an infinite number of such numbers, so the probability of each of them being chosen must be 0.

However in computer science, the representation format for floating point numbers is not infinite, meaning the range [0,1) is actually a discrete quantity. According to this StackOverflow answer, a number using IEEE754 format can represent 1023*2^52 numbers in the range [0,1), which means the probability of selecting 0 is 1/(1023*2^52). This is also discussed in this StackOverflow post.

C# (.NET Core), 140 139 138 bytes
using static System.Console;class P{static void Main(){Write(":q");if(ReadLine()[3]==':')Write(new System.Random().Next()>9?":x":":q!");}}

Try it online!

1 byte saved thanks to LiefdeWen!
1 byte saved thanks to Mord Zuber!

Placing your program in the System namespace makes you able to shorten System.Random to Random, saving 1 byte

@CarlosAlejo works for me in TIO, however it outputs q! not :q!

I don't see that they say a newline is needed after final output so cant you change C.WriteLine to C.Write?

@LiefdeWen namespace System is longer than what I saved by removing System.. About the newline, yes, I was considering removing that, thank you!

@Mayube oops, I slipped my fingers on the keyboard. I fixed it and removed the newlines after the commands, if that's OK.

@CarlosAlejo Ahh, I didn't even realize that you didn't use a namespace, the question also doesn't say uniformly random, just all possibilities should have non-zero chance so you change .Next(2)>0 to .Next()>9, it leaves a bit of a bad taste in the mouth but it's still legal.

using static System.Console lets you drop all C. calls, and saves you a byte

@MordZuber what the...? I didn't even know that was possible! Thank you!

><>, 32 30 29 bytes

Had a redundant !o.
-1 byte thanks to Aaron.

iii0["@!qx:q:"ooi{=?;o!ox~oo;

Try it online!
Explanation (old)
"@!qx:q:"ooi~i~i~i{=?;o!ox~oo;
"@!qx:q:"                        Push @!qx:q: on the stack (in reverse)
         oo                      Print :q [stack: @!qx:]
           i~i~i~                Remove first 3 input characters
                 i               Load @ or : from the input (= i)
                  {              Shift stack to the left [stack: !qx:i@]
                   =?            If 4th character was @
                     ;              Exit
                                 Else
                      o             Print :
                       !o           Jump to
                         x          Random direction (left or right because
                                    up and down retrigger x)
                                       Left:
                     ;o!o                 Print x and exit.
                                       Right:
                          ~oo;            Remove x, print q! and exit.

(will update soon)

I'm not sure this would be allowed, but you could win one byte by reading the 3 characters to discard first, then start working on a new stack with [ : iii0[ wil leave you with an empty stack ; nice one anyway, I like how you populate all your possible outputs at the start to avoid additional quotes

@Aaron Thanks, that's a very neat trick! Why wouldn't it be allowed?

Because you'd be reading the input before having printed the output that leads to its production, which I suppose goes against the spirit of the challenge. However it's not like the challenge can realistically implemented with the official ><> interpreter since python will wait for the input's EOF before executing the ><> code (or something like that)

JavaScript, 52 46 bytes
Saved 6 bytes thanks to @ETHProductions
prompt(':q')[30]&&alert(new Date%2?':q!':':x')

Doesn't there need to be a ! after the :q if the input is an error?

@Shaggy aww, didn't notice that, there goes 9 bytes

I think you can save a few bytes with prompt(':q')[30]&&.... Also, new Date%2?':x':':q!'

@ETHproductions oh yeah, thanks! not sure how I overlooked a ternary

Actually, 27 bytes
":q"ü[":x",":q!"]`⌂`J'!,cIƒ

Try it online! (Note: As TIO doesn't play nice with stdin, I've replaced the , (read from stdin) with the literal string, which you can change to test it. Also, you'll need to disable output cache in order to get a different response with the random output.)
Explanation:
":q"ü[":x",":q!"]`⌂`J'!,cIƒ
":q"ü                       - Push the literal :q and print
     [":x",":q!"]           - Push the list of literals :x and :q!
                 `⌂`J       - Push function literals ⌂ (terminate) and J (choose random element from list)
                     '!     - Push the literal !
                       ,    - Read from stdin
                        c   - Pop top two values a,b and return "a".count(b)
                         I  - Pop top three values a,b,c and return b if a is truthy and c if a is falsy
                          ƒ - Pop a function from the stack and call it

APL (Dyalog), 27 bytes
':q'⋄('!'∊⍞)/':q!' ':x'⊃⍨?2

Try it online!
':q' print this
⋄ then
?2 random integer among the first two
⊃⍨ use that to select from
':q!' ':x' this list of two strings
(…)/ replicate that with, i.e. make n copies of each element in that, where n is
 '!'∊⍞ is exclamation point a member of the text input? (Boolean, i.e. 0 or 1)

JavaScript, 76 71 50 bytes
prompt(":q")[3]<"@"?alert(new Date%2?":q!":":x"):0

Saved a bunch of bytes thanks to Artyer and Neil, as well as condensing my ternaries and moving first alert to prompt (duh).

Why not just call prompt() directly? (Also, are you allowed prompt(":q")?)

You can use the time as a random number (new Date%2 instead of Math.random()>.5), and you can use prompt directly like @Neil said: prompt()[3]<

@Neil Why? I had been doing a .indexOf on it, before I noticed the other way to do it. Forgot to switch back, thanks!

@Artyer thanks, I had thought of that and then forgot about it

Batch, 98 bytes
@echo :q
@set/ps=
@if %s:~3,1%==@ exit/b
@set/an=%random%%%2
@if %n%==0 (echo :x)else echo :q!

Ruby, 33 bytes (32 code, +1 for -n flag)
p:q;$_[?!]? p([:q!,:x][$$%2]): p

I'm not too sure on the $$%2 snippet. I'm using it to generate a random bit to index my array by taking the current ruby process's pid modulo 2, and it'll be fairly unpredictable. .sample adds an extra byte.
Try it online!

Python 2, 64 bytes
import time
if'w'in input(':q'):print'::qx!'[time.time()%2>1::2]

Try it online!
Since this is just an agglomeration of both of these Python answers, I've marked this as community wiki.

Python 2, 47 bytes
print'::qx!'[id(0)%3<2:('N'in input(':q'))*5:2]

Try it online
Explanation:
The source of randomness is id(0)%3<2. The function id returns the memory location of the parameter. Passing anything will give a non-deterministic memory address. The result will always be even, but it will only sometimes be divisible by 3. The results modulo 3 vary. So, this can be a source of randomness. Using <2 means that roughly 2/3 of the time, the resulting boolean is True.
The rest of the answer is inspired by this one.

Keg, 14 12 bytes
\:~2%[q\!|x]

This pushes a random number and outputs corresondingly to the random number.

LOGO, 37 36 bytes
pr[:q]if 4<count rl[pr pick[:q! :x]]

Try it online at Anarchy Golf Performance checker.
Explanation:
pr[:q]if 4<count rl[pr pick[:q! :x]]   Main program.
pr                                     Print
  [:q]                                 the list `[:q]` without delimiter `[]`
      if           [              ]    If...
         4<                            4 is less than...
           count                       the number of word in the...
                 rl                    ReadLine (from stdin),
                    pr                 print
                       pick            a random word picked from the list...
                           [:q! :x]    [:q! :x]

(because E37@vimmachine: /var/override) has 2 words, while E37: No write since last change (add ! to override) has 10 words)

An explanation would be great.

TCL, 95 bytes
puts :q;puts [if [string match *!* [gets stdin]] {puts [lindex ":q! :x" [expr round(rand())]]}]

A simple and rather long solution in tcl...

Assembly 86Bytes Linux System Calls
global _start
_start:
mov edx,4
mov ecx,g
mov ebx,1
mov eax,4
int 0x80
g db ':q!',10

Perl 5 (with -E flag), 35 bytes
say":q";<>=~l&&say qw(:q! :x)[$$%2]

Run this with perl -E 'say":q";<>=~l&&say qw(:q! :x)[$$%2]'.
Try it online!
Ungolfed:
say(":q");
if(<> =~ /l/){ #read a line and check if it contains 'l'
    @a=(":q!",":x");
    say($a[$$ % 2]); #print one element from array based on PID
}

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


text:
ASCII Reverse Quine
Okay, so everyone is familiar with the ASCII-table, correct? I'd hope so. I've been going to that site for my asciitable reference for as long as I can remember needing one. We'll be doing some fun source-code manipulating using the ASCII keyspace.

The Task
Your task is to write a program that, when executed, prints the source code with the ASCII decimal of each character reversed. What exactly does this mean? Say this was my sourcecode:
#;

The ASCII of this would be:
(35)(59)

After knowing this, we should reverse each to get what the program should output:
(53)(95)

Which means for a program of #; we need to output:
5_

Constraint 1 (Important)
However, like in most challenges, there's a hefty catch. All characters in your source code must be within the printable ASCII range. If the reverse of the ASCII character does NOT lie within 32-128, the character can't be used. For any character with an ASCII code greater than 100, you will reverse it and use the first two digits. For instance:
d = 100 => 001 => 00 => \0 => non-ASCII => invalid

Another example, of a valid 3-digit ASCII reverse:
{ = 123 => 321 => 32 => ' ' => valid

If this is unclear, see the "Conversion" part below, if the character is not listed there on the left, it cannot be in your source code.

Constraint 2 (Important)
In addition to this constraint, the user must also use at least one non-palindromic ASCII character. This means that if you want to use 7, which is ASCII 55 and converts directly TO 7, you will have a 2-byte answer at minimum.

Constraint 3
Your program will take no input, as this is a quine challenge. In addition to this, it must adhere to the specifications of a proper quine defined here:
http://meta.codegolf.stackexchange.com/questions/4877/what-counts-as-a-proper-quine

The Concrete Specification
Printable ASCII Set (32-126):
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Conversions:
  => 23 => (not valid)
! => 33 => ! (valid)
" => 43 => + (valid)
# => 53 => 5 (valid)
$ => 63 => ? (valid)
% => 73 => I (valid)
& => 83 => S (valid)
' => 93 => ] (valid)
( => 04 => (not valid)
) => 14 => (not valid)
* => 24 => (not valid)
+ => 34 => " (valid)
, => 44 => , (valid)
- => 54 => 6 (valid)
. => 64 => @ (valid)
/ => 74 => J (valid)
0 => 84 => T (valid)
1 => 94 => ^ (valid)
2 => 05 => (not valid)
3 => 15 => (not valid)
4 => 25 => (not valid)
5 => 35 => # (valid)
6 => 45 => - (valid)
7 => 55 => 7 (valid)
8 => 65 => A (valid)
9 => 75 => K (valid)
: => 85 => U (valid)
; => 95 => _ (valid)
< => 06 => (not valid)
= => 16 => (not valid)
> => 26 => (not valid)
? => 36 => $ (valid)
@ => 46 => . (valid)
A => 56 => 8 (valid)
B => 66 => B (valid)
C => 76 => L (valid)
D => 86 => V (valid)
E => 96 => ` (valid)
F => 07 => (not valid)
G => 17 => (not valid)
H => 27 => (not valid)
I => 37 => % (valid)
J => 47 => / (valid)
K => 57 => 9 (valid)
L => 67 => C (valid)
M => 77 => M (valid)
N => 87 => W (valid)
O => 97 => a (valid)
P => 08 => (not valid)
Q => 18 => (not valid)
R => 28 => (not valid)
S => 38 => & (valid)
T => 48 => 0 (valid)
U => 58 => : (valid)
V => 68 => D (valid)
W => 78 => N (valid)
X => 88 => X (valid)
Y => 98 => b (valid)
Z => 09 => (not valid)
[ => 19 => (not valid)
\ => 29 => (not valid)
] => 39 => ' (valid)
^ => 49 => 1 (valid)
_ => 59 => ; (valid)
` => 69 => E (valid)
a => 79 => O (valid)
b => 89 => Y (valid)
c => 99 => c (valid)
d => 001 => (not valid)
e => 101 => (not valid)
f => 201 => (not valid)
g => 301 => (not valid)
h => 401 => ( (valid)
i => 501 => 2 (valid)
j => 601 => < (valid)
k => 701 => F (valid)
l => 801 => P (valid)
m => 901 => Z (valid)
n => 011 => (not valid)
o => 111 => (not valid)
p => 211 => (not valid)
q => 311 => (not valid)
r => 411 => ) (valid)
s => 511 => 3 (valid)
t => 611 => = (valid)
u => 711 => G (valid)
v => 811 => Q (valid)
w => 911 => [ (valid)
x => 021 => (not valid)
y => 121 => (not valid)
z => 221 => (not valid)
{ => 321 =>   (valid)
| => 421 => * (valid)
} => 521 => 4 (valid)
~ => 621 => > (valid)

ESOLANGS: If you're using a custom CODEPAGE and wish to use the CODEPAGE definition as the ASCII table, I'll allow it. But you must be thorough in your explanation of why the characters are enumerated as they are (and it must make sense based on an existing code-page diagram). According to this 31/96 (32%) conversions are invalid, therefore it should follow that for a codepage of 255 characters, a consecutive range of 96 characters can be considered as "printable ASCII" if, and only if, it results in 31 (or 32%) or more of those characters being invalid.

This is code-golf, lowest byte-count wins.

@Mayube you should have no input to your program.

Here's a conversion script for verification.

Do our proper quine rules apply for this challenge? Otherwise, some languages might have solutions that are effectively literal-only answers (e.g. T in CJam prints 0, because T happens to be a variable that is initialised to zero).

@MartinEnder I've changed constraint 2 slightly, but I figured a conversion table would be a solid specification of what exactly can and cannot be done.

@MartinEnder I thought that was standard for all quine challenges ._.

Japt has a one byte solution with T too.

@JonathanAllan It just occurred to me that Retina has two 1-byte solutions that aren't actually literal-only (T and ^ both work), but they still fail the proper quine rules (necessarily, because the a single-byte solution can't have a part of the code encode a different part).

I was attempting to mitigate 1 byte quines with the "cannot use a palindromic character". It sat in the sandbox over the weekend, I wish you'd seen it then :(. Oh well, hopefully adding that proper quine part will handle the rest of the trivial answers.

Oh... this is my question.

CJam, 24 bytes
{s"_~"+{isW%Y60c~ic}%}_~

Try it online!
Prints:
 3+;>+" 23NIb-Tc>2c4I4;>

A fairly standard generalised quine. The only character we could have used that is forbidden is <, which we get with 60c~ instead.


text:
You are the Host of the Olympics!
You host the Olympic Games, and need to build a fantastic pool for the sake of the occasion, but the supervisors often change their mind regarding the dimensions, and need a quick way to rebuild it with the requested size!

Given two integers, L and x, your task is to build a swimming pool of length L and x lanes.
How is a pool built?

It contains an inner square, whose horizontal walls are made of L consecutive dashes(-) , and whose vertical walls are made out of 3x - 1 bars (|). Additionally, 4 + signs lie in each corner. Let's have an example (L = 10, x = 2):

+----------+
|          |
|          |
|          |
|          |
|          |
+----------+

Each lane has a width of 2 vertical units. The inner square is filled with x-1 lane separators, consisting of L horizontally consecutive : symbols. After putting the lane separators, our pool should look like this:

+----------+
|          |
|          |
|::::::::::|
|          |
|          |
+----------+

A pool also contains a padding (an outer square), whose horizontal walls are (L+4) -s and whose vertical walls are (3x + 1) |s, that surrounds the inner square:

+--------------+
| +----------+ |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| +----------+ |
+--------------+

And that's our olympic-sized** swimming pool!

Specs:

For design and functionality purposes, you are guaranteed that 100 ≥ L ≥ 10 and 15 ≥ x ≥ 2.
The output must be exactly as shown. Outputting a "vertically-built"* pool is disallowed.
Trailing and leading spaces are allowed.
You may take input and provide output through any standard method.
Default Loopholes apply.

Examples / Test cases:

L = 20, x = 3

+------------------------+
| +--------------------+ |
| |                    | |
| |                    | |
| |::::::::::::::::::::| |
| |                    | |
| |                    | |
| |::::::::::::::::::::| |
| |                    | |
| |                    | |
| +--------------------+ |
+------------------------+

L = 50, x = 5:

+------------------------------------------------------+
| +--------------------------------------------------+ |
| |                                                  | |
| |                                                  | |
| |::::::::::::::::::::::::::::::::::::::::::::::::::| |
| |                                                  | |
| |                                                  | |
| |::::::::::::::::::::::::::::::::::::::::::::::::::| |
| |                                                  | |
| |                                                  | |
| |::::::::::::::::::::::::::::::::::::::::::::::::::| |
| |                                                  | |
| |                                                  | |
| |::::::::::::::::::::::::::::::::::::::::::::::::::| |
| |                                                  | |
| |                                                  | |
| +--------------------------------------------------+ |
+------------------------------------------------------+

L = 10, x =15

+--------------+
| +----------+ |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| |::::::::::| |
| |          | |
| |          | |
| +----------+ |
+--------------+

This is code-golf, so the shortest code in bytes wins!
*The water could flow out if it is built vertically :P
**Yes, I am aware that the more the lanes are and the shorter the pool is, the less the drawing looks like a pool!

Sandbox, for those who can view deleted posts.

What should happen if x>=L??

@CraigR8806 The same algorithm. Just with more lanes than the length of the pool. I have a feeling that you have mistread the question...

What about the case where L=10 and x=15? Would there not be more lanes than could be placed in the pool?  I could be misunderstanding the intent

@CraigR8806 The length has nothing to do with the lanes! You can test it yourself with one of the existing answers

@CraigR8806 Added a test case on that

Sorry, I now see where I misunderstood the question.

Let us continue this discussion in chat.

I hate these kind of problems.

Why is that @pagie_ ??

@Mr.Xcoder  I've tried to do them in Python. They frustrate me, especially when the user has to input the size of the shape.

You forgot to say if a full program was required or a function will do.

@DavidConrad "You can take input and provide output by any standard method". That includes both functions and programs.

Charcoal, 32 bytes
ＮθＮη↓Ｅθ×η:  Ｂ⁺θ²⁺×³η¹↖←Ｂ⁺θ⁶⁺×³η³

Try it online!
-4 thanks to Neil.
AST:
Program
├Ｎ: Input Number
│└θ: Identifier θ
├Ｎ: Input Number
│└η: Identifier η
├Print
│├↓: Down
│└Ｅ: Map
│ ├θ: Identifier θ
│ └×: Product
│  ├η: Identifier η
│  └':  ': String ':  '
├Ｂ: Box
│├⁺: Sum
││├θ: Identifier θ
││└2: Number 2
│└⁺: Sum
│ ├×: Product
│ │├3: Number 3
│ │└η: Identifier η
│ └1: Number 1
├Move
│└↖: Up Left
├Move
│└←: Left
└Ｂ: Box
 ├⁺: Sum
 │├θ: Identifier θ
 │└6: Number 6
 └⁺: Sum
  ├×: Product
  │├3: Number 3
  │└η: Identifier η
  └3: Number 3

wow Charcoal has got this challenge down :)

You stayed true to your name - you have me outgolfed.

As usual, explanation request.

@CalculatorFeline Yeah, I don't have time to do all those explanations while I'm seeking something to outgolf...also you can check the AST using the -a command-line argument.

why does -a raise error >_<

32 bytes: ＮθＮη↓Ｅθ×η:  Ｂ⁺θ²⁺×³η¹↖←Ｂ⁺θ⁶⁺×³η³.

@Neil Doesn't seem to work...

@EriktheOutgolfer SO comments collapse consecutive spaces, as you would have noticed if you'd checked the apparent byte count of the string ;-)

Charcoal, 40 39 37 bytes
ＮθＮηＢ⁺θ⁶⁺×³η³↘→Ｂ⁺θ²⁺×³η¹→Ｆ⁻η¹«Ｍ³↓Ｐ×:θ

Try it online!
I know Neil already has a Charcoal answer of around the same length, but I took a bit of a different approach so I figured I may as well also post mine.
Explanation
ＮθＮηＢ⁺θ⁶⁺×³η³↘→Ｂ⁺θ²⁺×³η¹→Ｆ⁻η¹«Ｍ³↓Ｐ×:θ
ＮθＮη                                         take the two inputs as numbers in θ and η
      Ｂ⁺θ⁶⁺×³η³                               draw a rectangle θ + 6 by 3η + 3
                                               (characters default to |, - and +)
                ↘→                             move the cursor down one and right two
                   Ｂ⁺θ²⁺×³η¹                  draw a rectangle θ + 2 by 3η + 1
                             Ｆ⁻η¹«            for ι (unused) from 0 up until η - 1:
                                   Ｍ³↓            move the cursor down by 3
                                       Ｐ×:θ       print θ :s without moving the cursor
                                               [implicit end of for]

Explanation please.

@CalculatorFeline Added.

Huh, so the third parameter to Ｂ is optional? Nice, that saves me two bytes!

Charcoal, 40 38 36 31 bytes
Ａ⁺²ＮθＡ⁺¹×³ＮηＵＯθη:¶¶Ｂθη↖←Ｂ⁺⁴θ⁺²η

Try it online! Link is to verbose version of code. Explanation:
Ａ⁺²Ｎθ       Assign(Plus(2, InputNumber()), q);

Charcoal's drawing primitives use the overall character count including +s, however the input is just the number of -s, so we need to add 2 to obtain the width of the inner wall.
Ａ⁺¹×³Ｎη     Assign(Plus(1, Times(3, InputNumber())), h);

Calculate the height of the inner wall, again, inclusive of the bottom row, so three per lane plus one.
ＵＯθη:¶¶     Oblong(q, h, ":\n\n");

Draw the lanes. This is simply a rectangle filled with :s vertically separated by two blank lines (the pilcrows represent newline characters).
Ｂθη         Box(q, h);

The Rectangle command is exactly what we need to draw the inner wall. Edit: Box allows you to omit its third parameter, saving me 2 bytes.
↖           Move(:UpLeft);
←           Move(:Left);
Ｂ⁺⁴θ⁺²η     Box(Plus(4, q), Plus(2, h));

And again to draw the outer wall, except slightly wider and taller, and centred on the inner wall.

Why are the links to Charcoal code at TIO never to the actual code?

@JonathanAllan I link to the verbose code because it's more readable, plus I add the argument to generate the succinct code automatically for verification purposes.

...but how is 219 characters more readable than 40? :p

I could have just looked harder and noticed this tip :)

As usual, please explain.

Somewhat. A full codeblock of explanation would be optimal, however.

@CalculatorFeline Bah, just as soon as I write an explanation I find a 1-byte golf, and now I'm going to need a new explanation...

RIP explanation. Also, can you include concise code in the explanation?

@CalculatorFeline New golf, new explanation!

Congrats on tying me :)

@EriktheOutgolfer If only the 3-argument version of Box didn't move the cursor I'd be down to 35 bytes, sigh...

JavaScript (ES6), 137 124 bytes
Golfed it down a bit on my phone, more to follow.
x=>y=>`+--0--+
| +0+ |
${((a=`| |1| |
`)+a+`| |2| |
`).repeat(y-1)+a+a}| +0+ |
+--0--+`.replace(/\d/g,n=>"- :"[n].repeat(x))

Try it

f=
x=>y=>`+--0--+
| +0+ |
${((a=`| |1| |
`)+a+`| |2| |
`).repeat(y-1)+a+a}| +0+ |
+--0--+`.replace(/\d/g,n=>"- :"[n].repeat(x))
oninput=_=>o.innerText=f(+i.value)(+j.value);o.innerText=f(i.value=50)(j.value=5)
input{font-family:sans-serif;margin:0 5px 0 0;width:50px;}
<label for=i>L: </label><input id=i type=number><label for=j>x: </label><input id=j type=number><pre id=o>

I like this one because it's interactive :D

@xDaizu, check out some of my other JS solutions, so ;)

T-SQL, 284 281 bytes
DECLARE @ INT,@x INT,@S VARCHAR(MAX)='+--d--+b| +d+ |b'SELECT @=L,@x=x FROM t
P:SET @S+='| |s| |b| |s| |b| |c| |b'SET @x-=1IF @x>0GOTO P
PRINT REPLACE(REPLACE(REPLACE(REPLACE(LEFT(@S,LEN(@S)-6)+'+d+ |b+--d--+','d',REPLICATE('-',@)),'b',CHAR(13)),'s',SPACE(@)),'c',REPLICATE(':',@))

Input is taken from INT columns L and x in preexisting table t, per our allowed input methods.
Basically I'm creating a long string with letters representing the repeated characters (d=dashes, s=spaces, c=colons, b=line break), then REPLACE them all at the end with the appropriate fillers.
Formatted:
DECLARE @ INT,@x INT,@S VARCHAR(MAX)='+--d--+b| +d+ |b'
SELECT @=L,@x=x FROM t
P:
    SET @S+='| |s| |b| |s| |b| |c| |b'
    SET @x-=1
IF @x>0 GOTO P
PRINT REPLACE(REPLACE(REPLACE(REPLACE( LEFT(@S,LEN(@S)-6)+'+d+ |b+--d--+'
     ,'d',REPLICATE('-',@))
     ,'b',CHAR(13))
     ,'s',SPACE(@))
     ,'c',REPLICATE(':',@))

Inside the loop I append 2 rows of blanks and 1 row of colons, then at the end I chop off that divider row and append the pool border before performing the replaces.
EDIT: Saved 3 bytes by switching @ to the most-often used variable, and swapping initialization order.

Python 2, 124 120 117 bytes
-2 bytes thanks to Hyper Neutrino

l,x=input()
o='+--%s--+\n| +%s+ |\n'%(('-'*l,)*2)
print o+'| |%s| |\n'*(x*3-1)%((' '*l,' '*l,':'*l)*x)[:-1]+o[-2::-1]

Try it online!

122 bytes (your variable t is unnecessary)

Python 2, 128 126 bytes
L,x=input()
k='+'+'-'*(L+4)+'+\n| +'+'-'*L+'+ |\n'
f=lambda k:'| |'+k*L+'| |\n'
print k+f(':').join([f(' ')*2]*x)[:-1]+k[::-1]

Try it online!
-2 bytes thanks to @Mr.Xcoder

126 bytes

@Mr.Xcoder Right, thanks, I don't know what I was thinking with those extra brackets :P

SOGL V0.12, 52 51 bytes
:┌* +1Ο;@*┐1ΟG∙⁴++⁰
b3*Ie4+⁰b3*He⁰32žbH∫3*2+4;e :*ž

Try it Here!
Not bad considering that 20 bytes of this is a rectangle function, which charcoal has a built-in for.
Explanation:
Rectangle function: (example: on stack 4, 2)
:                   duplicate the top of stack (X pos)      [4, 2, 2]
 ┌*                 get that many "-"es                     [4, 2, "--"]
    +               push "+"                                [4, 2, "--", "+"]
     1Ο             wrap the dashes in pluses               [4, 2, "+--+"]
       ;            get the duplicated X position           [4, "+--+", 2]
        @*          get that many spaces                    [4, "+--+", "  "]
          ┐         push "|"                                [4, "+--+", "  ", "|"]
           1Ο       wrap the spaces with "|"                [4, "+--+", "|  |"]
             G      get the Y value ontop                   ["+--+", "|  |", 4]
              ∙     get an array with that many strings     ["+--+", ["|  |", "|  |", "|  |", "|  |"]]
               ⁴    duplicate the dashes wrapped in pluses  ["+--+", ["|  |", "|  |", "|  |", "|  |"], "+--+"]
                ++  add everything to one array             [["+--+", "|  |", "|  |", "|  |", "|  |", "+--+"]]
Main function: (example input: 2, 5)
b3*                              push variable B (input 1, Y length) multiplied by 3                     [6]
   I                             increase it                                                             [7]
    e4+                          push variable E (input 2, X length) + 4                                 [7, 9]
       ⁰                         execute the rectangle function [in X: E+4, Y: b*3+1]                    [["+---------+","|         |","|         |","|         |","|         |","|         |","|         |","|         |","+---------+"]]
        b3*                      push variable B * 3                                                     [["+---------+",..,"+---------+"], 6]
           H                     decrease it                                                             [["+---------+",..,"+---------+"], 5]
            e                    push variable E                                                         [["+---------+",..,"+---------+"], 5, 5]
             ⁰                   execute the rectangle function [on X: E, Y: B*3-1]                      [["+---------+",..,"+---------+"], ["+-----+","|     |","|     |","|     |","|     |","|     |","+-----+"]]
              32ž                at coordinates [3;2] (1-indexed) in the first rectangle put in the 2nd  [["+---------+",
                                                                                "| +-----+ |",
                                                                                "| |     | |",
                                                                                "| |     | |",
                                                                                "| |     | |",
                                                                                "| |     | |",
                                                                                "| |     | |",
                                                                                "| +-----+ |",
                                                                                "+---------+"]
                 bH∫             iterate over the numbers from 1 to B-1:                                 [[...], 1]
                    3*2+           push pop()*3+2                                                        [[...], 5]
                        4;         push 4 one below the stack                                            [[...], 4, 5]
                          e        push the variable E (X length)                                        [[...], 4, 5, 5]
                            :*     get that many colons                                                  [[...], 4, 5, ":::::"]
                              ž    insert [at coordinates [4; cIter*3+2] the colons]

C# (.NET Core), 202 bytes
(L,x)=>{char p='+',n='\n',e=' ';string v="|",r="",s=p+new string('-',L+4)+p+n,q=v+e+p+new string('-',L)+p+e+v+n;r+=s+q;for(int i=0;i<3*x-1;)r+=v+e+v+new string(i++%3<2?e:':',L)+v+e+v+n;r+=q+s;return r;}

Try it online!

PHP, 153 bytes
for(;$i-2<$z=3*$argv[2]+1;$i++)echo str_pad(strrev($r=["--+","+ |","| |"][!($b=$i>1&$i<$z)?$i&&$i<$z+1?1:0:2]),$argv[1]+3,"- :"[$b?$i%3!=1?1:2:0])."$r
";

Try it online!

Python 2, 97 bytes
L,x=input()
for i in'01'+'223'*~-x+'2210':r=('+|||-   -+||'+L*'-- :')[int(i)::4];print r+r[2::-1]

Try it online!

Python 2, 98 bytes
L,x=input()
s='+---| +-%s+-+---'%'|:'.join(['| '*5]*x)
while s:print s[:3]+s[3]*L+s[2::-1];s=s[4:]

Try it online!

Charcoal, 36 bytes
ＮθＮηＦη«Ｍ³↑Ｐ×θ:»←Ｂ⁺θ²⁺×³η¹↖←Ｂ⁺θ⁶⁺×³η³

Try it online!
This is a more Charcoal-y algorithm than my other answer.

Charcoal has officially taken over the whole challenge. 4/10 answers are in Charcoal...

@Mr.Xcoder Well, it's a language specifically designed to golf ascii-art, so that's what you get for it. ;)

Explanation request.

@Mr.Xcoder And three of them are the same length too!

C (gcc), 195 bytes
#define P printf
y;f(L,l){char s[L+1],t[L+1];memset(s,45,L);memset(t,58,L);t[L]=s[L]=0;P("+-%s-+\n|+%s+|\n",s,s);for(y=3*l;y-->1;y%3?P("||%*c||\n",L,32):P("||%s||\n",t));P("|+%s+|\n+-%s-+",s,s);}

Try it online!

Perl 5, 124 + 1 (-a) = 125 bytes
say$o='+'.'-'x($l=pop@F),$t="----+
",$i="| $o+ |
",$e=($d="| |").$"x$l.$d,$/,$e;say$d.':'x$l."$d
$e
$e"for 2..$_;say$i,$o,$t

Try it online!

APL (Dyalog Unicode), 72 bytes
{g' '∘,∘⌽∘⍉⍣4(g←{'+'@(⊂1 1)∘⌽∘⍉⍣4⊃(⍪∘⌽∘⍉)/'-|-|',⊂⍵})↑(¯1+3×⍵)⍺⍴⍺/'  :'}

Try it online!
A function that takes L on the left and x on the right.

Haskell, 111 bytes
r=replicate
a?b=a++b++reverse a
l!x=unlines$map(?r l '-')["+--","| +"]?map("| |"?)(tail$concat$r x$r l<$>":  ")

Try it online!