text:
The von Koch conjecture
You may know the mathematician von Koch by his famous snowflake. However he has more interesting computer science problems up his sleeves.
Indeed, let's take a look at this conjecture:
Given a tree with n nodes (thus n-1 edges). Find a way to enumerate the nodes from 1 to n and, accordingly, the edges from 1 to n-1 in such a way, that for each edge k the difference of its node numbers equals to k. The conjecture is that this is always possible.
Here's an example to make it perfectly clear :

YOUR TASK
Your code will take as input a tree, you can take the format you want but for the test cases I will provide the tree by their arcs and the list of their nodes.
For example this is the input for the tree in the picture :
[a,b,c,d,e,f,g]
d -> a
a -> b
a -> g
b -> c
b -> e
e -> f

Your code must return the tree with nodes and edges numbered.
You can return a more graphical output but I will provide this kind of output for the test cases :
[a7,b3,c6,d1,e5,f4,g2]
d -> a 6
a -> b 4
a -> g 5
b -> c 3
b -> e 2
e -> f 1

TEST CASES
[a,b,c,d,e,f,g]             [a7,b3,c6,d1,e5,f4,g2]
d -> a                      d -> a 6
a -> b                      a -> b 4
a -> g             =>       a -> g 5
b -> c                      b -> c 3
b -> e                      b -> e 2
e -> f                      e -> f 1

[a,b,c,d]                   [a4,b1,c3,d2]
a -> b                      a -> b 3
b -> c            =>        b -> c 2
b -> d                      b -> d 1

[a,b,c,d,e]                [a2,b3,c1,d4,e5]
a -> b                      a -> b 1
b -> c                      b -> c 2
c -> d             =>       c -> d 3
c -> e                      c -> e 4

This is code-golf this the shortest answer in bytes win!
Note : This is stronger than the Ringel-Kotzig conjecture, which states every tree has a graceful labeling. Since in the Koch conjecture it is not possible to skip integers for the labeling contrary to the graceful labeling in the Ringel-Kotzig conjecture.  Graceful labeling has been asked before here.

Will there be more than 26 nodes?

@LeakyNun It is already hard to brute force after 17 nodes ^^

@WheatWizard It's absolutely not the same as the von Koch conjecture since in this thread you're allowed to skip integers. The whole point of the conjecture is making the labeling possible without skipping

Jelly, 30 bytes
JŒ!³,$€
Çµy⁴VIAµ€Q⁼$€TðḢịø³JŒ!

Try it online! (Use GṄ³çG as footer to make output prettier. )
Inputs similar to example, e.g. abcdef and [d,a],[a,b],[a,g],[b,c],[b,e],[e,f]
Outputs the list e.g. a,b,c,d,e,f in order.
Note: My program produces different values than the test cases as there are several possibilities which are all valid.
Explanation
JŒ!³,$€                - helper function, generates all possible numberings, input is e.g. 'abcd'
J                      - range(len(input)). e.g. [1,2,3,4]
 Œ!                    - all permutations of the range.
   ³,$                 - pair the input with ...
      €                - each permutation. Sample element e.g. ['abcd',[3,1,2,4]]

Çµy⁴VIAµ€Q⁼$€TðḢịø³JŒ! - main dyadic link, input is e.g. 'abcd' and '[a,b],[b,c],[b,d]'
 µy                    - use a numbering as an element-wise mapping e.g. 'abcd'->[3,1,2,4]
   ⁴                   - apply this to the list of edges. e.g. '[3,1],[1,2],[1,4]'
    V                  - turn this into an internal list.
     IAµ€              - find absolute difference on each edge
         Q⁼            - Is this invariant under deduplication? Returns 1 if the numbering is valid; 0 otherwise.
Ç          $€          - apply this to all possible numberings
             Tð        - return the indices of all valid numberings
               Ḣ       - choose the first one and
                ị      - get the element corresponding to its index in
                 ø³JŒ! - all possible numberings

Save 1 byte by showing all possible solutions:
JŒ!³,$€
Çµy⁴VIAµ€Q⁼$€Tðịø³JŒ!

Try it online! (Use GṄ³çG⁷³G as a footer to make output prettier)
Use converter to copy-paste test case into an input list.

Ruby, 108 bytes
lamba function, accepts an array of 2-element arrays containing the edges (where each edge is expressed as a pair of numbers corresponding to the relevant notes.)
->a{[*1..1+n=a.size].permutation.map{|i|k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs}
(k&k).size==n&&(return[i,k])}}

Ungolfed in test program
f=->a{                                    #Accept an array of n tuples (where n is the number of EDGES in this case)
  [*1..1+n=a.size].permutation.map{|i|    #Generate a range 1..n+1 to label the nodes, convert to array, make an array of all permutations and iterate through it.
    k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs} #Iterate through a, build an array k of differences between nodes per current permutation, as a trial edge labelling.
    (k&k).size==n&&(return[i,k])          #Intersect k with itself to remove duplicates. If all elements are unique the size will still equal n so
  }                                       #return a 2 element array [list of nodes, list of edges]
}

p f[[[4,1],[1,2],[1,7],[2,3],[2,5],[5,6]]]

p f[[[1,2],[2,3],[2,4]]]

p f[[[1,2],[2,3],[3,4],[2,5]]]

Output
output is a 2 element array, containing:
the new node numbering
the edge numbering.
For example the first edge of the first example [4,1] is between nodes 6 and 1 under the new node numbering and is therefore edge 6-1=5.
[[1, 5, 2, 6, 3, 4, 7], [5, 4, 6, 3, 2, 1]]
[[1, 4, 2, 3], [3, 2, 1]]
[[1, 5, 3, 4, 2], [4, 2, 1, 3]]

There are in fact multiple solutons for each test case. the return stops the function once the first one is found.

Python3, 237 bytes:
def f(d,e,C=[]):
 if len(C)==len(d)-1:yield d
 for u,v in e:
  K={*range(1,len(d)+1)}-{*d.values()}
  for x in[K,[d[u]]][d[u]!=0]:
   for y in[K,[d[v]]][d[v]!=0]:
    if abs(x-y)==max(C+[0])+1:yield from f({**d,u:x,v:y},e,C+[abs(x-y)])

Try it online!


text:
Lengthen letter runs
Given a non-empty string of lowercase ASCII letters a-z, output that string with each consecutive “run” of the same letter lengthened by one more copy of that letter.
For example, dddogg (3 d’s, 1 o, 2 g’s) turns into ddddooggg (4 d’s, 2 o’s, 3 g’s).
This is code-golf: the shortest answer in bytes wins.
Test cases

aabbcccc -> aaabbbccccc
doorbell -> ddooorrbbeelll
uuuuuuuuuz -> uuuuuuuuuuzz
q -> qq
xyxyxy -> xxyyxxyyxxyy
xxxyyy -> xxxxyyyy

Related (only add another character if the length of the run is odd)

05AB1E, 5 bytes
.¡€ĆJ

Explanation:
Example input: "dddogg"
.¡       Split into chunks of consecutive equal elements
         stack: [['ddd', 'o', 'gg']]
  €      For each...
   Ć       Enclose; append the first character to the end of the string
         stack: [['dddd', 'oo', 'ggg']]
    J    Join array elements into one string
         stack: ['ddddooggg']
Implicitly output top element in stack: "ddddooggg"

Try it online or as a test suite.
Enclose is a pretty new builtin; it's the first time I've used it. Very convenient ;)
05AB1E, 4 bytes
γ€ĆJ

.¡ has been replaced by γ in the latest update.

Enclose is one of the craziest builtins ever.

@EriktheOutgolfer Crazy? Nah.

I think you mean dddd for the first element of the array on the stack in the explanation after "enclose" is executed.

Woah, wait a minute, what the hell is Ć?

Also, xx -> xxxx when it should be xx -> xxx...?

@carusocomputing Try using the new version. TIO has updated so that .¡ has been replaced with γ.

@Okx wouldn't that break existing answers using .¡? I thought language changes that break existing answers were frowned upon.

Python 3, 44 bytes
for c in input():print(c,end=c[id==c:]);id=c

Try it online!

Retina, 11 bytes
(.)\1*
$1$&

Try it online!
Replaces each run of characters with one of the run's characters followed by the run itself.

Pyth, 7 bytes
r9hMMr8

Test suite.
How it works
r9hMMr8  example input: "xxyx"
     r8  run-length encoding
         [[2, "x"], [1, "y"], [1, "x"]]
  hMM    apply h to each item
         this takes advantage of the overloading
         of h, which adds 1 to numbers and
         takes the first element of arrays;
         since string is array of characters in
         Python, h is invariant on them
         [[3, "x"], [2, "y"], [2, "x"]]
r9       run-length decoding
         xxxyyxx

MATL, 5 bytes
Y'QY"

Try it online!
Explanation
Consider input 'doorbell'.
Y'    % Implicit input. Run-length encoding
      % STACK: 'dorbel', [1 2 1 1 1 2]
Q     % Increase by 1, element-wise
      % STACK: 'dorbel', [2 3 2 2 2 3]
Y"    % Run-length decoding. Implicit display
      % STACK: 'ddooorrbbeelll'

Alice, 17 bytes
/kf.>o./
@i$QowD\

Try it online!
Explanation
/.../
@...\

This is a framework for programs which operate entirely in Ordinal mode and are essentially linear (simple loops can be written, and one is used in this program, but it's trickier to work with otherwise branching control flow here). The instruction pointer bounces diagonally up and down through the code from left to right, then gets shifted by one cell by the two mirrors at the end, and the moves back from right to left, executing the cells it skipped on the first iteration. The linearised form (ignoring the mirrors) then basically looks like this:
ifQ>w.Doo.$k@

Let's go through this:
i     Read all input as a string and push it to the stack.
f     Split the string into runs of equal characters and push those
      onto the stack.
Q     Reverse the stack, so that the first run is on top.
>     Ensure that the horizontal component of the IP's movement is east.
      This doesn't do anything now, but we'll need it after each loop
      iteration.
w     Push the current IP address to the return address stack. This marks
      the beginning of the main loop.

  .     Duplicate the current run.
  D     Deduplicate the characters in that run so we just get the character
        the run is made up of.
  o     Output the character.
  o     Output the run.
  .     Duplicate the next run. When we've processed all runs, this will
        duplicate an implicit empty string at the bottom of the stack instead.
  $     If the string is non-empty (i.e. there's another run to process),
        execute the next command otherwise skip it.

k     Pop an address from the return address stack and jump there. Note that
      the return address stack stores no information about the IP's direction,
      so after this, the IP will move northwest from the w. That's the wrong
      direction though, but the > sets the horizontal component of the IP's
      direction to east now, so that the IP passes over the w again and can
      now execute the next iteration in the correct direction.
@     Terminate the program.

Jelly, 6 bytes
Œg;Q$€

Try it online!
Only works as a full program (i.e. stringified output).

Brachylog, 8 bytes
ḅ{t,?}ᵐc

Try it online!
Explanation
             Example input: "doorbell"
ḅ            Blocks: ["d","oo","r","b","e","ll"]
 {   }ᵐ      Map: ["dd","ooo","rr","bb","ee","lll"]
  t            Tail: "d" | "o" | "r" | "b" | "e" | "l"
   ,?          Prepend to input: "dd" | "ooo" | "rr" | "bb" | "ee" | "lll"
       c     Concatenate: "ddooorrbbeelll"

2/10 not declarative enough

@LeakyNun I actually found that one too just after posting this one

You really need to make ~ take precedence over metapredicates (or change it to a postfix operation); if you did, you could do this in seven.

C, 49 bytes
i;f(char*s){for(;putchar(*s);)i=s[i]^s[1]||!s++;}

See it work online.

Python 2, 47 bytes
f=lambda s:s and-~(s[0]*2!=s[:2])*s[0]+f(s[1:])

Try it online!

PHP, 40 Bytes
<?=preg_filter('#(.)\1*#',"$1$0",$argn);

Online Version
PHP<7.1, 44 Bytes
Version without Regex

for(;a&$c=$argn[$i++];)echo$c[$c==$l].$l=$c;

Online Version

C, 53 bytes
i;f(char*s){for(;i=*s++;)putchar(i^*s?putchar(i):i);}

Try it online!

Thank you for posting this solution as it motivated me to come up with a shorter solution that omits the second putchar. Upvoted.

Japt, 8 bytes
7 bytes of code, +1 for the -P flag.
ó¥ ®+Zg

Test it online!
Explanation
This uses the ó (partition on falsy) built-in that I just added yesterday:
ó¥  ®   +Zg
ó== mZ{Z+Zg}

ó==           // Split the input into runs of equal chars.
    mZ{    }  // Replace each item Z in this array with
       Z+Zg   //   Z, concatenated with the first char of Z.
-P            // Join the resulting array back into a string.
              // Implicit: output result of last expression

Hexagony, 33 bytes
\~..,}/',\<.-/.<@;$>.${;/${/"$.>$

Expanded:
   \ ~ . .
  , } / ' ,
 \ < . - / .
