text:
Fill up to duplicate ranges
Let \$L\$ be a list of positive integers with no particular ordering, and which can contain duplicates. Write a program or function which outputs a list of positive integers \$M\$ (whose ordering is unimportant) such that merging \$L\$ and \$M\$ results into the smallest list which can entirely split into identical ranges of integers \$[1..i]\$, where \$i\$ is the biggest element in \$L\$
Example
Let L = [5,3,3,2,7]. The maximum element of L is 7. The most times a specific integer occurs is 2 (3 appears 2 times). Therefore, we need to output the list M that will allow to complete L so that we can construct 2 ranges of integers from 1 to 7.
Therefore, we need to output M = [1,1,2,4,4,5,6,6,7], so that each integer from 1 to 7 appears 2 times.
Inputs and outputs

Use anything in your language that is similar to lists. The data structure used for the input and the output must be the same.
The input list will contain only positive integers.
The input list will not be empty.
You cannot assume the input list is sorted.
The ordering in the output list is unimportant.

Test cases
Input                  Output
[1]                    []
[7]                    [1, 2, 3, 4, 5, 6]
[1, 1, 1]              []
[1, 8]                 [2, 3, 4, 5, 6, 7]
[3, 3, 3, 3]           [1, 1, 1, 1, 2, 2, 2, 2]
[5, 2, 4, 5, 2]        [1, 1, 3, 3, 4]
[5, 2, 4, 5, 5]        [1, 1, 1, 2, 2, 3, 3, 3, 4, 4]
[5, 3, 3, 2, 7]        [1, 1, 2, 4, 4, 5, 6, 6, 7]

Scoring
This is code-golf, so the shortest answer in bytes wins.

Just to be clear, as your test cases and statement contradict each other, is i the biggest element of L or M?

@Kroppeb i is the biggest element of L, it was a typo in the specs.

Is it OK to return M=[1,1,2,2,3] for L=[3] while "merging L and M results in a list which can entirely split into identical ranges of integers [1..i]"?

@tsh No, it should return [1,2]. I will clarify it so that it's clear it should result in the minimum number of ranges.

I suggest you to add your first example [5,3,3,2,7] among the test cases, since it's the only one with the maximum value != maximum repeated one

@digEmAll Done.

Jelly, 9 bytes
Saved 1 byte thanks to Jonathan Allan. The footer calls the main link, sorts the result to match the test cases and formats the output as a grid.
RṀẋLƙ`Ṁœ-

Try it online! or Check out a test suite!
Alternatives
ṀRẋLƙ`Ṁœ-
RṀẋṢŒɠṀƊœ-
ṀRẋṢŒɠṀƊœ-
LƙɓṀRẋṀœ-⁸
LƙɓRṀẋṀœ-⁸

Try one of them online!
Explanation

ṀRẋLƙ`Ṁœ-   Full program. N = Input.
ṀR          Range from 1 to max(N): [1 ... max(N)]
   Lƙ`      Map length over groups formed by identical elements.
  ẋ         Repeat the range T times, for each T in the result of the above.
      Ṁ     Maximum. Basically, get the range repeat max(^^) times.
       œ-   Multiset difference with N.

Perl 6, 37 33 bytes
-4 bytes thanks to nwellnhof!
{^.keys.max+1 xx.values.max∖$_}

Try it online!
Anonymous code block that takes a Bag and returns a Bag of values.
Explanation:
{                             } # Anonymous code block
 ^.keys.max+1  # Create a range from 1 to the maximum value of the list
              xx  # Multiply the list by:
                .values.max      # The amount of the most common element
                           ∖$_   # Subtract the original Bag

Nice! You can save a few bytes by coercing the second operand to Bag: {^.max+1 xx.Bag.values.max∖.Bag}

@nwellnhof Ah, thanks! I didn't realise the second argument could be the Bag

OTOH, the challenge requires that the data structures for input and output must be the same. With Bags as input, {^.keys.max+1 xx.values.max∖$_} saves another byte.

R, 59 49 48 bytes
rep(s<-1:max(L<-scan()),max(y<-table(c(L,s)))-y)

Try it online!

I have a 55 byte answer that basically generates the second argument to rep differently, but is otherwise the same as yours. I could post it myself but I don't think I would have thought of it unless I'd seen yours first. I challenge you to find it!

@Giuseppe: I don't know if that's was similar to your approach, but I saved 10 bytes :D

huh, no, I was using split but tabulate is much better!

mmh... now I'm curious, how did you use split for this ?

I had x=max(L<-scan());rep(1:x,1:x-lengths(split(L,c(L,1:x)))) which upon further testing doesn't work for test cases like 7...

You've just suggested me another 1 byte shorter approach :)

Python 2, 86 83 80 72 bytes
def f(l):m=range(1,max(l)+1)*max(map(l.count,l));map(m.remove,l);print m

Try it online!

05AB1E, 17 16 17 11 bytes
ZLŠ¢àиIð.;þ

