text:
Javascript tips: 2 to the power of x multiplied by n
I'm new to ES6 and code-golfing. Here's the original function:

function puzzle(n, x) {
  return n * Math.pow(2, x);
}

And here's what I have so far:
let puzzle=(n,x)=>n*2<<(x-1)

But the solution requires lesser characters. I went through the 'Code Golfing with ES6' thread, but couldn't find a better way.
Any help/links would be appreciated.

You can try n<<x.

FYI there isn't much point in a Stack Snippet if you aren't going to build it into some HTML

Ah. That did it :)
@βετѧΛєҫαγ Point noted.

17 bytes:
puzzle=n=>x=>n<<x

This uses the fact that 2 * 2^n = 2^(n + 1). Also, by our rules, using currying instead of taking multiple arguments the usual way is allowed. Also, I don't think the let is needed.

source: Stack Exchange

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

sort: votes


text:
Java Asterisk Rectangle
For my CS class, my instructor has given us the assignment of creating a rectangle made of asterisks with diagonal lines drawn through it in Java.
He also told us to write it in as few bytes as possible. I've gotten it down to 190 bytes, but I need to find a few to simplify this code even more to decrease bytes. Can anyone help me with this?
This code is functional:
interface d{static void main(String[]a){for(int z=0,w=new Byte(a[0]),h=new Byte(a[1]);z<h*w;){int y=z/w,x=z++%w;System.out.print((x>w-2)?"*\n":(y%(h-1)*x*((y-x)%3)==0)?"*":" ");}}}

Input is 10 10.
Output:
**********
**  *  * *
* *  *  **
*  *  *  *
**  *  * *
* *  *  **
*  *  *  *
**  *  * *
* *  *  **

Don't redirect him to SO; he'll get eaten alive.

Can you clarify the output and specs of the program? i.e. example input/output etc

What are the dimensions of the rectangle? Any other specifications?

Hello and welcome to PPCG. The way this question is worded is somewhat off-topic for this site. If asking for golfing advice, it is better to specify a particular aspect of your code. Take a look at the [tag:tips] tag for more info. You could also check out our tips for golfing in Java post.

I'm not entirely sure why this being close voted. This is most definitely not a general programming question. It's pretty much a standard [tag:tips] question, which is very much on topic. I'm not sure whether we have a policy on homework, although as far as I can see the OP is even showing their own effort, so I don't think there's really anything wrong with this?

@NathanMerrill Advice for specific golfing problems is most definitely not off topic.

@MartinEnder I'm not sure if I worded this badly in my other comment, but I think that post implies asking about a specific change ("how can I shorten these nested loops?") would be on-topic, but just "golf my code" seems like it's too broad. I haven't voted yet, but am I missing something?

@FryAmTheEggman You're right that a slightly more general question would probably be a bit more useful for future visitors, but I don't think asking about a specific piece of code is actually off topic. I'd imagine answers could still be very helpful content for beginning Java golfers in the future.

@MartinEnder sorry for not making the question specific enough, At this point I've exhausted my knowledge of Java, so I'm reaching out to codegolf for help here. as FryAmTheEggman said, I pretty much am just asking if you guys know anyway to help lower the character count. I'll update the code with the intended output.

@LeakyNun we don't eat people alive, we kill them first ;)

Is the last line of the grip supposed to have holes? I would think it's supposed to be a rectangle, filled with diagonal lines, instead of ⊓ filled with diagonal lines.

When I solely look at your code for golfing opportunities, I see a few: You can set the y and x inside the print itself, that way you can remove the brackets of the for-loop. You can change the ?"*":" " to chars instead of strings, so you can change it to ?42:' ' to save another byte. You can remove a few unnecessary parenthesis. Result (177 bytes) interface D{static void main(String[]a){for(int z=0,w=new Byte(a[0]),h=new Byte(a[1]),y,x;z<h*w;)System.out.print((x=z++%w)>w-2?"*\n":(y=z/w)%(h-1)*x*((y-x)%3)==0?42:' ');}}

I really recommend getting into golfing, especially with practical languages like Java or C. It really helps when trying to solve (very trivial) difficult challenges that you'll never learn how to solve in class, or being crucified on StackOverflow

Logically, there should be an asterisk (*) every time i == j and i+j==w-1(for diagonals), i == 0 and j == 0 (for top line and left side) and j == w-1 and i==h-1  (for right side and bottom line).
class d {
    public static void main(String[] a) {
        for(int i=0,w=new Byte(a[0]),h=new Byte(a[1]);i<h;i++) {
            for(int j=0;j<w;j++) {
                System.out.print(i==0 || j==0 || i==h-1 || i+j==w-1 || j==w-1 || i==j ? "*":" ");
            }
            System.out.println();
        }
    }
}

I don't know if this is an example of the logic that can be used or a fully golfed code. If it's the second case, there's a lot to golf here. Such as, the useless System.out.println() and all the useless whitespaces between the OR pipes (||) and the ternary operator.

this is just an example to logic @TuukkaX.

The code you provided could be reduced by doing this:

replace * with 42 and " " by ' ' (taking advantage of the charcode for *)
move ((y - x) % 3) to the beginning of the things to be multiplied and remove the surrounding parenthesis
remove surrounding parenthesis from (x > w - 2) and from ((y - x) % 3 * y % (h - 1) * x == 0)

The resulting code would be:
interface r{static void main(String[]a){for(int z=0,w=new Byte(a[0]),h=new Byte(a[1]);z<h*w;){int y=z/w,x=z++%w;System.out.print(x>w-2?"*\n":(y-x)%3*y%(h-1)*x==0?42:' ');}}}

Note: the last line is missing in the example output of the question! The output of the sample code is different.

178 174 chars
interface T{static void main(String[]a){for(int w=new Byte(a[0]),h=new Byte(a[1]),j,i=0;i<h;i++)for(j=0;j<w;System.out.print((i-j)%3*i*j!=0&i<h-1&++j<w?" ":j<w?"*":"*\n"));}}

Try it online!
Readable:
interface T{
    static void main(String[]a){
        for(int w=new Byte(a[0]),h=new Byte(a[1]),j,i=0;i<h;i++)
            for(j=0;j<w;System.out.print(
                    (i-j)%3*i*j!=0&i<h-1&++j<w?" ":j<w?"*":"*\n"));
    }
}

Output for field: 30 10:
******************************
**  *  *  *  *  *  *  *  *  **
* *  *  *  *  *  *  *  *  *  *
*  *  *  *  *  *  *  *  *  * *
**  *  *  *  *  *  *  *  *  **
* *  *  *  *  *  *  *  *  *  *
*  *  *  *  *  *  *  *  *  * *
**  *  *  *  *  *  *  *  *  **
* *  *  *  *  *  *  *  *  *  *
******************************

I don't actually have Java on my computer so I can't test this but I think it should work for 174 bytes and almost definitely could be golfed more
class d{static void main(String[]a){for(int i=0,w=new Byte(a[0]),h=new Byte(a[1]);i<h;i++)for(int j=0;j<w;j++)System.out.print(j==w-1?"*\n":i%h-1==0||!j||i+j%2==0?"*":" ");}}

Whitespace added for clarity:
class d {
    static void string main(String[] a) {
        for(int i=0,w=new Byte(a[0]),h=new Byte(a[1]);i<h;i++)
            for(int j=0;j<w;j++)
                System.out.print(j==w-1 ? "*\n" : i % h-1 == 0 || !j || i+j % 2 == 0 ? "*":" ");
    }
}

print *\n for the last char in each line, * for all of the first and last lines and the first column, and * for any time that the sum of the row and column is even, otherwise prints

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


text:
Evaluate a Dice 10,000 roll
Introduction
Dice 10,000 is a dice game which can be played with 6 dice and something to write. Players roll the dice multiple times a turn and gain a score at the end of it. The player who reaches 10,000 point first wins the game. Calculating the score of one roll is your job in this challenge.
Look here for the full rules.
Please note that the rules (especically the scoring) change from region to region since the game is widely known. We use the rules descibed below.
The Challenge
Given a list of six numbers from one to six representing a dice roll, output their score. The score is calculated in the follwing way:

Ones counts 100 points
Fives counts 50 points
Triplets count their number times 100 points. Three twos for example give 200 points. An exception are three ones which count 1000 points.
Six of the same number count like two triplets as described above. So six threes give 600 points. The same goes for the edge case with the ones: Six ones are 2,000 points.
One die can't be used more than once. If a die is part of a triplet, it does not count for other scorings. The fives in a triplet do not count 50 points in addition to the 500 points they give.
Triples are always counted first to maximize the score. So three fives are never counted as 150 points. Four fives are counted as one triplet and one ordinary five which then gives 550 points.

Notes

The input will always contain six numbers from one to six. You will not recieve invalid input.
The numbers can be in any order. You may not assume any specific ordering.

Rules

Input format is up to  you as long as it's not preprocessed.
Function or full program allowed.
Default rules for input/output.
Standard loopholes apply.
This is code-golf, so lowest byte-count wins. Tiebreaker is earlier submission.

Test cases

[1, 2, 3, 4, 5, 6] -> 150
[1, 1, 1, 2, 3, 5] -> 1050
[1, 1, 1, 1, 1, 1] -> 2000
[2, 2, 2, 2, 2, 2] -> 400
[6, 6, 1, 5, 5, 6] -> 800
[2, 3, 4, 6, 2, 4] -> 0
[1, 5, 1, 5, 1, 5] -> 1500
[5, 5, 5, 5, 2, 3] -> 550
[1, 1, 1, 1, 1, 5] -> 1250
[3, 3, 4, 4, 3, 4] -> 700

Though it has slightly different rules, this made me think of Zilch.

Also, die is the singular form of dice.

Technically, you can use both, but die is preferred.

@ThreeFx "A dice" is still incorrect. See http://english.stackexchange.com/a/167107/125966

@mbomb007 See this.

@mbomb007 In german its the same for singular and plural, why does english has to be so complicated? :P But thanks anyway, die sounds actually better :)

Wow I just noticed that. Funny, actually.

Is a trailing .0 on some (but not all) outputs okay? (i.e. 1000.0)

@Copper Don't see a reason against it, go ahead!

@DenkerAffe ah but is it "Der dice", "Die dice" or "Das dice"?

Can I output nothing instead of 0?

@DenkerAffe What Dave said. Having 2 words is better than having 3 articles to memorize for every noun.

@mbomb007 Actually you need only two articels, one for the singular and one for the plural. But anyway, I was joking ofc ;)

@DenkerAffe From the number of possible articles, though. Der, das, die.

@mbomb007 There are even more, depending on the case ^^

@Riley Gonna go with no on that, sorry. Output should always be a number.

@Dave Or "einen Dice", "dem Dice", "ein Dice", "eine Dice"...

05AB1E, 34 31 30 bytes
7G¹N¢O3‰N*2LRN1Q+°*X5‚Nå_i¨}OO

Explanation
7G                                  # for N in 1..6
  ¹N¢O                              # count number of occurrences of N in input
      3‰                            # divmod 3
        N*                          # multiply by N
          2LRN1Q+°*                 # multiply by 10, 100 or 1000
                   X5‚Nå_i¨}        # if N is not 1 or 5, scrap the singles
                            OO      # sum all triple and single scores so far
                                    # implicitly display total sum

Try it online

Python 2, 152 148 125 bytes
Pretty simple solution. Can be golfed more. L.count is a bit long, but I couldn't remove the first call because L is updated.
def f(L):s=n=0;exec"n+=1\nwhile L.count(n)>2:s+=[n*100,1e3][n<2];exec'L.remove(n);'*3\n"*6;C=L.count;print s+100*C(1)+50*C(5)

Try it online - (all test cases)
Ungolfed:
def f(L,s=0):
    L.sort()
    for n in range(1,7):
        while L.count(n)>2:
            s+=n*100*((n<2)*9+1) # multiply by 10 if n==1
            i=L.index(n)
            L=L[:i]+L[i+3:]
    s+=100*L.count(1)+50*L.count(5)
    print s

Some golf credit to @Copper, using some tips from his code

PowerShell v2+ v3+, 147 144 137 133 bytes
$n=$args[0]|sort;while($n){if(($x=$n[0])-eq$n[2]){$s+=100*$x+900*($x-eq1);$a,$b,$n=$n}else{$s+=50*($x-in1,5)+50*($x-eq1)}$a,$n=$n};$s

