text:
Prime Factor Encoding
How the encoding works
Given a list of bits:

Hold a prime (starting with 2)
Have a list
For each bit in the input

If it's the same as the previous bit, add the prime you're holding to the list
If it's different, hold the next prime and add that to the list

Return the product of all the numbers in your list
For the first bit, assume the previous bit was 0

Note: these steps are for illustration purposes only, you are not required to follow them.

Examples
Input: 001
hold 2

0:         add 2 to the list
0:         add 2 to the list
1: hold 3, add 3 to the list

list: 2,2,3
Output: 12

Input: 1101
hold 2

1: hold 3, add 3 to the list
1:         add 3 to the list
0: hold 5, add 5 to the list
1: hold 7, add 7 to the list

list: 3,3,5,7
Output: 315

Some more examples:
000000000 -> 512
111111111 -> 19683
010101010 -> 223092870
101010101 -> 3234846615
011101101 -> 1891890
000101101010010000 -> 3847834029582062520

Challenge
Write an encoder and a decoder for this encoding method.
(The decoder reverses the process of the encoder).
Input / Output

The encoder can take input in any reasonable format
The encoder must output either an integer or a string
The decoder must take input in the same format that the encoder outputs
The decoder must output the same format that the encoder takes as input

In other words decoder( encoder( input ) ) === input
Notes

The decoder may assume that its input is decodable
Your answer only has to deal with integers that your language can natively support without using (long, bigInt, etc.), be reasonable, if you language only supports ints up to 1, maybe reconsider posting an answer

Scoring
Your score is the sum of the lengths in bytes of the encoder and decoder.
If you need to import a module, the import can be counted only once provided that your encoder and decoder can coexist in the same file and be reused (like functions).
Default loopholes are forbidden.
This is code-golf so the shortest score for every language wins.

Is that last example mandatory, or can we limit the output to up to 64 bits (2^63-1 / 9223372036854775808)?

@KevinCruijssen No, your answer only has to work for integers that your language can handle.

@KevinCruijssen *handle natively without libraries of bigints, i'll clarify

05AB1E, 13 bytes
Encoder, 8 bytes
0ì¥ĀηOØP

Try it online!
Explanation
0ì          # prepend 0 to input
  ¥         # calculate deltas
   Ā        # truthify each
    η       # calculate prefixes
     O      # sum each
      Ø     # get the prime at that index
       P    # product

Decoder, 5 bytes
Ò.ØÉJ

Try it online!
Explanation
Ò       # get prime factors of input
 .Ø     # get their indices among the primes
   É    # check for oddness
    J   # join

Jelly, 17 bytes
Encoder (10 bytes):
0;IA+\‘ÆNP

Try it online!
Decoder (7 bytes):
ÆEĖŒṙḂ¬

Try it online!
How?
Encoder:
0;IA+\‘ÆNP - Link: list of integers (1s and 0s)  e.g. [1,1,1,1,0]
0;         - prepend a zero                           [0,1,1,1,1,0]
  I        - incremental differences                  [1,0,0,0,-1]
   A       - absolute values                          [1,0,0,0,1]
    +\     - cumulative reduce with addition          [1,1,1,1,2]
      ‘    - increment each of the results            [2,2,2,2,3]
       ÆN  - get the nth prime for each result        [3,3,3,3,5]
         P - product of the list                      405

Decoder:
ÆEĖŒṙḂ¬ - Link: integer         e.g. 405
ÆE      - prime exponent array       [0,4,1] (representing 2^0*3^4*5^1)
  Ė     - enumerate                  [[1,0],[2,4],[3,1]]
   Œṙ   - run-length decode          [2,2,2,2,3]
     Ḃ  - bit (mod 2)                [0,0,0,0,1]
      ¬ - logical NOT                [1,1,1,1,0]

JavaScript (ES6), 130 bytes
I/O: array of bits ↔  integer
Encoder, 71 bytes
a=>a.map(p=k=>r*=(g=i=>n%--i?g(i):i<2?n:g(++n))(n+=p^(p=k)),r=1,n=2)&&r

Try it online!
Decoder, 59 bytes
D=(n,k=2,x=b=0)=>k>n?[]:n%k?D(n,k+1,1):[b^=x,...D(n/k,k,0)]

Try it online!

Python 2, 234 193 174 bytes
Encoder, 116 101 97 bytes:
Uses Wilson's theorem.
i=input()
P=n=x=r=1
while i:
 P*=n*n;n+=1
 if P%n:t=(i+[x]).index(x);i=i[t:];r*=n**t;x^=1
print r

Try it online!
Decoder, 118 92 77 bytes:
i=input()
r=[]
n=x=1
while~-i:
 n+=1;x^=i%n<1
 while i%n<1:r+=x,;i/=n
print r

Try it online!

Java 10, 209 bytes
Encoder, 124 bytes
s->{long p=48,P=2,r=1,n,i;for(int c:s.getBytes()){if(p!=(p=c))for(n=0;n<2;)for(n=++P,i=2;i<n;n=n%i++<1?0:n);r*=P;}return r;}

Try it online.
Explanation:
s->{                // Method with String parameter and long return-type
  long p=48,        //  Previous character, starting at '0'
       P=2,         //  Current prime, starting at 2
       r=1,         //  Result, starting at 1
       n,i;         //  Temp-integers
  for(int c:s.getBytes()){
                    //  Loop over the digits of the input-String as bytes
    if(p!=(p=c))    //   If the current and previous digits are different
      for(n=0;      //    Reset `n` to 0
          n<2;)     //    And loop as long as `n` is still 0 or 1
        for(n=++P,  //     Increase `P` by 1 first with `++P`, and set `n` to this new `P`
            i=2;i<n;n=n%i++<1?0:n);
                    //     Check of the current `n` is a prime
                    //     If it remains the same it's a prime, if it becomes 0 or 1 not
    r*=P;}          //   Multiply the result by the current prime `P`
  return r;}        //  Return the result

Decoder, 85 bytes
n->{var r="";for(long P=2,f=0,i=1;++i<=n;)for(;n%i<1;n/=P=i)r+=i!=P?f^=1:f;return r;}

Try it online.
Explanation:
n->{                // Method with long parameter and String return-type
  var r="";         //  Result-String, starting empty
  for(long P=2,     //  Current prime, starting at 2
      f=0,          //  Flag integer, starting at 0
      i=1;++i<=n;)  //  Loop `i` in the range [2,`n`]
    for(;n%i<1;     //   Inner loop over the prime factors of `n`
        n/=P=i)     //     After every iteration: divide `n` by `i`,
                    //     and set `P` to `i` at the same time
      r+=i!=P?      //    If `i` and `P` are not the same
          f^=1      //     Append the opposite of the flag `f` (0→1; 1→0)
         :          //    Else:
          f;        //     Append the flag `f`
  return r;}        //  Return the result

You can save 2 bytes by changing long to int.

Husk, 18 bytes
Encoder, 11 bytes
Πmo!İp→∫Ẋ≠Θ

Try it online!
Decoder, 7 bytes
mȯ¬%2ṗp

Try it online!
How they work
Encoder:

Πmo!İp→∫Ẋ≠Θ – Full program. Takes input from the first CLA, outputs to STDOUT.
          Θ – Prepend a default element (0 in this case).
        Ẋ≠  – Map over pairs of adjacent elements with ≠ (not equals). In Husk,
              some operators return other useful things than just boolean values.
              Here, ≠ returns the absolute difference between its two arguments.
       ∫    – Cumulative sums.
 mo         – Map the following function over the list of sums:
    İp        – Yield the infinite list of primes.
   !  →       – And index into it with the current sum incremented.
Π           – Take the product.

Decoder:
mȯ¬%2ṗp – Full program.
      p – Prime factorization.
mȯ      – Map the following function over the list of factors:
     ṗ    – Retrieve the index in  the list of primes.
   %2     – Modulo 2.
  ¬       – Logical NOT.

C (gcc), 180 184 bytes

Added four bytes so that output formats match.

102 bytes -- Encoder
p,r,i,m;e(char*_){for(m=0,p=1,i=2;*_;m=*_++-48,p*=i)if(*_-48-m)for(i++,r=2;r<i;i%r++||(r=2,i++));i=p;}

Try it online!
82 bytes -- Decoder
d(C){for(m=C%2,r=2+m,p=2;C>1;p++)if(C%p<1)p-r&&(m=!m,r=p),putchar(m+48),C/=p,p=1;}

Try it online!

@AsoneTuhid Sorry, misread.

@AsoneTuhid Now added a decoder. Hopefully compliant now.

@ovs True; thanks for your remark.

