[Question]
      [
Notice the pattern in the below sequence:
```
0.1, 0.01, 0.001, 0.0001, 0.00001 and so on, until reaching 0.{one hundred zeros}1
```
Then, continued:
```
0.2, 0.02, 0.002, 0.0002, 0.00002 and so on, until reaching 0.{two hundred zeros}2
```
Continued:
```
0.3, 0.03, etc, until 0.{three hundred zeros}3
```
Continued:
```
0.4, 0.04, etc, until 0.{four hundred zeros}4
```
Sped up a bit:
```
0.10, 0.010, etc.  until 0.{one thousand zeros}10
```
Sped up some more:
`0.100, 0.0100...`
You get the idea.
The input your code will receive is an integer, the number of terms, and the output is that many number of terms of the sequence.
Input and output formats are unrestricted, and separators are not required.
Trailing zeros are necessary.
[Standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/48934) apply.
---
The outputs of some nth terms are given below:
```
nth term -> number
-------------------
1        -> 0.1
102      -> 0.2
303      -> 0.3
604      -> 0.4
1005     -> 0.5
1506     -> 0.6
2107     -> 0.7
2808     -> 0.8
3609     -> 0.9
4510     -> 0.10
```

[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 23 bytes
Online compiler can't show all terms for high N but it works fine offline.
```
Lvy2°*>F„0.0N×yJ,¼¾¹Qiq
```
**Explanation**
```
                          # implicit input X
Lv                        # for each y in range [1 .. X]
  y2°*>F                  # for each N in range [0 .. y*100+1)
        „0.               # push the string "0."
           0N×            # push 0 repeated N times
              y           # push current y
               J,         # join and print
                 ¼¾¹Qiq   # quit the program after X terms printed
```
[Try it online!](http://05ab1e.tryitonline.net/#code=THZ5MsKwKj5G4oCeMC4wTsOXeUoswrzCvsK5UWlx&input=MzAz)
[Answer]
# Python 2, ~~73~~ 64 bytes
I think this is pretty short. I'm not sure that I can get it any shorter now that I golfed the `if-else` away.
```
s=z=1
exec'print"0.%0*d"%(z,s);q=z>s*100;z+=1-z*q;s+=q;'*input()
```
[**Try it online**](https://repl.it/Dklg/2)
Less golfed:
```
n=input()
s=z=1
for i in range(n):
    print"0.%0*d"%(z,s)
    if z>s*100:z=1;s+=1
    else:z+=1
```
[Answer]
# Haskell, ~~53~~ 63 bytes
This does the same thing as the 05AB1E answer now
```
f=(`take`["0."++('0'<$[1..y])++show x|x<-[1..],y<-[0..x*100]])
```
[Answer]
# Perl 5, 57 52 bytes
(needs `-E` for `say`)
```
for(1..<>){say"0."."0"x$i++.$.;$.++,$i=0if$i>100*$.}
```
Or readably:
```
# $. is the input line number, use it to count the
# number at the end.
# $i counts zeroes in the middle, starts at 0 implicitly
for(1..<>){                      # get the number of terms from stdin and loop
                                 # <> implicitly increases $. (to 1)
    say "0." . "0" x $i++ . $.;  # print the number, add one zero
    $.++, $i=0 if $i > 100 * $.; # increment the number, reset number
                                 # of zeroes if we've printed enough
}
```
Trailing zeroes are printed since the number after the row of zeroes is just an integer concatenated as a string.
Test run:
```
$ perl -E 'for(1..<>){say"0."."0"x$i++.$.;$.++,$i=0if$i>100*$.}' | tail -3
4511
0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009
0.10
0.010
```
[Answer]
## [QBIC](https://codegolf.stackexchange.com/questions/44680/showcase-your-language-one-vote-at-a-time/86385#86385), ~~73~~ 64 bytes
```
:#0|{C=!q$D=@0.|[0,q*100|d=d+1?D+$LTRIM$|(C) D=D+A~d=a|_X]]q=q+1
```
Saved 9 bytes by removing `x` as upper bound in the `FOR` loop. Upper bound is now set as `q*100`. Shame that QBasic automatically adds a space in front of a printed number, that's a costly `LTRIM$`...
Some explanation: `q` is used as the current number in the loop. This starts as 1 and gets incremented every 100N turns. This number gets converted to a string and is then appended to the string `0.` and the correct number of `0`'s. In detail:
```
We use q as our 'base number', this is 1 implicitly
:                Get the max number of terms from a numeric CMD line param
#0|              Define string A$ as "0"
{                DO
C=!q$            our base number is cast to the string C$
D=@0.|           define D$ as "0."
[0,q*100|        FOR each of the terms we need to do for our base number
                 (i.e. 101 for 1, 201 for 2 ...)
d=d+1            Keep track of the total # of terms
                 (i.e. 101 after the 1 cycle, 302 after the 2...)
?D+$LTRIM$|(C)   Print to screen D$ + C$, where D$ = "0.[000]"
                 and C$ is our base number (1, or 2, or - much later - 100)
                 LTRIM is in there to prevent "0.00 1"
D=D+A            Add A$ to the end of D$ ("0.00" becomes "0.000")
~d=a|_X]         Stop if we've reached the max. # of terms
]                NEXT
q=q+1            If we've done all the terms necessary with this base number
                 then raise base number.
The DO loop gets closed implicitly by QBIC.
```
---
Edit: QBIC has seen quite some development over time, and the above can now be solved in 49 bytes, 15 bytes shorter:
```
{D=@0.`[0,q*100|d=d+1?D+!q$┘D=D+@0`~d=a|_X]]q=q+1
```
[Answer]
## PowerShell v2+, 89 bytes
```
param($n)for($j=1;;$j++){for($i=0;$i-le100*$j;$i++){"0.$('0'*$i)$j";if(++$k-ge$n){exit}}}
```
Straight-up double-`for` loop. The first, for `$j` is infinite. The inner, for `$i`, loops from `0` up to `100*$j`, using string concatenation and string multiplication to print out the appropriate item. It also checks total loop counter `$k` against input `$n`, and `exit`s the program after we hit that point.
[Answer]
# PHP, 83 Bytes
```
for($s=1;$i++<$argv[1];){if($r>100*$s){$s++;$r=0;}echo" 0.".str_repeat(0,$r++).$s;}
```
[Answer]
# GNU sed 163 157
+2 included for -rn
```
s,^,0.1\n,;:;P;s,\.,.0,;s,.$,,;/0{101}/{s,0\.0*(09)?,\1,
s,.9*\n,x&,;h;s,.*x(.*)\n.*,\1,;y,0123456789,1234567890,
G;s,(.*\n)(.*)x.*\n(.*),0.\2\1\3,};/\n./b
```
Takes input in unary [based in this consensus](http://meta.codegolf.stackexchange.com/a/5349/57100).
[Try it online!](http://sed.tryitonline.net/#code=cyxeLDAuMVxuLDs6O1A7cyxcLiwuMCw7cywuJCwsOy8wezEwMX0ve3MsMFwuMCooMDkpPyxcMSwKcywuOSpcbix4Jiw7aDtzLC4qeCguKilcbi4qLFwxLDt5LDAxMjM0NTY3ODksMTIzNDU2Nzg5MCwKRztzLCguKlxuKSguKil4LipcbiguKiksMC5cMlwxXDMsfTsvXG4uL2IKCiNleGFtcGxlIGlucHV0IGlzIDEwMg&input=MTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTEx&args=LXJu)
---
An easy way to run this is:
```
 yes 1 | head -{input} | tr -d '\n' | sed -rnf zeroOne.sed
```
---
**Explanation**
```
s,^,0.1\n,                   #add 0.1 as the first line of the pattern space
:
P                            #print everything up to the first newline
s,\.,.0,                     #add a 0 after the .
s,.$,,                       #reduce the number left to print by one
/0{100}/{                    #if there is a string of 100 zero do the following
    s,0\.0*(09)?,\1,                 #get rid of all the 0s (except one if the we are adding another digit)
    s,.9*\n,x&,              #put an x before the left most number that will change
    h                        #store in hold space
    s,.*x(.*)\n.*,\1,        #remove everything except the numbers that change
    y,0123456789,1234567890, #replace numbers with the next one up
    G                        #bring the rest of the string back
    s,(.*\n)(.*)x.*\n(.*),0.\2\1\3,
                             #replace the x and numbers that changed with the new ones
}
/\n./b                   #branch back unless there isn't anything on the last line
```
[Answer]
# Mathematica, 70 bytes
```
Take[Join@@Table["0."<>Array["0"&,k]<>ToString@m,{m,#},{k,0,100m}],#]&
```
Unnamed function that takes the desired length as its argument and returns a list of strings (using strings instead of numbers makes the trailing zeros easy to include).
This version is slow as hell! because if you want, for example, the first 10 terms, it actually computes the sequence all the way through the 10th segment (101 + 201 + ... + 1001 = 5510 terms) and then retains only the first 10. So already at input 303, it's computing nearly five million terms and discarding almost all of them. The **81**-byte version
```
Take[Join@@Table["0."<>Array["0"&,k]<>ToString@m,{m,Sqrt[#/50]+1},{k,0,100m}],#]&
```
doesn't have this flaw, and in fact calculates nearly the fewest segments possible.
[Answer]
# JavaScript (ES6), 69
```
n=>[...Array(n)].map(_=>(w=l--?z:(l=++x*100,z='0.'),z+=0,w+x),l=x=0)
```
Unnamed function with desired length in input and returning an array of strings.
**Test**
```
f=
n=>[...Array(n)].map(_=>(w=l--?z:(l=++x*100,z='0.'),z+=0,w+x),l=x=0)
var tid=0
function exec()
{
    var n=+I.value;
    O.textContent=f(n).map((r,i)=>i+1+' '+r).join`\n`;
}
function update()
{
  clearTimeout(tid);
  tid=setTimeout(exec, 1000);
}
exec()
```
```
<input id=I value=305 type=number oninput='update()'><pre id=O></pre>
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 71 bytes
```
sn1sj1si1[lj1+dddsjZ1-dkAr^/li1+si]sJ[0nK1+kA/pljA0*K=Jlnlid1+si<M]dsMx
```
[Try it online!](https://tio.run/##FckxDoAgDADA/0gMNKw6sEL4gAQXu7Q0xNjF39d46@FlMUTTCcqgBE0YHCIqH7DiSM/phcApdc0tzAJuJH8Lp7CUPcsUwn@32lHra/YB "dc – Try It Online")
Honestly, I thought taking advantage of dc's arbitrary precision would make this easy, but I'm pretty sure just printing a ton of zeroes will be golfier. It feels really suboptimal, but I still think the use of arbitrary precision is interesting.
`sn1sj1si1` We're taking top-of-stack as our nth-term target, so we store it in `n`, initialize `i` and `j` at 1, and leave a 1 on the stack.
`[lj1+dddsjZ1-dkAr^/li1+si]sJ` Macro `J` handles what to do when we've hit the 100, 200, &c. mark. Counter `j` keeps track of this, so we increment it, we set our precision to the number of digits it has less one, and then we leave the first digit of it (`Z1-Ar^/`; divide by 10^(number of digits less one)) on the stack since this is our starting point for the next big long chain.
`[0nK1+kA/pljA0*K=Jlnlid1+si<M]dsMx` Our main macro. First we print a leading 0 with `0n`. Then `K1+k` increments our precision by one place. `A/` divides by ten, pushing us a place over to the right.`p` prints, and then the rest is housekeeping. We can test our current precision to determine whether or not we need to jump into macro `J`, so we multiply counter `j` by a hundred (note: `A0` here may need to be replaced with `100` on some implementations (cygwin)) and do the comparison. We load `n`, our target nth term, increment our main counter, `i`, and then compare the two. If we haven't yet hit the target, we keep running `M`.
[Answer]
# Excel VBA, 63 Bytes
Anonymous VBE immediate window function that takes input from range `[A1]` and outputs to the VBE immediate window
```
n=[A1]:While n>i*100:n=n-1-i*100:i=i+1:Wend:?"0."String(n,48)&i
```
[Answer]
# Java 8, 120 bytes
```
n->{String r="";a:for(int i=1,j,k,c=n;;i++)for(j=0;j<=i*100;r+=i+"\n"){for(r+="0.",k=j++;k-->0;r+=0);if(c--<1)break a;}}
```
Explanation and TIO uses the one below however. The difference: the one above creates one big String and then returns it; the one below prints every line separately (which is much better for performance).
**130 bytes:**
```
n->{String r;a:for(int i=1,j,k,c=n;;i++)for(j=0;j<=i*100;System.out.println(r+i)){for(r="0.",k=j++;k-->0;r+=0);if(c--<1)break a;}}
```
**Explanation:**
[Try it here.](https://tio.run/##LY/BbsIwEETvfMWKk13HkSNVPXQxf1AuHFEPxjjV2sGJHINURfn24ADS7mFndqQ33tyN7AcX/SUstjPjCD@G4rQBoJhdao11cFhPgHtPF7Cs6BA5FmkuW2bMJpOFA0TQsES5n445UfyDhOa77dMzQbqpfBUqqyMiCcFXw2uFfqfpo1EKj/9jdte6v@V6KPHcRZYEcT6tn0lvVb2tgvZCYJByrzAJrThSy6yUu4afkzMBDM7zgptCNdzOXaF6wz3Zr6UZe7GdfsHwV61YW/alPt@N5uUB) (Will time out or exceed output limit for test cases above `604`, but locally test case `4510` works in below 2 seconds.)
```
n->{                  // Method with integer parameter and no return-type
  String r;           //  Row String
  a:for(int i=1,      //  Index integer `i` starting at 1
        j,k,          //  Some other index integers
        c=n           //  Counter integer starting at the input
        ;;i++)        //  Loop (1) indefinitely
      for(j=0;        //   Reset `j` to 0
          j<=i*100;   //   Loop (2) from 0 to `i*100` (inclusive)
          System.out.println(r+i)){
                      //     After every iteration: print `r+i` + new-line
        for(r="0.",   //    Reset row-String to "0."
            k=j++;    //    Reset `k` to `j`
            k-->0;    //    Loop (3) from `j` down to `0`
          r+=0        //     And append the row-String with "0"
        );            //    End of loop (3)
        if(c--<1)     //    As soon as we've outputted `n` items
          break a;    //     Break loop `a` (1)
      }               //   End of loop (2) (implicit / single-line body)
                      //  End of loop (1) (implicit / single-line body)
}                     // End of method
```
]


[Question]
      [
Write a program or function that prints or outputs this exact text (consisting of 142 characters):
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
Your program must take no input (except in languages where this is impossible, such as `sed`), and produce the above text (and *only* the above text) as output. A trailing newline is acceptable.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer (in bytes) wins.

[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~70~~ ~~68~~ 67 bytes
```
'()'12:)l10:&<toYP43Y$51hb(!10Xy'\::\'FFhZ++'|'3$Yc'||\'3:(95'Zd'o(
```
[Try it online!](http://matl.tryitonline.net/#code=JygpJzEyOilsMTA6Jjx0b1lQNDNZJDUxaGIoITEwWHknXDo6XCdGRmhaKysnfCczJFljJ3x8XCczOig5NSdaZCdvKA&input=)
### Explanation
What a mess. But hey, there's a convolution!
The explanation will be clearer if you can *inspect the stack contents after a given statement*. To do it, just insert `X#0$%` at that point. (This means: `X#` show stack contents, `0$` don't implicitly display anything else, `%` comment out rest of the code). For example, [see the stack right after the convolution](http://matl.tryitonline.net/#code=JygpJzEyOilsMTA6Jjx0b1lQNDNZJDUxaGIoITEwWHknXDo6XCdGRmhaK1gjMCQlKyd8JzMkWWMnfHxcJzM6KDk1J1pkJ28o&input=).
```
'()'       % Push this string
12:        % Range [1 2 ... 12]
)          % Index into string (modular, 1-based): gives '()()()()()()'
l          % Push 1 (will be used later)
10:        % Range [1 2 ... 10]
&<         % All pairwise "less than" comparisons. Gives matrix with "true"
           % below the main diagonal, and the remining entries equal to "false"
to         % Duplicate. Convert to numbers (true becomes 1, false becomes 0)
YP43Y$     % Compute pi with 43 significant digits (42 decimals). Gives a string
51h        % Append last decimal, '3' (ASCII 51). This is needed to avoid rounding
b          % Bubble up the true-false matrix, to be used as logical index
(          % Fill the chars from the pi string into the 0-1 matrix, at the positions
           % indicated by the true-false matrix. Thus each 1 is replaced by a char
           % from the pi string. Entries that were 0 remain as 0. This is done in
           % columm-major order...
!          % ...so transpose to make it row-major
10Xy       % Identity matrix of size 10
'\::\'     % Push this string...
FFh        % ...and append two zeros
Z+         % 2D convolution keeping size. The identity matrix convolved with the
           % above string gives the diagonal bands with chars '\'  and ':'
+          % Add to the matrix containing the digits of pi. At each entry, only one
           % of the two matrices is nonzero
'|'        % Push this string
3$Yc       % Three-input string concatenation. This prepends the 1 (which was pushed
           % a while ago) and appends '|' to each row of the matrix. This converts
           % the matrix to char. Note that char 1 will be displayed as a space. We
           % used char 1 and not char 0 (which would be displayed as a space too)
           % because function `Yc` (`strcat`) strips  off trailing space from the
           % inputs, counting char 0 as space, but not char 1
'||\'      % Push this string
3:(        % Assign it to the first 3 entries of the matrix (column-major), that is,
           % to the top of the first column
95         % Push ASCII for '_'
'Zd'o      % Push string 'Zd' and convert to numbers: gives [90 100]. These are the
           % (column-major) indices where the '_' char should appear in the last row
(          % Fill those chars
           % Implicitly display. (Chars 0 and 1 are displayed as space)
```
[Answer]
# Perl, 93 bytes
```
$_=bpi$=;printf'()'x6x!$`.'
%12s',F.ee x!$\--^substr"\32::\\$&|",-12while/.{$\}/g
```
Requires the command line option `-l71Mbignum=bpi`, counted as 14. The `\32` should be replaced by a literal character 26.
**Sample Usage**
```
$ perl -l71Mbignum=bpi pi-slice.pl
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
---
### Perl, 111 bytes
```
$_=bpi$_*($l=($.=$_)-3);printf'()'x($./2)x!$`."
%$.s",F.ee x!$l--^substr"\32::\\$&|",-$.while/.{$l}/g
```
Parameterized version. Requires the command line option `-nMbignum=bpi`, counted as 12.
**Sample Usage**
```
$ echo 10 | perl -nMbignum=bpi pi-slice.pl
()()()()()
|\3.14159|
|:\265358|
\::\97932|
 \::\3846|
  \::\264|
   \::\33|
    \::\8|
     \__\|
$ echo 20 | perl -nMbignum=bpi pi-slice.pl
()()()()()()()()()()
|\3.141592653589793|
|:\2384626433832795|
\::\028841971693993|
 \::\75105820974944|
  \::\5923078164062|
   \::\862089986280|
    \::\34825342117|
     \::\0679821480|
      \::\865132823|
       \::\06647093|
        \::\8446095|
         \::\505822|
          \::\31725|
           \::\3594|
            \::\081|
             \::\28|
              \::\4|
               \__\|
```
[Answer]
## JavaScript (ES6), ~~187~~ 174 bytes
This is *1 byte shorter* than just displaying the plain text.
```
for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y?(Math.PI+'2384626433832795028841971693')[n++]:`\\${y>8?'__':x+1|y>2?'::':'||'}\\`[y-x]||' ';console.log(s)
```
[Answer]
# [///](http://esolangs.org/wiki////), ~~129~~ 127 bytes
```
/-/\\\\//&/--::--//%/  //#/|
%//!/()()/!!!
|-3.1415926|
|:-53589793|
&2384626|
 &433832#&79502# &8841#%&971#% &69#%%&3#%% -__-|
```
[Try it online!](http://slashes.tryitonline.net/#code=Ly0vXFxcXC8vJi8tLTo6LS0vLyUvICAvLyMvfAolJS8vIS8oKSgpLyEhIQp8LTMuMTQxNTkyNnwKfDotNTM1ODk3OTN8CiYyMzg0NjI2fAogJjQzMzgzMnwKJSY3OTUwMnwKJSAmODg0MSMmOTcxIyAmNjkjJSYzIyUgLV9fLXw)
[Answer]
# Python 2, 131 bytes
```
print'()'*6+'\n|\\3.1415926|\n|:\\53589793|'
for n in 2384626,433832,79502,8841,971,69,3,'':print'%11s|'%('\%s'*2%('_:'[n<'']*2,n))
```
Joint effort between Sp3000 and Lynn. Copper saved a byte, too! [Ideone link.](https://ideone.com/JrC2Nl)
[Answer]
# Bash, 153 bytes
```
cat << _
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
_
```
[Answer]
## Batch, 195 bytes
```
@echo ()()()()()()
@echo ^|\3.1415926^|
@echo ^|:\53589793^|
@set i=\
@for %%d in (2384626 433832 79502 8841 971 69 3)do @call:l %%d
@echo %i%__\^|
@exit/b
:l
@set i= %i%
@echo%i%::\%1^|
```
[Answer]
# Fourier, ~~196~~ 190 bytes
***New feature alert!***
## Code
```
|SaCaaSa|f|~Y0~jY(32aj^~j)|w6(40a41ai^~i)10a~N124a~W92a~S3o46a1415926oWaNaWa58a~CSa53589793oWaNaf2384626oWaNa1wf433832oWaNa2wf79502oWaNa3wf8841oWaNa4wf971oWaNa5wf69oWaNa6wf3oWaNa7wSa95aaSaWa
```
## Explanation
This program is my first demonstration of functions in Fourier:
Functions are defined like so:
```
|code goes here|f
```
The first pipe starts the function declaration. You then put the code in between the pipes. The last pipe ends the function declaration. Finally, the `f` is the variable in which the function is stored. This can be any character, as long as it isn't a reserved function.
For example, in my code, one of the function s is:
```
|SaCaaSa|f
```
Where the variable `S` stores the number 92 and `C` stores the number 58.
When called, the function outputs the following:
```
\::\
```
Since it is the most repeated thing in the pie.
Similarly, to golf down the output, I have used a loop:
```
6(40a41ai^~i)
```
Which repeats the code `40a41a` 6 times. `40a41a` on its own outputs:
```
()
```
So repeating the code six times outputs:
```
()()()()()()
```
Thereby outputting the crust of the pie.
[**Try it on FourIDE!**](https://beta-decay.github.io/editor/?code=fFNhQ2FhU2F8Znx-WTB-alkoMzJhal5-ail8dzYoNDBhNDFhaV5-aSkxMGF-TjEyNGF-VzkyYX5TM280NmExNDE1OTI2b1dhTmFXYTU4YX5DU2E1MzU4OTc5M29XYU5hZjIzODQ2MjZvV2FOYTF3ZjQzMzgzMm9XYU5hMndmNzk1MDJvV2FOYTN3Zjg4NDFvV2FOYTR3Zjk3MW9XYU5hNXdmNjlvV2FOYTZ3ZjNvV2FOYTd3U2E5NWFhU2FXYQ)
Because I haven't implemented functions in the Python interpreter, this program will not work on <http://tryitonline.net>
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/Turtl-d), ~~135~~ 129 bytes
(the interpreter isn't really  ~~slightly~~ buggèd (anymore :])~~, but it does not affect this program~~)
By restructuring and rewriting my program, I golfed... six bytes
And now I have to make new explanation...
Still could be shorter probs though
---
At least the best solution in this lang isn't just writing in the raw data ¯\*(ツ)*/¯
---
[Answer]
# Pyth, 89 bytes
```
J_2K+.n0."09\07´\C2\84J\01£\07Nl:?í"*"()"6Vr9Zp*dJp?!Z\|?qZ9"|:""\::"p\\p:KZ+ZN\|=+ZN=hJ)p*dJ"\__\|"
```
[Try it online!](http://pyth.herokuapp.com/?code=J_2K%2B.n0.%2209%07%C2%B4%C2%84J%01%C2%A3%07Nl%3A%3F%C3%AD%22%2a%22%28%29%226Vr9Zp%2adJp%3F%21Z%5C%7C%3FqZ9%22%7C%3A%22%22%5C%3A%3A%22p%5C%5Cp%3AKZ%2BZN%5C%7C%3D%2BZN%3DhJ%29p%2adJ%22%5C__%5C%7C%22&debug=0)
Replace `\xx` (hexadecimal) with the corresponding ASCII character if you copy/paste the code from this answer; it contains unprintable characters in the packed string which SE filters out.
### Explanation
```
J_2        Sets J to -2
  .n0      Pi; returns 3.141592653589793
  ."(...)" Packed string; returns "2384626433832795028841971693"
 +         Concatenation; returns "3.1415926535897932384626433832795028841971693"
K          Sets K to that string
*"()"6     Repetition; returns "()()()()()()", which is implicitly printed with a newline
 r9Z       Range; returns [9, 8, 7, 6, 5, 4, 3, 2, 1] (Z is initialized to 0)
V          Loop through r9Z, using N as the loop variable
  *dJ      Repetition; d is initialized to " " (returns an empty string if J <= 0)
 p         Print without a newline
  ?!Z      Ternary; if not Z
   \|      then return "|"
   ?qZ9    else, ternary; if Z == 9
    "|:"   then return "|:"
    "\::"  else, return "\::"
 p         Print without a newline
  \\       One-character string; returns "\"
 p         Print without a newline
  :KZ+ZN   Slice; returns K[Z:Z+N], not including K[Z+N]
 p         Print without a newline
 \|        One-character string; returns "|", which is implicitly printed with a newline.
 =+ZN      Adds N to Z
 =hJ       Increments J by 1
)          Ends loop
 *dJ       Repetition; d is initialized to " "
p          Print without a newline
"\__\|"    Returns "\__\|", which is implicitly printed with a newline
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 83 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
surely still quite golfabale
```
7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7
⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|”
```
**[TryItOnline](http://jelly.tryitonline.net/#code=N-G4tuKBtuG6izvigqzigJxcOjpc4oCd4oCcfDpc4oCd4bmt4bmZNwrigb4oKeG6izbigbfigb58XDjDmFDDpnDigJ184oG3OFJVUuKCrMK14oCc4oG-4biFfFphIn7huYXhu7XDvsi3XuG5h-KBt8SK4oCZROG5gTvigqzigJ18xbxAwqJZ4oG3w7jigbbhuos34oCcXF9fXHzigJ0&input=&args=)**
How?
```
7Ḷ⁶ẋ;€“\::\”“|:\”ṭṙ7 - Link 1, left side padding and filling
7Ḷ                   - lowered range of 7 ([0,1,2,3,4,5,6])
      “\::\”         - filling ("\::\")
  ⁶ẋ;€               - space character repeated that many times and concatenate for each
            “|:\”    - top crust edge filling ("|:\")
                 ṭ   - tack (append to the end)
                  ṙ7 - rotate to the left by 7 (move top crust filling to the top)
⁾()ẋ6⁷⁾|\8ØPæp”|⁷8RUR€µ - Main Link (divided into two for formatting)
⁾()ẋ6⁷                  - "()" repeated 6 times and a line feed
      ⁾|\               - "|\"
          ØP            - pi
         8  æp          - round to 8 significant figures (top edge of the glaze)
              ”|⁷       - "|" and a line feed
                 8R     - range of 8 ([1,2,3,4,5,6,7,8])
                   U    - reverse ([8,7,6,5,4,3,2,1])
                    R€  - range for each ([[1,2,..8],[1,2,..7],...,[1,2],[1]])
                      µ - monadic chain separation
“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’Dṁ;€”|ż@¢Y⁷ø⁶ẋ7“\__\|” - Main link (continued)
“⁾ḅ|Za"~ṅỵþȷ^ṇ⁷Ċ’                       - base 250 representation of the rest of the digits
                 D                      - decimalise (makes it a list)
                  ṁ                     - mould (into the shape of the array formed above)
                     ”|                 - "|"
                   ;€                   - concatenate for each
                         ¢              - call last link (1) as a nilad
                       ż@               - zip (with reversed operands)
                          Y⁷            - join with line feeds, and another line feed
                            ø           - niladic chain separation
                             ⁶ẋ7        - space character repeated 7 times
                                “\__\|” - "\__\|" the very bottom of the pie wedge
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 105 bytes
```
'()'*6
'|\3.1415926|
|:\53589793|'
2384626,433832,79502,8841,971,69,3|%{" "*$i+++"\::\$_|"}
' '*7+'\__\|'
```
[Try it online!](https://tio.run/nexus/powershell#BcHBDcMgDADAP1NEKJEbsKKCwdjMYol3Z6g7O73b8LohcQA3ekorXSt78GmduuhQcgiVpHFlbERCFYf2d0WRVlBHQVYkv77xiOn85JyjzWnn8vgLcEAaGWwtc9j7Dw "PowerShell – TIO Nexus")
*Not sure how I never answered this challenge ... I upvoted it and several of the other answers. Oh well, better late than never?*
This puts six balanced parens as a string on the pipeline, then a literal string (saves two bytes) of the next two rows. Then, we loop through the rest of the numbers, each iteration incrementing the number of prepended spaces (`$i`) concatenated with `\::<number>|`. Finally, we create a string of the tip of the pie. Those strings are all left on the pipeline, and an implicit `Write-Output` sticks a newline between.
This is 39 bytes shorter than [just printing the pie.](https://tio.run/nexus/powershell#RcnBDYAgDEDRO1NwQy9GaAstszRhke6O0mDMP738mY7zL5jClTGTlGrBuhIQSxOwoL1rAca6TlxCAIbywtWEboeLGbPDJW3DVWXDBR@ijqGW5nwA "PowerShell – TIO Nexus")
[Answer]
# Python 2, ~~193~~ 176 bytes
```
P="3.1415926 53589793 2384626 433832 79502 8841 971 69 3".split()
f="()"*6+"\n|\%s|\n|:\%s|\n"%(P[0],P[1])
for s in range(7):f+=" "*s+"\::\\"+P[s+2]+"|\n"
print f+" "*7+"\__\|"
```
Or a shorter, more boring answer:
```
print r"""()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|"""
```
[Answer]
# C# 220 213 209 208 202 201 (171\*) Bytes
\*I find this to be unoriginal and cheating
```
void F()=>Console.Write(@"()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|");
```
201 Bytes:
```
void f(){var s="()()()()()()\n";for(int i=0;i<9;)s+=(i<1?"|":i<2?"|:":"\\::".PadLeft(i+1))+$"\\{new[]{3.1415926,53589793,2384626,433832,79502,8841,971,69,3}[i++]}|\n";Console.Write(s+@"       \__\|");}
```
220 bytes:
I'm sure that there is something to be golfed here
```
void f(){string s="()()()()()()\n",x="       ";for(int i=9,j=0;i>0;j+=i--)s+=(i>7?"|"+(i<9?":":"")+"\\":x.Substring(i)+@"\::\")+$"{Math.PI}32384626433832795028841971693".Substring(j,i)+"|\n";Console.Write(s+x+@"\__\|");}
```
[Answer]
# Ruby, ~~140~~ ~~138~~ 137 bytes
My solution to this problem in ruby, this is my first code golf answer :D
```
[0,2384626,433832,79502,8841,971,69,3,1].map{|n|puts n<1?"()"*6+"\n|\\3.1415926|\n|:\\53589793|":"\\#{n>1?"::\\#{n}":"__\\"}|".rjust(12)}
```
**Readable version and explanation:**
```
for n in [-1,2384626,433832,79502,8841,971,69,3,0]
  if n < 0 # n == -1
    puts "()"*6+"\n|\\3.1415926|\n|:\\53589793|"
  else
    if n > 0 # digits of pi
      puts "\\::\\#{n}|".rjust(12)
    else # edge of pie
      puts "\\__\\|".rjust(12)
    end
  end
end
```
Nothing really clever, just using some simple loops :)
**Output:**
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 31 bytes
```
×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤ＵＧPi
```
[Try it online!](https://tio.run/nexus/charcoal#@394@qPGbRqaj9pmPmqbfGjno8YNj9qmARGUORkkuulR24xHjTve71n7qG1ifDxYwYRDS6wetU0/tOT9nq3v9ywPyPz/HwA)
You may be wondering: what is this sorcery? How can you fill with `ＵＧPi`? Well, Charcoal is starting to get Wolfram Language support, in the hope that one day it can be competitive in more challenges!
## Previous, 71 bytes
```
×⁶()↙↓¹⁰↖↖¹⁰↓↓²↘⁸Ｍ↑__↖←¤:↗¤3.141592653589793238462643383279502884197169
```
[Try it online!](https://tio.run/nexus/charcoal#@394@qPGbRqaj9pmPmqbfGjno8YNj9qmARGUORkkuulR24xHjTve71n7qG1ifDxYwYRDS6wetU0/tMRYz9DE0NTSyMzU2NTC0tzS2MjYwsTMyMzE2NjC2Mjc0tTAyMLCxNDS3NDM8v9/AA "Charcoal – TIO Nexus")
## Verbose
```
Print(Multiply(6, "()"));
Move(:DownLeft)
Print(:Down, 10)
Move(:UpLeft)
Print(:UpLeft, 10)
Move(:Down)
Print(:Down, 2)
Print(:DownRight, 8)
Move(:Up)
Print("__")
Move(:UpLeft)
Move(:Left)
Fill(":")
Move(:UpRight)
Fill("3.141592653589793238462643383279502884197169")
```
Note that this is different as the deverbosifier automatically compresses strings and does not remove redundant commands.
## With compressed strings, 52 bytes
```
×⁶¦()↙↓¹⁰↖↖¹⁰↓↓²↘⁸↑__↖←¤:Ｍ↗¤”i¶∧²uτ¶R›    §Ｑ´⌈#_⮌ＰOÞ”
```
## xxd output
```
0000000: aab6 ba28 291f 14b1 b01c 1cb1 b014 14b2  ...()...........
0000010: 1eb8 125f 5f1c 11ef 3acd 1def 0469 0a01  ...__...:....i..
0000020: b275 f40a 52be 0999 9fa4 d1e0 1a23 5f86  .u..R........#_.
0000030: d04f de04                                .O..
```
[Try it online!](https://tio.run/nexus/charcoal#XY3NDoIwEITvPAXpqU3Q0G5/8Wo8SWJMPHNCadIAMRXj01elEoHbzs43M@F0t63H5cN527sXllmKMEGE7JKyG2pc7Ltne6yvniSRHB9ZSnPyAy79wo5yDnwDqzRb6LO9NZ@E/jdONqoqtN6JKt4H6xxGxYwZuyYDtpRTYZgUILRRBhhoLpnkABqYMiJnWnNqFJUGkRDCZngD "Charcoal – TIO Nexus")
[Answer]
# PHP, 170 bytes
no arbritrary precision Pi in PHP? Calculating takes much more space than Copy&Paste. Doesn´t matter that the last digit here is cut, not rounded; but in 64 bit Pi the last digit gets rounded up.
```
for(;$i<11;)echo str_pad($i?["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)].[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]."|
":"
",13,$i++?" ":"()",0);
```
Run with `php -r '<code>'`
**uncommented breakdown**
```
for(;$i<11;)
    echo str_pad($i?
         ["\\__\\","|\\","|:\\","\\::\\"][$i>9?0:min(3,$i)]
        .[3.1415926,53589793,2384626,433832,79502,8841,971,69,3][$i-1]
        ."|\n"
    :"\n"
    ,13,$i++?" ":"()",0);
```
[Answer]
# Python 2, ~~183~~ 171 bytes
```
p,d=[2384626,433832,79502,8841,971,69,3],"|\n"
c=("()"*6)+d[1]+"|\\"+`3.1415926`+d+"|:\\"+`53589793`+d
for x in range(7):c+=" "*x+"\\::\\"+`p[x]`+d
print c+" "*7+"\\__\\|"
```
Does't really do anything clever. Just builds up a big string then prints it out.
**EDIT**
Reduced to 171 after reading @Lynn's answer and learning. Sorry if it is wrong to (shamelessly) steal some bytes from you without you suggesting it. Please tell me if so and I will roll back the change.
**Output**
```
python pi.pie.py
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 63 bytes
```
ü?½Pi<Θ*q}ü¿▒5Ç>cdƒ±<Gw►,─ô╟▒g•iâÑ♠514Φ⌂!Ñεùáèè♂ÑD╔«dÿ47¡ô#UV•╧
```
[Run and debug online!](https://staxlang.xyz/#p=813fab50693ce92a717d81a8b135803e63649ff13c4777102cc493c7b167076983a506353134e87f21a5ee97a08a8a0ba544c9ae64983437ad9323555607cf&a=1)
Shorter than the accepted MATL answer. It would definitely be shorter if more digits were stored as the constant pi in Stax.
(What is that `Pi<0` in the code?)
## Explanation
Uses the ASCII equivalent to explain, which is
```
.()6*PVP$2ME.|\a+"|:\"a+"!RNyb2L$-!mV=223w+&O-"!{"\::\"s$+mELr"\__\"]+|>m'|+
```
Expalantion:
```
.()6*PVP$2ME.|\a+"|:\"a+
.()                           "()"
   6*P                        Print 6 times
      VP$                     First two lines of pi in the output
         2ME                  Push the two lines separately on the stack
            .|\a+             Prepend the first line with "|\"
                 "|:\"a+      Prepend the second line with "|:\"
"..."!{"\::\"s$+mELr"\__\"]+|>m'|+
"..."!                                [2384626,433832,79502,8841,971,69,3]
      {"\::\"s$+m                     Convert each element to a string and prepend "\::\"
                 ELr                  Prepend the first two lines to array
                    "\__\"]+          Append "\__\" to the converted array
                            |>        Right align text
                              m'|+    Append "|" to each array element and print
```
[Answer]
# Java 7, ~~260~~ ~~236~~ 191 bytes
```
String d(){return"()()()()()()\n|\\3.1415926|\n|:\\53589793|\n\\::\\2384626|\n \\::\\433832|\n  \\::\\79502|\n   \\::\\8841|\n    \\::\\971|\n     \\::\\69|\n      \\::\\3|\n       \\__\\|";}
```
Sigh, simply outputting the pie is shorter, even with all the escaped backslashes.. >.>
Here is previous answer with a tiny bit of afford, although still not very generic or fancy (**236 bytes**):
```
String c(){String n="\n",p="|",q=p+n,x="\\::\\",s=" ",z=s;return"()()()()()()"+n+p+"\\"+3.1415926+q+p+":\\53589793"+q+x+2384626+q+s+x+433832+q+(z+=s)+x+79502+q+(z+=s)+x+8841+q+(z+=s)+x+971+q+(z+=s)+x+69+q+(z+=s)+x+3+q+(z+=s)+"\\__\\|";}
```
A pretty boring answer, since simply outputting the result without too much fancy things is shorter in Java than a generic approach.
**Ungolfed & test code:**
[Try it here.](https://ideone.com/FW4KmJ)
```
class M{
  static String c(){
    String n = "\n",
           p = "|",
           q = p + n,
           x = "\\::\\",
           s = " ",
           z = s;
    return "()()()()()()" + n + p + "\\" + 3.1415926 + q + p + ":\\53589793" + q + x + 2384626 + q + s
            + x + 433832 + q + (z += s) + x + 79502 + q + (z += s) + x + 8841 + q
            + (z += s) + x + 971 + q + (z += s) + x + 69 + q + (z += s) + x + 3 + q
            + (z += s) + "\\__\\|";
  }
  public static void main(String[] a){
    System.out.println(c());
  }
}
```
**Output:**
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# Qbasic, 175 bytes
```
?"()()()()()()":?"|\3.1415926|":?"|:\53589793|":?"\::\2384626|":?" \::\433832|":?"  \::\79502|":?"   \::\8841|":?"    \::\971|":?"     \::\69|":?"      \::\3|":?"       \__\|"
```
[Answer]
# Lua, 152 Bytes
```
print[[()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|]]
```
Try as I might I could not compress this pi.
Lua is just too verbose to do it, maybe a pi of greater size, but not this one.
Another solution, 186 Bytes.
```
s="()()()()()()\n|\\3.1415926|\n|:\\53589793|\n"i=0 for z in('2384626|433832|79502|8841|971|69|3|'):gmatch'.-|'do s=s..(' '):rep(i)..'\\::\\'..z.."\n"i=i+1 end print(s..'       \\__\\|')
```
Annoyingly Lua's pi isn't accurate enough to even fill the pi. :(
[Answer]
# Javascript, 172 bytes
Paste into your console to run.
```
for(y=n=0,s=`()()()()()()
`;y<10;y++,s+=`|
`)for(x=-2;x++<9;)s+=x>y(Math.PI+'2384626433832795028841971693'[n++]:`\\${y>8?'__':x+1|y>1?'::':'||'}\\`[y-x]||' ';console.log(s)
```
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 871 bytes
```
{iiii}cicdcicdcicdcicdcicdcic{ddd}dc{{i}}{i}iiiic{ddd}ddc{dddd}dcdddddciiiciiicdddciiiiciiiic{d}iiiciiiic{{i}ddd}c{{d}}{d}ddddc{{i}}{i}iiiic{dddddd}ddddddc{iii}iiiic{dddd}icddciiciiicicddciicddddddc{{i}ddd}iiic{{d}}{d}ddddc{{i}dd}iic{ddd}ddddcc{iii}iiiic{dddd}ddciciiiiicddddciicddddciiiic{{i}ddd}c{{d}}{d}ddddc{ii}iic{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}cdcciiiiicdddddcdc{{i}ddd}iiiic{{d}}{d}ddddc{ii}iicc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}iiiciicddddcdddddciic{{i}ddd}iiiic{{d}}{d}ddddc{ii}iiccc{iiiiii}c{ddd}ddddcc{iii}iiiic{ddd}ddddddccddddcdddc{{i}ddd}iiiiic{{d}}{d}ddddc{ii}iicccc{iiiiii}c{ddd}ddddcc{iii}iiiic{ddd}dddddcddcddddddc{{i}ddd}iiiiic{{d}}{d}ddddc{ii}iiccccc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}iiciiic{{i}ddd}dddc{{d}}{d}ddddc{ii}iicccccc{iiiiii}c{ddd}ddddcc{iii}iiiic{dddd}dc{{i}ddd}iiic{{d}}{d}ddddc{ii}iiccccccc{iiiiii}ciiiccdddc{iii}iic{{d}}{d}ddddc
```
[Try it online!](https://tio.run/##jdJdDsMgCADgE@1QC2wZz3s0nN3xO@lmG5oYieInweLjjk96v25zDpKPgQA3YyAiI4xBzDI0NdbQZt3USXJlR0fEBJHLKxZAT0iAoqmBG9p139PK1garDnFPxpkauF/049t61i1rf7BSVqR7sObzuk0wyfp3oUsnCy4Nq9XSlm253lmvNB@hQTfsfICvfWDP3DYMWXDTbXYD6ms5vuda3tU/VahlaRqU3/Z4Zs4P "Deadfish~ – Try It Online")
Just because.
[Answer]
**JavaScript (ES6), ~~170 bytes~~ 165 bytes**
is a bit "cheated", since if run on the console, the return value would be displayed
```
v=0;("()()()()()()\n|9|:87654321".replace(/\d/g,(o)=>"\\"+(Math.PI+'2384626433832795028841971693').substr(v,o,v-=-o)+"|\n"+(o<9?" ".repeat(8-o)+(o>1?"\\::":"\\__\\|"):""))
```
After some teaking, the function looks like this(function must be called with parameter with the value 0):
```
v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)
```
If you want to call the function 167 bytes:
```
z=v=>`()()()()()()
 |9 |:87654321\\__\\|`.replace(/\d/g,o=>`\\${(Math.PI+"2384626433832795028841971693").substr(v,o,v-=-o)}|
${" ".repeat(9-o)+(o<9&o>1?"\\::":"")}`)
/*could be run like this or directly in the console*/
console.info("\n"+z(0));
```
[Answer]
# PHP, 142 bytes
Sneaky-sneaky :) `php` just prints everything out without trying to interpret them as PHP code if it does not see any `<?php ?>` pairs.
```
()()()()()()
|\3.1415926|
|:\53589793|
\::\2384626|
 \::\433832|
  \::\79502|
   \::\8841|
    \::\971|
     \::\69|
      \::\3|
       \__\|
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 76 bytes
```
`:+R' 7"¦__¦|":*"()"6§+(mo:'|t↑2)↓2m↓3z+zR¢" "Nmo`:'|+"¦::¦"Cṫ9Γ·::'.ṁs↑54İπ
```
[Try it online!](https://tio.run/##yygtzv7/P8FKO0hdwVzp0LL4@EPLapSstJQ0NJXMDi3X1sjNt1KvKXnUNtFI81HbZKNcIGFcpV0VdGiRkoKSX25@AlBaG6jRyurQMiXnhztXW56bfGi7lZW63sOdjcVAfaYmRzacb/j/HwA "Husk – Try It Online")
There's probably some interesing way to shorten this further.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 64 bytes
```
‛()6*15∆Iṅ\.1Ṁ½÷$‛|\p$`|:\\`p"43∆I16ȯ7ɾṘẇvṅ‛\:mvp‛\_mJJ\|vJJ12↳⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigJsoKTYqMTXiiIZJ4bmFXFwuMeG5gMK9w7ck4oCbfFxccCRgfDpcXFxcYHBcIjQz4oiGSTE2yK83yb7huZjhuod24bmF4oCbXFw6bXZw4oCbXFxfbUpKXFx8dkpKMTLihrPigYsiLCIiLCIiXQ==)
]


[Question]
      [
# Challenge
Given an input of an all-lowercase string `[a-z]`, output the total distance between the letters.
## Example
```
Input: golf
Distance from g to o : 8
Distance from o to l : 3
Distance from l to f : 6
Output: 17
```
## Rules
* Standard loopholes forbidden
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") - shortest answer in bytes wins.
* The alphabet can be traversed from either direction. **You must always use the shortest path.** (i.e the distance between `x` and `c` is 5).
![1](https://i.stack.imgur.com/RyIZy.jpg)
# Test cases
```
Input: aa
Output: 0
Input: stack
Output: 18
Input: zaza
Output: 3
Input: valleys
Output: 35
```

[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~11~~ 8 bytes
```
OIæ%13AS
```
Saved 3 bytes thanks to @[Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
[Try it online!](http://jelly.tryitonline.net/#code=T0nDpiUxM0FT&input=&args=J2dvbGYn) or [Verify all test cases.](http://jelly.tryitonline.net/#code=T0nDpiUxM0FTCsOH4oKs&input=&args=Wydnb2xmJywgJ2FhJywgJ3N0YWNrJywgJ3phemEnLCAndmFsbGV5cydd)
## Explanation
```
OIæ%13AS  Input: string Z
O         Ordinal. Convert each char in Z to its ASCII value
 I        Increments. Find the difference between each pair of values
  æ%13    Symmetric mod. Maps each to the interval (-13, 13]
      A   Absolute value of each
       S  Sum
          Return implicitly
```
[Answer]
## Haskell, ~~57~~ 56 bytes
```
q=map$(-)13.abs
sum.q.q.(zipWith(-)=<<tail).map fromEnum
```
Usage example: `sum.q.q.(zipWith(-)=<<tail).map fromEnum $ "valleys"` -> `35`.
How it works:
```
q=map$(-)13.abs                -- helper function.
                               -- Non-pointfree: q l = map (\e -> 13 - abs e) l
                               -- foreach element e in list l: subtract the
                               -- absolute value of e from 13
               map fromEnum    -- convert to ascii values
      zipWith(-)=<<tail        -- build differences of neighbor elements
  q.q                          -- apply q twice on every element
sum                            -- sum it up
```
Edit: @Damien saved one byte. Thanks!
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~14~~, 10 bytes
```
dt_v26\X<s
```
[Try it online!](http://matl.tryitonline.net/#code=ZHRfdjI2XFg8cw&input=J3ZhbGxleXMn)
*Thanks [@Suever](https://codegolf.stackexchange.com/users/51939/suever) for saving 4 bytes!*
Explanation:
```
d           % Take the difference between consecutive characters
 t_         % Make a copy of this array, and take the negative of each element
   v        % Join these two arrays together into a matrix with height 2
    26\     % Mod 26 of each element
       X<   % Grab the minimum of each column
         s  % Sum these. Implicitly print
```
Previous version:
```
d26\t13>26*-|s
```
[Answer]
## Python 3, ~~69~~ 68 bytes
```
lambda s:sum([13-abs(13-abs(ord(a)-ord(b)))for a,b in zip(s,s[1:])])
```
Breakdown:
```
lambda s:
         sum(                                                      )
             [                             for a,b in zip(s,s[1:])]
              13-abs(13-abs(ord(a)-ord(b)))
```
[Answer]
# Java, ~~126~~ ~~120~~ 117 bytes
```
int f(String s){byte[]z=s.getBytes();int r=0,i=0,e;for(;++i<z.length;r+=(e=(26+z[i]-z[i-1])%26)<14?e:26-e);return r;}
```
Thanks to @KevinCruijssen for pointing out a bug in the original version and suggesting to make the for-loop empty.
The use of `(26 + z[i] - z[i - 1]) % 26)` is inspired from a comment by @Neil on another answer. `(26 + ...)%26` serves the same purpose as `Math.abs(...)` because of `...? e : 26 - e`.
**Ungolfed**:
```
int f(String s) {
    byte[]z = s.getBytes();
    int r = 0, i = 0, e;
    for (; ++i < z.length; r += (e = (26 + z[i] - z[i - 1]) % 26) < 14 ? e : 26 - e);
    return r;
}
```
[Answer]
## JavaScript (ES6), ~~84~~ ~~82~~ 79 bytes
Saved 3 bytes thanks to Cyoce:
```
f=([d,...s],p=parseInt,v=(26+p(s[0],36)-p(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0
```
**Explanation:**
```
f=(
  [d,...s],                    //Destructured input, separates first char from the rest
  p=parseInt,                  //p used as parseInt
  v=(26+p(s[0],36)-p(d,36))%26 //v is the absolute value of the difference using base 36 to get number from char
  )
)=>
  s[0]?                        //If there is at least two char in the input
    f(s)                       //sum recursive call
    +                          //added to
    (v>13?26-v:v)              //the current shortest path
  :                            //else
    0                          //ends the recursion, returns 0
```
**Example:**
Call: `f('golf')`
Output: `17`
---
Previous solutions :
82 bytes thanks to Neil:
```
f=([d,...s],v=(26+parseInt(s[0],36)-parseInt(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0
```
84 bytes:
```
f=([d,...s],v=Math.abs(parseInt(s[0],36)-parseInt(d,36)))=>s[0]?f(s)+(v>13?26-v:v):0
```
[Answer]
## Ruby, 73 bytes
```
->x{eval x.chars.each_cons(2).map{|a,b|13-(13-(a.ord-b.ord).abs).abs}*?+}
```
[Answer]
# PHP, 93 Bytes
```
for(;++$i<strlen($s=$argv[1]);)$r+=13<($a=abs(ord($s[$i-1])-ord($s[$i])))?$a=26-$a:$a;echo$r;
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 12 bytes
```
SÇ¥YFÄ5Ø-}(O
```
**Explanation**
```
SÇ                   # convert to list of ascii values
  ¥                  # take delta's
   YF    }           # 2 times do
     Ä5Ø-            # for x in list: abs(x) - 13
          (O         # negate and sum
```
[Try it online!](http://05ab1e.tryitonline.net/#code=U8OHwqVZRsOENcOYLX0oTw&input=dmFsbGV5cw)
[Answer]
# Perl, 46 bytes
Includes +3 for `-p` (code contains `'`)
Give input on STDIN without final newline:
```
echo -n zaza | stringd.pl
```
`stringd.pl`:
```
#!/usr/bin/perl -p
s%.%$\+=13-abs 13-abs ord($&)-ord$'.$&%eg}{
```
[Answer]
## Racket 119 bytes
```
(λ(s)(for/sum((i(sub1(string-length s))))(abs(-(char->integer
(string-ref s i))(char->integer(string-ref s(+ 1 i)))))))
```
Testing:
```
(f "golf")
```
Output:
```
17
```
Detailed version:
```
(define(f s)
  (for/sum((i(sub1(string-length s))))
    (abs(-(char->integer(string-ref s i))
          (char->integer(string-ref s(+ 1 i)))))))
```
[Answer]
# C#, 87 85 bytes
**Improved** solution - *replaced Math.Abs() with the add & modulo trick to save 2 bytes:*
```
s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=(s[i]-s[++i]+26)%26)>13?26-d:d;return l;};
```
**Initial** solution:
```
s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};
```
**[Try it online!](https://ideone.com/4KtV7g)**
Full source, including test cases:
```
using System;
namespace StringDistance
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,int>f= s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};
            Console.WriteLine(f("golf"));   //17
            Console.WriteLine(f("aa"));     //0
            Console.WriteLine(f("stack"));  //18
            Console.WriteLine(f("zaza"));   //3
            Console.WriteLine(f("valleys"));//35
        }
    }
}
```
[Answer]
# Actually, 21 bytes
Based partially on [cia\_rana's Ruby answer](https://codegolf.stackexchange.com/a/93654/47581).
There was a bug with `O` (in this case, map ord() over a string) where it would not work with `d` (dequeue bottom element) and `p` (pop first element) without first converting the map to a list with `#`. This bug has been fixed, but as that fix is newer than this challenge, so I've kept `#` in.
**Edit:** And the byte count has been wrong since September. Whoops.
Golfing suggestions welcome. [Try it online!](http://actually.tryitonline.net/#code=TyM7ZFhAcFjimYAtYEE7w7psLWttYE3Oow&input=InZhbGxleXMi)
```
O#;dX@pX♀-`A;úl-km`MΣ
```
**Ungolfing**
```
         Implicit input string.
          The string should already be enclosed in quotation marks.
O#       Map ord() over the string and convert the map to a list. Call it ords.
;        Duplicate ords.
dX       Dequeue the last element and discard it.
@        Swap the with the duplicate ords.
pX       Pop the last element and discard it. Stack: ords[:-1], ords[1:]
♀-       Subtract each element of the second list from each element of the first list.
          This subtraction is equivalent to getting the first differences of ords.
`...`M   Map the following function over the first differences. Variable i.
  A;       abs(i) and duplicate.
  úl       Push the lowercase alphabet and get its length. A golfy way to push 26.
  -        26-i
  k        Pop all elements from stack and convert to list. Stack: [i, 26-i]
  m        min([i, 26-i])
Σ        Sum the result of the map.
         Implicit return.
```
[Answer]
# Java 7,128 bytes
```
 int f(String s){char[]c=s.toCharArray();int t=0;for(int i=1,a;i<c.length;a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);return t;}
```
# Ungolfed
```
 int f(String s){
 char[]c=s.toCharArray();
 int t=0;
 for(int i=1,a;
     i<c.length;
   a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);
return t;
 }
```
[Answer]
# Pyth, 20 bytes
```
Lm-13.adbsyy-M.:CMQ2
```
A program that takes input of a quoted string on STDIN and prints the result.
[Try it online](https://pyth.herokuapp.com/?code=Lm-13.adbsyy-M.%3ACMQ2&test_suite=1&test_suite_input=%22aa%22%0A%22stack%22%0A%22zaza%22%0A%22valleys%22&debug=0)
**How it works**
```
Lm-13.adbsyy-M.:CMQ2  Program. Input: Q
L                     def y(b) ->
 m      b              Map over b with variable d:
  -13                   13-
     .ad                abs(d)
                CMQ   Map code-point over Q
              .:   2  All length 2 sublists of that
            -M        Map subtraction over that
          yy          y(y(that))
         s            Sum of that
                      Implicitly print
```
[Answer]
## dc + od, 65 bytes
```
od -tuC|dc -e'?dsN0sT[lNrdsNr-d*vdD[26-]sS<Sd*vlT+sTd0<R]dsRxlTp'
```
**Explanation:**
Because in *dc* you can't access a string's characters, I used *od* to get the ASCII values. These will be processed in reverse order from the stack (LIFO container) like so:
```
dsN0sT             # initialize N (neighbor) = top ASCII value, and T (total) = 0
[lNrdsNr-          # loop 'R': calculate difference between current value and N,
                   #updating N (on the first iteration the difference is 0)
   d*vdD[26-]sS<S  # get absolute value (d*v), push 13 (D) and call 'S' to subtract
                   #26 if the difference is greater than 13
   d*vlT+sT        # get absolute value again and add it to T
d0<R]dsR           # repeat loop for the rest of the ASCII values
xlTp               # the main: call 'R' and print T at the end
```
**Run:**
```
echo -n "golf" | ./string_distance.sh
```
**Output:**
```
17
```
[Answer]
# C, ~~82 86 83~~ 76 bytes
```
t,u;f(char*s){for(t=0;*++s;u=*s-s[-1],t+=(u=u<0?-u:u)>13?26-u:u);return t;}
```
Assumes input string is at least one character long. This doesn't require `#include<stdlib.h>`
Edit: Argh, sequence points!
[Try it on Ideone](https://ideone.com/mLjkOm)
[Answer]
# C, 70 bytes ~~76 bytes~~
```
k,i;f(char *s){for(i=0;*++s;i+=(k=abs(*s-s[-1]))>13?26-k:k);return i;}
```
[Answer]
# Scala, 68 bytes
```
def f(s:String)=(for(i<-0 to s.length-2)yield (s(i)-s(i+1)).abs).sum
```
Criticism is welcome.
[Answer]
# C#, 217 bytes
Golfed:
```
IEnumerable<int>g(string k){Func<Char,int>x=(c)=>int.Parse(""+Convert.ToByte(c))-97;for(int i=0;i<k.Length-1;i++){var f=x(k[i]);var s=x(k[i+1]);var d=Math.Abs(f-s);yield return d>13?26-Math.Max(f,s)+Math.Min(f,s):d;}}
```
Ungolfed:
```
IEnumerable<int> g(string k)
{
  Func<Char, int> x = (c) => int.Parse("" + Convert.ToByte(c)) - 97;
  for (int i = 0; i < k.Length - 1; i++)
  {
    var f = x(k[i]);
    var s = x(k[i + 1]);
    var d = Math.Abs(f - s);
    yield return d > 13 ? 26 - Math.Max(f, s) + Math.Min(f, s) : d;
  }
}
```
Output:
```
aa: 0
stack: 18
zaza: 3
valleys: 35
```
'a' is 97 when converted to bytes, so 97 is subtracted from each one. If the difference is greater than 13 (ie, half of the alphabet), then subtract the differences between each character (byte value) from 26. A last minute addition of "yield return" saved me a few bytes!
[Answer]
# Python 3, 126 bytes
With list *in*comprehension.
```
d=input()
print(sum([min(abs(x-y),x+26-y)for x,y in[map(lambda x:(ord(x)-97),sorted(d[i:i+2]))for i in range(len(d))][:-1]]))
```
[Answer]
# PHP, 79 bytes
```
for($w=$argv[1];$w[++$i];)$s+=13-abs(13-abs(ord($w[$i-1])-ord($w[$i])));echo$s;
```
[Answer]
# Java, 109 bytes
```
int f(String s){int x=0,t,a=0;for(byte b:s.getBytes()){t=a>0?(a-b+26)%26:0;t=t>13?26-t:t;x+=t;a=b;}return x;
```
]


[Question]
      [
I remember people saying that code size should be measured in bytes, and not in characters, because it's possible to store information with weird Unicode characters, which have no visual meaning.
How bad can it be?
In this challenge, you should output the following Lorem Ipsum text, taken from [Wikipedia](https://en.wikipedia.org/wiki/Lorem_ipsum#Example_text):
```
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
```
Please specify the number of *characters* (not bytes) in your code. Code with the minimal number of characters wins.
Your code should only contain valid Unicode characters, as described [here](https://en.wikipedia.org/wiki/Valid_characters_in_XML#XML_1.1), that is:
* Code points up to U+10FFFF
* No surrogates (the range D800–DBFF is forbidden)
* No characters FFFE and FFFF
* No null characters (code 0)
If your code cannot be displayed, provide a version with offending characters redacted, and a hexdump.
Some notes:
* The output must be one long line (445 characters). If your system cannot do that (e.g. you're printing it on paper), output a closest approximation. Trailing linebreaks don't matter.
* Built-in functions that generate Lorem Ipsum text are not allowed
* Please specify a valid text encoding for your code, if relevant

[Answer]
# JavaScript (ES7), ~~326~~ ~~283~~ ~~273~~ ~~249~~ ~~243~~ 242 chars
```
_=>"򾍮󂙙󱤭󕜛񟉝񚫎󸦘󏇌󻮾󪕍򦙜񴫰𭙝𧇍񛜃򧮖󓔽򅬸󪙗񴦲񿫽񟮩򺥸󫡽񛜕󖷉󂨗񢕕򦯊񗮣󌫉񣔶򥹖񟷗򢫂󧩜񝼜󾿍񙇛񴮪󼬗񟪵񥦘񝕋󖹜񝹜򢟝񚪲󧩙񙁪񛌖󆆸񛌗󳭞񧔍􄮉񧮮񜭾󫤭󕜛񜫩󫬻򄗗񻭲󺙗񟼕􆞪󻤿򅙝𯎎񛉕򹤭󕜛򀿉򏨒񧔷􅚪񞕛򢮾󪂌򆞮􆴼򥾩󓆊򃅝񛏙򣕝񧔷󕴹󮉍򅾢󷫽񜫩񷪹񢝞򢜏򌦒񢖮󳭾󏔶󕚲󺕗򥤲񸾝񝕋󖿇"[r='replace'](/./gu,c=>(c.codePointAt()-4**8).toString(32))[r](/\d/g,d=>"  , exum. ".substr(d,2))[r](/^.|\. ./g,x=>x.toUpperCase())
```
### How it works
The first step in my compression technique is to convert the whole string to lowercase (not mandatory, but looks better), and replace each pair of chars in `, exum.` (as well as the trailing space by itself) with its index in the string plus 2. This makes the text a valid base-32 number:
```
lorem9ips69dolor9sit9amet2consectetur9adipiscing3lit2sed9do3iusmod9tempor9incididunt9ut9labore3t9dolore9magna9aliqua8ut3nim9ad9minim9veniam2quis9nostrud94ercitation9ullamco9laboris9nisi9ut9aliquip943a9commodo9consequat8duis9aute9irure9dolor9in9reprehenderit9in9voluptate9velit3sse9cill69dolore3u9fugiat9nulla9pariatur84cepteur9sint9occaecat9cupidatat9non9proident2sunt9in9culpa9qui9officia9deserunt9mollit9anim9id3st9laboru7
```
The next step is to convert each 4-char run to decimal, then get the character at that code point. This can be done with the following function:
```
f=s=>s.replace(/..../g,x=>(n=parseInt(x,32),String.fromCharCode(0xD800+(n>>10),0xDC00+(n&0x03FF))))
```
(**Note:** Since all digits are 2 or greater, the minimum possible value of four digits is 2222₃₂. This is equal to 95978₁₀, or 176EA₁₆; therefore, code points will never be in the restricted range.)
And now we have our compressed string:
```
򾍮󂙙󱤭󕜛񟉝񚫎󸦘󏇌󻮾󪕍򦙜񴫰𭙝𧇍񛜃򧮖󓔽򅬸󪙗񴦲񿫽񟮩򺥸󫡽񛜕󖷉󂨗񢕕򦯊񗮣󌫉񣔶򥹖񟷗򢫂󧩜񝼜󾿍񙇛񴮪󼬗񟪵񥦘񝕋󖹜񝹜򢟝񚪲󧩙񙁪񛌖󆆸񛌗󳭞񧔍􄮉񧮮񜭾󫤭󕜛񜫩󫬻򄗗񻭲󺙗񟼕􆞪󻤿򅙝𯎎񛉕򹤭󕜛򀿉򏨒񧔷􅚪񞕛򢮾󪂌򆞮􆴼򥾩󓆊򃅝񛏙򣕝񧔷󕴹󮉍򅾢󷫽񜫩񷪹񢝞򢜏򌦒񢖮󳭾󏔶󕚲󺕗򥤲񸾝񝕋󖿇
```
That's 445 chars compressed into 106 chars. The decompression simply reverses this process:
1. Convert each char to its code-point in base-32, minus 65536.
2. Replace each digit `n` with `" , exum. ".substr(n,2)`.
3. Convert each letter after a period or at the beginning of the string to uppercase.
The only ES7 feature used is `**`. Replace `4**8` with `65536` to run in a browser that doesn't yet support ES7.
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 123 characters
All but the final period are packed into 111 32-bit characters (UTF-32).
```
'.',⍨80⎕DR'𦽌򒁭󗕳󆽤𲁲𒁴󇑥󦽣񆍥𧕴򖑡𷍩􆝮񆥬񗌠󶐠񖥥񆽭󖕴􇉯򖍮񖑩񒁴𖰠񗉯􇑥󶱯󒁥𖹧򖱡󦅵􇑕󖥮􆑡򖹩񗘠󖅩񗄠󢁳𧑳񒁤𷉥񆅴􆹯𖱬􆽣󶉡􇍩򗍩􇑵𖥬􇁩񒁸󶌠񆽭󶌠𖕳󧑡򗕄񖄠򒁥񗉵󆽤򒁲񗈠򆕲񖑮􇑩񢁮􇕬񗑡󆕶񒁴􆕳󆱩񂁭𦽬񖔠񷕦􇑡󆱵𗀠񆅩􂹲񖍸񖕴򗌠󲁴񖅣􇑡򗁵𗑡󶸠𧀠񖑩􂱴񆹵􆹩􆱵񗄠񦼠򖍩񖐠񗉥󒁴򖱬󦄠򒁭𶔠𖰠񗉯'
```
`'.',⍨` period appended to
`80⎕DR` the 8-bit (`8`) character (`0`) **D**ata **R**epresentation of
`'`...`'` the 111 Unicode characters U+**26F4C 9206D D7573 C6F64 32072 12074 C7465 E6F63 46365 27574 96461 37369 10676E 4696C 57320 F6420 56965 46F6D D6574 10726F 9636E 56469 52074 16C20 5726F 107465 F6C6F D2065 16E67 96C61 E6175 107455 D696E 106461 96E69 57620 D6169 57120 E2073 27473 52064 37265 46174 106E6F 16C6C 106F63 F6261 107369 97369 107475 1696C 107069 52078 F6320 46F6D F6320 16573 E7461 97544 56120 92065 57275 C6F64 92072 57220 86572 5646E 107469 6206E 10756C 57461 C6576 52074 106573 C6C69 4206D 26F6C 56520 77566 107461 C6C75 17020 46169 102E72 56378 56574 97320 F2074 56163 107461 97075 17461 F6E20 27020 56469 102C74 46E75 106E69 106C75 57120 66F20 96369 56420 57265 D2074 96C6C E6120 9206D 36520 16C20 5726F**, which all fall in the range 12074–10756C and thus inside the OP's all-permitted range 10000–10FFFF.
[Answer]
# bash + coreutils + gzip + recode, 191 characters
```
echo -ne "ᾋࠀ㰟퍗\03㖐셱䌱ࡄ戋⪒宮⦀⃬〣ख़ʏ쬏湂삲מּ浊莎ᔍ얪䴬畐Ꮏ肭⽡តप㩴뇶ᮤ樶鞔岀梬昅⹭盖ꈥ먣Ვ빓ỢꞴꃑ괓꣪㷨삗䎺뛔䛓ﵸ摉篨䊷૤⦓헉픺ꉖ橬ꟲỒꗻ퉋則ใ⢍럴摧耼񸺷⒅୴䘺㦳櫇鐱窑駁愵䚞鎴鍉Ⅻक़毽➔脂ힸ⤹喝葁㎋頇㺞ⳃ┶왤惌⒜猜䌋吏젔掚ᛩ鯢⚕䜹鴛皽⨫ꇈ銹믍䄛逦軵융󌒣杻龇븁\0"|recode u8..utf16be|tr -d ٣ܣ|gunzip
```
The string is the gzip of the text interpreted as UTF-16BE, plus a few extra bytes to pair with the unpaired surrogate halves. The tr strips off the extra surrogate halves.
This script file (or the shell into which this command is typed) should interpret text as UTF-8, which is why the recode is needed.
[Answer]
## Javascript (ES6), ~~261~~ ~~255~~ 254 characters
*Saved 1 byte, thanks to ETHproductions*
```
_=>'L'+"⫒㠰拳␰䨒堵̎⨦W䙨ⅶ嵷˘㥆姳䗨⠬巯堡Ŋɩ懪䨶尩个˒≎㥎䜩怷㰷䤆ŵ̊㹩⫒ᨠᩌ㳠抮f̅㩊ᠰ䀩㩎搰㩊ئ抠ˮ婱拗⠩啺巨㬆ɒ㸘∦㰲䤆姵㩀Ƕ̘㨆㬴⠳⠺…䈲䥒䤠⫱᬴w㬣ᠶ⬘嗠⫘䥀噯䗠⫀⫓䕭啩̎Ɏ㹹庘⬆⭀巯奠Ŷ㷨䌯䥀噯⠪ⰸ㦸̆㼱ï哳峮૘梠䵨慷堵幎≠⣨峨愠◳ᬆ䐷ɒ䫓⥎ܑ拠̑Ɏ㼨ó㬴⹠⇫î奩拊̑㹰巯䓠ȮŎ廪ᨀ噧ਸ".replace(/./g,c=>(s=" ,.DEUabcdefghilmnopqrstuvx")[(c=c.charCodeAt()-32)&31]+s[c>>5&31]+s[c>>10])
```
### Breakdown
Payload: 148 Unicode characters
Code: 107 bytes
### How it works
We first remove the leading `'L'` from the original message so that we're left with 444 = 148 \* 3 characters.
Without the leading `'L'`, the character set is made of the 27 following characters:
```
" ,.DEUabcdefghilmnopqrstuvx"
```
Each group of 3 characters is encoded as:
```
n = 32 + a + b * 32 + c * 32^2
```
where a, b and c are the indices of the characters in the above character set.
This leads to a Unicode code point in the range U+0020 to U+801F, ending somewhere in the "CJK Unified Ideographs".
```
let f =
_=>'L'+"⫒㠰拳␰䨒堵̎⨦W䙨ⅶ嵷˘㥆姳䗨⠬巯堡Ŋɩ懪䨶尩个˒≎㥎䜩怷㰷䤆ŵ̊㹩⫒ᨠᩌ㳠抮f̅㩊ᠰ䀩㩎搰㩊ئ抠ˮ婱拗⠩啺巨㬆ɒ㸘∦㰲䤆姵㩀Ƕ̘㨆㬴⠳⠺…䈲䥒䤠⫱᬴w㬣ᠶ⬘嗠⫘䥀噯䗠⫀⫓䕭啩̎Ɏ㹹庘⬆⭀巯奠Ŷ㷨䌯䥀噯⠪ⰸ㦸̆㼱ï哳峮૘梠䵨慷堵幎≠⣨峨愠◳ᬆ䐷ɒ䫓⥎ܑ拠̑Ɏ㼨ó㬴⹠⇫î奩拊̑㹰巯䓠ȮŎ廪ᨀ噧ਸ".replace(/./g,c=>(s=" ,.DEUabcdefghilmnopqrstuvx")[(c=c.charCodeAt()-32)&31]+s[c>>5&31]+s[c>>10])
console.log(f())
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 319 [bytes](http://www.cp1252.com/)
Uses CP-1252 encoding.
```
•9y†QHÚSe²ŒÓdéÓ#Ç§ÖN›Íˆž4GÏóREØån‡·JîÁØ£ÎÁ¥evÑRZ¶—¥1RËÒÆzçå"UNé¨v¯ÊcŒÔÝjðtrœÛeã&“SÁxÌ4Þá1N$ù?T(çÛbŸœfó˜lUž}Þß-©ÃMšBÈÑPàê#jÇÐ+n¼BDFý>–¸äFT×›qÜY³ö9ªòËùˆA‡¾p=‘¤ÚÞ{I¶Œ±Ål#¨5´Aq˜Àž,s<*Ï;‡õã¾»ðŽL´ÅuØö+Xi+S>»/8Kã~WÎ”ƒß”¤µðWluØa'cUÐeà¥ä…ž+œ6*0RU£›aÝQ_ñœoþÏð””Þã7ã¨sŒV`_É-´éÄèÆd¦úE5Í^Aá,‘‡™™¢äTHä0¥3±.}Søg•36B0„. :™J'yð:'z',:'.«
```
**Interpret the following string as a base 36 number and encode into base 214**
```
LOREMYIPSUMYDOLORYSITYAMETZYCONSECTETURYADIPISCINGYELITZYSEDYDOYEIUSMODYTEMPORYINCIDIDUNTYUTYLABOREYETYDOLOREYMAGNAYALIQUA0UTYENIMYADYMINIMYVENIAMZYQUISYNOSTRUDYEXERCITATIONYULLAMCOYLABORISYNISIYUTYALIQUIPYEXYEAYCOMMODOYCONSEQUAT0DUISYAUTEYIRUREYDOLORYINYREPREHENDERITYINYVOLUPTATEYVELITYESSEYCILLUMYDOLOREYEUYFUGIATYNULLAYPARIATUR0EXCEPTEURYSINTYOCCAECATYCUPIDATATYNONYPROIDENTZYSUNTYINYCULPAYQUIYOFFICIAYDESERUNTYMOLLITYANIMYIDYESTYLABORUM
```
**After that we**
```
36B                      # encode back into base 36
   0„. :                 # replace 0 with ". "
        ™J               # convert to titlecase and join
          'yð:           # replace "y" with <space>
              'z',:      # replace "z" with ","
                   '.«   # add a "." at the end
```
For some reason the encoding didn't work with a 0 at the end which is why need a special case for the final ".".
[Try it online!](http://05ab1e.tryitonline.net/#code=4oCiOXnigKBRSMOaU2XCssWSw5Nkw6nDkyPDh8Knw5ZO4oC6w43LhsW-NEfDj8OzUkXDmMOlbuKAocK3SsOuw4HDmMKjw47DgcKlZXbDkVJawrbigJTCpTFSw4vDksOGesOnw6UiVU7DqcKodsKvw4pjxZLDlMOdasOwdHLFk8ObZcOjJuKAnFPDgXjDjDTDnsOhMU4kw7k_VCjDp8ObYsW4xZNmw7PLnGxVxb59w57Dny3CqcODTcWhQsOIw5FQw6DDqiNqw4fDkCtuwrxCREbDvT7igJPCuMOkRlTDl-KAunHDnFnCs8O2OcKqw7LDi8O5y4ZB4oChwr5wPeKAmMKkw5rDnntJwrbFksKxw4VsI8KoNcK0QXHLnMOAxb4sczwqw4874oChw7XDo8K-wrvDsMW9TMK0w4V1w5jDtitYaStTPsK7LzhLw6N-V8OO4oCdxpLDn-KAncKkwrXDsFdsdcOYYSdjVcOQZcOgwqXDpOKApsW-K8WTNiowUlXCo-KAumHDnVFfw7HFk2_DvsOPw7DigJ3igJ3DnsOjN8OjwqhzxZJWYF_DiS3CtMOpw4TDqMOGZMKmw7pFNcONXkHDoSzigJjigKHihKLihKLCosOkVEjDpDDCpTPCsS59U8O4Z-KAojM2QjDigJ4uIDrihKJKJ3nDsDoneicsOicuwqs&input=)
[Answer]
# PHP ,247 Characters
combination of the 2 previous versions
```
echo gzuncompress(base64_decode(mb_convert_encoding("敊眱歍䙸兺䕉剆癚䅪礯極南慷潧楏㡷䥷汚䅯⽌䐸灐扫䱁獶猫扅煄橨啎硡灎䱈噑䔷⭂牓㥨䘴㡊䭪瀰獦夷灇漲氵剣杇楳婧啵扥卹摴慩䩢潪䡊圫啨㝩氷卧ぢご煏潪㙍䍮儷焲ㅅ扔⽘桭卥㉇别桃琫啺䍵公欹塊ㅔ煩噭灳氯䥥ぱ堷ぱ⭫橨祇啂灶㙣浵䅈湋䐷硴卑潘㙉砰捭塖橩汪祲昰䥪佄㔸晔慯眸䨲歮欰䱗䕲䑗⭫㡯䅷塏畃猵⭪慅兔佌流晥塹穄䩔扇婇䑍䩊硺䡅䵌⭤㝉䙇佡䙵浢㑩慖剺湱潊ぢ摰㝋卩楹婏㕵猷灴ぁ慫楗倹捙ㄲ⽁䍧塋啊","UTF-16")));
```
PHP, 261 Characters
```
echo mb_convert_encoding("䱯牥洠楰獵洠摯汯爠獩琠慭整Ⱐ捯湳散瑥瑵爠慤楰楳捩湧汩琬⁳敤漠敩畳浯搠瑥浰潲湣楤楤畮琠畴慢潲攠整潬潲攠浡杮愠慬楱畡⸠啴湩洠慤楮業⁶敮楡洬ⁱ畩猠湯獴牵搠數敲捩瑡瑩潮⁵汬慭捯慢潲楳楳椠畴汩煵楰砠敡潭浯摯潮獥煵慴⸠䑵楳畴攠楲畲攠摯汯爠楮⁲数牥桥湤敲楴渠癯汵灴慴攠癥汩琠敳獥楬汵洠摯汯牥甠晵杩慴畬污⁰慲楡瑵爮⁅硣数瑥畲⁳楮琠潣捡散慴異楤慴慴潮⁰牯楤敮琬⁳畮琠楮畬灡ⁱ畩晦楣楡敳敲畮琠浯汬楴湩洠楤獴慢潲畭.","UTF-16");
```
Encoding $s contains the string
```
foreach(str_split(bin2hex($s),4)as $c)eval('echo"\u{'.$c.'}";');
```
Old Version PHP , 386 Bytes|Characters
```
echo gzinflate(base64_decode("NZDBcUMxCERb2QI8v4rklmsKIIjvMCMJWQKPyw/KT25CwLL7PmxKg44VDcWqTSx1UBO/ga0vYRePCSo6dLH2O6RqNpeUXIBorGYFLm3ksnbWoiW6IxyVvlIe4pe0oNG9E6jqI+jAp0O6ttRG0/14ZknthkfoQrflMwrkJZPVydU6olZqbJfyHtKl+9KvpI4chlAab+nJrgB5yg+8bUkKF+iMdHJl1Y4pY8q39CIzg+fH02qMPCdpJ5NC1hKw1vpPKAMFzrgrOfo2hEEzi5gH3l8swyU2xmRgzCSccxxDC/neyBRjmhbpm+ImlUc56qCdG3aeykoosmTubrO6bdAGpIlj/XGNdvwA"));
```
[Answer]
# C#, ~~337~~ ~~333~~ 331 characters
```
_=>{var q="";foreach(var c in"潌敲彭灩畳彭潤潬彲楳彴浡瑥弬潣獮捥整畴彲摡灩獩楣杮敟楬ⱴ獟摥摟彯楥獵潭彤整灭牯楟据摩摩湵彴瑵江扡牯彥瑥摟汯牯彥慭湧彡污煩慵弮瑕敟楮彭摡浟湩浩癟湥慩Ɑ煟極彳潮瑳畲彤硥牥楣慴楴湯畟汬浡潣江扡牯獩湟獩彩瑵慟楬畱灩敟彸慥损浯潭潤损湯敳畱瑡弮畄獩慟瑵彥物牵彥潤潬彲湩牟灥敲敨摮牥瑩楟彮潶畬瑰瑡彥敶楬彴獥敳损汩畬彭潤潬敲敟彵畦楧瑡湟汵慬灟牡慩畴ⅲ䕟捸灥整牵獟湩彴捯慣捥瑡损灵摩瑡瑡湟湯灟潲摩湥ⱴ獟湵彴湩损汵慰煟極潟晦捩慩摟獥牥湵彴潭汬瑩慟楮彭摩敟瑳江扡牯浵ਡ")q=q+(char)(c&255)+(char)(c>>8);return q.Replace("!",".").Replace("_"," ");};
```
*-4 characters by replacing the `.`s after "pariatur" and "laborum" with `!` before combining the chars to wide chars and adding a trailing new line.*
*-2 characters by re-assigning the output var rather than appending with `+=`.*
How it works:
The lorem ipsum string was converted to that mess by replacing `.` with `!`,  with `_` so when the ascii chars are placed next to each other to make a wide char each wide char is a single character.
```
/*Func<object, string> Lorem = */ _=> // unused parameter
{
    // Output var
    var q = "";
    // Enumerate each wide char
    foreach (var c in "潌敲彭灩畳彭潤潬彲楳彴浡瑥弬潣獮捥整畴彲摡灩獩楣杮敟楬ⱴ獟摥摟彯楥獵潭彤整灭牯楟据摩摩湵彴瑵江扡牯彥瑥摟汯牯彥慭湧彡污煩慵弮瑕敟楮彭摡浟湩浩癟湥慩Ɑ煟極彳潮瑳畲彤硥牥楣慴楴湯畟汬浡潣江扡牯獩湟獩彩瑵慟楬畱灩敟彸慥损浯潭潤损湯敳畱瑡弮畄獩慟瑵彥物牵彥潤潬彲湩牟灥敲敨摮牥瑩楟彮潶畬瑰瑡彥敶楬彴獥敳损汩畬彭潤潬敲敟彵畦楧瑡湟汵慬灟牡慩畴ⅲ䕟捸灥整牵獟湩彴捯慣捥瑡损灵摩瑡瑡湟湯灟潲摩湥ⱴ獟湵彴湩损汵慰煟極潟晦捩慩摟獥牥湵彴潭汬瑩慟楮彭摩敟瑳江扡牯浵ਡ")
        // Split each wide char into two ascii chars
        q = q + (char)(c&255) + (char)(c>>8);
    // Restore the replaced periods and spaces
    return q.Replace("!",".").Replace("_"," ");
};
```
[Answer]
# ISOLADOS, 44016 bytes
<http://pastebin.com/raw/Y2aAhdpi>
Push the ASCII code for every character in the Lorem Ipsum string, concatenate everything, and output.
[Answer]
# [MATL](http://github.com/lmendo/MATL), 354 characters
```
'8 sxAI($ltZ>2<xa`vYf:s2e9]c&^KtD%e{C*XEpQ]]>dwmi>2;{sUCIZ{V(}Yj 7K&)|,%JD/Pz^:3$*@vVJw)4pgvz4s_$,%pVGu~|PS/Qr7pz5Z2[VV{Lyq}{l!yGiKNg.zFJxL75 sT1]eL2f3iVe~11!|6c+O9.kMWFQYvEp^w0p oH,?Ey"nbV>0g`#)kqTq""" z_AYmyJutvg:o9&AT{#(<42wu.b7" QoOn\#])]ISdH$yc{eM> .[~/`"#2:7C4Mk@eRW8L*_!xjo\cO)!LHK=g:P?&Uc];KdnE(%K7J-z9:7&rhxHl/KZ8\t_C|rT#%28[%+#u.?'F2Y2' ,.DEL'hZa
```
This decodes from base-94 (using the printable ASCII chars except single quote; so only Unicode characters up to 126 are used) to the alphabet of required characters, formed by most lowercase letters, some uppercase letters, space, comma, and period.
It takes a few seconds in the online compiler.
[Try it online!](http://matl.tryitonline.net/#code=JyU5PmQiX300c1BzZEIrZU1uI3F5bzElS1ExZDc3VkhGeTY0JEUoPXhOYiRXTHZvTWlcbnNyVHcjKyJrR0tkYE51XD1VZWlefXJaU3EiYS1LLnZ7T3YwNG84bTw5fD5wUiIzeHMsVFkldk5bYGAgSCh8IE8heFxlMFoydnMzYm86dSgwNmRrJiR6JSA_JCVVPW0sPTpXJWp8KEVAKCVhNk0qP30xU2pCMz1VYmZHLjQ0c2orLmcmbjYiSEg7RUcxZFI6d11pQ31WYEZAKnFwNnR3RVJgVyJ6al86LjMuTkxGLUVGSVBsUjxIcjBYZ2slV1tiTigqeyAkOT5OYCg4IztMeildK0ZNdkB1flIrQGlaN119SDVMOm1EOHBPWU4qYVIhZC41UVJ-OUhSIyJjLy8tfTs0e15ENTRiWXd-IWB1dHlNXWBNbCdGMlkyJ2prd3l6J1gtJyAsLkRFTFUnaFph&input=)
[Answer]
## JavaScript (ES5), 342 characters
```
c="remo ipsudlta,cngbq.UvxDhfE";"L"+"Qq©Úu[Qsx7Ķz`¾ƅ&Øxø§Ëƴ%ţ¾÷öm¿Zw¥ſøûƠtĭĚǎmĭöđnŔơxēǮŗĭ*x÷;ƚ:ȸƚņţǮ{XĩámɓŏƙâĚDUĚǎÁƚÂtĭŎÝ¦1mňŽ8ZUŽƜ-äļÝÁŌĪqu[Qqƙ¢3*ôĭ[ÞĵĪ%mÄſĘÚu[Q#èĭƝĘň®ŏØȅ˔Ż#ÂƠoƈŅƆĭƂ§ÿĵĭƘƙ¢VôƠţÅƠqƙƂĔňǮjʨſňô¾Ơn[ēĭœq÷\"ĭĚǎI".split('').map(function(x){y=x.charCodeAt(0);return c[~~(y/27)]+c[y%27]}).join('')
```
Pretty straightforward, so I'm sure there's room for improvement. I encoded every pair of output characters as a single Unicode character.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 279 bytes
```
«;Jq×L↑yVx₅QȯZ3ẎhȦ¼_ø€ẋ°Q±3₀₈∑hṁ₃ø∧≤∆⌐>ʀ↵₌X⇧ƒ₀₆ḃ₅Ḣ~^9\6↓¾<₆≈Q‡‟ṄBḞUß¼ƈv→⟇ʀ7ė⟑∞~*Ṅ∩ꜝtW₴h⟨p&¥z%₇Jɖ⁋¥(₂⌐⌊mṖ⅛ɾṙ3±żð→Ṙq↳'ḭguIH?TLŻrhNɾwl꘍×ByÞkĿMτI□ǑΠȧ½Ḃ≬jȦ₂ṡ⇧j…0Ȧ₂wyẆ₈≠₂d„⟨>∵↔C7⟇≠∑¤ƈƛiḃṁ₍Q]*꘍ṡḂcu%İ∑lL5∧∴!qÞLOτxÞ≥€ṅQh₅Ṫ°₄B*ṫṘ:NḊεβ⋏ṫẎFpƈc⁰ŀqẏy↓{'Ǒ£ẏŻ@kżoƛg)K1cV⌈»ΠC¼⟩F^ȯ₌«\z‛. V‛  ‛, V¡
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%AB%3BJq%C3%97L%E2%86%91yVx%E2%82%85Q%C8%AFZ3%E1%BA%8Eh%C8%A6%C2%BC_%C3%B8%E2%82%AC%E1%BA%8B%C2%B0Q%C2%B13%E2%82%80%E2%82%88%E2%88%91h%E1%B9%81%E2%82%83%C3%B8%E2%88%A7%E2%89%A4%E2%88%86%E2%8C%90%3E%CA%80%E2%86%B5%E2%82%8CX%E2%87%A7%C6%92%E2%82%80%E2%82%86%E1%B8%83%E2%82%85%E1%B8%A2%7E%5E9%5C6%E2%86%93%C2%BE%3C%E2%82%86%E2%89%88Q%E2%80%A1%E2%80%9F%E1%B9%84B%E1%B8%9EU%C3%9F%C2%BC%C6%88v%E2%86%92%E2%9F%87%CA%807%C4%97%E2%9F%91%E2%88%9E%7E*%E1%B9%84%E2%88%A9%EA%9C%9DtW%E2%82%B4h%E2%9F%A8p%26%C2%A5z%25%E2%82%87J%C9%96%E2%81%8B%C2%A5%28%E2%82%82%E2%8C%90%E2%8C%8Am%E1%B9%96%E2%85%9B%C9%BE%E1%B9%993%C2%B1%C5%BC%C3%B0%E2%86%92%E1%B9%98q%E2%86%B3%27%E1%B8%ADguIH%3FTL%C5%BBrhN%C9%BEwl%EA%98%8D%C3%97By%C3%9Ek%C4%BFM%CF%84I%E2%96%A1%C7%91%CE%A0%C8%A7%C2%BD%E1%B8%82%E2%89%ACj%C8%A6%E2%82%82%E1%B9%A1%E2%87%A7j%E2%80%A60%C8%A6%E2%82%82wy%E1%BA%86%E2%82%88%E2%89%A0%E2%82%82d%E2%80%9E%E2%9F%A8%3E%E2%88%B5%E2%86%94C7%E2%9F%87%E2%89%A0%E2%88%91%C2%A4%C6%88%C6%9Bi%E1%B8%83%E1%B9%81%E2%82%8DQ%5D*%EA%98%8D%E1%B9%A1%E1%B8%82cu%25%C4%B0%E2%88%91lL5%E2%88%A7%E2%88%B4!q%C3%9ELO%CF%84x%C3%9E%E2%89%A5%E2%82%AC%E1%B9%85Qh%E2%82%85%E1%B9%AA%C2%B0%E2%82%84B*%E1%B9%AB%E1%B9%98%3AN%E1%B8%8A%CE%B5%CE%B2%E2%8B%8F%E1%B9%AB%E1%BA%8EFp%C6%88c%E2%81%B0%C5%80q%E1%BA%8Fy%E2%86%93%7B%27%C7%91%C2%A3%E1%BA%8F%C5%BB%40k%C5%BCo%C6%9Bg%29K1cV%E2%8C%88%C2%BB%CE%A0C%C2%BC%E2%9F%A9F%5E%C8%AF%E2%82%8C%C2%AB%5Cz%E2%80%9B.%20V%E2%80%9B%20%20%E2%80%9B%2C%20V%C2%A1&inputs=&header=&footer=)
Uses Vyxal base-255 encoding, since it can only do lowercase and space, I convert ". " to z and "," to " ", so when I decompress I can easily add back in the punctuation. Finally, it reintroduces uppercase through the sentence-case operator.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 139 UTF-8 characters
```
"EDUL ,.".z@:^A*"𝜋򙇶󎹤񕙕󁌯󑃳񞢤񍚙񚝋󖼄𺧶񾔯򣒋򓽅𦕪𢪤񛽹򝕄󒹶򮂏򢗪񺭴󑍺𤣨򮅤񞢊򬪸񙉧񭃤𼧷󙳄𖢋򣹤𺢓񽇳𧅴񹹥𥽯󉊕󎬛񑅾񞄯󑽏򭂛򔣳񍒒𺊸񾒔񾗤󞢇򓻻񽢋󱅧𢚳򝕕𢚴󊻻𾣄𡽺񙇸󞅤񕙕󁇴𦅶󂷋򢥸񾢏򡎕򖻚𾥤󢹏󑅹󊲉񼩛򙅕򕜋𢽤񦶯𾢔󜩇𥣸񹽛󁢀󲕶󒽸𦗴󑊩񉵩𾢉󝧪𾣺𥊴𥬕񺥴󑒙󝍄񽂉󜫇𥽯𥖌񺗧𢥹񞍴󑉵򔧺𡺏򙇪𢼺𤣨򮍳"TB32FB:32
```
[Try it online!](https://tio.run/##LZG9bttAEIS7PEegMghc2J2rxEhSpUza9Olcp4plEgRJU4QonQTqh4COpBgxkoWYNKU76vhIwe7tAygXwNUWOxjMN3P7/fZ87n388PXz67cXvYsf766/vX/Tg@XC17HT0EBkyGJGdw97Gt5XmPAMg1mMs6VPk5MFsmiwG@91Gvl6pGxYsxJ4meFcCb1kFkWi0Y/9UPNpiXJX0zCQkKW/9KOdGS9Pb8sjxm6Bu/sMTsWB4sqCCfd1KjKQfITKqaCwaxQih1ztyfUYDbZzHNodJpbJpEK968/1OK0wiCKQ3hG7aIzdNKOEO3rUtqi4T3/sAvisMpmYuTV5bQtdav09CFgpibFzpMR@QXVqWNsN9Q@@5rmx46FeDZietDPo8oy4CGloC/KeXDxt5jq2mWYLH7jKcN3soeNjWmwcyNMjCjWnO/6TnlhDkTrCemoq8DboPm@MzqVlUZoYEnKvhnzLUObmH8W0DCxUfZcWv53/2JBPHlBODUIuMAmMxn3W40LCSoZmJlP56aXWoHrV@3Jzdfnp5vrq8nz@Bw "Pip – Try It Online")
### Explanation
Observe that there are 28 distinct characters in the string. We can use characters up to character code U+10FFFF = \$1,114,111\$, and since \$\sqrt[4]{1,114,111} \approx 32 > 28\$, we can pack four Lorem Ipsum characters into one Unicode character. (In theory, we might run into some forbidden characters within that range. In practice, that didn't happen.)
The decoder is a little longer than it should be because Pip's builtin base conversion generates strings (e.g. `"1RFP"`) rather than lists of numbers (e.g. `[1;27;15;25]`).
```
"EDUL ,.".z@:^A*"𝜋..."TB32FB:32
                "𝜋..."           String of 112 Unicode characters
              A*                 Codepoint of each
                      TB32       Convert each to a (4-digit) base 32 number
             ^                   Split each base 32 number into a list of its digits
                          FB:32  Convert each digit from base 32 to an integer
           @:                    Use those numbers to index into
"EDUL ,.".z                      Character lookup table: "EDUL ,." plus lowercase letters
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 126 characters
A large integer is encoded in base 1114111, which is converted to custom base `" .,a..z"` and the resulting string is converted to sentence case.
```
"૵򡏚򈣸󑰙𴿧𦛭񆛤𝌱񊷈􊢗􋄇򟰕򋴜𓏃򸵫򒕎𯑇񜥷𷇞󛷪􆥮񹳞򵪦󾔁𵇫񽅨功򜡸񄟎𗼵󾌢񂰹󌲏񱲼񺪓񑷯򈽧𘟅󬕲񦗷剗񁛍󛋢􎔊󼱃儮򹔊򤬲򈏉􏢮𝔐󪸉󘝙񍺻􀺿􏶺򑑩򤺶򈳚󸙆񆸏􃜘񁹂򚽊󊫸򺙵򔗲𖁙񕅱𨸞򢟊򏷔󐥓򈞰򺽆񲋧񯺼򭋕񺦶􈫭󤜘𵓈𽂿𷟮򢒽󾫺𢠑򓁌򾟍𞍿􍵻󮘻򸷒񳗩񫄪󈆁񐶢򺍮􀕛񑖑󆷰𣽖񚮾󌞴򃋏󽷤"ÇćβA… .,ìÅвJ‡.ª
```
[Try it online!](https://tio.run/##BcHLjppQGADgV2lm3cw7dNu36CRddNVFX0C8AIKICIiKwsh4mQFFRfEgiiS166aP0Ezitjn/f87eft/3H1@evn293x@4XpZ/oxQn@hDll4wZmwHdlws6d1cgulM6bm1BITJXAoerdQn9jY3qfkRNvcaexwlmaYRdu/3PG9K1IcFoRiiRPOaSkIuzGI47D9Nwzi6WQFMpgqLxelN8HE0yqPtt6pxTdmkFUN0cWSvRYZucIQ9NMMga5WJB@36DLe0E5g65NR0QXI25asDblsLO29qtHuPRUnC6TFDWm1wPYjq2OizMmqw/HoCWn3glL7l@yNEw3nCaH1DeDVk2EEHMdF4b9UE4VnFYKEyJMswHKVpOQnvCAOzGlr5mHga@gjqxWGdmouxtMC9ESNQFrPMzrlQb8vmBy9GKTUd9mpoyLaolJX6MQbdglyinwbOBptDCi69RTyu5lp5Y3D9hRrqwc94gqodMFgXoHALMtZhXbBeMnsFEsqEvRQ@G8YW1vD3WVJ0VZPpwlX5Jv5NP75X5h8eP1@W18Sf5/F6ZPP4M7/f/ "05AB1E – Try It Online")
Or, with byte scoring:
# [05AB1E](https://github.com/Adriandmen/05AB1E), 277 bytes
```
.•Jã‘éLõÝåʒ?ÿU
¤Ú¹αšt\Žαæ™4c\’ÑÑ[Ï!îèιáÜ¶§:ºÃbxxQΩù2ú²º„¶₄êy³Ôá‚ιüá‚ÖÆjηatÜÿ˜≠²Ÿ‹»BˆAÇλ—W?üÿ¾TP×¸Ë·]Δ…È¶ª¢X9âtç¨’ƶövY∞ʒE¯Š¿[¹|εÔgƵΣCõ÷yʒĆ7hZ`ĀÀAFнúO¡]îγÄ¬-Ðu†₂≠т,ÜÞör,™¨}м!s±ÑH—‘DθwO³¦&‚ÚøγF∊6∊7p×Ì"₄ôʒÛ₅,ÿÉ½OÏ¦Ã9-p¦»:nÒƶÙØ¶∊[₁?θsÑK„³½ζp÷‰oæB¤|λ·(θŒ¨”∍∊₄=Ýá¾ÉĆΓΓŒ*›αβ™•„wy„.,‡.ª
```
[Try it online!](https://tio.run/##HZFdTxNBFIbv/Rd4YYwpvTBGAglpQCVGTaqJxo9CIhjjx4U0tgpNMBmXWlvUYJdGoJamW3ApjUHbtbvblrLJebtclGQCf@H8kTrlYiZzcc6c53nPfGx27tXzfj/IonwL2yw2sHcHDWzhV08PwXtwjnaQp6as@UZ82u/IGkxOlq88m2axiSyyEawOYR8V2YSBAtm0O0YtLM8tLt6Te2heRovq1GJRJJu1JKoJspCDwSKvOg7OHviB1GvpzMZRgHdc4EyJ6r7LokntyePUBD7LNovcw5Aq9@jw/l2sk4sv5MzIHAsTaTW0SuVHoyjHsUsVBXZkw37/mNPFnn6D/vgl8iLUXJIN5F4cNeT2NSXoJHp6NzXy8snTroCYmDrpoBUmYwb70kKSfg/j@zsWJdY0xXOqBRRbEfbbgJKnyoeTg6EY1ZC9qcBUZteluxAmi8wLA508XGlNcXrlqjojUazj6/mB@7@ejp@sfQrAQ4Y6YaySieXR4SiZ1B57A11hb2JDBZVeibD2MSTdGLK3B9lZ1JF2FA6Lv/MwJ2lnSbbJuShdXx8Ib3H6m2pSQ8bV5gw6RKabkmtyzdcvsWjJmqwrbrVi9ddCQl3BAAsjSNV@/z8 "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 300 chars
```
“ḊḄr⁷ƤⱮx#y&Ọ¬½ẇṾƤẋRṠỊ/IṗIÞƝỊż,CA~ñ;ßɦ4ṿḷNVẸẆ`°ṄjJ⁽Ɱ!Æḋ"uƒ⁽ƙfƈÇœƓ®ḶẓƭƊȮ⁻w}Ġṙ(1€CÐ-ɼ#ȯjėȮoZœ°ȥạ_ẊƊaʠiẸṂṪẒ$ċⱮiẹOṠBṇḲ^*GƓŒA>żıWṭƤe&ėẠF6³ṂḲzlçÇṪġṂŻỵḢ⁴WJC⁽Ỵihıỵṃ¥ẏƬEỴ⁽#ḍʠḢ*^O[4)ỵZ5VoPĠƘṙḅß]<œ/ṅẸ% ḍ"Ɱ+¢¦ß÷⁵Ḍ³Ṅ¶2X|©dċÆṁḢƭṗM°`KÇ¦ɗỤɱṆȯƘkṅbṙ⁻l<t,ḟȮạżæ€ṠṣIȥCṘƥṁ©53ẒþØŻṁ£æƥ?¬ṿFæṘ⁴nụ’ṃ“Lrem ipsudlta,cngbq.UvxDhfEo
```
[Try it online!](https://tio.run/##FVJdTxNBFP0rSJUoVokIvkg0WMEUVIyJYDAiIEVaK1UEBaOGxdKaLUbTfWibqF2guwbSli4indktkMzsTrb8i7t/pN59vGfO3PMxE4vE4yutlrf6E4gMJLngSXVR8ozqcmClA6wNVmZHYKaBHosSmJmHQFWw5K4w0FyY/xa/cHAawVD/Z25c58Wm3gP0BEj9/iiYBMzUJKsBTcaGPOkId57hKSCZ9iWRxVkUZsVXnnYUobAqkEMwFVERslv1JOv9J1sFWjh/xVsrh/iPS81GwN2L2Tm3mhh3FFZzNTA3n4EpC3nqVI36WnQN6C6Y2bN2BpUQoiPo9RbQNJD9ic47QnGy/Techm2MAa2IUqTDzoGpDl5jf/27ZP9DnP/hGHTX3kTAscD6B2TLkw7GhkJoF6yD6Jxt@Cj9wlD/uygPIIhHASDfTlUkd06MPOm5gJTx3tHEA1sVeQwBZJ0Xn/Y5ShfQdXR6rg3p7ejxIttiOi/yuieh0obvI8kOux9/ZDszdgarohLuFBWs@h6rTQ7zNNObObBKTQNoyt0T@Ze4cRolsLF432IQSNGtYjFOg@tYnP9UdDvsaiGgeaHhOrbTexUr4sc8j/lw3ua60G4ypJ4Mch1pGHceLM1bLWBK/BR3FyKv2qKv3y7NxBengs/nX0y/ufzo3fLtudmBRKv1Hw "Jelly – Try It Online")
The encoding is [Jelly](//github.com/DennisMitchell/jelly/wiki/Code-page).
Thanks to compressed strings, I was able to compress it by 3 bytes.
[Answer]
# Deadfish~, 3209 bytes
```
{{i}ddd}iiiiiic{iii}iiiiiciiic{d}dddc{i}ddc{{d}ii}iiic{{i}ddd}iiic{i}dddciiiciic{d}iic{{d}ii}iiic{{i}ddd}ddc{i}icdddciiiciiic{{d}ii}ddc{{i}dd}iiic{d}c{i}ic{{d}ii}ddddc{iiiiii}iiiiic{i}iic{d}iic{i}iiiiic{{d}iii}ddc{d}ddc{{i}ddd}dddc{i}iicdciiiiic{d}ddddcddc{ii}dddc{d}dddddc{i}iiiiicicdddc{{d}ii}ddc{iiiiii}iiiiiciiiciiiiic{i}dddc{d}iiic{i}c{d}ddddddciiiiiiciiiiic{d}iiic{{d}iii}dc{{i}ddd}dc{i}dddcdddc{i}ic{{d}iii}ddc{d}ddc{{i}dd}iiic{d}ddddcdc{{d}iii}iic{{i}ddd}ddc{i}ic{{d}ii}ic{{i}ddd}dciiiic{i}iicddcddddddciic{d}dc{{d}iii}iic{{i}dd}iiiic{d}dddddc{i}ddciiicdciiic{{d}ii}ddc{{i}ddd}iiiciiiiic{d}dciiiiiicdddddciiiiicdddddc{ii}dddc{d}iiiciiiiiic{{d}ii}ddddc{{i}dd}iiiiicdc{{d}ii}ddddc{{i}ddd}iiiiiic{d}dcic{i}iiiciiic{d}dddc{{d}iii}ic{{i}ddd}dc{i}iiiiic{{d}ii}ddddc{{i}ddd}ddc{i}icdddciiiciiic{d}dddc{{d}iii}ic{{i}dd}dddc{d}ddciiiiiic{i}dddc{d}dddc{dddddd}dddddc{iiiiii}iiiiic{i}icdddc{i}ddciiiic{dd}c{ddddd}dc{d}ddddc{iiiii}iiic{iii}ic{{d}ii}ddddc{{i}ddd}dc{i}dcdddddciiiic{{d}ii}iiic{iiiiii}iiiiiciiic{{d}iii}iic{{i}dd}dddcddddciiiiicdddddciiiic{{d}ii}iiic{{i}dd}iiiiiic{dd}iiic{i}dcdddddc{d}iic{i}iic{dddddd}dddddc{d}ddc{{i}dd}iciiiic{d}ddc{i}c{{d}ii}dddc{{i}dd}ddciciiiicicddciiic{dd}iiic{{d}iii}iic{{i}ddd}dc{ii}dc{dd}ic{i}iiic{d}dddddciiiiiic{i}ic{dd}ic{ii}dc{d}dciiiiiicdc{{d}ii}iic{{i}dd}iiiiic{d}icc{d}dc{i}iic{d}c{i}iic{{d}ii}ic{{i}ddd}iiiiiic{d}dcic{i}iiiciiic{d}ic{i}c{{d}ii}dddc{{i}dd}ddcdddddc{i}c{d}c{{d}iii}dddc{{i}dd}iiiiicdc{{d}ii}ddddc{iiiiii}iiiiic{i}icdddc{i}ddciiiic{d}ddc{i}dddc{{d}ii}c{{i}ddd}dc{ii}dc{{d}i}iic{{i}ddd}dcddddc{dddddd}dddddc{{i}ddd}dddc{i}iicddcciic{d}dc{i}ic{{d}ii}ic{{i}ddd}dddc{i}iicdciiiiic{d}ddddc{i}iiciiiic{dd}c{ii}dc{{d}iii}c{d}ddddc{iii}iiiiiic{iiiii}dc{d}ddc{i}c{{d}ii}dddc{iiiiii}iiiiic{ii}cdc{d}dddddc{{d}iii}ic{{i}ddd}iiic{i}dciiicdddc{d}dddc{{d}iii}ic{{i}ddd}ddc{i}icdddciiiciiic{{d}ii}ddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iic{d}dddc{i}iciic{d}dddciiicdddc{i}dc{d}cic{i}iiic{d}ic{i}ic{{d}ii}ddddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iiiiiic{d}iiicdddc{i}dcdddddciiiic{dd}ic{ii}dc{d}dddddc{{d}iii}ic{{i}dd}iiiiiic{dd}iiic{i}dddcdddc{i}ic{{d}ii}ddddc{{i}ddd}dc{i}iiiicc{d}ddddc{{d}iii}ic{{i}ddd}dddciiiiiiciiicc{i}dc{d}iic{{d}ii}iiic{{i}ddd}ddc{i}icdddciiiciiic{d}dddc{{d}iii}ic{{i}ddd}dc{i}iiiiiic{{d}ii}dddddc{{i}ddd}c{i}iiiiic{d}ddddciic{d}iic{ii}dc{{d}ii}ddddc{{i}dd}ddc{i}dddc{d}icc{d}dc{dddddd}dddddc{{i}dd}c{d}dddddc{ii}dddc{d}ic{d}iic{ii}dcicdddc{{d}iii}iic{d}ddddc{iiii}dddc{iiiii}ic{dd}dciic{i}iciiiic{d}dddddc{i}iiiiiicdddc{{d}ii}ddc{{i}dd}iiic{d}ciiiiiciiiiiic{{d}ii}ddddc{{i}dd}dc{d}ddccddciiiicddcddc{ii}dc{{d}ii}ddddc{{i}ddd}dddc{ii}ddcdddddc{d}iiicdddddcdddc{ii}dc{dd}ic{ii}dc{{d}ii}ddddc{{i}dd}ddcicdc{{d}ii}iic{{i}dd}ciicdddcddddddcdddddcic{i}dciiiiiic{{d}iii}ddc{d}ddc{{i}dd}iiiciic{d}iiiciiiiiic{{d}ii}ddddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}ddd}dddc{ii}ddc{d}iciiiic{d}dddddc{dddddd}dddddc{{i}dd}iciiiic{d}ddc{{d}iii}dddc{{i}dd}dc{d}icciiicddddddciiiiiic{d}iic{dddddd}dddddc{{i}ddd}ddcic{i}iiiic{d}ddddc{i}iiiciiic{d}iiiciiiiiic{{d}ii}ddddc{{i}dd}dddciicdddccdddc{i}ic{{d}ii}ddddc{iiiiii}iiiiic{i}iiicdddddciiiic{{d}ii}iiic{{i}ddd}iiicdddddc{{d}iii}iic{{i}ddd}dc{i}iiiicic{{d}ii}ddddc{{i}ddd}iiiiiic{d}dcic{i}iiiciiiciiic{d}iic{dddddd}dddc
```
[Try it online!](https://deadfish.surge.sh/#LGvd9WS0pbqf/4v3/5+KdQt0JT9/iW6n+LdR+eKfiU/f4lup0LeVH5+JT90Jbp/imLeJT91Qv/3/4t+Kfi3/4lP90KdCW6nULfkf+KdUUL3UKdVC3/5lQlP3Qv/3/5+f+LdQp/i2KdVR/+f+Kf4lP9wlupwt1FQt4lP90KdCW6f4p1RCU/34lup0LeJT94lupx/i35RVUeKcJT/fiW6f+KdVC3R+R+JT90Jbqf5/4px/+VUf+VUL3UKf5/+JT91Qlun/5CU/dUJbqf/4pxi3+finUJT/eJbqcLf/iU/dUJbqdC3lR+finUJT/eJbp1CnR/+LdQp1CqqdVC//f/i3lQt0f4qYqqcKdUL/3+L94lP3VCW6nC3FVH+JT9/i//f/n4lP9+Jbp1FUf+VUf4lP3+Jbp//ip/i3FVCn4t+Kqp1UKdCW6ef4p0LYlP3UJbp0Z/mUfip/iU/34lupwvcKni3+KdVH/4t4qeL3CnH/5CU/fiW6f/ingpwt+KYt+JT94lup//inGLf5+KeLYlP3UJbp0VULYpiU/3UJbp/+QlP3VC//f/i3lQt0f4p0LdQlP2JbqcL3CU9+JbqcVQqqnVQlup1C35QeKcLeJT94lup1C35H/inVC35/ipi9wlP9inVC/f/4v/cKdC2JT91C//f/i9kKdVCU/3iW6n+LcflQp1CU/3iW6nQt5Ufn4lP3Qlup/n/iU/fiW6finULeeKdR+VC3CmYt/ini3iU/dUJbqf5/4lP34lun/+Kf5ULcVUf4qeL3CnVQlP94lun/+Kn+LdRULeJT91Qlupwt/4KdUJT/eJbqdR/+fgtwp+JT9/iW6nQt5Ufn4p1CU/3iW6nC3/+JT91UJbqYt/+KdUeKfi9wlP3VCW6dC3UKeCnCqqdVCW6Yp1UL3UKeKfi9xlQlP9+KdUL/dQv/eKnHi3n+KdVC3/+VCU/dCW6f4pn/n/4lP3VCW6cKdBR/lFC9wlP3VCW6nUL3RVQp/lVFQvcKni9wlP3VCW6dGQlP34lumeVFVRVRi3H/4lP90KdCW6f54p/n/4lP3VCW6n+f+JT9+JbqdQvdCnn+KdVCqqdVCW6ef4p0JT/dQlunCnh+VVH/4p+Kqp1UJbqdGLf+KdULf5+Kf5/+JT91QlunUeVBULeJT91Qv/3/4t/lVH+JT9/iW6n+VUJT/fiW6nC3/mJT91Qlup//inGLf5+fin4qqnUA)
Who cares about all that compression nonsense...
[Answer]
# Deadfish~, 3061 characters
```
{i}dsdddddc{{iii}d}iciiic{d}dddc{i}ddc{{ii}dd}dc{{i}ddd}iiic{i}dddciiiciic{d}iic{{ii}dd}dc{dd}ddsc{i}icdddciiiciiic{{d}ii}ddc{{i}dd}iiic{d}c{i}ic{{ii}ddd}iic{{iii}ii}ic{i}iic{d}iic{i}iiiiic{{d}iii}ddc{d}ddc{dd}ddsdc{i}iicdciiiiic{d}ddddcddc{ii}dddc{d}dddddc{i}iiiiicicdddc{{d}ii}ddc{{iii}ii}iciiiciiiiic{i}dddc{d}iiic{i}c{dd}iiiiciiiiiiciiiiic{d}iiic{{d}iii}dc{dd}ddsic{i}dddcdddc{i}ic{{d}iii}ddc{d}ddc{{i}dd}iiic{d}ddddcdc{{ii}d}ddc{dd}ddsc{i}ic{{d}ii}ic{dd}ddsiciiiic{i}iicddcddddddciic{d}dc{{ii}d}ddc{{i}dd}iiiic{d}dddddc{i}ddciiicdciiic{{d}ii}ddc{{i}ddd}iiiciiiiic{d}dciiiiiicdddddciiiiicdddddc{ii}dddc{d}iiiciiiiiic{{ii}ddd}iic{dd}dsddddcdc{{ii}ddd}iic{{i}dd}ddddc{d}dcic{i}iiiciiic{d}dddc{{d}iii}ic{dd}ddsic{i}iiiiic{{ii}ddd}iic{dd}ddsc{i}icdddciiiciiic{d}dddc{{d}iii}ic{{i}dd}dddc{d}ddciiiiiic{i}dddc{d}dddc{{ii}d}ic{{iii}ii}ic{i}icdddc{i}ddciiiic{dd}c{ddddd}dc{d}ddddc{{iii}i}dc{iii}ic{{ii}ddd}iic{dd}ddsic{i}dcdddddciiiic{{ii}dd}dc{{iii}ii}iciiic{{ii}d}ddc{{i}dd}dddcddddciiiiicdddddciiiic{{ii}dd}dc{dd}dsdddc{dd}iiic{i}dcdddddc{d}iic{i}iic{{ii}d}ic{d}ddc{{i}dd}iciiiic{d}ddc{i}c{{d}ii}dddc{{i}dd}ddciciiiicicddciiic{dd}iiic{{ii}d}ddc{dd}ddsic{ii}dc{dd}ic{i}iiic{d}dddddciiiiiic{i}ic{dd}ic{ii}dc{d}dciiiiiicdc{{d}ii}iic{dd}dsddddc{d}icc{d}dc{i}iic{d}c{i}iic{{d}ii}ic{{i}dd}ddddc{d}dcic{i}iiiciiic{d}ic{i}c{{d}ii}dddc{{i}dd}ddcdddddc{i}c{d}c{{ii}dd}iiic{dd}dsddddcdc{{ii}ddd}iic{{iii}ii}ic{i}icdddc{i}ddciiiic{d}ddc{i}dddc{{d}ii}c{dd}ddsic{ii}dc{{d}i}iic{dd}ddsicddddc{{ii}d}ic{dd}ddsdc{i}iicddcciic{d}dc{i}ic{{d}ii}ic{dd}ddsdc{i}iicdciiiiic{d}ddddc{i}iiciiiic{dd}c{ii}dc{{d}iii}c{d}ddddc{{iii}d}iic{iiiii}dc{d}ddc{i}c{{d}ii}dddc{{iii}ii}ic{ii}cdc{d}dddddc{{d}iii}ic{{i}ddd}iiic{i}dciiicdddc{d}dddc{{d}iii}ic{dd}ddsc{i}icdddciiiciiic{{d}ii}ddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iic{d}dddc{i}iciic{d}dddciiicdddc{i}dc{d}cic{i}iiic{d}ic{i}ic{{ii}ddd}iic{{i}ddd}iiiciiiiic{{d}ii}iic{dd}dsdddc{d}iiicdddc{i}dcdddddciiiic{dd}ic{ii}dc{d}dddddc{{d}iii}ic{dd}dsdddc{dd}iiic{i}dddcdddc{i}ic{{ii}ddd}iic{dd}ddsic{i}iiiicc{d}ddddc{{d}iii}ic{dd}ddsdciiiiiiciiicc{i}dc{d}iic{{ii}dd}dc{dd}ddsc{i}icdddciiiciiic{d}dddc{{d}iii}ic{dd}ddsic{ii}ddddc{{ii}ddd}ddc{{i}ddd}c{i}iiiiic{d}ddddciic{d}iic{ii}dc{{ii}ddd}iic{{i}dd}ddc{i}dddc{d}icc{d}dc{{ii}d}ic{{i}dd}c{d}dddddc{ii}dddc{d}ic{d}iic{ii}dcicdddc{{ii}d}ddc{d}ddddc{iiii}dddc{iiiii}ic{dd}dciic{i}iciiiic{d}dddddc{ii}ddddcdddc{{d}ii}ddc{{i}dd}iiic{d}ciiiiiciiiiiic{{ii}ddd}iic{{i}dd}dc{d}ddccddciiiicddcddc{ii}dc{{ii}ddd}iic{dd}ddsdc{ii}ddcdddddc{d}iiicdddddcdddc{ii}dc{dd}ic{ii}dc{{ii}ddd}iic{{i}dd}ddcicdc{{d}ii}iic{{i}dd}ciicdddcddddddcdddddcic{i}dciiiiiic{{d}iii}ddc{d}ddc{{i}dd}iiiciic{d}iiiciiiiiic{{ii}ddd}iic{{i}ddd}iiiciiiiic{{d}ii}iic{dd}ddsdc{ii}ddc{d}iciiiic{d}dddddc{{ii}d}ic{{i}dd}iciiiic{d}ddc{{ii}dd}iiic{{i}dd}dc{d}icciiicddddddciiiiiic{d}iic{{ii}d}ic{dd}ddscic{i}iiiic{d}ddddc{i}iiiciiic{d}iiiciiiiiic{{ii}ddd}iic{{i}dd}dddciicdddccdddc{i}ic{{ii}ddd}iic{{iii}ii}ic{i}iiicdddddciiiic{{ii}dd}dc{{i}ddd}iiicdddddc{{ii}d}ddc{dd}ddsic{i}iiiicic{{ii}ddd}iic{{i}dd}ddddc{d}dcic{i}iiiciiiciiic{d}iic{{ii}d}iiic
```
The code is too long for the recursive Python [implementation on tio.run](https://tio.run/#deadfish-). So here is another link which works (I took it from [this other answer](https://codegolf.stackexchange.com/a/226172/25315)).
[Try it online](https://deadfish.surge.sh/#LGvq53tZLS+pqqHf9Sz8eVQ+qHf1Sh31Uvx9VH548vHf1Sh6VMPrKj8/HeXqh31S/HkPrHf1UvHf9esfXjy8fX/jvL9UPKh6VND68j/x5VRQ/qoeVVD6/8yod5eqHf9es/P/H1UPL8fQ9L/P/z/x5fjvL9Q9Kmx9VFQ+sd5fqh5UO+qX48qoh39SoelTD6x3l6x6VNn+Pryiqo8eUO/qVDvql/jyqofVH5H47y9UO+ql+f+PKP/yqj/yqh/VQ8vz/8d/VS8elNVEO/qpeO+qVUPKMfX5+PKod5frHpU2Pr/x39VLx6VMPrKj8/HlUO8v1jvqlUPKj/8fVQ8qh39Sx3/XrH1lQ+qP8ekPVSh5VQ7/rUP+sd/VS8elTY+oqo/x39Uod/16z8d/UqHfVKoqj/yqj/Hf1Sh6U1Q9L8fUVUPLx9eO/qWPKh31Sz/HlQ+h3l6qHfVKjP8yj8el+O/qVD0qbH9Q9LH1+PKqj/8fWPSx/UPKP/yHeXrx6U1UPLB5Q+vHkPrx3l6x31Sqh5Rj6/Px5Y+h3l6qHfVKiqh9DyHf1S/HpTVRDv6qXjv+vWPrKh9Uf48qH1UO8vQ9Kmx/UO8tePSpsqh39Sx6VND68oPHlD6x3l6x6VND68j/x5VQ+vP8ekP6h3l+h5VQ7/qXj/+oeVD6HeXqod/16x/RDyqod5frHfVS/H1H5UPKod5frHpUw+sqPz8d5eqHfVS/P/HeXrx31S8eVQ+s8eVR+VD6h5GPr8eWPrHf1UvHfVS/P/HeXrx6U1Q8vyofUVUf49LH9Q8qqHeX6x6U1Q9L8fVRUPrHf1UvHpU2Pr/B5VQ7y/WPSpo//PwfUPLx39UoelTD6yo/Px5VDvL9Y9Kmx/VUO/qpUO+qkPr/x5VR48vH9Q7+ql476pUPqoeWDyh39Sx31SHlVQ/qoeWPLx/UZUO/qVDyqh/9VD/+selHj6z/HlVQ/qqKh3l6od9Uvx5H/n/47+ql476pQ8qCj/KKH9Q7+ql49Kmh/VFVDy/KqKh/UPSx/UO/qpeO+qVGQ7y9eO+qR5UVVFVGPqP/x3l+qHlQ76pfnjy/P/x39VLx31Uvz/x3l68elTQ/qh5Z/jyqod/Usd9Us/x5UO/ql+O+qUPLD8qqP/x5eO/qWPSpjH1/jyqh9fn48vz/8d/VS8d9UqjyoKh9Y7+ql47/r1j6/KqP8d/VKHfVS/KqHf1Kh6VNj6/zHf1UvHfVKqHlGPr8/Px5eO/qX4A=)
Not sure it's optimal, but should be pretty close. It uses the `s` command. It also takes advantage of the overflow feature when it's useful - when the accumulator is equal to 256, it wraps around to 0.
]


[Question]
      [
# Description
Subtract the next P numbers from a N number. The next number of N is N + 1.
Look at the examples to get what I mean.
# Examples:
```
Input: N=2,P=3
Calculate: n - (n+1) - (n+2) - (n+3)     //Ending with 3, because P=3
Calculate: 2 -  2+1  -  2+2  - 2+3       //Replacing N with 2 from Input
Calculate: 2 -  3    -  4    - 5
Output: -10
Input: N=100,P=5
Calculate: n - (n+1) - (n+2) - (n+3) - (n+4) - (n+5)
Calculate: 100-  101 -  102  -  103  -  104  - 105
Output: -415
Input: N=42,P=0
Calculate: n
Calculate: 42
Output: 42
Input: N=0,P=3
Calculate: n - (n+1) - (n+2) - (n+3)
Calculate: 0 -  1    -  2    -  3
Output: -6
Input: N=0,P=0
Calulate: n
Calculate: 0
Output: 0
```
# Input:
**N**: Integer, positive, negative or 0
**P**: Integer, positive or 0, not negative
# Output:
Integer or String, leading 0 allowed, trailing newline allowed
# Rules:
* No loopholes
* This is code-golf, so shortest code in bytes wins
* Input and Output must be as described

[Answer]
# C89, ~~38~~, ~~35~~, 33 bytes
```
h(n,p,r)int*r;{*r=n-p++*(n+p/2);}
```
Test it on [Coliru](http://coliru.stacked-crooked.com/a/d79b4c81eab66666).
[Answer]
# Maple, 19 bytes
```
n-sum(i,i=n+1..n+p)
```
Usage:
```
> f:=(n,p)->n-sum(i,i=n+1..n+p);
> f(2, 3);
  -10
> f(100,5);
  -415
> f(42,0);
  42
```
[Answer]
# [Perl 6](http://perl6.org), 21 bytes
```
{$^n-[+] $n^..$n+$^p}
```
## Explanation:
```
# bare block lambda with two placeholder parameters ｢$n｣ and ｢$p｣
{
  $^n -
      # reduce using ｢&infix:<+>｣
      [+]
          # a Range that excludes ｢$n｣ and has ｢$p｣ values after it
          $n ^.. ($n + $^p)
}
```
[Answer]
# Java 8, 25 bytes
```
(n,p)->n-(p*n+p*(p+1)/2);
```
# Ungolfed test program
```
public static void main(String[] args) {
    BiFunction<Integer, Integer, Integer> f = (n, p) -> n - (p * n + p * (p + 1) / 2);
    System.out.println(f.apply(100, 5));
}
```
[Answer]
# Scala, 41 bytes
```
def?(n:Int,p:Int)=n-(1 to p).map{n+_}.sum
```
Testing code:
```
println(?(2,3))
println(?(100,5))
println(?(42,0))
println(?(0,3))
println(?(0,0))
// Output
-10
-415
42
-6
0
```
[Answer]
# Clojure/Clojurescript, 30 bytes
```
#(reduce -(range %(+ 1 % %2)))
```
The straightforward approach is shorter than the mathematically clever ones.
[Answer]
# [Julia](http://julialang.org): 17-18 bytes (13 as program with terminal inputs)
As per suggestion in comments that "function or program" form is needed:
* as function: 17 characters, 18 bytes if you count ∘ as multibyte
```
n∘r=2n-sum(n:n+r)
```
usage: `5∘3` outputs `-16`
* as program, passed initial parameters from terminal: 13 bytes:
```
2n-sum(n:n+r)
```
usage: `julia -E 'n,r=5,3;include("codegolf.jl")'`
[Answer]
# Excel, 20 bytes
Subtract the next `B1` integers from `A1`:
```
=A1-B1*(A1+(B1+1)/2)
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 11 bytes
Formula stolen elsewhere...
```
~1$1$)2/+*-
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v85QxVBF00hfW0v3/39DAwMFUwA "GolfScript – Try It Online")
## Explanation
This just boils down to
```
A-B*(A+(B+1)/2)
```
Converted to postfix.
# [GolfScript](http://www.golfscript.com/golfscript/), 15 bytes
```
~),{1$+}%{-}*\;
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v05Tp9pQRbtWtVq3VivG@v9/QwMDBVMA "GolfScript – Try It Online")
## Explanation
```
~               # Evaluate the input
 ),             # Generate inclusive range
   {1$+}%       # Add each item by the other input
         {-}*   # Reduce by difference
             \; # Discard the extra other input
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-hr`, ~~8~~ 6 bytes
```
+ɧ^∑$-
```
[Try it online!](https://tio.run/##y05N//9f@9D@k8vjHnVMVNH9/9/QwIDLlAtI/tfNKAIA "Keg – Try It Online")
No formula, just a for loop!
[Answer]
## [W](https://github.com/a-ee/w) `d`, ~~6~~ 4 bytes
Surprised to see that it's not short at all. (Although it at least ties with Jelly...)
```
7▄i←
```
## Explanation
Uncompressed:
```
+.@-R
+     % Generate b+a
 .    % Generate range(a,b+a)
  @-R % Reduce via subtraction
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ôV r-
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=9FYgci0&input=MiAz)
```
ôV r-     :Implicit input of integers U=N & V=P
ôV        :Range [U,U+V]
   r-     :Reduce by subtraction
```
[Answer]
# [Demsos](https://desmos.com), 20 bytes
```
f(n,p)=n-p(p/2+.5+n)
```
Other 20-byters:
```
f(n,p)=n-pn-p(p+1)/2
f(n,p)=n-pp/2-.5p-np
f(n,p)=n-.5p(2n+p+1)
f(n,p)=n-pn-.5pp-.5p
```
[Try it on Desmos!](https://www.desmos.com/calculator/ok09b870nw)
With the sum function, it's 27 bytes:
```
f(n,p)=n-∑_{x=n+1}^{n+p}x
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 10 bytes
```
{-/x+!y+1}
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLs6rW1a/QVqzUNqzl4kqLNrI2jgVShgYG1qYghomRtQGINoCIGwB5AFkZDQs=)
Quick.
[Answer]
# [Python 3](https://en.wikipedia.org/wiki/Python_(programming_language)), 43 bytes
```
lambda n,p:n-sum([n+i+1 for i in range(p)])
```
[Try it online!](https://tio.run/##LY3BCoMwEETP9iv2uIsR1tpCya@EHFLaaqCuS9RDvz51wdubGXijv21aZHhoqZ@lgDhQyAIhXB0M0UHomR3cjW5HxQZ8Tmw5@kujJcuGWL9pfr7SIVEv3brPGKTNbQ9mzqYtScY3KkWqhPZFVP8 "Python 3.8 (pre-release) – Try It Online")
Explanation:
```
lambda n,p:                                  # Lambda header
                 [n+i+1 for i in range(p)]   # Next P numbers
             sum(                          ) # Sum each number
           n-                                # Subtract from N for final result
```
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 14 bytes
```
n0ns-0Rl0I*-&+
```
[Try it online!](https://tio.run/##y6n8/z/PIK9Y1yAox8BTS1dN@/9/QwMDLlMA "Ly – Try It Online")
This relies on the fact that for X=starting number and Y=iterator, the answer is:
`X - (X*Y) - sum([1..Y])`
It uses the `R` command to generate the range of negative numbers.
```
n              - read starting number onto the stack
 0n            - push "0", read iteration count onto the stack
   s           - save iteration count
    -          - convert to negative number
     0         - push "0" to set ending number
      R        - generate a range of negative numbers
       l       - load the iterator count
        0I     - copy the starting number
          *    - multiple to get base number common to all decrements
           -   - convert to negative (relies on "0" from range)
            &+ - sum the stack, answer prints automatically
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 bytes
```
⊣-(+/(⍳⊢)+⊣)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHXYt1NbT1NR71bn7UtUhTG8jX/P@obypQytDAQCFNwZQLwjMCso25/gMA "APL (Dyalog Unicode) – Try It Online")
]


[Question]
      []