text:
KOTH: TNT Run Challenge
This was inspired by a Minecraft mini-game. The rules are pretty simple: you run and jump around, and every block you step on disappears once you've stepped on it. The goal is to be the last one left.
Your bot should be a complete program. It should accept input as a command line argument. The input will be a map of the "world"; here is an example:
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxx xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxx xxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxx x xxxxxxxxxxxxx@xxxxxxxxxxx
xxxxxx1xxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxx           xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx
xxxxxxxxxxxxxxxxx x x xxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxx xxx xx3xxxxxxxxxx
xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxx  x
xxxxxxxxxxxxxxxxxxxxxxxxxxx   xx
xxxxxxxxxxxxxxxxxxxxxxxxx      2
xxxxxxxxxxxxxxxxxxxxxxx

The legend is as follows:
x: solid block
 : empty air
@: your bot
1,2,3,4,5,6,7,8,9,0: other bots
Your bot should output your move as a pair of integers. Example: -1, 2 will move 1 block to the left and 2 blocks down (coordinates origin is in the top left corner).
You may move up to four blocks, manhattan distance, from your current location. If you try to move further than that, the move is invalid. Any move that would move you past the edge will put you on the edge instead. Invalid moves will be ignored.
Once you land on a block it is removed; if you remain on the same block next turn you will fall. Two bots may land on the same block on the same turn and both survive; if this happens, both bots will only see themselves and not the other bot.
If you need to store files for persistence, please do so in a folder with the name of your bot. You may not read other bots' persistent data if any exists.
The match controller is available at https://paste.ee/p/Xf65d.
Please use languages that can be run on a standard Linux or OSX install.
Current results (100 rounds):
JumpBot                   31
LookBot                   27
ShyBot                    26
Slow Bot                  15
KnightBot                 2
Moat Builder              0
UpBot                     0
Random Bot                0

Similar, although a key difference here is that you can "jump" several blocks - thus you can't simply block someone in if they see what you're doing.

you can't close as a dupe in the sandbox and I don't think it is quite one

Are the moves simultaneous or sequential? Is the input really a newline-containing string as a command line argument?