< @ ; $ > . $
 { ; / $ { /
  " $ . > $
   . . . .

Try it online!
The pseudo-code is more or less:
char = readchar()
while (char > 0)
    print(char)
    run_char = char
    do
        print(char)
        char = readchar()
    while (run_char == char)

Jelly, 5 bytes
n2\×ż

Try it online!
How it works
n2\×ż  Main link. Argument: s (string)

n2\    Reduce all overlapping slices of length two by non-equal.
       For input "doorbell", this returns [1, 0, 1, 1, 1, 1, 0].
   ×   Multiply the characters of s by the Booleans in the resulting array. This is
       essentially a bug, but integer-by-string multiplication works as in Python.
       For input "doorbell", this returns ['d', '', 'o', 'r', 'b', 'e', '', 'l'].
       Note that the last character is always left unchanged, as the Boolean array
       has one fewer element than s.
    ż  Zip the result with s, yielding an array of pairs.
       For input "doorbell", this returns [['d', 'd'], [[], 'o'], ['o', 'o'],
           ['r', 'r'], ['b', 'b'], ['e', 'e'], [[], 'l'], ['l', 'l']].
       (implicit) Print the flattened result.

Well played, Dennis.

JavaScript (ES6), 33 30 bytes
s=>s.replace(/(.)\1*/g,"$1$&")

Try It

f=
s=>s.replace(/(.)\1*/g,"$1$&")
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("aabbcccc")) // aaabbbccccc
console.log(f("doorbell")) // ddooorrbbeelll
console.log(f("uuuuuuuuuz")) // uuuuuuuuuuzz
console.log(f("q")) // qq
console.log(f("xyxyxy")) // xxyyxxyyxxyy
console.log(f("xxxyyy")) // xxxxyyyy
<input id=i><pre id=o>

brainfuck, 23 bytes
,[.[->->+<<]>[[-]>.<],]

Try it online!
Explanation
,            read the first input character
 [           main loop to be run for each input character
 .           output the character once
 [->->+<<]   subtract from previous character (initially 0), and create a copy of this character
 >[          if different from previous character:
   [-]       zero out cell used for difference (so this doesn't loop)
   >.<       output character again from copy
 ]
 ,           read another input character
]

Will this work with letter runs > 256?

@Challenger5 Yes.  The run length isn't even tracked, so there is no way for run length to overflow.

Thunno 2 J, 3 bytes
ġ€ẹ

Try it online!
Explanation
ġ€ẹ  # Implicit input
ġ    # Group consecutive
 €   # Single function map:
  ẹ  #  Enclose (append
     #  first character)
     # Join into a string
     # Implicit output

05AB1E, 8 bytes
.¡DÔ‚ø˜J

Try it online!
Explanation:
.¡DÔ‚ø˜J
.¡       Split equal runs of input
  D      Duplicate
   Ô     Take connected-uniquified
    ‚    Pair connected-uniquified equal runs with original equal runs
     ø   Zip
      ˜  Deep-flatten (i.e. normal flattening)
       J Join elements together

Perl 6, 18 bytes
{S:g/)>(.)$0*/$0/}

Try it
Expanded:
{   # bare block lambda with implicit parameter ｢$_｣

  S        # replace and return
  :global  # all occurrences
  /

    )>     # don't actually remove anything after this

    (.)    # match a character

    $0*    # followed by any number of the same character

  /$0/     # replace with the character (before the match)
}

Haskell, 36 bytes
f(a:b:c)=a:[a|a/=b]++f(b:c)
f x=x++x

Usage example: f "aab" -> "aaabb". Try it online!
When the string has at least two chars, bind a to the first char, b to he second and c to the rest of the string. The output is a followed by a if a is not equal to b followed by a recursive call with b:c.  If there's only one char, the result is two times this char.

CJam, 10 bytes
le`1af.+e~

Try it online!
Explanation:
e# Input: doorbell
l   e# Read line:              | "doorbell"
e`  e# Run-length encode:      | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]]
1a  e# Push [1]:               | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]] [1]
f.+ e# Vectorized add to each: | [[2 'd] [3 'o] [2 'r] [2 'b] [2 'e] [3 'l]]
e~  e# Run-length decode:      | "ddooorrbbeelll"
e# Implicit output: ddooorrbbeelll

Ruby, 30 bytes
->s{s.gsub(/((.)\2*)/){$1+$2}}

APL (Dyalog) with AGL, 11 bytes
⊢é⍨2-0,2=/,

Try it online!
, ravel*
2=/ pair-wise comparison (shows which characters to leave as-is)
0, prepend a zero (indicating that the initial character should be duplicated)
2- subtract that from two (gives 2 for the letters which need to be duplicated, and 1 for the rest)
⊢é⍨ replicate the argument using that (é is just the function /)

* This is a no-op on strings, but makes scalar characters into strings. Not required, as argument should be a string, but it makes the tests look neater, and we need a no-op function here anyway. To remove this feature, use ⊢ instead of ,.

Why doesn't simply ⊢/⍨ work?

@KritixiLithos I'll explain it in the APL chat room.

@miles Should be fixed now.

Mathematica, 34 21 bytes
Thanks to Martin Ender for finding the right way to do this in Mathematica, saving 13 bytes!
##&[#,##]&@@@Split@#&

Pure function using an array of characters as both input and output formats. Split separates a list into its runs of equal characters. ##&[#,##]& is a function that returns a sequence of arguments: the first argument it's fed, then all of the arguments (so repeating the first one in particular); this is applied (@@@) to every sublist of the Split list.

Maybe ##&[#,##]&@@@Split@#&? (Untested.)

^ Now tested. Btw, Gather doesn't actually work if there are multiple runs of the same character (but luckily Split is a byte shorter anyway)

(oh yeah, I meant Split in my heart) Wonderful construction in your first comment!

Batch, 140 bytes
@set/ps=
@set r=
:g
@if not "%s:~,1%"=="%s:~1,1%" set r=%r%%s:~,1%
@set r=%r%%s:~,1%
@set s=%s:~1%
@if not "%s%"=="" goto g
@echo %r%

Takes input on STDIN.

sed, 18 15 bytes (+1 for -r)
s/(.)\1*/\1&/g

Original solution
s/((.)\2*)/\1\2/g

R, 36 bytes
gsub("((.)\\1*)","\\2\\1",scan(,""))

Java, 151 146 60 bytes
String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}

-5 bytes, thanks to @FryAmTheEggman
-86 bytes, thanks to @KevinCruijssen

Regex
(         )     group

 (.)            a character

     \\2*       optional repetition

Detailed
import java.util.*;
import java.lang.*;
import java.io.*;

class H
{
    public static String f(String s)
    {
        return s.replaceAll("((.)\\2*)","$1$2");
    }

    public static void main(String[] args)
    {
        f("dddogg");
    }
}

Hadn't noticed there was already a Java answer, so I've deleted mine. But why the Matcher and Pattern? You can golf it to 60 bytes like this: String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}

@KevinCruijssen fixed now, thx.

PowerShell, 50 bytes
{-join([char[]]$_|%{if($_-ne$p){($p=$_)}$_});rv p}

Try it online!

brainfuck, 38 bytes
,.[.>,[[->+>+<<]<[->>-<<]>>[[-]>.<]]>]

Try it online!
,.               print the "doubling" of the first char of input
[                this main loop runs on every char
  .              print it "normally" (the not-doubling)
  >,             read the next char
  [              judiciously placed "loop" to prevent printing NULs
    [->+>+<<]    copy new char at position p to p+1 and p+2
    <[->>-<<]>>  subtract old char from p+1 - zero if same, nonzero otherwise
    [            if it *is* different (nonzero)...
      [-]        clear it
      >.<        print the char (at p+2 now) again
    ]
  ]
  >              the new char is now the old char
]

Alice, 12 bytes
Two bytes were golfed thanks to Martin Ender even before this answer was posted. He's more powerful than you could ever imagine.
I4&.h%?-$OO!

Try it online!
Explanation
I                 Input a character and push its unicode value
 4&.              Push 4 more copies of this value to the stack
                  (they will be needed for the following operations)
    h%            Try to compute n%(n+1), exits with an error if n==-1
                  which happens on EOF
      ?           Push a copy of what's currently on the tape.
                  In the first iteration this will push -1, in following
                  iterations it will push the previous character.
       -$O        If the two topmost values on the stack are different
                  output the third one. This will output one more copy of
                  any new character encountered.
          O       Output this character.
           !      Store this character on the tape.

                  Execution loops back to the beginning of the line.

Vyxal d, 3 bytes
ĠvǏ

Try it Online!

Vyxal, 9 bytes (Try it)
øeƛ÷›";ød

V, 9 bytes
Í¨.©±*/&±

Try it online!

Javascript ES6, 56 46 bytes
b=>[...b].map((c,i,a)=>a[i+1]!=c?c+c:c).join``

Saved 10 bytes thanks to @Shaggy using spread operator and c+c

Try it

f=

b=>[...b].map((c,i,a)=>a[i+1]!=c?c+c:c).join``

console.log(f("aabbcccc")); //aaabbbccccc
console.log(f("uuuuuuuuuz")); //uuuuuuuuuuzz
console.log(f("q")); //qq
console.log(f("xyxyxy")); //xxyyxxyyxxyy
console.log(f("xxxyyy")); //xxxxyyyy

b=>[...b].map((c,i,a)=>a[i+1]!=c?c+c:c).join'' for 46 bytes, replacing the single quotes at the end with backticks.

C#, 115 bytes

Data

Input The string to be stretched
Output The stretched string