-1 byte thanks to @Mr.Xcoder.
+1 byte after bug-fixing the work-around..
-5 bytes by using the new 05AB1E version and -1 byte because ordering of the output is unimportant
Maybe I completely look past it, but does 05AB1E even have a remove all elements of list b from list a.. (EDIT: It indeed doesn't..) I know how to remove all multiple times, but not once each.. (multiset difference)
Try it online or verify all test cases.
Explanation:
Z      # Push the maximum of the (implicit) input-list (without popping)
       #  i.e. [5,3,3,2,7] → 7
 L     # Pop and push a list in the range [1,max]
       #  → [1,2,3,4,5,6,7]
  Š    # Tripleswap: a,b,c → c,a,b, so input,[1,max] to [1,max],input,input
   ¢   # Count for each value in the input-list how many times it occurs
       #  → [1,2,2,1,1]
    à  # Pop and push the maximum count
       #  → 2
     и # Repeat the list [1,max] that many times
       #  → [1,2,3,4,5,6,7,1,2,3,4,5,6,7]

       #Now the work-around bit because 05AB1E lacks a builtin for multiset difference..
Ið.;   # Replace first occurrence of the values in the input-list with a space " "
       #  → [1," "," ",4," ",6," ",1,2," ",4,5,6,7]
    þ  # Remove all spaces by only keeping digits
       #  → [1,4,6,1,2,4,5,6,7]
       # (after which the result is output implicitly)

Are you looking for: K a,b Push a without b's? Oh wait, "once each"... hmm

@JonathanAllan No, that won't work, it removes all occurrences rather than the first occurrence of each. Kevin is looking for something like multiset difference

@JonathanAllan Almost. [1,2,3,4,5,6,7,1,2,3,4,5,6,7] and [5,3,3,2,7] with K results in [1,4,6,1,4,6] unfortunately. It removes all items instead of doing a multiset difference.

¢ZIZLŠŠи should save 1 byte

@Mr.Xcoder Thanks, but that wasn't the part I was looking to golf. ;p Funny how two triple-swaps is shorter than removing the access after the count..

If only either Z or á would pop...

@Mr.Xcoder Yeah, mentioned that as well in chat about an hour ago..

@Riley Fixed.. As if the workaround wasn't long enough already..

R, 59 55 bytes
Using the vecsets package we can drop the answer length some. With gl we can get the ordered output. This doesn't work in TIO. Following @digEmAll's style of (rather clever) solution without a function definition, this can be considered a 55 byte solution.
vecsets::vsetdiff(c(gl(m<-max(L<-scan()),sum(L==m))),L)

f=function(x){scan<-function()x
vecsets::vsetdiff(c(gl(m<-max(L<-scan()),sum(L==m))),L)
}

f(c(1))                # expected: integer(0)
f(c(7))                # expected: c(1, 2, 3, 4, 5, 6)
f(c(1, 1, 1))          # expected: integer(0)
f(c(1, 8))             # expected: c(2, 3, 4, 5, 6, 7)
f(c(3, 3, 3, 3))       # expected: c(1, 1, 1, 1, 2, 2, 2, 2)
f(c(5, 2, 4, 5, 2))    # expected: c(1, 1, 3, 3, 4)
f(c(5, 2, 4, 5, 5))    # expected: c(1, 1, 1, 2, 2, 3, 3, 3, 4, 4)

digEmAll's answer is perfectly valid; it takes input via stdin!

Also, as this is not base R, this should be considered a separate language "R + vecsets" (I can't find the relevant meta discussion for that, but I know it's standard practice)

This fails when the maximum value is not the maximum repeated one, e.g. try f(c(5,3,3,2,7))

JavaScript (ES6), 98 bytes
This turned out to be pretty hard to golf below 100 bytes. There may be a better approach.
a=>(a.map(o=M=m=n=>m=(c=o[M=n<M?M:n,n]=-~o[n])<m?m:c),g=k=>k?o[k]^m?[...g(k,o(k)),k]:g(k-1):[])(M)

Try it online!
How?
We first walk through the input array a[] to gather the following data:

M = highest element found in the input array
m = highest number of occurrences of the same element
o[n] = number of occurrences of n

Note that o is primarily defined as a function, but the underlying object is also used to store the number of occurrences.
a.map(                      // a[] = input array()
  o =                       // o = callback function of map()
  M = m =                   // initialize m and M to non-numeric values
  n =>                      // for each value n in a[]:
    m = (                   //   this code block will eventually update m
      c = o[                //     c = updated value of o[n]
        M = n < M ? M : n,  //     update M to max(M, n)
        n                   //     actual index into o[]
      ] = -~o[n]            //     increment o[n]
    ) < m ?                 //   if o[n] is less than m:
      m                     //     let m unchanged
    :                       //   else:
      c                     //     set it to c
)                           // end of map()

We then use the recursive function g() to build the output.
(g = k =>                   // k = current value
  k ?                       // if k is not equal to 0:
    o[k] ^ m ?              //   if o[k] is not equal to m:
      [ ...g(k, o(k)),      //     increment o[k] and do a recursive call with k unchanged
        k ]                 //     append k to the output
    :                       //   else:
      g(k - 1)              //     do a recursive call with k - 1
  :                         // else:
    []                      //   stop recursion
)(M)                        // initial call to g() with k = M

Brachylog, 18 17 bytes
⌉⟦₁;Ij₎R⊇p?;.cpR∧

Try it online!
Saved 1 byte thanks to @Kroppeb.
Explanation
⌉                  Take the largest element in the Input
 ⟦₁                 Construct the range [1, …, largest element in the Input]
   ;Ij₎R            Juxtapose that range to itself I times, I being unknown;
                       call the result R
       R⊇p?         The Input must be an ordered subset of R, up to a permutation
          ?;.c      Concatenate the Input and the Output
                       (the Output being unknown at this point)
              pR    This concatenation must result in R, up to a permutation
                ∧   (Find a fitting value for the Output that verifies all of this)

You could use ⌉ instead of ot

Haskell, 72 bytes
import Data.List
f l=(last(sortOn(0<$)$group$sort l)>>[1..maximum l])\\l

Try it online!
            sort l      -- sort input list
       group            -- group identical elements
   sortOn(0<$)          -- sort by length
 last                   -- take the last element, i.e. the list
                        -- of the most common element
      >>[1..maximum l]  -- replace each of it's elements
                        -- with the list [1..maximum l]
  \\l                   -- remove elements of the input list

MATL, 14 bytes
Input is a column vector, with ; as separator.
llXQtn:yX>b-Y"

Try it online! Or verify all test cases (this displays -- after each output so that empty output can be identified).
Explanation
Consider input [5; 2; 4; 5; 5] as an example.
llXQ     % Implicit input. Accumarray with sum. This counts occurrences
         % of each number, filling with zeros for numbers not present
         % STACK: [0; 1; 0; 1; 3]
tn:      % Duplicate, number of elements, range
         % STACK: [0; 1; 0; 1; 3], [1 2 3 4 5]
yX>      % Duplicate from below, maximum of array
         % STACK: [0; 1; 0; 1; 3], [1 2 3 4 5], 3
b        % Bubble up
         % STACK: [1 2 3 4 5], 3, [0; 1; 0; 1; 3]
-        % Subtract, element-wise
         % STACK: [1 2 3 4 5], [3; 2; 3; 2; 0]
Y"       % Repelem (run-length decode). Implicit display
         % STACK: [1 1 1 2 2 3 3 3 4 4]

Java 10, 186 bytes
import java.util.*;L->{Integer m=0,f=0,t;for(int i:L){m=i>m?i:m;f=(t=Collections.frequency(L,i))>f?t:f;}var r=new Stack();for(;m>0;m--)for(t=f;t-->0;)if(!L.remove(m))r.add(m);return r;}

Try it online.
Explanation:
import java.util.*;   // Required import for Collections and Stack
L->{                  // Method with Integer-list as both parameter and return-type
  Integer m=0,        //  Max, starting at 0
          f=0,        //  Max frequency, starting at 0
          t;          //  Temp integer
  for(int i:L){       //  Loop over the input-List
    m=i>m?i:m;        //   If the current item is larger than the max, set it as new max
    f=(t=Collections.frequency(L,i))>f?t:f;}
                      //   If the current frequency is larger than the max freq, set it as new max
  var r=new Stack();  //  Result-List
  for(;m>0;m--)       //  Loop the maximum in the range [m,0)
    for(t=f;t-->0;)   //   Inner loop the frequency amount of times
      if(!L.remove(m))//    Remove `m` from the input list
                      //    If we were unable to remove it:
        r.add(m);     //     Add it to the result-List
  return r;}          //  Return the result-List

Husk, 12 bytes
Saved 1 byte thanks to BWO.
S-§*oḣ▲(▲Ṡm#

Try it online!

MATL, 24 21 bytes
X>:GS&Y'X>yGhS&Y'q-Y"

Try it online!

Gaia, 12 bytes
::⌉┅¤:C¦⌉&¤D

Try it online!

C (gcc), 177 bytes
Input and output are done through stdin and stdout. Both arrays are capped at 2^15 elements, but they could be as large as 2^99 elements.
f(j){int n=0,m=0,i=0,a[1<<15],b[1<<15]={0};for(;scanf("%i",&a[i])>0;i++)j=a[i],m=j>m?j:m,b[j-1]++;for(i=m;i--;)n=b[i]>n?b[i]:n;for(i=m;i--;)for(j=n-b[i];j--;)printf("%i ",i+1);}

With some formatting:
f(j){
  int n=0, m=0, i=0, a[1<<15], b[1<<15]={0};
  for(;scanf("%i",&a[i])>0;i++) j=a[i], m=j>m?j:m, b[j-1]++;
  for(i=m;i--;) n=b[i]>n?b[i]:n;
  for(i=m;i--;) for(j=n-b[i];j--;) printf("%i ",i+1);
}

Try it online!

Pyth, 13 bytes
.-*SeSQeSlM.g

Try it here! or Check out a test suite!

Charcoal, 19 bytes
Ｆ…·¹⌈θＥ⁻⌈Ｅθ№θκ№θιＩι

Try it online! Link is to verbose version of code. Would have been 16 bytes if the integers had been non-negative instead of positive. Explanation:
     θ              First input
    ⌈               Maximum
 …·¹                Inclusive range starting at 1
Ｆ                   Loop over range
          θ         First input
         Ｅ          Loop over values
            θ       First input
             κ      Inner loop value
           №        Count occurrences
        ⌈           Maximum
               θ    First input
                ι   Outer loop value
              №     Count occurrences
       ⁻            Subtract
      Ｅ             Map over implicit range
                  ι Current value
                 Ｉ  Cast to string
                    Implicitly print on separate lines

APL (Dyalog Classic), 18 17 bytes
∊{⊂⍳⌈/⍵}~¨∘↓∘⍉⊣¨⌸

Try it online!
uses ⎕io←1

Prolog (SWI), 211 bytes
It's been a while since I programmed in Prolog. Can definitely be golfed further, but I have an exam to study for hahaha.
Code
f(L,X):-max_list(L,M),f(L,M,[],X,M).
f([],0,_,[],_).
f(L,0,_,A,M):-f(L,M,[],A,M).
f([],I,H,[I|A],M):-N is I-1,f(H,N,[],A,M).
f([I|R],I,H,A,M):-append(H,R,S),f(S,I,[],[I|A],M).
f([H|R],I,G,A,M):-f(R,I,[H|G],A,M).

Try it online!
Ungolfed version
f(List, Result) :-
    max_list(List, MaxIndex),
    f(List, MaxIndex, [], Result, MaxIndex).

f([], 0, _, [], _).

f(List, 0, _, Acc, MaxIndex) :-
    f(List, MaxIndex, [], Acc, MaxIndex).

f([], Index, History, [Index | Acc], MaxIndex) :-
    NewIndex is Index - 1, f(History, NewIndex, [], Acc, MaxIndex).

f([Index | Remaining], Index, History, Acc, MaxIndex) :-
    append(History, Remaining, Result),
    f(Result, Index, [], [Index | Acc], MaxIndex).

f([Head | Remaining], Index, History, Acc, MaxIndex) :-
    f(Remaining, Index, [Head | History], Acc, MaxIndex).

Surprisingly not that long!

Clojure, 94 bytes
#(for[F[(frequencies %)]i(range 1(+(apply max %)1))_(range(-(apply max(vals F))(or(F i)0)))]i)

C++, 234 bytes
#include<vector>
#include<map>
using X=std::vector<int>;
X f(X x){int q,z;q=z=0;std::map<int,int>y;X o;
for(auto i:x)++y[i];for(auto i:y)q=q>i.second?q:i.second;
for(;++z<=y.rbegin()->first;)for(;y[z]++<q;)o.push_back(z);return o;}

(Newlines in the function body are for readability).
The function takes and returns a vector of ints. It utilizes std::map for finding the max element of the input list and also for counting the occurrences of each distinct element.
Explanation:
// necessary includes. Note that each of these is longer than whole Jelly program!
#include <vector>
#include <map>

// this type occurs three times in the code
using X = std::vector<int>;

// The function
X f (X x)
{
   // initialize some variables
   int q, z; // q will hold the max count
   q = z = 0;
   std::map <int, int> y; // The map for sorting
   X o; // The output vector

   // Populate the map, effectively finding the max element and counts for all of them
   for (auto i : x)
       ++y[i];

   // find the max count
   for (auto i : y)
       q = q > i.second ? q : i.second;

   // Populate the output vector

   // Iterate all possible values from 1 to the max element (which is the key at y.rbegin ())
   // Note that z was initialized at 0, so we preincrement it when checking the condition
   for (; ++z <= y.rbegin ()->first;)
       // for each possible value, append the necessary quantity of it to the output
       for(; y[z]++ < q;)
           o.push_back (z);

   return o;
}


text:
Count Like a Babylonian
Challenge
Given an ASCII representation of a Babylonian number as input, output the number in Western Arabic numerals.
Babylonian Numeral System
How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system. Let's first consider the unit column of the system:
The Babylonians had only three symbols: T (or, if you can render it: ) which represented 1, and < (or, if you can render it: ) which represented 10, and \ (or, if you render it: ) which represented zero.
Note: Technically, \ (or ) isn't zero (because the Babylonians did not have a notion of 'zero'). 'Zero' was invented later, so \ was a placeholder symbol added later to prevent ambiguity. However, for the purposes of this challenge, it's enough to consider \ as zero
So, in each column you just add up the value of the symbols, e.g.:
<<< = 30
<<<<TTTTTT = 46
TTTTTTTTT = 9
\ = 0

There will never be more than five < or more than nine T in each column. \ will always appear alone in the column.
Now, we need to extend this to adding more columns. This works exactly the same as any other base sixty, where you multiply the value of the rightmost column by \$60^0\$, the one to the left by \$60^1\$, the one to the left by \$60^2\$ and so on. You then add up the value of each to get the value of the number.
Columns will be separated by spaces to prevent ambiguity.
Some examples:
<< <TT = 20*60 + 12*1 = 1212
<<<TT \ TTTT = 32*60^2 + 0*60 + 4*1 = 115204

Rules

You are free to accept either ASCII input (T<\) or Unicode input ()
The inputted number will always be under \$10^7\$
The <s will always be to the left of the Ts in each column
\ will always appear alone in a column

Winning
Shortest code in bytes wins.

May we assume that the < will always be to the left of any Ts in a given column?

@TaylorScott Yes, you may

In case it helps:  Max that needs to be handled is 4 columns: <<<<TTTTTT <TTTTTTT <<<<TTTTTT <<<<

@KevinCruijssen Thanks! I guess I should proofread a little more carefully next time :D

Can I take the columns separated by newlines rather than spaces?

@Mr.Xcoder Sure

Are columns always separated by exactly one space each? I notice answers relying on it.

@KRyan Yes, they are

Foreign types with the hookah pipes say Ay oh whey oh, ay oh whey oh -
Count like a Babylonian.   Great.  Now it's stuck in my head.

"How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system." Which is still in use today; the Babylonian number system is exactly what we use for clocks. Two decimal digits each for seconds, minutes, and hours, 60 seconds to the minute, 60 minutes to the hour.

@cobaltduck Been in my head since I wrote it ;)

JavaScript (ES6), 44 bytes
Takes input as an array of ASCII characters.
a=>a.map(c=>k+=c<1?k*59:c<'?'?10:c<{},k=0)|k

Try it online!
How?
The Babylonian Numeral System can be seen as a 4-instruction language working with a single register -- let's call it the accumulator.
Starting with \$k=0\$, each character \$c\$ in the input array \$a\$ modifies the accumulator \$k\$ as follows:

space: multiply \$k\$ by \$60\$ (implemented as: add \$59k\$ to \$k\$)
<: add \$10\$ to \$k\$
T: increment \$k\$
\: do nothing; this is the NOP instruction of this language (implemented as: add \$0\$ to \$k\$)

C (gcc), 140 138 136 bytes

Saved two bytes thanks to ceilingcat.

B,a,b,y;l(char*o){y=B=0,a=1;for(char*n=o;*n;n++,B++[o]=b,a*=60)for(b=0;*n&&*n-32;n++)b+=*n-84?*n-60?:10:1;for(B=a;B/=60;y+=*o++*B);B=y;}

Try it online!

+1 Taking "count like a babylonian" to the next level :D

Perl 6, 39 bytes
-3 bytes thanks to nwellnhof
{:60[.words>>.&{sum .ords X%151 X%27}]}

Try it online!
Uses the cuneiform characters.
Explanation:
{                                     }   # Anonymous code block
     .words  # Split input on spaces
           >>.&{                    }  # Convert each value to
                sum   # The sum of:
                    .ords # The codepoints
                          X%151 X%27   # Converted to 0,1 and 10 through modulo
 :60[                                ]  # Convert the list of values to base 60

You beat me by a couple of minutes. Here's what I came up with: {:60[.words>>.&{sum (.ords X%151)X%27}]} (40 bytes)

@nwellnhof Very well done! How did you find the mod values?

Simply by brute force.

Jelly,  13  12 bytes
ḲO%7C%13§ḅ60

A monadic link accepting a list of characters which yields an integer.
Try it online!
How?
ḲO%7C%13§ḅ60 - Link: list of characters   e.g. "<<<TT \ TTTT"
Ḳ            - split at spaces                 ["<<<TT", "\", "TTTT"]
 O           - cast to ordinals                [[60,60,60,84,84],[92],[84,84,84,84]]
  %7         - modulo by seven (vectorises)    [[4,4,4,0,0],[1],[0,0,0,0]]
    C        - compliment (1-X)                [[-3,-3,-3,1,1],[0],[1,1,1,1]]
     %13     - modulo by thirteen              [[10,10,10,1,1],[0],[1,1,1,1]]
        §    - sum each                        [32,0,4]
         ḅ60 - convert from base sixty         115204

Another 12: ḲO⁽¡€%:5§ḅ60 (⁽¡€ is 1013, so this modulos 1013 by the Ordinal values getting 53, 5, and 1 for <, T, \ respectively then performs integer division, : by 5 to get 10, 1 and 0)

Lol, I've deleted my answer exactly because of this, since I remembered I could use base conversion but was literally too lazy to find out how. +1

Python 2, 96 93 87 85 bytes
lambda s:sum(60**i*sum(8740%ord(c)/4for c in v)for i,v in enumerate(s.split()[::-1]))

Try it online!

Saved:

-1 byte, thanks to Mr. Xcoder
-4 bytes, thanks to Poon Levi
-2 bytes, thanks to Matthew Jensen

95: (ord(c)%5/2or 11)-1

@Mr.Xcoder Thanks :)

87: 8740%ord(c)/4

-2 by removing the parentheses around the second sum()Try it online!

@MatthewJensen Thanks :)

@PoonLevi Thanks :)

05AB1E, 13 bytes
8740|Ç%4/O60β

