text:
Roman Numeral Counting
Roman numerals can be (mostly) written in a one column format, because each letter intersects the top and the bottom of the line. For example: I, or 1 intersects both the top and bottom of the line, and V or 5 intersects the bottom and top lines, the top twice and the bottom at one place.
The value of all roman numerals is as follows:
I = 1
V = 5
X = 10
L = 50
C = 100
D = 500
M = 1000
and the number of intersections (top, bottom) is:
I = 1,1
V = 2,1
X = 2,2
L = 1,2
C = 1,1
D = 1,1
M = 2,3
Your job is to take in 2 numbers, which represent the number of intersections on the top and bottom of your line (in that order), and output all possible valid combinations of roman numerals, from smallest by literal value to largest. Inputs will always be at or above 1.
Here are some test cases:
Input: 1,1
Output: I,C,D

Input: 1,2
Output: L

Input: 2,1
Output: V

Input: 2,2
Output: II, X, IC, CI, CC, ID, DI
(note that DD is not a valid roman numeral, and thus should not be outputted, the value of all of these is (in order) 2, 10, 99, 101, 499, 501)

Input: 3,3
Output: III, IX, XI, LV, XC, CII, CX, CCI, CCC, DII, DX, DCI, DCC
(note that IIC, and IID are not valid numbers. DD (1000) is also not a valid number, as the correct numeral is M) The value of these numbers (in order) is: 3, 9, 11, 55, 90, 102, 110, 201, 300, 502, 510, and 601)

This is a usual code-golf, and needless to say, I'm interested to see how golf languages implement roman numeral counting rules. Best of luck!

Would you be able to add the counting rules?

+1 Looks interesting

Well written but upvoted mainly for sheer oddness of the challenge.

The last test case appears to be missing DCC. I wouldn't mind answering this question if it stuck to standard Roman numerals, where e.g. the last test case would only be III IX XI LV XC CII CX CCI CCC CDI DII DX DCI DCC.

Because 45 is written as XLV instead.

@Neil My Bad. I've fixed it

IC,  ID are not valid roman numerals.

https://projecteuler.net/about=roman_numerals

I think the last two answers should be 2,2 => II X CI CC CD DI DC and 3,3 => III IX XI LV XC CII CX CCI CCC CDI DII DX DCI DCC as IC and ID are not a valid roman numbers but CDI=401 is. Otherwise, this was a great puzzle.

How exactly does an L intersect the bottom line twice?

05AB1E, 32 29 25 bytes
žDL.Xʒ•BÌË"•4в2ôsÇ87%èøOQ

-7 bytes thanks to @Grimy.
Try it online or verify all test cases.
Explanation:
žD                # Push builtin 4096 (the maximum Roman number is 3999)
  L               # Create a list in the range [1,4096]
   .X             # Convert each integer to a Roman number
     ʒ            # Filter this list by:
      •BÌË"•     "#  Push compressed integer 195646806
            4в    #  Convert it to base-4 as list: [2,3,2,2,2,1,1,1,1,1,1,1,1,2]
              2ô  #  Split it into parts of size 2:
                  #   [[2,3],[2,2],[2,1],[1,1],[1,1],[1,1],[1,2]]
      s           #  Swap to get the current Roman number we're filtering on
       Ç          #  Convert its characters to their unicode values
        87%       #  Take modulo-87 for each (I=73; V=86; X=1; L=76; C=67; D=68; M=77)
           è      #  Index those into the list of pairs (with automatic wrap-around)
            ø     #  Zip/transpose; so we have inner lists of top/bottom values
             O    #  Sum each inner list
              Q   #  And check if it's equal to the (implicit) input-pair
                  # (after the filter, the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •BÌË"• is 195646806 and •BÌË"•4в is [2,3,2,2,2,1,1,1,1,1,1,1,1,2].

-2 by using the dictionary (either mild or divx works). -1 by using r once instead of s twice. TIO.

@Grimmy Thanks! I tried a triple swap, but in that case I was needing two of them. Didn't think about reverse stack.. >.> And thanks for the dictionary string.

25

@Grimmy Ah, nice find.

My first try on Code Golf, please point out some optimizations!
Python 3.7, 465 449 364 363 284 Bytes
Edit: Thanks for the improvements!
Jo King managed to squeeze this logic from 449 to just 364 bytes,
I took a single Byte off it so I felt justified to update it. :D
Description of the old function, which remains can still be found in the code:
To formulate all numerals with certain amount (a and b) of cross points, m() subtracts number of cross points of every numeral from a and b, and recursively calls the function again for every case. If a and b are negative when called, the function exits, and if both are zero, the next function checks if it is a valid roman number, and prints accordingly.
To check if a character string is a roman number, t(c) checks if there are any 4 characters in a row, or two in the case of 50 and 500. It then checks for the possible subtraction numeral before any numeral (The possible subtraction roman numeral is either 2 or 1 positions after the real roman numeral in the list of 'MDCLXVI', depending on the parity of the roman numerals index on that list!) If any are found, they are replaced for the next part as with just the real numeral, without the subtraction numeral. SUB-NBR-SUB sandwiches, like IVI are falsified. The next part just checks if the list is ordered.
def m(c,i,a=''):
 d,e,s,*p=a,c|i,str,2,3,*[1]*5,*[2]*4,1,1,1
 for x in range(7):c+i>0==m(c-p[x*2],i-p[x*2+1],a+s(x));e|=any(s(z)in d for z in[s(x)*4,11,33,f"{x+~x%2+1}{x}{x+~x%2+1}"]);d=d.replace(s(x+~x%2+1)+s(x),s(x))
 e or[*d]==sorted(d)==print(''.join('MDCLXVI'[int(x)]for x in a))

Welcome to PPCG! To save some bytes, (a,b)==(0,0) -> a==b==0, return(1) -> return 1, input("") -> input(), and you can save str as s=str at the beginning and use it as s(x) later.

Wow, Jo. Thanks a lot. Learned a ton. Also managed to pop one byte off your solution so the code is now updated :D

284 bytes with some stuff I missed earlier. Feel free to use it even if you can't golf more (though you should be able to)

Cool. I couldn't make it any shorter but now the 2nd row now spells despacito

Perl 5, 230 213 bytes
sub f{grep{($t,$b)=@_;map{($h='I1V21X2L12C1D1M23')=~/$_(.)(\d?)/;$t-=$1;$b-=$2||$1}/./g;!$t&&!$b}map{$r='I'x$_;for(qw(IVX XLC CDM)){($I,$V,$X)=/./g;$r=~s,$I{4}($I?),$1?$V:$I.$V,ge;$r=~s,$V($I?)$V,$1$X,g}$r}1..4e3}

Try it online!
With spaces and newlines added for readability:
sub f{
  grep{
    ($t,$b)=@_;
    map{
      ($h='I1V21X2L12C1D1M23')=~/$_(.)(\d?)/;
      $t-=$1;
      $b-=$2||$1
    }
    /./g;
    !$t&&!$b
  }
  map{
    $r = 'I' x $_;
    for( qw(IVX XLC CDM) ){
      ($I,$V,$X) = /./g;
      $r =~ s,$I{4}($I?),$1?$V:$I.$V,ge;
      $r =~ s,$V($I?)$V,$1$X,g
    }
    $r
  }
  1..4e3
}

The map at the end turns all integers 1 – 4000 into their roman equivalent. Since there is no letter for 5000 and 10000 and so on, it's reasonable to say that the maximum roman number is 3999=MMMCMXCIX. (One could just add more M's to get larger numbers, if so, just increase 4e3 here to whatever time you have to wait for the result...this is code golf where we optimize for code length, not runtime:)
The grep filters that list so that only the ones with the wanted input $t (top) and $b (bottom) numbers are returned. The maps inside grep decreases $t and $b by the right amount of "intersections" for each roman letter and the grep ends up being true for each roman number by !$t&&!$b if both  $t and $b are zero (which means they started as the numbers we wanted in the input parameters).

Charcoal, 144 97 bytes
ＮθＮηΦＥ×φθ⁺×M÷ιφ⮌⭆⪪”{⧴9i…⪫χM⎚GＯWbπ↗sＰ÷n“<BÞＤ‴!w≡θ⟧Ｌ≡§Ａ≦Ｉ⍘∨Φ…ok”²⁹§⪪λ ÷ιＸχμ∧⁼θΣＥι⊕№VXMλ⁼ηΣＥι⊕№LXMMλ

Try it online! Link is to verbose version of code. Explanation:
ＮθＮη

Input the two values.
ΦＥ×φθ

Loop up to 1000 times the first number, which is well past the largest valid Roman numeral, keeping only those that satisfy the validity of both the top and bottom intersections (according to the condition at the end of the code).
⁺×M÷ιφ⮌⭆⪪”{⧴9i…⪫χM⎚GＯWbπ↗sＰ÷n“<BÞＤ‴!w≡θ⟧Ｌ≡§Ａ≦Ｉ⍘∨Φ…ok”²⁹§⪪λ ÷ιＸχμ

The compressed string expands to I II III VI V IV IIV IIIV XI X XX XXX LX L XL XXL XXXL CX C CC CCC DC D CD CCD CCCD MC. This is used to calculate the Roman numeral in reverse, working from the units up to the 100s, and then the reverse is concatenated to any further Ms needed.
∧⁼θΣＥι⊕№VXMλ⁼ηΣＥι⊕№LXMMλ

For each Roman numeral, count the number of times each letter thereof appears in the strings VXM and LXMM respectively, then add one for each letter, and compare the totals to the inputs.

TIO link still says 144 bytes. Also, question is ambiguous, but IIII and IV are both valid Roman numerals that express 4.

@NickKennedy Thanks, I've updated the TIO link now.

Jelly, 129 bytes
ŒṗŒ!€ẎQ)p/ẈE$ƇZ€“(³l’ḃ9¤ḃ3¤ẹⱮŒpƊ€ẎŒgQ€QƑƊƇḂÐḟQƑ$ƇI<1kƲ€ḂḢ€ạẈƲỊẠƊƇIFṀ<ʋƇ3ị“¢¦½2d‘;.ȷ,ȷ¤ạ/€€S€Ụf<ƇS<ɗⱮ⁵*Ɱ3¤ẠaNÞƑƲ€T$ƲƊị$ị“IVXLCDM”K

Try it online!
A full program taking a pair of integers as its argument and printing to STDOUT a space-separated list of Roman numerals. Should produce all valid Roman numerals following the rules on Project Euler (so VIIII, IX and IIIIIIIII are all valid forms for 9, but VIV is not, and X is the only valid form for 10.)

how did you learned this language?

@rsonx From the GitHub page linked above and reading answers from people like JonathanAllan

@rsonx If you want to learn it, check out Jelly Hypertraining :)

@Bubbler how do you join?

@NickKennedy Go to the chat room and click the "request access" button.

Jelly, 61 bytes
1xⱮ4Ḷ¤$Ø½ṭ;2;Ɱ$Ʋ1,3ṭ+þ3Ḥ€Ż¤ṚŒpḣ4ȷF€ị“(³l’ḃ9¤ḃ3¤S⁼ɗƇị“IVXLCDM”

Try it online!
This monadic link takes a pair of integers as its argument and returns a list of strings representing the Roman numerals. Unlike my other Jelly answer, this one only uses the minimal (canonical?) representation of each Roman numeral, so it’s more straightforward to generate a list of all Roman numerals in order and filter them. It only generates Roman numerals up to 3999, but could be adapted to work for higher Roman numerals if needed. L


text:
Quine in Bytes, not Characters
Introduction
A quine is a program that takes no input and produces a copy of its own source code as output. Writing a quine is a standard test of a programming language. Most quines operate using strings of characters: that is what the source code is made of, after all! However, this quine is slightly different.
Challenge
Your challenge is to write a program that takes no input and produces the number of bytes in the program as output.

By "takes no input", I mean does not change based on input. Your program can still take command line arguments, or even arguments from stdin, but it cannot do anything with them. It must either discard or ignore them. Basically, your program should produce the same output no matter what input is given.
Your program must output the number of bytes in it. If it is a function, it can output through its return value. If, and only if your language has no stdout, you may store output in a variable. The input can be printed as a string or an integer; the user cannot tell the difference between the output of print('5') or print(5)! Note that I said byte count, not character count. If your program uses Unicode characters that take up more than 1 byte (like some Jelly or APL programs), the output must reflect that.

Rules
This is code-golf so shortest answer in bytes wins! Edit: Actually, since there is a 1 byte answer, let's do top 3 shortest.
Edit: this question is not the same as Output your Score. For one, this one does not disallow cheating quines. Also, I do not require a trailing " bytes" in output.

Does this have to meet standard Quine rules? For instance, 1 in Jelly is 1 byte long, and would output 1, is that acceptable?

@caird coinheringaahing - you do not have to follow standard rules. In this challenge, if it doesn't say you can't, assume you can.

When you say "byte count", do you mean UTF-8 byte count, or can we use our own encodings? For instance, if ¬ outputs 1, and is encoded as a single byte in our code page, would that be an acceptable answer?

No. A said in the answer, Unicode/UTF-8 byte counts are used.

Possible duplicate of Output your score

Characters in languages with SBCS do take up only one byte, so I don't see the point of penalising them for what character they use (which seems to be the opposite of what you want)

@JoKing pppery I would say this challenge is sufficiently different, given that the other is restricted-source.

My biggest problem with calling this a duplicate is that my answer here meets this challenge. No way it meets the other challenge. It's not even possible. The same might be true for many, if not most, of the other answers here. That doesn't feel right somehow....

Most languages, 0 bytes

Try it online!
Outputs via exit code, which is 0 for almost any language where an empty program is valid.

Just realised that my Jelly answer could be golfed to this :/ I'll leave it to avoid duplicate answers though

Not necessarily. In C it will be unable to find an entry symbol and the compile or link operation will fail.

@rsonx Well yes, the empty program isn't valid in C...

"If it is a function, it can output through its return value". This is not a function

@JBernardo Yes? I never claimed it was a function. As stated, this is a full program that outputs via exit code.

Poetic, 87 86 bytes
-1 byte due to a slightly better representation of the character "8".
hey-o
i guess i got a number i can write
an apple a day keeps doctors away, we suppose

Try it online!
Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
I couldn't resist making the word-lengths spell out a popular phrase, hehe.  ⚕

Jelly, 1 byte
1

Try it online!
This probably works in a lot of other languages as well. Note that the output does not have a trailing newline

Polyglot with Keg and Carrot obviously.

@A_ And probably 05AB1E, Gaia, Deorst, or almost other golfing languages :P

It even works in PHP

Python 2, 7 bytes
print 7

Try it online!

For Python 3, both print(8) and lambda:8 come out at 8 bytes.

Keg, 2 bytes
2#

Try it online!
Not a duplicate, and this should hopefully clinch me 3rd place :)

Perl 5 -p, 4 bytes
$_=4

Try it online!

Ruby, 3 bytes
Probably one of the only times Ruby can beat Perl in bytes.
p 3

Try it online!

JavaScript, 4 bytes
Boring!
_=>4

Try it Online!

brainfuck, 20 bytes
-[>+<-----]>-.--.kek

Try it online!

MathGolf, 1 byte
╧

Try it online!
Explanation
╧  On the empty stack, pop a,b, push a.contains(b)
   0 definitely contains 0, pushing a 1.

Implicit output

MathGolf, 1 byte
)

