text:
Test if a string can be made with substrings!
Given a string s and an array/list l, determine whether or not s can be made with parts from l.
For example, if the string is "Hello, world!" and the list is [' world!', 'Hello,'], then the program/function should return a truthy value, because you can arrange the list to form the string. The following list would also return a truthy value: ['l', 'He', 'o, wor', 'd!']. Just imagine the 'l' filling in where it needs to in he string. So yes, you may repeat elements of the list to form the string. If it cannot form the string, it should return a falsy value. Standard methods of IO, standard loopholes apply.
Test cases:
Input (In the form of s, l)
Output (1 if possible, 0 if impossible)

"Hello, world!", ["l", "He", "o, wor", "d!"]
1

"la lal al ", ["la", " l", "al "]
1

"this is a string", ["this should return falsy"]
0

"thi is a string", ["this", "i i", " a", " string"]
0

"aaaaa", ["aa"]
0

"foo bar foobar", ["foo", "bar", " ", "spam"]
1

"ababab", ["a","ba","ab"]
1

"", ["The string can be constructed with nothing!"]
1

Does it matter if the array contains more strings than are needed to construct the main string?

What should the return value be in those cases?

@Shaggy Truthy. If there is extra, then the string can be constructed with all the non-extra parts. I will add a test case.

I recommend adding this test case: "ababab", ["a","ba","ab"]

When you say capitiization does not matter do you mean that "tEsT", ["t","e","S"] will return true? If so, you should add that as a test case too

@mathjunkie Capitalization does matter, I don't know why I said it doesn't. Edited.

I'd suggest you add a test case containing regex metacharacters.

Missing test case: the string to construct is empty.

@Joey Interesting idea, but it does not fit the challenge in my point of view.   This is not a regex challenge. Good idea though.

@PeterTaylor Good idea, added.

@ComradeSparklePony: The point is to weed out solutions that blindly use regex and just pass the examples you posted, while something like ('abc', ['a', '.', 'b']) would pass for their solution, which shouldn't. Another point: When using unbalanced parentheses or quantifiers without anything to quantify (*) in the string list, those solutions would simply crash.

The final test case added after my submission not only breaks it, but all my mathematical intuition says the solution should be the opposite. If you're allowed to not use all the strings, then you should be allowed to use none of them.

@ØrjanJohansen Yes. I keep on confusing myself with this, and I think you are right. I will edit.

@ComradeSparklePony is it acceptable to return 0 if it can be created and a positive integer representing how far off the substrings are from the word  as a falsy value?

@carusocomputing Sorry, but the question asks for a truth/false value as output, and I will have to stand by that. However, feel free to post a solution that does that alongside a correct solution.

@ComradeSparklePony it's actually one byte less for my program to do that ;). Nbd, figured as much haha.

Brachylog, 8 bytes
~c¬{∋¬∈}

Try it online!
This is really slow. Took about 37 seconds for the "Hello, world!" test case on my PC, and timed-out on TIO.
This takes the string through the Input variable and the list through the Output variable
Explanation
             String = ?, List = .

             It is possible to find…
~c           …a deconcatenation of ?…
  ¬{   }     …such that it is impossible…
    ∋¬∈      …that an element of that deconcatenation is not an element of .

"la lal al" more than 60 seconds...

@RosLuP With this input and ["la", " l", "al "] as list, it terminated on my computer and correctly answered false. after 6800 seconds, and "only" 113 billion inferences.

I feel like writing anything in this language would result in a program not runnable on TIO haha.

@carusocomputing The language is not that slow for most programs, it's just that in some cases due to the declarativeness of the program, it results in very very slow execution times (which could be improved drastically at the cost of code length)

@Fatalize errr... I meant to say golfing not writing, seems like the fewer instructions, the broader the "question" becomes and the more calculation you need. Seems like an awesome langauge for theoretical math problems.

False negative for "", ["The string can be constructed with nothing!"]

Mathematica, 29 bytes
StringMatchQ[#,""|##&@@#2..]&

Explanation:
             #,               (* The first argument *)
StringMatchQ[                 (* matches the string pattern *)
               ""|##&         (*   Alternatives *)
                     @@       (*     applied to *)
                       #2     (*     the second argument *)
                         ..   (*   repeated *)
                           ]&

Borderline cheating solution, 21 bytes
StringMatchQ[#,#2..]&

Since Mathematica is a symbolic programming language, there is no* difference between the expressions List[a,b,...] and Alternatives[a,b,...] other than how they interact with other symbols and how they are displayed ({a,b,...} and a|b|..., respectively). When used in the second argument of StringMatchQ, an Alternatives expression is treated as a string pattern, and thus we can save 8 bytes over my above solution by taking the second argument as an Alternatives expression.
* Technically List is also Locked, which prevents users from Unprotecting it and changing its behavior.

{x,y,z} is treated the same as x|y|z for string pattern matching. I think you can replace ""|##&@@#2.. with just #2...

Pyth, 23 bytes
AQW&GhGJ.(G0Vf!xJTH aG>JlN;G

Takes input like [['string'],['list', 'of', 'parts']]. The output is either an empty list or a list with values inside. In Pyth, a list containing anything, even a null string (['']), evaluates to true.
Try it online!
Explanation:
                             | Implicit: Q = eval(input())
AQ                           | Assign the first value of Q to G and the second to H
  W&GhG                      | While G is not empty and G doesn't contain an empty string:
       J.(G0                 |  Pop the first value of G and store into J
            Vf!xJTH          |  For N in elements in H that match the beginning of J:
                             |   Additional space for suppressing printing
                    aG>JlN   |   Append to G the elements of J from the length of N to the end
                          ;  | End all loops
                           G | Print G

This solution continuously tries to remove every possible part from the beginning of the string, and keeps track of what values it still needs to look through.
If we look at the value of G in the test case [['ababab'],['a','ba','ab']] after each iteration of the while loop, this is what we get:
['ababab']
['babab', 'abab']
['abab', 'bab']
['bab', 'bab', 'ab']
['bab', 'ab', 'b']
['ab', 'b', 'b']
['b', 'b', '']
['b', '']
['']   <---Remember, this evaluates to True

And, in the test case [['aaaaa'],['aa']], this is what we get:
['aaaaa']
['aaa']
['a']
[]   <---And this evaluates to False

I created another test case, [['aaaaaa'],['a','aa','aaa']] and the output was this:
['', 'aaa', 'aa', 'a', 'aa', 'a', '', 'a', '', 'aa', 'a', '', 'a', '', '', 'a', '', '']

The output list contains a bunch of garbage inside of it, but it's still a truthy value.

Perl 5, 39 bytes
38 bytes of code + -p flag.
map{chop;$v.="\Q$_\E|"}<>;$_=/^($v)*$/

Try it online!
For the input "Hello, world!", ["l", "He", "o, wor", "d!"] (separated by newlines actually), it construct the pattern l|He|o, wor|d!| (with the metacharacters escaped, thanks to \Q..\E), and then looks if the first string matches this pattern with /^($v)*$/.
On the TryItOnline, note that there need to be a trailing newline.

"Hello, world!
l
He
o, wor
d!" this input with a space after the "l" generate no result

@RosLuP Can you give me a TryItOnline link please? (I don't understand what you mean exactly. Note that "false" actually prints nothing as this is Perl)

So for false print nothing? In this case excuse me, but this no output value not seems to me too much useful...

@RosLuP That's right. In Perl, undef is the falsy value returned by most builtin. And when printing it, it actually prints nothing. And that's exactly what I'm doing. Printing "1/0" is natural for C-like languages, but for Perl, "1/undef" is the natural way.

No output has one ambiguity "it is running or already the program end false?"

PHP, 69 Bytes
<?=($s=$_GET[0])>""?ctype_digit(strtr($s,array_flip($_GET[1])))?:0:1;

Testcases

Very clever, took me a minute to understand what you're doing. +1 for thinking outside the box

False negative for that pesky edge case ["", ["The string can be constructed with nothing!"]]

@JonathanAllan done is an empty string a string?

Yeah, the problem of empty partitioning is an issue in many solutions.

Pyth, 17 15 11 14 bytes
AQ|!G}Ym-dH./G

The requirement for the empty string changed, adding 3 bytes.
Explanation
AQ|!G}Ym-dH./G
AQ                     Save the input into G, H.
           ./G         Get all partitions of G.
       m-dH            Check if the parts are in H.
     }Y                The empty list should be present if and only
                           if the string can be made...
  |!G                  ... or the string might be empty.

Old versions
AQ}Ym-dH./G

Shorter and runs in the lifespan of the universe!
Explanation
AQ}Ym-dH./G
AQ                  Save the input into G, H.
        ./G         Get all partitions of G.
    m-dH            Check if the parts are in H.
  }Y                The empty list should be present if and only
                        if the string can be made.

AQ&G}GsMs.pMy*HlG

This is horrifyingly slow, but it works for my (trivially small) test cases.
Explanation
AQ&G}GsMs.pMy*HlG
AQ                  Save the input into G, H.
             *HlG   Repeat the list of substrings for each character of G.
            y       Take the power set.
         .pM        Take every permutation of each set of substrings.
      sMs           Get a list of all the joined strings.
    }G              Check if G is one of them.
  &G                Make sure G is not empty.

Python 2, 141 bytes
lambda s,l:s in[''.join(i)for r in range(len(s)+1)for j in combinations_with_replacement(l,r)for i in permutations(j)]
from itertools import*

Try it Online!
Extremely inefficient. The first test case times out on TIO.

JavaScript (ES6), 59 bytes
Takes the array of substrings a and the string s in currying syntax (a)(s). Returns false / true.
a=>g=s=>!s||a.some(e=>s.split(e)[0]?0:g(s.slice(e.length)))

