TweetFollow Us on Twitter

Apr 96 Challenge
Volume Number:12
Issue Number:4
Column Tag:Programmer’s Challenge

Programmer’s Challenge

By Bob Boonstra, Westford, Massachusetts

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

Mutant Life

Time for a little nostalgia this month. Most of you probably remember John Conway’s exploration of cellular automata known as the game of Life. The game is played on a grid of square cells. A cell has one of two states - it can be occupied (“alive”) or empty (“dead”). Time proceeds in discrete increments, or generations, and the state of a cell at time N+1 is determined by its state and that of its eight neighbors at time N. In the simplest variations of the game, a “birth” occurs in an empty cell if exactly three of its neighbors were alive in the previous generation. A “death” occurs in an occupied cell surrounded by four or more living cells, or by fewer than two living cells.

This month, the challenge is to write code that will compute the state of a Life-like world some number of generations into the future. The prototype for the code you should write is:

pascal long PropagateLife(
 BitMap cells,   /* the boundaries and population of your automata */
 long numGenerations,/* number of generations to propagate */
 short birthRules, /* defines when cells become alive */
 short deathRules/* defines when cells die */
);

Your automata live in a world defined by the rectangle cells.bounds (with top and left coordinates guaranteed to be 0). Their world is actually a torus instead of a rectangle: the cells.bounds.right-1 column of cells is adjacent to column 0, and the cells.bounds.bottom-1 row of cells is adjacent to row 0. The rules for birth and death are generalized from those in the first paragraph and defined by birthRules and deathRules. An empty cell with X occupied neighbors becomes alive in the next generation if the bit (birthRules & (1<<X)) is set. An occupied cell with Y occupied neighbors dies in the next generation if the bit (deathRules & (1<<Y)) is set. Any other cell retains its previous state (occupied or empty) from one generation to the next. As an example, the version of the game described in the first paragraph would have birthRules=0x0008 and deathRules=0x01F3.

The initial population of automata is pointed to by cells.baseAddr, one bit per cell, when PropagateLife is called. An occupied cell has the value 1, and an empty cell has the value 0. The cells BitMap is defined in the usual way, with row R found starting at *(cells.baseAddr + R*cells.rowBytes). You are to use birthRules and deathRules to propagate this population ahead for numGenerations generations, stopping only in the event that the population of generation N is identical to that of the immediately preceeding generation. Your code must return the number of generations processed (which will be numGenerations unless a static population was reached). When you return, the memory pointed to by cells.baseAddr must contain the propagated population.

You may allocate a reasonable amount of auxiliary storage if that is helpful, provided (as always) that you deallocate any memory before returning, as I will be calling your code many times.

This month, we continue the language experiment that permits your solution to the Challenge to be coded in C, C++, or Pascal, using your choice among the MPW, Metrowerks, or Symantec compilers for these languages. The environment you choose must support linking your solution with test code written in C. Along with your solution, you should provide a project file or make file that will generate a stand-alone application that calls your solution from C test code.

This will be a native PowerPC Challenge. Now, start propagating

Two Months Ago Winner

Congratulations to Ernst Munter (Kanata, Ontario) for submitting the fastest entry to the Intersecting Rectangles Challenge. Of the eighteen contestants who submitted entries, sixteen provided correct solutions. Recall that the Challenge was to provide code that would return a set of output rectangles containing all points inside in an odd number (or an even number, depending on an input parameter) of input rectangles.

A number of solutions scanned the list of input rectangles and created a list of rectangles formed by the intersections, keeping track of whether the resulting subrectangles were inside an odd or an even number of input rectangles. Other solutions used a bitmap approach, calculating the exclusive OR of the input rectangles (for the odd parity case). The bitmap technique tended to suffer when the rectangles spanned a large x/y space.

The winning solution combines these techniques in an interesting way. Ernst first scans the input rectangles to collect and sort the unique x and y vertex coordinates. He then forms a reduced-scale bitmap using these virtual pixels (dubbed “vixels”), applying the XOR technique to compute the odd or even parity intersections of the input rectangles. Finally, Ernst scans the “vixelMap” to form output rectangles of the appropriate parity. An innovative technique that was not only fast but also space-efficient compared with many of the other entries.

