text:
Text to Brain-Flak
Your challenge is to turn input text to brain-flak code that will output the text.
Tutorial taken from here with permission here
Brain-Flak has two stacks, known as 'left' and 'right'. The active stack starts at left. If an empty stack is popped, it will return 0. That's it. No other variables. When the program starts, each command line argument is pushed on to the active stack.
The only valid characters in a Brain-Flak program are ()[]{}<>, and they must always be balanced. There are two types of functions: Nilads and Monads. A nilad is a function that takes 0 arguments. Here are all of the nilads:

() Evaluates to one.
[] Evaluates to the height of the current stack.
{} Pop the active stack. Evaluates to the popped value.
<> Toggle the active stack. Evaluates to zero.

These are concatenated together when they are evaluated. So if we had a '3' on top of the active stack, this snippet:
()(){}

would evaluate to 1 + 1 + active.pop() which would evaluate to 5.
The monads take one argument, a chunk of Brain-Flak code. Here are all of the monads:

(n) Push 'n' on the active stack.
[n] Evaluates to negative 'n'
{foo} While zero is not on the top of the stack, do foo.
<foo> Execute foo, but evaluate it as 0.

These functions will also return the value inside of them, so
(()()())

Will push 3 but
((()()()))

Will push 3 twice.
The {} will evaluate to the sum of all runs.  So if we had '3' and '4' on the top of the stack:
{{}}

would evaluate as 7.
When the program is done executing, each value left on the active stack is printed, with a newline between. Values on the other stack are ignored.
Rules

You may assume that the Brain-Flak is being run with ascii out. (-A)
The brain-flak code must NOT require input
All standard rules apply
The code must run within 1 minute for any input up to 1024 bytes on TIO. (If no TIO output is available supply an interpreter and I will run it on my machine (my machine should be able to come close to TIO)).
You must support arbitrary length input.
You may take input from a file.
Optimization for test cases is not allowed
Deterministic output is required
Programs don't need to be stack clean

Test cases (try your code on these, actual scoring texts will be released in 1-2 weeks after challenge is posted)
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

The meaning of brain-flak is to flak your brain with pain.