Commented
a =>                          // main function that takes 'a' as input
  g = s =>                    // g = recursive function that takes 's' as input
    !s ||                     // if 's' is empty, return true (success!)
    a.some(e =>               // else, for each element 'e' in 'a':
      s.split(e)[0] ?         //   if 's' doesn't begin with 'e':
        0                     //     do nothing
      :                       //   else:
        g(s.slice(e.length))  //     remove 'e' at the beginning of 's' and
    )                         //     do a recursive call on the remaining part

Test cases

let f =

a=>g=s=>!s||a.some(e=>s.split(e)[0]?0:g(s.slice(e.length)))

console.log(f(["l", "He", "o, wor", "d!"])("Hello, world!"))        // true
console.log(f(["la", " l", "al "])("la lal al "))                   // true
console.log(f(["this should return falsy"])("this is a string"))    // false
console.log(f(["this", "i i", " a", " string"])("thi is a string")) // false
console.log(f(["aa"])("aaaaa"))                                     // false
console.log(f(["foo", "bar", " ", "spam"])("foo bar foobar"))       // true
console.log(f(["a","ba","ab"])("ababab"))                           // true

Haskell, 35 bytes
# takes a String and a list of Strings, and returns a Bool.
s#l=elem s$concat<$>mapM("":)(l<$s)

Try it online!
Just don't mind the test case I left out because it thrashed my meager laptop, even with -O2. I suspect GHC doesn't fuse away that intermediate 30517578125 element list, it has too much sharing to get swiftly garbage collected, and because the test case is false the program has to generate all of it... feel free to try if you can handle that.
mapM("":)(l<$s) is a list of all ways of making a length s list of elements that are either empty strings or strings from l.

Jelly, 14  12 8 bytes
;FŒṖḟ€Ạ¬

Try it online!
How it works
;FŒṖḟ€Ạ¬   - main function, left argument s, right argument l
;F         - concatenate to the string the list, flattened to deal with "" as string
  ŒṖ       - Get all partitions of s, that is, all ways to make s from substrings
     €     - For each partition...
    ḟ      -   Filter out (exclude) those elements which are not in...
           -   (implicit right arg) the list l. This leaves the empty set (falsy) if the partition can be made of elements from the list
      Ạ    - If any element is falsy (thus constructable from l), return 0; else return 1
       ¬   - Apply logical not to this, to yield the proper 1 = constructable from list, 0 otherwise.

bugfix on case "", ["The string can be constructed with nothing"] thanks to @JonathanAllan

False negative for "", ["The string can be constructed with nothing!"]

It'll be much slower but ;FŒṖḟ⁹$€Ạ¬ would fix it.

...and you can use an implicit right argument for ḟ, so you dont need the $ or the ⁹: ;FŒṖḟ€Ạ¬.

Grr, that's what I get for not testing every single testcase. I might be able to maintain 8 bytes by replacing ¬ with an operation which always returns true with right argument "".

^ well I got it back to 8 :)

R, 49 bytes
function(s,l)gsub(paste(l,collapse='|'),"",s)==""

Try it online!

Should fail for ('x', '.'), but doesn't.

Pyth, 10 8 bytes
f!-TQ./+zh

Test suite
This takes the list on the first line of STDIN, and the string (without quotes) on the second.
To start, the list is stored in Q, and the string is stored in z. Next, we form all possible partitions of z. Each partition will be filtered (f) to check if it uses only pieces in Q. To do this, we remove all elements of Q from T, the partition we're partitioning, and logically negate the result with !, so that only partitions where every element was in Q are kept.
To fix the problem that '' has no partitions, we add the first word of the dictionary to z, so that it won't be an empty string.

The test suite misses the bottom line (an empty string) - Does it need quoting? With an empty line or "" it seems to fail that case.

An empty string has no partitions, so it actually just gives the wrong answer here. Darn, I'll try to fix it.

The fix I suggested for Jelly was to concatenate the input string with the input array flattened, maybe you can do the same?

@JonathanAllan I did something similar, thanks.

The cases of "", [""] and "", [] have not been covered - lets not go there :)

PowerShell, 61 58 57 bytes
{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};+!$s}

Try it online!
Old solutions:
{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};[int]!$s}
{$s,$l=$_;$l|sort -d length|%{$s=$s.replace($_,'')};0+!$s}

This one is almost unreadable, so I'd reccommend changing it a bit. I'm fairly certain most other people would agree.

Thank you for the explanation of the reason of your correction of my solution.

C++(Bcc), 287 bytes
#include<algorithm.h>
f(a,b)char*a,**b;{int i,j,k,v,p[256];if(!a||!b||!*b)return-1;for(v=0;v<256&&b[v];++v)p[v]=v;if(v>=256)return-1;la:for(i=0,j=0;j<v&&a[i];){for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k);j=b[p[j]][k]?(i-=k),j+1:0;}if(a[i]&&next_permutation(p,p+v)) goto la;return i&&!a[i];}

because i do not wrote or used too much the next_permutation() i don't know if is all ok.
I don't know 100% if it is a solution too possibly this is out of quality...
One list of string is here one array of pointers to char; NULL terminated
The algo is easy, there is one algo that linearity try if all string in the list fit with argument "a" string
there is one other algo that permute the index of the list of string so it try all possible combination.
ungolf it, test code and results here
#include<stdio.h>
g(a,b)char*a,**b;
{int i,j,k,v,p[256];
 if(!a||!b||!*b) return -1;
 for(v=0;v<256&&b[v];++v) p[v]=v;
 if(v>=256)      return -1; // one array of len >256 is too much
la:
 for(i=0,j=0;j<v&&a[i];)
   {for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k);
    j=b[p[j]][k]?(i-=k),j+1:0;
   }
 if(a[i]&&next_permutation(p,p+v)) goto la;
 return i&&!a[i];
}

#define F for
#define P printf

test(char* a, char** b)
{int i;
 P("f(\"%s\",[",a);
 F(i=0;b[i];++i)
       P("\"%s\"%s", b[i], b[i+1]?", ":"");
 P("])=%d\n", f(a,b));
}

main()
{char *a1="Hello, world!",    *b1[]={"l","He", "o, worl", "d!",      0};//1
 char *a2="la lal al ",       *b2[]={"la", " l", "al ",              0};//1
 char *a3="this is a string", *b3[]={"this should return falsy",     0};//0
 char *a4="thi is a string",  *b4[]={"this", "i i", " a", " string", 0};//0
 char *a5="aaaaa",            *b5[]={"aa",                           0};//0
 char *a6="foo bar foobar",   *b6[]={"foo","bar"," ","spam",         0};//1
 char *a7="ababab",           *b7[]={"a","ba","ab",                  0};//1
 char *a8="",                 *b8[]={"This return 0 even if has to return 1", 0};//0
 char *a9="ababc",            *b9[]={"a","abc", "b", 0};//1

  test(a1,b1);test(a2,b2);test(a3,b3);test(a4,b4);test(a5,b5);test(a6,b6);
  test(a7,b7);test(a8,b8);test(a9,b9);
}

f("Hello, world!",["l", "He", "o, worl", "d!"])=1
f("la lal al ",["la", " l", "al "])=1
f("this is a string",["this should return falsy"])=0
f("thi is a string",["this", "i i", " a", " string"])=0
f("aaaaa",["aa"])=0
f("foo bar foobar",["foo", "bar", " ", "spam"])=1
f("ababab",["a", "ba", "ab"])=1
f("",["This return 0 even if has to return 1"])=0
f("ababc",["a", "abc", "b"])=1

this would compile in gcc C++ compiler
#include<algorithm>

int f(char*a,char**b){int i,j,k,v,p[256];if(!a||!b||!*b)return -1;for(v=0;v<256&&b[v];++v)p[v]=v;if(v>=256)return -1;la:;for(i=0,j=0;j<v&&a[i];){for(k=0;b[p[j]][k]==a[i]&&a[i];++i,++k);j=b[p[j]][k]?(i-=k),j+1:0;}if(a[i]&&std::next_permutation(p,p+v))goto la;return i&&!a[i];}

Gotta love C++! :)

Python 2, 64 bytes
lambda s,l:len(re.findall("^("+"|".join(l)+")*$",s))>0
import re

Try this online!

I think this doesn't totally work, try ("aaaaaaa",["aa","aaa"]).

@xnor I updated it.  Come to find out, regex is perfect for this.

Should fail for ('x', '.'), I guess, but doesn't.

@nfnneil Did you? Your last edit was 10 hours ago.

...or "Hello", ["\w"] etc.

PowerShell, 78
$s,$l=$args;!($s-creplace(($l|sort -d length|%{[regex]::escape($_)})-join'|'))

Pretty straightforward regex-based approach.

CJam (16 bytes)
{Ma+1$,m*:e_\a&}

This is an anonymous block (function) taking the string and the array of strings on the stack. Online demo.
It uses the obvious algorithm:
{        e# Declare a block. Call the args str and arr
  Ma+    e#   Add the empty string to the array
  1$,m*  e#   Take the Cartesian product of len(str) copies of (arr + [""])
  :e_    e#   Flatten each element of the Cartesian product into a single string
  \a&    e#   Intersect with an array containing only str
}

The return value is an empty array/string (falsy) if str can't be made, or an array containing str (truthy, even if str is itself the empty string) if it can be made.

@RosLuP, I'm not sure what you mean. That particular test case executes so fast that I can't actually time it. Other test cases do take a long time to execute, but the spec doesn't include any time constraints.

@RosLuP, online demo. But I don't understand what your complaint is.

Python, 66 bytes
lambda s,l:s==''or any(x==s[:len(x)]and f(s[len(x):],l)for x in l)