The table below summarizes the results for entries that worked correctly. It shows the total time required for 60 test cases of up to 250 input rectangles per test case, the number of output rectangles produced, and the total code/data size of each entry. (The limit of 250 input rectangles resulted from the large memory requirements of some of the solutions.) Numbers in parentheses after a person’s name indicate that person’s cumulative point total for all previous Challenges, not including this one.

Nametime# of rectssize
Ernst Munter (112)3121054602264
ACC Murphy3984465561210
John Nevard (10)551988043092
Miguel Cruz Picão (7)10322615621328
Xan Gregg (88)17161036731232
Cathy Saxton18544575081148
David Cary43614369932205
Elden Wood582417857101012
Bob Clark601617897491572
Randy Boring60334465562589
Alex Kipnis1015817857101218
Tom Saxton (10)15206980411264
Richard Cann231032821243581
Erik Sea548384350491125
Rishi Khan18020527951361288
Michael White9381912399241796

Top 20 Contestants of All Time

Here are the Top Contestants for the Programmer’s Challenges to date, including everyone who has accumulated more than 20 points. The numbers below include points awarded for this month’s entrants.

Rank Name Points Rank Name Points

1. [Name deleted] 176 11. Mallett, Jeff 44

2. Munter, Ernst 132 12. Kasparian, Raffi 42

3. Gregg, Xan 92 13. Vineyard, Jeremy 42

4. Larsson, Gustav 87 14. Lengyel, Eric 40

5. Karsh, Bill 80 15. Darrah, Dave 31

6. Stenger, Allen 65 16. Brown, Jorg 30

7. Riha, Stepan 51 17. Landry, Larry 29

8. Cutts, Kevin 50 18. Elwertowski, Tom 24

9. Goebel, James 49 19. Lee, Johnny 22

10. Nepsund, Ronald 47 20. Noll, Robert 22

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 place 20 points 5th place 2 points

2nd place 10 points finding bug 2 points

3rd place 7 points suggesting Challenge 2 points

4th place 4 points

Xan Gregg earns two points this month for being the first to point out an error in the winning Find Again and Again solution by Gustav Larsson published in the February issue. The error occurs because the routines BMH_Search() and SimpleSearch() use signed declarations char * when they ought to use unsigned char *. As a result, processing is not correct in some cases when the textToSearch contains characters >= 0x80. There was confusion on this point in a number of the entries, and I did not penalize any of the solutions for making this error.

Here is Ernst’s winning Intersecting Rectangles solution:

IntersectRects.c

Copyright 1996, Ernst Munter, Kanata, ON, Canada