Crossed out 144 looks kinda like 144?
Takes input $args[0] and sorts it, stores it into $n. Then, while there are still elements left, we evaluate an if/else.
If the first element (temp stored into $x to save some bytes) matches the third element, we have a triple. Add onto the $sum the result of some multiplication 100*$x plus a Boolean-based 900 only if $x is -equal to 1. This gets us the requisite 1000 for three ones. Then, peel off the first two elements into $a, and $b, and the remaining into $n -- removing the third element of the triple is handled later.
Otherwise, we don't have a triple, so add on to $sum the result of another Boolean-based addition. We add 50 if $x is either 1 or 5, then add on another 50 if it's -equal to 1. This section now requires v3+ for the -in operator.
In either case, we still have an element yet to remove, so peel off the first element into $a and leave the remaining in $n.
Finally, once the loop is done, place $s on the pipeline. Output is an implicit Write-Output at the end of execution.
Test cases
PS C:\Tools\Scripts\golfing> (1,2,3,4,5,6),(1,1,1,2,3,5),(1,1,1,1,1,1),(2,2,2,2,2,2),(6,6,1,5,5,6),(2,3,4,6,2,4),(1,5,1,5,1,5),(5,5,5,5,2,3),(1,1,1,1,1,5),(3,3,4,4,3,4)|%{($_-join',')+" -> "+(.\evaluate-dice-1000.ps1 $_)}
1,2,3,4,5,6 -> 150
1,1,1,2,3,5 -> 1050
1,1,1,1,1,1 -> 2000
2,2,2,2,2,2 -> 400
6,6,1,5,5,6 -> 800
2,3,4,6,2,4 -> 0
1,5,1,5,1,5 -> 1500
5,5,5,5,2,3 -> 550
1,1,1,1,1,5 -> 1250
3,3,4,4,3,4 -> 700

in re: 'crossed out 144': bold your strikethrough, it'll be more obvious.

Ruby, 80 78 bytes
Try it online!
-2 byte from @ezrast.
->d{s=0;7.times{|i|c=d.count i;i<2&&i=10;s+=c>2?c/3*i*100:1>i%5?c%3*i*10:0};s}

This gives me a SyntaxError. I think you need a space after the first colon.

@Jordan Even though it worked fine on repl.it it still breaks... it's OK, I rearranged the logic to not require it any more

i<2&&i=10 saves you 2 bytes.

JavaScript (ES6), 87 86 bytes
a=>a.sort().join``.replace(/(.)\1\1|1|5/g,s=>r+=s>>7?s/1.11:s>5?1e3:s>1?50:100,r=0)&&r

Sorts and stringifies the input so that scoring combinations can be identified by means of regexp. Edit: Saved 1 byte thanks to @Arnauld.

s>>7 instead of s>111 saves one byte in the first version

Python 2 or 3, 123 122 121 116 109 108 104 102 100 97 bytes
Python 2, 97 bytes
lambda r:100*sum(c/3*((v<2)*9+v)+c%3*(v<2or(v==5)/2.)for v,c in enumerate(map(r.count,range(7))))

Test cases are on ideone
Python 3, 97 bytes
lambda r:100*sum(c//3*((v<2)*9+v)+c%3*(v<2or(v==5)/2)for v,c in enumerate(map(r.count,range(7))))

Haskell, 130 123 bytes
This is not a challenge for Haskell. Also I am in golfing this.
Thanks to @nimi.
import Data.List
f=g.sort
g(x:a@(y:z:b))|x>z=j x+g a|0<1=100*h x+g b
g(x:y)=j x+g a
g _=0
h 1=10
h x=x
j 1=100
j 5=50
j _=0

Perl, 69 bytes
Includes +2 for -ap
Run with the input on STDIN:
dice10000.pl <<< "5 1 1 1 1 1"

dice10000.pl:
#!/usr/bin/perl -ap
$_=join 0,sort@F,A;print;s%(10|\d)\1\1|10|5%$n+=$1.0||$&%eg;$_=$n.0

This doesn't seem to work for an input like "2 2 2 2 2 2"

Python 3, 131 bytes
lambda r,C=list.count:sum([x%7*100,1e3][x%7<2]*(C(r,x%7)>2and not exec('r.remove(x%7);'*3))for x in range(14))+50*C(r,5)+100*C(r,1)

This is a lambda expression; to use it, assign it by prepending f=.
We first check for triples twice (by using modulus), removing the triples as we go; then we simply add the counts of 5 and 1 to the score and return it.
Try it on Ideone! (with all test cases)
Here's my older Python 2 submission:
Python 2, 176 172 171 145 136 134 133 bytes
def e(r):s=x=0;exec'x+=1;a=x%7;\nif r.count(a)>2:exec"r.remove(a);"*3;s+=[a*100,1e3][a<2]\n'*14;C=r.count;s+=50*C(5)+100*C(1);print s

Saved a byte on the Python 2 solution thanks to @mbomb007!

print s is shorter in Python 2.

@mbomb007 Thanks! I'll edit that in.

BASH (sed + bc) 161
sed -re's/([1-6])(.*)\1(.*)\1/\100\2\3/g;s/([1-6])( .*)\1( .*)\1/\100\2\3/g;s/10/1/g; s/1/100/g;s/5( |$)/50 /g;s/[1-6][^0]//g;s/ +/+/g;s/(^\+|\+$)//g;s/^$/0/'|bc

I wanted to do it all in sed, but addition is really hard...
Explanation:

Find a triplet, add 00 to the first number and remove the other
e.g. 1 2 1 3 1 4 -> 100 2 3 4
Repeat step 1 incase there are two triples
Replace 10 with 1 then 1 with 100
e.g. 100 -> 10 -> 1000 or 1 -> 1 -> 100
Replace each 5 not followed by 0 with 50
Remove any number that doesn't end in 0
Replace groups of spaces with +
Remove leading and trailing +s
If the string is empty, add a 0
Lastly pipe to bc to add everything up.

Javascript (ES6), 85 84 bytes
x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

Test cases:

let F =
x=>x.map(v=>s+=v*(((z+=1<<v*3)>>v*3&7)%3?v-5?v-1?0:10:1:v-5?v-1?10:80:8),s=z=0)|10*s

console.log(F([1, 2, 3, 4, 5, 6])); // 150
console.log(F([1, 1, 1, 2, 3, 5])); // 1050
console.log(F([1, 1, 1, 1, 1, 1])); // 2000
console.log(F([2, 2, 2, 2, 2, 2])); // 400
console.log(F([6, 6, 1, 5, 5, 6])); // 800
console.log(F([2, 3, 4, 6, 2, 4])); // 0
console.log(F([1, 5, 1, 5, 1, 5])); // 1500
console.log(F([5, 5, 5, 5, 2, 3])); // 550
console.log(F([1, 1, 1, 1, 1, 5])); // 1250
console.log(F([3, 3, 4, 4, 3, 4])); // 700

C# (.NET Core), 228 227 bytes
class A{static void Main(string[] a){int[] x=new int[7];int i=0,s=0;for(;i<6;i++)x[int.Parse(a[i])]++;while(i>0){while(x[i]>2){s+=i>1?10*i:100;x[i]-=3;}i--;}while(x[1]-->0)s+=10;while(x[5]-->0)s+=5;System.Console.Write(s*10);}}

Try it online!
I feel like I'm missing many, many potential optimizations here, but I did save a byte by multiplying by 10 at the end.  Input should be passed as separate command line args.

Perl 5 -ap, 78 bytes
$_=join'',sort@F;s|(\d)\1\1|!($\+=$1*($1-1?2:20))|ge;$\+=y/5//+2*y/1//}{$\*=50

Try it online!

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

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


text:
The coin catastrophe
In Golfenhagen, The people are allowed, and encouraged, to melt down old coins for scrap metal, if the smelter can make a profit off of it. There are 5 coins that make the Golfenhagen mint. The half-penny(0.5)(H), the penny(1)(P), the tea (5)(T), the flag (10)(F), and the driver (25)(D). Golfenhagen also mints bills, in the form of 100(O), 500(E), 1000(N), and 2500(Y). Recently, the price of metals has plumetted to an all time low, and so everybody is trying to give their coins away, as they are worth less than the bills.
A humble software engineer decides to write a program that will guarantee that those who pay with cash will always get at least 9 coins back on any purchase whose net difference is bigger than 3 cents.
Your challenge:
Take on the role of developer, and write a program that takes one input (the net difference of the money handed out and the purchase total) and outputs the correct change.
You must:

Make your program put out a nominal of 9 coins with any decimal, except where the difference is less than 5 cents (5).
Make your program output a diverse set of coins, all coins MUST be able to be outputted by your program. no giving change in exclusively in halfcents.
Use the dollar bills where applicable.
This is a golf, the shortest code wins

Examples:

301
  OODDDTTTTTP

This is a valid output. There are two dollars ("OO"), and 9 coins ("DDDTTTTTP ").

5693
  2Y1E1O2D3F2T3P

This is also valid output, as it specifies the currency type and quantities, and has 10 coins.

412
  OOOODPP

This is not valid output, as it only uses 3 coins.

20
  10P20H

This is not valid, see the second rule
Code example of a change counter for the least change possible. (as requested per cold golf)
package lookup;

public class Main {

    static void main(String[]s) {

        int changeincents = 53;
        int quartercount  =  0;
        int dimecount     =  0;
        int nickelcount   =  0;
        int pennycount    =  0;
        while(changeincents >= 25){//value of a quarter
            quartercount++;
            changeincents-=25;
        }
        while(changeincents >= 10){
            dimecount++;
            changeincents-=10;
        }
        while(changeincents >= 5){
            nickelcount++;
            changeincents-=5;
        }
        while(changeincents >= 1){
            pennycount++;
            changeincents--;
        }
    }
}

Good luck!

Use the dollar bills where applicable How will you ensure this rule is followed? Is there a way to calculate that using dollar bills is better in a specific situation?

I don't understand how one option is chosen when there's multiple choices.

@ColdGolf well, aside from the 9 coins, the consumers typically want the least ammount of change possible.

Is there a way to calculate "the least amount of change possible" in a given situation?

@ColdGolf add ing example of change counter to OP

Thanks! I think this is indeed an interesting challenge.

Your code suggests we should just greedily take the largest coin to use as few coins as possible. If so, I suggest removing these contradictory bullets: "Make your program put out a nominal of 9 coins with any decimal, except where the difference is less than 5 cents (5). - Make your program output a diverse set of coins, all coins MUST be able to be outputted by your program. no giving change in exclusively in halfcents. - Use the dollar bills where applicable."

I also don’t really understand the question as it’s currently written. AIUI, there is some leeway, and there are multiple valid outputs for each input; is that right?

On my reading of the question, I could always output 10 half-pennies and then pass the remainder to an answer to this older question.

@PeterTaylor sure, so long as the second rule is followed.

In that case it should be closed as a duplicate.

@PeterTaylor sure, and all other money related golfs as well. /s

Haskell, 177 165 bytes
Thanks to @Lynn.
f n|n>2504='Y':f(n-2500)|n>1004='N':f(n-1000)|n>504='E':f(n-500)|n>104='O':f(n-100)|n>29='D':f(n-25)|n>14='F':f(n-10)|n>9='T':f(n-5)|n>6='P':f(n-1)|0<1=[1..2*n]>>"H"

In a readable format:
f n
  | n > 2504 = "Y" ++ f(n-2500)
  | n > 1004 = "N" ++ f(n-1000)
  | n > 504 = "E" ++ f(n-500)
  | n > 104 = "O" ++ f(n-100)
  | n > 29 = "D" ++ f(n-25)
  | n > 14 = "F" ++ f(n-10)
  | n > 9 = "T" ++ f(n-5)
  | n > 6 = "P" ++ f(n-1)
  | 0 < 1 = replicate (2*n) 'H'

Just give out the biggest denomination which still leaves more than 5 cents to fill with halfcoins.

Some tips: replicate(2*n)'H' is [1..2*n]>>"H", and "A"++b is 'A':b.


text:
Figure Out the Android Lock Pattern
Lets say you saw your friend enter his or her password into their Android phone.  You don't remember how they made the pattern but you remember what the pattern looks like.  Being the concerned friend that you are you want to know how secure their password is.  Your job is to calculate all the ways that a particular pattern can be made.
How Android patterns work
Patterns are drawn on a 3x3 grid of nodes.  In a pattern one visits a series of nodes without ever lifting their finger from the screen.  Each node they visit is connected to the previous node by a edge. There are two rules to keep in mind.

You may not visit any one node more than once
An edge may not pass through an unvisited node

Note that, while typically very hard to perform and thus not very common in real android lock combinations, it is possible to move like a Knight.  That is, it is possible to move from one side to a non-adjacent corner or the other way around.  Here are two examples of patterns employing such a move:

Here is a an animated Gif of it being performed.
Solving a pattern
A typical pattern might look something like this:

With a simple pattern like this one it there are two ways two draw the pattern.  You can start at either of the two loose ends and traveling through the highlighted nodes to the other.  While this is true for many patterns particularly ones that human beings typically employ this is not true for all patterns.
Consider the following pattern:

There are two immediately recognizable solutions.  One starting in the upper left:

And one starting in the bottom center:

However because a line is permitted to pass through a point once it has already been selected there is an additional pattern starting in the top middle:

This particular pattern has 3 solutions but patterns can have anywhere between 1 and 4 solutions[citation needed].
Here are some examples of each:
1.

2.

3.

4.

I/O
A node can be represented as the integers from zero to nine inclusive, their string equivalents or the characters from a to i (or A to I).  Each node must have a unique representation from one of these sets.
A solution will be represented by an ordered container containing node representations.  Nodes must be ordered in the same order they are passed through.
A pattern will be represented by an unordered container of pairs of nodes. Each pair represents an edge starting connecting the two points in the pair.  Pattern representations are not unique.
You will take a pattern representation as input via standard input methods and output all the possible solutions that create the same pattern via standard output methods.
You can assume each input will have at least one solution and will connect at least 4 nodes.
You may choose to use a ordered container in place of an unordered one, if you so desire or are forced to by language selection.
Test Cases
With the nodes arranged in the following pattern:
0 1 2
3 4 5
6 7 8

Let {...} be an unordered container, [...] be a ordered container, and (...) be a pair.
The following inputs and outputs should match
{(1,4),(3,5),(5,8)} -> {[1,4,3,5,8]}
{(1,4),(3,4),(5,4),(8,5)} -> {[1,4,3,5,8]}
{(0,4),(4,5),(5,8),(7,8)} -> {[0,4,5,8,7],[7,8,5,4,0]}
{(0,2),(2,4),(4,7)} -> {[0,1,2,4,7],[1,0,2,4,7],[7,4,2,1,0]}
{(0,2),(2,6),(6,8)} -> {[0,1,2,4,6,7,8],[1,0,2,4,6,7,8],[8,7,6,4,2,1,0],[7,8,6,4,2,1,0]}
{(2,3),(3,7),(7,8)} -> {[2,3,7,8],[8,7,3,2]}
{(0,7),(1,2),(1,4),(2,7)} -> {[0,7,2,1,4],[4,1,2,7,0]}
{(0,4),(0,7),(1,3),(2,6),(2,8),(3,4),(5,7)} -> {[1,3,4,0,7,5,8,2,6]}
{(1,3),(5,8)} -> {}

An imgur album of all the test cases as pictures can be found here.  Patterns are in blue solutions in red.
Scoring
This is code golf. Fewest bytes wins.

Nice question, I often wondered the same in private. :)