I would suggest calling the bot once without a world for initialization (you don't know if your state saved as file is from last round or from this round)

@feersum moves are simultaneous; the input is indeed a newline-containing command line argument. If you need it as stdin instead, let me know and I could probably modify the contoller to allow for either.

"The goal is to be the last one left." How do any of the bots disappear?

@flawr if a bot lands on an empty space (or sits on a space for more than one turn) it is removed from the game.

@bauen1 I check whether there are any spaces on the field yet, because there won't be any on the first round.

@Skyler could you update the controller? (to include all bots and that i can get the same results as you)

@bauen1 updated!

Are additional entries still permitted?

@RohanJhunjhunwala Yes, I will re-run the tournament with any new entries

Slow Bot (Python)
He moves in a line pattern and checks his moves before making them (also suicides when he's the last one alive to prevent long runtimes)
He won 195/200 Battels in my test tournament.
import sys
import re

class vec2(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __add__(self, other):
        return vec2(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return vec2(self.x - other.x, self.y - other.y)

    def __iadd__(self, other):
        return self + other

    def __isub__(self, other):
        return self - other

    def __neg__(self):
        return vec2(-self.x, -self.y)

def xy_to_i(vec=vec2(0, 0)):
    vec -= vec2(1, 1)
    vec.y += (vec.x - vec.x % 32) / 32
    return vec.x + vec.y * 33

def i_to_xy(i=0):
    vec = vec2(0, 0)
    vec.x = i % 33
    vec.y = (i - vec.x) / 32 + 1
    vec.x += 1
    return vec

class World(object):
    def __init__(self, map=''):
        self.map = map

    def getPlayerPosition(self):
        return i_to_xy(re.search('@', self.map).start())

    def getNumOtherBots(self):
        return len(re.findall('([0123456789])', ' ' + self.map + ' '))

    def get_tile(self, vec=vec2(0, 0)):
        i = xy_to_i(vec)
        return self.map[i:i + 1]

world = World(sys.argv[1])
pos = world.getPlayerPosition()

def check_moveV(vecd=vec2(0, 0)):
    try:
        vecn = pos + vecd

        if vecn.x > 32 or vecn.x < 1 or vecn.y > 32 or vecn.y < 1 \
            or abs(vecd.x) + abs(vecd.y) > 4:
            return False

        # Note: this will also avoid positions other bots are on (will disappear in the next step).

        return world.get_tile(vecn) == 'x'
    except:
        raise
        return False

def check_move(x=0, y=0):
    return check_moveV(vec2(x, y))

def run():
    if world.getNumOtherBots() == 0:
        return '0 0'  # Suicide if we are the only one left.

    # this creates the "line" pattern

    if check_move(0, -1):
        return '0 -1'

    if check_move(0, 1):
        return '0 1'

    if check_move(1, 0):
        return '1 0'

    if check_move(1, -1):
        return '1 -1'

    # If we get here, we are desperate and need to find a safe place to jump.

    for dx in range(-2, 2):
        for dy in range(-2, 2):
            if check_move(dx, dy):
                return '%i %i' % (dx, dy)

    # If we can't find a place to jump in close range, try long range.

    for dx in range(-4, 4):
        for dy in range(-4, 4):
            if check_move(dx, dy):
                return '%i %i' % (dx, dy)

    # If we get here, we are dead no matter what; accept our fate.

    return '0 0'

print(run())

I'm not an expert in python and there are probably 100 ways of doing it shorter/better

Just one thing, if you are on the same space with another bot and you are the last two, yours will think it is last and suicide.

when i implement persistency, he will wait 5 rounds until suicide

Great, that's what I was going to suggest. Excellent answer, by the way.

JumpBot (C)
Try to jump to field with most possible moves in next round.
#include <stdio.h>
#include <stdlib.h>

typedef struct map {
     char *raw_map;
     int size;
     int lines;
     char *pos;
} *MAP;

typedef struct cdata {
     int result;
     MAP m;
     int x;
     int y;
} *CDATA;

typedef struct mdata {
     int x;
     int y;
     int moves;
     int bx;
     int by;
     MAP m;
} *MDATA;

int numberOfMoves(MAP, int, int);
char getAt(MAP, int, int);

int abs(int x)
{
    return x < 0 ? x*-1 : x;
}

void count(void *data, int x, int y)
{
    CDATA d = (CDATA)data;
    char c = getAt(d->m, d->x + x, d->y + y);
    if(c != 'x') return;
    d->result++;
}

void choose(void *data, int x, int y)
{
    MDATA m = (MDATA)data;
    char c = getAt(m->m, m->x + x, m->y + y);
    if(c != 'x') return;
    int moves = numberOfMoves(m->m, m->x+x, m->y+y);
    if(moves > m->moves || (!m->bx && !m->by)) {
        m->moves = moves;
        m->bx = x;
        m->by = y;
    }
}

MAP parse_input(char *input)
{
    MAP m = malloc(sizeof *m);
    if(!m) {
        fprintf(stderr, "failed to alloc map\n");
        return NULL;
    }

    m->size=0;
    m->lines=1;
    m->pos=0;

    char *temp;
    for(temp = input;*temp;temp++) {
        switch(*temp) {
            case '\n': m->lines++; break;
            default: break;
        }
    }
    m->size = (temp + 1) - (input + m->lines);
    m->raw_map = malloc(m->size);
    if(!m->raw_map) {
        fprintf(stderr, "failed to alloc raw_map\n");
        return NULL;
    }

    int index = 0;
    for(temp = input; *temp; temp++) {
        if(*temp == '@') m->pos = m->raw_map + index;
        if(*temp != '\n') m->raw_map[index++] = *temp;
    }

    return m;
}

char getAt(MAP m, int x, int y)
{
    return m->raw_map[x + y*(m->size / m->lines)];
}

void posToXY(MAP m, int *x, int *y)
{
    int index = m->pos - m->raw_map;
    int length = m->size / m->lines;
    *x = index % length;
    *y = index / length;
}

typedef void (*DOFUNC)(void *, int, int);
void processMoves(MAP m, int x, int y, DOFUNC proc, void *data)
{
    int length = m->size / m->lines;
    int left = x>=4 ? 4 : x;
    int right = x + 4 <= length ? 4 : length - (x + 1);
    int up = y >= 4 ? 4 : y;
    int down = y + 4 <= m->lines ? 4 : m->lines - (y + 1);

    for(int i=-left; i<=right; i++) {
        for(int j=-up; j<=down; j++) {
            if((abs(i) + abs(j) <= 4) && (i || j)) (*proc)(data, i, j);
        }
    }
}

int numberOfMoves(MAP m, int x, int y)
{
    struct cdata d;
    d.result = 0;
    d.x = x;
    d.y = y;
    d.m = m;
    processMoves(m, x, y, &count, &d);
    return d.result;
}

void getMove(MAP m, int *x, int *y)
{
    struct mdata d;
    posToXY(m, &d.x, &d.y);
    d.moves = 0;
    d.bx = 0;
    d.by = 0;
    d.m = m;
    processMoves(m, d.x, d.y, &choose, &d);
    *x = d.bx;
    *y = d.by;
}

int main(int argc, char *argv[])
{
    if(argc != 2) {
        fprintf(stderr, "bad number of arguments %d\n", argc);
        return -1;
    }

    MAP m = parse_input(argv[1]);
    int x=0, y=0;
    getMove(m, &x, &y);
    printf("%d %d\n", x, y);
    return 0;
}

LookBot (C)
Simple bot that is similar in performance to Slow Bot, except that this one makes random possible moves. Plan to improve this to PredictBot.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
#include <sys/time.h>

#define WORLDSZ (32)
#define WORLDSZ_2 (WORLDSZ*WORLDSZ)

int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}

struct Position{
    int x,y;
};
typedef struct Position Position;

struct World{
    Position me;
    double enemymap[WORLDSZ][WORLDSZ]; //chance of enemy present
    bool open[WORLDSZ][WORLDSZ];
};
typedef struct World World;

void world_read(World *world,const char *arg){
    int x,y,i=0;
    for(y=0;y<WORLDSZ;y++,i++){
        for(x=0;x<WORLDSZ;x++,i++){
            if(arg[i]=='@'){world->me.x=x; world->me.y=y;}
            world->enemymap[y][x]=arg[i]>='0'&&arg[i]<='9';
            world->open[y][x]=arg[i]=='x';
        }
    }
}

//returns relative position
Position world_calcmove(World *world){
    const int mex=world->me.x,mey=world->me.y;
    int dx,dy;
    Position poss[40];
    int nposs=0;
    for(dy=max(-mey,-4);dy<=min(WORLDSZ-1-mey,4);dy++){
        const int absdy=abs(dy);
        for(dx=max(-mex,absdy-4);dx<=min(WORLDSZ-1-mex,4-absdy);dx++){
            if(!world->open[mey+dy][mex+dx])continue;
            poss[nposs].x=dx;
            poss[nposs++].y=dy;
        }
    }
    if(nposs==0){
        poss[0].x=poss[0].y=0;
        return poss[0];
    }
    return poss[rand()%nposs];
}

int main(int argc,char **argv){
    if(argc!=2){
        fprintf(stderr,"Call with world!\n");
        return 1;
    }
    struct timeval tv;
    gettimeofday(&tv,NULL);
    srand(tv.tv_sec*1000000ULL+tv.tv_usec);

    World world;
    world_read(&world,argv[1]);
    Position move=world_calcmove(&world);
    printf("%d %d\n",move.x,move.y);
}

Moat Builder (Python)
If I dig a moat around myself, nobody outside it can screw me over.
...also known as "Paint yourself into a corner simulator 2016".
import numpy
import sys
import math
import os

if not os.path.exists('./moatbuilder'):
    os.mkdir('./moatbuilder')

raw_field = sys.argv[1]
field = numpy.array([numpy.array(list(i)) for i in raw_field.splitlines()])
field_size = len(field)
x, y = raw_field.replace('\n','').index('@')%field_size, int(raw_field.replace('\n','').index('@')/field_size)
# If there are no holes, it's the first round - reset persistence
if raw_field.count(' ')==0:
    open('./moatbuilder/persistent','w').write('')

def bigmove(target):
    if x < target[0]:
        return min(4, target[0] - x), 0
    elif x > target[0]:
        return max(-4, target[0] - x), 0
    elif y < target[1]:
        return 0, min(4, target[1] - y)
    else:
        return 0, max(-4, target[1] - y)

def smallmove(target):
        if x < target[0]:
        try:
            return min(max(1, list(field[y][x:x+4]).index('x')), target[0] - x), 0
        except:
            return 0, 0
        elif x > target[0]:
        try:
            return max(min(-1, 0-list(reversed(field[y][x-4:x])).index('x')), target[0] - x), 0
        except:
            return 0, 0
        elif y < target[1]:
        try:
                    return 0, min(max(1, list(field[:,x][y:y+4]).index('x')), target[1] - y)
        except:
            return 0, 0
        else:
        try:
            return 0, max(min(-1, 0-list(reversed(field[:,x][y-4:y])).index('x')), target[1] - y)
        except:
            return 0, 0

try:
    mode = int(open('./moatbuilder/persistent').read())
except:
    mode = 1

# Modes:
# 1 - go to the center
# 2 - go to an outside edge
# 3 - dig moat
if mode==1:
    dx, dy = bigmove((int(field_size/2), int(field_size/2)))
    if dx==0 and dy==0:
        open('./moatbuilder/persistent', 'w').write('2')
        mode = 2
if mode==2:
    dx, dy = bigmove((int(field_size-1), int(field_size/2)))
    if dx==0 and dy==0:
        dy = 1
        open('./moatbuilder/persistent', 'w').write('3')
        mode = 3
elif mode==3:
    direction = max(field_size-x, field_size-y)%2
    if direction == 1:
        if x > y:
            dx, dy = smallmove((y, y))
        else:
            dx, dy = smallmove((x, field_size - 1))
        if dx==0 and dy==0:
            dx = 1
    else:
        if y > x:
            dx, dy = smallmove((x, x))
        else:
            dx, dy = smallmove((field_size - 1, y))
        if dx==0 and dy==0:
            dy = 1

print "%i %i" % (dx, dy)

This actually works out quite nicely, but it will lose against bot that live for a long time (thats why i choose a line pattern btw)

You might want to fix your indentation in smallmove()... My python doesn't eat this :)

Monte (Python)
Sorry, that pun just had to be made.
Anyway, this bot works by doing a Monte Carlo Tree Search on all of the possible move sets. Think of JumpBot, only more in-depth.
To run, it needs an extra command line argument (can be specified in the controller). It controls how much time the bot should search for (in ms); I used 750-1500 in testing.
Code:
import sys
import math
import copy
#from profilestats import profile
pmap = sys.argv[2].split("\n")
pmap = [list(r) for r in pmap]

#find a player
#@profile
def find(tmap,bot):
   r,c=-1,-1
   for row in range(len(tmap)):
      for col in range(len(tmap[row])):
         if tmap[row][col]==bot:
            r,c=row,col
   return r,c

mer,mec=find(pmap,'@')
bots=[(mer,mec)]

#find all the other players
for b in range(10):
   r,c=find(pmap,str(b))
   if r != -1:
      bots.append((r,c))

#getter function, treats oob as spaces
def get(tmap,r,c):
   if r<0 or r>=len(tmap) or c<0 or c>=len(tmap[r]):
      return ' '
   return tmap[r][c]

#returns manhattan distance between 2 positions
def dist(r1,c1,r2,c2):
   return abs(r1-r2)+abs(c1-c2)

#gets all possible moves from a map
#@profile
def moves(tmap,ther=-1,thec=-1):
   if ther==-1: ther,thec = find(tmap,'@')
   pos=[]
   for r in range(-4,5):
      for c in range(-4,5):
         if abs(r)+abs(c)<=4 and get(tmap,ther+r,thec+c)=='x':
            pos.append((r,c))
   return pos

ttlmoves = 40
#monte-carlo tree node
class MCNode:
   def __init__(self):
      self.wins=0
      self.simu=0
      self.chld=[]
      self.cmap=[[]]
      self.prnt=None
      self.r=-1
      self.c=-1
   def add(self, cnode):
      self.chld.append(cnode)
      cnode.prnt = self
   #used to balance exploitation and exploration
   #@profile
   def param(self,cin):
      return self.chld[cin].wins/self.chld[cin].simu\
             + 1.414 * math.sqrt( math.log(self.simu) / \
             self.chld[cin].simu )
   #finds the child with the highest param
   #@profile
   def best(self):
      vals = [self.param(x) for x in range(len(self.chld))]
      binx = 0
      bval = vals[0]
      for x in range(len(vals)):
         if vals[x]>bval:
            binx=x
            bval=vals[x]
      return self.chld[binx]

#update all the parents
#@profile
def backprog(leaf):
   par = leaf.prnt
   if not (par is None):
      par.wins+=leaf.wins
      par.simu+=leaf.simu
      backprog(par)

#expand all the moves from a position
#@profile
def expand(rootn):
   ther,thec = rootn.r,rootn.c
   for r,c in moves(rootn.cmap,rootn.r,rootn.c):
      nmap = copy.deepcopy(rootn.cmap)
      nmap[ther+r][thec+c] = '@'
      nmap[ther][thec]=' '
      nnode = MCNode()
      nm = moves(nmap,ther+r,ther+c)
      nnode.wins = len(nm)
      nnode.simu = ttlmoves
      nnode.r=ther+r
      nnode.c=thec+c
      nnode.cmap = nmap
      rootn.add(nnode)
      backprog(nnode)

root = MCNode()
m = moves(pmap,mer,mec)
root.wins = len(m)
root.simu = ttlmoves
root.cmap=copy.deepcopy(pmap)
root.r=mer
root.c=mec
expand(root)

#simulate a bunch of outcomes
import time
curt  = lambda: int(round(time.time() * 1000))
strt = curt()
ttme = int(sys.argv[1])
while curt()-strt < ttme:
   tnode=root
   while tnode.chld:
      tnode=tnode.best()
   expand(tnode)

#choose the most explored one
bnode = max(root.chld,key=lambda n:n.simu)

#output
print("{} {}".format((bnode.c-mec),(bnode.r-mer)))

Trials
25 rounds:
MonteBot            14
JumpBot             6
ShyBot              5
LookBot             1
KnightBot           0
SlowBot             0

100 rounds:
JumpBot             38
MonteBot            36
ShyBot              15
LookBot             14
SlowBot             2
KnightBot           0

200 rounds:
MonteBot            87
JumpBot             64
LookBot             33
ShyBot              21
SlowBot             5
KnightBot           0

All of the simulations above used search time 750. This bot would probably be even better with a longer search time (I don't know what the max allowed is).
Improvements
This bot still needs improvements in:

Performance: it needs the entire time to search.
Prediction: it won't account for other bot's moves.
Balance: I'm not sure if the UCT formula I am using to calculate which node I should explore is optimal.

ShyBot (Python)
This bot really doesn't like other bots and will try to keep itself away if possible. ShyBot is also really careful about where it steps; it won't even step on other bots. However, ShyBot still looses often which makes insecure.
import sys
map = sys.argv[1]
map = map.split("\n")
map = [list(r) for r in map]

def find(map,bot):
   r,c=-1,-1
   for row in range(len(map)):
      for col in range(len(map[row])):
         if map[row][col]==bot:
            r,c=row,col
   return r,c

mer,mec=find(map,'@')
bots=[(mer,mec)]

for b in range(10):
   r,c=find(map,str(b))
   if r != -1:
      bots.append((r,c))

avg=[0,0]

for b in bots:
   avg[0]+=b[0]
   avg[1]+=b[1]

avg[0] = avg[0]/len(bots)
avg[1] = avg[1]/len(bots)

def get(map,r,c):
   if r<0 or r>=len(map) or c<0 or c>=len(map[r]):
      return ' '
   return map[r][c]

def dist(r1,c1,r2,c2):
   return abs(r1-r2)+abs(c1-c2)

pos=[]
for r in range(-4,5):
   for c in range(-4,5):
      if abs(r)+abs(c)<=4 and get(map,mer+r,mec+c)=='x':
         pos.append((r,c))

if len(pos)==0:
   bestr,bestc=0,0
else:
   bestr,bestc=pos[0]

for r,c in pos:
   if dist(mer+r,mec+c,avg[0],avg[1])>dist(mer+bestr,mec+bestc,avg[0],avg[1]):
      bestr,bestc=r,c

print(str(bestc)+" "+str(bestr))

KnightBot (Java)
It's works like chess, and is named like Twitch...
...
.........
............................sorry...
public class KnightBot{
   private static String[] map;
   private static int myx;
   private static int myy;
   public static void main(String[] args){
      map=args[0].split("\n");
      for(int y=0;y<map.length;y++){
         if(map[y].indexOf("@")!=-1){
            myy = y;
            myx = map[y].indexOf("@");
            break;
         }
      }
      System.out.println(move((int)(Math.random()*4),4));
   }
   public static String move(int dir,int tries){
      if(tries==0)return "0 0";
      int x=dir<2?1:-1;
      int y=dir%2==0?2:-2;
      if((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x'){
         x=dir<2?2:-2;
         y=dir%2==0?1:-1;
      }
      if((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x')
         return move(++dir>3?0:dir,tries-1);
      return x+" "+y;
   }
}

SwirlyBot (Java)
These are clearly not the optimal solutions, but I hope will be useful for midlevel testing.
public class SwirlyBot{
   private static String[] map;
   private static int myx;
   private static int myy;
   public static void main(String[] args){
      map=args[0].split("\n");
      for(int y=0;y<map.length;y++){
         if(map[y].indexOf("@")!=-1){
            myy = y;
            myx = map[y].indexOf("@");
            break;
         }
      }
      System.out.println(move(0));
   }
   public static String move(int dir){
      switch(dir){
         case 0:
            if(!safe(0,1)){
               if(safe(1,1)){
                  return "1 1";//Down-Right
               }else{
                  if(safe(1,0)){
                     return "1 0";//Right
                  }
               }
            }
            break;
         case 1:
            if(!safe(1,0)){
               if(safe(1,-1)){
                  return "1 -1";//Up-Right
               }else{
                  if(safe(0,-1)){
                     return "0 -1";//Up
                  }
               }
            }
            break;
         case 2:
            if(!safe(0,-1)){
               if(safe(-1,-1)){
                  return "-1 -1";//Up-Left
               }else{
                  if(safe(-1,0)){
                     return "-1 0";//Left
                  }
               }
            }
            break;
         case 3:
            if(!safe(-1,0)){
               if(safe(-1,1)){
                  return "-1 1";//Down-Left
               }else{
                  if(safe(0,1)){
                     return "0 1";//Down
                  }
               }
            }
            break;
         case 4:
            if(safe(0,-1))return "0 -1";
            break;
         case 5:
            if(!safe(0,2)){
               if(safe(1,2)){
                  return "1 2";//Down-Right
               }else{
                  if(safe(2,2)){
                     return "2 2";
                  }else{
                     if(safe(2,1)){
                        return "2 1";
                     }else{
                        if(safe(2,0)){
                           return "2 0";//Right
                        }
                     }
                  }
               }
            }
            break;
         case 6:
            if(!safe(2,0)){
               if(safe(2,-1)){
                  return "2 -1";//Up-Right
               }else{
                  if(safe(2,-2)){
                     return "2 -2";
                  }else{
                     if(safe(1,-2)){
                        return "1 -2";
                     }else{
                        if(safe(0,-2)){
                           return "0 -2";//Up
                        }
                     }
                  }
               }
            }
            break;
         case 7:
            if(!safe(0,-2)){
               if(safe(-1,-2)){
                  return "-1 -2";//Up-Left
               }else{
                  if(safe(-2,-2)){
                     return "-2 -2";
                  }else{
                     if(safe(-2,-1)){
                        return "-2 -1";
                     }else{
                        if(safe(-2,0)){
                           return "-2 0";//Left
                        }
                     }
                  }
               }
            }
            break;
         case 8:
            if(!safe(-2,0)){
               if(safe(-2,1)){
                  return "-2 1";//Down-Left
               }else{
                  if(safe(-2,2)){
                     return "-2 2";
                  }else{
                     if(safe(-1,2)){
                        return "-1 2";
                     }else{
                        if(safe(0,2)){
                           return "0 2";//Down
                        }
                     }
                  }
               }
            }
            break;
      }
      if(dir<8)return move(dir+1);
      return "0 -1";
   }
   public static boolean safe(int x, int y){
      return !((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x');
   }
}

Hello, and welcome to PPCG! Great answer!

Random Bot, UpBot
Two starting bots to compete against:
Random Bot: An example bot that moves randomly.
import random

x = random.randint(-4, 4)
y = random.randint(max(-4, -4 + abs(x)), min(4, 4 - abs(x)))
print x, y

UpBot: An example bot that moves up.
print '0 -1'

I ran 10 test rounds for my (now deleted) Random Walker answer, and hilariously, UpBot is doing very well. He got 7 out of 10 rounds.

Here are the test results and test script I used (and hacked).

Here are the full test results, provided as a zip file.

UpBot does well because he only moves one block at a time, so it usually takes him longer to run into a wall than it does Random Bot to walk into a hole.

@zyabin101: you know, you can just run it, hit 'y' for playing a full tournament, and enter 10 for the rounds.

@Skyler presumably he qanted competition logs as well

StalkerBot (Python)
Will get as close as possible to the closest bot it sees. Targets Slow Bot's (pointless) automatic suicide. (If I'm on the same square as it and there are no other players, it won't see me and will suicide.)
#!/usr/bin/python3
from math import inf
from sys import argv

class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __neg__(self):
        return Vector(-self.x, -self.y)

    def __abs__(self):
        return self.x ** 2 + self.y ** 2  # Technically the square of the magnitude, but we only need it for comparison.

    def __iter__(self):
        yield self.x
        yield self.y

def get_location(grid, target='@'):
    for i, line in enumerate(grid):
        for j, char in enumerate(line):
            if char == target:
                return Vector(i, j)

def main(grid):
    my_location = get_location()

    min_distance = inf
    min_distance_direction = None

    for i in range(10):
        enemy_location = get_location(str(i))

        if enemy_location is not None:
            direction = enemy_location - my_location
            distance = abs(direction)

            if distance < current_min:
                min_distance = distance
                min_distance_direction = direction

            if distance == 1:
                break

    if min_distance_direction is not None:
        return min_distance_direction

    for d in range(1, 5):
        for x in range(-d, d):
            for y in (d - abs(x), abs(x) - d):
                if grid[x][y] == ' ':
                    return x, y

    return 0, 0

if __name__ == '__main__':
    print(*main(argv[1].splitlines()))

Just FYI, in general we don't approve edits that alter code (like the one you did on another answer to this question). I approved that one since it seemed like it didn't touch the logic or anything but just cleaned it up, but that's not gonna fly on most answers. That one could definitely use it though.

@Riker Understood. It makes sense not to change the logic, but I was having trouble reading that code, so I decided to clean up the formatting.

No problem, but keep in mind that golfing edits and similar are likely to be rejected on other questions going forward. I agree that the code you did edit was kinda wonky though.

@Riker Basically, don't make any edits that could affect the score.


text:
Between the Lines

While doodling around on square-ruled paper the other day, I came up with the above negative-space font for digits. In case you haven't spotted it yet, the spaces between the above shapes yield the golden ratio 1.618033988749. In this challenge, your task is to take a number as input and render it exactly as the example above shows.
Here is how these are created: all lines will be on a regular grid, so that the individual digits are made up of a small number of grid cells. Here are the shapes of the 10 digits (we'll ignore the decimal point for this challenge):

Yes, the 7 differs from the golden ratio example at the top. I kinda messed that up. We'll be going with this one.
Notice that each digit is five cells tall, and three cells wide. To render a number, you can imagine placing all its digits next to each other, such that there is exactly one empty column between each pair of digits. For example, taking 319 as input, we'd write:

Notice that we add one leading and trailing empty column. Now we invert the cells:

The output should then be the boundaries of the resulting polygons:

Of course you may generate the result in any other way, as long as the rendered output looks the same.
Input

You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument, as a string, or list of digits. (You can't take a number as that wouldn't allow you to support leading zeros.)
You may assume that there will be no more than 16 digits in the input.

Output

Output may either be displayed on screen or written to a file in a common image format.
You may use both raster and vector graphics.
In either case, the aspect ratio of the cells of the underlying grid needs to be 1 (that is, the cells should be squares).
In the case of raster graphics, each cell should cover at least 20 by 20 pixels.
The lines must be no wider than 10% of the cell size. I'm willing to give one or two pixels leeway due to aliasing here.
Lines and background can be any two clearly distinguishable colours, but the shapes created by the lines must not be filled (that is the insides should be the background colour as well).
There must be no gaps within each closed loop.
Of course, the entire result must be visible.

Test Cases
Here are 10 inputs, which together cover all possible pairs of adjacent digits, as well as every possible leading and trailing digit:
07299361548
19887620534
21456837709
39284106657
49085527316
59178604432
69471338025
79581224630
89674235011
97518264003

And here are the expected results for those:

Make sure that your code also works when given a single digit (I don't want to include the expected results here, because they should be obvious, and the test case section is bloated enough as it is).

Would ASCII art be accepted?

@Blue I think that would make for a very different task, and answers would be hardly comparable, so no, sorry. I'm generally not a fan of mixing graphical output and ASCII art in a single challenge.

alright, thanks for the quick reply

Is it allowed to import fonts?

@Marv hm, interesting question. I'd say you should count the size of the font file in that case.

@MartinBüttner fair enough. Probably not worth it then!

BBC BASIC, 182 ASCII characters (tokenised filesize 175 bytes)
Download interpreter at http://www.bbcbasic.co.uk/bbcwin/bbcwin.html
I.n$
F.j=0TOLENn$*4p=ASCM."?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@",VALM.n$,j/4+1,1)*4+1+j MOD4)F.k=0TO4p*=2q=64A.p
V.537;q;0;2585;0;q;537;-q;0;2585;0;-q;25;0;64;
N.MOVEBY 64,-320N.

Scoring: When the above program is pasted into the editor and run, the editor will expand the abbreviated keywords into full keywords onscreen, though they are actually only 1 byte after tokenisation. (Example I.=INPUT storage space 1 byte.)
Explanation
I will just explain what the VDU line does: it draws a box by  bit-flipping the current pixel colour on the screen. This means that (with a bit of care with the corners) it is possible simply to draw one cell next to each other, and the intervening edge will cancel out and disappear due to double drawing.
Close examination will reveal that the top right and bottom left corners of a cell are drawn but the top left and bottom right are missing ("rounded") in order to make this work.
After the cell is drawn, the graphics cursor is moved up 32 pixels ready for the next cell to be drawn.
The rest of the program is a fairly straightforward ASCII bitmap decompression. The dimensions of the cell are 64x64 units for golfing/compatability with the way the bitmap is decompressed. q controls the size of the cell that is plotted: 64x64 units for a cell that is present, 0x0 for a cell that is absent.
Ungolfed code
  m$="?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@" :REM bitmap for digits, including column of filled cells at left. BBC strings are 1-indexed
  INPUTn$                                       :REM user input
  FORj=0 TO LENn$*4                             :REM iterate 4 times per input digit, plus once more (plot column 0 of imaginary digit to finish)
    d=VAL MID$(n$,j/4+1,1)                      :REM extract digit from n$ (1-character string). VAL of empty string = 0, so 123->1,1,1,1,2,2,2,2,3,3,3,3,0
    p=ASC MID$(m$,d*4+1+j MOD4)                 :REM get column bitmap from m$ d*4 selects digit, j MOD4 selects correct column of digit, add 1 to convert to 1-index
    FORk=0TO4                                   :REM for each cell in the column
      p*=2                                      :REM bitshift p
      q=64ANDp                                  :REM find size of cell to draw. 64 for a filled cell, 0 for an absent cell.
      VDU537;q;0;                               :REM line q units right, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;q;                              :REM line q units up, inverting existing screen colour. Dont draw last pixel (will be filled in next line)
      VDU537;-q;0;                              :REM line q units left, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;-q;                             :REM line q units down, inverting existing screen colour. Dont draw last pixel (avoid inverting 1st pixel of 1st line)
      VDU25;0;64;                               :REM move up 64 units for cell above
    NEXT
    MOVEBY 64,-320                              :REM move right and down for next column.
  NEXT

Output
The MOVEs are just get the output to appropriate heights on the screen. BBC basic uses 2 units = 1 pixel in this mode, so the cells are actually 32x32 pixels.

Octave, 233 225 216 213 bytes
o=@ones;l=z=o(5,1);for k=input('')-47;l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];end;L=~o(size(l)+2);L(2:6,2:end-1)=l;O=o(3);O(5)=-8;M=~conv2(kron(L,o(25)),O);imshow(M)

Here the first test case (from a resized screen capture, s.t. it fits my monitor=):

o=@ones;
l=z=o(5,1);                   %spacer matrices
for k=input('')-47;           %go throu all input digis
                              %decode the matrices for each digit from decimal
l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];
end
L=~o(size(l)+2);           %pad the image
L(2:6,2:end-1)=l;
O=o(3);O(5)=-8;               %create edge detection filter
imshow(~conv2(kron(L,o(25)),O)) %image resizing /edge detection (change 25 to any cell size you like)

The input can be arbitrary length, like e.g. '07299361548'

Convolution is the key to success.

Thanks @LuisMendo for improving the score by a bunch of bytes=)

I couldn't agree more with Convolution is the key to success :-)

Somehow this is always the motto for my successfull matlab/octave answers :D

Html+JavaScript ES6, 352
Test running the snippet below

<canvas id=C></canvas><script>s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),[...s].map(d=>[30,d*=3,++d,++d].map(w=a=>{for(a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[a],36)*2+1,p=1,y=100,i=64;i>>=1;p=b,y-=20)c.moveTo(x+20,y),b=a&i?1:0,c[b-p?'lineTo':'moveTo'](x,y),(a^q)&i&&c.lineTo(x,y-20);q=a,x+=20}),q=63,x=0),w(30),w(0),c.stroke()</script>

Less golfed
s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),
w=a=>{
  a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[i],36)*2+1
  for(p=1,y=100,i=32;i;p=b,y-=20,i>>=1)
    c.moveTo(x+20,y),
    b=a&i?1:0,
    c[b-p?'lineTo':'moveTo'](x,y),
    (a^q)&i&&c.lineTo(x,y-20)
  q=a
  x+=20
},
[...s].map(d=>[30,d*=3,++d,++d].map(w),q=63,x=0),
w(30),w(0)
c.stroke()

I don't think you need the closing script tag...

Javascript ES6, 506 bytes
a=>{with(document)with(body.appendChild(createElement`canvas`))with(getContext`2d`){width=height=(a.length+2)*80;scale(20,20);translate(1,1);lineWidth=0.1;beginPath();["oint",...a.map(i=>"05|7agd7|oint 067128a45|oicgmnt 01de25|oil9amnt 01de23fg45|oint 03fh5|68ec6|oint 03fg45|oij78knt 05|9agf9|oij78knt 01dh5|oint 05|78ed7|9agf9|oint 03fg45|78ed7|oint".split` `[i]),"05"].map(i=>{i.split`|`.map(i=>[...i].map((e,i,_,p=parseInt(e,36),l=~~(p/6),r=p%6)=>i?lineTo(l,r):moveTo(l,r)));translate(4,0)});stroke()}}

Ungolfed:
a=>{                                            // anonymous function declaration, accepts array of numbers
  with(document)                                // bring document into scope
  with(body.appendChild(createElement`canvas`)) // create canvas, drop into html body, bring into scope
  with(getContext`2d`){                         // bring graphics context into scope
    width=height=(a.length+2)*80;               // set width and height
    scale(20,20);                               // scale everything to 20x
    translate(1,1);                             // add padding so outline doesn't touch edge of canvas
    lineWidth=0.1;                              // have to scale line width since we scaled 20x
    beginPath();                                // start drawing lines
    ["oint",                                    // beginning "glyph", draws left end of negative space, see below
     ...a.map(i=>`05|7agd7|oint                 // glyphs 0-9 encoded as vertices
                  067128a45|oicgmnt             //   glyphs seperated by " "
                  01de25|oil9amnt               //   lines within each glyph seperated by "|"
                  01de23fg45|oint               //   a single vertex is stored as a base36 char
                  03fh5|68ec6|oint              //     where a number corresponds to one of the verts shown below:
                  03fg45|oij78knt               //        0  6 12 18 24
                  05|9agf9|oij78knt             //        1  7 13 19 25
                  01dh5|oint                    //        2  8 14 20 26
                  05|78ed7|9agf9|oint           //        3  9 15 21 27
                  03fg45|78ed7|oint`            //        4 10 16 22 28
       .split` `[i]),                           //        5 11 17 23 29
     "05"]                                      // end "glyph", draws right end of negative space, see above
      .map(i=>{                                 // for each glyph string
        i.split`|`                              // seperate into list of line strings
          .map(i=>[...i]                        // convert each line string into list of chars
            .map((e,i,_,p=parseInt(e,36),       // convert base36 char to number
                  l=~~(p/6),r=p%6)=>            // compute x y coords of vertex
              i?lineTo(l,r):moveTo(l,r)));      // draw segment
        translate(4,0)});                       // translate origin 4 units to right
    stroke()}}                                  // draw all lines to canvas

Assumes there's a <body> to append the canvas to, tested in Firefox 46.
Example run (assigning anonymous function to f):
f([1,0,3])

yields:

Java, 768 bytes
import java.awt.*;import java.awt.image.*;class G{public static void main(String[]v)throws Exception{int s=20,n=v[0].length(),i=0,j,w=(n*3+n+1)*s,h=5*s,a[][]={{6,7,8},{0,2,3,10,11,12,13},{1,6,8,13},{1,3,6,8},{3,4,5,6,8,9},{3,6,8,11},{6,8,11},{1,2,3,4,6,7,8,9},{6,8},{3,6,8}};BufferedImage o,b=new BufferedImage(w,h,1);Graphics g=b.getGraphics();g.setColor(Color.WHITE);for(;i<n;i++)for(j=0;j<15;j++){int c=j;if(java.util.Arrays.stream(a[v[0].charAt(i)-48]).noneMatch(e->e==c))g.fillRect((1+i*4+j/5)*s,j%5*s,s,s);}o=new BufferedImage(b.getColorModel(),b.copyData(null),0>1,null);for(i=1;i<h-1;i++)for(j=1;j<w-1;j++)if((b.getRGB(j+1,i)|b.getRGB(j-1,i)|b.getRGB(j,i+1)|b.getRGB(j,i-1))<-1)o.setRGB(j,i,-1);javax.imageio.ImageIO.write(o,"png",new java.io.File("a.png"));}}

Ungolfed
import java.awt.*;
        import java.awt.image.BufferedImage;

class Q79261 {
    public static void main(String[] v) throws Exception {
        int scale = 20, n = v[0].length(), i = 0, j, width = (n * 3 + n + 1) * scale, height = 5 * scale, values[][] = {{6, 7, 8}, {0, 2, 3, 10, 11, 12, 13}, {1, 6, 8, 13}, {1, 3, 6, 8}, {3, 4, 5, 6, 8, 9}, {3, 6, 8, 11}, {6, 8, 11}, {1, 2, 3, 4, 6, 7, 8, 9}, {6, 8}, {3, 6, 8}};
        BufferedImage output, temp = new BufferedImage(width, height, 1);
        Graphics g = temp.getGraphics();
        g.setColor(Color.WHITE);
        for (; i < n; i++)
            for (j = 0; j < 15; j++) {
                int finalJ = j;
                if (java.util.Arrays.stream(values[v[0].charAt(i) - 48]).noneMatch(e -> e == finalJ))
                    g.fillRect((1 + i * 4 + j / 5) * scale, j % 5 * scale, scale, scale);
            }
        output = new BufferedImage(temp.getColorModel(), temp.copyData(null), 0 > 1, null);
        for (i = 1; i < height - 1; i++)
            for (j = 1; j < width - 1; j++)
                if ((temp.getRGB(j + 1, i) | temp.getRGB(j - 1, i) | temp.getRGB(j, i + 1) | temp.getRGB(j, i - 1)) < -1)
                    output.setRGB(j, i, -1);
        javax.imageio.ImageIO.write(output, "png", new java.io.File("a.png"));
    }
}

Notes

Input is a single string as argument. How to use: javac G.java, java G 80085
I'm starting with a black canvas, then I'm adding the numbers as white positives. I create a copy of the image and then flip every black pixel that has 4 black neighbours on the original image.

Outputs

Some single digits:

java.awt.* does not contain java.awt.image.BufferedImage?

@Element118 it does not.

Python 3, 326 325 bytes
import numpy
from skimage import io,transform as t,filters as f
r=[[1]*5,[0]*5]
for c in map(int,input()):r+=[map(float,bin(0x3f1fa7e1bd7b5aff84ff6b7fd6f087ff5ff6bf)[2:][15*c+5*i:15*c+5*-~i])for i in[0,1,2]]+[[0]*5]
r+=[[1]*5]
p=[[1]*len(r)]
r=p+list(zip(*r))+p
io.imsave("o.png",1-f.sobel((t.rescale(numpy.array(r),16,0))))

I was going to comment this on one of your other answers the other day, but range(3) is never worth it.

R, too many bytes to golf (1530+ 1115)
library(reshape2);library(ggplot2);library(png)
M=matrix(1,5,3)
M=lapply(list(c(7:9),c(1,3,4,11:14),c(2,7,9,14),c(2,4,7,9),c(4:7,9,10),c(4,7,9,12),c(7,9,12),c(2:5,7:10),c(7,9),c(4,7,9)),function(x){M[x]=0;M})
g=function(P){
S=matrix(0,5,1)
R=NULL
for(N in P){R=Reduce(cbind2,list(R,S,M[[N+1]]))}
cbind(R,S)}
p=function(P){
o=t(apply(g(P),1,rev))
ggplot(melt(o),aes(x=Var1,y=Var2))+geom_raster(aes(fill=value))+coord_flip()+scale_fill_continuous(guide=FALSE,high="#FFFFFF",low="#000000")+scale_y_reverse()+scale_x_reverse()+theme_bw()+theme(panel.grid=element_blank(),panel.border=element_blank(),panel.background=element_blank(),axis.title=element_blank(),axis.text=element_blank(),axis.ticks=element_blank(),plot.margin=unit(c(0,0,0,0),"mm"))+ggsave("t.png",width=dim(o)[2]/2.5,height=2,units="in",dpi=99)
q=readPNG("t.png")
k=q[,,1]
b=replace(k,k==1,0)
for(i in 1:nrow(k)){
for(j in 1:ncol(k)){
u=(i==nrow(k))
v=(j==ncol(k))
if(u&v){b[i,j]=1;break}
if((i==1)|u|(j==1)|v){b[i,j]=1;next}else{if(all(k[c((i-1):(i+1)),c((j-1):(j+1))])){b[i,j]=1}else{b[i,j]=0}}}}
q[,,1:3]=abs(replace(k,b==1,0)-1)
writePNG(q,"t.png")}

# run p(c(0,1,2,3,4,5))

lol at writing to disk, then reading from disk edit away the black fill.

C#, 768 773 776 bytes
namespace System.Drawing{class P{static void Main(string[]a){uint[]l={0xEBFBFFFC,0xB89B21B4,0xABFFF9FC,0xAA1269A4,0xFFF3F9FC};var w=a[0].Length*80+20;var b=new Bitmap(w,100);var g=Graphics.FromImage(b);g.FillRectangle(Brushes.Black,0,0,w,100);for(int i=0;i<a[0].Length;i++)for(int r=0;r<5;r++)for(int c=0;c<3;c++)if((l[r]&((uint)1<<(175-a[0][i]*3-c)))>0)g.FillRectangle(Brushes.White,20*(1+i*4+c),20*r,20,20);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).B+b.GetPixel(x+1,y).B+b.GetPixel(x,y+1).B+b.GetPixel(x,y-1).B+b.GetPixel(x+1,y-1).B+b.GetPixel(x+1,y+1).B+b.GetPixel(x-1,y+1).B+b.GetPixel(x-1,y-1).B==0)b.SetPixel(x,y,Color.Red);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).R>0)b.SetPixel(x,y,Color.White);b.Save(a[0]+".bmp");}}}