/*
  The Problem
  -----------
  Given a bunch of overlapping rectangles, compute a set
  of rectangles which covers the area of either an odd or
  an even number of overlaps.  The output rects should only
  use edges from the repertoire of edges contained in the
  input set of rects.

  General Strategy
  ----------------
  We create a virtual raster with a (variable) resolution,
  where each x or y coordinate value corresponds to an
  edge of at least one input rectangle.  Depending on the
  number of input rects, and their coincidence of edges,
  this raster may be very small, or fairly large, but never
  larger than the screen it represents.

  We then paint rectangles into the raster, each raster
  point being represented by 1 bit, regardless how many
  pixels are within the corresponding edges on the real
  screen.  I call these bits “virtual pixels” or “vixels”.

  After all vixels are painted, the bit map is scanned
  to identify rectangular areas of set bits.

  The vertical extent of each output rect is at least equal
  to the distance between the two neighboring input edges.

  We then follow the slice down over as many slices as
  possible to maximize the height of the rectangle.

  Memory Use
  ----------
  The maximum amount of memory allocated dynamically is
  determined by the number of input rects.  The actual
  amount will be less if some input rects share edge
  coordinate values.

  Approximate size of the index heap:
  (16 * numRectsIn)  bytes
     plus a few overhead bytes

  Approximate combined size of the two vixel maps:
  (numRectsIn * numRectsIn) bytes
     plus a few overhead bytes,
     minus gain from elimination of duplicate values

  A double size vixel map is always allocated although
  only the even parity case needs both.

  For example, total dynamic memory for 100 rectangles will
  be about 16K.  1000 rectangles might need 1MB, but on
  any reasonable size screen, 1000 rectangles will share
  a very large number of edges, and will have considerably
  less memory allocated.


  Other assumptions (these are not checked)
  -----------------------------------------
  There is at least one input rect.

  All input rects are legal and not empty, that is:
      top<bottom, and left<right.
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAXLONG 0x7fffffff

void RectangleIntersections(
     const Rect inputRects[],
     const long numRectsIn,
     Rect  outputRects[],
     long  *numRectsOut,
     const Boolean oddParity);

// Local function prototypes:
void  PaintOdd(long* vm,long H,long L,long R,long mapWidth);
void  PaintEven(long* vm,long H,long L,long R,long mapWidth);
void  PackMap(long* vm,long mapSize);
void  Insert(long* h,long size,long x);
long* Sort(long* h,long size);
long  GetIndex(long size,long* index,long z);

//Some shorthand macros:
#define IRT (inputRects[i].top)
#define IRL (inputRects[i].left)
#define IRB (inputRects[i].bottom)
#define IRR (inputRects[i].right)

#define ORT (ORptr->top)
#define ORL (ORptr->left)
#define ORB (ORptr->bottom)
#define ORR (ORptr->right)

/* Masks needed to process the edges of vixel blocks
   which are not necessarily aligned with bitmap words.
*/
long leftMask[32] =
   {0xFFFFFFFF, 0x7FFFFFFF, 0x3FFFFFFF, 0x1FFFFFFF,
    0x0FFFFFFF, 0x07FFFFFF, 0x03FFFFFF, 0x01FFFFFF,
    0x00FFFFFF, 0x007FFFFF, 0x003FFFFF, 0x001FFFFF,
    0x000FFFFF, 0x0007FFFF, 0x0003FFFF, 0x0001FFFF,
    0x0000FFFF, 0x00007FFF, 0x00003FFF, 0x00001FFF,
    0x00000FFF, 0x000007FF, 0x000003FF, 0x000001FF,
    0x000000FF, 0x0000007F, 0x0000003F, 0x0000001F,
    0x0000000F, 0x00000007, 0x00000003, 0x00000001};

long rightMask[32] =
   {0x80000000, 0xC0000000, 0xE0000000, 0xF0000000,
    0xF8000000, 0xFC000000, 0xFE000000, 0xFF000000,
    0xFF800000, 0xFFC00000, 0xFFE00000, 0xFFF00000,
    0xFFF80000, 0xFFFC0000, 0xFFFE0000, 0xFFFF0000,
    0xFFFF8000, 0xFFFFC000, 0xFFFFE000, 0xFFFFF000,
    0xFFFFF800, 0xFFFFFC00, 0xFFFFFE00, 0xFFFFFF00,
    0xFFFFFF80, 0xFFFFFFC0, 0xFFFFFFE0, 0xFFFFFFF0,
    0xFFFFFFF8, 0xFFFFFFFC, 0xFFFFFFFE, 0xFFFFFFFF};