J, 34 bytes
Heavily inspired by Jonathan Allan's Jelly solution!
Encoder: 23 bytes
[:*/[:p:[:+/\2|@-~/\0,]

Try it online!
                    0,]  NB. prepend 0 to the input
             2  -~/\     NB. find the differences
              |@         NB. and their absolute values
        [:+/\            NB. running sums
    [:p:                 NB. n-th prime
[:*/                     NB. product

I don't like those many cap forks [: - it should be golfable.
Decoder: 11 bytes
2|[:_1&p:q:

Try it online!
        q:    NB. prime factorization
  [:_1&p:      NB. find the number of primes smaller than n
2|             NB. modulo 2

Jelly, 15 bytes
Encoder, 9 bytes
0;ŒgL€ÆẸH

Try it online!
Decoder, 6 bytes
Æf’ÆCḂ

Try it online!

Gol><>, 29 + 39 = 68 bytes
Encoder, 29 bytes
021IEh{$:}-Q$TP:SP?!t$|1k*3R!

Try it online!
Decoder, 39 bytes
02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

Try it online!
How these work
Encoder

021IEh{$:}-Q$TP:SP?!t$|1k*3R!

021                            Setup the stack as [last bit, current prime, current output]
   IEh                         Take input as int; if EOF, print top as number and halt
      {$:}-Q          |        If the next bit is different from the last bit...
            $                    Move the prime to the top
             T      t            Loop indefinitely...
              P:SP?!               Increment; if prime, skip `t` i.e. break
                     $           Move the prime to the correct position
                       1k*     Multiply the prime to the output
                          3R!  Skip 3 next commands (the init part)
                               Loop the entire program until EOF

---

Decoder

02I:MZ;:2k%:z}Q$TP:SP?!t$|1k,{{-z:N}3R!

02I                  Setup the stack as [last bit, current prime, encoded]
   :MZ;              If encoded == 1, halt
       :2k%          Compute encoded modulo prime
           :z}       Store NOT of the last at the bottom of the stack
              Q...|  Same as encoder's next-prime loop
1k,                  Divide encoded by prime (assume it is divisible)
   {{                Pull out the two bits at the bottom
     -z              Compute the next bit
       :N}           Print as number with newline, and move to the bottom
          3R!        Skip 3 init commands
                     Loop the entire program until finished

It'd be better if I could golf down the next-prime loop...


text:
??? Question Marks?
Challenge
Create a function that takes an string as a parameter. (Easy as far)
This string will contain

Single digit numbers
Letters from the alphabet
Question marks (Of course)

Your function will check if there are exactly 3 question marks between every pair of two numbers that add up to 10 or more. If so, then your function should return truthy, otherwise it should return  falsey.
If there are not any two numbers that add up to 10 or more in the string, your function should return false.
Rules

Input must be a string
Output must be truthy or falsey value
If string contains only one number or none return falsey
If string contains odd amount of single digits, ignore the last one (left to right)

Example
Given: "arrb6???4xxbl5???eee5"
Your function must output true because
there are exactly 3 question marks between 6 and 4, and 3 question marks between 5 and 5 at the end of the string

Given: "a4sd???9dst8?3r"
Your function must output false because there is just a single question mark between 8 and 3
Test Cases
Input: "aa6?9"
Output: false

Input: "acc?7??sss?3rr1??????5"
Output: true

Input: "sdty5???xcd8s3"
Output: true

Input: "sthfer5dfs"
Output: false

Update (Some clarification points)

Once you use a number to pair with other, you can not use it again.
You only can pair consecutive numbers (left to right). Example "as4f???6sda3?3d" the pairs are 4-6 and 3-3

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

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

The "Once you use a number to pair with other, you can not use it again." part is still not very clear. Perhaps you meant "only consider gaps at even indices", something like that.

Any reason why you special-cased the "1 number or none" case?

This question appears to be taken from here.

Yes it is @Laikoni

In that case, you should give attribution and make sure that you are not violating any copyright by posting the challenge here.

Under https://coderbyte.com/Terms/ you find "Don't Copy From Us. You agree not to copy, imitate, mirror, reproduce, distribute, publish, download, display, perform, post, store, or transmit any of Coderbyte's content, including without limitation any marks, in any form or by any means, including but not limited to electronic, mechanical, photocopying, recording, or otherwise. "

@Laikoni that doesn't apply for public challenges. I did not sigh any term and conditions

Python 3, 148 bytes
def f(a):q=[a.group(1).count("?")==3for a in re.finditer("(?=((\d+)\D+(\d+)))",a)if 10==sum(map(int,a.groups()[1:]))];return any(q)*all(q)
import re

Try it online!

Doesnt work with complex strings like arrb6???4xxbl5???eee5

@LuisfelipeDejesusMunoz sorry, had my condition backwards.

Python 2, 126 bytes
all*any idea is by @HyperNeutrino, checkout his answer
def f(n):r=[sum(map(int,g[0::2]))>9for g in re.findall('(\d)(.*?)(\d)',n)if 3==g[1].count('?')];return all(r)*any(r)
import re

Try it online!

Python 2, 125 bytes
Ouputs [] for false and [True] for true
def f(n):r=[sum(map(int,g[0::2]))>9for g in re.findall('(\d)(.*?)(\d)',n)if 3==g[1].count('?')];return r[:1]*all(r)
import re

Try it online!

source: Stack Exchange

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

sort: votes


text:
You must construct ASCII Pylons!
Cross posted from my anagolf post (note: may contain spoilers, post mortem).
Output the following text exactly.

You may have additional trailing whitespace on each line, and trailing newlines as well.
Shortest code, in bytes, wins.

                                              !"!
                                             "#$#"
                                            #$%&%$#
                                           $%&'('&%$
                                          %&'()*)('&%
                                         &'()*+,+*)('&
                                        '()*+,-.-,+*)('
                                       ()*+,-./0/.-,+*)(
                                      )*+,-./01210/.-,+*)
                                     *+,-./012343210/.-,+*
                                    +,-./0123456543210/.-,+
                                   ,-./01234567876543210/.-,
                                  -./0123456789:9876543210/.-
                                 ./0123456789:;<;:9876543210/.
                                /0123456789:;<=>=<;:9876543210/
                               0123456789:;<=>?@?>=<;:9876543210
                              123456789:;<=>?@ABA@?>=<;:987654321
                             23456789:;<=>?@ABCDCBA@?>=<;:98765432
                            3456789:;<=>?@ABCDEFEDCBA@?>=<;:9876543
                           456789:;<=>?@ABCDEFGHGFEDCBA@?>=<;:987654
                          56789:;<=>?@ABCDEFGHIJIHGFEDCBA@?>=<;:98765
                         6789:;<=>?@ABCDEFGHIJKLKJIHGFEDCBA@?>=<;:9876
                        789:;<=>?@ABCDEFGHIJKLMNMLKJIHGFEDCBA@?>=<;:987
                       89:;<=>?@ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA@?>=<;:98
                      9:;<=>?@ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA@?>=<;:9
                     :;<=>?@ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA@?>=<;:
                    ;<=>?@ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA@?>=<;
                   <=>?@ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA@?>=<
                  =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA@?>=
                 >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>
                ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?
               @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@
              ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA
             BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCB
            CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDC
           DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFED
          EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFE
         FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGF
        GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHG
       HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIH
      IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJI
     JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJ
    KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLK
   LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONML
  MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONM
 NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPON
OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPO

Is there an intentional first whitespace-only line?

@AdmBorkBork that's a space because that's the first ASCII char lol

@HyperNeutrino Oh, durr. lol

(note: may contain spoilers, post mortem). then don't click where the submissions are. :P

Plus points for the `_^ emoji.

@the4kman and the <=>=< fish.

Is an additional leading newline permitted? Can we output an array of lines? How about an array of character arrays?

Are leading spaces allowed? (equal amount of spaces on each line)

@Cowsquack Nope.

What about the additional leading newline I asked about?

@Shaggy I'm going to have to say no, I think.

Is there a reason this isn't titled "You Must Construct ASCII Pylons!"?

@mattdm I can change it, that's better haha

@mattdm I only came here from the HNQ list to upvote this because of its title. Nicely done.

I don't understand the title...

@EsolangingFruit It's a variation of a starcraft meme: You must construction additional pylons!

Canvas, 15 14 bytes
0ｃ［Ｃ²［ｊ｝¹ｍ］／││

Try it here!
Note that while making this I added a couple built-ins (ｃ & Ｃ) as Canvas somehow didn't have any built-ins for ASCII/unicode before...
Explanation (some characters have been replaced to look monospace):
0c              push the charcode of "0" - 48
  {       ]     map over 1..48
   C              push the ASCII characters
    ²[ ]          repeat by the counter (0-indexed)
      j             remove the last character
        ¹m        mold to the length of the counter
           /    pad each line with spaces so it looks like a diagonal
            ││  palindromize the whole thing horizontally

PowerShell, 73 bytes
' '*48;46..0|%{" "*$_+-join[char[]](($x=79-$_)..($y=$x+$j++)+(++$y)..$x)}

Try it online!
Outputs the first whitespace-only line, then loops from 46 to 0. Each iteration, outputs the corresponding number of spaces and then a -joined together char-array of the appropriate symbols, via some calculations.

Can you save some calculations by treating the first line as 47 spaces followed by a space character?

@Riking To do so, you'd need to special case how the char-array is created to only create one item instead of 3 or more. As a result, it's shorter to special case the spaces-only line completely separately.

Charcoal, 13 bytes
Ｅ⁴⁸⮌✂γι⊕⊗ι‖Ｏ←

Try it online! Link is to verbose version of code. Explanation:
 ⁴⁸             Literal 48
Ｅ               Map over implicit range
      ι  ι      Current index
        ⊗       Doubled
       ⊕        Incremented
     γ          Printable ASCII
    ✂           Slice
   ⮌            Reverse
                Implicitly print each slice on separate lines
          ‖Ｏ←   Reflect with overlap

The output seems wrong to me.

@Mr.Xcoder Ugh, classic off-by-1 error...

Python 2, 73 bytes
i=48
while i:i-=1;r=range(79-i,127-i*2);print' '*i+bytearray(r+r[-2::-1])

Try it online! Crossposted from anarchy golf (see my submission).
Quick post-mortem analysis: xnor and dianne discovered the exact same solution. ebicochneal submitted a 71 byte solution which mitchs improved to 70 bytes. They avoid dealing with bytearray (which is long) or ''.join(map(chr,…)) (which is even longer) entirely, by keeping a "current line" variable and cleverly updating it.

SOGL V0.12, 16 15 bytes
'½{ ~Δf⌡kFm}⁰¼╥

Try it Here!

Jelly, 17 bytes
48ḶḤr$z0ZUŒB+32ỌY

Try it online!

05AB1E, 16 bytes
48FžQNÝûN+èJ}).C

Try it online!

Ahhh... žQ was way better than žw79ŸvyžwN2*+ŸûçJ}).C

VBA, 71 bytes
An anonymous VBE immediate window function that takes no input and outputs to the console.
For i=0To 47:?Spc(47-i);:For j=-i To i:?Chr(32-Abs(j)+2*i);:Next:?:Next

Common Lisp, 110 bytes
(dotimes(i 48)(dotimes(j 96)(princ(if(>(abs(- j 48))i)" "(code-char(+(-(* i 2)(abs(- j 48)))32)))))(princ"
"))

Try it online!
Explanation
(dotimes(i 48)                   ;; for i from 0 up to 47
    (dotimes(j 96)               ;; for j from 0 up to 95
        (princ                   ;; print
            (if(>(abs(- j 48))i) ;; if abs(j - 48) > i
                " "              ;; print " "
                (code-char(+(-(* i 2)(abs(- j 48)))32)) ;; else print appropriate character
            )
        )
    )(princ"
") ;; print newline
)

Ruby, 70 bytes
s=[*?\s..?~]*'';48.times{|i|puts s[i,i+1].rjust(48)+s.reverse[-2*i,i]}

Try it online!
Constructs the full printable ASCII string and then prints the required number of forward (padded with spaces) + backward slices of it.

Jelly, 24 bytes
48RrḤ’$$ịØṖŒBṭ"48RU⁶ẋ$¤Y

Try it online!

C (gcc), 117 bytes
c;i;main(){for(i=0;i<48;++i){for(c=2*i-15;c<32+2*i;++c)putchar(c>31+i?c:32);for(;c>31+i;--c)putchar(c);putchar(10);}}

Try it online!
Ungolfed:
int ch;
int row;
int main(void) {
    for (row = 0; row < 48; ++row) {
        for (ch = 2*row-15; ch < 32 + 2*row; ++ch) {
            // The first character in the row is 2*row - 15 (row is zero-indexed)
            if (ch > 31+row)
                putchar(ch);
            else
                // If the current character is not in the pyramid, mask it with a space
                putchar(' ');
        }
        for (; ch > 31+row; --ch) {
            // Finish the other side of the pyramid
            putchar(ch);
        }
        putchar('\n');
    }
}

108 bytes

Perl 6, 55 53 bytes
say ' 'x 47-$_,chrs 32+2*$_ X-(-$_..$_)>>.abs for ^48

Try it online!

Perl 5, 77 75 69 bytes
map{say$"x(47-$_),(@a=map chr$_+32,$_..$_*2),reverse@a[0..@a-2]}0..47

Try it online!

C (gcc), 114 113 107 bytes
#define _(_)for(k=32;k<j;)putchar(j+_++);
f(j,k){for(j=31;++j<80;){printf("\n%*c",80-j,j);_(-31+k)_(j+~k)}}

Try it online!
101 bytes are possible using a compiler flag.

Japt -R, 18 15 bytes
14 bytes if an additional leading newline is allowed.
#0õ_odH+ZÉ ¬êÃû

Test it

Explanation
#0                  :48
  õ                 :Range [1,48]
   _         Ã      :Pass each Z through a function
    o               :  Range [0,Z)
      H+ZÉ          :    To each add 32+Z-1
     d              :    Get the character at that codepoint
           ¬        :  Join to a string
            ê       :  Palinrdomise
              û     :Centre pad each element to the length of the longest element
                    :Implicitly join with newlines and output

Ruby, 59 bytes
48.times{|i|-47.upto(i){|c|putc~c<i ?32-c.abs+2*i:32};puts}

Cross-posted from my answer on anagol.

J, 47 44 bytes
(,.~}:@|."1)(1+i.48)([|.@{.}.)"0 1 u:31+i.96

Try it online!
Thanks to Conor O'Brien for the template!
Thanks to FrownyFrog for indicating the invalid solution.

Perhaps this is more easily modifiable: Try it online!

@Conor O'Brien - Thank you for the template, I've updated the link.

Prints an extra line at the top.

@FrownyFrog Oh, it's only now that I see that only trailing newlines are permitted, not leading. I'll try to fix it.

@FrownyFrog - Fixed and slightly golfed.

T-SQL, 153 bytes
DECLARE @ INT=33,@t CHAR(95)=''a:PRINT @t;
SET @t=LEFT(STUFF(STUFF(@t,63-@/2,2,''),46,0,CHAR(@-1)+CHAR(@)+CHAR(@+1)+CHAR(@)),33+@/2)
SET @+=2IF @<128GOTO a

Returns are for display only.
I tried several ideas, including a loop to preconstruct the full string (163 characters), and a nested loop to build it on the fly (168 characters), but this ended up being the shortest.
Basically, each loop I'm cramming 4 new characters into the center of the string, then trimming off the extras from both ends, using the SQL STUFF() function.
Formatted and explained:
DECLARE @ INT=33,                      --Using a single counter for both rows and CHAR
        @t CHAR(95)=''                 --a non-null CHAR field will pre-fill with spaces
a:                                     --GOTO loop, shorter than a WHILE
    PRINT @t                           --duh
    SET @t = LEFT(                     --lops off the character at the end
            STUFF(                     --crams 4 new characters in the middle
            STUFF(@t, 63-@/2, 2, '')   --snips out a space and the leading character
                 ,46, 0, CHAR(@-1) + CHAR(@) + CHAR(@+1) + CHAR(@))
                 ,33 + @/2)            --rest of the LEFT()
    SET @+=2
IF @<128 GOTO a

J,  40 37 32 bytes
40 expression u:30+2>.(+:@i.@(2&+)(-*(>+:))"0 _|@i:)47 thanks to +Galen Ivanov & +Conor O'Brien for the ideas in their solutions
37 included echo echo u:32+|.(~.(>:*+:@[-])"0 _])|i:47
echo u:32+|.(~.(>:*[+-)"{])|i:47

incorporating @FrownyFrog tips from comments
TIO

I don't think expressions are valid submissions.

@LyricLy , opinion seems to vary as I do see another J answer in this form .. anyway thanks for prodding me to shave another 8 bytes .. now I have room to add "echo " : hope you're happy : )

"0 _ → "{

+:@[-] → [+-

beautiful .. thanks for these tips @FrownyFrog

Python 2, 98 88 bytes
-1 byte thanks to @Mr.Xcoder
i=32
exec"print''.join(chr(i+i-32-abs(j))for j in range(32-i,i-31)).center(95);i+=1;"*48

Try it online!

-i+32 => 32-i and you might use ' '*(79-i) instead of .center(95) to save bytes.

@Mr.Xcoder thanks! ' '*(79-i)+ doesn't really save bytes :D

JavaScript (Node.js), 95 bytes
f=(x=y=0)=>y<48?[`
`[x]]+Buffer([x<48-y|x>48+y?32:x<48?x+y*2-16:80-x+y*2])+f(++x%96?x:+!++y):''

Try it online!

Ruby, 78 bytes
s=*32;48.times{puts (s.map(&:chr)*'').center 95;c=*s[0]+1;s=c+s.map{|x|x+2}+c}

Try it online!
Full program. Ungolfed:
s=*32;                              # s is an array of integers
48.times{                           # Repeat 48 times:
  puts (s.map(&:chr)*'').center 95; # Turn each int to a char, join, center, and print
  c = *s[0] + 1;                    # c is a singleton array. It will bookend the next line
  s = c + s.map{|x|x+2} + c         # Add 2 to each element of s before adding the bookends
}

Yabasic, 80 bytes
An anonymous yabasic function that takes no input and outputs to the console
For i=0To 47
For j=i To 47?" ";Next
For j=-i To i?Chr$(32-Abs(j)+2*i);Next
?Next

Try it online!

uBASIC, 95 bytes
0ForI=0To47
1ForJ=ITo47:?" ";:NextJ
2ForK=-1*IToI:?Left$(Chr$(32-Abs(K)+2*I),1);:NextK
3?:NextI

Try it online!

MY-BASIC, 97 bytes
An anonymous MY-BASIC response that takes no input and outputs to the Console
For i=0 To 47
For j=i To 47
Print" "
Next
For j=-i To i
Print Chr(32-Abs(j)+2*i)
Next
Print;
Next

Try it online!
-1 byte thanks to Jonathan Frech

Print " " -> Print" ".

@JonathanFrech - whoops sorry I mispelled your name

C (gcc) 199 bytes
#include<stdio.h>
int i,j=32,k=32,l=49;int main(){while(k<127){for(i=0;i<l;++i)printf(" ");for(i=j;i<k;++i)printf("%c",i);printf("%c",k);for(i=k-1;i>=j;--i)printf("%c",i);printf("\n");j++;k+=2;l--;}}

Try it online!
Thanks to Picard and PunPun1000 for all of the help

@Picard I removed the spaces. I could further minify with a global iterator variable.

@Picard I edited it on my phone; didn't realize I'd left a blank line.

There's unnecessary spaces in the printf calls after the commas, and the variable names can be shortened down to one letter.  Also it would be nice if you could include a TIO link and the actual byte count.  Here's the link for your current code TIO

ok, i've squeezed it a bit more, i think i'd have to change the algorithm to shrink it further

MATL, 18 bytes
48:"@@Zv30++Xhc3Zu

Try it online!

Java 8, 115 114 110 bytes
()->{for(int m=0,c;m<48;m++)for(c=-48;++c<m+2;)System.out.print(c<-m?' ':c>m?'\n':(char)(32-(c<0?-c:c)+2*m));}

(c<0?-c:c) saves 1 byte over Math.abs(c)
I used ?: to print spaces before the pylon and a newline after it to save multiple System.out.print calls.

Is omitting the class declaration permitted? :)

@Trejkaz It is allowed to submit a full program or a function.

for(c=-47;c<m+2;c++){...} -> for(c=-48;++c<m+2;)....

@JonathanFrech Done.  Thanks.

@rgettman You can most likely also get rid of the brackets.

Tcl, 129 122 118 117 bytes
time {incr i;set j -48;set a {};time {set a $a[format %c [expr abs([incr j])>=$i?32:$i*2-abs($j)+30]]} 96;puts $a} 48

Try it online!
Explanation
time { # for i from 0 up to 47
    incr i
    set j -48
    set a {}
    time { # for j from -48 up to 47
        # add next character to a
        set a $a[format %c [expr abs([incr j])>$i?32:$i*2-abs($j)+32]]
    } 96
    puts $a # print a
} 48

Gol><>, 29 bytes
`0FaLssLF:P|LF:M|`/L-R` lRo|;

Try it online!
How it works
`0FaLssLF:P|LF:M|`/L-R` lRo|;

`0F                        |;  Repeat the following 48 times and halt...
   a                           Push 10 (\n)
    Lss                        Push L(loop counter) + 32
       LF:P|                   Repeat "Clone the top and increment" L times
            LF:M|              Repeat "Clone the top and decrement" L times
                 `/L-R`        Push 32 (space) 47-L times (space is significant)
                        lRo    Print everything as char, from the top,
                               until the stack is empty

Haskell, 102 bytes
main=putStr$do
i<-[48,47..0]
let l=replicate i 32++[79-i..126-i*2]
map toEnum$l++tail(reverse l)++[10]

Things I have tried that were not shorter:

Expressing everything in terms of character literals and succ or pred to save the map toEnum.
Writing a downward range instead of using reverse.

PHP, 94 bytes
for(;49>$k=++$i;printf("%47s%s
",$s,substr(strrev($s),1)))for($s="";$k--;)$s.=chr(30+$i*2-$k);

Run with -nr or try it online.

Deadfish~, 6049 bytes
{iii}ii{cc}{cc}cccccccc{dd}ddc{ii}ii{cc}{cc}ccccccicicdc{dd}dddc{ii}ii{cc}{cc}ccccciicicicdcdc{dd}ddddc{ii}ii{cc}{cc}cccciiicicicicdcdcdc{dd}dddddc{ii}ii{cc}{cc}ccciiiicicicicicdcdcdcdc{dd}ddddddc{ii}ii{cc}{cc}cciiiiicicicicicicdcdcdcdcdc{ddd}iiic{ii}ii{cc}{cc}ciiiiiicicicicicicicdcdcdcdcdcdc{ddd}iic{ii}ii{cc}{cc}{i}dddcicicicicicicicdcdcdcdcdcdcdc{ddd}ic{ii}ii{cc}{c}ccccccccc{i}ddcicicicicicicicicdcdcdcdcdcdcdcdc{ddd}c{ii}ii{cc}{c}cccccccc{i}dcicicicicicicicicicdcdcdcdcdcdcdcdcdc{ddd}dc{ii}ii{cc}{c}ccccccc{i}cicicicicicicicicicicdcdcdcdcdcdcdcdcdcdc{ddd}ddc{ii}ii{cc}{c}cccccc{i}icicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdc{ddd}dddc{ii}ii{cc}{c}ccccc{i}iicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdc{ddd}ddddc{ii}ii{cc}{c}cccc{i}iiicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdc{ddd}dddddc{ii}ii{cc}{c}ccc{i}iiiicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddd}ddddddc{ii}ii{cc}{c}cc{i}iiiiicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}iiic{ii}ii{cc}{c}c{i}iiiiiicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}iic{ii}ii{cc}{c}{ii}dddcicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}ic{ii}ii{cc}ccccccccc{ii}ddcicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}c{ii}ii{cc}cccccccc{ii}dcicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}dc{ii}ii{cc}ccccccc{ii}cicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}ddc{ii}ii{cc}cccccc{ii}icicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}dddc{ii}ii{cc}ccccc{ii}iicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}ddddc{ii}ii{cc}cccc{ii}iiicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}dddddc{ii}ii{cc}ccc{ii}iiiicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddd}ddddddc{ii}ii{cc}cc{ii}iiiiicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}iiic{ii}ii{cc}c{ii}iiiiiicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}iic{ii}ii{cc}{iii}dddcicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}ic{ii}ii{c}ccccccccc{iii}ddcicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}c{ii}ii{c}cccccccc{iii}dcicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}dc{ii}ii{c}ccccccc{iii}cicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}ddc{ii}ii{c}cccccc{iii}icicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}dddc{ii}ii{c}ccccc{iii}iicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}ddddc{ii}ii{c}cccc{iii}iiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}dddddc{ii}ii{c}ccc{iii}iiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{ddddd}ddddddc{ii}ii{c}cc{iii}iiiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}iiic{ii}ii{c}c{iii}iiiiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}iic{ii}ii{c}{iiii}dddcicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}ic{ii}iiccccccccc{iiii}ddcicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}c{ii}iicccccccc{iiii}dcicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}dc{ii}iiccccccc{iiii}cicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}ddc{ii}iicccccc{iiii}icicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}dddc{ii}iiccccc{iiii}iicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}ddddc{ii}iicccc{iiii}iiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}dddddc{ii}iiccc{iiii}iiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{dddddd}ddddddc{ii}iicc{iiii}iiiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{{d}iii}iiic{ii}iic{iiii}iiiiiicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc{{d}iii}iic{{i}ddd}dcicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicicdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdc

