text:
Simulate a Cisco Ping
Premise:
For those in networking, you've most likely sent a ping to or from some device to make sure everything's properly connected. Cisco, a popular company in networking[citation needed], has a command for it in their IOS that looks like this:

(Image source)
Your challenge is to graphically recreate a portion of this. The portions we are skipping are the first line (Type escape sequence to abort.) entirely, along with the IP address and round-trip times.
You will start by outputting the following:
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:

You will then simulate the echo requests going out. Each request will start by waiting 2 seconds and then generating the response. A successful echo response  is represented by a !, a failed one by .. We won't actually be sending packets but to represent packet loss, your program must randomly choose between the two options with a non-zero chance for each. This line will start empty and each tick will add another character.
After the fifth echo, the percentage line will be outputted and the program should then terminate. The percentage line will be in the format of
Success rate is $p percent ($s/5)

where $p is in regex 0|20|40|60|80|100 and $s is the number of successful echos. The screen must be updated after each wait period by either redrawing the new state or appending to the existing echo line. This includes the Sending line.
Example run: (The tick count should not be displayed and is there to clarify what the output should look like at each time step)
#Tick 0
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:

#Tick 1
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.

#Tick 2
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.!

#Tick 3
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.!.

#Tick 4
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.!.!

#Tick 5
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.!.!.
Success rate is 40 percent (2/5)

Input:
No usable input provided.
Output:
Any reasonable format. An example final output looks like this:
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
...!!
Success rate is 40 percent (2/5)

Rules:

You must either append to the echo line or redraw the screen after each tick.
! and . do not have to be equally likely, just both possible.
Successive runs must be able to generate different results
Gifs or webms of your output would be cool. No bonus or anything for it though.
Standard Loopholes forbidden
This is code-golf

Are we allowed to print the strings with trailing spaces if the output is visually the same?

Should the last line be terminated by a linefeed?

@Rogem It's optional.

C (gcc), 172 bytes
So, I shaved off a whopping 6 bytes off of this thing with some quite ridiculous trickery. Compile with -DK=!sleep(2)-putchar(rand()%2?33:46)/46. Depends on the sleep() function being defined in the system standard libraries.
Does not loop or recurse.
p(n){puts("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:");printf("\nSuccess rate is %i percent (%i/5)",n*20,n=K+K+K+K+K);}

Try it online!
Explanation
This solution depends on three critical implementation/runtime details. First, the sleep() must not be interrupted, via e.g. a signal. Second, the additions and subtractions being resolved in order from left-to-right. Third, the arguments to printf() must be resolved right-to-left.
With that out of the way, let's sort through this thing.
p(n){ // Unfortunately, I need a variable to store the RNG result.
    // This is straight-forward printing of a line.
    puts("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:");
    // So, resolving right-to-left, we have a) the K preprocessor macros,
    // b) the assigment of their sum to n, c) the percentage equivalent of
    // the fraction n/5 and d) a constant format string.
    // The summation of the K's is where the magic happens.
    printf("\nSuccess rate is %i percent (%i/5)",n*20,n=K+K+K+K+K);
}

The compiler argument
-DK=!sleep(2)-putchar(rand()%2?33:46)/46

So, starting from the left (i.e. like it should resolve), we have sleep().
sleep() returns the number of seconds left when it returns,
so we expect the user (and other processes) to be kind and to not interrupt our sleep. We take the logical complement, and because
in our case sleep() will always return 0, the result is 1. More on the
significance later.
Next, we enter putchar(). putchar() prints a single 1-byte character,
and returns the value of the byte. So, we get a random value inside,
compute modulo-2 for a nice 50-50 split (albeit with horrible entropy),
and then ternary-conditional it into our desired characters - ! (33)
and . (46). Then we divide the return value of putchar() with 46.
Now, that division will return 0 for ! and 1 for . - so we take 1 (from !sleep()) and subtract the result of the division from that. Presto!
Okay, there's a slight problem. When you write things to a buffer in C (i.e. stdout), it doesn't necessarily write to the receiving end immediately. In fact, when I was running this on my distro of choice, I discovered that it would only print the pings after the program terminated. However, given that all the other solutions in C are letting that slide, and that there probably exists at least one machine out there somewhere does that and fulfills all the other prerequisites (and one could always just "fix" that in the kernel...), I'm not going to mess with my score by fflush()ing stdout.

APL (Dyalog Unicode), 147 138 bytes
{5=≢⍵⊣⎕DL≢⎕←↑⌽'.!'[⍵]'Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:':⎕←('Success rate is',×∘20,'percent (','/5)',⍨⍕)+/⍵}¨1↓¨,\?6⍴2

Try it online!
This is a big Direct function. As with other answers, the TIO link will only output after the execution is completed. That said, @Adám has created a handy helper function so the timestamps can be visualized. That version of the code can be found here.
This answer uses ⎕IO←0, which sets the Index Origin of everything from 1 to 0.
Thanks to @ngn for the 9 bytes saved (and for ruining my explanation! Now I have to do it again (ლಠ益ಠ)ლ)
How:
The function receives 1 fixed argument, which is ⍵ on the right.
As ⍵, we have ¨1↓¨,\?6⍴2. This expression randomly chooses (?) between 0 and 1 6 times (6⍴2 creates a 6 element vector of 2's). The results are concatenated (,\) to form a 6 element vector of 1 to 6 element vectors (e.g.: 1  0 1  0 1 1  0 1 1 0  0 1 1 0 1  0 1 1 0 1 0). The first element of each is dropped (1↓¨), and then each resulting vector is passed as ⍵ (¨), running the function 6 times.
{5=≢⍵⊣...:...} is a conditional statement. If ⍵ has 5 elements (aka if it's the last iteration), it'll execute the code after the guard (:). The ⊣ assures the condition will be the last thing evaluated, so the program will always print the string before the guard.
{...⎕DL≢⎕←↑⌽'.!'[⍵]'Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:'...} creates a two-element vector formed by the indexed vector '.!'[⍵], which will output the successes and failures, and the ping string itself. That vector is then reversed (monadic ⌽) to the correct order, then mixed (monadic ↑) into a matrix. That matrix is then output to stdout (⎕←), and a DeLay (⎕DL) is added. The argument to ⎕DL is the number of elements in the matrix (≢), namely 2, creating a 2 second delay between function calls.
{...:⎕←('Success rate is',×∘20,'percent (','/5)',⍨⍕)+/⍵} creates the last string to be output. It'll sum the elements of the argument (+/⍵) and pass the result as argument to the tacit function inside the parenthesis. That function first prepends (dyadic ,, followed by ⍨) the stringified (⍕) argument with the string '/5)', then appends that to the string 'percent ('. Next, it'll append the resulting string to  20 times the argument (×∘20), and then append it to the rest of the output, which is sent to stdout via ⎕←.

Trailing newline is fine. Commenting here because I'm on mobile

⎕DL 2⊣⎕←... -> ⎕DL≢⎕←...

C# (Visual C# Interactive Compiler), 212 bytes
int i,p;for(Write("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:\n");i++<5;Write(".!"[-p+(p+=new Random().Next(2))]))System.Threading.Thread.Sleep(2000);Write($"\nSuccess Rate is {p*20} percent ({p}/5)");

Try it online!

Welcome to PPCG! I took the liberty of generating a Try It Online! link for you. I suggest you edit your answer with the template TIO provides for posting answers in PPCG (although that's naturally not required).

You can get this down to 299 bytes by inline constructing Random instead of saving it in var r. Heres a link to my suggestestion

This keeps crashing with IndexOutOfBoundsExceptions for me.

@mypronounismonicareinstate Fixed. How did I not catch this months ago?

Java (JDK), 227 bytes
()->{var o=System.out;int s=0,i=0;for(o.println("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:");i++<5;Thread.sleep(2000))o.print(Math.random()>.5&&s++<9?"!":".");o.printf("\nSuccess rate is %d percent (%d/5)",s*20,s);}

Try it online!

The ping in action

Explained
()->{                               // Lambda taking no input
    var o=System.out;               // Assign System.out to a variable
    int s=0,i=0;                    // Initialise successes and loop ints
    for(o.println("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:");
                                    // ^Print opening line
        i++<5;                      // Loop five times
        Thread.sleep(2000))         // Sleep for 2 seconds at the end of each loop
            o.print(                // Print out..
                Math.random()>.5    // ..if random number is greater than .5 (50%)
                    &&s++<9?        // ..and incremented successes
                        "!":".");   // ! for success and . for failure
    o.printf("\nSuccess rate is %d percent (%d/5)",s*20,s);
                                    //^Print formatted closing line
}

printing is the killer there :/

PowerShell, 166 162 158 bytes
'Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:'
0..4|%{sleep 2;write-host -no '.!'[($x=0,1|Random)];$d+=$x}
"
Success rate is $($d*20) percent ($d/5)"

Try it online!
Really similar to the Python answer to TFeld. Timing doesn't work on TIO (TIO only outputs at program completion), but works locally.
The first line is just a string placed on the pipeline. The middle line loops from 0 to 4, each iteration sleeping for 2 seconds, then write-host with -nonewline. We're writing out either a ! or . chosen Randomly and stored into $x. We then increment $d based on $x.
The last line is another (multiline) string placed on the pipeline, with a little bit of calculation in the middle to come up with the percentage.
-1 byte thanks to Veskah
-3 bytes thanks to Ciaran_McCarthy

Turning the success line into a multi-line string instead of using back-tick n (don't know how to escape it in comments) should save a byte. 161 bytes

Can you shave off 3 bytes from using *20 instead of /5*100?

@Veskah Yes, thanks.

@Ciaran_McCarthy Holy cow, thanks for the blindingly-obvious golf. :)

JavaScript + HTML, 203 + 9 = 212 bytes

setTimeout(f,2e3,-~x,y+z),u=s=>o.innerText+=s)=>x?x<6?u(`.!`[n=new Date%2],g(n)):u(`
Success rate is ${y/20} percent (${y}/5)`):u`Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:`&g(0)

Try it
If new Date isn't random enough then add 8 bytes to use Math.random() instead (some other modifications have been made to allow it to run properly in a Snippet):

f=(x,y=0,g=z=>setTimeout(f,2e3,-~x,y+z),u=s=>o.innerText+=s)=>x?x<6?u(`.!`[n=Math.random()+.5|0],g(n)):u(`
Success rate is ${y/20} percent (${y}/5)`):u`Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
`&g(0)
f()

Python 3, 221 220 216 209 208 201 bytes
import time,random
p=print
p('Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:')
n=0
exec("time.sleep(2);i=random.choice('.!');n+=i<'#';p(end=i);"*5)
p(f'\nSuccess rate is {n*20} percent ({n}/5)')

Try it online!
Timing doesn't work in TIO, but works in console. (TIO outputs at the end of execution)
-7 bytes, thanks to Erik the Outgolfer

201 bytes.

@EriktheOutgolfer Thanks! :)

JavaScript, 322 268 267 265 bytes

(f=(a,t,s)=>a--?new Promise(r=>setTimeout(r,2e3,s+='!.'[~~(Math.random()<.5)],t(`Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:`))).then(_=>t(s)||f(a,t,s)):t(`Success rate is ${s=s.match(/!/g),s=s?s.length*2:''}0 percent (${s/2}/5)`))(5,_=>console.log(_),'')

Try it online!
JavaScript + HTML, 299 bytes
To meet output formatting requirement

(f=(a,t,s)=>a--?new Promise(r=>setTimeout(r,2e3,s+='!.'[~~(Math.random()<.5)])).then(_=>t(...s)&&f(a,t,s)):t(`\nSuccess rate is ${s=s.match(/!/g),s=s?s.length*2:''}0 percent (${s/2}/5)`))(5,t=(..._)=>p.innerHTML+=_.pop(),'',t(`Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:\n`))

Perl 6, 154 bytes
say "Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:";say
sum(map {sleep 2;.print;?/\!/},roll
5,<. !>).&{"\nSuccess rate is {$_*20} percent ($_/5)"}

Try it online!

Clean, 305 bytes
import StdEnv,Math.Random
s::!Int->Int
s _=code {
ccall sleep "I:I"
}
t::!Int->Int
t _=code {
ccall time "I:I"
}
Start#l=take 5(map((bitand)1)(genRandInt(t 0)))
=("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:\n",[if(e>0)'!''.'\\e<-l|s 2==0],"\nSuccess rate is ",20*sum l," percent (",sum l,"/5)")

Try it online!

PHP, 161 bytes
<?="Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
";for(;$x++<5;print$y?'!':'.')$z+=$y=rand()%2+sleep(2);echo"
Success rate is ",$z*20," percent ($z/5)";

Try it online!
$ php fakeping.php
Sending 5, 100-byte ICMP Echos, timeout is 2 seconds:
.!.!.
Success rate is 40 percent (2/5)

C (gcc), 176 174 bytes
f(i,j){for(puts("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds"),j=i=5;sleep(2),i--;putchar(rand()%2?j--,33:46));printf("\nSuccess rate is %d percent (%d/5)",j*20,j);}

Try it online!
Saved 2 bytes thanks to Rogem
Ungolfed:
f(i,j) {
    for (puts("Sending 5, 100-byte ICMP Echos, timeout is 2 seconds"),
            j = i = 5; sleep(0), i--;
            putchar(rand() % 2 ? j--, 33 : 46));
    printf("\nSuccess rate is %d percent (%d/5)",j * 20, j);
}

174 with 33 and 46 instead of '!' and '.', respectively.

Befunge-98 (PyFunge), 164 bytes
#va":sdnoces 2 si tuoemit ,sohcE PMCI etyb-001 ,5 gnidneS5"k,>0"2 peels"=k
>?1'!>,+\1+:4`!jv\'^'=1p
;>0'.^;")5/",,,@>$" si etar sseccuS"afk,,:2a**.'0+"( tnecrep"9k,

Try it online!
Unfortunately, I could only test it on TIO, where it returns everything after ten seconds, but it should work as expected.

05AB1E, 83 bytes
т’Sïà 5, ÿ-ÄÁ ICMP ®Ès, €º€Ä is 2 šÀ:’,„.!5ãΩDv.Z.Zy?}õ,'.¢xT*“íÞ„¼€ˆ ÿ‰» (ÿ/5)“.ª?