Golfed
(string i)=>{var t=' ';for(int x=0;x<i.Length;x++)if(i[x]!=t){i=i.Insert(x,t+"");t=i[x+1];}i=i.Trim()+t;return i;};

Ungolfed
( string i ) => {
   var t = ' ';

   for( int x = 0; x < i.Length; x++ )
      if( i[ x ] != t ) {
         i = i.Insert( x, t + "" );
         t = i[ x + 1 ];
      }

   i = i.Trim() + t;

   return i;
};

Ungolfed readable
// Takes a string to be stretched
( string i ) => {

   // Creates a temp var to hold the chars
   var t = ' ';

   // Cycles through every char in the string
   for( int x = 0; x < i.Length; x++ )

      // Checks if the temp var is different to the current one
      if( i[ x ] != t ) {

         // If so, insert a new char in the middle
         i = i.Insert( x, t + "" );

         // Stores the new char
         t = i[ x + 1 ];
      }

   // Removes the trailling space added due to the temp var
   i = i.Trim() + t;

   // Return the stretched string
   return i;
};

Full code
using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = ( int[] i ) => {
            var t = ' ';

            for( int x = 0; x < i.Length; x++ )
               if( i[ x ] != t ) {
                  i = i.Insert( x, t + "" );
                  t = i[ x + 1 ];
               }

            i = i.Trim() + t;

            return i;
         };

         List<String>
            testCases = new List<String>() {
               "a",
               "ab",
               "aab",
               "abcdvaabb",
               "aasd231",
               "",
            };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput: {f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Releases

v1.0 - 115 bytes - Initial solution.

Notes

None

Cubix, 19 23 bytes
A.?@WW>o-!wu;W>1$o;

Try it online!
    A .
    ? @
W W > o - ! w u
; W > 1 $ o ; .
    . .
    . .

I think I can take a couple of this yet, but running out of steam and will probably come back to this later.
General algorithm hasn't changed much, just the program flow.

W redirect to top face heading down
A put all input onto stack
?@ test for end of input and exit if
W>o if positive (should be) W changes lane which put the IP on the > redirecting to the output
-!wu check against next char using subtraction, if truthy (different) jump the lane change on the u-turn
from the u-turn in execution order ;o$1>1$o.  This drops the difference; outputs the char; skips the 1; redirects back; push sacrificial 1; skips the output
from the end of the u-turn and the beginning of the lane change ;.;WW.  Drops the top 2 items from the stack; Change lane; Change lane.  This puts the IP back on the ? in the third step.  Rinse and repeat.

Swift, 61 bytes
var b="ab".characters.map {"\($0)"},c="";for a in b{c=c+a+a;}

Prolog (SWI), 51 bytes
\A:-get(C),C>0,(C=A;A<1;put(A)),put(C),\C;!.
:- \0.

Try it online!

Thes doesn't lengthen the last run. You can move the C>0 after the middle part, or just remove it and the ,! to let it terminate in an error

Arturo, 30 bytes
$=>[replace&{/((.)\2*)}"$1$2"]

Try it!
Non-regex answer:
Arturo, 38 bytes
$=>[chunk&=>[&]|map'x->x++x\0|flatten]

Try it!

source: Stack Exchange

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

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

sort: votes


text:
Make Wise Numbers
Wise is a simple bitwise language I designed a while back.  It is based around Python's bitwise operations.  It has several operations most of these are the same or very similar to the equivalent symbol in Python.

: Duplicate the top of the stack
? Rotate the top of the stack to the bottom
! Rotate the bottom of the stack to the top
[ ] loop while the top of the stack is not zero
~ not the top of the stack (-(n+1))
- negate the top of the stack (-n)
> bitshift the top of the stack once to the right (n//2)
< bitshift the top of the stack once to the left (n*2)
^ xor the top two items of the stack (Same as Python)
| or the top two items of the stack (Same as Python)
& and the top two items of the stack (Same as Python)

Making an integer in Wise is pretty simple you can make zero with ::^ and increment it with ~- so you make zero and increment it a bunch of times.  However if we remove the - things become a little more interesting.
We can still make every number using the remaining operations.  For example here is 3
~<<~

TIO
This works because ~ turns zero, an infinite string of 0 bits, into negative one, an infinite string of 1 bits,  each < appends a 0 bit to the end, when we are done we do ~ which turns each it into a string of 0s followed by a two 1s, or as most people call it 3.

Task
Write a program that when given a positive integer will output a Wise program that will create the number n without any - in its source (the source of the output, you may use - in your own source).  You may assume that there is already a zero on the top of the stack.
This is code-golf not meta-golf so you should aim to minimize the generating source code not necessarily the output.
Example outputs
This list is not exhaustive they are simply possible outputs
1  -> ~<~
2  -> ~<~<
3  -> ~<<~
4  -> ~<~<<
5  -> ~<~:<<|
6  -> ~<<~<
7  -> ~<<<~
8  -> ~<~<<<
9  -> ~<~:<<<|
10 -> ~<~:<<|<
11 -> ~<<~:><<<|
12 -> ~<<~<<
13 -> ~<<~:<<<|>
14 -> ~<<<~<
15 -> ~<<<<~
16 -> ~<~<<<<

is 0 included in positive integers

No, 0 is not included in positive integers.

Apparently : applied on an empty stack pushes a 0. I think this should be specified, as it's not obvious that duplicating from an  empty stack should give 0

Are other characters syntax errors, or are they ignored?

@Luismendo you do not know the contents of the stack other than that that too if the stack is a zero

@xnor they are ignored

Japt, 10 bytes
¤d0'<1"~<~

Try it online!
Basic idea: take the binary representation of the number, and map 0 to < and 1 to ~<~. Outputs for 1-10:
 1: ~<~
 2: ~<~<
 3: ~<~~<~
 4: ~<~<<
 5: ~<~<~<~
 6: ~<~~<~<
 7: ~<~~<~~<~
 8: ~<~<<<
 9: ~<~<<~<~
10: ~<~<~<~<

Metagolfing this would be easy, too. Just strip pairs of ~~

JavaScript (ES6), 34 33 bytes

f=n=>n?f(n&1?~n:n/2)+'<~'[n&1]:''
<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Works for any 32-bit integer.

Ok I figured this out.  Cool! nice job.

Haskell, 38 bytes
I feel like PPCG is really improving my Haskell. Strokes white cat.
f n=mapM(["<","~<~"]<$f)[1..n]!!n>>=id

f takes an Int and returns a String.
Try it online!
(I'm referring to that <$f by the way. It saves a character over \_->.)

 In the Functor instance for (->) a (functions from type a), we have: x <$ f = fmap (const x) f = const x . f = const x. The only limitation is that f and the final const x must use the same source type a. The instance is completely lazy so this never even evaluates f.

Alternatively, same length but less evil ((l!!) is an anonymous function):
(l!!)
l=(++)<$>"":tail l<*>["<","~<~"]

Try it online!
Both of these use the same representation as @ETHproductions' Japt answer, although especially the first one may give some redundant <s at the beginning.
The first one calculates all combinations of n "<" and "~<~" strings, then indexes into the resulting list.
The second one recursively calculates an infinite list formed by starting with "" and then constructing new elements by appending "<" and "~<~" strings to each element already in the list (actually it was slightly shorter to also let the "" get turned into "<".)

How on earth does that <$f work? Some weird functor instance?

@xnor Mwahahaha I guess I should add an explanation then.

Ruby, 118 116 109 107 105 91 bytes
Saved 2 bytes thanks to cyoce!
->n{o={0=>""}
o.dup.map{|c,k|["~~c","<c*2"].map{|t|o[eval t[1..9]]=k+t[0]}}until o[n]
o[n]}

Try it online!
This is a function that takes the integer as input and returns the string that represents that integer in Wise. You can find an ungolfed version here, which tests this program on all integers from 1 up.
The basic idea is to record a "pool" of constants. Then, with each "step", constants are added to the pool for each possible function. I have chosen the functions ~, <, and >, which I believe are sufficient to represent every number. (At least, every number under 10,000.)

You can use dup instead of clone iirc

Do you even need dup? map doesn't modify its receiver.

@Cyoce I think it does

Oh I see now. Ruby doesn't like modifying while iterating.

Python2, 54 52 51 bytes.
lambda x:'<'.join('>~<~'*int(i)for i in bin(x)[2:])

Thanks to Wheat Wizard for saving 2 bytes, and Ørjan Johansen for one byte! This uses the same idea as ETHproduction's Japt answer, but with different replacement strings (i.e. using the binary representation)

You don't need the [ ] around the generator inside of the join.  join can take a generator as its argument.

I think '>~<~'*int(i) may save you a byte.

I believe the newest score is supposed to be listed last, for the benefit of automated scoreboard snippets and the like.

There, sorry about being late on that.

05AB1E, 11 bytes
bS'<…~<~‚èJ

Try it online!
Similar to ETHproductions' Japt answer.
Saved 4 bytes thanks to @Adnan!

Hey nice! You don't actually need to convert the numbers to strings as they are equal 'types' in 05AB1E. Same for the number literals (you can do without the '). You can also use indexing, which should give you 11 bytes :).

@Adnan Thank you very much!

@Adnan Just a quick question, how does è work here?

First, it swaps the arguments because it would run into an exception if it was evaluated normally. After swapping, it maps 0 to the zeroth element and 1 to the first element (because it vectorizes automatically). Here is a more clear example of how it works.

Python 2, 123 110 bytes
def w(x):a=map(int,bin(x)[2:]);return x%2*("~<~:<"+"<".join(":"*e for e in a[-2::-1])+"|"*sum(a))or w(x/2)+"<"

Try it online!
Also as a lambda
w=lambda x:x%2*("~<~:<"+"<".join(":"*int(e)for e in bin(x)[-2:2:-1])+"|"*sum(map(int,bin(x)[2:])))or w(x/2)+"<"

Try it online!
Could be shorter but here is my solution. It takes the binary representation and turns it into the code.

Japt, 23 bytes
?Uu ?ß~U +'~:ßU/2 +'<:P

Try it online!

Jelly, 11 10 bytes
Bị“~<~“<”F

This is a ported version of ETHproductions' Japt answer. Speaking of ETHproductions, they saved me one byte!

Could you swap the strings and pretend the indexing is 0-based?

What do you mean? I'm referring to the fact that I have to increment the binary representation of the number to get usable indexes.

Try it online!

Doesn't work, 1 produces <, which in Wise produces 0

Really? It gives ~<~ for me

OK, thanks for that!

Oh, I see how it works now! Modular indexing, which was added recently, right?

I think it's been there from the start, actually

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


text:
HE COMETH NOT - a zalgo challenge
Write a program or function that, given a string, will strip it of zalgo, if any exists.
Zalgo
For this post, zalgo is defined as any character from the following Unicode ranges:

Combining Diacritical Marks (0300–036F)
Combining Diacritical Marks Extended (1AB0–1AFF)
Combining Diacritical Marks Supplement (1DC0–1DFF)
Combining Diacritical Marks for Symbols (20D0–20FF)
Combining Half Marks (FE20–FE2F)

https://en.wikipedia.org/wiki/Combining_character#Unicode_ranges
Input

May be passed via command line arguments, STDIN, or any other standard method of input supported by your language
Will be a string that may or may not contain zalgo or other non-ASCII characters

Output
Output should be a string that does not contain any zalgo.
Test Cases
Input -> Output

HE̸͚ͦ ̓C͉Õ̗͕M͙͌͆E̋̃ͥT̠͕͌H̤̯͛ -> HE COMETH
C͉̊od̓e͔͝ ̆G̀̑ͧo͜l͔̯͊f͉͍ -> Code Golf
aaaͧͩa͕̰ȃ̘͕aa̚͢͝aa͗̿͢ -> aaaaaaaaa
ññ        -> ñn
⚡⃤       -> ⚡

Scoring
As this is code-golf, shortest answer in bytes wins.

Is the string guaranteed to only contain ASCII and/or Zalgo? Or may it contain other unicode?

What about legitimate uses of those characters? Zalgo is pretty much only when those characters stack with each other in a way that was never intended.

@DJMcMayhem The input string may have other non-ASCII characters that must not be removed.

@Draco18s Any character in those Unicode ranges must be removed. Besides, I don't think golfing code that recognizes valid words with combining characters would be fun.

Is an encoding mandated or can any encoding be used?

@Doorknob Any encoding can be used but the definition of zalgo for this question still stands.

@totallyhuman I was thinking a more generic approach: only stripping if more than one occurs after a "standard" character. That is a͕ is fine but a͕̰ gets stripped to a. (Also now, thanks to the emoji detector, I want to put diacritics on emoji...̘͕̑ pfft, that looks silly)

@Draco18s That... might actually be a good idea but isn't it too late? Won't I be disrupting current progress?

No idea, honestly. I don't have a good idea of how things work around here. If this is deemed a good challenge, then my idea might make a good second challenge. But it's why we have a sandbox.

I did put it in the sandbox but I got different questions there.

Then this question is probably fine as is. :)

Related.

You should add some test cases with non-ASCII output.

I would be grateful if somebody could do that as I am unable to do so for a while. (Preferably with the same length as the others because that just works. :P)

Retina, 35 bytes
T`̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯

Try it online!
Simply removes all characters in the ranges given in the challenge from the input. The code is super unreadable of course, but the code is conceptually no different from something like T`0-9A-Za-z which would delete all alphanumeric characters.

Seems unbeatable enough to me.

@EriktheOutgolfer I don't know, I think Jelly might be able to generate the code point ranges more efficiently than just listing the characters.

Actually I don't think it's able to.

I'm surprised there is no Jelly solution yet.

@icrieverytim here, and rip it's longer. I haven't figured out how to generate codepoints more effectively than this :P

Python 3, 73 69 bytes
-4 bytes thanks to L3viathan.
Not sure if participating in your own challenge is ok or not but... Stole the regex and essentially the idea as well >< straight from the JS and Retina answers.
lambda s:re.sub('[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]','',s)
import re

Try it online!

Save 4 bytes by making that a normal import statement.

You forgot to update the byte count.

@xnor Huh? Seems right to me.

@totallyhuman My mistake, missed that those char are multibyte.

Well, it's fair to say that I stole the character range from the Retina answer. (With care though, since my editor wanted to remove the zalgo along with the ```.)

JavaScript (ES6), 55 bytes

f=
s=>s.replace(/[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]/g,'')
<textarea oninput=o.textContent=f(this.value)></textarea><pre id=o>

PHP, 67 Bytes
shorter as the write out

<?=preg_replace("#[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]#u","",$argn);

Try it online!
PHP, 115 Bytes
<?=preg_replace("#[\u{300}-\u{36f}\u{1ab0}-\u{1aff}\u{1dc0}-\u{1dff}\u{20d0}-\u{20ff}\u{fe20}-\u{fe2f}]#u","",$argn);

Try it online!
PHP, 35 Bytes
Valid for the given Testcases it removes all Marks

<?=preg_replace("#\pM#u","",$argn);

Try it online!

@FelixDombek No it replaces only all Marks in the given ranges with nothing

Japt, 37 bytes
r"[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]

Try it online!

Python 3, 127 118 bytes
Just a straightforward answer for now, let's see how golfable it is.
lambda y:"".join(chr(x)for x in map(ord,y)if not(767<x<880or 6831<x<6912or 7615<x<7680or 8399<x<8448or 65055<x<65072))

Changelog:

When will I ever learn that comprehensions are shorter than functional stuff (-9 bytes).

0or is not a thing, so you have to fix it or it will raise SyntaxError.

@EriktheOutgolfer Did you actually test it? Doesn't throw an error for me on neither Python 3 nor 2.

Oh right. I was confused for a bit.

Bash + coreutils, 41
tr -d '̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯'

Simply strips out characters in the given ranges.
Try it online.

APL (Dyalog Unicode), 43 bytes
'[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]'⎕R''

Try it online!
PCRE Replace all those with nothing

44 byte version not using RegEx or strange character literals (and thus single byte per character):
⍞~⎕UCS∊65055 8399 7615 6831 767+⍳¨16×2 6~⍨⍳7

Try it online!
⍳7 1…7 (1 2 3 4 5 6 7)
2 6~⍨ except 2 and 6 (1 3 4 5 7)
16× multiply by 16 (16 48 64 80 112)
⍳¨ 1… each (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16, 1 2 3…, …110 111 112)
+ add offset to each list (65056 65057 65058…, …877 878 879)
∊ enlist (flatten)
⎕UCS convert to corresponding Unicode character
⍞~ get text input and remove all such characters

Jelly, 32 bytes
“Żȷ'⁺¦60ƭṖ_WTɦ7Ụ|ṫYɠF’bȷ5r2/FỌḟ@

Try it online!
Explanation
“Żȷ'⁺¦60ƭṖ_WTɦ7Ụ|ṫYɠF’bȷ5r2/FỌḟ@  Main link
“Żȷ'⁺¦60ƭṖ_WTɦ7Ụ|ṫYɠF’            Base 250 compressed integer; 768008790683206911076160767908400084476505665071
                      bȷ5         Convert into base 100000; [768, 879, 6832, 6911, 7616, 7679, 8400, 8447, 65056, 65071]
                         r2/      Inclusive range on non-overlapping slices of length 2
                            F     Flatten
                             Ọ    chr; cast to character from codepoints
                              ḟ@  Filter; remove all characters from input that are in the characters generated before

o0 Didn't realize I bumped this question up lol. Is that b65072 what I think it is? :o

@icrieverytim yes numerical list compression :D

jelly is definitely the most zalgo language. i wonder what would happen if you ran the program on its own code? edit: unfortunately nothing

05AB1E, 32 bytes
•3xIαEλ¤’ä₆Ćkмм`0Â9"´•žHв2ôvyŸçK

Try it online!

Java 8, 57 bytes
s->s.replaceAll("[̀-ͯ᪰-᫿᷀-᷿⃐-⃿︠-︯]","")

Try it here.


text:
Implement Euler's method
The goal of this challenge is to use Euler's method to approximate the solution of a differential equation of the form f(n)(x) = c.†
The input will be a list of integers in which the nth value represents the value of f(n)(0). The first integer is f(0), the second is f'(0), and so on. The last integer in this list is the constant and will always remain the same.
Also provided as input will be a positive (nonzero) integer x, which represents the target value (you are trying to estimate f(x)). The step size for Euler's method will always be 1. Thus, you will need to take x steps total.
If you are unfamliar with Euler's method, here is a detailed example with an explanation for the input [4, -5, 3, -1], x = 8.
x       f(x)      f'(x)     f''(x)    f'''(x)
0          4         -5          3         -1
1   4-5 = -1  -5+3 = -2   3-1 =  2         -1
2  -1-2 = -3  -2+2 =  0   2-1 =  1         -1
3  -3+0 = -3   0+1 =  1   1-1 =  0         -1
4  -3+1 = -2   1+0 =  1   0-1 = -1         -1
5  -2+1 = -1   1-1 =  0  -1-1 = -2         -1
6  -1+0 = -1   0-2 = -2  -2-1 = -3         -1
7  -1-2 = -3  -2-3 = -5  -3-1 = -4         -1
8  -3-5 = -8

Essentially, each cell in the generated table is the sum of the cell above it and the cell above and to the right. So, f(a) = f(a-1) + f'(a-1); f'(a) = f'(a-1) + f''(a-1); and f''(a) = f''(a-1) + f'''(a-1). The final answer is f(8) ≈ -8.††
The input list will always contain 2 or more elements, all of which will have absolute values less than 10. x ≥ 1 is also guaranteed. The output is a single integer, the approximation of f(x). Input may be taken in either order (the list before x, or x before the list). x may also be the first or last element of the list, if desired.
Test cases:
[4, -5, 3, -1], x = 8 => -8
[1, 2, 3, 4, 5, 6], x = 10 => 3198
[1, 3, 3, 7], x = 20 => 8611
[-3, 3, -3, 3, -3, 3, -3, 3, -3], x = 15 => -9009
[1, 1], x = 1 => 2

†: it is notable that using an approximation method in this situation is, in fact, stupid. however, the simplest possible function was chosen for the purposes of this challenge.
††: the actual value happens to be -25⅓, which would qualify this approximation as "not very good."

Very closely related

Also very close related.

Haskell, 38 bytes
l%n|n<1=l!!0|m<-n-1=l%m+tail(l++[0])%m

Try it online!
Improved from 39 bytes:
l%0=l!!0
l%n=l%(n-1)+tail(l++[0])%(n-1)

Recursively expresses the output l%n. Moving up corresponds to decrementing n, and moving right corresponds to taking tail l to shift all list elements one space left. So, the output l%n is the value above l%(n-1), plus the value above and to the right (tail l)%(n-1)
The base case n==0 is to take the first list element.
Ideally, the input would be padded with infinitely many zeroes to the right, since the derivatives of a polynomial eventually become zero. We simulate this by appending a 0 when we take the tail.
Weird alt 41:
(iterate(\q l->q l+q(tail l++[0]))head!!)

MATL, 9 bytes
:"TTZ+]1)

Try it online! Or verify all test cases.
Explanation
:"      % Implicitly input x. Do the following x times
  TT    %   Push [1 1]
  Z+    %   Convolution, keeping size. Implicitly inputs array the first time
]       % End
1)      % Get first entry. Implictly display

Jelly, 6 5 bytes
Ḋ+$¡Ḣ

Try it online!
-1 byte thanks to @Doorknob
Explanation
Ḋ+$¡Ḣ  - Main dyadic link. First input list, second x
       - (implicit) on the previous iteration (starting at input list)
Ḋ      - Dequeue. e.g. [-5,3,-1]
 +     - Add this to
       - (implicit) the previous iteration. e.g. [4+(-5),-5+3,3+(-1),-1+0]
  $¡   - apply this successively x times
    Ḣ  - get the first element from the resultant list

Brachylog, 13 12 bytes
{,0s₂ᶠ+ᵐ}ⁱ⁾h

Try it online!
How it works
{,0s₂ᶠ+ᵐ}ⁱ⁾h
{       }ⁱ⁾   iterate the previous predicate
              to the array specified by first element of input
              as many times as the second element of input
           h  and get the first element

              example input to predicate: [4, _5, 3, _1]
 ,0           append 0: [4, _5, 3, _1, 0]
   s₂ᶠ        find all substrings with length 2:
              [[4, _5], [_5, 3], [3, _1], [_1, 0]]
      +ᵐ      "add all the elements" mapped to each subarray:
              [_1, _2, _2, _1]

Previous 13-byte solution
{b,0;?z+ᵐ}ⁱ⁾h

Try it online!
How it works
{b,0;?z+ᵐ}ⁱ⁾h
{        }ⁱ⁾   iterate the previous predicate
               to the array specified by first element of input
               as many times as the second element of input
            h  and get the first element

               example input to predicate: [4, _5, 3, _1]
 b             remove the first element: [_5, 3, _1]
  ,0           append 0: [_5, 3, _1, 0]
    ;?         pair with input: [[_5, 3, _1, 0], [4, _5, 3, _1]]
      z        zip: [[_5, 4], [3, _5], [_1, 3], [0, _1]]
       +ᵐ      "add all the elements" mapped to each subarray:
               [_1, _2, _2, _1]

Mathematica, 32 bytes
#&@@Nest[#+Rest@#~Append~0&,##]&

                               &  make a pure function
    Nest[                 &,##]   call inner function as many times as specified
           Rest@#                 drop the first element of the list
                 ~Append~0        and add a 0 to get [b,c,d,0]
         #+                       add original list to get [a+b,b+c,c+d,d]
#&@@                              take the first element after x iterations

Python, 80 58 bytes
Love the math for this challenge.

f=lambda a,x:x and f(map(sum,zip(a,a[1:]+[0])),x-1)or a[0]

How it works (only works with python 2):
f=lambda a,x:                                              - new lambda function
             x and                                         - iterate itself x times
                     map(sum,zip(a,a[1:]+[0]))             - e.g; f(a) = f(a-1) + f'(a-1)
                   f(                         ,x-1)        - iterate new array into itself
                                                   or a[0] - return first element

Try it online!
100 byte alternate with use of pascals triangle
from math import factorial as F
f=lambda a,x:sum([(a+[0]*x)[i]*F(x)/(F(x-i)*F(i))for i in range(x)])

How it works (works for python 2 and 3):
sum([                                                ]) - take the sum of array
     (a+[0]*x)                                        - append x zeros
              [i]*F(x)/(F(x-i)*F(i))                  - multiply each element by x choose i
                                    for i in range(x) - do this for every element

This formula works by mapping the coefficients of row x of pascals triangle onto the array. Each element of pascals triangle is determined by the choose function of the row and index. The sum of this new array is equivalent to the output at x. It's also intuitive as the iterated process of newtons method (shown in the example) acts exactly as the construction of pascals triangle.
Try it online!
Big thanks to ovs for reducing 22 bytes by converting loop into a recursive function

Here is an improved version. I converted the for loop to an recursive function

Ah, great idea @ovs

even shorter Note that it will only work with python2

Haskell, 52 45 bytes
l#n=iterate(zipWith(+)=<<tail.(++[0]))l!!n!!0

Usage example: [-3,3,-3,3,-3,3,-3,3,-3] # 15 -> -9009. Try it online!
How it works
iterate(      )l          -- apply the function again and again starting with l
                          -- and collect the intermediate results in a list
                          -- the function is
          (++[0])         -- append a zero
  zipWith(+)=<<tail       -- and build list of neighbor sums
                     !!0  -- take the first element from
                  !!n     -- the nth result

Edit: @xnor saved 7 bytes. Thanks!

I think the iterated function can be zipWith(+)=<<tail.(++[0]), i.e. fix the list beforehand rather than afterward.

@xnor: yes, that saves a lot of bytes. Thanks!

I just cannot wrap my mind around the use of =<< here, this is insane:)

@flawr: =<< is used in function context and is defined as: (=<<) f g x = f (g x) x. Here we use =<< infix: (f =<< g) x with f = zipWith(+) and g = tail, which translates to zipWith(+) (tail x) x.

Thank you for the detailed explanation, I was not aware of the function monad!

CJam, 12 bytes
q~{_(;.+}*0=

Try it online!
Explanation
The code directly implements the procedure described in the challenge.
q~            e# Read input and evaluate. Pushes the array and the number x
  {     }*    e# Do the following x times
   _          e# Duplicate array
    (;        e# Remove first element
      .+      e# Vectorized sum. The last element in the first array, which doesn't
              e# have a corresponding entry in the second, will be left as is
          0=  e# Get first element. Implicitly display

Octave, 42 bytes
@(a,x)conv(a,diag(flip(pascal(x+1))))(x+1)

This defines an anonymous function. Try it online!
Explanation
The solution could be computed by repeatedly convolving the input array and the resulting arrays with [1, 1]. But convolving twice, or thrice, or ... with [1, 1] corresponds to convolving once with [1, 2 ,1], or [1, 3, 3, 1], or ...; that is, with a row of the Pascal triangle. This is obtained as the anti-diagonal of the Pascal matrix of order x+1.

Pyth, 10 bytes
s.e*b.cQkE

Test suite.
How it works
s.e*b.cQkE
 .e      E   for (b,k) in enumerated(array):
     .cQk        (input) choose (k)
   *b            * b
s            sum

APL (Dyalog), 29 bytes
{0=⍺:⊃⍵
(⍺-1)∇(+/¨2,/⍵),¯1↑⍵}

Try it online!
This is a recursive dfn, but it turns out to be too verbose. Golfing in progress...

Actually, 7 bytes
;lr(♀█*

Try it online!
How it works
;lr(♀█*  input:
         8, [4, -5, 3, -1]
         top of stack at the right
;        duplicate
         8, [4, -5, 3, -1], [4, -5, 3, -1]
 l       length
         8, [4, -5, 3, -1], 4
  r      range
         8, [4, -5, 3, -1], [0, 1, 2, 3]
   (     rotate stack
         [4, -5, 3, -1], [0, 1, 2, 3], 8
    ♀█   map "n choose r"
         [4, -5, 3, -1], [1, 8, 28, 56]
      *  dot product
         -8

JavaScript (ES6), 41 bytes
f=(a,x,[b,...c]=a)=>x--?f(a,x)+f(c,x):b|0

Port of @xnor's excellent Haskell answer. Previous 47-byte solution.
f=(a,x)=>x--?f(a.map((e,i)=>e+~~a[i+1]),x):a[0]

Python 3 with Numpy, 82 bytes
import numpy
def f(a,x):
 for n in range(x):a=numpy.convolve(a,[1,1])
 return a[x]

Similar to my MATL answer, but using full-size convolution, and thus the result is the x-th entry of the final array.
Try it online!

Python, 51 bytes
f=lambda l,n:n and f(l,n-1)+f(l[1:]+[0],n-1)or l[0]

Try it online!
This is a port of my Haskell answer.


text:
A program that forgets itself
Background
While a program is running on a computer, the computer needs to keep track of that program somehow, typically by either copying or mapping the compiled form of the program into memory. (Even interpreted languages do this; a few primitive languages work with source code directly, but in most interpreted languages, the a running program in memory is stored in some sort of bytecode.) We'll call this the program's "image in memory", or just "image" for short. The important property that defines the image as a memory image is that if we modify it while the program is running, then it's the newly modified image that's running (because it's the image that's used to remember what it is that's running).
Now, the fact that this image is in memory means that it can be modified. (Unless the interpreter/runtime is rereading the program from disk as it executes every command, which would be a very unusual design, changing the file on disk won't change the image; likewise, this means that we're typically going to be able to change the image without affecting the disk file.) Most operating systems nowadays have a security feature (known as "W^X") that prevents altering a memory image of a currently running program, but they also normally have a way to turn it off (and it only applies to programs being executed directly by the OS, not programs whose image is being run by an interpreter).
The task
Write a program that modifies the portion of memory storing its own image so that it becomes all-bits-zero. (At this point, the interpreter is fairly likely to crash or enter an infinite loop, because an all-bits-zero program isn't very meaningful.) The difficulty in this task is mostly that as you write more and more zeroes to memory, less and less of your program will still be intact and runnable. The very last command of the original program that runs must, of course, overwrite itself.
To prevent degenerate solutions (such as the null program) being valid, your program's memory image must contain at least 31 contiguous bytes which will have no effect on the execution of the program, regardless of their values (i.e. they're overwritten with zeroes before the first time they execute). (Programming Puzzles & Code Golf will fit neatly into the gap, although you might want to use some other padding to save bytes.) This means that unless someone manages to find a pre-existing programming language in which all 31-byte programs self-annihilate, the best possible score on this challenge for a memory image submission will be 32 bytes. (A source code submission could be shorter, if it compiles to an image at least 32 bytes long.)
Clarifications and additional restrictions

If W^X or a similar security feature would prevents writes to the portion of memory you would need to write to, include instructions on how to turn it off. You're allowed to turn it off via any of building the program in an unusual way, running the program in an unusual way, or adding code to the program to request turning off W^X. In the last case, the added code does not count towards the length of the program, so long as the program would run without it on a hypothetical version of your operating system which had no restrictions on writing to memory.
It doesn't matter what happens after the program's image in memory is zeroed; you don't have control over that anyway.
In cases where it matters (e.g. C programs loaded from disk lazily by the MMU), we care about the logical addresses which hold the program's image, not the physical addresses. In particular, you're allowed to unmap part of the program and remap zeroes over it, so long as (obviously) that part of the program isn't running at the time. However, to avoid degenerate solutions, you are not allowed to atomically remap a section of memory; when remapping memory, it must spend some nonzero period of time unmapped in between.
You only need to zero the executable portions of your program's image (plus the 31 arbitrary bytes that prevent degenerate solutions). Note that this is based on what actually gets executed, not based on what the program claims will get executed, i.e. if you send the instruction pointer to an unusual place like the data segment or the stack, you'll have to zero that place too.
The previous restriction also applies to library functions, and the like; if you execute those, and doing so causes the library function to be interpreted (by an interpreter or by the operating system) in the same way as your program itself, you're going to have to zero its memory image too. It's not interesting or fun to just call a memset equivalent to set your program's entire memory image to zero, and have it work because the instruction pointer is inside memset at the time rather than inside the original program.
The 31 arbitrary bytes only need to be unread while the program's actually running. If your language has some sort of bytecode verification step (which would reject arbitrary bytes in the memory image), feel free to choose the values of the bytes as something that would pass verification, so long as the values could subsequently be changed without affecting the operation of the program in any way. (You also don't need to write the program's source code in such a way that it'd allow arbitrary values for the bytes; you can assume someone edits them on disk or in memory after any compilation, parsing, etc. stages have already happened.)
A few interpreters (mostly for concatenative languages, because this clearly doesn't work in languages that have loop constructs) naturally delete the program's image as it runs. Those aren't eligible for this challenge.

Victory condition
This is at least partly a challenge to see how many languages something like this is possible in; feel free to try to solve it using a language that hasn't been used yet, or to find a new way to accomplish this task. However, to promote competition and give some objective way to compare similar solutions, victory for this challenge is based on the common "shorter (in bytes) is better" rule, making this code-golf. You can measure the byte count of either your program's memory image, or your program's source code, although make sure you correctly label what's being counted in the post title (e.g. a source code submission would look like "C" or "Perl", whereas an image submission would look more like "x86_64 machine code" or "Perl bytecode").

If you're looking for a challenge about deleting the executable from disk (rather than the image of the executable from memory), that's this one. If you're looking for the Sandbox post (and can see deleted posts), that's here.

Are you sure this is so difficult? Typical modern processors have an instruction cache, so the new overwritten version of the memory need not be used by the processor.

@feersum: Unfortunately there's not much I can do to shut down that sort of thing. However, the modern processors I've worked with also flush the instruction cache if the memory image they're executing from gets modified (so although there's a cache, it's not usable for this sort of challenge); it wouldn't surprise me if there were some that don't, but identifying them should be at least a little nontrivial. The challenge would still remain open and competitive for interpreted languages, which rarely do that sort of caching.

So.. Delete itself from the RAM?

@SIGSEGV: Yes, that's the idea. Specifically, the part of RAM which is actually being used to remember what the program is.

"Unless the interpreter/runtime is rereading the program from disk as it executes every command, which would be a very unusual design" -- Windows Batch does this and "unusual" is the least profanity-ridden way in which this feature has been described.

I'm not even sure if I can disable W^X on OSX, it seems mandatory since 10.8. SIP is waay higher level than this. It makes sense that this can't be changed because I can't see a single reason why applications should be able to arbitrarily modify their own instruction memory

@Sirens: Some searching indicates that the mprotect function can turn it off for a region of memory on at least some versions of OSX. My sources were fairly old, though, so it's possible that this has changed since.

@ais523 mprotect doesn't work anymore at least on my client

Can i use direct run from read-only memory? For example in MCU with harvard architecture. Instruction memory is read-only, and data memory is zero-filled by default

authors: Евгений Новиков


text:
Generating a soccer team!
Generate the following soccer team ASCII art with the least number of bytes possible.
   |.|      |.|      |.|      |.|      |.|      |.|      |.|      |.|
   ]^[      ]^[      ]^[      ]^[      ]^[      ]^[      ]^[      ]^[
 /~`-'~\  /~`-'~\  /~`-'~\  /~`-'~\  /~`-'~\  /~`-'~\  /~`-'~\  /~`-'~\
{<| 8 |>}{<| 6 |>}{<| 1 |>}{<| 3 |>}{<| 7 |>}{<| 5 |>}{<| 4 |>}{<| 2 |>}
 \|___|/  \|___|/  \|___|/  \|___|/  \|___|/  \|___|/  \|___|/  \|___|/
  /   \    /   \    /   \    /   \    /   \    /   \    /   \    /   \
 /__|__\  /__|__\  /__|__\  /__|__\  /__|__\  /__|__\  /__|__\  /__|__\
 | / \ |  | / \ |  | / \ |  | / \ |  | / \ |  | / \ |  | / \ |  | / \ |
 (/   \)  (/   \)  (/   \)  (/   \)  (/   \)  (/   \)  (/   \)  (/   \)
 |)   (|  |)   (|  |)   (|  |)   (|  |)   (|  |)   (|  |)   (|  |)   (|
(.|,.,|,)(,|,.,|.)(.|,.,|,)(,|,.,|.)(.|,.,|,)(,|,.,|.)(.|,.,|,)(,|,.,|.)

Note that the players' feet alternate between (.|,.,|,) and its mirror, but their eyes all point the same direction `-'.
Score
Least number of bytes wins!
Rules

Standard loop holes apply
Any amount of trailing/leading white space legal.

Well, there isn't only 8 players in a soccer team, but...

Are leading spaces allowed?

@lacchus also most soccer players have two eyes, not one. I guess they look surprised.

Actually it's pretty cool to change the facial characters. You can get all kinds of expressions

This comma/dot alternation on left/right feet ruins my plans ... O_o

I thought there were 11 players, but whatever.

The alternating feet are well-camouflaged, a bit like a chameleon (challenge).

@lacchus, they might have red cards in soccer ;)