Try it online!
To make up for how lazy I've been with my Jelly answer, here is a submission in 05AB1E xD.

Help 05AB1E-ers out there, wasn't there  a way to compress numbers like 8740?

https://codegolf.stackexchange.com/a/166851/52210 Unfortunately it wouldn't be shorter: •Yη• (4 bytes)

@KevinCruijssen Thank you! That answer is very useful, I'll totally use it in the future

Glad the tip is of use. :) I figured these things out after seeing some answers using them. The dictionary part was explained here. And the compression of other strings or large integers I figured out myself after seeing the linked example answers for "goose" and 246060.

1|Ç7%-13%O60β is also 13 - is it golfable?

@JonathanAllan I doubt it is golfable, but thanks for the suggestion. I'll try to improve it, but I don't see many opportunities

@Grimy Ah ok. I could use the weekend I see.. :/ And you're indeed right it's inconsistent for single characters, where the legacy returns that integer, and the new version returns it as a (single-item) list. I personally prefer the behavior of the legacy version.

Dyalog APL, 33 30 bytes
{+/(⌊10*⍵-3)×60*+\2=⍵}'\ T<'⍳⌽

Try it online!
Edit: -3 bytes thanks to ngn
'\ T<'⍳ replaces the characters with numbers (their position in the string constant), and ⌽ reverses the input so most significant 'digits' are last. This allows +\2= to keep a running count of the desired power of 60 (applied by 60*) by counting the number of times a space (index 2 in the string constant) is encountered.
⌊10*⍵-3 gives the desired power of ten for each character. The order of characters in the string constant and the -3 offset cause '\' and space to go to negative numbers, resulting in fractions when those characters are raised to the power of 10, allowing them to be eliminated by ⌊.
All we have to do now is multiply the powers-of-10 digits by the powers-of-60 place values and sum the lot up with +/.

save a few bytes by avoiding the separate comparison with ' ': {+/(⌊10*⍵-3)×60*+\2=⍵}'\ T<'⍳⌽

Excel VBA, 121 bytes
Restricted to 32-Bit Office as ^ serves as the LongLong type literal in 64-Bit versions
Takes input from cell A1 and outputs to the vbe immediate window.
a=Split([A1]):u=UBound(a):For i=0 To u:v=a(i):j=InStrRev(v,"<"):s=s+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))*60^(u-i):Next:?s

Ungolfed and Commented
a=Split([A1])       '' Split input into array
u=UBound(a)         '' Get length of array
For i=0 To u        '' Iter from 0 to length
v=a(i)              '' Get i'th column of input
j=InStrRev(v,"<")   '' Get count of <'s in input
                    '' Multiply count of <'s by 10; check for any T's, if present
                    ''   add count of T's
t=t+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))
    *60^(u-i)       '' Multiply by base
Next                '' Loop
?s                  '' Output to the VBE immediate window

Canvas, 20 17 16 bytes
Ｓ｛｛<≡Ａ×²T≡］∑］<ｃ┴

Try it here!
Explanation:
E{          ]     map over input split on spaces
  {       ]         map over the characters
   <≡A×               (x=="<") * 10
       ²T≡            x=="T"
           ∑        sum all of the results
             <c┴  and encode from base (codepoint of "<") to 10

Python 2, 62 bytes
lambda s:reduce(lambda x,y:x+[10,0,59*x,1]["<\ ".find(y)],s,0)

Try it online!
This uses the technique from Arnauld's answer.

APL(NARS ⎕io←0), 28 chars, 56 bytes
{60⊥{+/⍵⍳⍨10⍴'\T'}¨⍵⊂⍨⍵≠' '}

some test with type check:
  q←{60⊥{+/⍵⍳⍨10⍴'\T'}¨⍵⊂⍨⍵≠' '}

  o←⎕fmt
  o q '<< <TT'
1212
~~~~
  o q '<<<TT \ TTTT'
115204
~~~~~~

Each type result is number.

Bash (with sed and dc), 50 bytes
sed 's/</A+/g
s/T/1+/g
s/ /60*/g
s/\\//g'|dc -ez?p

Takes space-delimited input from stdin, outputs to stdout
Try it online!
Explanation
Uses sed to transform the input with a bunch of regular expression matches until, for example, the input <<<TT \ TTTT has been transformed to A+A+A+1+1+60*60*1+1+1+1+. Then this input is fed to dc with the explicit input execution command ?, preceded by z (pushes the stack length (0) to the stack so that we have somewhere to ground the addition) and followed by p (print).

J, 34 30 bytes
60#.1#.^:2(10 1*'<T'=/])&>@cut

Try it online!

JavaScript (Node.js), 122 114 107 106 83 bytes
a=>a.split` `.map(b=>[...b].map(c=>x+=c<'T'?10:c<'U',x=0)&&x).reduce((a,b)=>a*60+b)

Try it online!
I'm a little obsessed with "functional-style" array operations, uses ASCII input, as far as I can tell, JS isn't very good at getting charcodes golfily
I'm keeping this for posterity's sake, but this is a naive/dumb solution, I suggest you check out Arnauld's answer which is far more interesting an implementation of the challenge

@Shaggy looks like it works to me!

c<'T' works in place of c=='<'

Save 1 more by replacing && with |.

@Shaggy and save a lot more by using for...of loops :P

Dyalog APL, 35 32 bytes
f←{⍵+('<T\ '⍳⍺)⌷10,1,0,59×⍵}/∘⌽0∘,

Try it online!
31 in dzaima/APL

Retina, 29 26 23 bytes
<
10*T
+`^(.*)¶
60*$1
T

Try it online! Uses newline separation, but link includes header to use spaces instead for convenience. Edit: Saved 3 bytes with help from @KevinCruijssen. Saved a further 3 bytes thanks to @FryAmTheEggman. Explanation:
<
10*T

Replace each < with 10 Ts.
+`^(.*)¶
60*$1

Take the first line, multiply it by 60, and add the next line. Then repeat until there is only one line left.
T