RectangleIntersections
void RectangleIntersections(
     const Rect inputRects[],
     const long numRectsIn,
     Rect  outputRects[],
     long  *numRectsOut,
     const Boolean oddParity) {

    long* xHeap;
    long* yHeap;
    long* vixelMap;

    long* xIndex;
    long* yIndex;
    long  xIndexMax;
    long  yIndexMax;
    long  xHeapSize;
    long  yHeapSize;

    long  i;
    long  mapWidth;
    long  mapSize;
    Rect* ORptr = outputRects;

//  First, we collect all X and Y coordinate values of
//  all input rectangles in a heap (priority queue), which
//  is then sorted into an index without duplicates for each
//  dimension, using a modified form of Heapsort.

    *numRectsOut=0;
    if (0==(yHeap=(long*)malloc((numRectsIn+3)*sizeof(long)*4)))
      return;
    xHeap=yHeap+(numRectsIn+3)*2;

    *xHeap=*yHeap=MAXLONG;
    xHeapSize=yHeapSize=1;

    for (i=0;i<numRectsIn;i++) {
      Insert(yHeap,yHeapSize,IRT);    yHeapSize++;
      Insert(yHeap,yHeapSize,IRB);    yHeapSize++;
      Insert(xHeap,xHeapSize,IRL);    xHeapSize++;
      Insert(xHeap,xHeapSize,IRR);    xHeapSize++;
    }

    xIndex=Sort(xHeap,xHeapSize);
    xIndexMax=xHeapSize-(xIndex-xHeap);
    yIndex=Sort(yHeap,yHeapSize);
    yIndexMax=yHeapSize-(yIndex-yHeap);

//note: IndexMax indexes to the last entry index[indexMax]
//      in each index list.  index[0] and index[indexMax]
//      are the edges of the enclosing rectangle.

//  Each block of real pixels that is defined by adjacent
//  X and Y edges (from any input rectangle) is considered
//  as a single virtual pixel (“vixel”).  The map of these
//  vixels will then be populated by the input rectangles.
//  Each vixel is represented by a bit in vixelMap.

//  We get memory for the vixel map and clear it to 0.
//  Vixels are stored as bitmaps in 32-bit words.

//  The vixel map is initially organized as either 1 word
//  per 32 vixels (odd parity) or 2 words (even parity).

    mapWidth=(32+xIndexMax) >> 5;
    mapSize=mapWidth*(yIndexMax+1);
    if (0==(vixelMap=
       (long*)malloc(2*mapSize*sizeof(long)))) return;
    if (oddParity) memset(vixelMap,0,mapSize*sizeof(long));
    else memset(vixelMap,0,2*mapSize*sizeof(long));

//  With odd parity, it is only necessary to XOR the vixels
//  of all input rects (PaintOdd).

//  With even parity, we also need to OR all vixels.  This
//  is done in the alternate words of vixelMap (PaintEven);
//  hence the vixelMap is stretched with even parity.

//  Accumulate the enclosed vixels of each input rect:

    for (i=0;i<numRectsIn;i++) {
      long  T,L,B,R,x,y;
      long* vm;
      T=GetIndex(yIndexMax,yIndex,IRT);
      L=GetIndex(xIndexMax,xIndex,IRL);
      B=GetIndex(yIndexMax,yIndex,IRB);
      R=GetIndex(xIndexMax,xIndex,IRR);
      if (oddParity) {
        vm=vixelMap+mapWidth*T+(L>>5);
        PaintOdd(vm,B-T,L,R-1,mapWidth);
      } else {
        vm=vixelMap+2*(mapWidth*T+(L>>5));
        PaintEven(vm,B-T,L,R-1,mapWidth);
      }
    }

//  For even parity, XOR all pairs of words in the vixelMap
//  to pack it into the same format as the odd parity
//  vixelMap.

    if (!oddParity) PackMap(vixelMap,mapSize);

//  Now the vixelMap (the bitmap of all vixels, that is
//  areas of the screen), is set to 1 for every vixel
//  meeting the criteria of either odd or even parity.

//  We scan the vixel map to find contiguous regions of
//  non-zero vixels in order to generate the output
//  rectangles.  For each row, we successively look for
//  blocks of set vixels. This will define one output rect.
//  The X/Y index arrays serve to convert the vixel
//  coordinates back to the real pixel coordinates which
//  define the output rectangles.

  { long word,bit,bb,c,u,L,B;
    long* vm=vixelMap;
    for (i=0;i<yIndexMax;i++) {
      bit=0;
      c=0;
      for (word=0;word<mapWidth;word++) {
        u=vm[word];c=0;
        if (u) {
          long* vmBelow=vm+word+mapWidth;
          bb=0;
          do {
            while (u>0) {bb++;u<<=1;}
            if (c==0) {
              L=bb;
              ORL=xIndex[bit+L]; c--;
            } else {
              long* vmx=vmBelow;
              long mask=~(leftMask[L] & rightMask[bb-1]);
              B=i+1;
//Default: the rectangle is 1 vixel high.
//We try to extend rectangle down as far as possible:
              while (-1==(mask | *vmx)) {
                B++;*vmx &= mask;vmx+=mapWidth;
              }
              ORB=yIndex[B];
              ORR=xIndex[bit+bb];
              ORT=yIndex[i];
              ORptr++;
              c=0;
            }
            if (0==(u=(~u) & rightMask[31-bb])) break;
          } while(bb<32);
          if (c) {
            long* vmx=vmBelow;
            long mask=~leftMask[L];
            B=i+1;
            while (-1==(mask | *vmx)) {
              B++;*vmx &= mask;vmx+=mapWidth;
            }
            ORB=yIndex[B];
            ORR=xIndex[bit+32];
            ORT=yIndex[i];
            ORptr++;
          }
        }
        bit+=32;
      }
      vm+=mapWidth;
    }

  }
  free(yHeap);                  //free allocated memory
  free(vixelMap);
  *numRectsOut=ORptr-outputRects;
}