`1234567890-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:"ZXCVBNM<>?

To be, or not to be, that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,
Or to take arms against a sea of troubles
And by opposing end them. To die-to sleep,
No more; and by a sleep to say we die

<your brain-flak code here>

The fitness pacer test is a multi stage test. Avacado Avacado Avacadad Avacadad carrot.bat carrot.jar carrot.carrot Quack Quack Quack Quack Quack Quack Quack Quack Quack downgoat doawngoat down down gaot

This challenge came from a online program that turned text into brain-fuck. However brain-fuck has limitations and it is not nearly as cool as brain-flak. I really am looking forward to cool programs :) I am glad you took the time to read this and look forward to seeing your answer.

Winning
To win you must give the total length of the brain-flak code given by each of the test cases which will be released 1-2 weeks after the post date. The shortest total length wins.
NOTE!!!!!!:
This is not code-golf, length of your code will not effect your final score in any way. Making clean readable code is appreciated. Thanks!
Test cases
here

Boxofsand

Is gaot a typo?

@WeijunZhou no meme from TNB

I see, thank you for clarification.

TNB memes are the dankest of memes.

@MagicOctopusUrn as always

05AB1E - 15 bytes - The worst possible score w/o actively trying to be bad, which (as it turns out) is almost as bad as trying to fail.

Wish I could double +1 this, instead I'll offer a bounty because I wanna know how this was supposed to be done. First answer that gets <your brain-flak code here> under 1000 is awarded the bounty. Which I cannot post for another day, whoops; didn't notice how new this was.

@magic sweet! That will bring fun answer's

@MagicOctopusUrn status-complete

@MagicOctopusUrn I think you've underestimated just how short that text could be golfed

What is the range of characters that can be inputted? Printable ASCII?

@JoKing anything that fits in 8 bits

@JoKing copy error

@Christopher If you aren't releasing the test cases yet, then you need to release their hashes, so you cannot change them. Otherwise, there's no way to know whether you design test cases after the fact to bias towards a certain answer. Though I don't think you would do that, I'm pretty sure it's policy that test cases should be fixed ahead of time if the score depends on them, and the proof of that is the hashes.

Also, if the range of input is not limited to printable ASCII, then you should include test cases that have every byte value, including NUL bytes.

@mbomb I will give the hash soon (mobile) but I wouldn't bias them :P

Just a reminder to release the test cases eventually

Also, is the NUL byte a possible input? Because that will invalidate most solutions

@joking I can't until Sunday because I ended up In Florida for a week

"Making clean, readable code is appreciated" hastily does challenge in 05AB1E

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

Try it online!
Output for <your brain-flak code here>: 5045 bytes
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())

Try it online!

Brain-flakking intensifies

@MagicOctopusUrn metaflakking :D

Test cases are out

Python 3, 17744 bytes
Edit: I've added a couple of options to help golf in stack safe situations.
import sys
sys.setrecursionlimit(1000000)
import time

def copy(n, code):
	if n == 1: return code
	for x in range(2, n):
		if n%x == 0: return '('*(x-1) + copy(n//x, code) + ')'*(x-1) + '{}'*(x-1)
	return '('*(n-1) + code + ')'*(n-1) + '{}'*(n-1)

letterCache = {}
def letterGen(n, stackLen, prev=0, enclosed=0):
	if (n, stackLen, prev, enclosed) in letterCache: return letterCache[(n, stackLen, prev, enclosed)]
	if n == 0: return ''
	if n == 1: return '()'
	if n == stackLen: return '[]'
	f = []
	if n < 0:
		f.append('[%s]'%letterGen(-n, stackLen, prev, enclosed))
	else:
		if prev != 0:
			diff = n-prev
			#Saves ~200 bytes but 20x longer
			#for x in range(min(diff, 0)-stackLen, max(diff, 0)+stackLen+1):
				#f.append(letterGen(x, stackLen - enclosed) + 's' + letterGen(diff - x, stackLen))

			f.append('s' + letterGen(diff, stackLen))
			f.append(letterGen(diff, stackLen - enclosed) + 's')
		x = 2
		while x*x < n:
			f.append(copy(x, letterGen(n//x, stackLen, prev, enclosed)) + letterGen(n%x, stackLen, prev, enclosed))
			x += 1
		f.append(letterGen(n-1, stackLen, prev, enclosed)+'()')
		if abs(n-stackLen) < n and stackLen > 1: f.append(letterGen(n-stackLen, stackLen, prev, enclosed) + '[]')
	letterCache[(n, stackLen, prev, enclosed)] = min(f, key=len)
	return letterCache[(n, stackLen, prev, enclosed)]

def s2BrainFlak(c, checkReverse = True):
	g = []
	c = c[::-1]
	stack = []
	out = []
	enclosed = 0

	if checkReverse:
		g.append(''.join(out) + s2BrainFlak(c, False) + '{({}<>)<>}<>')
		#for x in range(1,11): g.append(s2BrainFlak(list(c)+[chr(0)]*x, False) + '{({}<>)<>}<>')
	#if c and c[0] == chr(0):
	#	out.append('<>')
	#	while c[0] == chr(0):
	#		stack.append(0)
	#		out[0] = '(' + out[0] + ')'
	#		c = c[1:]

	for letter in range(len(c)):
		char = ord(c[letter])
		x = '(%s)'%letterGen(char, len(stack), stack[-1] if stack else 0, enclosed)

		if 's' in x:
			out[-1] = x.replace('s', out[-1])
			enclosed += 1
		else:
			out.append(x)
			enclosed = 1
		if checkReverse and c[letter+1:]:
			g.append(''.join(out) + '<>' + s2BrainFlak(c[letter+1:], False) + '{({}<>)<>}<>')
			m = min(list(map(ord, c[letter+1:])))-1
			#for i in range(1,m): g.append(''.join(out) + '<>' + s2BrainFlak(list(map(lambda x: chr(ord(x)-i), c[letter+1:])), False) + "{({}%s<>)<>}<>"%letterGen(i, 0))
			g.append(''.join(out) + '<>' + s2BrainFlak(list(map(lambda x: chr(ord(x)-m), c[letter+1:])), False) + "{({}%s<>)<>}<>"%letterGen(m, 0))
			#for x in range(1,11): g.append(''.join(out) + s2BrainFlak(list(c)+[chr(0)]*x, False) + '{({}<>)<>}<>')
		stack.append(char)
	g.append(''.join(out))
	return min(g, key=len)

Try it online!
A simple recursive solution which I will continue to improve further. This does very well with smaller inputs, but loses out to MegaTom's Ruby answer for longer inputs.
Notes:

This needs a clean stack to operate, otherwise the improvements with [] become useless (though they can be disabled by commenting out a couple of lines, and they only improve it by about 100 bytes quite a bit).
Since this is a recursive algorithm, it will take longer for chars with large values. For example, the character ÿ (value 255) takes 9 seconds to evaluate, where every test case at once takes 1.6 seconds. Cache implemented!
Idea of checking the reverse shamelessly borrowed from HyperNeutrino's answer, saving 800 bytes from the total.
I changed the total from all test cases at once to the total of each test case. This saves some bytes by adding more uses for the stack length operator ([])
~200 bytes from choosing the minimum of prepending the difference between characters, or appending them (again, this saves bytes through the stack length operator)
Implemented a cache (which caches values based on stack length), which allowed me to check more possible avenues without going over the time limit. This saved 1500 bytes from the total.

Also, I switched the em dash in the Shakespeare test case to a normal -. This cut out a few bytes, and a lot of time given the value of that em dash was 8212 :o .

Cut out 1200 bytes from the longer test cases by cutting them into slices and checking whether it was shorter to switch to the other stack, construct it in reverse, and push it back to the first stack again. Next up, even more slicing, and saving time by optimising the minimum slicing range.
Combined the number generating function with the checking for efficiencies with the previous character part into one recursive function. There's a couple of sections in here that save some bytes, but extend the runtime of the program a bit beyond the the one minute limit.

Uncommenting those parts can cut it down to 11394 bytes... but takes about 16 minutes.

Example outputs:
<your brain-flak code here> (312 bytes):
(()(((((((((()()()){}()){}()){}){})){}())[(()[][]){}])[][])[[]])([]((((([]((()[][][]){})[][]){})(()[]){})[()[][]])[()][]))([()][]([[]]((((([][]){}())){}[])(()()()){})))([()()()][]((((((()()[[][]]([()()()()][]((([][])[]){}()))[])())[((()()[])){}{}])[()()][]){})[()()()]))(([][]){}())((()()()()()[]){}){({}<>)<>}<>

Try it online!
Hello, World! (142 bytes [Note: The current previous best was 148 bytes, and is now 136 bytes]):
((()(((((((((()()()()){}){}){}()))){}{}())([][]){})[][])[[]])[((()[]){}){}])([()[]](((()(()[]([][]((()[][]){}[]))){}[])[()()()])))(([][][]){})

Try it online!

checking reversal saves 800 bytes? o_O

also you should cache the results of your recursive function; would save so much time

@HyperNeutrino Caching means I can’t use the stack length operator, which actually does save a lot, especially for shorter inputs

oh right, I see edit that's actually a really genius idea (stack length) mind if i steal it? :P

No worries @HyperNeutrino

@HyperNeutrino I just realised I can have a cache, as long as I make separate caches for each stack height

@HyperNeutrino Actually... tips for golfing in Brain-flak.

Your brain-flak meta-golfer out-golfed the best answer for a brain-flak regular golf? What.

Test cases are out

https://docs.python.org/3/library/functools.html#functools.lru_cache
Python has a built-in for an LRU cache, if you would like to use that.

Ruby, 17398 bytes for all (new) test cases
# cache for holding shortest push results
$p_cache = {}

# Get code to push a number "a" to the stack,
#  given top of stack "b" and stack height "h"
def push a,b=nil,h=0
  return $p_cache[[a,b,h]] if $p_cache[[a,b,h]]
  arr = []
  if b
    arr.push "(({})#{add(a-b,h)})"
  end
  arr.push "(#{add a,h}  )"
  arr.push "([]#{add a-h,h}  )"
  i=2
  while i*i<=a && i<4
    arr.push "#{'('*(i-1)}#{push a/i,b,h}#{')'*(i-2)+'{}'*(i-1)}#{add(a%i,h)})"
    i+=1
  end
  $p_cache[[a,b,h]] = arr.min_by(&:length)
end

$cache = {}

# Get code to add a number "n" to the 3rd stack
#  given stack height "h"

def add n,h=0
  return $cache[[n,h]] if $cache[[n,h]]
  arr = []
  if n > 0
    arr.push("()"*n)
  elsif n == 0
    return ""
  else
    if h > 0
      1.upto(-n/h){|i|
        arr.push "[#{'[]'*i}]#{add(h*i+n,h)}"
      }
    end
    arr.push "[#{add(-n,h)}]"
    return ($cache[[n,h]] = arr.min_by &:length)
  end

  if h > 0
    if n > h
      arr.push "[]#{add n-h,h}"
    else
      arr.push "[]#{add n-h}"
    end
  end

  i=2
  while i*i<=n && i<4
    arr.push "#{'('*(i-1)}#{add n/i,h}#{')'*(i-1)+'{}'*(i-1)}#{add(n%i,h)}"
    x=n-h-i+1
    if x > 0
      arr.push "#{'('*(i-1)}#{add x/i,h}#{')'*(i-1)}[]#{'{}'*(i-1)}#{add(x%i)}"
    end
    i+=1
  end
  $cache[[n,h]] = arr.min_by &:length
end

def push_arr(arr)
  i=0
  code = push(arr[0]) + "\n" +
  arr.each_cons(2).map{|r|
    i+=1;push r[1],r[0],i
  }.join(?\n)

  while code =~ /^\((.*)\)\n(\(*)\{\}/
    code.gsub!(/^\((.*)\)\n(\(*)\{\}/, '\2\1')
  end

  code.split(/\n| /).join
end

# push a string to the stack
def push_string(text)
  push_arr text.chars.map(&:ord)
end

$str_cache = {}
# Push a string in reverse order
def push_string_r(text)
  return $str_cache[text] if $str_cache[text]
  a = [push_string(text)+"{({}<>)<>}<>", push_string(text.reverse)]

  min = text.bytes.min-1
  a.push push_arr(text.bytes.map{|x|x-min}) + "{({}<>#{add min})<>}<>"

  # Try cutting it into bits
  3.upto([text.length/20, 10].min)do|x|
    spl = x*9
    a.push push_string_r(text[spl..-1]) + "<>" +
      push_string(text[0...spl]) + "{({}<>)<>}<>"
    spl = x*10
    a.push push_string_r(text[spl..-1]) + "<>" +
      push_string(text[0...spl]) + "{({}<>)<>}<>"
  end

  a.map!{|code|code.gsub("<><>","")}

  $str_cache[text] = a.min_by &:length
end

Try it online!

<your brain-flak code here>, 362 358 bytes
((((((((((()()()){}()){}()){}){})){}())[[][][][][]])[][])[()()()])((((((((([][][]()){}))){}{}()())[][]()())[[][]()])[][()])()()()()())([][][][]())(((([]([]())[]{}){})(()()()){})[[][()()()]])([]([][][]()){})((([][])[]){}())([]([][]())[]{})((([][]()())[]{})())((((((()()()()())[]{})[][()()]){})[()()()])((()()()){}){}())([][][][]())(((()())[]{}){}){({}<>)<>}<>

Try it online!

Your code takes over 1 minute for all the test cases at once (~950 bytes). It's good that it produces quite short code for the longer individual test cases though.

@JoKing it is fine that it takes longer for every cases :P

@Christopher I was referring to the Must run under 1 minute for inputs up to 1024 bytes rule (though it's much quicker now)

Although it doesn't actually matter for the code execution, an object that stores data for later use is called a cache, not cash ;p

Test cases are out

Python 3, 16222 bytes
cache = {}

def generate_number(num, height, level = 0, output = False): # Idea to use Stack Height inspired by Jo King
	if output: print(" " * level + str(num) + " " + str(height))
	if (num, height) in cache: return cache[(num, height)]
	if num == 0: return ""
	if num < 0: return "[" + generate_number(-num, height, level + 1, output) + "]"
	if num == height: return "[]"
	value = min((["[]" + generate_number(num - height, height, level + 1, output)] if height > num * 2 and abs(num - height) < num else []) + ["()" + generate_number(num - 1, height, level + 1, output)] + ["(%s)%s{}" % (generate_number(num // i, height, level + 1, output), "({})" * (i - 2)) for i in range(2, num) if num % i == 0], key = len)
	cache[(num, height)] = value
	return value

generate_number(256, 0, 0, False)

def generate_string(array):
	string = ""
	last = 0
	for height, num in enumerate(array):
		string = min("(" + string + generate_number(num - last, height) + ")", "<" + string + ">" + "(" + generate_number(num, height) + ")", key = len)
		last = num
	return string

a = lambda s: generate_string(list(map(ord, s)))

i = sys.stdin.read()
j = i[::-1]

print(min(a(j), a(i) + "{({}<>)<>}<>", key = len))

Try it online!
First below 1000 for <your brain-flak code here> :D
Brain-Flak, 448 bytes
<((((((<(((<((((<((((<((((((()(()(()(()()()){}){}){}){})(()((()()[]){}){})({}){})()((()[]){}){})[()(([]){}){}])()()())>((()([])({}){}){})()((()(()()[]){}){}){})[()])()()()[])[()()()[]])>(()()([])({}){})(()(()[]){})({}){})[(()()()()()){}])()(()()()()()){})[(()()()){}])>(([])({}){})()(([]){}){})[()()()()()])[(()()()()){}])>((([])({}){}){})[((()()()()){}){}])[(()[])({}){}])()(()()()()()[])({}){})()()())[(()()()){}])(()()()()()){})>((()()()()[]){})

Try it online!
(originally 827 for <your brain-flak code here>)

Bounty inc, soon.

@MagicOctopusUrn cool ty :D

You're now at 16222 bytes total

Hope 250 was cool.

@MagicOctopusUrn 250 is great :D tyvm

@JoKing Oh really. huh that's weird, guess I was using the wrong version to get the bytecount :P

You’re probably testing all the cases together. The stack height addition is more useful when they’re separate.

@JoKing oh yeah that makes more sense, thanks

Test cases are out

Your bytecount for the new test cases is 24882

05AB1E, too many bytes (My first BF anything)
ÇεDÑDg;<èUX÷VX"()"×"(ÿ)"YX-"()"×«"(ÿ)"}»"{({}<>)({<({}[()])><>({})<>}{}<><{}><>)<>}<>"«

Try it online!

Extremely basic attempt at golfing using a the premade "multiplication" Brain-flak code. All this does is finds the smallest-sum divisor pair for each ASCII code point, then pushes both of those divisors pairs as numbers. The Brainflak code ({}<>)({<({}[()])><>({})<>}{}<><{}>) is then appended and executed in a loop until all values are on the alternate stack.

List of people I'm thanking:

DJMcMayhem for pointing out (()())(()()()) = ((()())()) (-252 bytes)
DJMcMayhem for showing me how loops should work (-927 bytes).

Example golf of <your brain-flak code here> at 3470 3218 2291 bytes:
Brain-Flak, 2291 bytes
((()()()()()())()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()()()()()()())()()()())
((()()()()()())()()()()()()()()()()()()())
((()()()())()()()())
((()()()()()()())()()()()()()())
((()()()()()())()()()()()()()()()()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()()()()())()()()()()()()())
((()()()()()()()()()())())
((()()()()())()()()())
((()()()()()())()()()()()()()()()()())
((()()()()()()()()())()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()())()()()())
((()()()()()()()()())()())
((()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()()())()()()()()()()()()()()()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()())()()()())
((()()()()()()()())()()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()()()()()())()()()()()()()()()()()()())
((())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())
((()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()){({}<>)({<({}[()])><>({})<>}{}<><{}><>)<>}<>

Try it online!

Each row represents one character being golfed, this beats the basic solution I posted by 60%, and going in knowing literally nothing about Brainflak I feel this is a good baseline of what not to do. I'll score the answer in a little while, in the middle of something else and I'm sure I can improve on this. (I'm including the newlines in the byte-count because I don't expect this to win).

Here are some tips: 1) If you're pushing two numbers (say 4 and 5 to get 20), then you could push them together to save bytes. Compare (()()()())(()()()()()) and ((()()()())()) 2) Multiplication by a constant can be much shorter than push(); multiply();. For example, to double a number, you can do (({}){}) rather than (()())({}<>)({<({}[()])><>({})<>}{}<><{}>). But this isn't a terrible baseline. If you want more input, I'm always happy to chat in the third stack

@DJMcMayhem I was honestly looking to use deltas between numbers, restarting after each negative delta. But I see the idea for differences as well... I'm incorporating that now... theres some other problems with this as well that I'm fixing. Also, the 05AB1E code itself is ungolfed, not that it matters, but I want to redo that too.

The score cases aren't out yet. Will ping in a week or 2 when I post (avoid test case optimization solution)

@DJMcMayhem Would divisors of deltas be good?

Test cases are out

@Christopher my score: "bad"

Sounds good, :P

Brain-Flak
For each character (main loop)
(([])<{({}[()]<

Get the difference between the top two characters
(({}<>)<>[({})]<><({}<>)>)

Push an open paren on the other stack
<>(((((()()){}()){}){}){})

Retrieve difference
(<>{}<>)

Greater than zero
([(({})[(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

If
{{}

While non-zero
({

Add value if not 1
<(({})[()])>{()(<{}>)}{}

<

Divmod 2
({}(())(<()>)){({}[()]<({}([{}]()))>)}{}({}[({})])

Hold the div
({}<

Push the mod part
{({}[()]<
((((((()()){}()){}){}){})())
>)}{}

Put div down
>)

Open paren if div non-zero
(({}))
{(<({}<{}
(((((()()){}()){}){}){})
>)>)}{}

Less than 4
([([({})[()()()()](())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

If
{{}

Make that many 1s
{({}[()]<
((((((()()){}()){}){}){})())
>)}{}

End if
((<()>))}{}

End loop puting number of times run on the stack
>}{})

For each close push and pop
{({}[()]<
((((()()()()()){}){}){}())(((((((()()()()()){}){}){}())){}{})()())
>)}{}

End if
((<()>))}{}

Less than zero
([([({})(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

If
{{}

([{}]<

Push open bracket
((((((()()){}()){}()){}){}()){}())

>)

While non-zero
({

Add value if not 1
<(({})[()])>{()(<{}>)}{}

<

Divmod 2
({}(())(<()>)){({}[()]<({}([{}]()))>)}{}({}[({})])

Hold the div
({}<

Push the mod part
{({}[()]<
((((((()()){}()){}){}){})())
>)}{}

Put div down
>)

Open paren if div non-zero
(({}))
{(<({}<{}
(((((()()){}()){}){}){})
>)>)}{}

Less than 4
([([({})[()()()()](())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

If
{{}

Make that many 1s
{({}[()]<
((((((()()){}()){}){}){})())
>)}{}

End if
((<()>))}{}

End loop puting number of times run on the stack
>}{})

For each close push and pop
{({}[()]<
((((()()()()()){}){}){}())(((((((()()()()()){}){}){}())){}{})()())
>)}{}

Push close bracket
((((((()()){}()){}()){}()){}){}())

Endif
((<()>))}{}{}

Remove top character
<>{}

End of main loop
>)}{}{}

Close the open parens
<>>){({}[()]<(((((()()){}()){}){}){}())>)}{}

Reverse code
([]){({}[()]<({}<>)<>>)}{}<>

Try it online!
Output for <your brain-flak code here>, 582 bytes:
([()((()(()(()()()){}){}){}){}]((()(()()){}){}([(()()()){}](()(()){}((()(((()(()()){}){}){}){}){}([(()((((()()){}){}){}){}){}]([(((()()){}){}){}](()(((()()){}){}){}([((()()){}){}]([()(()()){}](()(((((()()){}){}){}){}){}([()(((()(()()()){}){}){}){}]([(()()()){}](()(()(()()){}){}([(()(()()){}){}](()(()((()((()()){}){}){}){}){}([()(()((((()()){}){}){}){}){}]([((()()()){}){}](()(()(()()){}){}([()](()((()(((()()){}){}){}){}){}([(((()((()()){}){}){}){}){}](()(()){}([()((()()()){}){}](()((()()()){}){}(()(()(()((()()){}){}){}){}((()(()(()(()()()){}){}){}){})))))))))))))))))))))))))))


text:
Create a Magic 8 Ball
As a child, my friend had a magic 8 ball that we would ask questions to and see what the fate of that question was.
Challenge
Your challenge is to write a program (or function) that when run (or called), outputs (or returns) a random answer from the possible answers below. (Random being: each output should have a nonzero chance of occurring but they do not need to meet any other criteria)
The possible answers from the Magic 8-ball are (case-insensitive):
It is certain
It is decidedly so
Without a doubt
Yes definitely
You may rely on it
As I see it, yes
Most likely
Outlook good
Yep
Signs point to yes
Reply hazy try again
Ask again later
Better not tell you now
Cannot predict now
Concentrate and ask again
Don't count on it
My reply is no
My sources say no
Outlook not so good
Very doubtful

Input
No input.
Output
A random choice from above. Case does not matter.
Rules
Standard loopholes are not allowed.
This is code-golf, so the shortest code in bytes for each language wins!

Is using a library / external files with all the words acceptable??

I changed "no input allowed" to "no input", some languages require blank/null arguments as inputs.

@Dat I am going to have to say no. This challenge is to find a clever way to output those values, not to save a bunch of bytes by printing different lines of an external file.

Is it me or someone is downvoting every answers??????

@Dat I posted something here in meta to discuss this. I have upvoted every answer, as I always do for answers that fulfil the requirements on my questions. Maybe a moderator will intervene...

@Dat Signs point to yes

@mbomb007 My favorite comment I have seen on PPCG thus far!

><>, 438 365 bytes
0x1+!
0\aa+%3+&
+>:&:&g1-o1
Zfq
Nptu!mjlfmz
Tjhot!qpjou!up!zft
Bt!J!tff!ju-!zft
Xjuipvu!b!epvcu
Ju(t!dfsubjo
Pvumppl!hppe
Zft!efgjojufmz
Zpv!nbz!sfmz!po!ju
Ju!jt!efdjefemz!tp
Btl!bhbjo!mbufs
Epo(u!dpvou!po!ju
Dboopu!qsfejdu!opx
Wfsz!epvcugvm
Nz!sfqmz!jt!op
Nz!tpvsdft!tbz!op
Sfqmz!ib{z!usz!bhbjo
Cfuufs!opu!ufmm!zpv!opx
Dpodfousbuf!boe!btl!bhbjo
Pvumppl!opu!tp!hppe

Try it online!
Not that interesting Now shorter than most solutions without compressed strings! I think it's also the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
Explanation:
All the messages are stored on the lines starting with Zfq, but with each character incremented by one (so Zfq is Yes). The first line 0x1+! randomly either increments a number (initially 0), resets it to 1 or exits the loop. When we get to the second line, we modulo this random number by 20 (though to get higher than that, would be like a one in a million chance), and add 3 to get the line number. Then we push a counter starting at 0, and move to the third line, where we print each character subtracting one from each, where we finally terminate by trying to print -1 as a character.

I will use this one. It (almost) always gives a positive response. Unfortunately the answer also smells fishy...

SOGL V0.12, 166 bytes
,▓a⁰²z○½℮ķčλ─fj[Ycψ-⁸jΔkÆΞu±⁄│(┼∞׀±q- υ~‼U/[DΓ▓νg⁸⅝╝┘¤δα~0-⁄⅝v⁄N⁷⁽╤oο[]āŗ=§№αU5$┌wΨgΘ°σΖ$d¦ƨ4Z∞▒²÷βΗ◄⁴Γ■!≤,A╬╤╬χpLΧ⁸⁽aIΘād⁵█↔‚\¶σΞlh³Ζ╤2rJ╚↓○sēχΘRψΙ±ιΗ@:┌Γ1⁷‘Ƨ! ΘlΨιw

Try it Here!
\o/ every word was in SOGLs dictionary!

This is an awesome answer!!!

I'd love to take a look at SOGL's compression engine, but unfortunately, I don't speak JavaScript :(

Wait, SOGL is a JavaScript-based language?

@cairdcoinheringaahing SOGL is written in Processing, and the relevant compression files are here and here. Though Processing is a Java-based language :p

Python 2, 369 368 bytes
print"It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split('.')[id(0)/7%20]

Python 3, 371 bytes
print("It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split('.')[hash(id)%20])

I was previously using the hash builtin to index (hash(id)%20), which returns a random value per-start of the Python interpreter ever since https://bugs.python.org/issue13703. It's not random for the empty-string though (always 0), so need to use something else, the id builtin!
On second look, I could use id directly, but it seems to always produce even numbers. IIRC, id(object) in CPython just returns the memory location of object, so this makes sense. Maybe if I used Jython or IronPython, I could skip the divide-by-7. Anyways, hash(id) vs id(0)//7 is equal in Python 3, but can use the / operator for truncating integer division in Python 2, saving a byte.

PowerShell, 354 bytes
"It is certain0It is decidedly so0Without a doubt0Yes definitely0You may rely on it0As I see it, yes0Most likely0Outlook good0Yep0Signs point to yes0Reply hazy try again0Ask again later0Better not tell you now0Cannot predict now0Concentrate and ask again0Don't count on it0My reply is no0My sources say no0Outlook not so good0Very doubtful"-split0|Random

Try it online!
Ho-hum. Takes all the outcomes, concatenated together with 0s, then -splits on 0 to create an array of strings. Passes that array to Get-Random which will randomly select one of them. That's left on the pipeline and output is implicit.

Python 2, 385 bytes
-1 byte thanks to ovs.
from random import*
print choice("It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split('.'))

Try it online!

@Downvoter, may I ask why you've downvoted every answer?

That strikes me as suspicious voting behaviour, I'd suggest flagging the question for a mod's attention so they can investigate.

So has someone looked for whoever posted the single answer with zero downvotes?  (I can't see up/down votes due to my sterling reputation level of 101.)

Applescript, 391
I love how AppleScript's lists have a some item method:
{"It is certain","It is decidedly so","Without a doubt","Yes definitely","You may rely on it","As I see it,yes","Most likely","Outlook good","Yep","Signs point to yes","Reply hazy try again","Ask again later","Better not tell you now","Cannot predict now","Concentrate and ask again","Don't count on it","My reply is no","My sources say no","Outlook not so good","Very doubtful"}'s some item

Cue the mean-spirited downvoter-of-all-answers in 3, 2, 1...  Go on - I dare you to reveal who you are and explain your downvote rationale.  Or will you continue to anonymously lurk in the shadows?

Bash + GNU utilities, 230

15 bytes saved thanks to @Dennis.

sed 1d $0|zcat|shuf -n1
# zopflied 8 ball list

The binary zopfli output is not well represented here; instead you can reconstruct the script from base64 encoded data:
base64 -d << EOF > 8ball.sh
c2VkIDFkICQwfHpjYXR8c2h1ZiAtbjEKH4sIAAAAAAACAz1QSZJCMQjd5xRv1fOlMEGlzIdfgbRF
n75NOayYeYMExFF5BImWe9W4SuPWE27lKnG2GSA0m4coyWvhKCrBPUvaxEaJcStgColCDoEzQ+IH
t/WymQe6XNa+zehmF5zMWknei8tJHbuJBsKw9gfvPXGmv0SMBJ0WNfLLPUOn4FEOHMEDaoHg3rGI
qF1LJV29fXCTGveWaWWNQcEgbXi9Ks30PVBtauBOfkvc4cWhtkq3OSo7nBJqLwELxO2u45dH3u05
zv4=
EOF

Note, as allowed by the question, the compressed data decompresses to all lower case.  This makes zopfli compression a bit more efficient and saves 16 bytes.

tail +2 doesn't work for me, but sed 1d $0 saves a byte anyway. Also, since output to STDERR is allowed by default, I don't think you need the exit. Also, the last ten bytes of the program can be removed.

@Dennis thanks!  Extra output to STDERR always makes me feel a little uncomfortable, but I guess I should run with it.

Charcoal, 203 184 bytes
‽⪪”}∨74Dυ3↖u➙Ｈ�↖vＩ⁻VＲ‹ψ#�Ii»ψPNξ⮌≔;≡8ν}¬Ｈ⁺ºº↖H⁴Ｋ⌕êτ｜⁼➙⟲W»″φ◨⟦(τ(jK“Ｎ\⍘“↷⊙ⅉvＴ>➙§⌊Ｆζ³⁻↔;ＴaÀ✳⁴≔67⍘i4¬⸿-A8⁻f7¡<⁰Zχ}ζ'¡¹→Oaε!ＯυP₂ïμ´MuＰ⁺Ｍ⮌1№-k¹№FvξＤü⊟ζⅉ⁰xW:Dε7ＴvM₂⊞θC⪪Ｒε⁰“Ｄ¡⸿⁰″A⊕λξ↥~Ｏ·PＥ&”¶

Try it online! Link is to verbose version of code. Edit: Saved 19 bytes by lowercasing everything. Explanation:
  ”...”     Compressed string of newline-delimited responses
 ⪪     ¶    Split on newlines
‽           Random element
            Implicitly print

Retina, 333 331 321 bytes

0cert10decided2so¶with34a d3bt¶yes definitely¶y3 ma5re26as i see it, yes¶mos4likely7good¶yep¶signs poin4to yes¶rep2haz5tr5ag18ain later¶better 94tell y3 9w¶can94predic49w¶concentrate and 81don'4c3n46m5rep2is 9¶m5s3rces sa59794so good¶ver5d3btful
9
no
8
ask ag
7
¶3tlook
6
on it¶
5
y
4
t
3
ou
2
ly
1
ain¶
0
it is
G?`

