text:
Compute the RFC 2550 timestamp
RFC 2550 is a satirical proposal (published on April 1, 1999) for a space-efficient ASCII representation of timestamps that can support any date (even those prior to the beginning of the universe and those past the predicted end of the universe). The algorithm for computing a RFC 2550-compliant timestamp is as follows (note: all ranges include the start but exclude the end - 0 to 10,000 means all n where 0 <= n < 10000):

Year format
Years 0 to 10,000: a 4-digit decimal number, left-padded with zeroes.
Years 10,000 to 100,000: a 5-digit decimal number, prefixed with the character A.
Years 100,000 to 1030: the decimal number for the year, prefixed with the uppercase ASCII letter whose index in the English alphabet is equal to the number of digits in the decimal year, minus 5 (B for 6-digit years, C for 7-digit years, etc.).
Years 1030 to 1056: the same format as 10,000 to 1030, starting the letters over with A, and additionally prefixing a caret (^) to the string (so the year 1030 is represented by ^A1000000000000000000000000000000, and the year 1031 is represented by ^B10000000000000000000000000000000).
Years 1056 to 10732: the year is prefixed by two carets and two ASCII uppercase letters. The uppercase letters form a base-26 number representing the number of digits in the year, minus 57.
Years 10732 onwards: the same format for 1056 to 10732 is used, extending it by adding an additional caret and uppercase letter when necessary.
BCE years (prior to Year 0): compute the year string of the absolute value of the year. Then, replace all letters by their base-26 complement (A <-> Z, B <-> Y, etc.), replace all digits by their base-10 complement (0 <-> 9, 1 <-> 8, etc.), and replace carets with exclamation marks (!). If the year string is 4 digits or less (i.e. -1 to -10,000), prepend a forward slash (/). If the year string is not prefixed by a forward slash or an exclamation mark, prepend an asterisk (*).
Months, days, hours, minutes, and seconds: since these values are only ever 2 digits at the most, they are simply appended to the right of the year string, in decreasing order of significance, left-padded with zeroes if necessary to form 2-digit strings.
Additional precision: if additional precision (in the form of milliseconds, microseconds, nanoseconds, etc.) is needed, those values are left-padded with zeroes to 3 digits (because each value is 1/1000 of the previous value, and thus is at most 999) and appended to the end of the timestamp, in decreasing order of significance.

This format has the benefit of lexical sorting being equivalent to numeric sorting of the corresponding timestamp - if time A comes before time B, then the timestamp for A will come before the timestamp for B when lexical sorting is applied.
##The challenge
Given an arbitrarily-long list of numeric values (corresponding to time values in decreasing order of significance, e.g. [year, month, day, hour, minute, second, millisecond]), output the corresponding RFC 2550 timestamp.
##Rules