Count the Ts.
Faster 51-byte version:
%`^(<*)(T*).*
$.(10*$1$2
+`^(.+)¶(.+)
$.($1*60*_$2*

Try it online! Uses newline separation, but link includes header to use spaces instead for convenience. Explanation:
%`^(<*)(T*).*
$.(10*$1$2

Match each line individually, and count the number of Ts and 10 times the number of <s. This converts each line into its base-60 "digit" value.
+`^(.+)¶(.+)
$.($1*60*_$2*

Base 60 conversion, running a line at a time. The computation is done in decimal for speed.

I'm pretty sure the third line can be just < without the +, unless I'm not seeing some kind of edge case.

@KevinCruijssen Even better, as $& is now always one character, I can use the default character, saving a further two bytes!

Ah nice! :) Didn't knew that could be done implicitly for single characters.

@KevinCruijssen Well, I don't care what the character is, as I'm only taking the length; in Retina 1 you get a _ while $* in earlier versions of Retina defaults to 1.

Ah, I see. Your initial code was taking all < as single match and repeat them 10 times the length (the amount of < in the match), and my proposed change is repeating every < separately 10 times (which you've golfed by 2 bytes more using the implicit 1 with 10*). Now I better understand why the + was there initially. I don't know too much about the Retina builtins, only regexes in general, hence my proposed change because I already read it as repeat every > 10 times. ;)

@FryAmTheEggman Wow, I'm impressed, thanks!

C (gcc), 65 64 63 bytes
f(s,o)char*s;{for(o=0;*s;s++)o+=*s>32?(93^*s)/9:o*59;return o;}

Try it online!

Replacing return o with s=o saves another 5 bytes.

Java 8, 64 60 bytes
a->{int r=0;for(int c:a)r+=c<33?r*59:c<63?10:84/c;return r;}

-4 bytes thanks to @ceilingcat.
Try it online.
Explanation:
a->{            // Method with character-array parameter and integer return-type
  int r=0;      //  Result-integer, starting at 0
  for(int c:a)  //  Loop over each character `c` of the input-array
    r+=         //   Increase the result by:
       c<33?    //    Is the current character `c` a space:
        r*59    //     Increase it by 59 times itself
       :c<63?   //    Else-if it's a '<':
        10      //     Increase it by 10
       :c<85?   //    Else (it's a 'T' or '\'):
        84/c;   //     Increase it by 84 integer-divided by `c`,
                //     (which is 1 for 'T' and 0 for '\')
  return r;}    //  Return the result

Ruby, 50 46 bytes
->a{x=0;a.bytes{|c|x+=[59*x,10,0,1][c%9%5]};x}

Try it online!
A basic port of Arnauld's answer improved by G B for -4 bytes.

45 bytes -actually 47 if you use "bytes" instead of "map"

Thanks @GB, I'll probably stick with the longer version, since taking input as raw bytecodes feels a bit too liberal for a language that normally supports strings.

Another byte off: 46 bytes

Noether, 55 bytes
I~sL(si/~c{"<"=}{k10+~k}c{"T"=}{!k}c{" "=}{k60*~k}!i)kP

Try it online!
Same approach as @Arnauld.

Charcoal, 26 bytes
≔⁰θＦＳ«≡ι ≦×⁶⁰θ<≦⁺χθT≦⊕θ»Ｉθ

Try it online! Link is to verbose version of code. Explanation:
≔⁰θ

Clear the result.
ＦＳ«...»

Loop over the input characters. The ≡ command is wrapped in a block to prevent it from finding a "default" block.
≡ι

Switch over the current character...
 ≦×⁶⁰θ

if it's a space then multiply the result by 60...
<≦⁺χθ

if it's a < then add 10 to the result...
T≦⊕θ

if it's a T then increment the result.
Ｉθ

Print the result.

R, 98  81 bytes
(u=sapply(scan(,""),function(x,y=utf8ToInt(x))y%%3%*%(y%%6)))%*%60^(sum(u|1):1-1)

Try it online!
Ridiculously long due to string parsing. Thanks Giusppe for shaving off 16 unnecessary bytes.
Define y the bytecode value of unicode input and R = y("T<\") = y("")
Observe that R%%3 = 1,2,0 and R%%6 = 1,5,0... so R%%3 * R%%6 = 1,10,0 !
The rest is easy: sum per column, then dot-product with decreasing powers of 60.

Porting Arnauld's asnwer using Reduce is likely to be more golfy.

doesn't scan(,"") split on spaces automatically?

nice trick with the mods, though! I was trying to figure that out but couldn't find it...and /60 can be replaced by -1 in the exponent expression for another byte off, plus the <- can be replaced by = since it's all in parentheses.

@Giuseppe I tried %%3 and it was promising so I kept looking... also using a dot product just saved me one additional byte :)

APL (Dyalog Extended), 18 bytesSBCS
Anonymous tacit prefix function.
60⊥10⊥¨≠'<T'∘⍧¨⍤⊆⊢

Try it online!
                  ⊢  the argument; "<<<TT \ TTTT"
       ≠             mask where different from space; [1,1,1,1,1,0,1,0,1,1,1,1]
                ⊆    enclose runs of 1; ["<<<TT","\","TTTT"]
               ⍤     on that
              ¨      for each one
             ⍧       Count the occurrences In it of the elements
            ∘        of the entire list
        '<T'         ["<","T"]; [[3,2],[0,0],[0,4]]
      ¨              for each one
   10⊥               evaluate as base-10 digits
60⊥                  evaluate as base-60 digits

F#, 128 bytes
let s(v:string)=Seq.mapFoldBack(fun r i->i*Seq.sumBy(fun c->match c with|'<'->10|'T'->1|_->0)r,i*60)(v.Split ' ')1|>fst|>Seq.sum

Try it online!
Ungolfed it would look like this:
let s (v:string) =
    Seq.mapFoldBack(fun r i ->
        i * Seq.sumBy(fun c ->
            match c with
                | '<' -> 10
                | 'T' ->1
                | _ -> 0
        ) r,
        i * 60) (v.Split ' ') 1
    |> fst
    |> Seq.sum

Seq.mapFoldBack combines Seq.map and Seq.foldBack. Seq.mapFoldBack iterates through the sequence backwards, and threads an accumulator value through the sequence (in this case, i).
For each element in the sequence, the Babylonian number is computed (by Seq.sumBy, which maps each character to a number and totals the result) and then multiplied by i. i is then multiplied by 60, and this value is then passed to the next item in the sequence. The initial state for the accumulator is 1.
For example, the order of calls and results in Seq.mapFoldBack for input <<<TT \ TTTT would be:
(TTTT, 1)     -> (4, 60)
(\, 60)       -> (0, 3600)
(<<<TT, 3600) -> (115200, 216000)

The function will return a tuple of seq<int>, int. The fst function returns the first item in that tuple, and Seq.sum does the actual summing.
Why not use Seq.mapi or similar?
Seq.mapi maps each element in the sequence, and provides the index to the mapping function. From there you could do 60 ** index (where ** is the power operator in F#).
But ** requires floats, not ints, which means that you need to either initialise or cast all the values in the function as float. The entire function will return a float, which (in my opinion) is a little messy.
Using Seq.mapi it can be done like this for 139 bytes:
let f(v:string)=v.Split ' '|>Seq.rev|>Seq.mapi(fun i r->Seq.sumBy(fun c->match c with|'<'->10.0|'T'->1.0|_->0.0)r*(60.0**float i))|>Seq.sum

Perl -F// -E, 39 bytes
$w+=/</?10:/T/?1:/ /?59*$w:0for@F;say$w

This reads the to be converted number from STDIN.
This is essential the same solution as given by @Arnauld using JavaScript.

Tcl, 134 bytes
proc B l {regsub {\\} $l 0 l
lmap c [lreverse $l] {incr s [expr 60**([incr i]-1)*([regexp -all < $c]*10+[regexp -all T $c])]}
expr $s}

Try it online!
In the reversed list, I loop incrementing the result in counting < and T (with -all regexp option) and incrementing a natural as power of 60.
Correct version (see comment)

It seems I failed this one, because of the \ in the last number... I should had a regsub {\\} $l0 l before the foreach loop....

05AB1E (legacy), 10 bytes
#Ç9%5BO60β

Try it online!
#               # split input on spaces
 Ç              # convert each character to its codepoint
  9%            # modulo 9 (maps  to 5,  to 1,  to 0)
    5B          # convert each to base 5 (5 becomes 10, 0 and 1 unchanged)
      O         # sum each column
       60β      # convert from base 60

05AB1E, 11 bytes
#Ç9%5B€O60β

Try it online!
Same algorithm, but in modern 05AB1E O doesn't work on lists of mixed ints and lists, so we need €O instead.

source: Stack Exchange

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

sort: votes


text:
A Knotty situation
Given the Dowker notation of a knot and its crossing signs, calculate its bracket polynomial.
Although there are more technical definitions, for this challenge it is enough to think of a knot as something made physically by attaching the two ends of a string together. Since knots exist in three dimensions, when we draw them on paper, we use knot diagrams - two-dimensional projections in which the crossings are of exactly two lines, one over and one under.

Here (b) and (c) are different diagrams of the same knot.
How do we represent a knot diagram on paper? Most of us aren't Rembrandt, so we rely on Dowker notation, which works as follows:
Pick an arbitrary starting point on the knot. Move in an arbitrary direction along the knot and number the crossings you encounter, starting from 1, with the following modification: if it's an even number and you're currently going over the crossing, negate that even number. Finally, pick the even numbers corresponding to 1, 3, 5, etc.
Let's try an example:

Taken with permission from wikimedia user Czupirek
On this knot, we chose "1" as our starting point and proceeded to move up and to the right. Every time we go over or under another piece of the rope, we assign the crossing point the next natural number. We negate the even numbers corresponding to strands that go over a crossing, for example [3,-12] in the diagram. So, this diagram would be represented by [[1,6],[2,5],[3,-12],[-4,9],[7,8],[-10,11]]. Listing the buddies of 1, 3, 5, 7, etc gives us [6,-12,2,8,-4,-10].
There are a few things to note here. First, the Dowker notation is not unique for a given knot, as we can choose an arbitrary starting point and direction. But, given the notation, one can fully determine the structure of the knot (technically, up to reflection of its prime knot components). While not all Dowker notations can form possible knots, in this problem you can assume that the input represents an actual knot.
To avoid the ambiguity between a knot's reflections, and to make the challenge easier to solve, you will also be given a list of crossing signs as input.

In a positive crossing the lower line goes to the left from the point of view of the upper line. In a negative crossing it goes to the right. Note that reversing the direction of going around the knot (i.e. reversing both the over line and under line) doesn't change the crossing signs. In our example the crossing signs are [-1,-1,-1,1,-1,1]. They are given in the same order as the Dowker notation, i.e. for crossings numbered 1, 3, 5, 7, etc.
In this challenge we will be calculating the bracket polynomial of a knot. It's an object that is invariant across most transformation of the knot diagram - a concept which makes it supremely useful in knot theory analysis. (Again, most knot theorists compute the bracket polynomial as an intermediate product on their way to computing the Jones polynomial, which is invariant across all transformations, but we will not be doing that.) So how does it work? The bracket polynomial is a Laurent polynomial - one in which the variable (traditionally named \$A\$) can be raised to negative powers, as well as positive.
For a given knot diagram \$D\$, the three rules for the polynomial, represented as \$\langle D\rangle\$, are:

A sole loop without any crossings has polynomial 1.
If we have a diagram consisting of \$D\$ and a loop disconnected from \$D\$, the polynomial for both is the polynomial for \$D\$ times \$(-A^2-A^{-2})\$.
This rule is the trickiest. It says that if you have a crossing in \$D\$ that looks like , then you can use this rule to simplify the knots in two different ways:

In the image above, the outlined crossing in the first diagram, which is of the form , can be transformed into  as in the second figure (a.k.a. positive smoothing), or  as in the third figure (negative smoothing).
So, the bracket polynomial of the first diagram is the bracket polynomial of the second times \$A\$ plus the third times \$A^{-1}\$, i.e.,

Confused yet? Let's do an example, trying to find the bracket polynomial of  (Note: this is two knots linked together. This sort of diagram will not be a potential input in this challenge since the inputs will only be single knots, but it may appear as an intermediate result in the algorithm.)
We first use rule 3

We use rule 3 again on both of the new knots

We substitute these 4 new knots into the first equation.

Applying rules 1 and 2 to these 4 tell us

So, this tell us

Congrats on completing your brief intro to knot theory!
Input
Two lists:

Dowker notation, e.g. [6,-12,2,8,-4,-10]. Numbering of the crossings must start from 1. The corresponding odd numbers [1,3,5,7,...] are implicit and must not be provided as input.
Signs (1/-1 or if you prefer 0/1 or false/true or '+'/'-') for the crossings corresponding to the Dowker notation, e.g [-1,-1,-1,1,-1,1].

Instead of a pair of lists, you could have a list of pairs, e.g. [[6,-1],[-12,-1],...
Output
Print or return the polynomial, for instance \$A^{-2}+5+A-A^3\$, as a list of coefficient-exponent pairs (or exponent-coefficient pairs) in increasing order of the exponents and without any zero coefficients, e.g. [[1,-2],[5,0],[1,1],[-1,3]].
Alternatively, output an odd-length list of coefficients correspondings to exponents \$-k\ldots k\$ for some \$k\in \mathbb{N}\$, e.g. [0,1,0,5,1,0,-1]. The central element is the constant term (coefficient before \$A^0\$). The leftmost and rightmost elements must not be both 0.
Rules
This is a code-golf challenge. None of the standard loopholes can be used, and libraries that have tools to calculate either Dowker notations, or Bracket polynomials, cannot be used. (A language that contains these libraries still can be used, just not the libraries/packages).
Tests
// 4-tuples of [dowker_notation, crossing_signs, expected_result, description]
[
 [[],[],[[1,0]],"unknot"],
 [[2],[1],[[-1,3]],"unknot with a half-twist (positive crossing)"],
 [[2],[-1],[[-1,-3]],"unknot with a half-twist (negative crossing)"],
 [[2,4],[1,1],[[1,6]],"unknot with two half-twists (positive crossings)"],
 [[4,6,2],[1,1,1],[[1,-7],[-1,-3],[-1,5]],"right-handed trefoil knot, 3_1"],
 [[4,6,2,8],[-1,1,-1,1],[[1,-8],[-1,-4],[1,0],[-1,4],[1,8]],"figure-eight knot, 4_1"],
 [[6,8,10,2,4],[-1,-1,-1,-1,-1],[[-1,-7],[-1,1],[1,5],[-1,9],[1,13]],"pentafoil knot, 5_1"],
 [[6,8,10,4,2],[-1,-1,-1,-1,-1],[[-1,-11],[1,-7],[-2,-3],[1,1],[-1,5],[1,9]],"three-twist knot, 5_2"],
 [[4,8,10,2,12,6],[1,1,-1,1,-1,-1],[[-1,-12],[2,-8],[-2,-4],[3,0],[-2,4],[2,8],[-1,12]],"6_3"],
 [[4,6,2,10,12,8],[-1,-1,-1,-1,-1,-1],[[1,-10],[2,-2],[-2,2],[1,6],[-2,10],[1,14]],"granny knot (sum of two identical trefoils)"],
 [[4,6,2,-10,-12,-8],[1,1,1,1,1,1],[[1,-14],[-2,-10],[1,-6],[-2,-2],[2,2],[1,10]],"square knot (sum of two mirrored trefoils)"],
 [[6,-12,2,8,-4,-10],[-1,-1,-1,1,-1,1],[[1,-2],[1,6],[-1,10]],"example knot"]
]

External resources
Not necessary for the challenge, but if you are interested:

A paper on Knot Polynomials
A paper on Dowker Notation

sandbox posts: 1, 2
thanks @ChasBrown and @H.Pwiz for catching a mistake in my definition of Dowker notation

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

@ngn: Much better! I was guessing that that was what was meant, but it's a bit of a tongue twister to express properly. :)

K (ngn/k), 196 193 185 177 172 bytes
-2 bytes thanks to @coltim
{N::2*n:#x;+/(-m-|/m:#'b)(|0,)/'b:(+/1-2*s){,/(&0|2*x;(#1_?{y[x]&:y@|x;y}[+,/y]/!N){-x+|x,:&4}/1;&0|-2*x)}'N!({(x,'1+|x;x+/:!2)}'(0<x)|:/'+(2*!n;-1+x|-x))@'/:+(0<y)=s:!n#2}

Try it online!
ungolfed:
f:{                                      /args: x:dowker notation, y:crossing signs
 N::2*n:#x                               /n:number of crossings, N:twice n
 s:1-2*!n#2                              /s:all possible sets of smoothing signs for the crossings (n*(2^n) matrix of -1 1)
 S:{(x,'1+|x;0 1+\:x:(0<x)|:/y,-1+x|-x)} /S:smoothe the crossing numbered x,y in dowker notation (x can be negative)
 a:N!(x S'2*!n)@'/:+~y=s                 /generate all possible smoothed knots (results consist of neighbour pairs that form sets of disjoint unknots)
 u::{#1_?{y[x]&:|y x;y}[+,/x]/!N}        /count number of disjoint unknots in a smoothed knot, minus one
 /       ^^^^^^^^^^^^^^^^^^^^^           /  transitive closure
 g::{-x+|x,:&4}                          /if x=L(A) is a laurent polynomial represented as list of coefficients centred on A^0 (the constant term)
 /                                       /  then g[x] represents (-A^2-A^(-2))*L(A)
 b:(+/s){,/(0<x)|:/(u[y]g/1;&2*x|-x)}'a  /build a laurent polynomials for each set of smoothing signs
 +/(-m-|/m:#'b)(|0,)/'b}                 /centre them and pad them to form a matrix and sum them to get the bracket polynomial

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

Try it online!
I regret nothing.  Input is a flattened list of pairs.
# Part 1: extract edges
(({})<

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

(({})[()()]<

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

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

>)}

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

{}{}(())

# Part 2: Compute bracket polynomial
{

  # Move degree/sign to other stack
  (<({}<({}<>)>)>)<>

  # If current shape has crossings:
  ((){[()](<

    # Consider first currently listed edge in set
    # Find the other edge leaving same crossing
    (({})<>){({}[({})]<>({}<>))}{}

    # Move to top of other stack
    # Also check for twist
    ({}<>({}<{}<>{({}<>)<>}>)[()])

    # Check for twist in current edge
    <>({}({})[()])

    (

      # Remove current edge if twist
      ([()]{()(<({}[({})]())>)}{})<{(<{}{}>)}{}>

      # Remove matching edge if twist
      <>{()((<({}()[({}<>)])<>>))}{}<{}{}>

    # Push 1 minus number of twists from current vertex.
    )

    # If number of twists is not 1:
    ((){[()]<

      # While testing whether number of twists is 2:
      ({}()<

        # Keep sign/degree on third stack:
        ({}<({}<

          # Duplicate current configuration
          <>({()<({}<>)<>>}<>){({}[()]<(({})<({()<({}<>)<>>})<>>)<>{({}[()]<<>({}<>)>)}{}>)}

        # Push sign and degree on separate stacks
        <>>)<>>)

      # If number of twists is not 2: (i.e., no twists)
      >)((){[()](<{}

        # Make first copy of sign/degree
        (({})<<>(({})<

          # Make second copy of sign/degree
          (<<>({}<<>({}<

            # Do twice:
            (()()){({}[()]<

              # Prepare search for vertex leading into crossing on other side
              ([{}]()<>)

              # While keeping destination on third stack:
              <>({}<

                # Search for matching edge
                <>{({}({})<>[({}<>)])}{}

              # Replace old destination
              {}>)

              # Move back to original stack
              {({}<>)<>}<>

            >)}{}

          # Add orientation to degree
          >{})>)>)

          # Move duplicate to left stack
          <>{}{({}<>)<>}<>

          # Create "fake" edges from current crossing as termination conditions
          ([({}<>)]<((()))>)(())<>

          # Create representation of "top" new edge
          ({}<>)<>{}({}[()])

          # While didn't reach initial crossing again:
          {

            # Keep destination of new edge on third stack
            <>({}<<>

              # Do twice:
              (()()){({}[()]<

                # Search for crossing
                ({}<<>{({}<>)<>}>){({}[({})]<>({}<>))}{}

                # Reverse orientation of crossing
                (({})<<>({}<>)<>([{}])>)

              >)}{}

              # Remove extraneous search term
              {}

            # Push new destination for edge
            >)

            # Set up next edge
            <>({}<(({})())>[()]<>)

          }

          # Get destination of last edge to link up
          {}({}<

            # Find edge headed toward original crossing
            <>{}([{}]()<{({}<>)<>}>){({}({})<>[({}<>)])}

          # Replace destination
          {}{}>)

          # Move everything to left stack
          {({}<>)<>}

          # Clean up temporary data
          <>{}{}{}

        # Push new sign/degree of negatively smoothed knot
        >{})>)

      # Else (two twists)
      # i.e., crossing is the twist in unknot with one half-twist
      >)}{}){(<{}

        # Copy sign and degree+orientation
        (({})<<>(({}{})<

          # Move sign to left stack
          <>(<({}<>)>)

          # Move copy of configuration to left stack
          <>{}{({}<>)<>}

        # Add an additional 4*orientation to degree
        <>>(({}){}){})>)

      >)}

    # Else (one twist)
    >}{}){(<

      # Invert sign and get degree
      {}([{}]<({}<

        # Search term for other edge leading to this crossing
        <>([{}]()<>)

        # With destination on third stack:
        <>({}<

          # Find matching edge
          <>{({}({})<>[({}<>)])}{}

        # Replace destination
        {}>)

        # Move stuff back to left stack
        {({}<>)<>}<>

      # Add 3*orientation to degree
      >({})({}){})>)

    >)}{}

  # Else (no crossings)
  >)}{}){{}

    # If this came from the 2-twist case, undo splitting.
    # If this came from an initial empty input, use implicit zeros to not join anything
    # New sign = sign - 2 * next entry sign
    (([{}]){}<>{}{}<

      # New degree = average of both degrees
      <>({}<>{})

      # Find coefficient corresponding to degree
      {([{}]({}()()<{}({}<>)(())<>>))}{}{}

    # Add sign to coefficient
    {}>{})

    # Move rest of polynomial back to right stack
    (())<>{{}({}<>)(())<>}

    # Set up next configuration
    (<>)<>

  }{}

}{}{}<>{}

# Step 3: Put polynomial in correct form

# Keeping constant term:
{}({}<

  # Move to other stack to get access to terms of highest absolute degree
  {{}({}<>)(())<>}<>

  # Remove outer zeros
  {{}{((<(())>))}{}}

  # Move back to right stack to get access to lower order terms
  {}{{}({}<>)(())<>}

>)<>

# While terms remain:
{

  # Move term with positive coefficient
  {}({}<(<()>)<>([]){{}({}<>)(())<>([])}{}>)<>{{}({}<>)<>}{}

  # Move term with negative coefficient
  {}({}<>)<>

}<>

Whoaaaaaa. Fantastic!!!! +1

I feel like I need to hand out another bounty

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


text:
Make an alphabeTrie
Consider the following alphabetically sorted list of words:
balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom

All of the words start with b, and the first 5 start with bal. If we just look at the first 2 words:
balderdash
ballet

we could write instead:
balderdash
  +let

where the ' ' is used where a word shares a prefix character with the previous word; except for the '+' character which indicates the LAST character where the second word shares a prefix with the previous word.
This is a sort of 'trie' visualization: the parent is 'bal', and has 2 descendants: 'derdash' and 'let'.
With a longer list, such as:
balderdash
ballet
brooding

we can additionally use the pipe character '|' to make it clearer where the shared prefix ends, as follows:
balderdash
| +let
+rooding

and the equivalent tree would have a root of 'b' having two children: the subtree having root 'al' and and its two children 'derdash' and 'let'; and 'rooding'.
If we apply this strategy to our original list,
balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom

we get output that looks like:
balderdash
| +let
|  +oonfish
|   | +ist
|   +t
+rooding
   +m

If two consecutive words in the list have no shared prefix, no special characters are substituted; e.g. for the list:
broom
brood
crude
crumb

we want the output:
broom
   +d
crude
  +mb

Input
The words in the input will be made up of only alphanumerics (no spaces or punctuation); this may be in the form of a list of strings, a single string, or any other reasonable approach, as long as you specify your chosen format. No two consecutive words will be the same. The list will be alphabetically sorted.
Output
Your output can contain trailing whitespace per line or in total, but no leading whitespace. A list of strings or similar would also be acceptable.
This is code-golf; the shortest code in each language retains bragging rights. The usual prohibitions against loopholes apply.
Test Cases
Input:
apogee
apology
app
apple
applique
apply
apt

Output:
apogee
 |+logy
 +p
 |+le
 | +ique
 | +y
 +t

Input:
balderdash
ballet
balloonfish
balloonist
ballot
brooding
broom
donald
donatella
donna
dont
dumb

Output:
balderdash
| +let
|  +oonfish
|   | +ist
|   +t
+rooding
   +m
donald
| |+tella
| +na
| +t
+umb

What about the case where I have the word ball after balloon. What output should we expect?

@RushabhMehta I'm guessing you would just have a + under the first o, but I didn't write the challenge so I'm not certain.

@RushabhMehta The words are alphabetically sorted, so this won't happen.

@Neil Oh good point

Can I assume that all words are limited to some reasonable length (like 99 characters)?

The words in the input will be made up of only alphanumerics: does that really include digits, or did you mean alphabetic?

@Curtis Bechtel: If you are concerned that your solution might be impractical due to real-world limitations on machine speed/memory, then don;t worry about that; but your solution should theoretically work for any finite sized input.

@Arnauld: Mostly I wanted to exclude edge cases which would be caused by having the input words include any of ' ','|','+'; I'm not otherwise particular.

Retina 0.8.2, 58 57 bytes
^((.*).)(?<=\b\1.*¶\1)
$.2$* +
m)+`^(.*) (.*¶\1[+|])
$1|$2

Try it online! Link includes one test case. Edit: Saved 1 byte thanks to @FryAmTheEggman pointing out that I overlooked a switch from \b to ^ made possible by the m). Explanation:
m)

Turn on per-line ^ for the whole program.
^((.*).)(?<=^\1.*¶\1)
$.2$* +

For each word, try to match as much as possible from the beginning of the previous word. Change the match to spaces, except the last character, which becomes a +.
+`^(.*) (.*¶\1[+|])
$1|$2

Repeatedly replace all spaces immediately above +s or |s with |s.

@FryAmTheEggman Indeed, I added the m) specifically to be able to do that, so I'm annoyed that I missed an instance.

Ugh, why do I even bother replying to comments if people are just going to delete them...

JavaScript (ES6), 128 bytes
Expects and returns a list of lists of characters.
a=>a.map((w,y)=>a[~y]=w.map(m=(c,x)=>(p=a[y-1]||0,m|=c!=p[x])?c:p[x+1]==w[x+1]?' ':(g=y=>a[y][x]<1?g(y+1,a[y][x]='|'):'+')(-y)))

Try it online!
How?
Spaces and +'s can be inserted by walking through the first to the last word in order, but |'s can only be inserted a posteriori once a + has been identified. This could be achieved by doing two distinct passes, but instead we save a pointer to each modified entry in a[~y] so that it can later be updated again within the same map() loop.
In theory, a simpler workaround would be to walk through the words in reverse order and to reverse the output as well at the end of the process. But this is a bit costly in JS and I didn't find a way to get a shorter version with this method.
a =>                           // a[] = input array
  a.map((w, y) =>              // for each word w at position y in a[]:
    a[~y] =                    //   save a pointer to the current entry in a[~y]
    w.map(m =                  //   initialize m to a non-numeric value
      (c, x) => (              //   for each character c at position x in w:
        p = a[y - 1] || 0,     //     p = previous word or a dummy object
        m |= c != p[x]         //     set m = 1 as soon as w differs from p at this position
      ) ?                      //     if w is no longer equal to p:
        c                      //       append c
      :                        //     else:
        p[x + 1] == w[x + 1] ? //       if the next characters are still matching:
          ' '                  //         append a space
        : (                    //       else:
            g = y =>           //         g() = recursive function to insert pipes
            a[y][x] < 1 ?      //           if a[y][x] is a space:
              g(               //             do a recursive call to g()
                y + 1,         //               with y + 1
                a[y][x] = '|'  //               and overwrite a[y][x] with a pipe
              )                //             end of recursive call
            :                  //           else:
              '+'              //             make the whole recursion chain return a '+'
                               //             which will be appended in the current entry
          )(-y)                //         initial call to g() with -y (this is ~y + 1)
    )                          //   end of map() over the characters
  )                            // end of map() over the words

would you look at my solution, i came up with it myself but it reminds of your solution. so if its too close you can submit it as yours (or not) and ill delete it :)

@DanielIndie No worries. It's different enough.

JavaScript (Node.js), 125 122 118 117 bytes
a=>a.map((w,i)=>a[i]=w.map((T,k)=>+i&&l[k]==T?l[-~k]<w[-~k]?(g=_=>a[--i][k]<"+"?g(a[i][k]="|"):"+")():" ":(i=l=w,T)))

Try it online!

thanks to @Arnauld for tio testing :)

Python, 263 260 bytes
-3 bytes thanks to Jonathan Frech
Code:
p=lambda t,f,g:"\n".join([(f[:-1]+"+"if(a!=min(t))*g else"")+a+p(t[a],(f+" "if len(t[a])>1or a==max(t)else f[:-1]+"| "),1)for a in t])if t else""
def a(t,x):
 if x:c=x[0];t[c]=c in t and t[c]or{};a(t[c],x[1:])
def f(*s):t={};[a(t,i)for i in s];return p(t,"",0)

Try it Online!
Explanation:
This solution builds a trie out of the input words and recursively parses it into the required output.  The a function takes a trie t and a string s and adds x to t.  Tries are implemented as nested dictionaries.  Each dictionary represents a node in the trie.  For example, the dictionary representing the trie generated by the first test case looks like this:
{'b': {'a': {'l': {'d': {'e': {'r': {'d': {'a': {'s': {'h': {}}}}}}}, 'l': {'e': {'t': {}}, 'o': {'o': {'n': {'f': {'i': {'s': {'h': {}}}}, 'i': {'s': {'t': {}}}}}, 't': {}}}}}, 'r': {'o': {'o': {'d': {'i': {'n': {'g': {}}}}, 'm': {}}}}}}

The p function recurses through this structure and generates the string representation of the trie expected by the challenge.  The f function takes a bunch of strings as arguments, adds them all to a trie with a, then returns the result of calling p on the trie.

Possible 252 bytes.

Perl 6, 149 144 142 bytes
{1 while s/(\n.*)\s(.*)$0(\+|\|)/$0|$1$0$2/;$_}o{$=({.[1].subst(/^(.+)<?{.[0].index($0)eq 0}>/,{' 'x$0.ords-1~'+'})}for '',|$_ Z$_).join("
")}

Try it online!
I'm sure this can be golfed a more, especially as I'm not an expert on regexes. This uses much the same process as Neil's Retina answer.

C (gcc), 165 155 bytes
Takes three arguments:

char** a : an array of null-terminated words
char* m : an array of the length of each word
int n : the number of words in the array

f(a,m,n,i,j)char**a,*m;{for(i=n;--i;)for(j=0;j<m[i]&j<m[i-1]&a[i][j]==a[i-1][j];j++)a[i][j]=a[i][j+1]^a[i-1][j+1]?43:++i<n&j<m[i]&a[i--][j]%81==43?124:32;}

Try it online!

Some quick wins

@Arnauld Of course! Although isn't ++i<n&j<m[i]&a[i--] undefined behavior? Can I rely on gcc evaluating it left to right?

It's very likely to be undefined behavior. But we define languages by their implementation, so as long as it works consistently with this version of gcc, I think that's fine.

Ruby, 118 bytes
->a{i=1;a.map{s="";a[i+=j=-1].chars{|c|a[i][j+=1]=i<0&&a[i-1][/^#{s+=c}/]?a[i+1][j]=~/[|+]/??|:?\s:c}[/[| ]\b/]&&=?+}}

Try it online!
Accepts an array of strings, outputs by modifying the original input array in-place.
Explanation
The basic string transformation is not too complex, but in order to insert vertical pipes properly, we need to iterate in reverse order, and since reverse method is quite verbose, we'll do it in a trickier way. Here, we use map just to run the loop, leave the first word alone, and then iterate from the end using negative indices:
->a{
 i=1;                   #Initialize word indexer
 a.map{                 #Loop
  s="";                 #Initialize lookup string
  a[i+=j=-1]            #Initialize char indexer and decrement i
  .chars{|c|            #Loop through each char c of current word
   a[i][j+=1]=          #Mofify current word at position j
    i<0&&               #If it's not the first word and
    a[i-1][/^#{s+=c}/]? #Word above matches current one from start to j
     a[i+1][j]=~/[|+]/? #Then if char below is | or +
      ?|:?\s:c          #Then set current char to | Else to Space Else leave as is
  }[/[| ]\b/]&&=?+      #Finally, replace Space or | at word boundary with +
 }
}

Python 2, 191 bytes
def f(w,r=['']):
 for b,c in zip(w[1:],w)[::-1]:
	s='';d=0
	for x,y,z in zip(r[0]+b,b,c+b):t=s[-1:];s=s[:-1]+[['+'*(s>'')+y,t+' |'[x in'+|']][y==z],t+y][d];d=d|(y!=z)
	r=[s]+r
 return[w[0]]+r

Try it online!


text:
Maximum Hamming distance among a list of padded strings
The Hamming distance between two strings of equal length is the number of positions at which the corresponding characters are different. If the strings are not of equal length, the Hamming distance is not defined.
Challenge
Write a program or function that finds the largest Hamming distance from among all pairs of strings from a list of strings, padded as required according to the rules described below.
The characters will be from within a-zA-Z0-9.
The strings may not be equal in length, so for each comparison the shorter string has to be padded as follows:

wrap the string from the beginning as many times as needed to match the required length
change the cases of the letters each odd time wrapping (1st, 3rd, 5th, etc.)
leave things outside a-zA-Z unchanged when wrapping

For example, let's say you need to pad the 5 character string ab9Cd so that it ends up with 18 characters. You would end up with:
ab9CdAB9cDab9CdAB9
     ^^^^^     ^^^

with ^ added underneath the 1st and 3rd wraps to highlight to case changes.
Input/Output
Input/output format is flexible. You can assume the input has at least two strings, and that all strings will have at least one character.
The output is an integer.
Rules
This is code-golf. Standard rules apply.
Test cases
[ "a", "b" ] => 1
[ "a", "b", "c" ] => 1
[ "a", "a", "c" ] => 1
[ "abc", "abcd" ] => 1
[ "abc12D5", "abC34d3", "ABC14dabc23DAbC89d"] => 17
[ "a", "Aaa", "AaaA", "aAaAa", "aaaaaaaaaaaaaa", "AAaAA", "aAa" ] => 8
["AacaAc", "Aab"] => 2

Reference implementation
I tested the examples with (completely ungolfed) R code that you can try here to compare any other examples you might try out with your code.

change the cases of the letters each odd time wrapping – Oh boy, this requirement is going to be a pain for my solution... I like the challenge, though, so +1

Suggested test case: ["AacaAc", "Aab"] => 2. A purposed golf to my Jelly answer would have failed that case, but would have passes all the other ones.

@ngm Excellent challenge! +1

Jelly, 20 bytes
Not really happy with it. Should be golfable, even to ~15 bytes perhaps.
LÞŒcµṁ/sḢL$ŒsÐeFn)§Ṁ

Try it online!
or Check out a test suite!
Explanation

LÞŒcµṁ/sḢL$ŒsÐeFn)§Ṁ    Full program or monadic link. N = input.                     | Example: ["abc12D5", "abC34d3", "ABC14dabc23DAbC89d"]
LÞ                      Sort N by length.                                            | [['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'C', '3', '4', 'd', '3'], ['A', 'B', 'C', '1', '4', 'd', 'a', 'b', 'c', '2', '3', 'D', 'A', 'b', 'C', '8', '9', 'd']] (in Jelly, strings are list of characters)
  Œc                    Unordered pairs: [x, y] for all distinct x, y in N.          | [[['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'C', '3', '4', 'd', '3']], [['a', 'b', 'c', '1', '2', 'D', '5'], ['A', 'B', 'C', '1', '4', 'd', 'a', 'b', 'c', '2', '3', 'D', 'A', 'b', 'C', '8', '9', 'd']], [['a', 'b', 'C', '3', '4', 'd', '3'], ['A', 'B', 'C', '1', '4', 'd', 'a', 'b', 'c', '2', '3', 'D', 'A', 'b', 'C', '8', '9', 'd']]]
                        Here, by distinct, I mean at different positions.            |
    µ            )      Map with a monadic link.                                     |
     ṁ/                 Mold x like y. That is, cycle x until it reaches length y.   | [['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1', '2', 'D', '5', 'a', 'b', 'c', '1', '2', 'D', '5', 'a', 'b', 'c', '1'], ['a', 'b', 'C', '3', '4', 'd', '3', 'a', 'b', 'C', '3', '4', 'd', '3', 'a', 'b', 'C', '3']]
       sḢL$             Split into chunks of x's length.                             | [[['a', 'b', 'c', '1', '2', 'D', '5']], [['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1']], [['a', 'b', 'C', '3', '4', 'd', '3'], ['a', 'b', 'C', '3', '4', 'd', '3'], ['a', 'b', 'C', '3']]]
           ŒsÐe         Swap the case of even-indexed chunks (1-indexed).            | [[['a', 'b', 'c', '1', '2', 'D', '5']], [['a', 'b', 'c', '1', '2', 'D', '5'], ['A', 'B', 'C', '1', '2', 'd', '5'], ['a', 'b', 'c', '1']], [['a', 'b', 'C', '3', '4', 'd', '3'], ['A', 'B', 'c', '3', '4', 'D', '3'], ['a', 'b', 'C', '3']]]
               F        Flatten.                                                     | [['a', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1', '2', 'D', '5', 'A', 'B', 'C', '1', '2', 'd', '5', 'a', 'b', 'c', '1'], ['a', 'b', 'C', '3', '4', 'd', '3', 'A', 'B', 'c', '3', '4', 'D', '3', 'a', 'b', 'C', '3']]
                n       Vectorized inequality with y.                                | [[[0, 0, 1, 1, 1, 1, 1]], [[1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], [[1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]]]
                  §     After ending the map, sum each bool (0 or 1) array.          | [[5], [17], [14]]
                   Ṁ    Maximum.                                                     | 17

I'm totally not familiar with Jelly, but I think you can omit LÞ and still get the same maximum at the end.

@ChasBrown Ugh, no, I should need that. Otherwise, instead of padding the shortest to the length of the longest one, ṁ/ would instead trim the longest to the length of the shortest one in some cases, which is not what we want.... I guess the test cases are too well chosen (and this is a rather unfortunate coincidence)...

@ChasBrown As an example, try ["AacaAc", "Aab"].

Ah yes, I see... I need to learn me some more Jelly... :)

Python 2, 86 bytes
lambda a:max(sum(x!=y for x,y in zip((s+s.swapcase())*len(t),t))for s in a for t in a)

Try it online!
Given two strings, s,t, zip((s+s.swapcase())*len(t),t)) will be a list of tuples of length len(t) since zip truncates to the shortest iterable. If len(s)<len(t), then this "pads out" s with the desired case swapping and we calculate the sum of differing characters.
If len(t)<=len(s), then the resulting sum will be less than or equal to the sum if we were evaluating t,s; so it has no effect on the resulting max in that case.

You can use y!= instead of !=y to save 1 byte

@Mr. Xcoder: Thx, but I ended up drastically reworking my solution...

JavaScript (Node.js), 111 bytes
a=>a.map(m=S=>a.map(s=>B(S).map((c,k)=>m=(c^(c=B(s)[k%(l=s.length)])^(k/l&c>9)<<5&&++x)<m?m:x,x=0)),B=Buffer)|m

Try it online!

Jelly, 19 bytes
WṁŒsÐeF=ċ0
LÞŒcç/€Ṁ

Try it online!
LÞŒcç/€Ṁ
LÞ         Sort by length
  Œc       unordered pairs
      €    to each of the pairs
    ç/     find the hamming distance with molding and swapping case (helper link)
       Ṁ   maximum

WṁŒsÐeF=ċ0
W            wrap the shorter string
 ṁ           repeat this string once for each character in the second string
    Ðe       for every other repeated string
  Œs         swap case
      F      flatten
       =     characterwise equality check between the two strings. If the first
             string is longer, the leftover characters are appended to the result.
             e.g. 'abABab' and 'xbA' give [0,1,1,'B','a','b']
        ċ0   count the number of 0s, giving the Hamming distance.

Ruby, 89 82 bytes
Creates the cross-product of the input list against itself before calculating the Hamming distance of each pair, using a duplication method similar to Chas Brown's answer. Ruby can't zip strings together or add booleans without additional overhead, though, so it becomes necessary to iterate through the pair of strings manually instead.
-7 bytes from GB.
->a{a.product(a).map{|s,t|(0...w=t.size).count{|i|(s+s.swapcase)[i%w]!=t[i]}}.max}

Try it online!

82 bytes

Java 10, 748 740 667 666 616 bytes
This has to be the most dense and unreadable, yet the longest golf I ever came up with.
Call method h(String[]) with an explicit array (no var args): eg,
h(new String[] {"a", "b", "c"});

returns 1.
char e(boolean w,char c){return(char)(w&(64<c&c<91|96<c&c<123)?c^32:c);}String p(String s,int l){var p="";int m=s.length(),n=l/m,r=l%m,i=0,j=0;var w=1<0;for(;i<n;++i,w=!w)for(char c:s.toCharArray())p+=e(w,c);for(;j<r;)p+=e(w,s.charAt(j++));return p;}int d(String s,String t){int l=s.length(),n=0,i=0;for(;i<l;)if(s.charAt(i)!=t.charAt(i++))++n;return n;}int h(String s,String t){int l=s.length(),m=t.length();return l>m?d(s,p(t,l)):l<m?d(p(s,m),t):d(s,t);}int h(String[]s){int l=s.length,i=0,j;int[]n=new int[l*l];for(;i<l;++i)for(j=i;++j<l;)n[i*l+j]=h(s[i],s[j]);return java.util.Arrays.stream(n).max().getAsInt();}

You can Try It Online!
Ungolfed and commented:
// Encode the character (swap case)
char e(boolean w, char c) {
    return (char) (w & (64 < c & c < 91 | 96 < c & c < 123) ? c ^ 32 : c);
}

// Pad the string to desired length
String p(String s, int l) {
    var p = "";
    int m = s.length(), n = l / m, r = l % m, i = 0, j = 0;
    var w = 1 < 0;
    for (; i < n; ++i, w = !w)
        for (char c : s.toCharArray())
            p += e(w, c);
    for (; j < r;)
        p += e(w, s.charAt(j++));
    return p;
}

// Calculate the actual hamming distance between two same-length strings
int d(String s, String t) {
    int l = s.length(), n = 0, i = 0;
    for (; i < l;)
        if (s.charAt(i) != t.charAt(i++))
            ++n;
    return n;
}
// Pad the strings as needed and return their hamming distance
int h(String s, String t) {
    int l = s.length(), m = t.length();
    return l > m ? d(s, p(t, l)) : l < m ? d(p(s, m), t) : d(s, t);
}

    // Dispatch the strings and gather their hamming distances, return the max
int h(String[] s) {
    int l = s.length, i = 0, j;
    int[] n = new int[l * l];
    for (; i < l; ++i)
        for (j = i; ++j < l;)
            n[i * l + j] = h(s[i], s[j]);
    return java.util.Arrays.stream(n).max().getAsInt();
}

I know a better solution can be achieved, especially for the string pairing part.
EDIT: shave off 8 bytes by changing the size of the int array in hammingDistance() to the square of the numbe of strings given. It also fixes an ArrayIndexOutOfBounds thrown in one of the test cases.
EDIT 2: Saved 33 bytes thanks to Kevin Cruijssen's comments: class declaration removed, names shortened to 1 char, operators changed, etc.
EDIT 3: Save 1 byte and reach Satan-approved score by changing method with var-arg to array.
EDIT 4: Save another 50 bytes thanks to Kevin Cruijssen, again: update Java version from 8 to 10 to use var keyword, removed StringBuilder instance, etc.

I don't have a lot of time, but some basic things to golf: Drop the class, only the methods is enough. Change all method and variable names to single bytes.. So instead of hammingDistance use d or some other unused variable. Most of your && can be & and || can be |. c^' ' can be c^32. boolean w = false; can be boolean w=0>1;. i=0 in the loop initialization can be removed and change the ,i,j to ,i=0,j. ++j can be removed and ++ can be added to the .charAt(j++). .toString() can be +"". for(j=i+1;j<l;++j) can be for(j=0;++j<l;). Etc. etc.

Tips for golfing in Java and Tips for golfing in  might be interesting to read through as well. :)

Thanks! That's some nice byte-lifting. Thanks for the links too, I'm taking a look at it and will edit asap!

Upvoted for the Satan-approved score. xD Some more small things: StringBuilder can be StringBuffer (if you switch to Java 10 it could be var b=new StringBuffer(l);. The boolean and char can then also be var. If you don't have Java 10 locally, it is available on TIO). In addition, for(;i<n;++i){for(char c:s.toCharArray())b.append(e(w,c));w=!w;} can be for(;i++<n;w=!w)for(char c:s.toCharArray())b.append(e(w,c));. And I'm pretty sure you can remove the StringBuffer completely and just use String and += instead of append.

Man, some many months of clean code and good coding practices made me forget how to even golf! I'll update my answer and include TIO.

459 bytes

05AB1E, 33 29 bytes
Ćü)€é©εćDš«s`g∍}®€¤‚ø€ζ€€Ë_Oà

Try it online or verify all test cases.
Can most likely be halved in byte-count, but it works..
Explanation:
Ć           # Enclose the input-list (adding the first item to the end of the list)
            #  i.e. ['ABC1','abcD','abCd32e'] → ['ABC1','abcD','abCd32e','ABC1']
 ü)         # Pair-vectorize each of them
            #  i.e. ['ABC1','abcD','abCd32e','ABC1']
            #   → [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
   €é       # Sort each pair by length
            #  i.e. [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
            #   → [['ABC1','abcD'],['abcD','abCd32e'],['ABC1','abCd32e']]
     ©      # Store this list in the register to re-use later on
ε        }  # Map each inner list in this list to:
 ć          # Head extracted
            #  i.e. ['abcD','abCd32e'] → 'abcD' and ['abCd32e']
  Dš        # Duplicate it, and swap the capitalization of the copy
            #  i.e. 'abcD' → 'ABCd'
    «       # Then merge it together
            #  i.e. 'abcD' and 'ABCd' → 'abcDABCd'
     s`     # Swap so the tail-list is at the top of the stack, and get it's single item
            #  i.e. ['abCd32e'] → 'abCd32e'
       g    # Get the length of that
            #  i.e. 'abCd32e' → 7
        ∍   # Extend/shorten the string to that length
            #  i.e. 'abcDABCd' and 7 → 'abcDABC'
®           # Get the saved list from the register again
 €¤         # Get the tail from each
            #  i.e. [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
            #   → ['abcD','abCd32e','abCd32e']
   ‚        # Pair it with the other list
            #  i.e. ['ABC1','abcDABC','ABC1abc'] and ['abcD','abCd32e','abCd32e']
            #   → [['ABC1','abcDABC','ABC1abc'],['abcD','abCd32e','abCd32e']]
    ø       # Zip it, swapping rows / columns
            #  i.e. [['ABC1','abcDABC','ABC1abc'],['abcD','abCd32e','abCd32e']]
            #   → [['ABC1','abcD'],['abcDABC','abCd32e'],['ABC1abc','abCd32e']]
     €ζ     # And then zip each pair again
            #  i.e. [['ABC1','abcD'],['abcDABC','abCd32e'],['ABC1abc','abCd32e']]
            #   → [['Aa','Bb','Cc','1D'],['aa','bb','cC','Dd','A3','B2','Ce'],['Aa','Bb','CC','1d','a3','b2','ce']]
€           # Then for each inner list
 €          #  And for each inner string
  Ë         #   Check if all characters are the same
            #    i.e. 'aa' → 1
            #    i.e. 'cC' → 0
   _        # And inverse the booleans
            #  i.e. [['Aa','Bb','Cc','1D'],['aa','bb','cC','Dd','A3','B2','Ce'],['Aa','Bb','CC','1d','a3','b2','ce']]
            #   → [[1,1,1,1],[0,0,1,1,1,1,1],[1,1,0,1,1,1,1]]
O           # Then sum each inner list
            #  i.e. [[1,1,1,1],[0,0,1,1,1,1,1],[1,1,0,1,1,1,1]] → [4,5,6]
 à          # And take the max as result
            #  i.e. [4,5,6] → 6

Java 11, 387 bytes
a->{int l=a.length,i=l,t,j=0,C[]=new int[l];var p=new String[l][2];for(;i-->0;p[i][0]=a[t>0?i:j],p[i][1]=a[t>0?j:i])t=a[i].length()<a[j=-~i%l].length()?1:0;i=0;for(var P:p){var s="";for(var x:P[0].getBytes())s+=(char)(x>64&x<91|x>96&x<123?x^32:x);for(P[0]=repeat(P[0]+s,t=P[1].length()).substring(0,t);t-->0;)if(P[0].charAt(t)!=P[1].charAt(t))C[i]++;i++;}for(int c:C)j=c>j?c:j;return j;}

Try it online. (NOTE: Since Java 11 isn't on TIO yet, String.repeat(int) has been emulated as repeat(String,int) for the same byte-count.)
Explanation:
a->{                      // Method with String-array parameter and integer return-type
  int l=a.length,         //  Length of the input-array
      i=l,                //  Index-integer, starting at the length
      t,j=0,              //  Temp-integers
      C[]=new int[l];     //  Count-array the same size as the input
  var p=new String[l][2]; //  String-pairs array the same size as the input
  for(;i-->0              //  Loop `i` in the range [`l`, 0)
      ;                   //    After every iteration:
       p[i][0]=           //     Set the first String of the pair at index `i` to:
               a[t>0?i:j],//      The smallest of the `i`'th or `j`'th Strings of the input-array
       p[i][1]=           //     And set the second String of the pair at index `i` to:
               a[t>0?j:i])//      The largest of the `i`'th or `j`'th Strings of the input-array
    t=a[i].length()<      //    If the length of the `i`'th item is smaller than
      a[j=-~i%l].length()?//    the length of the `i+1`'th item
                          //    (and set `j` to this `i+1` with wrap-around to 0 for the last item
       1                  //     Set `t` to 1 as flag
      :                   //    Else:
       0;                 //     Set `t` to 0 as flag
                          //  We've now created the String pairs, where each pair is sorted by length
  i=0;                    //  Reset `i` to 0
  for(var P:p){           //  Loop over the pairs
    var s="";             //   Temp-String starting empty
    for(var x:P[0].getBytes())
                          //   Loop over the characters of the first String of the pair
      s+=                 //    Append the temp-String with:
         (char)(x>64&x<91|x>96&x<123?
                         //      If the current character is a letter:
           x^32          //       Swap it's case before appending it to `s`
         :               //      Else (not a letter):
          x);            //       Append it to `s` as is
    for(P[0]=            //    Now replace the first String with:
        repeat(P[0]+s,   //     The first String appended with the case-swapped first String
               t=P[1].length())
                         //     Repeated `t` amount of times,
                         //     where `t` is the length of the second String of the pair
        .substring(0,t); //     And then shorten it to length `t`
        t-->0;)          //    Inner loop over the character of the now same-length Pairs
      if(P[0].charAt(t)!=P[1].charAt(t))
                         //     If the characters at the same indices in the pair are not equal
        C[i]++;          //      Increase the counter for this pair by 1
    i++;}                //    After every iteration of the outer loop,
                         //    increase `i` by 1 for the next iteration
  for(int c:C)           //  Now loop over the calculated counts
    j=c>j?c:j;           //   And set `j` to the maximum
  return j;}             //  And finally return this maximum `j` as result

R, 173 bytes
function(x,U=utf8ToInt,N=nchar)max(combn(x,2,function(z,v=z[order(N(z))])sum(U(substr(Reduce(paste0,rep(c(v[1],chartr('A-Za-z','a-zA-Z',v[1])),n<-N(v[2]))),1,n))!=U(v[2]))))

Try it online!
@ngm : I tried my best to golf your code (with my heavy customizations of course) but, as you well know, R is not very golfy in manipulating strings :P

I bet this can be sub 150 bytes, but I'm not sure how just yet.

@Giuseppe: I suspect that too... but I'm not really good in writing short strings manipulation codes and R doesn't help me very much either :D

@digEmAll I'm not going to try to solve my own challenge, but few possibilities might include outer to get all the combinations, and doing modular arithmetic on the code points in lieu of chartr.

@ngm: possible...I discarded the arithmetic approach because I couldn't find a short solution/formula to change the case for letters without touching the numbers...


text:
Codegolf Rainbow : Fun with Integer-Arrays
Introduction:
 (Source: Wikipedia)
When we look at a rainbow it will always have the colors from top to bottom:
Red; orange; yellow; green; blue; indigo; violet
If we look at these individual rings, the red ring is of course bigger than the violet ring.
In addition, it's also possible to have two or even three rainbow at the same time.
All this above combined will be used in this challenge:
Challenge:
Given a list of integers of exactly size 7, where each value indicates the color-particles available to form rainbows (where the largest index indicates red and the smallest index indicated violet), output the amount of rainbows that can be formed.
A single integer-rainbow has to have at least 3x violet, 4x indigo, 5x blue, 6x green, 7x yellow, 8x orange, 9x red. A second rainbow on top of it will be even bigger than the red ring of the first rainbow (including one space between them), so it will need at least 11x violet, 12x indigo, 13x blue, 14x green, 15x yellow, 16x orange, 17x red in addition to what the first rainbow uses. The third rainbow will start at 19x violet again.
Example:
Input-list: [15,20,18,33,24,29,41]
Output: 2
Why? We have 15x violet, and we need at least 3+11=14 for two rainbows. We have 20 indigo and we need at least 4+12=16 for two rainbows. Etc. We have enough colors for two rainbows, but not enough to form three rainbows, so the output is 2.
Challenge rules:

The integers in the input-array are guaranteed to be non-negative (>= 0).
The input-list is guaranteed to be of size 7 exactly.
When no rainbows can be formed we output 0.
Input and output format is flexible. Can be a list or array of integers of decimals, can be taken from STDIN. Output can be a return from a function in any reasonable output-type, or printed directly to STDOUT.

Minimum amount of colors required for n amount of rainbows:
Amount of Rainbows    Minimum amount per color
0                     [0,0,0,0,0,0,0]
1                     [3,4,5,6,7,8,9]
2                     [14,16,18,20,22,24,26]
3                     [33,36,39,42,45,48,51]
4                     [60,64,68,72,76,80,84]
5                     [95,100,105,110,115,120,125]
etc...

General rules:

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

Test cases:
Input:  [15,20,18,33,24,29,41]
Output: 2

Input:  [3,4,5,6,7,8,9]
Output: 1

Input:  [9,8,7,6,5,4,3]
Output: 0

Input:  [100,100,100,100,100,100,100]
Output: 4

Input:  [53,58,90,42,111,57,66]
Output: 3

Input:  [0,0,0,0,0,0,0]
Output: 0

Input:  [95,100,105,110,115,120,125]
Output: 5

Input:  [39525,41278,39333,44444,39502,39599,39699]
Output: 98

The 0,0,0,0,0,0,0 edge-case though :( (it does not fit with the 1-gap logic)

Pyth, 14 bytes
thS.ef<b*+tkyy

Test suite!
How?
Algortihm
First off, let's derive the formula this answer is based off. Let's call the function that gives the necessary amount of colour particles \$C(n, i)\$, where \$n\$ is the number of layers and \$i\$ is the index of the colour, 0-based. First, we note that for the \$n^\text{th}\$ layer alone (where \$n\$ is 1-indexed, in this case), we need \$L(n, i)=i+3+8(n-1)\$ colour particles. Keeping this in mind, we sum the results of each \$L(k, i)\$ for each layer \$k\$:
$$C(n, i)=\color{red}{\underbrace{(i+3)}_{1^\text{st} \text{ layer}}} + \color{blue}{\underbrace{(i+3+8)}_{2^\text{nd} \text{ layer}}}+\cdots + \color{green}{\underbrace{[i+3+8(n-1)]}_{n^\text{th} \text{ layer}}}$$
$$C(n, i)=(i+3)n+8\left(0+1+\cdots +n-1\right)$$
$$C(n, i) = (i+3)n+8\cdot\frac{(n-1)n}{2}=(i+3)n+4n(n-1)$$
$$C(n, i)=n(i+3+4n-4)\implies \boxed{C(n,i)=n(4n+i-1)}$$
Therefore, we now know that the maximum number of possible layers, call it \$k\$, must satisfy the inequality \$C(k, i) \le I_i\$, where \$I_i\$ is the \$i^\text{th}\$ element of the input list.
Implementation
This implements the function \$C\$, and iterates (.e) over the input list, with \$k\$ being the index (0-based) and \$b\$ being the element. For each value, the program searches the first positive integer \$T\$ for which \$b<C(T, i)\$ (the logical negation of \$C(T, i)\le b\$, the condition we deduced earlier), then finds the minimum result and decrements it. This way, instead of searching for the highest integer that does satisfy a condition, we search for the lowest that does not and subtract one from it to make up for the offset of 1.

Python 2, 64 61 bytes
lambda l:min(((16*v+i*i)**.5-i)//8for i,v in enumerate(l,-1))

Try it online!

Each colour of the rainbow uses (3+i)+n*8 for layer n and color i(0=violet, etc.)
The total for x layers is therefore: (3*i)*x + 8*x*(x+1).
We simply solve for n, and take the minimum value.

Saved:

-3 bytes, thanks to ovs

Ah, now I get that response ...

61 bytes

05AB1E, 18 17 16 bytes
-1 byte thanks to Magic Octopus Urn
[ND4*6Ý<+*¹›1å#N

Try it online!
The amount of colour needed for n rainbows is n(4n + [-1, 0, 1, 2, 3, 4, 5]).

[ND4*6Ý<+*¹›1å#N works but I don't know why. -1 byte though.

@MagicOctopusUrn Thanks! That just uses the loop index instead of the counter variable.

Seems weird I don't have to do N> though-- because you had ¾> before.

@MagicOctopusUrn The command to increase the counter variable doesn't push the counter variable.

JavaScript (ES6), 49 bytes
f=(a,n)=>a.some((v,k)=>v<4*n*n-~-k*n)?~n:f(a,~-n)

Try it online!
How?
The number \$P_{(n,k)}\$ of color particles required to generate \$n\$ times the \$k\$-th color is:
$$P_{(n,k)}=n(4n+(k-1))=4n^2+(k-1)n$$
We recursively try all values of \$n\$ until at least one entry \$v_k\$ in the input array is lower than \$P_{(n,k)}\$.
But for golfing purposes, we start with n === undefined and use negative values of n afterwards. The first iteration is always successful because the right side of the inequality evaluates to NaN. Therefore, the first meaningful test is the 2nd one with n == -1.

Jelly, 18 bytes
Ṁµ×4+-r5¤×)⁸<Ẹ€¬TṪ

Try it online!
Uses the explanation in Okx's 05AB1E answer.

Excel VBA, 78 bytes
Anonymous function that takes input from the range of [A1:G1] and outputs to the VBE immediate window.
[A2:G999]="=A1-(COLUMN()+8*ROW()-14)":[H:H]="=-(MIN(A1:G1)<0)":?998+[Sum(H:H)]

Charcoal, 21 bytes
Ｉ⌊ＥＡ÷⁻Ｘ⁺Ｘ⊖κ²×¹⁶ι·⁵⊖κ⁸

Try it online! Link is to verbose version of code. Explanation: Directly calculates the number of rainbows possible with each colour with a formula I derived independently but turns out to be the same as @TField's formula.
   Ａ                   Input array
  Ｅ                     Map over values
          κ             Current index
         ⊖              Decrement
        Ｘ  ²            Square
               ι        Current index
            ×¹⁶         Multiply by 16
       ⁺                Add
      Ｘ         ·⁵      Square root
                   κ    Current index
                  ⊖     Decrement
     ⁻                  Subtract
    ÷               ⁸   Integer divide by 8
 ⌊                      Take the maximum
Ｉ                       Cast to string
                        Implicitly print

JavaScript (Node.js), 54 bytes
Port of @TFeld answer
_=>Math.min(..._.map((a,i)=>((16*a+--i*i)**.5-i)/8))|0

Try it online!

Jelly, 14 bytes
This was hard!
Ṃ+9s8Ṗ‘+\>Ż§ỊS

A monadic Link accepting a list of seven integers which yields an integer, the number of rainbows possible.
Try it online! Or see the test-suite.
How?
Unfortunately any naive method seems to take 16 bytes, one such method is  Ṃɓ_J×¥H÷‘H<¬Ȧð€S, however it turns out the method used here is much more efficient as well as shorter!
This method builds more than enough rainbow stacks as particle counts, including ultra-violet bands, and adds up 1 for each stack which is possible.
The test for it being possible is to check that there is only a single band NOT possible given we need some ultra-violet band particles but were provided zero.
Ṃ+9s8Ṗ‘+\>Ż§ỊS - Link list of integers    e.g. [0,0,0,0,0,0,0]        or [17,20,18,33,24,29,41]
Ṃ              - minimum                       0                         17
 +9            - add nine                      9                         26
   s8          - split into eights             [[1,2,3,4,5,6,7,8],[9]]   [[1,2,3,4,5,6,7,8],[9,10,11,12,13,14,15,16],[17,18,19,20,21,22,23,24],[25,26]]
     Ṗ         - discard the rightmost         [[1,2,3,4,5,6,7,8]]       [[1,2,3,4,5,6,7,8],[9,10,11,12,13,14,15,16],[17,18,19,20,21,22,23,24]]
      ‘        - increment (vectorises)        [[2,3,4,5,6,7,8,9]]       [[2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17],[18,19,20,21,22,23,24,25]]
               -   (single rainbow counts, including ultra-violet bands, ready to stack)
       +\      - cumulative addition           [[2,3,4,5,6,7,8,9]]       [[2,3,4,5,6,7,8,9],[12,14,16,18,20,22,24,26],[30,33,36,39,42,45,48,51]]
               -   (stacked rainbow counts, including ultra-violet bands)
          Ż    - zero concatenate              [0,0,0,0,0,0,0,0]         [0,17,20,18,33,24,29,41]
               -   (we got given zero ultra-violet band particles!)
         >     - greater than? (vectorises)    [[1,1,1,1,1,1,1,1]]       [[1,0,0,0,0,0,0,0],[1,0,0,0,0,0,0,0],[1,1,1,1,1,1,1,1]]
               -   (always a leading 1 - never enough particles for the ultra-violet band)
           §   - sum each                      [8]                       [1,1,8]
               -   (how many bands we failed to build for each sacked rainbow?)
            Ị  - insignificant? (abs(X)<=1?)   [0]                       [1,1,0]
               -   (1 if we only failed to build an ultra-violet band for each sacked rainbow, 0 otherwise)
             S - sum                           0                         2
               -   (the number of rainbows we can stack, given we don't see ultra-violet!)

I feel you, it definitely was too hard for me to squeeze Okx's algorithm in 18 bytes...

Also, clever idea with the §ỊS!

05AB1E, 14 bytes
žv*āÍn+tā-Ì8÷ß

Try it online!
A closed-form solution which does not require additional looping rather than the map. This works by adapting my Pyth's answer's formula to match 05AB1E's indexing convention, then solving for \$n\$, which happens to match TFeld's algorithm.
Pyth algorithm ⟶ 05AB1E Algorithm
There are many methods one can try for solving this challenge in 05AB1E, so I tried a couple of them and this turned out to be the shortest. Adapting the aforementioned formula from my Pyth answer, keeping in mind that 05AB1E used 1-indexing, we can construct our function as follows:
$$C(n,i)=n(i+2)+4n(n-1)$$
Setting it equal to the element of the input (\$I\$) at index \$i\$ and writing it in standard (quadratic) polynomial notation, we have:
$$4n^2+n(i-2)-I_i=0$$
Note that this equality is not precise (but I currently don't know of a way to state this more formally) and that the solutions to this equation will yield floating-point numbers, but we fix this by using floor division rather than precise division later on. Anyway, to continue on with our argument, most of you are probably very familiar with the solutions of such an equation, so here we have it:
$$n_{1, 2}=\frac{2-i\pm\sqrt{(i-2)^2+16I_i}}{8}$$
As \$I_i\$ is always positive, \$\sqrt{(i-2)^2+16I_i}\ge i-2\$, so the "\$-\$" case doesn't make much sense, because that would be either \$2-i-i+2=4-2i\$, which is negative for \$i\ge 2\$ or \$2-i-2+i=4\$, which is constant. Therefore, we can conclude that \$n\$ is given by:
$$n=\left \lfloor\frac{2+\sqrt{(i-2)^2+16I_i}-i}{8}\right \rfloor$$
Which is exactly the relation that this answer implements.

C++, 127 125 bytes
Shaved off 2 bytes thanks to Kevin Cruijssen.
#include<cmath>
int f(int x[7]){size_t o=-1;for(int c=0,q;c<7;c++,o=o>q?q:o)q=(std::sqrt(--c*c-c+16*x[++c])-c+1)/8;return o;}

Try it online!
The function takes a C-style array of seven ints and returns an int.
The algorithm is pretty straightforward (and have already been described a number of times previously, so here is one more description, mostly for my own viewing pleasure).
Let \$c\$ be the color index (\$0\le c\le6\$), so the required number of particles to form \$n\$-th \$(n\ge1)\$ rainbow part of that color is \$y_c(n)=(c+3)+8(n-1)\$, and the total amount of particles to form \$n\$ rainbow parts of the color is then \$Y_c(n)=\sum_{k=1}^{n}y_c(k)=n(c+3)+\frac{8n(n-1)}{2}\$. Now we have a system of inequalities \$x_c\ge Y_c(n)\$ (where \$x_c\$ is the elements of input array), which gives us a set of upper bounds on \$n:\$ $$n\le\frac{-(c-1) + \sqrt{(c-1)^2 + 16x_c}}{8}$$.
What is left is just iterate over \$x_c\$ and find the minimum.
Explanation:
#include <cmath> // for sqrt

int f (int x[7])
{
     // Note that o is unsigned so it will initially compare greater than any int
     size_t o = -1;
     // Iterate over the array
     for (int c = 0; c < 7; c++)
     {
         // calculate the bound
         int q = c - 1;
         q = (std::sqrt (q * q + 16 * x[c]) - q) / 8;

         // if it is less than previously found - store it
         o = o > q ? q : o;
     }
     return o;
 }

Hi there, welcome to PPCG! I don't know C++ too well, but I'm pretty sure you can golf this part: for(int c=0;c<7;c++){int q=c-1;q=(std::sqrt(q*q+16*x[c])-q)/8;o=o>q?q:o;} to this: for(int c=0,q;c<7;c++,o=o>q?q:o)q=(std::sqrt(--c*c-c+16*x[++c]))/8;. Also, could you perhaps provide a TIO-link with test code?

@KevinCruijssen Thank you!