Ungolfed:
def f(s,l):
    if s=='':
        return 1
    for x in l:
        if s.startswith(x) and f(s[len(x):],l):
            return 1
    return 0

Microsoft Sql Server, 353 bytes
u as(select s.n,s collate Latin1_General_BIN s,l collate Latin1_General_BIN l,
row_number()over(partition by l.n order by len(l)desc)r from s,l where s.n=l.n),
v as(select n,s,l,replace(s,l,'')c,r from u where r=1 union all
select u.n,u.s,u.l,replace(v.c,u.l,''),u.r from v,u where v.n=u.n and v.r+1=u.r)
select s,iif(min(c)='',1,0)u from v group by n,s

Test it online.
Readable version:
with s as(
  select n,s
  from(values(1,'Hello, world!'),
             (2,'la lal al '),
             (3,'this is a string'),
             (4,'thi is a string'),
             (5,'aaaaa'),
             (6,'foo bar foobar'),
             (7,'ababab'),
             (8,''))s(n,s)),
l as(
  select n,l
  from(values(1,'l'),(1,'He'),(1,'o, wor'),(1,'d!'),
             (2,'la'),(2,' l'),(2,'al '),
             (3,'this should return falsy'),
             (4,'this'),(4,'i i'),(4,' a'),(4,' string'),
             (5,'aa'),
             (6,'foo'),(6,'bar'),(6,' '),(6,'spam'),
             (7,'a'),(7,'ba'),(7,'ab'),
             (8,'The string can be constructed with nothing!'))l(n,l)),
--The solution starts from the next line.
u as(
  select s.n,
    s collate Latin1_General_BIN s,
    l collate Latin1_General_BIN l,
    row_number()over(partition by l.n order by len(l)desc)r
  from s,l
  where s.n=l.n),
v as(
  select n,s,l,replace(s,l,'')c,r from u where r=1
    union all
  select u.n,u.s,u.l,replace(v.c,u.l,''),u.r
  from v,u
  where v.n=u.n and v.r+1=u.r
)
select s,iif(min(c)='',1,0)u from v group by n,s

C, 140 bytes
I'm sure there is a shorter way to do this in C but I wanted to create a solution that tests all the possible combinations of substrings instead of the usual find/replace method.
char p[999];c,o;d(e,g,l,f)int*e,**g,**l;{c=f&&c;for(l=g;*l;)strcpy(p+f,*l++),(o=strlen(p))<strlen(e)?d(e,g,0,o):(c|=!strcmp(e,p));return c;}

Try it online
Ungolfed:
#include <string.h>
#include <stdio.h>

char buf[999];
int result;
int temp;

int test(char *text, char **ss, char **ptr, int length)
{
    if (length == 0)
        result = 0;

    for(ptr = ss; *ptr; ptr++)
    {
        strcpy(buf + length, *ptr);
        temp = strlen(buf);
        if (temp < strlen(text))
        {
            // test recursivly
            test(text, ss, 0, temp);
        }
        else
        {
            if (strcmp(buf, text) == 0)
                result = 1;
        }
    }
    return result;
}

int main()
{
    char *text = "Hello,World";
    char *keywords[] = { "World", "Hello", ",", 0 };
    printf("%d", test(text, keywords, 0, 0));
}

138 bytes


text:
Number triangle flip
Say you list the positive integers in a triangle, then flip it left-to-right. Given a number, output the number it's sent to. This is a self-inverse mapping.
         1                      1
       2   3                  3   2
     4   5   6    <--->     6   5   4
   7   8   9  10         10   9   8   7
11  12  13  14  15     15  14  13  12  11

This is the n'th element of A038722, one-indexed:
1, 3, 2, 6, 5, 4, 10, 9, 8, 7, 15, 14, 13, 12, 11, ...

This sequence reverses contiguous chunks of the positive integers with increasing lengths:
 1, 3, 2, 6, 5, 4, 10, 9, 8, 7, 15, 14, 13, 12, 11, ...
<-><----><-------><-----------><------------------>

Test cases:
1 -> 1
2 -> 3
3 -> 2
4 -> 6
14 -> 12
990 -> 947
991 -> 1035
1000 -> 1026
1035 -> 991
1036 -> 1081
12345 -> 12305

Leaderboard:

var QUESTION_ID=117879,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/117879/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

JavaScript (ES7), 26 bytes
n=>((2*n)**.5+.5|0)**2-n+1

An implementation of the following formula from OEIS:

Demo

let f =

n=>((2*n)**.5+.5|0)**2-n+1

for(n = 1; n <= 50; n++) {
  console.log(n, '->', f(n))
}

I like the OR operation to chunk it into an integer! nice job!

Jelly, 8 7 bytes
RṁR€UFi

Thanks to @ErikTheOutgolfer for saving 1 byte!
Try it online!
How it works
RṁR€UFi  Main link. Argument: n

R        Range; yield [1, ..., n].
  R€     Range each; yield [[1], [1, 2], [1, 2, 3], ..., [1, ..., n]].
 ṁ       Mold the left argument like the right one, yielding
         [[1], [2, 3], [4, 5, 6], ...]. The elements of the left argument are
         repeated cyclically to fill all n(n+1)/2 positions in the right argument.
    U    Upend; reverse each flat array, yielding [[1], [3, 2], [6, 5, 4], ...].
     F   Flatten, yielding [1, 3, 2, 6, 5, 4, ...].
      i  Index; find the first index of n in the result.

Alice, 27 bytes
Thanks to Sp3000 for the .C idea.
/o
\i@/.2:e2,tE*Y~Z.H2*~.C+

Try it online!
Explanation
I think there may be a shorter  way to compute this using triangular numbers, but I thought this is an interesting abuse of a built-in, so here's a different solution.
The basic idea is to make use of Alice's "pack" and "unpack" built-ins. "Pack", or Z, takes two integers maps them bijectively to a single integer. "Unpack", or Y, inverts this bijection and turns one integer into two. Normally, this can be used to store a list or tree of integers in a single (large) integer and recover the individual values later. However, in this case we can use the functions in the opposite order, to let the nature of the bijection work for us.
Unpacking one integer into two integers basically consists of three steps:

Map ℤ → ℕ (including zero) with a simple "folding". That is, map negative integers to odd naturals, and non-negative integers to even naturals.
Map ℕ → ℕ2, using the Cantor pairing function. That is, the naturals are written along the diagonals of an infinite grid and we return the indices:
   ...
3  9 ...
2  5 8 ...
1  2 4 7 ...
0  0 1 3 6 ...

   0 1 2 3

E.g. 8 would be mapped to the pair (1, 2).
Map ℕ2 → ℤ2, using the inverse of step 1 on each integer individually. That is, odd naturals get mapped to negative integers, and even naturals get mapped to non-negative integers.

To pack two integers into one, we simply invert each of those steps.
Now, we can see that the structure of the Cantor pairing function conveniently encodes the triangle we need (although the values are off-by-one). To reverse those diagonals, all we need to do is swap the x and y coordinates into the grid.
Unfortunately, since all three of the above steps are combined into a single built-in Y (or Z), we need to undo the ℤ → ℕ or ℕ → ℤ mappings ourselves. However, while doing so we can save a couple of bytes by directly using ℕ+ → ℤ or ℤ → ℕ+ mappings, to take care of the off-by-one error in the table. So here is the entire algorithm:

Map ℕ+ → ℤ using (n/2) * (-1)n-1. This mapping is chosen such that it cancels the implicit ℤ → ℕ mapping during unpacking, except that it shifts the value down by 1.
Unpack the result into two integers.
Swap them.
Pack the swapped values into a single integer again.
Map ℤ → ℕ+ using |2n| + (n≥0). Again, this mapping is chosen such that it cancels the implicit ℕ → ℤ mapping during packing, except that it shifts the value up by 1.

With that out of the way, we can look at the program:
/o
\i@/...

This is simply a framework for linear arithmetic programs with integer input and output.
.    Duplicate the input.
2:   Halve it.
e    Push -1.
2,   Pull up the other copy of the input.
t    Decrement.
E    Raise -1 to this power.
*    Multiply. We've now computed (n/2) * (-1)^(n-1).
Y    Unpack.
~    Swap.
Z    Pack.
.H   Duplicate the result and take its absolute value.
2*   Double.
~    Swap with other copy.
.C   Compute k-choose-k. That's 1 for k ≥ 0 and 0 for k < 0.
+    Add. We've now computed |2n| + (n≥0).

Jelly, 8 bytes
Ḥ½+.Ḟ²‘_

Try it online!
Port of my MATL answer.

Haskell, 31 bytes
r=round
f n=r(sqrt$2*n)^2-r n+1

Try it online!
This answer just uses the formula.  It is the least interesting answer here, but it also happens to be the golfiest.
Haskell, 38 36 34 bytes
x!y|x<=y=1-x|v<-y+1=v+(x-y)!v
(!0)

Try it online!
(!0) is the point free function we are concerned with.
Explanation
Let me start out by saying I'm very happy with this answer.
The basic idea here is that if we remove the largest triangular number smaller than our input we can reverse it and add the triangular number back.  So we define an operator !, ! takes our regular input, x, but it also takes an extra number y.  y keeps track of the size of the growing triangular number.  If x>y we want to recurse, we decrease x by y and increase y by one.  So we calculate (x-y)!(y+1) and add y+1 to it.  If x<=y we have reached our base case, to reverse x's placement in the row of the triangle we return 1-x.
Haskell, 54 bytes
f x|u<-div(x^2-x)2=[u+x,u+x-1..u+1]
(!!)$0:(>>=)[1..]f