Takes the number as command line argument. Outputs a nice, clean, non-aliased BMP image with the number as the name.
Original before golfing:
namespace System.Drawing
{
    class P
    {
        static void Main(string[] args)
        {
            var numbers = args[0];
            uint[] lines = {
                0xEBFBFFFC, // 111 010 111 111 101 111 111 111 111 111 00
                0xB89B21B4, // 101 110 001 001 101 100 100 001 101 101 00
                0xABFFF9FC, // 101 010 111 111 111 111 111 001 111 111 00
                0xAA1269A4, // 101 010 100 001 001 001 101 001 101 001 00
                0xFFF3F9FC  // 111 111 111 111 001 111 111 001 111 111 00
            };
            var width = numbers.Length*4 + 1;
            var bmp = new Bitmap(width*20, 5*20);
            using (var gfx = Graphics.FromImage(bmp))
            {
                gfx.FillRectangle(Brushes.Black, 0, 0, width*20+2, 5*20+2);
                // Process all numbers
                for (int i = 0; i < numbers.Length; i++)
                {
                    var number = numbers[i]-'0';
                    for (int line = 0; line < 5; line++)
                    {
                        for (int col = 0; col < 3; col++)
                        {
                            if ((lines[line] & ((uint)1<<(31-number*3-col))) >0)
                                gfx.FillRectangle(Brushes.White, 20*(1 + i * 4 + col), 20*line, 20 , 20 );
                        }
                    }
                }
                // Edge detection
                for (int x = 1; x < width*20-1; x++)
                {
                    for (int y = 1; y < 5*20-1 ; y++)
                    {
                        if (bmp.GetPixel(x,y).B +
                            bmp.GetPixel(x + 1, y).B +
                                bmp.GetPixel(x, y + 1).B +
                                bmp.GetPixel(x, y - 1).B +
                                bmp.GetPixel(x + 1, y - 1).B +
                                bmp.GetPixel(x + 1, y + 1).B +
                                bmp.GetPixel(x - 1, y + 1).B +
                                bmp.GetPixel(x - 1, y - 1).B == 0)
                                bmp.SetPixel(x, y, Color.Red);
                    }
                }
                // Convert red to white
                for (int x = 1; x < width * 20 - 1; x++)
                {
                    for (int y = 1; y < 5 * 20 - 1; y++)
                    {
                        if (bmp.GetPixel(x, y).R>0)
                            bmp.SetPixel(x, y, Color.White);
                    }
                }
            }
            bmp.Save(@"c:\tmp\test.bmp");
        }
    }
}