There are 11 players per FOOTBALL team, yes (someone had to mention it).

how many bytes it's in bubblegum?

How are the eyes `-' lol?

@carusocomputing I was wondering that at first too.  I think those symbols are supposed to be the top of their jerseys, indicating they are looking to the left (our right).  That being said, the period is their sole eye |.|

Charcoal, 106 95 92 91 79 77 bytes
”∨+!rþW∕oc	σ<7↗OKd↶!(⊞”«5βＧ◨“Ｏc∕)ÿ6T”‖Ｂ←→→→,Ｆ³‖ＭＪ⁹¦³Ｆ6137542«ιＭ⁸→»↑Ｆ⁸«Ｍ⁸←←'

Try it online! Edit: Saved 11 bytes by looping over the shirt numbers. Saved 3 bytes by working out how Ｊ worked. Saved a further byte by using separate mirror instructions. Saved 12 bytes thanks to @ASCII-only by compressing the half player string. Saved 2 bytes by repeating the mirror in a loop. Explanation:
”∨+!rþW∕oc	σ<7↗OKd↶!(⊞”«5βＧ◨“Ｏc∕)ÿ6T”
            Print the right half of a player as a compressed string
‖Ｂ←         Butterfly to create the left half of the player
→→→,        Fix up the left foot
Ｆ³‖Ｍ        Mirror three times to end up with 8 footballers
Ｊ⁹¦³Ｆ6137542«ιＭ⁸→»↑
            Fix up the shirt numbers
Ｆ⁸«Ｍ⁸←←'    Fix up the right eyes

Edit: The above code no longer works in current Charcoal; the string compression appears to have changed and the reflect command now accepts a multidirection and leaves the cursor in a different position. However it's possible to adapt the code to run in current charcoal for the same byte count. Try it online! Link is to verbose version of code. (Note that the deverbosifier tries to compress 6137542 for some reason although it's unnecessary.) It then becomes possible to golf a further byte off. Try it online! Link is to verbose version of code.

charcoal can beat SOGL with compression: 78 bytes, how to generate - copy+paste, -sl is only to show length, that can be left out

@ASCII-only Thanks, although you accidentally lost the last ', but fortunately I spotted the mistake before saving the edit.

Brainf**k, 855 852 bytes
That's too long...
+++++[>++++++>+++++++++>+++++++++>>+++++[<+++++>-]>++<<<<<<-]>++>+>+>-<<<<++++++++[>...>>>.<.>.<<<...<-]>>>>>>.<<<<[>>>++<<<-]++++++++[<...>>>>+.+.---.+<<<<...>-]>>>>.<<++<<++++++++[<.>>+.>.>++++.----<<--.------.+++++++>.>.<<<<.>-]>>>>.<<<<+++++[>+++<-]<[>+<-]>>>>>>>+++++++[<+++++++>-]<+[>+>+>+>+>+>+>+>+<<<<<<<<-]>++++++>++++>->+>+++++>+++>++<<<<<<<<<<<<<++++++++[>>>---.<-.>+.<<.>>>>>>.[-]<<[>+<-]<[>+<-]<[>+<-]<[>+<-]<[>+<-]<[>+<-]>>.>>.<++.->+.+<<<-]>>>>>.<<--<--------------<<++++++++[>.>>>.<.>+++...---<.<.<.<-]>>>>>.<<<<<++++++++[>..>.<...>>>.<<<..<-]>>>>>.<<<<<++++++++[>.>.>>+++..<.>..---.<<<.<-]>>>>>.<<<<<++++++++[>.>>.<<.>.<.>>>.<<<.>>.<<.<-]>>>>>.<<<<<++++++++[>.>-------.+++++++.<...>>>.<<------.++++++<.<-]>>>>>.<<<<<++++++++[>.>>.<------.<...>-.+++++++>.<<.<-]>>>>>.<<<-<++++++++<++++[>.>.>.<--.++.--.>.<.<+.-.>.>.<.++.--.>.<++.<+.-<-]

Explanation:
+++++[
    >++++++ AT CELL1
    >+++++++++ AT CELL2
    >+++++++++ AT CELL3
    >>+++++[ AT CELL5
        <+++++>-
    ] CELL4 = 25
    >++ AT CELL6
    <<<<<<-
]
>++ CELL1 = 32
>+ CELL2 = 46
>+ CELL3 = 46
>- CELL4 = 124
CELL5 = 0
CELL6 = 10
<<<< AT CELL0
++++++++[
    >...>>>.<.>.<<<...<- PRINT FIRST LINE*8
]
>>>>>>. AT CELL6
<<<<[ AT CELL2
    >>>++<<<-
]
CELL2 = 0
CELL3 = 46
CELL4 = 124
CELL5 = 92
++++++++[ AT CELL2
    <...>>>>+.+.---.+<<<<...>- PRINT SECOND LINE*8
]
>>>>. AT CELL6
NOW PRINT 47 126 96 45 39 126 92
<<++ CELL4 = 126
<< AT CELL2
++++++++[
    <.>>+.>.>++++.----<<--.------.+++++++>.>.<<<<.>- PRINT THIRD LINE*8
]
>>>>. AT CELL6
NOW PRINT 123 60 124 32 NUMBER 32 124 62 125
CELL3 = 46
<<<<+++++ AT CELL2
[
    >+++<-
]
CELL2 = 0
<[>+<-]>
CELL2 = 32
CELL3 = 61
CELL4 = 126
CELL5 = 92
>>>>> AT CELL7
> AT CELL8
+++++++[
    <+++++++>-
]
AT CELL8
<+ CELL7 = 50
[>+>+>+>+>+>+>+>+<<<<<<<<-]
CELL7 = 0
CELL 8 9 10 11 12 13 14 15 = 50
>++++++>++++>->+>+++++>+++>++<<<<<<<
AT CELL7
<<<<<<
AT CELL1
CELL2 = 32
CELL3 = 61
CELL4 = 126
CELL5 = 92
++++++++[
    PRINT 123 60 124 32 NUMBER 32 124 62 125
    >>>---. AT CELL4
    <-. AT CELL 3
    >+. AT CELL4
    <<. AT CELL2
    PRINT 56 54 49 51 55 53 52 50
    EACH TIME MOVES CELL2 TO CELL5
    >>>>>>.
    [-] CLEAR CELL8
    <
    <[>+<-] CELL6 TO CELL7
    <[>+<-] CELL5 TO CELL6
    <[>+<-] CELL4 TO CELL5
    <[>+<-] CELL3 TO CELL4
    <[>+<-] CELL2 TO CELL3
    <[>+<-] CELL1 TO CELL2
    AT CELL1
    CELL3 = 32
    CELL4 = 61
    CELL5 = 126
    CELL6 = 92
    >>.>>.<++.->+.+<<<-
]
AT CELL9
CELL9 = 0
CELL10 = 32
CELL11 = 61
CELL12 = 126
CELL13 = 92
CELL14 = 10
>>>>>.
<<
--
CELL12 = 124
<
--------------
CELL11 = 47
<<++++++++[ AT CELL9
    PRINT 32 92 124 95 95 95 124 47 32
    >.>>>.<.>+++...---<.<.<.<-
]
>>>>>.
<<<<<++++++++[
    PRINT 32 32 47 32 32 32 92 32 32
    >..>.<...>>>.<<<..<-
]
>>>>>.
<<<<<++++++++[
    PRINT 32 47 95 95 124 95 95 92 32
    >.>.>>+++..<.>..---.<<<.<-
]
>>>>>.
<<<<<++++++++[
    PRINT 32 124 32 47 32 92 32 124 32
    >.>>.<<.>.<.>>>.<<<.>>.<<.<-
]
>>>>>.
<<<<<++++++++[
    PRINT 32 40 47 32 32 32 92 41 32
    >.>-------.+++++++.<...>>>.<<------.++++++<.<-
]
>>>>>.
<<<<<++++++++[
    PRINT 32 124 41 32 32 32 40 124 32
    >.>>.<------.<...>-.+++++++>.<<.<-
]
>>>>>.
<<<-
<++++++++
CELL10 = 40
CELL11 = 46
CELL12 = 124
<++++[
    PRINT 40 46 124 44 46 44 124 44 41
    >.>.>.<--.++.--.>.<.<+.
    PRINT 40 44 124 44 46 44 124 46 41
    -.>.>.<.++.--.>.<++.<+.-<-
]

You have some leftover *s which add 3 bytes, so your bytes right now should be 852.   2. You can replace [-] with ,, because some interpreter out there on no more input outputs 0x00

V, 127 bytes
i³ |.|
³ ]^[
 /~`-'~\
 \|³_|/
  /³ \
 /__|__\
 | / \ |
 (/³_\)
 |)³_(|  8ä{3Go86137542Ó./{<| & |>}
Gï2i(.|,.,|,)hr.%lr,|4ä$

Try it online!
As usual, here is a hexdump:
00000000: 69b3 207c 2e7c 0ab3 205d 5e5b 0a20 2f7e  i. |.|.. ]^[. /~
00000010: 602d 277e 5c0a 205c 7cb3 5f7c 2f0a 2020  `-'~\. \|._|/.
00000020: 2fb3 205c 0a20 2f5f 5f7c 5f5f 5c0a 207c  /. \. /__|__\. |
00000030: 202f 205c 207c 0a20 282f b35f 5c29 0a20   / \ |. (/._\).
00000040: 7c29 b35f 287c 2020 1b38 e416 7b33 476f  |)._(|  .8..{3Go
00000050: 3836 3133 3735 3432 1bd3 2e2f 7b3c 7c20  86137542.../{<|
00000060: 2620 7c3e 7d0a 47ef 3269 282e 7c2c 2e2c  & |>}.G.2i(.|,.,
00000070: 7c2c 291b 6872 2e25 6c72 2c7c 34e4 24    |,).hr.%lr,|4.$

JavaScript (ES6), 196 194 214 210 204 bytes
Early morning golf on my phone again, so there's room for improvement.
Had to sacrifice a few bytes fixing the feet which I didn't notice were alternating.
_=>`   |.|
   ]^[
 /~\`-'~\\
{<| 0 |>}
 \\|___|/
  /   \\
 /__|__\\
 | / \\ |
 (/   \\)
 |)   (|
(1|,.,|2)`.replace(/.+/g,x=>x.repeat(8)).replace(/\d/g,x=>`,.86137542`[x--?(z+=x)%2:++z],z=1)

Try it

o.innerText=(

_=>`   |.|
   ]^[
 /~\`-'~\\
{<| 0 |>}
 \\|___|/
  /   \\
 /__|__\\
 | / \\ |
 (/   \\)
 |)   (|
(1|,.,|2)`.replace(/.+/g,x=>x.repeat(8)).replace(/\d/g,x=>`,.86137542`[x--?(z+=x)%2:++z],z=1)

)()

(Outdated) Explanation
We start with a string containing the characters for a single player with each line separated by an n, a 0 as the placeholder for the number and with 1 & 2 used as placeholders for the punctuation marks in the alternating feet.
We split the string to an array of the individual lines on n, map over that array replacing each element with itself repeated 8 time and then join the array to a string using a literal newline.
Finally, we replace each number in the string with either the required player number if the number is 0 or the necessary character to complete the player's feet if the number is 1 or 2.

SOGL, 92 88 87 85 bytes
T◄ηψΚc∆╗*≥ζ≠/βW;θ/8ž⅔┌*lη.7¾η┐ø┘<ΟpC1ΧB‘-”ο⁸z╗≠#▲ķOjξ³Y3²‘čŗ9n8*č x"⁴⁾Jχ“r"}▓v#Χ⁶‘+čŗ

Explanation:
...‘                               push a compressed version of a soccer player
    -”                             push "-"
      ...‘č                        push ".]^[/~`-'~\\{<x>}" chopped into an array
           ŗ                       replace [in the player, "-", with each corresponding character]
            9n                     split into an array with each line with the length 9
              8*                   multiply 8 times horizonally
                č                  join into a multi-line string
                  x                push "x"
                   "...“r          push 86137542 converted to string
                         "...‘+    append to that ".,,..,,..,,..,,."
                               č   chop into an array of the chars
                                ŗ  replace [in the multi-line string, "x", with corresponding chars from "86137542.,,..,,..,,..,,."]

The compressed string is
   |-|      ---    ------- --| - |-- \\|___|/   /   \\   /__|__\\  | / \\ |  (/   \\)  |)   (| (x|,.,|x)

with dashes (because those could be compressed with boxstrings) in place of uncommon chars, which then get replaced and then split in lines to get
   |.|
   ]^[
 /~`-'~\
{<| x |>}
 \|___|/
  /   \
 /__|__\
 | / \ |
 (/   \)
 |)   (|
(x|,.,|x)

Java, 391 444 bytes
EDIT: Truly fixed. God, that really made the size go up
class a{static void l(String s){for(int i=0;i<8;i++)System.out.print(s);System.out.println();}static void q(){int[] a={8,6,1,3,7,5,4,2};l("   |.|   ");l("   |.|   ");l("   ]^[   ");l(" /~`-'~\\ ");for(int i:a)System.out.print("{<| "+i+" |>}");System.out.println();l(" \\|___|/ ");l("  /   \\  ");l(" /__|__\\ ");l(" | / \\ | ");l(" |)   (| ");for(int i=0;i<8;i++)if(i%2==1)System.out.print("(,|,.,|.)");else System.out.print("(.|,.,|,)");}}

Expanded
class a
{
    static void l(String s)
    {
    for(int i=0;i<8;i++)
        System.out.print(s);
    System.out.println();
    }
    static void q()
    {
        int[] a={8,6,1,3,7,5,4,2};
        l("   |.|   ");
        l("   |.|   ");
        l("   ]^[   ");
        l(" /~`-'~\\ ");
        for(int i:a)
            System.out.print("{<| "+i+" |>}");
        System.out.println();
        l(" \\|___|/ ");
        l("  /   \\  ");
        l(" /__|__\\ ");
        l(" | / \\ | ");
        l(" |)   (| ");
        for(int i=0;i<8;i++)
            if(i%2==1)
                System.out.print("(,|,.,|.)");
            else
                System.out.print("(.|,.,|,)");
    }
}

I don't think this answer prints the feet correctly.

It still looks wrong to me from code inspection. (Note that the feet alternate for each footballer.)

i%2>0 saves a byte, maybe even i++%2>0 works. Anyway the condition can be put into a ternary inside the print(...). Creating the array in the loop header should also save one or two bytes. I'm not quite sure but I think there is some whitespace missing in the last line of the legs...

There are lots of bytes to save: class B{int i;void p(String s){System.out.print(s);}void e(String s){for(i=8;i-->0;)p(s);p("\n");}void a(){e("   |.|   ");e("   ]^[   ");e(" /~\-'~\ ");for(int i:new int[]{8,6,1,3,7,5,4,2})p("{<| " + i + " |>}");p("\n");e(" \||/ ");e("  /   \  ");e(" /|_\ ");e(" | / \ | ");e(" (/   \) ");e(" |)   (| ");for(i=8;i-->0;)p(i%2<1?"(,|,.,|.)":"(.|,.,|,)");}}` "only" 366 bytes. Be careful of copy/pastes: SE software adds a few characters to split the chain. Remarks: fixed the legs, head, etc.

@OlivierGrégoire The class B{...} can be removed as well (which is also pretty pointless without a main-method). Also, you can further golf down the code in your comment by changing void p(String s){System.out.print(s);} to <T>void p(T x){System.out.print(x);}.

@KevinCruijssen I was merely scratching the surface with this. I haven't applied all my usual rules yet, but only the obvious ones. The OP says "generate", we could then even return a String instead of printing. All in all, I wouldn't be surprised if we could go as low as 325 bytes with Java.

05AB1E, 126 124 108 106 110 bytes
Thanks to Emigna for saving 7 bytes!
•5n¯в•vð3×Ðy"|.|
]^[
/~`-'~\
{<| ÿ |>}
\|___|/
/ÿ\
/__|__\
| / \ |
(/ÿ\)
|)ÿ(|".C.B})øJ»"(.|,.,|,)"Â„()Â‡«4×»

Uses the 05AB1E encoding. Try it online!

This answer does not print the feet correctly.

@Neil That is now fixed.

Ruby, 161
puts"|.|+]^[+/~`-'~\\+{<| %d |>}+\\|___|/+/   \\+/__|__\\+| / \\ |+(/   \\)+|)   (|+(.|,.,|,)(,|,.,|.)".split(?+).map{|i|(i.center(9)*8%[8,6,1,3,7,5,4,2])[0,72]}

Now with alternating feet. Internally it generates 8 double sets of feet (total 16). Some of these are then removed by truncating to 72 characters per line.
Ruby, 144
puts"|.|+]^[+/~`-'~\\+{<| %d |>}+\\|___|/+/   \\+/__|__\\+| / \\ |+(/   \\)+|)   (|+(.|,.,|,)".split(?+).map{|i|i.center(9)*8%[8,6,1,3,7,5,4,2]}

Fairly simple, prints line by line, 8 partial footballers at a time and uses the % operator (like sprintf) to substitute the shirt numbers (when the string does not contain %d they are ignored.)

I don't think this answer prints the feet correctly.

@Neil fixed. The alternating feet were very subtle, you should have pointed them out in the spec.

Different Neil, sorry.

Python 2.7, 179 bytes
print"\n".join(s*8for s in"   |.|   *   ]^[   * /~`-'~\ *{<| %s |>}* \|___|/ *  /   \  * /__|__\ * | / \ | * (/   \) * |)   (| *(%s|,.,|%s)".split("*"))%tuple("86137942"+".,,."*4)

Encode one player as a single string with out-of-band characters to let us split it into a list, so that we can then multiply each layer by 8 and finally insert the required numbers and punctuations into the output.

JavaScript (ES6), 198 197 bytes
Includes a leading line break.
f=(x=792)=>x--?f(x)+(x%72?'':`
`)+`   |.|      ]^[    /~\`-'~\\ {<| ${"75428613"[x%8]} |>} \\|___|/   /   \\   /__|__\\  | / \\ |  (/   \\)  |)   (| (${x&1?".|,.,|,":",|,.,|."})`[9*(x/9>>3)+x%9]:''

Demo

f=(x=792)=>x--?f(x)+(x%72?'':`
`)+`   |.|      ]^[    /~\`-'~\\ {<| ${"75428613"[x%8]} |>} \\|___|/   /   \\   /__|__\\  | / \\ |  (/   \\)  |)   (| (${x&1?".|,.,|,":",|,.,|."})`[9*(x/9>>3)+x%9]:''

o.innerHTML = f()

Python 2, 207 197 186 201 bytes
b=[x*8for x in"   |.|   #   ]^[   # /~`-'~\ ## \|___|/ #  /   \  # /__|__\ # | / \ | # (/   \) # |)   (| ".split("#")]+["(.|,.,|,)(,|,.,|.)"*4]
for y in'86137542':b[3]+='{<| %s |>}'%y
print'\n'.join(b)

Try it online!
Nothing very clever and way too long at 207 197 but as far as I can see, at least it prints the feet correctly.
Edit A bit better at 186
Edit 2 Back to over 200 after spotting why the feet were not in fact right. Well hidden gotcha!

PHP, 204 Bytes
<?=gzinflate(base64_decode(pdDLDcMwCAbgO1P8t9qS66jpIzlUWSRu6B6lmb3giAWKJawPDggAIFXQXwSk8drWoxQBYdjf59PeEAR9noIZsnwND8fFcXVMjrvj5hgNhCbMLAOC0BtphmbLhqA30obMtm0IBNGeTf8gCKnPlhGETqQZkvUOgVKVUouUnEpHzf9Vfg));

Try it online!
PHP, 205 Bytes
for(;$i++<11;)for($p=print"
";$c=_86137542[$p++];)echo str_pad(["|.|","]^[","/~`-'~\\","{<| $c |>}","\|___|/","/   \\","/__|__\\","| / \ |","(/   \)","|)   (|",$p&1?"(,|,.,|.)":"(.|,.,|,)"][$i-1],9," ",2);

Try it online!
PHP, 211 Bytes
for(;$i<11;)echo($p=str_pad)("
",73,$p(["|.|","]^[","/~`-'~\\","{<| ".join(" |>}{<| ",[8,6,1,3,7,5,4,2])." |>}","\|___|/","/   \\","/__|__\\","| / \ |","(/   \)","|)   (|","(.|,.,|,)(,|,.,|.)"][+$i++],9," ",2));

Try it online!

You forgot the alternating feet. And [+$i] needs no +.

You can save one more byte with a leading instead of a trailing newline: for(;$y++<11;)for($p=print"\n";$n=_86137542[$p++];) and [$y-1]

@Titus done thank you. An Array needs a +

206-1 bytes: for(;$y++<11;)for($p=print"\n";$n=_86137542[$p++];)echo str_pad(["|.|","]^[","/~``-'~\\","{<| $n |>}","\|___|/","/   \\","/__|__\\","| / \ |","(/   \)","|)   (|",$p&1?"(,|,.,|.)":"(.|,.,|,)"][$y-1],9," ",2); ;)

Oh right ... I tried foreach; that´s why I needed no +.

@Titus the ternary operator helps to save bytes Thank you

C#, 420 bytes
Golf:
using System;using static System.Console;class Z{static void Main(){int[]a={8,6,1,3,7,6,4,2};int i=0;X("   |.|   ");X("   ]^[   ");X(" /~`-'~\\ ");for(i=0;i<8;i++)Write("{<| "+a[i]+" |>}");WriteLine();X(" \\|___|/ ");X("  /   \\  ");X(" /__|__\\ ");X(" | / \\ | ");X(" (/   \\) ");X(" |)   (| ");for(i=0;i<8;i++)Write((i%2==0)?"(.|,.,|,)":"(,|,.,|.)");}static void X(String s){for(int i=0;i<8;i++)Write(s);WriteLine();}}

Expanded:
using System;
using static System.Console;
class Z
{
    static void Main()
    {
        int[]a={8,6,1,3,7,6,4,2};
        int i=0;
        X("   |.|   ");
        X("   ]^[   ");
        X(" /~`-'~\\ ");
        for(i=0;i<8;i++)
            Write("{<| "+a[i]+" |>}");
        WriteLine();
        X(" \\|___|/ ");
        X("  /   \\  ");
        X(" /__|__\\ ");
        X(" | / \\ | ");
        X(" (/   \\) ");
        X(" |)   (| ");
        for(i=0;i<8;i++)
            Write((i%2==0)?"(.|,.,|,)":"(,|,.,|.)");
    }
    static void X(String s)
    {
        for(int i=0;i<8;i++)
            Write(s);
        WriteLine();
    }
}

Inspired by Jesse M's Java answer, with a few edits to make it shorter

You can save 5 bytes with i%2 instead of (i%2==0) and reversing the ?: parts. Also I think Write(" {0} ",s); and trim the white space from the X() calls would save another 10 bytes.

I doubt that C# accept 0 as false

@hucancode The only truthy/falsey values in C# are booleans.

You can save bytes by removing the X method and just looping, I believe at least. You could compile to an Action<string> to remove the fluff. That would mean you return a string and don't have to write it out removing the need to the Console. You can remove the using System as that is only needed for String where you can use string instead. There are multiple other improvements as well. I'm sorry but it doesn't really look like you attempted to golf this much at all.

@TheLethalCoder Its my first code golf sorry mate

Ook!, 8519 bytes
Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook! Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook! Ook. Ook! Ook. Ook! Ook. Ook. Ook? Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook? Ook. Ook! Ook! Ook? Ook!

I had to.
Port of tony200910041's brainf**k answer

I downvoted because you either: 1) put this through a converter taking zero effort or 2) had an oversight and took actual effort doing this.