Try it online!
(!!)$0:(>>=)[1..]f is a point-free function
Explanation
The first thing we are concerned with is f, f is a function that takes x and returns the xth row of th triangle in reverse.  It does this by first calculating the x-1nd triangular number and assigning it to u. u<-div(x^2-x)2.  We then return the list [u+x,u+x-1..u+1]. u+x is the xth triangular number and the first number on the row, u+x-1 is one less than that and the second number on the row u+1 is one more than the last triangular number and thus the last number on the row.
Once we have f we form a list (>>=)[1..]f, which is a flattening of the triangle.  We add zero to the front with 0: so that our answers will not be offset by one, and supply it to our indexing function (!!).
Haskell, 56 bytes
f 0=[0]
f x|u<-f(x-1)!!0=[u+x,u+x-1..u+1]
(!!)$[0..]>>=f

Try it online!
This one is 2 bytes longer but a bit more elegant in my opinion.

MATL, 15 11 bytes
EX^.5+kUG-Q

Try it online!
This uses the formula
a(n) = floor(sqrt(2*n)+1/2)^2 - n + 1.

Octave, 71 68 bytes
3 bytes saved thanks to Conor O'Brien.
x=triu(ones(n=input('')));x(~~x)=1:nnz(x);disp(nonzeros(flip(x))(n))

This doesn't work for large inputs due to memory limitations.
Try it online!
Explanation
Consider input n = 4. The code first builds the matrix
 1     1     1     1
 0     1     1     1
 0     0     1     1
 0     0     0     1

Then it replaces nonzero entries in column-major order (down, then across) by 1, 2, 3 ... :
 1     2     4     7
 0     3     5     8
 0     0     6     9
 0     0     0    10

Then it flips the matrix vertically:
 0     0     0    10
 0     0     6     9
 0     3     5     8
 1     2     4     7

Finally, it takes the n-th nonzero value in column-major order, which in this case is 6.

@rahnema1 That e is genius! You should definitely post it as an answer, together with your other very good suggestions. As for ans =, I'm never sure it it's valid or not

C (gcc), 48 bytes
k,j,l;f(n){for(k=j=0;k<n;)l=k,k+=++j;n=1+k-n+l;}

Try it online!
Probably suboptimal, but I'm pretty happy with this one. Uses the fact that
NTFN = TN + A057944(N) - N + 1
(If I wrote the formula down correctly, that is.)

You're not calling return, but the a return value is used. That is undefined behavior.

@2501 As long as the program works, it's allowed. And, writing to the first argument of a function is equivalent to returning a value.

And, writing to the first argument of a function is equivalent to returning a value. No such thing exists in the C language. The standard even explicitly says using the returned value from a function that doesn't return is undefined behavior.

@2501 You seem to be confusing the C environment (gcc) for the C specification. Yes, the C language/spec calls it undefined, but it is implemented as such. So when I say "equivalent", I am most definitely referring to the implementation of C by gcc and most other compilers. On PPCG, we don't write "perfect" code--much code goes against specification for the sake of golfing. As I said, as long as it works, it's a valid answer.

@2501 I encourage you to read some articles on the meta site, particularly this one.

Batch, 70 bytes
@set/ai=%2+1,j=%3+i
@if %j% lss %1 %0 %1 %i% %j%
@cmd/cset/ai*i+1-%1

Uses a loop to find the index of the triangular number at least as large as n.

05AB1E, 30 bytes
U1V[YLO>X›iYLOX-UY<LO>X+,q}Y>V

Try it online!

I was about to say "What? An 05AB1E answer with no Unicode?" but then the one non-ASCII character ruins it... :P Nice first answer, though, welcome to Programming Puzzles and Code Golf!

@Qwerp-Derp Thank you very much! I just started learning this language, so I'm not surprised my answer was that bad.

Husk, 6 bytes
!ṁ↔´CN

