text:
That's one odd mountain!
Inspired by Display a chain of little mountains with an odd number on the top of it! by @sygmei.
Why have a chain of mountains when you can have one massive one?
Make a program that takes an input number and prints a mountain with every odd number up to the input number.
(Where "south west" means directly below and to the left, and "south east" means directly below and to the right)
Every number will have a / south west of it, and a \ south east. It starts from 1 at the top, and the next number will go south west of a / or south east of a \. The next number will go in the line closest to the top and to the left most possible.
For a multidigit number, just the 1st digit needs to be in the right place with the other digits directly after, and only the first digit should have \ and / coming out from it.
The mountain up to 1 or 2 is just:
 1
/ \

A mountain up to 3 or 4 is just:
   1
  / \
 3
/ \

For 25 or 26:
         1
        / \
       3   5
      / \ / \
     7   9   11
    / \ / \ / \
   13  15  17  19
  / \ / \ / \ / \
 21  23  25
/ \ / \ / \

Last two lines where the input is 121:
 111 113 115 117 119 121
/ \ / \ / \ / \ / \ / \

And the last two lines where the input is 1019:
 993 995 997 999 1001100310051007100910111013101510171019
/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \

You may assume that the input will be greater than 0 and less than 10001 (exclusive).
Trailing spaces are OK, and extra leading spaces are alright as long as there is the same on all lines.
This is code-golf, so the shortest program in bytes wins.
An ungolfed answer to this can be found online here (In Python on repl.it) if you need more test cases.

If the input is less than 101, then why do you have a 121 testcase?

@LegionMammal978 I meant 10001, fixed now. Thank you!

Harder than the original one, I'll give it a try :D

05AB1E, 54 52 47 46 bytes
ÅÉ¹L£D€g__ÏRv"/ \ "yg×N·©úˆyvy4yg-ð×}J®>úˆ}¯R»

Try it online!
Explanation
                                                # implicit input n
ÅÉ                                              # push a list of uneven numbers up to input
  ¹L£                                           # divide into sublists of length 1,2,3...n
     D€g__Ï                                     # remove empty sublists
           R                                    # reverse list
            v                                   # for each sublist
             "/ \ "                             # push the string "/ \ "
                   yg×                          # repeat it len(sublist) times
                      N·©ú                      # prepend (sublist index)*2 spaces
                          ˆ                     # add to global list
                           yv                   # for each number in sublist
                             y4yg-ð×            # prepend spaces until length is 4
                                    }           # end inner loop
                                     J          # join to string
                                      ®>ú       # prepend (sublist index)*2+1 spaces
                                         ˆ      # add to global list
                                          }     # end outer loop
                                           ¯    # push global list
                                            R   # reverse it
                                             »  # join rows by space and columns by newline
                                                # implicitly print

I could have saved 5 bytes with ÅÉ¹L£D€g__ÏRv"/ \ "yg×N·©úˆy4jJðÛ®>úˆ}¯R» if only I'd pushed that bugfix for j I wrote several weeks ago :/

Batch, 335 bytes
@echo off
set i=
set/ac=w=0
:l
set i=  %i%
set/aw+=2,c+=w
if %c% lss %1 goto l
set s=
set t=
set/ac=w=1
for /l %%a in (1,2,%1) do call:c %%a
echo  %s%
echo%t%
exit/b
:c
if not %c%==0 goto g
echo%i%%s%
set i=%i:~2%
echo%i%%t%
set s=
set t=
set/aw+=1,c=w
:g
set n=%1   (three trailing spaces)
set s=%s%%n:~0,4%
set t=%t% / \
set/ac-=1

@Artyer I'm pretty sure cmd /Q /C file.bat counts 3 extra bytes, but it's still better than @echo off. You should post that to the Batch tips question.

Python 2, 160 149 143 bytes
Thanks TFeld for saving 11 bytes and Artyer for saving 6 bytes
x=range(1,input()+1,2);y=[];i=1
while x:y+=[''.join('%-4d'%j for j in x[:i]),'/ \ '*len(x[:i])];x=x[i:];i+=1
while y:print' '*~-len(y)+y.pop(0)

You can do i=len(y) and for l in y:print' '*i+l;i-=1 instead of for i,l in enumerate(y):print(len(y)-i-1)*' '+l for -10 bytes

Also I think you can change \\  to \  since it is before a space

You can change the last 2 lines to while y:print' '*-~len(y)+y.pop(0). It saves 3 bytes.

And ''.join('%4d'%j for j in x[:i]) on the second line

@Artyer but that would break (hard) the alignment :c

@Rod Oops... I meant %-4d to left justify it by 4.

@Artyer woah, this negative value to left justify is new to me :D, nice trick