//////////////////////////////////////////////////////////////////
// Auxiliary functions called by RectangleIntersections: //
/////////////////////////////////////////////////////////////////

Insert
/* Insert grows a heap, that is a partially sorted balanced
   binary tree, where each node’s children must be less or
   equal, but not in any particular order.

   Each value x is inserted by appending it as the last node
   and then sifting it up (exchanging father and child
   nodes) until the heap property is restored.
*/
void Insert(long* h,long size,long x) {
  long i,j,z;
  i=size;
  do {
    j=i>>1;
    if (x<=(z=h[j])) break;
    h[i]=z;
    i=j;
  } while(1);
  h[i]=x;
}

Sort
/* The heap keeps the largest value at the root, at h[1].
   We sort as follows: each root value is removed and put
   at the end of the array;  then the last item in the heap
   is put into the root and sifted down until the heap
   property is restored.
   When we are done, the array is sorted.
   As we go along, we recognize duplicate values and remove
   them but do not put them back.  The result is that the
   start of the sorted list may be further up in the array.
*/
long* Sort(long* h,long size) {
  long  x,z,i,j;
  long* b=h+size+1;
  *b=MAXLONG;
  if (size>1) do {
    size--;
    i=1;
    j=2;
    if (*b != (z=h[1])) *(--b) = z;
    if (size<=1) break;
    x=h[size];
    h[size]=-MAXLONG;
    while (j<size) {
      long h0=h[j],h1=h[1+j];
      if (h0<h1) {j++; h0=h1;}
      if (x>=h0) break;
      h[i]=h0;
      i=j;
      j+=j;
    }
    h[i]=x;
  } while(1);
  return b;
}

GetIndex
/* GetIndex uses a binary search to locate a particular
   entry and returns its index.
*/
long GetIndex(long r,long* index,long z) {
  long l=0,m=r>>1,y;
  do {
    if (z>(y=index[m])) l=m+1;
    else if (z<y)       r=m-1;
    else return m;
    m=(l+r)>>1;
  } while (l<r);
  return r;
}


PaintOdd
/* The PaintOdd and PaintEven routines paint rectangles
   into the vixel map.
   PaintOdd only XORs a single bit map with a rectangle.
   PaintEven also ORs a second bit map with the same
   rectangle.  The 2 bit maps are word interleaved.
   It is hoped that this reduces cache misses by keeping
   to one area of memory for each row of a rectangle.
*/
void  PaintOdd(long* vm,long H,long L,long R,long mapWidth) {
long LM=leftMask[L & 31];
long RM=rightMask[R & 31];
long numMid=(>>R5)-(L>>5)-1;
long x,y,pad=mapWidth-numMid-2;

  if (numMid<0) {LM&=RM;RM=0;}

  for (y=0;y<H;y++) {
    *vm ^= LM; vm++;
    for (x=0;x<numMid;x++) {
      *vm ^= 0xFFFFFFFF; vm++;
    }
    if (RM) {
      *vm ^= RM; vm++;
    }
    vm+=pad;
  }
}

PaintEven 
void  PaintEven (long* vm,long H,long L,long R,long mapWidth) {
long LM=leftMask[L & 31];
long RM=rightMask[R & 31];
long numMid=(>>R5)-(L>>5)-1;
long x,y,pad=(mapWidth-numMid-2)<<1;

  if (numMid<0) {LM&=RM;RM=0;}

  for (y=0;y<H;y++) {
    *vm ^= LM; vm++;
    *vm |= LM; vm++;
    for (x=0;x<numMid;x++) {
      *vm ^= 0xFFFFFFFF; vm++;
      *vm |= 0xFFFFFFFF; vm++;
    }
    if (RM) {
      *vm ^= RM; vm++;
      *vm |= RM; vm++;
    }
    vm+=pad;
  }
}