Mathematica 328 bytes
j@d_:=Partition[IntegerDigits[FromDigits[d/.Thread[ToString/@Range[0,9]->StringPartition["75557262277174771717557117471774757711117575775717",5]],16],2, 20]/.{0->1,1->0},4];j@"*"=Array[{1}&,5];
w@s_:=  ColorNegate@EdgeDetect@Rasterize@ArrayPlot[Thread[Join@@Transpose/@j/@Characters@(s<>"*")],Frame->False,ImageSize->Large]

w["07299361548"]
w["19887620534"]

Explanation
Four bits will be used in each of 5 lines of cells for each input digit.
"75557262277174771717557117471774757711117575775717"represents 0 to 9 as bitmaps.
The first 5 digits in the large integer above, namely 75557 indicate how each array row for zero should be displayed.  7 will represent {0,1,1,1}, that is, a white cell, followed, on its right, by 3 black cells; the leading 0 is a blank space to separate displayed digits.  5 corresponds to {0,1,0,1}, that is  white, black, white, black cells.
The following produces a list of replacement rules:
Thread[ToString /@ Range[0, 9] -> StringPartition["75557262277174771717557117471774757711117575775717", 5]]

{"0" -> "75557", "1" -> "26227", "2" -> "71747", "3" -> "71717",
   "4" -> "55711", "5" -> "74717", "6" -> "74757", "7" -> "71111",
   "8" -> "75757", "9" -> "75717"}

