text:
Y2K... in 2019?
It's August 10th, 2019, but your task still involves Y2K. Weird, right?
Create a program that prints itself, with a two digit number appended to it. The first time you run it, it should append 00 to its output (its source code, because this is a quine variant). When you run that output, the original program without a two digit number, it should output the original program, but with 01 appended to it. Run that output to get the OG program with 02 appended, then that to get the program with 03... This chain should  continue until 99. That program should output BREAKING NEWS: WORLD ENDS.
If your program is Y2Kparanoia: yes then:

It should output Y2Kparanoia: yes00
That output should print Y2Kparanoia: yes01
That output should print Y2K paranoia: yes02
Repeat until step 100: this program outputs the doomsday news specified

This is code golf, so the shortest program that can print itself while following these steps wins.

According to the description the 99th time we run we'll be running 2Kparanoia: yes97 and producing 2Kparanoia: yes98, so shouldn't (4) read Repeat to step 100, but step 101 will output "BREAKING NEWS: WORLD ENDS"? (i.e. 2Kparanoia: yes99 produces the news)

It sounds weird starting a challenge with time-telling. That reminds me of "It's 8 A.M! Wake up immediately!"

Pyth, 81 80 bytes
.vh,K"?>J198\"BREAKING NEWS: WORLD ENDS\"s[\".vh,K\"N:KN+C92NN\"J\"?<J2*TT+J1"J1

Try it online!
Explanation:
.vh,K" ... "J1
.v               Eval pyth code
  h              Get the first item in list
   ,             Make a list of the next two items
            J1   Set J = 1 (J = 100 to 199 in future iterations)
    K" ... "     Set K to the given string

