In a field of geometry 5x5, put down 3 wolves and 5 sheeps. However, the wolves will kill the sheeps that they see in any diagonal or axial (horizonal and vertical) directions.

Actually, there is only one solution (ignoring transpose).

How to solve: (1) By enumeration.

import itertools

GRIDSIZE = 5
WOLVES = 3
SHEEPS = 5

solution = [['_' for j in range(GRIDSIZE)] for i in range(GRIDSIZE)]
coordinates = list(itertools.product(range(GRIDSIZE), range(GRIDSIZE)))

def getTransforms(coords):
    yield [(x, GRIDSIZE-1-y) for x, y in coords] # mirror vertically, aka rotate transpose 90 degree
    yield [(y, GRIDSIZE-1-x) for x, y in coords] # rotate 90 degree, aka mirror of transpose vertically
    yield [(y, x) for x, y in coords] # transpose
    yield [(GRIDSIZE-1-x, y) for x, y in coords] # mirror horizontally, aka rotate transpose 270 degree
    yield [(GRIDSIZE-1-x, GRIDSIZE-1-y) for x, y in coords] # rotate 180 degree
    yield [(GRIDSIZE-1-y, x) for x, y in coords] # rotate 270 degree, aka rotate transpose horizontally
    yield [(GRIDSIZE-1-y, GRIDSIZE-1-x) for x, y in coords] # rotate transpose 180 degree
def sameSet(coords1, coords2):
    coords1 = sorted(coords1)
    return any(coords1 == sorted(coords) for coords in getTransforms(coords2))
def wolfSee(wolfcoord):
    wx, wy = wolfcoord
    coords = [
        (wx,y) for y in range(GRIDSIZE) # coordinates of same row
    ] + [
        (x,wy) for x in range(GRIDSIZE) # coordinates of same column
    ] + [
        (wx+i,wy+i) for i in range(-GRIDSIZE+1,GRIDSIZE) # coordinates of forward diagonal
    ] + [
        (wx+i,wy-i) for i in range(-GRIDSIZE+1,GRIDSIZE) # coordinates of backward diagonal
    ]
    return set((x,y) for x,y in coords)
if __name__=='__main__':
    checked = set([])
    for wolves in itertools.combinations(coordinates, WOLVES):
        if any(sameSet(wolves, old_wolves) for old_wolves in checked):
            continue # just a transformation, skip
        checked.add(wolves)
        goodcoordinates = set(coordinates)
        for wolf in wolves:
            goodcoordinates = goodcoordinates - wolfSee(wolf)
            if len(goodcoordinates) < SHEEPS:
                break # no way to place sheeps in this config
        else:
            print "Solution found:"
            print "  Wolves: %s" % list(wolves)
            print "  Sheeps: %s" % list(goodcoordinates)

Also, (2) there is an analytical method to solve (in MathProg):

param N, integer, >0; /* grid size */

param W, integer, >0; /* number of wolves */
param S, integer, >0; /* number of sheeps */

var WOLF {1..N, 1..N}, binary; /* WOLF[j,k]=1 iff a wolf is in coordinate (j,k) */
var SHEEP {1..N, 1..N}, binary; /* SHEEP[j,k]=1 iff a sheep is in coordinate (j,k) */

var hb{1..N} binary; /* constraint helper */
var vb{1..N} binary;
var db{1-N..N-1} binary;
var bb{2..N*2} binary;

/* Every wolf has a unique coordinate */
s.t. wolf_coordinate: sum{x in 1..N, y in 1..N} WOLF[x,y] = W;

/* Every sheep has a unique coordinate */
s.t. sheep_coordinate: sum{x in 1..N, y in 1..N} SHEEP[x,y] = S;

/* No wolf see any sheep horizontally */
s.t. horizontals{y in 1..N}: sum{x in 1..N} SHEEP[x,y] <= (S+W)*hb[y];
s.t. horizontalw{y in 1..N}: sum{x in 1..N} WOLF[x,y] <= (S+W)*(1-hb[y]);
    /* On every horizontal scan, we either find sheeps or wolves or neither but not both */

/* No wolf see any sheep vertically */
s.t. verticals{x in 1..N}: sum{y in 1..N} SHEEP[x,y] <= (S+W)*vb[x];
s.t. verticalw{x in 1..N}: sum{y in 1..N} WOLF[x,y] <= (S+W)*(1-vb[x]);
    /* On every vertical scan, we either find sheeps or wolves or neither but not both */

/* No wolf see any sheep forward diagonally */
s.t. diagonals{i in 1-N..N-1}: sum{x in 1..N, y in 1..N: x-y=i} SHEEP[x,y] <= (S+W)*db[i];
s.t. diagonalw{i in 1-N..N-1}: sum{x in 1..N, y in 1..N: x-y=i} WOLF[x,y] <= (S+W)*(1-db[i]);
    /* On every diagonal scan, we either find sheeps or wolves or neither but not both */

/* No wolf see any sheep backward diagonally */
s.t. backwards{i in 2..N*2}: sum{x in 1..N, y in 1..N: x+y=i} SHEEP[x,y] <= (S+W)*bb[i];
s.t. backwardw{i in 2..N*2}: sum{x in 1..N, y in 1..N: x+y=i} WOLF[x,y] <= (S+W)*(1-bb[i]);
    /* On every diagonal scan, we either find sheeps or wolves or neither but not both */

solve;

printf "Wolves: ";
for {x in 1..N} {
    for {y in 1..N: WOLF[x,y] == 1} {
        printf "(%d,%d) ", x, y;
    }
}
printf "\n";
printf "Sheeps: ";
for {x in 1..N} {
    for {y in 1..N: SHEEP[x,y] == 1} {
        printf "(%d,%d) ", x, y;
    }
}
printf "\n";

data;

param N := 5;
param W := 3;
param S := 5;

end;