Are you going to answer this one in brainflak? Now that would be impressive. :P

Which is a pattern which can only be solved one way? I think you have at least 2 just by trivially reversing the arrows.

@DJMcMayhem I will try but I can't make any promises

@ThreeFx Try this one for yourself.  Because you cannot stop at a node that has already been visited but you can pass through one patterns can be made directional.

Oh yeah, you're right. That's what I get for belonging to the dark side in that regard.

I use the Knight in my Pattern passwords all the time! Now I have a better phone though and can unlock it in a variety of different ways.

You say: "Each node they visit is connected to the previous node by a edge."  Shouldn't the pattern for test case #1 be: {(1,4), (4,3), (3,5),(5,8)}? Otherwise, it suggests that node 4 is not connected to node 3.

@DavidC the (4,3) connection is made by the (3,5) connection.  The (3,5) connection implies a (4,3) and (4,5) connection.  The sentence you cite is not related to this.  It talks about how the combination works not how the representation works.

How about a pattern that have no valid answer, can I ignore it?

@ChristianIrwan If there is no valid answer you must output an empty container.  I will add a test case.

Can I brute-force?

@ChristianIrwan what do you mean?  You can choose whichever algorithm you wish as long as it solves the problem. You will have to verify that it works somehow.

Python 2.7, 493 430 bytes
exec("L=['012','345','678','036','147','258','048','246'];L+=[i[::-1]IL];S=sorted;F=lambda t:''.join(str(i)It)\ndef N(x):\n s=' '.join(F(S(i))Ix)\nIL:s=s.replace(i[::2],i[:2]+' '+i[1:])\n return S(set(s.split()))\ndef P(s):\n e=0\nIL:e|=-1<s.find(i[::2])<s.find(i[1])\n return[zip(s[:-1],s[1:]),L][e]\nx=N(input());print[F(i)I__import__('itertools').permutations({iI`x`if i.isdigit()})if x==N(P(F(i)))]".replace('I',' for i in '))

The single line version wraps the program with exec("...".replace('I',' for i in ')) so that all for-loops and generators can be shorted with a single I and saves 15 bytes over this more readable version:
L=['012','345','678','036','147','258','048','246'];L+=[i[::-1]for i in L]
S=sorted;F=lambda t:''.join(str(i)for i in t)
def N(x):
 s=' '.join(F(S(i))for i in x)
 for i in L:s=s.replace(i[::2],i[:2]+' '+i[1:])
 return S(set(s.split()))
def P(s):
 e=0
 for i in L:e|=-1<s.find(i[::2])<s.find(i[1])
 return[zip(s[:-1],s[1:]),L][e]
x=N(input())
print[F(i)for i in __import__('itertools').permutations({i for i in`x`if i.isdigit()})if x==N(P(F(i)))]

The program takes the input in the manner shown (e.g. {(1,4),(3,4),(5,4),(8,5)}) or as a list of string (e.g. ['14','34','54','85']) (or in other python friendly formats) and returns the output as a list of strings. So we technically have an ordered container of ordered containers.
The function N normalizes a pattern so that two patterns can be easily compared. The normalization sorts the pairs denoting edges (so '02' instead of '20'), use string replacement to expand double edges (e.g. '02' becomes '01 12'), splits the edges into a set to remove duplicates, and sorts the result.
The function F flattens tuples of ints/strings to strings, so we can normalize paths produced in different ways.
The list L contains all lines on screen.
We then take each permutation of all digits in the normalized pattern and compute a valid path or L if invalid (which never normalizes to list of pairs like real paths would), or a list of pairs indicating the order nodes are visited if valid. If this normalizes to the same pattern then we have a valid solution and include it in the final list.
The main check needed to validate a permutation as a string s is -1<s.find(i[::2])<s.find(i[1]), which detects an error with a line i. For instance with the line '210' the code detects an error if '20' occurs (i.e. it's index is greater than -1) and '1' occurs after it. We don't have to worry about 1 not occurring because the 1 will show up in the normalized pattern when it wasn't in the input.

NOTE: I know replacing str(i)for i in t with map(str,t) and {i for i in`x`if i.isdigit()} with set('012345678')&set(`x`) would make the original code shorter, but this would still be slightly longer that substituting I.

False could be 1<0 and there is an useless whitespace at F(i) for. +1.

@TuukkaX Thanks, I face palmed when I saw I left False in.

['012','345','678','036','147','258','048','246'] can be '012 345 678 036 147 258 048 246'.split()' for -1 byte.


text:
What base is this number in?
Here's a nice easy challenge:

Given a string that represents a number in an unknown base, determine the lowest possible base that number might be in. The string will only contain 0-9, a-z. If you like, you may choose to take uppercase letters instead of lowercase, but please specify this. You must output this lowest possible base in decimal.

Here is a more concrete example. If the input string was "01234", it is impossible for this number to be in binary, since 2, 3, and 4 are all undefined in binary. Similarly, this number cannot be in base 3, or base 4. Therefore, this number must be in base-5, or a higher base, so you should output '5'.
Your code must work for any base between base 1 (unary, all '0's) and base 36 ('0-9' and 'a-z').
You may take input and provide output in any reasonable format. Base-conversion builtins are allowed. As usual, standard loopholes apply, and the shortest answer in bytes is the winner!
Test IO:
#Input          #Output
00000       --> 1
123456      --> 7
ff          --> 16
4815162342  --> 9
42          --> 5
codegolf    --> 25
0123456789abcdefghijklmnopqrstuvwxyz    --> 36

my language doesn't really support string input, may I accept input as ascii integers separated by newlines?

I know it seems a bit "unreasonable" so I doubt its ok

@RohanJhunjhunwala, what's your language?

S.I.L.O.S https://github.com/rjhunjhunwala/S.I.L.O.S @Dopapp

In Python 3, could I take input as a byte string?

Can I output in base 36?

@LeakyNun Geez, I hope not.

@LeakyNun You must output this lowest possible base in decimal.

@RohanJhunjhunwala If that's your languages closest equivalent to a string, I don't see why not.

@Peter, I was just looking for dupes, but I think http://codegolf.stackexchange.com/q/48952/8478 is a better fit?

Although this is only a subset of the earlier question, it's a subset which is easy to extract.

@MartinEnder, you're right. Do you need me to retract my close vote, or are your powers sufficient without?

@PeterTaylor I can undo it myself, don't worry. (Although I do think the new spec is better than the old...)

Wait actually, I'm not sure it's a dupe of either. This only asks for the base, not for the actual conversion... I'll reopen this and let the community decide, but I don't think we'd close a prime-testing challenge as a dupe of any other challenge requiring a primality test either.

Usually unary is all 1s, and leading zeros are not standard for any positional-based numeric system.

Well, you lost me after the fourth test input.

if for hex the Greater digit is F, than yes for 36 is Z

Jelly, 4 bytes
ṀØBi

Requires uppercase. Try it online! or verify all test cases.
How it works
ṀØBi  Main link. Arguments: s (string)

Ṁ     Yield the maximum of s.
 ØB   Yield "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
   i  Find the 1-based index of the maximum in that string.

It's actually 7 bytes, not 4. The first 2 chars are multi-byte.

@Nicomak This answer is encoded in the Jelly code page, where all of these characters are encoded as 1 byte each.

Python, 27 22 bytes
lambda s:(max(s)-8)%39

This requires the input to be a bytestring (Python 3) or a bytearray (Python 2 and 3).
Thanks to @AleksiTorhamo for golfing off 5 bytes!
Test it on Ideone.
How it works
We begin by taking the maximum of the string. This the code points of letters are higher than the code points of digits, this maximal character is also the maximal base 36 digit.
The code point of '0' – '9' are 48 – 57, so we must subtract 48 from their code points to compute the corresponding digits, or 47 to compute the lowest possible base. Similarly, the code points of the letters 'a' – 'z' are 97 – 122. Since 'a' represents the digit with value 10, we must subtract 87 from their code points to compute the corresponding digits, or 86 to compute the lowest possible base. One way to achieve this is as follows.
The difference between 97 and 58 (':', the character after '9') is 39, so taking the code points modulo 39 can achieve the subtraction. Since 48 % 39 = 9, and the desired result for the character '0' is 1, we first subtract 8 before taking the result modulo 39. Subtracting first is necessary since otherwise 'u' % 39 = 117 % 39 = 0.
c    n    n-8    (n-8)%39
0    48    40     1
1    49    41     2
2    50    42     3
3    51    43     4
4    52    44     5
5    53    45     6
6    54    46     7
7    55    47     8
8    56    48     9
9    57    49    10
a    97    89    11
b    98    90    12
c    99    91    13
d   100    92    14
e   101    93    15
f   102    94    16
g   103    95    17
h   104    96    18
i   105    97    19
j   106    98    20
k   107    99    21
l   108   100    22
m   109   101    23
n   110   102    24
o   111   103    25
p   112   104    26
q   113   105    27
r   114   106    28
s   115   107    29
t   116   108    30
u   117   109    31
v   118   110    32
w   119   111    33
x   120   112    34
y   121   113    35
z   122   114    36

If you make it Python 3, and take the input as a byte string, you can drop the ord() and win by 3 bytes. :)

Nice idea! Let me ask the OP.

@AleksiTorhamo NOOOOOOOOOOOO y u do dis

Python, 25 bytes
lambda x:int(max(x),36)+1