Try it online!
Explanation
!ṁ↔´CN  -- implicit input N, for example: 4
   ´ N  -- duplicate the natural numbers:
           [1,2,3,…] [1,2,3,…]
    C   -- cut the second argument into sizes of the first:
           [[1],[2,3],[4,5,6],[7,8,9,10],…]
 ṁ↔     -- map reverse and flatten:
           [1,3,2,6,5,4,10,9,8,7,15,…
!       -- index into that list:
           6

tinylisp, 78 bytes
(d _(q((R N T)(i(l T N)(_(a R 1)N(a T R))(a 2(a T(s T(a N R
(d f(q((N)(_ 2 N 1

Defines a function f that performs the mapping. Try it online!
Ungolfed
We find the smallest triangular number that is greater than or equal to the input number, as well as which row of the triangle our number is in. From these, we can calculate the flipped version of the number.

If the current triangular number is less than N, recurse to the next row of the triangle. (We treat the top row as row 2 to make the math simpler.)
Otherwise, the flipped version of N is (T-N)+(T-R)+2.

The main function flip simply calls the helper function _flip starting from the top row.
(load library)

(def _flip
 (lambda (Num Row Triangular)
  (if (less? Triangular Num)
   (_flip Num (inc Row) (+ Triangular Row))
   (+ 2
    (- Triangular Num)
    (- Triangular Row))))))

(def flip
 (lambda (Num) (_flip Num 2 1)))

Julia 1.0, 29 23 bytes
!n=round((2n)^.5)^2-n+1

Try it online!
Port of Arnauld's JS answer.
-6 thx to @steffan

you don't need parens around floor(...), 2*n can be 2n

and you can save another three bytes by replacing floor(...+.5) with round(...)

21 bytes replacing round with a div by 1: !n=(√(2n)÷1)^2-n+1

05AB1E, 9 bytes
·LD£í˜¹<è

Try it online!
Explanation
·L          # push range [1 ... 2n]
  D         # duplicate
   £        # split the first list into pieces with size dependent on the second list
    í       # reverse each sublist
     ˜      # flatten
      ¹<è   # get the element at index <input>-1

Array flattening unfortunately doesn't handle larger lists very well.
At the cost of 1 byte we could do ·t2z+ïn¹-> using the mathematical formula floor(sqrt(2*n)+1/2)^2 - n + 1 found on OEIS.

Pyt, 13 12 bytes
←Đ2*√½+⌊²-~⁺

Port of Arnauld's approach

Python 3, 37 35 32 bytes
lambda n:round((2*n)**.5)**2-n+1

Try it online!
Port of Arnauld's JS answer.
-3 thx to @Steffan

you don't need parens around int(...)

and you can save another byte by replacing int(...+.5) with round(...)

Vyxal, 8 bytes
dɾ:ẇRfJi

Try it Online!

PHP, 35 Bytes
<?=((2*$argn)**.5+.5^0)**2-$argn+1;

Same formula that is used in Arnaulds Approach

C#, 46 44 bytes
n=>Math.Pow((int)(Math.Sqrt(2*n)+.5),2)-n+1;

I port @Arnauld's solution. Thank you!

Pow of 0.5 is Sqrt. 2 bytes saved!

APL (Dyalog), 27 bytes
I've got two solutions at the same bytecount.
A train:
⊢⊃⊃∘(,/{⌽(+/⍳⍵-1)+⍳⍵}¨∘⍳)

Try it online!
And a dfn:
{⍵⊃⊃((⍳⍵),.{1+⍵-⍳⍺}+\⍳⍵)}

Try it online!
Both of these solutions first create the flipped triangle and then extract element at the index stated by the argument (1-based).

J, 25 bytes
3 :'>:y-~*:>.-:<:%:>:8*y'

As an explanation, consider f(n) = n(n+1)/2. f(r), given the row r, returns the leftmost number of the the rth row of the mirrored triangle. Now, consider g(n) = ceiling[f⁻¹(n)]. g(i), given the index i, returns the row on which index i is found. Then, f(g(n)) returns the leftmost number of the row on which index n is found. So, h(n) = f(g(n)) - (n - f(g(n)-1)) + 1 is the answer to the above problem.
Simplifying, we get h(n) = [g(n)]² - n + 1 = ceiling[(-1 + sqrt(1 + 8n))/2]² - n + 1.
From the looks of @Arnauld's formula, it appears that:
ceiling[(-1 + sqrt(1 + 8n))/2] = floor[1/2 + sqrt(2n)].

J, 19 bytes
1-]-0.5*:@<.@+%:@+:

Try it online! Uses the formula from Arnauld's answer.
1-]-0.5*:@<.@+%:@+:
                 +:    2n
              %:@      sqrt(^)
    0.5      +         0.5 + ^
          <.@          floor(^)
       *:@             square(^)
  ]-                   input - ^
1-                     1 - ^
                       (computes - input + 1 in a golfier way)

J, 43 bytes
1+;@((#{.[:;(1<@,#&0)"0)<@|.;.1>:)@i.@+:i.]

Try it online!
Shortest non-formula solution I could think of. The array form of ;. is really unwieldly for code golf, and it doesn't help that ragged lists aren't that golfy either.
1+;@((#{.[:;(1<@,#&0)"0)<@|.;.1>:)@i.@+:i.]
                                  @i.@+:      range [0, 2n)
    (                       ;.1>:)            segment [1, 2n] according to
     (                 )                      the indices of triangular numbers:
            (       )"0                         over each integer in [0, 2n):
                 #&0                            create that many 0s
             1  ,                               prepend a 1 (a cut location)
              <@                                and box it
         [:;                                    then raze that boxed list
      #{.                                       and take 2n entries from that array
                        <@|.                  box and reverse each segment
  ;@                                          raze this list
                                        i.]   get the 0-based index of the input in it
1+                                            and add 1

For generating the indices of triangular number, the invariance under inverse transform (=(-:@*>:)@<.@%:@+:) is 1 byte longer, but much faster.

Japt, 11 bytes
0-indexed
gUòò@T±1ÃcÔ

Try it
gUòò@T±1ÃcÔ     :Implicit input of integer U
g               :Index into
 Uò             :  Range [0,U]
   ò            :  Range [0,each]
    @           :  Map each subrange
     T±1        :    Increment T (initially 0) by 1
        Ã       :  End map
         c      :  Flat map
          Ô     :    Reverse

source: Stack Exchange

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

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

sort: votes


text:
Sp|Lit wo(r)dS, S(P)lit wO|rds
m|Y bR|ain is We|iRd. F(o)R T(h)E La|sT fi(v)e YE|ars O|R s|o, (I) ha|ve C(u)T wO|rds in h(a)lf wh|En (I) s(e)e Th|em. Wh|EN I started Do|ing it, it To|oK a meN|TaL effort - B(u)T I almost cou(l)dn't N(o)T d|o it. N(o)w, I d|o it in the back of my head, a(n)d hardly ev|en not|iCe it. However, I thought this wo|uld make a great challenge.
Definitions
For this challenge, each letter is given a point score, based on my judgement of its width in a sans-serif font. You will use this width to cut a word into two halves of equal width. The characters that this challenge will use are the alphabet in lower and upper cases, apostrophe, and hyphen.
Width  Characters
1      i l I '
2      f j r t -
3      a b c d e g h k n o p q s u v x y z
4      m w A B C D E F G H J K L N O P Q R S T U V X Y Z
5      M W

For my explanations and test cases, | denotes the location in which a word can be cleanly split in half. ( and ) on either side of a letter indicate that that letter will be split in half to create a clean split.
Input
Input will consist of a single "word" (which is not required to be in the dictionary). You can take this word in whatever text input you would like (String, char array, etc.). This word will only contain letters, ', and - (see above table). Because of what you will do with this word (see below), case of input is left to the developer's discretion. Trailing newlines allowed if needed.
The Task
Permutate through all forms of the input (all letters at all possible upper or lower case positions). For example, for input it's, the below is all permutations:
it's
it'S
iT's
iT'S
It's
It'S
IT's
IT'S

To split a permutation of a word in half, the points on one side of the word must be the same as the points of the other side of the word. However, if a letter is stuck in between two even sections, you can also cut a letter cleanly in half.
Please note that "half" does not mean that you have moved halfway into the string. "Half" means that the points on both sides are equal.
Examples:
W is 5 points. i is 1 point. Splitting the permutation Wiiiii in half will result in W | iiiii, with 5 points on each side of the |.
T is 3 points. Splitting the permutation TTTT in half will result in TT | TT, with 6 points on each side of the |.
w is 4 points. a is 3 points. Splitting the permutation waw in half will result in w (a) w, with 5.5 points on each side. The points from a are distributed to both sides, as a is split in half.
Output
Your output is an integer of the number of unique permutations of the input that can be cleanly split in half. Trailing newlines allowed if needed.
Test Cases
I will be outputting all valid permutations of the input for the test cases. Remember that that is not part of the specs for you.
In my intermediate output, the numbers indicate the point value of the letter above them, so the output is a bit easier to visualize.
Input: a
( a )
  3
( A )
  4
Output: 2

Input: in
Output: 0

Input: ab
A | B
4   4
a | b
3   3
Output: 2

Input: abc
A ( B ) C
4   4   4
A ( b ) C
4   3   4
a ( B ) c
3   4   3
a ( b ) c
3   3   3
Output: 4

Input: will
W ( I ) L l
5   1   4 1
W ( I ) l L
5   1   1 4
W ( i ) L l
5   1   4 1
W ( i ) l L
5   1   1 4
w I | L l
4 1   4 1
w I | l L
4 1   1 4
w i | L l
4 1   4 1
w i | l L
4 1   1 4
Output: 8

Input: stephen
S T E ( P ) H E N
4 4 4   4   4 4 4
S T E ( p ) H E N
4 4 4   3   4 4 4
S T E | p h e n
4 4 4   3 3 3 3
S T e ( P ) H E n
4 4 3   4   4 4 3
S T e ( P ) H e N
4 4 3   4   4 3 4
S T e ( P ) h E N
4 4 3   4   3 4 4
S T e ( p ) H E n
4 4 3   3   4 4 3
S T e ( p ) H e N
4 4 3   3   4 3 4
S T e ( p ) h E N
4 4 3   3   3 4 4
S t E ( P ) H e n
4 2 4   4   4 3 3
S t E ( P ) h E n
4 2 4   4   3 4 3
S t E ( P ) h e N
4 2 4   4   3 3 4
S t E ( p ) H e n
4 2 4   3   4 3 3
S t E ( p ) h E n
4 2 4   3   3 4 3
S t E ( p ) h e N
4 2 4   3   3 3 4
S t e ( P ) h e n
4 2 3   4   3 3 3
S t e p | H E N
4 2 3 3   4 4 4
S t e ( p ) h e n
4 2 3   3   3 3 3
s T E ( P ) H E n
3 4 4   4   4 4 3
s T E ( P ) H e N
3 4 4   4   4 3 4
s T E ( P ) h E N
3 4 4   4   3 4 4
s T E ( p ) H E n
3 4 4   3   4 4 3
s T E ( p ) H e N
3 4 4   3   4 3 4
s T E ( p ) h E N
3 4 4   3   3 4 4
s T e ( P ) H e n
3 4 3   4   4 3 3
s T e ( P ) h E n
3 4 3   4   3 4 3
s T e ( P ) h e N
3 4 3   4   3 3 4
s T e ( p ) H e n
3 4 3   3   4 3 3
s T e ( p ) h E n
3 4 3   3   3 4 3
s T e ( p ) h e N
3 4 3   3   3 3 4
s t E ( P ) h e n
3 2 4   4   3 3 3
s t E p | H E N
3 2 4 3   4 4 4
s t E ( p ) h e n
3 2 4   3   3 3 3
s t e P | H E N
3 2 3 4   4 4 4
s t e p | H E n
3 2 3 3   4 4 3
s t e p | H e N
3 2 3 3   4 3 4
s t e p | h E N
3 2 3 3   3 4 4
Output: 37

Input: splitwords
S P L I T | W O r d s
4 4 4 1 4   5 4 2 3 3
<snip>
s p l i t w | o R d S
3 3 1 1 2 4   3 4 3 4
Output: 228

Input: 'a-r
' a ( - ) R
1 3   2   4
' a | - r
1 3   2 2
Output: 2

Input: '''''-
' ' ' ( ' ) ' -
1 1 1   1   1 2
Output: 1

Victory
This is code-golf, so shortest answer in bytes wins. You must be able to output all test cases (so, all inputs up to 10 characters) in a reasonable amount of time. Do not artificially cap your input.
Bounty
I do not know if this is in the realm of possibility. However, you're golfers - you'll do anything for rep. I am offering a 200 rep bounty (I'll start it once this bounty condition is fulfilled, as it seems basically impossible to me) for a program that outputs the correct output for antidisestablishmentarianism in under 15 seconds on an average computer (aka mine). Please note that this test case must not be hard coded in any way.
@DigitalTrauma crushed my bounty, coming in well under two seconds. Check out his answer here.

Can I assume that the input will be in lowercase?

@LeakyNun "Because of what you will do with this word (see below), case of input is left to the developer's discretion" - you can assume whatever you want, because you are going to be manipulating it anyway, just make sure you note in your answer if your answer assumes case-sensitive

Antidisestablishmentarianism is 28 letters, each letter can be upper or lower case, and your calculation has to be done for each of the permutations. That's 2 ^ 28, or 268,435,456 split checks. That's insane. I look forward to seeing if someone can golf that down.

@MackenzieMcClane I am aware of that - my (unoptimized) Java program has been running for 35 minutes and counting. That's why it is in a bounty - however, I will probably end up increasing the time cap :)

@MackenzieMcClane except there are five 'i's taking it down to 2 ^ 23 = 8,388,608.

@MackenzieMcClane I thought the input will only have 10 characters. Why bother with 28 letters?

@LeakyNun see bounty.

My first count for antidisestablishmentarianism (non-golfy) is 83307040 (and matching all test cases) but it takes ~37 seconds on my laptop (mind you it is Python). Anyone also have a count for it?

43 seconds at TIO

My brain is weird You are in the right place

I should not try to do the same. I sho|uld not try to do the same. I sho|uld n(o)t t(r)y t|o d|o t(h)e sa|me. O|h cr|ap...

@JonathanAllan matches mine, only mine took almost an hour (I was running 2 ^ 28 permutations and printing all found ones, though). I knew you guys would do cool stuff with it 0.o

@StewieGriffin 0, w is 4 points and each i can max at 1 points - see test case in

@JonathanAllan 83307040 - agreed.  (And <3sec for antidisestablishmentarianism on TIO - woohoo!)

Pyth, 75 74 73 70 bytes

lfsm}sT-Bysded._Tm.n]d*Fmm?k|qd\i+4}d"mw"|}d"il'"h|}d"fjrt-"+2}d"mw"-2}d"'-
lfsm}sT-Bysded._Tm.n]d*Fmm?k|qd\i+4}d"mw"|x}Ld+c"mw il' fjrt-")G1 4-2}d"'-
lfsm}sT-Bysded._Tm.n]d*Fm<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"-2}d"'-
lfsm}sT-Bysded._Tm.n]d*Fm<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

Try it online!
For the love of God, please don't even try antidisestablishmentarianism in the interpreter. You'll crash it.
Explanation
lfsm}sT-Bysded._Tm.n]d*Fm<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

Let us break down this code into X parts.
The first part: generating cased versions and mapping to the values
m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

Let us be clear here. In no part of the process are letters capitalized. We just need to map one letter to two values (and the punctuation marks to one value), without the need of capitalizing them. We'll be deciding for which characters we will be needing two values, and for which characters we will be needing one:
m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dGQ  Q implicitly appended
m                                             Q  for d in Q:
                                           }dG       d in alphabet?
                                          h          +1 (T/F as 1/0)
 <   take the first ^ elements of the following array
     for d in alphabet, it will take 2 elements;
     for d being ' or -, it will take 1 element.
  ,          pair up the following two values
   |x}Ld+c"mw il' fjrt-")G1 4                  this is the first value
                             |qd\i+4}d"mw"    this is the second value

As you see, even the first part is too long.
The first value is for lowercase version, which includes ' and -. The second value is for uppercase version, with ' and - will not take.
The first value:
|x}Ld+c"mw il' fjrt-")G1 4
       "mw il' fjrt-"        does what it says on the tin
      c              )       split on spaces, creating an
                             array with three elements
     +                G      append another element, which
                             is the alphabet, as a fail-safe;
                             now the array has 4 elements
  }Ld                        check if d is in each array
                             as with above, True becomes 1
                             and False becomes 0 (T/F as 1/0)
 x                     1     find the first occurrence of 1
|                        4   logical or with 4. If it was 0,
                             it would become 4 now.

The first string contains "mw" at index 0. It has a value of 4, which explains the need of the logical or. Note that Pyth uses 0-indexing. Also, the space before the 4 is to separate it from 1.
The second value (uppercase):
|qd\i+4}d"mw"
 qd\i          d=="i"
|              logical OR
       }d"mw"  is d in "mw"? That is, is d "m" or "w"?
     +4        +4

If d is "i", then it gives 1 on the first step. Otherwise, it continues. If d is "m" or "w", then the third step gives 1, which is added to 4 to give 5. If d is not "m" or "w", then the third step gives 0, which is added to 4 to give 4.
The second part: getting the job done
lfsm}sT-Bysded._Tm.n]d*F

This is prepended to the first part, which technically is not separated from the second part (it is still one command). So, the value from the first part is passed to the right.
Recap: in the first part, we mapped the letters to their possible values (lowercase and uppercase for letters, just one value for the two punctuation marks). For input "ab", one would get [[3,4],[3,4]].
To generate the different cased versions (which should have been done in the first part, but that would overflow), we use the Cartesian product repeatedly, and then flatten the result. Problems arise when there is only one letter (first testcase), because the Cartesian product would not give us an array, and the flatten command (.n) is overflowed to give strange results to numbers. We'll see how I circumvented this issue.
lfsm}sT-Bysded._Tm.n]d*F
                      *F  reduce by Cartesian product
                 m   d    for d in each unflattened version:
                    ]         [d] (wrap in array)
                  .n          flatten
 f                filter for resulting arrays as T
              ._T all prefixes of T
   m              for d in each prefix:
          sd          find the sum of d
         y            double
       -B   ed        [above, above - last element of d]
    }sT               is the sum of T in the above array of 2 elements?
  s               sum the 1/0 generated in each prefix
                  any non-zero value is regarded as truthy
l                 length

If it is a split in the middle by |, then the prefix would have the sum doubled being the sum of the total.
If it is split by (), then the prefix sum doubled minus the value in parentheses would be the sum of the total.

Yes, when I have the time to. (I apologize for my busy schedule.)

c, 378 bytes; about 0.6s for antidisestablishmentarianism
Updated answer.  I read @JonathanAllan's comment about is, and at first I didn't understand this optimization, but now I see that since both i and I have a width of 1, then we can count the associated permutations twice with only having to validate once.  Previously my solution used multiple threads to spread the load over multiple CPUs and with that I was just about able to go through all 228 possibilities on my machine.  Now with the i optimization there is no need to mess with threads - a single thread does the job easily within the time restriction.
Without further ado - golfed c function:
char m[128]={[39]=10,[45]=20};f(s,l,p)char *s;{m[65]?:bcopy("PPPPPPPPPPPdPPPPPPPPPdPPP      <<<<<(<<(<P<<<<(<(<<P<<<",m+65,58);int g,h,u=0,v=0,x=0,y=0,c=0;if(p<l){g=s[p];if(g>64&&g-'i'){s[p]-=32;c+=f(s,l,p+1);}s[p]=g;c+=((g=='i')+1)*f(s,l,p+1);}else{for(l--,p=0,g=m[s[p]],h=m[s[l]];p<=l;){y=v;x=u;if(u+g>v+h){v+=h;h=m[s[--l]];}else{u+=g;g=m[s[++p]];}}c=u==v||y==x;}return c;}

The recursive function f takes 3 parameters - a pointer to the input string, the string length and the offset in the string to start processing (should be 0 for top-level call).  The function returns the number of permutations.
Try it online.  TIO seems to typically run through all testcases (including antidisestablishmentarianism in under 2 seconds.
Note that there are some unprintables in the string that is bcopy()ed to m[].  The TIO seems to handle these correctly.
Ungolfed:
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>

int width_tbl[] = {
    ['\''] = 1,
    ['-'] = 2,
    ['A'] = 4,4,4,4,4,4,4,4,1,4,4,4,5,4,4,4,4,4,4,4,4,4,5,4,4,4,
    ['a'] = 3,3,3,3,3,2,3,3,1,2,3,1,4,3,3,3,3,2,3,2,3,3,4,3,3,3
};

int
f (char *str, int len, int pos) {
    int lidx, ridx;
    int tot_width = 0;
    int lwidth, rwidth;
    int tot_lwidth = 0, tot_rwidth = 0;
    int prev_tot_lwidth = 0, prev_tot_rwidth = 0;
    char tmp;
    int perm_cnt = 0;

    if (pos < len) {
        tmp = str[pos];
        if (isalpha(tmp) && (tmp != 'i')) {
            str[pos] = toupper(str[pos]);
            perm_cnt += f(str, len, pos+1);
        }
        str[pos] = tmp;
        perm_cnt += ((tmp == 'i') + 1) * f(str, len, pos+1);
    } else {
        //puts(str);
        lidx = 0;
        ridx = len - 1;
        lwidth = width_tbl[str[lidx]];
        rwidth = width_tbl[str[ridx]];
        while (lidx <= ridx) {
            prev_tot_rwidth = tot_rwidth;
            prev_tot_lwidth = tot_lwidth;
            if (tot_lwidth + lwidth > tot_rwidth + rwidth) {
                tot_rwidth += rwidth;
                rwidth = width_tbl[str[--ridx]];
            } else {
                tot_lwidth += lwidth;
                lwidth = width_tbl[str[++lidx]];
            }
        }
        if (tot_lwidth == tot_rwidth) {
            perm_cnt = 1;
        } else if (prev_tot_rwidth == prev_tot_lwidth) {
            perm_cnt = 1;
        }
    }
    return perm_cnt;
}

int main (int argc, char **argv) {
    int i;
    int perm_cnt;

    if (argc > 0) {
        char *str = strdup(argv[1]);
        assert(str);

        perm_cnt = f(str, strlen(str), 0);

        printf("n = %d\n", perm_cnt);
    }

    return 0;
}

I have a mid-2015 MacBook Pro running MacOS 10.12.4.  The compiler is the default MacOS clang.  I am compiling with:
cc splitwords.c -O2 -o splitwords

Running all testcases, including antidisestablishmentarianism gives:
$ time ./splitwords
Testcase "a": n = 2
Testcase "in": n = 0
Testcase "ab": n = 2
Testcase "abc": n = 4
Testcase "will": n = 8
Testcase "stephen": n = 37
Testcase "splitwords": n = 228
Testcase "'a-r": n = 2
Testcase "'''''-": n = 1
Testcase "antidisestablishmentarianism": n = 83307040

real    0m0.573s
user    0m0.564s
sys 0m0.003s
$

This is by no means optimal.  The algorithm simply brute-forces its way through all possibilities (modulo i - see comments above), and counts the words that may be split according to the criteria.

Good job, really I think it is probably possible to evaluate the result in O(n), using the fixed effects of the 7 classes of letter, i, -, ', l, mw, fjrt, and abcdeghknopqsuvxyz, but it would take an application of the Pólya enumeration theorem (or an equivalent combinatorial enumeration method), in which I am not well versed.

You destroyed my expectations, as I expected. This is how you use recursion :)

C, 403 394 bytes,
Thanks Kevin!
r;char*g[]={"","ilI'","fjrt-","","mw","MW",0},**p,b[99];q(c){for(p=g;*p;p++)if(strchr(*p,c))return p-g;return c>='a'&&c<='z'?3:4;}f(char*w,int l){int i,n,c,t,x,y;if(*w){for(i=0;i<2;i++)x=tolower(*w),y=toupper(*w),!i||x!=y?b[l]=i%2?x:y,b[l+1]=0,f(w+1,l+1):0;}else{t=0;for(c=0;c<2;c++)for(i=0;i<l;i++){x=y=0;for(n=0;n<l;n++)c==0||n!=i?((n<i)?(x+=q(b[n])):(y+=q(b[n]))):0;t|=x==y;}r+=t;}return r;}

Try it online
Ungolfed code:
int getwidth(int c)
{
    char **p, *g[] = { "", "ilI'", "fjrt-", "", "mw", "MW", 0};
    for (p=g; *p; p++)
    {
        if (strchr(*p,c))
            return p-g;
    }
    return c >= 'a' && c <= 'z' ? 3 : 4;
}

int test(char* w, int l)
{
    int i, n, c, t, x, y;

    if (*w)
    {
        for (i=0;i<2; i++)
        {
            x = tolower(*w);
            y = toupper(*w);
            if (!i || x != y)
            {
                b[l] = i % 2 ? x : y;
                b[l + 1] = 0;
                test(w + 1, l+1);
            }
        }
    }
    else
    {
        t = 0;
        for (c=0; c<2; c++)
        {
            for (i=0; i<l; i++)
            {
                x = 0;
                y = 0;
                for (n=0; n<l; n++)
                {
                    if (c == 0 || n != i)
                    {
                        if (n < i)
                            x += getwidth(b[n]);
                        else
                            y += getwidth(b[n]);
                    }
                }
                t |= x == y;
            }
        }
        r += t;
    }
    return r;
}

You forgot to golf some spaces here: f(char* w, int l){ -> f(char*w,int l){

JavaScript (ES6), 199 169 167 bytes
Expects the input string in lower case. Too slow for the bounty.
f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

Test cases

f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

;[ "a", "in", "ab", "abc", "will", "stephen", "splitwords", "'a-r", "'''''-" ]
.map(
  s => console.log(s, '->', f(s))
)

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


text:
Find how many alphanumeric characters can be made up of a single number
The alphanumeric characters have ASCII-values:
0-9  ->  48-57
A-Z  ->  65-90
a-z  ->  97-122

Your challenge is to take an integer as input, and output how many characters can be made using consecutive digits of that number. The character codes may be overlapping. 666 should result in 2, since you have 66 twice.
Test cases:
Input: 5698
Possible characters: '8' (56), 'E' (69), 'b' (98)
Output: 3

Input: 564693
Possible characters: '8' (56), 'E' (69)
Output: 2

Input: 530923864209124521
Possible characters: '5' (53), 'V' (86), '4' (52)
Output: 3

Input: 1111111
Possible characters: 'ooooo' (5*111)
Output: 5

Input: 5115643141276343
Possible characters: '3' (51), '8' (56), 'L' (76), 's' (115)
Output: 4

Input: 56789
Possible characters: '8' (56), 'C' (67), 'N' (78), 'Y' (89)
Output: 4

Input: 94
Possible characters: ''
Output: 0

Input: 1
Output: 0

Input and output formats are optional (yes, you may take the integer as a string).

05AB1E, 8 7 bytes
žKÇIŒÃg

Try it online!
Explanation
žK       # push [a-zA-Z0-9]
  Ç      # convert to list of ascii codes
   IŒ    # push all substrings of input
     Ã   # keep only the subtrings which exist in the list of acsii codes
      g  # push length of resulting list

ŒžKÇÃg doesn't work?

@carusocomputing: Unfortunately, it fails the 1111111 test-case.

Ã, that makes a LOT more sense now that I read what it's doing, crap.

Maybe I'm missing something, but your current answer fails for the 1111111 test case (output is 1 instead of 5), and the 6-byter suggestion made by @MagicOctopusUrn actually gives the correct output.

@KevinCruijssen I think this may have been Legacy 05AB1E.

@MagicOctopusUrn A very old version of legacy in that case, since your 6-byter gives the correct answer and his 7-byter not, even when using 05AB1E (legacy) on TIO.

@KevinCruijssen is 2017 very old now :P? I guess it is. Jeez I'm getting old too, aren't I?

MATL, 17 13 bytes
8Y2"G@oVXf]vn

Try it online! Or verify all test cases.
Explanation
8Y2     % Predefined literal: string with all letters, uppercase and lowercase,
        % and digits
"       % For each character in that string
  G     %   Push input, for example the string '5115643141276343'
  @     %   Push current character, such as 'A'
  o     %   Convert to its ASCII code, such as 65
  V     %   String representation, such as '65'
  Xf    %   Find string '65' within string '5115643141276343'. This gives a vector
        %   (possibly empty) with indices of occurrences
]       % End
v       % Concatenate all stack contents vertically
n       % Number of entries. Implicitly display

Java 8, 204 197 195 186 174 bytes
n->{int r=0,i=0,e=n.length()-1,t;for(;i<e;r+=t>47&t<57|t>64&t<91|t>96&t<100|(t=new Short(n.substring(i,i++>e-2?i:i+2)))>99&t<123?1:0)t=new Byte(n.substring(i,i+2));return r;}

-9 bytes thanks to @ceilingcat.
Try it online.
Explanation:
n->{                   // Method with String parameter and integer return-type
  int r=0,             //  Result, starting at 0
      i=0,             //  Index
      e=n.length()-1,  //  Length of String -1
      t;               //  Temp integer
  for(;i<e             //  Loop over the String using the index
      ;                //    After every iteration:
       r+=             //     Increase the result-sum by:
          t>47&t<57|t>64&t<91|t>96&t<100
                       //      If two adjacent digits are a digit or letter
          |            //      or
          (t=new Short(n.substring(i,i++>e-2?i:i+2)))>99&t<123?
                       //      if three adjacent digits are a letter:
           1           //       Increase the sum by 1
          :            //      Else:
           0)          //       Keep the sum the same by adding 0
    t=new Byte(n.substring(i,i+2));
                       //   Set `t` to the substring of [i, i+2) converted to integer
  return r;}           //  Return the result-sum

I cannot access a computer right now, so I cannot confirm, but here are two suggestions: 1. put the initiations into the for loop. 2. instead of string manipulation, use arithmetic (use integer division to iterate through the digits and use modulo to extract the last 2 or 3 digits).

@LeakyNun Thanks for the suggestions. As for your first one, the reason the integers initializations are outside the for-loop is because I have to return the result (r). However, I have been able to golf 7 bytes by putting everything else inside the for-loop, in a single ternary. I will see if I can do your second suggestion later perhaps. My lunch-time is over again, so I'll have to get back to work. Will keep it in mind.

Brachylog, 22 bytes
∧Ạụ:Ạ:Ịcạ:?{tT&h∋~sT}ᶜ

Try it online!
Explanation
       c                 Concatenate together:
∧Ạụ:                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    Ạ:                     "abcdefghijklmnopqrstuvwxyz"
      Ị                    "0123456789"
        ạ                Get the list of ASCII codes of that string
         :?{        }ᶜ   Count the number of results, for input [list of codes, Input], of:
            tT             Call the Input T
              &h∋          Take one ASCII code
                 ~sT       It is a substring of T

Unfortunately for me, fortunately for you, I don't have access to a computer at the moment ;)

@LeakyNun I have thought of shorter ways to do it, both failing because of bugs.

Can you join the two T together?

For some reasons, that does not work for me.

@LeakyNun The problem is that ~s will not backtrack properly if it doesn't have the right output T. Putting something like ~t? after ~s won't work for that reason.

What if you keep t in place and reverse the right half?

@LeakyNun The same problem occurs with ∈ in that case.

What is the cause of this bug?

@LeakyNun For e.g. the integer 13, there are infinitely many lists, and infinitely many integers which contain 13, and it's not obvious in which order you should list them.

JavaScript (ES6), 71 70 bytes
f=([a,...b])=>a?(a&(a+=b[0])+b[1]<123|a>47&a<58|a>64&a<91|a>96)+f(b):0

Test cases

f=([a,...b])=>a?(a&(a+=b[0])+b[1]<123|a>47&a<58|a>64&a<91|a>96)+f(b):0

console.log(f("5698"))                // 3
console.log(f("564693"))              // 2
console.log(f("530923864209124521"))  // 3
console.log(f("1111111"))             // 5
console.log(f("5115643141276343"))    // 4
console.log(f("56789"))               // 4
console.log(f("94"))                  // 0
console.log(f("1"))                   // 0

Perl 5, 47 bytes
46 bytes of code + -p flag.
$"="|";$_=()=/(?=@{[48..57,65..90,97..122]})/g

Try it online!
I couldn't find any shorter way to write that 48..57,65..90,97..122: map{ord}0..9,a..z,A..Z (getting the ascii value of the characters) is one byte longer. And doing for$c(0..122){$\+=chr($c)=~/\pl|\d/ for/(?=$c)/g}}{ (looking for all numbers, but keeping only those whose numbers corresponds to the ascii value of letters (\pl) or digits (\d)) will be 5 bytes longer (note that \pl|\d can't be replaced by \w as the latter also includes underscores)).

Previous approach (49 bytes):
for$@(48..57,65..90,97..122){$\+=()=/(?=$@)/g}}{

PHP, 68 Bytes
for(;a&($a=$argn)[$i];)$d+=ctype_alnum(chr($a[$i].$a[++$i]));echo$d;

Online Version

JavaScript (ES), 165 161 156 154 153 bytes
Yeah, RegEx definitely wasn't the right tool for the job here!
n=>[/\d{2}/g,/\d{3}/g].map(e=>eval("while(x=e.exec(n)){a.push(m=x[0]);e.lastIndex-=m.length-1}"),a=[])|a.filter(x=>x>47&x<58|x>64&x<91|x>96&x<123).length

Try It

f=

n=>[/\d{2}/g,/\d{3}/g].map(e=>eval("while(x=e.exec(n)){a.push(m=x[0]);e.lastIndex-=m.length-1}"),a=[])|a.filter(x=>x>47&x<58|x>64&x<91|x>96&x<123).length

console.log(f(5698))//3
console.log(f(564693))//2
console.log(f(530923864209124521))//3
console.log(f(1111111))//5
console.log(f(5115643141276343))//4
console.log(f(56789))//4
console.log(f(94))//0
console.log(f(1))//0

Regexp isn't that bad; A port of my Retina answer came to 78 bytes.

Haskell, 161 157 138 129 126 bytes
import Data.List
f x=sum[1|y<-nub$concat$words.concat<$>mapM(\c->[[c],c:" "])x,any(elem$read y)[[48..57],[65..90],[97..122]]]

I wonder if there is a better way to remove dupes of the list than importing Data.List for nub?

If you import Data.Lists instead of Data.List, you can use: y<-tail$powerslice x.

@nimi Is it against golfing rules if I have to download and install non standard modules? I dont think Data.Lists is standard in GHC.

As far as I know we still don't have consensus on what counts as a standard module. There are a couple of Haskell answers around here which use Data.Lists. It is even mentioned in the golfing tips for Haskell - nobody has complained so far.

@nimi Well honestly I think if I can just download any package from cabal, I could just write a function that solves the problem, upload it, then import the module in my solution. Technically I could cheat. But then certain challenges cant be done with basic GHC either like crypto stuff so I dont know.

Remember: everything used must predate the challenge, so uploading a custom module specifically made for the task won't work. Yes crypto things, image processing, graphic display, etc. are usually done with less common modules. As said, Data.Lists has been used in other challenges, but feel free to stick to the core modules only.

Back to golfing tips: or $ f <$> list is any f list: any(elem$read y)[...].

@nimi Nice job, golfed 3 bytes!

Pyth, 19 17 14 bytes
l@jGUTmr0Csd.:

takes a string.
-3 Bytes thanks to @LeakyNun
Try it!
Explanation
l@jGUTmr0Csd.:
    UT                # the list of digits [0,1,2,...,9]
  jG                  # join that on the lowercase alphabet (repetition doesn't matter)
              Q       # implicit input
            .:        # all substrings of the input
      m               # for each of those substrings
          sd          # Convert the string to a base 10 integer
         C            # convert that integer to the character with that number
       r0             # make that character lowercase
l@                    # length of the intersection of those two list of chars we generated

Instead of using idT, you can use sd.

Also, l@jGUTmr0Csd.: might be shorter (not sure if it works).

@LeakyNun Thank you, this works!

Retina, 52 bytes
&`1[01]\d|12[012]|4[89]|5[0-7]|6[5-9]|[78]\d|9[0789]

Try it online! (includes test suite)

Python 2, 74 64 62 bytes
f=lambda n:n and chr(n%10**(3-(n%1000>122))).isalnum()+f(n/10)

Try it online!

Japt, 24 bytes
;è"(?={9ò ¬+B+C ¬mc q|})

Try it online!
Alternate 27-byte version:
è"(?={#~o f_d f"%d|%l"Ãq|})

Try it online!

Jelly, 8 bytes
ØBODf@ẆL

Input is a digit array.
Try it online!
How it works
ØBODf@ẆL  Main link. Argument: A (digit array)

ØB        Base 62; yield all alphanumeric ASCII characters.
  O       Ordinal; get their code points.
   D      Decimal; convert the code points into digit arrays.
      Ẇ   Window; yield all contiguous subarrays of A.
    f@    Filter swapped; keep all elements of the result to the right that appear
          in the result to the left.
       L  Length; count the matches.

Ruby, 50 bytes
p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\p{Alnum}/}

Reads from standard input; requires the Ruby interpreter be invoked with the -n option (implicit while gets loop).
Could be reduced to 43 bytes if it were allowed to match underscores.
p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\w/}

This doesn't return the number of times the characters show up. Also, it fails on 111, which should return 1 but you're giving back 0.


text:
Rational decomposition
Write functions \$x(a)\$, \$y(a)\$ and \$z(a)\$ such that for any rational \$a\$ all functions return rational numbers and
$$x(a) \times y(a) \times z(a) \times (x(a) + y(a) + z(a)) = a$$
You may assume \$a \ge 0\$
You do not need to use rational types or operations in your program, as long as your program is mathematically sound. E.g. if you use a square root in your answer you must show that its argument is always a square of a rational number.
You may write three named functions x, y, z or write three programs instead if functions are cumbersome or non-existent for your language. Alternatively you may also write a single program/function that returns three numbers \$x\$, \$y\$, \$z\$. Finally, if you so prefer you may input/output the rational numbers as a numerator/denominator pair. Your score is the total size of the three functions or three programs in bytes. Smallest score wins.
Brute forcing is not allowed. For any \$a = \frac p q\$ where \$p, q \le 1000\$, your program should run in under 10 seconds.

An example (this does not mean your decomposition has to give these numbers):
x = 9408/43615
y = 12675/37576
z = 1342/390
x*y*z*(x+y+z) = 1

Can we write one function which outputs all of them together (say, in an array)?

Can we input the numerator and the denominator as two numbers?

@LeakyNun Yes and yes.

Is it provably doable for any a?

@Fatalize I wouldn't have made this challenge otherwise.

I assume you don't want to show a proof because it would give away a solution, but your word is not really a proof.

@Fatalize, I think this was inspired by a recent answer to a question on another stack, which mentions that Euler exhibited a triple of such functions in a letter to Goldbach.

I assume on the basis of the example and the lack of explicit statement otherwise that the output (numerator, denominator) don't have to be coprime?

@PeterTaylor Correct, the fraction doesn't have to be reduced. In fact, your answer can use floating point if you so desire, just your answer needs to be mathematically sound. If a rational type would get input into your function it should still function correctly (even if your language of choice doesn't actually have a rational type).

CJam (59 bytes)
{[WZ~C24X8TT]f*[4XGYC6 4Y].+_0=!>2%Z65135Zb+:(3/.f#:.*)W*+}

This is an anonymous block (function) which takes an integer or double on the stack and produces an array with three doubles. It has two cases internally to handle all non-negative inputs, since with only one case it would break on either 0.25 or 4. It still breaks for inputs -12 and -1.3333333333333333, but the spec allows that...
The online demo executes it and then adds up the values, prints all four, and multiplies them to show that it gets the original value (modulo rounding error).
Mathematical background
Following Noam Elkies we define the auxiliary \$w = - x - y - z\$. Then \$x + y + z + w = 0\$ and \$-xyzw = a\$ or \$xyzw + a = 0\$. This has lots of symmetry; any solution will have four formulae and we can pick the three golfiest ones.
Elkies gives four families of sets of solutions. Euler's:
$$\begin{eqnarray*}
x & = & \frac{6ast^3(at^4-2s^4)^2}{(4at^4+s^4)(2a^2t^8 + 10as^4t^4 - s^8)} \\
y & = & \frac{3s^5(4at^4+s^4)^2}{2t(at^4-2s^4)(2a^2t^8+10as^4t^4-s^8)} \\
z & = & \frac{2(2a^2t^8+10as^4t^4-s^8)}{3s^3t(4at^4+s^4)} \\
w & = & \frac{-(2a^2t^8+10as^4t^4-s^8)}{6s^3t(at^4-2s^4)}
\end{eqnarray*}$$
One related to Euler's:
$$\begin{eqnarray*}
x & = & \frac{(8s^8+a^2)(8s^8-88as^4-a^2)}{12s^3(s^4-a)(8s^8+20as^4-a^2)}\\
y & = & \frac{(8s^8+a^2)(8s^8-88as^4-a^2)}{12s^3(8s^4+a)(8s^8+20as^4-a^2)}\\
z & = & \frac{192as^5(s^4-a)^2(8s^4+a)^2}{(8s^8+a^2)(8s^8-88as^4-a^2)(8s^8+20as^4-a^2)}\\
w & = & \frac{-3s(8s^8+20as^4-a^2)^3}{4(s^4-a)(8s^4+a)(8s^8+a^2)(8s^8-88as^4-a^2)}\\
\end{eqnarray*}$$
A simpler one:
$$\begin{eqnarray*}
x & = & \frac{(s^4-4a)^2}{2s^3(s^4+12a)} \\
y & = & \frac{2a(3s^4+4a)^2}{s^3(s^4-4a)(s^4+12a)} \\
z & = & \frac{s^5+12as}{2(3s^4+4a)} \\
w & = & \frac{-2s^5(s^4+12a)}{(s^4-4a)(3s^4+4a)} \\
\end{eqnarray*}$$
And one related to that one:
$$\begin{eqnarray*}
x & = & \frac{s^5(s^4-3a)^3}{2(s^4+a)(s^{12}+12as^8-3a^2s^4+2a^3)} \\
y & = & \frac{s^{12}+12as^8-3a^2s^4+2a^3}{2s^3(s^4-3a)(3s^4-a)} \\
z & = & \frac{2a(s^4+a)^2(3s^4-a)^2}{s^3(s^4-3a)(s^{12}+12as^8-3a^2s^4+2a^3)} \\
w & = & \frac{-2s(s^{12}+12as^8-3a^2s^4+2a^3)}{(s^4-3a)(s^4+a)(3s^4-a)}
\end{eqnarray*}$$
Observe that every family has at least two denominators of the form \$ps^4 - qa\$ for positive \$p\$ and \$q\$: since all the terms involved are rational, that means that there's some positive \$a\$ for which we get division by zero. Therefore we must use at least two sets of solutions which have their singularities at different values of \$a\$. Intuitively it's going to be golfiest to choose two sets from the same family. I've chosen the simplest family (the third one) with parameters \$s=1\$ and \$s=2\$.

Axiom, 191 bytes
f(s,a)==(b:=s^4-4*a;c:=s^4+12*a;x:=3*s^4+4*a;[b^2/(2*c*s^3),2*a*x^2/(b*c*s^3),s*c/(2*x)])
g(a:FRAC INT):List FRAC INT==(s:=1;repeat(s^4=4*a or s^4=-12*a or 3*s^4=4*a=>(s:=s+1);break);f(s,a))

It is the traslation of the formula Peter Taylor report in this page
with some code would make the denominators not be 0.
one test
(7) -> y:=g(1)
          9   98 13
   (7)  [--,- --,--]
         26   39 14
                                              Type: List Fraction Integer
(8) -> y.1*y.2*y.3*(y.1+y.2+y.3)
   (8)  1
                                              Type: Fraction Integer

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