Try it online!
Explanation
) Increment this 0 value on the stack, returning a 1.

MathGolf, 1 byte
=

Try it online!
Explanation
= Check equality of 0 and 0, returns 1.

Retina 0.8.2, 1 byte
^

Try it online! In Retina, the empty program outputs 1 more than the length of its input, which is bad here, since we don't want the output to depend on the input. Fortunately, either ^ or $ help here, as they force the output to be 1, which is conveniently also their length.

HQ9+, 1 byte
+

This language does not allow you to write a program that prints only one number. Therefore, I save the number of bytes in a special counter.
HQ9+ online interpreter

Metatape, 22 bytes
@a{ooxooeooxoeo} !a !a

The space characters are not syntactically necessary, but they take up less space than it would to output 21 or 20.
@a{...} defines a subroutine named a, and !a executes that subroutine.
Output is bitwise (highest bit first). While the actual language is more complicated, for the sake of this program:

x makes subsequent os output 1.
e makes subsequent os output 0.

Haskell, 5 bytes
f a=5

Try it online!

Err... That's neither a function nor an action. Is this allowed?

Not sure, changed it to be safe.

You could maybe argue that f=3 was a function that takes no arguments

R, 6 bytes
cat(6)

Try it online!
(Note that Jo King's 0 byte answer is also valid in R.)

Bash, 6 bytes
echo 6

Try it online!

Japt -F0, 0 bytes
Try it
This can be my first 0 bytes answer!
Using -F"0" flag => outputs 0 if the programme returns a falsey  value

You can golf that flag to -F0! But note, as it says in the docs, many will consider the -Ex & -Fx flags to be "cheating". This, though, I'd say is a more borderline case.

@Shaggy yes.. I was just tempted to give my first 0bytes answer when I saw Jo King hint that most languages can do it

Rust, 3 bytes
||3

Try it online!

PMD 85 BASIC, 0 bytes
Without any lines of code, RUN will respond with

OK

i.e. zero kilobytes.
(yes, it's cheating)

I chuckled at this.

Turing Machine Code, 9 bytes
0 _ 9 * 1

Try it online!

source: Stack Exchange

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

sort: votes


text:
Max of the reversed of two numbers
Given two real numbers (postive or negative) in the limits of float pointing number data types, i.e., (\$-3.4e38\$ to \$3.4e38\$) not inclusive, you should output the max of the two reversed numbers.

TEST CASES
Example
Input:
135
210

Output:
531

\$531\$ is \$135\$ reversed, which is greater than \$012\$, i.e., \$210\$ reversed.

Negative numbers are allowed:
Example 2
Input:
-135
-210

Output:
-012

\$-012\$ is \$-210\$ reversed, which is greater than \$-531\$, i.e., \$-135\$ reversed.

Real numbers are allowed:
Example 3
Input:
13.5
10

Output:
5.31

\$5.31\$ is \$13.5\$ reversed, which is greater than \$01\$, i.e., \$10\$ reversed.

Example 4
Input:
-1112313.5
-312.5671

Output:
-5.3132111

\$-5.3132111\$ is \$-1112313.5\$ reversed (it reverses the number but is still negative, which is greater than \$-1765.213\$, i.e., \$-312.5671\$ reversed.

Example 5
Input:
0.0000001
0

Output:
1000000.0

\$1000000.0\$ is \$0.0000001\$ reversed, which is greater than \$0\$, i.e., still \$0\$ reversed.

Example 6
Input:
121
121

Output:
121

Both numbers are equal and are palindrome. Either one is correct.

Rules

Standard loopholes apply
This is code-golf, so the shortest program in bytes wins.

Good Luck!

I think this would be a decent challenge if you remove the bonuses, which are widely regarded as a bad idea in addition to your particular ones being unobservable and Do X without Y. I can see why you wanted to restrict built-ins to avoid more boring solutions, but we've seen time and time again that there's not a good way to define these for a wide class of languages, and solvers wind up mostly just probing the edges.

Also, the examples you explain are good, but you should add lots of test cases probing the more subtle points, for example like negatives combined with decimal points, and other instances of leading zeroes. One question is, what happens if the input is a number like 12.99999999999999999999999 that is beyond the float precision of a language, and so it's rendered as -13? I'd suggest putting some limit on decimal precision of inputs to avoid this, unless you think it's particularly important.

@xnor thanks for the feedback, will edit it to make it a better challenge.

I've edited my question

So, 10.0 would reverse to 0.01, while 10 would reverse to 01 or 1? Some languages might consider 10 and 10.0 equal or even not distinguish them at all. It seems like it's really a number string that's the input. I guess it don't matter since probably everyone will take the number as a string anyway (which is allowed by default).

Exactly! If you want to treat as a string, it's fine too!

There are two example 4s and the first one is wrong (answer should be -5.3132111

@NickKennedy nice catch, thank you! updated it

Now there are two example 5s :P

The rule for real numbers is strange. Just consider $ 1 = 0.{\dot {9}} $...

Thanks @Night2 no two 6s  now tho!

Your test cases show some extraneous 0s in the results, like -012 or 1000000.0. Are these 0s required in the output, or could you output -12 and 1000000?

Yeah sry for the confusion, you can output both ways

05AB1E, 6 7 6 bytes
+1 byte to fix cases when only one of the inputs is negative.
-1 byte by Grimmy
í'-δ†Z

Try it online!
Test all inputs
The input is taken as a list of strings [x, y].
Explanation:
í        Reverse each input
 '-      Push a minus sign
   δ†    Apply "filter out the minus sign to the front" to each input
     Z   Take the maximum

Unfortunately it fails on test 5 : [0.0000001,0] just take input as string may fix it.. Try it online!

Yes, you are right. I must have overlooked that. Thanks!

I think it also fails if only the second string is negative, as in this example: https://tio.run/##yy9OTMpM/f//UdOaoCh13UcNC/7/j1bSNTQ0NDI2NNYzVdJRMjY00jM1MzdUigUA

Thanks. To fix this, it seems like I have to filter out the minus sign to the front before I take the maximum, so the byte count went up by 1, since I had to replace € with ε }

Wren, 126 124 bytes
As always Wren is the longest. I hate Wren's verbosity.
Fn.new{|a|a.map{|i|i>0?"":"-"+(i.abs.toString[-1..-(i.abs.toString.count)])}.map{|i|Num.fromString(i)}.reduce{|x,y|x<y?x:y}}

Try it online!
Explanation
Fn.new{                                                                                // new anonymous function
       |a|                                                                                // with the parameter a
          a.map{|i|                                                                                // for each item in this parameter
                                  (i>0)?"":"-"                                                                       // The sign of each item. If the item is larger than 0, return the null string, otherwise return a negative sign.
                                              +(                                           )                         // Append this with the following string:
                                                i.abs                                                                // The absolute value of i
                                                     .toString                                                       // Convert this value to a string
                                                              [-1..-(i.abs.toString.count)]                          // Reverse this string
                   Num.fromString(                                                          )                        // convert this to a number from a string
                                                                                }.reduce{|x,y|x<y?x:y}} // Find the minimum value of the list

Perl 5, 51 bytes:
sub f{($x,$y)=map{/-?/;$&.reverse$'}@_;$x>$y?$x:$y}

Try it online!
...or if using a function from a core module is allowed (max in List::Util) it's 35 bytes:
35 bytes:
sub f{max map{/-?/;$&.reverse$'}@_}

Try it online!

Zsh, 63 bytes
for x;a+=(${(M)x#-}${(j::)${(Oas::)x#-}})
<<<$a[1+$[a[1]<a[2]]]

Try it online!
${x#-} removes the leading - if it exists. Adding the (M) flag causes the - to be substituted instead of what remains.
Then this construct reverses the remaining string: ${(j::)${(Oas::)var}}.
For each element, we append to an array, then use a comparison to index into the array.

Python 3, 89 86 bytes
Disclaimer: This answer does not work for the second example #4 due to floating point accuracy constraints in Python. Feel free to disqualify.
Update: This answer now works for all examples thanks to @JonathanAllan
f=float
r=lambda a:-f(a[:1:-1])if eval(a)<0else f(a[::-1])
m=lambda a,b:max(r(a),r(b))

Try it online!

It isn't floating point inaccuracy that breaks example 5, it's that str(0.0000001) is '1e-07' which, when reversed, is an invalid input to float. Take strings and use eval - you'll need to switch to<0 but  it's shorter anyway :)

Also m= is unnecessary, it may be unnammed. For even more savings see my Python 3.8 entry.

'%.16f'%a fixes the 0.0000001

@JonathanAllan That solution with eval is clever. Answer updated with credit

@AlexeyBurdin The reason I didn't go with this as a solution is that all you need to do to find a new input number that will break things is add some more zeros

JavaScript (ES6), 100 bytes
Takes input as (a)(b).
a=>b=>Math.max((g=n=>(s=n>0||-1)*[...(s*n).toFixed(9).replace(/\.0+$/,0)].reverse().join``)(a),g(b))

Try it online!

Python 3.8, 69 bytes
lambda*v:max(map(lambda x:(-1)**(z:=eval(x)<0)*float(x[z:][::-1]),v))

An unnamed function accepting 2 (actually, any number of) strings, which yields the maximal reversed version as a floating point number.
Try it online!

Any reason for the (pre-release) notice? Python 3.8 was released Oct. 14, 2019.

@Noodle9 It's because the name on TIO has not been updated, if Py 3.8 is out I guess that should be updated :)

Here is the name definition, but I'm unsure what else should be updated.

Red, 74 bytes
func[a][forall a[a/1:(sign? a/1)* do reverse to""absolute a/1]max a/1 a/2]

Try it online!
Takes the input as a list of two numbers.
The 5th test case (0.0000001 0) doesn't work in TIO, but works fine in the Red console:

JavaScript (Node.js), 64 bytes
a=>b=>(R=([h,...t])=>h?h+1<0?h+R(t):R(t)+h:t)(a)>+R(b)?R(a):R(b)

Try it online!
Input / output as strings.

Keg -hd 53 41 35 34 27 11 bytes (SBCS)
(2|¿⑶&)@MMƒ

-16 bytes with new reverse t.o.s function
Answer History
27 bytes
(2|᠀÷^:\-=[_^\-^]⅀&)ℝ$ℝ@MMƒ

-7 bytes due to using the new built-in function library which will be soon populated with helpful functions.
MM is the maximum function, and returns the maximum of the two items passed to it.
34 bytes
(2|᠀÷^:\-=[_^\-^]⅍⅀&)ℝ$ℝ:&^:^<[&|^

Try it online!
-1 byte due to using ⅍
35 bytes
(2|᠀÷^:\-=[_^\-]^``⅀&)ℝ$ℝ:&^:^<[&|^

Hey, so, uh, Keg has flags now. -hd prints only the top item if nothing has been printed. Also, summate command works as expected now. The github interpreter works, but not TIO yet.
41 bytes
(2|᠀÷^:`-`=[_^`-`^]``∑+)&)ℝ$ℝ:&^:^<[&|^].

Try it online!
-12 bytes due to not using functions
53 bytes
@m2|:&^:^<[&|^]ƒ(2|᠀÷^:`-`=[_^`-`^] ``(!;|+)&)ℝ$ℝ@mƒ.

Try it online!
I dont even know where to begin when explaining this, but it works. I know I could remove the need for a function, but I'm on my phone, so I'll do it later.
I would have used the summate command, but there's a bug with it.

PHP, 56 bytes
fn($a)=>max(array_map(fn($n)=>strrev($n)*($n>0?:-1),$a))

Try it online!
Input is an array of two string numbers, example: ['123', '25.5'].
Simply reverses both numbers as strings, then returns the max of them as numbers. To handle reversed negative numbers, the *($n>0?:-1) part is used which multiplies the reversed number by 1 if the original number was more than zero, else multiplies it by -1.
In PHP if you try to convert a string which starts with numeric values to a number, it will take the numeric part and ignore the rest. For example '321-' converted to a number will be 321 and the multiply operation automatically forces this numeric conversion.

Example 5 (the first of them) says output should be 1000000.0 not 1000000 as in your tests.

@KjetilS. 1000000.0 is equal to 1000000 . I don't see a problem here, unless OP explicitly asks for reversed string outputs.

see your point (I just read the examples)

APL+WIN, 32 bytes
Prompts for a nested string of the two numbers.
⌈/⍎¨(n↑¨'¯'),¨⌽¨(n←'¯'=↑¨m)↓¨m←⎕

Try it online! Courtesy of Dyalog Classic

Japt -g -N, 12 bytes
®®w}'-Ãn@Y-X

Try it
Thanks to @Arnauld for spotting an error
Takes input as array of strings
U.m // for each element
(function(Z) { return Z.m // split on '-'
(function(Z) { return Z.w() // reverse and convert to number
 }, "-") }) // rejoins
.n(function(X, Y, Z) { return Y - X }) // sort in descending order

Flag -gn to output first element obtained
Flag -N to output it as a number (remove leading 0s)

7 bytes: https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&code=rm13Jy3Dbg&input=WyIwIiwiMC4wMDAwMDAwMSJd

Also, you can't combine flags like that, and -gn is not a real flag. Either choose -g1 or -h

@Embodiment of Ignorance the -N flag is not really necessary as leading 0 are acceptable, I'll update just use -g and -N for nice output purpose. About your improvement.. It seems not to satisfy the specifics

@EmbodimentofIgnorance, that won't work, it needs to be 8 bytes. Note also that you can use -gN as a flag and that, although unusual, multiple flags can be used in some cases, particularly if one is lowercase and one is uppercase - e.g., -g -N.

Perl 6, 28 27 bytes
-1 byte thanks to Jo King
&max o**.&{.abs.flip*.sign}

Try it online!

27 bytes using a HyperWhatever. In an optimal world it would just be 25, but HyperWhatevers are rather disappointing

R, 82 bytes
options(scipen=99);b=sign(a<-scan());max(b*as.numeric(stringi::stri_reverse(b*a)))

Try it online!
Input is taken as two numbers.
Setting scipen=99 is needed to deal with more than a few decimals.

Ruby, 51 bytes
->*a{a.map{|w|(w<=>0)*"#{w.abs}".reverse.to_f}.max}

Try it online!

Haskell, 70 bytes
f a b=max(g a)(g b)
g('-':x)=(0-).h$x
g xs=h xs
h=read @Float .reverse

Try it here
or if Haskell language pragma aren't allowed (like TypeApplications)
77 bytes
f a b=max(g a)(g b)
g('-':x)=(0-).h$x
g xs=h xs
h=read.reverse::String->Float

APL(NARS), 17 chars, 34 bytes
{⌈/(⍎¨⌽¨⍕¨∣⍵)××⍵}

test:
  f←{⌈/(⍎¨⌽¨⍕¨∣⍵)××⍵}
  f 135 210
531
  f ¯135 ¯210
¯12
  f 13.5 10
5.31
  f ¯1112313.5   ¯312.5671
¯5.3132111
  f 0.0000001 0
SYNTAX ERROR
  f 0.000001 0
100000
  f 121 121
121
  f 121 ¯3 6 0.0001 9
1000

Charcoal, 13 bytes
Ｉ⌈Ｅ²Ｉ⪫Ｅ⪪Ｓ-⮌λ-

Try it online! Link is to verbose version of code. Explanation:
   ²            Literal `2`
  Ｅ             Map over implicit range
        Ｓ       Input string
       ⪪ -      Split on `-`s
      Ｅ         Map over substrings
           λ    Current substring
          ⮌     Reversed
     ⪫      -   Join with `-`s
    Ｉ           Cast to number
 ⌈              Maximum
Ｉ               Cast to string
                Implicitly print

... why the downvote?

Jelly, 11 bytes
ḟ€”-UV×VṠ$Ṁ

Try it online!
A monadic link taking a list of two strings and returning the maximum reversed number as a float or integer depending on the input.
Explanation
ḟ€”-        | Filter out “-“ from each
    U       | Reverse each
     V      | Evaluate as Jelly code
      ×  $  | Multiply by following as a monad:
       V    | - Evaluate as Jelly code
        Ṡ   | - Sign
          Ṁ | Max

Bash + coreutils, 40 bytes
rev|sed 's/\(.*\)-/-\1/'|sort -n|tail -1

Try it online!

Haskell, 104 bytes
r n=read((\s->if head s=='-'then"-"++reverse(drop 1 s)else reverse s)$show n)::Float
f a b=max(r a)(r b)

Try it online!
The 0.0000001 0 test case doesn't work though, I think there's an error on read.
Typing could also be improved when the input is type Int for example

Gaia, 11 bytes
⟨v'-%v$⟩¦d⌠

This is a function which accepts a list of two numbers as strings and leaves the result on the stack. OP wasn't clear about whether leading 0's or 0 decimals need to be included, but the program should be equally long either way. This function does not include these 0's:
⟨v'-%v$d⟩¦⌉

Try it online!
⟨       ⟩¦    Map this block over the list:
 v            Reverse the string
  '-%         Split it around -'s, leaving the separators in the result
     v        Reverse the splitting
      $       Rejoin it
         d⌠  Return the element of the list which gives the highest value when parsed as a number

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


text:
Minimum number of changes required
Given an array where each number represent a color. After iterating each item in the array (for each item in the iteration the pointer can also point to the second-item-to-the-right), and the two colors in the iteration is the same, do the following checking:
If there is a different color between the pointed colors, the colors will "dissolve" (which is not allowed).
eg.:  [1,2,1] is not allowed but [1,1,2,2] is allowed. Here is an explanation for the above test cases:
[1, 2, 1]
 ^     ^

We find that the two pointed items have the same color. We then realize that the color between the pointed items are different than the two same colors; this ensures a "dissolving".
The following is an explanation of the second example:
[1, 1, 2, 2]
 ^     ^

In this step, the atoms are different, so we don't perform the check.
[1, 1, 2, 2]
    ^     ^

In this step the atoms are still different. All colors do not "dissolve", ensuring a valid array.

We can change one color to another but the condition is if we change one color, then we have to change all of its occurrences in the array. The cost of changing color is the number of appearances of the color in the array.
eg.: if the array is [1,2,1,2,1,3,2] and we have decided to change 2 to 1, then our array will become [1,1,1,1,1,3,1] and the cost will be 3 (for changing three 2's to 1's)
We have to minimize the cost and make sure no color dissolves.
Test cases
[1,1,3,3,2,2] -> 0 (no changes are required to prevent dissolving)
[1,3,1,3,1] -> 2 (change all 3's to 1's costs 2)
[1,1,2,3,2,3]-> 2 (change color of all 2's to 3's OR change color of all 3's to 2's)
[1,2,2,2] -> 0 (This is valid; in the second iteration, the color between the pointed colors are equal to the pointed colors.)
[1,2,1,2,1,3,2] -> 3 (the 1's must be changed to make the array valid, and there's 3 of them)

Oh I get it! [1,2] is different, [1,2] is also different!

If I am wrong, feel free to explain why. This is my understanding of your challenge.

@A_ I didn't understood your query. can you elaborate.

Done, can you understand now?

Given [1,2,1,3,1] is the expected output 2?

Since you have not answered my question above, I've voted to close as unclear. Please clarify and then people can nominate for re-opening.

yes, the min no of changes is 2 .Convert 2 to 1 and 3 to 1.

Perl 5, 92 bytes
sub f{min map{$o=$_;map{$s="@_";$c=!/$o/*$s=~s,$o,$_,g;$s=~/(.) (.) \1/&&$1-$2?9e9:$c}@_}@_}

Try it online!
sub f{                        #ungolfed:
  min                         #minimum of the yielded list of numbers (from core module List::Util)
  map{                        #map: outer loop of f()'s input args
    $o=$_;                    #keep $o (outer) loop element
    map{                      #map: inner loop of f()'s input args
      $s="@_";                #$s string are input args (input chars) concatenated with no separation
      $c=!/$o/*$s=~s,$o,$_,g; #$c becomes 0 if inner and outer loop elements are equal
                              #otherwise $c becomes the number of changes on the input
                              #$s string when swapping $o with $_ (outer and inner loop variable)
      $s=~/(.) (.) \1/&&$1-$2 #check if $s after the swapping is valid: no three consecutive chars
                              #...should exists in $s where 1st and 3rd are equal but 2nd is not
        ? 9e9                 #yield big number 9e9 if $s is invalid to make sure it wont be the minimum
        : $c                  #yield the number of swaps if $s is valid
    }
    @_                       #input arg's
  }
  @_                         #input arg's, outer loop
}

I think [1,2,1,3,1] should output 2 (and have asked for clarification). Also I think your edit suggestion of "[1,2,1,2,1,3,2] -> 3 (the 1's must be changed to make the array valid, and there's 3 of them)" is incorrect since if you were to change all 1s to 2s you'll have [2,2,2,2,2,3,2] which still has [2,3,2] inside.

Your right. (And I've tried to withdraw my edit suggestion without luck)


text:
How can I golf this JavaScript code, if at all?
I have some JavaScript code in a

Is these the complete HTML or just a part of it?

Save 3 bytes by assigning document to a variable:
(d=document).write`YOU ARE IN THE BEDROOM.
YOU SEE CRAB NICHOLSON.
HE HAS NO MITTENS.
HIS CLAWS ARE MENACING.
OBVIOUS EXITS ARE:
BATHROOM, KITCHEN, LIVING ROOM
AND CRAB NICHOLSON'S
ULTIMATE LAIR OF AWESOMENESS`;d.body.style.background="#000"

Save 2 bytes by reusing ' CRAB NICHOLSON':
(d=document).write(`YOU ARE IN THE BEDROOM.
YOU SEE${c=' CRAB NICHOLSON'}.
HE HAS NO MITTENS.
HIS CLAWS ARE MENACING.
OBVIOUS EXITS ARE:
BATHROOM, KITCHEN, LIVING ROOM
AND${c}'S
ULTIMATE LAIR OF AWESOMENESS`);d.body.style.background="#000"

Save 1 byte by using .join`<br>`:
(d=document).write(`YOU ARE IN THE BEDROOM._YOU SEE${c=' CRAB NICHOLSON'}._HE HAS NO MITTENS._HIS CLAWS ARE MENACING._OBVIOUS EXITS ARE:_BATHROOM, KITCHEN, LIVING ROOM_AND${c}'S_ULTIMATE LAIR OF AWESOMENESS`.split`_`.join`
`);d.body.style.background="#000"

Further golfs suggested by @Night2:
Save 14 bytes by using .bgColor=0:
(d=document).write(`YOU ARE IN THE BEDROOM._YOU SEE${c=' CRAB NICHOLSON'}._HE HAS NO MITTENS._HIS CLAWS ARE MENACING._OBVIOUS EXITS ARE:_BATHROOM, KITCHEN, LIVING ROOM_AND${c}'S_ULTIMATE LAIR OF AWESOMENESS`.split`_`.join`
`);d.body.bgColor=0

Save 7 bytes by 'forgetting' to close the  tag (YMMV):
(d=document).write(`YOU ARE IN THE BEDROOM._YOU SEE${c=' CRAB NICHOLSON'}._HE HAS NO MITTENS._HIS CLAWS ARE MENACING._OBVIOUS EXITS ARE:_BATHROOM, KITCHEN, LIVING ROOM_AND${c}'S_ULTIMATE LAIR OF AWESOMENESS`.split`_`.join`
`);d.body.bgColor=0

You can save 1 byte by removing the # in the color. Google Chrome parses as the color rgb(64, 224, 208), with or without the #.

OP did this help you? If so, please accept the answer


text:
How compactly can your language perform accurate numerical integration?
WARNING: This challenge may need  128 bit floats.1
The task is to perform  numerical integration. Consider the following three functions.
\$
f(x) = cx^{c - 1}e^{-x^c}
\$
\$
g_1(x) = 0.5e^{-x}
\$
\$
g_2(x) = 5 e^{-10 x}
\$
We will have that \$c \geq 0.2\$. Your code should be correct for any value between 0.2 and 1.0.
The task is to perform the integral:
\$
\int_{0}^{\infty} f(x) \ln\left(\frac{f(x)}{g_1(x)+g_2(x)}\right) \mathrm{d}x.
\$
Your output should be correct to within plus or minus \$10^{-10}\$ percent of the correct answer.
Input
A single real number \$c\$.
Output shown to 15 significant places
c = 0.2. Output: 119.2233798550179
c = 0.3. Outout: 8.077346771987397
c = 0.4. Output: 2.07833944013377
c = 0.5. Output: 0.8034827042913205
c = 0.6. Output: 0.3961739639940003
c = 0.7. Output: 0.2585689391629249
c = 0.8. Output: 0.2287758419066705
c = 0.9. Output: 0.2480070283065089
c = 1.0. Output: 0.2908566108890576

Timing
Your code must complete on TIO before it times out.
As is usual, this is a competition per language. In other words, Java coders should not be put off by the single character solution in a language they can't believe exists. You may use any language/library you choose.
Questions and notes

Does this integral actually exist/converge?

Yes. It is the Kullback Leibler divergence between two probability distributions.

Show me any code that can compute these integrals.

See this Wolfram Alpha example.

Why such high precision that we need 128 bit floats?

It is quite easy to solve the integral to low precision using simple ideas.  However, to get high precision seems to need careful thought both about the integral itself but also the quadrature method that will  be used. I felt this made the question more challenging and interesting.
1. For lots of languages this is easy. E.g Fortran has real128, gcc/clang have _Float128 for C/C++, Python has Decimal (and many other options), Dyalog APL has 128 bit (decimal) floats, C# has the Decimal type, Haskell has rounded, PHP has decimal, MATLAB has  the Multiprecision Computing Toolbox, Julia has BigFloat, Java has BigDecimal, JavaScript has big.js,  Ruby has BigDecimal, R has Rmpfr, Perl has Math::BigFloat, SOGL has 200 digit decimal precision, etc. If your favourite golfing language doesn't, maybe consider adding it?
Update
Alexey Burdin has shown that
\$
\int_{0}^{\infty} f(x) \ln\left(\frac{f(x)}{g_1(x)+g_2(x)}\right) \mathrm{d}x = \int\limits_0^1 \left(\ln c+\left(\ln \left(-\ln t\right)\right)\cdot\frac{c-1}{c}+ \ln t- \ln\left(0.5+5e^{-9x(t)}\right) +(-\ln{t})^{1/c}\right)dt\$
This potentially greatly simplifies the problem.

Because of the very high precision requirements here, I think the answer to "How compactly can your language perform numerical integration?" is largely based on "Does your language have a high-precision real-number representation?"

@xnor It's a little more difficult than that :) But I think most (all?) main stream languages have at least libraries for 128 bit floats.

Many answers on this site are not written in mainstream languages.

@pppery that is true. But for every challenge there are a set of languages most suited and a set that are ill suited. Also the challenge is per language so even if you have to implement 128 bit multiplication/division yourself in your language, that's ok.

python3, 3982 2183 1866 1821 1677, ~14s
from functools import*
#let's start with the comments. I'll exclude them from total count
#from functools I need only reduce
#I've been coding in python2 for 5 years so I'm used to built-in reduce much
#and it's very handy here
g=range
#just keep it in mind while reading) ranGe -> g
#and we're getting rid of classes in favor of functions, that gives
#us ~100 bytes more. It's how it was:
#class P:
#it's a Polynomial, self.c are coefficients and self.d is a divisor. So all polynomial computations are exact
#we need polynomials to implement https://en.wikipedia.org/wiki/Gaussian_quadrature#Gauss%E2%80%93Legendre_quadrature
#   c=[0]
#   d=1
#don't even know if these initial values are necessary
#   def __init__(self,c,d=1):
#       self.c=list(c)
#       self.d=d
#n'th derivative
#   def dn(self,n=1):
#       c=self.c[:]
#       for _ in g(n):
#           c=[c[i]*i for i in g(1,len(c))]
#       d=reduce(gcd,c,self.d)
        #gcd is imported from math along with exp,log and gamma
#       return P([i//d for i in c],self.d//d)
#   def m(self,x):
#the value of poly at point x. __call__ may look better
#       return sum((x**i)*self.c[i] for i in range(len(self.c)-1,-1,-1))/self.d
        #the reverse order was for floats and really needed there for precision,
        #but python3 have exact Fractions, so maybe it's to be golfed too
#Now let's convert this class to functions
#derivative=lambda c:reduce(lambda c,_:[c[i]*i for i in g(1,len(c))],g(n),c)
#the_gcd=lambda c,d:reduce(gcd,c,d)
#the_result=lambda c,d,m:([i//m for i in c],d//m)
#where c is now the derivative
#and combined:
v=lambda c,d,n=1:(lambda c:
(lambda c,d,m:([i//m for i in c],d//m))(c,d,reduce(gcd,c,d))
)\
(reduce(lambda c,_:[c[i]*i for i in g(1,len(c))],g(n),c))
#the computing of a plynomial's value:
m=lambda c,d,x:sum((x**i)*c[i] for i in g(len(c)-1,-1,-1))/d
d={}
#https://en.wikipedia.org/wiki/Combination written recursively with Pascal's triangle, with the dict d for speed
def c(n,k):
    if (n,k) not in d:
        d[(n,k)]=1 if k==0 or k==n or n==0 else c(n-1,k)+c(n-1,k-1)
    return d[(n,k)]
#p=30
#it's the floating point precision for Decimal
#it was needed for computing the polynomial roots, you can see the raw version
#maybe I'll get rid of it if it's used in the only place
from math import*
from fractions import Fraction as F
n=61
l=v(sum(([c(n,i)*(-1)**(n-i),0] for i in g(n+1)),[]),
        2**n*reduce(lambda x,y:x*y,g(1,n+1),1),n)
#Legendre polynomial of order n, pretty straightforward, -3bytes for space
#you can't see these bytes in the tio version, there is 1 line
d=v(*l)
#and the derivative for weights
#see we can use c and d now 'cause we don't need them more
c=2**100
#maybe the hardest-to-read part, the roots of l
#taking too long to compute (2-3 mins) so hard-stored
#b(b'GKSmRyJoJz...') is the 390-bytes byte array,
#representing the <0 roots (the function is odd, so -x and x are both roots and we have to store only half)
#30 13-byte(100-bit, for 10^{-30} precision) integers are stored in lsbf order of bytes
#and c is common multiplier for all computed roots' denominators
from base64 import b64decode as b
#extract numbers from base-64,
r=(lambda b:[sum(2**(n*8)*i for n,i in enumerate(b[j:j+13])) for j in g(0,391,13)])(b(b'GKSmRyJoJzZNd978D7hBJ/SAXF6k3Q+D7w9eWlMN1hwU7v+nhNcPP3k+PPY3ALm75/G0DwxkhnBW7vYeTLvhhw8XTAWijBbPeSIxclAPxUQBLJIlU0r8S8gODz6W/ntGb0p0WeUPww6bS5oF+R0NzuqOe20OpkOWAx5DBcFecEQODqjUMBgWzmCaCiGqpQ2xekr44w56Xl998jMNN0/S8UF6TE04eGm5DL0i6Wm5wA/nHOhgNgxOR3kgsJNHFpZQMKsLdK2AMa1xRv65pzQYCxSYft+TX736FBjQfQqY8CuipXP9Bxm/adwJEKYLfykKeTs/aG00CVuQ6lnO2j04CUVLhggLyUIxC/eIqRKid9IHdSe6aSQRS8hkmWoZB2rhfvNKb9bHP8KfWwb379JeWbyiuY/elZkFsIKVLmMYZwdEhs7TBAvB47snQ/UMwtDNCgRb9soEqlNzn6z8GT8DTfSlRAVDCG07FjtxAheAQ01VIxgWXpy6oQEELmiRzDIqr+ckI9EA'))
#and make fractions
#0 is in r for magically mistaken 391 for 390 )
#maybe +[0]+r[::-1] is 1 byte shorter (or longer?)
#but at least more readable )
#roots computation code is in the raw below
r=[F(i,c) for i in [-j for j in r]+r[-2::-1]]
#the weights
w=[2/((1-x**2)*(m(*d,x))**2) for x in r]
from decimal import*
D=Decimal
setcontext(Context(prec=30, rounding=ROUND_HALF_DOWN))
#that was float=
#it's only converting Fraction to Decimal. no built-in
f=lambda r:(lambda n,d:D(n)/D(d))(*str(r).split('/'))
#number of sub-intervals of (0,1)
d=2**8
s=input().strip()
c=D(s)
#the inverse of c, not the math.exp(1) ))
e=D(1)/c
#pretty straightforward, I is the integrator,
I=lambda h:sum(sum(f(v)*h(f(((x+1)/2+i)/d))/(2*d) for v,x in zip(w,r))
        for i in range(d))
#the rest follows (at math:)
print(D(gamma(1/float(s)+1))+(c.ln())-I(lambda t:(D('0.5')+5*((-9*((-((t).ln()))**(e))).exp())).ln())-D('0.5772156649015328606065120900824')*(1-e)-1)

Try it online! -- takes input as a valid Decimal, like 0.2
Math:
0. We do google numerical integration.
1. Let's see provocative \$f(x)=c\cdot x^{c-1}\cdot e^{-x^c}=
-\left(e^{-x^c}\right)'\$
2. So, we have \$-\int\limits_0^\infty \ln\left(\frac{c\cdot x^{c-1}\cdot e^{-x^c}}{0.5e^{-x}+5e^{-10x}}\right)\left(e^{-x^c}\right)'dx\$,
we change the variable to \$t=e^{-x^c}\$, \$x^c=-\ln(t)\$,
\$x=\left(-\ln t\right)^\frac1c\$,
\$t(0)=1\$, \$t(+\infty)=0\$ and the integral is
\$\int\limits_0^1 \ln\left(\frac{c\cdot x(t)^{c-1}\cdot t}{\left(0.5+5e^{-9x(t)}\right)e^{-x(t)}}\right)dt=\$
\$\int\limits_0^1 \left(\ln c+\left(\ln x(t)\right)\cdot(c-1)+ \ln t- \ln\left(0.5+5e^{-9x(t)}\right) +x(t)\right)dt=\$
\$\int\limits_0^1 \left(\ln c+\left(\ln \left(-\ln t\right)\right)\cdot\frac{c-1}{c}+ \ln t- \ln\left(0.5+5e^{-9x(t)}\right) +x(t)\right)dt\$
3. Next we wolframalpha these things:
\$\int\limits_0^1\ln(-\ln t)dt\$,
\$\int\limits_0^1 (-\ln t)^a dt\$,
\$\int\limits_0^1 \ln t\,dt\$  and do the rest numerically (the latter thing maybe can be done with trapeziums or rectangles or Simpson -- the idea for short submissions).
The raw thing:
from copy import copy
from functools import reduce
class Poly:
    c=[0]
    d=1
    def __init__(self,c,d=1):
        self.c=list(c)
        self.d=d
    def dn(self,n=1):
        c=copy(self.c)
        for _ in range(n):
            c=[c[i]*i for i in range(1,len(c))]
        d=reduce(gcd,c,self.d)
        return Poly([i//d for i in c],self.d//d)
    def m(self,x):
        return sum((x**i)*self.c[i] for i in range(len(self.c)-1,-1,-1))/self.d
def gcd(x,y):
    return abs(gcd(y,x%y)) if y else x
cdict={}
def c(n,k):
    if (n,k) not in cdict:
        cdict[(n,k)]=1 if k==0 or k==n or n==0 else c(n-1,k)+c(n-1,k-1)
    return cdict[(n,k)]
def root(x,f,f_):
    x_old=0
    while x!=x_old:# and abs(f(x))>1e-15:
        print(x,f(x),f_(x))
        x_old=x
        x=x-f(x)/f_(x)
    print('===')
    return x
precision=30
def b(b,e,f,eps=1e-17):
    mold,m=0,1
    while e-b>eps and mold!=m:
        mold=m
        m=(e+b)/2
        if (l.m(m)>0)!=(l.m(b)>0):
            e=m
        else:
            b=m
        #print(*map(float,[b,e,f(b),f(e)]))
    print('.',sep='',end='')
    return b
##class Frac:
##    n=0
##    d=1
##    def __init__(self,n,d):
##        self.n=n
##        self.d=d
##    def
lcm=lambda x,y:x*y//gcd(x,y)
import math
from fractions import Fraction
degree=61
n=degree
l=Poly(sum(([c(n,i)*(-1)**(n-i),0] for i in range(n+1)),[]),
       2**n*reduce(lambda x,y:x*y,range(1,n+1),1)).dn(n)
ld=l.dn()
#print(l.coeffs,l.d)
#r=[root(math.cos(math.pi*(4*i-1)/(4*n+2)),l.m,ld.m) for i in range(1,n+1)]
##d=2**8#4096
##while True:
##    i_=[(b,e) for b,e in [(Fraction(i,d)-1,Fraction(i+1,d)-1)
##                          for i in range(2*d)] if (l.m(b)>0)!=(l.m(e)>0)]
##    print(d,len(i_))
##    if len(i_)==n:
##        break
##    d*=2
##r=[b(*i,l.m,Fraction(1,10**precision)) for i in i_]
##print('\n',sep='',end='')
cm=1267650600228229401496703205376
#cm=reduce(lambda x,i:lcm(int((str(i).split('/')+[1])[1]),x),r,1);cm
#[str(i*cm) for i in r]
r=[Fraction(int(i),cm) for i in ['-1266681605106811426160584860697', '-1262547799267707740863710314936', '-1255122086390021131342967954015', '-1244422184933863703004183427391', '-1230475806835976018691325584397', '-1213319288075032955237836344344', '-1192997371846808208190052844742', '-1169563069074221666262667138623', '-1143077514053466175428649175963', '-1113609802945881973204995949479', '-1081236812728978305124643427497', '-1046043000289730543348383120049', '-1008120181921745998647915597624', '-967567293702390287305984778942', '-924490133333634877286205966159', '-879001084101412705885157895540', '-831218821664589525108846925845', '-781268004433877062952267018393', '-729278948345971539276192261648', '-675387286880006687633990914140', '-619733617202494872284783888651', '-562463133363442075271048079222', '-503725247500289525435137450347', '-443673200037730123766618583031', '-382463659900222496924931293872', '-320256315780122313563780137228', '-257213459527711400732339664476', '-193499562749975057795207525453', '-129280847722706546595631169560', '-64724853735360852478581550597', '0', '64724853735360852478581550596', '129280847722706546595631169559', '193499562749975057795207525452', '257213459527711400732339664475', '320256315780122313563780137227', '382463659900222496924931293871', '443673200037730123766618583030', '503725247500289525435137450346', '562463133363442075271048079221', '619733617202494872284783888650', '675387286880006687633990914139', '729278948345971539276192261647', '781268004433877062952267018392', '831218821664589525108846925844', '879001084101412705885157895539', '924490133333634877286205966158', '967567293702390287305984778941', '1008120181921745998647915597623', '1046043000289730543348383120048', '1081236812728978305124643427496', '1113609802945881973204995949478', '1143077514053466175428649175962', '1169563069074221666262667138622', '1192997371846808208190052844741', '1213319288075032955237836344343', '1230475806835976018691325584396', '1244422184933863703004183427390', '1255122086390021131342967954014', '1262547799267707740863710314935', '1266681605106811426160584860696']]
#r=[Fraction(-72002513042367095, 72057594037927936), Fraction(-35883766692782835, 36028797018963968), Fraction(-35672715239059617, 36028797018963968), Fraction(-141474422995755015, 144115188075855872), Fraction(-69944451686068079, 72057594037927936), Fraction(-137938433007892963, 144115188075855872), Fraction(-135628098615462501, 144115188075855872), Fraction(-66481963419518119, 72057594037927936), Fraction(-32488216960856169, 36028797018963968), Fraction(-126602776952709289, 144115188075855872), Fraction(-61461197033678349, 72057594037927936), Fraction(-59460660411885473, 72057594037927936), Fraction(-7163124720376473, 9007199254740992), Fraction(-109999665903886841, 144115188075855872), Fraction(-105102359763536115, 144115188075855872), Fraction(-99930853605361871, 144115188075855872), Fraction(-23624659822433771, 36028797018963968), Fraction(-88819888837164975, 144115188075855872), Fraction(-41454708727199633, 72057594037927936), Fraction(-19195661220692463, 36028797018963968), Fraction(-70455555169530143, 144115188075855872), Fraction(-63944654967081315, 144115188075855872), Fraction(-28633465234423143, 72057594037927936), Fraction(-6304975386764939, 18014398509481984), Fraction(-10870271009372985, 36028797018963968), Fraction(-36408927801417385, 144115188075855872), Fraction(-29241784833142379, 144115188075855872), Fraction(-21998353389560073, 144115188075855872), Fraction(-14697530755564293, 144115188075855872), Fraction(-7358363943167303, 144115188075855872), Fraction(0, 1), Fraction(3679181971583651, 72057594037927936), Fraction(3674382688891073, 36028797018963968), Fraction(2749794173695009, 18014398509481984), Fraction(14620892416571189, 72057594037927936), Fraction(4551115975177173, 18014398509481984), Fraction(43481084037491939, 144115188075855872), Fraction(50439803094119511, 144115188075855872), Fraction(57266930468846285, 144115188075855872), Fraction(31972327483540657, 72057594037927936), Fraction(35227777584765071, 72057594037927936), Fraction(76782644882769851, 144115188075855872), Fraction(82909417454399265, 144115188075855872), Fraction(44409944418582487, 72057594037927936), Fraction(94498639289735083, 144115188075855872), Fraction(49965426802680935, 72057594037927936), Fraction(52551179881768057, 72057594037927936), Fraction(13749958237985855, 18014398509481984), Fraction(114609995526023567, 144115188075855872), Fraction(118921320823770945, 144115188075855872), Fraction(122922394067356697, 144115188075855872), Fraction(15825347119088661, 18014398509481984), Fraction(129952867843424675, 144115188075855872), Fraction(132963926839036237, 144115188075855872), Fraction(33907024653865625, 36028797018963968), Fraction(68969216503946481, 72057594037927936), Fraction(139888903372136157, 144115188075855872), Fraction(70737211497877507, 72057594037927936), Fraction(142690860956238467, 144115188075855872), Fraction(143535066771131339, 144115188075855872), Fraction(144005026084734189, 144115188075855872)]
#r=[Fraction(-144104924687379029, 144115188075855872), Fraction(-144061113633417193, 144115188075855872), Fraction(-71991152681636629, 72057594037927936), Fraction(-143868501524294767, 144115188075855872), Fraction(-35929931908622757, 36028797018963968), Fraction(-143536019344824829, 144115188075855872), Fraction(-71658710569760757, 72057594037927936), Fraction(-143063986084641675, 144115188075855872), Fraction(-142775775751233995, 144115188075855872), Fraction(-35613215044775229, 36028797018963968), Fraction(-142095317851501427, 144115188075855872), Fraction(-141703235672459401, 144115188075855872), Fraction(-141276708943911307, 144115188075855872), Fraction(-70407920670826367, 72057594037927936), Fraction(-140320744889653401, 144115188075855872), Fraction(-34947884983137447, 36028797018963968), Fraction(-139228355106226913, 144115188075855872), Fraction(-138631327306447751, 144115188075855872), Fraction(-69000300827755959, 72057594037927936), Fraction(-68668165733468573, 72057594037927936), Fraction(-136638678208163739, 144115188075855872), Fraction(-135907811461286037, 144115188075855872), Fraction(-67571954440908669, 72057594037927936), Fraction(-134347156155496359, 144115188075855872), Fraction(-16689718369143059, 18014398509481984), Fraction(-132655882883583863, 144115188075855872), Fraction(-131761773444627501, 144115188075855872), Fraction(-65417817986076227, 72057594037927936), Fraction(-64938847793634331, 72057594037927936), Fraction(-32222046285398959, 36028797018963968), Fraction(-127867345160661637, 144115188075855872), Fraction(-31703855946358703, 36028797018963968), Fraction(-62866338356003711, 72057594037927936), Fraction(-15577420891180097, 18014398509481984), Fraction(-123475765655790143, 144115188075855872), Fraction(-61151075136161875, 72057594037927936), Fraction(-121098806255952059, 144115188075855872), Fraction(-119866026109883705, 144115188075855872), Fraction(-118604109492524957, 144115188075855872), Fraction(-117313363144639965, 144115188075855872), Fraction(-115994100814789491, 144115188075855872), Fraction(-28661660795766563, 36028797018963968), Fraction(-28317829445786347, 36028797018963968), Fraction(-111868458922669023, 144115188075855872), Fraction(-110438407601984251, 144115188075855872), Fraction(-27245377857813575, 36028797018963968), Fraction(-26874531136490757, 36028797018963968), Fraction(-105988607520833283, 144115188075855872), Fraction(-26113331820545011, 36028797018963968), Fraction(-102892657018719659, 144115188075855872), Fraction(-50653488045428427, 72057594037927936), Fraction(-49848334969235775, 72057594037927936), Fraction(-98062129987227927, 144115188075855872), Fraction(-96403753553428489, 144115188075855872), Fraction(-94721943747436259, 144115188075855872), Fraction(-23254277343922147, 36028797018963968), Fraction(-45644832420663197, 72057594037927936), Fraction(-89540030043462969, 144115188075855872), Fraction(-10971078784389609, 18014398509481984), Fraction(-85975896119833679, 144115188075855872), Fraction(-42081131673510875, 72057594037927936), Fraction(-20582043201506859, 36028797018963968), Fraction(-40237035159487741, 72057594037927936), Fraction(-39300203286200335, 72057594037927936), Fraction(-19176909251924261, 36028797018963968), Fraction(-74796221710411347, 144115188075855872), Fraction(-72866625298407583, 144115188075855872), Fraction(-35459658404464939, 72057594037927936), Fraction(-68954769584591107, 144115188075855872), Fraction(-33486730579157493, 72057594037927936), Fraction(-32487936568629803, 72057594037927936), Fraction(-31481245542875313, 72057594037927936), Fraction(-60933804407252565, 144115188075855872), Fraction(-58890306225406907, 144115188075855872), Fraction(-56832493264165915, 144115188075855872), Fraction(-54760865727051299, 144115188075855872), Fraction(-26337963587783547, 72057594037927936), Fraction(-25289092203398143, 72057594037927936), Fraction(-48468147330210951, 144115188075855872), Fraction(-46346328843725859, 144115188075855872), Fraction(-11053311177256411, 36028797018963968), Fraction(-21034706713097939, 72057594037927936), Fraction(-19957678053844251, 72057594037927936), Fraction(-4718949543956531, 18014398509481984), Fraction(-35578660114658865, 144115188075855872), Fraction(-33397075583856055, 144115188075855872), Fraction(-15603686524289111, 72057594037927936), Fraction(-29010084771446223, 144115188075855872), Fraction(-1675359053686717, 9007199254740992), Fraction(-24594889131807827, 144115188075855872), Fraction(-22378054994346827, 144115188075855872), Fraction(-20155781304247947, 144115188075855872), Fraction(-4482152060343901, 36028797018963968), Fraction(-15697077176510773, 144115188075855872), Fraction(-6730865269878557, 72057594037927936), Fraction(-5611555844344803, 72057594037927936), Fraction(-4490882388138869, 72057594037927936), Fraction(-6738234618615355, 144115188075855872), Fraction(-2246533281244659, 72057594037927936), Fraction(-2246806352819167, 144115188075855872), Fraction(0, 1), Fraction(1123403176409583, 72057594037927936), Fraction(4493066562489317, 144115188075855872), Fraction(3369117309307677, 72057594037927936), Fraction(8981764776277737, 144115188075855872), Fraction(11223111688689605, 144115188075855872), Fraction(13461730539757113, 144115188075855872), Fraction(3924269294127693, 36028797018963968), Fraction(17928608241375603, 144115188075855872), Fraction(10077890652123973, 72057594037927936), Fraction(11189027497173413, 72057594037927936), Fraction(12297444565903913, 72057594037927936), Fraction(26805744858987471, 144115188075855872), Fraction(14505042385723111, 72057594037927936), Fraction(31207373048578221, 144115188075855872), Fraction(16698537791928027, 72057594037927936), Fraction(2223666257166179, 9007199254740992), Fraction(37751596351652247, 144115188075855872), Fraction(39915356107688501, 144115188075855872), Fraction(42069413426195877, 144115188075855872), Fraction(44213244709025643, 144115188075855872), Fraction(23173164421862929, 72057594037927936), Fraction(24234073665105475, 72057594037927936), Fraction(50578184406796285, 144115188075855872), Fraction(52675927175567093, 144115188075855872), Fraction(27380432863525649, 72057594037927936), Fraction(28416246632082957, 72057594037927936), Fraction(29445153112703453, 72057594037927936), Fraction(15233451101813141, 36028797018963968), Fraction(62962491085750625, 144115188075855872), Fraction(64975873137259605, 144115188075855872), Fraction(66973461158314985, 144115188075855872), Fraction(34477384792295553, 72057594037927936), Fraction(70919316808929877, 144115188075855872), Fraction(36433312649203791, 72057594037927936), Fraction(37398110855205673, 72057594037927936), Fraction(76707637007697043, 144115188075855872), Fraction(78600406572400669, 144115188075855872), Fraction(80474070318975481, 144115188075855872), Fraction(82328172806027435, 144115188075855872), Fraction(84162263347021749, 144115188075855872), Fraction(42987948059916839, 72057594037927936), Fraction(87768630275116871, 144115188075855872), Fraction(11192503755432871, 18014398509481984), Fraction(91289664841326393, 144115188075855872), Fraction(93017109375688587, 144115188075855872), Fraction(47360971873718129, 72057594037927936), Fraction(12050469194178561, 18014398509481984), Fraction(49031064993613963, 72057594037927936), Fraction(99696669938471549, 144115188075855872), Fraction(101306976090856853, 144115188075855872), Fraction(51446328509359829, 72057594037927936), Fraction(104453327282180043, 144115188075855872), Fraction(52994303760416641, 72057594037927936), Fraction(107498124545963027, 144115188075855872), Fraction(108981511431254299, 144115188075855872), Fraction(55219203800992125, 72057594037927936), Fraction(55934229461334511, 72057594037927936), Fraction(113271317783145387, 144115188075855872), Fraction(114646643183066251, 144115188075855872), Fraction(57997050407394745, 72057594037927936), Fraction(29328340786159991, 36028797018963968), Fraction(29651027373131239, 36028797018963968), Fraction(14983253263735463, 18014398509481984), Fraction(60549403127976029, 72057594037927936), Fraction(122302150272323749, 144115188075855872), Fraction(61737882827895071, 72057594037927936), Fraction(124619367129440775, 144115188075855872), Fraction(125732676712007421, 144115188075855872), Fraction(126815423785434811, 144115188075855872), Fraction(31966836290165409, 36028797018963968), Fraction(128888185141595835, 144115188075855872), Fraction(129877695587268661, 144115188075855872), Fraction(130835635972152453, 144115188075855872), Fraction(32940443361156875, 36028797018963968), Fraction(66327941441791931, 72057594037927936), Fraction(133517746953144471, 144115188075855872), Fraction(67173578077748179, 72057594037927936), Fraction(135143908881817337, 144115188075855872), Fraction(33976952865321509, 36028797018963968), Fraction(68319339104081869, 72057594037927936), Fraction(137336331466937145, 144115188075855872), Fraction(138000601655511917, 144115188075855872), Fraction(69315663653223875, 72057594037927936), Fraction(4350886097069591, 4503599627370496), Fraction(139791539932549787, 144115188075855872), Fraction(17540093111206675, 18014398509481984), Fraction(140815841341652733, 144115188075855872), Fraction(70638354471955653, 72057594037927936), Fraction(17712904459057425, 18014398509481984), Fraction(71047658925750713, 72057594037927936), Fraction(142452860179100915, 144115188075855872), Fraction(71387887875616997, 72057594037927936), Fraction(71531993042320837, 72057594037927936), Fraction(143317421139521513, 144115188075855872), Fraction(35884004836206207, 36028797018963968), Fraction(143719727634491027, 144115188075855872), Fraction(71934250762147383, 72057594037927936), Fraction(143982305363273257, 144115188075855872), Fraction(18007639204177149, 18014398509481984), Fraction(36026231171844757, 36028797018963968)]
w=[2/((1-x**2)*(ld.m(x))**2) for x in r]
from decimal import Decimal,Context,setcontext,ROUND_HALF_DOWN
setcontext(Context(prec=30, rounding=ROUND_HALF_DOWN))
float=lambda r:(lambda x:Decimal(x[0])/Decimal(x[1]))(str(r).split('/'))
d=2**8
s='{120.000000000000000000000000000,9.26052826812554737559992621571,3.32335097044784255118406403126,2.00000000000000000000000000000,1.50457548825155601882809780906,1.26582350605728327736200759570,1.13300309631934634747833911121,1.05218372089129332722399903882,1.00000000000000000000000000000}'
l=list(map(Decimal,s[1:-1].split(',')))
gamma=Decimal('0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495')
for (c,c_1,real),l_ in zip([
    (Decimal('0.1')*i,Decimal('10')/i,10/i) for i in range(2,11)],l):
    #let t=e^{-x^c},\ln t=-x^c,x=(-\ln t)^{\frac1c}
    #t(0)=1,t(\infty)=0
    #dt=-e^{-x^c}\cdot x^{c-1}\cdot c
    #f(x)=e^{-x^c}\cdot x^{c-1}\cdot c=t\cdot (-\ln t)^{\frac{c-1}c}\cdot c
    xt=lambda t:(-((t).ln()))**(c_1)
##    f=lambda x:c*(x**(c-1))#*(math.exp(-(x**c)))
    fln=lambda t:((-((t).ln())).ln())#+(t.ln())
##    g=lambda x:Decimal('0.5')+5*((-9*x).exp())#*math.exp(-x)
    g=lambda t:Decimal('0.5')+5*((-9*xt(t)).exp())#*math.exp(-x)
##    h=lambda x:f(x)*((-(x**c)).exp())*\
##       ((f(x)).ln()-(x**c)-((g(x)).ln()-x))
##    #0,inf->0,1: x=t/(t-1), xt-x=t, (x-1)t=x, t=x/(x-1)
##    h1=lambda t:h(t/(1-t))/((1-t)**2) # 0,1
##    h2=lambda v:h1((v+1)/2)/2
    h1=lambda t:g(t).ln()#f(t).ln()-((g(t).ln())-xt(t))
    int_=lambda h1:sum(
          sum(float(w_)*h1(float(((x+1)/2+i)/d))/(2*d) for w_,x in zip(w,r))
          for i in range(d))
    print(c,Decimal(math.gamma(real+1))+(c.ln())-int_(h1)-gamma*(1-c_1)-1)
h1_=r'''0.2 0.476044892154085268532810576285
0.3 0.326045243249124607083205564208
0.4 0.194544295792217104304557844994
0.5 0.0805857800502670858642542661562
0.6 -0.0176136562407463311404194282348
0.7 -0.102042234943715186336125809639
0.8 -0.174612380676135222634071174702
0.9 -0.237048749195042896134197564780
1.0 -0.290856610889057599214369459143'''
x=[i.split(': ') for i in r'''c = 0.2. Output: 119.2233798550179
c = 0.3. Outout: 8.077346771987397
c = 0.4. Output: 2.07833944013377
c = 0.5. Output: 0.8034827042913205
c = 0.6. Output: 0.3961739639940003
c = 0.7. Output: 0.2585689391629249
c = 0.8. Output: 0.2287758419066705
c = 0.9. Output: 0.2480070283065089
c = 1.0. Output: 0.2908566108890576'''.split('\n')]
y=[i.split(' ') for i in r'''0.2 119.223379855017945799292478451
0.3 8.07734677198740392689540304712
0.4 2.07833944013376923348715605315
0.5 0.80348270429132046532502570246
0.6 0.39617396399400051391328713871
0.7 0.25856893916292307961043114604
0.8 0.22877584190665494099938058972
0.9 0.24800702830645810748432393277
1.0 0.29085661088905759921436945914'''.split('\n')]
#[(lambda l:(l and min(l)) or 0)([n for n,(d1,d2) in enumerate(zip(i[1],j[1])) if d1!=d2]) for i,j in zip(x,y)]
#[0, 14, 15, 17, 17, 16, 15, 14, 17]

Pari/GP, 88 87 bytes, < 1 sec
Great work from @AlexeyBurdin!
I also saw the "provocative" way in which \$f\$ was a derivative of an easier function, but only had the idea to use this for partial integration, without success.
For golfing reasons I recombined all the logarithms, except the one giving \$-1\$ because it makes no difference for the code length and subtracting one seemed slightly more efficient than multiplying the integrand by \$t\$. I also took the logarithms of \$1/t\$ instead of \$t\$ to be able to get rid of the otherwise needed parentheses for the minus sign. The 2 in the last argument to intnum reduces the integration step size. That is needed to achieve the required precision.
l=log;i(c)=intnum(t=0,1,l(c*l(1/t)^(1-1/c)/(.5+5*exp(-9*l(1/t)^c^-1)))+l(1/t)^c^-1,2)-1

Try it online!

This is pretty awesome. Thank you.

Python 3, 150 133 122 bytes
(thanks to Delta and Alexey Burdin for further golfing this)
SymPy's mpmath module is a great way to handle this problem. All math functions (exp, log, euler, gamma and quad for integration) are run in high precision.
lambda c:gamma(1/c+1)+l(c)-euler*(1-1/c)-1-quad(lambda t:l(.5+5*exp(-9*((-l(t))**(1/c)))),[0,1])
from mpmath import*
l=log

Try it online!

This is great. Thank you.

Try it online! you can save some bytes if you use a lamda instead of the input()

@Delta thanks! I thought we needed to output a fixed number of digits, thus I hang on to the nprint, but indeed that is not required. That saves 17 bytes. Nice one.

128 bytes

@AlexeyBurdin thanks! I further golfed it to 122 bytes.

I really like how simple and clean this answer is now.

Wolfram Language (Mathematica), 105 bytes ~7.5 seconds
Mathematica is good at automatically determining the best method needed to perform the integration.  Setting the working precision high gets us to results that match the stated answer.  The time stated is to perform all the example integrals.
NIntegrate[((f=#*x^(#-1))*Log[f/(E^x^#*(5/E^(10*x)+0.5/E^x))])/E^x^#,{x,0,-Log@0},WorkingPrecision->128]&

Try it online!

At least**!** )))

Sorry... at least what?... don't follow.

At least someone posted wolfram mathematica solution. The language is perfect for numerical integration) or for all math)

62 bytes. In Mathematica, precision is specified in decimal digits. MachinePrecision offers 15.9 decimal digits (53 bits) of precision by default on TIO, which is sufficient for the stated requirement.

@attinat I don't think that is right.  Look at the end of the first output.

@Anush You only required accuracy to within +/-10^-10. 119.22337985501592 is sufficiently close.

61 bytes

@attinat Good point! I miscounted.

@attinat, I think you've got some good edits, but I'm not convinced that dropping the WorkingPrecision option works when c=0.8.  As the problem states, 10^-10% implies a relative error of 10^-12 or less, but the relative difference between your answer and the stated correct answer is 7.5*10^-11 which is just a tad bit too much error. I figured that was a corner case left in by the questioner to force the use of extra precision.

Desmos, 62 59 bytes
a=ln(1/t)^{1/c}
f(c)=∫_0^1(ln(a^c/a/e(.5+5e^{-9a})c)+a)dt

This is a port of Christian Siever's solution with some modifications for numeric precision.
Try it on Desmos!
-3 bytes thanks to Aiden Chow.
The final column in the table shows the relative error, which reaches 5.71×10^-13 as the worst case at c=0.2. This barely slips under the 10^-12 relative error requirement.
As for the speed requirement, this run in under 1500ms on my computer.
Precision notes
Desmos uses 64-bit floats for everything, so it's tough to get the desired precision, considering the machine precision is on the order of 10^-16. However, Desmos's quadrature routine is pretty good for general integrals because it works by recursively splitting the integration interval when it needs more precision.
ln(1/t) can be changed to (-lnt) for -1 byte, but this costs about two orders of magnitude of relative precision.

I try absorbing the -1 into the ln and it seem to work for 59 bytes. One of the relative errors is negative, but its absolute value is under $10^{-12}$ so I think it's fine. Try It On Desmos!. This runs anywhere from 1500ms to 2000ms on my computer.

@AidenChow Nice observation! Putting the -1 into the integral on its own doesn't work, but putting it inside the ln as ln(1/e) (as you did) does work

APL(NARS), 929 chars, time 1' 7''
⎕fpc←128⋄grv←gerr←0⋄ge←q←0v⋄funOne←{f←q×(⍵*q-1v)×*-⍵*q⋄f×⍟f÷(0.5v×*-⍵)+5×*-10v×⍵}

r←(f S)w
gerr←1⋄r←¯1J1⋄→0×⍳3≠≢w⋄→0×⍳w[3]>⎕fpc÷3.322⋄gerr←grv←0⋄ge←÷10v*w[3]⋄r←f It w[1]w[2]
→0×⍳∼gerr≠0⋄r←¯1J1

r←(f I)w;a;b;n;nn;h;s1;s2;h1;h2;i;t;p;m
r←⍬⋄→0×⍳gerr≠0⋄h2←h1←s2←s1←0v⋄(a b n)←w⋄→2×⍳n≤0⋄h←(2×nn←2v×n)÷⍨b-a⋄i←0v⋄→3
r←⍬⋄gerr←1⋄→0
t←f a+h×2×i+←1⋄s1+←t⋄→4×⍳∼0=2∣i⋄h1+←t⋄→5
h2+←t
→3×⍳i<nn-1⋄i←0v⋄→2×⍳∞=∣s1
s2+←f a+h×¯1+2×i+←1⋄→6×⍳i<nn⋄→2×⍳∞=∣s2⋄p←f¨a b⋄→2×⍳∞=+/∣p⋄t←+/p
p←(3÷⍨h×t+(4×s2)+2×s1)(3÷⍨h×2×t+(4×h2)+2×h1)
m←(h×s2+s1+t÷2)(h× 2×s1+t÷2)⋄→2×⍳(∞=∣m[1])∨∞=∣p[1]
s2←∣-/p⋄s1←∣-/m⋄→10×⍳∼s2>s1⋄r←m,s1⋄→0
r←p,s2

r←(f It)w;t;y;m
r←0v⋄→2×⍳0≠gerr⋄→3×⍳∼grv>250⋄gerr←1
r←0v⋄→0
grv+←1⋄t←f I w,1⋄→2×⍳0≠gerr⋄→6×⍳t[3]≥1⌊ge×1E5⋄→5×⍳ge>t[3]⋄t←f I w,19⋄→2×⍳0≠gerr
→6×⍳∼ge>t[3]
y←f I w,23⋄→2×⍳0≠gerr⋄→6×⍳ge≤∣y[1]-t[1]⋄grv-←1⋄r←↑y⋄→0
m←2v÷⍨-/⌽w⋄r←(f It w[1],w[1]+m)+(f It(w[1]+m),w[2])⋄grv-←1

:for q :in 0.1v+10÷⍨⍳9⋄q,(11⍕ funOne S 1E¯64v (7E8v) 11)⋄:endfor

82+ 8+82+18+2 +39+74+13+40+5+25+63+44+50+37+6+10+ 15+35+7+79+12+54+58+6 +65=929
"grv" is one global variable used for make not too deep the recursive function
"gerr" is one global variable used for find some possible error
"ge"  is one global variable used for store epsilon of precision
"funOne" would be the function use in exercise where the "c" is here "q".
"S" is the function to call for integration of one continue function in one interval,
it has arguments on the left the function, in the right 3 numbers, 2 are
a b for the integration interval [a, b], and one for the precision of calculation.
It is possible that S function fail (return ¯1J1 in that case) or not show the error in some integral
even if the number result is wrong (example some integral of periodic functions).
It is possible S give the wrong value to the function that stop the computation with "DOMAIN ERROR".
"I" is a function for calculate the integral in 2 differents way the trapezes and Simpson formula,
return the two sums have less difference.
"It" is a recursive function from the model of qsort, that use function "I" and change partition for recalculate
the result each little interval it find ok for to be a little more sure of result even if that means 2x slow
(so it is possible one silent fail).
  :for q :in 0.1v+10÷⍨⍳9⋄q,(11⍕ funOne S 1E¯64v (7E8v) 11)⋄:endfor
0.2  119.22337985502
0.3  8.07734677200
0.4  2.07833944015
0.5  0.80348270430
0.6  0.39617396400
0.7  0.25856893917
0.8  0.22877584191
0.9  0.24800702831
1  0.29085661089

1E¯64v would be one value not 0 sufficient little, the value for +oo that not make wrong results in function funOne,
it seems to be 7E8v.It gets 1' 7'' for all value of c (here it is q variable)  from 0.1 to 1.
The function integrate of sys (∫) is more fast, but the right result it seems to be only the first
     q←0.2v⋄30⍕  1E¯70v funOne ∫7E8v
 119.223379855016584445335168065350
     q←0.3v⋄30⍕  1E¯70v funOne ∫7E8v
 0.253368882611387716254867856476
     q←0.4v⋄30⍕  1E¯70v funOne ∫7E8v
 0.016195181203412657409325335505
     q←1v⋄30⍕  1E¯70v funOne ∫7E8v
 0.001677768739402358961260938889

For some function f, +/f¨a b is not the same +/f a b.
One has to eliminate all the places where is used "=" or use ⎕ct←0 in each function use "=".
In the function "I" these are the 4 sums, the first (p[1]) the more precise Simpson sum, than the second (p[2]) less precise Simpson
the 3rd the more precise use trapezes (m[1]), the less precise use trapezes (m[2]).
p←(3÷⍨h×t+(4×s2)+2×s1)(3÷⍨h×2×t+(4×h2)+2×h1)
m←(h×s2+s1+t÷2)(h× 2×s1+t÷2)

C (gcc), 1933 bytes, 3''
    #include <quadmath.h>
    #include <stdio.h>
    #define C signed char
    #define U unsigned
    #define I int
    #define LD __float128
    #define G goto
    #define P printf
    #define R return
    #define FM FLT128_MAX
    I PP(C*a,C*fmt,LD v){I r;C arr[1010];arr[0]=0;r=quadmath_snprintf(arr,1000,fmt,v);if(r<0)R r;R P("%s%s",a,arr);}
    I grv, gerr; LD ge,t[3],y[3],gq=0.2q;I Er(LD x){if(x<0)R-x>=FM;R x>=FM;}
    LD*In(LD*rf,LD(*f)(LD),LD a,LD b,U n){LD  h,h1,h2,s1,s2,t,x,p[2],m[2],r;U nn,i;if(gerr)R rf;h2=h1=s2=s1=0;if(n==0||n>1e6){L0:gerr=1;R rf;}nn=2*n;h=(b-a)/(2*nn);i=0;L1:++i;s1+=t=f(a+h*2*i);if(Er(t))G L0;if(i%2==0)h1+=t;else h2+=t;if(i<nn-1)G L1;i=0;if(Er(s1))G L0;L2:++i;s2+=t=f(a+h*(2*i-1));if(Er(t))G L0;if(i<nn)G L2;if(Er(s2))G L0;t=f(a);if(Er(t))G L0;x=f(b);if(Er(x))G L0;x=f(b);t+=x;p[0]=h*(t+4*s2+2*s1)/3;p[1]=2*h*(t+4*h2+2*h1)/3;m[0]=h*(s2+s1+t/2);m[1]=2*h*(s1+t/2);if(Er(p[0])||Er(m[0]))G L0;s1=fabsq(p[0]-p[1]);s2=fabsq(m[0]-m[1]);if(s1<s2){rf[0]=p[0];rf[1]=p[1];rf[2]=s1;}else{rf[0]=m[0];rf[1]=m[1];rf[2]=s2;}R rf;}
    LD It(LD(*f)(LD),LD a,LD b){LD r,m;if(gerr){L3: r=0;R r;}if(grv>250){gerr=1;G L3;}++grv;In(t,f,a,b,1);if(gerr)G L3;if(t[2]>=1||t[2]>=ge*1e5)G L6;if(ge>t[2])G L4;In(t,f,a,b,19);if(gerr)G L3;if(ge>t[2]){L4:In(y,f,a,b,23);if(gerr)G L3;if(ge<=fabsq(y[0]-t[0]))G L6;--grv;R y[0];}L6:m=(b-a)/2;r=It(f,a,a+m)+It(f,a+m,b);--grv;R r;}
    LD Si(LD(*f)(LD),LD a,LD b,U p){LD r; gerr=1;if(p>38)R FM;gerr=grv=0;ge=powq(10,-(LD)p);r=It(f,a,b);R gerr?FM:r;}
    LD fN(LD x){LD f,h,z;f=logq(gq)+(gq-1.0q)*logq(x)-powq(x,gq)+x-logq(0.5q+expq(-9.0q*x));return gq*powq(x,gq-1.0q)*expq(-powq(x,gq))*f;}
    LD fO(LD w){LD f=gq*powq(w,gq-1.0q)*expq(-powq(w,gq)),z;z=0.5q*expq(-w)+5.0q*expq(-10.0q*w);R f*logq(f/z);}
    LD funOne(LD x){R x<1000?fO(x):fN(x);}
    I main(){LD r[3],q,i,f,a,b;for(gq=0.2q;gq<=1;gq+=0.1q){q=Si(funOne,1e-64,7e8,11);PP("","%.2Qf",gq);PP(", ","%.30Qf",q);P("\n");}R 0;}

Try it online!
ungolfed:
// > gcc this.c -lquadmath
#include <quadmath.h>
#include <stdio.h>

#define C  signed char
#define U  unsigned
#define I  int
#define LD __float128
#define G   goto
#define P   printf
#define R   return
#define FM  FLT128_MAX

I PP(C*a,C*fmt,LD v)
{I r;C arr[1010];
 arr[0]=0;r=quadmath_snprintf(arr,1000,fmt,v);if(r<0)R r;
 R P("%s%s",a,arr);
}

I grv, gerr; LD ge,t[3],y[3],gq=0.2q;

I Er(LD x){if(x<0)R-x>=FM;R x>=FM;}

LD*In(LD*rf,LD(*f)(LD),LD a,LD b,U n)
{LD  h,h1,h2,s1,s2,t,x,p[2],m[2],r;U nn,i;
     if(gerr)R rf;
     h2=h1=s2=s1=0;if(n==0||n>1e6){L0:gerr=1;R rf;}
     nn=2*n;h=(b-a)/(2*nn);i=0;
 L1: ++i;s1+=t=f(a+h*2*i);if(Er(t))G L0;if(i%2==0)h1+=t;else h2+=t;if(i<nn-1)G L1;i=0;if(Er(s1))G L0;
 L2: ++i;s2+=t=f(a+h*(2*i-1));if(Er(t))G L0;if(i<nn)G L2;if(Er(s2))G L0;t=f(a);if(Er(t))G L0;x=f(b);if(Er(x))G L0;x=f(b);t+=x;
     p[0]=h*(t+4*s2+2*s1)/3;p[1]=2*h*(t+4*h2+2*h1)/3;
     m[0]=h*(s2+s1+t/2);m[1]=2*h*(s1+t/2);
     if(Er(p[0])||Er(m[0]))G L0;
     s1=fabsq(p[0]-p[1]);s2=fabsq(m[0]-m[1]);
     if(s1<s2){rf[0]=p[0];rf[1]=p[1];rf[2]=s1;}
     else     {rf[0]=m[0];rf[1]=m[1];rf[2]=s2;}
     R rf;
}

LD It(LD(*f)(LD),LD a,LD b)
{LD r,m;
    if(gerr){L3:  r=0;  R r;}
    if(grv>250){gerr=1;G L3;}
    ++grv;In(t,f,a,b,1);if(gerr)G L3;if(t[2]>=1||t[2]>=ge*1e5)G L6;if(ge>t[2])G L4;
    In(t,f,a,b,19);if(gerr)G L3;
    if(ge>t[2])
      {L4:In(y,f,a,b,23);if(gerr)G L3;if(ge<=fabsq(y[0]-t[0]))G L6;--grv;R y[0];}
L6: m=(b-a)/2;r=It(f,a,a+m)+It(f,a+m,b);--grv;
    R r;
}

LD Si(LD(*f)(LD),LD a,LD b,U p){LD r; gerr=1;if(p>38)R FM;gerr=grv=0;ge=powq(10,-(LD)p);r=It(f,a,b);R gerr?FM:r;}

LD fN(LD x)
{LD f,h,z;
 f=logq(gq)+(gq-1.0q)*logq(x)-powq(x,gq)+x-logq(0.5q+expq(-9.0q*x));
 return gq*powq(x,gq-1.0q)*expq(-powq(x,gq))*f;
}
LD fO(LD w)
{LD f=gq*powq(w,gq-1.0q)*expq(-powq(w,gq)),z;
 z=0.5q*expq(-w)+5.0q*expq(-10.0q*w);
 R f*logq(f/z);
}
LD funOne(LD x){R x<1000?fO(x):fN(x);}

I main()
{LD r[3],q,i,f,a,b;
 for(gq=0.2q;gq<=1;gq+=0.1q)
       {q=Si(funOne,1e-64,7e8,11);
        PP("","%.2Qf",gq);PP(", ","%.30Qf",q);P("\n");
       }
 R 0;
}

This would be one port of APL NARS answer to C....
"grv" is one global variable used for make not too deep the recursive function
"gerr" is one global variable used for find some possible error
"ge"  is one global variable used for store epsilon of precision
"funOne" would be the function use in exercise where the "c" is here "q".
"Si" is the function to call for integration of one continue function in one interval,
it has arguments on the left the function, in the right 3 numbers, 2 are
a b for the integration interval [a, b], and one for the precision of calculation.
It is possible that Si function fail (return FLT128_MAX in that case) or not show the error in some integral
even if the number result is wrong (example some integral of periodic functions).
It is possible S give the wrong value to the function that stop the computation.
"In" is a function for calculate the integral in 2 differents way the trapezes and Simpson formula,
return the two sums have less difference.
"It" is a recursive function from the model of qsort, that use function "In" and change partition for recalculate
the result each little interval it find ok for to be a little more sure of result even if that means 2x slow
(so it is possible one silent fail).
0.20, 119.223379855017788373126945485560
0.30, 8.077346772003659028828166522766
0.40, 2.078339440146599411449845152080
0.50, 0.803482704300521900602181696767
0.60, 0.396173964001614436175399637559
0.70, 0.258568939171353519263491445983
0.80, 0.228775841912709730320218436446
0.90, 0.248007028314673262106569598459
1.00, 0.290856610889722950747717956860

1E¯64 would be one value not 0 sufficient little, the value for +oo that not make wrong results in function funOne,
it seems to be 7E8.It gets 3'' for all value of c (here it is q variable) from 0.1 to 1.
There was some problem but one see the different behaviors of functions one know what to do:
Cut and paste 2 function in 1...
fO                fN
args: 1..10*114000
inf, 7.146180987711778877830383715838e-05
inf, 1.783936268160517786280124237027e-05
inf, 7.145191389859739510802225203435e-06
inf, 3.548880901445954254961267159123e-06
inf, 1.999831511094571465956022639528e-06
inf, 1.225727400360527391484147042523e-06
inf, 7.980629270833437955446020180540e-07
inf, 5.439501158831436480969842592496e-07
inf, 3.843424608223386417573364622201e-07

fO                                             fN
args: 1..10*10
3.675246391455555827226018131679e-02, 3.675246391455555827226018131679e-02
4.382838598960554328826955735253e-02, 4.382838598960554328826955735253e-02
4.457247966758306754921782013739e-02, 4.457247966758306754921782013739e-02
4.397010507150066869496325771966e-02, 4.397010507150066869496325771966e-02
4.298551944407423573690051874755e-02, 4.298551944407423573690051874755e-02
4.190240448327716144966191450276e-02, 4.190240448327716144966191450276e-02
4.082071320292452338988660547692e-02, 4.082071320292452338988660547692e-02
3.977794012002491268811702806721e-02, 3.977794012002491268811702806721e-02
3.878734785898533961995102431946e-02, 3.878734785898533961995102431946e-02

fO                                           fN
args: 1/1..10
-8.243106934757116432656018641562e-01, -1.344494569228624722492452318334e-01
-1.290429743446295599947997195038e+00, 2.015992534869343736972957346392e-01
-1.460826278910182993294146550044e+00, 7.738815018537929006207034760483e-01
-1.455905510003998243340646950725e+00, 1.487514582923200556163817499455e+00
-1.330519622929357039421233297650e+00, 2.297630406711373536179161098540e+00
-1.115252743630621385523306314288e+00, 3.179047478956116831216159688529e+00
-8.293358937016342749872510061477e-01, 4.115949553797663332308038109261e+00
-4.858491347654902257043425759574e-01, 5.097618989802348559994390744177e+00
-9.419553179254290987076726693566e-02, 6.116387165599517173497262275172e+00

An heroic effort!

@Simd if one has 2 or more functions suppose be equal or two implementation same algo, is not so difficult to debug for find the differences. i found that the type and the value of constants used, are fundamental if one want more than 8 digits of precision

1123 bytes


text:
Is it rectilinear?
Today's challenge:

Given an ordered list of at least 3 unique integer 2D points forming a polygon, determine if the resulting polygon is Rectilinear.

A polygon is rectilinear if every interior angle is a right angle. The edges do not necessarily have to be purely vertical or horizontal (parallel to the x or y axis), as long as the angles are all right (This is slightly different than Wikipedia's definition, but it's the definition we'll be sticking with). For example, the following shape is a perfect square rotated 45°
(0, -1)
(1, 0)
(0, 1)
(-1, 0)

None of the lines are parallel to the x or y axis, but all of the angles are right so it is considered truthy for today's challenge. Note that the order of the points is important. The following reordering of these points gives a self-intersecting polygon, which is basically an hourglass shape rotated 45°. This is falsy:
(0, -1)
(0, 1)
(1, 0)
(-1, 0)

You must take the input as an ordered set of points. Angles between the points or a "shape object" if your language has one, are not valid inputs.
You must output one consistent value for truthy and a different consistent value for falsy.
Note that truthy inputs will always have an even number of points.
It is acceptable if your submission fails for very large inputs because of floating-point inaccuracies.

Note: If you want to visualize a polygon, I've found this tool and Desmos Graphing Calculator both very useful.
Truthy examples
(0, 0)
(0, 20)
(20, 20)
(20, 0)

(1, 1)
(0, 3)
(6, 6)
(7, 4)

# This example is self-intersecting
(2, 3)
(3, 1)
(-3, -2)
(-2, -4)
(2, -2)
(0, 2)

(4, 0)
(4, 2)
(0, 2)
(0, 4)
(2, 4)
(2, 5)
(4, 5)
(4, 3)
(6, 3)
(6, 0)

Falsy examples
(0, 0)
(0, 20)
(20, 20)
(20, 10)

(100, 100)
(100, 50)
(50, 100)

(2, 2)
(3, 3)
(6, 2)
(7, 3)

(100, 100)
(100, -100)
(-100, -100)
(-100, 99)

Is (0,0) (0,1) (0,2) (2,2) (2,1) (2,0) expected falsy?

What should output for (1,0) (2,0) (2,1) (3,1) (3,0) (0,0) (0,1) (1,1)?

Isn't the answer always false if there are only three points?

May we take points as complex numbers?

Can we swap truthy and falsey?

@flawr Yes, any two consistent values are fine.

@xnor Yes, that's acceptable.

@EsolangingFruit Correct, because no triangles are comprised entirely of right angles.

@tsh Let's say to keep things simple, no inputs will have A) Multiple consecutive points along the same line, such as (0,0) (0,1) (0,2) or B) Shapes with 0-width sections such as (0, 2), (0, 0), (2, 0), (2, 2), (3, 2), (-1, 2)

Octave, 60 42 41 40 bytes
I was just looking for an excuse to use nlfilter, too bad the solution was too long:) Now we compute the vectors of the sides of the polygon using d=x-x(:,[2:end,1])). Then d * d' computes all pairwise dot products. We are only interested if consecutive dot products are all zero, therefore we check whether the first superdiagonal diag(...,1) is all zeros using any(...).
@(x)any(diag((d=x-x(:,[2:end,1]))*d',1))

Try it online!

APL (Dyalog Unicode), 16 bytes
×/0=4○∘×2÷/2-/,⍨

Try it online!
Accepts the input as a list of complex numbers, e.g. 1j2 means \$ 1 + 2i \$ which represents the point \$ (1,2) \$.
The result is 1 if the given polygon is rectilinear, 0 otherwise.
How it works
×/0=4○∘×2÷/2-/,⍨
              ,⍨  Concatenate self, so that all angles can be tested
           2-/    Difference of two adjacent values, i.e. vectors
        2÷/       Ratio of two adjacent values, i.e. angle difference
       ×          Normalize to unit vectors
    4○∘           Compute sqrt(1+x^2)
                  Zero if and only if the angle is a right angle
                  i.e. the normalized angle difference vector is i or -i
×/0=              Test if all results are zero, i.e. all angles are right angles

Jelly, 7 bytes
;`_ƝḋƝẸ

Try it online!
Outputs \$0\$ if rectilinear, \$1\$ otherwise
-2 bytes thanks to Jonathan Allan!

Save two: ;_ƝḋƝẸ

@JonathanAllan I'm not sure what you mean?

Looks like Jonathan Allan proposed a 7 bytes solution?

@stephanmg That's 6 bytes and doesn't work

@cairdcoinherinaahing: I see, then I have no idea. But I like your solution. Trying to look into Jelly now.

It's a formatting error in my comment - should be ;`_ƝḋƝẸ

@JonathanAllan Yep, that works, thanks!

Zsh, 94 bytes
for v w;:
for x y;a+=($[v-x]\ $[w-y])&&v=$x&&w=$y
for v w x y ($=a[-1] ${=a:^a})((r|=v*x+w*y))

Try it online!
Input as flattened list of coordinates, outputs via exit code (1 if rectilinear, 0 if not rectilinear). There are three loops here:
for v w;:   # this does nothing other than set $v and $w to the last coordinate pair

for x y                     # ($v,$w) is previous vertex, ($x,$y) is current vertex
    a+=($[v-x]\ $[w-y]) &&  # vector ($v,$w)->($x,$y) as space-delimited string
    v=$x && w=$y            # save previous point

for v w x y ($=a[-1] ${=a:^a}) # This iterates through all subsequent vectors (see below)
    ((r|=v*x+w*y))             # calculate the dot product, bitwise-or with previous dot-products
                               # if non-zero, r will be non-zero and the exit code will be zero

The last loop uses ${=  }, which splits parameters on spaces, and ${  :^  }, which zips two arrays together (in this case, an array with itself). So, we have the last element in the array, followed by every element twice. That isn't an even number of coordinate pairs, so on the last iteration, x and y are empty. This is fine for the dot product, though, it will compute the dot product with the zero vector, which will always be rectilinear.
Using debug traps, you can walk through the function here.

Python3, 98 bytes
lambda p:not sum((a-c)*(e-c)+(b-d)*(f-d)for(a,b),(c,d),(e,f)in zip(*[p[i:]+p[:i]for i in[0,1,2]]))

Try it online!
Takes in a list of tuple points and outputs True if the points are rectilinear, False otherwise.
How it works
p # contains a list of points
[p[i:]+p[:i]for i in[0,1,2]]  # makes 3 lists of p rotated 0, 1, and, 2 places respectively
zip(*[p[i:]+p[:i]for i in[0,1,2]])  # zips the shifted lists together
(a,b),(c,d),(e,f) in zip(*[p[i:]+p[:i]for i in[0,1,2]])  # extracts (x0,y0), (x1,y1), and (x2,y2) from the zipped lists
(a-c)*(e-c)+(b-d)*(f-d)  # translates the 0th and 2nd point by the 1st and computes the dot product, which should be 0 if the points are orthogonal
sum((a-c)*(e-c)+(b-d)*(f-d)for(a,b),(c,d),(e,f)in zip(*[p[i:]+p[:i]for i in[0,1,2]]))  # sums all of the consecutive dot products together
not sum((a-c)*(e-c)+(b-d)*(f-d)for(a,b),(c,d),(e,f)in zip(*[p[i:]+p[:i]for i in[0,1,2]]))  # finally negate the result since if the sum is 0 than all of the points are orthogonal and hence the points form a rectilinear shape!

Welcome to code-golf! I think this is actually 98 bytes since you'll need to include lambda p: in your answer. (Though you can leave out the f=)

Thanks, happy to be here! I've update the submission!

Since the challenge allows any 2 consistent values, you could swap true/false and use any instead of not sum 94 bytes

if you want to keep truthy/falsey you can do 1-condition

Wolfram Language (Mathematica), 49 48 bytes
0==##&@@Dot@@@({#,r@#})&[(r=RotateLeft)@#-#]&

Try it online!
-1 thanks to attinat!

48 bytes

Charcoal, 20 bytes
⬤θ¬ΣＥιΠＥ²⁻λ§§θ⁺κ⊖⊗νμ

Try it online! Link is to verbose version of code. Outputs using Charcoal's default boolean format, which is - for true and nothing for false. Works by separately subtracting each point's x- and y-coordinates from its two adjacent points, then taking the products of the subtractions, then summing, which results in zero when the point is at a right angle. Explanation:
 θ                      Input array
⬤                       Each point satisfies
     ι                  Current point
    Ｅ                   Map over coordinates
       Ｅ²               Map over implicit range `0`..`1`
          λ             Current coordinate
         ⁻              Subtract
                  ν     Inner value `0` or `1`
                 ⊗      Doubled to `0` or `2`
                ⊖       Decremented to `-1` or `1`
               κ        Outer index
              ⁺         Added
             θ          Input array
            §           Get the adjacent point
           §       μ    Take the relevant coordinate
      Π                 Take the product
   Σ                    Take the sum
  ¬                     Is zero
                        Implicitly print

Python 2, 68 bytes
lambda l:any(((a-b)/(b-c)).real for a,b,c in zip(l,l[1:]+l,l[2:]+l))

Try it online!
Input is a list of complex numbers. Output is True or False, swapped.

very nice trick for computing the dot product.

Haskell, 54 bytes
all((==0).sum).r(*).r(-)
r=(=<<tail<>id).z.z
z=zipWith

Try it online!
Uses (<>), which is available in base in the latest release.

Excuse my rusty Ruby. Maybe someone can hint how to shorten. :)
Ruby, 158 bytes
s=0;a=ARGV;a[0].split(",").zip(a[2].split(",")).map{|a,b|b.to_i-a.to_i}.zip(
a[1].split(",").zip(a[3].split(",")).map{|a,b|b.to_i-a.to_i}){|a,b|s+=a*b};p s==0

Try it online!

idk any ruby but creating a function instead of reading from stdin will likely be shorter.

I don't know ruby at all, but wouldn't saving ARGV to a shorter variable name be shorter?

@EdgyNerd: Yeah you right. I also don't know too much Ruby, just for fun.

Wolfram Language (Mathematica), 41 35 34 bytes
Norm@Cos@PolygonAngle@Polygon@#>0&

Returns False for rectilinear polygons and True otherwise.
Only works in 12.0+, so no TIO link
-6 bytes thanks to @Roman
-1 bytes thanks to deleted comment

37 bytes: 0==##&@@Sin[2PolygonAngle@Polygon@#]&

@Roman Thanks! I even managed to shave off another two bytes using Cos@ instead of Sin[2...] (since vertices will never lie in a straight line, this is enough)

Excellent, you read the instructions more closely than me.

Alternatives for 35 bytes: #.#==0&@*Cos@*PolygonAngle@*Polygon and #.#==0&@Cos@PolygonAngle@Polygon@#&

Python and numpy, 94 92 bytes
Uses roll a silly number of times and has two input lists of x and y coordinates. It is easier to rotate an array with python lists (x[1:]+x[:1]) but naturally numpy arrays aren't concatenated with +.
from numpy import roll as r
def f(x,y):a,b=r(x,1)-x,r(y,1)-y;return 1-any(a*r(a,1)+b*r(b,1))

You can drop the 1- in the return value, since any two distinct return values are fine

R, 60 53 bytes
Takes in a vector of complex coordinates and returns swapped truthy and falsey. Uses xnor's dot product trick.
function(x,a=c(x[-1],x[1])-x)any(Re(a/c(a[-1],a[1])))

-7 bytes by using inline rotation instead of creating a function.
R, 82 79 75 bytes
Improved version taking advantage of doing computation in default parameters to save on curly braces.
r=pryr::f(c(z[-1],z[1]))
function(x,y,a=r(x)-x,b=r(y)-y)any(a*r(a)+b*r(b))

-3 bytes by using pryr::f anonymous function and returning 0 for truthy, 1 for falsey.
-4 bytes with better roll function
R, 87 bytes, original answer
My first R answer! Uses same array rotation logic as my numpy answer.
r=function(x)c(tail(x,-1),x[1])
x=scan()
y=scan()
a=r(x)-x
b=r(y)-y
!any(a*r(a)+b*r(b))