text:
Is the graph acyclic?
A Directed Acyclic Graph (DAG) is a type of graph that has no cycles in it. In other words, if there is a link from node A to node B, there exists no path from B to A (via any nodes).
Challenge
Determine whether the directed graph given as input is acyclic.
Input
A list of lists of integers representing the links between nodes, where a node is identified by its index in the list.
Output
Standard I/O for decision problems; generally a truthy value for acyclic graphs, and a falsy one for cyclic graphs. Additionally, your program may halt/not halt to indicate truthy and falsy, if you wish.
Test Cases
[[1, 2], [3, 4], [5], [], [6], [6], []]

Represents the following graph (where all edges are directed downwards):
        0
      /   \
     1     2
    / \   /
   3  4  5
      | /
      6

This example is acyclic, so the result should be truthy.

[[1, 3], [2], [0], [1]]

Represents the following graph:
 -----<-----<----
/                \
0 --> 3 --> 1 --> 2
 \---->----/

This example is cyclic, so the result should be falsey. (Sorry for my terrible drawing; if this is unclear let me know.)
Constraints

No input will ever be invalid; i.e. no node will link to a node that does not exist
Self loops must be handled ([[0]] is a cyclic graph)

This is code-golf, so the fewest bytes in each language wins.

Very closely related. It could potentially be considered a duplicate, because checking if cycles exist is a core part of that challenge.

Is one-indexing acceptable? May we output truthy for cyclic and falsey for acyclic?

Feel free to use this drawing or modify it to suit you.

@Mego I did see that one before posting, but I think this is a much easier challenge

@JonathanAllan One-indexing is fine. And yes, based on standard I/O for decision problems you may use false for true and true for false.

Mathematica, 80 44 40 30 22 bytes
#//.x_:>#[[Union@@x]]&

Uses 1-based indexing for input. Returns an empty list iff the graph is acyclic.
Example:
In[1]:= #//.x_:>#[[Union@@x]]&[{{2,3},{4,5},{6},{},{7},{7},{}}]

Out[1]= {}

In[2]:= #//.x_:>#[[Union@@x]]&[{{2,4},{3},{1},{2}}]

Out[2]= {{2, 4}, {3}, {1}, {2}}

In[3]:= #//.x_:>#[[Union@@x]]&[{{1}}]

Out[3]= {{1}}