PackMap
/* PackMap reduces the two interleaved bit maps used for
   the even parity case, into a single bit map.  Each
   pair of words, of the entire bitmap, is XORed together
   regardless of rectangle boundaries.
*/
void PackMap(long* vm,long mapSize) {
long* vmE=vm;
long* endOfMap=vm+mapSize;
  while (vm<endOfMap) {
    *vm++ = *vmE ^ vmE[1];
    vmE+=2;
  }
}

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Navicat Premium Essentials 12.1.25 - Pro...
Navicat Premium Essentials is a compact version of Navicat which provides basic and necessary features you will need to perform simple administration on a database. It supports the latest features... Read more
Sketch 58 - Design app for UX/UI for iOS...
Sketch is an innovative and fresh look at vector drawing. Its intentionally minimalist design is based upon a drawing space of unlimited size and layers, free of palettes, panels, menus, windows, and... Read more
ClipGrab 3.8.5 - Download videos from Yo...
ClipGrab is a free downloader and converter for YouTube, Vimeo, Facebook and many other online video sites. It converts downloaded videos to MPEG4, MP3 or other formats in just one easy step Version... Read more
Dash 4.6.6 - Instant search and offline...
Dash is an API documentation browser and code snippet manager. Dash helps you store snippets of code, as well as instantly search and browse documentation for almost any API you might use (for a full... Read more
FotoMagico 5.6.8 - Powerful slideshow cr...
FotoMagico lets you create professional slideshows from your photos and music with just a few, simple mouse clicks. It sports a very clean and intuitive yet powerful user interface. High image... Read more
Civilization VI 1.2.4 - Next iteration o...
Sid Meier’s Civilization VI is the next entry in the popular Civilization franchise. Originally created by legendary game designer Sid Meier, Civilization is a strategy game in which you attempt to... Read more
Skype 8.52.0.138 - Voice-over-internet p...
Skype allows you to talk to friends, family and co-workers across the Internet without the inconvenience of long distance telephone charges. Using peer-to-peer data transmission technology, Skype... Read more
Bookends 13.2.6 - Reference management a...
Bookends is a full-featured bibliography/reference and information-management system for students and professionals. Bookends uses the cloud to sync reference libraries on all the Macs you use.... Read more
BusyContacts 1.4.0 - 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
Chromium 77.0.3865.75 - Fast and stable...
Chromium is an open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. Version 77.0.3865.75: A list of changes is available... Read more

Latest Forum Discussions

See All

Yoozoo Games launches Saint Seiya Awaken...
If you’re into your anime, you’ve probably seen or heard of Saint Seiya. Based on a shonen manga by Masami Kurumada, the series was massively popular in the 1980s – especially in its native Japan. Since then, it’s grown into a franchise of all... | Read more »
Five Nights at Freddy's AR: Special...
Five Nights at Freddy's AR: Special Delivery is a terrifying new nightmare from developer Illumix. Last week, FNAF fans were sent into a frenzy by a short teaser for what we now know to be Special Delivery. Those in the comments were quick to... | Read more »
Rush Rally 3's new live events are...
Last week, Rush Rally 3 got updated with live events, and it’s one of the best things to happen to racing games on mobile. Prior to this update, the game already had multiplayer, but live events are more convenient in the sense that it’s somewhat... | Read more »
Why your free-to-play racer sucks
It’s been this way for a while now, but playing Hot Wheels Infinite Loop really highlights a big issue with free-to-play mobile racing games: They suck. It doesn’t matter if you’re trying going for realism, cart racing, or arcade nonsense, they’re... | Read more »
Steam Link Spotlight - The Banner Saga 3
Steam Link Spotlight is a new feature where we take a look at PC games that play exceptionally well using the Steam Link app. Our last entry talked about Terry Cavanaugh’s incredible Dicey Dungeons. Read about how it’s a great mobile experience... | Read more »
PSA: GRIS has some issues
You may or may not have seen that Devolver Digital just released GRIS on the App Store, but we wanted to do a quick public service announcement to say that you might not want to hop on buying it just yet. The puzzle platformer has come to small... | Read more »
Combo Quest (Games)
Combo Quest 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: Combo Quest is an epic, time tap role-playing adventure. In this unique masterpiece, you are a knight on a heroic quest to retrieve... | Read more »
Hero Emblems (Games)
Hero Emblems 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: ** 25% OFF for a limited time to celebrate the release ** ** Note for iPhone 6 user: If it doesn't run fullscreen on your device... | Read more »
Puzzle Blitz (Games)
Puzzle Blitz 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: Puzzle Blitz is a frantic puzzle solving race against the clock! Solve as many puzzles as you can, before time runs out! You have... | Read more »
Sky Patrol (Games)
Sky Patrol 1.0.1 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0.1 (iTunes) Description: 'Strategic Twist On The Classic Shooter Genre' - Indie Game Mag... | Read more »

Price Scanner via MacPrices.net

Preorder your Apple Watch Series 5 today at A...
Amazon has Apple Watch Series 5 GPS models available for preorder and on sale today for $15 off Apple’s MSRP. Shipping is free and starts on September 20th: – 40mm Apple Watch Series 5 GPS: $384.99 $... Read more
21″ iMacs on sale for $100 off Apple’s MSRP,...
B&H Photo has new 21″ Apple iMacs on sale for $100 off MSRP with models available starting at $999. These are the same iMacs offered by Apple in their retail and online stores. Overnight shipping... Read more
2018 4 and 6-Core Mac minis on sale today for...
Apple resellers are offering new 2018 4-Core and 6-Core Mac minis for $100-$150 off MSRP for a limited time. B&H Photo has the new 2018 4-Core and 6-Core Mac minis on sale for up to $150 off... Read more
Save $150-$250 on 10.2″ WiFi + Cellular iPads...
Verizon is offering $150-$250 discounts on Apple’s new 10.2″ WiFi + Cellular iPad with service. Buy the iPad itself and save $150. Save $250 on the purchase of an iPad along with an iPhone. The fine... Read more
Apple continues to offer 13″ 2.3GHz Dual-Core...
Apple has Certified Refurbished 2017 13″ 2.3GHz Dual-Core non-Touch Bar MacBook Pros available starting at $1019. An standard Apple one-year warranty is included with each model, outer cases are new... Read more
Apple restocks 2018 MacBook Airs, Certified R...
Apple has restocked Certified Refurbished 2018 13″ MacBook Airs starting at only $849. Each MacBook features a new outer case, comes with a standard Apple one-year warranty, and is shipped free. The... Read more
Sunday Sale! 2019 27″ 5K 6-Core iMacs for $20...
B&H Photo has the new 2019 27″ 5K 6-Core iMacs on stock today and on sale for up to $250 off Apple’s MSRP. Overnight shipping is free to many locations in the US. These are the same iMacs sold by... Read more
Weekend Sale! 2019 13″ MacBook Airs for $200...
Amazon has new 2019 13″ MacBook Airs on sale for $200 off Apple’s MSRP, with prices starting at $899, each including free shipping. Be sure to select Amazon as the seller during checkout, rather than... Read more
2019 15″ MacBook Pros now on sale for $350-$4...
B&H Photo has Apple’s 2019 15″ 6-Core and 8-Core MacBook Pros on sale today for $350-$400 off MSRP, starting at $2049, with free overnight shipping available to many addresses in the US: – 2019... Read more
Buy one Apple Watch Series 5 at Verizon, get...
Buy one Apple Watch Series 5 at Verizon, and get a second Watch for 50% off. Plus save $10 on your first month of service. The fine print: “Buy Apple Watch, get another up to 50% off on us. Plus $10... Read more

Jobs Board

*Apple* Mobility Pro-Store 149 - Best Buy (U...
**731985BR** **Job Title:** Apple Mobility Pro-Store 149 **Job Category:** Store Associates **Location Number:** 000149-Towson-Store **Job Description:** At Best Read more
Student Employment (Blue *Apple* Cafe) Spri...
Student Employment (Blue Apple Cafe) Spring 2019 Penn State University Campus/Location: Penn State Brandywine Campus City: Media, PA Date Announced: 12/20/2018 Date Read more
Windows/ *Apple* Technical Support Engineer...
Windows/ Apple Technical Support Engineer McLean , VA , US Apply + Be you + Be Booz Allen + Be empowered + Learn More Job Description Location: McLean, VA, US Job Read more
*Apple* Mobile Master - Best Buy (United Sta...
**725617BR** **Job Title:** Apple Mobile Master **Job Category:** Store Associates **Location Number:** 001095-Chesterfield-Store **Job Description:** **What does a Read more
Geek Squad *Apple* Master Consultation Agen...
**732415BR** **Job Title:** Geek Squad Apple Master Consultation Agent **Job Category:** Services/Installation/Repair **Location Number:** 000425-Hickory-Store **Job Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.