Perl, 134
133 bytes + 1 for -p option
 $l="/ \\ ";$t=" ";while($c++<$_) {$t.=sprintf'%-4d',$c++;$v.=$l;if ($i++>=$j){$t=~s/^/  /gm;$t.="
  $v
 ";$i=$v="";$j++}}$_="$t
$v";

Formatted version (original golfed version uses real "new lines" instead of \n)
$l="/ \\ ";
$t=" ";
while($c++<$_) {
   $t.=sprintf'%-4d',$c++;
   $v.=$l;
   if ($i++>=$j){
      $t=~s/^/  /gm;
      $t.="\n  $v\n ";
      $i=$v="";
      $j++
   }
}
$_="$t\n$v";

Bash, 425 bytes
f() { k=0; o=""; l=1; for (( c=1; c<=$1; c++ )); do o="$o$c "; let c++ k++; if [ $l -eq $k ]; then o=$o"\n"; k=0; let l++; fi; done; s=$[$(echo -e $o | wc -l)*2-1]; p() { for c in $(seq $1); do echo -n " "; done }; IFS=$'\n'; for n in $(echo -e $o); do unset IFS; p $s; let s--; for w in $n; do echo -n "$w"; p $[4-${#w}]; done; echo; p $s; for c in $(seq $(echo $n|wc -w)); do echo -n "/ \ "; done; echo; let s-- j++; done }

Formatted:
l=1
k=0
o=""
for (( c=1; c<=$1; c++ ))
do
        o="$o$c "
        let c++ k++
        if [ $l -eq $k ]
        then
                o=$o"\n"
                k=0
                let l++
        fi
done
s=$[$(echo -e $o | wc -l)*2-1]
p() {
        for c in $(seq $1)
        do
                echo -n " "
        done
}
IFS=$'\n'
for n in $(echo -e $o)
do
        unset IFS
        p $s
        let s--
        for w in $n
        do
                echo -n "$w"
                p $[4-${#w}]
        done
        echo
        p $s
        for c in $(seq $(echo $n|wc -w))
                do echo -n "/ \ "
        done
        echo
        let s-- j++
done


text:
It's Your Turn ! (Renju)
EDITS:

Added link to the plain-text (multiple strings) test data
Added BLANK,EDGE and TIE2 test cases (see Test Data section) (11/25)
Updated the JSON test cases (some lines were ill-formatted) (11/24)

Renju match gone bad ! (well, technically these guys are playing Go, but who cares) Wikisource
TL;DR
Take a 15x15 grid of characters (made of '.', '0' and '*'), as an input, replace one of '.' s with '*',
in such a way that an unbroken horizontal, vertical or diagonal line of exactly five '*' chars is formed.
           *        *    *
           *       *      *
 ******    *      *        *
           *     *          *
           *    *            *

Output the coordinates of your '*', or string - 'T' if there is no solution.
Creating a line of more than 5 '*' long (directly or indirectly) is not allowed, this is called an "overline".
Some examples of overlines:
 ****.** - replacing . with * will result in a horizontal overline

 *.***  - replacing . with * will result in a diagonal overline
   *
    *
     *
      *
       *

Full Version
Abstract
Renju - is an abstract strategy board game (a simpler version of it is also known as Gomoku).
The game is played with black and white stones on a 15×15 gridded Go board.
Black plays first if white did not just win, and players alternate in placing a stone of their color on an empty intersection.
The winner is the first player to get an unbroken row of five stones horizontally, vertically, or diagonally.
Computer search by L. Victor Allis has shown that on a 15×15 board, black wins with perfect play.
This applies regardless of whether overlines are considered as wins.
Renju eliminates the "Perfect Win" situation in Gomoku by adding special conditions for the first player (Black).
(c) Wikipedia
Objective
Consider you are a part of a Renju match, you are playing black, and there is just one turn left for you to win.
Take the current board position as an input, identify one of the winning moves (if there is one), and output it (see below for the data formats and restrictions).
Sample input board:
    A B C D E F G H J K L M N O P       . - vacant spot (intersection)
 15 . . . . . . . . . . . . . . . 15    0 - white stone
 14 . . . . . . . . . . . . . . . 14    * - black stone
 13 . . . . . . . . . . . . . . . 13    X - the winning move
 12 . . . . . . . . . . . . . . . 12
 11 . . . . . . . . . . . . . . . 11
 10 . . . . . . . 0 . . . . . . . 10
  9 . . . . . . . * . . . . . . .  9
  8 . . . . . . . * . . . . . . .  8
  7 . . . 0 . . . * . . . . . . .  7
  6 . . . 0 0 . . * . . . . . . .  6
  5 . . . . . . . X . . . . . . .  5
  4 . . . . . . . . . . . . . . .  4
  3 . . . . . . . . . . . . . . .  3
  2 . . . . . . . . . . . . . . .  2
  1 . . . . . . . . . . . . . . .  1
    A B C D E F G H J K L M N O P

(axis labels are for illustration purposes only and are not part of the input)
Sample output:
H5

Rules
For the purpose of this challenge, only the following subset of Renju rules apply:

You can place your stone on any vacant intersection (spot);
Player who achieved an unbroken row of five stones horizontally, vertically, or diagonally, wins;
Black (you) may not make a move which will result (directly or indirectly) in creation of an "overline" i.e. six or more black stones in a row.

Data Formats
Input data is a 15x15 grid of characters (".","*","0"]), ASCII-encoded, in any acceptable format, e.g. a two-dimensional character array or a newline separated set of strings e.t.c.
You may not however modify the input alphabet in any way.
Output data is a string, denoting the alpha-numeric board position, as illustrated by the sample board above.
Note that original horizontal axis numeration (A..P), does not include 'I', you MAY use 'A..O' instead, w/o penalty.
If there is no winning move available, output "T" instead.
Scoring
This is code-golf, so the shortest answer in bytes wins !
Some Tests Cases
Tie
Input:
    A B C D E F G H J K L M N O P
 15 . . . . . . . . . . . . . . . 15
 14 . . . . . . . . . . . . . . . 14
 13 . . . . . . . . . . . . . . . 13
 12 . . . . . . . . . . . . . . . 12
 11 . . . . . . . . . . . . . . . 11
 10 . . . . . . . 0 . . . . . . . 10
  9 . . . . . . . * . . . . . . .  9
  8 . . . . . . . * . . . . . . .  8
  7 . . . 0 . . . * . . . . . . .  7
  6 . . . 0 0 . . * . . . . . . .  6
  5 . . . . . . . Z . . . . . . .  5
  4 . . . . . . . * . . . . . . .  4
  3 . . . . . . . . . . . . . . .  3
  2 . . . . . . . . . . . . . . .  2
  1 . . . . . . . . . . . . . . .  1
    A B C D E F G H J K L M N O P

Output:
 "T", the only "winning move" is H5 (denoted with "Z"), but that would create an overline H4-H9

Overline
Input:
    A B C D E F G H J K L M N O P
 15 . . . . . . . . . . . . . . . 15
 14 . . . . . . . . . . . . . . . 14
 13 . . . . . . . . . . . . . . . 13
 12 . . . . . . . . . . . . . . . 12
 11 . . . . . . . . . . . . . . . 11
 10 . . . . . . . . . . . . . . . 10
  9 . . . . . 0 . . . . 0 . . . .  9
  8 . . 0 . . . . . . * 0 0 . . .  8
  7 . . 0 . . . . . * . . 0 . . .  7
  6 . . 0 * . 0 . * . . 0 0 . . .  6
  5 . . 0 . * . * X * * * . . . .  5
  4 . . . . . Z . . . . . . . . .  4
  3 . . . . . . * . . . . . . . .  3
  2 . . . . . . . * . . . . . . .  2
  1 . . . . . . . . * . . . . . .  1
    A B C D E F G H J K L M N O P

Output:
 "H5", the other possible winning move is "F4", but that would result in J1-D6 diagonal overline.

Multiple winning moves
Input:
    A B C D E F G H J K L M N O P
 15 . * * * . . * * * . . . . . . 15
 14 . * . . . . . * . . * . . . . 14
 13 . * . . . . . . . . . . . * . 13
 12 . . . . . 0 0 0 0 0 0 0 . * . 12
 11 . . . . 0 . . X . . . 0 . * * 11
 10 . . . . 0 X * * * * X 0 . . * 10
  9 . . . . 0 . . * . . . 0 . * *  9
  8 . . . . 0 0 . * . . 0 0 . * .  8
  7 . . . . . 0 . * . . 0 . . * .  7
  6 . . . . . 0 . X . . 0 . . . .  6
  5 . . . . . 0 0 0 0 0 0 . . . *  5
  4 . . . . . . . . . . . . . . .  4
  3 . . . . . . . . . . . . . . .  3
  2 . . . . . . . . . . . . . . .  2
  1 . . . . . . . . . . . . . . .  1
    A B C D E F G H J K L M N O P

Output:
"H6" or "H11" or "F10" or "L10" (one of)

Test Data
The test data in a bit more machine-friendly form (JSON) is available HERE
Added BLANK,EDGE and TIE2 test cases: UPDATED TEST SUITE
You can use the following JS snippet to convert it to multiline strings, if necessary:
for(B in RENJU) { console.log(B+"\n"+RENJU[B].map(l=>l.join``).join`\n`); }

or just download them here

I'd recommend giving the test cases as they'd appear to the program, not in the form that's clearest for a human to see. That will make it much easier to test submissions.

@ais523 - I've posted JSON-formatted input data for the test cases to the Pastebin (see my update)

Jesus George! Can we please have columns from A to O instead of A to H and J to P!?!

@Titus, sure, I'll update the rules now to allow for this

Is it not promised that black and white are same amount?

Is it not promised that black and white are same amount?

It is not guaranteed.

JavaScript (ES6), 161
Input as multiline string.
Note: could save 1 byte using A..O instead of A..P
s=>[...s].some((q,p)=>([1,15,16,17].map(d=>x=(q=((r=p=>s[p-d]=='*'?r(p-d):p)(a=p)-r(p,d=-d))/d)>x?q:x,x=q!='.'&&5),x==4))?'ABCDEFGHJKLMNOP'[a%16]+(15-(a>>4)):'T'

Less golfed
s=>
[...s].some(
  (q, p) => // execute for each character q in position p, stop when true
  (
    [1, 15, 16, 17].map( // offset for 4 directions
      d => // for each direction d
      (
        // recursive function to find adjacent '*' in direction -d
        r = p => s[p-d] == '*' ? r(p-d) : p,
        // I need 4 adjacent '*' in at least 1 direction
        // but no more in any direction
        a = p, // current position in a, could be the answer
        q = r(p), // look back (reuse variable q)
        d = -d, q -= r(p), // then look forward
        q = q/d, // number of '*' in q
        x = q > x ? q : x // keep the max in any direction
      ),
      // init x to 0 if the current position is empty
      // else init x to 5, so it will be not valid in any case (too big)
      x = q !='.' && 5
    ),
    // if 4 '*' found, exit the loop
    x==4
  )
) // return true if solution found (solution in a)
? 'ABCDEFGHJKLMNOP'[a % 16] + (15 - ( a >> 4))
: 'T'

Test

F=
s=>[...s].some((q,p)=>([1,15,16,17].map(d=>x=(q=((r=p=>s[p-d]=='*'?r(p-d):p)(a=p)-r(p,d=-d))/d)>x?q:x,x=q!='.'&&5),x==4))?'ABCDEFGHJKLMNOP'[a%16]+(15-(a>>4)):'T'

out=x=>O.textContent+=x+'\n\n'

;renju = {
"BLANK":"...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............\n...............",
"EDGE":"...........****\n.0.............\n.0.............\n.0.............\n.00000.........\n.....0.........\n.....0.........\n.....0.........\n.....0.........\n...............\n...............\n.....*........*\n....*.........*\n...*..........*\n..*...........*",
"TIE":"...............\n...............\n...............\n...............\n...............\n.......0.......\n.......*.......\n.......*.......\n...0...*.......\n...00..*.......\n...............\n.......*.......\n...............\n...............\n...............",
"TIE2":"...............\n.....0****000..\n...............\n.*0............\n..*.0..........\n..0*...0.......\n.......*.......\n.......*.......\n.......*.00....\n.......*.......\n.......0.......\n...............\n...............\n...............\n...............",
"OVERLINE":"...............\n...............\n...............\n...............\n...............\n...............\n.....0....0....\n..0......*00...\n..0.....*..0...\n..0*.0.*..00...\n..0.*.*.***....\n...............\n......*........\n.......*.......\n........*......",
"MULTIPLE":"...............\n...............\n...............\n.....0000000...\n....0......0...\n....0.****.0...\n....0..*...0...\n....00.*..00...\n.....0.*..0....\n.....0....0....\n.....000000....\n...............\n...............\n...............\n..............."
};

for(k in renju) {
  var r=F(renju[k])
  out(k+' '+r+'\n   ABCDEFGHJKLMNOP\n'+renju[k].split`\n`.map((v,i)=>(115-i+' ').slice(1)+v).join`\n`)
}

So you need the parens around 15-(a>>4)?

@ZacharyT yes. String + number - number === NaN

s=>[...s].some((q,p)=>([1,15,16,17].map(d=>x=(q=((r=p=>s[p-d]=='*'&&1+r(p-d))(a=p)+r(p,d=-d)))>x?q:x,x=q!='.'&&5),x==4))?'ABCDEFGHJKLMNOP'[a%16]+(15-(a>>4)):'T'? (1B save)

s=>[...s].some((q,p)=>([1,15,16,17].map(d=>x=(q=((r=p=>s[p-d]=='*'&&.1+r(p-d))(a=p)+r(p,d=-d)))>x?q:x,x=q!='.'),x==.4))?'ABCDEFGHJKLMNOP'[a%16]+(15-(a>>4)):'T' add 0.1 instead of 1 to omit &&5

PHP, 205 203 201 246 257 238 bytes
requires PHP<7.1 (relies on empty negative string offsets)
third approach, finally really complete, and I think I have left nothing to golf.
for($p=240;(!$l|$o)&&$p--;)for($k=4,$l=$o=0;$k--;$l|=preg_match("#\*{5}#",$s),$o+=preg_match("#\*{6}#",$s))for($s="*",$i=0;"."==($g=$argv[1])[$p]&&$i++<5;)$s=$g[$p-$i*$d=!$k?:$k+14].$s.$g[$p+$d*$i];echo$p<0?T:chr(65+$p%16).(15-($p/16|0));

takes multiline string with Linux style linebreaks (1 character) from command line argument.
For 2 character linebreak: add one each to 14, 15 and 16 and replace 240 with 255.
Run with -r.
breakdown
for($p=240;(!$l|$o)&&$p--;)     // loop through positions while (no line or has overlines)
    for($k=4,$l=$o=0;$k--;          // loop through four directions
        $l|=preg_match("#\*{5}#",$s),   // post condition: set flag for line
        $o+=preg_match("#\*{6}#",$s)    // and count overlines
        )
        for($s="*",                     // assume asterisk at current position
            $i=0;
            "."==($g=$argv[1])[$p]      // if character is "."
            &&$i++<5;)                  // look 5 fields in +/- direction:
            $s=$g[$p-$i*
                $d=!$k?:$k+14               // map [3,2,1,0] to offset [17,16,15,1]
            ].$s.$g[$p+$d*$i];              // add characters
                                // output
echo$p<0?T:chr(65+$p%16).(15-($p/16|0));

uses columns A..O. For A..H+J..P, append +($p/8&1) to the chr parameter.

Nice, but does this work for "Tie" and "Overline" test cases ? (I can not recognize any overline detection code)

@zeppelin: At the top or bottom of the board, empty strings will be appended to $s and strlen will never hit 5. And if $s contains newline or 0, the preg_match will fail.

Well, I meant the "overline", as defined by the rules, i.e. a string 6 or more '*' long,  within the board (take a look at "Tie" and "Overline" test case illustrations).

@zeppelin: Oh I missed that one. I guess that will require some editing. Probably easier with the other approach that I´m currently working on.

Jelly, 46 bytes
ṭ³Ṛœẹ”*¤ŒṬµ;Z;ŒD;ŒdŒrẎḢƇṀf5
Ṛœẹ”.ÇƇḢṚịØA,ɗ/ȯ”T

Try it online! (OVERLINE testcase)
44 bytes if you allow indexing the rows from top to bottom or taking them in reverse order.
TIE testcase
MULTIPLE testcase
Explanation
ṭ³Ṛœẹ”*¤ŒṬµ;Z;ŒD;ŒdŒrẎḢƇṀf5   Auxiliary monadic link, takes a pair of coordinates
ṭ                             Append the pair to
       ¤                      (
 ³                              The input
  Ṛ                             Reverse
   œẹ”*                         Find all coordinates of "*"
       ¤                      )
        ŒṬ                    Create a matrix with 1s at these coordinates and 0s everywhere else
          µ                   With this matrix:
           ;                  Join with
            Z                   the columns
             ;                Join with
              ŒD                diagonals
                ;             Join with
                 Œd             antidiagonals
                   Œr         Run-length encode each subarray into pairs of [item, length]
                     Ẏ        Shallow flatten
                       Ƈ      Find pairs where
                      Ḣ         the first item is truthy (and remove the item)
                        Ṁ     Maximum (by the length, since the item has been removed)
                         f5   Filter 5. This creates [5] (truthy) if the longest run has length exactly 5, and [] (falsy) otherwise.

Ṛœẹ”.ÇƇḢṚịØA,ɗ/ȯ”T   Main monadic link, takes a list of strings
Ṛ                    Reverse
 œẹ”.                Find all coordinates of "."
      Ƈ              Find those for which
     Ç                 the auxiliary link gives a truthy result
       Ḣ             First item, or 0 if the list is empty
        Ṛ            Reverse
              /      Fold under the following operation
             ɗ       (
         ị             Index the first item into
          ØA             the uppercase alphabet
            ,          Pair with the second item
             ɗ       )
               ȯ     Logical OR with
                ”T   "T"

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:
Turn this array into a matrix
Take a non-nested array as input. Turn it into a matrix by using the following method:
Let's say my array is [1, 2, 3, 4, 5]
First, I repeat that array 5 times: (the length)
[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

Then, I read it along the diagonals:
[[1],
 [2, 1],
 [3, 2, 1],
 [4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2],
 [5, 4, 3],
 [5, 4],
 [5]]

I flatten this array and split it into pieces of five (the length):
[[1, 2, 1, 3, 2],
 [1, 4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2, 5],
 [4, 3, 5, 4, 5]]

This is code golf. Fewest bytes wins.

Next time, please CAPITALIZE things.

How does this work if the original array has a length other than 5?

@ais523 I'm assumming its the same thing, you just replace 'five' with the length

Can we assume the numbers always be positive integers?

luis mendo- yes

oliver- yes that is correct

@JohnCena You shouldn't accept the first answer, you need to give the post some time to gain traction and some more answers.

How do you get that triangle by reading along the diagonals?

@PeterTaylor They are anti-diagonals, in a matrix sense

05AB1E, 13 bytes
.p¹.sR¦«í˜¹gä

Try it online!
Explanation:
                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print

don't you need to print it

and how did you request input

@JohnCena 05AB1E uses implicit input and output, so at the end, it will automatically print. At the start, there is nothing on the stack, so it asks for input.

Many of these golfing languages, such as 05AB1E, have built in default rules for requesting input and producing output, so that the programmer doesn't have to waste bytes on them.

The Output does not really match the desired output. It is no matrix and the numbers don't match.

@KarlNapf Oops, one sec

Well, it is a matrix, but the numbers are not correct (or tryitonline.net computes wrong)

You can fix the output by replacing «˜ with «í˜.

Jelly, 11 bytes
WẋLŒDUṙLFsL

Try it online!
Explanation
               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)

Hmm when I tried it with L it did weird stuff, hence I used the register :/ I just tried it again and it works... basically the same so I guess I shall just remove mine.

Of course Jelly has "diagonals" built in.... :)

Python 2, 105 96 bytes
-1 and -4 and -4 bytes thanks to Flp.Tkc
a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

The for loop adds the items like in the description, the real magic happens in the zip which is from here

sorry for the spam, but now that R is only used once, you can just put it there directly :P

@Flp.Tkc no problem, i am happy :)

JavaScript (ES6) 100 101 105
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

Less golfed

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v)
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

Test

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()
<input id=I value='1 2 3 4 5' oninput='update()'>

Wow, that's a very clever way to avoid the return. You should post a tip about that in the ES6 tip thread.

@ETHproductions it has a very narrow scope. Most of times, eval is better.

@ETHproductions indeed eval is better even this time :(

@ETHproductions I posted the tip, even if it's rarely useful, just in case

MATL, 17 bytes
!Gg*tRwZRhPXzGne!

Try it online!
How it works
The following explanation uses input [1 2 3 4 5] as an example. To visualize the intermediate results, insert % (comment symbol) after any statement in the code.
Note that ; is the row separator for matrices. So [1 2] is a row vector, [1; 2] is a column vector, and [1 0; 0 1] is the 2×2 identity matrix.
!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]

J, 14 bytes
#($$&;</.)@#,:

Attempt This Online!

#...#,: Duplicate the input n times, where n is the input length.  We require ,: to make the duplication work at the "row level" rather than the element level.
</. Box every diagonal of the resulting n by n matrix.  J's /. does the heavy lifting here.
$$&; Unbox that result ; into a single list and reshape it $ to the shape of duplicated input $.

Uiua, 12 bytes
⊏⍜♭⍏⊞+.⊃⇡▽⧻.

Try it online!
⊏⍜♭⍏⊞+.⊃⇡▽⧻.   input: vector V of length N
               ⧻.    keep V and push N
           ⊃⇡▽     consume both and push [0..N-1], V cycled N times
       ⊞+.          self outer product of range by addition
 ⍜♭⍏              flatten, replace the array with its sorting order, and
                     put it back into the same sized matrix
⊏                   for each number in the matrix, select the item at that index
                    in "V cycled N times"

The above is a slightly golfuscated version of the code below:
Uiua, 14 bytes
⍜∩♭'⊏⍏⊞+.⍏.↯⧻.

Try it online!
⍜∩♭'⊏⍏⊞+.⍏.↯⧻.    input: a vector of integers of length N
               ↯⧻.     make the input a matrix by copying the input N times -> X
             ⍏         rise; sorting order of the rows (same as range N)
         ⊞+.           self outer product by addition -> Y
⍜∩♭          .        operate on X and Y flattened and assemble back..
    '⊏⍏                reorder elements of X by sorted order of elements of Y

JavaScript (ES6), 116 bytes
a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

Well, it's a start...

R, 84 bytes
t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

Reads input from stdin and outputs/returns an R-matrix.
reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

Explained
The most interesting aspect about this answer is how the diagonals are retrieved. In general an object can be split up using the split function if supplied an object containing factors upon which the object is split into. To create these factors we can use col and row which return a matrix containing the column and row indices respectively. By taking the differences: row(m)-col(m) we get a matrix like:
     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

in which each diagonal is uniquely identified. We can now split based on this matrix and turn it into a ragged list by applying split:
$`-4`
[1] 1
$`-3`
[1] 2 1
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

(Note how the name of each vector correspond to the diagonal values in the matrix above).
The last step is just to flatten and turn it into a matrix of the form:
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    1    3    2
[2,]    1    4    3    2    1
[3,]    5    4    3    2    1
[4,]    5    4    3    2    5
[5,]    4    3    5    4    5

Ruby, 110 bytes
n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a

      #=> [[1, 2, 1, 3, 2],
      #    [1, 4, 3, 2, 1],
      #    [5, 4, 3, 2, 1],
      #    [5, 4, 3, 2, 5],
      #    [4, 3, 5, 4, 5]]

The sort operation may not be required, but the doc for Enumerable#group_by does not guarantee the ordering of values in the hash values (which are arrays), but current versions of Ruby provide the ordering one would expect and the ordering I would need if sort were removed from my code.
The steps are as follows.
n=a.size
  #=> 5
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4]
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]]
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]}
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5]
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