Solutions must work for any given input. The only limitations should be time and available memory.
Input may be taken in any reasonable, convenient format (such as a list of numerics, a list of strings, a string delimited by a single non-digit character, etc.).
The input will always contain at least one value (the year). Additional values are always in decreasing order of significance (e.g. the input will never contain a day value without a month value, or a second value followed by a month value).
Input will always be a valid time (e.g. there won't be any timestamps for February 30th).
Builtins which compute RFC 2550 timestamps are forbidden.

##Examples
These examples use input as a single string, with the individual values separated by periods (.).
1000.12.31.13.45.16.8 -> 10001231134516008
12.1.5.1 -> 0012010501
45941 -> A45941
8675309.11.16 -> C86753091116
47883552573911529811831375872990.1.1.2.3.5.8.13 -> ^B478835525739115298118313758729900101020305008013
4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11 -> ^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711
-696443266.1.3.6.10.15.21.28 -> *V3035567330103061015021028
-5342 -> /4657
-4458159579886412234725624633605648497202 -> !Q5541840420113587765274375366394351502797

##Reference implementation
#!/usr/bin/env python

import string

# thanks to Leaky Nun for help with this
def base26(n):
    if n == 0:
        return ''
    digits = []
    while n:
        n -= 1
        n, digit = divmod(n, 26)
        digit += 1
        if digit < 0:
            n += 1
            digit -= 26
        digits.append(digit)
    return ''.join(string.ascii_uppercase[x-1] for x in digits[::-1])

year, *vals = input().split('.')

res = ""
negative = False

if year[0] == '-':
    negative = True
    year = year[1:]

if len(year) < 5:
    y = "{0:0>4}".format(year)
elif len(year) <= 30:
    y = "{0}{1}".format(string.ascii_uppercase[len(year)-5], year)
else:
    b26len = base26(len(year)-30)
    y = "{0}{1}{2}".format('^'*len(b26len), b26len, year)

if negative:
    y = y.translate(str.maketrans(string.ascii_uppercase+string.digits+'^', string.ascii_uppercase[::-1]+string.digits[::-1]+'!'))
    if len(year) == 4:
        y = '/' + y
    if y[0] not in ['/', '!']:
        y = '*' + y

res += y
for val in vals[:5]: #month, day, hour, minute, second
    res += '{0:0>2}'.format(val)

for val in vals[5:]: #fractional seconds
    res += '{0:0>3}'.format(val)

print(res)

Surely -696443266.1.3.6.10.15.21.28 should be *V3035567339896938984978971?

@Neil Only the years get transformed for BCE.

Sorry, I was getting confused there, although the year is negative, the other parts are still positive of course.

@Neil Until we invent negative months. Negember.

@TaylorScott Additional precision: if additional precision (in the form of milliseconds, microseconds, nanoseconds, etc.) is needed, those values are left-padded with zeroes to 3 digits.

@TaylorScott The explanation of the format describes it clearly: each character maps to the corresponding character on the opposite end of the alphabet (A -> Z, B -> Y, etc, and vice-versa), and each digit d maps to 9-d.

It looks to me like the spec given in the question doesn't actually match RFC2550. As I understand it, once you get past three carets the number of letters should increase faster than the carets do, because it's derived from the Fibonacci series (4 carets means 5 letters, 5 carets means 8 letters, etc.) Is it safe to assume we should be ignoring that aspect of the RFC?

@JamesHolderness You're right, I messed up the spec. However, it's too late to correct it, as there are already answers that would be invalidated.

@Mego : isn’t a bounty of 2550 more appropiate? ;-#

@Mego Is a single leading space allowed in the output?

@dylnan Sure, since it doesn't affect the format any

@Mego What was the winning criterion for the bounty? Also wasn't it 150 points?

@dylnan There was no winning criteria for the bounty. Because I wasn’t available to award it, it got awarded automatically, which I believe is why the bounty amount got cut in half.

Befunge, 418 384 bytes
It's hard to tell in advance how large a Befunge program is likely to end up, and when I started working on this I thought it might actually have some chance of competing. Turns out I was wrong.
~:59*-!:00p:2*1\-10p:9*68*+20p>0>#~$_v
68*-:0\`30p\>>:"P"%\"P"/9+p30g#v_1+:~>
0\`v`\0:\p04<<:+1g04-$<_\49+2*v>0>+#1:#\4#g\#0`#2_130p040p5-::01-`\49+2*-:
v:$_\50p\$:130g:1+30p:!^!:-1\*<>g*"A"++\49+2*/50g1-:
_$1+7g00g40g!**:!>_40g:!v!:\g8<^00*55*g01%*2+94:p05
|#9/"P"\%"P":<:_,#!>#:<$_1-00g^v3$\_\#`\0:>#g+
>10g*20g+,1+:^v\&\0+2`4:_@#`<0+<
/*v*86%+55:p00<_$$>:#,_$1+~0^
^!>+\55+/00g1-:^

Try it online!

JavaScript (ES6), 325 bytes

f=
s=>s.split`.`.map((n,i)=>i?`00${n}`.slice(i>5?-3:-2):n<'0'?g(n.slice(1),'!','*','/').replace(/\w/g,c=>c>'9'?(45-parseInt(c,36)).toString(36):9-c):g(n),g=(n,c='^',d='',e='',l=n.length)=>l<5?e+`000${n}`.slice(-4):l<31?d+(l+5).toString(36)+n:h(l-30,c)+n,h=(n,c)=>n?c+h(--n/26|0,c)+(n%26+10).toString(36):'').join``.toUpperCase()
;
<input oninput=o.value=f(this.value);><input id=o>

Shockingly long.

Would you mind adding a Stack Snippet for easy testing?

@Mego Done. Also fixed some typos that crept in (I accidentally deleted some of the code when copying and pasting because the line wrapping confused me. Oops.)

Java 11, 653 640 637 623 618 595 589 bytes
s->{String e="",r=e,q="ABCDEFGHIJKLMNOP",z=q+"QRSTUVWXYZ",y="0123456789",x;int i=0,f=0,t,u,v;for(var p:s){p=p.charAt(v=0)<46?p.substring(f=1):p;t=p.length();if(i++<1){r+=(t<5?"0".repeat(4-t):t<32?(char)(t+60):t<58?"^"+(char)(t+33+(v=1)):e);if(t>57){for(v=2,u=675;u<t-57;u*=26)v++;r+="^".repeat(v);x=e;for(var c:Long.toString(t-57,26).toUpperCase().split(e))x+=z.charAt((y+q).indexOf(c));r+=x;}r+=p;if(f>0){x=t<5?"/":t<32?"*":"!".repeat(v);for(int c:r.getBytes())x+=c>93?e:new StringBuffer(y+z).reverse().charAt((z+y).indexOf(c));r=x;}}else r+=i>6?t<2?"00"+p:t<3?0+p:p:t<2?0+p:p;}return r;}

Input as String-array and return-type as String.
Turned out to be quite long (as expected), but can definitely be golfed some more. I'm just glad it works after fiddling with it for quite a while..
-5 bytes thanks to @ceilingcat.
Try it here.
Explanation:

for(var p:s){: Loop over the parts

p=p.charAt(0)<46?p.substring(f=1):p;: Determine if it's negative, and if it is, remove the minus sign and set a flag to reduce bytes
t=p.length();: Get the amount of digits
if(i++<1){: If it's the first number (the year):

t<5?"0".repeat(4-t): If it's in the range \$[0, 100000)\$: add leading zeroes if necessary
t<32?(char)(t+60): If it's in the range \$[100000, 10^{30})\$: Add a leading letter
t<58?"^"+(char)(t+33+(v=1)): If it's in the range \$[10^{30}, 10^{732})\$: Add a literal "^" (and set v to 1) + leading letter
if(t>57)for(v=2,u=675;u<t-57;u*=26)v++;r+="^".repeat(v): Add the appropriate amount of literal "^" (and set v to that amount), plus x=e;for(var c:Long.toString(t-57,26).toUpperCase().split(e))x+=z.charAt((y+q).indexOf(c));r+=x;: leading letters (base-26 to alphabet conversion)
r+=p;: Add the year itself to the result-String
if(f>0){: If the year was negative:

x=t<5?"/":t<32?"*":"!".repeat(v);: Create a temp String x with the correct /, * or v amount of !
for(int c:r.getBytes())x+=c>93?e:new StringBuffer(y+z).reverse().charAt((z+y).indexOf(c));: Do the conversion (A↔Z, B↔Y, 0↔9, 1↔8, etc.)
r=x;: And then set the result to this temp String x

else: If it's the month, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, or smaller:

i>6?t<2?"00"+p:t<3?0+p:p: If it's milliseconds or smaller: Add leading zeroes if necessary
:t<2?0+p:p;: Else (month, days, hours, minutes, seconds): Add single leading zero if necessary

return r: Return the result

Input may be taken in any reasonable, convenient format (such as a list of numerics, a list of strings, a string delimited by a single non-digit character, etc.). - you could take input as a list of numerics, and skip the costly splitting and conversion.

@Mego Unfortunately default numerics (long with 64 bits being the largest) are too small in Java for some of the inputs, so String is shorter than java.math.BigInteger. I did change it to a String-array though, so I don't need to do the split by dots, which saved some bytes, so thanks.

What. The. F. Is the magic going on here...

@HighlyRadioactive There is an explanation ;p Although without reading the challenge description it would indeed make zero sense, haha. Btw, I've just ported my Java answer to 05AB1E, which is even less readable and probably closer to magic if you're not familiar with the language. ;)

Perl 5, 328 322 317 301 + 1 (-a) = 302 bytes
$_=shift@F;if(($l=y/-//c)<5){s/^/0 x(4-$l)/e}elsif($l<57){s/^/'^'x($l>30).chr 65+($l-5)%26/e}else{$l-=57;do{s/\^*\K/'^'.chr 65+$l%26/e}while$l=int$l/26;s/^\^\K\D-?\d/^A$&/}if(s/-//){s%^....$%/$&%;eval join'',reverse'!/',0..9,A..Z,"y/A-Z0-9^/";s%^[^!/]%*$&%}printf$_.'%02d'x(@F>5?5:@F).'%03d'x(@F-5),@F

Try it online!
Ungolfed
$_=shift@F; # Store the year in the default variable for easier regex

if(($l=y/-//c)<5){      # if the length of the year is less than 5
    s/^/0 x(4-$l)/e         # pad with leading zeros to 4 digits
}elsif($l<57){          # if the length is less than 57
    s/^/'^'x($l>30).chr 65+($l-5)%26/e  # put a carat at the front if there are more than 30 characters
                        # and map the length minus 5 to A-Z
}else{
    $l-=57;         # offset the length by 57
    do{
        s/\^*\K/'^'.chr 65+$l%26/e # put a carat at the front and map the length to base 26 (A-Z)
    }while$l=int$l/26;  # until the length is down to 0
    s/^\^\K\D-?\d/^A$&/ # insert an extra '^A' to pad the result to at least 2 characters if there was only 1
}
if(s/-//){          # if the year is negative
    s%^....$%/$&%;          # put a '/' in front of a 4 digit year
    eval join'',reverse'!/',0..9,A..Z,"y/A-Z0-9^/"; # map A-Z,0-9, and ^ to Z-A,9-0, and ! respectively
    s%^[^!/]%*$&%           # add a * at the front if there are no other indicators
}
printf$_.           # output the year
'%02d'x(@F>5?5:@F).             # followed by the month, day, hour, and minutes, padded to 2 digits
'%03d'x(@F-5),@F                # followed by fractional seconds, padded to three digits

Excel VBA, 500 486 485 461 Bytes
Anonymous VBE Immediate Window Function
Anonymous VBE immediate window function that takes input as year from [A1], month from [B1], days from [C1], hours from [D1], minutes from [E1], seconds from [F1] and an optional extra precision array from [G1:Z1], calculates the RFC2550 timestamp and outputs to the VBE immediate window. Makes  use of the declared helper function below.
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:Z1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p

Helper Function
Declared helper function that takes an input number and returns that number in base-26 such that 1->A and 26->Z
Must be placed into a public module.
Function b(n)
While n
n=n-1
d=n Mod 26+1
d=d+26*(d<0)
n=n\26-(d<0)
b=Chr(64+d)+b
Wend
End Function

Usage
Must be used in a clear module, or the module must be cleared before execution as the vars j, o and p are assumed to be in their default, uninitialized state at the beginning of execution of the code. For j, which is a Variant\Integer variable, this default value is 0 and for o and p, which are Variant\String variables, this default value is the empty string ("").
Input, an array of strings, is taken from 1:1 on the ActiveSheet and output is to the VBE immediate window.
Sample I/O
[A1:F1]=Split("4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11",".")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711021028

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1:H1]=Array("-696443266","1","3","6","10","15","21","28")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
*V3035567330103061015021028

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1]="45941"
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
A45941

Cells.Clear:j=0:o="":p="" '' clear the worksheet and vars
[A1:F1]=Split("4052107100422150625478207675901330514555829957419806023121389455865117429470888094459661251.2.3.5.7.11",".")
n=Left([A1],1)="-":y=Mid([A1],1-n):l=Len(y):o=IIf(l<5,Right("000"&y,4),IIf(l<31,"",String(Len(b(l-30)),94))&B(l-IIf(l<31,4,30))&y):For Each c In[B1:ZZ1]:j=j+1:p=p+IIf(c,Format(c,IIf(j>5,"000","00")),""):Next:If n Then For i=1To Len(o):c=Asc(Mid(o,i,1)):Mid$(o,i,1)=Chr(IIf(c<60,105,155)-c):Next:?IIf(l<5,"/",IIf(InStr(1,o,"="),"","*"))Replace(o,"=","!")p:Else?o;p
^^BI40521071004221506254782076759013305145558299574198060231213894558651174294708880944596612510203050711

Jelly, 165 126 bytes
ḣ5ṫ€3
ØD,“^ /*!”,ØA
_µ‘l26Ċṗ@€ØAẎị@
Lµç30;€”^UZFµç4⁶;µ®L>30¤?µḟ®L>4¤?;®AṾ€¤µL=4”/x2£FiÐ€ị€2£UF¤µ®S<0¤¡
4R¬+DU$UµḢ©Ç;Ñ;ṫ6ṫ€2$$F

Try it online!
Line 4 does the year formatting with help from lines 2 and 3. The first and last line deal with zero padding the elements of the input to their proper lengths then concatenating them with the formatted year.

_µ‘l26Ċṗ@€ØAẎị@ finds the base 26 prefix. It takes the cartesian power of the alphabet (ØA) for each number between 1 and ceil(log26(floor(log10(year))-n+1)) (where n is either 30 or 4) then gets indexes into this list with floor(log10(year))-n (ị@).
ç30;€”^UZF  formats years >= 1030 (®L>30¤?)
ç4⁶; formats years < 1030. (Edit: Saved a byte by using ⁶; instead of ;@⁶)
1RḊ ḟ gives an empty prefix for years < 105 (®L>4¤?). It takes the list of digits then filters out every element in itself. Just using this to yield [] because ⁸ doesn't work here.
This just evaluates to []. ⁸ and [] don't work here and I couldn't find another 2 bytes that return an empty list.
;®AṾ€¤ appends the year to the prefix then flattens it.
L=4”/x prefixes a / if the length of the year is 4 in the do statement of ®S<0¤¡.
2£FiÐ€¹ị€2£UF¤ takes the complements of A .. Z, 0 .. 9 and ^ /*! if the year is negative (®S<0¤¡). 2£ refers to the second link, ØD,“^ *!”,ØA which is the list [['0' .. '9'], ['^',' ','/','*','!'], ['A' .. 'Z']]. With a formatted year like ^C125... this link finds the index of each character in the flattened version of 2£ then uses those indices to construct a new string from the flattened version of 2£ where each sublist is reversed, i.e. ['9' .. '0','!','*','/',' ','^','Z' .. 'A'], yielding !X874.... / maps to itself because it is prefixed before everything has its complement taken.
L=4a®S<0x@”/; adds a / to the beginning of negative years in [-9999 .. -0001]. My guess is this can be shortened. I ended up including this in the previous do statement (¡) and saved 7 bytes because then I didn't need to test for negative years twice.

There are a lot of uses of ¡ in line 4 and I think they could be compressed by using ? instead but I'm not sure how to get those to work. I got ? to work and saved a few bytes.
James Holderness pointed out that my first submission didn't handle years with 30 digits correct. It turned out the bug was for any year that needed a Z in the base 26 prefix. It turns out I couldn't use ṃ because when you convert 26 to base 26 it gives you [1,0] instead of 26 (duh). Instead I used ordered pairs with replacement. I don't think there is an atom for that but if there is I can save a few bytes. Fixing this ended up costing me ~40 bytes. Definitely my longest Jelly program yet. Edit: Found a shorter way to do the cartesian product. I realized that I wasn't sure that the last one worked for prefixes with more than two letters anyway but the new way does work.
Sorry for the many times I've edited this post, I just keep discovering ways of shortening it.

05AB1E, 104 bytes
εþNĀiN6@Ìjð0:ëg©Ž¾S₃в@DUO0®4α×®60+ç®34+ç'^ì®57-D<₂®Ým675*@OÌ'^×sAuÅвJ«)ćèyÄ«y0‹ižK'^ìžL'!ì‡„/*õªX2£Oèì]J

Input as a list of integers.
Based on my Java answer.
Try it online or verify all test cases.
Explanation:
ε                          # Map over each integer `y` of the (implicit) input-list
 þ                         #  Only leave digits (same as absolute value `Ä`, but results in a string)
  NĀi                      #  If the 0-based map-index is NOT 0 (so not the year):
     N6@                   #   Check if the map-index is >= 6 (1 if truthy; 0 if falsey),
                           #   thus milliseconds or smaller
        Ì                  #   Increase that by 2
         j                 #   Add leading spaces to abs(y) to make the length (N>=6)+2 long
                           #   (note that builtin `j` requires the first argument to be a string,
                           #    hence the use of `þ` over `Ä` earlier)
          ð0:              #   And replace those leading spaces with 0s
    ë                      #  Else (the map-index is 0, thus the year):
     g                     #   Pop the absolute value, and push its length
      ©                    #   Store this length in variable `®` (without popping)
       Ž¾S                 #   Push compressed integer 48223
          ₃в               #   Convert it to base-95 as list: [5,32,58]
            @              #   Check for each if they're >= the length (1 if truthy; 0 if falsey)
             DU            #   Store a copy of those checks in variable `X`
               O           #   Sum the checks to get the amount of truthy values
      ®                    #   Push the length from `®` again
       4α                  #   Take its absolute difference with 4
     0   ×                 #   Repeat 0 that many times as string
     ®                     #   Push the length `®` again
      60+                  #   Add 60
         ç                 #   Convert it to an ASCII character with this codepoint
     ®                     #   Push the length `®` again
      34+                  #   Add 34
         ç                 #   Convert it to an ASCII character with this codepoint
          '^ì             '#   Prepend "^"
     ®                     #   Push the length `®` again
      57-                  #   Subtract 57
         D                 #   Duplicate it
          <                #   Decrease it by 1 (thus `®`-58)
            ®Ý             #   Push a list in the range [0,`®`]
           ₂  m            #   Take 26 to the power of each value in this list
               675*        #   Multiply each by 675
                   @       #   Check for each if the `®`-58 is >= the value
                    O      #   Sum those checks
                     Ì     #   Increase it by 2
                      '^× '#   Have that many "^"
      s                    #   Swap so `®`-57 is at the top of the stack again
       AuÅв                #   Convert it to base-"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
                           #   basically convert it to base-26 and index it into the alphabet
           J               #   And join those characters together to a single string
            «              #   After which we'll append it to the "^"-string
     )                     #   Wrap all values on the stack into a list
      ć                    #   Extract head; pop and push remainder-list and the first item separated,
                           #   where the first item is the sum of truthy values we calculated earlier
       è                   #   Use that to 0-based index into the remainder-list
        yÄ                 #   Push the absolute value of integer `y` again
          «                #   And append it to the string
     y0‹i                  #   If integer `y` is negative:
         žK                #    Push string "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
           '^ì            '#    Prepend a leading "^"
         žL                #    Push string "zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210"
           '!ì            '#    Prepend a leading "!"
              ‡            #    Transliterate all characters in the string
         „/*               #    Push string "/*"
            õª             #    Convert it to a list of characters, and append "": ["/","*",""]
              X            #    Push the list of checks we saved in variable `X`
               2£          #    Only leave the first two checks
                 O         #    Sum those
                  è        #    Use it to 0-based index into the ["/","*",""]
                   ì       #    And prepend it in front of the string
]                          # Close all if-statements and the map
 J                         # And join all mapped strings together
                           # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why Ž¾S is 48223; Ž¾S₃в is [5,32,58]; and is.

I'm however much more familiar with 05AB1E than Java, I learned it as my first golfing language...

@HighlyRadioactive Ah nice. 05AB1E is my first golfing language as well. Before that I answered all challenges mostly in Java. :)

Write a 05AB1E to Java transpiler. Or better, write a Java to 05AB1E transpiler.


text:
Visualize Church numerals
Background
Visualizing λ-calculus terms
Famous lambda-juggler (and code golfer) John Tromp devised an interesting visualization of terms in the λ-calculus. In his words:

abstractions (lambdas) are represented by horizontal lines, variables by vertical lines emanating down from their binding lambda, and applications by horizontal links connecting the leftmost variables.

For example, the lambda term λf.λx.f (f (f (f x))) corresponds to the visualization:
-------------------
 |   |   |   |
-------------------
 |   |   |   |   |
 |   |   |   |----
 |   |   |----
 |   |----
 |----
 |

Read it from top to bottom:

The first horizontal line represents the first λ.
The four lines descending from it represent the fs in the body.
Similarly, the second horizontal line represents the second λ, and the single new line descending from it represents the x in the body.
The rightmost f line and the x line are connected by a horizontal line representing an application (f x).
The next application is (f (f x)), et cetera.

Church numerals
The Church numerals are a specific sequence of terms in the λ-calculus, taking on the following pattern:
0 = λf. λx. x
1 = λf. λx. f x
2 = λf. λx. f (f x)
3 = λf. λx. f (f (f x))
...

Task
Given an input number n, print some ASCII art that visualizes the nth Church numeral. For instance, the example above is your target output when given n = 4. For n = 0, print:
---

---
 |
 |

Test cases
Your answer must output exactly the same text (modulo trailing newlines) as this stack snippet for all integer inputs n ≥ 0:

function visualize() {
  var vin = document.getElementById('visualize-in');
  var vout = document.getElementById('visualize-out');
  var n = Number(vin.value);
  if (n < 0) n = 0;
  var line = '-'.repeat(4 * n + 3);
  var bars = function(k) { return '   |'.repeat(k).substr(2); };
  var img = [line, bars(n), line, bars(n + 1)];
  for (var i = n; i > 0; --i) img.push(bars(i) + '----');
  vout.innerHTML = img.join('\n') + '\n |';
}
n <input style="width:50px;" type="number" id="visualize-in" name="visualize-in" onchange="visualize()"/>

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

Your snippet gives me error.

@LeakyNun which browser? Some browsers don't support .repeat.

Are trailing spaces allowed?

No, only trailing newlines. (This is à la anarchy golf, and I feel like it’s the best rule set for [tag:ascii-art] challenges.)

Retina, 74 67 63 bytes
Byte count assumes ISO 8859-1 encoding.
.
 |
^
$.'$*----¶
\z
¶$` |
+`(.+\|) .+$
$&¶$1----
$
¶ |
  ¶
¶

Input is in unary, using any character except linefeeds as the digit.
Try it online!
Explanation
.
 |

We start by turning each unary digit into  |   (note the trailing spaces). This gives us the second line of the output (plus two trailing spaces if the input is at least 1).
^
$.'$*----¶

We match the beginning of the string in order to prepend the first line. This is done using some Retina-specific substitution features. $* repeats the character on the right as many times as its left arugment. $.' evaluates the number of characters to the right of the match. Since the match is only the beginning of the string this gives as many - as there are characters in the string and --- appends three more. The ¶ is an alias for a linefeed. So now we've got the first two lines.
\z
¶$` |

Now we append the next two lines. We do this by matching the end of the string and appending a linefeed, the entire string again and then  | to get the fourth line right.
+`(.+\|) .+$
$&¶$1----

Time for the applications. The leading + makes Retina repeat this stage until the output stops changing (in this case because the regex no long matches). The regex matches the entire last line, provided it contains a | follows by a space. We capture everything up to the | (which will be the second to last) in group 1. We write the line back with $&, a linefeed, then group 1 (thereby dropping the last |) and then ----.
$
¶ |

This just adds the final line containing only a single |.
  ¶
¶

Finally we need to get rid of the trailing spaces on the second line.

JavaScript (ES6), 112 bytes

f=
n=>`${d=`-`.repeat(n*4+3)}
${(b=` |  `.repeat(n)).slice(0,-2)}
${d}
${b} |
${b.replace(/ \|  /g,`$' |----
`)} |`
;
<input id=i type=number min=0 oninput=o.textContent=f(this.value)>

Are all the newlines necessary? Also, is f= necessary?

@NoOneIsHere The newlines are part of the template string. The f= is not part of the answer, it's only needed for the snippet, and isn't counted as part of the byte total.

Python, 201 bytes
from pylab import*
n=input()
p=array(list(' -|\n'))
a=zeros((n+5,n*4+4),int)
for k in range(n):l=4*k+5;a[:-k-1,l]=2;a[-k-2,l-3:l+1]=1
a[:,1]=2
a[1,-3]=0
a[0]=a[2]=1
a[:,-1]=3
print''.join(ravel(p[a]))

Python 2, 138 bytes
def f(n,a=1):
 if ~n:b="---\n";c=" |";d="  "+c;print("-"*n*4+b+c*(n>0)+d*(n-1)+"\n"+"-"*n*4+b+c+d*n+"\n")*a+c+d*(n-1)+"-"*4*(n>0);f(n-1,0)

The function contains an extra parameter, but it is for internal use only.  It has a default value and should be omitted when calling the function.  I hope this doesn't violate the rules.
The function draws the first 5 rows, then recursively calls itself to draw the remaining rows.
Try it online

source: Stack Exchange

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

sort: votes


text:
Minimum cost block diagonalisation
Consider binary block diagonal matrices which have square blocks of 1s on the main diagonal, and are 0 everywhere else. Let's call such matrices "valid" matrices.
For example, here are some valid 4x4 matrices:
1 0 0 0     1 1 0 0     1 0 0 0     1 0 0 0     1 1 0 0    1 1 1 1
0 1 0 0     1 1 0 0     0 1 1 0     0 1 1 1     1 1 0 0    1 1 1 1
0 0 1 0     0 0 1 0     0 1 1 0     0 1 1 1     0 0 1 1    1 1 1 1
0 0 0 1     0 0 0 1     0 0 0 1     0 1 1 1     0 0 1 1    1 1 1 1

Note that an alternative way of describing such matrices is that there is a chain of square 1 blocks from the top-left to the bottom-right, touching corner to corner, and everywhere else is 0.
For contrast, here are some invalid 4x4 matrices:
1 0 1 0     1 0 1 0     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 1 1 1     0 1 0 1     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
1 0 0 1     1 0 1 0     0 0 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 0 1 0     0 1 0 1     0 0 0 1     1 0 0 0     0 0 1 1    0 0 0 0

You will be given an n by n binary matrix as input – what is the minimum number of 0 bits you'll need to set to 1 in order to get a valid matrix?
You may write a function or program taking in any convenient string, list or matrix format representing an n by n matrix of 0s and 1s (as long as it isn't preprocessed). Rows must be clearly separated in some way, so formats like a 1D array of bits are not allowed.
This is code-golf, so the goal is to minimise the number of bytes in your program.
Examples
For example, if the input is
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1

then the answer is 5, since you can set five 0 bits to 1 to get:
1 0 0 0 0
0 1 1 0 0
0 1 1 0 0
0 0 0 1 0
0 0 0 0 1

and this is the minimum number required. However, if the input was
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

then the answer is 24, since the only valid 5x5 matrix where the top-right is 1 is the matrix of all 1s.
Test cases
Tests are represented here as a 2D array of integers.
[[0]] -> 1
[[1]] -> 0
[[0,1],[0,0]] -> 3
[[1,0],[0,0]] -> 1
[[0,0,0],[0,1,0],[0,0,0]] -> 2
[[0,1,0],[0,0,0],[0,1,0]] -> 7
[[0,1,0],[1,0,0],[0,0,1]] -> 2
[[1,1,1],[1,1,1],[1,1,1]] -> 0
[[0,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,0]] -> 4
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] -> 8
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,1,0]] -> 14
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,1,0,0]] -> 14
[[0,0,0,0,0],[0,0,0,0,0],[0,1,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 7
[[0,0,0,0,0],[0,0,0,0,0],[1,0,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 11
[[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,1]] -> 5
[[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 24
[[0,0,0,1,0],[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 23
[[0,1,0,0,0],[1,0,0,0,0],[0,0,1,0,0],[0,0,0,0,1],[0,0,0,1,0]] -> 4
[[0,1,1,1,0],[0,1,1,0,1],[0,1,1,1,0],[0,1,0,0,1],[0,0,0,0,0]] -> 14

Notes

Related challenge: Print a Block-Diagonal Matrix
Inspiration: Freedom Factory, Google Code Jam 2016 Problem 2D

MATL, 46 43 bytes
nX^tQt:qZ^!tsb=Z)"@!"@1$l]@n$YdG-Q?6MG>zvX<

Input is a 2D array with semicolon as row separator. For example, the input for the last test case is
[0,1,1,1,0;0,1,1,0,1;0,1,1,1,0;0,1,0,0,1;0,0,0,0,0]

Try it online! Or verify all test cases (code slightly modified to take all inputs; the results appear after a few seconds)
Explanation
Let the input be an N×N matrix. The code first computes all (N+1)-tuples of block sizes that produce the appropriate matrix size. For example, for N=4 the tuples are 0 0 0 0 4, 0 0 0 1 3, ..., 4 0 0 0 0. For each tuple it builds the block-diagonal matrix with those block sizes. It then checks if the matrix covers all the 1 entries in the input, and if so takes note of the number of 1 entries that were not present in the input. The final result is the minimum of all the obtained numbers.
nX^      % Implicit input  an N×N matrix. Get N
t        % Duplicate N
Qt:q     % Vector [0 1 ... N]
Z^       % Cartesian power. Gives 2D array
!ts      % Transpose, duplicate, sum of each column
b=       % Logical vector that equals true if the sum is N
Z)       % Filter columns according to that. Only keep columns that sum to N. Each
         % column is the size of one block
"        % For each column
  @      %   Push that column
  "      %   For each entry of that column
    @    %     Push that entry
    1$l  %     Square matrix with that size, filled with 1
  ]      %   End
  @n     %   Column size. This is the number of blocks in the block-diagonal matrix
  $Yd    %   Build block-diagonal matrix from those blocks
  G-Q    %   Subtract input matrix element-wise, and add 1
  ?      %   If all entries are nonzero (this means each that entry that is 1 in the
         %   block-diagonal matrix is also 1 in the input matrix)
    6M   %   Push block-diagonal matrix again
    G>   %   For each entry, gives 1 if it exceeds the corresponding entry of the
         %   input, that is, if the block-diagonal matrix is 1 and the input is 0
    z    %   Number of 1 entries
    v    %   Concatenate vertically with previous values
    X<   %   Take minimum so far
         %   Implicit end
         % Implicit end
         % Implicit display

Python with numpy, 102
from numpy import*
lambda M:sum(diff([k for k in range(len(M)+1)if(M|M.T)[:k,k:].any()-1])**2)-M.sum()

An efficient algorithm. Finds the "neck points" on the diagonal that can separate blocks. These have all 0's above and right, as well as below and left. The minimal blocks are those between neck points.
??000
??000
00???
00???
00???

The length of a block is the difference between consecutive neck points, so their total area of the sum of squares of these. Subtracting the sum of the original matrix then gives the number of flips needed from 0 to 1.

Pyth, 45 bytes
-hSlMf@I.DRlQx1sQTms.b^+LsYN2d+0._ds.pM./lQss

Difficult task, so it's quite long.
Try it online: Demonstration or Test Suite
Explanation:
s.pM./lQ computes all integer partitions of len(matrix). ms.b^+LsYN2d+0._d converts them into coordinate-pairs. For instance the partition [1, 2, 2] of 5 gets converted into [[0,0], [1,1], [1,2], [2,1], [2,2], [3,3], [3,4], [4,3], [4,4].
f@I.DRlQx1sQT then filters for partitions, that completely overlap the matrix (.DRlQx1sQ computes all coordinate-pairs of the active cells in the matrix).
-hSlM...ss counts the cells of each remaining partitions, chooses the one with the least cells, and subtracts the already active cells.

Matricks, 180 bytes (noncompeting)
Matricks is a new esolang I created very recently to deal with matrix problems (such as this one), by only having 2 data types: floats and matricies. It is not fully featured yet, and still has a lot of missing operations (I had to add some functionality for this challenge). Anyway, here's the code:
il=1:j3;:bdx;;;s1::L;j1;;
b{q:1;mgr:c;|gc:r;|(r=c)|(gr-1:c;|gr:c+1;)&(rec)|(gr+1:c;|gr:c-1;)&(cer):l:L;};z:(l-1)/2;B1;s1::g1:;-1;ig1:;=0:j2;:j1;;
s1::d{q:1;};;kg1:;-g:;;
kg:;*-1+1;

Explanation
The first part, il=1:j3;:...; checks if the array is of size 1. If it is, it jumps to the last line, kg:;*-1+1;, which is a simple 0 <-> 1 function.
Otherwise, it continues on with the rest of the code. bdx;;; sets the cell 0,0 to the current sum, and s1::L;j1; creates a counter in the cell in the row below.
The next line is a bit more complicated. It is a loop that runs n times, n being the size of the matrix. I'll use the 3rd test case as an example. When we first get to the second line, the matrix looks like this:
1 0 1
2 0 0

First, we go into the matrix comprehension {q:1;m...;}. This makes the diagonal, and tries its best to clean up 0 that need filling in. All this is accomplished using simple boolean operators. Then, we prepend it to the current matrix, giving this:
    V--data we want to keep
1 1 1 0 1 <-|
1 1 2 0 0 <-- old matrix

Then, we cut of the old matrix using z:(l-1)/2;, and rotate the entire matrix to the left using B1;. That gives us a matrix ready for the next iteration, looking like:
1 1 1
2 1 1

Finally, we decrement the counter, check it, and continue with ig1:;=0:j2;:j1;;
Once the loop is broken out of, we find the new sum and set the counter's old spot with s1::d{q:1;};;. Finally, we take the difference and return kg1:;-g:;;. k sets the current array to a value, and printing is implicit.
...
As you can see, Matricks is pretty verbose, and not a very good golfing language. But heck, I wanted to show it off.

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


text:
Golf me an ASCII Alphabet
Don't you find that reading simple text isn't appealing enough? Try our
#####  ###   ###  ##### #####       ##### ##### #   # #####   #
#   # #     #   #   #     #           #   #      # #    #     #
#####  ###  #       #     #           #   ####    #     #     #
#   #     # #   #   #     #           #   #      # #    #
#   #  ###   ###  ##### #####         #   ##### #   #   #     #

Much more fancy isn't it? But it's pretty long to write by hand, it would be wonderful if someone did a program that do it for me !
Your task, if you volunteer to help me, will be to write a program or a function that takes a string containing [a-zA-Z\s\n] only, and output (or return) the ascii writing of it!
You must use the following alphabet to format your output:
##### ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   #
#   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ##
##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # #
#   # #   # #   # #   # #     #     #   # #   #   #   # #   # #   #     #   #
#   # ####   ###  ####  ##### #      ###  #   # ##### ###   #  #  ##### #   #

#   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     #
# # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #
#  ## #   # #     #  ## ##        #   #   #   #  # #  ## ##  # #    #    #
#   #  ###  #      #### # #    ###    #    ###    #   #   # #   #   #   #####

The space:
     |
     | it's a 5x5 square of spaces
     | but had to pad it with |s to make it appear in this post
     |
     |

As this is a fixed-width font, the space character is also surrounded by spaces, resulting in a 7-width space between the two letters.
a b
     1234567       -- these numbers are just for the example, you don't have to output them
#####       ####
#   #       #   #
#####       ####
#   #       #   #
#   #       ####

a  b
     1234567890123
#####             ####
#   #             #   #
#####             ####
#   #             #   #
#   #             ####

When you encounter a newline, as in the input
ascii
text

Just make sure to separate the two blocks of text by at least one empty line
#####  ###   ###  ##### #####
#   # #     #   #   #     #
#####  ###  #       #     #
#   #     # #   #   #     #
#   #  ###   ###  ##### #####

##### ##### #   # #####
  #   #      # #    #
  #   ####    #     #
  #   #      # #    #
  #   ##### #   #   #

Also, you are allowed to replace the #s with any other character as long as it is in the printable ASCII range, and is not spaces. You could for instance use As for the letter A, B for the letter B and so on.
As this is code-golf (and moreover kolmogorov-complexity) the winning submission will be the one that solve this challenge in the least byte possible, have fun!

Is the 5-char space also to be surrounded by single-spaces, or is this a variable width font?

@Adám you're right, it is supposed to be surrounded by spaces, I'll update regarding this point

Can we somehow retrieve the pixel alphabet as input or do we have to construct those characters inside our rated code snippet?

@ByteCommander One (big) part of this challenge is about string compressing, you have to find the best way to compress this alphabet in your code, while still being able to retrieve it and use it :). So yes, it is included in your golfed-code and can't be inputed to your program

@Katenkyo Aha, okay. Thanks for the clarification.

@muddyfish I don't know what to say, I feel that it is really close, but can't decide if it really is a duplicate or no. I'll leave this question as it is (rather than closing it myself), and let the potential voters the freedom of bashing it :).

Well, that one doesn't specify a specific alphabet... And this one uses different spacing, offset...

Are trailing whitespaces in the end of each line allowed or can we leave the padding there?

@ByteCommander You are allowed to leave a padding of one column of spaces at the end of a line, but it's not mandatory.

Also, what about leading or trailing newlines in the output?

@ByteCommander No trailing or leading newlines are allowed, as it would make the output not a direct translation of the input. Let the program you actually have to make be a function f(), the input be x and a function converting the ascii alphabet to a "standard" string g(), then g(f(x))==x

Python 3, 375 bytes
f=lambda i:"\n\n".join("\n".join(map(" ".join,zip(*[[x.replace("0"," ")[a*5:a*5+5]for a in range(5)]for x in[["{:025b}".format(int(c,36))for c in'0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH AT6Q9 AT6KK AWU7'.split()][x!=" "and ord(x)-64]for x in j.upper()]])))for j in i.split("\n"))

See this code running on ideone.com.
The same code, but somehow nicely indented, formatted and commented:
f = lambda i: \

    # join multiline strings together using an empty line as separator:
    "\n\n".join(

        # join the string lines of one big output line together:
        "\n".join(

            # join the corresponding rows of the letters together using " ":
            map(" ".join, zip(*

                # make a list (output line) of list (output characters)
                # of strings (single character's rows):
                [

                    # replace 0s with spaces and split the bit strings into
                    # chunks of 5 characters - the rows of each letter:
                    [x.replace("0", " ")[a*5 : a*5+5] for a in range(5)]

                    for x in [

                        # split the space separated character codes and
                        # convert them from base 36 to
                        # base 2 strings of length 25:
                        ["{:025b}".format(int(c, 36)) for c in

                         # the encoded font data (reformatted):
                         '0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 '
                         'AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE '
                         'J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH '
                         'AT6Q9 AT6KK AWU7'.split()]

                        # select element 0 if we want a space, else find
                        # out the index from the ASCII code of the letter:
                        [x != " " and ord(x) - 64]

                        # repeat for every character in the input line:
                        for x in j.upper()
                    ]
                ]
            ))

        # repeat for every line in the input
        ) for j in i.split("\n")
    )

I also decided to go for base 36 encoding as that's the highest base Python's built-in int() natively supports. Here is a short Python 3 script I wrote (ungolfed) that converts font definitions like in the question into base 36 codes: My converter on ideone.com
The result consists of the character 1 as enabled pixel and a space   as disabled pixel. Here's a single example run:
Input (line break as \n):
Hello World
Python rocks

Output:
1   1 11111 1     1      111        1   1  111  1111  1     1111
1   1 1     1     1     1   1       1   1 1   1 1   1 1     1   1
11111 1111  1     1     1   1       1 1 1 1   1 1111  1     1   1
1   1 1     1     1     1   1       11 11 1   1 11    1     1   1
1   1 11111 11111 11111  111        1   1  111  1 1   11111 1111

1111  1   1 11111 1   1  111  1   1       1111   111   111  1   1  111
1   1  1 1    1   1   1 1   1 11  1       1   1 1   1 1   1 1  1  1
1111    1     1   11111 1   1 1 1 1       1111  1   1 1     111    111
1       1     1   1   1 1   1 1  11       11    1   1 1   1 1 1       1
1       1     1   1   1  111  1   1       1 1    111   111  1  1   111

Clojure, 552 bytes
(defn t[s](print(reduce #(str %1"\n"%2)(map #(apply str %)(let[a[:jpcfl :j2uke :92y3y :j2kam :jomcf :jomc0 :92b72 :ayp81 :jfm3j :jfmho :azc7m :ab6zj :b5i5t :b43n5 :92ywe :j2uj4 :92yy7 :j2uqc :926um :jfm2s :aye5q :ay8g4 :ayhkh :at6q9 :at6kk :je7mn :0]](map(fn[o](map #(str(.replace %"0"" ")"\n")(map(fn[w](reduce #(str %1(.substring %2 w(+ w 5))"0")""(map #(str(apply str(repeat(- 25(count %))"0"))%)(map #(Integer/toString(Integer/valueOf(name %)36)2)(map a(map #(if(= % \space)26(-(int %)97))(.toLowerCase o)))))))(range 0 25 5))))(.split s"\n")))))))

Each letter in ascii is represented as a binary string with # - 1, space - 0. Then it's converted to base 36 so that it only takes 5 chars to store + ":" to let Clojure know that it should be treated as symbol.
Then the input is split by newline symbol and for each line we convert a letter in 36 base back to binary base and get first [0:5] symbols add newline symbols, get next [5:10] symbols and so on.
You can see it running here - https://ideone.com/y99ST5

SOGL, 137 bytes
 °f`7-π⅛χ%sΤ↕ņLRΕ⅓9׀b∫rr(¶æKGTΧ3;■ΦΤg¼⁰¡Νg‽}○eΧ²Y∫Οαν⌡l′}¾(8╔ <%╤∙i.d↔ū∫Æo┌jyŗ▲δ⁶=╗$↑yōΛ3h¼╔◄┼)‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO

Explanation:
...‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO
...‘                                           push a string with the letter data                            ["..."]
    ’«n                                        split in lengths of 25                                        [[".", ".", ".",...]]
       .{                                      repeat input times                                            [[".", ".", ".",...]]
         5{ø}                                  push 5 empty strings                                          [[".", ".", ".",...], "", "", "", "", ""]
             ¹                                 wrap those in an array                                        [[".", ".", ".",...], ["", "", "", "", ""]]
              ,                                get a string input                                            [[".", ".", ".",...], ["", "", "", "", ""], "Hello World"]
               u                               lowercase it                                                  [[".", ".", ".",...], ["", "", "", "", ""], "hello world"]
                R{                       }     itirate over the ordinals of the string                       [[".", ".", ".",...], ["", "", "", "", ""], 104]
                  8+                           add 8 to the ordinal                                          [[".", ".", ".",...], ["", "", "", "", ""], 112]
                    :A                         save on variable A                                            [[".", ".", ".",...], ["", "", "", "", ""], 112]
                      h                        swap 2 items one below the stack                              [["", "", "", "", ""], [".", ".", ".",...], 112]
                       w                       get the ord+8th item of the letter data array (modulo length) [["", "", "", "", ""], [".", ".", ".",...], "-----  -    -    -  -----"]
                        h                      swap 2 items one below the stack                              [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----"]
                         a                     load the variable A                                           [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----", 112]
                          ’#=?     }           if equals to 40 then                                          [[".", ".", ".",...], ["", "", "", "", ""], "----- -     -     - -----"] (temporalily switching to space case; it incorrectly picks "N" for space)
                              X                delete the string                                             [[".", ".", ".",...], ["", "", "", "", ""]]
                               ’«@*            push a string with 25 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], "                         "]
                                    ┼          add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"]] (back to "H")
                                     L@*       push a string with 10 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"], "          "]
                                        ┼      add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -  ", "-   -  ", "-----  ", "-   -  ", "-   -  "]]
                                          p    output the resulted line                                      [[".", ".", ".",...], ["", "", "", "", ""]]
                                           øO  append to output an empty line

note: currently this language can't really accept multiline input string so I've made it ask for a number and read the next x lines as the input.
The first string is
"------ -  - -  - -  ----------- - -- - -- - - - -  --- -   --   --   - - - ------   --   --   - --- ------ - -- - -- - --   ------- -  - -  - -  -     --- -   --   -- - -  -- -----  -    -    -  ------   --   -------   --   --  ---   -------    -    -----  -    --  -  --    -----    -    -    -    ------ -     -   -   ---------- -     -     - ----- --- -   --   --   - --- ------ -  - -  - -   -    --- -   --   --  -- ---------- -- - - -- -   -    -   - - -- - -- - -   - -    -    ------    -    ----     -    -    ----- --     --     -  -- --   -----   -   -     - ------   - - -   -   - - -   --     -     --- -   -    -   --  --- - ---  --   -"

compressed using a custom dictionary that uses " " and "-" (the compression has a special mode with "\n -|/_" available so even more compression!)
It contains 25 chars per ascii char in the order of the alphabet. they are ordered top-down then right.
the chars go like
16b
27c
38d . . .
49e
5af

and that's the same way that ┼ adds them to an array.

I'm definitly going to check how this turns out ! Instead of requiring an other input, the closest thing you could do to the original rules would be to require an input in the form foo\nbar for multiline inputs

C (gcc), 326 322 321 317 bytes
-8 bytes thanks to ceilingcat
#define X!!putchar
char*p,*q;i,j;f(int*s){for(;p=strtok(p?0:strdup(s),"\n");X(10))for(i=0;i<5;i+=X(10))for(q=p;*q;q+=X(32))for(j=0;j<5;)X((*q-32?"OAOAA?A?A?>A1A>?AAA?O1?1OO1?11>1IA>AAOAAO444OO4457A97591111OAKEAAACCIA>AAA>?A?11>AAIN?A?35>1>@>O4444AAAA>AA::4AAEKAA:4:AA:444O842O"[(*q&~32)*5-325+i]-48:0)>>j++&1?35:32);}

Try it online!

Powershell, 261 253 bytes
$args-split'
'|%{$s=$_
0..5|%{$l=$_
-join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)]
0..5|%{' #'[(+$c-shr$_)%2]}})}}

Test script:
$f = {

$args-split'
'|%{$s=$_
0..5|%{$l=$_
-join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)]
0..5|%{' #'[(+$c-shr$_)%2]}})}}

}

&$f "ascii art
text"

Output:
#####  ###   ###  ##### #####       ##### ####  #####
#   # #     #   #   #     #         #   # #   #   #
#####  ###  #       #     #         ##### ####    #
#   #     # #   #   #     #         #   # ##      #
#   #  ###   ###  ##### #####       #   # # #     #

##### ##### #   # #####
  #   #      # #    #
  #   ####    #     #
  #   #      # #    #
  #   ##### #   #   #

Note:
$s|% *per|% t*y is shortcut for $s|% toUpper|% toCharArray
About space:
For each character of the source string, the script takes a symbol (bit mask) from the magic string '_ONO__NQ...'. However, the index goes beyond the magic string for a space. In this case, the bit mask $c becomes empty. It means zero for all bits.
About blank line:
The script displays 6 rows for each symbol instead of 5. The index goes beyond the magic string for a blank line too. So, the row 6 contains spaces only.
It is best seen if you print another character instead of a space. For example ·.
#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························

JavaScript (ES6), 292 287 278 bytes
s=>s.split`
`.map(s=>`vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v`.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join`

`

Demo

let f =

s=>s.split`
`.map(s=>`vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v`.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join`

`

O.innerText = f('HELLO WORLD\nTHIS IS A TEST')

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


text:
Correct way to add numbers to get lots of 8's
Inspired by this question which was further inspired by this one, write a program which takes two integers and adds them in a unique way, by performing an OR operation on the segments used to display them in a 7-segment display.  For reference, the digits are represented in the following way:
 _        _   _         _    _   _    _    _
| |   |   _|  _|  |_|  |_   |_    |  |_|  |_|
|_|   |  |_   _|    |   _|  |_|   |  |_|   _|

Note that the 1 uses the two segments on the right, not the left.  There are two special characters that can be produced this way which are not numbers.  See the addition table below:
  | 0 1 2 3 4 5 6 7 8 9
--+--------------------
0 | 0 0 8 8 8 8 8 0 8 8
1 | 0 1 a 3 4 9 8 7 8 9
2 | 8 a 2 a 8 8 8 a 8 8
3 | 8 3 a 3 9 9 8 3 8 9
4 | 8 4 8 9 4 9 8 Q 8 9
5 | 8 9 8 9 9 5 6 9 8 9
6 | 8 8 8 8 8 6 6 8 8 8
7 | 0 7 a 3 Q 9 8 7 8 9
8 | 8 8 8 8 8 8 8 8 8 8
9 | 8 9 8 9 9 9 8 9 8 9

Useful observations:

Any digit plus itself equals itself
8 plus any digit equals 8
2 plus 1, 3, or 7 equals the letter 'a' (must be lower-case)
4 plus 7 equals either 'q' or 'Q', your choice
Numbers should be right-aligned, so the digits should be added from right to left.  If one number has more digits than the other, the extra digits at the beginning should be unchanged.  There are no leading 0's, unless the number is exactly 0.
All numbers will be 0 or greater.  You don't need to handle a '-' sign.  (Mainly because there's no good fit for the sum of a '-' and a '1' or '7'.)

Your program should accept 2 integers in any format you choose, and output a string containing their "sum" when calculated in this manner.  This is code-golf, so your program should be as small as possible.
Examples:

Input: 12345, 123.  Output: 12389
Input: 88888, 42.  Output: 88888
Input: 0, 23.  Output: 28
Input: 120, 240.  Output: a80
Input: 270, 42.  Output: 2Q8 (or 2q8)
Input: 1234567890, 1234567890.  Output: 1234567890

Interesting challenge, but this could use some test cases so people can validate their answers.

Shouldn't the Q be lowercase? The actual shape looks like a q rather than a Q

Will the input integers be single-digit, limited number of digits or unlimited?

@DigitalTrauma - Numbers can be any number of digits (within reason, depending on the limitations of your chosen language).  For simplicity, the numbers should be right-aligned, just as in normal addition.  (So unlike the linked puzzle where 22+4=82, in this challenge it would be 28.)

@LuisMendo - I suppose it could go either way.  I'll leave that up to your discretion.  The a should definitely be lower case though, since A looks completely different.

- plus 1 equals ⊣ and - plus 7 equals ᖷ!

@Zgarb - Done.  Also added a test that adds a value to itself (which should simply return the same number unchanged).

@Adám - Yeah, I thought about that, but figured not everybody has access to Unicode characters in their golfing languages of choice, so it'd be unfair to expect them to handle that.

Can input be an array of arrays of digits? Something like {[1 2 3 4 5] [1 2 3]} for the first test case

@LuisMendo - I don't know - what's the usual practice on this sort of thing?  I did say "any format you choose", but that might be stretching it a bit?  I'll let the community decide whether that's fair or not.

@DarrelHoffman Yes, I agree it might be stretching

Bash + Common Linux utilities, 80
s=~0my3[_p^?{}s
h()(tr 0-9 $s<<<$1|xxd -p)
dc -e$[0x`h $1`|0x`h $2`]P|tr $s 0-9aQ

Note the ^? in the source should be replaced with an ASCII 0x7f character.
The string s is each 7 segment digit 0-9, a, Q encoded with each segment corresponding to a bit of an ASCII char.
The h() function transliterates the input number from decimal to the encoding specified by s, then outputs the result as a raw hex string.
The two resulting raw hex strings are ORed together using regular bash arithmetic, then output by dc's P command as a bytestream.  This bytestream is then transliterated back to decimal + a + Q and output.
Note also that when using the <<< bash herestring construct in function h() a newline is implicitly appended to the redirected string.  This doesn't matter - it is simply translated to 0x0a at the end of each hex string; when the two hex numbers are ORed together, the result is still 0x0a in the last char which doesn't get transliterated and thus simply translates back to a newline which is output after the result.
Test output:
$ for testcase in \
> "12345 123" \
> "88888 42" \
> "0 23" \
> "1234 56789" \
> "4 7"; do
> ./7segadd.sh $testcase
> done
12389
88888
28
58a89
Q
$

I'll go ahead and award this since nobody seems to be trying this one anymore.

Thanks Darrel - It was a fun, interesting challenge.  If you want more answers, you might consider putting a bounty on it.

Nah, I don't have enough rep on this site to go spending it all on bounties.  (I can't even test this one since I'm not running Linux, I'm just giving the community the benefit of the doubt.)  I just kind of threw this together on a whim based on another question anyhow.

Python 2, 155 bytes
def f(a,b):exec"a=[ord('?(u|j^_,♥~'[int(c)])for c in a];a=max(len(b)-len(a),0)*[0]+a;a,b=b,a;"*2;print`['214567q3a980'[(c|d)%13]for c,d in zip(a,b)]`[2::5]

Replace the ♥ with a DEL character (0x7F).
Calling f("12345", "123") prints 12389.

There are three sets of values for which that %13 trick works. Obviously you went for the set which had no characters below 40, but for my JavaScript translation I chose the shortest set. The third set is the longest in JavaScript, it would have been 111,5,118,117,29,121,123,37,127,125.

JavaScript (ES6), 158 144 bytes
f=(s,t)=>t[s.length]?f(t,s):s[t.length]?f(s,' '+t):s.replace(/./g,(c,i)=>"540q9361278a"[(a[c]|a[t[i]])%13],a=[119,20,47,31,92,91,123,22,127,95])

Saved 14 bytes by shamelessly stealing @Lynn's %13 trick.

f=(s,t)=>t[s.length]?f(t,s):s[t.length]?f(s,' '+t):s.replace(/./g,(c,i)=>"540q9361278a"[(a[c]|a[t[i]])%13],a=[119,20,47,31,92,91,123,22,127,95])
;o.textContent=[...s="0123456789"].map(c=>f(c.repeat(10),s)).join`
`;

Java, 170 bytes
This is terribly long... but this is Java anyway.
String A(int a,int b){String c="|HgmY=?h}oy",r="";for(;a>0|b>0;a/=10,b/=10)r="0123456789aq".charAt(c.indexOf((a>0?c.charAt(a%10):0)|(b>0?c.charAt(b%10):0)))+r;return r;}

Full program, with ungolfed code
public class Q80716 {
    String A(int a,int b){String c="|HgmY=?h}oy",r="";for(;a>0|b>0;a/=10,b/=10)r="0123456789aq".charAt(c.indexOf((a>0?c.charAt(a%10):0)|(b>0?c.charAt(b%10):0)))+r;return r;}
    String Add(int a,int b){
        String c = "|HgmY=?h}oy", d = "0123456789aq";
        String r = "";
        for(;a>0|b>0;a/=10,b/=10){
            r = d.charAt(c.indexOf((a>0?c.charAt(a%10):0)|(b>0?c.charAt(b%10):0))) + r;
        }
        return r;
    }
    public static void main(String[]args){
        int[][] testcases = new int[][]{
            {12345,123},
            {88888,42},
            {0,23},
            {120,240},
            {270,42},
            {1234567890,1234567890}
        };
        for(int i=0;i<testcases.length;i++){
            System.out.println(new Q80716().Add(testcases[i][0],testcases[i][1]));
            System.out.println(new Q80716().A(testcases[i][0],testcases[i][1]));
        }
    }
}

All output (all duplicated once)
12389
88888
23
a80
2q8
1234567890

I promise that I will not use golflangs to solve this problem (it would probably cost not more than 50 bytes)

I never said people couldn't use golf languages for this - I'm honestly surprised nobody has yet.  Anyhow, even without that you could probably save some bytes using a Java 8 lambda?