Defines a lambda that takes the string x. Finds the largest digit in the string (sorted with letters above digits, by python's default), and converts to base 36. Adds 1, because 8 is not in base 8.

Haskell, 34 bytes
f s=length['\t'..maximum s]`mod`39

Uses the mod(ord(c)-8,39) idea from Dennis.
41 bytes
g '0'=1
g 'W'=1
g x=1+g(pred x)
g.maximum

45 bytes:
(`elemIndex`(['/'..'9']++['a'..'z'])).maximum

Outputs like Just 3.

Cheddar, 34 29 21 bytes
Saved 8 bytes thanks to Dennis!!!
s->(s.bytes.max-8)%39

Uses lowercase letters
Try it online
Explanation
s -> (      // Input is `s`
  s.bytes    // Returns array of char codes
   .max      // Get maximum item in array
) % 39      // Modulus 39

Or you could just put quotes around the input

@DJMcMayhem .___. i didn't even know my own language could do that

How about (-)&8 instead of n->n-8?

@ConorO'Brien >>>_> I haven't gotten to that yet. I was just planning to do it and then this challenge was posted. Bassically f&n bonds n to first arg of the function.

@Downgoat Oh. >_>

Then how about (+)&-8? Nevermind, that doesn't save any bytes...

s->(s.bytes.max-8)%39 saves 8 though, unless I'm missing something.

@Dennis yes it does... >_> I'm not sure how I missed that

05AB1E, 6 bytes
{¤36ö>

Takes letters in upper case.
Explanation
{       # sort
 ¤      # take last
  36ö   # convert from base 36 to base 10
     >  # increment

Try it online

Forgive my naivete with 05AB1E, but do you mean convert FROM base 36 (to base 10)?

@Keeta You are of course correct. My bad.

Julia, 22 bytes
!s=(maximum(s)-'')%39

There's a BS character (0x08) between the quotes. Try it online!

what does the -'' do?

It subtracts 8 from the code point and returns an integer.

Actually, 6 bytes
M6²@¿u

Try it online!

JavaScript (ES6), 41 37 bytes
s=>parseInt([...s].sort().pop(),36)+1

Edit: Saved 4 bytes thanks to @edc65.

use pop() to save 4

@edc65 I can't believe that's not under JavaScript tips.

Perl 6: 18 bytes
{:36(.comb.max)+1}

Defines a lambda that takes a single string argument, and returns an integer. It splits the string into characters, finds the "highest" one, converts it to base 36, adds 1.
{(.ords.max-8)%39}

This one uses the modulo approach from Dennis. Same length.

Haskell, 55 40 bytes
f=(\y->mod(y-8)39).Data.Char.ord.maximum

Thanks @Dennis for his approach. (take that, @xnor ;))

I think you can remove f= for 38 bytes since f doesn't take explicit arguments.

R, 99 89 85 bytes
Look ! Less than 100 bytes !
Look ! 10 bytes off !
Look ! 4 bytes off !
ifelse((m=max(strsplit(scan(,''),"")[[1]]))%in%(l=letters),match(m,l)+10,strtoi(m)+1)

Ungolfed :
l=letters                  #R's built-in vector of lowercase letters

n=scan(what=characters())  #Takes an input from STDIN and convert it to characters

m=max(strsplit(n,"")[[1]]) #Splits the input and takes to max.
                           #`letters` are considered > to numbers (i.e. a>1)

ifelse(m%in%l,match(m,l)+10,strtoi(m)+1) #If the max is in `letters`,
                                             #outputs the matching position of `m`in `letters` + 10 (because of [0-9]).
                                             #Else, outputs `m` (as a number) + 1.

As often, this answer makes use of the ifelse function : ifelse(Condition, WhatToDoIfTrue, WhatToDoElse)

I love your version; however, treating letters and numbers separately creates those pesky extra bytes. Please have a look at my solution that uses a different method.

Your answer is interesting indeed. I will use the your scan method to golf some bytes ;)

Retina, 28 bytes
O`.
.\B

{2`
$`
}T01`dl`_o
.

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

This sorts the characters of the input.
.\B

This removes all characters except the last, so the first two stages find the maximum character.
{2`
$`
}T01`dl`_o

These are two stages which form a loop. The first one duplicates the first character and the second one "decrements" it (replacing e.g. x with w, a with 9 and 1 with 0). The latter stage encounters a zero as the first character, it removes it instead. This is a standard technique for generating a range of characters, given the upper end. Hence, this generates all "digits" from 0 to the maximum digit.
.

Finally, we simply count the number of digits, which gives us the base.

Scala, 25 bytes
print((args(0).max-8)%39)
Run it like:
$ scala whatbase.scala 0123456789abcdefghijklmnopqrstuvwxyz

Java 7, 67 61 bytes
int c(char[]i){int m=0;for(int c:i)m=m>c?m:c;return(m-8)%39;}

(m-8)%39 is thanks to @Dennis' amazing answer.
Ungolfed & test code:
Try it here.
class Main{
  static int c(char[] i){
    int m = 0;
    for(int c : i){
      m = m > c
           ? m
           : c;
    }
    return (m-8) % 39;
  }

  public static void main(String[] a){
    System.out.println(c("00000".toCharArray()));
    System.out.println(c("123456".toCharArray()));
    System.out.println(c("ff".toCharArray()));
    System.out.println(c("4815162342".toCharArray()));
    System.out.println(c("42".toCharArray()));
    System.out.println(c("codegolf".toCharArray()));
    System.out.println(c("0123456789abcdefghijklmnopqrstuvwxyz".toCharArray()));
  }
}

Output:
1
7
16
9
5
25
36

Instead of Math.max() you can use m = m>c?m:c

@RobAu Ah of course, thanks. Completely forgot about it.. Sometimes I forget the easiest codegolfing things in Java that are even mentioned multiple times in the Tips for Codegolfing in Java post. Thanks for the reminder.

If you switch to Java 8 you can replace this whole function with a lambda that does a single reduce

@BlueRaja-DannyPflughoeft I know, which is why I specifically mentioned it as Java 7. Feel free to post a Java 8 lambda as a separate answer.

@BlueRaja-DannyPflughoeft I wonder if that would end up with less bytes..

R, 62 54 bytes
max(match(strsplit(scan(,''),"")[[1]],c(0:9,letters)))

Ungolfed:
max(
  match( # 2: Finds the respective positions of these characters
    strsplit(scan(,''),"")[[1]], # 1: Breaks the input into characters
                                c(0:9,letters)) # 3: In the vector "0123...yz"
                                                )

Update: shaved off 8 bytes due to the redundancy of na.rm=T under the assumption of input validity.
A 39% improvement in size compared to Frédéric's answer. Besides that, it runs a wee bit faster: 0.86 seconds for 100000 replications versus 1.09 seconds for the competing answer. So the one of mine is both smaller and more efficient.

CJam, 10 bytes
Thanks to Martin Ender for saving me a few bytes!
Uses Dennis's formula
q:e>8-i39%

Try it online
CJam, 18 16 btyes
Alternative solution:
A,s'{,97>+q:e>#)

Try it online
A,s'{,97>+       e# Push the string "0123456789abcdefghijklmnopqrstuvwxyz"
          q      e# Get the input
           :e>   e# Find the highest character in the input
              #  e# Find the index of that character in the string
               ) e# Increment

C89, 55 53 52 50 bytes
f(s,b)char*s;{return*s?f(s+1,*s>b?*s:b):(b-8)%39;}

-8%39 shamelessly stolen from Dennis
Test
test(const char* input)
{
    printf("%36s -> %u\n", input, f((char*)input,0));
}

main()
{
    test("00000");
    test("123456");
    test("ff");
    test("4815162342");
    test("42");
    test("codegolf");
    test("0123456789abcdefghijklmnopqrstuvwxyz");
}

Output
                               00000 -> 1
                              123456 -> 7
                                  ff -> 16
                          4815162342 -> 9
                                  42 -> 5
                            codegolf -> 25
0123456789abcdefghijklmnopqrstuvwxyz -> 36

Saved 2 bytes thanks to Toby Speight
Saved 2 bytes thanks to Kevin Cruijssen

You can save 2 bytes with the non-prototype declaration: f(char*s,int b) becomes f(s,b)char*s;.

You can save 3 bytes by removing the unnecessary parenthesis and space: f(s,b)char*s;{return*s?f(s+1,*s>b?*s:b):(b-8)%39;}

@KevinCruijssen thx

C, 55 bytes
This answer assumes that the input is in ASCII (or identical in the numbers and letters, e.g. ISO-8859 or UTF-8):

m;f(char*s){for(m=0;*s;++s)m=m>*s?m:*s;return(m-8)%39;}

We simply iterate along the string, remembering the largest value seen, then use the well-known modulo-39 conversion from base-{11..36}.

Test program
int printf(char*,...);
int main(int c,char **v){while(*++v)printf("%s -> ",*v),printf("%d\n",f(*v));}

Test results
00000 -> 1
123456 -> 7
ff -> 16
4815162342 -> 9
42 -> 5
codegolf -> 25
0123456789abcdefghijklmnopqrstuvwxyz -> 36

Couldn't you remove the m=0? If m appears at the top level of the file, its extern which implies static which implies it is initialized to zero.

@Batman - yes, but only if you won't call f() more than once.  I know that almost anything's fair game in golf, but my professional instincts regard that as too fragile!

On further thought, I could make it an external requirement to reset m between calls to f().  Then my test program could still work.

@Batman: on [meta], the majority opinion on the question "Do function submissions have to be reusable?" seems to be against allowing single-use functions.  So I'll stick with what I have.  Thanks for the suggestion, anyway.

C# REPL, 17 bytes
x=>(x.Max()-8)%39

Just ported @Dennis's answer to C#.

Mathematica, 34 32 bytes
saved 2 bytes thanks to Martin Ender
Max@BaseForm[Characters@#,36]+1&

Defines a pure function that takes a string as input.
Splits the input into characters, converts them to base 36 numbers, and returns the maximum +1.

Max@BaseForm[Characters@#,36]+1&

Mathematica, 34 32 bytes
2 bytes saved thanks to Martin Ender
Max@Mod[ToCharacterCode@#-8,39]&

I decided the different method deserved a new answer.
method stolen inspired by Dennis' solution

Use some prefix notation: Max@Mod[ToCharacterCode@#-8,39]& (same goes for your other answer)

Also, you need to add & to the end to indicate an anonymous function.

You forgot one @ in both of your answers (ToCharacterCode@# and Characters@#).

PHP, 51 38 bytes
(From Dennis) ^^
<?=(ord(max(str_split($argv[1])))-8)%39;

Other proposal without Dennis' trick
<?=($a=max(str_split($argv[1])))<a?$a+1:ord($a)-86;

Takes input as argument $argv[1];
Take max character (using ASCII) values
If it is a number (inferior to < 'a' ascii value) then output number+1
Else output ascii value -86 (97 for 'a' in ascii, -11 for 'a' is 11th base-digit)

It's too bad PHP has such verbose function names: <?=base_convert(max(str_split($argv[1])),36,10)+1 is an elegant solution, but at 49 bytes!

@YiminRong you can use intval() instead of base_convert() which shortens down to 38 bytes <?=intval(max(str_split($argn)),36)+1; tio: https://tio.run/##K8go@P/fxt42M6@kLDFHIzexQqO4pCi@uCAns0RDJbEoPU9TU8fYTFPb0Pr//@T8lNT0/Jy0f/kFJZn5ecX/dd0A

Octave, 20 bytes
@(a)mod(max(a)-8,39)

Pyke, 6 bytes
Seb36h

Try it here!
Se     -   sorted(input)[-1]
  b36  -  base(^, 36)
     h - ^ + 1

Vyxal, 6 bytes
kr$Gḟ›

Try it Online!

Perl, 30 27 bytes
Includes +1 for -p
Run with the input on STDIN, e.g.
base.pl <<< codegolf

base.pl:
#!/usr/bin/perl -p
\@F[unpack"W*"];$_=@F%39-9

BASH 70
grep -o .|sort -r|head -c1|od -An -tuC|sed s/$/-86/|bc|sed s/-/39-/|bc

Input letters are lowercase.

R, 59 57 bytes
Thanks to @Andreï-Kostyrka for two bytes.
max(which(c(0:9,letters)%in%strsplit(scan(,""),"")[[1]]))

scan(,'') takes the input and coerces it to a string. Then strsplit divides it into its individual characters. [[1]] is because that returns a list. %in% then checks which of the vector 0,1,2,...,8,9,a,b,c,...,x,y,z is in the input. which tells us the place in that vector of items in the input -- and max finds the biggest place -- which corresponds to the base.

Try removing the two extra spaces to save 2 bytes.

Powershell, 62 bytes
function t($s){(($s[0..$s.Length]|measure -Max).Maximum-8)%39}

%39 @Dennis, of course :)

Input through a variable isn't one of our accepted input methods, so unless I've misunderstood something, you should revert to using a function or convert this snippet to a full program.

JavaScript, 57 50 48 bytes
7 bytes saved thnks to @kamaroso97
2 bytes saved thanks to @Neil
n=>Math.max(...[...n].map(a=>parseInt(a,36))+1)

Original answer:
n=>n.split``.map(a=>parseInt(a,36)).sort((a,b)=>b-a)[0]+1

You can knock off 7 bytes with n=>Math.max(...n.split``.map(a=>parseInt(a,36)+1)).

@kamoroso94 I didn't realize Math.max existed. Thanks for telling me about it!

[...s] is shorter than s.split\``.

Dyalog APL, 10 bytes
Prompts for uppercase input.
⌈/⍞⍳⍨⎕D,⎕A

⌈/ maximum
⍞ characters of input
⍳⍨ 1-indexed into
⎕D, all digits followed by
⎕A all characters
TryAPL online!

LiveScript, 32 bytes
->1+parseInt (it/'')sort!pop!,36

A port of this answer in my favorite language that compile to JavaScript. If base~number operator worked with variables I could write ->1+36~(it/'')sort!pop! (23 bytes), but it conflicts with the function bind operator :/

PowerShell full program, 56 62 bytes
lowercase letters required.
([int]((read-host).ToCharArray()|sort|select -l 1)-8)%39

05AB1E, 3 bytes
Hà>

Try it online or validate all test cases.
Explanation:
          # implicit input
H         # convert each digit to decimal
 à        # maximum
  >       # add 1
          # implicit output

Thunno 2 G, 4 bytes
36b⁺

Try it online!
Takes input in uppercase.
Explanation
36b⁺  # Implicit input
36b   # Convert each character from base-36
   ⁺  # Increment each integer
      # Implicit output of maximum


text:
Text animation format Code Golf
Working with old files from DOS, I found an ancient text animation format, that specify how much time each frame must be shown in the screen. It's very simple:

F1W5F2W3

This example above indicates that Frame 1 must be shown for 5 units of time, and frame 2 for 3 units more. Now I want to convert it to:

1, 1, 1, 1, 1, 2, 2, 2

In the converted example below, frame 1 is repeated 5 times, and frame 2 three times.
Rules: The only allowed letters are F and W (and the lowercase counterparts, f and w). Numbers can go up to 255. Total input String with no more than 255 chars.
Other examples:

Input: F10W3F11W3F10W3F12W3
Output: 10, 10, 10, 11, 11, 11, 10, 10, 10, 12, 12, 12
Input: f1w0f2w10
Output: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2

Short code wins.
Edited - Accepted formats:
Any answer containing the output and ignoring spaces. Ex: 1, 1, 2, 2 or [1,1,2,2] or (1,1,2,2). But NOT 1 1 2 2 or [1; 1; 2; 2] or [1 1 2 2].

Welcome to Programming Puzzles & Code Golf! Just so you know, bonuses in code golf are discouraged.

Ok, thank you for the information. I have removed the bonus.

This might be a duplicate of this run-length decoding challenge.

Not a duplicate, because in the link above the numbers range from 1 to 9 only. This makes a big difference.

Do we have to support upper and lower case? Or just one or the other?

Would it be acceptable to output an extra comma at the end of the output?

Can the output be only comma separated I.e. 10,10,10 instead of 10, 10, 10?

I don't see as a problem having spaces (or not) between commas. But it is not acceptable to output an extra comma at the end of the output (just for fairness with other competitors).

What output formats are accepted, exactly? [1, 1, 2, 2] as in some answers?  [1 1 2 2]? [1; 1; 2; 2]?

@LuisMendo Edit made for this.

I don't think having multiple-digit numbers is enough of a difference to make this not a duplicate. It's a very minor change for most solutions, especially the regex-based ones.

Pyth, 13 bytes
smMcr7Xrz0Gd2

Test suite
This program uses one of my favorite tricks, mM, which maps the map function over a list. It is also uses a relic of Pyth's distant past, the r7 function, which splits a string on whitespace and evaluates the contents, which just so happens to be absolutely perfect for this challenge. Here's how it works, and each intermediate state:
smMcr7Xrz0Gd2     f1W5F2w3

        z        "f1W5F2w3"       Implicit: z is the input.
       r 0       "f1w5f2w3"       Lowercase
      X   Gd     " 1 5 2 3"       Replace all lowercase letters (G) with spaces (d)
    r7           [1, 5, 2, 3]     Split on whitespace, eval each string.
   c        2    [[1, 5], [2, 3]] Split into groups of length 2
 mM                               Apply the map function to each pair
                 [[1, 1, 1, 1, 1], [2, 2, 2]]
s                                 Flatten
                 [1, 1, 1, 1, 1, 2, 2, 2]

Python 3, 57 bytes
lambda s:eval(s.upper().translate({70:'+[',87:']*'})[1:])

Turns a string like
f1w0f2w10

into a expression like
[1]*0+[2]*10

that it evaluated as code. This is done by turning the string uppercase, turning each f into +[ and each w into ]*, and removing the initial +. Thanks to Dennis for saving 7 bytes in Python 3 by using translate with a dictionary.

lambda s:eval(s.upper().translate({70:'+[',87:']*'})[1:]) saves 7 bytes in Python 3.

@Dennis Thanks, I'd been trying to get that to work with a list, didn't think to use a dictionary.

3 bytes more to have it match the examples: eval(input().upper().translate({70:'+", ',87:'"*'})[1:])[2:]

V, 25 bytes
Óá¨ä«©á¨ä«©/²a±,
D@"hD

Try it online!
Here is a hexdump of the answer, which is encoded in latin1:
0000000: d3e1 a8e4 aba9 e1a8 e4ab a92f b261 b12c  .........../.a.,
0000010: 2016 1b0a 4440 2268 44                    ...D@"hD

Explanation:
<C-v> is byte 0x16 and <esc> is byte 0x1B. Since they are both unprintable, I am using this notation to refer to them.
Óá¨ä«©á¨ä«©/²a±, <C-v><esc>

This is a compressed regex, that basically transforms the input into V code. Here's what the buffer looks like after running this regex:
3a10, <esc>3a11, <esc>3a10, <esc>3a12, <esc>

Here's how that works:
3           "3 times:
 a    <esc> "Append the following text:
  10,       " '10, '

Running this in V (or its parent, vim) would create:
10, 10, 10,

And then a similar command repeats for each element of the input.

So, after running this regex, we've got valid V code that will create the desired output. Thankfully, V can easily self-interpret, as long as the code is in a buffer. So, we run the following:
D      "Delete this line into the unnamed register
 @"    "Run the text in the unnamed register as V code

This is exactly what we want, but now the output has a trailing ,. So:
h      "Move one character to the left. Now we are on the second to last character
 D     "Delete until the end of the current line

Pyth, 18 bytes
r_McvM:z"\d+"1 2 9

Try it online. Test suite.

MATL, 22 bytes
t58<*cU2eZ}Y"&D32','XE

