text:
Thinking outside the box - Am I doing it right?
I keep hearing that thinking outside the box is a goal worth achieving, but how can I tell if I'm successfully doing it?
To solve this dilemma I have already wrote a Brainwave-to-ASCII-translator which in theory should produce outputs like
                    #
   +------------+   #
   |   thinking |   #
   |            |   #
   +------------+   #
                    #

or
                   #
 +------+          #
 |      | thinking #
 |      |          #
 |      |          #
 +------+          #
                   #

which make it fairly easy to tell whether one is thinking outside the box or not. (The # are not part of the output and represent new lines.)
However, due to a bug sometimes only a smaller section of the output is returned:
   |         |         #
   +---------+         #
    thinking           #

        #
       +#
       |#
inking |#

    #
    #

The Task
Please help me to automatically classify the Brainwave-to-ASCII-translator output by writing a program or function which reads an ascii-reprensentation and returns whether thinking is in the box, outside of it or it could not tell from the input.
Input
A set of same-length strings either as a list or delimited by newlines containing

the string thinking or valid pre- or suffixes thereof
the characters +-| forming a rectangular box or valid parts of it
spaces
NO #, those are only included in the challenge to mark the ends of the input lines.

Output

a truthy value if thinking is outside the box
a falsy value if thinking is in the box
a distinct third maybe value if it can not be determined from the input whether thinking is in the box or not

Examples
Truthy:
                   #
 +------+          #
 |      | thinking #
 |      |          #
 |      |          #
 +------+          #
                   #

   |         |         #
   +---------+         #
    thinking           #

        #
       +#
       |#
       |#
inking |#

thinking #
-------+ #

 ++ # (thinking is not in the box, so it must be outside)
 ++ # (this is also the smallest possible box)

+ #
 t#

+----+# (The box is not wide enough to contain "thinking")

---# (The box is not high enough to contain "thinking")
---#

As string input:
"                   \n +------+          \n |      | thinking \n |      |          \n |      |          \n +------+          \n                   "
"   |         |         \n   +---------+         \n    thinking           "
"        \n       +\n       |\n       |\ninking |"
"thinking \n-------+ "
" ++ \n ++ "
"+ \n t"
"+----+"
"---\n---"
"g++"
"k\n+"

Falsy:
                    #
   +------------+   #
   |   thinking |   #
   |            |   #
   +------------+   #
                    #

  +---------------#
  |               #
  |               #
  |   thinking    #

      | #
king  | #
------+ #

+---#
|thi#
+---#

-#
n#
-#

As string input:
"                    \n   +------------+   \n   |   thinking |   \n   |            |   \n   +------------+   \n                    "
"  +---------------\n  |               \n  |               \n  |   thinking    "
"      | \nking  | \n------+ "
"+---\n|thi\n+---"
"-\nn\n-"

Maybe:
thinking#

g|#

think#
-----#

|          |# (box large enough to possibly contain the string)
|          |#

   +--#
   |  #

# (empty input)

As string input:
"thinking"
"g|"
"|t"
"-\ni"
"h\n-"
"think\n-----"
"|          |\n|          |"
"   +--\n   |  "
""

Rules

This is code-golf, so try to use as few bytes as possible.
The maybe value can be chosen freely as long as it's different from the truthy/falsy value and is the same for all maybe-inputs. It can also be an error.
You can assume that the input is always valid (eg. contains no other chars than +-ghiknt|, no more than one box, ...).

Idea for truthy test case: +\n+, box too small for a word

@DestructibleWatermelon Thanks, I'll add a similar test case.

You don't have the most basic cases in your test cases. Mind including the entire box with thinking in it, and the entire box with the entire word thinking outside it?

Is there a possiblity of the word overlapping the box(thinking on the box)?

@MukulKumar No, thinking and the box will never overlap.

@ATaco I included them in the string testcases now.

Must the box have at least one - or | on each side? Or can it look like +---+\n+---+, ++\n++ or even +?

@feersum The minimal box is "++\n++".

This is a boundary case nightmare, jeez.

Javascript (ES6), 274 263 bytes
f=(a,b=(b,c="")=>a=a.replace(b,c),c=b=>b.test(`,${a},`))=>(b(/\w+/,5),b(/\+/g,1),b(/\-/g,2),b(/\|/g,3),b(/\n/g,4),c(/[13][2 ]{0,7}[13]|[12] *4 *[12]/)||(b(/ /g),b(/43+(?=4)/g),!c(/353|24542|12+435|21453|35412|5342+1/)&&(!c(/^([^1]*|([^15]*1){1,2}[^15]*)$/)||-1)))

The function f returns true, false, or -1 as its "maybe" value. It should be called with one argument: the input. The other two parameters only exist to shorten the code.
Here's a less golfed version with comments:
var f = (input) => {
    var replace = (re, s) => input = input.replace(re, s);
    var test = re => re.test(input);

    /*
        Replace some "special" characters with ones that are shorter to put in a regex.
        "+" --> "1"
        "-" --> "2"
        "|" --> "3"
        "\n" --> ","
    */
    replace(/\+/g,1);
    replace(/\-/g,2);
    replace(/\|/g,3);
    replace(/\n/g,',');

    /*
        Shorten the word, if there is one, to just a single character "a".
    */
    replace(/[a-z]+/g,'a');

    /*
        Append a newline to the beginning and end of the input.
    */
    input = ','+input+',';

    /*
        Test the size of the box. These are the cases covered:
        /[13][2 ]{0,7}[13]/ : A horizontal edge or middle section has an inner width of fewer than 8 characters.
        /[12] *, *[12]/     : There are two horizontal edges in a row, with no space between.

        If either of these match, the word must be outside of the box. Return the truthy value (true).
    */
    if (test(/[13][2 ]{0,7}[13]|[12] *, *[12]/)) return true;

    /*
        Remove any spacing from the input. It it unnecessary from this point onwards.
    */
    replace(/ /g,'');

    /*
        Remove any lines with only vertical bars. These are also unnecessary.
    */
    replace(/,3+(?=,)/g,'');

    /*
        Edge / corner cases (heh). These are the cases covered:
        /3a3/    : two vertical bars with the word between.
        /2,a,2/  : two horizontal bars with the word between.
        /12+,3a/ : word inside the top left corner.
        /21,a3/  : word inside the top right corner.
        /3a,12/  : word inside the bottom left corner.
        /a3,2+1/ : word inside the bottom right corner.

        If any of these match, the word is inside the box. Return the falsy value (false).
    */
    if (test(/3a3|2,a,2|12+,3a|21,a3|3a,12|a3,2+1/)) return false;

    /*
        "Maybe" cases. These are the cases covered:
        /^[^1]*$/                : Input contains no corners, and may or may not contain a word.
        /^([^1a]*1){1,2}[^1a]*$/ : Input contains 1 or 2 corners, and no word.

        If either of these match, assuming the previous test cases have not been hit,
        we cannot tell if the word is inside or outside the box. Return the maybe value (-1).
    */
    if (test(/^([^1]*|([^1a]*1){1,2}[^1a]*)$/)) return -1;

    /*
        If none of the previous cases matched, the word must be outside of the box. Return the truthy value (true).
    */
    return true;
};

Had a lot of fun with this one. Thanks!
Edit: Saved 6 bytes thanks @L. Serné by modifying b to use a default argument, saving 3 bytes, and changing [a-z] to \w, saving 3 more bytes. Also saved 5 more bytes by making the word replacement non-global, saving 1 byte, and changing "a" to 5 and "," to 4, saving 4 bytes.

Tried with console.log(f("input")). Seems to work. Great job on golfing this.

Nice job on the answer. I tried answering this, and I got stuck halfway. I noticed 2 small byte-savers: change b=(b,c) to b=(b,c=""), and then you can remove the last argument of the two calls to b with an empty string as second argument, saving (2*3-3=) 3 bytes in total. Also, you can shorten the word regex from [a-z]+ to \w+ (do this before the other replaces, because this will also match digits) saving 3 more bytes.

Welcome to PPCG and nice first answer!

Awarded bounty. Shortest answer. Great job, amazing answer.

Python 2.7, 532 494 453 bytes
This one sure had a lot of special cases. My truthy and falsy values are the strings "True" and "False" respectively. My maybe value is an Index Error, as they're easy to trigger and one of my test cases triggers it if the input is an empty string, which is a maybe case anyway. I made use of regular expressions quite a bit.
I don't golf in python often, so I'm sure this could be golfed down more, but here's my code:
import re
def e(s):exit(str(s))
i=input()
T=1<2
F=2<1
a=len(i)+1
c=i.count('+')
s='[a-z]'
x=re.search
p=x(s,i)
k=x('\+.*'+s,i)
l=x(s+'.*\|',i)
r=x('\|.*'+s,i)
f=i.find('+')
g=i[f-1]=='-'and f>0
if x('\-.*\n.*\-',i):e(T)
if x('\+.{0,7}\+',i):e(T)
if c>1 and not p:i[a]
if c>3:e(not(r and l))
if c>0:
 if r and l:e(F)
 if g:
    if l:e(F)
    if p or k:e(T)
    i[a]
 if r or k:e(F)
 if p:e(T)
 i[a]
if x('-.*\s[a-z].*\s-',i):e(F)
if x('\|.*[a-z].*\|',i):e(F)
i[a]

In my golfed version, I display the True/False answer by calling exit(bool as string). Here's a commented version, in which the exit statements are replaced with return statements, and everything's been moved into a function:
import re
i=input()
T=True
F=False
def z():
    # some variables and shortcuts useful for testing

    # length of input +1. Used to throw an index out of bounds error on 'maybe'
    a=len(i)+1
    # c for i.Count()
    c=i.count
    # string used in regular expressions often
    s='[a-z]'
    # shorten regeX calls
    x=re.search
    # p is true is 'thinking' is Present on canvas
    p=x(s,i)
    # k is true if 'thinking' is Right of a 'Korner' (corner)
    k=x('\+.*'+s,i)
    # l is true if 'thinking' is Left of a pipe (|)
    l=x(s+'.*\|',i)
    # r is true if 'thinking' is right of a pipe
    r=x('\|.*'+s,i)
    # f is First corner (+) index
    f=i.find('+')

    # g is true if box is facing riGht (i.e. there is a dash before the first +)
    # for example, '---+' indicates the box faces right. if the + is the 0th
    # character, then the box must be facing left.
    # Note that this assignment also checks for the empty string 'maybe'
    # case, which is signalled by an IndexOutofBounds error
    # CASE 1: Empty Input
    # ex: ''
    g=i[f-1]=='-' and f>0

    # Begin testing all possible scenarios

    # CASE 2: Box is too short (vertically)
    # ex: ------
    #     ------
    if x('\-.*\n.*\-',i):return T

    # CASE 3: box is too short (horizontally)
    # ex: ||
    if x('\+.{0,7}\+',i):return T

    # CASE 4: box is not too short yet no corners (+) or text are present on canvas
    # ex:
    # |       |         --------
    # |       |   or
    # |       |         --------
    # this is a maybe case, so throw out of bounds error
    if c('+')>1 and not p:i[a]

    # CASE 5: Four corners visible (whole box visible)
    # ex: +---+
    #     | X |
    #     +---+
    # return false if text is both right of and left of pipes (i.e. in box)
    if c('+')>3:return not(r and l)

    # CASE 6: one or two corners visible
    # ex:
    # ----+        |    |          |
    #     |    or  +----+   or  ---+  etc
    # ----+
    # in this case, we idenify which way the box faces
    if c('+')>0:

        # CASE 6-A: Text is between two pipes
        # ex:
        #     |   X   |
        #     +-------+
        # if text is between pipes (box is extending from top or bottom of
        # canvas), then it is inside box
        if r and l:return F

        # CASE 6-B: Box faces right
        # if the box is riGht-facing, ex:
        # ----+
        #     |    or  ----+  etc
        # ----+            |
        if g:

            # CASE 6-B-a: Letters are left of a pipe or a + in a right facing box
            # ----+
            #  X  |   or  ----+
            # ----+         X |
            if l :return F

            # CASE 6-B-b: Letters are right of a pipe or + in a right facing box
            # ----+
            #     | X  or  ----+
            # ----+            | X
            if p or k:return T

            # CASE 6-B-c: right-facing otherwise
            # otherwise, it is a 'maybe' case
            # use an index out of bounds error to signal 'maybe'
            i[a]

        # CASE 6-C: Box faces left (or letters are on canvas yet not inside box)
        # ex:
        #   +----
        #   |        or   +---  or
        #   +----         |
        else:

            # CASE 6-C-a: Letters are right of a pipe or a + in a left facing box
            # if letters are right of pipe, they are inside box, ex:
            #   +----
            #   | X       or   +---  or X +---
            #   +----          | X        |
            if r or k:return F

            # CASE 6-C-b: Letters are left of a pipe in a left facing box
            # ex:
            #     +----
            #   X |        or     +---
            #     +----         X |

            # CASE 6-C-c: Letters are on canvas yet not left or right of
            # a pipe or a + (they must therefore be outside the box)
            # ex:
            #  |     |
            #  +-----+
            #     X
            if p:return T

            # CASE 6-C-d: text is not visible on canvas, and only part of the box is
            # ex:
            #  |     |
            #  +-----+
            #
            # this is a 'maybe' case, as text is off canvas
            # use an index out of bounds error to signal 'maybe'
            i[a]

    # CASE 7: No corners visible, nonempty input

    # CASE 7-A: No corners visible, letters sandwitched between dashes
    # ex:
    # -----
    #   X
    # -----
    # if there are no corners, yet letters are sandwitched between dashes,
    # then word is in box
    if x('-.*\s[a-z].*\s-',i):return F

    # CASE 7-B: No corners visible, letters sandwitched bewteen pipes
    # ex: |  X  |
    # in this case, word is inside box
    if x('\|.*[a-z].*\|',i):return F

    # If none of the above cases are met, it is a maybe, so throw the error
    i[a]

print z()

My solution assumes that the input is valid, i.e. 'Thinking' (or its substrings) are spelled correctly, there is only a single box, etc.
Edit: Saved 10 bytes thanks to @ais523's suggestion to change c to i.count('+'), 3 bytes thanks to @Pavel's suggestion of replacing True with 1<2 and False with 2>1, 23 bytes by removing an unneeded else block, and 2 bytes by removing some spaces.
Edit 2: Saved 36 bytes thanks to @Wheat Wizard who kindly pointed out that my 'tabs' were actually 5 spaces (D'oh!) and suggested some other improvements.

Impressive. Someone actually did it.

I think i never changes, right? So you could probably save some bytes by storing i.count('+') in c rather than i.count, as you never call it with any argument but +.

You can replace true and false with 1<2 and 2<1, right?

You don't have to carriage return and indent in your function definition.  As far as I can tell you are using 4 spaces for indentation.  You can indent to depth one using a single space and depth 2 with a single tab.

@WheatWizard well this is embarassing... looks like Atom was converting tabs to 4 spaces. Thanks for the advice, it shaved off 36 bytes!

I think there's a typo -- if c>1 and not p:i[a] should be if c<1 and not p:i[a]. This causes the case where the input contains a box large enough to store the word, but no word, to result in the maybe value rather than the truthy one. In fact, I think this case may be able to be removed entirely, since the maybe value is covered at the end, although I haven't tested it.

Befunge, 535 bytes
This isn't pretty, and doesn't come close to competing with the existing answers, but it's the best I could achieve in Befunge.
Returns 1 if thinking outside the box, 0 if thinking inside the box, and -1 for maybe.
p10p20p130p140p150p9-:60p70p"~":80p90pvp8p04+1:g04p03:$p9g04+g9g\<<
0$$$$"xxxx"5p041p031p$_v#!-+55:_v#`0:~<p05+1g
v01g04$_v#*`\"|"\`"-"::<>0g\8\p"0"-!!40g1-\8\p:4-!:00g0`*!:00g\6\p40g\8\p00g!*4v
>p50g20p>8%:30g88+*+:3-v4v\-1g05!!*-"3"\-"4"::p\7\g05!!-3:+*+88g8g04:p00+g00*g0<
v!*-"3"\-"5"::p\6\g04!!<!>>7\p::"C"-\"3"-*!!50g\9\p"0"-!!50g1-\9\p:5-!:40g9g48*v
>!40g1-\6\p::"S"-\"3"-*!^>0#4g#p9#\g#94#\8#g*#0-#5!#p*#\5#70#\g#-*^#84g9g04:!*`<
>80g60g-8`90g70g-1`**+!:10g80g`60g10g`20g90g`70g20g`+++!!*\!-.@
^!g01***`"}"g09`"}"g08`g070`g060<

Try it online!


text:
Reverse Deltas of an Array
A continuation of Inverse Deltas of an Array
Your task is to take an array of signed 32 bit integers, recompile it with its deltas reversed.
Example
The List,
18  19  17  20  16

has the deltas:
   1  -2   3  -4

which, when reversed, yields:
  -4   3  -2   1

then when recompiled, using yields:
18  14  17  15  16

which should be your return value.
Recompiling consists of taking the C, which is the first value of the array. In this case, 18, and applying the deltas to it in order.
So 18 + -4 gives 14, 14 + 3 gives 17, and so on.
Input/Output
You will be given a list/array/table/tuple/stack/etc. of signed integers as input through any standard input method.
You must output the modified data once again in any acceptable form, following the above delta reversing method.
You will receive N inputs where 0 < N < 10 where each number falls within the range -1000 < X < 1000
Test Cases
1 2 3 4 5      -> 1 2 3 4 5
18 19 17 20 16 -> 18 14 17 15 16
5 9 1 3 8 7 8  -> 5 6 5 10 12 4 8
6 5 4 1 2 3    -> 6 7 8 5 4 3

Notes

As stated in above, you will always receive at least 1 input, and no more than 9.
The first and last number of your output, will always match that of the input.
Only Standard Input Output is accepted
Standard loopholes apply
This is code-golf, so the lowest byte-count wins!
Have fun!

And the winner is...
Dennis! Who firstly took the first place, then beat himself with a shorter solution, giving himself both the first and second place!
Honorable mention to ais523 with their Jelly, that if not for Dennis getting in just before them, would have held the second place.

These delta challenges have only proven how unneeded deltas are in mathematics.

how unneeded deltas are in mathematics One of the most important branches of mathematics is based on (infinitesimally small) deltas

I am still a not happy chappy

I can't C a mathematical challenge on ppcg...:P

Jelly, 5 bytes
.ịS_Ṛ

This uses the algorithm from Glen O's Julia answer.
Try it online!
How it works
.ịS_Ṛ  Main link. Argument: A (array)

.ị     At-index 0.5; retrieve the values at the nearest indices (0 and 1). Since
       indexing is 1-based and modular, this gives the last and first element.
  S    Compute their sum.
    Ṛ  Yield A, reversed.
   _   Subtract the result to the right from the result to the left.

Dennis Please

Jelly, 6 bytes
I;ḢṚ+\

Try it online!
How it works
I;ḢṚ+\  Main link. Argument: A (array)

I       Increments; compute the deltas of A.
  Ḣ     Head; yield the first element of A.
 ;      Concatenate the results to both sides.
   Ṛ    Reverse the resulting array.
    +\  Compute the cumulative sum of the reversed array.

Dennis Please

Looks like you beat me by a few minutes. Surprisingly, our programs aren't even identical (you have Ṛ where I have U). I don't know if that makes them different enough to not consider duplicates.

@ais523 U vectorizes while Ṛ does not, but their behavior for flat arrays is identical.

I guess I'll delete my answer, then (whilst being a little annoyed since I managed to come up with the "right" answer on my own, and the only real issue here is that someone else managed to find the same answer first).

In what ASCII format does it come out as 6 bytes? Pluma on Xubuntu says it's 10 bytes, and Julia stores Ḣ as 0x1e22 and Ṛ as 0x1e5a, each of which therefore requires 3 bytes.

@GlenO Jelly uses a SBCS, specifically this code page.

Julia, 24 bytes
!x=x[end]+x[]-reverse(x)

This is the "clever" way to solve the problem. The negative reverse of the array has the "deltas" reversed, and then you just need to fix the fact that it starts/ends at the wrong places.

Snowman 1.0.2, 72 bytes
((}#0AaGwR#`wRaCaZ`0NdE`aN0AaG:dU,0aA|1aA,nS;aM`0wRaC|#0aA*|:#nA*#;aM*))

Try it online!
This is a subroutine that takes input from and outputs to the current permavar.
((
  }       enable variables b, e, and g
  #       store the input in variable b
  0AaG    remove the first element (take indices > 0)
  wR      wrap the array in another array
  #`wRaC  concatenate with the original input array
  aZ      zip (transpose); we now have pairs of elements
  `0NdE   obtain the number -1 (by decrementing 0)
  `aN     reverse the zipped array
  0AaG    remove first (there is one fewer delta than array elements)
  :       map over the array of pairs:
    dU     duplicate; we now have b=[x,y] e=[x,y]
    ,0aA   move the copy and get the first element; b=x g=[x,y]
    |1aA   get the second element from the copy; b=y g=x
    ,nS    subtract; we now have b=y-x which is returned from the map
  ;aM     (map)
  `0wRaC  prepend a zero (in preparation for the next step)
  |#0aA   get the first element of the original array
  *       store this in the permavar
  |:      map over the array of deltas with 0 prepended:
    #       store the permavar in e
    nA      add the delta and the permavar
    *#      make this the new value of the permavar
  ;aM     (map)
  *       "return" the resulting array from the subroutine
))

JavaScript (ES6), 45 37 bytes
a=>a.reverse(z=a[0]).map(e=>z+a[0]-e)

Port of @JHM's Mathematica answer. (I'm sure I could have derived it myself, but not at this time of night.) Edit: Saved 8 bytes thanks to @edc65.

Is there a reason why you need [... and ]?

@MamaFunRoll otherwise it would modify a, which is used later in the program

Oh right, forgot about that :P

37: a=>a.reverse(z=a[0]).map(e=>z+a[0]-e)

@edc65 Bah, I was awake enough last night to consider z=a[0], but I forgot to remove the [...] and (,i,b).

Mathematica, 23 bytes
#&@@#+Last@#-Reverse@#&

Unnamed function. The result is simply: reverse( (first element) + (last element) - (each element) ).

Python 2, 96 74 54 44 bytes
lambda l:[l[0]+l[-1]-j for j in l][::-1]

Input is given as an array surrounded by square brackets. Output is in the same format.
Thanks to @Kade for saving 22 42 bytes by using a much more simple method than whatever I was doing before!
Thanks to @Sherlock9 for saving 10 bytes by eliminating the index counter from the list comprehension!
Great, now if I golf it anymore I'll get the "crossed out 44 is still 44" problem. ;_;

What about lambda l:[l[0]+l[-1]-l[i]for i in range(len(l))][::-1] for 54 bytes? :) (Credits to Glen O. for the calculation)

Oh wow, how did I not figure that out. Thanks! :)

Alex, you can just use that lambda function as your answer :)

What. Oh. Okay, thanks! :)

Instead of l[i]for i in range(len(l)), you can use j for j in l to save 14 bytes.

R, 37 30 bytes
Edit: Now using the approach in Glen O's Julia answer
x=scan();x[1]+tail(x,1)-rev(x)

Old:
x=scan();cumsum(c(x[1],rev(diff(x))))

Reads input, compute deltas, concatenate with first element and calculate the cumulative sum.

05AB1E, 8 bytes
¬s¤sR(++

Try it online!
Translation of my MATL answer, second approach.
¬    % Implicit input. Head, without consuming the input
s    % Swap
¤    % Tail, without consuming the input
s    % Swap
R(   % Reverse and negate
++   % Add head and tail of input to reversed and negated input. Implicitly display

Smarter than what I was trying: ¬s¥Rvy)}

MATL, 8 bytes
1)GdPhYs

Try it online!
This is direct application of the definition. Consider input [18 19 17 20 16] as an example.
1)     % Implicit input. Get its first entry
       % STACK: 18
G      % Push input again
       % STACK: 18, [18 19 17 20 16]
d      % Consecutive differences
       % STACK: 18, [1 -2 3 -4]
P      % Reverse
       % STACK: 18, [-4 3 -2 1]
h      % Concatenate
       % STACK: [18 -4 3 -2 1]
Ys     % Cumulative sum. Implicitly display
       % STACK: [18 14 17 15 16]

Different approach, same byte count:
P_G5L)s+

Try it onllne!
Reversed and negated array plus the first and last entries of the original array.
P_     % Implicit inut. Reverse and negate
G      % Push input again
5L)s   % Sum of first and last entries
+      % Add to reversed and negated array. Implicitly display

Japt, 8 bytes
Ô®nUÌ+Ug

Run it online

Exactly what I had :)

아희(Aheui), 3 * 21 chars + 2 "\n" = 65 bytes
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Assumes input in stack 아. The output will be stored in stack 안.
If you want to try this code:
At the end of the first line of this code, add the character 벙 length(n)-times (i.e. if the input is 7 integers, insert it 7 times). For each prompt, type one integer:
어우
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

Try it here! (copy and paste the code)
Example
For 1, 2, 3, 4, 5:
어우벙벙벙벙벙
우어
빪쑥쌳텆슉폎귁삯씬희
뿓팤팧쎢싺솎
싺싹삭당뽔

and then type 1, 2, 3, 4, and 5 (there will be 5 prompts).
Alternative Version (65 bytes)
빠쑥쌳터슉펴ㅇ삯씬희
뿌파파쎢싺솎
싺싹삭다뽀

Why don't you just say 65 bytes in UTF-8 or something?

@mbomb007 because some people don't know Korean characters are 3 bytes each.

Perl 6,  48 33  30 bytes
{[\+] .[0],|.reverse.rotor(2=>-1).map({[-] @_})}

{.reverse.map: {.[0]+.[*-1]-$^a}}

{[R,] .map: {.[0]+.[*-1]-$^a}}

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

  [R,]               # reduce the following using the comma operator [R]eversed
                     # (short way to do the same thing as ｢reverse｣)

    .map:            # map the input (implicit method call on ｢$_｣

      {              # bare block lambda with placeholder parameter ｢$a｣

          .[     0 ] # the first value of ｢$_｣ (implicit “method” call)
        + .[ * - 1 ] # add the last value of ｢$_｣ (implicit “method” call)
        -     $^a    # declare the parameter and subtract it from the above
      }
}

The *-1 is also a lambda expression of type WhateverCode, where the * is the only positional parameter.

Explanation for those that don't speak perl?

@Cyoce Added for the shortest version. This would need explaining to someone that knew Perl 5 as well. In case you were wondering [\+] from the first example, is triangle reduce [\+] 3,-1,1,-5 →(3,2,3,-2) and [\,] 3,-1,1,-5 → ((3,), (3,-1), (3,-1,1), (3,-1,1,-5))

C# 42 bytes
Takes an int[] and returns an IEnumerable<int>.
a=>a.Select(v=>a[0]+a.Last()-v).Reverse();

(This is actually just a ported version of JHM's version..)

TSQL, 200 bytes
Table variable used as input
DECLARE @ table(a int, b int identity)

INSERT @ values(5),(9),(1),(3),(8),(7),(8);

WITH c as(SELECT*,rank()over(order by b desc)z FROM @)SELECT g+isnull(sum(-f)over(order
by b),0)FROM(SELECT sum(iif(c.b=1,c.a,0))over()g,d.a-lead(d.a)over(order by d.b)f,c.b
FROM c,c d WHERE c.b=d.z)d

Try it out

PHP, 60 56 52 bytes
-4 bytes thanks to @user59178
for($a=$argv;--$argc;)echo$a[1]+end($a)-$a[$argc],_;

operates on command line arguments, uses underscore as separator. Run with
php -r '<code>' <space separated numbers>

Is there a reason why you don't just use $n as the control variable? I tried a version like that and it was 4 bytes shorter and seemed to work.

Pyth - 10 bytes
sM._+hQ_.+

Test Suite.

Desmos, 34 bytes
f(l)=l[1]+l[k]-l[k...1]
k=l.length

Uses the trick from the Mathematica answer. Go check that answer out too!
Try It On Desmos!
Try It On Desmos! - Prettified

Factor, 39 bytes
[| s | s first s last + s reverse n-v ]

Try it online!
A rare problem where local variables win out over stack shuffling. Note that s is the only variable; n-v is the name of a word that subtracts a vector from a number. Uses the same logic as JungHwan Min's Mathematica answer.

BASH, 71 bytes
s=$1
echo $s
for i in `seq ${#@} -1 2`;{
echo $[s=s+${!i}-${@:i-1:1}]
}

C++14, 103 bytes
As unnamed lambda, requiring its input to have rbegin, rend, back and push_back like the containers vector, deque or list.
Using the approach from Glen O's Julia answer
[](auto c){decltype(c)d;for(auto i=c.rbegin()-1;++i!=c.rend();)d.push_back(c[0]+c.back()-*i);return d;}

Ungolfed and usage:
#include<iostream>
#include<vector>

//declare generic function, return is deduced automatically
auto f=[](auto c){
  //create fresh container of the same type as input
  decltype(c)d;

  //iterate through the reverse container
  for(auto i=c.rbegin()-1;++i!=c.rend();)
    //add the first and last element minus the negative reverse
    d.push_back(c[0]+c.back()-*i);
  return d;
}
;

int main(){
  std::vector<int> a={18,  19,  17,  20,  16};
  auto b = f(a);
  for(auto&x:b)
    std::cout << x << ", ";
  std::cout<<"\n";
}

Julia 0.4, 32 bytes
!x=[x[];x|>diff|>flipud]|>cumsum

Try it online!

Clojure, 101 bytes
(fn[c](conj(map #(-(first c)%)(reductions +(reverse(map #(apply - %)(partition 2 1 c)))))(first c))))

Pretty much follows the description:
(def f (fn[c]
         (conj
           (->> c
                (partition 2 1)
                (map #(apply - %))
                reverse
                (reductions +)
                (map #(-(first c)%)))
           (first c))))

Haskell, 33 bytes
Uses the same logic as JHM:
f a=map(head a+last a-)$reverse a

Quite readable as well.

You can save 3 bytes by using (!!0) for head and using (<$>) for map: Try it online!

Convex, 10 bytes
_î\(@¥+¡p;

Try it online!

Java 7, 96 bytes
int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

Explanation:
int[] c(int[] a){     // Method with integer-array parameter and integer-array return-type
  int l=a.length,     //  Length of input array
      i=1,            //  Index (starting at 1, although Java is 0-indexed)
      r[]=a.clone();  //  Copy of input array
  for(; i<l;          //  Loop over the array
    r[i] =            //   Replace the value at the current index in the copied array with:
      r[i-1]          //    The previous value in this copied array
      + a[l - i]      //    plus the opposite value in the input array
      - a[l - ++i])   //    minus the value before the opposite value in the input array (and increase the index)
  ;                   //  End the loop (implicit / no body)
  return r;           //  Return the result array
}                     // End of method

Test code:
Try it here.
class M{
  static int[]c(int[]a){int l=a.length,i=1,r[]=a.clone();for(;i<l;r[i]=r[i-1]+a[l-i]-a[l-++i]);return r;}

  public static void main(String[] a){
    System.out.println(java.util.Arrays.toString(c(new int[]{ 18,19,17,20,16 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 1,2,3,4,5 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 5,9,1,3,8,7,8 })));
    System.out.println(java.util.Arrays.toString(c(new int[]{ 6,5,4,1,2,3 })));
  }
}

Output:
[18, 14, 17, 15, 16]
[1, 2, 3, 4, 5]
[5, 6, 5, 10, 12, 4, 8]
[6, 7, 8, 5, 4, 3]

APL (Dyalog Unicode), 11 bytesSBCS
Anonymous tacit prefix function.
+\⊃,∘⌽2-⍨/⊢

Try it online!
+\ cumulative sum of
⊃ the first element of the argument
, followed
∘ by
⌽ the reversal of
2-⍨/ the pairwise difference of
⊢ the argument

Husk, 9 bytes
m`-§+←→¹↔

Try it online!

source: Stack Exchange

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

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

sort: votes


text:
Dutch Burgerservicenummer (BSN) eleven-test
Introduction:
A Dutch BSN (BurgerServiceNummer) is valid when it complies to the following rules:

It only contains digits.
The length should be either 8 or 9 in length.
When the digits are indexed as A through I, the result of the following sum: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI (NOTE the -1 instead of 1!) should be divisible by 11, and should not be 0.

Challenge:
Input: A string or char-array representing the BSN.
Output: A truthy or falsey result whether the input is a valid BSN.
Challenge Rules:

The input format should be a string or char-array. You are not allowed to use an int-array of digits, or a (possibly octal) number. (You are allowed to convert it to an int-array of digits yourself, though, but not directly as argument.)
Despite the restriction on the input above, you can assume all test cases will contain one or more digits ([0-9]+)
Regarding the BSN with length 8 instead of 9, the Dutch Wikipedia states the following: "For the eleven-test and for other practical uses, a leading zero is added to make the number of length 9." (source)

General rules:

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

Test cases:
// Truthy test cases:
111222333
123456782
232262536
010464554
10464554
44016773

// Falsey test cases:
000000000
192837465
247594057
88888888
73
3112223342
000000012

Is it true that if there are 8 digits, one omits A from the formula given?

@isaacg I've added the rule regarding this with a link to the (Dutch) wikipedia page. You are indeed right, it omits A from the formula (or basically adds a leading 0 to make it length 9, resulting in the same result as omitting A).

Test case for "sum [...] should not be 0.": 000000012

@betseg I've added it to the list

Hi! I'm doing my solution in python, and am wondering about clarification of truthy and falsey. Python counts the integer 0 as falsey and any other integer as truthy, and my current solution always converts to bools?

@StephenUniverse I assume you're talking about the standard for truthy/falsey? In which case 0 as falsey and any other integer as truthy for Python is indeed fine.

Thanks for the clarification! I've been since browsing other answers, and it seems like that's what people are indeed doing.

Note that most answers do accept a 0 padded number like 000000073, which is technically not a valid number. The rule "The length should be either 8 or 9 in length." should be interpreted as non-zero padded.

@3limin4t0r Although you're correct for actual BSN numbers, in this challenge I do accept 0-padded numbers as input. E.g., the truthy test case 010464554 or falsey test cases 000000000 and 000000012 are examples of that.

05AB1E, 23 21 bytes
`()DgLR*OD11Ö89¹gåP0Ê

Try it online! or as a Test suite
Explanation
`                        # push input as individual chars onto stack
 (                       # negate top value
  )                      # wrap in list
   DgLR                  # range [len(input) ... 1]
       *O                # multiply with list of digits and sum
         D11Ö            # is evenly divisible by 11
             89¹gå       # len(input) is 8 or 9
                  P      # product of sum/divisible by 11/len in (8,9)
                   0Ê    # not equal to 0

Probably due to an older version of 05AB1E, but you can save 3 bytes now by changing DgL to ā and 0Ê to Ā. Try it online.

89 should actually be 89S, since an input with length 89 could potentially give a false-positive.

JavaScript (ES6) 57
Input as an array of chars. reduceRight saves the day!
s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)

Test

F=
s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)

;['111222333','123456782','232262536','010464554','10464554','44016773']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

;['000000000','192837465','247594057','88888888','73','3112223342','3112223342']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

Always nice to see a reduceRight answer!

Finally found a way to reach 58 with map(), just to realize that your answer is actually 57 bytes long :-)

@Arnauld yep I can't believe I counted wrong again, thanks

R, 86 67 bytes
Edit: Thanks to Jarko Dubbeldam for suggesting the dot product!
l=length(x<-scan(,""));s=as.double(x)%*%c(l:2,-1);!s%%11&s&l>7&l<10

Reads input from stdin and store as an array/vector of characters. Subsequently convert to numeric,multiply with the vector 9...2,-1 and check all conditions.

Does not work for me. You should split x as vector.

@djhurio Enter the values separated by space and they are implicitly stored in a vector of characters. Alternatively enter them one by one by hitting enter in between.

if(l<9)x=c(0,x);s=sum(as.double(x)*c(9:2,-1)) can be turned into s=sum(as.double(x)*c(l:2,-1)). Also, the sum of the pairwise product of two vectors is the same as their dot-multiplication %*%.

@JarkoDubbeldam Nice! The dot product is really clever.

JavaScript (ES6), 61 60 59 58 bytes
Takes an array of chars as input. Returns false / true.
a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

Test cases

let f =

a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

// truthy
console.log(f([..."111222333"]));
console.log(f([..."123456782"]));
console.log(f([..."232262536"]));
console.log(f([..."010464554"]));
console.log(f([..."10464554"]));
console.log(f([..."44016773"]));

// falsy
console.log(f([..."000000000"]));
console.log(f([..."192837465"]));
console.log(f([..."247594057"]));
console.log(f([..."88888888"]));
console.log(f([..."73"]));
console.log(f([..."3112223342"]));

C, 112 101 96 98 104 bytes
Thanks to @MartinEnder for saving 5 3 bytes while fixing my code!
j,i,k,l;f(char*s){l=strlen(s);for(i=l,j=k=0;j<l;)k+=(s[j++]-48)*(i>1?i--:-1);return!(k%11)&&k&&(l^8)<2;}

Returns 0 if invalid, 1 if valid. Try it online!

This accepts 61 even though it is not of correct length.

This does not work with my personal BSN.

Hopefully fixed.

Not fixed. Doesn't work with mine either.

I'm still not a valid Dutch citizen according to this :(. I can PM you my BSN if needed.

@Roberrrt, @DavidPostill; is it OK now or should I just give up? =(

It returns a 1 for mine now :)!

!(k%11) and (l^8)<2 are both always 0 or 1, so you can change one && to &: !(k%11)&(l^8)<2&&k.

Turning this into a recursive function makes it 100 bytes: i,k;f(char*s){*s?f(s+1),k+=i*(*s-48),!++i?i=2:0:0;}g(char*s){i=-1;k=0;f(s);return!(k%11)&i-9u<2&&k;} That's because l can be avoided when it can be inferred from i.

R, 95 79 93 bytes
function(x){y=as.double(el(strsplit(x,"")));z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

Unnamed function that takes a string as argument. At first I overread the requirement of having a string as input instead of a number, but that's good, because it saves some bytes on conversion.
I am not sure how to interpret the array of characters, but if that means that you can use a vector of stringed digits "1" "2" "3" "4" etc as input, it becomes a bit shorter even:
function(x){y=as.double(x);z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

Splits x into a numeric vector, then appends a 0 if length is 8, then calculates the dotproduct of vector y and c(9,8,7,6,5,4,3,2,-1). Tests if the result is both nonzero and divisible by 11.
Saved 16 bytes thanks to the logic by @Emigna, implicitly appending the 0 in the creation of the vector c(length(x):2,-1).
Forgot to add check for length 8/9, so +14 bytes :(

Perl, 58 bytes (52 + 6)
@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)

Run with
perl -F// -lapE

Input passed through STDIN:
Usage
echo 232262536 | perl -F// -lapE '@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)'

Outputs 1 for as the truthy value, 0 or nothing for falsey values.

You can save some bytes at the beginning: $r+=$_*(-1,2..9)[$i++]for reverse@F. Also, -F -pe (and input supplied without final newline, with echo -n for instance) is enough (unless your Perl is too old, in which case you'll need -a (but on recent Perls, it's implied by -F). Finally, your code was 70 bytes long, not 52 ;)

C++14, 107 106 bytes
-1 byte for int instead of auto in for loop.
As unnamed lambda returning via reference parameter. Requires input to be std::string or a container of char, like vector<char>.
[](auto c,int&r){int i=c.size();r=7<i&&i<10?-2*c.back()+96:~1<<9;for(int x:c)r+=(x-48)*i--;r=r%11<1&&r>0;}

Ungolfed and usage:
#include<iostream>
#include<string>

auto f=
[](auto c, int& r){
 int i = c.size();
 //if the size is correct, init r to -2*I so we can add I safely later
 //otherwise such a big negative number, that the final test fails
 r = 7<i && i<10 ? -2*c.back()+96 : ~1<<9;
 for (auto x:c)
  r += (x-48)*i--;
 r = r%11<1 && r>0;
}
;

using namespace std;
using namespace std::literals;

int main(){
 int r;
 f("111222333"s,r); std::cout << r << std::endl;
 f("123456782"s,r); std::cout << r << std::endl;
 f("010464554"s,r); std::cout << r << std::endl;
 f("10464554"s,r); std::cout << r << std::endl;
 f("44016773"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("000000000"s,r); std::cout << r << std::endl;
 f("192837465"s,r); std::cout << r << std::endl;
 f("73"s,r); std::cout << r << std::endl;
 f("88888888"s,r); std::cout << r << std::endl;
 f("3112222342"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("99999999"s,r); std::cout << r << std::endl;
 f("999999999"s,r); std::cout << r << std::endl;
}

Jelly, 21 bytes
V€U×JN1¦µL:2=4×Sµ11ḍa

TryItOnline! or run all test cases
Truthy return values are non-zero (and are, in fact, the multiple of 11 sum).
How?
V€U×JN1¦µL:2=4×Sµ11ḍa - Main link: string of digits  e.g. "111222333"
V€                    - eval each - effectively cast each to an integer (keeps leading zeros)
  U                   - upend                        e.g. [ 3, 3, 3, 2, 2, 2, 1, 1, 1]
    J                 - range(length)                e.g. [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
   ×                  - multiply                     e.g. [ 3, 6, 9, 8,10,12, 7, 8, 9]
      1¦              - apply to index 1 (first element)
     N                -     negate                   e.g. [-3, 6, 9, 8,10,12, 7, 8, 9]
        µ             - monadic chain separation   e.g. z=[-3, 6, 9, 8,10,12, 7, 8, 9]
         L            - length(z)                    e.g. 9
          :2          - integer divide by 2          e.g. 4
            =4        - equals 4?                    e.g. 1
               S      - sum(z)                       e.g. 66
              ×       - multiply                     e.g. 66
                µ     - monadic chain separation   e.g. z=66
                 11ḍ  - divides(11, z)               e.g. 1
                    a - and z (for z=0 case)         e.g. 66 (truthy)

Unfortunately I can only accept one answer instead of two, since yours has the same 21 byte-count as @Emigna's 05AB1E answer. But since Enigma answered sooner (and his edit for 21 bytes was also sooner) I've accepted his.

That sounds fair to me!

Haskell, 116 112 102 bytes
f x=div(length x)2==4&&g x>0&&h x
h=((==0).(`mod`11)).g
g=sum.zipWith(*)(-1:[2..]).map(read.(:[])).reverse

g counts the sum used in the eleven-proef of h, while f also checks for the correct length and that the eleven-proef is not 0. Especially the checks of f take a lot of bytes.
EDIT: saved 10 bytes thanks to Lynn and div rounding down.

How about f x=div(length x)2==4&&g x>0&&h x?

@Lynn: that is a nice one, thanks.

Befunge, 72 bytes
>+~>:0`v
^1\-*68_\2/4-!00p*8>1-10p\910gv
@.!+!\%+56:*g00$  _^#!:g01+*-<<

Try it online!
Explanation
>+~>:0`v            Read characters from stdin until EOF, converting each digit into
^1\-*68_              a number on the stack, and keeping a count of the characters read.

      \2/4-!00p     Save !(count/2-4), which is only true for valid lengths (8 and 9).
               *    Multiply the EOF (-1) with the final digit; this is the initial total.

8>1-10p\910gv       Loop over the remaining 8 digits, multiplying each of them by 9-i and
 ^#!:g01+*-<<         add to the total; i goes from 7 down to 0, so 9-i goes from 2 to 9.

               $    Drop the loop counter.
           *g00     Multiply total by the length calculation (invalid lengths become 0).
      %+65:         Make a copy of the total, and calculate modulo 11.
    !\              Boolean not the other copy to check for zero.
  !+                !(total%11 + !(total)) is only true for non-zero multiples of 11.
@.                  Output the result and exit.

MATL, 36 bytes
Not the longest MATL program I've ever written, but I like how if/else statements get very lengthy very quickly in golfing languages. I feel that this solution may not be optimal in MATL, but as of yet I can't optimize it any further. I'm thinking of using the double 0 somewhere, and maybe cut down on the t's everywhere.
48-tn8=?0wh]tn9=?P[a2:9]*st11\~Y&}x0

Try it online! Explanation:
48-                                  % Subtract 48 (ASCII '0')
   tn                                % Duplicate. Get length.
     8=?                             % If length equals 8
        0wh                          %     Prepend 0 to the duplicate
           ]                         % End if.
            t                        % Duplicate again.
             n9=?                    % If length equals 9.
                 P                   %     Reverse the duplicate
                  [a2:9]*            %     Element-wise product with [-1 2 ... 9]
                         s           %     Sum
                          t11\       %     Duplicate sum, modulus 11
                              ~Y&    %     Result on stack: modulus==0 AND sum!=0
                                 }   % Else
                                  x0 %     Remove the duplicate. Put 0 on stack.
                                     % Display implicitly.

If you can make do with a column vector: !U instead of 48-

Beat ya :-P

@LuisMendo Too bad. [a2:9]* results in a non-element-wise multiplication, so another ! would be needed which would offset the initial gain.

MATL, 26 bytes
!UGg*R!s0&)s-t11\~Gn8-tg=v

The result is a non-empty column vector, which is truthy iff all its entries are nonzero.
Try it online!
Or verify all test cases with each result on a different line.
Explanation
This tests the three conditions in the following order:

Weighted sum is nonzero;
Weighted sum is dividible by 11;
Length is 8 or 9.

Consider input '8925' for the explanation. ; is the row separator for matrices.
!     % Implicit input. Transpose into a column vecvtor
      % STACK: ['8'; '9'; '2'; '5']
U     % Convert each digit to number
      % STACK: [8; 9; 2; 5]
Gg    % Push a row array of ones as long as the input
      % STACK: [8; 9; 2; 5], [1 1 1 1]
*     % Multiply, element-wise with broadcast
      % STACK: [8 8 8 8; 9 9 9 9; 2 2 2 2; 5 5 5 5]
R     % Upper triangular part
      % STACK: [8 8 8 8; 0 9 9 9; 0 0 2 2; 0 0 0 5]
!     % Transpose
      % STACK: [8 0 0 0;8 9 0 0;8 9 2 0;8 9 2 5]
s     % Sum of each column. This multiplies last element by 1, second-last by 2 etc
      % STACK: [32 27 4 5]
0&)   % Split into last element and remaining elements
      % STACK: 5, [32 27 4]
s     % Sum of array
      % STACK: 5, 63
-     % Subtract
      % STACK: -58. This is the result of condition 1
t11\  % Duplicate. Modulo 11
      % STACK: -58, 8
~     % Logical negation
      % STACK: -58, 0. This gives condition 2
Gn    % Push numnber of entries in the input
      % STACK: -58, 0, 4
8-    % Subtract 8. For valid lengths (8 or 9) this gives 0 or 1
      % STACK: -58, 0, -4
tg    % Duplicate. Convert to logical: set nonzero values to 1
      % STACK: -58, 0, -4, 1
=     % 1 if equal, 0 otherwise. Lenghts 8 or 9 will give 1. This is condition 3
      % STACK: -58, 0, 0
v     % Vertically concatenate the entire stack. This is truthy iff all values
      % are non-zero. Implicitly display
      % STACK: [-58; 0; 0]

Well done. I figured that an approach without ? would probably be more efficient, but I couldn't figure out how to shorten the length 8 or 9. Your Gn8-tg= is very clever.

By the way, wouldn't a column vector input qualify as a char-array representing the BSN, saving you the first !?

@Sanchises The problem is that then G pushes a column vector and I need to transpose it to do the repetition with g*

Oh right of course. Never mind!

PHP 139 128 bytes
 $u=-1;$i=$argv[1];while($u<=strlen($i)){$c+=($u*(substr($i,-(abs($u)),1)));$u +=$u<0?3:1;}echo($c>0&&!($c%11)&&$u>8&&$u<11?1:0);

Could not get the CLI to just echo the true of false. Had to make do it this way. Any ideas?
128 bytes: Turned "true" and "false" to 1 and 0.

PowerShell v2+, 96 bytes
param($n)$i=8-($n.count-eq8);!(($b=($n|%{(-"$_",(($i+1)*+"$_"))[!!$i--]})-join'+'|iex)%11)-and$b

OK, I'll admit, this looks like a complete mess. And it kinda is. But, bear with me and we'll get through it.
We take input $n (as a char-array) and set $i equal to 8 minus a Boolean value for whether there are 8 items in $n. Meaning, if there are 8 items, then $i would be 7.
The next section combines the calculation with our output. Working from the inside, we loop through $n with $n|%{...}. Each iteration, we use a pseudo-ternary to come up with one of two results -- either -"$_" or (($i+1)*+"$_"). The index is based on whether $i is 0 or not (i.e., we've hit the -1xI case from the challenge equation), which gets post-decremented for the next go-round. Those are all gathered up in parens and -joined together with +. For example, with input 111222333 at this point we'd have 9+8+7+12+10+8+9+6+-3. That is piped to iex (short for Invoke-Expression and similar to eval) before being stored into $b. We then take that %11 and perform a Boolean-not !(...) on that (i.e., so if it is divisible by 11, this portion is $true). That's coupled with -and$b to ensure that $b is non-zero. That Boolean result is left on the pipeline and output is implicit.
Examples
PS C:\Tools\Scripts\golfing> 111222333,123456782,232262536,010464554,10464554,44016773|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
111222333 -> True
123456782 -> True
232262536 -> True
10464554 -> True
10464554 -> True
44016773 -> True

PS C:\Tools\Scripts\golfing> 000000000,192837465,247594057,88888888,73,3112223342,000000012|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
0 -> False
192837465 -> False
247594057 -> False
88888888 -> False
73 -> False
3112223342 -> False
12 -> False

Python 3.8 (pre-release), 111 110 104 bytes
-1 byte thanks to @Kevin-cruijssen
-6 bytes by reading the rules (yay)
lambda s:len(s)in(8,9)and not(x:=sum(a:=[*map(lambda n,m:int(n)*m,s[::-1],range(1,10))])-2*a[0])%11and x

Try it online!
There's probably more golfing to do, but this is what I have for now.

You can remove the space at 11and for -1 byte. :)

Python 2, 102 bytes
def f(i):S=sum(a*b for a,b in zip([-1]+range(2,10),map(int,i)[::-1]));return(7<len(i)<10)*(S%11<1)*S>0

Python 2, 96 bytes
def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(2,10))-int(s[-1]);print(u%11<1)*u

Takes a string as input.  The function adds a '0' to the front of the string whether it needs it or not, and uses Python's negative indices to add elements, starting from the end of the string and working back-to-front.
The -1xI is handled separately, using a second call to int().  I couldn't figure out how to avoid this without costing more bytes than I saved.
def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(10))-2*int(s[-1]);print(u%11<1)*u would work just as well, since it would add 1 times s[-1] but then subtract it twice, and it would also add 0 times (something) which of course wouldn't affect the sum.

92 bytes (Python 3.8)

Brain-Flak, 345 Bytes
Includes +3 for -a
([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<>([][(()()()()){}]){({}[()]){([]){{}{}([])}}}{}([{}])({}({}){})({}({})({}){})({}(({}){}){})({}(({})({})){}{})({}(({})({}){}){})({}((({}))({}){}){}{})({}((({}){}){}){})(({}(((({})){}){}){}{}{}<(((()()())()){}{})>)){{}({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}[{}]<(())>){((<{}{}>))}{}(<()>)}{}

Truthy is 1, Falsy has a 0 on the top of the stack.
Try it Online!
I'm pretty sure there is a shorter way to do the multiplication in a loop, but I haven't found it yet.
#reverse and subtract 48 from all numbers (ASCII -> decimal)
([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<>

([][(()()()()){}])       #height - 8
{({}[()]){               #if not 0 subtract 1
   ([]){{}{}([])}        #if still not 0 pop everything
}}{}                     #this loop pops everything unless there are 8 or 9 digits

([{}])                   # -I
({}({}){})               # H*2
({}({})({}){})           # G*3
({}(({}){}){})           # F*4
({}(({})({})){}{})       # E*5
({}(({})({}){}){})       # D*6
({}((({}))({}){}){}{})   # C*7
({}((({}){}){}){})       # B*8
(({}(((({})){}){}){}{}{} # A*9 pushed twice with:
<(((()()())()){}{})>))   # 11 under it

{{} #if not 0
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}   # mod 11
[{}]<(())>){((<{}{}>))}{}                       # logical not
(<()>)                                          # push 0 to exit loop
}{}
                                                # implicit print

C#, 120 115 bytes
This loops through the char[] it receives as input and returns true or false:
bool b(char[]n){int r=0,k,i=0,l=n.Length;for(;i<l;i++){k=i==l-1?-1:l-i;r+=k*(n[i]-48);}return r>0&r%11<1&l<10&l>7;}

Fiddle:
https://dotnetfiddle.net/3Kaxrt
I'm sure I can scrape out a few bytes, especially in the messy return. Any ideas welcome!
Edit: Saved 5 bytes thanks to Kevin. I had no idea I could use & instead of &&!

+1! r>0&&r%11==0&&l<10&&l>7 can be golfed to r>0&r%11<1&l<10&l>7 (&& to & and r%11==0 to r%11<1). And -'0' can be golfed to -48.

Java 8, 115 98 94 bytes
b->{int l=b.length,i=l,r=0;for(;l>7&l<10&i-->0;)r-=(b[i]-48)*(l-i<2?1:i-l);return r>0&r%11<1;}

I'm surprised no one has posted a Java answer yet, so here is one.
-4 bytes thanks to @ceilingcat.
Explanation:
Try it here.
b->{                // Method with character-array as parameter and boolean return-type
  int l=b.length,   //  Length of the array
      i=l,          //  Index-integer, starting at this length
      r=0;          //  The result-sum, starting at 0
  for(;l>7&l<10     //  Start looping if the length is either 8 or 9
       &i-->0;)     //  And continue looping downwards while the index is larger than 0
      r-=           //   Decrease the result-sum by:
         (b[i]-48)  //    The current digit
         *(         //    Multiplied by:
           l-i<2?   //     If `l-i` is 1:
            1       //      Simply multiply by 1
           :        //     Else:
            i-l);   //      Multiply by `i-l`
  return r>0        //  Return if the result-sum is larger than 0,
    &r%11<1;}       //   and if the result-sum is divisible by 11

PHP, 86 85 84 83 82 79 bytes
Note: uses PHP 7.1 for negative string indices.
for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;

Run like this:
echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo
> 1

Version for PHP < 7.1 (+10 bytes)
echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[strlen($a)-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo

Explanation
for(
  $l=log10(         # Take the log of the input number.
    $a=$argn        # Set input to $a
  );
  ~$c=$a[-++$x];    # Iterate over digits of input (reverse). Negate to
                    # change every char to extended ASCII (all truthy),
                    # without changing empty sting (still falsy, ending
                    # the loop).
)
  $s+=$x>1?         # Add current char to the sum...
     ?$x*$c:-$c;    # multiplied by $x, unless $x is 1; subtract it.
echo
  $s%11<1 &         # Check if sum is divisible by 11, and
  $l>7   &          # log of the input is greater than 7, and
  $l<9;             # log of the input is less than 9. Outputs 0 or 1.

Tweaks

Shorter way to distinguish between empty string and "0", saved a byte
Since 10000000 is invalid, no need to compare with greater than or equals, greater than suffices, saving a byte
Shorter way to subtract least significant digit
Negate char instead of XOR, saving a byte
Saved 3 bytes by using -R to make $argn available

Ly, 58 bytes
iy9L[r'0r!]ppry9=[pp8[f'0-srlrpsrl`*r,]p'0-N&+[92+%!u;]]u;

Try it online!
I thought this would be shorter...  There's probably room for improvement?
First part, input digits, pad with leading 0 if necessary
i              - input all digits (as codepoints)
 y             - push the stack size onto the stack
  9L[    !]p   - if/then block, true if <9 digits
     r'0r      - reverse stack, push 0, reverse again
            p  - pop the stack size entry off the stack

Second part, only process digits if we end up with 9 digits
r              - reverse the stack
 y             - push the stack size info the stack
  9=[pp ... ]  - if/then block, true if stack size is 9

Third part, process the first 8 digits
8[               ,]p - loop 8 times
  f                  - bring digit forward
   '0-               - convert from char to int
      s              - save digit value
       rl            - copy digit to bottom of stack
         rp          - delete from top of stack
           s         - save current loop var
            rl       - copy to bottom of stack
              `      - increment by one
               *     - multiple with current digit
                r    - reverse stack

Fourth part, process last digit, sum results
'0-     - convert digit from char to int
   N    - negate
    &+  - sum all entries on the stack

Fifth part, "is it zero?" and "is divisible by 11?" checks
[       ]   - if/then block, true is sum is non-zero
 92+        - push 11 onto the stack
    %!      - modulo math to get remainder, invert the result
      u;    - print top of stack as int, then exit

Last part, prints "falsey" if some success criteria wasn't met
u;  - print top of stack (which will be 0) and exit

AWK, 88 bytes
$0="0"$0,n=gsub(a," ")-1{b=n-9;c=9}!b||b==1{for(d-=$n;++b<n;e=d%11)d+=$b*c--}1,$0=!e*!!d

Try it online!
And one I had fun golfing, just to abuse the flexibility of AWK.
$0="0"$0                             - append "0" to the input
           gsub(a," ')-1             - re-parse the input, one char per arg
        ,n=           -1             - set "n", decr RC to get number of chars
                        {         }  - code block...
                         b=n-9;      - set "b" to first char to use
                               c=9   - set "c" to initial multiplier val

!b||b==l                                   - true is we got 8 or 9 chars
        {                                } - code block...
         for(                  )           - loop over initial 8 chars
             d-=$n;                        - init: "d" set to neg of last digit
                   ++b<n;                  - test: ends after 8 chars processed
                         e=d%11            - loop-end: "e" is remainder of "%11"
                                d+=$b*c--  - loop-code: multiply and add next digit

1,           - unconditionally run implicit "print $0" code block
  $0=!e*!!d  - "$0" is 1 if accum value is non-zero and divisible by 11

K (ngn/k), 42 41 bytes
-1 byte from @ngn's improvements
{(4=-2!#x)&t&~11!t:+/(|-1,2+!8)*-9#0,.'x}

Try it online!
Takes the input as a list of characters.

.'x convert each digit to its integer (e.g. convert "123" to 1 2 3)
-9#0, prepend a 0, then take the last nine values (handles padding 8-digit codes, and avoids errors on input that is not 9 digits long)
(|-1,2+!8)* generate 9 8 7 6 5 4 3 2 -1, and multiply the parsed digits by this
t:+/ take the sum, storing in variable t
t&~11!t check that 11 evenly divides t, and that t is non-zero
(4=-2!#x)& also check that the input is 8 or 9 characters long (literally: the length of the input (integer) divided by 2 is equal to 4)

|/8 9= -> 4=-2!

Ruby, 65 bytes
-1 byte thanks to Kevin Cruijssen
->n{a,*b=n.to_i.digits
i=1
b[6]&&(b[..7].sum{_1*i+=1}-a)%11<1||p}

Attempt This Online!

@KevinCruijssen Thanks. I've updated my answer.

Looking good now, +1 from me. :) Also, I think you can change the ==0 to <1 for -1 byte. :)

Don't forget about $. for int vars, -1 byte

@south I’m told that’s invalid in function submissions because it’s not reusable. See comments here: https://codegolf.stackexchange.com/posts/comments/563313?noredirect=1

@Jordan My understanding might be a little flawed then. Maybe I am making too many assumptions with standard I/O. Will look into it, thanks.

Clojure, 114 bytes
Well this is something, - substracts the rest of the arguments from the first one so that handles the special case of weight -1. This function returns nil for inputs of invalid length, but on if clauses they operate the same as false. (#{8 9}(count v)) returns nil if length of v is not 8 or 9.
(fn[v](if(#{8 9}(count v))(#(and(< % 0)(=(mod % 11)0))(apply -(map *(range 1 10)(reverse(map #(-(int %)48)v)))))))

Test cases:
(pprint (group-by f (map str [123456782 232262536 "010464554" 10464554 44016773 "000000000" 192837465 247594057 88888888 73 3112223342 "000000012"])))
{true  ["123456782" "232262536" "010464554" "10464554" "44016773"],
 false ["000000000" "192837465" "247594057" "88888888" "000000012"],
 nil   ["73" "3112223342"]}

Perl 5, 63 + 2 (-F) = 65 bytes
$F[-1]*=-1;map$s+=++$i*$_,reverse@F;say/^.{8,9}$/&&$s&&!($s%11)

Try it online!

Stax, 23 bytes
╪╦µΘç}<╔▼◘╞i∟~¿≥←║▐√ 4u

Run and debug online!
Explanation
Uses the unpacked version to explain.
i%8A:byr{]ei^*mBN+|+c11%!L|A
i                               Suppress implicit eval
 %8A:b                          Length is 8 or 9 (Element #1 on the final stack)
      yr                        Reverse input
        {     m                 Map each element with
         ]e                         Its numerical value
           i^*                      Multiplied current 1-based loop index
               BN+              Negate the first element
                  |+            Sum (Element #2 on the final stack)
                    c11%!       Sum is multiple of 11 (Element #3 on the final stack)
                         L|A    Collect all the three elements and `and` them.

-1

Python 3.8, 96 bytes
lambda i:7<len(i)<10*((S:=sum(a*b for a,b in zip([-1,*range(2,10)],map(int,i[::-1]))))%11<1)*S>0

Try it online!
Similar to @TFeld's Python 2 answer, but uses Python 3.8 assignment expressions and a few other tricks to get it down to 96 bytes.

TI-Basic, 60 bytes
max(length(Ans)={8,9})sum(seq(int(10fPart(expr(Ans)/₁₀^(I)))(I-2(I=1)),I,1,9
not(fPart((Ans+not(Ans))/11

Takes input in Ans as a string. Output is stored in Ans and is displayed.

Python 3.8 (pre-release), 87 bytes
lambda s:s[7:][:(q:=eval('-'+'+'.join(map('*'.join,zip('123456789',s[::-1])))))>q%11<1]

Try it online!
Returns a non-empty string if the number is valid, and an empty string otherwise.

MathGolf, 23 20 bytes
~b*]h╒xm*Σ_A÷l£½4=ß╓

Outputs 1/0 for truthy/falsey respectively.
Try it online.
Explanation:
~          # Dump the digits of the (implicit) input-string to the stack
 b*        # Multiply the top one by -1
   ]       # Wrap all values on the stack into a list
    h      # Push the length (without popping the list)
     ╒     # Pop and push a list in the range [1,length)
      x    # Reverse it to (length,1]
       m*  # Multiply the values in the two lists at the same positions
         Σ # Sum it together
_          # Duplicate this sum
 A÷        # Pop and check if it's divisible by 11
l£         # Push the input-length
  ½        # Integer-divide it by 2
   4=      # Check if it's equal to 4
ß          # Wrap all three values on the stack into a list
 ╓         # Pop and push the minimum
           # (after which the entire stack is output implicitly as result)

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

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


text:
Interleave strings
Inspiration.* I cannot believe we have not had this challenge before:
Task
Given one or more printable ASCII strings, interleave them by taking one character from each string, cyclically until out of characters. If a string runs out of characters before the others, just skip that one from then on.
Examples
SIMPLE gives SIMPLE
POLLS and EPEES gives PEOPLELESS
LYES and APRONS gives LAYPERSONS
ABCDE and a c and 123 567 gives Aa1B 2Cc3D E567
"\n$?* and  (empty string) and ,(.)"  (trailing space) gives ",\(n.$)?"*  (trailing space)

* There are shorter APL solutions.

Since this is basically just a transpose operation, we've had a few challenges that are very similar, but possibly none that are exactly the same.

I had this question on my CS HW, does that mean I can close this as a homework question? ;P

@EriktheOutgolfer Cool! I learned something today.

Jelly, 1 byte
Z

Try it online!
The “transpose” built-in will do exactly this to a list of strings.

I'm curious, what would the code have looked like if you had to pad short strings with spaces?

That would be z⁶. z is “transpose left, padding with right”; ⁶ is a space.

And what if built-ins doing the exact job were not allowed?

@Adám Jelly works very well on lists; where do built-ins end and language constructs / design begin?

@Lynn In Jelly? Anything on the Atoms and Quicks lists are buildt-ins.

@Adám ;" (element-wise concatenation) would solve the task without a built-in.

@Dennis ;"/ tbf

Python 2, 101 89 86 69 bytes
I'm hoping I can get this into a lambda somehow, shortening it down by making it recursive. It isn't ideal because you would hope transposing is shorter, unfortunately it isn't (from what I have managed to come up with so far).
f=lambda s:' '*any(s)and''.join(x[:1]for x in s)+f([x[1:]for x in s])

Old solutions:
w=input();o=''
while any(w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o
lambda s:''.join(''.join([c,''][c<' ']for c in x)for x in map(None,*[list(y)for y in s]))
w=input();o=''
while any(x>=' 'for x in w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o
thanks to mathmandan for making me feel dumb ;) saved me a bunch of bytes! (on an old solution)

Couldn't you just do while any(w):?  Empty strings are falsey in Python.

@mathmandan You're absolutely right, don't know what I was thinking..

No problem :)  Your new solution looks great, except I think you need to prepend f=.

You can take the [] off of the recursive call, leaving f(x[1:] for x in s), that makes it a generator comprehension, which acts the same as a list in this context.

Perl 6, 34 32 bytes
{[~] flat roundrobin |$_».comb}

{roundrobin(|$_».comb).flat.join}

A lambda that takes an array of strings as argument, and returns a string.
(Try it online)

I  would have used @_ instead of $_

CJam, 4 bytes
qN/z

Try it online!
We can also write an unnamed function for 4 bytes, which expects a list of strings on top of the stack:
{zs}

Try it online!

That's one byte a minute!

Pyth - 3 bytes
Very simple, will add expansion later, on mobile.
s.T

Test Suite
s                         Join all the strings together
 .T                       Transpose, without chopping off overhang
  (Q implicit)

@Daniel I'm in school too :P

Any plans on adding the explanation?

@JanDvorak sure doing it now.

JavaScript (ES6), 52 46 bytes
f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

Takes input as an array of strings and outputs as a single string.
Test snippet

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

g=a=>console.log("Input:",JSON.stringify(a),"Output:",JSON.stringify(f(a)))

g(["SIMPLE"])
g(["POLLS","EPEES"])
g(["LYES","APRONS"])
g(["ABCDE","a c","123 567"])
g(["\"\\n$?*",",(.)\" "]) // Backslash and quote are escaped, but in/output are correct

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

@Neil That's a great approach. I managed to golf 6 bytes off my own :-)

Haskell, 33 bytes
import Data.List
concat.transpose

Try it on Ideone. Usage:
Prelude Data.List> concat.transpose$["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

Without using a build-in: (38 34 bytes)
f[]=[]
f x=[h|h:_<-x]++f[t|_:t<-x]

Try it on Ideone. 4 bytes off thanks to Zgarb! Usage:
Prelude> f["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

You can remove all parens in the alternative version. Still won't beat the import though.

Do you actually need the base case?

Never mind, of course the base case is needed.

@xnor You also can't move the base case to the end and replace it with f a=a to save a byte because both [] have a different type ... so close.

PHP, 68 67 bytes
for(;$f=!$k=$f;$i++)for(;y|$v=$argv[++$k];$f&=""==$c)echo$c=$v[$i];

Loops over command line arguments. Run with -r.
After the inner loop, $f is 1 when all strings are finished, 0 else (bitwise & casts ""==$c to int).
Next iteration of the outer loop: copy $f to $k (saves one byte from $k=0) and toggle $f:
When all strings are done, $f is now false and the loop gets broken.

Doesn't work with empty input strings. Take a look at the last testcase

@aross: fixed. thanks.

C, 114 84 bytes
-20 bytes for not calculating the length.
i,b;f(char**s){b=1;while(b){i=-1;b=0;while(s[++i]>0)if(*s[i])putchar(*s[i]++),++b;}}

Accepts array of char pointers and requires last item to be a null-pointer (see usage).
Ungolfed and usage:
i,b;f(char**s){
 b=1;
 while(b){
  i=-1;
  b=0;
  while(s[++i]>0)
   if(*s[i])
    putchar(*s[i]++),++b;
 }
}

int main(){
 char*a[]={
//  "POLLS","EPEES"
//  "LYES","APRONS"
 "ABCDE","a c","123 567"
 ,0};
 f(a);
 puts("");
}

Does the usage of printf/sprintf not allowed ? :D you would win quite some bytes.

@Walfrat Without printing directly I'd need to allocate a string, so how could this save anything.

it was before your edit where you added the ++b and remove length compute, so yes can't work anymore.

@Walfrat Yes, but i had a malloc and return before and this was longer than just printing

J, 13 bytes
({~/:)&;#\&.>

Try it online!
Based on the inspiration for this question.
Another way to do it takes 27 bytes but operates using transpose. Most of the bytes are to handle the automatically added zeroes from padding.
[:u:0<:@-.~[:,@|:(1+3&u:)&>

Explanation
({~/:)&;#\&.>  Input: list of boxed strings S
          &.>  For each boxed string x in S
        #\       Get the length of each prefix from shortest to longest
                 This forms the range [1, 2, ..., len(x)]
                 Rebox it
(    )         Operate on S and the prefix lengths
      &;         Raze both
   /:            Grade up the raze of the prefix lengths
 {~              Index into the raze of S using the grades
               Return

J's prohibiting mixed arrays really hurts you here. Try it in APL.

Very nice approach.  You can do the transpose approach in 15 bytes without worrying about 0 like this: [:u:@,@|:3&u:&>.  TIO

Retina, 13 bytes
Byte count assumes ISO 8859-1 encoding.
O$#`.
$.%`
¶

Try it online!
Explanation
O$#`.
$.%`

This is based on the standard transposition technique in Retina. We sort (O) all non-linefeed characters (.), by ($#) the number of characters in front of them on the same line ($.%`), i.e. their horizontal position.
The second stage then simply removes linefeeds from the input.

Java, 19+155=174 160
String f(java.util.Queue<String> q){String s,r="";while(!q.isEmpty()){s=q.poll();r+=s.isEmpty()?"":s.charAt(0);if(s.length()>1)q.add(s.substring(1));}return r;}

Ungolfed:
  String f(java.util.Queue<String> q) {
    String s, r = "";
    while (!q.isEmpty()) {
      s = q.poll();
      r += s.isEmpty() ? "" : s.charAt(0);
      if (s.length() > 1) {
        q.add(s.substring(1));
      }
    }
    return r;
  }

Output:

SIMPLE
PEOPLELESS
LAYPERSONS
Aa1B 2Cc3D E567
",(n.$)?"*

First modification: merged string declaration to save some bytes. Removed import, it was used by the main() method (not shown here) that also needed LinkedList. It is fewer bytes to referece Queue directly.

initialize string s with string r can save few more

I know it's been almost a year ago, but you can golf a few bytes: String f(java.util.Queue<String>q){String s,r="";for(;!q.isEmpty();r+=s.isEmpty()?"":s.charAt(0))if((s=q.poll()).length()>1)q.add(s.substring(1));return r;}

Python 2, 58 bytes
lambda*m:''.join(map(lambda*r:''.join(filter(None,r)),*m))

Try it online!

Can't you remove the space in lambda *m?

I just did that! Thank you!

Actually, 7 6 bytes
Golfing suggestions welcome! Try it online!
Edit: -1 byte thanks to Teal pelican.
a Z♂ΣΣ

Ungolfing
          Implicit input each string.
a         Invert the stack so that the strings are in the correct order.
<space>   Get the number of items on the stack, len(stack).
Z         Zip all len(stack) strings into one, transposing them.
♂Σ        sum() every transposed list of chars into strings.
Σ         sum() again to join the strings together.

Can you not remove the # to make it 6 bytes?

@Tealpelican Welp, now I'm going to have to dig through all of my old Actually answers and see if I can't change Z♂#Σ to Z♂Σ in all of them. Thanks for the tip :D

First time looking into the language, it looks so much fun! Glad I could help :))

PHP, 77 bytes
Golfed
function($a){for($d=1;$d!=$s;$i++){$d=$s;foreach($a as$v)$s.=$v[$i];}echo$s;}

Anonymous function that takes an array of strings.
I'm sure this could be golfed more, but it's early. On each iteration, we grab the i-th letter from each given string and append it to our final string, one at a time. PHP just throws warnings if we access bits of strings that don't exist, so that's fine. We only stop when no changes have been made after looping through all the strings once.
I feel like the usage of $d can be golfed more, but it's early. :P

How exactly do you put an array of strings in a single argument?

@Titus. Y'know, I never really thought about it. I just kinda assumed you could.

JavaScript (ES6), 46 bytes

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)
<textarea oninput=o.textContent=f(this.value.split`\n`)></textarea><div id=o>

Bash + GNU utilities, 55
 eval paste `sed "s/.*/<(fold -1<<<'&')/g"`|tr -d \\n\\t

I/O via STDIN (line-separated) and STDOUT.
The sed formats each line to a bash process substitution.  These are then evaled into paste to do the actual interleaving.  tr then removes unnecessary newlines and tabs.
Ideone.

PHP, 63 bytes
Note: uses IBM-850 encoding
for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];

Run like this:
php -r 'for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];' "\"\n\$?*" "" ",(.)\" " 2>/dev/null;echo
> ",\(n.$)?"*

Explanation
for(                       # Iterate over string index.
  ;
  $s ^= 1;                 # Continue until $s (stop iterating) is 1.
                           # Flip $s so each iteration starts with $s
                           # being 1.
  $i++                     # Increment string index.
)
  for(
    ;
    "n" | $w=$argv[++$$i]; # Iterate over all input strings. OR with "n"
                           # to allow for empty strings.
    $s &= $x<~■            # If last character printed was greater than
                           # \x0 (all printable chars), set $s to 0,
                           # causing the loop to continue.
  )
    echo $x = $w[$i];      # Print char $i of current string.

IBM-850?! Is that a natural encoding for PHP?

@Adám what do you mean by "natural"? PHP treats bytes in the range 128-255 as text, which is therefore interpreted as a constant. If the constant is undefined, it will be interpreted as a string. It's so I can do ~■ (negated binary 254) instead of "\x1" (binary 1).

I see. It isn't that you actually need that codepage, you just need a 254 byte.

@Adám yes, the codepage just makes it a printable char which is a little less annoying.

Great use of $$!

Python 2, 128 96
I was hoping not to have to use itertools
a=lambda a:"".join([i for i in reduce(lambda: b,c:b+c, map(None,*map(lambda m:list(m),a)) if i])

Ungolfed
 a=lambda a:                              #Start a lambda taking in a
    "".join(                              #Join the result together with empty string
        [i for i in reduce(               #For every item, apply the function and 'keep'
           lambda: b,c:b+c,               #Add lists from...
                map(None,*map(            #None = Identity function, over a map of...
                    lambda m:list(m), a)  #list made for mthe strings m
                   ) if i                 #truthy values only (otherwise the outer map will padd with None.
       ])

Would appreciate feedback/advice on improving this.

Looks like this answer is invalid due to some syntax errors. Here's a fixed version, and here's one possible way to golf it (58 bytes).

@DLosc thanks! Not sure how best to incorporate those right now, but I appreciate it.

Python 3, 75 Bytes
I know the other Python one is shorter, but this is the first time I've used map ever in my life so I'm pretty proud of it
lambda n:''.join(i[k]for k in range(max(map(len,n)))for i in n if len(i)>k)

Python 3, 59 bytes
f=lambda s:s and s[0][:1]+f(s[1:]+[s[0][1:]][:s[0]>""])or""

A recursive function that takes a list of strings and returns a string. Try it online!
Explanation
We're going to build the interleaved string one character at a time. There are several cases to consider:

Is the first string in the list nonempty? Take its first character, move the rest of it to the end of the list, and recurse.
Is the first string in the list empty? Remove it from the list and recurse.
Is the list of strings empty? Then we're done. Return empty string.

The implementation goes as follows:
f = lambda s: s and ... or ""

Define f to be a function of one argument, s, which is a list of strings. If s is nonempty, do the ... part (see below); otherwise, return "".
s[0][:1] + f(...)

Since we now know s is nonempty, we can refer to its first element, s[0]. We don't know yet whether s[0] is empty, though. If it isn't, we want to concatenate its first character to a recursive call; if it is, we can concatenate the empty string to a recursive call. Slicing everything left of index 1 works in both cases.
s[1:] + ...

The argument to the recursive call is going to be all but the first element of s, concatenated to either a 1-element list (the rest of s[0] if it was nonempty) or an empty list (if s[0] was empty).
[s[0][1:]][:s[0] > ""]

We put s[0][1:] (the part of s[0] after the first character, which is the empty string if s[0] is empty) into a singleton list and then take a slice of that list. If s[0] is empty, s[0] > "" is False, which is treated as 0 in a slice; thus, we slice from index 0 to index 0--an empty slice. If s[0] is not empty, s[0] > "" is True, which is treated as 1; thus, we slice from index 0 to index 1--the whole 1-element list.

If lists of single-character strings can be used in place of strings, this solution can be 54 bytes:
f=lambda s:s and s[0][:1]+f(s[1:]+(s[0]and[s[0][1:]]))

Try it online!

K (ngn/k), 13 bytes
<!/,/'(!#:)'\

Try it online!
Port of miles's J and DLosc's BQN. For a language with flatten and grade/sort-by but not zip-longest, I guess this is one of the best possible approaches.
More straightforward port would be {(,/x)@<,/!'#'x} because K doesn't have fork or over. But it is possible to use K train by abusing repeat-scan:
<!/,/'(!#:)'\
      (   )'\   Given a list of strings, apply this to each list
                until convergence and collect all intermediate values
                (including the input):
       !#:        get the indices of the list
                This always converges after step 1, giving (x;!#x)
   ,/'          Flatten each
<!/             Sort first by second

Pip, 3 bytes
WVg

Try it online!
The WV (weave) builtin does exactly this. It's commonly used as a binary operator to weave two iterables together, but it can also be used as a unary operator to weave a list of iterables together. Here, g is the list of command-line arguments.

C, 75 71 bytes
Only limitation is the output length. Currently it's 99, but can be easily stretched to 999 (+1 byte).
i;main(a,b)char**b;{a--;for(;i<99;i++)*b[i%a+1]&&putchar(*b[i%a+1]++);}

Ungolfed:
i;
main( a, b )
char **b;
{
    a--;
    for( ; i < 99; i++ )
        *b[i % a + 1] && putchar( *b[i % a + 1]++ );
}

Oracle SQL, 195 bytes
    select listagg(b,'') within group(order by l,o) from(select substr(a,level,1) b,level l,o from i start with length(a)>0 connect by prior a=a and level<=length(a) and prior sys_guid() is not null)

Takes its input from a table named i with columns a (containing the string) and o (order of the string):
    create table i (a varchar2(4000), a integer)

Explanation:
We're exploiting CONNECT BY to break up the strings into each of the characters making them up. PRIOR SYS_GUID() being NOT NULL ensures we don't end up stuck in a loop.
We then concatenate the single characters with LISTAGG but we shuffle them around with an ORDER BY clause, ordering them first by their position in the original string and only then by the string they came from.
Not as short as the other answers but SQL isn't really meant as a string manipulation language :)

Perl 5, + -0n 24 bytes
1while s/^./!print$&/gem

Try it online!
Explanation
-0n slurps the input into $_ and repeatedly replaces the first char of each line with the result of negating the print of each match (which is the empty string since print returns 1 by default)

I thought I was good in Perl, but this baffled me.  So -0 on input that doesn't contail a NUL is equivalent to slurping all.  And then ^. with /g prints each beginning of line, while replacing it with nothing.

@Daniel Yeah that's about it! Needing to negate the print is a little annoying... Having looked at this again, I can save a byte using 1while s/.... so thanks!

R, 73 bytes
for(i in 1:max(nchar(s<-scan(,""))))for(j in seq(s))cat(substr(s[j],i,i))

Try it online!
Explanation: very simple (but verbose), just loop through printing ith character of the jth string. Fortunately, substr returns an empty string if given an out-of-range input.

Jq 1.5, 49 bytes
map(explode)|transpose|map(map(values)[])|implode

Explanation
                      # example input:          ["LYES","APRONS"]
  map(explode)        # make list of ordinals   [[76,89,69,83],[65,80,82,79,78,83]]
| transpose           # zip lists               [[76,65],[89,80],[69,82],[83,79],[null,78],[null,83]]
| map(map(values)[])  # rm nulls and flatten    [76,65,89,80,69,82,83,79,78,83]
| implode             # convert back to string  "LAYPERSONS"

Sample Run
$ paste input <(jq -Mrc 'map(explode)|transpose|map(map(values)[])|implode' input)
["SIMPLE"]                  SIMPLE
["POLLS","EPEES"]           PEOPLELESS
["LYES","APRONS"]           LAYPERSONS
["ABCDE", "a c", "123 567"] Aa1B 2Cc3D E567
["\"\\n$?*", "", ",(.)\" "] ",\(n.$)?"*

$ echo -n 'map(explode)|transpose|map(map(values)[])|implode' | wc -c
  49

Try it online

Factor, 22 bytes
[ round-robin ""like ]

Try it online!

BQN, 23 10 bytes
Massive savings by porting miles's J solution
↕∘≠¨⍋⊸⊏○∾⊢

Anonymous tacit function that takes a list of strings and returns a string. Try it at BQN online!
Explanation
↕∘≠¨⍋⊸⊏○∾⊢
   ¨         For each string in the argument list:
  ≠            Take its length
↕∘             and make a range from 0 to that number (exclusive)
             With that list of lists of indices as the left argument
          ⊢  and the original list of lists of strings as the right argument:
        ○∾     Flatten both lists
      ⊸⊏       Index into the flattened string using
    ⍋          the grade-up of the flattened list of indices

Grade up, for those unfamiliar with APL-related languages, is an operation that takes a list and returns a permutation of its indices, such that if the items in the list were reordered according to the order of the indices, the list would become sorted ascending. For example:
Indices:  0 1 2 3 4 5
List:     3 1 4 1 5 9

Grade up: 1 3 0 2 4 5
Sorted:   1 1 3 4 5 9

This operation is useful for sorting one list according to the values of another list, as seen in the above solution.

Vyxal s, 1 byte
∩

Try it Online!

Python, 112 bytes
i=len(x)if len(x)>len(y) else len(y) h=0 a="" while h<i: if h<len(x) a+=x[h] if h<len(y): a += y[h] h+=1 print a

Your formatting is really messed up.. where do you even get x and y from?

TXR Lisp, 20 bytes
(opip weave cat-str)

Run:
1> (opip weave cat-str)
#<intrinsic fun: 0 param + variadic>
2> [*1 "LYES" "APRONS"]
"LAYPERSONS"
3> [*1 "ABCDE" "a c" "" "123 567"]
"Aa1B 2Cc3D E567"
4> [*1 "\"\\n$?*" "" ",(.) "]
"\",\\(n.$)? *"

The weave function is lazy, so it returns a list, which is why we have to force the result to a string. Being lazy, it can weave infinite sequences. For instance, we can weave the even and odd natural numbers, which are themselves infinite lazy lists:
5> (take 20 (weave (range 2 : 2) (range 1 : 2)))
(2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19)

Perl 5, 53 bytes
$i=0,map{push@{$a[$i++]},$_}/./g for<>;print@$_ for@a

Try it online!
Method
Creates a two dimensional array where the number of rows is equal to the length of the longest string and the maximum number of columns is equal to the number of strings.  Then output each row of the array without spacing.

K (oK), 35 29 bytes
Solution:
{`c$r@&~^r:,/+(`i$x)[;!#,/x]}

Try it online!
Example:
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("ABCDE";"a c";"123 567")
"Aa1B 2Cc3D E567"
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("\n$?*";"";",(.)\" ")
"\n,$(?.*)\" "
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("POLLS";"EPEES")
"PEOPLELESS"

Explanation:
Use 2nd-level indexing to pull out indices from 0 to max (length of flattened list) across all input lists. Any indexing beyond the bound of the sub-list will return a null. Flip (rotates 90), flatten, and then pull out the non-null results.
Notes:

I cast to integer (i$) so that we get useful nulls, as space () is considered null for a char list which means you cant tell nulls from valid spaces.
Also I couldnt get the TIO to work with input (worked fine in the oK repl) so the TIO link includes the "ABCDE"... example.

Python3 -66
Python3 version of this one:
lambda*m:''.join(map(lambda*r:''.join([_f for _f in r if _f]),*m))

A super golfed version:
exec(bytes('慬扭慤洪✺⸧潪湩洨灡氨浡摢⩡㩲✧樮楯⡮彛潦⁲晟椠⁲晩张嵦Ⱙ洪⤩','u16')[2:])

How long is the "super golfed" version?  It looks longer.

It has 8 fewer characters.

Why not use a filter instead of a list comprehension like the answer you're porting from?

C# (Visual C# Interactive Compiler), 86 bytes
a=>a.SelectMany(b=>b.Select((c,i)=>(i,c))).OrderBy(b=>b.i).Aggregate("",(s,x)=>s+x.c);

Try it online!

Knight, 103 bytes
;=m=iF;W=xP;=mI>mLx mLxE++"=x"=i+1i" x"W+=m-mT1;=j~1W>i=j+1j;O+G E+"x"+1jF1'\'E++++"=x"+1j"Sx"+1j"F1''"

Try it online!

Python, 68 bytes
lambda S:filter(None,chain(*zip_longest(*S)))
from itertools import*
Attempt This Online!


text:
Make a number Fouriest
The problem is taken from this comic: http://www.smbc-comics.com/?id=2874

Your program must convert a number to the smallest base system in which it has the most fours in its digit sequence. Shortest code wins!
Function entries are allowed provided that the function prints the base in which the number is fouriest as well as the number in that base. You could just have it print "base:number" or "base number", so "5:4444" or "5 4444", or whatever is most convinient. Please provide sample outputs of your function when called.

What is the range of the bases? How small should they be?

Are function entries allowed? Must we output the number converted to base n, or may we output n instead?

Test cases would be a good idea.