Note that when 3 is input, it will be replaced by 71717
This representation is expressed in binary:
p = Partition[IntegerDigits[FromDigits["3" /. {"3" -> "71717"}, 16], 2, 20], 4]

{{0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 1, 1}}

Its black-white inverse is found by simply exchanging the 1s and 0s.
q = p /. {0 -> 1, 1 -> 0}

{{1, 0, 0, 0}, {1, 1, 1, 0}, {1, 0, 0, 0}, {1, 1, 1, 0}, {1, 0, 0, 0}}

Let's see what p and q look like when displayed by ArrayPlot:
ArrayPlot[#, Mesh -> True, ImageSize -> Small, PlotLegends -> Automatic] & /@ {p, q}

This simply joins the arrays of zeros and ones for each digit before rendering the big array via ArrayPlot.  * is defined in j as the final vertical space after the last digit.
Thread[Join @@ Transpose /@ j /@ Characters@(s <> "*")]

source: Stack Exchange

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

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

sort: votes


text:
Briefest code to find vowels and print consonants
Challenge: Read a string from user, print number of each vowel, then place all remaining chars in a line. Shortest answer wins!
Output must look like this:

Enter String: Input
Vowel Count: a: #, e: #, i: #, o: #, u: #
Remaining characters: Vowel-less Input

For example:
Enter String: LoremIpsumDolorSitAmetConsecuteurAdipscingElit!
Vowel Count: a: 0, e: 4, i: 4, o: 4, u: 3
Remaining characters: LrmIpsmDlrStAmtCnsctrAdpscngElt!

Edited to better suit the site. Yeah... Just browsing other questions and even taking the tour isn't much help. Gotta be a better way.

Yeah, that is something that I have been complaining about recently. Your edit makes the post a lot better. The only other thought I have would be to add some test input and output like you had in the first revision. Maybe even some additional test cases.

Okay. I can certainly do that. And thank you, wonderful community, for being more forgiving than Stack Overflow to noobs.

Is the output format flexible? For example, can the output contain only the numbers (without the vowel names) and then the consonants in a different line?

No not flexible, this interface specifically.

Also, is the input format flexible? Rather than prompting the user, could I take the string as a function argument? (This is generally the default. You can override the default, but it's not recommended.)

No. It must be an input in this case, I agree, this is a little against the norm :)

Unfortunately I think this question will boil down to which language has the shortest compression of strings

You're treating lowercase a different than capital A?

Also, for future challenges, I heartily recommend using the Sandbox, so you can elicit feedback before posting to the main page, and thus make your challenge even better. Welcome to PPCG!

This is missing a blurb about what characters will be in the input. Will the input include newlines, unicode, etc? From your example it seems like you might not want spaces.

The fun fact is that we are trying to be nice

@CalebWoodman I don't think it has anything to do with being a noob or not -- rather, restrictive input/output requirements on non-Kolmogorov challenges shift the focus of the challenge, so that instead of actually doing work on the interesting part, people instead need to account for the I/O requirements, which instead feels like drudgery. Please don't take the downvotes personally (see the PostScript to Peter's answer)!

Welcome to Programming Puzzles and Code Golf. This might be worth reading. The main problem here is the cumbersome output format, which isn't actually the interesting part of this challenge. Since no one actually gave a solution on how this can be fixed, here's my suggestion. Instead of the long output format, try to change the output format to something like [1, 2, 0, 3, 4] \n LrmIpsmDlrStAmtCnsctrAdpscngElt. Or something else involving just an array and a string :p.

Do capital vowels not count as vowels (i.e. are not counted and removed)?

You're clearly missing a vowel.. (y). You English people and their lack of 'y' as vowels.. shakes head in disappointment

For these purposes, no 'y', but yes, I believe in its vowelitude.

@KevinCruijssen. And w. Tsk. All the Welsh people must be feeling left out.

Um, crafting my solution-- vowel majuscules seem to be ignored. Is that correct? Otherwise the vowels should be a: 2 e: 5 i: 5 o: 4 and u:3.

05AB1E, 62 bytes
Code:
”‡Á•Ë: ÿ”,”Vowelš‹: ”?"aeiou"©vy": "¹y¢««}", "ý,“«¶šÞ: “ª¹®-J,

Explanation:
There is a lot of string compression going on here. Here is a list of all strings that are compressed:

”‡Á•Ë” is equivalent to Enter String.
”Vowelš‹” is equivalent to Vowel Count.
“«¶šÞ“ª is equivalent to Remaining characters.

To see how the actual string compression works, see the Hello, World! answer, or an even more elaborate explanation at the bottom of the Code Review question. Without the string compression, the code looks like this:
"Enter String: ÿ","Vowel Count: "?"aeiou"©vy": "¹y¢««}", "ý,"Remaining characters: "¹®-J,

Or a more readable 3-part version:
"Enter String: ÿ",
"Vowel Count: "?"aeiou"©vy": "¹y¢««}", "ý,
"Remaining characters: "¹®-J,

Part 1:
We first push the string "Enter String: ÿ". The ÿ here is used for string interpolation. But since the stack is empty, implicit input is requested. The ÿ will be substituted with the user input. We print this with a newline using ,.
Part 2:
We first print the "Vowel Count: " string without a newline using ?. After that, we push the aeiou string, ©opy that to the register and map over the string using v and do the following:
vy": "¹y¢««}    # Mapping loop

v          }    # The loop itself
 y              # Push the current letter (which is a, e, i, o or u)
  ": "          # Push this string
      ¹         # Push the first input again
       y        # Push the letter again
        ¢       # Count the number of occurences of that letter in the input
         ««     # Concatenate to one single string, (e.g. "a: 4")

This leaves 5 different string onto the stack, the stack looks like this now:
stack: ['a: 0', 'e: 1', 'i: 0', 'o: 2', 'u: 0']

We join each element in the stack with ", " using ý. After this, we print it with a newline using ,.
Part 3:
We first push the string "Remaining characters: ". We push the first input again using ¹. We then push "aeiou" which we retrieve from the register using ®. After this, we remove all letters in aeiou using - and Join this with the Remaining characters-string. Finally, we output this with a newline using ,.
Uses CP-1252 encoding. Try it online!.

I've seen answers with 05AB1E a couple of times now, but like most languages on this stackexchange I don't understand a lot of it.. Which of the characters in your code-snippet are used for the words "Enter", "String", "Count", "Remaining", and "Characters"? I can clearly see the "Vowelš" in the code (with an š instead of an s..), but I'm clueless about the others. (If possible I'd love a complete description of the entire code-snippet.)

@KevinCruijssen I have added an explanation. If you have any other questions, feel free to ask them :).

Wow, thanks for the clear and extended explanation. I know it's not just for me but also in general to others, but I really appreciate the afford explaining it in such a clear way. :)

This is every sort of amazing!

JavaScript (ES6), 165
Fixed error in output, thx @Neil
3 bytes saved thx @Dom Hastings

a=prompt`Enter String:`.replace(/[aeiou]/g,v=>(V[v]=-~V[v],''),V=[]);alert("Vowel Count: "+[...'aeiou'].map(v=>v+': '+(V[v]|0)).join`, `+`
Remaining characters: `+a)

Needs a space after the comma, but I'm surprised you didn't use a template string with a literal newline character.

@Neil I was careless, with so many unnecessary characters in the output, what's one more...

A couple more bytes you can save, using a template string for the argument to prompt(...) and using |0 instead of ||0.

@DomHastings right, thanks

You need a space after the colon in Enter String:

@ericw31415 I don't think so. prompt add a newline anyway

Why do you use prompt instead of a lambda function?

@Bálint Challenge: Read a string from user, ... the spec for input / output are strange enough, I take them literally

Python, 168 bytes
s=input('Enter String:')
v='aeiou'
print('Vowel Count: '+', '.join([a+':'+str(s.count(a)) for a in v])+'\nRemaining characters: '+''.join([a for a in s if a not in v]))

https://repl.it/CMzO/1

Welcome to PPCG! Nice first post.