Try it online!


text:
Most Populated WordSearch
Write a program to generate a rectangular word-search of size 6x9. Words may go downwards, rightwards and diagonally (downwards and to the right), they may also overlap on the board.
The challenge is to include as many different English words as possible from https://www.ef.co.uk/english-resources/english-vocabulary/top-3000-words Your program may select desirable words itself to include. You score 1 point per word included.

For example:
For clarity I've used "." symbols below instead of random letters.
dolphin..
o.....o..
g.....u..
.....ono.
.........
.........

The above word-search contains {'do', 'dog', 'dolphin', 'hi', 'i', 'in', 'no', 'noun', 'on', and 'phi'} so from what is filled in so far scores 10 points.
In the unlikely event of a tie the shortest code size will be used to choose a winner.

Comments are not for extended discussion; this conversation has been moved to chat.

Right, I hope those edits have covered everyones issues. Sorry if I missed anyone out. I'll put in a reopen request.

The ptoblem with this challenge is that answers will just consist of printing the optimal wordsearch itself, rather than a program finding the wordsearch. What I'd recommend instead is having the submission take input as a list of words and returning a wordsearch within reasonable time complexity. You could turn it into a [tag:test-battery] question, where you have a series of test cases and see which submission produces the most compact wordsearchs.

@King Test batteries in this case being several specific subsets of words from the original word list?

Voting to reopen on the condition that you make it just one word search-- two is unnecessary.

@lirtosiast Wouldn't a test batteries mean that there were in effect several word-searches? Also it's only 2 because it was suggested on the Meta post about this question. I'm inclined to agree but cannot do all thease contradictory things. Do you think that a totally optimal solution will be found and reposted by all, or looking up the answer etc… and not posting code is going to be an issue? Most compact to contain all the words will be impractically large.

Jelly, 20 bytes, score  53  57
“¦/œḌ⁼ƥ~ẹµḲ5&Ċd@ṡ»ḲY

Try it online!
Wordsearch:
a d m i s s i o n
h o u s e h o l d
s o m e t h i n g
g e n e r a l l y
p o t e n t i a l
t h e r e f o r e

Words:
admission generally household potential something therefore
general mission
house stair there thing
ally gene here hill hold miss some tent thin
air all due era for hat her ill oil old one pot see set son ten the use
ad ah at do go he hi ie in me ms oh on or so to us
i

Previous
...the dictionary referenced in the question has changed since this was posted so this would drop to a score of 33.
Jelly, 23 bytes, score  150 154 158  160
“RʂȥḄ0ḣq⁾÷yḊzIḥẊḥYx »ḲY

Try it online!
Used Python to search for boards; there are, no doubt, higher scores possible though.
The board:
donations
beverages
placement
performed
metallica
thousands

The words:
['a', 'ac', 'ace', 'ae', 'ag', 'age', 'ages', 'al', 'all', 'am', 'an', 'and', 'ar', 'art', 'as', 'at', 'ati', 'au', 'b', 'be', 'beverage', 'beverages', 'bp', 'c', 'ca', 'cd', 'ce', 'cement', 'cf', 'd', 'da', 'das', 'db', 'do', 'don', 'donation', 'donations', 'ds', 'e', 'ec', 'ed', 'ee', 'eh', 'el', 'em', 'en', 'ent', 'er', 'era', 'es', 'et', 'ev', 'eve', 'ever', 'f', 'fa', 'fo', 'for', 'form', 'formed', 'g', 'ge', 'gem', 'h', 'ho', 'i', 'ia', 'ic', 'in', 'io', 'ion', 'l', 'la', 'lace', 'le', 'lee', 'li', 'll', 'ls', 'm', 'me', 'med', 'men', 'ment', 'met', 'meta', 'metal', 'metallic', 'metallica', 'mi', 'min', 'mr', 'mt', 'n', 'na','nat', 'nation', 'nations', 'nd', 'ne', 'nec', 'ns', 'nt', 'nv', 'o', 'oe', 'og', 'ol', 'on', 'ons', 'or', 'ou', 'p', 'pe', 'per', 'perform', 'performed', 'pl', 'place', 'placement', 'pm', 'pp', 'ppm', 'r', 'ra', 'rage', 're', 'rf', 'rl', 'rm', 'rt', 's', 'sa', 'san', 'sand', 'ss', 'st', 'std', 't', 'ta', 'tall', 'td', 'th', 'thou', 'thousand', 'thousands', 'ti', 'tion', 'tions', 'to', 'tr', 'treo', 'u', 'us', 'usa', 'v', 'va', 'var', 've', 'ver']

The search
Note LIMIT_TO_N_BEST_NINES limits the search - lower numbers try fewer boards by never using the lower scoring rows (nine letter words) which will find "good" scores quicker, while higher numbers (up to 909 - the number of 9 letter words in the dictionary) will search more boards (and likely never complete!).
f = open(filePath, 'r')
ws = set(w.replace('\n', '').lower() for w in f.readlines())

def iterSubWords(w, ws):
    for l in range(1,len(w)+1):
        for s in range(len(w)-l+1):
            if w[s:s+l] in ws: yield w[s:s+l]

nines = sorted([w for w in ws if len(w) == 9], key=lambda w:len(tuple(iterSubWords(w, ws))), reverse=1)

def diags(rows):
    for rs in range(len(rows)):
        yield ''.join(rows[rs + x][x] for x in range(min(len(rows) - rs, len(rows[0]))))
    for cs in range(1, len(rows[0])):
        yield ''.join(rows[x][cs + x] for x in range(min(len(rows[0]) - cs, len(rows))))

def diagWords(rows, validWords):
    for d in diags(rows):
        for sw in iterSubWords(d, validWords): yield sw

def allWordsOnBoard(rows, validWords):
    r = set()
    for row in list(rows) + [''.join(col) for col in zip(*rows)]:
        for validWord in iterSubWords(row, validWords): r.add(validWord)
    for validWord in diagWords(rows, validWords): r.add(validWord)
    return r

from itertools import combinations, permutations

LIMIT_TO_N_BEST_NINES = 107

m = 0
for wl in combinations(nines[:LIMIT_TO_N_BEST_NINES], 6):
    fws = allWordsOnBoard(wl, ws)
    if len(fws) > m:
        for p in permutations(wl):
            fws = allWordsOnBoard(p, ws)
            if len(fws) > m:
                m = len(fws)
                print(m, p)

Are all of your examples words? Some of them look like just plain letters of the alphabet ('m', 'n', 'l', etc...). Also, I don't think many of the two letter examples are words either ('aa', 'ht', 'nn', etc...).

I'm using the linked dictionary.

This challenge is off to a worrisome start. You're using 'words' from a list that contains many that aren't words in the English language. I'm strictly using English, but none of my words show up in that list! And these are the only two answers so far.