Lastly, f.to_a returns the array shown earlier.

Vyxal, 55 bitsv2, 6.875 bytes
LẋÞ`f?Lẇ

Try it Online!
Bitstring:
0110000101111000101000101100100011000011001101100100000

LẋÞ`f?Lẇ
# implicit input
Lẋ        # repeated [length] times
  Þ`      # antidiagonals
    f?Lẇ  # flatten and wrap in chunks the size of the length

Created with the help of Luminespire.

Vyxal, 52 bits2, 6.5 bytes: `L~ẋÞ`fẇ` (vyncoded)

oh what i was totally trying to do stack manipulation before giving up and just rereading the input

K (ngn/k), 22 bytes
{x@l!s#,/=+/!s:2#l:#x}

Try it online!

With @Bubbler’s idea to use grade becomes {s#x@l!<+/!s:2#l:#x}.

Ruby, 72 bytes
->a,*r{t=[]
a.map{r+=t=[_1]+t}
r+=t while t.pop
[*r.each_slice(a.size)]}

Attempt This Online!

Scala, 154 bytes
Golfed version. Try it online!
a=>{val n=a.size;var L,M=List[Int]();for(i<-0 to n-1){L=L:::a.slice(0,i+1).reverse.toList;M=M:::a.slice(i+1,n).reverse.toList};(L::: M).grouped(n).toList}

Ungolfed version. Try it online!
object Main {
  def main(args: Array[String]): Unit = {
    val a = Array(1, 2, 3, 4, 5)
    val n = a.length
    var L, M = List.empty[Int]

    for (i <- 0 until n) {
      L = L ::: a.slice(0, i+1).reverse.toList
      M = M ::: a.slice(i+1, n).reverse.toList
    }

    val zipped = (L ::: M).grouped(n).toList

    println(zipped)
  }
}

Uiua (0.1.0), 20 bytes
↯~√⧻./⊐⊂≐(□↘)-⇡×2.⧻.

Try it online
Explanation
                  ⧻. # (nondestructively) get array length
             -⇡×2.   # construct a range from len down to -len + 1
        ≐(□↘)        # for each element of the range, drop that many from the array
     /⊐⊂             # join all resulting arrays together
  √⧻.                # get square root of length, suppose we call it N...
↯~                   # ...then this reshapes the array to MxN, where M is inferred

It seems that the output is reversed? Adding ⇌ at the front seems to work. ≐(□↘) can be shortened to ⊐≐↘.

Mathematica 93 Bytes
Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

Here's how I'd ordinarily write this code (109 Bytes):
Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

This matrix plot gives a good idea from the structure due to a sequentially increasing input vector.

Here's the matrix plot with a random input vector. Obviously some structure still exists.

Mathematica, 92 bytes
n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

Unnamed function taking a list as its argument. There might be other structures to such a function, but hopefully I golfed this structure pretty good....
The first part n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]& defines a function n of two arguments: the first is a list of length l, and the second is a function to apply to lists. n applies that function l-1 times to the reversed argument list, saving all the results in its output list. (Defining r and l along the way is just golfing.)
n is called twice on the original list, once with the function being Rest (drop the first element of the list) and once with the function being Most (drop the last element). This produces all the desired sublists, but the whole list is there twice (hence the extra Most) and the first half is there in backwards order (hence the r[...]). Finally, ~ArrayReshape~{l,l} forgets the current list structure and forces it to be an lxl array.

Mathematica, 85 bytes
Literally performing the steps suggested:
(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

My gut says that there should be a clever way to use Part to do this shorter, but every attempt I've made has been longer than 85 bytes.

Husk, 9 8 bytes
CL¹Σ∂RL¹

Try it online!
-1 byte from Zgarb.
Explanation
CL¹Σ∂*L¹;
       ¹  input(appends a ¹ to the end)
        ; enclosed
     *L   repeated length times
    ∂     antidiagonals
   Σ      flattened into a single list
C         cut into pieces of size
 L¹       of the length of the input

Wolfram Language (Mathematica), 60 bytes
Partition[Join@@Reverse[#~Drop~i]~Sum~{i,l=-Tr[1^#],-l},-l]&

Try it online!

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


text:
Make a simplified Tamagotchi/Giga Pet!
Tamagotchi and Giga Pets were small electronic devices which simulated a little virtual pet. This pet had several stats, like health, hunger,  etc.
I recently wrote this example:
import msvcrt,os,sys;d=m=100;h=s=t=p=0;f=10
while 1:
 os.system('cls'if os.name=='nt'else'clear');print("health:",d,"\nhunger:",h,"\nsleep:",s,"\nfood:",f,"\npotions:",p,"\nmoney:",m);t+=1
 if msvcrt.kbhit():
  k=ord(msvcrt.getch())
  if k==102 and h>8 and f:f-=1;h-=9
  if k==115:s=0
  if k==112 and p:p-=1;d+=9
  if k==98 and m>8:m-=9;p+=1
  if k==116 and m>8:m-=9;f+=1
 if t>99:
  t=0;h+=1;s+=1
  if s>80:s=0;h+=9
  if h>80:d-=1
  if d<1:sys.exit(0)
  if d>79:m+=1

This is a bare-bones virtual pet in 467 bytes! I then wondered how well the code golf pros could do, so now, the challenge.
The Challenge
Make a program that tracks 6 stats of a virtual pet, and updates them over time and in response to user input. The stats are: health and money (starting at 100), food (starting at 10), and hunger, sleep, and potions (starting at 0).
The program should update the values in response to the following events:

While the program is receiving no input, it should perform updates at regular intervals (the interval between updates should not be shorter than half a second nor longer than one second). Each update does the following:

Hunger and Sleep each increase by 1.
If Hunger is 80 or above, Health decreases by 1.
If Sleep is 80 or above, it is reset to 0, and Hunger increases by an additional 9.
If Health is 80 or above, Money increases by 1.
If Health is 0, the program exits.

The program must also respond immediately upon the following keypresses by the user (this means that you will need to use a language feature or library that can detect a key being pressed and respond to it immediately, rather than just reading from standard input), performing the following actions:

f: If Hunger is greater than 8 and Food is nonzero, then Food is decreased by 1 and Hunger is decreased by 9.
s: Sleep is reset to 0.
p: If Potions is greater than zero, Potions is decreased by 1 and Health is increased by 9.
b: If Money is greater than 8, then Money is decreased by 9 and Potions are increased by 1.
t: If Money is greater than 8, then Money is decreased by 9, and Food is increased by by 1.

Whenever the values of the stats change, they must be displayed on screen in the form Stat: value. All six stats must be displayed whenever any of them changes; and the stats within a display must be separated either by commas or by newlines.
This challenge follows normal code-golf rules: the shortest program complying with the specification above wins. (Note that as usual, if the language is newer than the competition, the submission must be marked as non-competing.)

You don't say what the starting stats are

I wouldn't allow languages that postdate the challenge, the loophole's closed by default for a reason...

Outputs must be in a "easy to read manner" is ambiguous, and so it "once per-second ish". You should submit challenges to the sandbox to get feedback and improve them before you post to main...

@Flp.Tkc I added it for the reason that maybe someone wants to show off their new language with something other than the standard "Hello, World!".

@ender_scythe new languages are permitted to post anyway as long as they mark their submissions as non-competing...

Okay, I'll do that.

The f button doesn't seem to care if food > 0 according to the spec.

How is this unclear? I wish unclear had more details, because itself is unclear.

In case you weren't aware, we have a sandbox where you can post challenge drafts and get feddback from the community before "going live".

Sandbox doesn't help anymore, as there are answers already.
The people who've marked this as unclear should say why it's unclear, instead of being unclear themselves.

@BlueEyedBeast (and other close voters) I'm also curious as to what is unclear.  The original version had some significant issues, but it seems like the edits fixed that.  At the very least, it was clear enough for Carcigenicate and I to provide submissions.   Share some details about what you find unclear so ender_scythe can improve it.

@Ray as I said in my first comment, you don't initialise the stats. Other closevoters have commented as well

@BlueEyedBeast stats initial values have been added to the spec now

@edc65 I voted to reopen after the edit

C, 424 406 386 357 bytes
#define x(a,b,c)if(*#a==C){if(b>8){c-=9;}Z=0;}
L,M=100,H,S=-1,F=10,P,Z,C;t(){H++;S++;L-=H>79;if(S>79)S=0,H+=9;Z=1/L/2;alarm(1);}main(){nodelay(initscr(),L=M);signal(14,t);for(t(H=S);C=getch();Z=Z||printf("\rhealth: %d,hunger: %d,sleep: %d,food: %d,potions: %d,money: %d\n",L,H,S,F,P,M)){x(s,9,S=9;S)x(p,P+8,P--;L+=18;L)x(f,H,F--;H)x(b,M,P++;M)x(t,M,F++;M)}}

I appreciate the need for raw input and asynchronous updates in the problem spec.  Even though that required some overhead from the ncurses setup and signal handlers, it's nice to have the occasional challenge that (hopefully) won't be automatically won by one of the dedicated golfing languages.
You didn't specify exactly how game over is indicated, so this one perishes with the traditional Tamagotchi death cry of "Floating point exception (core dumped)".
Ungolfed
/* Playing a bit fast and loose with the prototyping rules by omitting these;
 * none of the functions I'm using from them *exactly* match the default
 * prototype of `int f();`
 */
//#include <curses.h>
//#include <stdio.h>
//#include <signal.h>
//#include <unistd.h>

#define x(a,b,c)if(*#a==C){if(b>8){c-=9;}Z=0;}
L,M=100,H,S=-1,F=10,P,Z,C;

t() {
    H++;
    S++;
    L-=H>79;
    if(S>79)S=0,H+=9;
    Z=1/L/2;//0 if L>0. otherwise the pet dies of a floating point error
    alarm(1);
}

main(){
    nodelay(initscr(),L=M);
    signal(14,t);
    for(t(H=S); C=getch(); Z=Z||printf("\rhealth: %d,hunger: %d,sleep: %d,food: %d,potions: %d,money: %d\n",L,H,S,F,P,M)){
        x(s,9,S=9;S)
        x(p,P+8,P--;L+=18;L)
        x(f,H,F--;H)
        x(b,M,P++;M)
        x(t,M,F++;M)
    }
}

C#6, 567 563 bytes
using System;using System.Threading;class T{int L,M,F=10,H,S,P;static void Main(){T t=new T();}T(){M=L=100;var W=new Thread(new ThreadStart(Q));W.Start();while(1>0){var r=Console.Read();bool B=0>1,K=1>0;if(r=='f'&H>8&F>0){F--;H-=9;B=K;}if(r=='s'){S=0;B=K;}if(r=='p'&P>0){P--;L+=9;B=K;}if(r=='b'&M>8){M-=9;P++;B=K;}if(r=='t'&M>8){M-=9;F++;B=K;}if(B)p();}}void Q(){while(1>0){H++;S++;if(H>79)L--;if(S>79){S=0;H+=9;}if(L>79)M++;L*=L/L;p();Thread.Sleep(500);}}void p(){Console.Write($"\nhealth: {L}\nhunger: {H}\nsleep: {S}\nfood: {F}\nmoney: {M}\npotions: {P}\n");}}

Ungolfed:
using System;
using System.Threading;
class T
{
    int L,M,F=10,H,S,P;
    static void Main()
    {
        T t=new T();
    }
    T()
    {
        M=L=100;
        var W=new Thread(new ThreadStart(Q));
        W.Start();
        while(1>0)
        {
            var r=Console.Read();
            var B=0>1;
            if(r=='f'&H>8&F>0){F--;H-=9;B=1>0;}
            if(r=='s'){S=0;B=1>0;}
            if(r=='p'&P>0){P--;L+=9;B=1>0;}
            if(r=='b'&M>8){M-=9;P++;B=1>0;}
            if(r=='t'&M>8){M-=9;F++;B=1>0;}
            if(B)p();
        }
    }
    void Q()
    {
        while(1>0)
        {
            H++;S++;
            if(H>79)L--;
            if(S>79){S=0;H+=9;}
            if(L>79)M++;
            L*=L/L;
            p();
            Thread.Sleep(500);
        }
    }
    void p()
    {
        Console.Write($"\nhealth: {L}\nhunger: {H}\nsleep: {S}\nfood: {F}\nmoney: {M}\npotions: {P}\n");
    }
}

Mathematica, 374 bytes
h=m=100;f=10;g=s=p=0;RunScheduledTask[g++;s++;If[g>79,h--];If[s>79,s=0;g+=9];If[h>79,m++];If[h<1,Quit[]]];Dynamic@Row[{EventHandler[InputField[],"KeyDown":>Switch[CurrentValue@"EventKey","f",If[g>8&&f>0,f--;g-=9],"s",s=0,"p",If[p>0,p--;h+=9],"b",If[m>8,m-=9;p++],"t",If[m>8,m-=9;f++]]],"
Health: ",h,"
Money: ",m,"
Food: ",f,"
Hunger: ",g,"
Sleep: ",s,"
Potions: ",p}]

The line breaks are important because they are newline characters in the string so I could use Row instead of Column. If you evaluate this in a Mathematica notebook you should see something like this:

You have to click in the input field and quickly (less than a second) type your character before Dynamic causes the input field to update. This headache could be avoided entirely if the EventHandler was in its own cell rather than being an element of Row, but that would require saving the program as a .nb file which would greatly increase the byte count.

Nice work! I was going to use a structure like CurrentValue[EvaluationNotebook[],     NotebookEventActions] = {"KeyDown" :>      Switch[CurrentValue@"EventKey", "f",       If[g > 8 && f > 0, f--; g -= 9], "s", s = 0, "p",       If[p > 0, p--; h += 9], "b", If[m > 8, m -= 9; p++], "t",       If[m > 8, m -= 9; f++]]}; ... this should let you avoid the need to click in an input field. Adding the option , PassEventsDown -> True to the end of that code will let you continue to edit the notebook, but can be removed at the very end for byte savings :)

Thanks, that's exactly the functionality I was looking for initially! Unfortunately it seems it's longer than what I currently have.

PHP, 396 413 bytes
(Dang, my first code golf entry that I had to edit up in byte count. Edited to remove sleep() call, as it wasn't really complying with rules-as-intended.)
Requires a unix-ish OS for the non-blocking STDIN. Oddly, using switch/case versus cascading if/else produced shorter source code, but the subsequent compressed version was longer.
<?eval(gzinflate(base64_decode('bY5BT8MwDIXv/Ao0WWujtVJ7YmtITwiNAwhp3KutOE20pImWVGxa999J1IEAcbH87O892wlUqsEjtmnivD/d5rLd9qZPCHX+gFvdOPTNTpl2L/su3bw9PL1kBaEwMHAMLCsocFaGKhjo0BT0Q0iFaUnO4JmXGlPyPZI8TWHPeIe+nbIIGccJqsGTXbi4p4EKEEt4Qs6xH+rlfA6c5DnwEYacregFlcMvziUk/FLQnzN79drosiOIxV/X7kroeklAh9BxsQD7m/H/MXxi4iKoob5bxRuCTtpFHd8Jn8ab0S7iLOz0pO5LgkfpQ0wrzGyNW+VFBSJ7Nj2eKtDZozHvFfBsPfQdHioYso1CtBW47NV4aXpXgb2Z0csn')));

Ungolfed:
<?
shell_exec('stty -icanon');
stream_set_blocking(STDIN, 0);
$u = $s = $p =0;
$f = 10;
$h = $m = 100;
while(1) {
    $t=time();
    while(1)
        if (($k = fgetc(STDIN)) || time() > $t)
            break;
    if ($k == 'f'){
        if ($u > 8 && $f) --$f | $u -= 9;
    } elseif ($k == 's')
        $s = 0;
    elseif ($k == 'p') {
        if ($p) --$p | $h += 9;
    } elseif ($k == 'b') {
        if ($m > 8) $m -= 9 | ++$p;
    } elseif ($k == 't') {
        if ($m > 8) $m -= 9 | ++$f;
    } else {
        if (++$u > 79) --$h;
        if (++$s > 79) $s = 0 | $u += 9;
        if ($h > 79) ++$m;
        if ($h < 1) exit;
    }
    echo"Health:$h,Money:$m,Food:$f,Hunger:$u,Sleep:$s,Potions:$p\n";
}

This doesn't "respond immediately upon the following keypresses by the user".  It waits until the call to sleep(1) returns before processing input.  Although it does process any queued commands before doing the next update, so it might be fine.

Yeah, noted. The wording there was a big vague so I took some liberty on the interpretation because this way was shorter. :) If I have time today, I'll code up the alternative solution with a timed loop and present both for consideration.

Clojure, 1224 702 bytes
V2
Made all the atoms loose variables instead of being inside a state object. That alone got rid of a lot of code. I also created the shortcut functions a! and s! to add and subtract from the atoms easier (basically acting as += and -=, since Clojure doesn't have those operators).
I realized that I could probably do away with atoms if I manage to integrate key input into a loop. I'll have to see.
(ns bits.golf.pet.v2.petms)(def h(atom 100))(def j(atom 0))(def s(atom 0))(def f(atom 10))(def p(atom 0))(def m(atom 100))(defn a[sa n](swap! sa #(+ % n)))(defn v[sa n](swap! sa #(- % n)))(defn c[](a j 1)(a s 1)(if(>=@j 80)(v h 1))(if (>=@s 80)(do(reset! s 0)(a j 9)))(if(>= @h 80)(a m 1)))(defn l[k](case k\f(if(> @j 8)(do(v f 1)(v j 9)))\s(reset! s 0) \p(if(>@p 0)(do(v p 1)(a h 9)))\b(if(> @m 8)(do(v m 9)(a p 1)))\t(if(>@m 8)(do(v m 9)(a f 1)))nil))(defn b[](.start(Thread.^Runnable(fn[](while(>@h 0)(l(first (read-line))))))))(defn -main[](b)(while(>@h 0)(Thread/sleep 500)(c)(println(str"Health: "@h"\nHunger: " @j"\nSleep: "@s"\nFood: "@f"\nPotions: "@p"\nMoney:"@m"\n")))(println"You died!\n"))

Ungolfed:
(ns bits.golf.pet.v2.pet)

; 100 0 0 10 0 100
(def he (atom 100))
(def hu (atom 0))
(def sl (atom 0))
(def fo (atom 10))
(def po (atom 0))
(def mo (atom 100))

(defn a! [sa n]
  (swap! sa #(+ % n)))

(defn s! [sa n]
  (swap! sa #(- % n)))

(defn apply-rules []
    (a! hu 1)
    (a! sl 1)
    (if (>= @hu 80)
      (s! he 1))
    (if (>= @sl 80)
      (do
        (reset! sl 0)
        (a! hu 9)))
    (if (>= @he 80)
      (a! mo 1)))

(defn handle-keypress [k]
    (case k
      \f (if (> @hu 8)
           (do
             (s! fo 1)
             (s! hu 9)))
      \s (reset! sl 0)
      \p (if (> @po 0)
           (do
             (s! po 1)
             (a! he 9)))
      \b (if (> @mo 8)
           (do
             (s! mo 9)
             (a! po 1)))
      \t (if (> @mo 8)
           (do
             (s! mo  9)
             (a! fo 1)))
      nil))

(defn start-listener []
  (.start
    (Thread. ^Runnable
      (fn []
        (while (> @he 0)
            (handle-keypress (first (read-line))))))))

(defn -main []
  (start-listener)
  (while (> @he 0)
    (Thread/sleep 500)

    (apply-rules)

    (println (str
               "Health: " @he "\n"
               "Hunger: " @hu "\n"
               "Sleep: " @sl "\n"
               "Food: " @fo "\n"
               "Potions: " @po "\n"
               "Money:" @mo "\n")))

  (println "You died!\n"))

V1
Ohdeargod. Definitely room for improvement here. This kind of problem is easiest to do with side effects, and Clojure is functional, so I'm trying to abuse atoms to lessen the amount of code needed. Unfortunately, I didn't go in with a plan, so it's kind of haphazard right now. I've already gotten a few ideas to shrink I though.
It's a full program. It can be run by running -main.
(ns bits.golf.pet)(defrecord S[he hu sl fo po mo])(def new-state(->S 100 0 0 10 0 100))(def state(atom new-state))(defn update![sa k f](swap! sa #(update % k f)))(defn apply-rules[s](let [s' (atom s)u! #(update! s' %1 %2)g #(get @s' %)](u! :hu inc)(u! :sl inc)(if(>=(g :hu)80)(u! :he dec))(if(>= (g :sl)80)(do(u! :sl (fn[_]0))(u! :hu #(+ % 9))))(if(>=(g :he)80)(u! :mo inc))@s'))(defn get-input [](let [raw (read-line)](first raw)))(defn handle-keypress[s k](let [s'(atom s)u! #(update! s' %1 %2)g #(get @s' %)](case k\f(if (> (g :hu)8)(do(u! :fo dec)(u! :hu #(- % 9))))\s(u! :sl (fn [_] 0))\p(if(> (g :po)0)(do(u! :po dec)(u! :he #(+ % 9))))\b(if(>(g :mo))(do(u! :mo #(- % 9))(u! :po inc)))\t(if(>(g :mo)8)(do(u! :mo #(- % 9))(u! :fo inc)))nil@s')))(defn start-listener[](.start(Thread.^Runnable(fn[](while true(let[k(get-input)](swap! state #(handle-keypress % k))))))))(defn -main[](start-listener)(let[g #(get @%1 %2)](while true(Thread/sleep 500)(swap! state #(apply-rules %))(println(str"Health: "(g state :he)"\nHunger: "(g state :hu)"\n""Sleep: " (g state :sl)"\nFood: "(g state :fo)"\nPotions: "(g state :po)"\n""Money:"(g state :mo)"\n"))(if(<=(g state :he)0)(do(println"You died!\n")(reset! state new-state))))))

Ungolfed:
(ns bits.golf.pet)

(defrecord State [he hu sl fo po mo])

(def new-state (->State 100 0 0 10 0 100))

(def state (atom new-state))

(defn update! [sa k f]
  (swap! sa #(update % k f)))

(defn apply-rules [s]
  (let [s' (atom s)
        u! #(update! s' %1 %2)
        g #(get @s' %)]
    (u! :hu inc)
    (u! :sl inc)
    (if (>= (g :hu) 80)
      (u! :he dec))
    (if (>= (g :sl) 80)
      (do
        (u! :sl (fn [_] 0))
        (u! :hu #(+ % 9))))
    (if (>= (g :he) 80)
      (u! :mo inc))
    @s'))

(defn get-input []
  (let [raw (read-line)]
    (first raw)))

(defn handle-keypress [s k]
  (let [s' (atom s)
        u! #(update! s' %1 %2)
        g #(get @s' %)]
    (case k
      \f (if (> (g :hu) 8)
           (do
             (u! :fo dec)
             (u! :hu #(- % 9))))
      \s (u! :sl (fn [_] 0))
      \p (if (> (g :po) 0)
           (do
             (u! :po dec)
             (u! :he #(+ % 9))))
      \b (if (> (g :mo))
           (do
             (u! :mo #(- % 9))
             (u! :po inc)))
      \t (if (> (g :mo) 8)
           (do
             (u! :mo #(- % 9))
             (u! :fo inc)))
      nil
      @s')))

(defn start-listener []
  (.start
    (Thread. ^Runnable
      (fn []
        (while true
          (let [k (get-input)]
            (swap! state #(handle-keypress % k))))))))

(defn -main []
  (start-listener)
  (let [g #(get @%1 %2)]
    (while true
      (Thread/sleep 500)

      (swap! state #(apply-rules %))

      (println (str
                 "Health: " (g state :he) "\n"
                 "Hunger: " (g state :hu) "\n"
                 "Sleep: " (g state :sl) "\n"
                 "Food: " (g state :fo) "\n"
                 "Potions: " (g state :po) "\n"
                 "Money:" (g state :mo) "\n"))

      (if (<= (g state :he) 0)
        (do
          (println "You died!\n\n\n\n\n")
          (reset! state new-state))))))

That's a nice amount of code there.

@ender_scythe Ya. I was trying to adhere to half-decent coding practices in some places, like making applying-rules and handle-keypress pure. I'm writing a "screw-it" version right now.


text:
Let's decrease the monotony
...but hey, no need to be strict.
Given a non-empty array of strictly positive integers, determine if it is:

Monotone strictly decreasing. This means that each entry is strictly less than the previous one.
Monotone non-increasing, but not strictly decreasing. This means that each entry is less than or equal to the preceding, and the array does not fall in the above category.
None of the above.

Note the following corner cases:

An array with a single number is monotone strictly decreasing (vacuously so).
An array with the same number repeated is monotone non-increasing, but not strictly decreasing.

Rules
You may provide a program or a function
Input can be taken in any reasonable format: array, list, string with numbers separated by spaces, ...
You can choose any three consistent outputs for the three categories respectively. For example, outputs can be numbers 0, 1, 2; or strings 1 1, 1 0, empty string.
Shortest code in bytes wins
Test cases
Monotone strictly decreasing:
7 5 4 3 1
42 41
5

Monotone non-increasing, but not strictly decreasing:
27 19 19 10 3
6 4 2 2 2
9 9 9 9

None of the above:
1 2 3 2
10 9 8 7 12
4 6 4 4 2

Does writing a variadic function (where the input values aren't wrapped in any kind of data type at all but are all passed straight to the function as arguments) fall under "any reasonable format"?

@Martin Yes, it does!

Jelly, 10 9 5 bytes
-Method found by DrMcMoylex, go give some credit!
;0IṠṀ

TryItOnline! or run all tests
Returns :-1=monotone strictly decreasing; 0=monotone non-increasing; 1=other.
How?
;0IṠṀ - Main link: list
;0    - concatenate with a zero
  I   - incremental differences
   Ṡ  - sign
    Ṁ - maximum

Is diacrtic M a part of any 8bit character map? You cannot say that it is 5 bytes because it is not. CP1252 does not have it for example.

@EuriPinhollow Jelly uses this custom code page to count bytes, which is linked in the word byte in the header of this post.

@Fatalize: thx, got it.

Perl 6, 17 bytes
{[>](@_)+[>=] @_}

Monotone strictly decreasing: 2
Monotone non-increasing: 1
Other: 0

Expanded:
{            # bare block lambda with implicit parameter list ｢@_｣
  [>]( @_ )  # reduce using ｢&infix:« > »｣
  +
  [>=] @_    # reduce using ｢&infix:« >= »｣
}

Perl is magical

This can be extended to work with any type if > was switched with after and >= with !before. say {[after](@_)+[!before] @_}(<d c b a>) #=> 2

MATL, 10, 7 bytes
0hdX>ZS

Try it online! or verify all test cases!
3 bytes saved, thanks to @LuisMendo!
The outputs are

Strictly decreasing: -1
Non-increasing: 0
Other: 1

Explanation:
0           % Push a '0'
 h          % Join the 0 to the end of the input array.
  d         % Get consecutive differences
   X>       % Get the largest difference
     ZS     % Get its sign
            % Implicitly print it

Can't you append a 0 instead of prepending the last plus 1? Something like 0hdX>ZS

@LuisMendo Ah, that's genius! Thankyou!

Doesn't help, but for obfuscation you could also use: 0hdX>0/ -- Question for you and @LuisMendo : Is it possible to leverage the fact that sort is only 1 char (opposed to X>), by somehow implicitly using the last value?

@DennisJaheruddin I also thought about using S, but I haven't found a way to make it shorter...

Mathematica, 22 bytes
Sign@*Max@*Differences

Unnamed function taking a list of numbers as input. Returns -1 if the list is strictly decreasing, 0 if it's nonincreasing but not strictly decreasing, and 1 if it's neither.
Pretty simple algorithm: take the differences of consecutive pairs, take the largest one, and take the sign of that largest one.
(I feel like there must exist some language in which this algorithm is 3 bytes....)
Regarding an array with a single entry: Differences yields an empty list; Max of an empty list gives -∞ (!); and Sign[-∞] evaluates to -1 (!!). So it actually works on this corner case. Gotta love Mathematica sometimes. (Indeed, the function also correctly labels an empty list as strictly decreasing.)

I see DrMcMoylex beat me by 7 minutes! :)

"I feel like there must exist some language in which this algorithm is 3 bytes" http://chat.stackexchange.com/transcript/message/33720906#33720906 :(

Haskell, 40 38 37 bytes
foldl min GT.(zipWith compare<*>tail)

Returns

GT for Monotone strictly decreasing
EQ for Monotone non-increasing
LT else

compare compares two numbers and returns GT (EQ, LT)  if the first number is greater than (equal to, less than) the second number. zipWith compare<*>tail compares neighbor elements. foldl min GT reduces the list of the comparison results with the min function starting with GT (note: LT < EQ < GT).
Edit: @xnor found 2 3 bytes. Thanks!

Can you prepend a LT instead of appending 0?

@xnor: Yes, thanks, but it must be a GT, because we need the minimum of the list (I had maximum, which was wrong and a relict from an early version where I used =<< instead of <*>).

I see. Actually, how about foldl min GT?

Common Lisp, 43 40 bytes
(defun f(x)`(,(apply'> x),(apply'>= x)))

This takes input as a Lisp list, and returns (T T), (NIL T) and (NIL NIL) to distinguish the 3 categories. Here it is running on the provided test cases:
CL-USER> (mapcar #'f '((7 5 4 3 1)
                       (42 41)
                       (5)
                       (27 19 19 10 3)
                       (6 4 2 2 2)
                       (9 9 9 9)
                       (1 2 3 2)
                       (10 9 8 7 12)
                       (4 6 4 4 2)))
((T T) (T T) (T T) (NIL T) (NIL T) (NIL T) (NIL NIL) (NIL NIL) (NIL NIL))

The exact same number of bytes as (defun f(x)(mapcar'apply'(> >=)\(,x,x))). Note that you can just write (lambda(x)...)` to be shorter.

Python 2, 30 bytes
lambda l:max(map(cmp,l[1:],l))

-1 for strictly decreasing, 0 for weakly decreasing, +1 for non-decreasing
Using cmp to compare consecutive elements, and takes the maximum. This is done by removing the first element of one copy of the list, then mapping cmp . For example, l=[2,2,1] gives
l[1:]  2   1   None
l      2   2   1
cmp    0  -1   -1

which has max 0 because an equality exists.
The shorter list is automatically extended with None, which is less than all numbers and so harmless. This phantom element also insulates against taking the min of an empty list when the input has length 1.

Even with the very little Python I know I can appreciate how great this answer is

Brachylog, 7 bytes
>,1|>=,

Try it online!
This prints 1 for strictly decreasing, 0 for non-increasing and false. otherwise.
Explanation
  (?)>              Input is a strictly decreasing list
      ,1(.)         Output = 1
|                 Or
  (?)>=             Input is a non-increasing list
       ,(.)         Output is a free variable; gets automatically labeled as an integer at
                      the end of execution. Since its domain is [-inf, +inf], the first
                      value it takes is 0
                  Or
                    No other possibility, thus this main predicate is false.

Other 7 bytes solutions
>=!>,;1           Returns 0 for strictly decreasing, false. for non-increasing, 1 otherwise.

>=!>,1|           Returns 1 for strictly decreasing, false. for non-increasing, 0 otherwise.

R, 44 bytes
d=diff(scan());c(any(!d)&all(d<=0),all(d<0))

Reads input from stdin and prints the following depending on the input:
Output:
[1] FALSE  TRUE: Monotone non-increasing
[1]  TRUE FALSE: Monotone strictly decreasing
[1] FALSE FALSE: None of the above

d=diff(scan());ifelse(all(d<=0),!prod(d),2) is 1 byte shorter. It returns 0 if monotone strictly, 1 if monotone non-increasing and 2 if none of the above. Not sure if it is allowed to return nothing if none of the above, but then you could simplify further to d=diff(scan());if(all(d<=0))!prod(d).

Actually, d=diff(scan());if(all(d<=0))any(!d) is one byte better.

JavaScript (ES6), 51 bytes
a=>a.some((e,i)=>e>a[i-1])+a.some((e,i)=>e>=a[i-1])

Returns 0 for strict decreasing, 1 for non-increasing, 2 otherwise.

05AB1E, 5 8 bytes
Bug fixed by Emigna, thanks!
It uses the same method as DrMcMoylex's.
®¸ì¥Z0.S

®¸ì   Implicitly take input and appends -1 to it
¥     Yield deltas
 Z    Take the largest delta
  0.S Take its sign and implicitly display it

Try it online!
Output is:
-1 if strictly decreasing sequence
 0 if non-strictly decreasing sequence
 1 otherwise

®¸ì¥Z0.S would fix the single element issue.

Nice, thanks! I think 0 at the beginning would also work since all numbers are positive (strictly by default I guess).

Yes 0 would work as well, but it's nice that it works for input containing 0 (even though by definition it wont) :)

Fun fact: in French "positive" means positive or zero and you have to specify "strictly positive" to reach the same meaning as "positive" in English.

Ruby, 37 bytes
->l{[d=l==l.sort.reverse,d&&l|[]==l]}

Output:[true,true], [true,false] or [false,false]

Haskell, 34 bytes
maximum.(zipWith compare<*>(1/0:))

Try it online!
Outputs LT,EQ,GT for strictly monotonic, non-increasing, and otherwise, respectively. Thanks to @xnor for pointing out that my previous version failed on singleton lists and suggesting this alternative.
Takes the maximum of the sighn of the differences between adjacent pairs, prepending with inf.
(zipWith compare<*>(1/0:) applied to l computes compare l inf:l elementwise).
This is competitive with the existing Haskell answers and ekes out ahead by being pointfree and anonymous.

Retina, 41 bytes
\d+
$*
A`\b(1+) 1\1
S`\b$
\b(1+) \1\b.*|$

Try it online! (The first line enables a linefeed-separated test suite.)

Strictly decreasing: 2
Non-increasing: 3
Neither: 1

Explanation
\d+
$*

Converts the input unary.
A`\b(1+) 1\1

The regex here matches an increasing pair of consecutive numbers. If this is the case, the input can clearly not be non-increasing. The A denotes it as an "anti-grep" stage which means that the input line is discarded and replaced with the empty string if the regex matches.
S`\b$

This is a split stage which is used to append a linefeed to the input only if the input wasn't discarded. So we've got two possible outcomes so far: non-increasing inputs get a linefeed at the end and others are still empty.
\b(1+) \1\b.*|$

Finally, we count the number of matches of this regex. The regex either matches to identical numbers (and then everything to the end of the string to avoid multiple matches of this kind for inputs like 1 1 1 1), or the "end of the input". Let's go through the three types of inputs:

Strictly decreasing: the first part of the regex can't match because all values are unique, but the $ matches. Now $ isn't exactly "the end of the string". It can also match in front of a trailing linefeed. So we'll actually get two matches from it, one at the end of the input, and one after the linefeed we inserted.
Non-increasing: now the first part of the regex also provides a match, and we end up with three matches.
Neither: remember that we took care to turn the input into an empty string, so now $ matches only once.

Racket, 44 bytes
(λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))

Invoked:
(map (λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))
 '((7 5 4 3 1)
   (42 41)
   (5)
   (27 19 19 10 3)
   (6 4 2 2 2)
   (9 9 9 9)
   (1 2 3 2)
   (10 9 8 7 12)
   (4 6 4 4 2)))

Result:
'((#t #t)
 (#t #t)
 (#t #t)
 (#f #t)
 (#f #t)
 (#f #t)
 (#f #f)
 (#f #f)
 (#f #f))

It's a shame Racket doesn't define the arity 1 case of > as true. Common Lisp gets that right, but fails to define the arity 0 case (which should also be true).

Mathematica, 15 11 bytes
##>0|##>=0&

This is a variadic function, taking all input integers as separate arguments.

Strictly decreasing: True | True
Non-increasing: False | True
Neither: False | False

Note that | is not Or but Alternatives, which is part of pattern matching syntax, which explains why these expressions don't get evaluated to True, True, False, respectively.
The code itself is mostly an application of this tip. For example ##>0 is Greater[##, 0] but then ## expands to all the input values so we get something like Greater[5, 3, 2, 0], which itself means 5>3>2>0.

Python 3, 81 52 bytes (Thanks to FryAmTheEggMan)
e=sorted
lambda a:(a==e(a)[::-1])+(e({*a})[::-1]==a)

Try it online !

sorted(s)[::-1] is shorter for reversing a sorted list. In Python 3 you can do {*a} to get a set of the elements of a. sorted returns a list so you don't have to cast the set to a list either. Also adding booleans is perfectly kosher! Finally you can submit an anonymous lambda, so you don't need f=. I get 52 bytes in the end. https://repl.it/E7eG/2

C++14, 85 bytes
int f(int x){return 3;}int f(int x,int y,auto...p){return((x>=y)+2*(x>y))&f(y,p...);}

Returns 3 (0b11) for strict decreasing, 1 (0b01) for non-increasing and 0 otherwise.
Ungolfed:
int f(int x) {return 3;}
int f(int x,int y,auto...p){
  return ((x>=y)+2*(x>y)) & f(y,p...);
}

I thought this was a perfect problem for C++17's folding expressions:
int g(auto...x){return(x>...)+(x>=...);}

Unfortunately it does not chain the relational operators but does
((x1>x2)>x3)>x4)...

which is not was wanted.

Python 2, 61 74 bytes
+13 bytes for the single number input
x=map(str,input())
print[2,eval(">".join(x))+eval(">=".join(x))][len(x)>1]

Requires input in bracket list form like [3,2,1]. Returns 2 for strict decreasing, 1 for non-increasing and 0 otherwise.
Old solution:
print eval(">".join(x))+eval(">=".join(x))

Befunge, 50 bytes
&: >~1+#^_v>:0`|
1\:^  @.$$<-@.2_
-: ^    >& ^   >

Try it online!
Accepts input as a sequence of int separated by spaces, and returns 0 if strictly decreasing, 1 if non-strictly decreasing, 2 otherwise.
Since reading befunge is kind of impossible if you don't know the language, this is the algorithm in pseudocode:
push(input())

while( getchar()!=EOF ){
  push(input())
  subtract()
  duplicate()
  if(pop()>0){
    subtract() //we are doing a-(a-b), so b is now on top
    duplicate()
  }
  else{
    if(pop()==0){
      push(1) //the sequence is not strictly decreasing
      swap()
      duplicate()
    }
    else{
      push(2) //the sequence has just increased
      output(pop)
      return
    }
  }
}
pop()
pop()
output(pop())

*in befunge memory is a stack which starts with an infinite amount of 0 on it. pop(), push(x), input() and output(x) are self-explainatory, the other pseudofunctions i used work like this:
function duplicate(){
  a=pop()
  push(a)
  push(a)
}

function subtract(){
  a=pop()
  b=pop()
  push(b-a)
}

function swap(){
  a=pop()
  b=pop()
  push(a)
  push(b)
}

Funge!

Previous version, just 41 bytes but invalid since it requires a 0 to terminate the input sequence (or using an interpreter like this)
&:  >&:|>:0`|
1\v@.$_<-@.2_
- >:v  >^   >

Try it online!

I'm afraid a trailing 0 doesn't count as a valid input format. I think it falls under the "preprocessed input" category. In fact, some answers append a 0 in the code (thus including that in the byte count). I would be acceptable if you could Can you replace the 0 by some non-numeric character? That would be acceptable

@LuisMendo Actually, with this interpreter (which is the one I used to develop the code) EOF does return 0, so there is no need to add anything to the input. I wasn't able to discover what the intended behaviour should be, so I don't know if this assumption is standard or not.
A thing that I may have misinterpreted, though, is: can zeroes be part of the input sequence? If so, I would need to modify the code anyway.

No, zeros can't be part of the sequence (Given a non-empty array of positive integers_ I meant strictly positive integers). But some answers do use a 0 inserted by the code to deal with the case that the input has only one entry. That's one reason why I consider that including that 0 in the input is not valid. Anyway, if there is an interpreter that doesn't need it, you can use that interpreter to prove that your answer is valid without the 0. If the Try-it-online interpreter needs that 0, you can include it for demonstration purposes, with an appropriate explanation note

@JamesHolderness while on tryonline ~ works as it should, & has a strange behaviour on EOF, apparently repeating the last input forever. See here for an example

I edited the answer using James's approach, now input is terminated by EOF

Haskell, 36 bytes
f l=[scanl1(min.(+x))l==l|x<-[0,-1]]

(+x) is because haskell mis-interprets (-x) as a value instead of a section. I wonder if the whole expression can be profitably made pointfree.

J, 14 bytes
Monadic verb taking the list on the right, returning 1 for strictly decreasing, 0 for weakly decreasing, and _1 otherwise.
*@([:<./2-/\])

Takes the sign * of the minimum <./ of consecutive differences 2-/\ of the list. J doesn't swap the order of the differences when taking them so e.g. the sequence is strictly decreasing if these are all positive. Notably, <./ returns positive infinity on zero-element lists.
In use at the REPL:
   *@([:<./2-/\]) 3
1
   *@([:<./2-/\]) 3 2
1
   *@([:<./2-/\]) 3 2 2
0
   *@([:<./2-/\]) 3 2 2 3
_1

C, 68 67 Bytes
A function f, which is passed an array of ints (l) preceded by its length (n, also an int). Returns 3 if monotone strictly decreasing, 1 if monotone non-increasing, but not strictly decreasing, 0 otherwise.

f(int n,int*l){return n<2?3:((l[0]>l[1])*2|l[0]>=l[1])&f(n-1,l+1);}

Un-golfed slightly for readability:
int f_semiungolfed(int n, int* l) {
    return (n < 2) ? 3 : ((l[0] > l[1]) * 2 | l[0] >= l[1]) & f(n - 1, l + 1);
}

Rearranged and commented to show logic:
int f_ungolfed(int n, int* l) {
    int case1 = 0, case2 = 0, recursion = 0;
    if (n < 2) { // Analogous to the ternary conditional I used - n < 2 means we have a single-element/empty list
        return 3; // Handles the vacuous-truth scenario for single lists
    } else {
        case1 = l[0] > l[1]; // The first case - are the two numbers in the list strictly decreasing? (case1 is 1 if so)
        case2 = l[0] >= l[1]; // The second case - are the two numbers strictly non-increasing (case2 is 1 if so)
        recursion = f_ungolfed(n - 1, l + 1); // Recursively call ourselves on the "rest" of the list (that is, everything other than the first element). Consider that comparison is transitive, and that we already have a vacuous-truth scenario covered.
        case1 *= 2; // Shift case1's value over to the left by one bit by multiplying by 2. If case1 was 1 (0b01), it's now 2 (0b10) - otherwise it's still 0 (0b00)
        return (case1 | case2) & recursion;
        // The bitwise OR operator (|) will combine any 1-bits from case1's value (either 0b10 or 0b00) or case2's value (either 0b01 or 0b00) into either 3, 2, 1, or 0 (0b11, 0b10, 0b01, or 0b00 respectively).
        // The bitwise AND operator (&) will combine only matching 1-bits from (case1|case2) and the return value of the recursive call - if recursion = 0b11 and case1|case2 = 0b01, then the return value will be 0b01.
    }
}

Test cases (courtesy IDEOne):

{7, 5, 4, 3, 1}: 3
{42, 41}: 3
{5}: 3
{27, 19, 19, 10, 3}: 1
{6, 4, 2, 2, 2}: 1
{9, 9, 9, 9}: 1
{1, 2, 3, 2}: 0
{10, 9, 8, 7, 12}: 0
{4, 6, 4, 4, 2}: 0

Vim, 69 bytes
V}JYu:sor!n
V}JP:%s/^\(.*\)\n\1/m\r\1
:%s/\vm\n.*<(.+) \1.*/n
:g/\d/d

Try it online!
This is vanilla vim (TIO supports V (vim), which is backwards compatible). Takes input as a list of integers, one per line. Outputs m for strictly monotonic, n for non-increasing, and empty string otherwise.
V}              " select everything
  J             " space-join it all into one line
   Y            " yank that
    u           " undo back to one per line
     :sor!n     " reverse sort (the whole file, by line) numerically
V}J             " space join again
   P            " paste the previously yanked original list
                " now we have the list on line 1 and a sorted copy on line 2

Next we have two regexes.
:%s/^\(.*\)\n\1/m\r\1

Matches two copies of the same line and replaces the first with "m".
:%s/\vm\n.*<(\d+) \1.*/n

Matches that "m" followed by a line containing <(.+) \1, i.e. a word boundary followed by <foo> <foo>, and if found replaces everything with n. The \v at the start says "all characters are special" so we don't have to escape any of <()+.
There's a bit of careful cleverness here: we don't need a word boundary after the \1 because the first number can't be a prefix of the second in a reverse sorted list. Furthermore, even though (.+) can match several numbers (as opposed to (\d+) which would match only one for an extra byte), this won't result in any false positives for the same reason: we can't have a repeated string of multiple numbers in a reverse sorted list unless they're all the same, in which case we want to match them anyway.
The state after all this is one of:
monotonic     non-increasing      other
---------     --------------      -----
m             n                   3 1 2
3 2 1                             3 2 1

So, to collapse these states, we just delete any line which still has a digit: :g/\d/d, resulting in the desired output.
I do wonder whether the regexes can be golfed some (maybe avoiding some cross-line stuff?) but the corner cases can be a bit tricky.

I see. My mistake then. Deleting comment to avoid confusion

Ceylon, 86 bytes
Object m(Integer+l)=>let(c=l.paired.map(([x,y])=>x<=>y))[if(!smaller in c)equal in c];

The function takes the input as its parameters, and returns a tuple of zero or one booleans – [false] for Monotone strictly decreasing, [true] for Monotone non-increasing, but not strictly decreasing, and [] for None of the above.
It can be used like this:
shared void run() {
    print("Monotone strictly decreasing:");
    print(m(7, 5, 4, 3, 1));
    print(m(42, 41));
    print(m(5));

    print("Monotone non-increasing, but not strictly decreasing:");
    print(m(27, 19, 19, 10, 3));
    print(m(6, 4, 2, 2, 2));
    print(m(9, 9, 9, 9));

    print("None of the above:");
    print(m(1, 2, 3, 2));
    print(m(10, 9, 8, 7, 12));
    print(m(4, 6, 4, 4, 2));
}

Output:
Monotone strictly decreasing:
[false]
[false]
[false]
Monotone non-increasing, but not strictly decreasing:
[true]
[true]
[true]
None of the above:
[]
[]
[]

An ungolfed and commented version:
// Let's decrease the monotony!
//
// Question:  http://codegolf.stackexchange.com/q/101036/2338
// My Answer: http://codegolf.stackexchange.com/a/101309/2338

// Define a function which takes a non-empty list `l` of Integers)
// (which arrive as a tuple) and returns an Object (actually
// a `[Boolean*]`, but that is longer.)
Object m(Integer+ l) =>
        // the let-clause declares a variable c, which is created by taking
        // pairs of consecutive elements in the input, and then comparing
        // them. This results in lists like those (for the example inputs):
        // { larger, larger, larger, larger }
        // { larger }
        // {}
        // { larger, equal, larger, larger }
        // { larger, larger, equal, equal }
        // { equal, equal, equal }
        // { smaller, smaller, larger }
        // { larger, larger, larger, smaller }
        // { smaller, larger, equal, larger }
        let (c = l.paired.map( ([x,y]) => x<=>y) )
            // now we analyze c ...
            // If it contains `smaller`, we have an non-decreasing sequence.
            // We return `[]` in this case (an empty tuple).
            // Otherwise we check whether `equal` is in the list, returning
            // `[true]` (a non-strictly decreasing sequence) if so,
            // and `[false]` (a strictly decreasing sequence) otherwise.
            [if(!smaller in c) equal in c];

Actually, 9 8 bytes
This answer is based on Jonathan Allan's excellent Jelly answer, and returns -1 for a strictly decreasing array, 0 for a non-increasing array, and 1 for none of the above. Golfing suggestions welcome! Try it online!
;\♀-dXMs

Ungolfing
     Implicit input a.
;\   Duplicate a and rotate that duplicate left by 1.
♀-   Vectorized subtract the two duplicates.
dX   Discard the last element, leaving only the first differences of a.
M    Get the maximum first difference.
s    Push the sign of the maximum first difference, returning -1, 0, or 1 as described above.
     Implicit return.

Dennis's? Are you sure? :P

@ErikTheOutgolfer Whoops. Thanks for letting me know

Axiom, 114 bytes
m(c:List(INT)):INT==(i:=r:=1;repeat(~index?(i+1,c)=>break;c.i<c.(i+1)=>return 0;if c.i=c.(i+1)then r:=2;i:=i+1);r)

Ungolfed
-- if [a,b,..n] decrescente ritorna 1
--          non crescente   ritorna 2
--          altrimenti      ritorna 0
m(c:List(INT)):INT==
   i:=r:=1
   repeat
      ~index?(i+1,c)=>break
      c.i<c.(i+1)   =>return 0
      if c.i=c.(i+1) then r:=2
      i:=i+1
   r

Results
(x) -> m([3,1])=1, m([1,1])=2, m([])=1, m([1])=1, m([1,3])=0
   (x)  [1= 1,2= 2,1= 1,1= 1,0= 0]

Forse dovresti tradurre i commenti all'inglese :-)

Clojure, 34 bytes
#(if(apply > %)1(if(apply >= %)2))

Very straight-forward, returns 1 for if strictly decreasing, 2 if non-increasin and nil otherwise.
Also tried avoiding apply with macro's ~@ but it is just longer at 43 chars (this results in [1 2 nil]):
(defmacro f[& i]`(if(> ~@i)1(if(>= ~@i)2)))

[(f 7 5 4 3 1)
 (f 27 19 19 10 3)
 (f 1 2 3 2)]

APL, 16 bytes
(a≡a[⍒a])×1+a≡∪a

Note: enter one element array as eg a←1⍴3 otherwise: a←4 3 2 1
Interpreting output:
2 Monotone strictly decreasing
1 Monotone non-increasing, but not strictly decreasing
0 None of the above

Idea: test for monotonicity by comparing original to sorted array, check for non-increasing by comparing to array with removed duplications.
(And I think it can be improved...)

Changed to one number. Bytes increased by 2...

LabVIEW, 12 nodes, 18 wires ==> 48 bytes by convention

No functions hidden in the other case frames, just a single wire across.

Pip, 8 bytes
O$>g$>=g

Full program. Takes the input list as command-line arguments. Outputs 11 for strictly decreasing, 01 for non-increasing, 00 for neither.
Try it online!
Explanation
This approach works because Pip's comparison operators, like Python's, chain together: 4>3>2 is true, rather than being (4>3)>2 (false) as in C. And the same behavior holds when the comparison operators are modified with the $ fold meta-operator.
          g is list of command-line args (implicit)
 $>g      Fold g on >
O         Output without newline
    $>=g  Fold g on >=
          Print (implicit)

Japt, 9 8 7 bytes
Outputs -1 for "monotone strictly decreasing", 0 for "monotone non-incresing" and 1 otherwise.
än rw g

Try it
1 byte saved thank to Oliver.

@Oliver, yes; otherwise it will default to ... Wait, what? Why does that work?! än mg rw returns the wrong results without the J but that's not the case with än rw g. Weird.

R, 34 bytes
function(x)max(sign(diff(c(x,0))))

Try it online!
Ports DJ's MATL answer.
R, 43 bytes
function(x)all(diff(x)<0)+all(x==cummin(x))

Try it online!
Returns 2 for strictly decreasing, 1 for non-increasing, and 0 otherwise.
all(x==cummin(x)) is TRUE (converts to 1 when used in arithmetic) if and only if f is non-increasing, including the strict case.
all(diff(x)<0) is TRUE only when f is strictly decreasing.

Pyth, 8 bytes
._eS.+aZ

Try it online!
Literal translation of James's MATL answer.

Thunno 2 G, 5 bytes
0aṢ€ʂ

Try it online!
Port of DJMcMayhem's MATL answer. Gives -1 for strictly deceasing, 0 for non-increasing, and 1 for none of the above.
Explanation
0aṢ€ʂ  # Implicit input
0a     # Append a 0
  Ṣ    # Deltas of the list
   €ʂ  # Sign of each
       # Take the maximum
       # Implicit output

Python 3, 113 bytes
def f(L):
 z=0
 for i in range(0,len(L)-1):
  if L[i]-L[i+1]<0:
   return 2
  if L[i]-L[i+1]==0:
   z=1
 return z

Try it online!
Could be shorter if there were a sign function. This outputs 0 for strictly decreasing, 1 for weakly decreasing and 2 for none of the above.

Can you please include some code in the footer to actually use the function with one or several example inputs? Also, removing 0, from range(...) saves 2 bytes


text:
How to Draw Melting Icicles
A sculptor is tasked to creating icicle sculptures for the new museum in Greenland. He has been given specifications by his boss, which consists of two numbers: [s, m] or size and melt. Size must be an odd number. He was given some photos of real icicles:
vvvvv [5, 0]
 vvv
  v

vvvvvvv [7, 0]
 vvvvv
  vvv
   v

vvvvvvv [7, 2]
 vvvvv

vvvvvvv [7, 3]

vvv [3, 1]

He needs a program to help draw. Any language allowed. The program needs to take in S and M, any method of input acceptable. You must then print out an ascii art representation of it.
S is how many vs are on the first layer. M is how many layers are cut out from the bottom.
This is code-golf, so as usual this competition is byte based. White space does count for byte counting. Least bytes wins.
Edit:
You will never get a set of numbers that draws nothing, for example [5, 3]. Checking code is not required however.

You say whitespace does count, but in the examples some lines have trailing spaces. Is that allowed?

05AB1E, 11 bytes
;-Ý·¹+'v×.c

;-          Compute x = Input[1]-Input[0]/2  (e.g. 7,2 -> -1.5)
  Ý         Push [0, ..., x]                 (e.g. 7,2 -> [0, -1])
   ·        Multiply each value by 2         (e.g. 7,2 -> [0, -2])
    ¹+      Add Input[0] to each value       (e.g. 7,2 -> [7, 5])
      'v×   String multiply by 'v'
         .c Center all strings and implicitly display them

Try it online!

Good Job, you bean @Adnan's 12 bytes in 05AB1E!!

@yummypasta well, I think his nick is not a coincidence :)

Thanks! Adnan and Emigna usually help me more than I can help then. And you're right, my nickname is quite related to 05AB1E ;) .

V, 15 bytes
Àévò^lYp2x>òÀñd

Try it online!
Fairly straightforward.
À               " Arg1 times:
 év             "   Insert a 'v'
   ò       ò    " Recursively:
    ^l          "   Break if there is only one character on this line
      Y         "   Yank this line
       p        "   Paste it below us
        2x      "   Delete two characters
          >     "   Indent this line
            À   " Arg2 times:
             ñd "   Delete a line

I think that V wins for "most obfuscatable language".

that language looks fun to debug

The source code looks like some random generated hash. I could use it as a safe password.

I like that there's a language called V that can solve this problem.

05AB1E, 12 bytes
Code:
ÅÉ'v×R²F¨}.c

Explanation:
ÅÉ             # List of uneven numbers: [1, 3, 5, ..., input]
  'v×          # String multiply by 'v', giving ['v', 'vvv', 'vvvvv', ...]
     R         # Reverse the array
      ²F }     # Second input times, do...
        ¨      #   Remove the first element of the array
          .c   # Centralize the array

Uses the CP-1252 encoding. Try it online!

;-Ý·¹+'v×.c would save one byte

@Osable isn't that just a completely different answer?

Good point, I really don't know since there is no big algorithm behind both answers. I'll post it as another answer if needed.

@Osable Nice find! I think you should put it as a different answer, since it's  very different from this one.

MATL, 22 bytes
'v'itQ2/i-wX"R2&PRZ{Zv

Try it online!
Explanation
'v'   % Push character 'v'
it    % Input first number. Duplicate
Q2/   % Add 1 and divide by 2
i-    % Input second number. Subtract
w     % Swap
X"    % Char matrix of 'v' repeated those many times along each dim
R     % Upper triangular part
2&P   % Flip horizontally
R     % Upper triangular part
Z{    % Split char matrix along first dimension into a cell array of strings
Zv    % Remove trailing spaces from each string. Implicitly display

Jelly, 19 bytes
Rm-2”vẋµLḶ⁶ẋżðḣL_¥Y

TryItOnline!
How?
Rm-2”vẋµLḶ⁶ẋżðḣL_¥Y - Main link: s, m
       µ            - monadic chain separation
R                   - range(s)  [1,2,3,...s]
 m-2                - mod -2    [s,s-2,s-4,...,1]
    ”v              - 'v'
      ẋ             - repeat    ['v'*s,...,'vvv','v']  (call this y)
             ð      - dyadic chain separation
        L           - length, effectively (s+1)/2
         Ḷ          - lowered range [0,1,2,...length-1]
          ⁶         - ' '
           ẋ        - repeat ['', ' ', ... ' '*(length-1)]
            ż       - zip with y
                 ¥  - last two links as a dyad
               L    -     length
                _   -     subtract m
              ḣ     - head
                  Y - join with line feeds
                    - implicit print

I like that length-unlength chain in the middle ;-)

Yeah, J’ (range of length decremented) would also have the same effect, but there is no lowered version of J, and the LḶ is kind of cute :)

Ruby, 46 44 bytes
->s,m{0.upto(s/2-m){|i|puts' '*i+?v*s;s-=2}}

2 bytes saved thanks to G B

puts does not need the whitespace

And you can save one more character by decrementing s: instead of ?v*(s-2*i) use ?v*s;s-=2

Batch, 142 bytes
@set/ah=%1-%2-%2
@set s=v
@for /l %%i in (3,2,%1)do @call set s=%%s%%vv
@for /l %%i in (1,2,%h%)do @call echo %%s%%&call set s= %%s:~0,-2%%

Python, 76 73 bytes
def f(s,m):print"\n".join([' '*(s/2-i/2)+'V'*i for i in range(s,m*2,-2)])

Edit: Saved 3 bytes thanks to @TuukkaX and @Challenger5 (Thanks!)

After the print, there's an useless whitespace :)

Why not use a lambda? lambda s,m:"\n".join([' '*(s/2-i/2)+'V'*i for i in range(s,m*2,-2)])

You can put the function code directly after the def f(s,m):, saving two bytes.

@J843136028 It's the same number of bytes: def f() is 7 lambda  is 7. with Challenger5's tip, def is actually shorter. at least if that's what you meant like i think :)

@nephi But you also remove the print, so it's 4 characters shorter (lambda s,m:"\n".join(...)), as lambdas basically have an implicit return.

JavaScript (ES6), 57 bytes
f=(s,m,p=``)=>s<m+m?``:p+`v`.repeat(s)+`
`+f(s-2,m,p+` `)

Outputs a trailing newline. If a leading newline is acceptable, then for 54 bytes:
f=(s,m,p=`
`)=>s<m+m?``:p+`v`.repeat(s)+f(s-2,m,p+` `)

Python 2, 63 bytes
lambda s,m:'\n'.join((s-x)/2*' '+x*'v'for x in range(s,m*2,-2))

Turtlèd, 53 bytes
@v?,:l[v,l][ [ l]rr[ d,ur]ld' l]?<:d[ [ u]d[ ' d]luu]

Try it online!
Explanation:
@v,           set char var to v, write it to cell

   ?:l        take positive int input, move that many character right, move 1 left

      [v,l]   move left back to the v, writing v on all the cells it goes on

           [                   ]                      until the current cell is a space

             [ l]    move left until finding a space
                 rr  move two right

                   [     ]  until cell is a space
                     d,ur   move down, write v, move up and right

                          ld' l    move left, down, write space

                                [end of big loop]

                                  [that part made the "icicle", the next melts some]

                                ?<:
           Take integer input again,
           rotate counterclockwise, move that number right (now up the icicle)

                                    d      move down
                                     [               ] until cell is space
                                       [ u]d   up until space is found, down 1
                                            [ ' d]  until space is found, write space to cell and move down
                                                  luu    move left, up, up
                                                   [end loop]

Java, 138 137 bytes
void m(int l,int r){int f=l;do{String v="";for(int i=0;i++<l;v+="v");if(l/2<r)break;System.out.printf("%"+f--+"s%n",v);l-=2;}while(l>0);}

Ungolfed:
void m(int l, int r) {
    int f = l;
    do {
        String v = "";
        for (int i = 0; i++ < l; v += "v");
        if (l / 2 < r) break;
        System.out.printf("%" + f-- + "s%n", v);
        l -= 2;
    } while (l > 0);
}

Update: One byte and loop body gone thanks to @ClaytonRamsey.

You can cut down on one byte if you rewrite the for-loop as for(int i=0;i++<l;v+="v");

C, 83 bytes
i,j;f(s,m){for(i=-1;i++<s/2-m;)for(j=-1;++j<=s;)putchar(j<s?j>=i&&s-j>i?86:32:10);}

Ungolfed and usage:
i,j;
f(s,m){
  for(i=-1;i++<s/2-m;)
    for(j=-1;++j<=s;)
      putchar(j<s ?
                j>=i&&s-j>i ? 86 : 32
                : 10);
}

main() {

  f(5,0);
  f(7,0);
  f(7,2);
  f(7,3);
  f(3,1);

}

Pyth, 21 bytes
j<E.e+*kd*hyb\v_Uh/Q2

A program that takes input of S followed by M, newline-separated, and prints the result.
Test suite
How it works
j<E.e+*kd*hyb\v_Uh/Q2  Program. Inputs: Q, E
                  /Q2  Yield Q // 2
                 h      + 1
                U      Yield [0, 1, 2, ..., Q //2 +1]
               _       Reverse
   .e                  Map over with elements as b and zero-indexed indices as k:
           yb           2 * b
          h              + 1
         *   \v          "v" characters
     +                  prepended with
       k                k
      * d                spaces
 <E                    All but the last E elements
j                      Join on newlines
                       Implicitly print