@DestructibleLemon I kinda disagree. It is indeed likely this has been put through a converter for zero effort, but it's a valid answer nonetheless. I wouldn't upvote it, but downvoting it because it was generated doesn't make the answer less valid. Besides, ports or generated answers are posted all the time. Usually Dennis, MartinEnder, etc. creates an original and short method, and almost everyone changes their original answer to a port of that, because it's just shorter. Also, reason 2 is an even worse reason to downvote.. Perhaps (s)he wrote his own converter, which still took effort.

I did, in fact, write my own converter. Not that that takes a huge amount of effort.

I never said it was invalid. but the answer is just someone else's golf, trivially converted

For a weird language like this, who would actually write program using it? He just want to have some funny, non-competing program. You are a little strict here @DestructibleLemon.

Mathematica 282 bytes
d={"   |.|   ","   ]^[   "," /~`-'~\\ ",StringRiffle[{8,6,1,3,7,5,4,2},{"{<| "," |>}{<| "," |>}"}]
," \\|___|/ ","  /   \\  "," /__|__\\ "," | / \\ | "," (/   \\) "," |)   (| ", "(.|,.,|,)"};f[x_, y_] :=Table[Row@Table[d[[i]],8],{i,x,y}];Column@Flatten@Join[{f[1,3],d[[4]],f[5,11]}]