I am following the specification :(

Maybe the specification should be edited to remove the specific reference to English? That might make it better....

@ouflak, challenge specs trump everything here. Even reality!

@Shaggy, I'm fine with that. But the spec does say English.

Lua, 73 bytes - 49 66 74 75 words
print("abraiders\nscrapings\nsheathers\ncarabiner\nbrahmanis\nrelapsers")

Try it online!
I got the words from another StackExchange question on the Puzzles site. Prints:
abraiders
scrapings
sheathers
carabiner
brahmanis
relapsers

So it's a minimum of eight words each row for 48 words, plus the indefinite article 'a' for 49 words horizontally. Edit: It seems there was an edit to the challenge and there now may be a limit to a list of very specific words and, unlike all of the words forming my list, not all of those words are actually even English. sigh Might just leave this here for posterity.
Edit
Words formed horizontally:
i (pronoun 'I')
id
aid
aide
raid
aider
braid
aiders
raider
raiders
braiders
abraiders

la
lap
laps
lapse
elapse
relapse
relapser
relapsers

in
pin
rap
ping
crap
pings
aping
scrap
raping
craping
scraping
scrapings

at
he
eat
her
she
the
eath
heat
hers
heath
sheath
sheathe
sheather
sheathers

a
ab
rab
bin
car
arab
arabi
arabin
arabine
carabine
carabiner

is
ra
rah
man
bra
rahm
brahm
brahma
brahman
brahmani
brahmanis

Words formed vertically:
as
aha
are
ass
era
char
hare

Use the dictionary in the question, all single letters are words for example.

Formed my answer before that edit. Darn!

Are there any words vertically in this?

Yes, I've done some reshuffling and am slowly editing the word count to include those. I was going for a maximum along the 9 length row to have the most possible words right from the start.

I think I might need to edit my answer to show all of the possible words.

I count 95 words (from the list): ['a','aa','aaa','ab','ah','ai','aid','an','ap','api','ar','arab','as','ass','at','b','bc','bi','bin','bm','br','bra','c','ca','car','cb','ch','char','cr','crap','d','de','der','di','e','ea','eat','el','en','er','era','g','gr','h','ha','he','heat','heath','heather','her','hi','i','ia','id','ide','in','ing','ip','l','la','lap','m','ma','man','n','ne','ng','ni','nn','p','pi','pin','ping','ps','pt','r','ra','raid','rap','re','rg','rr','rs','s','sc','se','ser','sh','she','sr','ss','t','tb','th','the']

Sorry @ouflak, I'm not doing this to mess you around. I'm trying to address peoples issues with the question, I've made a meta post about this too.

@ouflak There good words listed in your answer. Thank you. It's the closest so far to the answer I'd like to mark as correct.

source: Stack Exchange

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

sort: votes


text:
Sort a list, poorly
Don't you hate it when you're trying to roughly sort a list based on user data, but you have to poll the user for thousands of comparisons?
Hate no more, because the answers to this challenge are (going to be) here!
Method
The sorted-ness of a list is defined by how many possible comparisons it has which are correct.
Let's have an example. The list [1, 2, 4, 3] has the possible comparisons 1 <= 2, 1 <= 4, 1 <= 3, 2 <= 4, 2 <= 3 and 4 <= 3. 1 out of those 6 comparisons are incorrect, so this list is (5 / 6) * 100 = 83.33% sorted.
Challenge
Create a program or function that sorts a given list (but not necessarily 100%) and sorts all of the below test cases by at least 75%.
If your program sorts a list by less than 75% that is not in the test cases, that's okay, but try not to hard-code to the test-cases although I can't ban you from doing so.
You must use a comparison sort. Pretend the numbers are black boxes that only support comparison operations.
Your program may sort the list backwards, which means if it's is able to sort all of the test cases by less than 25%, you can post it as a backwards sort.
For programs that perform STDIO, the list should be taken and printed as base-10 integers with some kind of separator, with optional text at the start and end (for example 1\n2\n3 or [1, 2, 3])
You may also return or print a list of indices that correspond to the sorted list (e.g. [1, 3, 2] when sorted is indices [0, 2, 1])
You may not compare any of the elements of the list with any constant values.
The defaults for I/O and standard loopholes apply as usual.
Scoring
This is a code-challenge, not a code-golf. Your code is scored by the highest number of comparisons your code needs to be able to sort across all of the test cases.
A comparison is defined as any operation that involves a value x from the given list and another value y which may or may not also be from the given list, and does a boolean check of one of x < y, x <= y, x == y, x >= y or x > y or returns a result depending on whether x < y, x == y or x > y. This includes any expressions, including mathematical equations, that have the same effect of comparison.
The test cases are here.
To verify your sorted lists, use this program.
The lowest score wins. Good luck!

Given that it takes about n log n comparison for a naive algorithm, make sure that there are >> n log n lists with some length may work. For example, if each list has length 200, having 50000 tests should be ok.

Is this code valid? (100% sorted, no observable comparison)

@Arnauld See my Python verifier above, if it helps.

Now it's not allowed to compare an element with a constant, the verifier is here.

Info: even if compare to constant is not allowed, it's still possible to hardcode for the test cases with score n+log(number of test cases), assume test cases are random.

@user202729 "valid" was a badly chosen word. I should have asked: what is the score for this code? Is it 0?

@Arnauld Don't answerers have to prove that their code has the claimed score? If the performed operations are unobservable and the answerer can't count number of comparisons then it's their fault. /// It's possible to make the rules rigorous by making it similar to an interactive problem in competitive programming, but then people are forced to implement a lot of boring boilerplate code to interact via stdin/stdout/etc.

@Anders Kaseorg Yes, it should. Updated.

Are we required to use a comparison sort, that is, only access the list by comparing pairs of values at given indices? I'm unclear in general how many operations on elements can be scored if they are not comparisons.

@xnor Browsing TVTropes, are you? ;) Yes, a comparison sort is required. Pretend the numbers are objects that support comparisons but you are unable to get their intrinsic value for some reason or another.

@Arnauld user is correct, if you are unable to tell how many comparisons your code actually performs by a custom object or other introspection, it is not valid to post. As for the issue of defining an expression that performs a comparison, anything that splits the programs behavior into one of 2 or 3 outcomes depending on the relationship between x and y. That means that subtraction doesn't count, as it can yield one of any number of results, as opposed to only one of a few.