Perl 5, 127 bytes
$_=<>;print"Enter String: ${_}Vowel Count:";for$s(a,e,i,o,u){print" $s: ".~~s/$s//g,$s!~u&&","}print"
Remaining characters: $_"

Many thanks to Dom Hastings (in a comment hereon) for 14 bytes.

I had a slightly different approach using a loop, can you use the same mechanism to save bytes? sub p{print@_}p"Enter String: ";$_=<>;p"Vowel Count:";for$s(a,e,i,o,u){p" $s: ".~~s/$s//g,$s!~/u/&&","}p"\nRemaining characters: $_" (note: \n is a literal newline!)

@DomHastings, many thanks, that saves a bunch.

PostgreSQL, 295, 263 bytes
SELECT v "Enter string:", string_agg(r,', 'ORDER BY n) "Vowel Count:",TRANSLATE(v,'aeyiou','') "Remaining characters:"
FROM (SELECT 'LoremIpsumDolorSitAmetConsecuteurAdipscingElit!'::text v)s
,LATERAL(SELECT LENGTH(v)l)a
,LATERAL(SELECT c||': '||l-LENGTH(REPLACE(v,c,''))r,n FROM (VALUES('a',1),('e',2),('i',3),('o',4),('u',5))t(c,n))b
GROUP BY v

SqlFiddleDemo
Output:
╔══════════════════════════════════════════════════╦═══════════════════════════════╦══════════════════════════════════╗
║                  Enter string:                   ║         Vowel Count:          ║      Remaining characters:       ║
╠══════════════════════════════════════════════════╬═══════════════════════════════╬══════════════════════════════════╣
║ LoremIpsumDolorSitAmetConsecuteurAdipscingElit!  ║ a: 0, e: 4, i: 4, o: 4, u: 3  ║ LrmIpsmDlrStAmtCnsctrAdpscngElt! ║
╚══════════════════════════════════════════════════╩═══════════════════════════════╩══════════════════════════════════╝

Input: (SELECT '...'::text v)s
How it works:

(SELECT 'LoremIpsumDolorSitAmetConsecuteurAdipscingElit!'::text v)s input
,LATERAL(SELECT LENGTH(v)l)a - length of input
(VALUES('a',1),('e',2),('i',3),('o',4),('u',5)) - vowels with oridinal
SELECT c||': '||l-LENGTH(REPLACE(v,c,''))r,n - calculate number of occurences
string_agg(r,', 'ORDER BY n) ... GROUP BY v combine result
TRANSLATE(v,'aeyiou','') string without vowels

EDIT 3:
Removed additional LATERAL, input moved to table.
SELECT v"Enter string:",string_agg(r,', 'ORDER BY n)"Vowel Count:",TRANSLATE(v,'aeyiou','')"Remaining characters:"
FROM s,LATERAL(SELECT c||': '||LENGTH(v)-LENGTH(REPLACE(v,c,''))r,n FROM(VALUES('a',1),('e',2),('i',3),('o',4),('u',5))t(c,n))b
GROUP BY v

SqlFiddleDemo

I'm still amazed how people use SQL for anything other than databases

@Bálint In all my answers I use SQL . In production I would not use this kind of code but as puzzle why not.

This would appear to hardcode the input and does not show the prompt required in the question.

Output must look like this

@cat Added version with table. Output must look like this with SQL (declarative statement) you cannot get interactive prompt.

Lua, 242 Bytes
For a moment, I thought that it will be longer than SQL... still a monster for such a simple task.
t={}x="aeiou"i=io.write
x:gsub(".",function(c)t[c]=0 end)i("Enter string: ")z=io.read()s="Remaining characters: "..z:gsub(".",function(c)if x:find(c)then
t[c]=t[c]+1return""end end)i("Vowel Count: ")x:gsub(".",function(c)i(c..": "..t[c]..(c=="u"and"\n"or", "))end)i(s)

The job is done by the part
z:gsub(".",function(c)if x:find(c)then t[c]=t[c]+1return""end end)

Everything else is mainly for the purpose of outputing in the right format.
Ungolfed
t={}                             -- create an empty array
x="aeiou"                        -- list of vowels
i=io.write                       -- shorthand for outputing
x:gsub(".",function(c)t[c]=0 end)-- create a celle at 0 for each vowel
i("Enter string: ")              -- output some boilerplate
z=io.read()                      -- take the input
s="Remaining characters: "..     -- save in s the concatenation of this string
  z:gsub(".",function(c)         -- and the result of gsubing on each character of the input
  if x:find(c)                   -- if the current char is a vowel
  then
    t[c]=t[c]+1                  -- increment its counter
    return""                     -- suppress it from the input
  end
end)

i("Vowel Count: ")               -- output some more boilerplate
x:gsub(".",function(c)           -- iterate over the vowels
  i(c..": "..t[c]..              -- output "l: #" appended with
    (c=="u"
        and"\n"                  -- "\n" if the current char is "u"
      or", "))                   -- ", " otherwise
end)
i(s)                             -- output the content of s

Python, 220 201 bytes
This is my first submission on codegolf so go easy. :P
def f(y):
  global x;c=x.count(y);x=x.replace(y,'');return c;
x=input('Enter string: ');print('Vowel Count: a: {}, e: {}, i: {}, o: {}, u: {}'.format(*map(f,"aeiou")));print('Remaining characters: '+x)

Ungolfed:
def f(y):
  global x
  c=x.count(y)
  x=x.replace(y,'')
  return c;
x=input('Enter string: ')
print('Vowel Count: a: {}, e: {}, i: {}, o: {}, u: {}'.format(*map(f,"aeiou")))
print('Remaining characters: '+x)

Output:
Enter string: LoremIpsumDolorSitAmetConsecuteurAdipscingElit!
Vowel Count: a: 0, e: 4, i: 4, o: 4, u: 3
Remaining characters: LrmIpsmDlrStAmtCnsctrAdpscngElt!

Welcome to Code Golf! You might be able to save some bytes by using Python's list comprehensions and unpacking them into the format function instead of calling each function individually: ...u: {}'.format(*[f(c)for c in 'aeiou']). Also, I think you can put the commands from a function on the same line right after the colon and it should work, saving some bytes.

@KevinLau-notKenny It might be shorter to do .format(*map(f,"aeiou"))

JavaScript, 190 186 bytes
(s,a=[..."aeiou"].map(v=>(s.match(v,"g")||[]).length))=>`Enter String: ${s}
Vowel Count: ${[..."aeiou"].map((v,i)=>v+": "+a[i]).join`, `}
Remaining characters: `+s.replace(/[aeiou]/g,"")

I just remembered that literal newlines are only 1 byte! Also remembered to golf something I missed before.

Why do you use RegExp(expression, modifier) instead of /expression/modifier?

I need to plug in the v into the RegExp. If I used /v/g, the v would be a literal string instead of the value of the variable.

Java, 272 bytes
class L{public static void main(String[]v){String p=v[0],o="Enter String: "+p+"\nVowel Count:",d=" ",e="aeiou";for(char c:e.toCharArray()){o+=d+c+": "+p.replaceAll("[^"+c+"]","").length();d=", ";}System.out.println("\nRemaining characters: "+p.replaceAll("["+e+"]",""));}}

Ungolfed
class L {
    public static void main(String[] v) {
        String input = v[0], result = "Enter String: " + input + "\nVowel Count:", delimiter = " ", vowels = "aeiou";
        for (char c : vowels.toCharArray()) {
            result += delimiter + c + ": " + input.replaceAll("[^" + c + "]", "").length();
            delimiter = ", ";
        }
        System.out.println("\nRemaining characters: " + input.replaceAll("[" + vowels + "]", ""));
    }
}

Notes

Input via program arguments: Save as L.java, compile with javac L.java, run with java L LoremIpsumDolorSitAmetConsecuteurAdipscingElit!

Output
Enter String: LoremIpsumDolorSitAmetConsecuteurAdipscingElit!
Vowel Count: a: 0, e: 4, i: 4, o: 4, u: 3
Remaining characters: LrmIpsmDlrStAmtCnsctrAdpscngElt!

I know it's a while, but you can golf it to 246 bytes like this: interface M{static void main(String[]v){String p=v[0],o="Enter String: "+p+"\nVowel Count:",d=" ",e="aeiou";for(String c:e.split("")){o+=d+c+": "+~-p.split(c,-1).length;d=", ";p=p.replace(c,"");}System.out.print(o+"\nRemaining characters: "+p);}} Try it here.

PowerShell v2+, 196 149 bytes
$z=read-host "Enter string"
"Vowel Count: "+(([char[]]"aeiou"|%{$_+": "+($z.length-($z=$z-creplace$_).length)})-join', ')
"Remaining characters: "+$z

Takes input via read-host with a prompt, save into $z.
We then output a string literal "Vowel Count: " concatenated with the result of a loop/join through the vowels to construct the a: #, e: #,... string. This is done by taking the current string's .length minus the new string's .length after we perform a case-sensitive replacement with -creplace (i.e., how many did we remove). In addition, we re-save the result of the replace back into $z for the next loop.
We then also output the second string literal concatenated with whatever is still left in $z.
This keeps the current specification intact, in that capital vowels are distinguished from lowercase vowels, since -creplace is explicitly case sensitive.
Examples
PS C:\Tools\Scripts\golfing> .\briefest-code-find-vowels.ps1
Enter string: LoremIpsumDolorSitAmetConsecuteurAdipscingElit!
Vowel Count: a: 0, e: 4, i: 4, o: 4, u: 3
Remaining characters: LrmIpsmDlrStAmtCnsctrAdpscngElt!

PS C:\Tools\Scripts\golfing> .\briefest-code-find-vowels.ps1
Enter string: ProgrammingPuzzlesAndCodeGolf
Vowel Count: a: 1, e: 2, i: 1, o: 3, u: 1
Remaining characters: PrgrmmngPzzlsAndCdGlf

Retina, 133 bytes
(a()|e()|i()|o()|u()|.)+
Enter string: $&¶Vowel count: a: $#2, e: $#3, i:$#4, o:$#5, u:$#6¶Remaining characters: $&
(?<=s:.+)[aeiou]
<empty-line>

Try it online!
Who is more fit for this challenge than Retina?

Groovy, 181 177 bytes
online
{i->r=[:].withDefault{0};o=i.toLowerCase().replaceAll(/[aeiou]/,{r[it]++;''})
"Enter String: $i\nVowel Count: ${r.collect{k,v->"$k: $v"}.join(' ')}\nRemaining characters: $o"}

Tcl, 184 (counting majuscule vowels) / 180 (ignoring them)
puts -nonewline {Enter String: }
flush stdout
gets stdin s
set c {Vowel Count:}
foreach v {a e i o u} {append c " $v: [regsub -all (?i)$v $s {} s]"}
puts "$c\nRemaining Characters: $s"

Explanation
Most of the code is actually dealing with the strict I/O requirements. The remainder works by doing a regular expression substitution (deletion) on the input string $s for every vowel and appending the vowel $v and associated number of substitutions to the output string $c.
The above code works for mixed-case vowels. Remove the (?i) option from the regular expression on the penultimate line for strictly minuscule vowels.

C# 317 bytes
string t=Console.ReadLine();Dictionary v = new Dictionary<char,int>{{'a',0},{'e',0},{'i',0},{'o',0},{'u',0}};string o="";foreach(char c in t){if(v.Keys.Contains(c)){v[c]++;}else{o+=c;}}Console.WriteLine("a: "+v['a']+", e: "+v['e']+", i: "+v['i']+", o: "+v['o']+", u: "+v['u']);Console.WriteLine("Remaining Characters: "+o);

Any suggestions, trying to learn to golf with C#. 1KB is obviously way bigger than the other answers though.
Ungolfed:
string t=Console.ReadLine();
Dictionary v = new Dictionary<char,int>
{
    {'a',0},
    {'e',0},
    {'i',0},
    {'o',0},
    {'u',0}
};
string o="";
foreach(char c in t)
{
    if(v.Keys.Contains(c))
    {
        v[c]++;
    }
    else
    {
        o+=c;
    }
}
Console.WriteLine("a: "+v['a']+", e: "+v['e']+", i: "+v['i']+", o: "+v['o']+", u: "+v['u']);
Console.WriteLine("Remaining Characters: "+o);

Please specifiy an exact byte count in the future, 1 KB is way off from 317 bytes, wich isn't that bad.

@Bálint Using school computer, it's cryptic getting to the properties of a file for some reason.

I'd suggest using a regex ( /[aeiou]/ instead of a dictionary, an use that to match strings

Just use an online byte counter.

like http://mothereff.in/byte-counter

Python 162 Bytes
v,s="aeiou",input()
print "String:"+s+"\n"+"Vowel Count"+" ".join([c+":"+str(s.count(c)) for c in v])+"\n"+"Remaining Characters:"+filter(lambda x:v.count(x)<1,s)

Ruby, 202 bytes
print"Enter String: ";t=gets;c=->(x){t.chars.count(x)};a="aeiou".chars
s=a.zip(a.map(&c)).map{|e|"#{e[0]}: #{e[1]}"}.join(", ");r=t.gsub(/[aeiou]/,"")
puts"Vowel Count: #{s}\nRemaining characters: #{r}"

Use $><< instead of print. Do s="aeiou".chars.map{|e|"#{e}: #{t.count e}"}*", " to save a ton of bytes over setting up lambdas and zipping things together. Use t.tr('aeiou','') instead of gsub to replace, and maybe put it directly into where you have #{r} instead of assigning it.

C++, 449 bytes

Golfed:
#include <iostream>
#include <string>
int main(){std::string x;std::cout<<"Enter String: ",std::cin>>x;int a=0,e=0,i=0,o=0,u=0;for(int c=0;c<x.length();c++){switch(x[c]){case 'a':a++;x.erase(c,1);break;case 'e':e++;x.erase(c,1);break;case 'i':i++;x.erase(c,1);break;case 'o':o++;x.erase(c,1);break;case 'u':u++;x.erase(c,1);break;}}std::cout<<"\n Vowel Count: a: "<<a<<", e: "<<e<<", i: "<<i<<", o: "<<o<<", u: "<<u<<"\n Remaining characters: "<<x;}

Ungolfed:
#include <iostream>
#include <string>

int main(){
    std::string x;
    std::cout<<"Enter String: ", std::cin>>x;
    int a=0,e=0,i=0,o=0,u=0;
    for(int c = 0; c < x.length(); c++){
        switch(x[c]){
            case 'a':
                a++;
                x.erase(c,1);
                break;
            case 'e':
                e++;
                x.erase(c,1);
                break;
            case 'i':
                i++;
                x.erase(c,1);
                break;
            case 'o':
                o++;
                x.erase(c,1);
                break;
            case 'u':
                u++;
                x.erase(c,1);
                break;
        }
    }
    std::cout<<"\n Vowel Count: a: "<<a<<", e: "<<e<<", i: "<<i<<", o: "<<o<<", u: "<<u<<"\n Remaining characters: "<<x;
}

does case 'u', et al really need a space? I don't have a C compiler in front of me right now but I don't think it does.

C++17, 313 bytes
#include <cctype>
#include <iostream>
#include <string>
using namespace std;int main(){int n,h[6]={0};string s,v="aeiou",r;cout<<"Enter String: ";getline(cin,s);for(c:s){h[n=v.find(tolower(c))+1]++;if(!n)r+=c;}cout<<"Vowel Count:";n=1;for(c:v)cout<<" "<<c<<": "<<h[n++];cout<<"\nRemaining Characters: "<<r<<"\n";}

I suppose I could make this just a function to eliminate standard boilerplate from the byte count.
Ungolfed
#include <cctype>
#include <iostream>
#include <string>
using namespace std;

int main()
{
  int n;
  int histogram[6] = {0};   // { (consonants), A, E, I, O, U }
  string source;
  string vowels = "aeiou";  // vowel order matches the histogram
  string consonants;

  cout << "Enter String: ";
  getline( cin, source );

  for (c : source)
  {
    // n ← consonants=0, A=1, E=2, ...
    n = vowels.find( tolower(c) ) + 1;
    histogram[n]++;
    if (!n)
      consonants += c;
  }

  cout<<"Vowel Count:";
  n = 1;
  for (vowel : vowels)
    cout << " " << vowel << ": " << histogram[n++];

  cout << "\nRemaining Characters: " << consonants << "\n";
}

Explanation
Computes a histogram using the std::string lookup functions.
Again, you can eliminate 27 bytes from the count if only minuscule vowels matter. (Remove the first #include and the call to tolower().)

275 bytes

Ruby, 134 133 131 bytes
Because the other Ruby answer didn't respond to my suggestions, I golfed it down further myself.
-2 bytes from @manatwork
$><<"Enter String: "
r=gets.tr v='aeiou',''
puts"Vowel Count: #{v.chars.map{|e|e+": #{$_.count e}"}*', '}
Remaining characters: "+r

r=gets.tr v='aeiou',''

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


text:
Determine If a Challenge is Worth Answering
I am a very casual code golfer, and don't often see posts until they show up in the "Hot Network Questions" sidebar over on StackOverflow.  Usually, I'm late to the game, and since the only language I know is Python, there is little point in me answering as there are already several Python answers.  Your challenge is to figure out if a question is worth me answering.
Input:

Your code (function or program) will take one input parameter i

Output:

Truthy or Falsey value for question id i.  Output Truthy if question has more than 5 answers, greater than 3 question score, and one or less answer in Python (no distinction between version).

Rules/Clarifications:

Input format can be anything reasonable (stdin, file, command line), but should be specified in your answer.  Data types and leading/trailing whitespace doesn't matter.
Assume question id is valid for codegolf.stackexchange.com.
Ignore language specific question requirements.  (i.e. if a question meets votes and answers, and has no Python answers because it is Java only, it still results in Truthy).
An answer qualifies as a Python answer if "python" (case insenstive) occurs anywhere before the first newline of the post.
This is code golf, so shortest code in bytes wins.

Sample Cases*
id = 79082 => True
id = 78591 => False (less than 5 answers, also hella hard)
id = 78410 => True
id = 76428 => False (greater than 1 Python answer)
id = 78298 => False (not high enough question score)

*Verified at time of posting, may have changed

I also only know Python...

I also know Python, mainly.

I've got to start learning some other languages.

@R.Kap, this challenge would be a great time to start!

This challenge is worth answering apparently.

05AB1E, 167 160 159 158 156 154 143 bytes
Damn, almost as long as a normal language...
Crap... longer currently beating the the Ruby answer by 1 byte.
Now longer than the Ruby answer, argh!.
I probably should go to bed right now.
Thanks to @wnnmaw for saving 1 byte and thanks to @R. Kap for saving another 2 bytes!
Code:
’£Ø ˆå§¾.‡¢ as g;#.¾¿„–(g.ˆåƒÛ('·Ç://ÐÏg.´¢/q/'+•œ_#()).‚Ø())’.e©’„à="Ž»"’DU¢®…îŒ€ƒŠ‡¡`99£þs\®X¡¦vy’„à="‚¬-„¹"’¡¦'>¡¦¦¬l’±¸’¢s\}rUV)O2‹X5›Y3›)P

Or with more readability:
’£Ø ˆå§¾.‡¢ as g;#.¾¿„–(g.ˆåƒÛ('·Ç://ÐÏg.´¢/q/'+•œ_#()).‚Ø())’
 .e©
’„à="Ž»"’
 DU¢®
“îŒ€ƒŠ‡“
 ¡`99£þs\®X¡¦
v
 y’„à="‚¬-„¹"’¡¦'>¡¦¦¬l’±¸’¢s\}rUV)O2‹X5›Y3›)P

Explanation:
First of all, a lot of text is being compressed here, which translates to good old Python. The uncompressed version is:
"import urllib.request as g
 f=g.urlopen('http://ppcg.lol/q/'+pop_#())
 #.append(f.read())"
.e©“class="answer"“¢®"useful and clear"¡`99£þs\®“class="answer"“¡¦vy“class="post-text"“¡¦'>¡¦¦¬l"python"¢s\}rUV)O2‹X5›Y3›)P

This part:
import urllib.request as g
stack.append(g.urlopen('http://ppcg.lol/q/'+pop_stack()).read())`

actually pops a stack value, copies it into the url and fetches all HTML data. The HTML data is pushed on top of the stack using #.append(f.read()).
We count the number of answers, by count the number of occurences of class="answer".
To count the number of votes, we just split the data at "useful and clear" and keep only the digit values of [0:99] using ®"useful and clear"¡`99£þ. This is the number of upvotes.
Eventually, we need to check every answer if the text "Python" exists before the closing header text. To get all answers, we just split the data on class="post-text" and split each of them again on <. We remove the first two elements to get the part in which the language is displayed and check if the lowercase version is in this string.
So, now our stack looks like this for id = 79273:
`[6, '14', 0, 0, 0, 1, 0, 0]`
  │    │   └───────┬──────┘
  │    │           │
  │    │   is python answer?
  │    │
  │    └── number of upvotes
  │
  └─── number of answers

This can also be seen with the -debug flag on in the interpreter.
So, it's just a matter of processing the data:
rUV)O2‹X5›Y3›)P

r                # Reverse the stack
 U               # Pop the number of answers value and store into X
  V              # Pop the number of upvotes value and store into Y
   )O            # Wrap everything together and sum it all up
     2‹          # Check if smaller than 2
       X5›       # Push X and check if greater than 5
          Y3›    # Push Y and check if greater than 3
             )P  # Wrap everything into an array and take the product.
                   This results into 1 if and only if all values are 1 (and not 0).