Try it online!
Explanation
t        % Implicitly input string, say 'F10W2F1W3'. Duplicate
58<      % Array that contains 1 for numeric chars, 0 otherwise: [0 1 1 0 1 0 1 0 1]
*        % Multiply element-wise. Converts chars to numeric code
c        % Cast to char. Gives the original string with letters replaced by char 0
U        % Interprets as a numeric array. So the string ' 10 2 4 3' (where spaces are
         % actually char 0) gives the array [10 2 4 3]
2e       % Reshapes into a 2-column array in column-major order: [10 4; 2 3]
Z}       % Split into rows: [10 4], [2 3]
Y"       % Run-length decoding: [10 10 4 4 4]. Implicitly display
&D       % Get string representation, in the format '[10 10 4 4]'
32','XE  % Replace spaces by commas

Where are the commas? ;-)

@Chaotic I thought the output format was flexible, as usual. I'll try to solve that later, I'm seeing this on the phone now

@Chaotic Solved (9 bytes!)

Jelly, 18 (strict), 8 (relaxed) bytes
Strict input (any upper or lower) & strict output form of a flat list
Œl“wẋ”yṣ”fj“ð;ø”VḊ

How?
Œl“wẋ”yṣ”fj“ð;ø”VḊ - takes an input, example: F11w7f13W5F17w3f19W2
Œl                 - to lower case            f11w7f13w5f17w3f19w2
  “wẋ”             - make string "wẋ"
      y            - map "w":"ẋ"              f11ẋ7f13ẋ5f17ẋ3f19ẋ2
        ”f         - make string "f"
       s           - split on "f"             [,11ẋ7,13ẋ5,17ẋ3,19ẋ2]
           “ð;ø”   - make string "ð;ø"
          j        - join with "ð;ø"s         ð;ø11ẋ7ð;ø13ẋ5ð;ø17ẋ3ð;ø19ẋ2
                V  - eval Jelly code...
each ẋ will repeat left right times, e.g. 17ẋ3 yields [17,17,17]
; will concatenate,
ð will treat the last chain as a dyadic link (the first will yield 0 as there is no link)
ø will treat the last chain as a niladic link
- so the example evaluates to:
[0, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13, 13, 17, 17, 17, 19, 19]
                 Ḋ - dequeue
[11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13, 13, 17, 17, 17, 19, 19]

Test it at TryItOnline
Non-strict version: only lower input, returns smashed lists [a,a,...][b,b,..][...
“wẋfø”yv

How?
“wẋfø”yv - takes an input, example: f11w7f13w5f17w3f19w2
“wẋfø”   - make the string "wẋfø"
      y  - map "w":"ẋ";"f":"ø"      ø11ẋ7ø13ẋ5ø17ẋ3ø19ẋ2
       v - eval Jelly code left with input right (empty)
           this is a hack as V should work (I think)
           but by forcing no input the leading ø evaluates to nothing
evaluation is as above, but simply yields the ẋ lists in turn
- so the example evaluates to:
[11, 11, 11, 11, 11, 11, 11][13, 13, 13, 13, 13][17, 17, 17][19, 19]

Test it at TryItOnline

Perl 6, 30 bytes
{m:g/\d+/.map:{|(+$^f xx$^w)}}

Anonymous function (aka: lambda) which uses a regex match to pull out all the numbers.
I then map over this list, pulling out 2 items at a time using self-declared positional variables $^f and $^w. Self-declared positional variables are assigned alphabetically, so f and w works nicely.
The regex match actually produces a list of Match objects, so I use the + prefix operator to coerce f to an Int.
The map creates a list of f, w times. This would normally create a List-of-Lists, so I use the Slip prefix operator |. A Slip is a List sub-type that flattens into an outer list, ie. It slips a list into the surrounding list, so in the end we get a flat list.
Usage example: {m:g/\d+/.map:{|(+$^f xx $^w)}}('F1W5F2W3') returns (1, 1, 1, 1, 1, 2, 2, 2).
Here is the same function written as a full-blown named subroutine, with a more explicit definition.
sub f(Str $s) {
    ($s ~~ m:g/\d+/).map(-> $f, $w {
        slip( $f.Int xx $w )
    });
}

The space after xx isn't necessary. I would have used .comb(/\d+/), I will have to remember to try m:g/.../ in the future instead.

My initial solution used comb! I realised the regex match syntax was slightly shorter so I edited my answer. The benefit of using comb is that you don't get Match objects, so no Int coercion necessary inside the map... However, I just Bench'd it and the regex is slightly faster.

05AB1E, 16 bytes
l'f¡vy'w¡`FDïˆ}\

Explanation
                   # implicit input
l                  # convert to lower case: 'f1w5f2w3'
 'f¡               # split on "f": ['','1w5','2w3']
    v              # for each: ex '1w5'
     y'w¡          # split on "w": ['1','5']
         `         # flatten: '5','1'
          FDïˆ}    # N times do; duplicate, convert to int, push to global array: [1,1,1,1,1]
               \   # discard last copy
                   # implicitly print list at the end of the program

Try it online

JavaScript ES6, 68 bytes
s=>s.replace(/F(\d+)W(\d+)/gi,(z,a,b)=>(f=n=>n&&f(n-1,alert(a)))(b))

Hopefully an alert box counts as a frame as I couldn't think of another way to count as a 'frame'.
Slightly modified version to try in-browser

t=function(s){s.replace(/F(\d+)W(\d+)/gi,function(z,a,b){(f=function(n){return n&&f(n-1,alert(a))})(b)})}

// Demo
document.getElementById('go').onclick=function(){
  document.getElementById('output').innerHTML = t(document.getElementById('input').value)
};

Text Animation

<input placeholder="Input here..." style="resize:none;border:1px solid #DDD;" id="input"><button id='go'>Run!</button>

Output:

I don't think you need the F in the regex.

Why are you using alert? As I understand the challenge, the output should be as a single list of frames.

Perl, 28 bytes
27 bytes of code, plus 1 for the p flag in perl -pe '…':
s|f(\d+)w(\d+)|"$1
"x$2|gie

Output for F10W3F11W3F10W3F12W3:
10
10
10
11
11
11
10
10
10
12
12
12

The handicap for -p is only 1 since you can run as perl -pe 'code' which is only 1 character longer than a plain perl -e 'code'. So you are actually at 28 bytes :-)

@TonHospel Scoring flags is so tricky. Thanks!

C#, 160 155 bytes
s=>{var r="";int i=1,j;var t=s.Split('f','F');while(i<t.Length){var u=t[i++].Split('w','W');for(j=0;j++<int.Parse(u[1]);)r+=u[0]+",";}return r.Trim(',');};

VBA, 162 bytes 147 bytes
Okay, this is only for fun since it's kinda hard to beat esoteric programming languages but I don't care too much about winning the challenge. I do enjoy solving the challenge, though. Here is my stab for this challenge:
Function F(a):b=Split(Replace(a,"F","W"),"W"):For i=1To Ubound(b)/2:c="":For j=1To b(2*i):c=c & b(2*i-1) & ",":Next:d=d & c:Next:F=Left(d,Len(d)-1)

Ungolfed the code:
Function F(a)

b = Split(Replace(a, "F", "W"), "W")

    For i = 1 To UBound(b) / 2
        c = ""
        For j = 1 To b(2 * i)
            c = c & b(2 * i - 1) & ","
        Next
        d = d & c
    Next

F = Left(d, Len(d) - 1)

End Function

Explanation:

Substitute the letter F in the string input with W using VBA function Replace.
Split the string result with delimited letter W into a 1D array.
Looping through each element array where every odd element is replicated as many as its next element value (the nearest even element).
Concatenate each of looping output.
Truncate the output so that the trailing , is excluded.

Thanks Kevin Cruijssen for the advice.

I've never programmed in VBA, so correct me if I'm wrong, but isn't there a Replace in VBA which is shorter than Application.Substitute? So b=Split(Replace(a,"F","W"),"W") instead?