Try it online! Edit: Saved 1 byte by compressing doubt and 1 byte by lowercasing everything so I could compress reply. Then saved 10 bytes by using @Leo's Retina Kolmogorov golfer on the lowercased text (which coincidentally is the number of bytes it saved on my 333-byte answer).

323 bytes by using my Retina 0.8 Kolmogorov golfer

@Leo Note that Retina 0.8.2 is a different language

@mbomb007 I know, but for simple substitutions like these it has the same syntax as Retina 1.0. I was just pointing out that the Kolmogorov golfer was written for an older version of Retina but it is still usable in this case.

R, 360 bytes
sample(readLines(),1)
It is certain
It is decidedly so
Without a doubt
Yes definitely
You may rely on it
As I see it, yes
Most likely
Outlook good
Yep
Signs point to yes
Reply hazy try again
Ask again later
Better not tell you now
Cannot predict now
Concentrate and ask again
Don't count on it
My reply is no
My sources say no
Outlook not so good
Very doubtful

Try it online!
Not exactly the most elegant solution. R has a neat feature where stdin will redirect to the source file, so you can put (small) datasets into source code, saving bytes for string splitting or worse, constructing the vector itself (all those quotes add up in a hurry). Along with builtins for random sampling, this makes a short-ish answer.

T-SQL, 393 bytes
SELECT TOP 1*FROM STRING_SPLIT('It is certain-It is decidedly so-Without a doubt-Yes definitely-You may rely on it-As I see it, yes-Most likely-Outlook good-Yep-Signs point to yes-Reply hazy try again-Ask again later-Better not tell you now-Cannot predict now-Concentrate and ask again-Don''t count on it-My reply is no-My sources say no-Outlook not so good-Very doubtful','-')ORDER BY NEWID()