all_licenses: 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/


text:
Minimal Triangles
Make an upside down triangle of positive integers. Every number in the triangle must be distinct. Each number is the summation of its two parents (similar to how Pascal's triangle is constructed, but upside-down). Construct it in such a way that the bottom number is minimized.
For example, for input n = 4, here is a possible solution:
4  1  2  7
 5  3  9
  8  12
   20

A reversal of the top numbers, such as 7 2 1 4, would also work.
For input n = 5, here is a possible solution:
7  2  1  4  6
  9  3  5 10
   12  8 15
     20 23
       43

The solution for n = 2 is rather boring:
1 2
 3

The sequence of bottom numbers is described in OEIS A028307.
Challenge
Given an input integer n > 0 describing how many elements are in the first row, output the corresponding minimal triangle as explained above. Output can be as ASCII-art of the triangle, a list-of-lists or matrix, to STDOUT as one row per line, etc.
Rules

If applicable, you can assume that the input/output will fit in your language's native Integer type.
The input and output can be given by any convenient method.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Is padding between numbers specified?

@DeadPossum Up to you, so long as it's unambiguous (e.g., don't use 1 as your padding). The I/O isn't the interesting part of this challenge.

Jelly, 20 bytes
!*ṗµ+ƝÐĿ€FQƑ$Ðf-ị$ÞḢ

Try it online!
It's trivial to prove that there exists a solution which all elements on the first row are in range [1,n!n].
Be careful as this computes an array of 10'077'696 3-element arrays for n=3.