@LyricLy Haha, I ninja-fixed the link. I think this makes sense, but could be made clearer and more precise in the challenge text. The usual model for this is that you have a black-box function that takes two indices i and j and tells you whether a[i]<a[j] (or since, you allow ties, it could give cmp(a[i],a[j]).

Also, a technicality: since the output is itself a list of numbers, the code needs to at some point get the actual values of the numbers, unless it can do something like manipulate pointers to the numbers which is not an abstraction all languages have. Allowing output to be a permutation of list indices that would sort the list could address that.

Please clarify whether an answer is required to sort all lists 75% of the way (given “To poorly sort a list, you must sort it at least 75% of the way.… Create a program or function that poorly sorts a given list”), or whether it’s allowed to sort the given test cases 75% of the way while sorting other possible inputs less than 75% of the way (given “and sorts all of the below test cases by at least 75%”)? I assumed the former, but it looks like @xnor assumed the latter.

@AndersKaseorg Ah, that's a mistake I made while writing the challenge. It's only required to sort the test case lists all of the way. I'll clarify that.

@xnor That's what I suggested above, but then people are forced to implement a lot of boilerplate code, etc.

Are we allowed to actually treat the numbers in a way that their value is unknown?

If I've read correctly, I only have to count comparisons that involve list elements and values derived from list elements, but any number of comparisons having nothing to do with the list content is fine?

@Οurous That is correct.

Python 3, score 244
def sort_func(l):
	num_pieces = 9

	medians = [median5(l[5*i : 5*(i+1)]) for i in range(num_pieces)]

	center = median(medians)

	lows = []
	highs = []

	for x in l:
		if x < center:
			lows.append(x)
		else:
			highs.append(x)

	for d in range(9):
		for lst in [lows, highs]:
			if lst[d] > lst[~d]:
				lst[d], lst[~d] = lst[~d], lst[d]

	l[:] = lows + highs

def median(lst):
	lst.sort()
	return lst[len(lst)//2]

def median5(l):
	a, b, c, d, e = l

	if a > b: a,b=b,a
	if c > d: c,d=d,c

	if a < c:
		a = e
		if a > b: a,b=b,a
	else:
		c = e
		if c > d: c,d=d,c

	if a < c:
		if b > c:return c
		else: return b
	else:
		if d > a:return a
		else: return d

Try it online! Thanks to user202729 for making the comparison-counting class for verification.
The algorithm has 3 parts:

Estimate the median of the list (~76 comparisons if unlucky)
Compare each element to the estimated median and put it in the low or high sub-list (150 comparisons, 1 per list element)
Tweak each of the low and high lists by swapping the first and last elements if they are other of order, then the 2nd and 2nd to last, up to the 9th and 9th-to-last (18 comparisons)
Output the concatenated low and high list

The idea is that if we knew the median of the list, we could partition the list into its low and high halves by comparing each element to the median. Then, putting the high half after the low half, any comparison between elements from different halves is correct. On average half the within-half comparisons happen to be right, so a random comparison has about a 75% chance of being correct overall.
Sometimes though we get unlucky in the random comparisons for a given list. So, we improve each half a little by swapping the first and last element if they happen to be out of order, since this is the highest-impact swap for one comparison. Then, do the same for the 2nd and 2nd-to-last element, and so on. It turns out that doing this for 9 elements on each end for each half is enough to bring us over the 75% mark for all the test cases.
The median used is an estimate, since finding the actual median is too expensive, which also contributed to getting worse-than-average scores. It's estimated by taking 9 groups of 5 elements, finding the median of each, and then finding the median of those values.
The median of 5 is found using an worst-case-optimized algorithm that uses a maximum of 6 comparisons. The median of 9 is computed naively by sorting, which is surely inefficient. There are algorithms that use 14 comparisons in the worst cases, but I haven't found code for one.
A potential improvement would be to used the information gained in the median-finding step in the sorting step. We already know how the median compares to itself, the 8 other elements in the list of medians, and the 4 other elements in its group. This would save 13 comparisons, for a score of 231.
Further information could be gleaned using elements that were found smaller (resp, bigger) than a median that is itself smaller than the median-of-medians. We could also put each element used in the median finding into its estimated rank position in the final list.
Another potential improvement would be to use the full cmp comparisons rather than just < to better handle the case when elements are equal, for exactly by putting elements equal to the estimate median into the middle.

Python 3, score = 172 164
def shell(a, cmp):
    for step in [148, 138, 107, 43]:
        for i in range(len(a) - step):
            if cmp(a[i], a[i + step]) > 0:
                a[i], a[i + step] = a[i + step], a[i]

Try it online!
Four passes of Shellsort.
Python 3, score = 229 196
def insert(x, a, cmp):
    if not a:
        return [x]
    m = len(a)//2
    c = cmp(x, a[m])
    if c < 0:
        return insert(x, a[:m], cmp) + a[m:]
    elif c > 0:
        return a[:m + 1] + insert(x, a[m + 1:], cmp)
    else:
        return a[:m] + [x] + a[m:]

def ford_johnson(a, cmp):
    if len(a) <= 1:
        return a
    m = len(a)//2
    cmp1 = lambda x, y: cmp(x[-1], y[-1])
    b = ford_johnson([insert(x, [y], cmp) for x, y in zip(a[:m], a[m:2*m])], cmp1)
    if len(a) % 2:
        b += [[a[-1], None]]
    for k in range(m, len(a)):
        l, i, (x, y) = max((-i.bit_length(), i, t) for i, t in enumerate(b) if len(t) == 2)
        b[:i + 1] = insert([x], b[:i], cmp1) + [[y]]
    if len(a) % 2:
        b.pop()
    return [x for x, in b]

def thirty_four(a, cmp):
    for i in range(34):
        a[i::34] = ford_johnson(a[i::34], cmp)

Try it online!
Consider the list as 34 interleaved lists and sort each independently, using the Ford–Johnson merge-insertion sort.

I know it's allowed, but can it fail on some other cases?

@l4m2 Yeah, for example, [-(i%34) for i in range(150)] is not in the test cases and only gets 45.7% sorted.

Python 3, score 757
def f(l):
	a = 0  # we are going to sort the first (a) elements
	n = len(l)
	while (
			a*(a-1)//2  # there are ~ pairs that is guaranteed to be in order
			<=
			n*(n-1)//2  # total number of pairs
			*0.75):  # it's possible to compute this in O(1), but I'm lazy
		a+=1
	return sorted(l[:a])+l[a:]

Try it online!
The solution simply sorts about first ~75% of the array, so that it's guaranteed to be valid.
Python sorted takes about O(n log n) comparison.

Can you use a custom array-type that counts all comparisons?

@michi7x7 Currently I'm using a custom object type for that. What's the difference?

Ah, so that's how you computed your score. You didn't mention that

@MishaLavrov If you read the code instead of the explanation, you’ll see that it actually computes the smallest a such that a(a−1)/2 > n(n−1)/2 · .75, so it sorts about √75% ≈ 86.6% of the array.

@AndersKaseorg Thanks for spotting that! I indeed only read the explanation and not the code.

JavaScript (Node.js), 669
cnt=0;
function wtf(arr){return arr.length*~-arr.length}
function finished(arr) {
  x = 150*149*.25; // toleration
  for (i in arr) x-=wtf(arr[i]);
  return x>=0;
}
function cut(arr) {
  rnd=(Math.sin(arr.length)*1237812731+127317823102)%arr.length|0;
  tmp=[[],[arr[rnd]], []];
  for(i=0; i<arr.length; i++) if(i!=rnd) {
    cnt++;
    //tmp[arr[i]<arr[0]?0:1].push(arr[i]);
    if(arr[i]<arr[rnd]) tmp[0].push(arr[i]); else
    if(arr[i]>arr[rnd]) tmp[tmp.length-1].push(arr[i]); else
    tmp.splice(1,0,[arr[i]]);
  }
  //console.log(arr.length+','+t)
  return tmp;
}
function nesort(arr) {
  e=[arr];
  while(!finished(e)){
    x*=-5;
    t=0;
    for(i in e) if(e[i].length>e[t].length)t=i;
    for(i in e) if(e[i].length<e[t].length && wtf(e[i])>x)t=i;
    e.splice(t,1,...cut(e[t]));
  }
  return (e+'').match(/\d+/g).map(parseFloat);
}

Try it online!

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


text:
Nth subset of a set
The task
Given the set
$$S = \left[{1,2,3,4,5,6,7,8}\right]$$
and an integer
$$0 \leq N < 2^{|S|}$$
find the Nth subset.
Input/Output
N is given as an unsigned integer on stdin. You must print the Nth subset in a format suitable for your language (this may include [1,2,3],{1,2,3},[1, 2, 3],1 2 3,1,2,3 etc. for as long as it is a human readable text format).
A little bit about subsets
There is a relationship between subsets and numbers in base two. Each digit
$$d_{i}$$ specifies whether the ith element of the set is within the subset.
For example 00000000 would be the empty set and 10000001 is the subset containing [1,8] (the last and first element). You get the Nth subset by converting the number into base 2 and then the subset includes all elements where $$d_{i} > 0$$. The 3rd subset (3 = 00000011) thus contains [1,2]. The rightmost digit is digit #0. It's ok to print [2,1]. The set does not have to be sorted.
Addendums:
Yes, the set is fixed to 1..8. The set is not part of the input. Input is just N.
Yes, you may use alternate input forms.
All expected outputs for all N: https://tio.run/##SyotykktLixN/f/fyNS02qIoP8soJd1CwSAg2kY32LPWPaoqs7jg/38A

Is the set specifically 1 to 8, or is it any set?

Can we use a 1-indexed subset list instead?

It's specifically 1..8

@Giuseppe what do you mean?

Nth subset? In which order?

Could you include a few more test cases?

@mroman so 1 corresponds to the empty set rather than 1 and 2^8 corresponds to the full set rather than 2^8-1.

I'm surprised nobody asked before: Would you be so kind to allow functions as submissions which take the input as argument and not force languages to use stdin (which some are not able to)? The question is about subsets and not fiddling with inputs.

@Giuseppe That's acceptable yes.

@Dennis https://tio.run/##SyotykktLixN/f/fyNS02qIoP8soJd1CwSAg2kY32LPWPaoqs7jg/38A contains a list of all outputs.

@user202729 order is based on the base2 representation of N.

@BMO You may use alternate input forms, yes.

You don't need to tell everyone whether their solution is correct, you can restrict yourself to telling when it's not.

Since the set is limited to 1..8, an output such as "123" would be unambiguous. Is it valid?

Can we use 0-indexed [0,7] instead of [1,8]?

@Arnauld By the looks of it, yes ("as long as it is a human readable text format").

Ah. See... that's why I prefer "fixed stdin/fixed stdout" because there's just going to be hundreds of questions for "can I use this shortcut" and "can I do this instead" questions all the time if you don't have fixed input/output.

You're just given N as an input.

Jelly, 3 bytes
BUT

Try it online!
How it works
BUT  Main link. Argument: n

B    Binary; convert n to base 2.
 U   Upend; reverse the resulting array, so it starts with the LSB.
  T  Truth; find all 1-based indices of set bits.

But, but, BUT...?!

@Arnauld BUT everything is a lie! You think everything is Binary, eh? Well... that Upended is the Truth! So, nope, not everything is Binary. Welcome to the gray area!

R, 52 26 bytes
which(intToBits(scan())>0)

Try it online!
Converts the input to its bits and returns the 1-based indices of where they are TRUE. That makes this a port of Dennis' Jelly answer.
Returns integer(0), the empty list of integers, for input of 0.

Although this answer contains no IFs, ANDs, or BUTs.

Python 2, 40 bytes
lambda x:[i+1for i in range(8)if x>>i&1]

Try it online!

Perl 6, 33 bytes
(1..*Zxx*.base(2).flip.comb).flat

Try it online!

Python 2, 42 bytes
f=lambda n,k=1:n*[k]and n%2*[k]+f(n/2,k+1)

Try it online!

Japt, 7 bytes
ì2 Ôi ð

Try it
ì2          :Convert to base-2 digit array
   Ô        :Reverse
    i       :Prepend null element
      ð     :0-based indices of truthy elements

¤¬²Ôð¥1

Try it
¤           :Convert to base-2 string
 ¬          :Split
  ²         :Push 2
   Ô        :Reverse
    ð       :0-based indices of elements
     ¥1     :  Equal to 1

Haskell, 55 54 bytes
s n=[x|(x,d)<-zip[8,7..]$mapM(pure[0,1])[1..8]!!n,d>0]

Outputs the set in reversed order, try it online!
General version, 56 bytes
This will work for sets larger than \$\{i\}_{i=1}^8\$:
s n=[x|(x,d)<-zip[n,n-1..]$mapM(pure[0,1])[1..n]!!n,d>0]

Try it online!
Explanation
The term mapM (pure [0,1]) [1..n] generates the list (n=4) [[0,0,0,0],[0,0,0,1],[0,0,1,0],..,[1,1,1,1]] - ie. the binary representations of [0..2^n-1]. Indexing into it with n gives us the binary representation of n.
Now we can just zip it with the reversed numbers [1..n] and only keep the elements where the binary-digit is non-zero:
 [ x | (x,digit) <- zip [n,n-1,..1] binaryRepN, digit > 0 ]

K4, 7 bytes
Solution:
1+&|2\:

Example:
First 10...
q)k)(1+&|2\:)@'!10
`long$()
,1
,2
1 2
,3
1 3
2 3
1 2 3
,4
1 4

Explanation:
1+&|2\: / the solution
    2\: / convert to base-2
   |    / reverse
  &     / indices where true
1+      / add 1

MATLAB/Octave, 31 29 27 bytes
@(n)9-find(dec2bin(n,8)-48)

reduced of 2 bytes thanks to alephalpha
reduced of 2 bytes thanks to Giuseppe

Try it online!

@(n)9-find(dec2bin(n,8)-48)

@alephalpha Thanks!

Husk, 5 bytes
`fN↔ḋ

Takes input as command-line argument not on stdin (I hope this is ok), try it online!
Explanation
`fN↔ḋ  -- example input: 6
    ḋ  -- convert to binary: [1,1,0]
   ↔   -- reverse: [0,1,1]
`      -- flip the arguments of
 fN    -- | filter the natural numbers by another list
       -- : [2,3]

Charcoal, 11 bytes
↓⭆⮌↨Ｎ²×ιＩ⊕κ

Try it online! Link is to verbose version of code. If printing the answer horizontally without spaces is acceptable then the first character can be removed. Explanation:
    Ｎ       Input as a number
   ↨        Converted to base
     ²      Literal 2
  ⮌         Reversed
 ⭆          Map over bits and join
          κ Current index (0-indexed)
         ⊕  Incremented
        Ｉ   Cast to string
       ι    Current bit
      ×     Repeat string
↓           Print vertically

JavaScript (ES6), 37 bytes
+4 bytes if a separator is mandatory
+3 bytes if this separator is a comma and a leading comma is allowed
f=(n,i=1)=>n?(n&1?i:'')+f(n/2,i+1):''

Try it online!

J, 13 10 bytes
-3 bytes thanks to Bubbler

1+I.@|.@#:

Try it online!

10 bytes.

@Bubbler Thanks! I thought I tried this - apparently not :)

Perl 6, 21 bytes
{1 X+grep $_+>*%2,^8}

Try it online!
Alternative:
{grep $_*2+>*%2,1..8}

Common Lisp, 57 bytes
(lambda(x)(dotimes(i 7)(format(logbitp i x)"~a "(1+ i))))

Try it online!

Haskell, 33 bytes
s n=[x+1|x<-[0..7],odd$div n$2^x]

Try it online!

37 bytes
concat.(mapM(\i->[[],[i]])[8,7..1]!!)

Try it online!
Test cases from nimi.

C# (Visual C# Interactive Compiler), 47 bytes
x=>{for(int y=0;y<8;)if((1&x>>y++)>0)Print(y);}

Try it online!
Looks similar to the Java solution now, although I came up with mine independently.

Japt, 7 bytes
¢Ô¬ðÍmÄ

Test it online

Japt, 7 bytes
¤Ôð1 mÄ

Test it online

05AB1E, 6 bytes
bRSƶ0K

Try it online or verify all possible test cases.
Explanation:
b         # Convert the (implicit) integer input to binary
          #  i.e. 22 → "10110"
 R        # Reverse it
          #  i.e. "10110" → "01101"
  S       # Convert it to a list of 0s and 1s
          #  i.e. "01101" → ["0","1","1","0","1"]
   ƶ      # Multiply each with its 1-indexed index
          #  i.e. ["0","1","1","0","1"] → [0,2,3,0,5]
    0K    # Remove all 0s (and output implicitly)
          #  i.e. [0,2,3,0,5] → [2,3,5]

Java 8, 58 bytes
n->{for(int i=0;i<8;)if((1&n>>i++)>0)System.out.print(i);}

Try it online.
Explanation:
n->{                        // Method with integer as parameter and no return-type
  for(int i=0;i<8;)         //  Loop `i` in the range [0,8):
    if((1&n>>i++)>0)        //   If 1 AND `n` bitwise right-shifted to `i` is larger than 0
                            //   (with `i` increased by 1 afterwards with `i++`)
      System.out.print(i);} //    Print `i+1`

Python 3.6, 58 bytes
f=lambda n:[8-v for v,i in enumerate(f'{n:08b}')if int(i)]