@KevinCruijssen Ahh, you're correct. I didn't use it since it Excel function with 5 arguments, I forgot there is a VBA version of it. Edited. Spasibo.

Haskell, 68 bytes
p""=[]
p(_:b)|[(c,_:d)]<-reads b,[(e,f)]<-reads d=(c+0<$[1..e])++p f

Usage example: p "F1W5F2W3" -> [1,1,1,1,1,2,2,2].
reads takes a string and reads something from the front of it and returns a singleton list with a pair of the something and the rest of the string. The type system knows from the usage c+0 and [1..e] that the somethings must be numbers, so reads consumes all digits from the beginning of the string. The _ in the patterns match the letters F and W that we don't need otherwise.

R, 78 bytes
m=strsplit(scan(,""),"[FWfw]")[[1]][-1];cat(rep(m[c(T,F)],m[c(F,T)]),sep=", ")

Credit for the rep(m[c(T,F)],m[c(F,T)]) bit goes to @flodel.
Usage:
> m=strsplit(scan(,""),"[FWfw]")[[1]][-1];cat(rep(m[c(T,F)],m[c(F,T)]),sep=", ")
1: F10W3F11W3F10W3F12W3
2:
Read 1 item
10, 10, 10, 11, 11, 11, 10, 10, 10, 12, 12, 12
> m=strsplit(scan(,""),"[FWfw]")[[1]][-1];cat(rep(m[c(T,F)],m[c(F,T)]),sep=", ")
1: f1w0f2w10
2:
Read 1 item
2, 2, 2, 2, 2, 2, 2, 2, 2, 2

Nice one ! I don't get the m[c(T,F)] part however...

@Frédéric c(T,F) is the same as c(TRUE,FALSE). This vector will get recycled along the indexed vector, meaning in this case that it will be TRUE for each odd member and FALSE for each even member, meaning it will return every odd member of m. Similarly c(F,T) returns every even member.

Credit for that particular bit of code goes to flodel. The linked challenge is very similar to this one.

Pyth, 18 bytes
r9m_sMdcR\Wtcr1Q\F

If you don't need to allow for both upper and lower case, you can take out the r1 for 16 bytes:
r9m_sMdcR\WtcQ\F

Try it online!
Explanation:
            c      split:
             r1Q    the uppercase of the input
                \F  on the letter "F"
           t       Remove the first result
                       The first "F" in the notation has nothing in front of it,
                       so this removes the empty string that prefaces everything
       cR\W        Split each of the results on "W"
  m_               Reverse each of the splits so that the "W" part is first (how many repetitions, then what is to be repeated)
    sMd            Cast everything within the splits to integers
r9                 Run length decode

If the output format is flexible (and many other solutions assume so), you don't need to stringify or remove the opening/trailing braces which should save 3 chars. Also, why do you need to explicitly cast to integer?