And the code in the string is (breaking news shortened):
?>J198"BNWE"s[".vh,K"N:KN+C92NN"J"?<J2*TT+J1
?                                              Ternary: If A then B else C
 >J198                                         Test if J > 198
      "BNWE"                                   String literal; If ternary was true, return this (which is then implicitly printed)
            s[".vh,K"N:KN+C92NN"J"?<J2*TT+J1   ternary else
            s                                  concatenate list of strings
             [                                 create list
              ".vh,K"                          string literal, list[0]
                     N                         N is set to the double-quote character, list[1]
                      :KN+C92N                 list[2]
                      :                        Regex substitution. In A, replace B with C
                       K                       Variable K (set to the string being eval'd)
                        N                      N is double-quote
                         +C92N                 A backslash followed by a double-quote
                         +                     concat two strings
                          C92                  character with code point 92 (backslash)
                             N                 N is double-quote
                              N                N is double-quote, list[3]
                               "J"             String literal, list[4]
                                  ?<J2*TT+J1   Inner ternary, list[5]
                                   <J2         If J < 2 ..
                                      *TT      return T * T (10 * 10), else
                                          +J1  return J+1

Ruby, 158 154 146 128 122 100 bytes
Inspired by this answer.
eval s=%{$><<(D>198?'BREAKING NEWS: WORLD ENDS':'eval s=%%{%s}<<D=%d'%[s[0..-2],D<2?100:D+1])#}<<D=1

EDIT: I was able to remove (s.split(35.chr)[0]+35.chr).inspect and replace it with s[0..-2] (range of every value except the last) and the %{ ... } string syntax I used before. Saved 22 bytes!
Old version:
EDIT: Saved a pair of parens (and corresponding pair in the data section) by realizing that "BREAKING NEWS: WORLD ENDS" is a perfectly valid format string, and ruby ignores any extraneos parameters.
END{$><<(q=S>198?"BREAKING NEWS: WORLD ENDS":%{END{$><<(q=S>198?"BREAKING NEWS: WORLD ENDS":%%{%s})%%[q,S<2?0:S-99]}
S=1%02d})%[q,S<2?0:S-99]}
S=1

When starting this I realized that since the number has to go at the very end of the program, and ruby doesn't allow using variables before they are declared, I would have to make code run after the digits somehow. I could've done something like def a(s) ... end;a 1 which would become ...end;a 100, however using ruby's lesser-known END syntax uses fewer bytes. However, the block inside END is in a different scope, so S must be a global variable or constant.
Explanation:

END{ ... };S=1: Run block of code just before program terminates; Set constant S to 1 (or 100 - 199 in future iterations)
$><<( ... ): $> is a shortcut in ruby for stdout, and << on an IO writes to the IO. The parens are required, otherwise it becomes ($><<S)>198...
S>198?"BREAKING NEWS: WORLD ENDS":(q=...)%[q,S<2?0:S-99]: If I were to break this out into slightly more reasonable code it would be:
if S > 198
  "BREAKING NEWS: WORLD ENDS"
else
  q = ...
  number_to_append = if S < 2
    0
  else
    S - 100 + 1
  end
  q % [q, number_to_append]
end

The % operator applied to a string is effectively printf, with the LHS being the format string and the RHS being the arguments.
%{ ... (q=%%{%s}) ... S=1%02d}: ruby has an interesting syntax for strings that also allows for pairs of curly brackets to appear within the string without any escaping as long as they are balanced. This is very helpful, as otherwise a similar quine would have to escape the string to put it into itself as a string literal. The two substitutions in the format string are %s for a regular string and %02d for a number right-padded to a size of 2 with the character 0.

My thoughts on shortening further:

It'd be nice to be able to use s instead of $s, but defining s s=$s; or making a function def a(s) ... both use more bytes than they save, and I can't think of any other way to do it. EDIT: Constants are global and can be one character!
It'd be nice if S was always less then 100, so that it could be compared using 2-digit numbers instead of 3-digit numbers. However, if I use S=0 at the end, the next two digits are interpreted as octal, and 8 and 9 are invalid and all is bunk. S= simply isn't valid, and I don't know any other way to make a value valid both before and after appending two digits. Of note, 0 (and every other integer) is truthy in ruby.

Any thoughts on how to make this shorter, please let me know!
Try it online!

Maybe if you used s=100-1? Then s will be 99, 0, -1...-99, and -s will be -99, 0...99.

@PurpleP No matter how I try I can't figure any way to do that and save characters.

Perl 6, 122 114 106 bytes
-8 bytes thanks to Shelvacu
END {<print $!-199??"END \{<$_>~~.EVAL};\$!="~($!-1&&$!-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};$!=1

Try it online!
Takes the standard quine format and adds the breaking news string as well as a new function call with the appended number. This uses END to execute the function when the program ends.

You can save 3 more bytes by using END and an our variable: END {<print $s-199??"END\{<$_>~~.EVAL};our\$s="~($s-1&&$s-99)+100!!"BREAKING NEWS: WORLD ENDS">~~.EVAL};our$s=1

For now, this is the current winner.

Go, 382 366 354 340 305 298 272 bytes
Won't win but I had fun with the challenge.
package main
func main(){if n<199{s+="\x60,"
print(s[:135],s,100+(n/100)*(n%100+1))}else{print("BREAKING NEWS: WORLD ENDS")}}
var s,n=`package main
func main(){if n<199{s+="\x60,"
print(s[:135],s,100+(n/100)*(n%100+1))}else{print("BREAKING NEWS: WORLD ENDS")}}
var s,n=`,1

Try it on the Go Playground!
Based on a quine. If the variable n is less than 199, then it adds to the string variable n a grave accent (\x60), Go's character for multiline strings, followed by a comma ,. It continues by printing the first 147 characters of s (to prevent printing the , because that only occurs at the end) then prints s as a whole, and finally prints 100 if n == 1 and n+1 otherwise. The result is that successive runs change the variable n at the end of the program to 100, 101, etc. If the variable n is 199 or more, then it prints breaking news.

Haskell, 240 232 218 216 bytes
p=putStr;h 1=100;h k=k+1;g _=p$"n="++show(h n);main|n>198=p"BREAKING NEWS: WORLD ENDS"|1>0=p<>print<>g$"p=putStr;h 1=100;h k=k+1;g _=p$\"n=\"++show(h n);main|n>198=p\"BREAKING NEWS: WORLD ENDS\"|1>0=p<>print<>g$"
n=1

Try it online!
Adapted from a quine

JavaScript (ES6), 116 bytes
setTimeout(s="alert((n-1?++n:n=100)-200?`setTimeout(s=${JSON.stringify(s)}),n=`+n:'BREAKING NEWS: WORLD ENDS')"),n=1

94 bytes, if stringifying functions is allowed
f=_=>((p=`f=${f}`.split`|`)[4]=p[4]-1?-~p[4]:100)-200?p.join`|`:'BREAKING NEWS: WORLD ENDS'||1

You can't read your own source code (f=${f}), that's not a quine according to https://codegolf.meta.stackexchange.com/a/4878/13400

C# (Visual C# Interactive Compiler), 193 bytes
x=>{var a=t>198?"BREAKING NEWS: WORLD ENDS":"x=>{{var a=t>198?{1}BREAKING NEWS: WORLD ENDS{1}:{1}{0}{1};Write(a,a,(char)34,t+(t<2?99:1));}};int t={2}";Write(a,a,(char)34,t+(t<2?99:1));};int t=1

Try it online!


text:
The Practice of Programming
At 1998, Brian Kernighan, while working on the book "The Practice of Programming", wanted to demonstrate realisation of regular expression engine. But struggled to find small engine, that cod could fit in the book.
So Brian Kernighan asked Rob Pike to write one for him, and Rob did it gracefully. Here is original source:
    /* match: search for regexp anywhere in text */
    int match(char *regexp, char *text)
    {
        if (regexp[0] == '^')
            return matchhere(regexp+1, text);
        do {    /* must look even if string is empty */
            if (matchhere(regexp, text))
                return 1;
        } while (*text++ != '\0');
        return 0;
    }

    /* matchhere: search for regexp at beginning of text */
    int matchhere(char *regexp, char *text)
    {
        if (regexp[0] == '\0')
            return 1;
        if (regexp[1] == '*')
            return matchstar(regexp[0], regexp+2, text);
        if (regexp[0] == '$' && regexp[1] == '\0')
            return *text == '\0';
        if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))
            return matchhere(regexp+1, text+1);
        return 0;
    }

    /* matchstar: search for c*regexp at beginning of text */
    int matchstar(int c, char *regexp, char *text)
    {
        do {    /* a * matches zero or more instances */
            if (matchhere(regexp, text))
                return 1;
        } while (*text != '\0' && (*text++ == c || c == '.'));
        return 0;
    }

Rules

Write regex engine that supports the same operations, as Rob's:

Any char (as symbol)
. to match any char
^ to match start of the string
$ to match end of the string
* to match any count of char from zero

Auxiliary code do not count (to accept input, for example)
Make the shortest solution and beat Rob Pike!

Input
Two strings: one for regex, one for match.
Output

True (in your language), if regex matches string
False (in your language), if regex do not match string

@Abigail You right, my typo. Edited post

What is the range of any char? Is it any character apart from the special characters?

Related: Match strings with wildcards, Regular expression parser, Compile regexes. (Also note that this set of features falls short of truly being a regex engine: there are regular languages which it can't match).

@KrzysztofSzewczyk edited

What does Any char (as symbol) mean?

@JoKing just any char, that can be passed to program. a b c ... @ and so on. You did much better and included character sets support, i'm impressed

Perl 6, 39 bytes
->\a{&{?/<{a}>/}}o{S:g/<-[.*$^]>/'$/'/}

Try it online!
Simply evaluates the input as a regex, adding quotes to avoid any special characters Perl 6 uses. This takes input curried, as f(regex)(string), though it could be a lot shorter if I can just return a regex object.

Reason for downvote?

Fails for this

Oh, didn't see your comment. I'm not the downvoter.

Oh okay. I'm not sure what chars are valid as matching, since clearly some are not meant to be matched literally

Well, rules say ., ^, $ and * should be special (with usual meaning), and everything else is literal.

It says any char is itself, then contradicts itself with the special characters. I don't see any rules about special characters in regards to the any characters. It is implied by the reference program, but that's about it. I have fixed my program to work like that though

source: Stack Exchange

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

sort: votes


text:
Generate Brainfuck for the numbers 1–255
Write a program that, for the numbers 1 through 255, prints out BF code that will produce the given number in some byte of the array, plus a newline.
For example, the first four lines of the output could (and most likely will) be:
+
++
+++
++++

The winner will be the smallest: source code + output (in bytes).
Clarifications & Revisions:

BF programs use wrapping cells.
The output BF program must terminate with the only non-zero cell being the cell containing the number.
Programs must be output in ascending order.
Outputting a program for 0 is optional.
Negative data pointers are not allowed. < at the first pointer will do nothing. (leave a comment if it would be more appropriate to have it throw)

Are we counting the newlines in the output or only the brainfuck code?

@JoKing The entire output is counted.

@JoKing I'm trying to say the number can be in any of the cells. Is that what I should say? I'm not super familiar with BF terminology.

Oh I see, you're saying that the code doesn't have to end on the output cell

Would have been useful to get references as to what "BF" exactly refers to in your context, i.e. https://esolangs.org/wiki/Brainfuck_constants or else, etc.

I've VTCed this as unclear as it contains very little information (beyond +) on the various ways to generate numbers in BF - challenges should be self contained but this one assumes prior knowledge of BF.

Is brute forcing allowed?

+1 for a dual-constraint challenge where you have to balance golfing the BF output versus golfing the code to output the BF.  An interesting twist ☺

Perl 6, 224 + 3964 = 5834 4188 bytes
map {say (.[0]~'['~.[3]~'>'~.[1]~'<]')x?.[1],'>'x?.all,.[2]}o*.min({$_>>.abs.sum+6*?.[1]})>>.&{<- +>[.sign>0]x.abs},classify({0+|(grep(*%%1,(((256 X*^4)X+.[0]%256)X/-.[3]))[0]*.[1]+.[2])%256},[X] |(^27-13 xx 3),-7..-1){^256}

Try it online! (may timeout. Change the ^27-13 to ^25-12 to speed up slightly at the cost of some extra output)
Outputs the shortest code in the form *>[*>*<]>*, where each * is a certain number of +s or -s. There are some extra tweaks like removing the loop if it is not needed, as well as trailing >s.
As far as I can tell, the output is the most golfed for this particular format.
Explanation:
([X] |(^27-13 xx 3),-7..-1)        # Define the search space as the cross product of:
                                        # -13 to 13 for:
                                            # Initialisation     +++>
                                            # Change in target   [*>+++<]
                                            # Last change        >+++
                                        # And -7 to -1 for the change in start [-->*<]
  .classify({                  })  # Group them by calculating
                  (256 X*^4)                         # Each of the multiples of 256
                 (          X+.[0]%256)              # Plus the initialisation
                (                      X/-.[3])      # Divided by the change in start
      grep(*%%1,                               )     # Filter out the whole numbers
                                                [0]  # And take the first value
          # This is the amount of times the inner loop will execute
          # Being Nil, converted to 0 if it is an infinite loop
      *.[1]              # Multiply by the change to the target cell
           +.[2]         # And add the final section
     (          )%256    # And modulo the whole lot by 256
                     +|0 # And floor it just to keep the .0 out
classify(                   ){^256}     # Take the corresponding groups in order
   .map(                             )  # And map each to
        *.min({                    })   # Find the minimum by:
               $_>>.abs.sum             # The sum of the absolute values
                           +6*?.[1]     # Plus 6 if it loops
      >>.*{                   }    # Then map each value to
           <- +>[.sign>0]          # + or - depending on the sign
                         x.abs     # Repeated by the absolute value
   {                    }o              # And pass this to the next code block
    say                       # Print
        (.[0]~'['~.[3]~'>'~.[1]~'<]')             # The loop section
                                     x?.all       # If it is needed
                                           ,.[2]  # And the final part

Brainfuck, 77 75 73 + 32894 = 32967 32969 32971 bytes
++++++[->+++++++<]>+>++++++++++>+[>+[-<<<.>>>]<<.>[->+>+<<]>>[-<<+>>]<<+]

Try it online!
output is the simplest possible
+
++
+++
++++
...

explanation:
++++++[->+++++++<]>+ set cell 2 to 43 (ascii of plus)
>++++++++++ set cell 3 to 10 (ascii of new line)
>+ set cell 4 to 1
[
    >+ increment cell 5
    [
        -<<<.>>> decrement cell 5 and print a plus (content of cell 2)
    ] until cell 5 == 0
    <<.> print a new line (content of cell 3)
    [
        ->+>+<< move value of cell 4 to cell 5 & 6, setting cell 4 to 0
    ]
    >> goto cell 6
    [
        -<<+>> move it's value to cell 4, setting cell 6 to 0
    ]
<<+ increment cell 4
] exit when cell 4 goes beyond 255 because cell contains C uchar meaning 255 + 1 == 0

That's what I wanted to see - a BF code producing another BF code!

Stax, score 4751 4783 (812 bytes + 3971)
ç♥←Ä§òqε↓F"QS₧9(2╤↑▌T~│áZk♣☺nàK╬l•▼2≡→fZ⌂▼├▄<ÖΘá6≈¡K"B∩₧∟µ#°ôQí⌡B2ô§↕*∩)V╕EôD=)O╥T⌠û◘¬dⁿ┤☻∞ô↓♫√○¬z.â\²╕ùHÑ~≡M√☻:EzLƒ→B{O◙ΔΦ_S┼╤g°▓─+dï-┌└α½╥ôRù♠3f½⌐▀Pösúô₧f☻■Aε→τΓ£╒fε▬▬►EÜ%¬╧←y═←{╤╒öú5Ñ╡♀^α☺╨▼$kEÑ■µjh≈↕█Cªü←Z#∟gV↓►S3≥╟╗K‼╞.N|⌠↨╣}5H↕ê;±↓♣≤Tj█'x╒·±ΩßL;ª$Å÷ÑPIδ`◘▌╦┼╡<√▌{òE√PPQ/h@8kq/ÖΓb6╡]≈╤æ░╣{┌‼¢ÜαT├#ΓCN∞*╬⌡↕ÜVX←Ä)◘ù⌂ëøön╗)ôö∙╬⌠☻↨F¢X╓SÅ¼9¡φö^⌂iøFB/┌º▼┤3¶☼Zëôû⌡ôΣfcäéi╣⌠"↨√$,.ë═┴↨Φz⌡τ¢S╜{╨)z:╦@}♦*│P±Æ1x╒ΦP▄◄·╢∙xF╢cá<T╗7;▐≤←÷╛╢;½▲§║│≈⌂ƒ*'F♂☼ùrT╞·╨nG∙=♦`;á$≥┼Ω▬≡aû┼☺╥ò♥R╧╖█▓uìf↕ñ∟φÖ♣°≥←▐G▀╗┘┴÷a*▐♂9╝┬çG─⌠ñ≈☻K·⌐α⌠╡↑!≤≡¡qßτú=Θ≤C░°¡ƒ╛>╨RP○v¡I♦◘╣ô6â₧scÉ♀╣+HO┌☼<♀»?£┴≥ï½.ohaë║ëb┼âù²┌─┬]░ΘQ¥τ┘q▼$v╞Ñ╒æ±tXƒ♪>SC▌LVWª■z↑¶ßΩû↕'L╓BÅï;↑ΦB2.G╞╜&╓π♥1¥0^B0ª≤5e|☼τ5╩╘µåΩ╬◙☻xª└í∞$┐☻∙d▼}╒R⌠AU@Ω♥δÇi0î┴ ↕ù‼☼ƒ┌Aw£╧à7û«W3ùΦ╚A)P○♥Xn⌂øôEΦGB≥╢g[∟a(◘&¥◙─♂→A@┴ö≡↕9PZK║î⌂eóë≥─Åⁿ1‼╢▀ó╙ª▲╒π╗tΣ4○√;■<ä║äqñ8╠T/»q\→↔1ç°ΘZδV♀EçZ▄g┤Å╤ ┴àúJ║wµ$▄«N

Run and debug it
I started with the optimal published programs.
I used some regex-fu, to limit it to the shortest programs that use at most 2 cells.  Then I trimmed any trailing < or > characters.  I think this is a possibly conservative way to ensure that there are no extraneous non-zero cells at program termination.
Then I ran it through an experimental stax program I wrote to generate stax programs for fixed kolmogorov-type output.
This program works by repeatedly applying string replacements.  At each step, it looks for >1 length substring that occurs most frequently and replaces it with an unused character.

@JoKing:  I think I addressed the extraneous non-zero cells.  It cost over 200 bytes in brainfuck program size, but I made it almost all back in compressability.

Charcoal, 707 698 410 + 3627 = 4334 4325 4037 bytes
ＵＴ≔”}⊞Ｊ5±)↷γ²⁼⎇⦃<✂f^⊗Ｌ…¬⁻←«θ↥v⊙^≔¶υＳψVτ16⁷·9I⌕↘;⦃@Pmt↙ ｜TＬ ‹.bＥ^↷Ａm⟧←⪫✂«ＧＩχ¤⟲V⁻PÀ$χ¹'$↙‖%S³6◧N=$kＨＩpQ×ïu｜%÷I↖➙⁸≔Wλ¹ê8⌕dNK‽3H∨↥γh➙↘⊙⊕“~Oj↨-⬤…⊟⁺§◨ＣＢ℅Ｐ⌕KＮＥAR№K⬤Ｘ"¬Ｓ⎇⧴V⁻±6⁼✂kι×ＣÀ⊞‴≡w↓γ=`→P5η1Ｃ⊖ＯSoNυs⊘$M↙êαη↖φ¡¿:θ-γ“rＪW%Ｅ(7<w¤Ｕφ´ρＨπ←SＸ↔τ↧%<Ｔº⎇0gθμ↓⌕；σw⌈pL;Ｙ↘ＹΠ⊙>ξＬzλ↓⁸ι⎚｜⌕ΠP″M³⧴⬤¦➙⟧⌕/δ；↥⁻ºJK⌊≡<⊖λ✳Ｊκ⟲➙ξ⭆｜^Σ*βＭπ⍘⊟；ÀＵ÷‹⭆◧�ωκ?σηkＹＯδO/Ｂº？lＡnaＫ{*Ｋaκ◨+↧aSφ0q‖Ｂ/φx⊘⌕«³ψü✂‹º≡/yc⁴＆Ｊ↙Ｓ²~⎇z§‖$SＰ≧”θＧ↘←¹⁴+⮌⪪θ⸿↑Ｆθ§⁺+-ι⌕-+ιＧ→↙¹⁴-

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

Turn off space padding.
≔”...”θ

Assign a large compressed string consisting of @JonathanAllen's answers for -128..-15 but with + and - signs transposed.
Ｇ↘←¹⁴+

Draw a triangle of +s of side 14, which generates the correct results for 1 to 14. The cursor is left in the bottom corner, although the trailing return on the compressed string will move the next output to the next line.
⮌⪪θ⸿

Split the large string on return characters and print each substring in reverse order, thus generating the results from 15 to 128.
↑

Move up a line so that the result for 128 is overwritten by the negated result for 128.
Ｆθ§⁺+-ι⌕-+ι

Loop through the string transposing + and - back again so that they generate the correct results for 128 to 241.
Ｇ→↙¹⁴-

Draw a triangle of -s of side 14, which generates the correct results for 242 to 255.

Jelly, 1224 + 3716 = 4940 bytes
⁾+-ẋ€Ɱ14ZY€U0¦j“6VⱮ×ė7¬(Ị¢ẋṀⱮM⁵Ñ¬kbvœ⁸½ẋƓ0⁽ṖçḟŻßɓẉḷ0Ƙ¥@ⱮZĊⱮ{ṫṇØ"ỵðẓ⁵!ḳqḄƬiỴƥṇØm@ɗẆḅƥƲ⁴ŀ-5¦€ÑɓZĖ/gPṄḌ!ẹ$ḞıƒĿỵ⁷£Q.%¦ẊiUı-M⁹ƈxṁ,CsḲtÆƇỴṄĿiæEṛⱮẒʠþƘ%ƘƙṾ ('ȥ€½⁵ḥ+,þ@ẇ&ạV|ĊuAYḃfṖƘLƥQtPƬivxHj)Ṇɓ5JṘØẓæĿøɗjḥrñþa®OṅḍṪ¥=ɼġċṫßṬỌƈrUẉçŻ½\=]€ʂ_ⱮṖ¥Ƥȥ6SṡÆcạdn;ṅⱮDɦ⁹ṢAy)~Ḷ`ẒẓMTİṂḋ|ẉ]Wɠ¿⁾Ṣ|ḷ6hẸƒⱮQ1ẏƝC@Ŀ!ʠ⁽ṃ@ƓŒQ3@ƝḊñçcZ\¥3Z¤~çD>ċọuⱮȦAẈⱮ%L3Æ¢ḞtĖė!ƇtñṪɓẓ¥Fṅ⁵shB'wṪẸ¦ṄÞṭ³ʂḶƊ³iȧṂRœŒƤ\r1Çwi6ŀỵɼḃa⁵Ṣ_Q⁸Ẹ'{|\+Æ®|ḤcʂÑ/Ɓz¶ɦÄ!ʂ"Ẋ ẓĠĠ⁷⁵QƝ¶%ṙƇḋ[^j&W×*°ḳçʂSżḊⱮ⁻IȦṄXȥlẋḅ7;⁺ḃİÞÆðLX¢1K£€Ä&X½VȮ(;Q£ḞḢ¹zG+ṅ¹LḥW³ḅd@^ẊḶJ¹T8ṛ($ȧṢzq,Ṫ⁻ȥ{Ṛ"Ḍ®Ä8QḋþɼȮhỵB"Ḍ⁶ȧZ⁵ẒNɓḃȧ¶Ƒð$Ẇ/"Eṭ*I:ØḃL}<KȦ+ṣ¥x&Ṇ£Œṫḋġ0lİḍ¿H£(ỌƝ×^Ḃ°⁽⁼UƭĠḥkQð7ṫƤżȷƘxjƑRḣqƒ$HƬ7ḳ-JµnṇṣðXŻİẉbSu×]bṾ0ƊHßçQh⁸°ƒɦSCñ_⁾ʂC⁼Ġø⁵SAʋƊİ¡⁴ÄḋẸḶwȧZẈĠ7rṀẏẉṖa¤ɱELƝȧẈṣṄk]d⁹øṇÞṡ.ạtƥṢḅ⁺ṂLpÑƘṄṡḍ⁵,Ç¤$Ọ8ṛuṚvAṖÑ1!vƤD3ß¶ʂÐ°]EÞUĠ€ḋḲ⁸¬r`YḊ0ṙ5ċmṅȯ*ɲU÷pƭẉṭȦB¹ɦSNɱ)]ĠṾʋ³Øḟ23ṭð#ẆuẎṬṫVɠ(ỊỊQɼF}ịƒ$Ẏ_Ṡ'ḳOLc?ṾŀẊẎṆ⁵p"VẏAȮ⁴ⱮȦ®e®Ɱi"ÇJẊ4ñḍḲY]ḌḌẓ⁺ƙ"iṄḅoLṙfOS&}HGɼĖİĠḷuḃ³ṡıḳỊẹzq⁶ƈ£ċHZɱ.#⁶ḟUṗŀȮṘḶḲ]@¶+ḊĖ8ĖṆɗçŻŀ®ṭẇƓḄḷıM@⁷²36ɲṗ¡ḂḊ'Ṿ⁵ėƙṘ-⁺µʠṡṂ[_¤ḥṢ]ṘÐḤ½ḟ4ȷ}E¹Ṙb⁹ḅḢ¹hƬZ§Ẏẹ÷Æ$ḅoĖẉ⁹ịJ.ȥḊẋʋṄȯ1<ẎṄḲṛœ"æ)ḥ8)ḤlñA⁾%⁶LỴ⁶M4Ṙ\`ỵƊȥŀƒ⁷ḌƬƙḳƑ⁴vʂ⁻ðQpñḷḳṄœ>ṪỴƭƙɓ3[&Ḅzḅ<⁾µİṪȧ⁹C>ẹ{ẈÐlC&j?LṆṛ⁽æȤið<⁽$Ḋ7⁻FṡḅɓɱḂJoPŻẆṃṛḂ¹ẓð[1eƘ2T⁶ḟɼ7P~©ṚṙE8RƒṬẹLœẇẸịøḷ*⁾²ÄƓy€VƈɱNSẏẓÑ¶pƲḞḅX⁹ọaœ<aỴTĠ^ðƑṙẊḅOḥŀG4ị¤ÑėÐịʠɗ=YṚċẋĠżẉịṪṁtḳṪ{ṬṃıızD/ĊvȤpḣðÐ¡þfÞ⁶ỵỊµṅḷÄ÷Vẇ\Ạ$-§OẠn^ȯfẎlḊd⁶ni¥ẓɱn¶’ṃ“¶><-][+”¤⁷

A full program.
Try it online!
How?
Almost entirely compression of current bests on esolangs which leave only a single non-zero, with trailing tape moves removed. There is probably a way to evaluate a subset of BF programs such that they will terminate and yield the shortest solutions that'd beat this naive program. There may well also be a way to beat this by a smarter pattern-based or factorisation-building program.
⁾+-ẋ€Ɱ14ZY€U0¦j“ ... ’ṃ“¶><-][+”¤⁷ - Link: no arguments
⁾+-                                - list of characters ['+','-']
    €                              - for each:
   ẋ                               -   repeat
     Ɱ14                           -   mapped across [1..14]
        Z                          - transpose
         Y€                        - join each with newline characters
           U0¦                     - reverse the rightmost
                                   -   (now we have ["+\n++\n+++\n ...","... \n---\n--\n-"]
                                ¤  - nilad followed by link(s) as a nilad:
               “ ... ’             -   a really big number compressed as base 250
                       “¶><-][+”   -   list of characters ['\n','>','<','-',']','[','+']
                      ṃ            -   decompress - use as base 7 digits [1,2,3,4,5,6,0]
              j                    - join (the list ["+\n++...","...--\n-"]) with that
                                   - implicit print
                                 ⁷ - a newline character
                                   - implicit print

Fixed up the offenders (and removed trailing tape moves)

SuperMarioLang, 231 + 32894 bytes
)
))++>(>+)*>[!((&(>[!*>-)-[!([!
===+"="==="=#===="=#="====#==#
+++<(       )    !+< !  ( <
+===+ (   - .    #=" #===="
>[!+( (   !(<
"=#++ (   #="
- (++ !.))    )))            <
) +++ #======================"
+ +++
+ ++!
!+<=#
#="

Try it online!
This sure can be golfed more, as the output is the most basic for brainfuck, but it took me all day to write this answer (my three children leave me little time to spare) and I'm proud that at least I managed to achieve this.

Python 2, 70 + 8428 = 8498
-2 Bytes Thanks to A__!
-20 Bytes Thanks to Jonathan Allan!
-229 Bytes by putting the number in the second cell
-1000ish bytes by switching from 16 to 9
p='+'
i=1
exec"print[p*i,i/9*p+'[>'+p*9+'<-]>'+i%9*p][i>20];i+=1;"*255

Try it Online!
Output

Ruby 271 + 5363 = 5634
1.upto(255){|n|r=n>(o=n>128?256-n:n)??-:?+;puts o>20?(s=o.to_s(i=(3..9).find{|i|!(s=o.to_s i)[1..-2][s[0]]}).bytes;s[-1]+=s[0]%8;(s[1,9].reverse.map{|c|(c-=s[0])<0??-*-c:c>0??+*c:?-}*?>+'[>'+?+*(s[0]%8)).tr(n>o ?'+-':'','-+')+'[-<'+?+*i+'>]<<]'+(s[-1]>s[0]?'':?>+r)):r*o}

Try it online!
Converts each value to the smallest base which doesn't contain a zero its initial digit at any other place, and then converts from that base. Values greater than 127 are calculated as their inverses.

Non-Wrapping, 221 + 5888 = 6109
1.upto(255){|n|puts n>20?(s=n.to_s(i=(3..9).find{|i|!(s=n.to_s i)[1..-2][s[0]]}).bytes;s[-1]+=s[0]%8;s[1,9].reverse.map{|c|(c-=s[0])<0??-*-c:c>0??+*c:?+}*?>+'[>'+?+*(s[0]%8)+'[-<'+?+*i+'>]<<]'+(s[-1]>s[0]?'':?>+?-)):?+*n}

Using the same approach as above, with non-wrapping cells.
Try it online!

JavaScript (Node.js), 691 + 3627 = 4318
Using the same approach as @Neil's Charcoal answer, and therefore also based on @JonathanAllan's Jelly answer.
_=>(a=require('zlib').inflateRawSync(Buffer('bZXRsQMhCEX/0wpDB4yNOPbfxoMLKLAvs8lyQBEBDf2I9MHXf+I3X/f9hCJVsckdBgH3gih8YHT80Kpj01zQ7dUZb9osZ0Fzfvra+qiCl6GaqTB9vTdvNn2TjiaVjvBQKG5mHS/mMBGrywc1Vl2eIzqbwFPReVjJo1+I3mLfbAOYY201Sm491vaxDM+Vh9WSaJtgfBDYUHQeVrKkqzMEaYMrWpgbMS7MtIlIry3DgztWahbqNPElykKItD4e1hgN8qyrHA1CJ/dC5Imz3WS5PeDKDdGKDvS8WqBq+reSd4lH2Gtjcr9W95ydm/8kcaaRPsNpMiHS1kjW8qWAOsFmWEdHeiw/kenG1zdqzR0bVXhy0VKVPQVesFNloU4TI5nsp4qzunLytsCheK4B2Gz0UeXobM+M3Q2NcXhx+GlF389GH53eWr31utUf90W02MVu89LZs45IhP/Qc6jx9dYoCs8W1d4vKHHO8wJ9l8y4Vd614g788IzrViKArok/CmguX/KLqSl+c7h3STZcxUYVnvwH','base64'))+'')+`
--[>-<--]>-
`+[...a.split`
`].reverse().map(s=>s.replace(/[-+]/g,c=>c>','?'+':'-')).join`
`

Try it online!

brainfuck, 3785 + 4120 = 7905 bytes
-->>>->>->>->>+>>->>->>->>-->+>->>->>->>->+>->>->>->>>+>->>->>->>->>>>-->+>->->>>>>-->+>->->->>>>->+>->->->>>>-->+>>->>>>>-->+>>->+>>>>-->+>>->->>>>->+>>->>>>>->+>>->+>>>>->+>>->->>>>>+>>->->>-->->->+>->+>>>-->->->+>->+>->>-->->+>+>-->+>>>-->->+>+>-->+>->>-->->>+>->+>->>-->->++>+>-->+>>>-->->++>+>-->+>-->->-->->+>+>->+>->>-->->+>+>->+>->>-->->>+>>+>>>-->->>+>>+>->>-->->++++>+>-->+>->>-->->++>+>->+>>>-->->++>+>->+>->>-->->+>+>>+>>>-->->+>+>>+>->>-->->+++>+>->+>>>-->->+++>+>->+>->->>++>->->+>>-->->>++>->->+>>->>>++>->->+>>->>>++>>>-->+>>>>++>>>-->+>+>>>++>>>-->+>>->->++>>>+>>->->->++>>>+>>-->->->++>>>+>>->>->++>>>+>>>>->++>>>+>>+>>->++>>>+>>-->+>->++>>>+>>+>->>+>>>>>>->>+>>>>>->->>+>>>>>-->->>+>>>>>->>>+>>>>>>>>+>>>>>+>>>+>>>>>-->+>>+>>>>>->+>>+>>>>>>+>>+>>>>>->>++>++>>>>>>>++>++>>>>>+>->->+>>>->+>>->->+>>>->+>->->->+>>>->+>-->->->+>>>->+>->>->+>>>->+>>>->+>>>->+>+>>->+>>>->+>-->+>->+>>>->+>->>->+>>->->+>>>->+>>->->+>+>>->+>>->->+>>->++>+>>>>>->->++>+>>>>>-->->++>+>>>>>->>++>+>>>>>>>++>+>>>>>+>>++>+>>>>>-->+>++>+>>>>>+>++>-->+>>>>>>++>-->+>>>>>->++>-->+>>>>>++>->-->+>>>>>+>->-->+>>>>>>->-->+>>>>>->->-->+>>>>>-->->-->+>>>>>->>-->+>>>>>>>-->+>>>>>+>>-->+>>>>>-->+>-->+>>>>>->+>-->+>>>>>>+>-->+>>>>>+>+>-->+>>>>>++>+>-->+>>>>>+++>+>-->+>>>>>++++>+>-->+>>>>>>++>>+>+>>>>->++>>+>+>>>>++>->>+>+>>>>+>->>+>+>>>>>->>+>+>>>>->->>+>+>>>>-->->>+>+>>>>->>>+>+>>>>>>>+>+>>>>+>>>+>+>>>>-->+>>+>+>>>>->+>>+>+>>>>>+>>+>+>>>>->->++>+>->->>>-->->++>+>->->>>->>++>+>->->>>>>++>+>->->>>+>>++>+>->->>>-->->++>++>+>>>>->>++>++>+>>>>>>++>++>+>>>>->>+>>-->+>+++>+>-->->+>>>+>->+>->>+>>>+>->+>->>+>>-->+>+>+>->->+>>-->+>->+>-->->+>>-->+>->+>->>+>>-->+>->+>+>->+>>>>+>>>->+>>>>+>>->->+>>>>+>>-->->+>>>>+>>->>+>>>>+>>>>+>>>>+>>->>+>>-->->+>>>>+>>-->->+>>+>>+>>-->->+>>-->+>+>>-->->+>>->+>+>>-->->+>>->>+>>>->->+>>>+>>>->->+>+>>+>>>->->+>->>+>>>->+>+>->>+>>++>->->+>>>+>>++>->->+>->>+>>>->+++>+>-->->++>++>->->>>->>++>++>->->>>>>++>++>->->>>->->++>+>+>>>>-->->++>+>+>>>>->>++>+>+>>>>>>++>+>+>>>>+>>++>+>+>>>>++>->>+>->->>>+>->>+>->->>>>->>+>->->>>->->>+>->->>>-->->>+>->->>>->>>+>->->>>>>>+>->->>>+>>>+>->->>>-->+>>+>->->>>->+>>+>->->>>>+>>+>->->>>+>+>>+>->->>>++>+>>+>->->>>++>++>-->+>-->->>>+>++>-->+>-->->>>>++>-->+>-->->>>->++>-->+>-->->>>++>->-->+>-->->>>+>->-->+>-->->>>>->-->+>-->->>>->->-->+>-->->>>-->->-->+>-->->>>->>-->+>-->->>>>>-->+>-->->>>+>>-->+>-->->>>-->+>-->+>-->->>>->+>-->+>-->->>>>+>-->+>-->->>>+>+>-->+>-->->>>++>+>-->+>-->->>>+++>+>-->+>-->->>>>->++>+>-->->>>->->++>+>-->->>>-->->++>+>-->->>>->>++>+>-->->>>>>++>+>-->->>>+>>++>+>-->->>>-->+>++>+>-->->>>->->->+>-->+>->+>-->->->+>-->+>->+>->>->+>-->+>->+>>->->+>-->->->+>->->->+>-->->->+>-->->->+>-->->->+>->>->+>-->->->+>>>->+>-->->->+>+>>->+>-->->->+>-->+>->+>-->->->+>->+>->+>-->->->+>-->->++>++>-->->>>->>++>++>-->->>>++>->>+>-->->>>+>->>+>-->->>>>->>+>-->->>>->->>+>-->->>>-->->>+>-->->>>->>>+>-->->>>>>>+>-->->>>+>>>+>-->->>>-->+>>+>-->->>>->+>>+>-->->>>>->->++>-->->+>>->->->++>-->->+>>-->->->++>-->->+>>->>->++>-->->+>>>>->++>-->->+>>+>>->++>-->->+>>-->+>->++>-->->+>>->->>++>-->->-->+>-->->>++>-->->-->+>->>>++>-->->-->+>->>>++>+>>+>>>>>++>+>>+>>+>>>++>+>>+>>-->->>>+>++>+>->->>>>+>++>+>->-->->>>->++>++>->->>>>->++>++>->-->->>>>++>+>->->>>>>++>+>->->>>>++>++>>->-->->>>++>->++>->->>>>++>->++>->->>>>->++>+>->>>>>->++>+>->-->->>>>++>>->->>>>>++>>->->>>>++>->+>->-->->>>->++>>->->>>>->++>>->-->->>>+>->+>->->>>>+>->+>->->>>>++>->>->->->>>+>->>->-->->>>+>->>->->>>>+>->>->->->>>>->>->-->->>>>->>->->>>>>->>->->>>>+>->->->-->->>>>->->->->>>>>->->->++>->->>->>->>+>->->>->>->>>->->>->>->>->->->>->>->>-->->->>->>->>>+++++[>++++++<-]>+[>+++>++>>++>>+++>++>+<<<<<<<<-]>-->>>-->>>>-[>+<---]<[[<]<]<<++[>>[-]--[<+>++++++]+<<<+++>-[>++<<-->-[<++++>-[>--<<++>-]]]<[>>.<<-]>+[>]->[.>]>[<<[<]>>[-]]<<[<+<<<+<<+<<<+<[<]]>>+<<<++]

Try it online!
This code reads a list of values and produces output in the pattern a [> b < c ]> d, where a, b, c and d stand for a number of '+' or '-' characters.
Except for the first and last 15 numbers, it uses the shortest constants from https://esolangs.org/wiki/Brainfuck_constants that follow the specified pattern.
[
Tape: -2 (end of values), [List of values], 0, 0, "\0 [> \0 < \0 ]> \0 \n" (the spaces are only for better readability.
      Not in the actual string.
      Zeroes are "not printed yet" markers.
      Printed sequences will be prepended by -1.)
List of Values: charCount, class
class: -2 = end of values,
       -1 = (char "+", offset 3),
        0 = (char "-", offset 1),
        1 = (char "-", offset 5),
        2 = (char "+", offset 7)

Ascii:
      ] 93
      [ 91
      > 62
      < 60
      + 43
      - 45
]

[values]
-->>>->>->>->>+>>->>->>->>-->+>->>->>->>->+>->>->>->>>+>->>->>->>->>>>-->+>->->>>>>-->+>->->->>>>->+>->->->>>>-->+>>->>>>>-->+>>->+>>>>-->+>>->->>>>->+>>->>>>>->+>>->+>>>>->+>>->->>>>>+>>->->>-->->->+>->+>>>-->->->+>->+>->>-->->+>+>-->+>>>-->->+>+>-->+>->>-->->>+>->+>->>-->->++>+>-->+>>>-->->++>+>-->+>-->->-->->+>+>->+>->>-->->+>+>->+>->>-->->>+>>+>>>-->->>+>>+>->>-->->++++>+>-->+>->>-->->++>+>->+>>>-->->++>+>->+>->>-->->+>+>>+>>>-->->+>+>>+>->>-->->+++>+>->+>>>-->->+++>+>->+>->->>++>->->+>>-->->>++>->->+>>->>>++>->->+>>->>>++>>>-->+>>>>++>>>-->+>+>>>++>>>-->+>>->->++>>>+>>->->->++>>>+>>-->->->++>>>+>>->>->++>>>+>>>>->++>>>+>>+>>->++>>>+>>-->+>->++>>>+>>+>->>+>>>>>>->>+>>>>>->->>+>>>>>-->->>+>>>>>->>>+>>>>>>>>+>>>>>+>>>+>>>>>-->+>>+>>>>>->+>>+>>>>>>+>>+>>>>>->>++>++>>>>>>>++>++>>>>>+>->->+>>>->+>>->->+>>>->+>->->->+>>>->+>-->->->+>>>->+>->>->+>>>->+>>>->+>>>->+>+>>->+>>>->+>-->+>->+>>>->+>->>->+>>->->+>>>->+>>->->+>+>>->+>>->->+>>->++>+>>>>>->->++>+>>>>>-->->++>+>>>>>->>++>+>>>>>>>++>+>>>>>+>>++>+>>>>>-->+>++>+>>>>>+>++>-->+>>>>>>++>-->+>>>>>->++>-->+>>>>>++>->-->+>>>>>+>->-->+>>>>>>->-->+>>>>>->->-->+>>>>>-->->-->+>>>>>->>-->+>>>>>>>-->+>>>>>+>>-->+>>>>>-->+>-->+>>>>>->+>-->+>>>>>>+>-->+>>>>>+>+>-->+>>>>>++>+>-->+>>>>>+++>+>-->+>>>>>++++>+>-->+>>>>>>++>>+>+>>>>->++>>+>+>>>>++>->>+>+>>>>+>->>+>+>>>>>->>+>+>>>>->->>+>+>>>>-->->>+>+>>>>->>>+>+>>>>>>>+>+>>>>+>>>+>+>>>>-->+>>+>+>>>>->+>>+>+>>>>>+>>+>+>>>>->->++>+>->->>>-->->++>+>->->>>->>++>+>->->>>>>++>+>->->>>+>>++>+>->->>>-->->++>++>+>>>>->>++>++>+>>>>>>++>++>+>>>>->>+>>-->+>+++>+>-->->+>>>+>->+>->>+>>>+>->+>->>+>>-->+>+>+>->->+>>-->+>->+>-->->+>>-->+>->+>->>+>>-->+>->+>+>->+>>>>+>>>->+>>>>+>>->->+>>>>+>>-->->+>>>>+>>->>+>>>>+>>>>+>>>>+>>->>+>>-->->+>>>>+>>-->->+>>+>>+>>-->->+>>-->+>+>>-->->+>>->+>+>>-->->+>>->>+>>>->->+>>>+>>>->->+>+>>+>>>->->+>->>+>>>->+>+>->>+>>++>->->+>>>+>>++>->->+>->>+>>>->+++>+>-->->++>++>->->>>->>++>++>->->>>>>++>++>->->>>->->++>+>+>>>>-->->++>+>+>>>>->>++>+>+>>>>>>++>+>+>>>>+>>++>+>+>>>>++>->>+>->->>>+>->>+>->->>>>->>+>->->>>->->>+>->->>>-->->>+>->->>>->>>+>->->>>>>>+>->->>>+>>>+>->->>>-->+>>+>->->>>->+>>+>->->>>>+>>+>->->>>+>+>>+>->->>>++>+>>+>->->>>++>++>-->+>-->->>>+>++>-->+>-->->>>>++>-->+>-->->>>->++>-->+>-->->>>++>->-->+>-->->>>+>->-->+>-->->>>>->-->+>-->->>>->->-->+>-->->>>-->->-->+>-->->>>->>-->+>-->->>>>>-->+>-->->>>+>>-->+>-->->>>-->+>-->+>-->->>>->+>-->+>-->->>>>+>-->+>-->->>>+>+>-->+>-->->>>++>+>-->+>-->->>>+++>+>-->+>-->->>>>->++>+>-->->>>->->++>+>-->->>>-->->++>+>-->->>>->>++>+>-->->>>>>++>+>-->->>>+>>++>+>-->->>>-->+>++>+>-->->>>->->->+>-->+>->+>-->->->+>-->+>->+>->>->+>-->+>->+>>->->+>-->->->+>->->->+>-->->->+>-->->->+>-->->->+>->>->+>-->->->+>>>->+>-->->->+>+>>->+>-->->->+>-->+>->+>-->->->+>->+>->+>-->->->+>-->->++>++>-->->>>->>++>++>-->->>>++>->>+>-->->>>+>->>+>-->->>>>->>+>-->->>>->->>+>-->->>>-->->>+>-->->>>->>>+>-->->>>>>>+>-->->>>+>>>+>-->->>>-->+>>+>-->->>>->+>>+>-->->>>>->->++>-->->+>>->->->++>-->->+>>-->->->++>-->->+>>->>->++>-->->+>>>>->++>-->->+>>+>>->++>-->->+>>-->+>->++>-->->+>>->->>++>-->->-->+>-->->>++>-->->-->+>->>>++>-->->-->+>->>>++>+>>+>>>>>++>+>>+>>+>>>++>+>>+>>-->->>>+>++>+>->->>>>+>++>+>->-->->>>->++>++>->->>>>->++>++>->-->->>>>++>+>->->>>>>++>+>->->>>>++>++>>->-->->>>++>->++>->->>>>++>->++>->->>>>->++>+>->>>>>->++>+>->-->->>>>++>>->->>>>>++>>->->>>>++>->+>->-->->>>->++>>->->>>>->++>>->-->->>>+>->+>->->>>>+>->+>->->>>>++>->>->->->>>+>->>->-->->>>+>->>->->>>>+>->>->->->>>>->>->-->->>>>->>->->>>>>->>->->>>>+>->->->-->->>>>->->->->>>>>->->->++>->->>->>->>+>->->>->>->>>->->>->>->>->->->>->>->>-->->->>->>->

>>+++++[>++++++<-]>+        31
[>+++>++>>++>>+++>++>+<<<<<<<<-]    93 62 0 62 0 93 62 31
>-->>>-->>>>-[>+<---]       complete string 0 0 91 62 0 60 0 91 62 0 10
<[[<]<]<<                   go to first class cell
++[                         repeat for each value pair
  >>[-]--[<+>++++++]+<      ascii plus
  <<+++                     add offset 3 to value
  >-[                       if not class = "plus 3"
    >++                     change charater to minus
    <<--                    set offset to 1
    >-[                     if not class = "minus 1"
      <++++                 set offset to 5
      >-[                   if not class = "minus 5"
        >--                 set charater to plus
        <<++                set offset to 7
        >-                  delete class value
      ]
    ]
  ]
  <[>>.<<-]                 print char value plus offset times
  >+[>]                     go to next string
  -                         set printed marker
  >[.>]                     print string
  >[                        if not end of chars
    <<[<]                   go to cell next to next class cell
    >>[-]                   empty two cells right (for exit if)
  ]<<[                      else
    <+<<<+<<+<<<+           reset printed markers
    <[<]                    go to exit if cell
  ]
  >>+                       set empty cell = 1 (for scanning over non null cells)
  <<<                       go to class cell
  ++                        repeat if not end of values
]

brainfuck (the easy way), 41 + 32895 = 32936 bytes
+[>>++++++++++.+[<++++>-]<-<[>.>+<<-]>>+]

Try it online!
+[              start loop (loop until overflow)
  >>            go to newline position
  ++++++++++.   print newline
  +[<++++>-]<-  store 43 (plus)
  <[            for each count
    >.          print plus
    >+          increment next count
    <<-         decrement current count
  ]
  >>+           increment next count
]

Ruby 23 + 32895 = 32918 bytes
256.times{|n|puts ?+*n}

As a baseline. This is the simplest solution I can think of.

0 should probably be 1 (although I asked if we may output for zero too)

-3: 256.times{|n|puts ?+*n} not that it matters too much...

Unofficial Keg 16 + 32895 = 32911 bytes
A baseline solution for a golfing language. This is the simplest I can think of.
ÿï((:|\+$;)_\
')

Try it online!

As it stands this needs reversing (although I asked if we may output descending)

I will wait until OP replied with your query.

Retina 0.8.2, 28 + 16640 = 16668 bytes

127$*+128$*-
\+
¶$`+
-
¶$'-

Try it online! Includes output for 0. Just outputs using +s up to 127 and -s up to 255.

Scala, 95 + 16639 = 16734 bytes
object M extends App{(1 to 127).map(x=>println("+"*x));(0 to 127).map(x=>println("-"*(128-x)))}

Try it online!
A simple answer which obviously is not going to win. Uses only the fact that the - operator (decreasing a byte) wraps back to 255.

Scala isn't the best golfing language, but you can save quite a few bytes by just writing a method instead of a whole app, that's allowed under typical golfing rules here. Additionally, instead of printing out the result, it's usually more byte efficient to just return the list. On Try It Online, you can put all the object extends app type stuff in the header and footer, to run your method without counting the irrelevant bytes.

In this case, you can save 36 bytes with: https://tio.run/##K05OzEn8n5@UlZpcouCrkFpRkpqXUqzgWFBQXZaYo5CmYPtfQ9PWTsNQoSRfwdDIXFMvN7FAo8LWTklbSatC01rDAENCV0lLw9DIQrdCU/N/QVFmXklOnkaaBlA@O7gEyE3XUIrJU9LUrP0PAA

22 bytes

05AB1E, score: 4848 (1219 bytes source code + 3629 bytes output)
'+14L×»Â'+'-:•тômG‚ΣP;e3₃ìèÕwƵÜè-½;¨Z±µΛé±V™NkKJžšë₅ušΘ(M₄+Ü§‘мoÕθÚzÇYï#J×¢θýει™₃tQØËв¿U®GƵ´GZ’¯ε¨jjØÛλÄ₅X∍µxθÆvËjS¹∊f˜«VÐZ<ÇĆ’Š2&ØÍäßÍĆlΓV₆ëßê©Œ‡ÛiyĆ=*÷Í´¢‹j,3½íµ'ž4‘û29ôãζм§x…1P|ÛéΣ=~çš5Œ±€Ô“q òǝ?ó¬Æí5¢G‘°êóÿв4LFÍK&zζb2Ó∍æïι8₃4XƵÜÙôt₁‘,Ö…6₅ÞαÇø†c÷Ûλ9…F;ĆA¬iмéλ8ä¶×ƶYΔè¡aû
v=M„ûñ]C₅Õ¶Þ*Ú`Úˆ/₃UιΩW¾eTεvˆ£nYõ¶S¼ÿ{õN9Ω¨£1w‚Ï”Xd;¹OýŒéDнĀvÌ–d=±ΛΣÃÊîD—GR>~ºD‹K¥‘l×yz.éFE1Í©ØM/ƒœOαU‘KΓO‰∍Aм‚œ2нƶþøÌ×¼āHgΩC'Λê¡-ß…Ì¾Ā–м–¿<₂δ¡áтgö¬Í~θFíнā‹°ü8[À(xï¸.›*W©¹º₅ÇмδçΛλÉFÕL4†EćÛ´ǝ{тÀ¯†ª™ŽćÉuè¬ƵÀSìFÙη¶1È¸Ö›GÜlRv˜jy5mfè∞_åEηŠyo‡xÐ/™¥òÜ#Áx#м6r&₁cÿXÛ¬Æ„ÌƵ₅∊Ð±γ²Θj∞;6o·¼ýŠΩÚò›c[>ö₅¥=—ªÃ±¿ecSBÐ6Ê!ú¢E¡âìþßƒ¿;Ò;„Xoƶ*∍Σǝñ"Tµ†8s®βµ4ìA|«÷γt³+<B¤špTp¸ï7Ëo[>–îiTôóζª‚?É8zн²ìC1ãl6+ƶå4sÐŒÃšb(°·8ˆ´ˆŸ²ÚÌY3ŸËÃ®ÿ‘àUāçh9im„ÝĆm3ŠC×η“åX¨₄|ëPô3O<6Mþ'Ì-s{e`ζQΔ¹œP@l%¥‹èδcsÎcΘÂþ®i₅∞ð¡@`¸¿…BÎN2н>g;ΛSníÐ^Rαθ₆ΣÕ3¹ÐÔCfrQ¦7¨gfŒ|v||þÚÜvz≠pá»‡T˜ǝ=ß·„®¡xи™#?†-Aʒ2åβ₃A¬Ão6ºтõ}Ë.&QηÕ~Δ4€@-5î^aÌ¬.»Èõ4áL¾ò¥n
¶p›éŽžgǝSZγāmεålz₅°dβÂ~λà€Ê%zmŠиˆRη≠éwüǝΛζƵмƶdζ`SÖ₅\≠³äŸj!"(†Üćí“ŠxVöÇe#‡PÏÉ‡"xð®6ÊεGиe"NÊ›i.k…’Ú8:ǝ/₂ÌÜkãŽo™Áā‚ζΩ«мÁp=}ÂýõλиëÆζиîSÖt¶‚wĀθºd“
₆ŽsLвQ”ÖÜvGõƶiò{÷ÀPy/‹θÑè}¿Á5º˜¯sëØSËƶK_ÍyX∊3Øå4IOθ I+∊ÌñÙçakÞŸŒʒζ¤±,mεjæ‰O%<ÅtƒVöV=³ÇƶƒC¬‰xðÈ¬M4Ïóä)∍Êfa§õØÂ,“X¾₆₄Ö¦ÈJµÿmÈ¾Î∍=¡YнŸV!¨J£ü|&¢cUg4e±6w™¼“fÊÙ ,Ž|šP·ùèd}ãŠÅ#GγhYÇN´¼ÁÌMGʒ§Æ1¸‚Δ:j7ΩƵAqá¢<äò´Θ•“-+>][<
“ÅвJs»

Output is a port of @Neil's Charcoal answer, so make sure to upvote him as well!
Try it online.
Explanation:
'+                      '# Push a "+"
  14L                    # Push a list in the range [1,14]
     ×                   # Repeat the "+" that many times as string: ["+","++","+++",...]
      »                  # Join these strings by newlines
       Â                 # Bifurcate it (short for Duplicate & Reverse copy)
        '+'-:            # Replace all "+" for "-"
•тôm...ò´Θ•              # Push compressed integer 18302226724133383998250107335646038608225046109581810887431446835557987256955354954509163336111304735021044106950262344427892947550841899099611054599885158084492762836812161427050275372983896356189873217422270707048679161884382784973706990123491668808316983431947218815813441209357230471947480445527653281307616982417034289994948061000591427114479102114229222423495882782326672492922269629953210111953959859902281658658439835047182218017657439552630082372181376525413759195763958434475193943488791777228373958162363214252781530693967200164833437881609482421594458966138936433283311419810119896020066082377462298326514652481546557215787238749539873039910952003326954299252586309028025200870623285261199142261807190771369911425142504345271105103035478661301795311828767848235694787283635190364512722037791815037475799545052058894119573664059402985074146226606245848663046901585891882552845134633210352731812274795773552227786140415336764040421001184646630833787917147474644077938952053956874031774587527717793206158934471919975714697099518810712871948398923739276321843455690477328633199064849928974478179435369018512187592263559949835435473650276637191671401061097340919482725489354844550472281209666291367830643727358624135371626379451084552903536762775083445643853806852513122856150361979701049267928548063465967555886420646898485890108420374549485423234679327438138302730692296669063696581268627535131608200283731275951916433249161017999011290215932205767570177905442947203826039265793694687731078121685736352831955773450680945121984143563963149079990880719573067270197057276219243821370885160589340870891346257233778661271435191351926058080186177296974642815621539128350975752011448032262905976766027084285390087966682234081285502231618383962136055937741758125210487103109250885525370548106186539295203084216890820183575639032509902729248016346072449636148699098049659529168757116706057794418245039559549604674043961198447420311513558044229534569679723496972989178091506175996419296780639212192856671882116470677803387276814324094247508763467887301684211112080372036284371596072213153957411329532202432808677726223798116216330275138697515009114689489577370759238857602332613821627667530873656034962827810927061440822808985980383150080767015247752949877604372029666921293343149038246728649404223795601960991061986482063744094221616603849190547637439116347239768975065217383194655478092271791087679802480625740835053103772632489195507735140119501008503485917456615266596210333924964188989678201446160111091052524780358620148464886929989973412559470628329156848340802659185674541202787279386158230228148429451357621709967247567009904339076971643378255946241011579618610095231079053137553024558887196808709177094386352264708730475553352082713138948975317023830903305435434148828341201637230241697870602236452176330225025183518037443992277303117971849493548326433875
           "-+>][<\n"    # Push string "-+>][<\n"
                     Åв  # Convert the integer with this string as custom base
                       J # Join all characters together to a single string
s                        # Swap so the triangle of "-" we created it as the top of the stack
 »                       # Join the strings on the stack by newlines
                         # (and output implicitly as result)

See this 05AB1E tip of mine (section How to compress large integers) to understand why •тôm...ò´Θ• is 183...875.

Rust + -O, 618 576 + 3953 = 4571 4529 bytes
-O to turn on optimizations, otherwise TIO times out because it's too slow. If you're using cargo, use --release instead.
||{let r=|s:&str,n:i64|s.repeat(n as usize);let f=|n:i64|if n<0{r("-",-n)}else{r("+",n)};let w=|n:i64|n as u8 as i64;print!("{}",(0..256).flat_map(|n|(0..9).flat_map(|a|(-9..=a).map(move|b|(a,b))).flat_map(|x|(-9..9).map(move|c|(x,c))).flat_map(|x|(-9..10).map(move|d|(x,d))).filter_map(|(((a,b),c),d)|match(0..256).scan(a,|s,_|if *s>0{*s=w(*s+d);Some(1)}else{None}).sum(){256=>None,r if w(r*b+c)==n=>Some(format!("{}[>{}<{}]{}{}",f(a),f(b),f(d),if c!=0{">"}else{""},f(c))),_=>None}).chain(vec![r("+",n),r("-",256-n)]).min_by_key(|s|s.len())).fold(format!(""),|a,b|a+&b+"
"))}

Try it online!
This generates programs in the shortest of the following 3 forms:

+++...
---... (using underflow)
a[>b<c]d, where a, b, c, and d are some number of '+' or '-' characters

Full explanation:
// Closure
|| {
    // Repeats a string (shorthand)
    let r = |s: &str, n: i64| s.repeat(n as usize);
    // Formats a constant as a sequence of '+' or '-' characters (depending on sign)
    let f = |n: i64| if n < 0 { r("-", -n) } else { r("+", n) };
    // Wraps an i64 around a u8 cell
    let w = |n: i64| n as u8 as i64;
    // Print the solution
    print!("{}",
        // For rows [0, 255]
        (0..256)
            // ... map each row to its solution
            // For a in [0, 8]
            .flat_map(|n| (0..9)
                // For b in [-9, a] (flattened to `(a, b)`)
                .flat_map(|a| (-9..=a).map(move |b| (a, b)))
                // For c in [-9, 8] (flattened to `((a, b), c)`)
                .flat_map(|x| (-9..9).map(move |c| (x, c)))
                // For d in [-9, 9] (flattened to `(((a, b), c), d)`)
                .flat_map(|x| (-9..10).map(move |d| (x, d)))
                // Calculate result of `a[>b<d]c`
                .filter_map(|(((a, b), c), d)| {
                    // Loop up to 256 times to calculate the number of times X will run in `a[>X<d]`
                    match (0..256)
                        .scan(a, |s, _| {
                            if *s > 0 {
                                *s = w(*s + d);
                                Some(1)
                            } else {
                                None
                            }
                        })
                        .sum()
                    {
                        // Assume infinite loop
                        256 => None,
                        // Finite loop, ends in the value we want, now format the values
                        r if w(r * b + c) == n => Some(format!("{}[>{}<{}]{}{}", f(a), f(b), f(d), if c != 0 { ">" } else { "" }, f(c))),
                        // Finite loop, doesn't end in what we want
                        _ => None,
                    }
                })
                // Append the trivial cases of all '+' or '-' characters
                .chain(vec![r("+", n), r("-", 256 - n)])
                // Find the shortest solution
                .min_by_key(|s| s.len())
            )
            // Join each row
            .fold(format!(""), |a, b| a + &b + "
")
    )
}

Decompressing a solution would definitely be shorter, but this was more fun in my opinion :)

GolfScript, 296 + 3628 = 3924 bytes
12.?:&{{}if}:i{&6base:c[0:x:^:h]25:e*:|"(":a")":b{["x(:x|,,?):e".a/b*"|x=(256%|x<\\|x)>++:|".a/b*"{1{c^):^=.4={;)}{5={b}i}if.c,,^)?1+:e*}do"."^)c,-"\"b"/a*+"!{e):e}i^(:^}i"+"|x="@b/a*"b"/b*"}i"++]c^==~];^):^c,=!6.?,h):h?)e*:e*}do|$)\{+}*!*.e*{c':c'@+~}i&(:&}do];255,{n'c'@)+~{'<>-+[]'1/\=}/}/"":n

Try it online!
The extra byte in the output is a newline for the code for 0, removing it requires more than one byte.
This program passes through 8 916 100 448 256 BF codes, tests if it produces only one number and stores the code. In the end the shortest code for each number is printed. This is not effitient at all, it would take millions of years to end, the estimated number of bytes in the solution assumes the shortest codes are all listed in this esolang page. This doesn't reach the memory limit or any other errors I know, it is just very slow.
12.?:&          # Assign 12^12 = 8916100448256 to &, this represents the current BF code
{{}if}:i        # This will be used to go from {code}{}if to {code}i
{  ...  }do     # Main loop, will be explained later
];              # Clean the stack
255,{  ...  }/  # Go through every number
"":n            # This removes the automatic newline that is printed

What is inside the 255,{  ... }/:
n                      # Newline
 'c'@+                 # For the N-th number push 'cN'
      ~                # Execute the string, this will push the value stored in the variable, it will be an array with the shortest code for N
       {'<>-+[]'1/\=}/ # Translate the array to a BF code

Main loop:
In the main loop there is a BF interpreter that can avoid errors. There are 3 ways something can go wrong:
1 It doesn't halt. This can be avoided by putting an operation limit. Here the limit is 14889 for the numbers 78 and 178, this means that if the code doesn't halt in 14889 operations, it is not one of the optimal codes.
2 Unpaired [ ]. We test if the instruction pointer left the code while searching for the pair. If it isn't necessary to look for the pair (Eg >>]+-), it means that that instruction is not necessary and the code will be replaced by a better one later.
3 The data pointer leaves the tape. We test if it left the tape using the same strategy used above. The tape here is only 25 bytes long, if the code needs more, it means it isn't optimal. The numbers 78 and 178 need 24 cells.
This interpreter doesn't have the , and . operations, so every BF code can be represented by a base 6 number. The problem is that a number can't start with 0, but here it isn't a problem because 0 represents <, which doesn't do anything at the start.
&6base:c                              # Convert & to base 6 and store the resulting array in c.
        [0:x:^:h]                     # Push [0] and assign 0 to x, ^ and h. x= data pointer  ^= instruction pointer  h= operation counter
                 25:e                 # Assign 25 to e, this will be the error variable, if it is 0 something went wrong
                     *:|              # Multiply [0] and 25 to get the tape called |
                        "(":a")":b    # Assign "(" to a and ")" to b
                                  {[  # Start a loop and an array

In this array we will have the 6 functions written as strings for easier manipulation:
op      string
0 <     x(:x|,,?):e
        x(:x                   # Decrement x
            |,,?):e            # Test if the result is within the tape

1 >     x):x|,,?):e            # Same thing as before but with ")" instead of "("

2 -     |x=(256%|x<\\|x)>++:|
        |x=                    # Get the value from the tape
           (256%               # Decrement mod 256
                |x<\\|x)>++:|  # Replace the old value in the array, the \\ is a \ but inside a string

3 +     |x=)256%|x<\\|x)>++:|  # Same thing as before but with ")" instead of "("

4 [     ^)c,-{1{c^):^=.4={;)}{5={(}i}if.c,,^)?1+:e*}do!{e):e}i^(:^}i
        ^)c,-{                                                    }i  # If it isn't the last byte of the code
              1{                       .c,,^)?1+:e*}do                # While the pair has not been found and the next byte to be tested is within the code
                c^):^=                                                # Get next byte
                      .4=            if                               # Is it a [ ?
                         {;)}                                         # Increment the counter
                             {5={(}i}                                 # Decrement the counter if it is a ]
                                                      !{e):e}i        # If the code ends with ] it will be counted as an error and this part solves the problem
                                                              ^(:^    # Move the instruction pointer to the left, later it will be moved to the right and the ] will be read

5 ]     |x={1{c^(:^=.4={;(}{5={)}i}if.c,,^(?1+:e*}do}i
        |x={                                        }i                # If the current cell is not 0
            1{c^(:^=.4={;(}{5={)}i}if.c,,^(?1+:e*}do                  # Same thing as before but with ( and ) swapped

[ always jumps to the ] and there it decides if the things inside should be executed.
This array is very repetitive, so we replace "x):x|,,?):e" by .a/b*, this copies the code for < and replaces the ( by ). The code for + is also replaced by .a/b*, but the code for ] is a bit more complex. The code for [ and ] will be replaced by:
"{1{c^):^=.4={;)}{5={b}i}if.c,,^)?1+:e*}do"."^)c,-"\"b"/a*+"!{e):e}i^(:^}i"+"|x="@b/a*"b"/b*"}i"++

"{1{c^):^=.4={;)}{5={b}i}if.c,,^)?1+:e*}do"             # Repeated part

."^)c,-"\                                               # Make a copy of it and push ^)c,- under that long string
         "b"/a*+                                        # Replace the b by ( and concatenate the result with the ^)c,-
                "!{e):e}i^(:^}i"+                       # Add this to the end of the string
                                 "|x="@                 # Push |x= and get that original string
                                       b/a*"b"/b*       # Replace the ) by ( and the b by )
                                                 "}i"++ # Push }i and concatenate the 3 parts

Now comes the part that executes these functions, remember that this array was created inside the loop, this means it will be recreated every time it reads a byte from the code.
]                                   # End the array
 c^=                                # Get current instruction
    =~                              # Get the function for it and execute it
      ];                            # Clean the stack, this replaces the ; that would have to be in every function
        ^):^                        # Go to next instruction
            c,=!                    # Is it NOT the last instruction?
                6.?,h):h?)          # Increment h and test if it is within the operation limit. It actually uses 6^6=46656 instead of 14889 to save 2 bytes.
                          e*:e      # Updates e
                              *}do  # Repeats everything if there were no errors

Now we just have to test if the output is valid and store it if it is.
|$                                  # Sort the tape
  )                                 # Separate the last number
   \{+}*                            # Add all other numbers in the array
        !                           # Is the sum 0?
         *                          # This will be the only non-zero cell or 0 if the output is invalid
          .e*                       # Change it to 0 if there was an error
             {        }i            # If it isn't 0 it is the code for some number, let this number be N
              c                     # Push the code
               ':c'@+~              # Store it in the variable cN
                        &(:&}do     # Go to the next code and repeat untill it gets to 0

The codes are tested in decreasing order, that way the shortest solutions will automatically replace the longer ones. The longest code is number 6774727080140 and that's why we started at such a big number.
Here are some versions of the code using other constants so we can see the output (only the found codes are outputted):
Starting at 216, this tests every 3 byte code.
From 6774727080145 to 6774727080135, includes the solution for 117.
30 codes starting at a random number

Python 3, 80 + 9839 = 9919 bytes
for n in range(1,256):m=int(n**.5);s='+'*m;print(f">{s}[<{s}>-]<{'+'*(n-m**2)}")

Try it online!
Expanded:
for n in range(1, 256):
    m = int(n ** 0.5);
    s = '+' * m;
    print(f">{s}[<{s}>-]<{'+'*(n - m**2)}")

Process:

try to do a square number amount of increments
add the remaining +'s to the end

The program loops for 1 - 255, not including 0 because while that saves 2 bytes in the input, it adds >2 bytes to the output.
The brainfuck memory is laid out so that we have [num, square_counter].
And it puts m +'s in square_counter, then m +'s every time that decrements up to 0.
Then we just add n - m^2 more pluses at the end.

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


text:
The cat ate your input again!
Create a cat program, a.k.a a program that takes an input and prints it.
...Except, the program will randomly take characters away from your input and print that instead.
Each character in the input should have generally equal odds to be removed with the program, though, as it is hard to make that, the odds for each character can vary by 10% at most.
Your program should take the input, then randomly remove characters from the input, then print that version again. (You can print with trailing newlines or other characters in case your language has to print newlines.)
If the input was BOOOWL, it shouldn't remove all Os with an equal chance: each character (not unique) should be considered, so instead of every O combined having a 1/5 chance (for example), each O should have a 1/5 chance, so, instead of there being a 1/5 chance of BWL, there should be a 1/5 chance of BOWL, BOOWL.
Input is restricted to STDIN or closest equivalent.
Each character must have a minimum of 10% and a maximum of 30% chance to be removed.
Each character's odds should be calculated individually.
You can use any component of your language supporting random actions, be it functions or something other.
Output must be through STDOUT or the closest equivalent. If your language does have STDOUT, do not output in any other way. If your language cannot output strings as text, use closest equivalent (C's character array output's OK here).
This is code golf. Shortest program wins.

Should there always be between 10% and 30% chance for a specific character to be removed? Or is that just for the purpose of the example?

Is output as an array of character allowed?

what do you mean by "sets of one character"? if the input is BOWL OF SOUP might all the O's be deleted in one go?

all answers thus far use a fixed 20% chance for a character to be removed. I'm not sure the question intent is for all characters to have the same odds.

As long as the chance is within the 10% - 30% range, it's good.

Output must be through STDOUT, as a text. Do not output a character array. <-- I have a language that allows you to output a character array (it is flattened before output). Is that disallowed? How about languages like C, where a string is basically a character array?

Use the closest equivalent. C's character array strings are OK, as they are the closest equivalent to text.

Can I add trailing newline that wasn't in input?

You specified that stdout must be used for output, bat said nothing about input. I assume that it's restricted to stdin only as well?

I'm confused by this line "so instead of every O combined having a 1/5 chance (for example), each O should have a 1/5 chance."

om nom nom nom nom

friggen cat eating my input

Japt -f, 2 bytes
5ö

The -f flag "runs the program on each element in the first input, outputting an array of those that return a truthy value." 5ö returns a random number between 0(inclusive) and 5(exclusive). Like JavaScript, 0 is falsy in Japt.
Try it

Normally one would include the flag in the byte count wouldn't you?

Python 3, 63 bytes
from random import*
for c in input():print(end=c[random()<.2:])

Try it online!
Python 2, 67 65 bytes
from random import*
print''.join(c for c in input()if.8>random())

Try it online!
Each character has a 20% chance of beeing dropped.
Different approach, same length:
from random import*
print''.join(c[random()<.2:]for c in input())

Try it online!

63 bytes in python 2 with a function

The rules explicitly state to write a full program: Create a cat program, a.k.a a program that takes an input and prints it.

This only reads the first line of input.

Problem does not state it had to read multiple lines.

Charcoal, 4 bytes
ΦＳ‽⁵

Try it online! Link is to verbose version of code. Explanation:
 Ｓ      Input a string
Φ       Filter where nonzero
  ‽⁵    Random number 0..4
        Implicitly print

You can use any number from 4 to 10 to get chances of 25% to 10% respectively.

Befunge-98 (PyFunge), 11 bytes
>#@~3j4???,

Try it online!
Each character has a 25% chance of being removed. This decision is made at the three ? instructions.
? sets the program counter to one of the four directions, with equal probability. In this case, up & down wrap back around to the same instruction, so we can ignore those as options.
There are two ways out of the forest of ?s: to the right (output) and to the left (no output). This situation is symmetric, so if starting from the middle ?, there is a \$p_2 = 1/2\$ chance of outputting. The chance of outputting if starting from the right ? is \$p_3 = 1/2 * 1 + 1/2 * p_2 = 3/4\$. Therefore, after reading a character, we jump to the rightmost ? to determine whether or not to output.

Octave, 23 bytes
Generates an array of the same size as the input (strings in Octave are character arrays), checks each of the random numbers whether it is greater than 0.2 and then uses logical indexing to extract the characters at the corresponding positions.
@(s)s(rand(size(s))>.2)

Try it online!

Pyth, 8 5 bytes
sfO4Q

Try it online!
sfO4Q   Implicit: Q=eval(input())
 f  Q   Filter characters of Q where the following is truthy:
  O4      Random number in the range [0-4)
          Any non-zero value is truthy, so this will drop characters 25% of the time
s       Concatenate into string, implicit print

Previous version, 8 bytes:
s*Vm!!O4

Try it online!
s*Vm!!O4QQ   Implicit: Q=eval(input())
             Trailing QQ inferred
   m    Q    Map each character in Q using:
      O4       Choose random integer in [0-4)
    !!         Logical NOT twice - maps 0 to 0, anything else to 1
             The result is a list of 0s and 1s, with 0 having 25% chance to appear
 *V      Q   Vectorised multiplication of the above with Q
s            Concatenate into string, implicit print

Q will throw an error if the input is not python-esque. Errors for example from [1 or a/b. Q, w and z will only work for single-line input, so the best option would probably be j.z

Jelly, 9 5 bytes
5X’µƇ

Try it online!
A monad which takes a Jelly string as its argument and returns the processed Jelly string. When used as a full program implicitly prints the output. Each character has a 20% chance of being removed.
Explanation
   µƇ | Filter using the following as a monad for each character:
5X    | - Random number between 1 and 5
  ’   | - Decreased by 1

Japt, 3 bytes
Each character has a 1 in 5 chance of being removed. The 5 can be changed to anything between 4 & 9, inclusive, or A for 10 to change the odds.
Æ5ö

Try it
Æ5ö     :Implicit input of string
Æ       :Filter by
 5ö     :  Random integer in the range [0,5), with 0 being falsey

Wolfram Language (Mathematica), 24 bytes
Select[RandomReal[]>.2&]

Try it online!
Takes a list of characters as input. Each character has a .2 chance to be removed.

05AB1E, 5 4 bytes
ʒ₄Ω≠

-1 byte thanks to @Grimy.
Try it online or run the same program 10 times.
Each character has a 25% change of being dropped.
Explanation:
ʒ     # Filter the characters of the (implicit) input-string by:
 ₄    #  Push 1000
  Ω   #  Pop and push a random digit from it
   ≠  #  And check that it's NOT 1 (!=1)
      # (after which the result is output implicitly)

≠ could also be _ (==0).

5L can be ₄ for -1 (changes the chance from 20% to 25%, which is still acceptable).

@Grimy Nice one, thanks! :)

MATL, 9 bytes
t&n&r.2>)

Exaplanation:
t         implicitly take input and duplicate it
 &n       compute the size of the input and...
   &r     generate a random array of that size
     .2>  check which entries of that array are greater than 0.2
        ) and use the result using logical indices to extract certain characters of the input

Try it online!

Cubix, 20 bytes
u$w\A|UDw@?;...>o._U

Try it online!
Longer than I had hoped as I had a number of no-ops that I can't seem to get rid of.  The chance to drop a character is 25%.  I assume this is okay.
    u $
    w \
A | U D w @ ? ;
. . . > o . _ U
    . .
    . .

Watch it run
Brief explanation:

A|A this initialises the the stack, Input all, reflect back, Input all (just an EOI -1)
;? pop to of stack, test for EOI (-1).
_?@ if negative, reflect back into test and end on halt
$D jump the \ into the random direction setter.

from the direction setter, 3 direction lead to the o for output then back into the loop, one misses the o in it's path and goes straight to the loop.

APL (dzaima/APL), 10 9 bytesSBCS
Anonymous tacit prefix function. Each character has exactly 20% chance of being removed.
⊢⌿⍨4≥∘?5¨

Try it online!
5¨ zero for each character
? random integer range 1–5 for each character
4≥ Boolean mask for those integers that are less than or equal to 4
⊢⌿⍨ filter the argument using that mask

Retina, 15 bytes
/./_?(`.

Try it online! Explanation:
/./_

Process each character individually.
?(`

Perform a substitution at random. The first substitution deletes the character, while the other three leave it unchanged, thus giving a 25% chance of deleting the character. This can be decreased as necessary by appending additional pairs of newlines.

R, 32 23 bytes
function(x)x[rt(x,3)<1]

Try it online!
A function taking a character vector as input and returning a processed character vector. Each character has a 20% chance of being removed.
Thanks to @Roland and @Giueseppe for helping save 7 bytes, and @JDL for a further 2!

function(x)x[!rbinom(x,1,0.2)]

along the same lines as @Roland, function(x)x[rf(x,1,1)>1]; df(1,1,1) is about 0.16 which does the trick.

or rt(x,3)>1 (about 20% chance)

@JDL it’s <1, but thanks! Another 2 saved.

T-SQL 2012, 83 bytes
Looping through the input from right to left removing 0 or 1 character.
25% chance for each character getting removed.
DECLARE @i varchar(max)='The cat ate my homework'

DECLARE @ int=len(@i)WHILE @>0SELECT
@i=stuff(@i,@,str(rand()*2)/2,''),@-=1PRINT @i

Explanation:

rand()*2 returns a float, which can't be used in the stuff command.
The str converts this into a varchar after rounding to nearest whole number. The float is being converted to a varchar(which isn't allowed as third parameter in stuff either).
This varchar has a 25% chance of being '2', 50% chance of being '1', 25% chance of being '0'. Dividing by 2, there is a 25% chance of result being 1. This division converts the varchar to an integer.
Integer is the expected third parameter in stuff function.

Try it online

Very nice trick with STR, I will have to remember that. Not sure it is fair to piggyback off your (uncounted) DECLARE in your (counted) code; but changing that would only cost you 1 byte, since you can eliminate the extra SET with DECLARE @ INT=len(@i)

@BradC I agree, and I will try to remember not to piggyback in the future

PHP, 43 42 bytes
for(;''<$l=$argn[$i++];rand()%5&&print$l);

Try it online!
Each character has 20% of chance to be removed.

J, 10 bytes
#~5>6?@$~#

Try it online!
Similar to Adam's APL answer, though I actually wrote it before looking at his.

6.. $~ # Take the length of input # and shape $~ the number 6 into a list that long.
?@ Treat each six in that list as a die and roll ? it.
>5 Is the die less than 5 (possible values are 0..5)?  Use that boolean result to create a bit mask.
#~ Filter the input with that mask.

C# (Visual C# Interactive Compiler), 71 bytes
var y=new Random();foreach(var k in ReadLine())if(y.Next(5)<4)Write(k);

Try it online!

I think that < 1 is eating too much. Maybe <3 or < 4 matches the parameters of the problem. Anyway this does not change the length of the code.

I haven't programmed in C# in a while, but why is't new Random().Next(5) directly possible?

@KevinCruijssen Because then the same seed will be used for each number, so each number be the same. Just try it with new Random().Next(5), all you will get is the whole input or nothing.

@Luca You're right, changed

@EmbodimentofIgnorance Yea, I noticed the output, I just don't really get how var y=new Random() with y.Next uses different seeds. You're still creating the Random-instance just once, and use .Next multiple times on it.. As a Java developer, I would expect both to either use the same seed or not. In Java they don't: Try it online. Which is why I'm confused..

@KevinCruijssen when using new Random(), the default seed value is Environment.TickCount, which increments every millisecond. If they're all created in the same millisecond tick, they will all have the same seed.
The answer is only using a single instance of Random, and when it's called it updates the internal seed value - so each time Next() is called, it creates a different output value.
.Net Core however uses a singleton RNG to generate the seed, so it doesn't have this problem

is it allowed to have a statement that gets executed outside your function

@LiefdeWen To be honest, I don't know, but I'm following the precedent set by these answers: https://codegolf.stackexchange.com/a/188896/84206, https://codegolf.stackexchange.com/a/185440/84206, https://codegolf.stackexchange.com/a/185737/84206. I remember more, but those are the ones that I have tracked down

@EmbodimentofIgnorance Okay, works for me

42 bytes?

@LiefdeWen Because the seed is always the index, you will always get the same result on each call.

@Holger Next(5) generates either 0, 1, 2, 3, or 4. 4 is not less than 4, so it is 80% of success

@EmbodimentofIgnorance Ok, I was confused by never seeing a char removed. But then, that’s pure chance, because of the rather small sample input.

@EmbodimentofIgnorance Does it need to be different per run? As far as I understand it just needs to have a different random seed per character

Input is restricted to STDIN or closest equivalent. and Output must be through STDOUT or the closest equivalent. If your language does have STDOUT, do not output in any other way. I'm 99.99% sure C# has STDOUT.

@BenjaminUrquhart Fixed, but added 26 bytes. Also, one can argue doesn't say input has to be from STDIN, but restricted to STDIN or closest equivalent, and function arguments may be the closest equivalent, but I'm not going to do that

Perl 5 -p, 18 bytes
s/./.2<rand&&$&/ge

Try it online!
Each character has a 20% chance of being dropped.

Javascript,  46   44  51 bytes
i=>alert([...i].filter(c=>Math.random()>.2).join``)

+7 bytes because of the added STDOUT requirement
-2 bytes thank to Birjolaxew

original answer:
44 bytes without the STDOUT requirement
i=>[...i].filter(c=>Math.random()>.2).join``

Since you don't use the name of the function, you're allowed to just provide the function itself. Removing f= gets you down to 44 bytes. You may also input/output as an array, which should save you quite a bit.

@Birjolaxew I'm not sure but as I understand it the question disallow the use of char array if the language has string

Yes, Andrew edited the question with additional requirements after my comment. This is generally frowned upon because it invalidates answers that were previously valid (in this case it's even debatable whether your initial answer fits the "Output must be through STDOUT" requirement).

What does join\`` mean? Can't find it in the spec (cause I don't really know what it is)

@nickzoum in es6 it is equivalent to join("") mdn revelent page

Scala, 51 46 30 bytes
s=>s.flatMap(x=>if(math.random>.2)Some(x)else None)

Try it online!
PS. Like in many other solutions, the probability of dropping char is 20%.
Update:
-5 bytes by using String instead of Option[String] in flatMap
s=>s.flatMap(x=>if(math.random>.2)x+""else "")

30 bytes by using filter
s=>s.filter(x=>math.random>.2)

You can shave off 7 bytes by changing scala.math.random to math.random and 0.2 to .2. Nice trick using ^ like that.

@KjetilS, thank you. I also posted function literals instead of function definitions as a solution. It is acceptable according to this: https://codegolf.stackexchange.com/questions/3885/tips-for-golfing-in-scala

You could save 3 bytes with _.filter

C (gcc), 50 bytes
This program has a 20% chance of dropping a letter. Unfortunately the random number generator isn't seeded so you get the same sequence on each run. Basically the only trick is inverting the input character to halt the loop on EOF.
main(c){for(;c=~getchar();rand()%5&&putchar(~c));}

Try it online!
C (gcc), 64 59 bytes
Thanks to ceilingcat for the -5 bytes.
If you want the RNG seeded on each run.
main(c){for(srand(&c);c=~getchar();rand()%5&&putchar(~c));}

Try it online!

You don't have to use main() for Code Golf submissions, you can also define an arbitrary function that does what is required. So you can write f(c){...}.

Zsh, 53 41 40 bytes
Try it Online!
for c (${(s::)1})((RANDOM%4))&&printf $c

Converts the input to an array of characters, then tries to print each element c, unless it's eaten by the ((RANDOM%4)) evaluating to false!
53 bytes, Original
41 bytes, thanks to @GammaFunction

Smart use of \c, I would not have remembered that! There's still a few optimizations to be made...

Nice, clever use of RANDOM and array conversion

Lua, 69 68 bytes
for c in io.lines(nil,1)do io.write(math.random()>.2 and c or '')end

Try it online!
Kinda straightforward, but seems to be shortest version: iterate over stdin char by char (with io.lines… that name is misleading), then based on random value either print one or empty string (e.g. nothing).

Java
Non-terminating: 82 bytes
v->{for(int i;;i=System.in.read(),System.out.print(Math.random()<.2?"":(char)i));}

Terminating (TIO): 105 bytes
v->{var n=System.in;for(int i;n.available()>0;i=n.read(),System.out.print(Math.random()<.2?"":(char)i));}

Is dealing with stdout really necessary? Other answers only create a function just converting a string. Seems unfair towards Java. If this C# solution is valid, then s->s.filter(c->Math.random()<.2) is too.

@Holger Input is restricted to STDIN or closest equivalent. and Output must be through STDOUT or the closest equivalent. If your language does have STDOUT, do not output in any other way. So no, that answer is not valid

MathGolf, 5 bytes
æƒ√∞*

Try it online!
Explanation
æ       foreach character...
 ƒ      random float in range [0,1)
  √     take square root (making P(x < 0.5) = 0.25)
   ∞    pop a, push 2*a
    *   repeat character int(x) times

Each character will be repeated 0 or 1 times, depending on the random value. Since the expected value after the square root is shifted, there is a 25% probability that each character is removed.
Alternative 5-byter
gÉ;4w

Filter the characters by a random number in [0, 4]. Due to how filtering works, I have to discard the actual character within the filter loop, which adds 1 byte.

Zsh, 50 bytes
for c (${(s::)"$(<&0)"})
((RANDOM%5))&&echo -nE $c

Try it online!
Similar to RobLogic's answer, but following the input requirements more closely, and works for inputs with backslashes.
"$(<&0)" instead of "<&0" or $(<&0) because the first doesn't work in substitutions, and the second eats newlines. The -nE flags are necessary to prevent backslashes from being parsed as escape sequences, and to prevent newlines being inserted.
echo -nE

GFortran, 120 bytes
Not too bad, if we use the deprecated RAN() function, which is pseudo-random, i.e. you get the same sequence each time. The proper way to generate random numbers in GFortran is with CALL RANDOM_SEED() and CALL RANDOM_NUMBER(R) but that's a lot of bytes!
character(99)S;read(*,'(A)')S;do i=1,len_trim(S)
if(ran(0)*5.gt.1)then;write(*,'(A)',advance="no")S(i:i)
endif;enddo;end

Try it online!

Pseudo randomness is allowed, if that is the closest way you have to making random actions take hold.

Oracle SQL, 133 bytes
select listagg(decode(sign(dbms_random.value-0.2),1,substr(x,level,1)))within group(order by level)from t connect by level<=length(x)

It works with an assumption that input data is stored in a table t(x), e.g.
with t(x) as (select 'The cat ate my homework' from dual)

Python3, 61 bytes
Does this count? I guess if you consider execution across seconds of time "random"
import time
for c in input():print(end=c[time.time()%5<1:])

Welcome to the site! Is it possible you could add a link to an online testing site, such as TryItOnline!, so that other users can verify your answer? Especially given that, as far as I can see, this doesn't remove any characters when run.

Pepe, 61 bytes
REEerEERREeeeeEeEeREEeEerEEEEErrEEReReEeRRERRErEereereReReree

Try it online!
There is 11.11% or \$\frac{1}9\$ chance of characters being deleted.
Explanation:
... # some-command -> (stack) // some-explanation
REEe # Input (str) -> (R)
rEE # Create label 0 -> (r) // main loop begins
  RREeeeeEeEe # Push 10 -> (R) // this is for the randomiser
              # R flag: place it in the beginning
  REEeEe # Random number from 1 to 10 -> (R)
  rEEEEE # Increment -> (r) // 0 > 1, for the next command
  rrEE # Create label 1 -> (r) // without previous command, the existing label 0 is replaced
       # r flag: Skip until rEe (return)
    Re # Pop -> (R) // removes the random number
    ReEe # Output as char & pop it -> (R)
    RRERRE # Push 0 2 times -> (R) // these are popped to fix the pos of R stack
  rEe # Return to where goto was called
  ree # Goto 1 if 1 != random from 1 to 10 // The whole rrEE ... rEe ree is an if..then
  re # Pop -> (r)
  ReRe # Pop 2 times -> (R)
ree # Loop while char of (R) != 0

Ruby -p, 27 bytes
The -p flag takes each line of input as the global variable $_ and runs it through the code block and then prints its contents. gsub modifies $_ by replacing characters that match the given regex (only works if -p or -n is present).
gsub(/.|\n/){$&if rand>0.2}

Try it online!

Gaia, 10 bytes
⟨w8&Ø+ṛ⟩¦$

Try it online!
Has a 1/9th (11%) chance of removing any given character. This abuses the fact that the meta ¦ treats a string as a list, much as Python does.
 ⟨	⟩¦	| for each character do:
  w8&		| wrap as list and duplicate 8 times
     Ø+		| add empty string to that list
       ṛ	| select element at random
	  $	| and join with no separator
		| implicitly print top of stack

Vyxal s, 4 bytes
'₀ʁ℅

Try it Online!
Each  char has 10% chance to be removed.
'    # Filter by...
   ℅ # Random choice from
 ₀ʁ  # 0...10

Thunno 2, 4 bytes
æ5Lɼ

Try it online!
Explanation
æ5Lɼ  # Implicit input
æ     # Filter it by:
   ɼ  #  Random number from
 5L   #  [0, 1, 2, 3, 4]
      #  (×, ✓, ✓, ✓, ✓)
      # Implicit output


text:
Print an array as a table
Write a program that prints an associative array (key-value) to a table.
Requirements

Standard loopholes are forbidden
Please include a link to an online interpreter and the byte count  in the answer
Use box drawing characters  to draw the table.
You can write both a full program or a function.
Key or value can't contain multiline strings.
Value/key can't be an array/associative array ( example: ["a"=>["a"=>"b"]] or  ["a"=>["a","b"]] )

Special cases

If the programming language lacks of associative array , you can use a list of pairs. Example:  [[key1,value1],[key2,value2]]
You can insert horizontal lines between successive pairs.
An input array can't be empty

This is a code-golf, the answer with the shortest byte count wins!
Challenge
Your code must draw a vertical table like in the example from a associative array . The key must be at left and value must be at right and them needs to be separed,you can choose how separe them. Every key-value pair must be in another row.
There must be only 2 columns for the keys and value.
Example
Array(PHP):
["a"=>"b","c"=>"d","d"=>"d"]
Output:
┏━━━┓
┃a┃b┃
┃c┃d┃
┃d┃d┃
┗━━━┛

Thanks, please edit the post accordingly (we prefer not to have spec in comments). Also what are the rules regarding justification? (e.g ["abba"=>"1","b"=>"20"])

Can we use any normal box drawing characters instead of the heavy ones?

Can we use ┬ and ┴ when separating the columns?

@PurpleP there is no specification about justification

Maybe for next time, use the sandbox to get all the questions answered before posting?

@Adám yes, i fixed my question

While I'm still waiting for an answer about the 3-way pieces, does the separators between names and values have to line up?

separators between key-values not necessary have to line up and yes, you can use 3 way pieces @Adám

@MicioInformatico "Value/key can't be an array" doesn't quite work, as "a list of pairs" is also an array, and, well, an "associative array" is obviously also an array.

I mean, you cant do this : ["a"=>["x"=>"b"],"c"=>["d"=>"b"]] ( in languages without associative array [[key1,[x=>value1]],[key2,[d=>value2]])

"An imput array can't be empty"

@MicioInformatico OK, so we can take input as an N-row 2-column matrix?

TryAPL, 1 byteSBCS
Anonymous tacit prefix function. As TryAPL has no associative arrays, this takes a list of pairs as argument.
↑

Try APL!
↑ mix the list of pairs into a table

Question over, go home folks.

J, 1 byte
>
So… to take strings as input they need to be in boxes already, and to make them pairs I think they need to be put into a box again so that they can be treated separately. I'm not too sure about the second part.
Anyway, unboxing the whole thing gives the desired form.
I get a sense that this could be a 0 byte answer if we twist the format enough (or maybe less, since a 2d array of boxes seems to be the proper input format instead of my weird format), but I don't understand boxing all that well.
Try it online!

PHP, 563 bytes
<?php
    $t = ["a"=>"b","c"=>"d"];
    $k = $v = $i = $j = 0;
    foreach ($t as $a => $b){
        $k = (strlen($a) > $k ? strlen($a) : $k);
        $v = (strlen($b) > $v ? strlen($b) : $v);
    }
    echo "┏"; for(; $i++ < $k + $v + 3;) echo "━";
    echo "┓\n";
    foreach ($t as $a => $b){
        echo "|{$a} ";
        for($i = 0; $i < $k - strlen($a); $i++) echo " ";
        echo "| {$b}";
        for($i = 0; $i < $v - strlen($b); $i++) echo " ";
        echo "|\n";
    }
    echo "┗"; for(; $j++ < $k + $v + 3;) echo "━";
    echo "┛";
?>

Try it online!

Charcoal, 62 bytes
Ｆ²⊞υ×━⌈ＥθＬ§κι⟦⪫┏┓⪫υ┳⟧Ｅθ⪫┃┃⪫Ｅι◨λＬ§υμ┃⪫┗┛⪫υ┻

Try it online! Link is to verbose version of code. Charcoal's code page doesn't include box-drawing characters so they cost 3 bytes but the code uses them instead of their three-byte encoding because it looks nicer. Takes input as an array of tuples as Charcoal doesn't have an iterable dictionary. Explanation:
Ｆ²⊞υ×━⌈ＥθＬ§κι

Find the length of the longest key and value and repeat ━ according to that length.
⟦⪫┏┓⪫υ┳⟧

Embed the ━s in ┏┳┓.
Ｅθ⪫┃┃⪫Ｅι◨λＬ§υμ┃

For each tuple, pad the strings to the length of the ━s and wrap them with ┃s.
⪫┗┛⪫υ┻

Embed the ━s in ┗┻┛.

Python 3, 189 172 168 173 169 bytes
def f(d):t=d.items();a,b=map(lambda*l:max(map(len,l)),*t);c='─'*a,'─'*b;print("┌%s┬%s┐"%c,*[f"│{k:{a}}│{v:{b}}│"for k,v in t],"└%s┴%s┘"%c,sep="\n")

Try it online!


text:
Is this n-speak?
Inspired by Is it double speak?, I devised a harder challenge. Given a string, determine if the string is n-speak, for any \$n\geq 2\$.
N-speak is defined by repeating each letter \$n\$ times. With \$n = 4\$, the string Hello is transformed to HHHHeeeelllllllloooo. Your goal is to figure out if the input is a valid output for any n-speak transformation.
It should be noted that any sentence which is valid n-speak, for \$n = 2k\$, is also valid k-speak. Thus, the hard parts to solve will be odd values of \$n\$.
Input
A string consisting of at least 2 characters. Input could also be a list of characters. Input is case sensitive.
Output
Truthy if the string is n-speak, falsey otherwise.
Examples
True cases
HHeelllloo,,  wwoorrlldd!!
TTTrrriiipppllleee   ssspppeeeaaakkk
QQQQuuuuaaaaddddrrrruuuupppplllleeee    ssssppppeeeeaaaakkkk
7777777-------ssssssspppppppeeeeeeeaaaaaaakkkkkkk
999999999
aaaabb
aaaaaaaabbbbcc
aaaaabbbbb
@@@

If you want to generate additional truthy cases, you can use this MathGolf script. Place the string within the quotation marks, and the value of \$n\$ as the input.
False cases
Hello, world!
TTTrrriiipppllleee   speak
aaaaaaaaaaaaaaaab
Ddoouubbllee  ssppeeaakk
aabbab
aaaabbb
a (does not need to be handled)
(empty string, does not need to be handled)

Of course, since this is code golf, get ready to trim some bytes!

Suggested test case: aabbab

Suggested test case: aaaabbb

I'll add them both tomorrow, good suggestions.

I am genuinely honoured and flattered that you have used and expanded my challenge :)

@AJFaraday glad that you liked it! I enjoyed both of your challenges, which gave me the idea for this one. There might be an even harder challenge coming soon.

@maxb by all means. Although I find that relatively simple challenges often get more response. Just think to yourself "If I saw this, would I automatically start thinking about how to code it". Those are the winners :)

When is someone going to post "n-speak"? ;)

"It should be noted that any sentence which is valid n-speak, for n=2k, is also valid k-speak. Thus, the hard parts to solve will be odd values of n." This is an interesting claim since your examples are $n=2$ and $n=4$ which can't be reduced to odd values.

@JiK the 2nd, 4th, 5th, and 9th test cases are all odd numbered. It was mostly an observation that for every even case, a solution to the original Is is double speak? challenge would also would also be correct.

APL (Dyalog Unicode), 12 bytes
Runs with ⎕io←0
1≠∨/⍸2≠/∊0⍞0

Try it online!
Golfed together with Adám.
On the input (example: "aaccccaaaaaabb", using "" to denote a string (an array of chars) and '' to denote a char)
∊0⍞0 surround with 0s and flatten, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0
2≠/ perform pairwise not-equal, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1
⍸ get the 0-indexed indices, 0 2 6 12 14
∨/ compute the GCD, 2
1≠ is this not equal to 1?

Java 10, 85 bytes
s->{var r=0>1;for(int i=0;++i<s.length();)r|=s.matches("((.)\\2{"+i+"})*");return r;}

Regex ported from @Arnauld's JavaScript answer.
Try it online.
Explanation:
s->{                          // Method with String parameter and boolean return-type
  var r=0>1;                  //  Result-boolean, starting at false
  for(int i=0;++i<s.length();)//  Loop `i` in the range [1, input-length):
    r|=                       //   Change the result to true if:
      s.matches("((.)\\2{"+i+"})*");
                              //    The input-String matches this regex
                              // NOTE: String#matches implicitly adds a leading ^ and
                              //       trailing $ to match the full String
  return r;}                  // After the loop, return the result-boolean

Regex explanation:
^((.)\2{i})*$                 // Full regex to match, where `i` is the loop-integer
^           $                 // If the full String matches:
  (.)                         //  A character
     \2{i}                    //  Appended with that same character `i` amount of times
 (        )*                  //  And that repeated zero or more times for the entire string

Jelly, 5 bytes
Œɠg/’

Try it online!

05AB1E, 5 bytes
γ€g¿≠

Try it online!

I thought my 14-byter in MathGolf was a good one, but you just crushed it. I'd love an explanation both for this and your Jelly answer.

@maxb It really just takes the lengths of the group runs, calculates their GCD and tests if it's not 1.

JavaScript (ES6), 53 bytes
Derived from the regular expression used by @wastl in Is it double speak?.
s=>[...s].some((_,n)=>s.match(`^((.)\\2{${++n}})*$`))

Try it online!

Recursive version, 55 bytes
s=>(g=n=>s[++n]&&!!s.match(`^((.)\\2{${n}})*$`)|g(n))``

Try it online!
Commented
s => (                    // s = input string
  g = n =>                // g is a recursive function taking a repetition length n
    s[++n] &&             // increment n; abort if s[n] is not defined
    !!s.match(            // otherwise, test whether s consists of groups of:
      `^((.)\\2{${n}})*$` //   some character, followed by n copies of the same character
    )                     //
    | g(n)                // or whether it works for some greater n
)``                       // initial call to g with n = [''] (zero-ish)

Python 2, 73 70 69 67 bytes
lambda s:s in[''.join(c*n for c in s[::n])for n in range(2,len(s))]

Try it online!
-4 bytes, thanks to Jitse

You can save 3 bytes by replacing set(...) with {...}

Also, you can remove the space in ...1 in[...

QuadS, 16 bytesSBCS
1≠∨/⍵
(.)\1*
⊃⍵L

Try it online!
1≠ is 1 different from
∨/ the GCD
⍵ of the result of
(.)\1* PCRE Searching for any character followed by 0 or more repetitions thereof
⊃⍵L and returning the first of the match lengths (i.e. the length of the match)

Stax, 5 bytes
╢b}▄;

Run and debug it
Procedure:

Calculate run-lengths.
GCD of array
Is > 1?

T-SQL 2008 query, 193 bytes
DECLARE @ varchar(max)='bbbbbbccc';

WITH C as(SELECT number+2n,@ t
FROM spt_values
WHERE'P'=type
UNION ALL
SELECT n,stuff(t,1,n,'')FROM C
WHERE left(t,n)collate Thai_Bin=replicate(left(t,1),n))SELECT 1+1/~count(*)FROM C
WHERE''=t

Try it online

Is "collate Thai_Bin" really necessary?

@DrYWit it depends, the database could be set up as case sensitive. But case sensitive databases are not a popular choice. This could be handled better differently using HASHBYTES or maybe VARBINARY, but  that is more costly in bytes

Python 3, 69 bytes
lambda s:any(s=="".join(i*k for i in s[::k])for k in range(2,len(s)))

Try it online!

PHP, 76 75 bytes
while(($x=strspn($argn,$argn[$n+=$x],$n))>1&&($m=max($m,$x))%$x<1);echo!$x;

Try it online!
First attempt, a somewhat naïve iterative approach.
Ungolfed:
// get the length of the next span of the same char
while( $s = strspn( $argn, $argn[ $n ], $n ) ) {

    // if span is less than 2 chars long, input is not n-speak
    if ( $s < 2 ) {
        break;
    }

    // k is GCD
    $k = max( $k, $s );

    // if span length does not divide evenly into GCD, input is not n-speak
    if( ( $k % $s ) != 0 ) {
        break;
    }

    // increment current input string index
    $n += $s;

}

-1 byte, thx to @Night2!

Perl 6, 30 27 26 bytes
{1-[gcd] m:g/(.)$0*/>>.to}

Try it online!
Also uses the GCD trick, but uses the index of the end position of each run matched by the regex. Returns a negative number (truthy) if n-speak, zero (falsey) otherwise.

Haskell, 48 bytes
import Data.List
f=(>1).foldr(gcd.length)0.group

Try it online!
Straightforward; uses the GCD trick.

Red, 80 bytes
func[s][repeat n length? s[if parse/case s[any[copy t skip n t]][return on]]off]

Try it online!
More idiomatic Red:
Red, 81 bytes
func[s][any collect[repeat n length? s[keep parse/case s[any[copy t skip n t]]]]]

Try it online!

Japt -¡, 8 bytes
ò¦ mÊrÕÉ

Try it
ò¦ mÊrÕÉ     :Implicit input of string
ò            :Partition by
 ¦           :  Inequality
   m         :Map
    Ê        :  Length
     r       :Reduce by
      Õ      :  GCD
       É     :Subtract 1
             :Implicit output of boolean negation

Brachylog, 5 bytes
ġz₂=Ṁ

Try it online!
Takes input through the input variable and outputs through success or failure.
At first I thought this would actually be shorter than my solution to Is it double speak?, but then I realized that ġ can and will try a group length of 1.
ġ        It is possible to split the input into chunks of similar length
 z₂      such that they have strictly equal length, and zipped together
    Ṁ    there are multiple results
   =     which are all equal.

Kotlin, 78 bytes
{s->(2..s.length/2).any{i->s.chunked(i).all{z->z.length==i&&z.all{z[0]==it}}}}

Try it online!
Explanation
{s->                      Take a string as input
  (2..s.length/2)         The each string needs two parts at least, prevents the case "aaa" is 3-speak
    .any{i->              If there is any n (in this case i) that is n-speak return true
      s.chunked(i)        Split into length i substrings
      .all{z->            All substrings z
        z.length==i       Should be completely full, ie. "aaa"->["aa","a"]
        &&                And
        z.all{            All chars (it)
          z[0]==it        Should be the same as the first char
        }
      }
    }
  }

Perhaps the description is unclear, but "aaa" is valid 3-speak. The input string should have at least two characters, but they do not need to be different.

@maxb, ok cool. That should be -2 bytes. Thanks for the update. I'll fix that tomorrow

Scala, 80 bytes
s=>"(.)\\1*".r.findAllIn(s).map(_.size).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1

Try it online!
PS. Original solution was based on split function but it's longer (83 bytes).
s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1

This returns true for input aab, unfortunately.

@maxb, thanks for checking. s. replaced with (s+s). to handle that.

Good job! Though now I noticed that it fails for aaaabb and aabbbb.

@maxb, apologies, now I tested on all your test cases from starting post.

Wolfram Language (Mathematica), 34 bytes
GCD@@Length/@Split@Characters@#>1&

Try it online!

Perl 5 -p, 83 79 76 74 bytes
$_=s,(.)\1+,$t=length$&;$t/=2while$t%2-1;$r+=$t==($g||=$t);'',ge==$r&&/^$/

Try it online!

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

Try it online!
Uses the same GCD trick that many other submissions use.  Output is 0 if the input is not n-speak, and a positive integer otherwise.
# For each character in the input
{

  # Add 1 to current run length
  <>({}())<>

  # If current and next characters differ:
  ({}[({})]){

    # Clean up unneeded difference
    {}<>

    # Move current run length to left stack, exposing current GCD on right stack
    ({}<>)

    # GCD routine: repeat until L=0
    {

      # Compute L mod R
      {(({})){({}[()])<>}{}}<>

      # Move R to left stack; finish computing L mod R and push to right stack
      ([{}()]({}<>)<>)

    }

    # Push 0 for new run length
    (<>)<>

  }{}

}

# Output GCD-1
<>{}({}[()])

Oracle SQL, 182 bytes
select+1-sign(min(length(x)-(select sum(length(regexp_substr(x,'(.)\1{'||i||'}',1,level)))from t connect by level<length(x))))from(select x,level i from t connect by level<length(x))

It works with an assumption that input data is stored in a table t(x), e.g.
with t(x) as (select 'HHeelllloo,,  wwoorrlldd!!' from dual)

K (ngn/k), 29 23 bytes
{~|/(&/s@&1<s)!s:#'=:x}

Try it online!
edit: removed some unnecessary colons (i know when a monadic is required but it's not always clear to me if there's ambiguity so i default to including the colon) and changed the mod x-y*x%y to ngn/k's y!x, which meant i could remove a variable assignment

APL (Dyalog Unicode), 24 22 bytesSBCS
Anonymous tacit prefix function.
⊂∊1↓⍳∘≢{⍵/⍨(≢⍵)⍴⍺↑⍺}¨⊂

Try it online!
⊂ enclose the string to treat map using the entire string
 e.g. "aaabbb"
⍳∘≢{…}¨ for each of the ⍳ ɩndices 1 through the tally of characters in the string:
 e.g. 3
 ⍺↑⍺ take the current number of elements from the current number, padding with 0s
 e.g. [3,0,0]
 (≢⍵)⍴ cyclically reshape into the shape of the tally of characters in the string
  e.g. [3,0,0,3,0,0]
 ⍵/⍨ use that to replicate the string's characters
  "aaabbb"
1↓ drop the first one (n = 1)
⊂∊ is the the entire string a member of that list?

Are you dividing the input string into n-sized chunks, and checking that all characters are equal within each chunk? I haven't gotten into APL, but it's definitely the most readable "golfing" language.

@maxb I'm in the process of writing an explanation. I'm filtering with all possible masks [1,0,0,1,0,0…] etc. I'll be happy to teach you APL (it doesn't take long to learn). Just pop unto the APL Orchard.

Here's {1<∨/≢¨⍵⊆⍨≢∘∪¨,\⍵} for 18

@Cowsquack Clever, and different, so why don't you post {1<∨/≢¨⍵⊆⍨≢¨∪\⍵}?

Unfortunately it fails for aacccaaaaabb

@Cowsquack 1<∨/≢¨0⊂⍨1,2≠/⍞ then

@Cowsquack 1<∨/2-/⍸2≠/∊0⍞0 works too.

I suppose at this point you can just post the answer :P

---That (1<∨/2-/⍸2≠/∊0⍞0) is a nice answer btw--- Actually wait it fails for 999999999 but that can be fixed by changing the 1< to 1≠

Here's 1≠∨/⍸2≠/∊0⍞0 with ⎕io←0

@Cowsquack OK, you post then (I don't need rep) and we'll call it a collaborative effort :-) Try it online!

Japt -mR, 12 bytes
ÊÆóXÃ¤d_äe e

Try it

Retina 0.8.2, 28 bytes
M!`(.)\1*
.
.
^(..+)(\1|¶)*$

Try it online! Link includes test cases. Explanation:
M!`(.)\1*

Split the text into runs of identical characters.
.
.

Replace them all with the same character.
^(..+)(\1|¶)*$

Check whether the GCD of the lengths of the runs is greater than 1.

MathGolf, 14 bytes
£─╞möl╠mÅ▀£╙╓┴

Try it online!
Explanation
Checks all possible divisions of the input string into equal length chunks, and checks if there is a partition in which all chunks have just one unique character.
£                length of string with pop
 ─               get divisors
  ╞              discard from left of string/array (removes 1)
   mö            explicit map using 7 operators
     l           push input
      ╠          divide input into chunks of size k
       mÅ        explicit map using 2 operators
         ▀£      number of unique elements of list
           ╙     get maximum number of unique characters per chunk
                 loop ends here
            ╓    get the minimum of all maximums
             ┴   check if equal to 1

Gaia, 10 bytes
ẋl¦d¦&⊢⌉1>

Try it online!
Same "GCD of run-lengths > 1" as many other submissions use.
There is a bug in ė (run-length encoding) that drops the last unique element of the list, otherwise we could have the following 9 byte solution: ė(¦d¦&⊢1>.

Pyth, 7 bytes
Outputs 0 for falsy inputs or a positive integer otherwise.
tiFhCr8

Try it online!

D , 126 bytes
bool f(string s){import std.algorithm;auto a=s.group.minElement!(a=>a[1])[1];foreach(g;s.group)if(g[1]%a)return 0;return a>1;}

First code golf I've done in D.
Does not handle empty input strings (causes an assertion failure in the standard library).
Ungolfed version:
bool f(string s) {
    import std.algorithm; // for group and minElement

    // splits the string into a groups of the same character
    // eg. "HHHiii".group returns
    // [Tuple!(char, uint)('H', 3), Tuple!(char, uint)('i', 3)]
    auto groups = s.group;

    // gets the smallest group length
    auto min_length = groups.minElement!(a => a[1])[1];

    foreach(g; groups) // for each group
        if(g[1] % min_length) // if it's length is not divisible by smallest length
            return 0; // return false

    return min_length > 1; // return true if smallest length was above 1
}

Pyth, 8 bytes
<1iFhMr8

Try it online!
<1iFhMr8Q   Implicit: Q=eval(input())
            Trailing Q inferred
      r8Q   Run length encode Q into [count, character]
    hM      Take first element of each
  iF        Reduce by GCD
<1          Is 1 less than the above? Implicit print

Perl 5 -n, 38 bytes
for$i(1..y///c){print/^((.)\2{$i})*$/}

Try it online!
The print"\n" in the footer is needed to separate the outputs.
Straightforward loop through all possible ns. Outputs nothing for "1-speak", anything else for n-speak where n > 1.

C# (Visual C# Interactive Compiler), 76 bytes
s=>s.Where((_,n)=>s.Count%(n+=2)<1&!s.Where((c,i)=>c!=s[i/n*n]).Any()).Any()

Try it online!
Generate all n from 2, 3, 4, ... and do the following:

Check if the length of input is divisible by n
Compare each character of input to the corresponding character of an n-speak string

If both checks pass, the input string is n-speak.