TweetFollow Us on Twitter

Oct 96 Challenge
Volume Number:12
Issue Number:10
Column Tag:Programmer’s Challenge

Programmer’s Challenge

By Bob Boonstra

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

DNA Match

This month’s Challenge is based on a suggestion submitted by Vicente Giles of the Universidad de Málaga. Vincente faces a real-world problem to look for all the genomic sequences that match certain

criteria, given a DNA database sequence and a problem sequence. A DNA sequence is a string of the four different nucleotides involved in the genetic code, denoted ‘A’, ‘C’, ‘G’, and ‘U’, which stand for adenine, cytosine, guanine, and uracil. The problem is to find all possible matches of the problem sequence in the database sequence, allowing a specified number of differences.

The prototype for the code you should write is:

long FindMatch(
 char *alphabet, /* legal characters for database and fragment strings */
 char *database, /* reference string to compare fragments against */
 void *storage,  /* storage preallocated for your use */
 char *fragment, /* string to match against database */
 long diffsAllowed,/* differences allowed between fragment and database */
 long matchPosition[]/* return match positions in this array*/

void InitMatch(
 char *alphabet, /* legal characters for database and fragment strings */
 char *database, /* reference string to compare fragments against */
 void *storage   /* storage preallocated for your use */

Because we would like our DNA-matching algorithm to be useful even if scientists discover an extraterrestrial genetic code based on other nucleotides, the algorithm accepts the genetic alphabet as a parameter. In the problem posed by Vincente, this would be the string “ACGU”, but in our Challenge it might include any of the characters ‘a’..’z’ or ‘A’..’Z’ (Extraterrestrial DNA is case sensitive). The null-terminated reference string contained in the database parameter can be up to 1000000000 (109) characters long. The fragment that you are to match is also null-terminated, but will be significantly shorter on average (up to 10000 characters) than the database string. You should compare the input fragment against database, finding all occurrences of fragment that differ in no more than diffsAllowed positions from a substring of database. Your code should populate one entry in the preallocated matchPosition array for each match found, storing the offset of the character in database that corresponds to the first character of fragment. The FindMatch function should return the number of matches found.

As an example, given the following input

alphabet: ACGU


fragment: ACGTACGTAC

diffsAllowed: 5

your code should find 7 matches and store the following values in matchPosition:

-4 0 4 8 15 19 23

Notice that partial matches can occur at the beginning or the end of database, and as a result, the offsets returned in matchPosition can be negative or greater than strlen(database) - strlen(fragment).

To allow you to do some preprocessing, your InitMatch routine will be called once before a sequence of calls to FindMatch. InitMatch will be called with the same alphabet and database parameters provided to subsequent FindMatch calls. Both routines will also be given the same storage parameter that points to at least 1MB of memory allocated and initialized to zero by the calling routine. FindMatch will be called between 100 and 1000 times, on average, for each call to InitMatch. The winning solution will be the one with the fastest execution time, including the execution time for both InitMatch and FindMatch.

Other fine print: The alphabet characters will be provided in increasing ASCII order. The offsets you store in matchPosition need not be in any particular order. The value for diffsAllowed will typically be smaller than 50% of strlen(fragment). Finally, you should not allocate any dynamic storage in your solution beyond that provided in the storage parameter.

This will be a native PowerPC Challenge using the latest Symantec environment. Solutions may be coded in C or C++.

Two Months Ago Winner

Congratulations to Randy Boring for submitting the fastest entry to the A-Maze-ing Programmer’s Challenge. The Challenge this month was to write code that would find a path leading out of a three-dimensional maze. The solutions were provided with the maze size, an initial position, some storage for use in mapping the maze, and a callback routine. The callback provided the result of attempting to move in a given direction, indicating whether the attempt to move succeeded, failed because there was no opening in the specified direction, resulted in a fall down a shaft in the mine, or found an exit to the mine. Of the four entries submitted, only two successfully solved all of my test mazes; one of the entries crashed, and one went into an infinite loop.

The table below summarizes the results for each correct entry, including the language in which the solution was written, the size of the solution code, the amount of static data used by the solution, the total execution time for all test cases, and the number of moves needed to solve the mazes.

Name Language Code Size Data Size Time Moves

Randy Boring C++ 2792 484 343153 33519

Jay Negro C++ 1788 51 40945114 7120802

The test mazes used in the evaluation ranged in size from 10x20x30 to 100x100x200, and ranged in density (the percentage of open cells) from 10% to 20%. As indicated in the problem statement, a path to an exit was guaranteed to exist from any cell reachable from the starting position.

Randy’s winning entry spent more time processing each move than the second place entry from first-time Challenge contestant Jay Negro, but Randy’s code solved the maze using significantly fewer moves and executed two orders of magnitude more quickly. His code maintains a queue of what are believed to be the best moves to try. As long as there are moves in the best move list, it invokes the callback with the best move, checks for success, and then updates the map with what it has learned about the maze position it just tried. The CalcBestMove routine determines the best possible move (surprise!) by first moving toward an adjacent maze boundary if one exists, or moving toward the nearest maze boundary if nothing is known about the current position, or trying adjacent positions about which nothing is known, or finally by moving toward a position about which nothing is known. The CalcBestMove heuristics, along with judicious use of inline functions and some optimization of maze offset calculations, combined to make this an efficient solution.

Careful readers of the code will note one potential problem with the Initialize routine, in that it simply gives up and returns if it is unable to allocate enough memory. This could have caused the winning entry to fail for larger mazes when given only the amount of memory guaranteed by the problem. However, the size of the mazes that I could practically evaluate was limited by the speed of the other entries, and the memory problem did not show up with those cases, so I elected to ignore it. Under other circumstances, proper handling of low memory conditions would have been required to win.


Here are the Top 20 Contestants for the Programmer’s Challenge. The numbers below include points awarded over the 24 most recent contests, including points earned by this month’s entrants.

1.Munter, Ernst193
2.Gregg, Xan92
3.Larsson, Gustav87
4.[Name deleted]60
5.Lengyel, Eric40
6.Lewis, Peter30
7.Boring, Randy27
8.Beith, Gary24
9.Kasparian, Raffi22
10.Vineyard, Jeremy22
11.Cutts, Kevin21
12.Picao, Miguel Cruz21
13.Brown, Jorg20
14.Gundrum, Eric20
15.Karsh, Bill19
16.Stenger, Allen19
17.Cooper, Greg17
18.Mallett, Jeff17
19.Nevard, John17
20.Nicolle, Ludovic14

There are three ways to earn points: (1) scoring in the top 5 of any Challenge, (2) being the first person to find a bug in a published winning solution or, (3) being the first person to suggest a Challenge that I use. The points you can win are:

1st place20 points
2nd place10 points
3rd place7 points
4th place4 points
5th place2 points
finding bug2 points
suggesting Challenge2 points

Here is Randy’s winning solution:


Copyright © 1996 Randy Boring

typedef Boolean (*MoveProc) (
 long xMove,long yMove,long zMove,
 long *newXPos,long *newYPos,long *newZPos

// the MoveProc, MakeAMove, is a callback.  It returns true if you 
// have found your way out of the maze.
// You give it (x,y,z) as a delta from your current position,
// each from [-1, 0, 1].  Straight up and straight down (and all zeroes)
// always result in no movement. 

Boolean Maze (long xMove, // these are your initial position
 long yMove,
 long zMove,
 long xSize,// these are the dimensions of the maze
 long ySize,
 long zSize,
 MoveProc MakeAMove, // this is your callback routine
 char *mapStorage// this is your preallocated storage
 );// (one char per position in maze)

Typedefs and Constants
typedef long dirT; // direction enumerator (0-24)

const long dir2dx[25]={9,
 -1, 0, 1,  -1, 1,  -1, 0, 1,
 -1, 0, 1,  -1, 1,  -1, 0, 1,
 -1, 0, 1,  -1, 1,  -1, 0, 1,};
const long dir2dy[25]={9, 
 1, 1, 1,   0, 0,  -1,-1,-1,
  1, 1, 1,   0, 0,  -1,-1,-1,
  1, 1, 1,   0, 0,  -1,-1,-1,};
const long dir2dz[25]={9,
  1, 1, 1,   1, 1,   1, 1, 1,
  0, 0, 0,   0, 0,   0, 0, 0,
 -1,-1,-1,  -1,-1,  -1,-1,-1,};
const dirT di[3][3][3] = {
static const dirT kNoDir = 0;
static const dirT kFirstDir = 1;
static const dirT kLastDir = 24;
static const dirT kNumDirs = 25; // including kNoDir at zero
static const char kUnknown = 0;  // unknown square
    // every type below is known
static const char kWall = 1;// wall
static const char kSpace = 2; // space-above-wall
static const char kFall = 4;// space-above-space
static const char kTriedSpace = 10;// searched space
static const char kTriedFall = 12; // searched fall

static const short kTakeProb = 4;  // 1/4th
static const long kSTNBlockSize = 48;

typedef long squareIndexT;
typedef struct STN {
 struct STN *parent;
 squareIndexT square;// square index of this node
 dirT   direction; // how I got here from my parent
 } SearchTreeNode, *STNPtr, **STNHandle;

static STNPtr gTreeRoot;
static STNPtr gTreeTop;
static STNPtr gQHead;
static STNPtr gQTail;
static STNPtr gBestMoveList;
static STNHandle gTreeRootH;
static STNHandle gBestMoveListH;
static STNPtr gBestMoveListNextPos;

#define myIsUnknown(sq) (kUnknown == (sq))
#define myIsKnown(sq)(kUnknown != (sq))
    // the below should only be used when the square is known
#define myIsWall(sq) (kWall == (sq))
#define myIsUntriedWalkable(sq)  (kSpace == (sq))
#define myIsOpen(sq) (0x00 == (0x01 & (sq)))
#define myIsWalkable(sq) (0x02 == (0x02 & (sq)))
#define myIsUntriedFall(sq) (kFall == (sq))
#define myIsFall(sq) (0x04 == (0x04 & (sq)))
#define myIsTried(sq)(0x08 == (0x08 & (sq)))
#define d2x(d) (dir2dx[d])
#define d2y(d) (dir2dy[d])
#define d2z(d) (dir2dz[d])
#define xvec(d) (d2x(d))
#define yvec(d,xN) (d2y(d) * (xN))
#define zvec(d,xyN) (d2z(d) * (xyN))
#define offsetD(d,xN,xyN) (xvec(d) + yvec(d,xN) + zvec(d,xyN))
#define offsetXYZ(x,y,z,xN,xyN) ((x) + (y) * xN + (z) * (xyN))
#define map(m,x,y,z,xN,xyN) (*(m + (x) + (y) * xN + (z) * (xyN)))

#ifdef powerc
#define BreakToSourceDebugger_()   Debugger()
#else   // 68K
#define BreakToSourceDebugger_()   SysBreak()
#endif  // powerc

static inline Boolean
isEmptySearchQ() {return (gQHead == gQTail);}

static inline Boolean
isFullSearchQ() {return (gTreeTop <= gQTail);}

static inline STNPtr
DeQ(void) {return gQHead++;}

static inline STNPtr
EnQ(void) {
 STNPtr p = gQTail++;
    //if (isFullSearchQ())
    //    BreakToSourceDebugger_();
 return (p);

// Add this move (direction to a square index) to the tree at the current node, assumes 
// the square index has not already been visited by this search.
static void
EnQNewCandidate(STNPtr parent, const long sqi, 
 const dirT d)
STNPtr newNode = EnQ();
newNode->parent = parent;
newNode->direction = d;
newNode->square = sqi;

static inline Boolean
isEmptySearchTree() {return (gTreeRoot == gQTail);}

static inline long
PopSearchTree(void) {return ((-gQTail)->square);}

static void
NewSearchTree(void) {
 gQTail = gQHead = gTreeRoot;
 gQTail++;// the only time we’re called,
}//  gTreeRoot is immediately the EnQed elem.

static void
DisposeSearchTree(char *m) {
while (!isEmptySearchTree()) {
    // remove ‘tried’ mark
 *(m + PopSearchTree()) = kSpace;

static inline Boolean
 {return (gBestMoveListNextPos == gBestMoveList);}

static inline void
PushMoveList(const dirT d) {
 gBestMoveListNextPos->direction = d;

static inline dirT
PopMoveList(void) {
 return (gBestMoveListNextPos->direction);}

static void
NewBestMoveList(void) {gBestMoveListNextPos = gBestMoveList;}

// Copy the sequence of best directions-to-move to the
// best move list.  (The tree is about to be freed.)
static void
SetBestMove(STNPtr node, const dirT d)
while (kNoDir != node->direction) { // the root’s dir
 node = node->parent;

// Initialize everything for the routine
// map is already initialized to zeroes (kUnknown == 0)
static Boolean
Initialize(const long x, const long y, const long z,
 const long xSize, const long ySize, const long zSize,
 char *m)
const long xySize = xSize * ySize;
long treeBytesWanted = sizeof(SearchTreeNode)
 * ((xSize - 2) * (ySize - 2) * (zSize - 2) + 4);
long treeBytesNeeded = sizeof(SearchTreeNode)
 * ((xSize - 2) + (ySize - 2) + (zSize - 2) + 1);
Boolean succeed = true;

map(m,x,y,z,xSize,xySize) = kSpace;
map(m,x,y,z-1,xSize,xySize) = kWall;

gBestMoveListH = (STNHandle) NewHandle(sizeof(SearchTreeNode)
 * (zSize + xySize) * 2);
if (!gBestMoveListH) succeed = false;
 // unable to initialize successfully,MEM
HLock((Handle) gBestMoveListH);
gBestMoveList = *gBestMoveListH;

do {
 gTreeRootH = (STNHandle) NewHandle(treeBytesWanted);
 treeBytesWanted *= 0.9;
 while (!gTreeRootH && 
 (treeBytesNeeded <= treeBytesWanted));
if (!gTreeRootH) succeed = false;
 // unable to initialize successfully,MEM
HLock((Handle) gTreeRootH);
gTreeRoot = *gTreeRootH;

return succeed;

// Free everything we allocated
static void
HUnlock((Handle) gBestMoveListH);
DisposeHandle((Handle) gBestMoveListH);
HUnlock((Handle) gTreeRootH);
DisposeHandle((Handle) gTreeRootH);

// Are we at an edge?
// return true if we are
static Boolean
AtEdge(const long x, const long y, const long z,
 const long xMax, const long yMax, const long zMax)
if (0==x || 0==y || 0==z) return true;
if (xMax==x || yMax==y || zMax==z) return true;
return false;

// Map the move we just made/tried.
// I.e., store our new knowledge of the maze in the map
static void
MapMove(const long oldx, const long oldy, const long oldz,
 const long newx, const long newy, const long newz,
 char *m, const long xN, const long xyN,
 const long dx, const long dy, const long dz)
long x = oldx + dx; // where we tried to move
long y = oldy + dy; // (we need these in either case below)
long z = oldz + dz;
long sqi = offsetXYZ(x, y, z, xN, xyN);
if (newx==oldx && newy==oldy && newz==oldz) { // bump!
    // mark as wall the square we bumped into
 *(m + sqi) = kWall;
    // lastTried was not successful
    //gLastWasSuccess = false;
else {
    // mark as clear any squares we fell through
    // actually mark them with as fall because they can’t
    // really be moved ‘to’ only through, downwards.
 if (newz < z) {
 do {
 *(m + sqi) = kFall;
 sqi -= xyN;
 } while (newz < z);
    // mark as clear our current space
 *(m + sqi) = kSpace;
    // mark as ‘wall’ the square we are standing on
 sqi -= xyN;
 *(m + sqi) = kWall;
    // lastTried was successful
    //gLastWasSuccess = true;
    // direction of last success
    //gLastSuccess = lastTried;

// return a direction in which
// there may be an adjacent exit.
// A possible exit must be both an edge and untried.
static dirT
APossibleExit(const long x, const long y, const long z,
 const long xSize, const long ySize, const long zSize,
 char *m, dirT lastTried)
dirT tryD = lastTried + 1; // start here
/* check for edge conditions first */
if (x > 1 && x < xSize - 2)
 if (y > 1 && y < ySize - 2)
 if (z > 1 && z < zSize - 2)
    /* no exits are possibly nearby */
    /* because no edges are nearby */
 return kNoDir; // zero

/* search the adjacent spaces for a possible exit */
/* this could improve a lot */
while (tryD <= kLastDir) {
 const long dx = d2x(tryD);
 const long dy = d2y(tryD);
 const long dz = d2z(tryD);
 if (AtEdge(x+dx, y+dy, z+dz, xSize-1, ySize-1, zSize-1))
 if (myIsUnknown(map(m, x + dx, y + dy, z + dz,
 xSize, xSize * ySize)))
 return tryD;
tryD = kFirstDir;
while (tryD <= lastTried) {
 const long dx = d2x(tryD);
 const long dy = d2y(tryD);
 const long dz = d2z(tryD);
 if (AtEdge(x+dx, y+dy, z+dz, xSize-1, ySize-1, zSize-1))
 if (myIsUnknown(map(m, x + dx, y + dy, z + dz,
 xSize, xSize * ySize)))
 return tryD;
return kNoDir; // zero, no possible exit found nearby

// returns true if every move leads to an unknown square
// this is only possible at the beginning and after falling
// at least three below our last position.
static Boolean
TotallyUnknown(const long x, const long y, const long z,
 const long xSize, const long xySize, char *m)
dirT dir;
/* loop through the directions until we find a known spot */
for (dir = kFirstDir; dir <= kLastDir; dir++) {
 const long dx = d2x(dir);
 const long dy = d2y(dir);
 const long dz = d2z(dir);
 if (!myIsUnknown(map(m, x + dx, y + dy, z + dz,
 xSize, xySize)))
 return false;
return true;

// Pick a move that is towards a near wall
// (NOTE: only used when all directions are unknown)
static dirT
MoveTowardsNearWall(const long x, const long y, const long z,
 const long xSize, const long ySize, const long zSize,
 char *m)
#pragma unused (m)
long distx = xSize - x - 1; // distance from x==xMax edge
long disty = ySize - y - 1; // distance from y==yMax edge
long distz = zSize - z - 1; // distance from z==zMax edge
// [xyz] is distance from [xyz]==0 edge
long dx, dy, dz;
long xy = xSize * ySize;

if (x < distx) dx = -1;
else if (x == distx) dx = 0;
else dx = 1;
if (y < disty) dy = -1;
else if (y == disty) dy = 0;
else dy = 1;
if (z < distz) dz = -1;
else if (z == distz) dz = 0;
else dz = 1;

return di[dy+1][dz+1][dx+1];

// Fall until we find a floor below us
// Only use after mapping new knowledge
// (Don’t use during mapping)
static long
Gravity(long i, const char *m, const long xySize)
do {i -= xySize;}
 while (kWall != *(m + i));
return i + xySize;

// Search from this square for an adjacent unknown square
// queueing up moveable squares (including spaces below
// falls) for further research later,
// marking enqueued squares as ‘tried’ (immediately meaning
// ‘not-to-be-queued-for-trying’, later ‘actually-tried’)
// NOTE: while I could mark falls as tried (upward from
// every space) they are rather unlikely to be in the
// search path, so it’s not worth it.  Just re-enact
// gravity each time, and check last square for ‘tried’.
static Boolean
SearchOneSquare(STNPtr startSTN,
 const long xSize, const long xySize, char *m)
dirT d;
const long startSquare = startSTN->square;

for (d = kFirstDir; d <= kLastDir; d++) {
 const long sqi = startSquare + offsetD(d,xSize,xySize);
 const char sq = *(m + sqi);
 if (myIsUnknown(sq)) {
 SetBestMove(startSTN, d);
 return true;
 else if (myIsUntriedWalkable(sq)) {
 *(m + sqi) = kTriedSpace;
 else if (myIsUntriedFall(sq)) {
 const long bottomSqi = Gravity(sqi,m,xySize);
 const long bottomSq = *(m + bottomSqi);
 if (myIsUntriedWalkable(sq)) {
 *(m + bottomSqi) = kTriedSpace;
    //else if (myIsUnknown(bottomSq)) {
    //    BreakToSourceDebugger_(); // should be impossible
    //    return true; //??
    //    }
 else ; //it’s an already tried space, do nothing
 else ; // it’s a wall or already tried space, do nothing
return false;

// Find a move sequence that will lead to an unknown
// square (preferably an edge square?).
static dirT
FindNearestUnknown(const long x, const long y, const long z,
 const long xSize, const long ySize, const long zSize,
 char *m)
#pragma unused (zSize)
const long xySize = xSize * ySize;
Boolean found = false;
// make new search tree with square at x,y,z
gTreeRoot->parent = nil;
gTreeRoot->square = offsetXYZ(x,y,z,xSize,xySize);
gTreeRoot->direction = kNoDir;
*(m + gTreeRoot->square) = kTriedSpace;
// fan out from this one layer at a time
while (!isEmptySearchQ() && !found) {
 STNPtr tryNode = DeQ();
 found = SearchOneSquare(tryNode, xSize, xySize, m);
// found move(list) or failed
return found;

// Calculate the best move to try
// return true if we have found an exit or are at wit’s end
static dirT
CalcBestMove(const long x, const long y, const long z,
 const long xSize, const long ySize, const long zSize,
 char *m)
static dirT lastTried = kNoDir;
dirT d;

if (!isEmptyMoveList()) { // we have a pre-made list of moves


Community Search:
MacTech Search:

Software Updates via MacUpdate

BetterTouchTool 2.412 - Customize multi-...
BetterTouchTool adds many new, fully customizable gestures to the Magic Mouse, Multi-Touch MacBook trackpad, and Magic Trackpad. These gestures are customizable: Magic Mouse: Pinch in / out (zoom... Read more
Tor Browser Bundle 7.5.2 - Anonymize Web...
The Tor Browser Bundle is an easy-to-use portable package of Tor, Vidalia, Torbutton, and a Firefox fork preconfigured to work together out of the box. It contains a modified copy of Firefox that... Read more
Monosnap 3.4.11 - Versatile screenshot u...
Monosnap lets you capture screenshots, share files, and record video and .gifs! Features Capture Capture full screen, just part of the screen, or a selected window Make your crop area pixel... Read more
Yummy FTP Pro 2.0.3 - $29.99
Yummy FTP Pro is an advanced Mac file transfer app which provides a full-featured professional toolkit combined with blazing speeds and impeccable reliability, so whether you want to transfer a few... Read more
Smultron 10.1.3 - Easy-to-use, powerful...
Smultron 10 is an elegant and powerful text editor that is easy to use. You can use Smultron 10 to create or edit any text document. Everything from a web page, a note or a script to any single piece... Read more
Time Out 2.4 - Break reminder tool with...
Time Out helps remind you to take work breaks throughout the day. It has two kinds of breaks: a "Normal" break, typically for 10 minutes after 50 minutes of work, so you can move about and relax,... Read more
Iridient Developer 3.2.2 - Powerful imag...
Iridient Developer (was RAW Developer) is a powerful image-conversion application designed specifically for OS X. Iridient Developer gives advanced photographers total control over every aspect of... Read more
DesktopLyrics 2.6.13 - Displays current...
DesktopLyrics is an application that displays the lyrics of the song currently playing in "iTunes" right on your desktop. The lyrics for the song have to be set in iTunes; DesktopLyrics does nothing... Read more
BusyContacts 1.2.8 - Fast, efficient con...
BusyContacts is a contact manager for OS X that makes creating, finding, and managing contacts faster and more efficient. It brings to contact management the same power, flexibility, and sharing... Read more
iClock 4.2.5 - Customizable menu bar clo...
iClock replaces the old Apple's default menu bar clock with more features, customization and increases your productivity. Features: Have your Apple or Google calendar instantly available from the... Read more

Latest Forum Discussions

See All

How PUBG, Fortnite, and the battle royal...
The history of the battle royale genre isn't a long one. While the nascent parts of the experience have existed ever since players first started killing one another online, it's really only in the past six years that the genre has coalesced into... | Read more »
Around the Empire: What have you missed...
Oh hi nice reader, and thanks for popping in to check out our weekly round-up of all the stuff that you might have missed across the Steel Media network. Yeah, that's right, it's a big ol' network. Obviously 148Apps is the best, but there are some... | Read more »
All the best games on sale for iPhone an...
It might not have been the greatest week for new releases on the App Store, but don't let that get you down, because there are some truly incredible games on sale for iPhone and iPad right now. Seriously, you could buy anything on this list and I... | Read more »
Everything You Need to Know About The Fo...
In just over a week, Epic Games has made a flurry of announcements. First, they revealed that Fortnite—their ultra-popular PUBG competitor—is coming to mobile. This was followed by brief sign-up period for interested beta testers before sending out... | Read more »
The best games that came out for iPhone...
It's not been the best week for games on the App Store. There are a few decent ones here and there, but nothing that's really going to make you throw down what you're doing and run to the nearest WiFi hotspot in order to download it. That's not to... | Read more »
Death Coming (Games)
Death Coming Device: iOS Universal Category: Games Price: $1.99, Version: (iTunes) Description: --- Background Story ---You Died. Pure and simple, but death was not the end. You have become an agent of Death: a... | Read more »
Hints, tips, and tricks for Empires and...
Empires and Puzzles is a slick match-stuff RPG that mixes in a bunch of city-building aspects to keep things fresh. And it's currently the Game of the Day over on the App Store. So, if you're picking it up for the first time today, we thought it'd... | Read more »
What You Need to Know About Sam Barlow’s...
Sam Barlow’s follow up to Her Story is #WarGames, an interactive video series that reimagines the 1983 film WarGames in a more present day context. It’s not exactly a game, but it’s definitely still interesting. Here are the top things you should... | Read more »
Pixel Plex Guide - How to Build Better T...
Pixel Plex is the latest city builder that has come to the App Store, and it takes a pretty different tact than the ones that came before it. Instead of being in charge of your own city by yourself, you have to work together with other players to... | Read more »
Fortnite Will Be Better Than PUBG on Mob...
Before last week, if you asked me which game I prefer between Fortnite Battle Royale and PlayerUnknown’s Battlegrounds (PUBG), I’d choose the latter just about 100% of the time. Now that we know that both games are primed to hit our mobile screens... | Read more »

Price Scanner via

MacBook Pro sale! B&H drops prices on new...
B&H Photo has dropped prices on new 2017 13″ MacBook Pros, with models now on sale for up to $200 off MSRP. Shipping is free, and B&H charges sales tax for NY & NJ residents only. Their... Read more
13″ MacBook Airs on sale for $100-$150 off MS...
B&H Photo has 13″ MacBook Airs on sale for $100-$150 off MSRP. Shipping is free, and B&H charges sales tax for NY & NJ residents only: – 13″ 1.8GHz/128GB MacBook Air (MQD32LL/A): $899, $... Read more
Huge iMac sale! Apple reseller now offering 2...
B&H Photo has new 2017 21″ & 27″ iMacs on sale today for up to $300 off MSRP. Shipping is free, and B&H charges sales tax for NY & NJ residents only: – 27″ 3.8GHz iMac (MNED2LL/A): $... Read more
Sale! 1.4GHz Mac mini for $399, $100 off MSRP
B&H Photo has the 1.4GHz Mac mini on sale for $399 for a limited time. Their price is $100 off MSRP, and it’s the lowest price available for a mini from any Apple reseller: – 1.4GHz Mac mini (... Read more
Sale of the year continues as Apple resellers...
Adorama has new 2017 15″ MacBook Pros on sale for $250-$300 off MSRP. Shipping is free, and Adorama charges sales tax in NJ and NY only: – 15″ 2.8GHz Touch Bar MacBook Pro Space Gray (MPTR2LL/A): $... Read more
iPad sale continues! 9″ WiFi iPads for $50-$8...
Walmart has 9.7″ Apple iPads on sale for $50-$80 off MSRP for a limited time. Sale prices are for online orders only, in-store prices may vary: – 9″ 32GB iPad: $249.99 $80 off – 9″ 128GB iPad: $379 $... Read more
Apple resellers offer 27″ 3.4GHz 5K iMac for...
B&H Photo has new 2017 27″ 3.4GHz iMacs on sale for $200 off MSRP. Shipping is free, and B&H charges sales tax for NY & NJ residents only: – 27″ 3.4GHz iMac (MNE92LL/A): $1599.99 $200 off... Read more
Certified Refurbished 21″ & 27″ iMacs ava...
Apple has a full line of Certified Refurbished iMacs available for up to $350 off original MSRP. Apple’s one-year warranty is standard, and shipping is free. The following models are available: – 27... Read more
Sunday Sales: $200 off 13″ Touch Bar MacBook...
Amazon has new 2017 13″ 3.1GHz Touch Bar MacBook Pros on sale this weekend for $200 off MSRP, each including free shipping: – 13″ 3.1GHz/256GB Space Gray MacBook Pro (MPXV2LL/A): $1599.99 $200 off... Read more
B&H drops prices on 15″ MacBook Pros up t...
B&H Photo has dropped prices on new 2017 15″ MacBook Pros, now up to $300 off MSRP and matching Adorama’s price drop yesterday. Shipping is free, and B&H charges sales tax for NY & NJ... Read more

Jobs Board

*Apple* Solutions Consultant - Apple (United...
# Apple Solutions Consultant Job Number: 113587340 Hialeah, Florida, United States Posted: 12-Mar-2018 Weekly Hours: 40.00 **Job Summary** Are you passionate about Read more
*Apple* Watch HW Engineering Program Special...
# Apple Watch HW Engineering Program Specialist Job Number: 113466877 Santa Clara Valley, California, United States Posted: 12-Mar-2018 Weekly Hours: 40.00 **Job Read more
*Apple* Technical Specialist - Apple, Inc. (...
…customers purchase our products, you're the one who helps them get more out of their new Apple technology. Your day in the Apple Store is filled with a range of Read more
*Apple* Information Security Project Manager...
# Apple Information Security Project Manager Job Number: 113440724 Santa Clara Valley, California, United States Posted: 15-Mar-2018 Weekly Hours: 40.00 **Job Read more
Senior Linus Systems Engineer, *Apple* Pay...
# Senior Linus Systems Engineer, Apple Pay Job Number: 113584532 Santa Clara Valley, California, United States Posted: 13-Mar-2018 Weekly Hours: 40.00 **Job Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.