Explicit cast to integer is to allow run length decoding (which doesn't work with strings as the "key"). I'll remove the stringification.

Perl, 32 bytes
29 bytes code + 3 for -n.
print"$1 "x$' while/(\d+)w/gi

Usage
cat text-animation.pl
print"$1 "x$' while/(\d+)w/gi
perl -n text-animation.pl <<< 'F1W5F2W3'
1 1 1 1 1 2 2 2

Perl, 29 bytes
26 bytes code + 3 for -n.
If no separator is required, this works:
print$1x$' while/(\d+)w/gi

You can fix the separator issue at the cost of 1 byte: s%\d+w%say for($&+0)x$'%gie (needs -E or -M5.010 to activate say)

Clojure, 86 bytes
(fn[a](mapcat #(repeat(read-string(last %))(first %))(partition 2 (re-seq #"\d+" a))))

Depending on requirements, I could also drop "cat" from "mapcat".

PowerShell v2+, 67 bytes
($args[0]-replace'F','+,'-replace'W','*').trim('+')+'-join", "'|iex

Takes input $args[0] as a string, pumps it through two -replace statements to swap the F for a +, and the W for a *. Then .trims the errant initial + before concatenating -join with a ,<space>, and piping to iex to evaluate the resulting string into a new string. That's left on the pipeline, and output is implicit.
As an example, with input F1W5F2W3, after the -replaces, our string will be +,1*5+,2*3. After the .trim, it'll be ,1*5+,2*3. That's concatenated with the -join statement, like ,1*5+,2*3-join", ". The iex then evaluates that string by forming an array of 5 1s via the comma-operator, using array concatenation to add on an array of 3 2s, so we have an array like (1,1,1,1,1,2,2,2), which is then fed into -join to put the comma-space between the elements.
Since -replace is by default case-insensitive, it handles lowercase as well.
Test cases
PS C:\Tools\Scripts\golfing> .\text-animation-format.ps1 'F1W5F2W3'
1, 1, 1, 1, 1, 2, 2, 2

PS C:\Tools\Scripts\golfing> .\text-animation-format.ps1 'F10W3F11W3F10W3F12W3'
10, 10, 10, 11, 11, 11, 10, 10, 10, 12, 12, 12

PS C:\Tools\Scripts\golfing> .\text-animation-format.ps1 'f1w0f2w10'
2, 2, 2, 2, 2, 2, 2, 2, 2, 2

Retina, 51 bytes
Might be able to be golfed further, I'm not super familiar with Retina.
i`F(\d+)W(\d+)
$1_$2$*n
(?<=(\d+).*?)n
$1,
\d+_|,$

The trailing linefeed is significant.
Try it online!
Explanation:
The code consists of three replacement stages.
i`F(\d+)W(\d+)
$1_$2$*n

This replaces each group of FxWy into x_ followed by n repeated y times. For example, F2W3 is replaced with 2_nnn. i` makes the regex case insensitive.
(?<=(\d+).*?)n
$1,

This matches all the repeated n's. and replaces each of them with the number closest before it, followed by a comma. Using our previous example of F2W3, 2_nnn is replaced with 2_2,2,2,.
\d+_|,$

This removes the final garbage left behind. It replaces the numbers directly followed by underscores, and the comma at the end of the line, with nothing. So 2_2,2,2, becomes 2,2,2, which is the desired output.

Drop the look behind and perhaps and after the capture group reference

@Downgoat: I'm not entirely sure what you mean... if I drop the lookbehind then it will replace all the ns with 1 number, rather than each n with the number.


text:
Can I take your order: a Chipotle concept conund
Challenge
Your program will take in a string from stdin, and output multiple lines to stdout.
An example of input looks like this:
My favorite Chipotle order:

B1113YNNY

Let's break it down:

The first character is either A (burrito), or B (burrito bowl).
The second character is 1 (black beans), or 2 (pinto beans).
The third character is either 1 (white rice), or 2 (brown rice).
The fourth character is either 1 (chicken), 2 (sofritas), or 3 (steak).
The fifth character is either 1 (mild salsa), 2 (medium salsa), or 3 (hot salsa).
The last four characters are Y if they want the item, or N otherwise:
character 6 is corn
character 7 is guacamole
character 8 is sour cream
character 9 is cheese

A working program for this challenge will output this to stdout:

burrito bowl with:
  black beans
  white rice
  chicken
  hot salsa
  corn
  cheese

Replace the above words with the words acquired from input.
Clarifications.
Standard loopholes are disallowed.
You may only get input from stdin, and only put output to stdout.

We have some Defaults for I/O here. Also functions instead of full programs are always allowed. Overriding those should only be done if there is a specific reason for that, which I don't see here.

May be worth removing and submitting to the sandbox to get it up to scratch?

@JonathanAllan sure

It amazes me that all answers have zero votes so far!

Python 3, 293 bytes
j=input();a,b,c,d,e,f,g,h,i=[1-ord(c)%7%5for c in j];print('\n'.join(('burrito'+[' bowl',''][a]+' with:',['pinto','black'][b]+' beans',['brown','white'][c]+' rice',['sofritas','chicken','steak'][d],['medium','mild','hot'][e]+' salsa'))+'\ncorn'*f+'\nguacamole'*g+'\nsour cream'*h+'\ncheese'*i)

Mostly basic lookups with a little modulo trickery for the indexes of items:
AB123YN yielding indexes -1,-2,1,0,-1,1,0 respectively, and
using string multiplication for the optional items rather than a lookup.

Python 2, 302 298 bytes
o=input()
print"\n".join([s[0]+s[1+(ord(c)+1)%3]+s[-1]for(x,c)in zip(["burrito ,,bowl, with:",",black,pinto, beans",",white,brown, rice",",chicken,sofritas,chicken,",",mild,medium,hot, salsa"],o)for s in[x.split(",")]]+[x for(x,c)in zip(["corn","guacamole","sour cream","cheese"],o[5:])if c=="Y"])

EDIT: according to the consensus on meta, I'm allowed to use input instead of raw_input, requiring the user of the program to type his or her Chipotle order in quotes! Thanks, @StevenH. for informing me of this.

Batch, 445 364 bytes
@echo off
set/ps=
set l=call:l
%l%"burrito with:" "burrito bowl with:"
%l%"black beans" "pinto beans"
%l%"white rice" "brown rice"
%l%chicken sofritas steak
%l%"mild salsa" "medium salsa" "hot salsa"
%l%corn
%l%guacamole
%l%"sour cream"
%l%cheese
exit/b
:l
for %%a in (B N 2 3 3)do if %s:~0,1%==%%a shift
if not "%~1"=="" echo %~1%
set s=%s:~1%

New rewrite saved me 81 bytes. Reading from STDIN conveniently saves a byte over using the command line. Each character of the input is processed in turn to select from a list of options; the characters B, N and 2 cause the second option to be chosen, while 3 causes the third option to be chosen.

Pyth, 225 Bytes
=rQ0s["burrito "?xGhQ"bowl "k"with:")+@,"pinto""black"shtQ" beans"+@,"brown""white"shttQ" rice"@c"steak chicken sofritas")s@Q3+@c"hot medium mild")s@Q4" salsa"seMf}\y@QhT[,5"corn\n",6"guacamole\n",7"sour cream\n",8"cheese\n")

Python 2, 336 335 Bytes
q,i=input(),int
print"burrito "+{"A":"","B":"bowl"}[q[0]]+" with:\n"+["black","pinto"][i(q[1])-1]+" beans\n"+["white","brown"][i(q[2])-1]+" rice\n"+["chicken","sofritas","steak"][i(q[3])-1]+"\n"+["mild","medium","hot"][i(q[4])-1]+" salsa\n"+"\n".join([x for y,x in enumerate(["corn","guacamole","sour cream","cheese"]) if q[y+5]=="Y"])

Try it online!
Removed one byte by renaming int: i=int

You can save some bytes by interleaving the strings like "wbhriotwen"[i(q[2])-1::2], also for black and pinto

Don't you mean raw_input?

@Omar, requiring input to be wrapped in quotation marks and escaped as would be needed for using input() over raw_input() is allowed by meta consensus.   This is especially true when the original question specifies that input is passed as a string, as it is here.

Ooh, excellent, @StevenH., I'll change that in my submission, then. :)

No problem! Glad I could help.

Racket 544 bytes
(let*((s(read-line))(l(string->list s))(lr list-ref)(d displayln)(p display)(c -1)(g(λ()(set! c(+ 1 c))(lr l c))))
(match(g)[#\A(d"burrito with:")][#\B(d"burrito bowl with:")])(match(g)[#\1(d"black beans")][#\2(d"pinto beans")])
(match(g)[#\1(d"white rice")][#\2(d"brown rice")])(match(g)[#\1(d"chicken")][#\2(d"sofritas")][#\3(d"steak")])
(match(g)[#\1(p"mild ")][#\2(p"medium ")][#\3(p"hot ")])(d"salsa")(match(g)[#\Y(d"corn")][#\N""])
(match(g)[#\Y(d"guacamole")][#\N""])(match(g)[#\Y(d"sour cream")][#\N""])(match(g)[#\Y(d"cheese")][#\N""]))

Ungolfed:
(define (f)
  (let* ((s (read-line))
         (l (string->list s))
         (lr list-ref)
         (d displayln)
         (p display)
         (c -1)
         (g (lambda() (set! c (add1 c)) (lr l c))))
    (match (g)
      [#\A (d "burrito with:")]
      [#\B (d "burrito bowl with:")])
    (match (g)
      [#\1 (d "black beans")]
      [#\2 (d "pinto beans")])
    (match (g)
      [#\1 (d "white rice")]
      [#\2 (d "brown rice")])
    (match (g)
      [#\1 (d "chicken")]
      [#\2 (d "sofritas")]
      [#\3 (d "steak")])
    (match (g)
      [#\1 (p "mild ")]
      [#\2 (p "medium ")]
      [#\3 (p "hot ")])
    (d "salsa")
    (match (g)
      [#\Y (d "corn")]
      [#\N ""])
    (match (g)
      [#\Y (d "guacamole")]
      [#\N ""])
    (match (g)
      [#\Y (d "sour cream")]
      [#\N ""])
    (match (g)
      [#\Y (d "cheese")]
      [#\N ""])))

Testing:
(f)

burrito bowl with:
black beans
white rice
chicken
hotsalsa
corn
cheese

PHP, 301 Bytes
<?="burrito".($i=$_GET[a])[0]>A?" bowl":""," with:\n".[black,pinto][$i[1]>1]." beans\n".[white,brown][$i[2]>1]." rice\n".[_,chicken,sofritas,steak][$i[3]]."\n".[_,mild,medium,hot][$i[4]]." salsa".["","\ncorn"][$i[5]>N].["","\nguacamole"][$i[6]>N].["","\nsour cream"][$i[7]>N].["","\ncheese"][$i[8]>N];

Previous version 311 Bytes
<?printf("burrito%s with:\n%s beans\n%s rice\n%s\n%s salsa%s%s%s%s",($i=$_GET[a])[0]>A?" bowl":"",[black,pinto][$i[1]>1],[white,brown][$i[2]>1],[_,chicken,sofritas,steak][$i[3]],[_,mild,medium,hot][$i[4]],["","\ncorn"][$i[5]>N],["","\nguacamole"][$i[6]>N],["","\nsour cream"][$i[7]>N],["","\ncheese"][$i[8]>N]);

C#, 737 Bytes
Not going to win any prizes here...
Golfed:
string O(string s){var c=new List<string>();var m=new Dictionary<int,List<string>>(){{0,new List<string>(){"burrito","burrito bowl"}},{1,new List<string>(){"","black beans","pinto beans"}},{2,new List<string>(){"","white rice","brown rice"}},{3,new List<string>(){"","chicken","sofritas","steak"}},{4,new List<string>(){"","mild salsa","medium salsa","hot salsa"}},{5,new List<string>(){"corn"}},{6,new List<string>(){"guacamole"}},{7,new List<string>(){"sour cream"}},{8,new List<string>(){"cheese"}},};for(int i=0;i<s.Length;i++){if(i==0){c.Add(s[0]=='A'?m[0][0]:m[0][1]+" with:");continue;}if(i>4){c.Add(s[i]=='Y'?m[i][0]:"");continue;}c.Add(m[i][int.Parse(s[i]+"")]);}return string.Join("\n",c.Where(o =>!string.IsNullOrEmpty(o)));}}

Ungolfed:
public string O(string s)
{
  var c = new List<string>();

  var m = new Dictionary<int, List<string>>()
  {
    {0, new List<string>(){"burrito", "burrito bowl"}},
    {1, new List<string>(){"", "black beans", "pinto beans"}},
    {2, new List<string>(){ "", "white rice", "brown rice"}},
    {3, new List<string>(){ "", "chicken", "sofritas", "steak"}},
    {4, new List<string>(){ "", "mild salsa", "medium salsa", "hot salsa"}},
    {5, new List<string>(){"corn"}},
    {6, new List<string>(){"guacamole"}},
    {7, new List<string>(){"sour cream"}},
    {8, new List<string>(){"cheese"}},
  };

  for (int i = 0; i < s.Length; i++)
  {
    if (i == 0)
    {
      c.Add(s[0] == 'A' ? m[0][0] : m[0][1] + " with:");
      continue;
    }

    if (i > 4)
    {
      c.Add(s[i] == 'Y' ? m[i][0] : "");
      continue;
    }

    c.Add(m[i][int.Parse(s[i]+"")]);
  }

  return string.Join("\n", c.Where(o => !string.IsNullOrEmpty(o)));
}

Testing:
  var chipotleOrder = new ChipotleOrder();
  Console.WriteLine(chipotleOrder.P(Console.ReadLine()));
  Console.ReadLine();

Output:
burrito bowl with:
black beans
white rice
chicken
hot salsa
corn
cheese

JavaScript (ES6), 267
a=>[...a].map((c,i,a,s=x=>`
`+(','+x).split`,`[c])=>i--?i--?i--?i--?i?c>'N'?(c=i,s`corn,guacamole,sour cream,cheese`):'':s`mild,medium,hot`+' salsa':s`chicken,sofritas,steak`:s`white,brown`+' rice':s`black,pinto`+' beans':'burrito'+(c>'A'?' bowl':'')+' with:').join``

Less golfed
a=>
[...a].map((c,i,a,s=x=>'\n'+(','+x).split`,`[c])=>
       i--?i--?i--?i--?i?
       c>'N'?(c=i,s`corn,guacamole,sour cream,cheese`):''
       :s`mild,medium,hot`+' salsa'
       :s`chicken,sofritas,steak`
       :s`white,brown`+' rice'
       :s`black,pinto`+' beans'
       :'burrito'+(c>'A'?' bowl':'')+' with:'
).join``

Test

f=
a=>[...a].map((c,i,a,s=x=>`
`+(','+x).split`,`[c])=>i--?i--?i--?i--?i?c>'N'?(c=i,s`corn,guacamole,sour cream,cheese`):'':s`mild,medium,hot`+' salsa':s`chicken,sofritas,steak`:s`white,brown`+' rice':s`black,pinto`+' beans':'burrito'+(c>'A'?' bowl':'')+' with:').join``

function update()
{
  O.textContent=f(I.value);
}

update()
<input id=I value="B1113YNNY" oninput='update()'>


text:
How secure are my locks?
You have been assigned the task of installing new locks to the company's building. However, the locks you use are quite unusual: they require some combination of keys to open. Now, you want to figure out which locks are the most secure, so you can prioritize the most important locations.
The keys you use are numbered by security: key 1 is the weakest and could be given to the cat, key 2 is a bit better, and so on.
The locks are defined by AND and OR expressions between the keys. For example, a lock might open with just key 1, so it's defined by the string 1; another one might require key 3 and either key 1 or 2, so it's defined by 3 & (1 | 2). A lock opens if the expression is truthy when all key numbers are substituted for true/false depending on if the user possessed the respective keys. XOR and NOT are not needed, since possessing extra keys doesn't matter.
The security of a lock is defined by the weakest key combination required to open the lock. One way to compute this is the following algorithm:

Find all the subsets of the keys that open the lock.
Sort each combination descending (from the strongest key to the weakest).
Sort the combinations lexicographically ascending.
The security value of the lock is now the first item in the list.

In order to compare two locks, one just has to compare their security values lexicographically: the larger one is more secure.
Challenge
You are given a list of expressions that define locks. Your task is to sort the locks based on security in descending order.
Standard code-golf rules apply.
Input
You will receive a list of locks as input.

The list may be taken as lines or in the list representation of your choice.
Each lock can be given either as a string like 1 & ((2 | 3) & 4) or a nested list like [1, "&", [[2, "|", 3], "&", 4]].

Any whitespace in the string is optional, and all operations except for the outermost one will be wrapped in parentheses.
You are free to choose the list format that suits your needs.

Each operator will have two operands.
Key numbers will range from 1 to 99 and there will not be unused keys between 1 and the maximum used key.

Output
You will output the same list you got as input, sorted by security in descending order. All formats listed above are valid. If two locks are equally secure, their order does not matter.
Test cases
The test cases are in the "list" format. The outputs include the security values of each lock for reference; you should not output them.
Input:
[1]
[2]
[3]
[1, "&", 2]
[1, "&", 3]
[3, "&", 2]
[1, "|", 2]
[2, "|", 3]
[[1, "&", 2], "|", 3]
[[2, "|", 3], "&", 3]

Result:
[3, "&", 2]            # (3, 2)
[1, "&", 3]            # (3, 1)
[[2, "|", 3], "&", 3]  # (3)
[3]                    # (3)
[1, "&", 2]            # (2, 1)
[[1, "&", 2], "|", 3]  # (2, 1)
[2]                    # (2)
[2, "|", 3]            # (2)
[1]                    # (1)
[1, "|", 2]            # (1)

Input:
[[[6, '|', [[10, '|', 1], '&', [3, '&', 3]]], '|', 10], '&', [[12, '&', [9, '|', 7]], '|', [[3, '|', 8], '&', [[10, '|', [[1, '&', 3], '&', 9]], '|', [[2, '|', 1], '&', 1]]]]]
[[7, '|', 9], '&', [[5, '|', 10], '&', [[12, '|', 3], '&', 4]]]
[7, '|', 7]
[[[5, '|', [1, '|', 9]], '&', [[7, '&', [[6, '&', [1, '|', 7]], '|', 2]], '|', 5]], '&', [[[[8, '&', 6], '&', 1], '&', 5], '&', [10, '|', [11, '&', [3, '&', 6]]]]]
[[[[2, '&', [6, '&', 8]], '|', [[4, '|', 4], '|', [[5, '&', 4], '|', [[[1, '|', 5], '|', 1], '&', 7]]]], '&', [[[9, '|', [3, '&', 7]], '|', [9, '|', 5]], '&', [[[[8, '|', 11], '|', 8], '|', 2], '|', 2]]], '&', [[3, '|', 6], '&', 9]]
[[12, '|', [5, '&', [[12, '&', 3], '|', [9, '&', 1]]]], '|', [10, '&', [[8, '|', 9], '&', [[[8, '|', 3], '|', 8], '|', 11]]]]
[[9, '|', 11], '&', [[[11, '&', 12], '|', 10], '&', [3, '&', 12]]]
[[[5, '&', 9], '&', [10, '&', 2]], '|', [10, '|', 10]]
[[6, '&', 4], '&', [4, '|', 11]]
[[[[11, '&', [[[[5, '|', 11], '&', [10, '|', 7]], '&', 2], '|', 2]], '|', 12], '|', 5], '&', [[[2, '&', [5, '|', 9]], '&', 4], '&', [6, '|', [3, '&', 2]]]]

Result:
[[9, '|', 11], '&', [[[11, '&', 12], '|', 10], '&', [3, '&', 12]]] # (12, 10, 9, 3)
[[[5, '|', [1, '|', 9]], '&', [[7, '&', [[6, '&', [1, '|', 7]], '|', 2]], '|', 5]], '&', [[[[8, '&', 6], '&', 1], '&', 5], '&', [10, '|', [11, '&', [3, '&', 6]]]]] # (10, 8, 6, 5, 1)
[[[5, '&', 9], '&', [10, '&', 2]], '|', [10, '|', 10]] # (10)
[[12, '|', [5, '&', [[12, '&', 3], '|', [9, '&', 1]]]], '|', [10, '&', [[8, '|', 9], '&', [[[8, '|', 3], '|', 8], '|', 11]]]] # (9, 5, 1)
[[[[2, '&', [6, '&', 8]], '|', [[4, '|', 4], '|', [[5, '&', 4], '|', [[[1, '|', 5], '|', 1], '&', 7]]]], '&', [[[9, '|', [3, '&', 7]], '|', [9, '|', 5]], '&', [[[[8, '|', 11], '|', 8], '|', 2], '|', 2]]], '&', [[3, '|', 6], '&', 9]] # (9, 4, 3, 2)
[[7, '|', 9], '&', [[5, '|', 10], '&', [[12, '|', 3], '&', 4]]] # (7, 5, 4, 3)
[7, '|', 7] # (7)
[[6, '&', 4], '&', [4, '|', 11]] # (6, 4)
[[[[11, '&', [[[[5, '|', 11], '&', [10, '|', 7]], '&', 2], '|', 2]], '|', 12], '|', 5], '&', [[[2, '&', [5, '|', 9]], '&', 4], '&', [6, '|', [3, '&', 2]]]] # (5, 4, 3, 2)
[[[6, '|', [[10, '|', 1], '&', [3, '&', 3]]], '|', 10], '&', [[12, '&', [9, '|', 7]], '|', [[3, '|', 8], '&', [[10, '|', [[1, '&', 3], '&', 9]], '|', [[2, '|', 1], '&', 1]]]]] # (3, 1)

This program can be used to generate additional test cases. It also outputs the security values of each lock generated.

Can we take input locks in a format like or(3,and(4,6))?

@xnor No, sorry. Infix as string or array is the only option since that would require me to allow any "directly evaluable" format, which would in turn probably end up in a rewrite of the existing answers.

You should add an example like [[2, "|", 3], '&', 3]  # (3) to the first input set, so that people notice when their solution prematurely prunes the set of possible keys. (See my comment under the Python solution.)

Perl 6: 132 124 bytes
{reverse .sort: {use MONKEY-SEE-NO-EVAL;my &infix:<|>={|$^a,|$^b}
min map *.flat.sort.squish.reverse,EVAL .trans('&'=>'X')}}

A lambda that takes a list of lines as input.
It generates the sort key for each line as follows:

Declare | as a list concatenation operator within the lexical scope.
Replace & in the string with X, the Perl 6 cartesian product operator.
Eval the string (which unfortunately requires the ghastly MONKEY-SEE-NO-EVAL pragma), yielding all possible combinations of keys that open the door.
Post-process the lists and pick the "least secure" combination.

Python, 253 246 bytes
m=lambda a,b:min(sorted(a),sorted(b))
def w(s):
    if type(s)!=list:return[s]
    if len(s)==1:return s
    k=w(s[0])
    z=w(s[2])
    if s[1]=="|":return m(k,z)
    return k+z
r=[]
for i in n:r+=[(i,sorted(w(i),reverse=1))]
sorted(r,reverse=1,key=lambda x:x[1])

You can save 5 bytes by using a lambda for m(a,b): m=lambda a,b:min(sorted(a),sorted(b))

This gives wrong results for keys where a higher alternative in one branch results in a lower overall security value for the lock. For example for the lock [[2, "|", 3], '&', 3] it calculates the security value [2, 3] instead of [3].

@smls That's an excellent point. I'll fix it as soon as I get time. Any suggestions?

@gowrath In the Perl 6 solution, I first generate a flat list of all possible sets of keys that open the lock, and only then pick the "minimum" set.
I generate the sets from the textual input basically by replacing each & with a cartesian product operator, and each | with a list concatenation operator, and then EVALing it, but the same could be done using a recursive function as well.

@smls I was hoping there would be a way to do it without generating all possible sets; that was the motivation behind using a recursive function.


text:
My triangle needs more nodes
Consider the standard equilateral triangle, with nodes labeled using barycentric coordinates:

We can turn this 3 node triangle into a 6 node triangle by adding a new line of 3 vertices (one more than was present on a side of the original 3 node triangle), remove any internal edges (but not internal nodes) and re-normalize the coordinates:

Repeating the process to go from a 6 node triangle to a 10 node triangle, add a line of 4 vertices (again, one more than was present on a side of the original 6 node triangle), remove any internal edges (but not internal nodes) and re-normalize the coordinates:

This process can be repeated indefinitely. The goal of this challenge is given an integer N representing how many times this process has been performed, output all the nodes for the associated triangle in barycentric coordinates.
Input
Your program/function should take as input a single non-negative integer N representing how many times this process has been applied. Note that for N=0, you should output the original triangle with 3 nodes.
The input may come from any source (function parameter, stdio, etc.).
Output
Your program/function should output all the nodes in normalized barycentric coordinates. The order of the nodes does not matter.
A number can be specified as a fraction (fraction reduction not required) or a floating point number. You may also output "scaled" vectors to specify a node. For example, all 3 of the following outputs are equivalent and allowed:
0.5,0.5,0

1/2,2/4,0

[1,1,0]/2

If using floating point output, your output should be accurate to within 1%. The output may be to any sink desired (stdio, return value, return parameter, etc.). Note that even though the barycentric coordinates are uniquely determined by only 2 numbers per node, you should output all 3 numbers per node.
Examples
Example cases are formatted as:
N
x0,y0,z0
x1,y1,z1
x2,y2,z2
...

where the first line is the input N, and all following lines form a node x,y,z which should be in the output exactly once. All numbers are given as approximate floating point numbers.
0
1,0,0
0,1,0
0,0,1

1
1,0,0
0,1,0
0,0,1
0.5,0,0.5
0.5,0.5,0
0,0.5,0.5

2
1,0,0
0,1,0
0,0,1
0.667,0,0.333
0.667,0.333,0
0.333,0,0.667
0.333,0.333,0.333
0.333,0.667,0
0,0.333,0.667
0,0.667,0.333

3
1,0,0
0.75,0,0.25
0.75,0.25,0
0.5,0,0.5
0.5,0.25,0.25
0.5,0.5,0
0.25,0,0.75
0.25,0.25,0.5
0.25,0.5,0.25
0.25,0.75,0
0,0,1
0,0.25,0.75
0,0.5,0.5
0,0.75,0.25
0,1,0

Scoring
This is code golf; shortest code in bytes wins. Standard loopholes apply. You may use any built-ins desired.

You say "If using floating point output". What alternatives are there? Fractions? If so, do they have to be reduced? How about scaled vectors like [1,2,3]/6?

Yes, all of those alternatives are allowed. I'll update the problem statement.

CJam (22 bytes)
{):X),3m*{:+X=},Xdff/}

This is an anonymous block (function) which takes N on the stack and leaves an array of arrays of doubles on the stack. Online demo
Dissection
{         e# Define a block
  ):X     e# Let X=N+1 be the number of segments per edge
  ),3m*   e# Generate all triplets of integers in [0, X] (inclusive)
  {:+X=}, e# Filter to those triplets which sum to X
  Xdff/   e# Normalise
}

Haskell, 53 bytes
f n|m<-n+1=[map(/m)[x,y,m-x-y]|x<-[0..m],y<-[0..m-x]]

Python 3, 87 bytes
This is actually supposed to be a comment to the solution by TheBikingViking but I don't have enough reputation for comments.
One can save a few bytes by only iterating over the variables i,j and using the fact that with the third one they add up to n+1.
def f(n):d=n+1;r=range(n+2);print([[i/d,j/d,(d-i-j)/d]for i in r for j in r if d>=i+j])

05AB1E, 10 bytes
ÌL<¤/3ãDOÏ

Explanation
ÌL<          # range(1,n+2)-1
   ¤/        # divide all by last element (n+1)
     3ã      # cartesian product repeat (generate all possible triples)
       DO    # make a copy and sum the triples
         Ï   # keep triples with sum 1

Try it online

Since ¤ consumes the array, why does / divide the array by that? Does it "remember" that last popped value and use it if needed?

@LuisMendo: ¤ is one of the few commands that does not pop and consume from the stack. It pushes the last element of the list while leaving the list on the stack.

Hm? That doesn't seem to be the case

@LuisMendo 05AB1E only outputs the top of the stack at the end of a program.

Oh, of course! Thanks for the explanations

Mathematica,  44  43 bytes
Select[Range[0,x=#+1]~Tuples~3/x,Tr@#==1&]&

This is an unnamed function taking a single integer argument. Output is a list of lists of exact (reduced) fractions.
Generates all 3-tuples of multiples of 1/(N+1) between 0 and 1, inclusive, and then selects those whose sum is 1 (as required by barycentric coordinates).

MATL, 17 bytes
2+:qGQ/3Z^t!s1=Y)

Try it online!
Explanation
The approach is the same as in other answers:

Generate the array [0, 1/(n+1), 2/(n+1), ..., 1], where n is the input;
Generate all 3-tuples with those values;
Keep only those whose sum is 1.

More specifically:
2+     % Take input and add 2: produces n+2
:q     % Range [0 1 ... n+1]
GQ/    % Divide by n+1 element-wise: gives [0, 1/(n+1), 2/(n+1)..., 1]
3Z^    % Cartesian power with exponent 3. Gives (n+1)^3 × 3 array. Each row is a 3-tuple
t      % Duplicate
!s     % Sum of each row
1=     % Logical index of entries that equal 1
Y)     % Use that index to select rows of the 2D array of 3-tuples

Jellyfish, 37 33 bytes
Thanks to Zgarb for saving 4 bytes.
p
*%
# S
`
=E   S
`/
1+r#>>i
   3

Try it online!
Like my Mathematica and Peter's CJam answers, this generates a set of candidate tuples and then selects only those that sum to 1. I'm not entirely happy with the layout yet, and I wonder whether I can save some bytes with hooks or forks, but I'll have to look into that later.

Perl 6: 50 40 bytes
{grep *.sum==1,[X] (0,1/($_+1)...1)xx 3}

Returns a sequence of 3-element lists of (exact) rational numbers.
Explanation:

$_
Implicitly declared parameter of the lambda.
0, 1/($_ + 1) ... 1
Uses the sequence operator ... to construct the arithmetic sequence
that corresponds to the possible coordinate values.
[X] EXPR xx 3
Takes the Cartesian product of three copies of EXPR, i.e. generates all possible 3-tuples.
grep *.sum == 1, EXPR
Filter tuples with a sum of 1.

Ruby, 62
I'd be surprised if this can't be improved on:
->x{0.step(1,i=1.0/(x+1)){|a|0.step(1-a,i){|b|p [a,b,1-a-b]}}}

Taking the advice latent in the puzzle, this calculates the second node options based on the first, and the third node by subtracting the first two.

Brachylog, 24 bytes
+:1f
yg:2j:eaL+?/g:Lz:*a

Try it online!

JavaScript (Firefox 30-57), 88 81 bytes
n=>[for(x of a=[...Array(++n+1).keys()])for(y of a)if(x+y<=n)[x/n,y/n,(n-x-y)/n]]

Returns an array of arrays of floating-point numbers. Edit: Saved 7 bytes by computing the third coordinate directly. I tried eliminating the if by calculating the range of y directly but it cost an extra byte:
n=>[for(x of a=[...Array(++n+1).keys()])for(y of a.slice(x))[x/n,(y-x)/n,(n-y)/n]]

At the end, you wrote [x/n,y/n/z/n], did you forget a comma?

@kamoroso94 You're right, I typoed the last comma, thanks for letting me know.

Python 3, 106 bytes
def f(n):r=range(n+2);print([x for x in[[i/-~n,j/-~n,k/-~n]for i in r for j in r for k in r]if sum(x)==1])

A function they takes input via argument and prints a list of lists of floats to STDOUT.
Python is not good at Cartesian products...
How it works
def f(n):                         Function with input iteration number n
r=range(n+2)                      Define r as the range [0, n+1]
for i in r for j in r for k in r  Length 3 Cartesian product of r
[i/-~n,j/-~n,k/-~n]               Divide each element of each list in the product
                                  by n+1
[x for x in ... if sum(x)==1]     Filter by summation to 1
print(...)                           Print to STDOUT

Try it on Ideone

Actually, 15 bytes
This uses an algorithm similar to the one in TheBikingViking's Python answer. Golfing suggestions welcome. Try it online!
u;ur♀/3@∙`Σ1=`░

Ungolfed:
u;                Increment implicit input and duplicate.
  ur              Range [0..n+1]
    ♀/            Divide everything in range by (input+1).
      3@∙         Take the Cartesian product of 3 copies of [range divided by input+1]
         `Σ1=`    Create function that takes a list checks if sum(list) == 1.
              ░   Push values of the Cartesian product where f returns a truthy value.

Ruby, 77 74 bytes
Another answer using the algorithm in TheBikingViking's Python answer. Golfing suggestions welcome.
->n{a=[*0.step(1,i=1.0/(n+1))];a.product(a,a).reject{|j|j.reduce(&:+)!=1}}

Another 74-byte algorithm based on Not that Charles's Ruby answer.
->x{y=x+1;z=1.0/y;[*0..y].map{|a|[*0..y-a].map{|b|p [a*z,b*z,(y-a-b)*z]}}}


text:
Exploring 10-Rep Questions
Related
Introduction
As it happens, someone put forward the idea that, since PPCG has graduated, up votes on questions should be worth 10 rep. As a result, I started wondering how much rep I would have if it had always been 10 rep.
Challenge
Given a PPCG user's id as input, output how much total rep the user would have if question up votes were worth +10.
Example Calculation
I, Beta Decay (user id 30525), have 6744 rep. 3488 of that was earned by posting questions (calculated by subtracting the total rep lost from downvotes from the total rep gained from upvotes).
Firstly, we subtract 3488 from 6744, giving us 3256 rep, the amount earned from posting answers.
Next, we find out how much I would have earned from 10 rep questions by simply multiplying 3488 by 2, giving us 6976.
Finally, we add 3256 and 6976 together to get a final answer of 10232 rep.
A simplified method is to take the total, 6744 and add the rep from questions, 3488, giving is 10232 rep.
For continuity, you must use the method described above
Examples
Note that these examples are subject to change and are unlikely to stay current.
Helka Homba (UID 26997)
71398

Martin Ender (UID 8478)
121077

Downgoat (UID 40695)
21894

Rules
Internet access is allowed. Similarly, access to the Stack Exchange API is allowed. However, URL shorteners are disallowed.
T-SQL entrants using the Stack Exchange Data Explorer are allowed.
You also do not have to take into account the daily rep cap of 200.
Winning
Shortest code in bytes wins.

If we don't take down votes into account where does 3488 come from, as it's not a multiple of 5?

@Neil Hm, well I've changed the rules now to accountt for this

Python, 336 Bytes
Anonymous lambda function, takes a string.
Should work, but couldn't test it, because I drained my api quota.
(Warning! Will drain your api quota!)
import requests,re
lambda x,u="http://api.stackexchange.com/2.2/users/%s%s?site=codegolf&page=%d":int(re.search('n":\d+',requests.get(u%(x,"",1)).text).group()[3:])+sum([5*len(re.findall(':5,',requests.get(u%(x,"/reputation-history",i)).text))-2*len(re.findall('-2',requests.get(u%(x,"/reputation-history",i)).text))for i in range(99)])

a bit quota-friendlier:
import requests,re
f=lambda x,u="https://api.stackexchange.com/2.2/users/%s%s?site=codegolf&pagesize=100&page=%d":int(re.search('n":\d+',requests.get(u%(x,"",1)).text).group()[3:])+sum([5*len(re.findall(':5,',requests.get(u%(x,"/reputation-history",i)).text))-2*len(re.findall('-2',requests.get(u%(x,"/reputation-history",i)).text))for i in range(30)])