Nice job dealing with the strict input format (and I didn't know about LoopFreeGraphQ!). Too badFindCycle@#=={} doesn't save anything over AcyclicGraphQ@#.

Can you replace #2[[1]] by #&@@#2?

Could you add an explanation? Also, is the +1 just to correct for 0-indexing? If so, it could be eliminated.

Is there a perhaps short way to convert to adjacency matrix, raise it to a high power, and check if the result is zero?

@xnor The graph is acyclic if and only if the only eigenvalue of its adjacency matrix is 0. But I can't find any short way. f@g_:={0}==Union@Eigenvalues[SparseArray[#+1->1&/@#,Length@g]&/@g] is 66 chars.

Jelly,  8  7 bytes
µị³FµL¡

A full program, printing no output for an acyclic input; or some output for a cyclic input.
Try it online!
How?
µị³FµL¡ - Main link: list of lists of natural numbers, g
µ   µ ¡ - repeat
     L  - length times:
  ³     -   program's 3rd command line argument, 1st program input, g
 ị      -   index into
   F    -   flatten (makes a list of nodes that are reachable, possibly with repeats)
        - implicit print - If cyclic:  it contains integers, and the Jelly representation
                                       is a `[]` enclosed `, ` separated string of them.
                           If acyclic: it contains nothing, anf the Jelly representation
                                       is an empty string (the `[]` is not even printed)

The result should be falsy for cyclic instances.

I asked about it and got this response.

Python 2, 70 bytes
f=lambda G,s=0,v=-1:G[s:]and all(f(G,s+1,x)for x in(G+[sum(G,[])])[v])

Try it online!
An n-vertex graph is cyclic only if one can take an n-step path. In an acyclic graph, no vertex on the path can repeat so it must hit a dead end.
This recursive function tries all paths in the graph G, tracking the current number of steps s and current vertex v. Once s is at least len(G), we the Falsey value of [] is returned. To allow the walk to start on any vertex, the initial phantom vertex v=-1 connects to every (reachable) node of G, extracted as sum(G,[]).
An iterative version tied in length.
Python 2, 70 bytes
G=input()
r=sum(G,[])
for _ in G:r=sum([G[v]for v in r],[])
print[]==r

Try it online

Haskell, 28 bytes (halts or doesn’t halt)
f g|let s=(>>=s.(g!!))=g>>=s

Try it online!
For any list xs of nodes, s xs = xs >>= s . (g !!) = [y | x <- xs, y <- s (g !! x)] does a recursive search through all nodes reachable from them.  We run this on all nodes in the graph with g >>= s.
Haskell, 36 bytes (returns True or False)
f g=null$foldr(=<<)(id=<<g)$(g!!)<$g

Try it online!
For any list xs of nodes, (g!!) =<< xs = [y | x <- xs, y <- g !! x] is the list of endpoints of all edges starting at nodes in xs.  Now if g has length n, then
foldr(=<<)(id=<<g)$(g!!)<$g
= foldr (=<<) (id =<< g) [(g!!), (g!!), …, (g!!), (g!!)] (n repetitions)
= (g!!) =<< (g!!) =<< … =<< (g!!) =<< (g!!) =<< id =<< g
= (g!!) =<< (g!!) =<< … =<< (g!!) =<< (g!!) =<< concat g
= (g!!) =<< (g!!) =<< … =<< (g!!) =<< (g!!) =<< [endpoints of all edges, i.e., paths of length 1]
= (g!!) =<< (g!!) =<< … =<< (g!!) =<< [endpoints of all paths of length 2]
= …
= (g!!) =<< [endpoints of all paths of length n]
= [endpoints of all paths of length n + 1],
which is null if and only if the graph is acyclic.

APL (Dyalog Classic), 20 bytes
⍳∘≢∨.∊⊂{⍵∪∊⍺[⍵]}⍣≡¨⊢

Try it online!

Mathematica, 82 bytes
AcyclicGraphQ[g=Graph[Join@@Thread/@Thread[Range@Length@#->#]]]&&LoopFreeGraphQ@g&

Python 2, 53 bytes
f=lambda i:map(f,l[i]);l=input();map(f,range(len(l)))

Crashes if and only if the graph is cyclic, due to infinite recursion. Takes input via stdin.
Try it online!

This doesn't work for [[], [2], [1]] (aside from the dubious interpretation of I/O rules).

Thanks, I knew I was missing something. This should work now, though it is significantly longer.

I think this still doesn't work, like for [[],[0]].

You are correct. I was trying to over-zealously golf my fix, which caused that issue. Now it really should work, for real :)

I don't like infinite recursion as an output method. In particular, this will also crash on a sufficiently large acyclic graph.

My original intent was for it to halt if and only if the graph were acyclic, which would occur if the runtime stack were infinitely large.

JavaScript (ES6), 98 bytes
f=(a,b=[...a.keys()],c=b.filter(i=>b.some(b=>a[b].some(b=>b==i))))=>1/b[c.length]?f(a,c):!(1/c[0])

Returns true for acyclic, false for cyclic. Explanation: Starting with the set b of all the nodes in a, the subset of all nodes of b which are the target of a link is iterated until it doesn't change. If the resulting subset is empty then the graph is acyclic.


text:
Sums of 100 Rolls of Two Six Sided Dice
Suppose you have two six-sided dice. Roll the pair 100 times, calculating the sum of each pair. Print out the number of times each sum occurred.
If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled.
Example Output:
[3, 3, 9, 11, 15, 15, 11, 15, 7, 8, 3]
The number of times a sum was rolled is represented in the sums index - 2
In this example, a sum of two was rolled 3 times ([2-2]), a sum of three 3 times ([3-2]), a sum of four 9 times ([4-2]), and so on. It does not matter the individual dice rolls to arrive at a sum (5 and 2 would be counted as the same sum as 6 and 1)
"Ugly" outputs are fine (loads of trailing zeros, extra output, strange ways of representing data, etc.) as long as you explain how the data should be read.

Do you mean "print out the number of times each pair occurred" or "print out the number of times each sum occurred"?

what numbers are on the dice? how 15 comes up?

In the array, [3, 3, 9...], it means "2 came up 3 times, 3 came up 3 times, 4 came up 9 times..."

If a particular sum never comes up, does there need to be a 0 in the list, or can it be omitted?

Do the different values need to be consistently identifiable or do the counts alone suffice?

@GregMartin That would be ambiguous, would it not?

It would. But it would also be ugly, and the spec is unclear....

If the output is just the number of times each combination of pairs occurs, why do we need to sum the value of each roll? What are we supposed to do with that total? What do you mean by "ugly"?

extra output but we still can't output an infinite list of random numbers and say it randomly appears somewhere in there, right? That's a standard loophole iirc.

And can we return an array of the values from a function instead of printing them?

@StepHen The loophole about randomness wouldn't work anyway, because of the output format (Result for 2d6 = array index + 2). However, one similar but valid loophole is that you could output a list of 11 random numbers that sum up to 100, as this is a valid (yet unlikely) result of 100 dice rolls.

Jelly, 13 12 bytes
³Ḥ6ẋX€+2/ṢŒr

A niladic link. Output format is a list of lists of [value, count].
(Zero rolls means no such entry is present in the output - e.g. an output of[[6, 12], [7, 74], [8, 14]] would identify that only sums of six, seven and eight were rolled.)
Try it online!
How?
³Ḥ6ẋX€+2/ṢŒr - Main link: no arguments
³            - 100
 Ḥ           - double = 200
  6          - 6
   ẋ         - repeat -> [6,6,6...,6], length 200
    X€       - random integer from [1,z] for €ach (where z=6 every time)
       2/    - pairwise reduce with:
      +      -   addition (i.e. add up each two)
         Ṣ   - sort
          Œr - run-length encode (list of [value, length] for each run of equal values)

Python 2, 84 77 76 bytes
-7 bytes thanks to @JonathanAllan
-1 byte thanks to @FelipeNardiBatista
from random import*
a=[0]*13
exec'a[%s]+=1;'%('+randint(1,6)'*2)*100
print a

Try it online!
The output has two leading zeros

golfed to 76 bytes TIO

Perl 6, 30 bytes
bag [Z+] (^6).pick xx 100 xx 2

(^6).pick is a random number from zero through five.  xx 100 makes a hundred-element list of such numbers.  xx 2 produces two such lists.  [Z+] zips those two lists with addition, producing a hundred-element list of two-die rolls.  Finally, bag puts that list into a bag, which is a collection with multiplicity.  Example REPL output:
bag(1(4), 9(4), 0(4), 4(14), 5(18), 3(9), 10(2), 6(19), 7(13), 2(3), 8(10))

That means 1, 9, and 0 occurred four times each, four occurred fourteen times, etc.  Since the "dice" in this code produce a number from 0-5, add two to each of these numbers to get the rolls a pair of standard 1-6 dice would produce.

Wow. Perl 6 is a force to be reckoned with.

However, "If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled." Doesn't look like the bag solution satisfies that.

If a particular number was not rolled, that situation can be identified by the number's absence in the bag.

05AB1E, 21 19 bytes
-2 bytes thanks to @Emigna
TÝÌтF6Lã.RO¸ì}{γ€g<

Try it online!
TÝÌтF6Lã.RO¸ì}{γ€g<
TÝÌ                   Range from 2 to 12
   тF                 100 times do:
     6L                 Range from 1 to 6
       ã                Cartesian product (creates all possible pairs of 1 and 6)
        .RO             Choose random pair and sum
           ¸ì           Prepend result to initial list
             }        end loop
              {γ€g<   Sort, split on consecutive elements, count and decrement

TÝÌтF6Lã.RO¸ì}{γ€g< saves 2 bytes.

@Emigna, didn't expect looping to be shorter, thanks!

CJam, 18 20 bytes
100{;6mr6mr+))}%$e``

Try it online!

It outputs in an ugly format - the number of times each roll occurred is represented as the length of the continuous segments.

@JonathanAllan All right, fine then. e`  only takes two bytes.

Mathematica, 50 bytes
r:=RandomInteger@5
Last/@Tally@Sort@Table[r+r,100]

Straightforward implementation. If any sum is never achieved, the 0 is omitted from the list.

MATL, 17 bytes
6H100I$Yrs!11:Q=s

Output is a list of 11 numbers (some of them possibly 0) separated by spaces, indicating the number of times for each pair from 2 to 12.
Try it online!
For comparison, the theoretical average number of times each pair will appear on average can be computed as 6:gtY+36/100*.
If the number of rolls is increased the obtained values approach the theorerical ones. See for example the obtained and theoretical values with 10000 rolls.

R, 45 37 35 bytes
`[`=sample;table(6[100,T]+6[100,T])

Try it online!
-7 bytes thanks to Jarko Dubbledam

JavaScript, 72 70 bytes
Outputs an array of up to 11 elements for each of the roll counts. Except for the first element, if the count is 0 then the element will be empty or, if it's at the end of the array, omitted completely.
f=(a=[n=0])=>n>99?a:f(a,a[x=(g=_=>Math.random()*6|0)()+g(++n)]=-~a[x])

Try it online!

Aren't you wasting a byte to make it 100 elements instead of 99 or 20 or just even 12?

@RohanJhunjhunwala, the challenge calls for 100 rolls of the two dice.

Oh, i thought were just initializing a 100 element array to store the rolls.

68

q/kdb+, 31 28 25 bytes
Solution:
sum!:[11]=/:sum(2#100)?'6

Example:
q)sum!:[11]=/:sum(2#100)?'6
1 3 5 11 16 21 16 9 8 9 1i

Explanation:
Roll a dice 100?6 , roll a dice again and add the vectors together. Then see where each results matches the range 0..10, then sum up all the trues in each list:
sum til[11]=/:sum(2#100)?'6 / ungolfed solution
                 (2#100)    / 2 take 100, gives list (100;100)
                        ?'6 / performs rand on each left-each right, so 100 & 6, 100 & 6
              sum           / add the lists together
    til[11]                 / the range 0..10
           =/:              / apply 'equals?' to each right on left list
sum                         / sum up the results, e.g. how many 1s, 2s, 3s.. 12s

Notes:
'Golfing' is mostly swapping out q keywords for the k equivalents, namely each and til.

PHP, 53 Bytes
prints an associative array. key is result of two dices and value is the count of these results

for(;$i++<100;)$r[rand(1,6)+rand(1,6)]++;print_r($r);

Try it online!

If a sum was never rolled, you must include a zero or some way to identify that that particular sum was never rolled.

S.I.L.O.S, 99 bytes
i=100
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
lblb
c=get b
printInt c
b+1
d=11-b
if d b

Try it online!
Rolls the dice, and stores them in the first 11 spots of the heap, then just iterates through the heap printing each counter. This is one of the first recorded uses of the rand keyword combined with an assignment operator.
It is worth noting, that a few modifications can be made to output a histogram of the rolls.
Unfortunately it must be run from the offline interpreter.
i=4000
lbla
x=rand*6+rand*6
a=get x
a+1
set x a
i-1
if i a
canvas 1100 1000 Output
lblb
c=get b
printInt c
d=c*1
y=1000-d
x=b*100
newObj 0 100 d
moveObj b x y
b+1
d=11-b
if d b
wait 10000

Elixir, 157 118 bytes
l=&Enum.random(1..&1)
p=fn(o,s)->y=l.(6)+l.(6)
s=List.update_at(s,y,&(&1+1))
if Enum.sum(s)<100 do s=o.(o,s) end
s end

Tried something harder than Jelly.
Explanation:

Define function that returns a random number between 1 and 6 inclusive.
Define the function anonymously and let y be the variable with the roll sum.
update the appropriate place in the list by adding 1.
if we are 100 rolls in, quit. Else call yourself again passing in yourself and the updated list.
return the updated array.

Should be called like p.(p,[0,0,0,0,0,0,0,0,0,0,0,0,0]). It will raise a warning, but it will return the desired array with 13 elements, the first 2 should be ignored.

Java 8, 104 bytes
A lambda returning an int[] of frequencies. Assign to Supplier<int[]>.
()->{int o[]=new int[11],i=0;while(i++<100)o[(int)(Math.random()*6)+(int)(Math.random()*6)]++;return o;}

Try It Online
Ungolfed lambda
() -> {
    int
        o[] = new int[11],
        i = 0
    ;
    while (i++ < 100)
        o[(int) (Math.random() * 6) + (int) (Math.random() * 6)]++;
    return o;
}

Javascript 85 75 characters
Thanks Shaggy!
a=[]
for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o]|0)+1
alert(a)

History
85
a={}
f=_=>Math.random()*6
for(i=0;i++<100;)a[o=-~f()-~f()]=(a[o]||0)+1
console.log(a)

Kept meaning to give you a few savings for this; here's a very quickly golfed 75 byte version of your solution: a=[];for(i=100;i--;)a[o=(f=_=>Math.random()*6|0)()+f()]=(a[o]|0)+1;alert(a). (Note: in this instance, the IIFE neither saves nor costs any bytes but there are times when it can save you a byte or 2, so it's handy to have it in your "golfbag".)

Oh, awesome, thanks. Useful tricks there! So interesting that |0 is the golfy solution to "Math.floor()" and also to "convert undefined to 0".

QBIC, 45 bytes
[100|h=_r1,6|+_r1,6|-2┘g(h)=g(h)+1][0,z|?g(b)

Explanation:
[100|         FOR a = 1 to 100
h=_r1,6|       set h to a random value between 1-6
 +_r1,6|       + another rnd(1,6) (2, 3 ... 11, 12)
 -2            - 2 (index: 0 ... 10
┘             Syntactic linebreak
g(h)          When using array parenthesis on an undefined array,
              it is interpreted as an array with 10 indexes of all zeroes.
    =         Of array g, set the value of index h (0 ... 11)
      g(h)+1  to one higher (all indices start out as 0)
              Note that we need to track 11 values. Fortunately, QBasic'set
              empty, 10-sized array has 11 indices, because of base 0 / base 1 ambiguity.
]             NEXT set of dice
[0,z|         FOR b = 0 to 10
?g(b)           PRINT the tracker array

APL, 14 bytes
,∘≢⌸+/?100 2⍴6

Presents data as a table with the left column representing the sum and the right representing the number of occurrences.
Explained
        100 2⍴6  ⍝ create an 2×100 array of 6
       ?         ⍝ roll for each cell from 1 to 6
     +/          ⍝ sum every row
   ⌸            ⍝ for every unique sum
,∘≢              ⍝ get the sum and the number of indexes

Previous post:
APL, 36 31 bytes
5 bytes saved thanks to @Adám
(11⍴⍉⌽f)[⍋11⍴⍉f←,∘≢⌸+/?100 2⍴6]

Explanation
f←,∘≢⌸+/?100 2⍴6
          100 2⍴6    ⍝ create an 2×100 array of 6
         ?           ⍝ roll for each cell from 1 to 6
       +/            ⍝ sum every row
     ⌸              ⍝ for every unique sum
  ,∘≢                ⍝ get the sum and the number of indexes

(11⍴⍉⌽f)[⍋11⍴⍉f]  ⍝ ⍋x returns the indexes of the sorted x in the current x
                     ⍝ x[y] find the yth elements of x
                     ⍝ x[⍋y] reorders x the same way that would be required to sort y

            11⍴⍉f   ⍝ the column of sums - see below
 11⍴⍉⌽f            ⍝ the column of counts - see below

How does  11⍴⍉⌽f works?
⍝ ⌽ - Reverses the array
⍝ ⍉ - Transposes the array

  ⍝   f
 9 14   ⍝ Sum - Occurences
 4  9
 7 17
 8 18
 6 15
 5  7
10  3
11  5
 3  6
 2  2
12  4

  ⍝   ⍉f
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences

  ⍝   ⍉⌽f
14 9 17 18 15 7  3  5 6 2  4  ⍝ Occurences
 9 4  7  8  6 5 10 11 3 2 12  ⍝ Sum

Save a few bytes by combining the statements and making the operand tacit: (11⍴⍉⌽f)[⍋11⍴⍉f←,∘⍴⌸+/?100 2⍴6]

Sorry, I edited my suggestion while you incorporated it. Notice the tacit operand.

However, OP allows any unambiguous output format, so ,∘⍴⌸+/?100 2⍴6 should be enough, as it lists the occurring sums (thus indicating which ones are not there) and their frequencies (so no sorting is needed).

><>, 93 bytes
00[0[v
v 1\v/4
v 2xxx5
v 3/^\6
>l2(?^+]laa*=?v0[
  /&1+&\ v1&0]<
=?/ :?!\}>:@@:@
oa&0n&}< ^+1

Try it online, or watch it at the fish playground!
The ugly output format is a sequence of numbers separated by newlines, where the nth number says how many times the sum was n — it's ugly because it prints forever, for all positive integers n, although most of the lines will be 0. (The TIO link is modified to stop after n=12, at the cost of 5 bytes.)
The fish playground is fairly slow — it takes about three and a half minutes to print up to n=12 at top speed — so you may want to modify it to roll 10 pairs of dice instead of 100 by changing the aa* in the 5th line to a   (that is, a followed by two spaces).
The random dice rolls are done by this bit:
1\v/4
2xxx5
3/^\6

The xs change the fish's direction randomly. Assuming that's implemented with equal probabilities, it's clear that the die roll result is a uniform distribution by symmetry.
Once the fish has rolled 100 pairs of dice, it counts how many times the sum was n with this bit (unwrapped for clarity, and starting in the top left):
v       /&1+&\
>:@@:@=?/ :?!\}
^   +1oa&0n&}<

We keep n at the front of the stack, and use the register to count the number of times n appears.

Perl 5, 64 bytes
map$s{2+int(rand 6)+int rand 6}++,1..100;say"$_ $s{$_}"for 2..12

Try it online!
Output format:
<sum> <# rolls>
For sums with zero rolls, the rolls column is blank.

PHP, 65 bytes
while($i++<100)${rand(1,6)+rand(1,6)}++;for(;++$k<13;)echo+$$k,_;

prints a leading 0_ and then the occurences of 2 to 12, followed by an underscore each.
Run with -nr or try it online.

K (oK), 24 22 bytes
Solution:
+/(!11)=/:+/(2#100)?'6

Try it online!
Explanation:
k 'port' of my q solution. Evaluation occurs right-to-left, hence brackets around the til (!)
+/(!11)=/:+/(2#100)?'6 / the solution
            (2#100)    / the list (100;100)
                   ?'6 / take 6 from each left/each right (roll the dice twice)
           +/          / sum rolls together
  (!11)                / til, performs range of 0..n-1, thus 0..10
       =/:             / equals each right (bucket the sum of the rolls)
+/                     / sum up to get counts per result

Edits:

-2 bytes switching the each-left for an each-both, and the each-left + flip for each-right

Pyth, 21 bytes
V100aY,O6O6)VTlfqsTNY

Outputs each step in the creation of the rolls, then outputs frequency of each sum 0 - 10 on a separate line.

V100aY,O6O6)VTlfqsTNY Full program, no input, outputs to stdout
V100                  For N from 0 to 100
    a ,O6O6           Append a pair of random ints below 6
     Y                To a list Y, initialized to the empty list
           )          Then
            VT        For N from 0 to 10
              f     Y Print Y filtered to only include pairs
                q  N  For which N is equal to
                 sT   The sum of the pair

Java (OpenJDK 8), 95 bytes
a->{int r[]=new int[11],i=0,d=0;for(;i++<200;)r[d+=Math.random()*6]+=i%2<1?1-(d=0):0;return r;}

Try it online!
Explanations
a->{
  int r[] = new int[11],     // Rolls or result
      i   = 0,               // Iteration
      d   = 0;               // Dice accumulator
  for (;i++<200;)
    r[d+=Math.random()*6] += // Accumulate a new die and start an addition
     i % 2 < 1               // Accumulate up to two dice
       ? 1 - (d = 0)         // If we're at 2 dice, reset the accumulator and add 1
       : 0;                  // If we only have one die, add 0
  return r;
}

Vyxal, 9 bytes
₁ƛ6℅6℅+;Ċ

Try it Online!
Returns a list of [roll, count]. If a roll total didn't happen, then it isn't included in the list.
Explained
₁ƛ6℅6℅+;Ċ
₁ƛ        # for each item in range(1, 100 + 1):
  6℅6℅    #   push a random number from range(1, 6 + 1) and then another random number from that range
      +   #   and add them together
       ;  # end map - this leaves 100 random dice rolls in a list.
        Ċ # get the count of each item

Burlesque, 18 bytes
1J6rn200.+2CO)++f:

Try it online!
1J6rn # Infinite random d6 rolls
200.+ # Take first 200
2CO   # Chunks of 2
)++   # MapSum
f:    # Frequency list

source: Stack Exchange

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

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

sort: votes


text:
Give me some questions to answer!
Introduction
Sometimes I get bored and there are no new questions on PPCG, so I want you to dig a random question from PPCG's past.
Challenge
Given a user's PPCG ID as input (e.g. my ID is 30525), output the URL of a randomly chosen PPCG question. If the question does not meet the following criteria, you must choose another question until it does meet the criteria:

The question asker must not be the user whose ID was inputted to the question
The question must not have already been answered by the  user whose ID was inputted to the question
The question must not be unanswered: it's probably too hard
The question must not have over 10 answers: it's probably too easy
The question must be tagged code-golf

Rules
URL shorteners are disallowed.
You may use the Stack Exchange API and the Stack Exchange Data Explorer.
You will only ever be given a real PPCG user's ID.
In the unlikely event that there are no suitable questions, you do not have to output anything (undefined behaviour is fine).
Side Challenge
Although you won't be awarded extra points, it would be appreciated if someone designed a usable bookmarklet which, when run, opened the browser window to a random PPCG question that follows the above criteria. The user ID should be hardcoded into program (for the bookmarklet only).
Challenge
The shortest code in bytes wins.

PowerShell, 261 Bytes
param($i)$q=irm (($u="api.stackexchange.com/questions/")+($s="?tagged=code-golf&site=codegolf"))
do{$t=$q.items|?{$c=$_|% an*;$_.owner.user_id-ne$i-and$c-gt0-and$c-lt10}|random}while((irm($u+$t.question_id+'/answers'+$s)).items.owner.user_id-contains$i)
$t.link

Explanation:
param($i)
$q=irm (($u="api.stackexchange.com/questions/")+($s="?tagged=code-golf&site=codegolf")) #run this query
do{ #until we find a valid question, get a random one that fits the basic specs
    $t=$q.items|?{$c=$_|% an*;$_.owner.user_id-ne$i-and$c-gt0-and$c-lt10}|random
}while( #Get all of the answers, and their owners into an array, check it doens't contain the provided id
(irm($u+$t.question_id+'/answers'+$s)).items.owner.user_id-contains$i
)
$t.link #output the question link

add 4 bytes for a version which opens it in webbrowser
param($i)$q=irm (($u="api.stackexchange.com/questions/")+($s="?tagged=code-golf&site=codegolf"))
do{$t=$q.items|?{$c=$_|% an*;$_.owner.user_id-ne$i-and$c-gt0-and$c-lt10}|random}while((irm($u+$t.question_id+'/answers'+$s)).items.owner.user_id-contains$i)
saps $t.link

JavaScript (ES6), 333 329 327 323 283 bytes
Needs to be run from within the api.stackexchange.com domain (relevant meta). Returns a Promise containing the URL (relevant meta).
f=async i=>await(u="/questions/",s="?tagged=code-golf&site=codegolf",q=await(await(await fetch(u+s)).json()).items.filter(x=>x.owner.user_id!=i&x.answer_count<11).sort(_=>.5-Math.random())[0],await(await fetch(u+q.question_id+s)).json()).items.some(x=>x.owner.user_id==i)?f(i):q.link

Try it

f=async i=>await(u="//api.stackexchange.com/questions/",s="?tagged=code-golf&site=codegolf",q=await(await(await fetch(u+s)).json()).items.filter(x=>x.owner.user_id!=i&x.answer_count<11).sort(_=>.5-Math.random())[0],await(await fetch(u+q.question_id+s)).json()).items.some(x=>x.owner.user_id==i)?f(i):q.link
k.previousSibling.value=58974 // me
k.onclick=_=>f(+k.previousSibling.value).then(p=>k.nextSibling.innerText=p)
<input type=number><button id=k>Fetch</button><pre>

Bookmarklet
And here it is as a customisable bookmarklet, which will load a random question you've yet to answer. To use it, simply add a new bookmark to your browser's toolbar and drop the full code into the URL field.
Unlike the above solution, this works with all questions on a site therefore it may be slow to run (depending on the site and tags) and could also be expensive in the number of queries it needs to make to the API, as the API can only return 100 questions at a time.
To customise, change the following variables

k: Your API key - you can register for one here.
s: The Stack Exchange site you want to grab a question for.
i: Your user ID on that site.
t: The tags you want to filter by. There are 4 options available for this one:

"": An empty string; if you don't want to filter by any tags,
"code-golf;string": A semi-colon separated list of tags you want to filter by,
prompt("Tags:"): You will be prompted to enter the tags you want to filter by, or,
prompt("Tags:","code-golf;string"): You will be prompted to enter the tags you want to filter by, with a default list provided.

javascript:(f=(

/* See https://codegolf.stackexchange.com/a/122400/58974 for documenation */
k="",
s="codegolf",
i=58974,
t="code-golf",

p=1,q=[],r=1)=>fetch((u="//api.stackexchange.com/questions/")+(d=`?key=${k}&tagged=${t}&site=`+s)+`&page=${p}&pagesize=100`).then(r=>r.json()).then(j=>r&&(q=[...q,...j.items.filter(x=>x.owner.user_id!=i&(a=x.answer_count)&a<11)])^j.has_more?f(i,k,s,t,p+1,q,1):q.sort(_=>.5-Math.random())[0]).then(y=>fetch(u+y.question_id+"/answers"+d).then(r=>r.json()).then(j=>j.items.some(x=>x.owner.user_id==i)?f(i,k,s,t,q,0):window.location=y.link)))()

based my powershell answer on this one, nice reuse of the strings for the api.

At which point do you get banned permanently? ;)

@BetaDecay, if the API challenges pick up pace again, I might soon find out! :D

You can use the api tokens from here: https://stackapps.com/q/7384/45852 to increase your rate limit.

Gave me "Golf you an Anagram for great good!" (my own question) for the default id! :D

You put the heart across me there, @Arjun; thought you were about to tell me it returned one of your own questions for your ID!

Don't worry, that's not the case! :)

This is only returning questions which are on the front page... :P Not exactly what I was looking for

@BetaDecay, will it suffice as a solution to the challenge? If not, I could (in ascending order of extra bytes): 1. Get the first 5 pages of questions, 2. get the last page, 3. both of the above, 4. Get all questions. Let me know which would meet the requirements but note that the last option involves a lot of queries to the API.

@Shaggy Well I think it is within rules, so you don't need to change it, but it doesn't really fit into the digging questions from PPCG's past box :/

@BetaDecay, I did intend on expanding it into a usable script but ran out of time; I'll try to come back to it tomorrow.

@BetaDecay; boomarklet now available :)

Nice! This'll be great :D

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


text:
Alice's ordinal formatting
Introduction
Alice is a 2-d language by Martin Ender which has two different execution modes, cardinal and ordinal. When the instruction pointer passes through a mirror (either / or \), it switches from one mode to the other one.
In this challenge we will focus on ordinal mode, where commands operate on strings and the instruction pointer moves diagonally, bouncing against the edges of the code.
Simple programs operating only in ordinal mode can be written in a quite compact style, like in the following example:
/fbd/
@aec\

Here the IP starts in cardinal mode from the first cell going east, passes through the first mirror and starts moving diagonally and bouncing, executing commands a, b, and c. It then encounters the north-east mirror which makes it go south towards the other mirror and then start bouncing back towards the west, encountering commands d,e,f, and finally @, which terminates the program.
This kind of structure is quite compact, but it's not easy to write and maintain (adding a single command might force us to reorder most of the code!), so I'd like you to help me with formatting.
The task
Given a sequence of commands, where each command is a single printable ASCII character, reorder them on two lines so that the first half of the sequence can be read starting from the first character of the second line and then moving always diagonally towards the right, while the second half can be read taking the remaining characters from right to left. Don't worry about mirrors and the termination symbol, I'll add them myself.
So, for example, given input abcdef you should output
fbd
aec

In case the input is of odd length, you should add a single space (which is a noop in Alice) anywhere, as long as the sequence of commands encountered remains the same. You can also choose to output two lines differing in length by one character, in which case the shorter one is considered as having a single space at the end.
Rules
This is code-golf, the shortest answer, in bytes, wins!

You may input/output via any of the default input/output methods
Input consists of a single line of printable ASCII characters
A single trailing newline is permitted in the output
Some outputs of your program may not have a completely correct behavior when run as Alice programs (e.g. if the padding space is inserted inside a string literal). You don't have to concern yourself with these situations
Standard loopholes are forbidden

Test cases
--Input
abcdef
--Output
fbd
aec

--Input
123
--Output
 2
13
OR
31
 2
OR
3
12
OR
32
1

--Input
O
--Output
O

OR

O

--Input
"Hello, World!"o
--Output
oH!lloo
""edlr,W

--Input
i.szR.szno
--Output
o.zz.
inssR

--Input
"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So
--Output
o *^i}'.*[;.h~r}}~"{.[^
"S .^~ y~a}~~.["{!~"}^^^
(Odd length, your solution may be different)

Jelly, 15 bytes
œs2U2¦ṚZUJḤ$¦ZY

Try it online!
Takes quoted input.
Explanation:
œs2U2¦ṚZUJḤ$¦ZY Main link, monadic
œs2             Split into 2 chunks of similar lengths, last might be shorter
   U2¦          Reverse the 2nd chunk
      Ṛ         Swap the chunks
       Z        Transpose into chunks of length 2
        UJḤ$¦   Reverse the chunks at even indices (1-indexed)
             Z  Transpose into 2 chunks again
              Y Join by a newline

Alice, 28 bytes
/mY. zm~wZ.k;
\I;'!*?RR.OY@/

Try it online!
If the input length is odd, this puts the padding space at the end of the linearised program, which ends up being the first character of the output.
Leo wrote an Ordinal formatter in Alice a few days ago. After adding support for odd-length inputs and then removing some stuff that wasn't necessary for this challenge, we ended up at 28 bytes. I wanted to try a slightly different approach, which is this answer. Unfortunately, it just ended up tying 28 bytes, but at least this way I can post my own solution and let Leo post his original algorithm.
This does use Leo's really clever idea to split a string in half with ..Y;m;.!z?~.
Explanation
Let's assume that the input has even length (because we'll just pad it with a space if it doesn't). The pattern is a bit easier to see if we use 0123456789 as the code. The required output would be:
91735
08264

So the first line contains all odd positions of the input and the second line all the even inputs. Furthermore, if we reverse the odd positions, then the lines itself are both the first half (possibly longer) interleaved with the reverse of second half.
So the basic idea is:

Separate input into odd and even positions.
Pad the odd positions with a space if necessary.
Reverse the odd positions.
Then twice: halve the current string, reverse the second half, interleave both halves, print with trailing linefeed.

As for the code, this looks a lot like the kind of layout we're producing in this challenge, but it's subtly different: when the IP hits the / at the end of the code it gets reflected east, not south. Then, while in Cardinal mode, the IP will wrap around to the first column. The \ there re-enters Ordinal mode, so that the second half of the code doesn't go from right to left here, but from left to right as well. This is beneficial when working with the return address stack, because it doesn't store information about the IP's direction. This lets us save a few bytes because the IP will move in the same (horizontal) direction on both w and k.
The linearised code is this:
IY' *mRw..Y;m;.!z?~RZOk@

Let's go through it:
I       Read one line of input.
Y       Unzip. Separates the string into even and odd positions.
' *     Append a space to the odd half.
m       Truncate: discards characters from the longer of the two
        strings until they're the same length. So if the input
        length was even, appending a space will make the odd half
        longer and this discards the space again. Otherwise, the
        space just padded the odd half to the same length as the
        even half and this does nothing.
R       Reverse the odd half.
w       Push the current IP address to the return address stack.
        The purpose of this is to run the following section
        exactly twice.

          This first part splits the current line in half, based
          on an idea of Leo's:
  ..        Make two copies of the current half.
  Y         Unzip one of the copies. The actual strings are irrelevant
            but the important part is that the first string's length
            will be exactly half the original string's length (rounded up).
  ;         Discard the potentially shorter half.
  m         Truncate on the original string and its even half. This shortens
            the original string to the first half of its characters.
  ;         Discard the even half, because we only needed its length.
  .!        Store a copy of the first half on the tape.
  z         Drop. Use the first half to discard it from the original string.
            This gives us the the second (potentially shorter half).
  ?         Retrieve the first half from the tape.
  ~         Swap it so that the second half is on top.
          The string has now been split in half.
  R       Reverse the second half.
  Z       Zip. Interleave the two halves.
  O       Print the result with a trailing linefeed.

k       Pop an address from the return address stack and jump back there.
        The second time we reach this, the return address stack is empty,
        and this does nothing.
@       Terminate the program.

I'll have to post another challenge for this new layout you came up with! :D Very nice, I think I'll start using it even when I don't use the return stack, it's easier to read both halves of the code from left to right

Jelly, 23 22 bytes
-1 byte thanks to Leo (bottom-left may be the padding)
LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y

A full program printing the result (the monadic link returns a list of lists of lists of characters).
Try it online! or see a test suite.
How?
LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y - Main link: list of characters
L                      - length
 Ḃ                     - modulo 2
  ⁶                    - literal space character
   ẋ                   - repeat
    ;@                 - concatenate (swap @rguments) (appends a space if the input's length is odd)
      µ                - monadic chain separation, call that s
       Ṛ               - reverse s
        ,              - pair with s
         µ         µ€  - for €ach:
          m2           -   modulo 2 slice (take every other character)
            œs2        -   split into two "equal" chunks (first half longer if odd)
               U0¦     -   upend index 0 (reverse the second chunk)
                   /   -   reduce by:
                  ż    -     zip
                     Y - join with newlines (well just the one in this case)
                       - implicit print (mushes the sublists together)

JavaScript (ES6), 104 bytes

f=
s=>s.replace(/./g,(c,i)=>a[1&~i][i+i>l?l-i:i]=c,a=[[` `],[]],l=s.length-1|1)&&a.map(a=>a.join``).join`
`
<input oninput=o.textContent=f(this.value)><pre id=o>

Works by emulating the execution path and filling the commands in as it goes.

Seems like a nice idea, but I don't know enough about javascript to understand the algorithm you used... Could you add some explanation?

@Leo I'm not sure how much more I can explain. As you know, the commands follow a zig-zag line from left to right and back left again. The 1&~i achieves the vertical zig-zag, while the i+i>l?l-i:i achieves the halfway mirror. Once all the commands have been entered into the desired execution positions, the array is then collected together to produce the desired result.


text:
KOTH - Loaded RPS
Contest permanently opened - Updated August 10th 2017
Even though on June 5th 2017 I declared a winner (who will be kept as the best answer) I'll be rnning new bots and updating the results.
June 5th Results
Congratulations user1502040
Since there are no ties, I only show the % of matches won.
Statistician2 - 95.7%
Fitter - 89.1%
Nash - 83.9%
Weigher - 79.9%
ExpectedBayes - 76.4%
AntiRepeater - 72.1%
Yggdrasil - 65.0%
AntiGreedy - 64.1%
Reactor - 59.9%
NotHungry - 57.3%
NashBot - 55.1%
Blodsocer - 48.6%
BestOfBothWorlds - 48.4%
GoodWinning - 43.9%
Rockstar - 40.5%
ArtsyChild - 40.4%
Assassin - 38.1%
WeightedRandom - 37.7%
Ensemble - 37.4%
UseOpponents - 36.4%
GreedyPsychologist - 36.3%
TheMessenger - 33.9%
Copycat - 31.4%
Greedy - 28.3%
SomewhatHungry - 27.6%
AntiAntiGreedy - 21.0%
Cycler - 20.3%
Swap - 19.8%
RandomBot - 16.2%
I created a Google Sheet with the grid of results of each pairing: https://docs.google.com/spreadsheets/d/1KrMvcvWMkK-h1Ee50w0gWLh_L6rCFOgLhTN_QlEXHyk/edit?usp=sharing

Thanks to the Petri Dilemma I found myself able to handle this King of the Hill.
The game
The game is a simple "Rock-Paper-Scissors" with a twist: Points gained with each victory increase during the match (your R, P or S get loaded).

Paper wins Rock
Scissors wins Paper
Rock wins Scissors

The winner gets as many points as his load on his play.
The loser increases by 1 the load on his play.
In the case of a tie, each player increases the load on his play by 0.5.
After 100 plays, the one with more points is the winner.
e.g.: P1 has loads [10,11,12] (Rock, Paper, Scissors) and P2 [7,8,9]. P1 plays R, P2 plays P. P2 wins and gets 8 points. P1 loads become [11,11,12], P2 loads stay the same.
Challenge specifications
Your program must be written in Python (sorry, I don't know how to handle it otherwise). You are to create a function that take each of these variables as an argument on each execution:
my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history

points - Current points (yours and your opp)
loaded- Array with loads (in order RPS) (yours and your opp)
history- String with all plays, last character is the last play (yours and your opp)
You must return "R", "P" or "S". If you would return something different, it would be an automatic lose of the match.
Rules
You cannot change built-in functions.
Testing
I'll keep a Git updated with the code and all the bots compiting: https://github.com/Masclins/LoadedRPS
Judging
The winner will be decided by selecting the person with the most win matches after 1000 full round-robin. Ties will be broken by matches tied.
1000 matches are being played rather than one because I expect a lot of randomness, and that way the randomness would be less relevant.
You can submit up to 5 bots.
The contest ends on JulyJune 4th (that will be the last day I'll accept any answer), and on JulyJune 5th I'll post the final stadings (might try to post an advancemnt before).

Since this is my first KOTH, I'm 100% opened to changing anything for improvement, such as the number of matches played against each bot.
Edited to 1000 matches, since I see there really is quite randomness involved.

with some randomised bots, you actually want to make multiple games of multiple rounds

@DestructibleLemon I thought about making each bot play three times against each other bot rather than once. Seeing you think similarly, I'll do so.

three might not be enough, for some pairings

(really you need a fair large number, since some probabilites do really extend over multiple matches. see my bot, where it could get trounced, but likely wouldn't with a fair amount of matches)

I'm glad my question helped you be able to run this, @AlbertMasclans!

It would be nice to allow any language that can take input from command-line args and can output to STDOUT. I am intrested in a node.js submission.

@programmer5000 it would be indeed, but I don't know how to do so.

@AlbertMasclans is it possible to have python execute shell code and get the printed result?

@programmer5000 yes. Using from subprocess import call, the function call does what you want.

What's runcode?

@AlbertMasclans Can you post the full testscript (including runcode and bots)?

Does "full round-robin" mean that each bot plays with each other bot and all results are summed?

It would be more interesting if bots could maintain state between rounds

Which Python version will be used for testing?

@CalculatorFeline Full code posted

@SargeBorsch It means exactly what you said. I'm using Python 3.

@AlbertMasclans code can be simplified A Lot, don't forget that python has first class functions. it will also be less error prone.

does current testing code make bots also play with themselves? it looks like it does, and if a bot makes lots of ties when playing with itself, it reduces its chances to be first in leaderboard

@SargeBorsch to be honest, the main reason for me to handle this KOTH is learn Python (which I just began doing), so any advice would be welcomed. And no, it doesn't make them play themselves

oops, i looked in wrong place. yes, looks correct

i think a time limit should be chosen otherwise someone will post a solution which practically disrupts the whole shootout

Can you make a Github repo with all of the bots?

@Qwerp-Derp done (I think)

How long is the script expected to take? My PC is no slouch but it's been 2 hours and the terminal still says 0%.

in my PC it took less than an hour. Still, though, in no time the first matches should be solved, since they are for quick bots.

You said July, but you meant June, didn't you? Seems I got lucky that my bot even got accepted. Then again, I didn't realise that someone had already submitted a better Nash bot otherwise I wouldn't have bothered. And I didn't even beat NotHungry which is was my original aim...

@Neil Ooops! Yes I ment June. My deepest apologies.

Statistician (no longer playing)
import random
import collections

R, P, S = moves = range(3)
move_idx = {"R": R, "P": P, "S": S}
name = "RPS"
beat = (P, S, R)
beaten = (S, R, P)

def react(_0, _1, _2, _3, _4, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    return beat[opp_history[-1]]

def anti_react(_0, _1, _2, _3, _4, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    return beaten[opp_history[-1]]

def random_max(scores):
    scores = [s + random.normalvariate(0, 1) for s in scores]
    return scores.index(max(scores))

def greedy_margin(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    scores = [my_loaded[move] - opp_loaded[beat[move]] for move in moves]
    return random_max(scores)

def anti_greedy(my_points, opp_pints, my_loaded, opp_loaded, my_history, opp_history):
    scores = [-my_loaded[move] for move in moves]
    return random_max(scores)

def recent_stats(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    opp_history = opp_history[-10:-1]
    counts = collections.Counter(opp_history)
    scores = [(counts[beaten[move]] + 1) * my_loaded[move] -
              (counts[beat[move]] + 1) * opp_loaded[move] for move in moves]
    return random_max(scores)

def statistician(_0, _1, _2, _3, my_history, opp_history):
    m1 = []
    o1 = []
    my_loaded = [0] * 3
    opp_loaded = [0] * 3
    my_points = 0
    opp_points = 0
    strategies = [react, anti_react, greedy_margin, anti_greedy, recent_stats]
    strategy_scores = [0 for _ in strategies]
    for i, (mx, ox) in enumerate(zip(my_history, opp_history)):
        mx = move_idx[mx]
        ox = move_idx[ox]
        for j, strategy in enumerate(strategies):
            strategy_scores[j] *= 0.98
            move = strategy(my_points, opp_points, my_loaded, opp_loaded, m1, o1)
            if move == beat[ox]:
                strategy_scores[j] += my_loaded[move]
            elif move == beaten[ox]:
                strategy_scores[j] -= opp_loaded[ox]
        m1.append(mx)
        o1.append(ox)
        if mx == beat[ox]:
            opp_loaded[ox] += 1
            my_points += my_loaded[mx]
        elif mx == beaten[ox]:
            my_loaded[mx] += 1
            opp_points += opp_loaded[ox]
        else:
            my_loaded[mx] += 0.5
            opp_loaded[ox] += 0.5
    strategy = strategies[random_max(strategy_scores)]
    return name[strategy(my_points, opp_points, my_loaded, opp_loaded, m1, o1)]

Switches between a few simple strategies based on expected past performance
Statistician 2
import random
import collections
import numpy as np

R, P, S = moves = range(3)
move_idx = {"R": R, "P": P, "S": S}
names = "RPS"
beat = (P, S, R)
beaten = (S, R, P)

def react(my_loaded, opp_loaded, my_history, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    counts = [0, 0, 0]
    counts[beat[opp_history[-1]]] += 1
    return counts

def random_max(scores):
    scores = [s + random.normalvariate(0, 1) for s in scores]
    return scores.index(max(scores))

def argmax(scores):
    m = max(scores)
    return [s == m for s in scores]

def greedy_margin(my_loaded, opp_loaded, my_history, opp_history):
    scores = [my_loaded[move] - opp_loaded[beat[move]] for move in moves]
    return argmax(scores)

recent_counts = None

def best_move(counts, my_loaded, opp_loaded):
    scores = [(counts[beaten[move]] + 0.5) * my_loaded[move] -
              (counts[beat[move]] + 0.5) * opp_loaded[move] for move in moves]
    return argmax(scores)

def recent_stats(my_loaded, opp_loaded, my_history, opp_history):
    if len(opp_history) >= 10:
        recent_counts[opp_history[-10]] -= 1
    recent_counts[opp_history[-1]] += 1
    return best_move(recent_counts, my_loaded, opp_loaded)

order2_counts = None

def order2(my_loaded, opp_loaded, my_history, opp_history):
    if len(my_history) >= 2:
        base0 = 9 * my_history[-2] + 3 * opp_history[-2]
        order2_counts[base0 + opp_history[-1]] += 1
    base1 = 9 * my_history[-1] + 3 * opp_history[-1]
    counts = [order2_counts[base1 + move] for move in moves]
    return best_move(counts, my_loaded, opp_loaded)

def nash(my_loaded, opp_loaded, my_history, opp_history):
    third = 1.0 / 3
    p = np.full(3, third)
    q = np.full(3, third)
    u = np.array(my_loaded)
    v = np.array(opp_loaded)
    m0 = np.zeros(3)
    m1 = np.zeros(3)
    lr = 0.2
    for _ in range(10):
        de0 = u * np.roll(q, 1) - np.roll(v * q, 2)
        de1 = v * np.roll(p, 1) - np.roll(u * p, 2)
        m0 = 0.9 * m0 + 0.1 * de0
        m1 = 0.9 * m1 + 0.1 * de1
        p += lr * m0
        q += lr * m1
        p[p < 0] = 0
        q[q < 0] = 0
        tp, tq = np.sum(p), np.sum(q)
        if tp == 0 or tq == 0:
            return np.full(3, third)
        p /= tp
        q /= tq
        lr *= 0.9
    return p

strategies = [react, greedy_margin, recent_stats, order2, nash]

predictions = strategy_scores = mh = oh = None

def statistician2func(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    global strategy_scores, history, recent_counts, mh, oh, predictions, order2_counts
    if not opp_history:
        strategy_scores = [0 for _ in strategies]
        recent_counts = collections.Counter()
        order2_counts = collections.Counter()
        mh, oh = [], []
        predictions = None
        return random.choice(names)
    my_move = move_idx[my_history[-1]]
    opp_move = move_idx[opp_history[-1]]
    if predictions is not None:
        for j, p in enumerate(predictions):
            good = beat[opp_move]
            bad = beaten[opp_move]
            strategy_scores[j] += (my_loaded[good] * p[good] - opp_loaded[opp_move] * p[bad]) / sum(p)
    mh.append(my_move)
    oh.append(opp_move)
    predictions = [strategy(my_loaded, opp_loaded, mh, oh) for strategy in strategies]
    strategy = random_max(strategy_scores)
    p = predictions[strategy]
    r = random.random()
    for i, pi in enumerate(p):
        r -= pi
        if r <= 0:
            break
    return names[i]

Nash
import numpy as np
import random

def nashfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    third = 1.0 / 3
    p = np.full(3, third)
    q = np.full(3, third)
    u = np.array(my_loaded)
    v = np.array(opp_loaded)
    m0 = np.zeros(3)
    m1 = np.zeros(3)
    lr = 0.2
    for _ in range(10):
        de0 = u * np.roll(q, 1) - np.roll(v * q, 2)
        de1 = v * np.roll(p, 1) - np.roll(u * p, 2)
        m0 = 0.9 * m0 + 0.1 * de0
        m1 = 0.9 * m1 + 0.1 * de1
        p += lr * m0
        q += lr * m1
        p[p < 0] = 0
        q[q < 0] = 0
        tp, tq = np.sum(p), np.sum(q)
        if tp == 0 or tq == 0:
            return random.choice("RPS")
        p /= tp
        q /= tq
        lr *= 0.9
    r = random.random()
    for i, pi in enumerate(p):
        r -= pi
        if r <= 0:
            break
    return "RPS"[i]

Computes an approximate Nash equilibrium by gradient descent.

I really like this approach, and can understand why you'd want to be able to keep the state between rounds. Even though I see it a huge problem to change it given the number of submissions. I'll take that into account for further challenges (which I expect to do when this finishes).

Weigher
I lost track of reasoning while experimenting with the code, but the basic idea is to estimate opponent's move probability by last 3 moves using some weights and multiply them by another weight which depends on loads. I thought that I can somehow use my_loaded too, but I couldn't decide how, so left it out.
def weigher(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    idx = {"R": 0, "P": 1, "S": 2}
    sc = [0, 0, 0]
    for i, m in enumerate(reversed(opp_history[-3:])):
        sc[idx[m]] += (1 / (1 + i))

    for i in range(3):
        sc[i] *= (opp_loaded[i] ** 2)

    return "PSR"[sc.index(max(sc))]

Satan
Probably will be disqualified, because it's kind of cheating and it makes some assumptions about the testing function (it has to have opponent's function in a variable on its stack frame), but it doesn't technically break any current rules — it doesn't redefine or rewrite anything. It simply uses black magic to execute the opponent function to see what turn did/will they do. It cannot deal with randomness, but deterministic bots have no chance to defeat Satan.
def satan(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    import inspect, types
    f = inspect.currentframe()
    s = f.f_code.co_name
    try:
        for v in f.f_back.f_locals.values():
            if isinstance(v, types.FunctionType) and v.__name__ != s:
                try:
                    return "PSR"[{"R": 0, "P": 1, "S": 2}[
                        v(opp_points, my_points, opp_loaded, my_loaded, opp_history, my_history)]]
                except:
                    continue
    finally:
        del f

Without any doubt the best one in terms of Simplicity-Results

By the way, to use my_loaded you could add a weight that values the move that would lose against your last move(s). That is like assuming your opponent will do something similar to what you did, and therefore punishing him for assuming you will keep playing the same. Something like: for i, m in enumerate(reversed(my_history[-3:])): sc[(idx[m]+1)%3] += (K / (1 + i))

@AlbertMasclans added another solution

I really like the Satan one. But as you said, I believe it shouldn't qualify: Even if it doesn't break any explicit rule, it's clearly against the spirit of the game. Still, congratulations on your idea!

Anti-Repeater
from random import choice
def Antirepeaterfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    s = opp_history.count("S")
    r = opp_history.count("R")
    p = opp_history.count("P")

    if s>p and s>r:
        return "R"
    elif p>s and p>r:
        return "S"
    else:
        return "P"

Picks paper on the first turn, after which it returns whatever beats what the opponent has done the most, picking paper in case of a tie.
Copycat
import random
def copycatfunc(I,dont,care,about,these,enmoves):
    if not enmoves:
        return random.choice(["R","P","S"])
    else:
        return enmoves[len(enmoves)-1]

Simply copies the opponents last move.
Anti-Anti-Greedy
from random import choice
def antiantigreedy(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if opp_loaded[0] > opp_loaded[1] and opp_loaded[0] > opp_loaded[2]:
        return "S"
    if opp_loaded[1] > opp_loaded[0] and opp_loaded[1] > opp_loaded[2]:
        return "R"
    if opp_loaded[2] > opp_loaded[0] and opp_loaded[2] > opp_loaded[1]:
        return "P"
    else:
        return choice(["R","P","S"])

Picks whatever loses to the opponent's most heavily weighted choice.
Somewhat Hungry
from random import choice
def somewhathungryfunc(blah, blah2, load, blah3, blah4, blah5):
    if load[0] > load[1] and load[0] < load[2] or load[0] < load[1] and load[0] > load[2]:
        return "R"
    if load[1] > load[0] and load[1] < load[2] or load[1] < load[0] and load[1] > load[2]:
        return "P"
    if load[2] > load[1] and load[2] < load[0] or load[2] < load[1] and load[2] > load[0]:
        return "S"
    else:
        return choice(["R","P","S"])

Yggdrasil
This is named "Yggdrasil" because it looks ahead in the game tree. This bot does not perform any prediction of the opponent, it simply attempts to maintain a statistical advantage if it is given one (by balancing current and future profits). It calculates an approximately ideal mixed strategy, and returns a move selected randomly with those weights.  If this bot were perfect (which it's not, because the state valuation function is pretty bad and it doesn't look very far ahead), then it would be impossible to beat this bot more than 50% of the time.  I don't know how well this bot will do in practice.
def yggdrasil(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    cache = {}
    def get(turn, ml, ol):
        key = str(turn) + str(ml) + str(ol)
        if not key in cache:
            cache[key] = State(turn, ml, ol)
        return cache[key]

    def wrand(opts):
        total = sum(abs(w) for c,w in opts.items())
        while True:
            r = random.uniform(0, total)
            for c, w in opts.items():
                r -= abs(w)
                if r < 0:
                    return c
            print("error",total,r)

    class State():
        turn = 0
        ml = [1,1,1]
        ol = [1,1,1]
        val = 0
        strat = [1/3, 1/3, 1/3]
        depth = -1
        R = 0
        P = 1
        S = 2
        eps = 0.0001
        maxturn = 1000

        def __init__(self, turn, ml, ol):
            self.turn = turn
            self.ml = ml
            self.ol = ol
        def calcval(self, depth):
            if depth <= self.depth:
                return self.val
            if turn >= 1000:
                return 0
            a = 0
            b = -self.ol[P]
            c = self.ml[R]
            d = self.ml[P]
            e = 0
            f = -self.ol[S]
            g = -self.ol[R]
            h = self.ml[S]
            i = 0
            if depth > 0:
                a += get(self.turn+1,[self.ml[R]+1,self.ml[P],self.ml[S]],[self.ol[R]+1,self.ol[P],self.ol[S]]).calcval(depth-1)
                b += get(self.turn+1,[self.ml[R]+2,self.ml[P],self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                c += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]+2]).calcval(depth-1)
                d += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R]+2,self.ol[P],self.ol[S]]).calcval(depth-1)
                e += get(self.turn+1,[self.ml[R],self.ml[P]+1,self.ml[S]],[self.ol[R],self.ol[P]+1,self.ol[S]]).calcval(depth-1)
                f += get(self.turn+1,[self.ml[R],self.ml[P]+2,self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                g += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]+2],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                h += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R],self.ol[P]+2,self.ol[S]]).calcval(depth-1)
                i += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]+1],[self.ol[R],self.ol[P],self.ol[S]+1]).calcval(depth-1)
            self.val = -9223372036854775808
            for pr in range(0,7):
                for pp in range(0,7-pr):
                    ps = 6-pr-pp
                    thisval = min([pr*a+pp*d+ps*g,pr*b+pp*e+ps*h,pr*c+pp*f+ps*i])
                    if thisval > self.val:
                        self.strat = [pr,pp,ps]
                        self.val = thisval
            self.val /= 6

            if depth == 0:
                self.val *= min(self.val, self.maxturn - self.turn)
            return self.val

    turn = len(my_history)
    teststate = get(turn, [x * 2 for x in my_loaded], [x * 2 for x in opp_loaded])
    teststate.calcval(1)
    return wrand({"R":teststate.strat[R],"P":teststate.strat[P],"S":teststate.strat[S]})

please remove comments which don't make code more understandable

@SargeBorsch done

@PhiNotPi I'm aware that I posted no time limitation, but Yggdrasil is taking more than a minute against each opponent. Would it be possible to optimize it a little bit?

yeah it's unbearably slow

@AlbertMasclans by minute per opponent do you mean 1 minute total for all games against an opponent?  Also I can try to speed it up but I don't really know how to do it, it only looks 1 move ahead as is.

@PhiNotPi yours is not the slowest, though. For future partial rankings I'll try to post also the elapsed mean time of each bot so you see how long it took.

@AlbertMasclans I believe I have sped it up a little, although its performance might decrease.

I just timed this thing at well under 1 millsecond per move.  That's pretty fast if you ask me.

Fitter
This Bot improves Pattern and fuses it with Economist (Pattern and Economist will no longer participate)
The improvement of Pattern is that the Bot now looks for two two kinds of patterns: Opponent reacting to his last play and opponent reacting to my last play. Then evaluates both predictions to use the one that fits the best.
From that pattern the Bot has now the probability for R, P and S. Taking that into account and the expected value of each play (as Economist did), the Bot plays the one that gives the most value.
import random
import numpy as np
def fitterfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        t = len(opp_history)
        RPS = ["R","P","S"]
        if t <= 2:
                return RPS[t]
        elif t == 3:
                return random.choice(RPS)

        def n(c): return RPS.index(c)

        total_me = np.zeros(shape=(3,3))
        total_opp= np.zeros(shape=(3,3))
        p_me = np.array([[1/3]*3]*3)
        p_opp = np.array([[1/3]*3]*3)

        for i in range(1, t):
                total_me[n(my_history[i-1]), n(opp_history[i])] += 1
                total_opp[n(opp_history[i-1]), n(opp_history[i])] += 1
        for i in range(3):
                if np.sum(total_me[i,:]) != 0:
                        p_me[i,:] = total_me[i,:] / np.sum(total_me[i,:])
                if np.sum(total_opp[i,:]) != 0:
                        p_opp[i,:] = total_opp[i,:] / np.sum(total_opp[i,:])

        error_me = 0
        error_opp = 0

        for i in range(1, t):
                diff = 1 - p_me[n(my_history[i-1]), n(opp_history[i])]
                error_me += diff * diff
                diff = 1 - p_opp[n(opp_history[i-1]), n(opp_history[i])]
                error_opp += diff * diff

        if error_me < error_opp:
                p = p_me[n(my_history[-1]),:]
        else:
                p = p_opp[n(opp_history[-1]),:]

# From here, right now I weight values, though not 100% is the best idea, I leave the alternative in case I'd feel like changing it
        value = [(p[2]*my_loaded[0] - p[1]*opp_loaded[1], "R"), (p[0]*my_loaded[1] - p[2]*opp_loaded[2], "P"), (p[1]*my_loaded[2] - p[0]*opp_loaded[0], "S")]
        value.sort()

        if value[-1][0] > value[-2][0]:
                return value[-1][1]
        elif value[-1][0] > value[-3][0]:
                return random.choice([value[-1][1], value[-2][1]])
        else:
                return random.choice(RPS)

#       idx = p.tolist().index(max(p))
#       return ["P", "S", "R"][idx]

Here are the two old codes
Pattern (no longer playing)
The Pattern tries to find patterns on his opponent. It looks what the opponent had played after the last play he did (giving more weight to the latter plays).
Through that, it guesses what the opponent will play, and plays the countermatch to that.
import random
import numpy as np
def patternfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if len(opp_history) == 0:
                return random.choice(["R","P","S"])
        elif len(opp_history) == 1:
                if opp_history == "R":
                        return "P"
                elif opp_history == "P":
                        return "S"
                elif opp_history == "S":
                        return "R"

        p = np.array([1/3]*3)
        c = opp_history[-1]
        for i in range(1, len(opp_history)):
                c0 = opp_history[i-1]
                c1 = opp_history[i]
                if c0 == c:
                        p *= .9
                        if c1 == "R":
                                p[0] += .1
                        elif c1 == "P":
                                p[1] += .1
                        elif c1 == "S":
                                p[2] += .1

        idx = p.tolist().index(max(p))
        return ["P", "S", "R"][idx]

Economist (no longer playing)
The Economist does the following:
Guesses the probability of each play by the opponent by watching what he had played the last 9 turns. From that, computes the expected benefit of each play and goes with the one that has the best expected value.
import random
def economistfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if len(opp_history) == 0:
                return random.choice(["R","P","S"])
        if len(opp_history) > 9:
                opp_history = opp_history[-10:-1]
        p = [opp_history.count("R"), opp_history.count("P"), opp_history.count("S")]

        value = [(p[2]*my_loaded[0] - p[1]*opp_loaded[1], "R"), (p[0]*my_loaded[1] - p[2]*opp_loaded[2], "P"), (p[1]*my_loaded[2] - p[0]*opp_loaded[0], "S")]
        value.sort()

        if value[-1][0] > value[-2][0]:
                return value[-1][1]
        elif value[-1][0] > value[-3][0]:
                return random.choice([value[-1][1], value[-2][1]])
        else:
                return random.choice(["R","P","S"])

The messenger

def themessengerfunc(I, do, not, need, these, arguments):return "P"

Rockstar

def rockstarfunc(I, do, not, need, these, arguments):return "R"

Assassin

def assassinfunc(I, do, not, need, these, arguments):return "S"

Explanation
Now, you may think that these bots are entirely stupid.
not entirely true, these are actually based on idea, of amassing a huge bonus, and the enemy making a misstep and getting walloped with it.
now, these bots play very similarly to greedy, however, they are simpler, and do not randomly pick until they get a load on one weapon, they stick with their weapon of choice.
Another thing to note: these will each beat greedy around half the time, drawing a third of the time, and losing one sixth of the time. when they do win, they will tend to win by a lot. why is this?
Greedy, until he loses a round, will randomly pick a weapon. this means that when he does not win a round, he will pick a weapon randomly again, which could be a winning one again. if greedy draws or loses, he sticks with that weapon. if greedy wins at least one round, then picks the same weapon as the bot, greedy wins. if greedy picks the losing weapon at some point, our bot wins, because the load on our weapon would have been higher than the score greedy has.
Assuming greedy doesn't always just pick the winning weapon through grand chance, this will mean that the chances are:
1/3 : {
    1/2 win (1/6 total).
    1/2 lose (1/6 total).
}
1/3 draw
1/3 win
so: 1/3 chance to draw, 1/6 chance of a loss, 1/2 chance to win.
this probably shows that you need to do multiple games of multiple rounds
these are mainly to get the challenge rolling

Reactor
Makes the play that would have won the previous round.
import random
def reactfunc(I, dont, need, all, these, opp_history):
    if not opp_history:
        return random.choice(["R","P","S"])
    else:
        prev=opp_history[len(opp_history)-1]
        if prev == "R":
            return "P"
        if prev == "P":
            return "S"
        else:
            return "R"

You can replace opp_history[len(opp_history)-1] with opp_history[-1].

Artsy Child
This bot acts like a child playing arts and crafts, will start with paper and use either paper or scissors randomly, but will not use scissors after rock or scissors because she needs to use the scissors on paper. Will throw a rock back at anyone who throws a rock at her.
import random
def artsychildfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if len(opp_history) == 0:
            return "P"
    elif opp_history[-1] == "R":
            return "R"
    elif my_history[-1] != "P":
            return "P"
    else:
            return random.choice(["P", "S"])

Here the three Bots I have build for testing:

RandomBot
import random
def randombotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        return random.choice(["R","P","S"])

Greedy
Simply chooses his most loaded option.
import random
def greedyfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if my_loaded[0] > my_loaded[1]:
                if my_loaded[0] > my_loaded[2]:
                        return "R"
                elif my_loaded[0] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["R","S"])
        elif my_loaded[0] < my_loaded[1]:
                if my_loaded[1] > my_loaded[2]:
                        return "P"
                elif my_loaded[1] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["P","S"])
        else:
                if my_loaded[0] > my_loaded[2]:
                        return random.choice(["R","P"])
                elif my_loaded[0] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["R","P","S"])

Antigreedy
Assumes opponent will play greedy and plays the winning alternative.
import random
def antigreedyfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if opp_loaded[0] > opp_loaded[1]:
                if opp_loaded[0] > opp_loaded[2]:
                        return "P"
                elif opp_loaded[0] < opp_loaded[2]:
                        return "R"
                else:
                        return "R"
        elif opp_loaded[0] < opp_loaded[1]:
                if opp_loaded[1] > opp_loaded[2]:
                        return "S"
                elif opp_loaded[1] < opp_loaded[2]:
                        return "R"
                else:
                        return "S"
        else:
                if opp_loaded[0] > opp_loaded[2]:
                        return "P"
                elif opp_loaded[0] < opp_loaded[2]:
                        return "R"
                else:
                        return random.choice(["R","P","S"])

Best of Both Worlds
This bot basically combines Anti-Greedy and Greedy (hence the name).
def bobwfunc(a, b, my_loaded, opp_loaded, c, d):
    opp_max = max(opp_loaded)
    opp_play = "PSR"[opp_loaded.index(opp_max)]

    my_max = max(my_loaded)
    my_play = "RPS"[my_loaded.index(my_max)]

    if opp_play == my_play:
        return opp_play
    else:
        return my_play if opp_max < my_max else opp_play

This is the Antigreedy, already posted as an example.

@AlbertMasclans Changed it to another bot.

find is for strings. my_loaded and opp_loaded are both lists. index should be good for what you want.

@AlbertMasclans Whoops, fixed now. Thanks for the catch! I hope this isn't another dup... I don't want to delete this post again.

This is ok, thanks for playing

Not Hungry
def nothungryfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if my_loaded[0] < my_loaded[1]:
            if my_loaded[0] < my_loaded[2]:
                    return "R"
            elif my_loaded[0] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["R","S"])
    elif my_loaded[0] > my_loaded[1]:
            if my_loaded[1] < my_loaded[2]:
                    return "P"
            elif my_loaded[1] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["P","S"])
    else:
            if my_loaded[0] < my_loaded[2]:
                    return random.choice(["R","P"])
            elif my_loaded[0] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["R","P","S"])

This is literally the inverse of Greedy, it chooses the lowest points option available.

Use Opponent's Favorite
from collections import Counter
import random
def useopponents(hi, my, name, is, stephen, opp_history):
  if opp_history:
    data = Counter(opp_history)
    return data.most_common(1)[0][0]
  else:
    return random.choice(["R","P","S"])

For the first turn, chooses a random item. For every other turn, uses the opponent's most common choice. If there is a tie, it defaults to the earliest most common choice.
//I stole code from here

Winning is Good
import random
def goodwinning(no, yes, maybe, so, my_history, opp_history):
  if opp_history:
    me = my_history[len(my_history)-1]
    you = opp_history[len(opp_history)-1]
    if you == me:
      return goodwinning(no, yes, maybe, so, my_history[:-1], opp_history[:-1])
    else:
      if me == "R":
        if you == "P":
          return "P"
        else:
          return "R"
      elif me == "P":
        if you == "S":
          return "S"
        else:
          return "R"
      else:
        if you == "R":
          return "R"
        else:
          return "P"
  else:
    return random.choice(["R","P","S"])

Returns the choice of the winner of the previous round. If the previous round was a tie, recursively checks the round before that. If it was only ties, or it is the first round, returns a random choice.

NashBot
import random
def nashbotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    r = opp_loaded[0] * opp_loaded[2]
    p = opp_loaded[0] * opp_loaded[1]
    s = opp_loaded[1] * opp_loaded[2]
    q = random.uniform(0, r + p + s) - r
    return "R" if q < 0 else "P" if q < p else "S"

Randomly chooses between the three options in such a way that the opponent statistically has no preference between moves with regards to how much it scores; in other words, both Greedy and Not Hungry should have the same average expected score against it.

Expectedbayes
Edit: Updated Ranking
This is the new top ranking after inclusion of Expectedbayes:

statistician2func   91.89%
fitterfunc          85.65%
nashfunc            80.40%
weigherfunc         76.39%
expectedbayesfunc   73.33%
antirepeaterfunc    68.52%
...

Explanations
(NB: post 05/06/2017 submission)
This bot tries to maximize the expected value of its next move by:

Computing the probability for each of the opponent's next possible move
Using that figure and the loads to compute the expected value for each of R,P and S
Selecting  the move that has the highest expected value
Randomly selecting a value if predicting failed

Probabilities are updated every ten moves. The number of past moves used to compute the probabilities has been set to 10 for each bot (so 20 features overall). This is probably overfitting the data, but I did not try to check further.
It relies on the scikit library to compute the opponent's move probabilities (i am saying it in case I misread the rules and it was in fact not allowed).
It easily wins against bots that always make the same choice. Surprisingly, it is quite effective against the random bot with a 93% win rate (I believe this is due to the fact that it limits the number of points his opponent can get while maximizing its own number of possible points for each round).
I made a quick try with 100 turn and only a limited number of bots, and this is what I got from result_standing:

randombotfunc,35
nashbotfunc,333
greedyfunc,172
antigreedyfunc,491
themessengerfunc,298
rockstarfunc,200
statistician2func,748
fitterfunc,656
expectedbayesfunc,601

Which is not that bad!
from sklearn.naive_bayes import MultinomialNB
import random

#Number of past moves used to compute the probability of next move
#I did not really try to make such thing as a cross-validation, so this number is purely random
n_data = 10

#Some useful data structures
choices = ['R','P','S']
choices_dic = {'R':0,'P':1,'S':2}
point_dic = {(0,0):0,(1,1):0,(2,2):0, #Same choices
             (0,1):-1,(0,2):1, #me = rock
             (1,0):1,(1,2):-1, #me = paper
             (2,0):-1,(2,1):1} #me = scissor

def compute_points(my_choice,opp_choice,my_load,opp_load):
    """
    Compute points
    @param my_choice My move as an integer
    @param opp_choice Opponent choice as an integer
    @param my_load my_load array
    @param opp_load opp_load array
    @return A signed integer (+ = points earned, - = points losed)
    """
    points = point_dic[(my_choice,opp_choice)] #Get -1, 0 or 1
    if points > 0:
        return points*my_load[my_choice]
    else:
        return points*opp_load[opp_choice]

#This use to be a decision tree, before I changed it to something else. Nevertheless, I kept the name
class Decision_tree:
    def __init__(self):
        self.dataX = []
        self.dataY = []
        self.clf = MultinomialNB()

    def decide(self,my_load,opp_load,my_history,opp_history):
        """
        Returns the decision as an integer

        Done through a try (if a prediction could be made) except (if not possible)
        """
        try:
            #Let's try to predict the next move
            my_h = list(map(lambda x: choices_dic[x],my_history[-n_data:-1]))
            opp_h = list(map(lambda x: choices_dic[x],opp_history[-n_data:-1]))
            pred = self.clf.predict_proba([my_h+opp_h])
            #We create a points array where keys are the available choices
            pts = []
            for i in range(3):
                #We compute the expected gain/loss for each choice
                tmp = 0
                for j in range(3):
                    tmp += compute_points(i,j,my_load,opp_load)*pred[0][j]
                pts.append(tmp)
            return pts.index(max(pts)) #We return key for the highest expected value
        except:
            return random.choice(range(3))

    def append_data(self,my_history,opp_history):
        if my_history == "":
            self.clf = MultinomialNB()
        elif len(my_history) < n_data:
            pass
        else:
            my_h = list(map(lambda x: choices_dic[x],my_history[-n_data:-1]))
            opp_h = list(map(lambda x: choices_dic[x],opp_history[-n_data:-1]))
            self.dataX = self.dataX + [my_h+opp_h]
            self.dataY = self.dataY + [choices_dic[opp_history[-1:]]]

            if len(self.dataX) >= 10:
                self.clf.partial_fit(self.dataX,self.dataY,classes=[0,1,2])

                self.dataX = []
                self.dataY = []

#Once again, this is not actually a decision tree
dt = Decision_tree()

#There we go:
def expectedbayesfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    dt.append_data(my_history,opp_history)
    choice = choices[dt.decide(my_loaded,opp_loaded,my_history,opp_history)]
    return choice

Welcome to PPCG, and nice first post!

Thanks a lot! I wanted to participate in PPCG for a long time. Now it's fixed!

Cycler
def cycler(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    return "RPS"[len(myhistory)%3]

0

b l o d  s o c e r
s o c e r y
I gave it a fix, so it should probably work now I hope
I messed something up again so I deleted and undeleted. I am making a lot of mess ups.
def blodsocerfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    import random
    # tuned up an ready to go hopeful
    # s o c e r y
    if len(my_history) > 40 and len(set(opp_history[-30:])) == 1:
        if opp_history[-1] == "S":
            return "R"
        elif opp_history[-1] == "R":
            return "P"
        else:
            return "S"
        # against confused bots that only do one thing most of the time.
    elif len(my_history)>30 and min(opp_history.count(i) for i in "RPS")/max(opp_history.count(i) for i in "RPS") >0.8:
        return "RPS"[my_loaded.index(max(my_loaded))] # This is so if the other bot is acting errratic
                                                      # the max bonus is used for advantage
    elif len(my_history) < 10:
        if len(my_history) > 2 and all(i == "S" for i in opp_history[1:]):
            if len(my_history) > 5: return "S"
            return "P"
        return "S" # Be careful, because scissors are SHARP
    elif len(set(opp_history[1:10])) == 1 and len(my_history) < 20:
        if opp_history[1] == "S":
            return "R"
        elif opp_history[1] == "R":
            return "R"
        else:
            return "P"
    elif len(opp_history) -  max(opp_history.count(i) for i in "RPS") < 4 and len(my_history) < 30:
        if opp_history.count("R") > max(opp_history.count(i) for i in "PS"):
            return "P"
        if opp_history.count("P") > max(opp_history.count(i) for i in "RS"):
            return "S"
        if opp_history.count("S") > max(opp_history.count(i) for i in "RP"):
            return "R"
    elif len(my_history) < 15:
        if max(opp_loaded)<max(my_loaded):
            return "RPS"[len(my_history)%3]
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+len(my_history)%2)%3]
    elif len(my_history) == 15:
        if max(opp_loaded)<max(my_loaded):
            return "RPS"[(len(my_history)+1)%3]
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+ (len(my_history)%2)^1)%3]
    else:
        if max(opp_loaded)<max(my_loaded):
            return random.choice("RPS")
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+ (random.randint(0,1)))%3]

if opp_history[1] == "S": return "R" elif opp_history[1] == "R": return "R" else: return "P" what sort of socery is this?

@DestructibleLemon This divides by 0: elif min(opp_history.count(i) for i in "RPS")/max(opp_history.count(i) for i in "RPS") >0.8 and len(my_history)>30:

@AlbertMasclans I fixed that.

@RobertFraser what exactly is outstanding about that code snippet?

@DestructibleLemon I'm not entirely sure what you wanted to do here: "RPS"[my_loaded.index(max(my_loaded))+len(my_history)%2] but it looks out of range (and so will the further lines).

whoops. I should fix this. will delete and undelete

@RobertFraser r i s k m a n g m e n t s o c e r y

Ensemble
from random import *
def f(I):
    if I==0:return "R"
    if I==1:return "P"
    return "S"
def b(I):
    if I=="R":return 0
    if I=="P":return 1
    return 2
def Ensemble(mp,op,ml,ol,mh,oh):
    A=[0]*3
    B=[0]*3
    if(len(oh)):
        k=b(oh[-1])
        A[k-2]+=0.84
        A[k]+=0.29
        for x in range(len(oh)):
            g=b(oh[x])
            B[g-2]+=0.82
            B[g]+=0.22
        s=sum(B)
        for x in range(len(B)):
            A[x]+=(B[x]*1.04/s)
        r=max(A)
    else:
        r=randint(0,3)
    return f(r)

Several competing algorithms vote on the best solution.
Swap
from random import *
def f(I):
    if I==0:return "R"
    if I==1:return "P"
    return "S"
def b(I):
    if I=="R":return 0
    if I=="P":return 1
    return 2
def Swap(mp,op,ml,ol,mh,oh):
    A=[0]*3
    B=[0]*3
    if(len(mh)):
        r=(b(mh[-1])+randint(1,2))%3
    else:
        r=randint(0,3)
    return f(r)

Does a random move, but without repeating the last move it did.

Weighted Random
Like RandomBot, but it picks only 2 to throw each time it is invoked.  Will sometimes beat Rockstar or Assassin, but will pump up the scores of the other one (e.g., if it beats Rockstar, it gives Assassin a point boost).
import random

selection_set = ["R", "P", "S"]
selection_set.pop(random.randint(0,2))
def weightedrandombotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    return random.choice(selection_set)

Greedy psychologist
Named that because it defaults to greedy, but if it can't decide, it counters whatever the opponent would do if they used the greedy strategy. If it still can't decide, it goes randomly.
from random import choice

def greedypsychologistfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    greedy = get_my_move(my_loaded)
    combined = list(set(greedy) & set(get_opp_counter(opp_loaded)))

    if len(combined) == 0:
        return choice(greedy)
    return choice(combined)

def get_indexes(lst, value):
    return [i for i,x in enumerate(lst) if x == value]

def get_my_move(my_loaded):
    return ["RPS"[i] for i in get_indexes(my_loaded, max(my_loaded))]

def get_opp_counter(opp_loaded):
    return ["PSR"[i] for i in get_indexes(opp_loaded, max(opp_loaded))]

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


text:
Count the videos in a Youtube Playlist
Challenge
Given a Youtube playlist, output the number of videos in it.
I/O
The playlist will be given as an URL; for example, https://www.youtube.com/playlist?list=PL_3jnZNPYn7qUatgDYBS5NShkfXoehSRC (this is a playlist a friend sent me to try to get me to listen to K-Pop because she's obsessed with it and I don't like it :P)
The link to a playlist is of the form https://www.youtube.com/playlist?list=<id>. The input is the URL, not the ID.
The output is to be a single integer indicating how many videos are in this playlist. You can either output the total number of videos or the number of non-deleted videos, whichever one is more golfy for you.
Test Cases
https://www.youtube.com/playlist?list=PL_3jnZNPYn7qUatgDYBS5NShkfXoehSRC -> 12
https://www.youtube.com/playlist?list=PLIEbITAtGBebWGyBZQlkiMXwt30WqG9Bd -> 114 OR 1

Feel free to add more test cases.

Hats off for finding the sneakiest way of asking people to make you a library to count videos in a YouTube playlist.

I just resisted the urge to add a rickroll playlist. Or the "Dank Memes" playlist.

Off topic: I'd be more interested in a way list all videos a youtube channel has to offer.  The source code doesnt seem to include this naturally.

@Blauhirn That's an interesting idea. Maybe you could make a challenge about that.

05AB1E, 22 bytes
Assumes that the URL is passed without the https://.
Code:
.w’®Ã-ƒ¢’¡`"
"¡2è#¬

Uses the 05AB1E encoding. Cannot be tried online, because of internet access.
Explanation:
.w                       # Receive implicit input and read all data from the url
  ’®Ã-ƒ¢’¡               # Split on the string "header-details"
          `              # Flatten once which leaves the last element on top of the stack
           "
"¡       # Split on the string "
"
                  2è     # Get the third element
                    #    # Split on spaces
                     ¬   # Retrieve the first element

This is what I get when running in the command line:

What sort of command line is that? I haven't seen it before.

@Okx It's cmder

How does it work?

@StevenVascellaro Thanks for the reminder, I have added an explanation.

MATL, 15 bytes
Thanks to Hyper Neutrino for finding a mistake, now corrected.
Xi'wner">\n'XXn

The input is a string enclosed with single quotes. The output is the number of undeleted videos.
Here's an example run with the two test cases. As of June 13, 2017 the number of undeleted videos in the playlists are 12 and 1 respectively.

How it works
Xi          % Read string containing URL and get contents as a string
'wner">\n'  % Push this string
XX          % Regexp matching. Gives a cell array with the matched strings
n           % Number of elements. Implicitly display

Ha, clever regex!

What are you using to capture the screen?

@Matt LICEcap for Windows

Question: What if I create a playlist called "wner"? Will it still work?

@HyperNeutrino Good point. I have corrected it. BTW, the number of videos in the first list has changed

Nice fix. And yes, thanks for pointing that out. That would make sense; that's my friend's K-Pop playlist which she makes her friends listen to (including me >.<) and she keeps adding to it :P

@HyperNeutrino Well, in this case it looks like she removed one track :-)

Oh? Hm, that's weird. I'll check and maybe ask her right now.

Scala 2.12, 138 bytes
print("""
.*?

(\d+).*?
""".r.findFirstMatchIn(scala.io.Source.fromURL(args(0),"utf-8").getLines.mkString("")).get.group(1))

Save it to something.scala and run by scala something.scala {url}.

JS (ES6), 68 bytes
x=>fetch(x).then(x=>x.text()).then(x=>alert(x.match(/(\d+) vi/)[1]))

Paste this in to your console on youtube.com to try:
(x=>fetch(x).then(x=>x.text()).then(x=>alert(x.match(/(\d+) vi/)[1])))(prompt("Enter the URL"))

bash + curl + gnu grep, 32 bytes
Finally giving Code Golf a go:
curl -s $1|grep -Po \\d+(?= vid)

Use curl -s to download without any extra output.
Pipe the output to grep (perl regex) which will output only the match

Match the first number that proceeds " vid"

This is golfed from how I would do this practically.

Nice first submission!

PowerShell, 55 Bytes
"$(iwr "$args")"-match'(?s)(\d+) vid'>$null;$matches[1]

Browse to the site. Convert the object to a string which is the html source. Parse out the string that has a number preceding "vid" with regex.
Logic works with both test cases.

Haskell 161 bytes
import Network.Curl.Download
import qualified Data.ByteString.Char8 as B
z=do u<-getLine;(Right b)<-openURI u;putStrLn$show$length$B.findSubstrings(B.pack"<tr")b