Proof:
Let x be on the kth layer (1 ≤ k ≤ n, and there are a numbers to the left of x. Let b0, b1, ..., bn-1 be the numbers on the first line.
Then:
x = ba × (k-1 choose 0) + ba+1 × (k-1 choose 1) + ... + ba+k-1 × (k-1 choose k-1)
It can be proven that all of the coefficients are non-negative and less than n! (except when n=1, in that case the algorithm gives correct result anyway), and two different numbers have two different set of coefficients.
So if the first line are chosen to be the powers of n! with exponent 0,1,2,...,n-1, the value of each cell uniquely determines the set of coefficients, and thus is unique.

Jelly, 19 bytes
!*r1œcµ_ƝÐĿ€FQƑ$ÐfṪ

Try it online!
Output format: Columns, upside down.

Python 2, 251 239 230 bytes
-9 bytes thanks to @Mr.Xcoder
Outputs list of lines of triangle, bottom to top.
def F(s,d):
 if-~d==len(s):
	u=sum(s,[])
	if len(u)==len(set(u)):print s;g
 else:
	for j in range(s[d][0]):
	 s[d+1]=[j]
	 for i in s[d]:j=i-j;s[d+1]+=j,
	 if min(s[d+1])>=0:F(s,d+1)
i,I=1,input()
while i:F(eval(`[[i]]*I`),0);i+=1

Try it online!
Bruteforce-ish solution.
For all i in [1 .. ] generate all possbile triangles starting from the bottom, until one with all different numbers is found.

Yeah, that output is fine.

230 bytes


text:
A pile of weights
Challenge:
You'll be given an ASCII image of a pile of weights as input, and must output the combined weight of the pile.

Format:
There are 5 different weights, weighing 1, 2, 5, 10, 20 Passerees (or some other arbitrary unit).
The weights looks like this, in ascending order:
1:   __
    |__|

2:   ______
    |______|

5:   ______
    |      |
    |______|

10:  ______________
    |              |
    |______________|

20:  ____________________
    |                    |
    |____________________|

The weighs will be symmetrically placed (as in the example image), not necessarily in a sorted order. Weighs will share boundaries, where applicable:
Test cases:
You may use all the single weights as test cases too.
   __
 _|__|_
|______|
|      |
|______|
1 + 2 + 5 = 8

 ____________________
|                    |
|____________________|
   |              |
   |______________|
        _|__|_
       |______|
       |      |
       |______|
20 + 10 + 1 + 2 + 5 = 38

 ______
|______|
|______|
|______|
|______|
2 + 2 + 2 + 2 = 8

Additional rules:

You may not assume additional leading spaces. The largest weight will be all the way to the left.
You may assume trailing spaces and newlines.
You may assume there will be maximum 10 weights
You may take the input on an optional format, but you can't substitute the characters used by something else

This is code-golf so the shortest code in bytes each languages wins. Explanations are encouraged as always.

Your challenge inspired me to write this one.  Any tips are appreciated!

Jelly,  24  23 bytes
ḟ⁶Ỵẹ€”|IFṚ’œṗ$Ḅ:3“ÇÞ‘yS

Try it online!
How?
The weights may be identified by their widths and heights. The widths may be measured by looking at the distance between the line's | characters. If we first remove all the spaces then those weights of height two will contribute such a line with a measured width of one.
The different weights have widths of 3, 7, 7, 15, 21 (for weights 1, 2, 5, 10, 20 respectively). Adding a trailing 1 for those of height two we find [3],[7],[7,1],[15,1],[21,1] converting from binary these are 3,7,15,31,43, integer dividing by three gives us 1,2,5,10,14, which are the weights except 14 needs replacing by 20.
ḟ⁶Ỵẹ€”|IFṚ’œṗ$Ḅ:3“ÇÞ‘yS - Link: list of characters    e.g. <example 2>
 ⁶                      - literal space character
ḟ                       - filter discard
  Ỵ                     - split at new lines
     ”|                 - literal pipe character
   ẹ€                   - get indices for €ach             [[],[1,2],[1,22],[1,2],[1,16],[2,5],[1,8],[1,2],[1,8]]
       I                - incremental differences          [[],[1],[21],[1],[15],[3],[7],[1],[7]]
        F               - flatten                          [1,21,1,15,3,7,1,7]
         Ṛ              - reverse                          [7,1,7,3,15,1,21,1]
             $          - last two links as a monad:
          ’             -   decrement                     [6,0,6,2,14,0,20,0]
           œṗ           -   partition at truthy indices   [[],[7,1],[7],[3],[15,1],[21,1]]
              Ḅ         - convert from binary             [0,15,7,3,31,43]
               :3       - integer divide by three         [0,5,2,1,10,14]
                 “ÇÞ‘   - code-page-indices               [14,20]
                     y  - translate                       [0,5,2,1,10,20]
                      S - sum                             38

Alternatively replace the measured widths of 21 with 30 prior to the conversion using “ßœ‘y:
ḟ⁶Ỵẹ€”|IF“ßœ‘yṚ’œṗ$Ḅ:3S

Python 2, 77 bytes
lambda x:sum(i/21*x.count('|'+i%21*' _'[i<50]+'|')for i in[23,48,69,224,440])

Try it online!
[i/21, i%21, ' _'[i<50] for i in [23,48,69,224,440]] will generate the following triplets [1, 2, '_'], [2, 6, '_'], [3, 6, ' '], [10, 14, ' '], [20, 20, ' '] that represent the weight, the lenght and the character in the base of each weight, that will be used to make a unique single-line representation of each weight.
Since the 3rd weight would overlap with the 2nd, I replace it's base with it's body (_ -> ) and reduced the value to 3 (it will count the base as 2 and the body as 3, resulting in 5)

Retina 0.8.2, 60 bytes
T`|`!
!__!
1
!_{6}!
11
! {6}!
3$*
!.{14}!
5$*
!.{20}!
10$*
1

Try it online! Explanation: The |s are replaced with !s for ease of matching, then the weights are converted into unary and totalled. The only interesting portion is that the 5 weight is considered to be the sum of a 2 and a 3 weight, while the 10 and 20 weights are just two lines of half the weight.

JavaScript (Node.js), 73 bytes
x=>x.replace(/\|.*\|/g,s=>u+=s.length/4*(s[1]<1?s[21]?29/11:1.5:1),u=0)|u

Try it online!

Python 3, 76 bytes
lambda t:sum([1,2,3,5,5,9,11][len(x)//4+(x<'_')]for x in t.split('|')[1::2])

Try it online!
How?
sum([1,2,3,5,5,9,11][len(x)//4+(x<'_')]for x in t.split('|')[1::2])
                                                t.split('|')         - split ascii art into pieces
                                                            [1::2])  - weights are at odd indexes
                                       for x in                      - iterates over the weights
                     len(x)//4                                       - map widths to 0,1,3,5,7
                              +(x<'_')                               - add 1 if the first row of 2-row weight
    [1,2,3,5,5,9,11][                 ]                              - value of each part of a weight
sum(                                                              )  - add 'em all up

I'm sure there are some improvements to be made, but this is what I have at the moment:
Groovy, 131 bytes
def f(s){s.split('\n').sum{n=0;[2:1,6:2,14:5,20:10].each{k,v->if(it==~".*\\|[ _]{$k}\\|.*"){n=v+(!it.contains('_')&&k==6?1:0)}};n}}
Converts the input String into a Collection<String> and then sums the results for each line to get the total. Uses a Map where the key is the number of spaces or underscores in between the pipe characters and the value is the corresponding Passerees amount. The key is plugged into the regex to determine if the line matches a significant pattern. The one caveat is the ternary to add 1 in the case where the length of the substring between the pipes is 6 and is composed of spaces (as opposed to underscores). If no pattern matches, the line has a value of 0.

Perl 6, 57 bytes
{sum map {.comb+>2*(1.5,3)[.comb>16]**!/_/},m:g/\|.*?\|/}

Try it online!


text:
Ascending integer pyramid
Output either the text below, or a list of lists of integers (more details below).
 0
10  1
20 11  2
30 21 12  3
40 31 22 13  4
50 41 32 23 14  5
60 51 42 33 24 15  6
70 61 52 43 34 25 16  7
80 71 62 53 44 35 26 17  8
90 81 72 63 54 45 36 27 18  9
91 82 73 64 55 46 37 28 19
92 83 74 65 56 47 38 29
93 84 75 66 57 48 39
94 85 76 67 58 49
95 86 77 68 59
96 87 78 69
97 88 79
98 89
99

Rules

If you wish, you may "one index" and replace each n with n+1. In this case the output will contain the numbers 1 to 100 inclusive.

If output is text

The single digits are right aligned in each column in the text provided, but it is fine if you wish to left align. Additionally, alignment is not required to be consistent between columns.
Leading/trailing whitespace is permitted. Trailing spaces on each line are also permitted.
Returning a list of lines is acceptable.

If output is numerical

Output can be a list of lists of integers (or 2D array): [[1], [11, 2], [21...
Floats are fine.
If it is not possible to have nonrectangular array in the language used, then the elements in the array that aren't within the triangle can take any value and will be ignored.

If you prefer another format, feel free to ask.
Shortest code wins.

Sandbox

Since leading/trailing white-space is permitted in the textual output, are leading/trailing empty lists permitted in the list output?

@JonathanAllan Sure

i cant edit it in, but this should have the kolmogorov complexity tag (not sure i spelled that right...)

@BrianH. According to others, since there isn't really a single constant that is meant to be produced, the KC tag doesn't apply here

Jelly,  13 12 10  6 bytes
-4 thanks to Dennis, yes FOUR! (use of group indices and Cartesian product)
⁵pḅ1ĠU

Uses 1-indexing and the list option for output.
Try it online! (The footer formats the output in Python representation)
...or see a 0-indexed, formatted version.
How?
⁵pḅ1ĠU - Main link: no arguments
⁵      - literal 10
 p     - Cartesian product (with the leading constant of 10 and implicit ranges)
       -       = [[1,1],[1,2],[1,3],...,[10,8],[10,9],[10,10]]
  ḅ1   - to base one (proxy for sum each without the monad)
       -       = [2,3,4,5,6,7,8,9,10,11,3,4,5,6,7,8,9,10,11,12,4,...,18,19,20]
    Ġ  - group indices by value
       -       = [[1],[2,11],[3,12,21],...,[90,99],[100]]
     U - upend = [[1],[11,2],[21,12,3],...,[99,90],[100]]

Nice. I had 7 bytes

What in the world does Ġ even do?!

@MagicOctopusUrn it groups the indices of an array by their corresponding value. So [5,7,5,9]Ġ would return [[1,3],[2],[4]].  This is because indices [1,3] correspond to value 5 in the original array, [2] to 7 and [4] to 9.

Python 2, 54 bytes
k=1
exec"print range(k,0,-9)[:101-k];k+=10-k/91*9;"*19

Try it online!
(1-indexed, because range(k,0,-9) is shorter than range(k,-1,-9).)

Charcoal, 29 20 bytes
Ｅ¹⁹⪫Ｉ⮌Φ¹⁰⁰⁼ι⁺÷λχ﹪λχ

Try it online! Link is to verbose version of code. Note: trailing space. Explanation:
 ¹⁹                     Literal 19
Ｅ                       Map over implicit range
       ¹⁰⁰              Literal 100
      Φ                 Filter over implicit range
              λ  λ      Inner index
               χ  χ     Predefined variable 10
                ﹪       Modulo
             ÷          Integer divide
            ⁺           Sum
           ι            Outer index
          ⁼             Equals
     ⮌                  Reverse
    Ｉ                   Cast to string
   ⪫                    Join with spaces
                        Implicitly print each string on its own line

JavaScript (ES6), 61 bytes
0-based. Returns a string.
f=(k=n=0)=>k>98?k:k+((k-=9)%10>0?' '+f(k):`
`+f(n+=n>89||10))

Try it online!
How?
We start with k = n = 0 and stop when k = 99. We subtract 9 from k at each iteration.
End of rows are detected with k % 10 <= 0. This condition is fulfilled if:

k is negative (upper part of the pyramid) because the sign of the modulo in JS is that of the dividend.
 0 (-9)
10  1 (-8)
20 11  2 (-7)

or k % 10 == 0 (lower part of the pyramid)
90 81 72 63 54 45 36 27 18  9 (0)
91 82 73 64 55 46 37 28 19 (10)
92 83 74 65 56 47 38 29 (20)

At the beginning of the next row, we add either 1 or 10 to n and restart from there.

Python 2, 66 bytes
r=range
for a in r(0,90,10)+r(90,100):print r(a,a/10+a%10*10-1,-9)

Try it online!

J, 14 bytes
,.<@|./.i.,~10

Try it online!
Note:
This solution uses boxed output - I'm not sure if it's allowed (I hope it is, because lists of integers are also allowed)
Alternative:
J, 10 bytes
|./.i.,~10

In this solution the numbers outside the triangular area are displayed as 0
Try it online!
Explanation:
i.,~10 creates a matrix 10x10 of the numbers 0..99 ,~10 is short for 10 10
   i.,~10
 0  1  2  3  4  5  6  7  8  9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31 32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47 48 49
50 51 52 53 54 55 56 57 58 59
60 61 62 63 64 65 66 67 68 69
70 71 72 73 74 75 76 77 78 79
80 81 82 83 84 85 86 87 88 89
90 91 92 93 94 95 96 97 98 99

/. finds the oblique diagonals (antidiagonals) of the matrix
   ]/.i.,~10
 0  0  0  0  0  0  0  0  0  0
 1 10  0  0  0  0  0  0  0  0
 2 11 20  0  0  0  0  0  0  0
 3 12 21 30  0  0  0  0  0  0
 4 13 22 31 40  0  0  0  0  0
 5 14 23 32 41 50  0  0  0  0
 6 15 24 33 42 51 60  0  0  0
 7 16 25 34 43 52 61 70  0  0
 8 17 26 35 44 53 62 71 80  0
 9 18 27 36 45 54 63 72 81 90
19 28 37 46 55 64 73 82 91  0
29 38 47 56 65 74 83 92  0  0
39 48 57 66 75 84 93  0  0  0
49 58 67 76 85 94  0  0  0  0
59 68 77 86 95  0  0  0  0  0
69 78 87 96  0  0  0  0  0  0
79 88 97  0  0  0  0  0  0  0
89 98  0  0  0  0  0  0  0  0
99  0  0  0  0  0  0  0  0  0

Using ] (same) pads all lines with 0s. Each line is reversed. In order to get rid of the zeroes I box the lines < after they are reversed |.
   <@|./.i.,~10
┌─┬────┬───────┬──────────┬─────────────┬────────────────┬
│0│10 1│20 11 2│30 21 12 3│40 31 22 13 4│50 41 32 23 14 5│. . .
└─┴────┴───────┴──────────┴─────────────┴────────────────┴

Boxing makes the list of lists to be flatten. I finally ravel ,. the list so that the lines are ordered in a column.
  ,.<@|./.i.,~10
┌────────────────────────────┐
│0                           │
├────────────────────────────┤
│10 1                        │
├────────────────────────────┤
│20 11 2                     │
├────────────────────────────┤
│30 21 12 3                  │
├────────────────────────────┤
│40 31 22 13 4               │
├────────────────────────────┤
│50 41 32 23 14 5            │
├────────────────────────────┤
│60 51 42 33 24 15 6         │
├────────────────────────────┤
│70 61 52 43 34 25 16 7      │
├────────────────────────────┤
│80 71 62 53 44 35 26 17 8   │
├────────────────────────────┤
│90 81 72 63 54 45 36 27 18 9│
├────────────────────────────┤
│91 82 73 64 55 46 37 28 19  │
├────────────────────────────┤
│92 83 74 65 56 47 38 29     │
├────────────────────────────┤
│93 84 75 66 57 48 39        │
├────────────────────────────┤
│94 85 76 67 58 49           │
├────────────────────────────┤
│95 86 77 68 59              │
├────────────────────────────┤
│96 87 78 69                 │
├────────────────────────────┤
│97 88 79                    │
├────────────────────────────┤
│98 89                       │
├────────────────────────────┤
│99                          │
└────────────────────────────┘

Pure Bash (no external utilities), 66
eval a={{9..1},}\;b={9..0}';c[a+b]+=$a$b\ '
printf %s\\n "${c[@]}"

Try it online!

R, 137 86 73 69 bytes
for(u in 0:18)cat("if"(u>9,seq(81+u,10*u-81,-9),seq(10*u,u,-9)),"\n")

Try it online!
Previous golfed version, %100 credits to Giuseppe.

S=sapply
c(S(1:10,function(u)1:u-1+10*(u-1:u)),S(9:1,function(y)1:y+9-y+10*(y:1+9-y)))

Try it online!
Below my first attempt at Codegolf keeping it just for the record.
x<-c(1:10)
z<- c(9:1)
c(sapply(x,function(u) seq_len(u)-1+10*(u-seq_len(u))),sapply(z,function(y) seq_len(y)+9-y+10*rev(seq_len(y)+9-y)))

Try it online!

Nice answer! Like you say, you can remove quite a few bytes; I've managed to find an 86 byte solution by removing some unnecessary white-space, and replacing seq_len with 1: in most places; I also used y:1 instead of rev.

@Giuseppe many thanks for the improved answer - it shows that I haven't coded in years.

Pyth, 16 bytes
V19fqssM`TN_U100

Try it online!

15 bytes.

Gol><>, 24 bytes
0D9FlF{a+|lD|9F~lF{P|D|;

Try it online!
The output looks like this:
[0]
[10 1]
[20 11 2]
[30 21 12 3]
[40 31 22 13 4]
[50 41 32 23 14 5]
[60 51 42 33 24 15 6]
[70 61 52 43 34 25 16 7]
[80 71 62 53 44 35 26 17 8]
[90 81 72 63 54 45 36 27 18 9]
[91 82 73 64 55 46 37 28 19]
[92 83 74 65 56 47 38 29]
[93 84 75 66 57 48 39]
[94 85 76 67 58 49]
[95 86 77 68 59]
[96 87 78 69]
[97 88 79]
[98 89]
[99]

How it works
0D9FlF{a+|lD|9F~lF{P|D|;

0D                       Push 0 and print stack
  9F        |            Repeat 9 times...
    lF{a+|                 Add 10 to all numbers on the stack
          l                Push stack length (the last one-digit number)
           D               Print stack
             9F       |  Repeat 9 times...
               ~           Discard the top
                lF{P|      Increment all numbers on the stack
                     D     Print stack
                       ; Halt

R, 50 48 bytes
split(y<-rev(order(x<-outer(0:9,0:9,"+"))),x[y])

Try it online!
1-indexed. Follows the same logic as Jonathan Allan's Jelly answer, so make sure to upvote him.
As a bonus, here is also an implementation of standard looping approach (0-indexed). Here, I at least tried to make the output prettier (thus, didn't even save bytes for print instead of cat(...,"\n") to get rid of annoying [1]s in the console.
R, 66 59 bytes
for(i in c(0:8*10,90:99))cat(seq(i,i/10+i%%10*10-1,-9),"
")

Try it online!
Edit: -2 and -7 both thanks to Giuseppe.

I managed to golf down the second one to 59 bytes and the first to 48 bytes

@KirillL.It's always realy elegant to use outer. plus in this case it's shorter!

Octave, 67 66 65 64 bytes
for i=0:8disp(10*i:-9:0)end,for i=0:9disp(90+i:-9:11*i+(i<1))end

Try it online!
Those missing semicolons hurt my eyes!

05AB1E, 22 bytes
TLûvTLD>T*«NèyGD9+})R,

Try it online!

Super Naive Approach: Try it online! may be a better solution but I can't figure out how to get from A to B.

Is there a "sort a based on values of b" command?

PowerShell, 77 bytes
(0..90|?{!($_%10)})+91..99|%{"$(for($i=$_;$i-gt$_/10+$_%10*10-1;$i-=9){$i})"}

Try it online!
Outputs as ASCII-art with the single-digits left-aligned. Exploits the fact that stringifying an array inserts spaces between elements by default.
Very similar to Rod's Python answer, apparently, but developed independently.

05AB1E, 16 bytes
тL<ΣTLãOsè}TLû£í

Try it online!
Explanation
тL<Σ      }       # sort the values in [0 ... 99] by
        sè        # the value at that index in
       O          # the sum of
      ã           # the cartesian product of
    TL            # the range [1 ... 10]
              £   # split the result into pieces of sizes
           TLû    # [1,2,...,9,10,9,...2,1]
               í  # and reverse each

JavaScript, 69 bytes
f=(i=e=[])=>e[i<19&&(e[+i]=[]),i/10+i%10|0].unshift(+i)*i++-99?f(i):e

Try it online!
JavaScript REPL, 77 bytes
[...Array(100)].map((_,i)=>e[i<19&&(e[i]=[]),i/10+i%10|0].unshift(i),e=[])&&e

Perl 6, 43 40 bytes
{map {[R,] grep :k,$_,(^10 X+ ^10)},^19}

Try it online!
-3 bytes thanks to Brad Gilbert b2gills.

[R,] LIST is shorter than reverse LIST

@BradGilbertb2gills Nice, thanks!

Perl 5, 62 bytes
$,=$";say@,=map$_+=10,@,,$_ for-9..0;say map++$_,@,while pop@,

Try it online!
1-indexed to save a couple bytes

Red, 105, 95 91 bytes
v: make vector! 0
loop 10[alter v + 10 length? v print v]loop 9[alter v last v print 1 + v]

Try it online!
Explanation:
v: make vector!   0                           ; start with a vector with one element: -10
loop 10[alter v + 10 length? v print v]       ; Ten times print the vector after adding 10
                                              ; to its elements and appending the length
loop 9[alter v last v print 1 + v]            ; Nine times print the vector after adding 1
                                              ; to its elements and removing the last one
                                              ; `alter` appends the item if it's not
                                              ; in the list, otherwise removes it

Ruby, 58 bytes
0.step(180,10){|x|p x.step(0,-9).select{|y|y<100&&y>x-90}}

Try it online!

JavaScript, 112 bytes
Not that optimal, but I wanted to try a different approach.
[...Array(19)].map((x,y)=>y>9?81+y:y?y+'0':y).map(x=>(f=(n,a=[n])=>!n|a[n+='']|n[1]>8?a:f(n-=9,a.concat(n)))(x))

Try it online!
Old Solution:

[...Array(19)].map((x,y)=>y>9?y-9+'9':y).map((x,y)=>(f=(n,a=[n])=>a[n/10]|!n?a.reverse():a.push(n+=9)&&f(n,a))(x*1).slice(y-19))

Try it online!


text:
Implement Tyrant Sort
TL;DR

Record (left-right)/length for each pair of consecutive elements. If they're 0 or negative, don't record it.
Once this is done, take these actions. Don't update quotients:

Increment right and decrement left for (0, .3)
Remove from the array at >=.3
Print both elements for >.5

Print the remaining array. Have some separator for executed and remaining.

Now, onto the challenge…
This is the sorting algorithm that has a worst-case of GLORIOUS LINEAR TIME, and where any who dare oppose its INFINITE WISDOM will be promptly EXECUTED for their HEINOUS CRIME OF HIGH TREASON.
The FEARLESS LEADER has tasked you with the HONORABLE MISSION of writing a program or function that takes in an array of integers and sorts it using the following sorting algorithm:

Iterate through your array, enlightening each element with the GLORIOUS presence of their FEARLESS LEADER.
Have your SECRET POLICE check on every pair of 2 consecutive elements to make sure they are PROPERLY LOYAL TO THEIR NATION. If they're not ordered correctly, record the difference between the numbers, divided by the length of the array. This is their dissent quotient.
At the end of your GLORIOUS TOUR, go through the list and RAIN FEARLESS LEADER'S DIVINE PUNISHMENT on all of the TREASONOUS DISSENTERS as follows:

For a dissent quotient of less than .3, they merely need brainwashing a reminder of the INFINITE GLORY OF THE FEARLESS LEADER. Decrement the left element and increment the right element. Don't change any dissent quotients.
For a dissent quotient of .3-.5 (inclusive), they are TRAITORS and should be sent to PRISON CAMPS. Remove them from the array.
For a dissent quotient greater than .5, they are ODIOUS REBEL SCUM. They should be PUBLICLY EXECUTED as an example for any other TREASONOUS HERETICS they might have allied with. Remove them from the array and send it to the national news source, The STDOUT Times.

Your array is now COMPLETELY AND FOREVER sorted. Send it to The STDOUT Times so they can sing of your GLORIOUS VICTORY.

As MANDATORY VIEWING to those who are too FOOLISH to understand the INFINITE GLORY of this algorithm, it will be used to sort the following array:
[1,8,6,0,4,9,3,5,7,2]

1 and 8 are ordered correctly.
8 and 6 aren't ordered right, so the dissent quotient of .2 is recorded for both of them.
6 and 0 are another pair of dissenters. This dissent quotient is .6.
0 and 4 are ordered correctly.
4 and 9 are ordered correctly.
9 and 3 have a dissent quotient of .6.
3 and 5 are ordered correctly.
5 and 7 are ordered correctly.
7 and 2 have a dissent quotient of .5.

So, you take the following actions in the name of the FEARLESS LEADER:

Decrement 8 to 7, and increment 6 to 7.
Remove 0 and the new 7, and EXECUTE THEM.
Follow with 9 and 3.
Haul the original 7 and the 2 to the re-education camps and remove them.

This should be your press release, done in STDOUT or whatever's convenient:
Executions: 7, 0, 9, 3
[1, 7, 4, 5]

As you can see, the resulting array is COMPLETELY AND FOREVER SORTED. Attempting to suggest that it isn't sorted constitutes HIGH TREASON.
Now, as a GLORIOUS DEMONSTRATION of the UNENDING RESOURCES given by the FEARLESS LEADER, he has provided you with his INFINITE WISDOM in generating test cases:
import random

len=random.randint(2,20)
arr=list(range(len))
random.shuffle(arr)
print(arr)

dissent=[(arr[i]-arr[i+1])/len for i in range(len-1)]
dissent.append(0) # Barrier between front and back of the array.
executions=[]
for i in range(len-1):
    if dissent[i] > 0:
        if dissent[i] < 0.3:
            arr[i] -= 1
            arr[i+1] += 1
        elif dissent[i] > 0.5:
            if dissent[i-1] <= 0.5:
                executions.append(arr[i])
            executions.append(arr[i+1])

print([arr[i] for i in range(len) if dissent[i] < 0.3 and dissent[i-1] < 0.3])
print(executions)

Try it Online - hit the run button to use, otherwise you're just getting what the last person got.
In the interest of stare desecis, the FEARLESS LEADER has also provided an edge case example:
Input                  Output
3,2,1,4,4,1,2,3,4,5    2,2,2,4,2,3,4,5

(There are no executions in this example.)
Finally, you should treat the bytes in your program as key supporters and minimize them. The shortest program in bytes will win the ETERNAL FAVOR OF THE FEARLESS LEADER.
Credit where it's due
The concept for this was inspired by Lazy Drop Sort, and the writing style used was largely taken from Psychotic Dictatorships—go visit them if you enjoyed the parody aspect of this.
Additional credit goes to everyone who voted on this in the Sandbox early on. The +8 it attained was my motivation to rewrite it to avoid duplication.

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

this needs a hell lot of renovation. More on what to do and less on stories. what do you think ?

@MuhammadSalman as with the first time this was closed, I'd really like to know what's missing from the summary.

@StephenLeppik : Nothing is missing from summary (I am pretty sure) but like I said , less stories and more to the point facts regarding what needs to be done. At least that is the reason I voted for it to be put on hold. Others may have different reasons.

+1 for the interesting idea. -1 for the unnecessary over the top writing style.  Interesting stories, while I'm not a fan of them, can be ok if they don't detract from the challenge, but I had to reread the challenge 3 times (even with the examples) to make sure I didn't miss anything.  Also in your tl;dr you are missing the point saying if left < right then dissent = 0.  Additionally, I'm pretty sure you mean left minus right, not right minus left since that would always be negative if right is less than left.

Ruby, 146 135 bytes
->l{e=[];i=0;l.inject{|j,k|q=(j-k)*10.0/l.size;b,c=l[i],l[i+=1];q>5&&e<<b<<c;q>0&&(l[i-1],l[i]=q<3?[b&&b-1,c&&c+1]:p);k};[l-a=[a],e-a]}

Try it online!


text:
Find out my number neighbors
The input consists of i rows with neighbors information. Each ith row contains 4 values, representing the neighbor of i to the North, East, South and West directions, respectively. So each value represents a neighbor at the given direction of the ith row, starting from row 1, and can go up to 65,535 rows. The 0 value indicates no neighbor to that direction.
For instance, if the first row is "0 2 3 10" it means that the i neighbor has three other neighbors: no one to the north, neighbor 2 to the east, neighbor 3 to the south and neighbor 10 to the west.
You need to output the array of neighbors, starting from the value which is most to the northwest. Each neighbor will be displayed only once, at its position relative to others. Let's see some examples:
Input:
0 0 0 0

No neighbors (empty case), output:
1

Input:
0 2 0 0
0 0 0 1

1 has neighbor 2 to the east. 2 has neighbor 1 to the west
Output:
1 2

Input:
0 2 0 0
0 0 3 1
2 0 0 0

1 has neighbor 2 to the east. 2 has neighbor 1 to the west and 3 to the south.
3 has neighbor 2 to the north
Output:
1 2
  3

Input:
2 0 0 0
0 0 1 0

Output:
2
1

Input:
0 2 3 0
0 0 4 1
1 4 0 0
2 0 0 3

Output:
1 2
3 4

Rules:

Test cases are separated by one empty line. Output of different test cases must also be separated by one empty line.
The output graph is always connected. You are not going to have 1 neighbor to 2 only, along with 3 neighbor to 4 only (isolated from 1-2 component).
All entries are valid. Example of invalid entries:

Entries containing letters or any symbol different than spaces, line breaks and digits (0-9).
the ith row containing the ith value (because one can't be its own neighbor).
a negative value or value higher than 65,535.
Less than four values in a row.
More than four values in a row.
The same neighbor pointing to two different directions (ex: 0 1 1 0).

Standard loopholes apply, and the shortest answer in bytes wins.

How strict are I/O and the order of NESW?  For example, could I take a list of lists in [N, S, W, E] order?

@Mnemonic Thank you, fixed.

Test cases are separated by one empty line - This is an unusual requirement.  Normally it is given that challenge entries will handle one testcase at a time (one per invocation).  If challenge entries can handle more than one testcase at a time, then great, but there is little value to strictly specifying how multiple testcase entries should be formatted.

@Digital Trauma Thank you for your edits and also this suggestion. I removed this rule (striked though it).

@Chaotic you can remove it completely (if you want to), the revision history take care of the changelog

@Rod Yes, I'm aware of this, but let it rest some time there, because in the past I was warned against changing the rules in the middle of the challenge. Best regards.

I don't understand how the output relates to the output. Can you explain in more detail what "array of neighbors" means, and by which rules this array should be created by?

Aaaaah, I think I get it. The neighbors are enumerated 1,2,.... I though they had a neighbor 2 "units" to the east, and 1 "unit" to the south and so on. Couldn't make sense of it.

@StewieGriffin yep I had to read through it a few times before it was clear

I assume that leading spaces (the same number of spaces per line), trailing spaces, and leading and trailing newlines don't matter in the output. Right? Because there's no way to tell from the input whether such spaces exist.

Python 2, 152 bytes
l=input()
def f(x,y,n):
 if m[x][y]<n:m[x][y]=n;[f(i%3-1+x,i/3-1+y,h)for h,i in zip(l[n-1],[3,7,5,1])]
e=len(l)
m=eval(`[[0]*e*2]*e*2`)
f(e,e,1)
print m

Try it online!
The input order is NESW
f is a recursive function to populate the houses

Sorry, it is not working. I even tried with your input format (which I guess it's fine): [[0, 5, 2, 0], [1, 6, 3, 0], [2, 7, 4, 0], [3, 8, 0, 0], [0, 9, 6, 1], [5, 10, 7, 2], [6, 11, 8, 3], [7, 12, 0, 4], [0, 13, 10, 5], [9, 14, 11, 6], [10, 15, 12, 7], [11, 16, 0, 8], [0, 17, 14, 9], [13, 18, 15, 10], [14, 19, 16, 11], [15, 20, 0, 12], [0, 21, 18, 13], [17, 22, 19, 14], [18, 23, 20, 15], [19, 24, 0, 16], [0, 0, 22, 17], [21, 0, 23, 18], [22, 0, 24, 19], [23, 0, 0, 20]]

@Chaotic seems fine to me maybe the output format is not satisfactory?

Ok, I got lost with all those zeros there. I think it woud be better to remove them, but I'm not used to code golf standard rules.

Do you just remain the unused space?

still golfing :)

JavaScript (Node.js), 135 bytes
R=>R.map((t,y)=>r.map((T,Y)=>T.map((X,I)=>X==y+1?[-1,1,1,-1].map((x,i)=>t[i]?(r[a=Y+x*-~i%2]=r[a]||[])[I+x*i%2]=t[i]:0):0)),r=[[1]])&&r

Try it online!
_______________________________________________________________
Second approach
JavaScript (Node.js), 130 bytes
f=(R,x=0,y=0,c=1,r=[[]])=>[-1,1,1,-1].map((d,i)=>(t=R[c-1][i])&&!(r[Y=y+d*-~i%2]=r[Y]||[])[X=x+d*i%2]?f(R,X,Y,t,r):0,r[y][x]=c)&&r

Try it online!


text:
Where am I now?
Where am I now?
Given a string d, containing only the letters NSWE, determine the coordinates I've traveled (from left to right, consuming greedily) and the final coordinate where I reside.
The rules for reading coordinates from left-to-right:

If the next character is N or S:

If the character after the N or S is another N or S:

Consume only the first N or S.
Output [0,1]  for N
Output [0,-1] for S

If the character after the N or S is W or E:

Consume both the N or S and the W or E.
Output [1,1] or [-1,1] for NE and NW, respectively.
Output [1,-1] or [-1,-1] for SE and SW, respectively.

If the character is an E or W not preceded by an S or N:

Consume the E or W.
Output [1,0] for E.
Output [-1,0] for W.

Worked Example
NSWE
[0,1]   (North      N)
[-1,-1] (South-west SW)
[1,0]   (East       E)
[0,0]   (N+SW+E = Didn't actually move)

Note this can be in any format, here are other examples of valid output:
[[0,1],[-1,-1],[1,0],[0,0]]

[[[0,1],[-1,-1],[1,0]],[0,0]]

"0,1\n0,-1\n-1,0\n1,0\n0,0"

Etc...

More Examples
SWSENNESWNE
[-1,-1]
[1,-1]
[0,1]
[1,1]
[-1,-1]
[1,1]
[1,0]

NNEESESSWWNW
[0,1]
[1,1]
[1,0]
[1,-1]
[0,-1]
[-1,-1]
[-1,0]
[-1,1]
[0,0]

NENENEE
[1,1]
[1,1]
[1,1]
[1,0]
[4,3]

NEN
[1,1]
[0,1]
[1,2]

EEE
[1,0]
[1,0]
[1,0]
[3,0]

Rules

You may output in any convenient format that doesn't violate loopholes.
You must consume greedily, NWE is never N,W,E, it is always NW,E.

This applies to: SW*, SE*, NW*, NE*.
You are consuming left to right, greedily.

The is code-golf, lowest byte-count wins.

"determine the coordinates I've traveled": I'm not sure if it does really match what's described afterwards. It's more like "determine the vectors of all my moves". Only the final output is actual coordinates.

Test case suggestion: 2 or more Es or Ws not preceded by an N or an S.

I'm pretty sure that SWSENNESWNE should give [0, 1] not [1, 0]

A test case that walks to [4, 3] or so would make it a little easier to see what's going on in the test output.

Are complex numbers formatted as 1, -1j, (-1+1j) etc a valid output format?

Based on the absence of this case in both the rules and examples given I assume the input-String will never end in an 'N' or 'S'?

@KevinCruijssen no. That's not mentioned anywhere. An example is added, by the spec that doesn't make sense.

@Lynn I suppose.

Is consuming greedily actually different than not?  Since NE is just N+E shouldn't it not matter?

@WhatWizard NEE outputs [1,1],[1,0] instead of [0,1][1,0][1,0] when you consume lazily? That's what I meant.

Python 2, 116 bytes
import re
a=[(int(s,35)%5-3,('N'in s)-('S'in s))for s in re.findall('[NS][EW]?|.',input())]
print a,map(sum,zip(*a))

Try it online!
With output as [(3+4j), 1, -1j, …], 91 bytes
lambda x:[sum(1j**(ord(c)%8%5)for c in s)for s in[x]+re.findall('[NS][EW]?|.',x)]
import re

Try it online!
This lambda returns a list of Gaussian integers: the first is the final coordinate, and all others are the steps required to get there.

Attache, 80 bytes
V#Sum##{Chop[1-ToBase[22260446188,3],2][Sum@Ords=>MatchAll[_,/"[NS][WE]|."]%11]}

Try it online!
This is an anonymous function which takes one string argument.
Explanation
The first task is to implement the parsing phase of this question. I found it shortest to use a simple Regex to parse the input (_):
MatchAll[_,/"[NS][WE]|."]

This matches all occurrences of the regex [NS][WE]|., as seen in many other answers. This greedily yields the requested directions.
Now, we're going to apply a hash function to each direciton. We take the codepoints of each direction and sum them. This gives the following mapping:
Direction       Ord-sum
E               69
N               78
S               83
W               87
NE              147
SE              152
NW              165
SW              170

We shall try to map these values to a smaller domain; modulo is useful for this, and we can demonstrate that the smallest modulo which results in unique values for all given inputs is 11. Sorting by remainders, this gives us the following table:
Direction       Ord-sum         % 11
NW              165             0
N               78              1
E               69              3
NE              147             4
SW              170             5
S               83              6
SE              152             9
W               87              10

Now, we have an input correspondence, as encoding by Sum@Ords=>[...]%11. Next, we have to transform these remainders into points. We shall try to derive another mapping, which means inserting "sparse-filling values" to hashes which do not correspond to directions shall be useful:
Direction       Hash        Coordinates
NW              0           [-1, 1]
N               1           [0, 1]
--             (2)          [0, 0]
E               3           [1, 0]
NE              4           [1, 1]
SW              5           [-1, -1]
S               6           [0, -1]
--             (7)          [0, 0]
--             (8)          [0, 0]
SE              9           [1, -1]
W               10          [-1, 0]

We currently have a series of points, which can gives a list indexable by the hash:
[-1, 1] [0, 1] [0, 0] [1, 0] [1, 1] [-1, -1] [0, -1] [0, 0] [0, 0] [1, -1] [-1, 0]

Now, we shall compress this, seeing as how its only composed of -1s, 0s, and 1s. Since the list represents pairs, we can flatten the list without losing data. Then, if we take each number x and calculate 1-x, we get the following list:
2 0 1 0 1 1 0 1 0 0 2 2 1 2 1 1 1 1 0 2 2 1

We can convert this into a base 3 number:
20101101002212111102213
Converting to base 10:
20101101002212111102213 ≡ 2226044618810
To summarize, we've taken our points, un-paired them, took each element subtracted from 1, and converted from base 3, giving us 22260446188. We can decompress as such:

Convert to base 3: ToBase[22260446188,3]
Take each number subtracted from one (self-inverse): 1-ToBase[22260446188,3]
Re-pair the list: Chop[1-ToBase[22260446188,3],2]

This gives us our original set of pairs. Then, we can perform the aforementioned indexing like this:
(chopped value)[hashes]

Since, in Attache, indexing by an array returns all elements corresponding to those indices. (So, [1,2,3,4][ [0,0,-1,1] ] = [1,1,4,2].) Now, we have the directions of the path that the OP walked. What's left is to calculate the sum.
So we capture this result in a lambda {...} and put it as the first function in a function composition (a##b), with the second being V#Sum. This is a fork, which, given input x, expands to be:
V[x, Sum[x]]

Sum, when given an 2D array, happens to sum every column in the array (as a result of vectorized summation). So, this pairs the directions with the final destination, and we have our final result.

JavaScript (ES6), 102 bytes
Returns a string.
s=>s.replace(/[NS][EW]|./g,s=>(D=d=>!!s.match(d),x+=h=D`E`-D`W`,y+=v=D`N`-D`S`,[h,v]+`
`),x=y=0)+[x,y]

Try it online!

I like the use of template functions! :D

@ConorO'Brien Yeah, they're pretty handy here. All the hashing sorcery spells that I've summoned so far are at least a bit longer.

MATL, 45 bytes
'NS' 'WE'Z*Z{2MhX{h'eklihfmj'X{YX9\3_2&YAqts

Try it online! Or verify all test cases.
Explanation (with example)
Consider input 'NSWE' as an example.
'NS' 'WE'  % Push these two strings
           % STACK: 'NS', 'WE'
Z*         % Cartesian product. Gives a 4×2 char matrix
           % STACK: ['NW'; 'NE'; 'SW'; 'SE']
Z{         % Cell array of rows (strings)
           % STACK: {'NW', 'NE', 'SW', 'SE'}
2M         % Push again the inputs of the second-last function call
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NS', 'WE'
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE'}, 'NSWE'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW', 'NE', 'SW', 'SE'}, {'N', 'S', 'W', 'E'}
h          % Concatenate horizontally
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}
'eklihfmj' % Push this string
           % STACK: {'NW', 'NE', 'SW', 'SE', 'N', 'S', 'W', 'E'}, 'eklihfmj'
X{         % Cell array of individual elements (chars)
           % STACK: {'NW','NE','SW','SE','N','S','W','E'},{'e','k','l','i','h','f','m','j'}
YX         % Implicit input. Regexp replace: replaces 'NW' by 'e', then 'NE' by 'k', etc.
           % Note that the two-letter combinations are replaced first, which implements
           % the greediness; and the target letters do not appear in the source, which
           % avoids unwanted interactions between replacements
           % STACK: 'hlj'
9\         % Modulo 9 (of codepoints), element-wise
           % STACK: [5, 0, 7]
3_2&YA     % Convert to base 3 with 2 digits. Gives a 2-column matrix
           % STACK: [1, 2; 0, 0; 2, 1]
q          % Subtract 1, element-wise
           % STACK: [0, -1; -1, -1; 1, 0]
tXs        % Duplicate. Sum of each column
           % STACK: [0, -1; -1, -1; 1, 0], [0, 0]
           % Implicit display

Java (JDK), 167 bytes
s->{var r="";int i=0,l=s.length,c,x=0,y=0,Y,X;for(;i<l;x+=X=c>1||i<l&&(c=~-s[i]/6%4)>1&&++i>0?c*2-5:0,r+=X+","+Y+" ")y+=Y=(c=~-s[i++]/6%4)<2?1-c*2:0;return r+x+","+y;}

Try it online!
Explanations
Thanks to c=~-s[i]/6%4, the following mapping is done:
'N' -> ascii: 78 -> -1 = 77 -> /6 = 12 -> %4 = 0
'S' -> ascii: 83 -> -1 = 83 -> /6 = 13 -> %4 = 1
'W' -> ascii: 87 -> -1 = 86 -> /6 = 14 -> %4 = 2
'E' -> ascii: 69 -> -1 = 68 -> /6 = 11 -> %4 = 3

NS is checked with c<2 and mapped to +1/-1 using 1-c*2;
EW is checked with c>1 and mapped to +1/-1 using c*2-5.

Credits

at the very least 9 bytes saved thanks to Kevin Cruijssen.
-4 bytes thanks to ceilingcat

Ah, you posted your Java answer while I was typing the explanation of mine. :) Since we both use a completely different approach I'll leave mine for now. Too bad variables used in lambdas need to be effectively final, otherwise you could have returned a String instead of a List to save bytes.

Thanks, it only saved a few bytes (4), but it's better than nothing ;)

@KevinCruijssen Thanks, it seemed rather obvious at first, but I was working on another approach which reduced my byte-count by more than 30. A "parsing" one, not a "matching" one.

@KevinCruijssen Yep, I do... ^^' Thanks!

Sorry, I changed totally the algorithm. It's now invalid :s

181 bytes. Nice approach with the /6%4 and *2-5. :)

Sigh.. 172 bytes

@KevinCruijssen Sorry, it's a mess integrating your changes... I'm taken at work and I forget to refresh this page... Thanks for all anyways ^^' The credit count is very likely below your actual credit. Sorry for that too :s

Retina 0.8.2, 93 bytes
.+
$&¶$&
\G[NS]?[EW]?
$&¶
G`.
W
J
%O`.
+`EJ|NS

m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Try it online! Explanation:
.+
$&¶$&

Duplicate the input.
\G[NS]?[EW]?
$&¶

Split the first copy up into directions.
G`.

Remove extraneous blank lines created by the above process.
W
J

Change W into J so that it sorts between E and N. (Moving E to between S and W would also work.)
%O`.

Sort each line into order.
+`EJ|NS

Delete pairs of opposite directions (this only affects the last line of course).
m`^((J)?[EJ]*)((S)?[NS]*)
$#2$*-$.1,$#4$*-$.3

Count the number of horizontal and vertical movements, adding signs where necessary.
Those of you who know the differences between Retina 0.8.2 and Retina 1 will want to point out that I can save 2 bytes in Retina 1 because it uses * instead of $*. While I was there I tried to simplify the splitting process but I was unable to reduce the byte count further, I was only able to equal it with this:
L$`$(?<=(.*))|[NS]?[EW]?
$&$1

Java 10, 269 265 243 238 224 219 bytes
s->{var r="";int x=0,y=0,t,X,Y,a;for(;!s.isEmpty();r+=X+"|"+Y+" ",s=s.substring(t+1)){a=s.charAt(t=0);var b=s.matches("[NS][EW].*");x+=X=b?1-s.charAt(t=1)/70*2:a<70?1:-a/87;y+=Y=b|a>69&a<87?1-a%2*2:0;}return r+x+"|"+y;}

-10 bytes thanks to @ceilingcat.
Try it online.
Explanation:
s->{                  // Method with String as both parameter and return-type
  var r="";           //  Result-String, starting empty
  int x=0,            //  Ending `x`-coordinate, starting at 0
      y=0,            //  Ending `y`-coordinate, starting at 0
      t,X,Y,a;        //  Temp-integers
  for(;!s.isEmpty()   //  Loop as long as the input-String is not empty yet:
      ;               //    After every iteration:
       r+=X+"|"+Y+" ",//     Append the current steps to the result-String
       s=s.substring(t+1)){
                      //     Remove the first `t+1` characters from the input-String
    a=s.charAt(t=0);  //   Set `a` to the first character of the input to save bytes,
                      //   and reset `t` to 0
    var b=s.matches("[NS][EW].*");
                      //   Check if the input-String starts with N/S followed by E/W
    x+=X=             //   Set `X` to (and increase `x` by `X` afterwards):
      b?              //    If the boolean check was truthy:
        1-s.charAt(t=1)/70*2
                      //     Set `X` to 1 if 'E', -1 if 'W'
                      //     And set `t` to 1
       :              //    Else:
        a<70?1:-a/87; //     Set `X` to 1 if 'E', -1 if 'W', 0 if 'N' or 'S'
    y+=Y=             //   Set `Y` to (and increase `y` by `Y` afterwards):
      b|a>69&a<87?1-a%2*2
                      //    Set `Y` to 1 if 'N', -1 if 'S'
       :              //    And if the boolean check was falsey:
        0;}           //     Set `Y` to 0 if 'E' or 'W'
  return r+x+"|"+y;}  //  Append the ending coordinates, and return the result-String

Java answers get points though cause everyone gets them :).

@MagicOctopusUrn True. :) And I still enjoy golfing in Java, even though you'll never be the shortest.. Unless you're the only one to answer (got two accepted Java answers.. XD). For this challenge however, the Java answer by OlivierGrégoire is about 70 bytes shorter, so most upvotes should go to him.

APL (Dyalog Unicode), 40 32 bytes
2((⊢,+/)1⊥¨0j1*⊢⊂⍨1,2≤/|)'NWS'∘⍳

Try it online!
It turns out that we don't need PCRE.
How it works
2((⊢,+/)1⊥¨0j1*⊢⊂⍨1,2≤/|)'NWS'∘⍳
                         'NWS'∘⍳  ⍝ V←Map 'NWSE' into 1,2,3,4
2(                     |)  ⍝ Modulo 2 (1 if NS, 0 otherwise)
                    2≤/    ⍝ For each consecutive pair,
                           ⍝ 0 if [NS][EW] combination, 1 otherwise
                  1,  ⍝ Add a leading 1
               ⊢⊂⍨    ⍝ Chunkify V at ones
           0j1*  ⍝ Power of imaginary unit
        1⊥¨      ⍝ Sum within each chunk
  (⊢,+/)  ⍝ Append the grand total to the vector

APL (Dyalog Unicode), 40 bytes
(⊢,+/)1⊥¨0j1*(⊂'NWS')⍳¨'[NS][EW]|.'⎕S'&'

Try it online!
Uses PCRE to divide into segments, and then the power of 0j1 (imaginary unit) to convert the directions to complex numbers. EW is mapped to the real part (E being positive) and NS to the imaginary part (N being positive).
9 11∘.○ in the footer converts the vector of complex numbers into a two-row matrix, by splitting each complex number into its real (top row) and imaginary (bottom row) parts.
How it works
(⊢,+/)1⊥¨0j1*(⊂'NWS')⍳¨'[NS][EW]|.'⎕S'&'
                       '[NS][EW]|.'⎕S'&'  ⍝ Regex search; split into greedy segments
             (⊂'NWS')⍳¨  ⍝ Index of each char within 'NWS' (1 2 3)
                         ⍝ 'E' becomes 4 since it is not found
         0j1*  ⍝ Power of imaginary unit
      1⊥¨      ⍝ Sum within each segment
(⊢,+/)         ⍝ Append its sum on its right

Perl 5 -n, 94 74 bytes
map{say$v=/N/-/S/,',',$h=/E/-/W/;$y+=$v;$x+=$h}/[NS][EW]?|E|W/g;say"$x,$y"

Try it online!

With a little messing around, managed to reduce this to 58 bytes: Try it online!

JavaScript (ES6), 102 bytes

f=
s=>s.replace(/((N)|(S))?((E)|(W))?/g,(m,v,n,s,h,e,w)=>(x+=h=!w-!e,y+=v=!s-!n,m?[h,v]+`
`:[x,y]),x=y=0)
<input oninput=o.textContent=/[^NSEW]/.test(this.value)?``:f(this.value)><pre id=o>0,0

Returns a string.

F# (Mono), 269 bytes
let f s=
 let l,h=(string s).Replace("NW","A").Replace("NE","B").Replace("SW","C").Replace("SE","D")|>Seq.map(function 'N'->0,1|'S'->0,-1|'W'-> -1,0|'E'->1,0|'A'-> -1,1|'B'->1,1|'C'-> -1,-1|'D'->1,-1)|>Seq.mapFold(fun(x,y) (s,t)->(s,t),(x+s,y+t))(0,0)
 Seq.append l [h]

Try it online!

Hi, welcome to PPCG. Unfortunately your're missing the last item of your output, which should be the position where you ended. So for the NSWE you are currently outputting (0,1), (-1,-1), (1,0), but a fourth output should be the sum of those coordinates, so (0,0) (because 0+-1+1 = 0 and 1+-1+0 = 0).

@KevinCruijssen OK, I didn't catch that. Made an update.

Seems to work great now, so +1 from me. Enjoy your stay! :) And in case you haven't seen it yet, Tips for golfing in F# and Tips for golfing in  might be interesting to read through.

Ruby, 75 71 bytes
->x{[*x.scan(/[NS][EW]?|./),x].map{|s|s.chars.sum{|c|1i**(c.ord%8%5)}}}

Try it online!
-4 bytes thanks to benj2240.
Since returning complex numbers looks to be an acceptable output format, I guess it won't get much golfier than just making a port of the very nice Lynn's answer.

Very nice. you can save a few bytes by skipping the inner map, passing its block directly to sum: Try it online!

sed, 125
The taking liberties with output format version:
Score includes +1 for the -r parameter to sed.
s/(N|S)(E|W)/\L\2,\1 /g
s/N|S/,& /g
s/E|W/&, /g
s/N|E/A/gi
s/S|W/a/gi
p
:
s/(\S*),(\S*) (\S*),(\S*)/\1\3,\2\4/
t
s/Aa|aA//
t

Try it online.
Output is as follows:

coordinate elements are comma-separated
each set of coordinates are TAB-separated
the final coordinate is on a new line
all numbers are in ℤ-unary:

a string of A characters represents the +ve integer len(string)
a string of a characters represents the -ve integer -len(string)
the empty string represents 0

For example:

, is [0,0]
,AA is [0,2]
aaa, is [-3,0]

sed 4.2.2 including GNU exec extension, 147
The sensible output format version:
Score includes +1 for the -r parameter to sed.
s/(N|S)(E|W)/\L\2 \1\n/g
s/N|S/0 &\n/g
s/E|W/& 0\n/g
s/N|E/1/gi
s/S|W/-1/gi
p
:
s/(\S+) (\S+)\n(\S+) (\S+)/\1+\3 \2+\4/
t
s/\S+/$[&]/g
s/^/echo /e

Output is given as space-separated coordinates, one per line.  There is an extra newline between the penultimate and ultimate sets of coordinates - not sure if that is problematic or not.
Try it online!

PHP, 153 bytes
let a regex do the splitting; loop through the matches, print and sum up the intermediate results:
preg_match_all("/[NS][EW]?|E|W/",$argn,$m);foreach($m[0]as$s){$x+=$p=strtr($s[-1],NEWS,1201)-1;$y+=$q=strtr($s[0],NEWS,2110)-1;echo"$p,$q
";}echo"$x,$y";

Run as pipe with -nR or try it online.

C (gcc), 173 bytes
It's interesting doing this one in a language with no regex support!
f(char*s){char*t="[%d,%d]\n";int x[4]={0},i;for(;*s;*x=x[1]=!printf(t,x[1],*x))for(i=-1;i<5;)if(*s=="S NW E"[++i]){x[i/3+2]+=x[i/3]=i%3-1;i+=2-i%3;s++;}printf(t,x[3],x[2]);}

Try it online!

164 bytes


text:
Getting the Vowel Square
Challenge
You will create a function which takes a matrix filled with letters from the alphabet and determine if a 2x2 square composed of vowels exists.

If a 2x2 square of vowels is found, your function should return the top-left position (row-column) of the square.
If no 2x2 square of vowels exists, then return the string "not found".
If there are multiple squares of vowels, return the one that is at the most top-left position in the whole matrix.

Rules

Matrix must be at least 2x2
Matrix can only contain letters from the alphabet
Input can be a String, where each line is separated by \n, ,, ., \t (\n means line break and \t TAB) or an array of strings.
Vowels are a e i o u.

Example
Given ["abcd", "eikr", "oufj"]
a   b   c   d
e   i   k   r
o   u   f   j

Output: 1-0

Given ["gg", "ff"]
g   g
f   f

Output not found

Test Cases
Given ["asd", "qie", "euo"]
a s d
q i e
e u o

Output: 1-1
Given ["aqrst", "ukaei", "ffooo"]
a   q   r   s   t
u   k   a   e   i
f   f   o   o   o

Output: 1-2
Given ["ghsdfhsd", "sdfgsdff", "sdfgsdfg"]
g   h   s   d   f   h   s   d
s   d   f   g   s   d   f   f
s   d   f   g   s   d   f   g

Output: "not found"

Consider the examples as test cases as well

Update

If you are going to use 1-based index, please clarify it in your answer.

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

If there are multiple squares of vowels, return the one that is at the most top-left position in the whole matrix. What should happen with that test case : [[p,d,e,o],[w,v,a,i],[e,u,n,c],[e,e,w,v]] ?

@Therandomguy You will take the one that is at the most top-left, so first check the top and then the left. The result in that test case would be 0-2

I'd recommend relaxing the return if nothing is found to either a false value or an impossible value, rather than a string

@LuisfelipeDejesusMunoz I phrased my question poorly; can we consistently take only uppercase letters or only lowercase letters in the matrix?

@Giuseppe. Yes. Sorry, i misunderstood the question.

Having to return an index pair or a string makes this unnecessarily cumbersome in strictly typed languages.

Agreeing with Dennis, returning any falsy value would seem reasonable.

This challenge is taken from coderbyte, which is not allowed.

@Laikoni It's allowed to take the challenge from somewhere else and rewrite the statements. Although {@}OP you should link to the source.

Python 2, 121 bytes
import re
s=input()
w=s.find(',')
v='[aeiou]'*2
m=re.search(v+'.'*~-w+v,s)
print m and divmod(m.start(),-~w)or'not found'

Try it online!
I feel like I don't get to use divmod often in Python, haha.
Takes input like "aqrst,ukaei,ffooo".
Explanation
We compute the width w of the matrix by finding the position of the first ,: in this case, that's 5.
Then, we build the regex [aeiou][aeiou]....[aeiou][aeiou] with (w − 1) dots: to match vowels on the next row, we skip (one row − 2 letters + 1 comma) = (w − 1) characters we don't care about.
To turn m.start() back into coordinates, we divmod by (w + 1) (minding the comma).

JavaScript (ES6), 89 88 bytes
Saved 1 byte thanks to @RickHitchcock
Takes input as a comma-separated string.
s=>~(k=s.search((v='[aeiou]{2}')+`.{${(w=s.search`,`+1)-2}}`+v))?[k/w|0,k%w]:'not found'

Try it online!

Python 3, 143 132 130 129 bytes

Thanks to musicman523 for golfing eleven bytes; golfed {m[y][x],m[y][x+1],m[y+1][x],m[y+1][x+1]} to {*(m[y][x:x+2]+m[y+1][x:x+2])}.
Thanks to ovs, golfed {...}<={*"aeiou"} to {...}<{*"aeiou"}; using the fact that five vowels do not fit into four cells.

lambda m:([(y,x)for y in range(len(m)-1)for x in range(len(m[y])-1)if{*(m[y][x:x+2]+m[y+1][x:x+2])}<{*"aeiou"}]+["not found"])[0]

Try it online!

Also another interesting but longer solution, but worth posting in case it inspires someone else: Python 3 139 bytes

@musicman523 Thanks; when using Python 3, one can also use the splat operator on strings: {*"aeiou"}.

You can use < instead of <= as the 2x2 square will never contain all vowels

@ovs Wow. true.

Java 8, 156 bytes
m->{for(int i=0,j;++i<m.length;)for(j=0;++j<m[i].length;)if((m[i][j]+m[i][j-1]+m[i-1][j]+m[i-1][j-1]).matches("[aeiou]+"))return i+"-"+j;return"not found";}

1-indexed output.
Try it online.
m->{                           // Method with String-matrix input and String return-type
  for(int i=0,j;++i<m.length;) //  Loop over the rows, skipping the first
    for(j=0;++j<m[i].length;)  //   Inner loop over the columns, skipping the first
      if((m[i][j]+m[i][j-1]+m[i-1][j]+m[i-1][j-1])
                               //    If four characters in a square appended to each other,
         .matches("[aeiou]+")) //    are only vowels
        return i+"-"+j;        //     Return the 1-indexed output
  return"not found";}          //  Return "not found"

Jelly, 26 bytes
e€€ØcaƝ⁺€T€µT,FZḢȯ“¤Ø#"ȯ"»

Indexing is 1-based.
Try it online!

Retina 0.8.2, 82 bytes
(.*¶)*?(.)*?[aeiou]{2}.*¶(?>(?<-2>(.))*)[aeiou]{2}(.|¶)*
$#1-$#3
^[^-]*$
not found

Try it online! Explanation:
(.*¶)*?

Match an optional number of rows which are stacked into capture group 1.
(.)*?

Match an optional number of columns which are stacked into capture group 2.
[aeiou]{2}

Match two vowels.
.*¶

Match the rest of the line.
(?>(?<-2>(.))*)

Match an equal number of columns on the next line, which are stacked into capture group 3, as the matching empties the capture group 2 stack.
[aeiou]{2}

Match two more vowels.
(.|¶)*

Match the rest of the input.
$#1-$#3

If there's a match, replace the entire input with the number of rows and columns matched.
^[^-]*$
not found

If the input doesn't yet contain a - then the match must have failed.

Jelly, 35 bytes
FḟØcṆ
ZÇ€T,€
ṡ€2ṡ2ç"JṖFḣ2Uȯ“¤Ø#"ȯ"»

Try it online! (comes with test-suite)
Way too long, but I guess it'll improve. Uses 1-based indexing.

APL+WIN, 73 bytes
Prompts for character matrix input:
z←,(,r)/(⍴r)⊤(⍳⍴,r←<⍀<\(2^/m,0)×2^⌿(m←⎕∊'aeiou')⍪0)⋄z,(~×⍴z)↑⊂'not found'

Python 2, 134 bytes
f=lambda m,i=0,y=0:m[i+1:]and(m[i][y+1:]and(set(m[i][y:y+2]+m[i+1][y:y+2])<set('aeiou')and(i,y)or f(m,i,y+1))or f(m,i+1))or'not found'

Try it online!

Haskell, 146 140 bytes
l x=[0..length x-2]
h x|p<-(!!).(x!!)=([show(i,j)|i<-l x,j<-l(x!!0),all(`elem`"aeiou")[p i j,p(i+1)j,p i$j+1,p(i+1)$j+1]]++["not found"])!!0

Try it online!
Explanation
This just generates a list of possible indices, nothing special:
l x=[0..length x-2]

This is just a little helper, that allows quickly accessing the element at (i,j) with p i j (due to operator precedence it's shorter not to use an operator):
    p<-(!!).(x!!)

This generates a list with all the indices (as strings...) of 2x2 sub-matrices that consist of vowels in order:
h x|             = [show(i,j)|i<-l x,j<-l(x!!0),all(`elem`"aeiou")[p i j,p(i+1)j,p i$j+1,p(i+1)$j+1]]

Now we just need to append the "not found" string:
                  (                                                                                ++["not found"])

This way we can simply retrieve the first element in this list (since it's generated in order and in case of no such indices, there's always the "not found" string):
                                                                                !!0

J, 61 bytes
[:'not found'"_`($#:t)@.(#@,~:t=.4:i.~,)2 2+/@,;.3'aoeiu'e.~]

Try it online!
Explanation:
   ] a =. 'asd','qie',:'euo'   Let `a` be the first test case
asd
qie
euo
  'aoeiu'e.~] a        creates an equality table between the input and the vowels
1 0 0
0 1 1
1 1 1

2 2<;.3'aoeiu'e.~] a      2 2 u ,. 3 x splits the table into 2x2 overlapping windows
┌───┬───┬─┐
│1 0│0 0│0│
│0 1│1 1│1│
├───┼───┼─┤
│0 1│1 1│1│
│1 1│1 1│1│
├───┼───┼─┤
│1 1│1 1│1│
└───┴───┴─┘

I need to check if all the 4 chars are vowels, so I add the numbers
(reduce with addition +/ the flattened list):
    2 2+/@,;.3'aoeiu'e.~] a
2 2 1
3 4 2
2 2 1
   (t=.4:i.~,)2 2+/@,;.3'aoeiu'e.~] a   flattens the list, finds the first
4                                        occurence of 4 in it and saves it in `t`

If 4 is not found J returns the length of the list. That's why I compare the result
    with the length of the flattened list:
   (#@,~:t=.4:i.~,)2 2+/@,;.3'aoeiu'e.~] a    (0 means not found; 1 - found)
0

u`v@.y     '@.' is 'agenda' - checks the value of y and uses it as an index to the
train of verbs on the left. 0 > u; 1 -> v and so on.

If 0, it simply returns 'not found'
If 1, finds the position by converting the index to a pair of numbers in a number system
    denoted by the size of the input $#:t:
  3 3#:4          (t is the index of 4, #: convert to antibase, the base is
1 1               the shape of the table, $)