The function STRING_SPLIT is only available in SQL 2016 and later.
Best I could get for prior versions using VALUES('It is certain'),('It is decidedly so'),... was 464 characters.
Formatted, just so you can see the working part:
SELECT TOP 1 *
FROM STRING_SPLIT('It is certain-It is decidedly so-...', '-')
ORDER BY NEWID()

NEWID() generates a new, pseudo-random GUID, so is a way to do a pseudo-random sort.

Coconut, 380 bytes
Coconut port of totallyhuman's answer
from random import*
choice$("It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split('.'))

Try it online!

Jelly, 201 bytes
-2 bytes thanks to Mr. Xcoder. -1 byte thanks to user202729.
“æ⁽IẊ?⁽ʋṠ¶ÐƝKW¬ḃỴɓ⁾:Eṇ⁵ṾɱD×⁴2ṇỤðċỊ¥ḷƬị÷ṣÐṆⱮ$u²OŀṚƁȮ1⁼ṁ$bp⁾v]Ɠ-/NẓḲnỵdḳḋ½ȥṿ=kv¥ɓl[kR AḞ¶gḣḞiẊŒẊḳçȤ⁻Ɱʋx:ØṖ|zY=ṾḌẓY1Ḃ$50d⁹⁸ŀhʂƤṢM;ḢoƁṾ⁷-uṙu¡Ọ3ṣȮ@⁹ðẹȥXƭ⁸|ƬẋẆḢɠœxḳsĿƘ(0çỌ~A½YIEFU3Ọ=⁷ɗḷBḷİṄhṗgṡƊẏẏḄ#Ṙʋ$ʂȷĠ»ỴX

Try it online!
Damn, SOGL's compression is good.

202 bytes

201 bytes. Just append the 2 last characters.

(I mean, append ỴX to the end of the code so it chooses randomly from one of them)

Ruby, 362 361 bytes
puts"It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split(?.).sample

Try it online!

1 byte thanks to @benj2240

You can shave off a byte with ?. instead of '.'.

@benj2240 wow, I hadn't seen that before. Very cool.

I had to go digging for the documentation on that ? single character string literal

05AB1E, 171 bytes
“€•€ˆ‹ì€•€ˆŸíly€Ê„›€…¬³…Ü´Î€î€¿Ëœ€‰€•€œ I€È€•,…Ü‚¢îÙ®½‚¿ yepŸé…®€„…Ü…ƒ hazy‡Ü†îˆ¹†îŠ´…ç€–ˆœ€î€Ó€©notßä€Óäè€ƒˆ¹†î€·n'tš‹€‰€•€¯…ƒ€ˆ€¸€¯Žç…è€¸®½€–€Ê‚¿‚Ò¬³ful“#•8∞f{ʒβ®•6в£ðýΩ

Try it online!
Explanation
“ ... “ pushes a string of all the required words.
Some words are taken directly from the 05ab1e dictionary.
Some are written out in plain ascii (like haze).
Some are combined dictionary and ascii (like do+n't).
Then the processing code is:
#                 # split string on spaces to a list of words
 •8∞f{ʒβ®•        # push the number 2293515117138698
          6в      # convert to a list of base-6 numbers
                  # ([3,4,3,2,5,5,2,2,1,4,4,3,5,3,4,4,4,4,4,2])
            £     # group the list into sublists of these sizes
             ðý   # join on spaces
               Ω  # pick one at random

Try it online! - 176 with bruteforce conversion.

@MagicOctopusUrn: I think it's 182 with , and ' added.

D'oh! Ah I see it, yes. By the way remove the input from your TIO, it's confusing a little.

@MagicOctopusUrn: Doh! Thanks. I wasn't aware I'd left that in there :P

166: TIO. Thrice -1 from using new dictionary words ( ye, don, and ha), and -2 from sorting the list by word count and using delta compression.

163 (TIO) by using run-length encoding instead of deltas (requires switching to modern 05AB1E).

Python 3, 386 bytes
from random import*
lambda:choice("It is certain;It is decidedly so;Without a doubt;Yes definitely;You may rely on it;As I see it, yes;Most likely;Outlook good;Yep;Signs point to yes;Reply hazy try again;Ask again later;Better not tell you now;Cannot predict now;Concentrate and ask again;Don't count on it;My reply is no;My sources say no;Outlook not so good;Very doubtful".split(';'))

Java 8 , 433, 392, 380, 379 bytes
 a->"It is certain~It is decidedly so~Without a doubt~Yes definitely~You may rely on it~As I see it, yes~Most likely~Outlook good~Yep~Signs point to yes~Reply hazy try again~Ask again later~Better not tell you now~Cannot predict now~Concentrate and ask again~Don't count on it~My reply is no~My sources say no~Outlook not so good~Very doubtful".split("~")[(int)(Math.random()*20)]

Try it online!

41 bytes thanks to AdmBorkBork!
10 bytes thanks to Kevin!
1 byte thanks to Oliver!

Surely you can use String.split() to save a bunch of bytes — https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split%28java.lang.String%29

As @AdmBorkBork stated, you can save 41 bytes using String#split. Also, you can save an additional 11 bytes using (int)(Math.random()*20) instead of new java.util.Random().nextInt(20). And the semi-colon isn't counted towards the byte-count for lambdas. So in total: 380 bytes.

There's an extra space in your answer and in @KevinCruijssen's golf: use Don't instead of Don' t.

Javascript, 372 bytes
-10 bytes thanks to Shaggy
_=>"It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful".split`.`[Math.random()*20|0]

Try it online!

Use bitwise OR instead of Math.floor() to save 7 bytes: Math.random()*20|0.

05AB1E, 208 217 bytes
"don'".•W˜FζÃT¥„ò.1₁∍Y<`Ì°5jýúž+ìmHSéÁ¬–xÈƒø‚ž}_Øviòª§l["]0â^)„2æδ∍G1∊EÌLÝ'îôΛβ;ƒĀαÏw L°gðÈγ³€wE‘fι¥¤šαrˆQŠë¢-º8Æ~ÁŠ∍δBx®(β™Žü6»ƶÙÐ~†«\%ÍŒΘ-´sÈƵJŸ₃H7Ó˜:Å∍₂èÑï∞—Râú'óвb…ÓUXʒǝ₄ÝrÒ₄¨÷äè¤“oθWÎλî~bj(Ri
Þиe‘ãj]•", yes"J'x¡Ω

Try it online!
Pretty basic solution. The possible answers are concatenated with the character x (since it's not present in the answers) and then compressed (inside the •), 'x¡Ω split on x and pop a random choice.
Thanks to @Emigna for pointing out that the alphabet compression doesn't like ' or , much. Fixed by surrouding the compressed string with don' and , yes.

Nice idea to split on a character not present. Unfortunately alphabet compression replaces , and ' with spaces, so the output for those 2 lines are wrong.

@Emigna Thanks a lot for pointing it out ! I'm wondering if a better fix doen't exist for this issue... I could have used other non-used characters in the answers but there are only two: q and x :-(

Perl, 366
print((split",","It is certain,It is decidedly so,Without a doubt,Yes definitely,You may rely on it,As I see it,yes,Most likely,Outlook good,Yep,Signs point to yes,Reply hazy try again,Ask again later,Better not tell you now,Cannot predict now,Concentrate and ask again,Don't count on it,My reply is no,My sources say no,Outlook not so good,Very doubtful")[rand 19])

I found a bug. You can't use comma as a separator because 1 of the possible answers from the Magic 8-ball contains a comma: As I see it, yes.

I'd suggest that you use a single digit as the separator. It would save 1 byte, as the quotes are no longer needed, but a space must still be added to separate the digit and split.

Also, you can omit parenthesis for print and save 1 more byte. Just put a unary plus sign before the list: print((0..9)[5]) would become print+(0..9)[5].

PHP, 412 385 337 384 bytes
<?php $a=explode(1,"It is certain1It is decidedly so1Without a doubt1Yes definitely1You may rely on it1As I see it, yes1Most likely1Outlook good1Yep1Signs point to yes1Reply hazy try again1Ask again later1Better not tell you now1Cannot predict now1Concentrate and ask again1Don't count on it1My reply is no1My sources say no1Outlook not so good1Very doubtful");echo$a[array_rand($a)];

Try it online!
Fairly straight forward solution. Split the string by a delimiter(in this case 1) and choose a random element from the array.

Welcome to PPCG! I've made some minor formatting changes to your post, and have a couple little suggestions - 1, you need to add a space after php to get your code to compile; 2, you can replace '|' with 1 and all | with 1 for -2 bytes; 3 should consider changing your link for Trying it Online to TIO.run as is preferred by the community.

And here is a working version based off my feedback. Try it online!

@TaylorScott It seems to be working fine on my enovironment without the space after the <?php tag. I'm running PHP 7.2.3-1+ubuntu16.04.1+deb.sury.org+1 (cli) (built: Mar  6 2018 11:18:25) ( NTS ). Not sure if in previous versions that matters or not. Either way, I've edited the question.

Ahh, it may just be the version - The link you provided uses PHP version 7.0.3, and it does not run on TIO.run without the space

Indeed. It's an int now, not a string. Gotta love(and hate) type coercion in PHP. It won't complain.

You could use <?= and echo the explode directly using [rand(0, 19)] instead of first adding to to a variable <?= explode("1", "str1str1str")[rand(0, 19)]

Change the string to all lower case (so it compresses better), gzcompress/base64_encode and use that string with gzuncompress base64_decode - gets it down to 352:    <?php $a=explode(1,gzuncompress(base64_decode("eJw9UEluwzAM/MrceulFT1IkxiEsk4ZINVBfX8pGeuKC4SxkBxsKdc8sia+pUuFKtU2Ypjf7S4cjo+p4eJq0AE8WdmozTR048kSPASpgT9nAMKLovxHwdKg5Gu8LH1RNdcemWoPrTMabGE5lcbhe+E5nkL3y74T3ibwta9n2u0PLTj09yKNANM6oNSwjou9Usqzd2aly8XulUki8xx2yVPxTpary5Sg6Qvw2f6woSz7+ILpG09FLhLZIGZtPgCVieuf4obB5vec52h9Jf3yq[")));echo$a[array_rand($a)];

You can save 4 bytes with shuffle($a);echo$a;

Befunge
1221 870 bytes (perimeter of the entire field is 33x36 30*29 charachters) Thanks to Jo King for helping me to remove the trailing nulls and urging me to change the randomizer.
"<"99+9+1+v
v         <
 >>>>>>>>>>55++v
 0123456789
>??????????<
 0123456789
 >>>>>>>>>>    v
               >88++p       v
v"It is certain"
v"It is decidedly so"
v"Without a doubt"
v"Yes definitely"
v"You may rely on it"
v"As I see it, yes"
v"Most likely"
v"Outlook good"
v"Yep"
v"Signs point to yes"
v"Reply hazy try again"
v"Ask again later"
v"Better not tell you now"
v"Cannot predict now"
v"Concentrate and ask again"
v"Don't count on it"
v"My reply is no"
v"My sources say no"
v"Outlook not so good"
v"Very doubtful"
>:#,_@

The top line puts the '<' character and the x-position (28) where it should go on the stack. Then we enter the sort of random number generator. This could be improved, but this is what I could deliver on short notice... The "random" number is offset to get the actual "random" line to read.
After the random number is generated, we put the '<' character at that line and push the letters on the stack and on the bottom line output them again.
Note; if you use the interpreter I linked to in this posts title you have to reclick the "Show" after each run, because the addition of the '<' character remains after execution.

You're much better off using the same format as my ><> answer. Try it online!. As it is now, it also prints a bunch of null bytes at the end

Yeah, I know, I wanted the random number thingy not to be too biased, but I could've just used a single line of question marks.

You can at least golf a couple of hundred bytes of whitespace off, and change the last line to >:#,_@ to avoid printing null bytes. Oh, and add a TIO link.

That's true, I'll post an update later today.

Excel, 399 Bytes
=CHOOSE(1+20*RAND(),"It is certain","It is decidedly so","Without a doubt","Yes definitely","You may rely on it","As I see it, yes","Most likely","Outlook good","Yep","Signs point to yes","Reply hazy try again","Ask again later","Better not tell you now","Cannot predict now","Concentrate and ask again","Don't count on it","My reply is no","My sources say no","Outlook not so good","Very doubtful")

Since CHOOSE(X.Y,<>) is the same as CHOOSE(X,<>), no need for an INT
Not much golfing you can do here though...

Red, 367 bytes
prin pick split{It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful}"."random 20

Try it online!
It doesn't seem really random in TIO (although it works just fine in the Red Console), that's why I added a random/seed to the header.

Aceto, 345 + 1 = 346 bytes (+1 for -l flag)
"It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful"'.:Yp

Try it online!
Not overly interesting, but I can't think of anything shorter in this language, no compressed strings or anything.

"...."   push strings separated by periods
      '.  literal period
        :  split on period
         Y  shuffle stack
          p  print top

without the -l flag might look more interesting.

@LauraBostan But I don't know hilbert curves past type 3

and it's more bytes for all of the \n

But yes it would look more 'interesting' per se

iup... the -l flag was added for golfing. However, I am not very fond of it, steals cheaply the whole point of the language. Maybe next version of Aceto will give up this flag.

Anyways, I am always happy to see new uses of Aceto :]. Welcome on Stack Exchange!

Thanks! I agree that yes, it is rather 'boring', but I liked aceto for it's relative golfiness, not its hilbert curve

Excel-VBA, 362 341 339 Bytes
v=[1:1]:?v(1,Rnd*19)

Where A1:T1 contain the different options. Reads entire first row of sheet into array v and indexes a random point along the first 19 values.
Surprised to find that indexing an array doesn't require integer values

My concerns about your answer for Excel are even more so here, as the Worksheet is counted as a STDIN for Excel VBA, so this is closer to having pre-determined input

C - 426 bytes
char a[][99]={"It is certain","It is decidedly so","Without a doubt","Yes definitely","You may rely on it","As I see it, yes","Most likely","Outlook good","Yep","Signs point to yes","Reply hazy try again","Ask again later","Better not tell you now","Cannot predict now","Concentrate and ask again","Don't count on it","My reply is no","My sources say no","Outlook not so good","Very doubtful"};int main(){int n;puts(a[n%20]);}

Uses an uninitialized variable mod 20 to index into an array of strings containing all possible outputs. Compilers complain that stdio.h isn't included, but it works OK. Probably because it just so happens to have the standard library linked in anyways. Lucky me.

Worth noting on some implementations, an uninitialized variable has a value of 0, since the behavior is, well, undefined. Ask your magic 8-ball whether this is true on your machine.

Go, 530 Bytes
package main;import"fmt";func main(){for k:=range map[string]struct{}{"It is certain":{},"It is decidedly so":{},"Without a doubt":{},"Yes definitely":{},"You may rely on it":{},"As I see it, yes":{},"Most likely":{},"Outlook good":{},"Yep":{},"Signs point to yes":{},"Reply hazy try again":{},"Ask again later":{},"Better not tell you now":{},"Cannot predict now":{},"Concentrate and ask again":{},"Don't count on it":{},"My reply is no":{},"My sources say no":{},"Outlook not so good":{},"Very doubtful":{}}{fmt.Print(k);break}}

Please note that, on the Go Playground, because of how seeding works, it always gives the same result. When running on a regular computer, everything works as it should.
I think it is possible to save a bit more but my knowledge in Go stops there :)
Formatted and testable version

Welcome to PPCG! The Go interpreter on Try It Online seems to use a random seed.

I must be terribly unlucky then D:

Are you refreshing the page? That would fetch the result from cache every time, so it won't change. Clicking the Run button will run the code again.

I keep getting "It is certain" even after with a CTRL+R to hard refresh... I don't get it :x

Refreshing won't change the result; they are cached on the server side. Click the run button (play icon in a circle) or press Ctrl-Enter.

Oh okay I'm completely stupid, that was me. Forget it .-.

Let us continue this discussion in chat.

Julia , 381 bytes
a=split("It is certain.It is decidedly so.Without a doubt.Yes definitely.You may rely on it.As I see it, yes.Most likely.Outlook good.Yep.Signs point to yes.Reply hazy try again.Ask again later.Better not tell you now.Cannot predict now.Concentrate and ask again.Don't count on it.My reply is no.My sources say no.Outlook not so good.Very doubtful",".")
print(a[rand(1:length(a))])

Try it online

 Excel Google Sheets, 319+21 = 342 340 Bytes
=INDEX(A:A,1+20*RAND(

Where cells A1:A19 contain the different output options. Reads from the array using a random index. Saves a whole load of bytes by avoiding a delimiter in the list
Saved 2 bytes thanks to Taylor Scott

I have some concerns about this answer - 1, with raw text and no delimiters, there are 319 bytes of data, and 2 I think that you should have to count have to count a single byte towards delimiting the cell data, because in its raw text represntation - that is if you were to store the data as a CSV (comma-delimited) or an ASC file - there would be a single , character separating the columns' values (or \n separating the rows)

That said, you can drop 2 bytes off of your score by switching to Google Sheets and dropping the terminal ))

Java 8, 379 Bytes
b->"It is certain-It is decidedly so-Without a doubt-Yes definitely-You may rely on it-As I see it, yes-Most likely-Outlook good-Yep-Signs point to yes-Reply hazy try again-Ask again later-Better not tell you now-Cannot predict now-Concentrate and ask again-Don't count on it-My reply is no-My sources say no-Outlook not so good-Very doubtful".split("-")[(int)(Math.random()*20)]

Try it online

VBA, 358 bytes
An anonymous VBE immediate window function that takes no input and outputs to STDOUT.
?Split("It is certain1It is decidedly so1Without a doubt1Yes definitely1You may rely on it1As I see it, yes1Most likely1Outlook good1Yep1Signs point to yes1Reply hazy try again1Ask again later1Better not tell you now1Cannot predict now1Concentrate and ask again1Don't count on it1My reply is no1My sources say no1Outlook not so good1Very doubtful",1)(19*Rnd)

C (gcc), 408 bytes
f(s){char*p="It is certain\0It is decidedly so\0Without a doubt\0Yes definitely\0You may rely on it\0As I see it, yes\0Most likely\0Outlook good\0Yep\0Signs point to yes\0Reply hazy try again\0Ask again later\0Better not tell you now\0Cannot predict now\0Concentrate and ask again\0Don't count on it\0My reply is no\0My sources say no\0Outlook not so good\0Very doubtful";for(s=time(0)%20;s;)*p++?0:s--;s=p;}

Try it online!
Users are hard to predict, making the timing of their decision to call the function pseudo-random enough for our purposes.

source: Stack Exchange

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

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

sort: votes


text:
Cutpoints in a maze
A maze is given as a matrix of 0s (walls) and 1s (walkable space) in any convenient format. Each cell is considered connected to its 4 (or fewer) orthogonal neighbours. A connected component is a set of walkable cells all transitively connected to each other. Your task is to identify the cutpoints - walkable cells which, if turned into walls, would change the number of connected components. Output a boolean matrix with 1-s only at those locations. The goal is to do it in the fewest bytes of code.
The input matrix will consist of at least 3 rows and 3 columns. At least one of its cells will be a wall and at least one will be walkable. Your function or program must be able to process any of the examples below in under a minute on TIO (or on your own computer, if the language is not supported by TIO).
in:
11101001
11011101
00000001
11101111
11110101
00011111
10110001
11111111
out:
01000000
00001001
00000001
00000101
00110000
00010000
00000000
11100000

in:
1111111111111111
1000000000000001
1111111111111101
0000000000000101
1111111111110101
1000000000010101
1011111111010101
1010000001010101
1010111101010101
1010101111010101
1010100000010101
1010111111110101
1010000000000101
1011111111111101
1000000000000001
1111111111111111
out:
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

in:
1011010001111010
1111111011101101
1110010101001011
1111001110010010
1111010000101001
0111101001000101
0011100111110010
1001110011111110
0101000011100011
1110110101001110
0010100111000110
1000110111011010
0100101000100101
0001010101100011
1001010000111101
1000111011000010
out:
0000000000111010
1011110001001000
0000000000000011
0000000100010000
0000010000101000
0000001000000100
0000000011000000
1001100000011110
0000000001000010
0110100001000110
0000100101000010
1000100000000000
0100001000000100
0000000100100001
0000010000111000
0000010000000010

so, find all bridges in all subgraphs

I think that the challenge would benefit from a step-by-step example for a smaller matrix.

@HyperNeutrino yes, except I tried to use mainstream graph-theoretic terminology

ok. (..pretty sure they are called bridges formally but idk lol)

@Mr.Xcoder There are multiple possible approaches for solving this. I prefer not to describe any particular algorithm.

@HyperNeutrino a bridge is something different - it's an edge (not a vertex) whose removal increases the number of connected components

@HyperNeutrino also, a subgraph is not quite the same as a connected component

oh right, it does slightly differ. nvm

@HyperNeutrino "bridge"? I think it should be articulation point.

Can we choose other characters than 01 in input and/or output ?

@TonHospel sure, you can also use 01 as numbers or true/false if you language has a boolean type, whichever is most convenient

Isn’t a cutpoint usually defined to be a vertex whose deletion increases the number of components, not just changes the number? Your definition counts isolated vertices as cutpoints, but this one doesn’t.

@Notatree You're right. I made a mistake. It's too late to fix it now but I hope it won't spoil the fun.

I originally lost 5 bytes to fix this behaviour for isolated vertices but by now I optimzed it so much that it would be longer to not count them :-)

@TonHospel huh, i thought it would be just a matter of < vs !=

@ngn a test case about isolated vertices? 000,010,000 -> 000,010,000 ?

@edc65 the third test case has some of those

MATL, 26 bytes
n:"GG0@(,w4&1ZIuz]=~]vGZye

The input is a numerical matrix, using ; as row separator.
Try it online! Or verify all test cases.
Explanation
n           % Implicit input: matrix. Push number of elements, N
:           % Range: gives [1 2 ... N]
"           % For each k in [1 2 ... N]
  GG        %   Push input matrix twice
  0@(       %   Write 0 at position k (in column-major order: down, then across).
            %   The stack now contains the original matrix and a modified matrix
            %   with 0 at position k
  ,         %   Do twice
    w       %     Swap
    4       %     Push 4. This specifies 4-element neighbourhood
    &1ZI    %     Label each connected component, using the specified
            %     neighbourhood. This replaces each 1 in the matrix by a
            %     positive integer according to the connected component it
            %     belongs to
    u       %     Unique: gives a vector of deduplicate elements
    z       %     Number of nonzeros. This is the number of connected components
  ]         %   End
  =~        %   Are they different? Gives true of false
]           % End
v           % Concatenate stack into a column vector
GZye        % Reshape (in column-major order) according to size of input matrix.
            % Implicit display

Stax, 40 bytes
Çóê↓â.Φ}╞│*w<(♦◙¼ñ£º█¢,D`ì♥W4·☺╛gÇÜ♠╗4D┬

Run and debug test cases
This program takes input as a space separated string containing rows.  The output is in the same format.  Here's the unpacked ascii representation.
{2%{_xi48&GxG=-}_?m}{'1'2|e{"12|21".22RjMJguHgu%

The fundamental operation for counting an island works like this.

Replace the first '1' with a '2'.
Regex replace '12|21' with '22'.
Split on spaces.
Transpose matrix.
Repeat from 2. until a string is repeated.
Repeat from 1. until there is no longer a '1' in the string.  The number of repetitions is the number of islands.

.
{               start map block over input string, composed of [ 01]
  2%            mod by 2. space and 0 yield 0. 1 yields 1. (a)
  {             start conditional block for the 1s.
    _           original char from string (b)
    xi48&       make copy of input with current character replaced with 0
    G           jump to unbalanced }, then return; counts islands (c)
    xG          counts islands in original input (d)
    =           are (c) and (d) equal? 0 or 1 (e)
    -           b - e; this is 1 iff this character is a bridge
  }             end conditional block
  _?            execute block if (a) is 1, otherwise use original char from string
m               close block and perform map over input
}               goto target - count islands and return
{               start generator block
  '1'2|e        replace the first 1 with a 2
  {             start generator block
    "12|21".22R replace "12" and "21" with "22"
    jMJ         split into rows, transpose, and rejoin with spaces
  gu            generate values until any duplicate is encountered
  H             keep the last value
gu              generate values until any duplicate is encountered
%               count number of iterations it took

Bonus 44 byte program - this version inputs and outputs using the grid format.

does it process the second example in under a minute on your computer?

@ngn: It does all three examples in 41s on this mid-range laptop in Chrome.  Also, I just fixed the main link.  I accidentally left it set to an older non-working version.

Perl 5, -p0 105 101 96 93 90 89 bytes
Uses b instead of 1 in the input.
Make sure the matrix on STDIN is terminated with a newline
#!/usr/bin/perl -p0
s%b%$_="$`z$'";s:|.:/
/>s#(\pL)(.{@{-}}|)(?!\1)(\pL)#$&|a.$2.a#se&&y/{c/z />0:seg&/\B/%eg

Try it online!
Uses 3 levels of substitution!
This 87 byte version is both in input and output format easier to interpret, but is not competing since it uses 3 different characters in the output:
#!/usr/bin/perl -0p
s%b%$_="$`z$'";s:|.:/
/>s#(\w)(.{@{-}}|)(?!\1)(\w)#$&|a.$2.a#se&&y/{c/z />0:seg&/\B/%eg

Try it online!
It's easy to save another byte (the regex s modifier) in both versions by using some different (non-alphanumeric) character as row terminator (instead of newline), but that makes the input quite unreadable again.
How it works
Consider the substitution
s#(\w)(.{columns}|)(?!1)(\w)#c$2c#s

This will find two letters that are different and next to each other horizontally or vertically and replace them by c. In a maze whose paths consist of entirely the letter b nothing will happen since the letters are the same, but as soon as one of the letters is replaced by another one (e.g. z) that letter and a neighbor will be replaced by c and repeated application is a flood-fill of the connected component with c from seed z.
In this case I however don't want a complete flood-fill. I want to fill only one of the arms neighboring z, so after the first step I want the z gone. That already works with the c$2c replacement, but I later want to restart a flood-fill along another arm starting from the same point and I don't know which of the cs was originally z anymore. So instead I use
s#(\w)(.{columns}|)(?!\1)(\w)#$&|a.$2.a#se

b | a is c, b | c is c and z | a is {. So in a maze with paths made up of b and a seed z in the first step b will get replaced by c and z will get replaced by { which is not a letter and does not match \w and so will not cause further fills. The c however will keep a further flood-fill going and one neighbor arm of the seed gets filled. E.g. starting from
  b                      c
  b                      c
bbzbb       becomes    bb{bb
  b                      b
  b                      b

I can then replace all c by some non letter (e.g. -) and replace { by z again to restart the flood-fill:
  -                      -
  -                      -
bbzbb       becomes    cc{bb
  b                      b
  b                      b

and repeat this process until all neighbors of the seed have been converted. If I then once more replace { by z and flood-fill:
  -                      -
  -                      -
--z--       stays      --z--
  -                      -
  -                      -

The z remains behind at the end because there is no neighbor to do a transformation with.
That makes clear what happens in the following code fragment:
/\n/ >

Find the first newline. The starting offset is now in @-
s#(\w)(.{@{-}}|)(?!\1)(\w)#$&|a.$2.a#se

The regex discussed above with @{-} as number of columns (since plain @- confuses the perl parser and doesn't properly substitute)
&&

The /\n/ always succeeds and the substitution is true as long as we can still flood-fill. So the part after && is executed if the flood-fill of one arm is done. If not the left side evaluates to an empty string
y/{c/z / > 0

Restart the flood-fill and return 1 if the previous flood-fill did anything. Else return the empty string. This whole piece of code is wrapped inside
s:|.: code :seg

So if this is executed on a starting string $_ with a z at the seed position the piece of code inside will be executed many times mostly returning nothing but a 1 every time a neighbor arm gets flood-filled. Effectively $_ gets destroyed and replaced by as many 1s as there are connected components attached to z. Notice that the loop needs to be executed up to sum of component sizes + number of arms times but that is OK since it will "number of characters including newlines * 2 + 1" times.
The maze gets disconnected if there are no 1's (empty string, an isolated vertex) or if there are more than 1 arms (more than 2 1s). This can be checked using the regex /\B/ (this gives 0 instead of 1 on older perl versions. It's arguable which one is wrong). Unfortunately if it doesn't match this will give an empty string instead of 0. However the s:|.: code :seg was designed to always return an odd number so by doing an & with /\B/ this will give 0 or 1.
All that is left is walking the whole input array and at each walkable position seed with z and count connected arms. That is easily done with:
s%b%$_="$`z$'"; code %eg

The only problem is that in the non-walkable positions the old value is retained. Since we need 0s there that means the original input array must have 0 in the non walkable positions and 0 matches \w in the original substitution and would trigger flood-fills. That's why I use \pL instead (only match letters).

Java 8, 503 489 459 455 407 bytes
int R,C,v[][];m->{int r[][]=new int[R=m.length][C=m[0].length],i=R*C,a=i(m),x,y,q;for(;i-->0;m[y][x]=0,r[y][x]=i(m)!=a?1:0,m[y][x]=q)q=m[y=i/C][x=i%C];return r;}int i(int[][]m){int r=0,i=R*C,x,y;for(v=new int[R][C];i-->0;)if(m[y=i/C][x=i%C]>v[y][x]){d(m,x,y);r++;}return r;}void d(int[][]m,int c,int r){v[r][c]=1;for(int k=-3,x,y;k<4;k+=2)if((x=c+k%2-k/2)>=0&x<C&(y=r+k/2)>=0&y<R&&m[y][x]>v[y][x])d(m,x,y);}

-66 bytes thanks to @ceilingcat.
Try it online.
Explanation:
int R,C,                    // Amount of rows/columns on class-level
    v[][];                  // Visited-matrix on class-level

m->{                        // Method with int-matrix as both parameter and return-type
  int r[][]=new int[R=m.length][C=m[0].length],
                            //  Create the result-matrix, and set `R` and `C`
      i=R*C,                //  Index-integer
      a=i(m),               //  The current amount of islands
      x,y,                  //  Temp integers for the coordinates
      q;                    //  Temp integer for the value
  for(;i-->0                //  Loop `i` over each cell:
      ;                     //    After each iteration:
       m[y][x]=0,           //     Temporarily change the current value to 0
       r[y][x]=i(m)!a?      //     If the current and initial amount of islands are not
                            //     the same anymore:
                1           //      Set the result-value at this coordinate to 1
               :            //     Else:
                0,          //      Set the result-value at this coordinate to 0
       m[y][x]=q)           //     Then change the current value back to what it was
    q=m[y=i/C][x=i%C];      //   Save the current value at this coordinate
  return r;}                //  Return the result-matrix

// Separated method to determine the amount of islands in a matrix
int i(int[][]m){
  int r=0,                  //  Result-count, starting at 0
      i=R*C,                //  Index integer
      x,y;                  //  Temp integers for the coordinates
  for(v=new int[R][C];      //  Reset the visited array
      i-->0;)               //  Loop over the cells:
    if(m[y=i/C][x=i%C]      //   If the current cell is a 1,
       >v[y][x]){           //   and we haven't visited it yet:
      d(m,x,y);             //    Check every direction around this cell
      r++;}                 //    And raise the result-counter by 1
   return r;}               //  Return the result-counter

// Separated method to check each direction around a cell
void d(int[][]m,int c,int r){
  v[r][c]=1;                //  Flag this cell as visited
  for(int k=-3,x,y;k<4;k+=2)//  Loop over the four directions:
    if((x=c+k%2-k/2)>=0&x<C&(y=r+k/2)>=0&y<R
                            //   If the cell in the direction is within bounds,
       &&m[y][x]            //   and it's a path we can walk,
         >v[y][x])          //   and we haven't visited it yet:
      d(m,x,y);}            //    Do a recursive call for this cell

Python 2, 290 bytes
lambda m:[[b([[C and(I,J)!=(i,j)for J,C in e(R)]for I,R in e(m)])!=b(eval(`m`))for j,c in e(r)]for i,r in e(m)]
def F(m,i,j):
	if len(m)>i>=0<=j<len(m[i])>0<m[i][j]:m[i][j]=0;F(m,i,j+1);F(m,i,j-1);F(m,i+1,j);F(m,i-1,j)
b=lambda m:sum(F(m,i,j)or c for i,r in e(m)for j,c in e(r))
e=enumerate

Try it online!
-11 bytes thanks to Rod
-11 bytes thanks to Lynn

It's shorter to use F(m,i,j) for each element, saving 11 bytes

for q in((i,j+1),(i,j-1),(i+1,j),(i-1,j)): -> for q in(i,j+1),(i,j-1),(i+1,j),(i-1,j): - rm outer parens

Since F implicitly returns None, you can use F(m,i,j)or c instead of [F(m,i,j)]and c.

Also, and m[i][j] can be >0<m[i][j], and [q[:]for q in m] can be eval(`m`).

@Lynn you mean eval('m')? wouldn't that return the same list instance?

@ngn no, eval('m') would return the same instance (but it doesn't even work because of scoping). eval(\m`)basically is just stringifyingmand theneval`ing it again

@HyperNeutrino oh, I see... Thanks. I guess my python3 is too old, it fails with a SyntaxError.

@ngn no actually python 3 is too new. the backtick thing was removed in python 3.

@HyperNeutrino One of the many reasons why Python 2 is superior ...

Wolfram Language (Mathematica), 118 bytes
(r=ReplacePart)[0#,Cases[#~Position~1,p_/;(c=Max@MorphologicalComponents[#,CornerNeighbors->1<0]&)@r[#,p->0]>c@#]->1]&

Try it online!

Javascript 122 bytes
Input/output as a multiline string.
m=>m.replace(/./g,(v,p,m,n=[...m],f=p=>n[p]==1&&(n[p]=0,v=f(p-1)+f(p+1)+f(p-w)+f(p+w)-1?1:0,1))=>(f(p),v),w=~m.search`\n`)

For each walkable cell, put a block and try to fill the 4 neighbor cells. If the current cell is not a cut point, then starting from any open neighbor will fill all of them. Else, I will need more than one fill operation to reach all neighbor cells.
Less golfed
m=>{
  w = m.search('\n') + 1; // offset to the next row
  result = [...m].map( // for each cell
     ( v, // current value
       p  // current position
     ) => {
     n = [...m]; // work on a copy of the input
     // recursive fill function from position p
     // returns 1 if managed to fill at least 1 cell
     fill = (p) => {
        if (n[p] == 1)
        {
           n[p] = 0;
           // flag will be > 1 if the fill from the current point found disjointed areas
           // flag will be 0 if no area could be filled (isolated cell)
           var flag = fill(p+1) + fill(p-1) + fill(p+w) + fill(p-w);
           // v is modified repeatedly, during recursion
           // but I need the value at top level, when fill returns to original caller
           v = flag != 1 ? 1 : 0;
           return 1; // at least 1 cell filled
        }
        else
           return 0; // no fill
     }
     fill(p)
     return v // orginal value or modified by fill function
  })
}

Test

var F=
m=>m.replace(/./g,(v,p,m,n=[...m],f=p=>n[p]==1&&(n[p]=0,v=f(p-1)+f(p+1)+f(p-w)+f(p+w)-1?1:0,1))=>(f(p),v),w=~m.search`\n`)

var test=`in:
11101001
11011101
00000001
11101111
11110101
00011111
10110001
11111111
out:
01000000
00001001
00000001
00000101
00110000
00010000
00000000
11100000

in:
1111111111111111
1000000000000001
1111111111111101
0000000000000101
1111111111110101
1000000000010101
1011111111010101
1010000001010101
1010111101010101
1010101111010101
1010100000010101
1010111111110101
1010000000000101
1011111111111101
1000000000000001
1111111111111111
out:
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

in:
1011010001111010
1111111011101101
1110010101001011
1111001110010010
1111010000101001
0111101001000101
0011100111110010
1001110011111110
0101000011100011
1110110101001110
0010100111000110
1000110111011010
0100101000100101
0001010101100011
1001010000111101
1000111011000010
out:
0000000000111010
1011110001001000
0000000000000011
0000000100010000
0000010000101000
0000001000000100
0000000011000000
1001100000011110
0000000001000010
0110100001000110
0000100101000010
1000100000000000
0100001000000100
0000000100100001
0000010000111000
0000010000000010
`.match(/\d[10\n]+\d/g);
for(i = 0; test[2*i]; ++i)
{
   input = test[2*i]
   check = test[2*i+1]
   result = F(input)
   ok = check == result
   console.log('Test '+ i + ' ' + (ok?'OK':'FAIL'),
   '\n'+input, '\n'+result)
}

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


text:
There, I fixed it (with rope)
Related: Rather similar (but much easier) challenge horizontally: There I fixed it (with tape)
Challenge:
Given a string only containing upper- and/or lowercase letters (whichever you prefer) and new-lines, put rope vertically to fix it. We do this by checking the difference of two adjacent letters in the alphabet (ignoring wrap-around and only going downward), and filling the space with as much ROPE/rope as we would need.
NOTE: One other key difference between this challenge and the There I fixed it (with tape) challenge is that we're not wasting rope this time like we did with the tape (suggested by @JonathanAllan in part one of the challenge).
Example:
Input:
abc
bcd
ddd
eex
gfz
hka
imh

Output:
abc
bcd
Rdd
deE
efR
OPO
gEP
hRE
iOR
 kO
 PP
 mE
  R
  O
  P
  E
  R
  O
  P
  E
  R
  O
  x
  P
  z
  a
  E
  R
  O
  P
  E
  R
  h

Why?

Between b and d in column 1 should be c (length 1), so we fill this with R;
Between e and g in column 1 should be f (length 1), so we fill this with O;
Between f and k in column 2 should be ghij (length 4), so we fill this with PERO;
Between k and m in column 2 should be l (length 1), so we fill this with P;
Between d and c in column 3 should be efghijklmnopqrstuvw (length 19), so we fill this with EROPEROPEROPEROPERO;
Between x and z in column 3 should be y (length 1), so we fill this with P;
Between a and h in column 3 should be bcdefg (length 6), so we fill this with EROPER.

Challenge rules:

The difference only applies downwards, so no rope between za (column 3 in the example above).
It is possible to have multiple of the same adjacent letters like dd (column 3 in the example above).
You will continue using the ROPE one column at a time to not waste parts (suggested by @JonathanAllan in part 1 of the challenge).
You are allowed to take the input in any reasonable format. Can be a single string, string-array/list, character-matrix, etc. Output has the same flexibility.
You are allowed to use lowercase and/or uppercase any way you'd like. This applies both to the input, output, and ROPE.
Trailing spaces are optional (note that the correct amount of leading spaces are mandatory so the columns are correct).
Any amount of trailing and/or leading new-lines are also optional.
You can assume that all test cases will have the same length across all rows, so a\naa/[[a][a,a]] wouldn't be a valid input.
It is possible no ROPE is necessary, in which case the input remains unchanged.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Test cases:
As string:
 Input:  "abc\nbcd\nddd\neex\ngfz\nhka\nimh"
 Output: "abc\nbcd\nRdd\ndeE\nefR\nOPO\ngEP\nhRE\niOR\n kO\n PP\n mE\n  R\n  O\n  P\n  E\n  R\n  O\n  P\n  E\n  R\n  O\n  x\n  P\n  z\n  a\n  E\n  R\n  O\n  P\n  E\n  R\n  h"
As array-matrix:
 Input:  [[a,b,c],[b,c,d],[d,d,d],[e,e,x],[g,f,z],[h,k,a],[i,m,h]]
 Output: [[a,b,c],[b,c,d],[R,d,d],[d,e,E],[e,f,R],[O,P,O],[g,E,P],[h,R,E],[i,O,R],[ ,k,O],[ ,P,P],[ ,m,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,O],[ , ,x],[ , ,P],[ , ,z],[ , ,a],[ , ,E],[ , ,R],[ , ,O],[ , ,P],[ , ,E],[ , ,R],[ , ,h]]

As string:
 Input:  "a\nz\na"
 Output: "a\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nz\na"
As array-matrix:
 Input:  [[a],[z],[a]]
 Output: [[a],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[z],[a]]

As string:
 Input:  "zz\nyy\nxx\nxx\ncc\ncc\nbb\nad"
 Output: "zz\nyy\nxx\nxx\ncc\ncc\nbb\naR\n d"
As array-matrix:
 Input:  [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,d]]
 Output: [[z,z],[y,y],[x,x],[x,x],[c,c],[c,c],[b,b],[a,R],[ ,d]]

As string:
 Input:  "a\nb\nc\nc\nx\nx\ny\nz"
 Output: "a\nb\nc\nc\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nR\nO\nP\nE\nx\nx\ny\nz"
 As array-matrix:
  Input:  [[a],[b],[c],[c],[x],[x],[y],[z]]
  Output: [[a],[b],[c],[c],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[R],[O],[P],[E],[x],[x],[y],[z]]

As string:
 Input:  "zai\nybj\nxcq\nxcu\ncxw\ncxw\nbyr\nazw"
 Output: "zai\nybj\nxcR\nxcO\ncRP\ncOE\nbPR\naEO\n Rq\n OP\n PE\n ER\n Ru\n OO\n Pw\n Ew\n Rr\n OP\n PE\n ER\n RO\n Ow\n P \n E \n x \n x \n y \n z "
As array-matrix:
  Input:  [[z,a,i],[y,b,j],[x,c,q],[x,c,u],[c,x,w],[c,x,w],[b,y,r],[a,z,w]]
  Output: [[z,a,i],[y,b,j],[x,c,R],[x,c,O],[c,R,P],[c,O,E],[b,P,R],[a,E,O],[ ,R,q],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,u],[ ,O,O],[ ,P,w],[ ,E,w],[ ,R,r],[ ,O,P],[ ,P,E],[ ,E,R],[ ,R,O],[ ,O,w],[ ,P, ],[ ,E, ],[ ,x, ],[ ,x, ],[ ,y, ],[ ,z, ]]

As string:
 Input:  "asdljasdjk"
 Output: "asdljasdjk"
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k]]
 Output: [[a,s,d,l,j,a,s,d,j,k]]

As string:
 Input:  "asdljasdjk\nlkawdasuhq\nasjdhajksd"
 Output: "asdljasdjk\nRkaOdasPhR\nOPOPEajEPO\nPEPER  REP\nERERO  ORE\nROROh  POR\nOPOP   EPq\nPEPE   ROd\nERER   OR \nRsRO   PO \nO jP   EP \nl  w   RE \na  d   Os \n       P  \n       E  \n       R  \n       O  \n       u  \n       k  "
As array-matrix:
 Input:  [[a,s,d,l,j,a,s,d,j,k],[l,k,a,w,d,a,s,u,h,q],[a,s,j,d,h,a,j,k,s,d]]
 Output: [[a,s,d,l,j,a,s,d,j,k],[R,k,a,O,d,a,s,P,h,R],[O,P,O,P,E,a,j,E,P,O],[P,E,P,E,R, , ,R,E,P],[E,R,E,R,O, , ,O,R,E],[R,O,R,O,h, , ,P,O,R],[O,P,O,P, , , ,E,P,q],[P,E,P,E, , , ,R,O,d],[E,R,E,R, , , ,O,R, ],[R,s,R,O, , , ,P,O, ],[O, ,j,P, , , ,E,P, ],[l, , ,w, , , ,R,E, ],[a, , ,d, , , ,O,s, ],[ , , , , , , ,P, , ],[ , , , , , , ,E, , ],[ , , , , , , ,R, , ],[ , , , , , , ,O, , ],[ , , , , , , ,u, , ],[ , , , , , , ,k, , ]]

As string:
 Input:  "re\nop\npo\ner"
 Output: "re\noR\npO\neP\n E\n R\n O\n P\n E\n R\n O\n p\n o\n P\n E\n r"
As array-matrix:
 Input:  [[r,e],[o,p],[p,o],[e,r]]
 Output: [[r,e],[o,R],[p,O],[e,P],[ ,E],[ ,R],[ ,O],[ ,P],[ ,E],[ ,R],[ ,O],[ ,p],[ ,o],[ ,P],[ ,E],[ ,r]]

Can I fix it with hope instead? Hope is stronger than rope. (This is a poor attempt at humor, not a real question)

@KevinCruijssen did you mean this is easier of the TAPE is easier??

@MagicOctopusUrn Nope, rope is our only hope.

Can I ouput and array of columns??

@Dat The tape challenge is a lot easier (imho). And yes, you can output an array of column.

Just to doublecheck - if we can output an array of columns, I suppose we are also allowed to take input in columnwise manner, right?

@KirillL. Yep, completely fine by me.

Jelly, 21 bytes
ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y

Try it online!
Explanation
ZµOI’R“¡nⱮ»ṁż@"µF€z⁶Y  Main Link
Z                      Transpose the input so the columns are now rows
 µ                     New monadic chain
  O                    [Vectorizing] Convert each letter to its character code
   I                   [Vectorizing] Get the differences (gap size)
    ’                  [Vectorizing] Add one
     R                 [Vectorizing] Range from 1 .. x
           ṁ           Mold the string        into the ranges
      “¡nⱮ»                            "rope"
            ż@"        Vectorizing zip the rope strings with the original string (place ropes in gaps)
               µ       New monadic chain
                F€     Flatten Each
                  z⁶   Zip and fill with spaces
                    Y  Join on newlines for output

-1 byte thanks to Mr. Xcoder
-2 bytes thanks to Erik the Outgolfer

21 bytes using rope

@KevinCruijssen fixed

21 bytes

@EriktheOutgolfer oh yeah thanks idk why I was each-ing auto-each things :P

@KevinCruijssen done

05AB1E, 38 37 25 bytes
Saved 10 bytes with suggestions from Magic Octopus Urn and another byte changing output format.
Outputs a list of strings.
Footer pretty prints.
'ÙºUζεDÇ¥<)ζε`FX¬sÀU}J]Jζ

Try it online!
Explanation
'ÙºU                       # store the string "rope" in variable X
    ζ                      # transpose input
     ε                ]    # for each transposed row
      D   )ζ               # zip the row with
       Ç¥<                 # the decremented deltas of its character codes
            ε              # for each pair of [letter, delta-1]
             `F     }      # delta-1 times do:
               X¬          # get the first letter of X (originally "rope")
                 sÀU       # rotate the letters left by 1 and store in X
                     J     # join the rope-letter to the current row-letter
                       J   # join to list of strings (the new columns)
                        ζ  # transpose

@MagicOctopusUrn: The main difference is that with Tape we started over each time we should insert it, aTAdTAg. Now with rope we continue where we left off on the rope, so aROdPEg.

missed that tidbit, what about "extend string to length X" and inserting spaces inbetween each character representing places where the "rope" is supposed to go, then inserting the extended string into the spaces?

@MagicOctopusUrn: I think I have 32 using your suggestion above. Could still be golfable as well.

Does 05AB1E have a: pop a,b,c | push c[b..a] type dealio?

@MagicOctopusUrn: Nope. I have been thinking it needs one though.

X¬sÀU is flipping brilliant. Is there a way to use "head_extracted" and save 1 byte? I can't see it.

@MagicOctopusUrn: I don't think so. Not with this technique at least, as I only keep the original word. Might have worked in one of the previous versions.

F can be G and then you can remove the < for -1.

Python 2, 197 194 bytes
def f(s):
 r='ROPE'*len(`s`)*9;x=[]
 for i in zip(*s):
	x+='',
	for c,C in zip(i,i[1:]+(' ',)):l=(C>c)*(ord(C)+~ord(c));x[-1]+=c+r[:l];r=r[l:]
 print zip(*['%*s'%(-max(map(len,x)),s)for s in x])

Try it online!

-3 bytes thanks to ovs

Ruby, 119 bytes
->a{l=0;a.map!{|r|r.reduce{|x,y|x+("ROPE"*7)[l%4,-l+l+=[0,y.ord+~x[-1].ord].max]+y}}.map{|s|s.ljust a.map(&:size).max}}

Try it online!
Yes, this is much more difficult than the "TAPE" challenge. I tried to build up on my solution to that task, but this has a few extra twists.
Takes input as a columnwise array of characters, returns an array of strings, also in columnwise format. The code in the footer of the TIO link performs pre- and post-processing of I/O data so that we could supply a more manageable string and then print the result nicely.
Explanation
The code makes two passes through the input array.
In the first pass we apply the reduce operation that fills up the space between the characters with the required amount of ROPE (y.ord-x[-1].ord-1 characters, if positive).
We also need to keep track of the used ROPE length (l).
Unlike in the TAPE case we cannot simply use rjust for filling, as it would always start from the R character. Instead, taking a proper slice of a long "ROPEROPE..." string seems lighter on byte count, especially since we also need to update l on the fly.
In the second pass we left-justify the resulting strings with spaces to match the length of the longest of them. Since we need the full results of the previous iteration here, the first pass modifies the array in place (hence map!, not map).

To my mind your columnwise I/O format already solves so much of the problem that it becomes a loophole

@TonHospel I also hesitated at first, but OP specifically confirmed this is OK in comments to the challenge

Ah, not what I would have decided, but that's OK then.

-1 bytes thanks to Kevin Cruijssen
-70 bytes thanks to Jonathan Frech, wow.......
Python 3, 203 bytes
def f(s,c=0,x=()):
	for i in range(len(s[0])):
		p,o=" ",""
		for j in s:t=j[i];y=p>' 'and~ord(p)+ord(t);o+=('ROPE'*y)[c:y+c]+t;c,p=c%4+y*(y>=0)%4,t
		x+=o,
	for i in x:yield i.ljust(len(max(x,key=len)))

Try it online!

ord(t)-ord(p)-1 can be ord(t)+~ord(p) to save a byte again. ;) Here is the relevant tip.

+=[o] -> +=o,.

@Dat Are you sure?

Since you only deal with printable characters, p!=' ' is also equivalent to p>' '.

268 bytes.

241 bytes, heavy golfs!

k for k in is also a no-op ...

229 bytes.

@JonathanFrech, you might as well write your own answer man :) Thats really impressive!

204 bytes.

203 bytes, using a generator.

Python 3, 182 bytes
from itertools import*
def f(l):r=cycle('ROPE');return zip_longest(*(''.join(c+''.join(islice(r,max(ord(n)+~ord(c),0)))for c,n in zip(z,z[1:]+(' ',)))for z in zip(*l)),fillvalue=' ')

Try it online!
The function takes its input as a list (or an iterable) of strings and also returns a generator for a sequences of strings, which is almost as good as a list.
Ungolfed
…for better readability of the nested generators.
def f(l):
    r = cycle('ROPE')
    return zip_longest(
        *(
            ''.join(
                c + ''.join(islice(r, max(ord(n) - ord(c) - 1, 0)))
                for c, n in zip(z, z[1:] + (' ',)))
            for z in zip(*l)),
        fillvalue=' ')

Explanation

The function uses zip to transpose the incoming list of lines into a generator of columns.
The innermost generator looks at pairs of adjacent characters and…
…slices the required amount of continuous ROPE out of an (infinite) cycle generator.
After copious amounts of string joining from generators the function re-transposes the list of columns back to a generator or lines and fills missing entries with zip_longest.

Stax, 25 bytes
ÅiV╘ε╢+gA┘♦W[≈{`Co?-φvM«'

Run and debug online!
Input and output are given as space separated lists. Input is the list of rows as required, output is the list of columns as permitted.
Explanation
Uses the unpacked version to explain.
M"ROPE"s{2B{Ev|r%b:m~|(,m_s\mJ
M                                 Transpose
 "ROPE"                           The string "ROPE"
       s{                   mJ    Map each column (in the original input) with block, and output with space as the separator
         2B                       All contiguous pairs of current column
           {            m         Map each pair with block
            Ev|r%                     Pair [j,k] to length of range [j..k-2]
                 b:m                  Repeat current repeating string to given length
                    ~                 Last line gives the result the pair should map to, now store it on the input stack
                     |(               Rotate current repeating string `p` times, where `p` is the length of the range [j..k-1]
                       ,              Fetch back the result
                         _s\      Zip with current column, filling missing element with empty string