text:
A Zealous "Quick Brown Fox" "Jumped" Along the Groovy Spiral
Introduction
Write a program to output the outgoing spiral of the famous pangram following given rules.
Challenge
A pangram is a sentence using every letter of a given alphabet at least once. One of the most famous pangrams is the one used extensively in Windows font viewer, namely "The quick brown fox jumps over the lazy dog". The challenge is to output a spiral based on this text.
Your task is output this exact text:
heeeeellllllllllllazzzzzzzzzzz
hummmmmmmmmmmmmppppppppppppppy
hubrrrrrrrrrrrrrrrrrrooooooosy
hukyddddoooooooooooooooggggwsy
hukyveeeeerrrrrrrrrrrrrrrrtwsy
hukyvxjjjjjjjjjjuuuuuuuuuttwsy
hukyvxkbbrrrrrrrrrrrrrrrmttwsy
hukyvxkogggggggttttttttomttwsy
tukyvokoellllllllllllahomttwsy
tukyvokoeovvvvvvvvvvvzhomttwsy
tukyvocoeoummmmmmmmmezhomttwsy
tukyvocoeoufooooooopezhomttwsy
tukyvocohoufroooooxpezhomttwsy
tukyvoiohoufrquuuwxpezhomttwsy
tucyvoiohoufbqttiwxpezhomttwsy
tucyvoiohoufbeehiwxprzhomttwsy
tucyvoiohoufkccciwxprzeomttwsy
tjiyvoidhounnnnnnwxprzeomttwsy
tjiyvoidhojjjjjjjjxprzeomttwsy
tjiyvoidhssssssssssprzeopttwsy
tjiyvoidttttttttttttrzeopttwsy
tjiyvoiyyyyyyyyyyyyyyzqopttwoy
tjiyvouuuuuuuuuuuuuuuuqwpttwoy
tjiyvffffnnnnnnnnnnnnnnwpttwoy
tjiyossssssssssssssssssspthwoy
tjizzzzalllllllllllleeeeehhwoy
tjuuqqqqqqqqqqqqqqqqqeeeeehnod
txxxxxoooooooooooooooffffffnod
reeeeevvvvvvvvvvvvvvvvvvvvvvod
       gggggggoooooooooooooood

Here is how it is generated,

There was a zealous fox who enjoyed the pangram "The quick brown fox jumps over the lazy dog". One day he was in the center of an outward spiral and decided to jump in it and paint along.
He would like to go through the pangram from the beginning to the end, and if a letter is the n-th letter in the alphabet he would like to paint it n times.
However, the fox was not very good at making turns on corners, so upon reaching each corner he also had to stop and switch to the next letter.
He also decided to repeat the pangram thrice to emphasize that he is the quick brown fox.
Your job is to show how the spiral would look like after the fox painted all those letters.

(Plain version without story-telling)

The famous pangram "The quick brown fox jumps over the lazy dog" is repeated thrice, with the spaces removed and all letters in lower case, to generate
thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog

The spiral starts from the center and begins with the letter "t", it starts by going to the right, and goes outward clockwise. If the current character is the n-th letter in the alphabet, then it switches to the next character whenever

the spiral reaches a corner, or
the current letters is printed exactly n times.

To better illustrate it, I will explain how the spiral related to the first three words "thequickbrown" is generated.
 rooooo
 rquuuw
 bqttiw
 beehiw
 kccciw
nnnnnnw

The fox starts from "t", goes right, reaches the 1st corner, paints it with the "t" and then switches to "h" and goes down, reaches the 2nd corner, switches to "e" and goes left, reaches the 3rd corner, switches to "q" and goes up, reaches the 4th corner, switches to "u" and goes right, reaches a corner and switches to "i", goes down, reaches a corner and switches to "c", goes left, successfully paints 3 "c"s before reaching the next corner, switches to "k" and goes on to the left, reaches a corner right away, switches to "b" and goes up, paints 2 "b"s before reaching the next corner, switches to "r" and goes on upwards, reaches a corner and switches to "o", goes right, then "w", down, "n", left.
Specs

You can take an optional input that contains any standard form of the string
thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog

Your output must be formatted as a string, and must go to STDOUT instead of files or STDERR, with newlines placed correctly. Heading and trailing empty lines do not matter. Heading and trailing spaces in each line are allowed, but need to be be consistent. So if you add 5 spaces before one line of the given text, you'll need to add exactly 5 spaces before each line so that the spiral looks the same.
This is code-golf, the lowest number of bytes wins.
As usual, default loopholes apply here.

Explanations are welcome, although not necessary.

Title edited to make it a pangram per comment by caird coinheringaahing.

The lazy dog is too lazy to appear in the story.

I am aiming at creating a string challenge in which the letter to output cannot be computed by simple functions of the coordinates.

It's a shame that the title isn't a pangram

@cairdcoinheringaahing Good point, I'll try to come up with one. Any suggestions?

@cairdcoinheringaahing Updated

Minor point: shouldn't the 'h' in the first 'the' be repeated twice, not the 't'?

@mudkip201 The corner is painted with the original letter before switching to the next character. Maybe I should clarify.

@WeijunZhou Whoops. I misread the question. I thought it was saying the fox painted the nth letter of the string n times.

For anyone else trying to cheat by directly printing the output, packing each character into 5 bits yields a whopping 581 bytes (including padding). Trying to run-length encode it (then pack it) makes it even worse (639 bytes). Cheating the puzzle is almost as interesting as doing it right. "Turning" the puzzle might yield a modest improvement, but I doubt it would be much.

Thank you for your interest. I had some thoughts before posting this challenge and I decide to make it medium-sized.

Stax, 35 34 33 32 bytes
é╛îá%ⁿ┌○iê}→Ug=╩◙╘Ç⌐)QX↑L╓₧╗▌╧▬q

Run and debug it online
Stax is a language I've been working on for about 6 months.  This is the first public golfing with it.  Let's get down to business.
Stax is normally written in the printable ASCII character set.  This 34 byte submission is packed into a variant of the CP437 character set.  The corresponding ascii representation is
't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr

