text:
Longest run of a character in a string
Your challenge: Write a function that takes a string s, a character c, and finds the length of the longest run of c in s. The length of the run will be l.
Rules:

If s is of length 0 or c is empty, l should be 0.
If there are no instances of c in s, l should be 0.
Standard loopholes and Standard I/O Rules apply.
No matter where in s the run of cs is located, l should be the same.
Any printable ASCII characters can appear in s and c.

Test cases:
s,c --> l
"Hello, World!",'l'  -->  2
"Foobar",'o'         -->  2
"abcdef",'e'         -->  1
"three   spaces",' ' -->  3
"xxx xxxx xx",'x'    -->  4
"xxxx xx xxx",'x'    -->  4
"",'a'               -->  0
"anything",''        -->  0

Winner:
As with code-golf the shortest answer in each language wins.

Related. Sandbox post.

Could you include the edge cases of empty s and a c that isn't contained in a non-empty s in your test cases?

What range of characters can appear in s/c?

@MartinEnder Clarified both.

c can be empty? In many languages, a character is just an integer with special semantics, and you can't really have an empty integer either.

@MartinEnder I didn't explicitly state that c can be empty, I just stated that if it (somehow) is then l must be 0.

That doesn't really make sense to me. Your test cases suggest that we have to support it. If we don't have to support it, then specifying its required output doesn't make sense, because I can always just say that it's not supported if my solution would do something else in that case.

Any ASCII or any printable ASCII?

@jpmc26 Printable ASCII; updating.

05AB1E, 5 bytes
Code:
SQγOM

Uses the 05AB1E encoding. Try it online!
Explanation:
SQ      # Check for each character if it is equal to the second input
  γ     # Split the list of zeros and ones into groups
   O    # Sum each array in the arrays
    M   # Get the maximum

Nice solution! I knew there was a way to do it like this, I just couldn't think of it.

γ¢M isn't performing like I thought it would, thought that'd be a 3-byte.