Wolfram Language (Mathematica), 32 bytes
Pick[r=Range@8,BitGet[#,r-1],1]&

Try it online!

Pari/GP, 31 bytes
n->[x|x<-[1..8],bittest(n,x-1)]

Try it online!

APL+WIN, 13 bytes
Prompts for N:
((8⍴2)⊤⎕)/⌽⍳8

Try it online!  Courtesy of Dyalog Classic
Explanation:
((8⍴2)⊤⎕) prompt for N and convert to binary

/⌽⍳8 generate a vector from 1 to 8, reverse and select integers according to 1s in binary

Returns subset in reverse order

Burlesque - 8 bytes
8roR@j!!

Try it online.

Oracle SQL, 77 bytes
select*from(select rownum r,value(p)from t,table(powermultiset(x))p)where:n=r

Test in SQL Plus
SQL> var n number
SQL> exec :n:=67;

PL/SQL procedure successfully completed.

SQL> with t as (select ku$_vcnt(1,2,3,4,5,6,7,8) x from dual)
  2  select*from(select rownum r,value(p)from t,table(powermultiset(x))p)where:n=r
  3  /
        67
KU$_VCNT('1', '2', '7')

MathGolf, 8 bytes
â^mÉ┤\*─

Try it online!
Explanation
â         Convert first input to binary list
 ^        Zip with [1,2,3,4,5,6,7,8] (other input)
  mÉ      Map 2D array using the next 3 instuctions
    ┤     Pop from right of array
     \*   Swap top two elements and repeat array either 0 or 1 times
       ─  Flatten to 1D array

Alternate output format
With a more flexible output format (that I personally think looks quite good) I can come up with a 6-byter:
â^É┤\*

Instead of mapping, I use the implicit for-each, and I skip the flattening. Output looks like this:
[1][2][][4][5][6][7][]

Ruby, 31 bytes
->n{n.times{|a|n[a]>0&&p(-~a)}}

Try it online!

F# (Mono), 45 bytes
let m x=Seq.where(fun y->x>>>y-1&&&1>0)[1..8]

Try it online!
I also implemented a generic/recursive function, but its pretty ugly and the byte count is a lot larger...
F# (Mono), 107 bytes
let rec g y i=
 if y>0 then seq{
  if y%2>0 then yield i
  yield!g(y/2)(i+1)
 }else Seq.empty
let f x=g x 1

Try it online!


text:
Create a kind of quine, such that the program prints one character of itself, then two, then three and so on
Create quine variant such that the program prints its first character, then the first two, then three and so on until the whole program is printed.
Example
Suppose your code is @@@@@2 in some language. Then the output should be
@
@@
@@@
@@@@
@@@@@
@@@@@2

in that order, each line separated by a newline.
The winner is the shortest quine like this.

What's the winning criteria?

Whoops, sorry. If nobody submits a quine in 1 week from the last submission, the last submitter wins.

Isn't that essentially the same as "no winning criteria"? ... (or "your score is 1. The lowest score wins." etc.)

(we do have some previous challenges like this, the pop-con ones and some answer-chaining ones where the latter answer isn't dependent on the former, but not everyone think that's ok.) See also meta post.

Hello, welcome to the site! I think the core of this challenge is interesting, but the win condition makes it kind of pointless. There's nothing that any one could do to improve the chances of winning. With [tag:code-golf], you can always improve your program and your score.

yeah, i just wanted to do a test challenge tbh, the next one will indeed have a winner

@DJMcMayhem Instead of code-golf, i think this is one of the few times where code-bowling would be appropriate. It is far easier to create a one byte solution to this than a 1000 byte solution, at first glance.

so reverse code golf? ok, i did a cool thing at least

@Quintec This is just a generalized quine challenge. Nothing prefvents a program to be arbitrarily long.

yee. now that i mention it, the winning criterium may be the most interesting generalized quine

@quintec But this isn't code-bowling either. If it was code-bowling, you can do something to improve your own programs score. In this challenge, there isn't even a score, you just cross your fingers and hope that no one else answers.

eh, i realized how much of a fool i was. now it's a mini-competition

I'm voting to close this question as off-topic

newlines it is.

Does the program have to print a substring of itself, or can the characters be in any order? Does the program ABCDE have to print A AB ABC ABCD ABCDE, or can it print A BC CDE BCDE ABCDE? Or D BD ACE ACDE ABCDE?

A, AB, ABC, ABCD, ABCDE.

HQ9+ Q will be making an appearance fwen this question is reopened.

@Sparr I assume quines would still have to follow the community consensus on valid quines, of which the HQ9+ quine does not

There are now 4 answers beating mine, you should update the checkmark (currently this is the winning answer).

Jelly, 10 bytes
“;⁾vṾÄY”vṾ

Try it online!
How it works
“;⁾vṾÄY”vṾ  Main link. No arguments.

“;⁾vṾÄY”    Set the return value to the string ';⁾vṾÄY'.
         Ṿ  Uneval; yield a string representation of the string, i.e., '“;⁾vṾÄY”'.
        v   Dyadic eval; execute the string to the left, passing the string to the
            right as argument.
  ⁾vṾ         Literal; yield 'vṾ'.
 ;            Concatenate the argument ('“;⁾vṾÄY”') and 'vṾ', yielding '“;⁾vṾÄY”vṾ'.
     Ä        Accumulate; take the cumulative sum.
              Since string addition is concatenation in Python (and Jelly doesn't do
              type checks), this yields all prefixes of the string.
      Y       Join the prefixes, separated by linefeeds.

Husk, 18 bytes
G:""S+s"G:\"\"S+s"

Try it online!
Explanation
An extension of the standard quine S+s"S+s". To get all the prefixes we cannot use ḣ (heads), because ḣS+s"ḣS+s" would show "ḣS+s" which results in "\7715S+s":
ḣS+s"ḣS+s"

Try it online!
So we need to re-implement heads without using any unicode, this can be done by scanl snoc "" (snoc is just a flippped version of (:)), ie. G:"" which is ASCII.

Oracle SQL, 154 bytes
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;

Test in SQL Plus
SQL> set lines 160 pages 0
SQL> select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;
s
se
sel
sele
selec
select
select
select s
select su
select sub
select subs
select subst
select substr
select substr(
select substr(r
select substr(rp
select substr(rpa
select substr(rpad
select substr(rpad(
select substr(rpad(1
select substr(rpad(1,
select substr(rpad(1,2
select substr(rpad(1,24
select substr(rpad(1,240
select substr(rpad(1,240,
select substr(rpad(1,240,'
select substr(rpad(1,240,'|
select substr(rpad(1,240,'||
select substr(rpad(1,240,'||c
select substr(rpad(1,240,'||ch
select substr(rpad(1,240,'||chr
select substr(rpad(1,240,'||chr(
select substr(rpad(1,240,'||chr(3
select substr(rpad(1,240,'||chr(39
select substr(rpad(1,240,'||chr(39)
select substr(rpad(1,240,'||chr(39))
select substr(rpad(1,240,'||chr(39)),
select substr(rpad(1,240,'||chr(39)),5
select substr(rpad(1,240,'||chr(39)),53
select substr(rpad(1,240,'||chr(39)),53,
select substr(rpad(1,240,'||chr(39)),53,l
select substr(rpad(1,240,'||chr(39)),53,le
select substr(rpad(1,240,'||chr(39)),53,lev
select substr(rpad(1,240,'||chr(39)),53,leve
select substr(rpad(1,240,'||chr(39)),53,level
select substr(rpad(1,240,'||chr(39)),53,level)
select substr(rpad(1,240,'||chr(39)),53,level)f
select substr(rpad(1,240,'||chr(39)),53,level)fr
select substr(rpad(1,240,'||chr(39)),53,level)fro
select substr(rpad(1,240,'||chr(39)),53,level)from
select substr(rpad(1,240,'||chr(39)),53,level)from
select substr(rpad(1,240,'||chr(39)),53,level)from d
select substr(rpad(1,240,'||chr(39)),53,level)from du
select substr(rpad(1,240,'||chr(39)),53,level)from dua
select substr(rpad(1,240,'||chr(39)),53,level)from dual
select substr(rpad(1,240,'||chr(39)),53,level)from dual
select substr(rpad(1,240,'||chr(39)),53,level)from dual c
select substr(rpad(1,240,'||chr(39)),53,level)from dual co
select substr(rpad(1,240,'||chr(39)),53,level)from dual con
select substr(rpad(1,240,'||chr(39)),53,level)from dual conn
select substr(rpad(1,240,'||chr(39)),53,level)from dual conne
select substr(rpad(1,240,'||chr(39)),53,level)from dual connec
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect b
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by l
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by le
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by lev
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by leve
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<1
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<15
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;s
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;se
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;sel
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;sele
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;selec
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select s
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select su
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select sub
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select subs
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select subst
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(r
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rp
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpa
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,2
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,24
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'|
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||c
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||ch
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(3
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39))
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),5
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,l
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,le
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,lev
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,leve
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)f
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)fr
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)fro
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from d
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from du
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dua
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual c
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual co
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual con
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual conn
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual conne
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connec
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect b
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by l
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by le
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by lev
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by leve
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<1
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<15
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155
select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;select substr(rpad(1,240,'||chr(39)),53,level)from dual connect by level<155;

154 rows selected.

Haskell, 100 98 bytes
-2 bytes thanks to Dennis
main=mapM g[1..98];g n=putStrLn$take n$id<>show$"main=mapM g[1..98];g n=putStrLn$take n$id<>show$"

Try it online!
Surprisingly 2 4 bytes shorter than the obvious port of my Husk answer:
main=mapM putStrLn$scanl((.pure).(++))[]$id<>show$"main=mapM putStrLn$scanl((.pure).(++))[]$id<>show$"

Python 3.8 (pre-release), 54 bytes
exec(a:="s=''\nfor i in'exec(a:=%r)'%a:print(s:=s+i)")

Try it online!
I also have 2 variants of the same length :
exec(a:="s=''\nfor i in'exec(a:=%r)'%a:s+=i;print(s)")

exec(a:="s='';[print(s:=s+i)for i in'exec(a:=%r)'%a]")

How it works :
It is the standard "exec" quine in python: exec(a:="print('exec(a:=%r)'%a)") in which I added an iteration.
This base quine is pretty usefull because it doesn't require to write all the added byte twice unlike the shorter a='a=%r;print(a%%a)';print(a%a) quine

JavaScript, 47 bytes
This can probably be improved.
Revisions
20 bytes have been saved so far between 3 versions!
Revision 5
There's been a lot of bytes saved with this revision:

Don't assign a single-use variable for the quine to save 2 bytes
Use templated strings for the quine to save a byte
Use a single parameter (_) instead of no parameters (()) to save a byte

These three changes get it down to 47 bytes!!
(s=_=>{for(c of `(s=${s})()`)alert(name+=c)})()

Revision 4
On most pages, it seems that window.name is an empty string by default. We can take advantage of this to get 53 bytes!
(s=()=>{q="(s="+s+")()";for(c of q)alert(name+=c)})()

Unfortunately this is not the case for the snippet page, but try running it with the developer tools!
Revision 3
We can save 2 bytes, down to 55 bytes, by combining the two statements in the loop into one:

(s=()=>{q="(s="+s+")()",h="";for(c of q)alert(h+=c)})()

Revision 2
We can get down to 57 bytes by using an EcmaScript 2015 arrow function:

(s=()=>{q="(s="+s+")()",h="";for(c of q)h+=c,alert(h)})()

Revision 1
We can also get down to 61 bytes by using alert instead of console.log, if you consider that to be printing:

(function s(){q="("+s+")()",h="";for(c of q)h+=c,alert(h)})()

Initial Version
Initially, this script was at 67 bytes:

(function s(){q="("+s+")()",h="";for(c of q)h+=c,console.log(h)})()

Explanation
Here's the prettified code:

(function func() {
  quine = "(" + func + ")();";
  substr = "";
  for (char of quine) {
    substr += char;
    console.log(substr);
  }
})();

We start with a standard quine, then we define substr. We loop over each character of the quine, add it to substr, then output that.

uhhh... it doesn't really work. no chance of qualifying.

Try now. I accidentally sent it before I was done.

good one, it qualifies now

I accidentally clicked run code snippet on the alert version... add a warning to that plz :P

-1 by removing the space between of and `.

Excel, 182 bytes
=LEFT(SUBSTITUTE("=LEFT(SUBSTITUTE(@,CHAR(64),CHAR(34)&@&CHAR(34)),ROW(1:182))",CHAR(64),CHAR(34)&"=LEFT(SUBSTITUTE(@,CHAR(64),CHAR(34)&@&CHAR(34)),ROW(1:182))"&CHAR(34)),ROW(1:182))

Added LEFT( ~ , ROW(1:182)) to standard quine.
Cheesy version, 32 bytes
=LEFT(FORMULATEXT(A1),ROW(1:32))

Vyxal Dj, 40 bits, 5 bytes
`I¦`I¦

Try it Online!
Explained
`I¦`I¦
     ¦   # Prefixes of
`I¦`     # the string "I¦"
    I    # with `I¦` prepended
# joined on newlines by the j flag

6 bytes with j flag (or 5 with Vyncode)

@TheThonnu I haven't reincorperated the golfing suggestion yet - all I did was a roll back because I was a little short on time and unable to reformat everything.

Befunge-98 (PyFunge), 31 bytes
"2+,a<_@#-2$,k-'p11+1:g11+4+ff

Try it online!
Modification of a wrapping string literal quine that repeats printing prefixes until it prints everything.
Explanation:
"         Wrapping string literal that pushes the code backwards
 2+,      Add 2 to the space and print as "
   ,a<    Reverse direction and print a newline
"         Push the code again, but the right way this time
                          +4+ff   Push a quote
                       g11        Get the counter at (1,1)
                                  This is initially 32 (space)
                 p11+1:    Increment and store back at (1,1)
              -'          Subtract 31 from the counter
            ,k             Print counter many times plus one
          2$    Swap and check if the next number on the stack is 2
 2     _@#      If so, end the program as this is the leftover 2
   ,a           Print a newline and repeat

Jelly, 14 bytes
“Ṿ;¹¹ƤY”Ṿ;¹¹ƤY

Try it online!

05AB1E, 17 bytes
0"D34çýη»"D34çýη»

Try it online!

PowerShell Core, 44 bytes
&($f={&{1..44|%{"&(`$f={$f})"|% s*g 0 $_}}})

Try it online!
Idea borrowed from this answer by bb216b3acfd8f72cbc8f899d4d6963, thank you!

Japt -R, 11 bytes
BõîQi"BõîQi

Test it
BõîQi"BõîQi
B               :11
 õ              :Range [1,B]
  î             :For each mould the following
   Q            :  Quotation mark
    i           :  Prepend
     "BõîQi     :    String literal
                :Implicit output joined with newlines

Thunno 2 N, 12 bytes
"DṘs+ƒ"DṘs+ƒ

Explanation
"DṘs+ƒ"DṘs+ƒ  # Full program
"DṘs+ƒ"       # Push the string "DṘs+ƒ"
       D      # Duplicate it
        Ṙ     # Get its representation
              # (surround by quotes)
         s+   # Prepend this to the string
           ƒ  # Get the new string's prefixes
              # Implicit output, joined by newlines

Screenshot
 (click to enlarge)

Julia 0.6, 91 bytes
Q="1:91.|>x->println(\"Q=\$(repr(Q));\$Q\"[1:x])";1:91.|>x->println("Q=$(repr(Q));$Q"[1:x])

Try it online!
Adapted from the Julia quine from Rosetta Code, which is based on repr
Requires at least Julia 0.6, but includes syntax that is deprecated in 0.7 and removed in 1.0
There exist shorter quines in Julia (32 and 35-byte quines based on @show, 37-byte quine based on eval), and it might be possible to adapt either of these methods.

Java 10, 202 bytes
v->{var s="v->{var s=%c%s%1$c;s=s.format(s,34,s);for(int i=0;++i<s.length();)System.out.println(s.substring(0,i));}";s=s.format(s,34,s);for(int i=0;++i<s.length();)System.out.println(s.substring(0,i));}

Try it online.
Explanation:
quine part of the explanation:

var s contains the unformatted source code.
%s is used to input this String into itself with s.format(...).
%c, %1$c, and the 34 are used to format the double quotes
s.format(s,34,s) puts it all together

Challenge part of the explanation:

for(int i=0;++i<s.length();) then loops i in the range [1, formatted_code_length)
System.out.println(...) prints the String with trailing newlines
s.substring(0,i) gets the substring of the formatted code in the character-range [0,i).

Python 2, 72 bytes
s,f="",'s,f="",%r\nfor i in f%%f:s+=i;print s'
for i in f%f:s+=i;print s

Try it online!

Pyth, 17 bytes
j._jN*2]"j._jN*2]

Try it online!

Japt -R, 11 bytes
CÇîQi"CÇîQi

Try it online!
If the leading newline isn't acceptable, here's a 15 13-byte alternative:
Dõ_îQi"Dõ_îQi

Try it online!

Pushy, 28 26 24 bytes
`I"Ov:L69w69`96w96L:vO"I

Try it online!
Explanation:
`I"Ov:L69w79`                \ String literal: push this to stack
             96              \ Append backtick: I"Ov:L69w69`
               w             \ Mirror:          I"Ov:L69w69`96w96L:vO"I
                96           \ Append backtick: I"Ov:L69w69`96w96L:vO"I`
                             \ We now have the source code, backwards, on the main stack.

                  L:         \ len(stack) times do:
                    v        \     Move last character to auxiliary stack
                     O"I     \     Print the auxiliary stack

Julia, 63 bytes
(a=:([println(("(a=:($(a)))|>eval")[1:x]) for x = 1:63]))|>eval

Try it online!
The spaces and parenthesis are necessary because the code is stored in an Expr (AST), which will add them when interpolated.
based on this quine:
(a=:(print("(a=:($(a)))|>eval")))|>eval Try it online!


text:
Let's play Peg Solitaire
Peg solitaire is a popular game usually played alone. The game consists of some number of pegs and a board which is divided into a grid - usually the board is not rectangular but for this challenge we will assume so.
Each valid move allows one to remove a single peg and the goal is to play in a way, such that there is a single peg left. Now, a valid move has to be in a single direction (north, east, south or east) and jump over one peg which can be removed.
Examples
Let . be empty spaces on the board and numbers are pegs, the following move will move 1 one to the right and remove 2 from the board:
.....     .....
.12..  -> ...1.
.....     .....

A move will always have to jump over a single peg, so the following is not valid:
......    ......
.123.. -> ....1.
......    ......

Here are some valid configurations after one move each:
...1...        ...1...        ..71...        ..71...
.2.34.5  --->  .24...5  --->  .2....5  --->  ......5
.678...  (4W)  .678...  (7N)  .6.8...  (2S)  ...8...
.......        .......        .......        .2.....

Challenge
Given an initial board configuration and some other configuration, output whether the other configuration can be reached by successively moving pegs around as described above.
Rules

Input will be a \$n \times m\$ matrix/list of lists/... of values indicating an empty space (eg. zero or false) or pegs (eg. non-zero or true)

you may assume \$n \geq 3\$ and \$m \geq 3\$
you may use true/non-zero to indicate empty spaces and vice-versa if it helps

Output will be two distinct (one of the values might differ) values indicating whether the end-configuration can be reached (eg. falsy/truthy, []/[list of moves] ..)

Test cases
initial  goal -> output
[[1,0,0],[1,1,0],[0,1,0]]  [[0,0,0],[0,1,0],[1,1,0]] -> True
[[1,0,0],[1,1,0],[0,1,0]]  [[0,0,1],[0,1,1],[0,0,0]] -> False
[[0,0,0],[1,0,0],[0,0,0]]  [[0,0,0],[0,0,1],[0,0,0]] -> False
[[0,0,0],[1,1,0],[0,0,0]]  [[0,0,0],[0,1,1],[0,0,0]] -> False
[[0,0,0,0],[1,1,1,0],[0,0,0,0]]  [[0,0,0,0],[0,0,0,1],[0,0,0,0]] -> False
[[1,0,0],[1,1,0],[1,1,1],[1,1,1]]  [[0,0,1],[0,1,0],[1,0,0],[0,0,1]] -> True
[[1,0,0],[1,1,0],[1,1,1],[1,1,1]]  [[1,0,0],[0,0,0],[0,0,0],[0,0,0]] -> False
[[1,0,1,1],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,1,0],[1,0,0,0],[1,0,1,0],[1,0,0,1]] -> True
[[1,0,1,1],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]] -> False
[[1,0,0,0],[1,1,0,0],[1,1,1,0],[1,0,1,0]]  [[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]] -> True
[[0,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,0]]  [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] -> False
[[0,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,0]]  [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]] -> False
[[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]]  [[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]] -> True
[[0,0,0,1,0,0,0],[0,1,0,1,1,0,1],[0,1,1,1,0,0,0],[0,0,0,0,0,0,0]]  [[0,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0]] -> True
[[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,0,1,1,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,0,0]]  [[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,1,0,0,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,0,0]] -> True
[[0,0,1,1,1,0,0],[0,0,1,1,1,0,0],[1,1,1,1,1,1,1],[1,1,1,0,1,1,1],[1,1,1,1,1,1,1],[0,0,1,1,1,0,0],[0,0,1,1,1,0,0]]  [[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,1,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,0,0]] -> True

What happened to peg 7 in your example? Why does it vanish after 2 moves south?

@Ourous: That was just a typo, fixed it.

JavaScript (ES6),  184 178  173 bytes
Takes input as (initial_board)(target_board). Returns \$0\$ or \$1\$.
a=>g=b=>a+''==b|a.some((r,y)=>r.some((v,x,A,X,R)=>[-1,0,1,2].some(h=>(A=a[y+(R=~-h%2)]||0)[X=x+(h%=2)]&v>(R=a[y+R*2]||0)[h+=x+h]&&g(b,A[X]=r[x]=R[h]++)&(A[X]=r[x]=R[h]--))))

Try it online!
(removed the last two test cases that take too much time for TIO)
Commented
a =>                             // main function taking the initial board a[]
  g = b =>                       // g = recursive function taking the target board b[]
    a + '' == b |                // yield a truthy result if a[] is matching b[]
    a.some((r, y) =>             // for each row r[] at position y in a[]:
      r.some((v, x, A, X, R) =>  //   for each value v at position x in r[]:
        [-1, 0, 1, 2]            //     list of directions (West, North, East, South)
        .some(h =>               //     for each direction h:
          ( A =                  //       A = a[y + dy]
            a[y + (R = ~-h % 2)] //       R = dy
            || 0                 //       use a dummy row if we're out of the board
          )[X = x + (h %= 2)]    //       h = dx, X = x + dx
          &                      //       yield 1 if there's a peg on the skipped cell
          ( R =                  //       R = target row
            a[y + R * 2]         //         = a[y + 2 * dy]
            || 0                 //       use a dummy row if we're out of the board
          )[h += x + h]          //       h = x + 2 * dx = target column
          < v                    //       yield 1 if there's no peg on the target cell
          &&                     //       and there's a peg on the source cell (0 < 1)
          g(                     //       if the above result is true, do a recursive call:
            b,                   //         pass b[] unchanged
            A[X] = r[x] =        //         clear the source and skipped cells
            R[h]++               //         set the target cell
          ) & (                  //       and then restore the board to its initial state:
            A[X] = r[x] =        //         set the source and skipped cells
            R[h]--               //         clear the target cell
          )                      //
        )                        //     end of some() over directions
      )                          //   end of some() over columns
    )                            // end of some() over rows

Clean, 232 bytes
import StdEnv,Data.List
r=reverse
@[a:t=:[b,c:u]]=[[a:v]\\v<- @t]++take(a*b-c)[[0,0,1:u]];@l=[]

flip elem o\c=limit(iterate(nub o concatMap\l=[l]++[f(updateAt i p(f l))\\f<-[id,transpose],q<-f l&i<-[0..],p<- @q++(map r o@o r)q])[c])

Try it online!
This is one of the rare occasions in which I can utilize composition and currying while saving bytes.
Explained:
@ :: [Int] -> [[Int]] is a helper function used to generate the different potential new rows/columns that could result from a move being made. It avoids needing to special-case [1,1,0:_] by noticing that a*b-c>0 only when [a,b,c]=[1,1,0], and so take(a*b-c)... gives [] by taking -1 or 0 elements for all configurations that aren't a valid move.
flip elem o... reverses the order of arguments to elem (making it "does x contain a y" instead of "is x a member of y") and applies the anonymous function on c to the first argument.
\c=limit(iterate(nub o concatMap ...)[c]) generates every potential board that can result from the c by joining the current set of boards with all the moves that can happen on all of the boards and removing the duplicates, until the result stops changing.
\l=[l]++... prepends the board l to the list of all potential new boards one-move distance away, generated by applying @ to the rows of each orientation of the board (0, 90, 180, 270-degree rotations) and replacing the corresponding changed row with the new row.


text:
How frustrating is my movie?
My parents have an home theater device.  The remote is broken making it incredibly difficult to navigate rightwards in a menu.  Most the time it doesn't work but when it does it moves rightwards incredibly quickly.
This is obviously frustrating but it is most frustrating when you want to enter a movie title which requires navigating a keyboard that looks like this:
a b c d e f
g h i j k l
m n o p q r
s t u v w x
y z 1 2 3 4
5 6 7 8 9 0

Your task is to take as input a movie title and calculate how "frustrating" it is to type that movie title.  The frustration number of a particular string is the number of letters that require moving right from the letter before them.  We don't care how far right they are, since if we start moving right we pretty much instantly go to the end of the line, and we don't care about up, down or leftwards movement because they are easy.
For example if we wanted to type in
keyboard

We start at k for free.
e is just above k so we don't need to move right.
y is all the way left so no need to move right.
b however is on the next column rightwards so we need to move right to get to it.
o is on the next column over so we have to move rightwards to get to it.
a is back in the first column so we move left to get to it.
r is all the way on the right so we move right to it.
d is two columns to the left of r's column.

The characters that need to move to the right are bor meaning that this is frustration 3.
Additional rules
This is a code-golf challenge so your answers will be scored in bytes with fewer bytes being better.  The input will always consist of alphanumeric characters, you can support either capital or lowercase letters and you only need to support one.  The input will never be empty.
Testcases
keyboard -> 3
2001aspaceodyssey -> 6
sorrytobotheryou -> 8
thinblueline -> 5
blast2 -> 3

Suggested test case: "blast2" -> 3 (not a real movie, but some answers have problems with such test cases)

Suggested test case: one consisting of only digits, such as 5 -> 0

Suggested test case: 90 -> 1

Can we assume the input string will be non-empty?

@ChasBrown That is covered in the question.

I´d take the total number of key strokes (including "OK") as frustration level. But a nice idea nontheless.

JavaScript (Node.js), 61 55 54 bytes
Saved 1 byte thanks to @nwellnhof
Takes input as an array of characters.
s=>s.map(p=c=>r+=p>(p=(+c?~c:1-Buffer(c)[0])%6),r=0)|r

Try it online!
How?
For all characters but digits greater than \$0\$, the 0-indexed column \$x\$ is given by:
$$x=(c-1)\bmod 6$$
where \$c\$ is the ASCII code of the character.
For positive digits \$n\$, we need to do instead:
$$x=(n+1)\bmod 6$$
Examples:
"a" --> (97 - 1) mod 6 = 96 mod 6 = 0
"b" --> (98 - 1) mod 6 = 97 mod 6 = 1
"0" --> (48 - 1) mod 6 = 47 mod 6 = 5
"3" --> ( 3 + 1) mod 6 =  4 mod 6 = 4

Commented
s =>                       // s = input string (as array)
  s.map(p =                // initialize p to a non-numeric value
  c =>                     // for each character c in s:
    r +=                   //   update the result r:
      p > (                //   compare p with
        p = (              //   the new value of p defined as:
          +c ?             //     if c is a positive digit:
            ~c             //       -(int(c) + 1)
          :                //     else:
            1-Buffer(c)[0] //       -(ord(c) - 1)
        ) % 6              //     apply modulo 6
      ),                   //   yields 1 if the previous value is greater than the new one
    r = 0                  //   start with r = 0
  ) | r                    // end of map(); return r

It seems to work without the ternary for 46 bytes

@Shaggy It won't. See my suggested test case "blast2".

Ah. In that case: 53 bytes

@Shaggy A bitwise OR would fail for, say, "234".

Damn it, of course it would! I need more caffeine!

@Shaggy And of course, my logical OR fails as well. :p Seems like I need more caffeine too (or less whiskey in the present case).

Less whiskey is never the answer!

Jelly, 11 bytes
⁾04yO‘%6<ƝS

A monadic Link accepting a list of (uppercase) characters.
Try it online!
How?
First replaces any '0's with '4's (so the rest of the code treats them as being in the rightmost column). Then casts to ordinals, adds one and modulo's by 6 to get 0-based column indices. Then compares neighbours with is-less-than and sums the result.
⁾04yO‘%6<ƝS - Link: list of characters         e.g. "BLAST20"
⁾04         - list of characters = ['0', '4']
   y        - translate                             "BLAST24"
    O       - ordinals                              [66,76,65,83,84,50,52]
     ‘      - increment                             [67,77,66,84,85,51,53]
       6    - literal six
      %     - modulo                                [ 1, 5, 0, 0, 1, 3, 5]
         Ɲ  - neighbourly:
        <   -   less than?                          [  1, 0, 0, 1, 1, 1  ]
          S - sum                                   4

Oh my, this is art.

Perl 6, 45 39 bytes
{sum .[1..*]Z<$_}o{(2 X-.ords)X%46 X%6}

Try it online!
Works with uppercase letters. (2-ord(c))%46%6 computes the reversed x coordinate.

K (ngn/k), 32 31 28 bytes
+/>':6!(,/"a10"+!'26 9 1)?0+

Try it online!

Japt -x, 14 bytes
®rT4 c Ä u6Ãä<

Try it online!
Port of this Jelly answer. Takes input as an array of characters, with letters uppercase.
Explanation:
®rT4 c Ä u6Ãä<    :
®          Ã      :Map each character through:
 rT4              : Replace 0 with 4
     c            : Get the char-code
       Ä          : Increment it
         u6       : Modulo 6
            ä<    :Replace with 1 if you had to move right, 0 otherwise
                  :Implicitly sum and output

Clean, 85 bytes
import StdEnv
(\s=sum[1\\a<-s&b<-tl s|b>a])o map(\e=(toInt e+if(e-'1'>'/')1 -1)rem 6)

Try it online!

Ruby, 56 bytes
->s{w=9;s.count{|c|w<w=[*?a..?z,*?1..?9,?0].index(c)%6}}

Try it online!
Preliminary naive version, will be golfed.

05AB1E, 12 11 bytes
-1 byte thanks to @Kevin Cruijssen
¾4:Ç>6%¥1@O

Another port of Jonathan Allan's Jelly answer. Takes input in uppercase.
Explanation:
¾4:Ç>6%¥1@O   //full program
¾4:           //replace all '0's with '4's
   Ç          //get ASCII code points
    >         //increment
     6%       //modulo 6
       ¥      //get deltas
        1@    //is >= 1
          O   //sum

Try it online!

0'4 can be ¾4 to save a byte (relevant 05AB1E tip).

Java (OpenJDK 8), 73 bytes
Not a bad solution for Java! That zero being on the right-hand side cost me several bytes.
t->{int a=9,c=0;for(int d:t)c+=a<(a=(--d+(d/48==1?2:0))%6)?1:0;return c;}

Try it online!
Explained
t -> {                          // Lambda taking a char array as input
    int a=9,                    // Initialise last column value
        c=0;                    // Initialise frustration count
    for(int d:t)                // Loop through all chars in title
        c+=                     // increment the frustration count if...
          a<                    // The last column is smaller than the current column
            (a=                 // Set last column to current column
              (--d+             // Decrement ascii value of char
                  (d/48==1      // If ascii decremented ascii value is between 48 and 95
                    ?2:0)       // increment by 2 (1 total) or 0 (-1 total)
                )%6)            // Mod 6 to retrieve column index
            ?1:0;               // Increment if to right hand side
    return c;                   // return calculated frustration count
}

Retina 0.8.2, 46 bytes
T`l1-90`1-61-61-61-61-61-6
.
;$&$*
&`;(1+);1\1

Try it online! Link includes test cases. Explanation:
T`l1-90`1-61-61-61-61-61-6

List the alphabet and digits in the order on the OSK and map each one to a (1-indexed) column number.
.
;$&$*

Convert each column number to unary.
&`;(1+);1\1

Count the number of columns that are followed by a larger (i.e. rightwards) column. The &` allows the matches to overlap.

Python 2, 84 bytes
def f(s,k=6):j=(ord(s[0])+('0'<s[0]<':')*2-1)%6;return(j>k)+(~-len(s)and f(s[1:],j))

Try it online!

Mathematica, 102 bytes
Differences[Last@@Join[Alphabet[],ToString/@Range@9,{"0"}]~Partition~6~Position~#&/@#]~Count~_?(#>0&)&

Pure function. Takes a list of characters as input and returns a number as output. This is a pretty naive solution, golfing suggestions welcome.

PHP, 74 81 77 bytes
for(;$o=ord($argn[$i]);$i++&&$f+=$p<$x,$p=$x)$x=(--$o/48^1?$o:$o+2)%6;echo$f;

Run as pipe with -nR or try it online.

C (gcc),  82 79  77 bytes
o;c(i){i+=i<60&i>48?1:5;i%=6;}f(char*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

Try it online!
This function will only support lowercase inputs

Ungolfed and commented:
o; //Used for output
c(i){             //Calculates the column of given character
     i+=          //Correct i to get the correct column
        i<60      //If i is a digit...
        & i>48   //... but not '0'
        ?1           //Then move it one column on the right
        :5;          //Else move it five columns on the right
     i%=6;        //Get the column number
}
f(char*s){                        // The actual "frustrating" function
          for(                    //Loop for each character
              o=0;                //reinitialize output
              *++s;               //move to next character / while this is not '\0'
              o+=c(*s)>c(s[-1])  //Increment if current character is on the right of the previous one
             );
           o=o;                   // Outputs result
}

If my function is allowed to accept wide character strings, it can be reduced to 76 bytes with:
o;c(i){i+=i<60&i>48?1:5;i%=6;}f(int*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

Try it online!
This version just accept input as int* instead of char*

Edits:

Golfed 3 bytes in the calculation of the column (function c)
Golfed 2 bytes thanks to ceilingcat

And there, 77 bytes


text:
Special quines and code golf, hooray!
Make a quine. Simple enough, except it has to be a palindrome and accept input.
Now, any side of a palindromic quine is one half of it. For example, one side of the hypothetical quine AAAA is AA. One side of AAAAA is AA (the center symbol is ignored).
Your job is to make a quine like this that accepts input. If the input is the whole quine, then the quine prints the left side of itself. If the input is either side of the quine then the quine prints itself. Of course, with quines with an odd number of symbols the center symbol is ignored. If the input is anything other than the cases specified, the program must do nothing.
This is code golf, so the shortest submission wins.

It can be the right side, the left side or the quine itself. If anything else is inputted the program must do nothing.

@l4m2 From the spec it would need to print ; if the input is empty, so if ; is a nop it wouldn't be valid as far as I see.

yee. the program must print nothing.

Javascript, 224 200 bytes
Prompts for input. I shaved off some bytes by using ES6 features. Still can probably be golfed a lot more.

(f=_=>{a=prompt();s=`(f=${f})()/`;r=[...s].reverse().join('');return a==s||a==r?s+r:a==s+r?s:""})()//)()}"":s?r+s==a:r+s?r==a||s==a nruter;)''(nioj.)(esrever.]s...[=r;`/)()}f{$=f(`=s;)(tpmorp=a{>=_=f(

Haskell, 350 346 342 bytes
main=interact f;f s|s==l++r=l|s/=l,s/=r=[]|1<3=l++r;r=reverse l;l=q++shows q['-'];q="main=interact f;f s|s==l++r=l|s/=l,s/=r=[]|1<3=l++r;r=reverse l;l=q++shows q['-'];q="--"=q;]'-'[q swohs++q=l;l esrever=r;r++l=3<1|][=r=/s,l=/s|l=r++l==s|s f;f tcaretni=niam"=q;]'-'[q swohs++q=l;l esrever=r;r++l=3<1|][=r=/s,l=/s|l=r++l==s|s f;f tcaretni=niam

Prints its left half with itself as input: https://tio.run/##7ZAxCoUwEESvEmwsoohYxjlJSBEkYvhrJNnwbXJ3f8gd7H4zsMPsY5jD8scRPc9pfYAP2SW7ZbGrXXBhgKRMoMITaKiSoE2Z16X5KiG5r0vsBClClJKP62YRdT/2RkV0r0DHsUNUpp46Cr6vg6WMqGHhuL2iQqQkLOtcjK74iQeqUgjNRy3RyuTNJpeDR/D2fAX63/WdXX8
Prints itself with its left half as input: Try it online!
Prints itself with its right half as input: Try it online!
Prints nothing with anything else as input: Try it online!

Edit: -8 bytes thanks to Ørjan Johansen! Also changed to a version which does not need (<>).

Save 4 bytes by rearranging guards to turn || into ,. (I also tried several ways to turn (++['-']) into something simpler like ('-':), including switching l and r, but it hasn't worked.)

@ØrjanJohansen Thanks!

the legend orjan johansen has appeared to help this man in his quest.

With your new version, you can save 4 more with shows.


text:
ASCII art H trees
An H tree is a fractal tree structure that starts with a line. In each iteration, T branches are added to all endpoints. In this challenge, you have to create an ASCII representation of every second H tree level.
The first level simply contains three hyphen-minus characters:
---

The next levels are constructed recursively:

Create a 2x2 matrix of copies from the previous level, separated by three spaces or lines.
Connect the centers of the copies with ASCII art lines in the form of an H. Use - for horizontal lines, | for vertical lines, and + whenever lines meet each other.

Second level
-+-   -+-
 |     |
 +-----+
 |     |
-+-   -+-

Third level
-+-   -+-   -+-   -+-
 |     |     |     |
 +--+--+     +--+--+
 |  |  |     |  |  |
-+- | -+-   -+- | -+-
    |           |
    +-----------+
    |           |
-+- | -+-   -+- | -+-
 |  |  |     |  |  |
 +--+--+     +--+--+
 |     |     |     |
-+-   -+-   -+-   -+-

Rules

Input is an integer representing the level of the ASCII art H tree as described above (not the actual H tree level), either zero- or one-indexed.
Output is flexible. For example, you can print the result or return a newline-separated string, a list of strings for each line, or a 2D array of characters.
You must use -, |, + and space characters.
Trailing space and up to three trailing white-space lines are allowed.

This is code golf. The shortest answer in bytes wins.

Related: Create an “H” from smaller “H”s

Canvas, 20 19 bytes
ø⁸«╵［↷Ｌ⇵；ｌ⇵└┌├-×╋‼│

Try it here!
Explanation:
ø                    push an empty canvas
 ⁸«╵[              repeat input*2 + 1 times
     ↷               rotate clockwise
      L⇵             ceil(width/2)
        ;l⇵          ceil(height/2); leaves stack as [ ⌈½w⌉, canvas, ⌈½h⌉ ]
           └┌        reorder stack to [ canvas, ⌈½w⌉, ⌈½h⌉, ⌈½w⌉ ]
             ├       add 2 to the top ⌈w÷2⌉
              -×     "-" * (2 + ⌈w÷2⌉)
                ╋    in the canvas, at (⌈w÷2⌉; ⌈h÷2⌉) insert the dashes
                 ‼   normalize the canvas (the 0th iteration inserts at (0; 0) breaking things)
                  │  and palindromize horizontally

Charcoal, 22 bytes
Ｐ-²ＦＮＦ²«⟲Ｔ²+×⁺²κＸ²ι←‖Ｏ

Try it online! Link is to verbose version of code. 0-indexed. Explanation:
Ｐ-²

Print the initial three -s, leaving the cursor in the middle.
ＦＮ

Repeat for the number of times given.
Ｆ²«

Repeat twice for each H. Each loop creates a slightly bigger H from the previous loop, but we only want alternate Hs.
⟲Ｔ²

Rotate the figure.
+×⁺²κＸ²ι←

Draw half of the next line.
‖Ｏ

Reflect to complete the step.
The result at each iteration is as follows:
---

|   |
+---+
|   |

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

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

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

If you wonder how a 5-th level H looks like, a quick zoomed-out glance: https://i.imgur.com/EGapcrS.png

Perl 6, 118 bytes
{map ->\y{map {' |-+'.comb[:2[map {$^b%%1*$b&&6>=$^a/($b+&-$b)%8>=2},$^x/¾,y/2,y,$x/3-$_]]},2..^$_*6},2..^$_*4}o*R**2

Try it online!
0-indexed. Returns a 2D array of characters. The basic idea is that the expression
b = y & -y   // Isolate lowest one bit
b <= x % (4*b) <= 3*b

generates the pattern
--- --- --- ---
 -----   -----
--- --- --- ---
   ---------
--- --- --- ---
 -----   -----
--- --- --- ---

Explanation
{ ... }o*R**2  # Feed $_=2**$n into block
map ->\y{ ... },2..^$_*4  # Map y=2..2**n*4-1
map { ... },2..^$_*6      # Map $x=2..2**n*6-1
' |-+'.comb[:2[ ... ]]    # Choose char depending on base-2 number from two Bools
map { ... }  # Map coordinates to Bool
  # Horizontal lines
  ,$^x/¾  # Modulo 8*¾=6
  ,y/2    # Skip every second row
  # Vertical lines
  ,y      # Modulo 8
  ,$x/3   # Skip every third column
   -$_    # Empty middle column
# Map using expression
$^b%%1*$b&&  # Return 0 if $b is zero or has fractional part
6>=$^a/($b+&-$b)%8>=2  # Pattern with modulo 8

Python 2, 227 bytes
L=len
def f(n):
 if n==1:return[['-']*3]
 m=[l+[' ']*3+l for l in f(n-1)];w=L(m[0]);y=L(m)/2;x=w/4-1;m=map(list,m+[' '*w,' '*x+'-'*(w-x-x)+' '*x,' '*w]+m)
 for i in range(y,L(m)-y):m[i][x]=m[i][w+~x]='|+'[m[i][x]>' ']
 return m

Try it online!


text:
Fibonacci with n numbers instead of 2
How to
Given an integer n start with n ones (i.e. 4 -> 1 1 1 1). Then sum up the
last n numbers, and repeat.
For n = 4 this looks like this:
Start with 1 1 1 1, sum up the last 4 numbers resulting in 1 1 1 1 4, then
sum up the last 4 numbers resulting in 1 1 1 1 4 7, then sum up the last 4 numbers resulting in 1 1 1 1 4 7 13 and so on.
The task
Write a program or function that produces the first 30 numbers of this sequence given n as input (either as argument, stdin, command line argument, on the stack, ...)
The 30 terms for n = 4 are:
1 1 1 1 4 7 13 25 49 94 181 349 673 1297 2500 4819 9289 17905 34513 66526 128233 247177 476449 918385 1770244 3412255 6577333 12678217 24438049 47105854
The 30 terms for n = 5 are:
1 1 1 1 1 5 9 17 33 65 129 253 497 977 1921 3777 7425 14597 28697 56417 110913 218049 428673 842749 1656801 3257185 6403457 12588865 24749057 48655365
In case n is smaller than two or larger than 30 the behaviour can be undefined.

Can the function return more than 30 elements, or must it return exactly 30 elements?

No, exactly 30. But it's a duplicate. Sorry about that.

JavaScript (ES6), 64 bytes
f=(n,i,a=[])=>i>29?a:f(n,-~i,[...a,(g=_=>n--&&a[--i]+g())()||1])

Try it online!

05AB1E, 12 bytes
Å1 30FDO¸«ć,

Try it online!
Explanation
Å1            # push a list of n 1s
  30F         # 30 times do:
     D        # duplicate
      O       # sum
       ¸«     # append
         ć,   # extract and print the head

Tidy, 35 bytes
{x:30^recur(*tile(x,c(1)),sum@c,x)}

Try it online!
Explanation
{x:30^recur(*tile(x,c(1)),sum@c,x)}
{x:                               }   lambda taking parameter `x`
   30^                                take the first 30 terms of...
      recur(                     )        a recursive function
            *tile(x,c(1))                 whose seed is `x` `1`s
                                x         with a window of `x`
                          sum@c           and the functor takes the sum of its arguments

Python 2, 60 bytes
lambda n:reduce(lambda a,c:a+[sum(a[-n:])],'.'*(30-n),[1]*n)

Try it online!

Clean, 81 bytes
import StdEnv
$n=reverse(while((>)30o length)(\l=[sum(take n l):l])(repeatn n 1))

Try it online!
(repeatn n 1) gives us n ones in a list, which we repeatedly prepend the sum of the first n elements to (with (\l=[sum(take n l):l])), while it has less than 30 elements.
As the list is backwards, we reverse it and return.