Retina, 270 bytes

A |.|AKKKKKKK ¶A ]^[AJJJJJJJ NEEEEEEEE¶{<| 8H6H1H3H7H5H4H2 |>} N\|___|/GGGGGGG ¶MMMM NDDDDDDDDNCCCCCCCCNLLLLN|)A (|IIIIIII ¶BBBB
N
¶
M
AFAAFA
L
(F)A(F)A
K
AA|.|A
J
AA]^[A
I
A|)A (|
H
 |>}{<|
G
A\|___|/
F
/A \
E
/~`-'~\A
D
/__|__\A
C
| / \ |A
B
(.|,.,|,)(,|,.,|.)
A

Try it online!

Bubblegum, 130 117 bytes
00000000: a4c6 bb0d 4231 0c86 d1de 537c 1d89 1412  ....B1....S|....
00000010: f1a6 402c 42c0 ecc1 cf9d 1d5d 244f e053  ..@,B......]$O.S
00000020: 1d40 5d40 3206 3c5f 0f20 1963 2cef ed66  .@]@2.<_. .c,..f
00000030: 9964 639f 9bb8 a2fb 77cd 39b2 8b1c 2297  .dc.....w.9...".
00000040: c829 728c ecd7 604c b9bb 06c9 180c 6042  .)r...`L......`B
00000050: 36c6 7097 fb24 1b43 0c26 221b a30c 6056  6.p..$.C.&"...`V
00000060: b231 5481 2292 b1d2 d57a 53ab a5fd d3eb  .1T."....zS.....
00000070: 6fe4 8900 00                             o....

Try it online!

Perl 5, 206 bytes
say$_ x 8 for'   |.|   ','   ]^[   ', " /~`-'~\\ ";print"{<| $_ |>}"for 8,6,1,3,7,5,4,2;say;say$_ x 8 for' \\|___|/ ','  /   \\  ',' /__|__\ ',' | / \\ | ',' (/   \\) ',' |)   (| ';say'(.|,.,|,)(,|,.,|.)'x4

Try it online!
It's ugly and brute force, but it works.

Deadfish~, 4964 bytes
{i}cc{ii}iiccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddcccccc{{i}d}iic{{d}ii}iic{{i}dd}ddc{{d}i}ddccc{dd}ddc{ii}iiccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}icccccc{iiiiii}icicdddc{dddddd}iccc{dd}ddc{ii}iic{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{i}iiiiic{{i}dd}dc{ddd}c{ddddd}dcddddddc{{i}d}dddc{ddd}ddddc{dddddd}cc{dd}ddc{{i}}{i}iiic{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}iiiic{dd}ddddc{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}iic{dd}ddc{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}dddc{dd}iiic{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}dc{dd}ic{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}iiic{dd}dddc{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}ic{dd}dc{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}c{dd}c{{i}d}iic{dddddd}ddc{iiiiii}iiicddc{dddddd}dddc{iiiiii}iiiic{{d}i}ddc{ii}ddc{dd}iic{{i}d}iic{dddddd}ddc{iiiiii}iiic{{d}i}dddc{dd}ddc{ii}iic{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddcc{iiiiii}c{iii}iic{ddd}iccc{iii}dc{{d}ii}iiic{d}dddddc{dd}ddc{ii}iicc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}cccc{i}iiiiic{d}dddddccc{iiiiii}c{dddddd}ccc{dd}ddc{ii}iic{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{i}iiiiic{iiiii}ddcc{iii}dc{ddd}iccdddc{dddddd}cc{dd}ddc{ii}iic{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{i}iiiiic{d}dddddc{iiiiii}c{dddddd}c{{i}d}iic{{d}i}ddcc{dd}ddc{ii}iic{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{i}ddc{i}dddc{d}dddddccc{iiiiii}c{ddddd}dc{d}icc{dd}ddc{ii}iic{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddcc{{i}d}iic{{d}ii}dddc{d}iccc{i}ddc{{i}dd}iiiic{{d}i}ddc{dd}ddc{iii}ciiiiiic{{i}dd}ddc{{d}ii}ciicddc{{i}dd}c{{d}ii}cdddcdciiiic{{i}dd}c{{d}ii}ciicddc{{i}dd}c{{d}ii}iicdddddcdciiiiiic{{i}dd}ddc{{d}ii}ciicddc{{i}dd}c{{d}ii}cdddcdciiiic{{i}dd}c{{d}ii}ciicddc{{i}dd}c{{d}ii}iicdddddcdciiiiiic{{i}dd}ddc{{d}ii}ciicddc{{i}dd}c{{d}ii}cdddcdciiiic{{i}dd}c{{d}ii}ciicddc{{i}dd}c{{d}ii}iicdddddcdciiiiiic{{i}dd}ddc{{d}ii}ciicddc{{i}dd}c{{d}ii}cdddcdciiiic{{i}dd}c{{d}ii}ciicddc{{i}dd}c{{d}ii}iicdddddc{ddd}dc

Try it online!
Wow, out-ungolfed everyone by 25x!