Uses CP-1252 encoding. You can download the interpreter here.

I like the "more readable" version; those extra line breaks really make a difference!  ;)

@Wildcard They do indeed make a difference ;)

Could you save bytes by using ppcg.lol/q/id compression?

@wnnmaw Thanks, now I'm just 1 byte away from the Ruby answer :p.

If possible, you can do import urllib.request as u and then use u in place of the second urllib.request to save 8 bytes.

@R.Kap Thanks! That actually saved 2 bytes in the compressed version (beating the Ruby answer :p).

Hi! I'm beating you again, sorry...

nvm I messed up. We're actually tied

@KevinLau-notKenny Okay, now this is a war! :p.

Oh no! I don't think I can cut enough corners to save the 7 bytes I need to get ahead again... I guess I just have to settle for second place

Python 3.5, 280 272 260 242 240 bytes:
(Thanks to Adnan for the trick about using the * operator in comparisons resulting in 2 saved bytes!)
def g(o):import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());print((len(R('(?:<h[0-9]>|
).*python',w.lower()))<2)*(int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3)*w.count('answercell">')>5)

Simple enough. Uses Python's built in urllib library to go to the question's site, and then uses regular expressions to find the vote count, answer count, and the count of Python specific answers in the decoded text returned from the website. Finally, these values are compared against the conditions required to return a truthy value, and if they satisfy all the conditions, then True is returned. Otherwise False is.
The only thing I may be worried about here is that the regular expressions give a lot of lee way in the terms of the number of python specific answers to save bytes, so it may be a bit inaccurate at times, though it's probably good enough for the purposes of this challenge. However, if you want a much more accurate one, I have added one below, although its longer than the one above. The one shown below is currently 298 bytes since it uses a much longer regular expression–one which you couldn't know how long it took me to discover–for counting Python answers than my original function for the sake of accuracy. This one should work for about at least 80% to 90% of all test cases thrown at it.
def g(o):import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());print(len(R('(?<=answercell">).*?(?:<h[0-9]>|)[^\n]*python[^\n]*(?=</h[0-9]>|)',w.lower()))<2and int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3and w.count('answercell">')>5)

But, what about those questions with multiple pages of answers? Neither of the above will work very well in that situation, if, say, 1 python answer is on the first page and another is on the second. Well, I took the liberty to fix this issue by creating another version of my function (shown below) that checks every page of answers, if multiple ones exist, for Python answers, and it has done quite well on many of the test cases I have thrown at it. Well, without further ado, here is the new and updated function:
def g(o):
 import urllib.request as u,re;R=re.findall;w=bytes.decode(u.urlopen('http://ppcg.lol/q/'+o).read());t=0if len(re.findall('="go to page ([0-9]+)">',w))<1else max([int(i)for i in re.findall('="go to page ([0-9]+)">',w)])
 if t<1:print(len(R('(?<=answercell">).*?(?:<h[0-9]>|)[^\n]*python[^\n]*(?=</h[0-9]>|)',w.lower(),re.DOTALL))<2and int(R('(?<="vote-count-post ">)[0-9]+',w)[0])>3and w.count('answercell">')>5)
 else:
  P=[];U=[];K=[]
  for i in range(2,t+2):P.append(len(R('(?<=answercell">).*?(?:<h[0-9]>|)[^\n]*python[^\n]*(?=</h[0-9]>|)',w.lower(),re.DOTALL)));U.append(int(R('(?<="vote-count-post ">)[0-9]+',w)[0]));K.append(w.count('answercell">'));w=bytes.decode(u.urlopen('http://ppcg.lol/questions/'+o+'/?page='+str(i)).read())
  print(sum(P)<2and U[0]>3and sum(K)>5);print('# Python answers: ',sum(P));print('# Votes: ',U[0]);print('# Answers: ',sum(K))

Quite long, isn't it? I wasn't really going much for code golf with this, although, if you want, I can golf it down a bit more. Otherwise, I love it, and could not be happier. Oh, I almost forgot, as an added bonus, this also outputs the total number of Python answers on the question, total votes on the question, and total number of answers on the question if the question id corresponds to a question with more than 1 page of answers. Otherwise, if the question only consists of a single page of answers, it just outputs the truthy/falsy value. I really did get a bit carried away with this challenge.
These each take the question's id in the form of a string.
I would put Try It Online! links here for each function, but unfortunately, neither repl.it nor Ideone allow fetching of resources via Python's urllib library.

You can use http://codegolf.stackexchange.com/q/ to fetch the question. Also, is http:// mandatory?

Ideone and repl.it don't allow fetching external resources a la urllib.

@Mego Dang...well then, I guess people are going to have to confirm it works using their own Python interpreters.

@Marv Yes, apparently it is. Otherwise, I get a unknown url type error.

I can't test it, but I think you can save one byte by using from urllib.request import*

ppcg.lol/q/id also works

@WashingtonGuedes Really? Thanks! :) What kind of a url ending is .lol though?...

@Mego Do you, by any chance, know of any other online interpreter(s) that actually allow the fetching of resources via urllib?

@R.Kap You can thank Quill for that short URL. I'm not aware of any online interpreters that allow external resource fetching.

Ruby + HTTParty, 170 146 145 142 139 138 + 11 ( -rhttparty flag) = 181 157 156 153 150 149 bytes
I don't think there's any edge cases that would cause my regex patterns to break, I hope...
Updated to the shortlink provided by @WashingtonGuedes and discovering that HTTParty doesn't complain if I start with // instead of http://.
Updated for slightly more secure regexes. I saved bytes anyways by discovering that HTTParty response objects inherit from String, which means I don't even need to use .body when matching the regex!
@manatwork pointed out an accidental character addition that I had left in, and for the sake of golf, i has to be accepted as a String now.
Updated regexes. Same length. -1 byte by cutting out a paren.
->i{/"up.*?(\d+)/=~s=HTTParty.get("//ppcg.lol/q/"+i)
$1.to_i>3&&(a=s.scan /st.*xt".*\n(.*)/).size>5&&a[1..-1].count{|e|e[0]=~/python/i}<2}

Extra notes:

The first line of an answer (which should contain the language according to the spec) is two lines after the HTML Tag with class "post-text", which we matched with st.*xt". A more secure version would have added a space after it, but we're sacrificing that for the sake of golf.
HTTParty is used over the native net/http modules because of proper redirect handling for the given URL.
"up*?\d was the shortest sequence I found that corresponded with the number of votes. We only need the first one, so thankfully answers don't affect this.

ppcg.lol/q/#{i} also works

@WashingtonGuedes ppcg.ga/q#{i} maybe? (I don't know Ruby)

@ΈρικΚωνσταντόπουλος ppcg.ga is not a wildcard redirect, try it yourself - http://ppcg.ga/q/79273/

@Timtech So ppcg.lol/q#{i} is applicable I think? (a/#b is the same as a#b)

@ΈρικΚωνσταντόπουλος You don't need the number symbol in ppcg.lol/q/{i} right? And yeah I guess it works.

@Timech @ΈρικΚωνσταντόπουλος Nope, #{...} is a special string substitution sequence in Ruby, similar to %s formatting but putting the value directly into the string. Which means the # isn't actually part of the URL at all.

The " is ruining the /"e-c.*?(\d+)/ regular expression. By the way, the requirement say about the input that “Data types (…) doesn't matter.” So better pass the i parameter as string, so you can replace substitution with concatenation: "//ppcg.lol/q/"+i.

Julia, 275 bytes
using Requests
f(q,p=(s,t)->JSON.parse(readall(get("https://api.stackexchange.com/2.2/questions/$q$s",query=Dict(:site=>"codegolf",:filter=>"$t"))))["items"],x=p("","")[1])=x["answer_count"]>5&&x["score"]>3&&count(i->ismatch(r"python",i["body"]),p("/answers","!9YdnSMKKT"))<2

This is a function that accepts an integer and returns a boolean. It connects to the Stack Exchange API and each run of the function makes 2 API requests, so don't run it too many times or you'll exhaust your 300 requests/day quota.
Ungolfed:
using Requests

function f(q)
    # Define a function that takes two strings and returns a Dict
    # that connects to the SE API
    p = (s,t) -> JSON.parse(readall(get("https://api.stackexchange.com/2.2/questions/$q$s",
        query = Dict(:site => "codegolf", :filter=> "$t"))))["items"]

    # Get the question object
    x = p("", "")[1]

    # Get all answers using the `withbody` API filter
    y = p("/answers", "!9YdnSMKKT")

    x["answer_count"] > 3 && x["score"] > 5 &&
        count(i -> ismatch(r"python", i["body"], y) < 2
end

I wasn't aware of the "withbody" API filter! +1. If it saves bytes on my Ruby answer, can I use that trick as well?

@KevinLau-notKenny Of course! Do what you gotta do in the name of golf. :P

I didn't want to plagiarize =3 but alas, after learning of ppcg.lol as a short link to all things codegolf, the API version just wasn't enough

Racket, 339 Bytes
(λ(q)((λ(h)((λ(g)((λ(j)(and(>(h j'score)3)(>(h j'answer_count)5)(<(for/sum([a(g"~a/answers"q)]#:when(regexp-match #rx"(?i:python)"(h a'body)))1)2)))(car(g"~a"q))))(λ(s d)(define-values(x y b)(http-sendrecv"api.stackexchange.com"(format"/2.2/questions/~a?site=codegolf&filter=withbody"(format s d))))(h(read-json b)'items))))hash-ref))

There is much to golf, still.

Beat me to it! :P

TODO: make a racket-like that is golf-able. :)

339 bytes of which 68 are parens... so a LISP for golf would need short identifiers and no parens. Not very LISPy :(

Groovy, 179 161 157
{i->t=new URL("http://ppcg.lol/q/$i").text;a=0;p=0;(t=~/"(?i)p.{25}>\n.*python/).each{p++};(t=~/(?m)v.{13}t ">(\d+)/).each{if(it[1].toLong()>3)a++};a>5&&p<2}

Thanks to Timtech 17 chars saved.
Keyword def is also not necessary.

You can replace codegolf.stackexchange.com with ppcg.lol

see also: Tips for golfing in Groovy


text:
Calculate the Gamma function for half-integer arguments
Gamma function is defined as

It is a well-known fact that for positive integers it coincides with a properly shifted factorial function: Γ(n) = (n - 1)!. However, a less famous fact is

Γ(1/2) = π1/2

Actually, the Gamma function can be evaluated for all half-integer arguments, and the result is a rational number multiplied by π1/2. The formulas, as mentioned in Wikipedia, are:
 (for n > 0)
In this challenge, you should write code (program or function) that receives an integer n and returns the rational representation of Γ(1/2 + n) / π1/2, as a rational-number object, a pair of integers or a visual plain-text representation like 15/8.
The numerator and denominator don't need to be relatively prime. The code should support values of n at least in the range -10 ... 10 (I chose 10 because 20! < 264 and 19!! < 232).
Test cases (taken from Wikipedia):
Input | Output (visual) | Output (pair of numbers)
0     | 1               | 1, 1
1     | 1/2             | 1, 2
-1    | -2              | -2, 1
-2    | 4/3             | 4, 3
-3    | -8/15           | -8, 15

What kind of built-ins are allowed/forbidden? Gamma function? Pi function?

All built-ins are allowed (it's the default, isn't it?): gamma-function, factorial, whatever.

Can I use the letter r instead of /?

Yes (just because I want to know how that would give you an advantage).

J uses r (rational) as fraction separator.

This is a subset of http://codegolf.stackexchange.com/questions/63887/gamma-function-golf

@Mego Except that this requires exact rational output.

@user202729 Hence why I just commented (nearly a year ago), rather than closing it as a dupe

M, 7 bytes
,0_.!÷/

Try it online! or verify all test cases.
Trivia
Meet M!
M is a fork of Jelly, aimed at mathematical challenges. The core difference between Jelly and M is that M uses infinite precision for all internal calculations, representing results symbolically. Once M is more mature, Jelly will gradually become more multi-purpose and less math-oriented.
M is very much work in progress (full of bugs, and not really that different from Jelly right now), but it works like a charm for this challenge and I just couldn't resist.
How it works
,0_.!÷/  Main link. Argument: n

,0       Pair with 0. Yields [n, 0].
  _.     Subtract 1/2. Yields [n - 1/2, -1/2].
    !    Apply the Π function. Yields [Π(n - 1/2), Π(-1/2)] = [Γ(n + 1/2), Γ(1/2)].
     ÷/  Reduce by division. Yields Γ(n + 1/2) ÷ Γ(1/2) = Γ(n + 1/2) ÷ √π.

Octave, 27 bytes
@(n)rats(gamma(n+.5)/pi^.5)

Built-ins all the way.
Test suite on ideone.

If you have rats I think you'll need a cat.

Pyth - 27 26 25 24 bytes
Too cumbersome for my liking. Also, implicit input seems not to work with W. Uses the second to last first form listed above.
_W<QZ,.!yK.aQ*^*4._QK.!K

Test Suite.

J, 20 17 19 18 bytes
Saved 3 bytes using @Dennis's technique in his M, and another! This is a tacit verb.
x:@%&!/@(0.5-~,&0)

(Previous answers: x:@%/@(!@-&0.5@,&0), x:%/(!@-&0.5@,&0), x:((%:o.1)%~!@-&0.5))
(Note that instead of being -a/b, it's _arb.)
Test cases:
   gamma =: x:@%&!/@(0.5-~,&0)
   gmR0  =: gamma"0    NB. apply to 0-cells of a list
   gamma 0
1
   gamma 1
1r2
   gamma 2
3r4
   gamma -1
_2
   gamma -2
4r3
   i:2
_2 _1 0 1 2
   gmR0 i:2
4r3 _2 1 1r2 3r4
   gmR0 i:5
_32r945 16r105 _8r15 4r3 _2 1 1r2 3r4 15r8 105r16 945r32

Mathematica, 17 15 bytes
(#-1/2)!/√π&

Uses factorial function since gamma(n + 1/2) = (n - 1/2)!.
There are only 12 characters now but it needs 15 bytes to be represented. The bytes are counted using UTF-8. Sqrt = √ is 3 bytes from 5 bytes with @ (2 bytes saved, thanks to @CatsAreFluffy) and Pi = π is 2 bytes (equal).

Haskell, 81 71 69 bytes
import Data.Ratio
p=product
f n|n<0=1/(p[n+1%2..0-1])|0<1=p[1%2..n-1]

This seems bloated, but I'm not sure where to golf this from here. Any golfing suggestions are welcome.
Edit: Used the fact that the default step of range [x..y] is 1, and moved product to p=product to save two bytes.
Ungolfing:
import Data.Ratio
gamma_half n | n < 0     = 1 / ( product [ n + 1%2 .. (-1) ] )
             | otherwise = product [ 1%2 .. n-1 ]

Ruby, 80 59 58 bytes
f=->n{n<0?(-1)**n/f[-n]:(1..n).reduce(1){|z,a|z*(a-1r/2)}}

Any golfing suggestions are welcome.
Ungolfing:
def half_gamma(n)
  if n < 0
    return (-1) ** n / f(-n)
  else
    # Is there an golfier way to write product([1/2,3/2..(2*n-1)/2])?
    return (1..n).reduce(1) {|z, a| z * (a - 1r/2)}
  end
end