Stax is a stack based language, but it has two data stacks, "main" and "input".  Most operations use the main stack, but input starts on the input stack.  Stax instructions are mostly one or two character ascii sequences.  Most of them are overloaded, meaning their behavior is determined by the top few values on the stack(s).
At a high level, this program builds a grid by repeatedly appending strings to the last row.  When the last row fills up, it rotates the grid clockwise.  At the end, it mirrors the grid horizontally.  In more detail, the program works like this.
't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr
't]                                         ["t"]
   ,                                        Pop from input, push to main ("thequick...")
    {                            F          For each character in input, execute block...
     ]_96-*                                 Produce string using character appropriate
                                                number of times (a=1, b=2, etc)
           ~                                Pop from main, push to input for use later
            cH                              Copy last row from grid.
              T                             Right-trim whitespace
               ,+                           Pop from input stack and append
                 nh%                        Get the width of the first row of the grid
                    ^                       Add 1
                     (                      Right-pad/truncate string to this length
                      X                     Store in the x register
                       Us&                  Overwrite last row of the grid with new value.
                          xH                Get the last element from x.
                                                Basically, the lower right corner.
                             {  }M         Conditionally execute block.  This will happen
                                                when the bottom right corner isn't a space.
                              rM            Reverse and transpose (aka rotate clockwise)
                                  |<        Left-justify grid; give all rows equal size.
                                     m      For each row, execute the rest of the program
                                               and then print the result to output
                                      r     Reverse the row

Wow, I am really amazed that the challenge would see the first public appearance in golfing for a golfing language. Thank you very much for your support! Interested in Language of the Month? I hope to see more users using it and that it appears on the candidate list soon!

@WeijunZhou: You mean this?  I didn't know it was a thing until now.  I wouldn't mind a nomination.  It seems like it might be better suited to more established languages, but I don't object.

Yes. I may nominate it when it is better established, as you say. I hope it won't be long.

Since "heading space in each line does not matter as long as they are consistent" you may save another byte if you wish.

@WeijunZhou: Thanks for pointing that out.  Saved a byte.

I have just made a submission using Stax. You may give advice on that if you wish. Edit: What a coincidence. I will try to learn from your submission.

Charcoal, 66 40 36 bytes
≔²ηＦＳ«Ｆ¬η«¶↷⊞υη≔⊕÷Ｌυ²η¶»Ｆ⊕⌕βι¿η«≦⊖ηι

Try it online! Link is to verbose version of code. Edit: Saved 16 bytes by taking the text as input. Explanation:
≔²η

Start with 2 ts for some reason.
ＦＳ«

Loop over all the letters in the pangram.
Ｆ¬η«

Have we reached a corner yet?
¶

Move down (or whatever the next direction will be) one line.
↷

Rotate the print direction 90° clockwise.
⊞υη≔⊕÷Ｌυ²η

Calculate the length of the next side.
¶»

Finish fixing up the cursor position. (Charcoal would have preferred the side to end just before the corner, so that you rotated on the corner itself.)
Ｆ⊕⌕βι

Loop as many times as the current letter's position in the alphabet.
¿η«

If we haven't reached the corner,
≦⊖ηι

Decrement the count and print the current letter.

Thank you. Great job and well explained. A small typo: there times -> three times.

This 43 byte version is also acceptable according to specification. https://tio.run/##rY7NTsMwEITPzlNYPW2kcumVExJCikRRhLgBh9Rx4oV4nfon/KnPbuy4SH0ALtbOznj2E6qzwnRTjDfO4Uiw23JVX1dFNTQHDyLpwVieBv5TsXNwj4Q6aHhuSFipJXnZwx1SD4ctx7pOPa/pOabPrLVIHp5QSweYd3m57@ZS9Yij8rkvuOSV@wwHDg/Gg6rXo6zFxfiSzDZrg1MQzuE/pkuUhvwtLthLuJc0@hRONLuVqxSsTJsX2lxIzPOpOsXolTwGFO8Haz5oMJ9vQc/OLNImY@q@v3oz/k8kXi3TLw

@WeijunZhou Thanks, I didn't notice that clause in the question before.

Ruby, 217 212 209 208 bytes
->s{s+=' '*8
x=0
a=[""]*30
i=14
a[i]=?t
l=->{a[i]=s[x]+a[i]}
r=->{a[i]+=s[x]}
(0..58).map{|g|c=0
(0..g/2).map{c>s[x].ord-97&&(x+=1;c=0)
c+=1
eval %w{r i+=1;r l i-=1;l}[g%4]+"[]"}
x+=1}
a[-1].slice!0
$><<a*$/}

Try it online!
Spends a fair amount of time managing pointers, so there may be room for more golfing.
-5 bytes: Triple the pangram before inputting. Thanks to Weijun Zhou.
-3 bytes: Pad the input string and trim the last leg, instead of generating the last leg from scratch.
-1 bytes: Use && instead of a ternary operator with a throwaway value.
Explanation:
->s{
  s += " " * 8                             # These spaces will show on the bottom row
  x = 0                                    # x is a pointer into s
  a = [""] * 30                            # a is an array of row strings
  i = 14                                   # i is a pointer into a
  a[i] = ?t                                # "Starts with two t's for some reason"
  l = ->{ a[i] = s[x]+a[i] }               # lambda to prepend char x to row i
  r = ->{ a[i] += s[x] }                   # lambda to append char x to row i
  (0..57).map{|g|                          # There are 58 "legs" to the spiral
    c = 0                                  # c is the print count of s[x]
    (0..g/2).map{                          # Leg g has g/2+1 characters
      c > s[x].ord-97 && (x+=1;c=0)        # Possibly switch to next letter
      c += 1
      eval %w{r i+=1;r l i-=1;l}[g%4]+"[]" # Call the appropriate lambda
    }
    x += 1                                 # Definitely switch to next letter
  }
  a[-1].slice!0                            # Remove the first char from the bottom row
  $> << a*$/                               # Join with newlines and print
}

Nice submission and clearly explained. I appreciate the use of r and l lambdas. Based on current answers the last leg seems to be a trouble maker although it wasn't when I wrote my C snippet to generate the sample output ...

It seems you can save the s*=3 altogether and also omit the 0 in the ?: operator. https://tio.run/##rY5dbsIwEITf9xSWBQJiOSQtKGqLk4NYfjD5cd2GmjoEQoPPntpU3KAvq9lvZkdr@/11athE826EgSUgGcdYRM8JaJZuQHItWHGCltF8vC8dHwQJyoF9QHKnDpZJHG@zVXyQx/GmbqXvC0itn/5YmYdcbGxFX7JiORCWvvnQ6hVKL6E@yxbNL6NFOjgWtUhTL1rH1XwjCOYCOwhXzj9GU8EWaBFlpFBhmCjdkqKCWb7byWi2dlPD8em9/u51@bm35vLVmOGjPxw7c66tN1r5c62M@p8IFtMv

@WeijunZhou Ahh, thanks for the tip. I do need that 0 though, or Ruby will pull up the c+=1 from the next line and only execute it most of the time. And nice challenge!

You are right. I didn't look careful enough. Thank you for your appreciation. I am glad that you enjoyed it.

Deadfish~, 3360 bytes
{i}cc{{i}d}iiiicdddccccc{i}ddd{c}cc{d}dc{ii}iiiii{c}c{{d}}{d}ddc{{i}d}iiiic{i}iiic{d}ii{c}ccciii{c}cccc{i}dc{{d}}{d}dc{{i}d}iiiic{i}iiic{dd}ic{i}iiiiii{c}ccccccccdddccccccciiiiciiiiiic{{d}}{d}dc{{i}d}iiiic{i}iiic{d}c{i}iiiic{dd}dcccc{i}i{c}ccccc{d}iicccc{i}iiiiiicddddciiiiiic{{d}}{d}dc{{i}d}iiiic{i}iiic{d}c{i}iiiicdddc{dd}iiiccccc{i}iii{c}cccccciiciiicddddciiiiiic{{d}}{d}dc{{i}d}iiiic{i}iiic{d}c{i}iiiicdddciic{d}dddd{c}{i}icccccccccdcciiicddddciiiiiic{{d}}{d}dc{{i}d}iiiic{i}iiic{d}c{i}iiiicdddciic{d}dddc{d}icc{i}iiiiii{c}cccccdddddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}d}iiiic{i}iiic{d}c{i}iiiicdddciic{d}dddciiiic{d}iiccccccc{i}iiiccccccccdddddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiicddddciiiic{d}c{i}ddd{c}cc{d}dc{i}dddc{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiicddddciiiic{d}c{i}c{i}ddd{c}ciiiic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiic{d}ddc{i}iic{d}c{i}ciiiiiic{d}iiccccccccc{d}iic{ii}ic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiic{d}ddc{i}iic{d}c{i}ciiiiiic{d}dddddc{i}dcccccccic{d}dc{ii}ic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiic{d}ddc{i}iic{d}iiic{i}dddciiiiiic{d}dddddc{i}iicdddccccc{i}dc{d}iic{d}dc{ii}ic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{d}c{i}iiiicdddc{d}iiicddddddciiiiiic{d}iiic{i}dddciiiiiic{d}dddddc{i}iicdciiiiccciicic{d}iic{d}dc{ii}ic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{dd}iic{ii}iicdddc{d}iiicddddddciiiiiic{d}iiic{i}dddciiiiiic{d}dddddcddddc{i}iiiiiciiicc{d}dc{i}iiiicic{d}iic{d}dc{ii}ic{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{dd}iic{ii}iicdddc{d}iiicddddddciiiiiic{d}iiic{i}dddciiiiiic{d}dddddcddddciiicciiicic{i}iiiicic{d}iiciic{i}ddc{dd}iic{i}dddcddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiicic{dd}iic{ii}iicdddc{d}iiicddddddciiiiiic{d}iiic{i}dddciiiiiic{d}dddddciiiiic{d}iiccciiiiiic{i}iiiicic{d}iiciic{i}ddc{dd}dc{i}cddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiicddddddcdddddciiiic{i}dddciiiiiic{d}iiicccccc{i}dcic{d}iiciic{i}ddc{dd}dc{i}cddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiicddddddcdddddciiiic{i}dddcdddddcccccccc{i}iiiic{d}iiciic{i}ddc{dd}dc{i}cddc{i}dddcciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiicddddddcdddddciiiic{i}i{c}dddciic{i}ddc{dd}dc{i}ciciiiicciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiicddddddcdddddc{i}iiiiii{c}ccddc{i}ddc{dd}dc{i}ciciiiicciiicddddciiiiiic{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiicddddddc{i}iiiiii{c}ccccic{d}icddciciiiicciiic{d}iic{i}c{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}iiiciiiiii{c}ccccccddddciiiiiic{d}iiiciiiicciiic{d}iic{i}c{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiicdddc{d}ddddddcccc{i}dd{c}cccc{i}dc{d}iiiciiiicciiic{d}iic{i}c{{d}}{d}dc{{i}}iiiiiic{d}cdc{i}iiiiiic{d}ciiii{c}cccccccccdddciiiic{d}ddc{i}iiiiic{d}iic{i}c{{d}}{d}dc{{i}}iiiiiic{d}cdc{ii}dddcccc{dd}dddddc{i}i{c}cc{d}iiiccccciiicc{i}iiiiic{d}iic{i}c{{d}}{d}dc{{i}}iiiiiic{d}c{i}iccdddd{c}ccccccc{d}ddccccciiiciiiiiicic{d}dc{{d}i}c{{i}}iiiiiiciiiiccccc{d}i{c}ccccc{d}icccccc{i}ddcic{d}dc{{d}i}c{{i}}iiiic{d}dddccccc{ii}ddd{cc}cc{d}iiic{d}dc{{d}i}c{ii}iiccccccc{{i}ddd}iccccccc{i}dd{c}ccccc{d}dc{{d}i}c

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


text:
Compressing the Atomic Ionization Energies
This is a different type of compression challenge.  In a normal kolmogorov-complexity challenge, you are required to recreate a list exactly.  Here, you are allowed to round the values in any way you wish.  What's the catch?  Your score is penalized based on how wrong your output is.
At the bottom of this question is a list of the first ionization energies for the first 108 elements.  Your program, upon execution, should output a reasonably accurate copy of this list.  There will be no input or arguments. For scoring purposes your output should be deterministic (same output every time).
Output format
Your program/function must output a list of 108 numbers, sorted in order of increasing atomic number. This list can be in any appropriate format. The source data below is provided in the correct order, from hydrogen to hassium.
Scoring
Your score will be your program's length in bytes plus a rounding penalty.  A rounding penalty is calculated for each element and summed to give the total penalty.
As an example, let's take the number 11.81381. Let's say that your program outputs an incorrect value of 11.81299999.

First, both numbers are multiplied by the same power of 10 such that there is no longer a decimal point in the true value: 1181381, 1181299.999. Trailing zeros in the true value are considered significant.
Then, the absolute difference is taken to determine the absolute error: 81.001.
Finally, we calculate this element's penalty as max(0, log10(err * 4 - 1)) -> 2.50921.  This formula was chosen such that an error < 0.5 gives no penalty (since the answer is correct within rounding), while also giving an asymptotic 50% chance that rounding the number to any particular decimal place would provide a net benefit in score (assuming no other compression).

Here is a Try-It-Online implementation of a penalty-calculating program.  The input to this program is provided as a list of numbers, one per line.  The output of this program is the total penalty and a per-element breakdown of scoring.
Data
The list of numbers below is the target data, in the correct order from atomic number 1 to 108.
Source
13.598434005136
24.587387936
5.391714761
9.322699
8.2980190
11.260296
14.53413
13.618054
17.42282
21.564540
5.1390767
7.646235
5.985768
8.151683
10.486686
10.36001
12.96763
15.7596112
4.34066354
6.11315520
6.56149
6.82812
6.746187
6.76651
7.434018
7.9024678
7.88101
7.639877
7.726380
9.3941990
5.9993018
7.899435
9.7886
9.752392
11.81381
13.9996049
4.177128
5.69486720
6.21726
6.63390
6.75885
7.09243
7.11938
7.36050
7.45890
8.33686
7.576234
8.993822
5.7863552
7.343917
8.608389
9.00966
10.45126
12.1298431
3.893905548
5.211664
5.5769
5.5386
5.473
5.5250
5.582
5.64371
5.670385
6.14980
5.8638
5.93905
6.0215
6.1077
6.18431
6.254159
5.425871
6.825069
7.549571
7.86403
7.83352
8.43823
8.96702
8.95883
9.225553
10.437504
6.1082871
7.4166796
7.285516
8.414
9.31751
10.7485
4.0727409
5.278424
5.380226
6.3067
5.89
6.19405
6.2655
6.0258
5.9738
5.9914
6.1978
6.2817
6.3676
6.50
6.58
6.65
4.90
6.01
6.8
7.8
7.7
7.6

Baselines & Tips
The source data above is 906 bytes, with certain compression tools able to get it to sub-500 bytes. Interesting solutions are those that attempt to perform intelligent rounding, use algebraic formulas, or other techniques to output approximate values in fewer bytes than compression alone. It is difficult, however, to judge these tradeoffs across languages: for some languages compression alone might be optimal, while many other languages might lack compression tools altogether, so I expect a wide variation in score across languages. This is fine, as I'm going by the "competition within languages, not between them" philosophy.
I anticipate that it might be useful to attempt to take advantage of trends in the periodic table.  Below is a graph I found of ionization energies, so that you can see some of these trends.

Hm, the graph shows some interesting trends, maybe that's helpful for compression...

Side note: this is a pretty experimental challenge. The scoring scheme is unique, I hope it works out well.

Very nice challenge. Unfortunately, the accuracy of the reference is so high that physically motivated approximation formulas (which can't really expect to predict more than two digits) have hardly a chance to compete against literal compression of the digits. (Short of actually solving the Schrödinger equation of course, which isn't very feasible either.) It would IMO be more interesting without the logarithm in the penalty formula, so that high-significant digits are actually more important to get right.

@PhiNotPi The scoring scheme isn't that unique, right?

@EsolangingFruit Yeah I see the similarities. I think this is unique in that the penalty is "continuous" meaning that you're not simply right or wrong for any particular output, so it's about finding how much you should fudge each number. (This scoring scheme was much more unique back in 2015 when I first sandboxed it, lol.)

Clean, 540 bytes + 64.396 Penalty = 604.396
Note: for the sake of readability, I've escaped every byte in the [Char] literal as most of them are non-printable. However, they are counted as only one byte per escape (except the null, quote, and newlines) as Clean naturally takes source files encoding-independently (except nulls).
import StdEnv,GenLib
c[h:t]=[(toInt h>>i)rem 2\\i<-[0..7]]++c t
c[]=[]
r[]=[]
r l=[7<<29+2^62+sum[d<<p\\d<-l&p<-[32..53]]:r(drop 22l)]
u::Maybe[Real]
u=uncompress{e\\e<-[108:r(c['\145\062\353\227\045\336\021\131\341\224\212\225\230\140\121\241\231\027\321\306\361\254\075\154\161\041\144\255\346\110\371\126\172\155\361\127\152\023\350\222\117\116\341\222\155\357\351\072\341\153\315\025\171\317\141\367\076\232\377\323\206\301\257\235\103\154\157\274\035\010\347\167\142\370\355\074\172\320\347\036\165\262\210\364\177\025\144\176\303\223\143\116\340\270\012\172\062\377\257\141\265\320\342\261\225\347\215\165\044\152\017\011\133\251\027\347\243\307\231\304\165\351\325\035\036\053\010\341\344\131\363\207\072\045\327\012\130\347\167\023\312\023\210\013\347\244\236\020\172\153\362\370\142\123\276\116\226\341\211\245\105\136\145\146\130\367\123\026\312\244\225\347\152\225\145\142\207\164\227\145\360\105\140\201\041\271\141\273\274\230\020\101\166\101\133\171\063\155\302\062\036\061\335\147\130\365\175\201\203\035\357\341\272\172\270\067\047\002\200\223\342\156\230\253\152\347\105\322\335\117\203\220\242\342\316\137\311\247\004\155\164\124\131\205\325\203\116\306\365\170\325\032\143\337\017\331\232\006\266\122\176\305\334\137\214\312\130\035\110\306\206\227\001\000\150\353\121\132\146\246\226\231\071\365\050\140\063\063\333\314\314\307\314\354\231\231\171'])]}

Try it online!
This is the first challenge where I've been able to utilize Clean's generic compression ability (technically not actually compression, it's binary serialization) to gain an actual benefit.
I started with a [Real] - a list of 64-bit floating-point numbers, those from the question. After serializing this list, I simplified the top 10 bits (which were the same for each number), and the optimal configuration of the bottom 32 bits into the constant 7<<29+2^62. The remaining 22 bits per number were translated into 2.75 characters each, and encoded in a string.
This leaves the entire compressed constant at only 302 bytes, including every escape!

Perhaps you can get better compression with CleanSnappy; https://cloogle.org/src/#CleanSnappy/Snappy / https://github.com/camilstaps/CleanSnappy

Python 3, 355 + 202 353 bytes + 198 penalty = 551
for i in'趐㠡愍噢甹靍跄땠㖀侙㹐哜洫毙蛿ꐏⴰ㾤䑎䜕䘻䙱䵤剄刋侈偯懌㹴刼旧斆竼醽⭼㭉䂹䔏䙜䧕䨝䲠䶦囊仟嶡㰽䱴妝巋泍繆⢉㙁㨎㦨㣺㦄㨜㫀㬈䀅㴋㷔㺯㾕䁡䄛㡼䜍亘凞册埘嵙嵃怊沨㾗䴵䯘垗惿濥⩦㛳㠂䆧㵑䁻䄺㺻㸰㹟䂅䅥䉊䎫䒀䔺㌃㺑䛊儳倩伞':print(ord(i)/2665)

Try it online!
I used 0xffff (65535) as upper bound because it's the max value that can be stored in a single 3-bytes unicode character.
Since the highest ionization energy is ~24.587, that gives a ratio of 2665.
To generate the string itself I used the snippet ''.join([chr(int(round(n*2665)))for n in ionization_energies]) (on python2 you need to use unichr), your console may or may not be able to print the characters.

4-bytes characters, 462 bytes + 99 penalty = 561
for i in'':print(ord(i)/45312)

Try it online!
Same idea, but the max value is 0x110000

Why can a single three byte unicode character only store 0x100**2 values and not 0x100**3?

I would say that the currently known highest atomic number is 118 -- in this case the highest to consider is 108 --, not ~24. You probably meant ionization energy in eV.

@JonathanFrech has a point: UTF-8 is a bad choice here. Other encodings are more efficient.

C, 49 bytes + 626.048 penalty = 675.048
f(i){for(i=0;i<108;)printf("%f\n",5.5+i++/13%2);}

Try it online!

37 bytes: f(i){for(i=0;i++<108;)printf("6\n");} ; penalty: 625.173330827107 ; total = 662,173330827

@Tsathoggua Hmm, I thought I tried that and got a higher penalty. I guess I was wrong. f(i){for(i=0;i<108;)puts("6");} does the same thing in 31 bytes.

You need the i++ too (in the "31"), but f(i){for(i=108;i;i--)puts("6");} does 32.

@JonathanAllan Whoops. f(i){for(i=108;i--;)puts("6");} gets it back down to 31.

CJam (389 bytes + 33.09 penalty => 422.09)
xxd-encoded:
0000000: 2256 3232 7c24 1bf9 7116 2f43 c82b 110e  "V22|$..q./C.+..
0000010: 6b93 4525 1cb3 4118 4afc 4d05 5c22 e15a  k.E%..A.J.M.\".Z
0000020: 11bc 563c 38e4 626c 1efb 6b10 c229 0e35  ..V<8.bl..k..).5
0000030: 873d 15df 2f71 36ca 404d 54d9 4979 17ba  .=../q6.@MT.Iy..
0000040: 4938 a953 6fb6 5f04 75f0 5c22 5c6b 39e5  I8.So._.u.\"\k9.
0000050: 3073 6fbd 343e fb36 4fff 357c 8c36 10f3  0so.4>.6O.5|.6..
0000060: 3b3c 37cd 3f1c 10a1 3f06 933d 0f1d fa3d  ;<7.?...?..=...=
0000070: 67e8 4549 6a9c 2f7f 24be 3f99 4713 e147  g.EIj./.$.?.G..G
0000080: 011c e14f 20d5 577f 668d 2135 30c2 2d47  ...O .W.f.!50.-G
0000090: 45d1 315e bc35 8936 0987 385e d238 7a9f  E.1^.5.6..8^.8z.
00000a0: 3af1 3b55 f441 2cbc 3c4e 8843 7ceb 2e25  :.;U.A,.<N.C|..%
00000b0: 1d93 3a60 15f1 4237 3fb0 4404 f949 e750  ..:`..B7?.D..I.P
00000c0: 423d b21e 265b 7cf6 2958 df2c 4edf 2c27  B=..&[|.)X.,N.,'
00000d0: c32b e42c 992c d32d 1394 2d2e 3cd9 3119  .+.,.,.-..-.<.1.
00000e0: b22e 74c3 2f41 cb30 9630 6ea4 313c dd32  ..t./A.0.0n.1<.2
00000f0: 04a1 2b34 0be1 364c 6fb8 3c32 61af 3e74  ..+4..6Lo.<2a.>t
0000100: e23e 55c3 4160 af43 6f8e 436a f544 733d  .>U.A`.Co.Cj.Ds=
0000110: eb49 e030 6e71 b43b 2ad7 3a24 af41 d345  .I.0nq.;*.:$.A.E
0000120: 5c22 c84a 7f9d 204a 3ea5 2a1d 0dcb 2b05  \".J.. J>.*...+.
0000130: 2cfd 32ba af31 46da 320f ef30 1ab5 2fe5  ,.2..1F.2..0../.
0000140: 2ff7 314a c632 20ba 3278 b6b4 34d1 b5a7  /.1J.2 .2x..4...
0000150: b0b6 bebd bc22 7b69 3235 362b 3262 283b  ....."{i256+2b(;
0000160: 287d 2531 6125 7b32 253a 2b5f 323e 315c  (}%1a%{2%:+_2>1\
0000170: 2b32 6232 405f 2c33 2d5c 323c 3262 2d23  +2b2@_,3-\2<2b-#
0000180: 642f 4e7d 2f                             d/N}/

Basically this is
"MAGIC STRING"{i256+2b(;(}%1a%{2%:+_2>1\+2b2@_,3-\2<2b-#d/N}/

This uses a custom variable-width floating point format to store the numbers. Two bits suffice for the exponent; the mantissa gets anywhere from 5 bits to 47 bits, in multiples of 7. The remaining bit per byte serves as the separator.
There seems to be some corruption going on when I copy the magic string to make an online demo, so that scores about 2 penalty points more. I'll have to figure out how to build the URL directly...

Generation program:
e# Score calculation
{1$`'.+'.%1=,10\#_@*@@*-z 4*1- 0e> ml10ml/0e>}:E;

q~]

e# Custom float format
e# Exponent goes from 2^1 to 2^4, so 2 bits
e# Each byte has 1 bit for continuation, so 7 bits available
e# That means the options for the mantissa are 5 bits, 12 bits, 19 bits, 26 bits, 33 bits, 40 bits, 47 bits
{
  :X
  0\{2/\)\_2<!}g
  e# Stack: exponent mantissa
  2 47#*i2b(;
  e# Stack: exponent mantissa-bits
  W%7/W%Wf%:M
  7,{
    )M<e_
    1_$+2b2@,#d/
  }%
  2 3$#f*
  X\f{E}
  _,,.+
  _:e<
  #)<

  \(4+2b(;\+e_7/
  _,,:!W%\.+2fb:c
}%
""*`

Online demo

Note to self: fixed point saves about 1 point.

Note to self: does tweaking the string to remove the escaped " increase the error too much to be worth it?

Jelly,  379 361  360 bytes + 0 Penalty = 360
-18 using an observation from Peter Taylor (order 10 values have leading 1 or 2, while order 1 values do not).
<3Ḣ‘_L⁵*×Ḍ
“KẸ⁺dzⱮÑ2⁵İ2ṭ¬⁴²¬¶9°ß°øİẆGẊœ%X(¢ṆḢ/8¬Ɗ’b7µ18,-;_3+\⁺Ṭœṗ“SŒƥŻƭ°}MḋṘḥfyɼ{ṅĊLƝġœ⁺ḟ8ḶhỊDṭ&æ%*ɱ¬ =¦ẉ Qh"¶:ḌĊ€ĖṢė°ġṀƬmẓSṃ÷E⁴Ȥ⁼ḋ#ØĖḂ2øzẸżƈ¥Ȧƥ7¢®|ḳẊṆƙƲɦḟɼṖỊɲṁẉɗ6ẇSɗ⁴ẉİt]ẓeṆHṚƑ½>]ɦ~T¢~ẆẆA`/6ƭṡxṠKG£Ḅ+wḃḣỤw×ḌŻƲF>Ụ]5bJḤḟCḞİḶ|ȥ9Ỵ0ụKṗT⁴ƥƁṖı×ṄtTĊG©ṀḥṬƭʂd½ḊȦÑƒŀṣ¹ʋṖẓYL²ṅṿ&ẏdDṬIɦỵ¹b,ḷṣƭ#P'µ{GTƇẹ¥L8SƥÑṆẈėẎßṀḷƓ⁷ðḳċ¿ḶM_ḲẈg9ḢĠi+LṭẹḲẎ¤g<ṘJJĿßæ⁺(ɲỴ3ɲgkSḃIƙṭ.Ỵ&_:cĿƝı’D¤Ç€

Try it online!
How?
Creates these two constants (AKA nilads):

(A) all the decimal digits used (i.e. the numbers all joined up ignoring where they join and their decimal place separators), and
(B) the number of significant figures used by each number

Then uses those to reconstruct floating point representations of the numbers.
The full program is of this form:
<3Ḣ‘_L⁵*×Ḍ
“...’b7µ18,-;_3+\⁺Ṭœṗ“...’D¤Ç€

(where ... are encoded numbers for constructing B, and A)
and works like this:
<3Ḣ‘_L⁵*×Ḍ - Link 1, conversion helper: list of digits  e.g. [1,2,9,6,7,6,3]
<3         - less than three?                                [1,1,0,0,0,0,0]
  Ḣ        - head                                            1
   ‘       - increment                                       2
     L     - length                                          7
    _      - subtract                                        -5
      ⁵    - literal ten                                     10
       *   - exponentiate                                    0.00001
         Ḍ - undecimal (convert from base 10)                1296763
        ×  - multiply                                        12.96763
           - i.e. go from digits to a number between 3 and 30

“...’b7µ18,-;_3+\⁺Ṭœṗ“...’D¤Ç€ - Main link: no arguments
“...’                          - base 250 literal = 16242329089425509505495393436399830365761075941410177200411131173280169129083782003564646
     b7                        - to base seven = [2,0,4,3,2,4,2,4,3,2,3,3,4,2,3,5,3,3,0,3,4,2,4,4,1,4,3,4,3,2,1,5,3,5,1,5,0,3,3,3,3,3,3,3,4,3,4,2,3,2,4,5,4,0,1,3,2,4,2,5,4,2,2,4,2,3,4,4,3,3,3,2,3,3,3,3,4,4,3,3,2,0,5,3,5,2,3,1,1,6,2,3,3,3,3,3,3,1,3,3,3,3,2,3,3]
       µ                       - start a new monadic chain, call that x
        18,-                   - integer list literal = [18,-1]
            ;                  - concatenate with x = [18,-1,2,0,4,3,2,4,2,4,3,2,3,3,4,2,3,5,3,3,0,3,4,2,4,4,1,4,3,4,3,2,1,5,3,5,1,5,0,3,3,3,3,3,3,3,4,3,4,2,3,2,4,5,4,0,1,3,2,4,2,5,4,2,2,4,2,3,4,4,3,3,3,2,3,3,3,3,4,4,3,3,2,0,5,3,5,2,3,1,1,6,2,3,3,3,3,3,3,1,3,3,3,3,2,3,3]
             _3                - subtract three = [15,-4,-1,-3,1,0,-1,1,-1,1,0,-1,0,0,1,-1,0,2,0,0,-3,0,1,-1,1,1,-2,1,0,1,0,-1,-2,2,0,2,-2,2,-3,0,0,0,0,0,0,0,1,0,1,-1,0,-1,1,2,1,-3,-2,0,-1,1,-1,2,1,-1,-1,1,-1,0,1,1,0,0,0,-1,0,0,0,0,1,1,0,0,-1,-3,2,0,2,-1,0,-2,-2,3,-1,0,0,0,0,0,0,-2,0,0,0,0,-1,0,0]
                \              - cumulative reduce with:
               +               -   addition    = [15,11,10,7,8,8,7,8,7,8,8,7,7,7,8,7,7,9,9,9,6,6,7,6,7,8,6,7,7,8,8,7,5,7,7,9,7,9,6,6,6,6,6,6,6,6,7,7,8,7,7,6,7,9,10,7,5,5,4,5,4,6,7,6,5,6,5,5,6,7,7,7,7,6,6,6,6,6,7,8,8,8,7,4,6,6,8,7,7,5,3,6,5,5,5,5,5,5,5,3,3,3,3,3,2,2,2]
                               -                 ("B" significant figures, with 1 extra for the very first entry and a missing last entry)
                 ⁺             - repeat (the cumulative addition to get
                               -         partition positions) = [15,26,36,43,51,59,66,74,81,89,97,104,111,118,126,133,140,149,158,167,173,179,186,192,199,207,213,220,227,235,243,250,255,262,269,278,285,294,300,306,312,318,324,330,336,342,349,356,364,371,378,384,391,400,410,417,422,427,431,436,440,446,453,459,464,470,475,480,486,493,500,507,514,520,526,532,538,544,551,559,567,575,582,586,592,598,606,613,620,625,628,634,639,644,649,654,659,664,669,672,675,678,681,684,686,688,690]
                  Ṭ            - untruth (1s at those indices) = [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,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,1,0,1,0,1]
                           ¤   - nilad followed by link(s) as a nilad:
                     “...’     -   base 250 literal = 1359843400513624587387936539171476193226998298019011260296145341313618054174228221564540513907677646235598576881516831048668610360011296763157596112434066354611315520656149682812674618767665174340187902467878810176398777726380939419905999301878994359788697523921181381139996049417712856948672062172666339067588570924371193873605074589083368675762348993822578635527343917860838990096610451261212984313893905548521166455769553865473552505582564371567038561498058638593905602156107761843162541595425871682506975495717864037833528438238967028958839225553104375046108287174166796728551684149317511074854072740952784245380226630675896194056265560258597385991461978628176367665065866549060168787776
                          D    -   decimal (to base 10) = [1,3,5,9,8,4,3,4,0,0,5,1,3,6,2,4,5,8,7,3,8,7,9,3,6,5,3,9,1,7,1,4,7,6,1,9,3,2,2,6,9,9,8,2,9,8,0,1,9,0,1,1,2,6,0,2,9,6,1,4,5,3,4,1,3,1,3,6,1,8,0,5,4,1,7,4,2,2,8,2,2,1,5,6,4,5,4,0,5,1,3,9,0,7,6,7,7,6,4,6,2,3,5,5,9,8,5,7,6,8,8,1,5,1,6,8,3,1,0,4,8,6,6,8,6,1,0,3,6,0,0,1,1,2,9,6,7,6,3,1,5,7,5,9,6,1,1,2,4,3,4,0,6,6,3,5,4,6,1,1,3,1,5,5,2,0,6,5,6,1,4,9,6,8,2,8,1,2,6,7,4,6,1,8,7,6,7,6,6,5,1,7,4,3,4,0,1,8,7,9,0,2,4,6,7,8,7,8,8,1,0,1,7,6,3,9,8,7,7,7,7,2,6,3,8,0,9,3,9,4,1,9,9,0,5,9,9,9,3,0,1,8,7,8,9,9,4,3,5,9,7,8,8,6,9,7,5,2,3,9,2,1,1,8,1,3,8,1,1,3,9,9,9,6,0,4,9,4,1,7,7,1,2,8,5,6,9,4,8,6,7,2,0,6,2,1,7,2,6,6,6,3,3,9,0,6,7,5,8,8,5,7,0,9,2,4,3,7,1,1,9,3,8,7,3,6,0,5,0,7,4,5,8,9,0,8,3,3,6,8,6,7,5,7,6,2,3,4,8,9,9,3,8,2,2,5,7,8,6,3,5,5,2,7,3,4,3,9,1,7,8,6,0,8,3,8,9,9,0,0,9,6,6,1,0,4,5,1,2,6,1,2,1,2,9,8,4,3,1,3,8,9,3,9,0,5,5,4,8,5,2,1,1,6,6,4,5,5,7,6,9,5,5,3,8,6,5,4,7,3,5,5,2,5,0,5,5,8,2,5,6,4,3,7,1,5,6,7,0,3,8,5,6,1,4,9,8,0,5,8,6,3,8,5,9,3,9,0,5,6,0,2,1,5,6,1,0,7,7,6,1,8,4,3,1,6,2,5,4,1,5,9,5,4,2,5,8,7,1,6,8,2,5,0,6,9,7,5,4,9,5,7,1,7,8,6,4,0,3,7,8,3,3,5,2,8,4,3,8,2,3,8,9,6,7,0,2,8,9,5,8,8,3,9,2,2,5,5,5,3,1,0,4,3,7,5,0,4,6,1,0,8,2,8,7,1,7,4,1,6,6,7,9,6,7,2,8,5,5,1,6,8,4,1,4,9,3,1,7,5,1,1,0,7,4,8,5,4,0,7,2,7,4,0,9,5,2,7,8,4,2,4,5,3,8,0,2,2,6,6,3,0,6,7,5,8,9,6,1,9,4,0,5,6,2,6,5,5,6,0,2,5,8,5,9,7,3,8,5,9,9,1,4,6,1,9,7,8,6,2,8,1,7,6,3,6,7,6,6,5,0,6,5,8,6,6,5,4,9,0,6,0,1,6,8,7,8,7,7,7,6]
                               -                          ("A" all the required digits in order)
                   œṗ          - partition at truthy indices = [[1,3,5,9,8,4,3,4,0,0,5,1,3,6],[2,4,5,8,7,3,8,7,9,3,6],[5,3,9,1,7,1,4,7,6,1],[9,3,2,2,6,9,9],[8,2,9,8,0,1,9,0],[1,1,2,6,0,2,9,6],[1,4,5,3,4,1,3],[1,3,6,1,8,0,5,4],[1,7,4,2,2,8,2],[2,1,5,6,4,5,4,0],[5,1,3,9,0,7,6,7],[7,6,4,6,2,3,5],[5,9,8,5,7,6,8],[8,1,5,1,6,8,3],[1,0,4,8,6,6,8,6],[1,0,3,6,0,0,1],[1,2,9,6,7,6,3],[1,5,7,5,9,6,1,1,2],[4,3,4,0,6,6,3,5,4],[6,1,1,3,1,5,5,2,0],[6,5,6,1,4,9],[6,8,2,8,1,2],[6,7,4,6,1,8,7],[6,7,6,6,5,1],[7,4,3,4,0,1,8],[7,9,0,2,4,6,7,8],[7,8,8,1,0,1],[7,6,3,9,8,7,7],[7,7,2,6,3,8,0],[9,3,9,4,1,9,9,0],[5,9,9,9,3,0,1,8],[7,8,9,9,4,3,5],[9,7,8,8,6],[9,7,5,2,3,9,2],[1,1,8,1,3,8,1],[1,3,9,9,9,6,0,4,9],[4,1,7,7,1,2,8],[5,6,9,4,8,6,7,2,0],[6,2,1,7,2,6],[6,6,3,3,9,0],[6,7,5,8,8,5],[7,0,9,2,4,3],[7,1,1,9,3,8],[7,3,6,0,5,0],[7,4,5,8,9,0],[8,3,3,6,8,6],[7,5,7,6,2,3,4],[8,9,9,3,8,2,2],[5,7,8,6,3,5,5,2],[7,3,4,3,9,1,7],[8,6,0,8,3,8,9],[9,0,0,9,6,6],[1,0,4,5,1,2,6],[1,2,1,2,9,8,4,3,1],[3,8,9,3,9,0,5,5,4,8],[5,2,1,1,6,6,4],[5,5,7,6,9],[5,5,3,8,6],[5,4,7,3],[5,5,2,5,0],[5,5,8,2],[5,6,4,3,7,1],[5,6,7,0,3,8,5],[6,1,4,9,8,0],[5,8,6,3,8],[5,9,3,9,0,5],[6,0,2,1,5],[6,1,0,7,7],[6,1,8,4,3,1],[6,2,5,4,1,5,9],[5,4,2,5,8,7,1],[6,8,2,5,0,6,9],[7,5,4,9,5,7,1],[7,8,6,4,0,3],[7,8,3,3,5,2],[8,4,3,8,2,3],[8,9,6,7,0,2],[8,9,5,8,8,3],[9,2,2,5,5,5,3],[1,0,4,3,7,5,0,4],[6,1,0,8,2,8,7,1],[7,4,1,6,6,7,9,6],[7,2,8,5,5,1,6],[8,4,1,4],[9,3,1,7,5,1],[1,0,7,4,8,5],[4,0,7,2,7,4,0,9],[5,2,7,8,4,2,4],[5,3,8,0,2,2,6],[6,3,0,6,7],[5,8,9],[6,1,9,4,0,5],[6,2,6,5,5],[6,0,2,5,8],[5,9,7,3,8],[5,9,9,1,4],[6,1,9,7,8],[6,2,8,1,7],[6,3,6,7,6],[6,5,0],[6,5,8],[6,6,5],[4,9,0],[6,0,1],[6,8],[7,8],[7,7],[7,6]]
                            Ç€ - call the last link (1) as a monad for €ach = [13.598434005136,24.587387936000002,5.391714761,9.322699,8.298019,11.260295999999999,14.534129999999998,13.618053999999999,17.422819999999998,21.56454,5.1390766999999995,7.646235,5.985767999999999,8.151683,10.486686,10.360009999999999,12.96763,15.759611200000002,4.34066354,6.1131552000000005,6.561490000000001,6.82812,6.746187,6.76651,7.434018,7.902467799999999,7.881010000000001,7.639876999999999,7.72638,9.394199,5.9993018,7.8994349999999995,9.7886,9.752392,11.81381,13.9996049,4.177128,5.6948672,6.2172600000000005,6.633900000000001,6.758850000000001,7.09243,7.1193800000000005,7.360500000000001,7.458900000000001,8.336860000000001,7.5762339999999995,8.993822,5.7863552,7.343916999999999,8.608388999999999,9.00966,10.45126,12.129843099999999,3.893905548,5.211664,5.5769,5.538600000000001,5.473,5.525,5.582,5.6437100000000004,5.670385,6.149800000000001,5.8638,5.939050000000001,6.0215000000000005,6.1077,6.184310000000001,6.254159,5.425871,6.825069,7.549570999999999,7.8640300000000005,7.833520000000001,8.43823,8.967020000000002,8.95883,9.225553,10.437504,6.1082871,7.416679599999999,7.285515999999999,8.414,9.31751,10.7485,4.072740899999999,5.278423999999999,5.3802259999999995,6.3067,5.89,6.194050000000001,6.2655,6.0258,5.973800000000001,5.9914000000000005,6.1978,6.281700000000001,6.3676,6.5,6.58,6.65,4.9,6.01,6.800000000000001,7.800000000000001,7.7,7.6000000000000005]

"Whether they are of order 1 or 10" is easy: if the first digit is 1 or 2, it's of order 10. Does that help golf it even further, or is it cheaper to unpack a bit array?

@PeterTaylor had not noticed, that will almost certainly save some bytes, thanks!

Bubblegum, 403 + 9.12 = 412.12
00000000: 1551 5116 c030 04fb 7718 af20 e2fe 17db  .QQ..0..w.. ....
00000010: f2d1 454d 4322 cae7 d8d5 ef4d 142c db87  ..EMC".....M.,..
00000020: 5bdc 2bd8 785d 6cf4 22ec bc32 7167 f43c  [.+.x]l."..2qg.<
00000030: be38 8bf0 c4cb 8345 fb54 4759 9423 f8a6  .8.....E.TGY.#..
00000040: 2dd6 3b93 6919 3ee8 691b 8fba b758 5b47  -.;.i.>.i....X[G
00000050: 236b 6cfc 380b 1a3d 26c0 b278 de04 0845  #kl.8..=&..x...E
00000060: 85f7 c222 fdb0 288b f19d 4344 5a7b f503  ..."..(...CDZ{..
00000070: 6ada e011 1533 69f0 41f4 fdc8 64e8 be8d  j....3i.A...d...
00000080: e02a 0026 6c5d 3a83 7f70 2f1b ab88 8ca7  .*.&l]:..p/.....
00000090: 5fa8 e36a b64d 1425 f73a ee0c aab9 eb1a  _..j.M.%.:......
000000a0: 3b5f 1282 c9ba 9401 8c62 58b4 b5c7 6e24  ;_.......bX...n$
000000b0: 6d1c d7c4 aa7f c626 7e44 d569 8a21 c7d6  m......&~D.i.!..
000000c0: df65 d78f 1157 b495 4ea5 7b28 77ab 4035  .e...W..N.{(w.@5
000000d0: 9d45 561b fdae 9869 e34b d44c ea45 6b31  .EV....i.K.L.Ek1
000000e0: 46c7 63f1 ecfc bd03 645a 4f24 645a a4f6  F.c.....dZO$dZ..
000000f0: 1a56 ceab 7b33 ade1 3202 681b d19f a088  .V..{3..2.h.....
00000100: 1f7a 4b97 1c7d 9952 d1b5 21dc 571c d9dc  .zK..}.R..!.W...
00000110: 2702 a204 a254 f665 08e2 ed0a d451 c2a7  '....T.e.....Q..
00000120: 6344 df39 5c65 98f3 7092 d537 2bc3 897e  cD.9\e..p..7+..~
00000130: 25ac 9a34 7a17 b324 17fb 5238 64d9 79e6  %..4z..$..R8d.y.
00000140: cc94 a475 edbc 3675 6372 45d2 01ec c9ae  ...u..6ucrE.....
00000150: e44c 403c d1da 5eec 841e 6d73 acfd 6d6e  .L@<..^...ms..mn
00000160: 3f8d 94cb 4e39 507c 995a 4f3d ac94 9da8  ?...N9P|.ZO=....
00000170: afa5 cb13 2378 3994 da2d 0a2e 5a35 b754  ....#x9..-..Z5.T
00000180: 0943 9a0b 2b92 d151 1a6a 77a6 9c96 abb3  .C..+..Q.jw.....
00000190: ffc1 07                                  ...

Try it online!

Jelly, 164 bytes + 409.846 = 573.846
“?#4ß<Ʋƒ⁻µ`kḞÑ6{ɱ~.ṣ¬⁷Ḷlŀ⁸ẎṘ£ỌgfĖỌƒ⁻ḋN?ḤḞ{ị#qp⁵mp&WṘƙ=/rŻ-vn⁼ẊTị}W;!z€ȦMẊẇİ_D8ỴtṫQAẎḣṬr¥1J3Ƙ~ʋ$ĿẠ7þƭ8ṛM{ịḟƇỵ÷b?°6I@?Ȥ⁾d⁹DẈcȷv5ⱮAJb}øDȯRµ’Ds3Ḍ÷³×⁵$2R;6r⁵¤¤;15r18¤¤¦Y

Try it online!
There is a compressed number in there that is the concatenation of the first three digits of each energy (including trailing zeroes). I get a list of these three digit numbers with Ds3Ḍ then divide each by 100 with ÷³. Some of the numbers should only be divided by 10, so I multiply some of these by 10 to improve the score slightly (×⁵$2R;6r⁵¤¤;15r18¤¤¦).
Previous version:
Jelly, 50 bytes + 571.482 penalty = 621.482
“¡9;ẋkñ¬nƑḳ_gÐ.RḊụʠṁṬl⁾l>ɼXZĖSṠƈ;cḶ=ß³ṾAiʠʠɼZÞ⁹’DY

Try it online!
Rounded each energy to it's nearest single digit integer. Concatenated together this gives 995989999958689999467777788889689999466777777889679999456656666666666657888899996778994556666666666677567888. “¡9;ẋkñ¬nƑḳ_gÐ.RḊụʠṁṬl⁾l>ɼXZĖSṠƈ;cḶ=ß³ṾAiʠʠɼZÞ⁹’ is a base 250 number which yields this. DY  joins the digits of this number with newlines.

Jelly, 116 bytes + 429.796016684433 Penalty = 545.796016684433
“tẏØA5X¶tɱḅÐ-ı3OMm⁾¦ȷ #""*00-.Bı0FF_y¤ß÷!"&&)+5,=æ)8=Nc¡ÑÞŒŒŒÞßßñçðıȷñ÷Ø#,//6==@Nȷ*(6AR£ÑØøðñ÷ıııñ÷øþ !€ı#/-,‘+47÷12

Try it online!
Nothing particularly spectacular, a code-page index list, “...‘ (numbers between 0 and 249), to each of which we add 47, +47, and then divide by 12, ÷12.

Java 8, 48 bytes + 625.173330827107 Penalty = 673.173330827107
v->{for(int i=108;i-->0;System.out.println(6));}

Try it online.
Initial version that prints 108 times 6. Will try to improve from here.

J, 390 bytes + 183.319 Penalty = 573.319
d=.'5@-103659=-/-02247,...../////1-/1135,-...////0/0-/0124+--------.--....-.///00012.//012,--.-...--......,..///'
f=.'[ZG@=:U]JX-`~/PD~kB+XrjlKzx_hG~ynkq~1e5_k)+DMAY~nB\ M,y5YUOTZ`c.v}"*29JrVvsK~~6K*I<I?j'';F>y3:"~~3<DRZaz!ppf\'
p=.'tj1;p#Iq<M{^Z1c l~''@/q^aH9*~`J}~v8F~gQiGy8~%ye^F`Gt~-~G1ev>R4E$~F{/mKJ[S~HCrfxXkscWHku;t"c IWZF.n1l',9$' '
echo,.(_40+a.i.d)+(100%~_32+a.i.f)+1e4%~_32+a.i.p

Try it online!
I rounded the numbers to four decimal digits and split them into one list for integer parts, one list for the first 2 fraction digits and one for the second 2 fraction digits. I encoded each number with a printable character.
For decoding I simpy extract the ingerer and fraction parts of a number from the associated character lists and assemble them back to float.
J, 602 bytes + 0 Penalty = 602
q=.'qy7?JOZp@''T1}Ciz={3L/0rHp/r}`M{m^ZHZSy55MYPBaNcV+\?A%/{eyQxQPkDs8W''@m$\6wZsV%KjI''_9"o\XMCP+vU=S3''c3\IKD@ovEW''4LX2O=>n&dgNktY><Ru_TvNpArL?}Y642=}5Hb"yYsD19$<OP2<|Jo)!8S`^9N3w{Q]968P2VF`[(2HOa%XL*V|,[8PcL)}w8"*l%JNC{amnCNx\yH73(pmJGCDq?8@D$ww{X`t0[o.`$''RB&eXiP|_u#9WBFS%U:3|O.U+is5E$A[c{1MpJ@Dw&^rpM_N:M^:o&!HPX9?0i}{j?%2W20z>Q?AOw!fuTWC"Q{-Er'
f=:3 :0
a=.0$0 while.*#y do.l=.1+{.y
a=.a,<' '-.~":}.l{.y
y=.l}.y
end.a
)
echo;(('.',~":"0)&.>_40+a.i.'5@-103659=-/-02247,...../////1-/1135,-...////0/0-/0124+--------.--....-.///00012.//012,--.-...--......,..///'),.(f 12,10#.inv 94x#._32+a.i.q),.<CR

Try it online!
This time I went for a slightly different approach. I split the numbers to 2 streams - the first one contains the integer parts which are simply encoded with a single printable character. The second stream contains the entire fractional parts. I removed all intervals between the digits and prepended each substring with its length 1-9 (I tweaked the first fraction, wich is 13 digits long). Then I encoded this list as a base 94 number, presented it as a list of characters.
About 20 bytes can be saved if the verb is rewriten as tacit one.

source: Stack Exchange

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

sort: votes


text:
The Pyramid of Languages
Write a code that runs or compiles in as many programming languages as possible and prints a newline separated list of names of previous and current programming languages.

Every used language must have 1 character longer name than previous; ex. C#, C++, Ruby, Jelly, Python...
Each language must output a list of language names separated with a newline, sorted by length.

Output must be a pyramid: The list can only contain used language names, that are shorter than the running script language name + the running script language's name.

Leading and trailing newlines are allowed.
Standard loopholes are forbidden.
It's not allowed to create custom programming languages just to increase the score.
Version numbers don't count in language name, but you can specify it in your post if there are any incompatible changes in new versions of the language.
You can decide if you want to use the shortcut for the language name or it's full name, but you can't submit both forms in one answer. You can use ex. either SPL or Shakespeare Programming Language.

Only letters, numbers, ASCII symbols and single spaces (not leading nor trailing) count in language name length.

Examples
Example outputs for C, C# and C++:
C
C

C#
C
C#

C++
C
C#
C++

Sandbox post

There are plenty of languages with single-letter names: tio.run alone has 4, 7, C, D, I, J, K, M, R, and V. (Another significant one is B, the predecessor to C.)

@Lynn But if you start from a longer language name you might lose score

10 languages C, rk, ><>, Rail, Width, Gol><>, Fission, Cardinal, brainfuck, Befunge-98, 991 bytes
//Q rk:start print: "C^nrk" rk:end @,k*97C'a"rk"a"><>"a-1"Sail"a"Width"a"Gol><>"a"Fission"a"Cardinal"a"brainfuck"a"Befunge-98"
main(){puts("C");}
/*
$'main'
 \-[C\n\rk\n\><>\n\Rail]o

++++[++++>---<]>.>++++++++++.[------->+++<]>.-------.>++++++++++.[->++++++<]>++.--.++.>++++++++++.>-[--->+<]>---.[------>+<]>--.++++++++.+++.>++++++++++.[------>+<]>.+++[->++++<]>+.-----.--[--->+<]>--.------------.>++++++++++.[->+++++++<]>+.[--->+<]>++.---.--[->+++<]>.--.++.>++++++++++.[->+++++++<]>.[-->+++<]>.++++++++++..----------.++++++.-.>++++++++++.+[->++++++<]>+.-[-->+++<]>--.--[--->+<]>---.--------------.+++++.+++++.-------------.+++++++++++.>++++++++++.+[--->++++<]>--.[--->+<]>----.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.
R"C"N"rk"N"><>"N'S_!"ail"N"Width"N"Gol><>"N"Fission"*
/"><>krC"oaoooaooooE ao'liaR>'~ooooaoS"Width"aoS"Gol><>"; QQaAWAmcOAWAaicmaiWAAiwAOaOwWAAAOawmmFOcQww
 %"C"++++++++++,"rk","><>",=--t++,"ail"~,"Width","Gol><>","Fission","Cardinal"
 */

Try it online!
568 bytes of this is just the brainfuck code. The Befunge-98 program produces:
C
rk
><>
Rail
Width
Gol><>
Fission
Cardinal
brainfuck
Befunge-98

Can't you save 2 bytes by using puts instead of printf?

@Neil Thanks! (haven't golfed in C before (some would say i still haven't))

Nice! I would look into adding Parenthetic next — it ignores everything but ( and ), making it easy to quine with.

7 languages (J, es, zsh, Bash, Straw, Retina, Fission), 222 bytes
echo 'J'
#0 : 0
echo es #(10)#»:::J>>(es)>>(zsh)>>(Bash)>>(Straw)>>
(echo zsh;)
if [[ $BASH_VERSION ]]; then echo Bash; fi
#              ;R"J"N"es"N"zsh"N"Bash"N"Straw"N'Q+!"etina"N"Fission"N;
K`J¶es¶zsh¶Bash¶Straw¶Retina

Try it online!

I know this isn't a code-golf challenge, but you can remove the N after "Fission" to save 1 byte. :)

rk, sed, Swap, 65 bytes
s/.*/rk\nsed/
rk:start print: "rk"
r>"pawSdeskr"oo52*oooo52*ooooo

rk: Try it online!
sed: Try it online!
Swap: Try it online!


text:
Let's Encrypt It!
Note
This is the encryption challenge. The decryption challenge can be found here.
Challenge
The challenge is to encrypt a given string, using the rules as specified below. The string will only contain lowercase alphabets, digits, and/or blank spaces.
Equivalent of a Character
Now, firstly you would need to know how to find the "equivalent" of each character.
If the character is a consonant, this is the way of finding it's equivalent:
1) List all the consonants in alphabetical order
    b c d f g h j k l m n p q r s t v w x y z
2) Get the position of the consonant you are finding the equivalent of.
3) The equivalent is the consonant at that position when starting from the end.

eg: 'h' and 't' are equivalents of each other because 'h', 't' are in the 6th position from start and end respectively.
The same procedure is followed to find the equivalent of vowels/digits. You list all the vowels or the digits (starting from 0) in order and find the equivalent.
Given below is the list of the equivalents of all the characters:
b <-> z
c <-> y
d <-> x
f <-> w
g <-> v
h <-> t
j <-> s
k <-> r
l <-> q
m <-> p
n <-> n

a <-> u
e <-> o
i <-> i

0 <-> 9
1 <-> 8
2 <-> 7
3 <-> 6
4 <-> 5

Rules of Encrypting

You start moving from the left and go towards the right.

If the character is a consonant/digit, then its equivalent is taken and if it is a blank space, then a blank space is taken.

If the character is a vowel, you take it's equivalent and start to move in the opposite direction. For example, if you are moving right and encounter a vowel, encrypt that character then skip to the rightmost unencrypted character and begin encrypting in the left direction, and vice versa.

You shouldn't consider a character in the same position twice. The steps should be followed until all the characters in the input are covered.

The total number of characters in the input(including blank spaces) should be equal to the total number of characters in the output.

Please note that the encrypted characters appear in the output in the order in which they were encrypted.
Now let me encrypt a string for you.
String = "tre d1go3t is"
Moving left to right
"t" -> "h"
"r" -> "k"
"e" -> "o"
Vowel encountered. Now moving right to left.
"s" -> "j"
"i" -> "i"
Vowel encountered. Now moving left to right.
" " -> " "
"d" -> "x"
"1" -> "8"
"g" -> "v"
"o" -> "e"
Vowel encountered. Now moving right to left.
" " -> " "
"t" -> "h"
"3" -> "6"

Output -> "hkoji x8ve h6"

Examples
"flyspy" -> "wqcjmc"
"hero" -> "toek"
"heroic" -> "toyike"
"ae" -> "uo"
"abe" -> "uoz"
"the space" -> "htoo jmuy"
"a d1g13t" -> "uh68v8x "
"we xi12" -> "fo78i d"
"this is a code" -> "htioj ixej uy "

You may also choose to use uppercase alphabets instead of lowercase.
Scoring
This is code-golf, so the shortest code wins!

Step 3 is a bit unclear with regards to switching directions. I think you should say something like "If you are moving right and encounter a vowel, encrypt that character then skip to the rightmost unencrypted character and begin encrypting in the left direction." (If that is what you mean). I think you should also specify explicitly that the encrypted characters appear in the output in the order in which they were encrypted.

@dylnan Added that.

Just out-of-curiosity - Can you describe decryption procedure ? Because encryption function is not it's own inverse (like in ROT13 algo). So if we pass an encrypted data to the same cipher procedure - we will not get the original text. Thanks

Decryption can be done in the opposite way. You will get the original text on decrypting

@AgniusVasiliauskas: One way of doing it would be: Apply the same character transformations. Keep 2 decrypt strings. Loop over the string left-to-right. Alternate between appending chars to the first string and prepending to the second every time you handle a vowel. Merge the strings at the end.

There will soon be a decryption challenge for the same, in which I will try to explain the process

For the curious, in Indian English alphabet means letter.

JavaScript (Node.js), 173 ... 166 156 ... 124 123 bytes
-28 byte Thanks Arnauld
f=([q,...s])=>q?(c="aeioubcdfghjklmpqrstvwxyz",t=c.search(q),q=="0"|+q?9-q:~t?c[(t<5?4:29)-t]:q)+f(~t&&t<5?s.reverse():s):s

Try it online!
In the first iteration the String will be changed to Array, and subsequent iterations will continue to use Array. Voilà!
Original Approach (166 bytes):
f=(s,i=0,r=s.length,d=1,c="bcdfghjklmnpqrstvwxyz",v="aeiou")=>(d^=!!(t=~v.search(q=s[d?i:r])),q<"0"|q>"9"?c[20-c.search(q)]||v[5+t]||q:9-q)+(i<r-1?f(s,i+d,r-!d,d):"")

& didn't work for some numbers but && worked. Thanks.

Oh yes, I didn't find a method to optimize that and you did it! Thanks!

124 bytes by using the same string for all letters and applying some more golfing.

Wow brilliant! I didn't think of combining the strings AT ALL

q=="0"|+q is actually 1 byte shorter than q>" "&&1/q.

05AB1E, 22 bytes
vćžNÂ‡žMÂ‡žhÂ‡D?žMsåiR

Try it online!
or as a Test suite
Explanation
v                        # for each char in input
 ć                       # extract the head of the current string (initially input)
  žNÂ‡                   # transform consonants
      žMÂ‡               # transofrm vowels
          žhÂ‡           # transform numbers
              D?         # print a copy of the current char
                žMsåi    # if the current char is a vowel
                     R   # reverse the rest of the string

žhžMžN)UvćXJXíJ‡D?žMsåiR was what I was thinking for improvement, but can't cut XJXiJ down enough.

@MagicOctopusUrn: I had a similar idea with DJsíJ which wasn't very effective either.

C, 196 bytes
#define C(k,m)for(i=m;i--;)k[i]-c||putchar(k[m+~i],r^=m==5);
r;p(c,i){C("bcdfghjklmnpqrstvwxyz",21)C("0123456789",10)C("aeiou",5)C(" ",1)}f(S){char*s=S,*t=s+strlen(s);for(r=1;s<t;)p(r?*s++:*--t);}

Try it online!

Clean, 221 206 198 190 186 178 bytes
import StdEnv
r=reverse
l=['bcdfghjklm01234aeou56789pqrstvwxyz']
$s#(a,b)=span(\e=all((<>)e)['aeiou'])s
|s>[]=[j\\e<-a++b%(0,0),i<-['in ':l]&j<-['in ':r l]|e==i]++ $(init(r b))=s

Try it online!

J, 132 bytes
f=:3 :0
c=.(u:97+i.26)-.v=.'aeiou'
d=.u:48+i.10
g=.;"0|.
a=.''
while.*#y do.a=.a,{.y rplc(g c),(g d),g v
y=.|.^:({:a e.v)}.y
end.a
)

Try it online!
A verbose explicit verb this time.
Explanation:
c=.(u:97+i.26) makes a list a-z
v=.'aeiou' makes a list of vowels
-. removes the vowels from the list of letters
d=.u:48+i.10 makes a list of digits
g=.;"0|. a utility verb for creating a list of boxed pairs of replacement symbols
   g d
┌─┬─┐
│0│9│
├─┼─┤
│1│8│
├─┼─┤
│2│7│
├─┼─┤
│3│6│
├─┼─┤
│4│5│
├─┼─┤
│5│4│
├─┼─┤
│6│3│
├─┼─┤
│7│2│
├─┼─┤
│8│1│
├─┼─┤
│9│0│
└─┴─┘

a=.'' a list to store the result
while.*#y do.a=.a,{.y rplc(g c),(g d),g v while the length of the list is > 0 take a symbol, replace it and append it to the result
y=.|.^:({:a e.v)}.y drop one symbol from the beginning of the list and if the symbol is a vowel, reverse the list
end. ends the while loop
a returns the result

Stax, 24 bytes
╥j•td╢Ä;Sµ*ûⁿvÉ╫î▓J o╩π╗

Run it
Here is the ascii representation of the same program.
VcGVdGVvGwB]qVvs#!Hv*c}cr\$|t

It translates each character class first, then begins a while loop.  In the loop, it outputs the next character, and conditionally reverses the rest of the string if a vowel is encountered.
VcG                             Push lowercase consonants and jump to trailing }
   VdG                          Push digits and jump to trailing }
      VvG                       Push lowercase vowels and jump to trailing }
         wB]qVvs#!Hv*c          While; run this block until popped value is falsy
          B]                    Split first character off string
            q                   Output with no newline; keep on the stack
             Vvs#               1 if letter is a vowel, 0 otherwise
                 !Hv            Not, Double, then Decrement
                                    -1 for vowels, 1 otherwise
                    *           Multiply string. -1 causes reversal
                     c          Copy value to be popped as while condition
                      }         Jump target from above.  Return when done.
                       cr\$     Copy, reverse, zip, and flatten.
                           |t   Translate: use string as a character map
                                    for replacements

Brachylog, 43 39 bytes
hX∧Ḅ;Ṿ,Ị,Ṣ∋C↔;Cz∋[X,H]&{h∈Ṿ&b↔|b}↰↔,H↔|

Try it online!
I only bothered finishing this grand mess because I'm struggling to make Jelly cooperate...

Retina, 78 69 bytes
T`b-df-hj-maed\oup-tv-z`Ro
/[aeiou]/{*>0L`.*?[aeiou]
0`.*?[aeiou]

V`

Try it online! Link includes test cases. Explanation:
T`b-df-hj-maed\oup-tv-z`Ro

Swap each character with its equivalent. The Ro causes the string to transliterate to its reverse. The middle consonant n and vowel i map to themselves so don't need to be listed. The first 10 consonants are listed first and the last 10 last so that they transliterate to each other. The first and last two vowels then surround the digits. (The o is normally special so it has to be quoted here.)
/[aeiou]/{

Repeat while a vowel remains.
*>0L`.*?[aeiou]

Output the text up to the vowel.
0`.*?[aeiou]

Delete the text up to the vowel.
V`

Reverse the remaining text. When there are no vowels left, this is then implicitly output, however for the purposes of the test cases, the header outputs the text at the end of each line.

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


text:
Simulate a model neuron
An Izhikevich neuron is a simple yet quite effective model of a biological neuron, designed for use in a discrete time-stepping simulation. In this golfing challenge, you will be implementing this model.
Parameters
This model involves only 7 variables organized into 2 differential equations, compared to the dozens of parameters of a physiologically accurate model.

v and u are the two state variables of the neuron. Here, v is the "fast" variable representing the cell potential over time, and u is the "slow" variable representing certain membrane properties.  The v variable is the most important one, as this is the output of the simulation.
a, b, c, and d are fixed constants that describe the properties of the neuron.  Different types of neurons have different constants, depending on the desired behavior.  Notably, c is the reset potential, which is the membrane potential the cell returns to after spiking.
I represents the input current to the neuron. In network simulations, this will change over time, but for our purposes we will treat I as a fixed constant.

The Model
This model has very simple pseudocode.  First, we take the constant values of abcd and use them to initialize v and u:
v = c
u = b * c

Next, we loop through the simulation code as many times as desired.  Each iteration represents 1 millisecond of time.
for 1..t:
  if v >= 30:    # reset after a spike
    v = c
    u = u + d
  v += 0.04*v^2 + 5*v + 140 - u + I
  u += a * (b*v - u)
  print v

Certain real-world implementations include additional steps for numerical accuracy, but we aren't including those here.
Input
As input, your program/function should take the values of a, b, c, d, I, and t (the number of time steps to simulate). Once set, none of these parameters will be changing during our simple simulation. The order of input does not matter: you can specify the order in which your program takes these parameters.
Output
Output will be a list of numbers representing the cell's membrane potential (given by variable v) over the course of the simulation.  The list can be in any appropriate format.
You have the choice of whether to include the 0th value of the simulation (the initial configuration before any time has passed) in your output.  For example, for an input of 0.02 0.2 -50 2 10 6 (for a b c d I t), an output of either
-50
-40
-16.04
73.876224
-42.667044096
-25.8262335380956
29.0355029192068

or
-40
-16.04
73.876224
-42.667044096
-25.8262335380956
29.0355029192068

is acceptable.
Your values do not have to be exactly the same as those above, depending on how your language handles floats.
Reference Implementation
Here is a TIO implementation I wrote in Perl to demonstrate the model.  The parameters are that of a "chattering" neuron from the paper linked above, and this serves as a demonstration of how this model is able to recreate some of the more complex properties of neurons, such as alternating between states of high and low activity. If you look at the output, you can see where the neuron immediately spikes several times, but then waits a while before spiking several more times (despite the cell input voltage I being constant the whole time).

Will t ever be negative?

@kamoroso94 No, you can't simulate negative time.

R, 110 99 bytes
Anonymous function that takes 6 arguments. Nothing fancy, just a straightforward port of the reference implementation. The updating of u, v, and the printing of v have all been combined into a single line, thanks to the fact that R's print returns the value that is being printed, so you can use it in assignment. Many thanks to Giuseppe for saving 11 bytes!
pryr::f({v=c;u=b*c;for(i in 1:t){if(v>=30){v=c;u=u+d}
u=a*b*(v=print((.04*v+6)*v+140+I-u))-a*u+u}})

Try it online!

This is great, +1. Although, since you're explicitly labeling the arguments, there's no byte saving between pryr::f() and function(). However, you can, after some experimentation, move v and u's declarations into the function body while preserving the order of arguments, to save a dozen bytes: Try it online!

since v doesn't necessarily take integer values, you do need v>=30, though

@Giuseppe Thanks, those improvements are fantastic. For some reason I hadn't considered not explicitly labeling the arguments...

Clean, 150 145 140 138 bytes
import StdEnv
$a b c d i t=map snd(iterate(\(u,v)#(w,n)=if(30.0<v)(c,u+d)(v,u)
#y=0.04*w*w+6.0*w+140.0-n+i
=(a*b*y-a*n+n,y))(b*c,c))%(0,t)

Try it online!
Defines the function $ :: Real Real Real Real Real Int -> [Real], implementing the algorithm as described in the OP, starting from the 0th term.

Python 2, 100 bytes
a,b,c,d,I,t=input();v=c;u=b*c
exec"if v>=30:v=c;u+=d\nv=v*v/25+6*v+140-u+I;u+=a*(b*v-u);print v\n"*t

Try it online!
Saved 2 bytes thanks to user71546.

@ovs Oops, you’re right. Should be fixed now.

Turning 0.04*v*v to v*v/25. should save 1 byte. If floats are always given for c then v*v/25 suffices for -2 bytes.

@ceilingcat If you take a look at my revision history, you’ll notice that I had v>29 in my initial version. However, that is invalid becuause v is not necessarily an integer.

JavaScript (Node.js), 107 ... 103 101 bytes
Contributed by @apsillers
(a,b,c,d,I,t)=>[...Array(t)].map(_=>(v<30||(v=c,u+=d),v=v*(v/25+6)+140-u+I,u+=a*(b*v-u),v),u=b*(v=c))

Try it online!
Original Approach: 105 103 bytes. -1 byte Thanks Arnauld, and -2 bytes Thanks @Kamoroso94.
(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);console.log(v)}}

Try it online!
Or if popping alerts is OK, then 101 ... 99 97 bytes (-1 byte Thanks Arnauld, -2 bytes Thanks @Kamoroso94):
(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);alert(v)}}

var u, v;
var f =
(a,b,c,d,I,t)=>{for(u=b*(v=c);t--;){v<30||(v=c,u+=d);v=v*(v/25+6)+140-u+I;u+=a*(b*v-u);alert(v)}}

function run() {
 f(...["a", "b", "c", "d", "I", "t"].map(x => document.getElementById(x).value * 1));
}
a = <input id="a" value="0.02">

b = <input id="b" value="0.2">

c = <input id="c" value="-50">

d = <input id="d" value="2">

I = <input id="I" value="10">

t = <input id="t" value="6">

<input type="button" value="Run" onclick="run()">

v>29 is not equivalent to v>=30 for floats. You probably want to do v<30?0:(v=c,u+=d) instead, or better yet v<30||(v=c,u+=d) which saves a byte.

@Arnauld Oh yes, when I looked at the Python answer I realized that I didn't optimize that but I didn't realize that I was processing floats either.;P Fixed.

You can save two bytes by changing t-->0 to simply t--.

You can get this down to 101 by refactoring the for loop into a map operation on an array of length t: (a,b,c,d,I,t)=>[...Array(t)].map(_=>(v<30||(v=c,u+=d),v=v*(v/25+6)+140-u+I,u+=a*(b*v-u),v),u=b*(v=c)). The function returns an array instead of logging values, which appears to satisfy the specification. Doesn't beat the alert solution, though.

Ruby, 94 bytes
->a,b,c,d,i,t{v=c
u=b*c
t.times{v>=30?(v=c;u+=d):0
v+=0.04*v**2+5*v+140-u+i
u+=a*(b*v-u)
p v}}

Try it online!
Another straightforward port of the reference implementation, a lambda accepting 6 arguments.

Haskell, 112 111 bytes
(a#b)c d i t|let r(v,u)|v>=30=r(c,u+d)|p<-0.04*v^2+6*v+140-u+i=(p,u+a*(b*p-u))=fst<$>take t(iterate r$r(c,b*c))

Try it online!
Does not output the zero case. Assumes that c is never >=30 since that wouldn't make sense.
Never thought I'd have to use a where clause in a code golf but there are just too many variables.
EDIT: Thanks @Lynn for taking off a byte! I forgot that you can put let statements in guards. Sure kills the readability though

You can replace the where by the strange f x|let g a=b=y syntax to save a byte: (a#b)c d i t|let r(v,u)|v>=30=r(c,u+d)|p<-0.04*v^2+6*v+140-u+i=(p,u+a*(b*p-u))=fst<$>take t(iterate r$r(c,b*c))

Element, 81 bytes
_a;_b;_3:b~*u;_d;_I;_'[3:\.04*5+*140+u~-+I~++4:\
.`30<!b~*u~-+a~*u~+[d~+]u;[#2:]]

Try it online!, Esolangs page
Explanation:
_a;_b;_3:b~*u;_d;_I;_'[ ... ]

This part of the program takes input.  It stores constants a, b, d, and I into variables.  The input for c is never stored in a variable, but rather remains on the main stack throughout execution. Three copies are made: one on top for initializing u, one in the middle to serve as the initial v, and one on the bottom to serve as the constant c.  The input for t is thrown immediately onto the control stack to serve as the basis of the FOR loop (the [...]) surrounding the rest of the program.
3:\.04*5+*140+u~-+I~++4:

This part of the program takes the current value of v and calculates the new value, and then four copies of the new v value are made.
\
.`

The first copy of v has a newline appended and is printed.
30<!

The second copy of v is used to test if the neuron has spiked.  The result of this test is put on the control stack for later use.
b~*u~-+a~*u~+

This part computes the "delta u", meaning the amount to add to u.
[d~+]

This IF block adds d to the above sum if the neuron is spiking.  This combines what would normally be two assignments into a single assignment.
u;

This stores the updated value of u.
[#2:]

This IF block is a continuation of the above IF block.  If the neuron is spiking, delete the current value of v (which is now on the top of the main stack), and replace it with a duplicate of c (which has been on the bottom of the main stack this entire time).
And that's basically all there is to it.  One minor note is that this thing leaks memory: it takes an extra "# in there to delete the top of the control stack (the evaluated IF condition) after each loop iteration.
Although I wouldn't call Element the most graceful golfing language, this challenge does allow me to showcase an interesting feature: due to the division between the main stack and control stack, I can take an IF statement and split the condition and body into multiple parts, interlaced with unconditional code.

MATLAB, 111 bytes
function z(a,b,c,d,I,t)
v=c;u=b*c;for i=1:t if v>=30 v=c;u=u+d;end
v=.04*v^2+6*v+140-u+I
u=u+a*(b*v-u);
end
end

Pretty simple implementation, can probably be further improved.


text:
Romanize Korean

Yes, It's basically You're a Romanizer, Baby, but harder. like, way harder.

Learning Korean is HARD. at least for a person outside Asia. But they at least have the chance to learn, right?
What you must do
You will be given a Korean Statement. For example, 안녕하세요. You must convert the input to its Roman pronunciation. For the given example, the output can be annyeonghaseyo.
Now it gets technical
A Korean character has three parts, Starting consonant, Vowel, and Ending consonant. The Ending consonant may not exist in the character.
For example, 아 is ㅇ(Starting consonant) and ㅏ(Vowel), and 손 is ㅅ(Starting consonant), ㅗ(Vowel), and ㄴ(Ending consonant).
Evert consonant and vowel has its pronunciation. The pronunciation for each consonant is as following.
Korean                 ㄱ   ㄲ  ㄴ  ㄷ   ㄸ  ㄹ  ㅁ  ㅂ  ㅃ  ㅅ  ㅆ  ㅇ   ㅈ   ㅉ  ㅊ ㅋ  ㅌ   ㅍ  ㅎ
Romanization Starting   g   kk  n   d   tt  r   m   b   pp  s   ss  –   j   jj  ch  k   t   p   h
               Ending   k   k   n   t   –   l   m   p   –   t   t   ng  t   –   t   k   t   p   h

( - means no pronunciation or not used. you do not have to handle them.)
and Pronunciation for each vowels is as following.
Hangul          ㅏ  ㅐ  ㅑ  ㅒ   ㅓ  ㅔ  ㅕ  ㅖ  ㅗ   ㅘ   ㅙ  ㅚ ㅛ  ㅜ  ㅝ  ㅞ  ㅟ   ㅠ  ㅡ   ㅢ ㅣ
Romanization    a   ae  ya  yae eo  e   yeo ye  o   wa  wae oe  yo  u   wo  we  wi  yu  eu  ui  i

Now its the real hard part
The consonant's pronunciation changes by the Ending consonant in before. The pronunciation for every Starting/Ending consonant is as the following image.
(You do not have to do the hyphen between pronunciations. Its unnecessary. If a cell has two or more pronunciations, choose one. If there's no ending consonant, use the original pronunciation.)
Examples
Korean => English
안녕하세요 => annyeonghaseyo
나랏말싸미 듕귁에달아 => naranmalssami dyunggwigedara  //See how the ㅅ in 랏 changes from 't' to 'n'

Example suggestion welcomed. You can get answers for your own inputs here. (The one in "General text", Revised is what I'm asking for)

Will the input always consist of Unicode characters AC00-D7AF + space?

There are several special ㅎ + X combinations which are not highlighted in yellow (e.g. ㅎ+ ㅈ = ch). Does that mean that we don't have to support them? (Also, ㅎ is 'romanized' as t instead of h in the picture, which is a bit confusing.)

Test cases: https://gist.github.com/perey/563282f8d62c2292d11aabcde0b94d2d As @Arnauld says, there are some oddities in the special combinations; this has tests for all of the ones I found in the table, whether highlighted or not. Where multiple options exist, they are space-separated. No hyphens are used as I expect people to golf them out.

I don't see "General text" in your suggested output-checking link; do you mean "General things"? If so, which one of the three should we use (Revised, McCune, Yale)? None seem to match your table; for example, ㅈ followed by ㄹ should be "nn" according to you but is "tr" or "cl" at that link. (Note that my test cases in the previous comment are based on transliterations in the question!)

ㅎ followed by ㄱ, ㄷ, ㅈ are also special cases (they become aspirated to ㅋ, ㅌ, ㅈ (k, t, j) ) should highlight those too.

As a Korean myself, I like to see Korean-related challenges. But it's kinda sad that double final consonants aren't considered in this challenge...

@JungHwanMin I could (As I am a Korean myself too), but that would only complicate things more. :P

@JungHwanMin Also It's already highlighted in the image.

@lol doesn't seem like it: (for instance ㅎ then ㄱ makes k, but that's not highlighted)

Python 3.6, 400 394 bytes
Edit: Thanks to RootTwo for -6 bytes.
This is my first submission on CodeGolf, so I'm pretty sure there are better ways to golf it, but I thought I'd still post it, as nobody has mentioned the key idea yet, and this is still significantly shorter than other solutions.
import re,unicodedata as u
t='-'.join(u.name(i)[16:]for i in input()).lower()
for i in range(19):t=re.sub('h-[gdb]|(?<!n)([gdbsjc]+)(?!\\1)(?!-?[aeiouyw]) gg dd bb -- - h(?=[nmrcktp])|hh hj l(?=[aeiouyw]) l[nr] [nt][nr] tm pm [pm][nr] km kn|kr|ngr c yi weo'.split()[i],([lambda m:'ktpttt'['gdbsjc'.index(m[0][-1])]]+'kk,tt,pp, ,,t,c,r,ll,nn,nm,mm,mn,ngm,ngn,ch,ui,wo'.split(","))[i],t)
print(t)

How it works
The solution attempts to exploit the fact (which I learned from the original Japanese romanization challenge) that romanized character names are accessible through Python's unicodedata module. For Korean language, they take the form of HANGUL SYLLABLE <NAME>. Unfortunately, processing these names to meet the provided specification and to cover all the syllable combination scenarios still requires quite a bit of effort (and bytes).
The obtained character names list all consonants in their voiced form anywhere in the syllable, e.g. GGAGG for 깎, R/L are transcribed as intended (starting R, ending L), and CH is given as C (this actually saves us a bit of headache).
First of all, we strip off the HANGUL SYLLABLE part (first 16 chars), mark the syllable boundaries with -, and then apply a series of RegEx'es to do the conversions.
The first RegEx looks particularly nasty. What it basically does, is conversion of starting consonants into their ending equivalents (also removing the extra letter in case of double consonants), when they are not followed by a vowel, or for some letters - when they are preceded by h. The (?<!n) lookbehind prevents matching g which is part of ng, and (?!\\1) lookahead ensures that we don't convert, e.g., ssa to tsa.
The next few RegEx'es convert starting double consonants into their unvoiced equivalents. Here's where - separators also come in handy as they help discerning boundary collisions (g-g) from double consonants (gg). Now they can also be removed.
Next, we handle the remaining h+consonant combinations, l->r before vowels, and other special cases.
Finally, we restore c to ch, and resolve some other pecularities of our incoming char names, such as yi instead of ui and weo instead of wo.
I'm not an expert in Korean and can't comment much more, but this seems to pass all the tests posted in the task and on Github.
Obviously, a few more bytes could be shaved off, if the output is acceptable in uppercase, as this is what we get from the name function.

Welcome to PPCG! Great first answer.

Nice answer.  As of python 3.6, m[0] is the same as m.group(0); saving 6 bytes.

JavaScript (ES6), 480 bytes (WIP)
This is an early attempt based on the current specs to get the ball rolling. It may require some fixing when the questions in the comments are addressed.
s=>[...s].map(c=>c<'!'?c:(u=c.charCodeAt()-44032,y='1478ghjlmnpr'.search((p=t).toString(36)),t=u%28,u=u/28|0,v=u%21,x=[2,5,6,11,18].indexOf(u=u/21|0),~x&~y&&(z=parseInt(V[y+68][x],36))>10?V[z+69]:V[p+40]+V[u+21])+V[v],t=0,V='8a6y8ye6e46ye4y64w8wa6o6y4u/w4w6wi/yu/eu/ui/i/g/k21d/t7r/3b/p0s/ss95j5ch/270h922/197l999930/77ng/77270h/bbcd6afaa8gghi5ffak8alaa8llmn4gghp8abaa8gghq5gghr5ggha5gghs8ng1ng3g/2ll/n1n3d/7r/m1m3b/0s/5ch/h'.replace(/\d/g,n=>'pnkmojeta/'[n]+'/').split`/`).join``

Test cases

let f =

s=>[...s].map(c=>c<'!'?c:(u=c.charCodeAt()-44032,y='1478ghjlmnpr'.search((p=t).toString(36)),t=u%28,u=u/28|0,v=u%21,x=[2,5,6,11,18].indexOf(u=u/21|0),~x&~y&&(z=parseInt(V[y+68][x],36))>10?V[z+69]:V[p+40]+V[u+21])+V[v],t=0,V='8a6y8ye6e46ye4y64w8wa6o6y4u/w4w6wi/yu/eu/ui/i/g/k21d/t7r/3b/p0s/ss95j5ch/270h922/197l999930/77ng/77270h/bbcd6afaa8gghi5ffak8alaa8llmn4gghp8abaa8gghq5gghr5ggha5gghs8ng1ng3g/2ll/n1n3d/7r/m1m3b/0s/5ch/h'.replace(/\d/g,n=>'pnkmojeta/'[n]+'/').split`/`).join``

console.log(f("안녕하세요"))
console.log(f("나랏말싸미 듕귁에달아"))

How?
Once decompressed, the array V contains the following data:
00-20 vowels
a/ae/ya/yee/eo/e/yeo/ye/o/wa/wae/oe/yo/u/wo/we/wi/yu/eu/ui/i

21-39 starting consonants
g/kk/n/d/tt/r/m/b/pp/s/ss//j/jj/ch/k/t/p/h

40-67 ending consonants
/k/k//n///t/l////////m/p//t/t/ng/t/t/k/t/p/h

68-79 indices of substitution patterns for consecutive consonants
      ('a' = no substitution, 'b' = pattern #0, 'c' = pattern #1, etc.)
bbcde/afaaa/gghij/ffaka/alaaa/llmno/gghpa/abaaa/gghqj/gghrj/gghaj/gghsa

80-97 substitution patterns
ngn/ngm/g/k/ll/nn/nm/d/t/r/mn/mm/b/p/s/j/ch/h

We split each Hangul character into starting consonant, vowel and ending consonant. We append to the result:

V[80 + substitution] + V[vowel] if there's a substitution
V[40 + previousEndingConsonant] + V[21 + startingConsonant] + V[vowel] otherwise

Can '!' not be 33?

@JonathanFrech c is not a byte. It's a 1-character string. That said, when applying an arithmetic operation, a space is coerced to 0 while other non-digit characters are coerced to NaN. Which means that c<1 should actually worked as expected. (And c<33 would also work for non-digit characters, although this is kind of fortuitous.)

@JonathanFrech Addendum: c<1 would also be truthy for "0" (which is probably OK if the input is guaranteed not to contain any Arabic numeral.)

Thanks. I did not think that JavaScript would have characters implemented as a single byte, though tried nonetheless. It, however, seemed to work. Glad to now know why.

Tcl, 529 bytes
fconfigure stdin -en utf-8
foreach c [split [read stdin] {}] {scan $c %c n
if {$n < 256} {append s $c} {incr n -44032
append s [string index gKndTrmbPsS-jJCktph [expr $n/588]][lindex {a ae ya yae eo e yeo ye o wa wae oe yo u wo we wi yu eu ui i} [expr $n%588/28]][string index -Ak-n--tl-------mp-BGQDEkFph [expr $n%28]]}}
puts [string map {nr nn
A- g An ngn Ar ngn Am ngm A kk
t- d p- b B- s D- j
nr ll l- r ln ll lr ll
A k B t G t D t E t F t
K kk T tt P pp S ss J jj C ch Q ng
- ""} [regsub -all -- {[tpBDEFh]([nrm])} $s n\\1]]

Algorithm

Decomposition into lead, vowel, and tail indices
First lookup to intermediate alphabetic representation
Apply an initial pass for all the xn→nn/xm→nm transforms
Apply a final pass for the remaining transforms

This algorithm is crunched for purposes of the challenge; the trade-off being that the input is assumed to not contain any Latin alphabetic characters, nor to use characters outside the U+AC00 Hangul block as described in the challenge. Were this real code, I'd keep all the transforms in Jamo until the final pass.
I suppose I could throw some more brainpower at crunching those vowels and some of the repetitions in the lookup table, but this is as good as it gets from me today.
Testing
Make sure you can supply UTF-8 input to the Tcl interpreter. This is most easily accomplished with a simple UTF-8 text file. Alas, Tcl still does not default to UTF-8 by default; this cost me 33 bytes.
Here’s my (currently pathetic) test file:
한
안녕하세요
나랏말싸미 듕귁에달아

Notes
I know nothing about Korean language (except what little I have learned here). This is a first attempt, pending potential revision due to updates in the question specification.
And, about that, some additional information is useful. In particular, there is not a 1:1 correspondence between lead and tail consonants as seems to be suggested in the challenge. The following two sites helped immensely figuring that out:
  • Wikipedia: Korean language, Hangul
  • Wikipedia: Hangul Jamo (Unicode block)


text:
Selling electricity
Jack is a little businessman. He found out a way to earn money by buying electricity on days when it's cheap and selling it when it's much more expensive. He stores the electricity in a battery he made by himself.
Challenge
You are given N (if required), the number of days Jack knows the cost of electricity for, and X, the amount of money Jack has available to invest in electricity, and the value(buy/sell value) of the electricity for N days. Your job is to determine when Jack should buy and when he should sell electricity in order to earn as much money as possible and simply print the largest possible sum of money he could have afterwards.
The value of the electricity is always a positive integer but depending on the amount of money Jack has, the amount of electricity and money he has may be floating point numbers.
Examples
(I/O need not be exactly as shown):
1.
4 10
4 10 5 20

Output: 100
- because he buys electricity on the 1st day and the sells it on the 2nd and buys it on the 3rd and sells it on the 4th day.
2.
3 21
10 8 3

Output: 21
- because it's better if he doesn't buy/sell any electricity.
3.
3 10
8 10 14

Output: 17.5
- because he buys electricity on the 1st day, but he sells it on the 3rd day.
4.
5 10
4 2 10 5 20

Output: 200
- much like example 1, but this time Jack waits for the price to drop to 2 before making a purchase.

The program with the shortest amount of code wins! This is a code golf problem.
Note:You can shorten the input, as long as it still makes sense.

Is this code golf?

Yes, yes it is.

Do we have to take the input exactly as described (N X on line 1, everything else on line 2) or can we use any reasonable format?

You can use any reasonable format.

Please edit that clarification into your question.

By "earn" do you mean his final amount of money? (that is I think 4 10 and 4 10 5 20 only earns 90, not 100)

What's the point of taking N as input if it's simply the length of the list of days?

Also, how does John buy at 8, sell at 14 and end up earning 17.5? Surely he's earned 6 there?

@Shaggy He spends his 10 buying at 8 storing 1.25 units which he sells at 14 for 17.5 (14*1.25). (He nets 7.5, but "earns" 17.5. See my comment above)

If this is not your own problem please do provide its source.

@JonathanAllan The price is never less than 1 because they're always integers.

Yes, sorry for the imprecision!

@JonathanAllan, It's all great! Thank you for your help and enthusiasm regarding this problem!

Can you give a reference implementation? I don't quite get the specs.

I suggest not accepting any answers. The +2 is not that important.

Husk, 7 bytes
Π:mY1Ẋ/

Try it online!
How?
Π:mY1Ẋ/ – Full program.
     Ẋ  – For each pair of adjacent elements from the input list...
      / – ... Divide the second by the first.
  m     – For each quotient...
   Y1   – ... Get the maximum between it and 1.
 :      – Append the second input.
Π       – Get the product of the resulting list.

Jelly,  8  7 bytes
-1 byte thanks to Mr. Xcoder (use the Ɲ quick which performs 2\)
÷@Ɲ»1P×

A dyadic link taking a list of the prices on the left and the initial capital on the right which returns the maximal capital.
Try it online! or see the test-suite.
How?
Jack can sell every day on which the preceding day had a lower price and buy on those days (even if it is one on which he sold). When he does so his capital increases by priceToday ÷ priceYesterday, such gains multiply his initial capital, while any time the price falls he may simply forego the loss and multiply his capital by 1 instead by not transacting.
÷@Ɲ»1P× - Link: list, prices; number, initial capital  e.g. [4,2,10,5,20], 10
  Ɲ     - pairwise overlapping reduce left (prices) by:
÷@      -   division with swapped arguments                 [0.5,5,0.5,4]
    1   - literal one                                       1
   »    - maximum (vectorises)                              [1,5,1,4]
     P  - product                                           20
      × - multiply by right (initial capital)               200

2\ can be replaced by Ɲ.

Oh I forgot about that one, thanks!

Coconut, 51 45 bytes
thanks to @totallyhuman for -5 bytes
d->m->reduce((*),map(max$(1)..(/),d[1:],d))*m

Try it online!
Uses Jonathan Allan's algorithm.
Coconut extends Python with several functional programming constructs.
d->m->                      lambda function taking two arguments, money and prices, in currying syntax

    reduce((*),              product of...
           map(               map
               max$(1)..(/),   (x,y)->max(1, x/y)
                              over
               d[1:],d         consecutive pairs of prices
               )
          )*m                multiply with the initial money

46 bytes.

@totallyhuman thanks a lot, I wasn't aware that the behaviour of map differs between Python 2 and 3.

Haskell, 41 bytes
l#n=foldr((*).max 1)n$zipWith(/)(tail l)l

Try it online!

Stax, 21 20 bytes
àq'4¢<╪╦ÉdεÖ!≤♠┬☻∟In

Run it
This is the ascii representation of the same program:
c|)s\Dc{|Mms{hm\{E:_m:**

I'm sure there is room for golfing here, but I wanted to give Stax a spin. Here's the breakdown.
                            Input stack: initial funds, array of prices
c                           Copy the array of prices
 |)                         Rotate the top copy one place right
   s                        Swap the two arrays on the main stack
    \                       Zip the arrays to get consecutive price pairs
     D                      Drop the first pair (don't need [price N, price 1])
      c                     Copy the result
       {|Mm                 Map max: Keep only the max of each pair (copy 1)
           s                Swap copy 1 and copy 2 on the main stack
            {hm             Map first: Keep only the first of each pair (copy 2)
               \            Zip copy 1 and copy 2
                {E:_m       Map explode, divide: Transform pairs with float division
                     :*     Array product: Multiply all resulting quotients
                       *    Multiply by other input (initial funds)

Perl, 37 bytes
Includes +4 for -ap
On STDIN first give a line with the list of prices, then a line with the starting capital
electricity.pl:
#!/usr/bin/perl -ap
$\=<>;s%\d+%$\*=$&>$'||$'/$&%eg}{

You can then for example run it as:
(echo 4 2 10 5 20; echo 10) | electricity.pl; echo

05AB1E, 9 bytes
Rü/εXM}P*

Try it online!
Uses the same method as in Jonathan Allan's Jelly answer
Explanation
R           # reverse input list of buy/sell values
 ü/         # pairwise division
   εXM}     # max of each element and 1
       P    # product
        *   # multiply by initial capital

Ruby, 57 bytes
->a,x{x*a.each_cons(2).map{|t|t.max*1.0/t[0]}.reduce(:*)}

Try it online!
A lambda taking an array of prices a and the starting capital x. The most interesting thing I found here is that it's faster to treat the pairs of prices as a tuple t, whereas my first instinct was .map{|n,m|[m,n].max*1.0/m}.
->a,x{
  x *                       # Multiply the starting capital by...
  a.each_cons(2).map{ |t|   # For each consecutive pair of prices
    t.max*1.0 / t[0]        # The larger of that pair, divided by the first
  }.reduce(:*)              # All multiplied together
}


text:
John's lost arrays
John has made an array of numbers which are important to him. Unfortunately, John lost the array.
Luckily, he knows some details about the array. You will receive each of these sets of details (which are lists of 3 integers).
Each detail is the sum of a section of the list. Each has the numbers a, the starting index of the sum, b, the ending index of the array's sum, and c, which is 1 if the sum is positive and -1 if the sum is negative.
Your job is to find an array that matches the given details and to print them out, or to print -1 if no such array exists.
Example Input: (0-indexed and inclusive)
[0, 1, 1]
[1, 2, -1]

Output:
[-1, 2, -3]

The details here require that the sum from 0 to 1 is positive, and from 1 to 2 is negative.  You can output any array that matches.
You can take the input in any reasonable format.
Whoever writes the shortest program wins! This is a code golf problem.

What are the scoring rules?

I recommend getting your previous challenge reopened before posting a new one. You might also want to give the sandbox a try, instead of directly posting questions on main.

@Dennis beat me to it; sort out your other challenge first before posting a new one.

Don't make the I/O format so strict

If this is not your own problem please do provide its source.

I've edited this to make it more clear and to make the i/o format less strict. Most languages don't require those extra details about how many lines of details there are, so I've removed that.  In addition, challenges like this work best with only one 'test case' per input, so I've removed that as well.

Please don't roll-back the edit entirely, but feel free to edit some things as you see fit.

@Riker Multiple test cases as input and their number as the first line is a strong indication the challenge is missing some attribution, although, as always, you can't be 100% sure that's the case.

Seriously, I hate misformatted questions/answers (as that implies the posters being lazy) so please format the post carefully. Especially use the preview part to see if the post is rendered properly. I see a lot of (bad) StackOverflow questions and your challenges seems like one of them.

@EriktheOutgolfer I noticed that too, but somebody else already pointed that out.

It is not clear about the case when the sum is zero.

Perl, 101 bytes
Includes +7 for -0pF\n
lost_array.pl:
#!/usr/bin/perl -0pF\n
$_="@G"x!grep{$a=!/ \d+ /;grep{$_+=$`if$`^$a<=>0}grep{$a+=$_;1}@G[$&+0..$']}@F until$n{"@G"}++

Input triples on seperate lines on STDIN in the order sign from to
Outputs either a valid assignment or nothing. don't care positions in the output array are left empty (noticable as consecutive spaces). So for example:
(echo 1 0 1; echo -1 1 2) | lost_array.pl; echo

outputs
1 0 -1

This is way too long and I'm not even sure it is correct, but it's the best I could immediately think of.
For all given ranges it calculates the sum and if the sign isn't right adds the sign to all values in the range to make the sum better. It stops as soon as it detects that the array of values is repeated. If no value update was done during the last loop this is a solution and it is printed. Otherwise no solution is possible and nothing gets printed

I think it's correct, but it would be great if you could add an explanation of the code, not just how you did it.