Mathematica, 35 bytes
Max[Tr/@Split@Boole@Thread[#==#2]]&

Pure function taking a list of characters and another character as input and returning a nonnegative integer. Improved upon my first effort using Adnan's observation (go upvote!) that one should test for equaling the special character before splitting the array.
Thread[#==#2] checks whether each input character in the first argument equals the character given as the second argument. Boole converts the resulting Trues and Falses to 1s and 0s. Split splits the list into runs of consecutive elements; Tr/@ sums each sublist, and Max finds the winner. (Because of how Max works, if the first argument is the empty list, then this function returns -∞. So, you know, don't do that.)
first submission (51 bytes)
Max[Split@#/.a:{c_String..}:>Boole[c==#2]Length@a]&

Split@# splits the input into runs of consecutive characters, such as {{"t"}, {"h"}, {"r"}, {"e", "e"}, {" ", " ", " "}, {"s"}, {"p"}, {"a"}, {"c"}, {"e"}, {"s"}} for the fourth test case. /.a:{c_String..}:> replaces each subexpression a that is a list of a repeated character c by Length@a multiplied by Boole[c==#2], which is 1 if c equals the input character and 0 otherwise. Then Max extracts the answer.

Japt, 20 18 15 bytes
fV+Vî+)ª0)n o l

Try it online!
Saved 5 bytes thanks to obarakon and ETHproductions

I played around with my own solution for a while and ended up with one that was nearly yours, but shorter. If you use fV+Vî+)... I'll let you figure the rest out :-)

@ETHproductions "If s is of length 0 or c is empty, l should be 0", I might be taking that too literally though

Oh, I hadn't realized that fails whenever s does not contain any instances of c.

Python, 38 bytes
f=lambda s,c:+(c in s)and-~f(s,c+c[0])

Try it online!
Dennis saved 3 bytes by updating c to a string of duplicated characters rather than recursively updating a number to multiply c by.

f=lambda s,c:c in s and-~f(s,c+c[0]) saves 6 bytes (3 if False is not allowed).

05AB1E, 11 6 bytes
-5 bytes thanks to carusocomputing
γvy²¢M

Try it online!
γ      # split into chunks of consecutive equal elements
 vy    # For each chunk...
   ²¢  #  Count the number of input characters in this chunk
     M #  Push the largest count so far

γvy²¢M for 6-bytes, same idea.

Vyxal, 4 bytes
=ĠṠG

Try it Online!
=    # Is each character of the string equal to the character?
     # Produces a list of 1s and 0s
 Ġ   # Group consecutive items
  Ṡ  # Sum each - groups of 1s become their length, groups of 0 become 0
   G # Find the maximum

9 bytes, also later I got it down to 6 bytes, but I decided to post myself, +1 too you too

JavaScript (ES6), 54 53 51 bytes
-2 bytes thanks to @Neil
-1 byte thanks to @apsillers
s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j

Takes input in currying syntax: f("foobar")("o").
Test Snippet

f=
s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j
String: <input id=I> Letter: <input id=J maxlength=1 size=1> <button onclick='O.innerHTML+=`f("${I.value}")("${J.value}") = ${f(I.value)(J.value)}\n`'>Run</button>

Another option using eval and for (54 bytes)
s=>c=>eval("i=j=0;for(x of s)i=x==c&&i+1,i>j?j=i:0;j")

Old Answer using Regex (85 bytes)
s=>c=>c?Math.max(...s.match(eval(`/${/\w/.test(c)?c:"\\"+c}*/g`)).map(x=>x.length)):0

I think x==c?i++:i=0 can just be i=x==c&&i+1 since a false result on x==c comparison will be treated as a 0 for numerical comparisons and increments (and will never be the return value, since any number, including 0, in j will always take priority over the zero-like false in i)

@apsillers Thanks, updated, but what do you mean about it never being the return value?

Sorry for the confusion; I was just explaining that the change would never make your program return false (since the challenge always requires it to return a number)

s=>c=>[...s].map(x=>j=(x!=c?i=0:++i)>j?i:j,i=j=0)&&j seems to save a couple of bytes.

@Neil Nice, thanks, that's one more byte off

Sorry, I posted the wrong code, I meant to post f=s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j, which is a byte shorter.

@Neil Updated. One less than apsillers now, thanks!

C# 116 115 bytes
My first code golf
Edited because initial submission was a snippet and was missing required namespace for regex
Edit#2 complete rewrite to support characters with special regex meanings
using System.Linq;s=>c=>System.Text.RegularExpressions.Regex.Replace(s,"[^"+c+"]",++c+"").Split(c).Max(x=>x.Length);
using System.Linq;s=>c=>{var r=(char)(c-1);return string.Join("",s.Select(x=>x==c?c:r)).Split(r).Max(x=>x.Length)};

I don't know C# but it looks like your code expects variables c and s to be predefined.  We call this a "code-snippet" and it is not allowed.  You could probably restructure your code as an anonymous function or to set those variables to input.  Both of which are allowed.

Does that work? (See above edit)

Once again I don't know C#, but it looks like it does.  You might want to checkout our [tag:tips] for golfing in C# here for more experienced advice in C#.

Thanks for the links! I will definitely peruse the C# tips

Hi just some general comments for golfing in C#, you can define your function as (s,c)=>. You have to either use  System.Text.RegularExpressions.Regex or add an using statement right before your function.

Building off of Stefan's comment your using Linq so you must include using System.Linq; into your byte count. When compiling to an anonymous function you can also save bytes by using currying i.e. s=>c=>...

Do I also need using System.Collections.Generic if I am using Lists? Asking for another entry I submitted to another question.

Also, thank you for introducing me to currying. This is exactly why I wanted to start doing these, it's only my first post and already I'm learning new things I'd never heard of before.

Does this also work for c=']'?

Here is a collection of C# golfing tips!

@RomanGräf No, it does not,and now that you pointed out that bug I see a few more. Looks like I've got a rewrite to work on.

Haskell, 43 39 bytes
f c=maximum.scanl(\n k->sum[n+1|c==k])0

Try it online!
Run through the string and replace the current char with a counter that is increased whenever it equals c or reset to 0 if not. Take the maximum of the list.
Thanks to @xnor for 4 bytes.

You can do sum[n+1|c==k].

@xnor: Nice! I've experimented with *fromEnum(c==k), both pointfree and lambda, but it was always 2 or 3 bytes longer.

JavaScript (Firefox 30-57), 75 72 bytes
(s,c)=>Math.max(0,...(for(s of s.split(/((.)\2*)/))if(s[0]==c)s.length))

ES6 compatible snippet:

f=
(s,c)=>Math.max(0,...s.split(/((.)\2*)/).filter(s=>s[0]==c).map(s=>s.length))

<input id=s><input id=c maxlength=1 size=1>
0

split returns a bunch of empty strings and single characters as well as the runs but this doesn't affect the result.

Micro, 112 bytes
{T l m 1+:Q # T Q T l~:r}:Z{T[0]+}:X
{i s m:n
n p = if(Z,X)
i L=if(,a)}:a
0\\:C:s:i"":p"":n[0]:T
s l:L
a
T l m:\

PHP, 70 bytes
for(;~$c=$argv[1][$i++];)$r[]=$argv[2]==$c?++$n:$n=0;echo$r?max($r):0;

Try it online!
PHP, 75 bytes
for(;~$s=substr($argv[1],$i++);)$r[]=strspn($s,$argv[2]);echo max($r?:[0]);

Try it online!
PHP, 83 bytes
<?=@preg_match_all("<".preg_quote($argv[2])."+>",$argv[1],$t)?strlen(max($t[0])):0;

Try it online!
+8 Bytes to avoid @
<?=($a=$argv[2])&&preg_match_all("<".preg_quote($a)."+>",$argv[1],$t)?strlen(max($t[0])):0;

The 67 bytes version will fail for any regex special char (and # of course).

... and ~ may fail for chr(207).

@Titus Done and Input can only be Ascii characters

good eye for ++$n! You meant printable ascii. ;)

echo$r?max($r):0; saves one byte

Jelly, 10 9 bytes
f⁴L
ŒgÇ€Ṁ

Explanation:
f⁴L
f⁴      -Filter by the character argument.
  L     -Return Length of filtered String.

ŒgÇ€»/
Œg      -Group string by runs of characters.
  Ç€    -Run above function on each group.
    Ṁ   -Return the largest in the list.

Try it online!

You can save a couple of bytes with Œgf€L€Ṁ.

C (gcc), 63 bytes
i;m;f(s,c)char*s;{for(i=m=0;*s;s++)*s^c?m=m>i?m:i,i=0:i++;s=m;}

Try it online!

Perl 6,  45 43  42 bytes
->$_,$c {$c&&$_??.comb(/$c+/)».chars.max!!0}

Test it
->$_,$c {$c&&$_??.comb(/$c+/).max.chars!!0}

Test it
->$_,$c {$c&$_??.comb(/$c+/).max.chars!!0}

Test it
Expanded:
-> $_, $c {       # pointy block lambda

    $c & $_       # AND junction of $c and $_
                  #   empty $c would run forever
                  #   empty $_ would return 4 ( "-Inf".chars )

  ??              # if True (neither are empty)

    .comb(/$c+/)  # find all the substrings
    .max          # find the max
    .chars        # get the length

  !!              # if False (either is empty)

    0             # return 0
}

JavaScript, ES6, 52
Recursive solution that treats the string input as an array (note: the initial input is still a string) and consumes left-to-right in character C:
f=([C,...s],c,t=0,T=0)=>C?f(s,c,C==c&&++t,t>T?t:T):T

Tracks current run in t and global best in T.
Explanation:
f=            // function is stored in `f` (for recursion)
  ([C,...s],  // turn input string in first-char `C` and the rest in `s`
   c,         // argument `c` to search for
   t=0,T=0)   // current total `t`, best total `T`
     =>
        C?             // if there is still any char left in the string
          f(s,c,       // recursively call `f`
            C==c&&++t, // increment `t` if char is match, or set `t` to `false`
            t>T?t:T)   // set global `T` to max of `t` and `T`
          :T           // when string is depleted, return `T`

Setting t to false on non-matches works because whenever t is incremented, false is treated as 0 (i.e., false + 1 is 1), and false will never compare grater than any value in global-max T.

Nice solution, I was unfamiliar with the [C,...s] syntax.  Should help me slice() off bytes from my own posts.

JavaScript (ES6), 47 40 38 bytes
(Saved 7 bytes thanks to @Neil, and 2 bytes thanks to @HermanLauenstein.)
s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0

Explanation:
Recursively searches for a longer run until none is found.
Snippet:

let f=

s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0

console.log(f('Hello, World!')('l'  ));  //2
console.log(f('Foobar')('o'         ));  //2
console.log(f('abcdef')('e'         ));  //1
console.log(f('three   spaces')(' ' ));  //3
console.log(f('xxx xxxx xx')('x'    ));  //4
console.log(f('xxxx xx xxx')('x'    ));  //4
console.log(f('')('a'               ));  //0
console.log(f('anything')(''        ));  //0

So simple! Brilliant!

Can you not do f=(s,c)=>c&&s.includes(c)&&1+f(s,c+c[0])?

Or better still, curry it to s=>g=c=>c&&s.includes(c)&&1+g(c+c[0]).

That almost works, but it returns "false" and a null string for the last two cases.  That's fixed by appending ||0, which is still shorter than my solution.

The f= isn't part of the curried version, because only the inner function is recursive.

Sweet.  I post so many recursive answers, this technique should really help out.

f=s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0 is 2 bytes shorter

Jelly, 5 bytes
=ŒgṀS

This is a dyadic link/function that takes a string and a character. Note that it cannot work as a full program, as input from command-line arguments uses Python syntax, and Python – unlike Jelly – does not distinguish singleton strings from characters.
Try it online!
How it works
=ŒgṀS  Main link. Left argument: s (string). Right argument: c (character)

=      Compare all characters in s with c, yielding 1 for c and 0 otherwise.
 Œg    Group adjacent, equal Booleans in the resulting array.
   Ṁ   Take the maximum. Note that any array of 1's will be greater than any array
       of 0's, while two arrays of the same Booleans are compared by length.
    S  Take the sum, yielding the length for an array of 1's and 0 otherwise.

Retina, 25 bytes
(.).*?(\1*)(?!.+\2).*
$.2

Try it online!
The first character is the character to be checked.

PHP, 70 67 bytes
three versions:
while(~$c=$argv[1][$i++])$x=max($x,$n=($c==$argv[2])*++$n);echo+$x;
while(~$c=$argv[1][$i++])$x=max($x,$n=$c==$argv[2]?++$n:0);echo+$x;
for(;++$n&&~$c=$argv[1][$i++];)$x=max($x,$n*=$c==$argv[2]);echo+$x;

takes input from command line arguments; run with -r or test them online.

APL (Dyalog), 18 11 bytes
Requires swapping ⊂ with ⊆ in Version 16.0 or having ⎕ML←3 (default on many systems).
⌈/0,≢¨⊂⍨⎕=⎕

Try it online!
⎕=⎕ Boolean for equality between two inputs
⊂⍨ self-partition (begin partitions where a non-zero element is greater than its predecessor)
≢¨ tally each
0, prepend a zero (for the empty-input cases)
⌈/ max of those

Old solution
Prompts first for s, then for c
⌈/0,(⎕,¨'+')⎕S 1⊢⎕

Try it online!
⎕ prompt for s
⊢ for that
(…)⎕S 1 PCRE Search for the lengths of occurrences of
 '+' a plus symbol (meaning one or more)
 ,¨  appended to each of the elements of
 ⎕ the prompted-for c
0, prepend a zero (for the empty-input cases)
⌈/ max of those
c must be given as a 1-element vector of an enclosed string if it needs escaping.

Python 3, 71 bytes
f=lambda s,c,m=0,k=0:s and f(s[1:],c,-~m*(s[0]==c),max(m,k))or max(m,k)

Try it online!

Haskell, 66 bytes
import Data.List
((maximum.(0:).map length).).(.group).filter.elem

Try it online!
A slightly easier to read version - not pointfree:
f c s = maximum (0:(map length (filter (elem c) (group s))))

Groups the string by letter, then filters by those groups that contain the right character, then finds the lengths, appends 0 to the list of lengths in case it doesn't appear, and finally finds the maximum value.

Mathematica, 109 bytes
(s=Differences[First/@StringPosition[#,#2]];k=t=0;Table[If[s[[i]]==1,t++;If[k<t,k=t],t=0],{i,Length@s}];k+1)&

input

["xxx xxxx xx","x"]

Python 2, 69 bytes
lambda s,c:c and max(map(len,re.findall(c+'+',s))or[0])or 0
import re

Try it online!

CJam, 20 19 18 16 bytes
0q~e`f{~@=*}$+W=

Try it online!
Explanation
0                 e# Push 0. We'll need it later.
 q~               e# Read and eval input. Pushes c and s to the stack.
   e`             e# Run-length encode s: turns it into an array of [length, char] pairs.
     f{           e# Map over these pairs using c an extra parameter:
       ~          e#  Dump the pair to the stack.
        @=        e#  Bring c to the top, check equality with the char, pushing 0 or 1.
          *       e#  Multiply the length by the result.
           }      e# (end map)
            $     e# Sort the resulting list in ascending order.
             +    e# Prepend the 0 from before, in case it's empty.
              W=  e# Get the last element.

R, 66 58 bytes
-8 bytes thanks to BLT and MickyT

function(s,c)max((r=rle(el(strsplit(s,''))))$l*(r$v==c),0)

returns an anonymous function. TIO has a 1-byte difference because el doesn't work there for inexplicable reasons.
Try it online!

Save a byte with r=rle(el(strsplit(s,'')))

Ignore my previous comment if you saw it.  Got a better one for you function(s,c)max((r=rle(el(strsplit(s,''))))$l*(r$v==c),0)

@BLT el doesn't work on TIO (no idea why) and I just copied and pasted it from the working code there so I'll have to remember to put that back in
@MickyT very clever! Thanks!

Excel, 56 bytes
{=MAX(IFERROR(FIND(REPT(A2,ROW(A:A)),A1)^0*ROW(A:A),0))}

s should be input to A1.
c should be input to A2.
Formula must be an array formula (Ctrl+Shift+Enter) which adds curly brackets { }.
Technically, this can only handle where the longest run is less than 1,048,576 (which is 2^20) because that's how rows the current Excel will let you have in a worksheet. Since it loads the million+ values into memory whenever it recalculates, this is not a fast formula.

MATL, 15 bytes
0i0v=dfd1L)0hX>

Try it online!
The basic algorithm is very simple (no use of split!), but I had to throw in 0i0v and 0h to allow for the edge cases. Still, I thought the approach was nice, and perhaps I can still find another technique to handle the edge cases: the algorithm finds the longest run in the middle of a string just fine, but not for single characters  or empty strings; I'm still testing if I can 'pad' the variables at better places for better results.
0i0v % Prepends and appends a zero to the (implicit) input.
   = % Element-wise equality with the desired char (implicit input)
   d % Pairwise difference. Results in a 1 at the start of a run, and -1 at the end.
   f % Get indices of 1's and -1's.
   d % Difference to get length of the runs (as well as length of non-runs)
 1L) % Only select runs, throw out non-runs. We now have an array of all run lengths.
  0h % 'Find' (`f`) returns empty if no run is found, so append a zero to the previous array.
  X> % Maximum value.

Does not work on empty c. Then again, I suppose each string contains an infinite run of empty strings between each character :)

Java 8, 67 65 bytes
s->c->{int t=0,m=0;for(char x:s)m=m>(t=x==c?t+1:0)?m:t;return m;}

-2 bytes thanks to @OlivierGrégoire
Takes input s as a char[], and c as a char
Explanation:
Try it here.
s->c->{          // Method with char[] and char parameters and int return-type
  int t=0,       //  Temp counter-integer
      m=0;       //  Max integer
  for(char a:s)  //  Loop over the characters of the input
    m=m>(
     t=x==c?     //   If the current character equals the input-character:
      t+1        //    Raise `t` by 1
      :          //   Else:
       0)        //    Reset `t` to 0
    ?m:t;        //   If `t` is now larger than `m`, put `t` as new max into `m`
                 //  End of loop (implicit / single-line body)
  return m;      //  Return the resulting max
}                // End of method

m=m>(t=x==c?t+1:0)?m:t; is shorter than {t=x==c?t+1:0;m=m>t?m:t;}.

Even though it's wayyyyyy longer, I like my first thought: s->c->java.util.Arrays.stream(s.split("[^"+c+"]")).mapToInt(z->z.length()).max().orElse(0) ;)

Zsh, 18 bytes
tr -c $1 \\n|wc -L

Try it online!
Explanation:

tr: translate characters in STDIN:

-c: replace all except
$1: the first command-line argument
\\n: with newlines

|wc -L: then output the length of the longest line

K (ngn/k), 11 bytes
Takes arguments in swapped order.
#1_|':\1,^?

Try it online!
^? for each character in s, is it not a member of c?
1, prepend 1.
|':\ until the value stops changing, do pairwise or. This shrinks each run of 0s by 1 per iteration. Collects all intermediate results.
1_ Drop the first value (the initial boolean vector).
# Length. Counts the number of steps it took to fill the vector with 1s.
If we wouldn't have to deal with empty c, this could be 10 bytes instead:
#1_&':\0,=

Try it online!

Jelly, 5 bytes
=Œg§Ṁ

Try it online!
-3 bytes thanks to Unrelated String. Port of my Vyxal answer.
This takes a literal character, which can't be input (Jelly treats strings as char arrays), so the footer converts the single-character string into a character. The link can also be called this way.
=     # Is each char of the string equal to the given character?
 Œg   # Group consecutive identical items
   §  # Sum each
    Ṁ # Get the maximum

Jelly, 5 bytes
ṁ¹ẇƤS

Try it online!
Takes a character on the left and the string on the right. Can also take the character as a length-1 string (and thus be run as a full program), but errors if given a length-0 string, so it's unclear if this is valid given input that way due to one of the most confusing comment clarifications in site history.
ṁ        Mold the character to the length of the string,
 ¹       then
   Ƥ     for each prefix of that result
  ẇ      test if it's a contiguous substring of the string.
    S    Count up how many are.

Ruby, 40 bytes
->s,c{s.split(%r{[^#{c}]}).max&.size||0}
Try it online!

Clojure, 56 bytes
#(apply max(reductions(fn[r c](if(= c %2)(inc r)0))0 %))

Arturo, 31 bytes
$[s c]->size max match s~{|c|+}

Try it

J, 17 bytes
[:>./0(+/;.1)@,e.

Attempt This Online!
[:>./0(+/;.1)@,e.
[:                NB. enforces f(g(y))
     0(+/;.1)@,e. NB. g
               e. NB. check if each char of x is equal to y
     0        ,   NB. prepend a 0
             @    NB. then
      (+/;.1)     NB. cutting and summing
         ;.1      NB. cut up array using first item as delimiter, groups runs of 1's
       +/         NB. sum to get count
  >./             NB. f, get max of result

Japt, 9 bytes
ôÀV mÊrwT

Try it

Lua, 89 bytes
s,c=...a=0s:gsub(c:gsub('%W','%%%1')..'+',load'a=math.max(#...,a)')print(#c==0 and 0or a)

Try it online!
Ungolfed version:
s,c=...                           --Take s and c as program arguments
a=0                               --a stores max run of c
s:gsub(c:gsub('%W','%%%1')..'+',  --For every run of c
load'a=math.max(#...,a)')         --If length of c is longer than a, put into a
print(#c==0 and 0or a)            --If c is 0, print 0, otherwise print a

Scala, 98 bytes
Golfed version. Try it online!
def f(c:Char,s:String)=s.foldLeft((0,0)){case((d,m),x)=>if(x==c)(d+1,Math.max(d+1,m))else(0,m)}._2

Ungolfed version. Try it online!
object Main {
  def f(c: Char, s: String): Int = s.foldLeft((0, 0)) {
    case ((count, maxCount), char) =>
      if (char == c) (count + 1, Math.max(count + 1, maxCount))
      else (0, maxCount)
  }._2

  def main(args: Array[String]): Unit = {
    println(f('c', "ccc cccc cc"))
    println(f('c', ""))
    println(f('c', "abcdef"))
  }
}

Thunno 2 G, 3 bytes
=ġʂ

Try it online!
Port of Adnan's 05AB1E answer.
Explanation
=ġʂ  # Implicit input
=    # For each character, does it equal the second input?
 ġ   # Group consecutive equal items together
  ʂ  # Sum each inner list
     # Implicit output of maximum


text:
Draw a big slash X
Given a non-negative integer, print out an X that is that big. X is the output for input 0, and you will add slashes equal to the input in each direction to extend the X for larger inputs.
Test Cases
0
X

1
\ /
 X
/ \

2
\   /
 \ /
  X
 / \
/   \

...
10
\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \

Rules
You may either print the output, or return a string or list of string from a function. A trailing newline, as well as extra interior whitespace that does not affect appear, is allowed.
This is code-golf, so shortest answer in bytes wins!

Sandbox; related

... I'm just gonna wait for the charcoal 1-byte solution.

@LeakyNun I'd be surprised if Charcoal can easily deal with the X in the middle (part of why I added it) but who knows :D

Also related

Related, related

If these had come in in Sandbox, I might not have posted this 0.o

Canvas, 3 bytes
╵＼┼

Try it here!
half of the size of the Charcoal answer :D
╵    increment the input
 \   create a diagonal that long
  ┼  and quad-palindromize, mirroring what's required, with 1 overlap;
     This overlaps the `/` and `\`, resulting in `X`

Dang that is short.

:||||||| +1 for golfiness

also i wonder if stack-based languages basically always outgolf other languages?

@ASCII-only jelly

@Okx *stack-based/tacit

@ASCII-only pyth

Charcoal, 6 bytes
ＰX⁺¹ＮX

Your nonsense ain't stopping me ;)
Try it online!

The TIO looks... interesting when you put a really big number into it

@StephenS Only because of wrapping.

I know, it's just intuitive that all of the wrapped \\s get left aligned (because spaces don't get wrapped)

5 chars (postdates challenge) just to get that little bit closer to Canvas

JavaScript (ES6), 79 bytes
Uses a recursive function g that walks through a grid and builds the output character by character.
n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

How?
Both variables x and y iterate from 2n to -1, where n is the input.
For each position (x, y) in the grid, we pick one of these characters:

0: /
1: \
2: space
3: X
4: newline

using the following tests:

~x: Falsy if x == -1: we've reached an end of line.
x-y: Falsy if x == y: we're located on the anti-diagonal.
x+y-w: Falsy if x + y == w: we're located on the diagonal.
x-n: Falsy if x == n: because this test is only performed when x == y, this means that we're located in the exact center of the grid.

and the following decision tree:

Demo

let f =

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

console.log(f(0))
console.log(f(1))
console.log(f(4))

This is... JavaScript? What has happened to you, old friend.

MATL, 16 bytes
'\/X 'iEQXytEP+)

Try it online!
Consider input 2 as an example. The stack is shown here upside down, i.e. lower elements are the ones most recently pushed.
'\/X '  % Push this string
        %   STACK: '\/X '
iEQ     % Input a number, n. Multiply by 2, add 1: gives 2*n+1
        %   STACK: '\/X '
                   5
Xy      % Identity matrix of that size
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
tEP     % Duplicate, multiply each entry by 2, flip vertically
        %   STACK: '\/X '
                   [1 0 0 0 0;
                    0 1 0 0 0;
                    0 0 1 0 0;
                    0 0 0 1 0;
                    0 0 0 0 1]
                   [0 0 0 0 2;
                    0 0 0 2 0;
                    0 0 2 0 0;
                    0 2 0 0 0;
                    2 0 0 0 0]
+       % Add the two matrices
        %   STACK: '\/X '
                   [1 0 0 0 2;
                    0 1 0 2 0;
                    0 0 3 0 0;
                    0 2 0 1 0;
                    2 0 0 0 1]
)       % Index into the string. Indexing is 1-based and modular, so 1 picks
        % the first character ('\'), ..., 0 picks the last (space)
        %   STACK: ['\   /';
                    ' \ / ';
                    '  X  ';
                    ' / \ ';
                    '/   \']
        % Implicit display

I wanted to do something similar in Octave, but you beat me to it and in MATL it is even shorter than Octave, so great work!

@Michthan Thanks! An Octave version would definitely be worth posting too. My atempt is at 38 bytes, what's yours?

I have been thinking about it all weekend and couldn't find a more efficient way than the one you are using here.. So all credits should go to you for an octave version.

C, 108 106 104 bytes
a;g(n){for(int b=2*n,i=1,c=47;a+=i;!b?i=-i,c=92:puts(""),b-=2*i)printf("%*c%*c",a,b?c^115:88,b,b?c:10);}

Try it online!
(−2 golfing thanks to MD XF)
(−1 golfing thanks to ceilingcat)
It prints two characters (at first, c = 47, which is a slash, and c + 45, which is a backslash; then they are swapped) with a dynamic field width.
The field widths start at 1 and 2n, and at each iteration, the first width is incremented by 1, and the second one is decremented by 2.
When the second field width becomes 0, it outputs 'X' and a newline instead of the regular characters, and reverses the direction of increments (i). A newline is printed for all other lines separately (puts("")).

106 bytes: a,b,i=1,c;g(n){for(b=2*n,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);} Try it online!

Thanks for the idea! I only used a part of it to make sure the code can be called twice.

Thanks for the suggestion. Removing unneeded parentheses is always great!

C, 168 155 150 bytes
-5 thanks to Computronium
#define p printf(
s(x){while(x--)p" ");}j;f(x){for(;j<x;j++)s(j),p"\\"),s((x-j)*2-1),p"/\n");s(x);p"X\n");while(j--)s(j),p"/"),s((x-j)*2-1),p"\\\n");}

Can certainly be golfed; I'm doing so. Try it online!
Ungolfed:
int space(int x)
{
    while (x--)
        putchar(' ');
}

int f(int x)
{
    for (int j = 0; j < x; j++) {
        space(j);
        printf("\\");
        space((x-j)*2-1);
        printf("/\n");
    }

    space(x);
    puts("X");

    while (j--) {
        space(j);
        putchar('/');
        space((x-j)*2-1);
        printf("\\\n");
    }
}

You can lose 5 characters by defining p to be "printf(" instead of "printf".

shortC, 111 bytes
s(x){Wx--)R" ")}j;f(x){O;j<x;j++)s(j),P92),s((x-j)*2-1),R"/\n");s(x);R"X\n");Wj--)s(j),P47),s((x-j)*2-1),R"\\\n

Based on my C answer. Conversions:

R -> printf(
P -> putchar(
W -> while(
O -> for(
Auto-inserted closing ");}

This also uses ASCII codes for \ and /.
Try it online!

Python 2, 81 bytes
r=range(2*input()+1)
for i in r:print''.join(' \/X'[i==j::2][r[~i]==j]for j in r)

Try it online!

V, 21 bytes
éXÀñ>HÄÒ r\Á/YGpr/$r\

Try it online!
Hexdump:
00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\

Explanation:
éX                      " Insert an 'X'
  Àñ                    " Arg1 times:
    >H                  "   Add a space to every line.
                        "   Conveniently, this also puts us on the first line
      Ä                 "   Duplicate this line
       Ò                "   And replace the whole line with spaces
         r\             "   Replace the first char with '\'
           Á/           "   Append a '/' char
             Y          "   Yank this line
              G         "   Move to the last line
               p        "   And paste the line we yanked
                r/      "   Replace the first character with a '/'
                  $     "   Move to the end of the line
                   r\   "   And replace the last character with a '\'

Essentially, we have Insert an X, n times extend the slashes.
But it's not quite that simple because we also have to add the slashes the first time. If the slashes were already there, we could write extend the slashes as:
>HÄX2pGÙX2p

Which would save us 6 bytes.

Java (OpenJDK 8), 135 bytes
i->{int k=0,j,l=2*i+1;String[]s=new String[l];for(;k<l;k++)for(s[k]="",j=0;j<l;j++)s[k]+=j==k?j==i?"X":"\\":j==l-1-k?"/":" ";return s;}

Lambda expression that takes and integer and returns an array of Strings
Try it online!
Ungolfed:
i->{
    int k=0,j,l=2*i+1;                // Some variables to be used
    String[]s=new String[l];            // Return array (size 2*i+1)
    for(;k<l;k++)                       // For each array entry
        for(s[k]="",j=0;j<l;j++)        // Set each character to
            s[k]+=j==k?j==i?"X":"\\"    // \ or X if it's the jth character of the jth row
                 :j==l-1-k?"/"          // / if it's the opposite char
                 :" ";                  // else blank
    return s;
}

T-SQL, 201 bytes
DECLARE @ INT SELECT @=a FROM t DECLARE @i INT=@
WHILE @>0BEGIN PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'SET @-=1 END
PRINT SPACE(@i)+'X'WHILE @<@i BEGIN SET @+=1 PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'END

Formatted:
DECLARE @ INT
SELECT @=a FROM t
DECLARE @i INT=@
WHILE @>0
    BEGIN
        PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'
        SET @-=1
    END
PRINT SPACE(@i)+'X'
WHILE @<@i
    BEGIN
        SET @+=1
        PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'
    END

Input is via column a in named table t, per our guidelines.

C#, 157 122 120 bytes
_=d=>"".PadLeft(d)
a=>{var s=_(a)+"X\n";for(int i=0;++i<=a;)s=$@"{_(a-i)}\{_(i*2-1)}/
{s+_(a-i)}/{_(i*2-1)}\
";return s;}

Ungolfed version:
 Func<int, string> _ = (d) =>"".PadLeft(d);
        Func<int, string> func = a => {

            var s = _(a) + "X\n";

            for (int i = 0; ++i <= a;) {

                s = $@"{_(a - i)}\{_(i * 2 - 1)}/
{s + _(a - i)}/{_(i * 2 - 1)}\
";

            }
            return s;
        };

You can move the other anonymous function out of the first and then include it as _=d=>new string(' ',d); (note no need for the braces around d). You can remove the curly braces around the for loop. Make use of a verbatim string with so you don't need to escape all of the backslashes. If you set i=0 then you can do ++i<a+1 and remove the i++.

Also with verbatim strings you don't need to include \n an actual line feed will work, though I'm not sure if you will then be able to remove the braces around the for loop, you would have to try.

After applying the first suggestion by TheLethalCoder, you can also replace the ++i<a+1 for ++i<=a EDIT You can also save 4 more bytes by changing the Func from new string(' ',d) to "".PadLeft(d)

Thanks for suggestions, @TheLethalCoder am I allowed to declare 2 functions like that, wouldn't that make a lot of C# golfing shorter if we can do that?

@StefanDelport There's a meta discussion about it somewhere but as it stands I believe you can as long as you show the functions name. In this case _.

You can still remove the braces on the for loops scope to save 2 bytes.

Ruby, 66 bytes
Recursive function.
f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}

Try it online!
Explanation
f=->x{                  # Start of recursive function named `f`
      ?X[x]||           # Return 'X' if x==0, otherwise the following:
"\\#{s=' '*(2x-1)}/     #  Top edge of the cross. Save no. of spaces needed
#{f[x-1]                #  Get result of f[x-1]
        .gsub /^/,' '}  #  Regex sub to left-pad every line w/ a space
/#{s}\\"                #  Bottom edge of cross (insert saved no. of spaces)

Jelly, 24 17 bytes
Ḥ‘=þ`µḤ+Uị“/\x ”Y

Try it online!
How it Works
Ḥ‘=þ`µḤ+Uị“/\x ”Y   main link, input a
Ḥ‘                  input doubled and incremented
   þ                Make a table: Apply
  =                 "equals"/ to
    `               each element in range(2a+1) cartesian multiplied with itself.
                      eg. For input 1: [1=1,1=2,1=3],[2=1,2=2,2=3],[3=1,3=2,3=3]
     µ              on this array:
       +            add:
      Ḥ             double of it to
        U           its reverse (changes south-east to north-west)
         ị“/\x ”    index into the string "/\x " to get the right characters
                Y   join by newlines for the final output.

-6 bytes thanks to @LeakyNun and -1 byte with an additional improvement

18 bytes

Mathematica, 71 bytes
(Partially inspired by Jenny_mathy's 104-byte solution)
""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&

Returns a list of strings.
Explanation: IdentityMatrix[2#+1] makes a matrix of the right size with 1s along the diagonal and 0s elsewhere. Next, we multiply it by "\\" (an escaped backslash), which makes it a matrix with backslashes along the diagonal and 0s elsewhere, since of course 1 times backslash is backslash and 0 times backslash is 0. We add this to "/" times its reverse to make the X shape. We're nearly done, except there are still 0s everywhere, and the middle is "\\" + "/". We fix these two things by substituting " " for 0 and "X" for a_+_, which matches any sum of two things (like _+_ should, except Mathematica is too clever for its own good and interprets that as 2 times _). Finally, ""<>#&/@ turns this into a list of strings.

APL (Dyalog), 25 bytes
Requires ⎕IO←0 which is default on many systems.
' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]

Try it online!
' \/X'[…] index the string with
 ⎕ get input
 2× multiply by two
 1+ add one
 ⍳ that many integers
 ∘.=⍨ equality table (i.e. identity matrix; NW-SE diagonal)
 (…) apply the following tacit function on that
  ⊢ the argument
  + plus
  2× two times
  ⌽ the horizontally mirrored argument (i.e. NE-SW diagonal)

///, 223 bytes
/|/\\\\//i///& /  &// &///> /^b|b^v|v^^$|+^
f|fvv&i|||^$|-^^$|-^$|+^^<|$^<-|$>|->vv&i||||
^^<-|$^<|$^^f|f| ^ f|f^^>|->| ^ >|->^^f|fv|v^||||^^>|->v|v^|||^^^v|v  ^ b|b^>//^/\///b\/>/b\/\/$|+\/\/\/<|$\/\///>$+//>i$+
iX/<$//
<$

Try it online!
Seems like a fitting language for the challenge. (suck it, sed)
Input is given in unary spaces, after /i/:
/|/\\\\//i/<spaces here>//& /  &// &///...

Explanation:
don't ask me, I only programmed it ;)
sorta commented version, lightly ungolfed version
I didn't save the pregolfed code, and I don't understand it enough anymore to take it apart again (or maybe just laziness, who knows)

Bash, 138 bytes
for i in `seq $1;seq $[$1-1] -1 1`
{ $[a++]
printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`
}|sed 's/22/X/'|tr 12 /\\

Try it online!
Really long, bash heates '\ and /'
Less golfed
 for i in {1..10} {9..1};{
   $[a++];                      #argument as padding, prints 1 for \ and 2 for /
   printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`;
  }|sed 's/22/X/g' | tr 12 /\\

Batch, 201 bytes
@echo off
set s= /
for /l %%i in (2,1,%1)do call set s=  %%s%%
set s=\%s%
for /l %%i in (-%1,1,%1)do call:c
exit/b
:c
echo %s%
set s=%s:\ = \%
set s=%s:X =/\%
set s=%s:\/=X %
set s=%s: /=/ %

Starts by building up the top line, then after printing each line, moves the \ right one space and the / left once space, making sure that they make an X in the middle.

05AB1E, 21 bytes
F'\Nú}'X¹ú).B€.∞ø€.∞»

Try it online!

Python 2, 95 84 bytes
-10 bytes thanks to @FelipeNardiBatista
f=lambda s,i='\n':i+(s and'\\'+'  '*~-s+' /'+f(s-1,i+' ')+i+'/'+'  '*~-s+' \\'or'X')

Try it online!

85 bytes: TIO

@FelipeNardiBatista thanks a lot

PHP, 115 bytes
for(;$i<$c=1+2*$argn;$b?:$t[$i-1]="\\".!$t[$c-$i]="/",$o.="$t\n")$t=str_pad(" X"[$b=$argn==+$i++],$c," ",2);echo$o;

Try it online!

Mathematica, 131 bytes
(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&

Mathematica, 104 bytes
here is another approach using Grid
(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&

Retina, 74 bytes
.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1

Try it online! Explanation:
.+
$* X

Place the X.
+`^ ( *).( *)
$1\  $2/¶$&

Starting at the X, working upwards, place a \ diagonally to the left each time. Also place a / two more spaces after the / than last time.
+`¶ ( *).( *).?$
$&¶$1/  $2\

Starting at the X, working downwards, place a / diagonally to the left each time. Also place a \ two more spaces after the / than last time.
m` (\W)$
$1

The number of spaces between the two diagonals needs to be odd, so the last space on each line (except the original X line) is deleted.

Pyke, 14 bytes
\XQV.X \   /\/

Try it here!
\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ",
                              tl="\",
                              left=" ",
                              right=" ",
                              lower=" ",
                              tr="/",
                              br="\",
                              bl="/")

QBIC, 90 bytes
~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ

How this monstrosity works, is left as an excercise for the reader...
Sample output:
Command line: 3
\     /
 \   /
  \ /
   X
  / \
 /   \
/     \

Perl 5, 110 + 1 = 111 bytes
Uses -n flag.
$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}

R, 75 72 bytes
y=diag(b<-2*scan()+1);write(c(" ",'\\','/','X')[y+2*y[,b:1]+1],'',b,,'')

Inspired by this answer, generates an implicit matrix and writes it to stdout; reads the size from stdin. It has to build a matrix of space characters and uses sep='' b/c otherwise it has spacing issues.
diag(b)                     # generates a main diagonal of 1, rest 0
2*diag(b)[,b:1]             # the other diagonal is 2
                            # [,b:1] reverses columns
                            # [b:1,] reverses the rows; they're equivalent
diag(b)+2*diag(b)[,b:1]     # sums, so we get 1 for main diagonal
                            # 2 for other diagonal, 3 for center
diag(b)+2*diag(b)[,b:1]+1   # add 1 since R is 1-indexed
                            # the result is indices for the vector
c(' ','\\','/','X')

Try it online!

Visual Basic.Net, 454 450 Bytes
Option Strict Off
module m
sub main(a As String())
dim v=Convert.toInt32(a(0))
for i as Integer=v to 1 step -1
for j as Object=1 to v-i
w(" ")
next
w("\")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("/")
next
console.writeline(new String(" ",v)&"X")
for i as Object=1 to v
for j as Object=1 to v-i
w(" ")
next
w("/")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("\")
next
end sub
sub w(s)
console.write(s)
end Sub
end module

not sure whether making a func for writeline will save some bytes
thanks to Stephen S for pointing at as ... removal
also changed integer into object
last edit changed the first one back

You're a brave one :) I believe you can remove all of the as Types, because if you have Option Strict Off, VB.NET acts like a loosely typed language.

Currently on Linux mono is anoying

mono doesn't cares about Option Strict, or at least thats what I think

Oh it seemed functions != for loops thanks for the golf

Isn't Option Strict off by default? It is in Visual Studio at least

probably it is :)

05AB1E, 22 bytes
F'\IN-úR.∞})Âí'Xs)˜.c»

Try it online!
Explanation
F                        # for N in [0...input-1] do
 '\                      # push a backslash
   IN-ú                  # prepend input-N spaces
       R                 # reverse
        .∞               # mirror
          }              # end loop
           )             # wrap stack in a list
            Â            # bifurcate
             í           # reverse each item
              'Xs        # push an "X" between the 2 lists on the stack
                 )˜      # wrap in flattened list
                   .c    # pad lines to equal length
                     »   # join on newlines

Alternative 22 byte solution
F'\N·>ú'/ì})Âí'X¸«ì.c»

tcl, 134
proc P {x s b} {time {puts [format %[incr ::i $x]s%[expr ($::n-$::i)*2+2]s $s $b]} $::n}
P 1 \\ /
puts [format %[incr i]s X]
P -1 / \\

demo
Set n on the first line.
May be I can golf it more using a recursive approach

C (gcc), 99 85 bytes
f(x,h,t){for(h=2*x+2,t=h*h-h;t--;putchar(t^h*x-~x?t%h?~-t%~h?t%~-h?32:47:92:10:88));}

-14 bytes, Thanks to ceilingcat
Try it online!

brainfuck, 285 276 bytes
+++++++++++[>+>>++++++++>++++>++++++++>+++<<<<<<-]>->>++++>+++>>->>>,[>>-<<[<<[<.>->+<]<[<]>.[>]>>[<<++>>->+<]<<-[<.>-]<<<.<<<.>>[>]+>[<+>-]>>-[<+>-]<]<<[<.>->>+<<]<<.<<<<.>>[>]>>[->+<[<<<.>>+>-]<<<<<.>>>>[>+<-]>>[<<<++>+>>-]<<[>>+<<-]<-[<.>-]<<[<]>.<<.>>[>]>>]]>>+[<<<<<<.>>]

Try it online!
Input uses bytes. So 1 is \x01
Alternative Version which supports numbers (366 313 bytes)

Zsh, 83 bytes
2=${(l:$1:)}
S=$2\ $2
F()for i;(S[i]=\\;S[-i]=/;<<<$S)
F {1..$1}
<<<$2X
F {-$1..-1}

Try it online!

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:
Create the slowest growing function you can in under 100 bytes
Your job is to create the slowest growing function you can in no more than 100 bytes.
Your program will take as input a nonnegative integer, and output a nonnegative integer. Let's call your program P.
It must meet the these two criterion:

Its source code must be less than or equal to 100 bytes.
For every K, there is an N, such that for every n >= N, P(n) > K. In other words, lim(n->∞)P(n)=∞. (This is what it means for it to be "growing".)

Your "score" is the growth rate of your program's underlying function.
More specifically, program P is grows slower than Q if there is a N such that for all n>=N, P(n) <= Q(n), and there is at least one n>=N such that P(n) < Q(n). If neither program is better than the other, they are tied. (Essentially, which program is slower is based on the value of lim(n->∞)P(n)-Q(n).)
The slowest growing function is defined as the one that grows slower than any other function, according to the definition in the previous paragraph.
This is growth-rate-golf, so the slowest growing program wins!
Notes:

To assist in scoring, try to put what function your program calculates in the answer.
Also put some (theoretical) input and outputs, to help give people an idea of how slow you can go.

Related.

An effective strategy is to write a fast-growing function and take its inverse, i.e. find the smallest input to it that produces at least the required value. Perhaps this is a dupe?

A third of the "More specifically" paragraph was missing because Markdown thinks a < followed by a letter is the start of an HTML tag. Preview your questions before you post them please :P

What large cardinal axioms can we assume?

@Peter Taylor uhm, whichever you want I guess

Is the time machine to test our answers provided?

Your definitions of "growing" and "slowest growing" are exceedingly hard for me to understand, and that is made much worse by using both n and N as different variables. It's gibberish when read aloud.

@DavidConrad essentially, it's asymptotic

How is this any different than saying "For every K there is an N such that P(N) > K"? Why did you introduce two N's? Just to be confusing? Sorry, I guess I'm just not smart enough to understand this. But naming both terms "N", distinguished only by case, is definitely a bad, bad idea.

@DavidConrad I can change it if you like (I didn't try reading it out loud).

Can we ignore 0 as an input?

See Binary Lambda Calculus entry below given assumption of large cardinal axiom as asked by Peter Taylor.

Haskell, 100 bytes, score=fε0−1(n)
_#[]=0
k#(0:a)=k#a+1
k#(a:b)=(k+1)#(([1..k]>>fst(span(>=a)b)++[a-1])++b)
f n=[k|k<-[0..],1#[k]>n]!!0

How it works
This computes the inverse of a very fast growing function related to Beklemishev’s worm game.  Its growth rate is comparable to fε0, where fα is the fast-growing hierarchy and ε0 is the first epsilon number.
For comparison with other answers, note that

exponentiation is comparable to f2;
iterated exponentiation (tetration or ↑↑) is comparable to f3;
↑↑⋯↑↑ with m arrows is comparable to fm + 1;
The Ackermann function is comparable to fω;
repeated iterations of the Ackermann function (constructions like Graham’s number) are still dominated by fω + 1;
and ε0 is the limit of all towers ωωω⋰ω.

I like the description here better.

You could put in a link to Googology Wiki's introduction to the fast growing hierarchy

Your code seems to compute something very different from Beklemishev's worm, as you fail to compute k#(a:b) as 1+(k+1#,,,). I found this one-line version that computes the worm exactly: m#[]=m;m#(a:s)=(m+1)#g a where(x,y)=span(>=a)s;g 0=s;g a=([0..m]>>(a-1:x))++y

@JohnTromp Yeah, I only said it’s related—I had to make some modifications that are inessential to the growth rate to fit this into 100 bytes. But I don’t remember my justification for replacing the step counter with the initial argument, so I’ve put it back.

Brachylog, 100 bytes
llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Try it online!
This is probably nowhere near the slowness of some other fancy answers, but I couldn't believe noone had tried this simple and beautiful approach.
Simply, we compute the length of the input number, then the length of this result, then the length of this other result... 100 times in total.
This grows as fast as log(log(log...log(x), with 100 base-10 logs.
If you input your number as a string, this will run extremely fast on any input you could try, but don't expect to ever see a result higher than 1 :D

+1 just for pure insanity :o Fun fact: Also works in Jelly if you make it all caps. :P

The first number that outputs 2 is 10↑↑99.

JavaScript (ES6), Inverse Ackermann Function*, 97 bytes
*if I did it right
A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

Function A is the Ackermann function. Function a is supposed to be the Inverse Ackermann function. If I implemented it correctly, Wikipedia says that it will not hit 5 until m equals 2^2^2^2^16. I get a StackOverflow around 1000.
Usage:
console.log(a(1000))

Explanations:
Ackermann Function
A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

Inverse Ackermann Function
a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

Isn't Stack Overflow good though?

Your statement that it won't hit 5 until m=2^^7 is wrong. It won't hit 5 until m=2^^7-3, but at 2^^7-1, it is 5. I know that -3 is very small compared to 2^^7, but 5A5=2^^7-3<2^^7. (^^ represents tetration)

Pure Evil: Eval
a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

The statement inside the eval creates a string of length 7*1010101010108.57 which consists of nothing but more calls to the lambda function each of which will construct a string of similar length, on and on until eventually y becomes 0. Ostensibly this has the same complexity as the Eschew method below, but rather than relying on if-and-or control logic, it just smashes giant strings together (and the net result is getting more stacks...probably?).
The largest y value I can supply and compute without Python throwing an error is 2 which is already sufficient to reduce an input of max-float into returning 1.
A string of length 7,625,597,484,987 is just too big: OverflowError: cannot fit 'long' into an index-sized integer.
I should stop.
Eschew Math.log: Going to the (10th-)root (of the problem), Score: function effectively indistinguishable from y=1.
Importing the math library is restricting the byte count. Lets do away with that and replace the log(x) function with something roughly equivalent: x**.1 and which costs approximately the same number of characters, but doesn't require the import.  Both functions have a sublinear output with respect to input, but x0.1 grows even more slowly.  However we don't care a whole lot, we only care that it has the same base growth pattern with respect to large numbers while consuming a comparable number of characters (eg. x**.9 is the same number of characters, but grows more quickly, so there is some value that would exhibit the exact same growth).
Now, what to do with 16 characters. How about...extending our lambda function to have Ackermann Sequence properties? This answer for large numbers inspired this solution.
a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

The z**z portion here prevents me from running this function with anywhere close to sane inputs for y and z, the largest values I can use are 9 and 3 for which I get back the value of 1.0, even for the largest float Python supports (note: while 1.0 is numerically greater than 6.77538853089e-05, increased recursion levels move the output of this function closer to 1, while remaining greater than 1, whereas the previous function moved values closer to 0 while remaining greater than 0, thus even moderate recursion on this function results in so many operations that the floating point number loses all significant bits).
Re-configuring the original lambda call to have recursion values of 0 and 2...
>>>1.7976931348623157e+308
1.0000000071

If the comparison is made to "offset from 0" instead of "offset from 1" this function returns 7.1e-9, which is definitely smaller than 6.7e-05.
Actual program's base recursion (z value) is 101010101.97 levels deep, as soon as y exhausts itself, it gets reset with 10101010101.97 (which is why an initial value of 9 is sufficient), so I don't even know how to correctly compute the total number of recursions that occur: I've reached the end of my mathematical knowledge. Similarly I don't know if moving one of the **n exponentiations from the initial input to the secondary z**z would improve the number of recursions or not (ditto reverse).
Lets go even slower with even more recursion
import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1

n//1 - saves 2 bytes over int(n)
import math,math. saves 1 byte over from math import*
a(...) saves 8 bytes total over m(m,...)
(y>0)*x saves a byte over y>0and x
9**9**99 increases byte count by 4 and increases recursion depth by approximately 2.8 * 10^x where x is the old depth (or a depth nearing a googolplex in size: 101094).
9**9**9e9 increases the byte count by 5 and increases recursion depth by...an insane amount. Recursion depth is now 1010109.93, for reference, a googolplex is 1010102.
lambda declaration increases recursion by an extra step: m(m(...)) to a(a(a(...))) costs 7 bytes

New output value (at 9 recursion depth):
>>>1.7976931348623157e+308
6.77538853089e-05

Recursion depth has exploded to the point at which this result is literally meaningless except in comparison to the earlier results using the same input values:

The original called log 25 times
The first improvement calls it 81 times

The actual program would call it 1e992 or about 10102.3 times

This version calls it 729 times

The actual program would call it (9999)3 or slightly less than 101095 times).

Lambda Inception, score: ???
I heard you like lambdas, so...
from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

I can't even run this, I stack overflow even with a mere 99 layers of recursion.
The old method (below) returns (skipping the conversion to an integer):
>>>1.7976931348623157e+308
0.0909072713593

The new method returns, using only 9 layers of incursion (rather than the full googol of them):
>>>1.7976931348623157e+308
0.00196323936205

I think this works out to be of similar complexity to the Ackerman sequence, only small instead of big.
Also thanks to ETHproductions for a 3-byte savings in spaces I didn't realize could be removed.
Old answer:
The integer truncation of the function log(i+1) iterated 20 25 times (Python) using lambda'd lambdas.
PyRulez's answer can be compressed by introducing a second lambda and stacking it:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

99 100 characters used.
This produces an iteration of 20 25, over the original 12.  Additionally it saves 2 characters by using int() instead of floor() which allowed for an additional x() stack. If the spaces after the lambda can be removed (I cannot check at the moment) then a 5th y() can be added. Possible!
If there's a way to skip the from math import by using a fully qualified name (eg. x=lambda i: math.log(i+1))), that would save even more characters and allow for another stack of x() but I don't know if Python supports such things (I suspect not). Done!
This is essentially the same trick used in XCKD's blog post on large numbers, however the overhead in declaring lambdas precludes a third stack:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

This is the smallest recursion possible with 3 lambdas that exceeds the computed stack height of 2 lambdas (reducing any lambda to two calls drops the stack height to 18, below that of the 2-lambda version), but unfortunately requires 110 characters.

FYI, I count 103 bytes in the top program

@ETHproductions oh oops. I probably did a count without the int conversion and thought I had some spares.

I think you can remove the space after import and the space after y<0. I don't know much Python though so I'm not certain

Also, perhaps y<0and x or m(m,m(m,log(x+1),y-1),y-1) to save another byte (assuming x is never 0 when y<0)

@ETHproductions That in fact does work. I'd looked at removing the space, but the editor I was using dropped the syntax highlighting so I thought it wasn't valid. Aaand... I can drop a space from the import.

Instead of math.log(x+1), how about x.bit_length()?  It's built-in so you don't need to import math, and and it returns an int so there's no need for //1.

.bit_length() is really quite long and is essentially log2(x), which has comparable growth to the shorter x**.1 that I'm using now.

(Well, certainly any logarithm grows more slowly than the tenth root, which is what x**.1 is.)

@mathmandan Yes, but the difference isn't relevant when stacked a billion billion billion times. Heck, that may as well be a /2 for all the difference it makes. The power of the algorithm lies in its recursion depth. At the maximum recursion depth I can run on my PC a /2 results in stripping 93 decimal digits off the input. That is, the function recursed about 3.3*10^93 times on the inputs of just (x,9,4) and my answer here is pumping in (x, 9, 9^9^9^9). That's a stack of four nines. For reference, (x,9,3) strips fifteen digits.

u=lambda n,p=3:p and u(n.bit_length(),p-1)or n is 46 bytes.  That means, if you replace the 3 with any integer X that takes 55 or fewer bytes to evaluate, you can iterate the log2 function X times.  (In that amount of space, you can get a lot more than 9**9**9**9 iterations.)  Indeed, this approach basically transforms the question into  "write the biggest number you can in 55 bytes or less,"

@mathmandan I'm not enough of a mathemetician to show that it is slower, unfortunately.

@mathmandan you know what I can do in 55 bytes, though? eval("a("*p**p**p+"x**.1"+",y-1)"*p**p**p) plus 9**9**9**9**9 and that merely computes the size of the next call which is 10^10^10^10^10^10^8.57 deep, each one of which is going to create almost as many more.

Well...log(x) grows more slowly than ANY positive power of x (for large values of x), and this isn't hard to show using L'Hopital's rule.  I am pretty sure your current version does (...(((x**.1)**.1)**.1)** ...) a whole bunch of times.  But those powers just multiply, so it's effectively x**(.1** (whole bunch)), which is a (very small) positive power of x.  That means that it actually grows faster than a SINGLE iteration of the log function (although, granted, you'd have to look at VERY large values of x before you'd notice...but that's what we mean by "going to infinity").

@mathmandan As I've already said, I'm at the limits of my mathematical understanding. I cannot ascertain for myself that what you're saying is true nor can I provide a counter argument.

MATL, 42 bytes
iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

Try it online!
This program is based on the harmonic series with the use of Euler–Mascheroni constant. As I was reading @LuisMendo documentation on his MATL language (with capital letters, so it looks important) I noticed this constant. The slow growth function expression is as following:

where  εk ~ 1/2k
I tested up to 10000 iterations (in Matlab, since it is too large for TIO) and it scores below 10, so it is very slow.

Explanations:
 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

Empirical proof:
(ln k) + 1 in red always above lnk + γ + εk in blue.

The program for (ln k) + 1 was made in
Matlab, 47 18 14 bytes
n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

Interesting to note that the elapsed time for n=100 is 0.208693s on my laptop, but only 0.121945s with d=rand(1,n);A=d*0; and even less, 0.112147s with A=zeros(1,n). If zeros is a waste of space, it saves speed!
But I am diverging from the topic (probably very slowly).
Edit:
thanks to Stewie for helping reducing this Matlab expression to, simply:
 @(n)log(1:n)+1

+1 for not just being the inverse of a fast function

An interesting SO-post about your interesting note. :)

By the way, golfing the script in the bottom (since you included the byte count): The last MATLAB script is simply: n=input('');A=log(1:n)+1, or as an unnamed anonymous function (14 bytes): @(n)log(1:n)+1. I'm not sure about MATLAB, but A=log(1:input(''))+1 works in Octave...

thank you @Stewie n=input('');A=log(1:n)+1 works, @(n)log(1:n)+1 don't (indeed a valid function with handle in Matlab, but input is not asked), A=log(1:input(''))+1 works and can be shortened log(1:input(''))+1

What I meant with the anonymous function was this. That's the "normal" way to save bytes (on this site at least) by requiring the input is given as function arguments (meta-post) instead of command line. Also, the f= doesn't need to be counted, since it's possible to just to: @(n)log(1:n)+1 followed by ans(10) to get the first 10 numbers.

Haskell, 100 bytes
f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

Try it online!
This solution does not take the inverse of a quickly growing function instead it takes a rather slowly growing function, in this case length.show, and applies it a bunch of times.
First we define a function f.  f is a bastard version of Knuth's uparrow notation that grows slightly faster (slightly is a bit of an understatement, but the numbers we are dealing with are so large that in the grand scheme of things...).  We define the base case of f 0 a b to be a^b or a to the power of b.  We then define the general case to be (f$c-1) applied to b+2 instances of a.  If we were defining a Knuth uparrow notation like construct we would apply it to b instances of a, but b+2 is actually golfier and has the advantage of being faster growing.
We then define the operator #.  a#b is defined to be length.show applied to b a times.  Every application of length.show is an approximately equal to log10, which is not a very swiftly growing function.
We then go about defining our function g that takes and integer in and applies length.show to the integer a bunch of times.  To be specific it applies length.show to the input f(f 9 9 9)9 9.  Before we get into how large this is lets look at f 9 9 9.  f 9 9 9 is greater than 9↑↑↑↑↑↑↑↑↑9 (nine arrows), by a massive margin.  I believe it is somewhere between 9↑↑↑↑↑↑↑↑↑9 (nine arrows) and 9↑↑↑↑↑↑↑↑↑↑9 (ten arrows).  Now this is an unimaginably large number, far to big to be stored on any computer in existence (in binary notation).  We then take that and put that as the first argument of our f that means our value is larger than 9↑↑↑↑↑↑...↑↑↑↑↑↑9 with f 9 9 9 arrows in between.  I'm not going describe this number because it is so large I don't think I would be able to do it justice.
Each length.show is approximately equal to taking the log base 10 of the integer.  This means that most numbers will return 1 when f is applied to them.  The smallest number to return something other than 1 is 10↑↑(f(f 9 9 9)9 9), which returns 2.  Lets think about that for a moment.  As abominably large as that number we defined earlier is, the smallest number that returns 2 is 10 to its own power that many times.  Thats 1 followed by 10↑(f(f 9 9 9)9 9) zeros.
For the general case of n the smallest input outputting any given n must be (10↑(n-1))↑↑(f(f 9 9 9)9 9).
Note that this program requires massive amounts of time and memory for even small n (more than there is in the universe many times over), if you want to test this I suggest replacing f(f 9 9 9)9 9 with a much smaller number, try 1 or 2 if you want ever get any output other than 1.

Meh, I don't think anyone cares about how long it takes or how much memory is required for the program to run on these sorts of questions.

Binary Lambda Calculus, 237 bits (under 30 bytes)
-- compute periods of final row of Laver tables as in as in
-- section 3.4 of https://arxiv.org/pdf/1810.00548.pdf
let
  -- Let mx = 2^n - 1. We consider a dual version of the shelf, determined
  -- by a |> mx = a-1 (mod 2^n), which satisfies
  --   0 |> b  = b
  --   a |> 0  = 0
  --   a |> mx = a-1
  --   a |> b  = (a |> b+1) |> a-1
  -- Note that the latter two equations iterate f_a = \x. x |> (a-1).
  -- In fact, for a > 0, we implement a |> b = f_a^{mx-b} (a-1) as f_a^{mx*b} 0,
  -- exploiting the fact that a |> mx = a-1 = 0 |> a-1 = f_a 0
  -- and (modulo 2^n) 1+mx-b = -b = -1 * b = mx*b

  0 = \f\x. x;
  1 = \x. x;
  2 = \f\x. f (f x);
  succ = \n\f\x. f (n f x);
  pred = \n\f\x. n (\g\h. h (g f)) (\h. x) (\x. x);
  laver = \mx.
    -- swap argument order to simplify iterated laver
    let laver = \b\a. a (\_. mx (b (laver (pred a))) 0) b
    in laver;
  dblp1 = \n\f\x. n f (n f (f x)); -- map n to 2*n+1
  find0 = \mx\i.laver mx i mx (\_.find0 mx (succ i)) i;
  period = \n.let mx = pred (n 2) in find0 mx 1
in
  period

compiles down to the 237 bits
010000010101000110100000000101010101000110100000000101100001011111110011110010111110111100111111111101100000101101011000010101111101111011100000011100101111101101010011100110000001110011101000100000000101011110000001100111011110001100010

This function grows to infinity assuming large cardinal axiom I3, which I believe is what Peter Taylor was hinting at. It grows way slower than any sort of inverse Ackerman.

Do you have a source for your claimed properties of 16th column? The paper you cited mentions these properties for the sequence of periods $\pi_n(p)$, not for the columns of the table itself.

I have rewritten the program to compute the periods of rows 2^n-1, which are monotonically nondecreasing.

Wow, impressive! I've been learning about Laver Tables before and tried to utilize them to create the opposite of this task, namely a fast-growing function, but mine wouldn't work. Congrats on implementing this beast of a slow-growing function!

Python 3, 100 bytes
The floor of the function log(i+1) iterated 99999999999999999999999999999999999 times.
One can use exponents to make the above number even larger...
from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

Try it online!

Do solutions have to actually work? This throws an OverflowError.

@ETHproductions in problems like this, it is commonly accepted that solutions only need to be theoretically viable, on a machine with infinite memory and cpu. If you want to try this, cut the 99999...999 down to just 999 or so

So why not use 9**9**9**...**9**9e9?

APL, Apply log(n + 1), e^9^9...^9 times, where the length of the chain is e^9^9...^9 of length of chain minus 1 times, and so on.
⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

Is there a way I can run this?

@Draco18s get a quantum computer with virtually-infinite memory, install a decent APL distribution, and spend the time you wait for it to create an aging preventing serum, cos you'll have to sit tight for a couple centuries.

Haha. Ok then. :p

Are you sure this approaches infinity?

@PyRulez it's just the same as the other solutions, only with a lot more iterations on the log. but more iteration is still the same closing - defied by exponenting that much as well. I was not sure about the e^n^n...^n part so I turned it into constant, but it might be true

Yeah, I think that if you increase the iterations based on n, it will stay near 0.

"for a couple centuries" More like a giggolplex.

The floor of the function log(i+1) iterated 14 times (Python)
import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

I don't expect this to do very well, but I figured its a good start.
Examples:

e^n^n^n^n^n^n^n^n^n^n^n^n^n^n -> ~n (approximately n)

If you use int instead of floor, you can fit in another x(

@BetaDecay Okay I updated it.

Shouldn't the expression be e^e^e^e...^n? Also, why is there a space after the :?

@CalculatorFeline because this isn't code golf, it just needs to be under 100 bytes.

So? What's so bad about saving a byte so you can add another x() call?

Ruby, 100 bytes, score-1 = fωω+1(n2)
Basically borrowed from my Largest Number Printable, here's my program:
->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

Try it online
Basically computes the inverse of fωω+1(n2) in the fast growing hierarchy.  The first few values are
x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

And then it continues to output 2 for a very long time.  Even x[G] = 2, where G is Graham's number.

But what about g(fω9001CK3) where f is FGH?

@user75200 the fgh isn't well defined for uncomputable ordinals.

FGH is well-defined for uncomputable ordinals, as they have fundamental sequences. It's just uncomputable.

@user75200 No. Fundamental sequences are very arbitrary. I could define ω9001CK[x] = x to have a fundamental sequence of length ω9001CK, which is computable for finite x, but very likely not what you wanted. By "well-defined," I meant there isn't a standard fundamental sequence for uncomputable ordinals that everyone can agree on.

While it’s true that fundamental sequences aren’t unique, a fundamental sequence for a countable ordinal is supposed to be of length ω.

@AndersKaseorg Usually yes, but not necessarily. I was merely making a point.

@user75200 f_ω9001CK may be computable btw. For example, take (ω9001CK[n])[k] = k for all k ≤ n. Then f_ω9001CK = f_ω, nothing too special.

The ordinal $\omega_{9001}^{CK}$ in FGH is computable, and fundamental sequences of length $\omega$ for it can be obtained (and are quite commonly used, I might add) using Klev's $\mathcal{O}^+$ and $\mathcal{O}^{++}$, which means that $f_{\omega_{9001}^{CK}}(n)$ is computable.

Python, 100 bytes, \$999 \uparrow^{99999} \text{Score} = \text{Input}\$, using up-arrow notation
f=lambda b,i,n:n/b if i==0 else(0if n<=1else 1+f(b,i,f(b,i-1,n)));print(f(999,99999,int(input(""))))

This is based on extremely iterated logarithms, since most people know that logarithms alone grow pretty slowly.
This program describes a ternary lambda function known simply as f which takes a base b, iterations i and input n. If i == 0, it just returns the input divided by the base. With i == 1, you may recognise the output as \$\text{max}(0, \lfloor \text{log}_b(n)\rfloor)\$. Then, with i == 2, this is equal to \$\text{log*}(n) = \text{max}(0, \lfloor \text{slog}_b(n)\rfloor)\$, where \$\text{slog}\$ is the super logarithm (iteration instead of exponentiation). Then, this program gets user input and returns \$\text{max}(0, \lfloor ^{99999}\text{log}_{999}(n)\rfloor)\$. Here, \$^m\text{log}\$ is logarithm using \$\uparrow^m\$, so \$^2\text{log}\$ is \$\text{slog}\$.

Clojure, 91 bytes
(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

Kind of calculates the sum 1/(n * log(n) * log(log(n)) * ...), which I found from here. But the function ended up 101 bytes long so I had to drop the explicit number of iterations, and instead iterate as long as the number is greater than one. Example outputs for inputs of 10^i:
0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

I assume this modified series still diverges but do now know how to prove it.

The third series actually requires a googolplex numbers of terms before the partial terms exceed 10.

Javascript (ES6), 94 bytes
(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

Explanation:
Id refers to x => x in the following.
Let's first take a look at:
p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log) is approximately equal to log*(x).
p(p(Math.log)) is approximately equal to log**(x) (number of times you can take log* until the value is at most 1).
p(p(p(Math.log))) is approximately equal to log***(x).
The inverse Ackermann function alpha(x) is approximately equal to the minimum number of times you need to compose p until the value is at most 1.
If we then use:
p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

then we can write alpha = p(Id)(Math.log).
That's pretty boring, however, so let's increase the number of levels:
p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

This is like how we constructed alpha(x), except instead of doing log**...**(x), we now do alpha**...**(x).
Why stop here though?
p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

If the previous function is f(x)~alpha**...**(x), this one is now ~ f**...**(x). We do one more level of this to get our final solution.

"p(p(x => x - 2))  is approximately equal to log**(x) (number of times you can take log* until the value is at most 1)".  I don't understand this statement.  It seems to me that p(x => x - 2) should be "the number of times you can subtract 2 until the value is at most 1".  That is, p(x => x - 2)should be the "divide by 2" function.  Thereforep(p(x => x - 2))should be "the number of times you can divide by 2 until the value is at most 1"...that is, it should be thelogfunction, notlog*orlog**`.  Perhaps this could be clarified?

@mathmandan looks like I made a typo on that line, it should be p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x)), where p is passed p(f) like in the other lines, not f.

Mathematica, 99 bytes
(assuming ± takes 1 byte)
0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

The first 3 commands define x±y to evaluate Ackermann(y, x).
The result of the function is the number of times f(#)=#±#±#±#±#±#±#±# need to be applied to 1 before the value get to the value of parameter. As f(#)=#±#±#±#±#±#±#±# (that is, f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) grow very fast, the function grow very slow.

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


text:
Fully-palindromic triangles
Consider the string 160615051. It can be "triangulated" as such:
  1
 606
15051

Then, each row is a palindrome. Also note that each side on the perimeter is also a palindrome:
  1  |   1   |
 6   |    6  |
1    |     1 | 15051

Therefore, this string can be considered to be a fully-palindromic triangle. Don't worry about the altitude 100 in this case, it doesn't have to be palindromic.
Input: A string of printable ASCII characters from 0x20 to 0x7E. This can be a character array, a single string, or an array of ASCII code points. Your input will always be able to be triangulated (that is, its length will always be a perfect square).
Output: A truthy value if the string is a fully-palindromic triangle, or a falsey value otherwise.
Test cases
input => output

1 => true
A => true
AAAA => true
nope => false
{{}} => false
1101 => true
1011 => false
1202 => false
111110001 => true
160615051 => true
160625052 => false
1111111111111111 => true
1121123211234321123454321 => true
HHeHHeleHHellleHHellolleH => true
HellolleHHellleHHeleHHeHH => false
111111111111111111111111111111111111 => true
abcbdefeddefgfedbcdefedcbabcdefedcba => true

Jelly, 14 12 bytes
J’Æ²œṗZ⁻¦µU⁼

Try it online!
Background
We start by looking at the 0-based indices of the input string.
 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H
 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

To get the rows of the triangle, we can split the string before the indices 1, 1 + 3 = 4, 1 + 3 + 5 = 9, and 1 + 3 + 5 + 7 = 16. Since (n + 1)² = n² + (2n + 1), these sums are precisely the positive, perfect squares in the index list. If we also split the string before 0, this is as simple as splitting before all 0-based indices that are perfect squares.
After splitting, we get the following strings.
""
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

Next, we replace the empty string at the beginning with all the characters in the first column.
"HHHHH"
"H"
"HeH"
"HeleH"
"HellleH"
"HellolleH"

The task is now reduced to checking whether reversing all strings yields the same string array.
How it works
First J generates all 1-based indices of the input string J, then decrements them with ’ to yield all 0-based indices. Æ² tests all 0-based indices for squareness. For our example from above, this yields the following Boolean array.
 1  1  0  0  1  0  0  0  0  1  0  0  0  0  0  0  1  0  0  0  0  0  0  0  0

Next, we call œṗ to partition the input string, e.g.,
 H  H  e  H  H  e  l  e  H  H  e  l  l  l  e  H  H  e  l  l  o  l  l  e  H

before all 1's (actually, all truthy elements). For our example, this yields the following string array.
['',
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

Z⁻¦ is arguably the most interesting part of this answer. Let's analyze the more straightforward Z1¦ first.
¦ is the sparse quick. It consumes two links from the stack, specifically 1 and Z in this case. First Z is applied to its argument: the string array from before. Z is the zip atom and reads the string array / 2D character array by columns, yielding
['HHHHH',
 'eeee',
 'Hlll',
 'ell',
 'Hlo',
 'el',
 'Hl',
 'e',
 'H'
]

What used to be left side of the input string and the first column of the string array now becomes the first string.
Now ¦ peeks at 1 and finds a single index: 1. Thus the first string in the original string array is replaced with the first string in the return value of Z; strings at other indices remain unaffected.
['HHHHH',
 'H',
 'HeH',
 'HeleH',
 'HellleH',
 'HellolleH'
]

Let's call this array A.
We used Z⁻¦ instead of Z1¦, but this makes no difference: ⁻ compares the string array with the input string for inequality, yielding 1 since they're not equal. The difference between the two is that Z⁻¦ is dyadic because ⁻ is, allowing us to write œṗZ⁻¦ instead of œṗ¹Z1¦. This is because a dyad (œṗ) followed by a monad (œṗ¹Z1¦) is a fork (the monad is applied to the chain's argument / the input string, and the returned value is passed as the right argument to œṗ), while a dyad followed by another dyad (or at the end of the chain) is a hook, i.e., its right argument is the chain's argument.
All that's left to do is check for palindromicness. µ begins a new (monadic) chain who's argument is A. The upend atom U reverses all strings in A (but not A itself), then ⁼ compares the result with A for equality. The returned Boolean 1 indicates a fully-palindromic triangle; other strings would return 0.

I really should learn how to read Jelly. (Explanation, please?)

I've edited my answer.

Japt, 25 21 17 bytes
Saved 2 bytes thanks to @obarakon
ò@°T ¬v1
pUmg)eêP

Test it online!
How it works
 ò@  ° T ¬ v1   // Implicit: U = input string, T = 0
UòXY{++T q v1}  // First line; reset U to the result of this line.
UòXY{        }  // Partition U at indices where
     ++T q      //   the square root of T incremented
           v1   //   is divisible by 1.
                // This breaks U at square indices, giving rows of 1, 3, 5, ... chars.
 pUmg)eêP
UpUmg)eêP
  Umg           // Take the first char of every item of U.
Up   )          // Append this to U.
      e         // Check that every item in the resulting array
       êP       // is a palindrome.
                // Implicit: output result of last expression

Note that we don't need to check both sides; if the sides are not the same, At least one of the rows is not a palindrome.

It this multiline thing a new feature of Japt?

@Luke Yes, I just added it Tuesday. This is my first chance to show it off :-)

Never mind my golfing tip. It simply check whether every line was palindromic, which also happened to give correct results...

05AB1E, 18 bytes
gÅÉ£õÜÐíQs€¬āÈÏÂQ*

Uses the 05AB1E encoding. Try it online!

You can save one byte by modifying it slightly gÅÉ£ÐíQs€¬āÈÏJÂQ*

gÅÉ£ you sly fox... I underestimate those list-commands.py

Jelly, 18 16 bytes
J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ

Try it online!
Thanks to Jonathan Allan for trivial but not so obvious -2 byte savings.

Use my triangle construction and save a byte: JÆ²0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ

...in fact combine that idea with the untruth and save another byte, since partitioning will "zip shortest": J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ

@JonathanAllan Umm...why do I need to ½ at all? Now J makes more sense...

JavaScript (ES6), 112 bytes
f=(s,n=1,t='',u='',g=([...a])=>''+a==a.reverse())=>s?g(s.slice(0,n))&f(s.slice(n),n+2,t+s[0],u+s[n-1]):g(t)&g(u)

t and u collect the sides so that they can be tested at the end.

Java 8, 358 301 bytes
import java.util.*;s->{List<String>l=new Stack();for(int i=0,p=1,t=1;p<=s.length();p+=t+=2)l.add(s.substring(i,i=p));String a="",b=a;for(String q:l){a+=q.charAt(0);b+=q.charAt(q.length()-1);}return p(a)&p(b)&p(l.get(l.size()-1));}boolean p(String s){return s.equals(new StringBuffer(s).reverse()+"");}

Input is a String, output is a boolean.
Explanation:
Try it here.
import java.util.*;               // Required import for List and Stack

s->{                              // Method (1) with String parameter and boolean return-type
  List<String>l=new Stack();      //  Create a String-list
  for(int i=0,p=1,t=1;            //  Initialize some index/counter integers
      p<=s.length();              //  Loop (1) over the String in sections
      p+=t+=2)                    //    And increase `p` like this after every iteration: 1,4,9,16,25,etc.
    l.add(s.substring(i,i=p));    //   And add a substring-section to the list (0,1 -> 1,4 -> 4,9 -> 9,16 -> etc.)
                                  //  End of loop (1) (implicit / single-line body)
  String a="",b=a;                //  Two temp Strings
  for(String q:l){                //  Loop (2) over the list
    a+=q.charAt(0);               //   And append the first character to String `a`
    b+=q.charAt(q.length()-1);    //   And the last character to String `b`
  }                               //  End of loop (2)
  return p(a)                     //  Return if String `a` is a palindrome
        &p(b)                     //   as well as String `b`
        &p(l.get(l.size()-1));    //   as well as the last String in the list
}                                 // End of method (1)

boolean p(String s){              // Method (2) with String parameter and boolean return-type
  return s.equals(new StringBuffer(s).reverse()+"");
                                  //  Return if this String is a palindrome
}                                 // End of method (2)

C#, 184 bytes
using System.Linq;
b=a=>string.Concat(a.Reverse())==a
f=>{string c=f[0]+"",d=c,e="";for(int i=1,k=1,s=f.Length;i<s;)
{c+=f[i];d+=f[(i+=k+=2)-1];e=f.Substring(s-k);}return b(c)&b(d)&b(e);}

Thought the solution was looking good until I got to the palindrome part
Ungolfed version:
Func<string, bool> b = a => string.Concat(a.Reverse()) == a;
        Func<string, bool> func = f => {

            string c = f[0] + "", d = c, e = "";

            for (int i = 1, k = 1, s = f.Length; i < s;) {
                c += f[i];
                d += f[(i += k += 2) - 1];
                e = f.Substring(s - k);
            }

            return b(c) & b(d) & b(e);
        };

Can you move e=.. into the for loop line to save a byte? There's no need to count the newlines into the byte count so I'm assuming you're not.

No i'm not counting newlines, I can't move the e into the loop cause I need it in the return statement.

I meant like this ....; i < s;e = f.Substring(s - k)){c+=....

Java, 136 bytes
l->{for(int i=0,j,k=1;i<l.size();i=j,k+=2)if(!l.subList(i,j=i+k).equals(l.subList(i,j).asReversed().toList()))return false;return true;}

Uses a MutableList<Character> from Eclipse collections
Function<MutableList<Character>, Boolean> func = l->{
   for(int i=0,j,k=1;i<l.size();i=j,k+=2)  // `i` is the start index, `j` is the end index, `k` increments by 2
       if(!l.subList(i,j=i+k).equals( //Check that the first partition equals
           l.subList(i,j).asReversed().toList())  // The same sublist reversed
       )
       return false;
   return true;
};

Jelly,  20  21 bytes
+2 bytes - I released buggy code :(
-1 byte - moved from moulding like odd integers to partitioning at square indexes
JÆ²0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ

A monadic link accepting a list of characters and returning 1 (Truthy) or 0 (Falsey).
Note: this uses the part of the specification that limits the input to a square length.
Try it online! or see the test suite.
This may be simplified to 17 bytes by noting that if all rows are palindromes only one "side" needs checking (JÆ²0;œṗ⁸ZḢ$ṭ$ŒḂ€Ạ), however Erik the Outgolfer already noticed this fact and used it in their answer so I have given the triangle construction method to them saving a byte there.
Additionally, that may in turn be improved to 16 bytes by noting that partitioning at truthy indexes does not mind if there is excess in the left argument (J²‘Ṭœṗ⁸ZḢ$ṭ$ŒḂ€Ạ).
How?
JÆ²0;œṗµ2BịÐ€⁸Z;⁸ŒḂ€Ạ - Link: list, a      e.g. "abcbazxza"
J                     - range of length of a  = [1,2,3,4,5,6,7,8,9]
 Æ²                   - is square? (vectorises) [1,0,0,1,0,0,0,0,1]
   0;                 - prepend a zero        [0,1,0,0,1,0,0,0,0,1]
     œṗ               - partition a at 1s     ["a","bcb","azxza"]
       µ              - monadic chain separation, call that t
        2B            - 2 in binary = [1,0]
             ⁸        - chain's left argument, t
          ịÐ€         - map with index into    ["aa","bb","aa"] (1st and last of each of t)
              Z       - transpose              ["aba","aba"] (left and right "sides" of t)
               ;⁸     - concatenate t          ["aba","aba","a","bcb","azxza"]
                 ŒḂ€  - palindromic? for €ach  [1,1,1,1,1]
                    Ạ - all?                   1

Darn, I was just about to make a Jelly answer. Though technically mine is wrong and like twice as long... nice job :) :P

"noting that partitioning at truthy indexes does not mind if there is excess in the left argument" noticed too before reading.

PHP, 97 bytes
for($t=1;~$s=substr($argn,$i**2,$i++*2+1);$d.=$s[0])$t&=strrev($s)==$s;$t&=strrev($d)==$d;echo$t;

Try it online!

Wait, does this actually test the diagonals? I'm getting false positives for a couple of the test cases ("1202" and "160625052").

@Jenny_mathy now it works

Mathematica, 156 bytes
B=StringTake;Count[PalindromeQ/@Join[A=Table[B[#,{i^2+1,(i+1)^2}],{i,0,(s=Sqrt@StringLength@#)-1}],{StringJoin@Table[B[A[[i]],1],{i,Length@A}]}],True]==s+1&

input

["1101"]

Can't you replace If[<stuff>, True, False] with just <stuff>? And I think And@@(...) is shorter than Count[...,True]==s, which also means you don't have to define s as a variable.

Wait, does this actually test the diagonals? I'm getting false positives for a couple of the test cases ("1202" and "160625052").

all problems fixed

Perl 5, 81 + 1 (-p) = 82 bytes
$a[0].=$1while($a[++$q]=substr$_,0,($#i+=2),'')=~/(.)/;$\||=$_ ne reverse for@a}{

Try it online!
Outputs undef (i.e., blank, null) for true, any number for false

Python 2, 128 118 115 bytes
def f(s):
 w=1;l=r='';b=[]
 while s:l+=s[0];r+=s[w-1];b+=[s[:w]];s=s[w:];w+=2
 print all(d==d[::-1]for d in[l,r]+b)

Try it online!

Excel VBA, 87 Bytes
Anonymous VBE immediate window function that takes input from cell [A1] and outputs to the VBE immediate window
k=1:For i=1To[Len(A1)^.5]:s=Mid([A1],j+1,i*2-1):j=j+i*2-1:k=k*(s=StrReverse(s)):Next:?k

APL (Dyalog Extended), 38 bytes
{(⌽¨≡⊢)(⊢,⊢/¨,⍥⊂⊃¨)⍵⊆⍨w⍴∊⍴⍨¨1+2×⍳w←≢⍵}

Try it online!
The cuts are of size 1,3,5,7..., so that is used with ⊆ to get the appropriate array.
Requires ⎕IO←0 for zero indexing.
Shortened with a lot of help from Marshall and dzaima.
Explanation
{(⌽¨≡⊢)(⊢,⊢/¨,⍥⊂⊃¨)⍵⊆⍨w⍴∊⍴⍨¨1+2×⍳w←≢⍵}
                                   ≢⍵  length of the string
                                 w←    assign to var w
                                ⍳      range from 0..length-1
                            1+2×       convert each to 2n+1 (odd numbers)
                         ⍴⍨¨           replicate each element times itself
                        ∊              flatten that
                      w⍴               reshape to string's length
                   ⍵⊆⍨                 partition the string based on that
       (⊢,⊢/¨,⍥⊂⊃¨)                    Train:
       (⊢,        )                    concatenate the partition with:
       (  ⊢/¨     )                    last character of each partition
       (        ⊃¨)                    first character of each partition
       (      ⍥⊂  )                    both enclosed into two strings
  ⌽¨                                   do the reverses of each part
    ≡                                  match
     ⊢                                 the parts?