How to recover from DDOS'ed internet The internet has failed.  DDoS attacks are now rampant and widespread.  It is up to you to take control and repair the internet.
Each bot will control 20 nodes in this network.  Every node is either active or safe, has an owner, and has a strength, which starts at 2. Every active node is connected to all other active nodes.
Each turn, you will receive a list of all active nodes with their strength.  For each of the active nodes that you own, you either:

Designate an active node you want to transfer your entire strength to, or
Save and increase its strength

Then the following happens in order:

A Node choosing to save its strength will increase its strength by 1.
All nodes choosing to transfer their strength will simultaneously transfer their entire strength to the new node.
If a node was transferred strength from an enemy node, an attack will ensue.  If an enemy owner collectively transfers more strength than the original owner (and all other attackers), then that enemy becomes the new owner.  The strength of that node then becomes the strength of the attacker.  If there is a tie for strength, then the owner will be chosen randomly.
All nodes left without any strength will be considered safe, and gives 1 point to the owner.

After 100 games of 100 turns, the owner with the most safe nodes across all games wins. EDIT: I changed it from 2000 to 100 turns, as it ended up that the last 1900 turns were useless
IO
You will be passed the list of active nodes (via command line args) like the following:
F20 F4 E7 E2 E20 F2

F designates that the node is a friendly node, and E designates that the node is an enemy.
For each of your friendly nodes, you should return an action (via STDOUT) like the following:
0,0 1,3 5,0

The above would mean that you want to increase your strength of the first node, use your second node to attack the fourth node, and your last node will transfer its strength the first node (and if nobody attacks it, it will become a safe node).
After returning, your program should quit.
Scoreboard

accumulator got 3240 points
classy got 2370 points
dumbot got 2262 points
random_bot got 1603 points
smarter_random_bot got 1319 points
steady_bot got 1097 points

The controller can be found here: https://github.com/nathanmerrill/NetAttack
Accumulator, Python

Let's get this party started! My submission should work both on Python 2 and Python 3.

import sys

inputs = [(i, x[0], int(x[1:])) for (i, x) in enumerate(sys.argv[1].split())]

own_nodes = sorted([(s,i) for (i,o,s) in inputs if o == 'F'])
targets = sorted([(s,i) for (i,o,s) in inputs if o == 'E'])

if targets:
    t_copy = targets[:]
    out = ""
    total_str = 0
    attackers = []
    for (s,i) in own_nodes:
        attackers += [i]
        if t_copy:
            total_str += s
            if t_copy[0][0] &lt; total_str - 1:
                j = max([j for j in range(len(t_copy)) if t_copy[j][0] &lt; total_str - 1])
                out += " ".join([str(k) + "," + str(t_copy[j][1]) for k in attackers]) + " "
                attackers = []
                total_str = 0
                t_copy = t_copy[:j] + t_copy[j+1:]
    if attackers:
        if t_copy:
            out += " ".join([str(k) + "," + str(t_copy[0][1]) for k in attackers])
        else:
            out += " ".join([str(k) + "," + str(attackers[0]) for k in attackers])
else:
    out = " ".join([str(i) + "," + str(own_nodes[0][1]) for (s,i) in own_nodes])

print(out.rstrip())
sys.stdout.flush()


The idea is really simple.
I start enumerating my nodes in ascending order of strength, keeping a running sum of the strengths.
When the sum exceeds the strength of the weakest enemy node (+1 for a possible increase), I attack that node and remove it from the pool, reset the sum, and continue.
At the end, if the strongest nodes can't find anyone to attack, they'll collect more strength.

EDIT: Accumulator is now a bit smarter.
Instead of always attacking the weakest enemy node, it accumulates the strength until it could do so, and then attacks the strongest free node it can with that strength.
Also, if there are still enemies left at the end, any unassigned nodes will attack the weakest remaining enemy, just in case it decides to transfer its strength away.