TweetFollow Us on Twitter

Jan 95 Challenge
Volume Number:11
Issue Number:1
Column Tag:Programmer’s Challenge

Programmer’s Challenge

By Mike Scanlin, Mountain View, CA

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

Poker Hand Evaluator

This month’s challenge was suggested by Chris Derossi (Mountain View, CA). The goal is to compare two poker hands and determine which is higher. Your routine will be given two hands of 7 cards each. It will have to make the best 5 card hand it can from each and return the two 5-card hands as well as which is higher.

Here is how poker hands rank (from lowest to highest, with an example of each in parentheses):

one pair (5, 5, *, *, *)

two pair (5, 5, 8, 8, *)

three of a kind (5, 5, 5, *, *)

straight (5, 6, 7, 8, 9)

flush (club, club, club, club, club)

full house (5, 5, 5, 8, 8)

four of a kind (5, 5, 5, 5, *)

straight flush (5, 6, 7, 8, 9; all clubs)

five of a kind (5, 5, 5, 5, wildCard)

The prototype of the function you write is:

typedef unsigned char Card;

typedef SevenCardHand {
 Card cards[7];
} SevenCardHand;

typedef FiveCardHand {
 Card cards[5];
} FiveCardHand;

ComparePokerHands(hand1Ptr, hand2Ptr,
 best1Ptr, best2Ptr, 
 wildCardAllowed, wildCard, 
SevenCardHand  *hand1Ptr;
SevenCardHand  *hand2Ptr;
Boolean  wildCardAllowed;
Card     wildCard;
Boolean  straightsAndFlushesValid;
void    *privateDataPtr;

A Card is a byte value (unsigned char) from 0 to 51 where 0 represents the 2 of clubs, 9 is the jack of clubs, 12 is the ace of clubs, 13 is the 2 of diamonds, 26 is the 2 of hearts, 39 is the 2 of spades and 51 is the ace of spades.

The inputs are two SevenCardHands (from the same deck; you won’t get duplicate Cards). Your routine should make the highest hand possible with 5 of the 7 cards and store the resulting hand in the two FiveCardHands. It should then return one of the following values: -1 if hand 1 is higher than hand 2, 0 if the hands are tied and 1 if hand 2 is higher than hand 1. Hands can be tied because suit counts for nothing when ranking hands. Aces can be high or low (whichever makes the resulting hand better).

WildCardAllowed is true if wild cards are allowed and false if not. If they are allowed then wildCard will be the card that is wild, from 0 to 12. All suits of that care are wild. For example, if wildCard is 4 then all 6’s are wild (Card values 4, 17, 30 and 43).

StraightsAndFlushesValid is true if straights and flushes are to be counted in the ranking. If it is false then straights and flushes do not count for anything (they are low hands).

PrivateDataPtr is the value returned by your Init routine, which is not timed, whose prototype is:

void *
ComparePokerHandsInit(wildCardAllowed, wildCard,
Boolean wildCardAllowed;
Card    wildCard;
Boolean straightsAndFlushesValid;

You can allocate up to 1MB of memory in your Init routine (in case you want to generate some lookup tables). The pointer you return will be passed to your ComparePokerHands routine.

E-mail me if you have any questions. Have fun.

Two Months Ago Winner

I had to disqualify two of the eight entries I received for the Huffman Decoding challenge because of incorrect results. Congratulations to Challenge Champion Bob Boonstra (Westford, MA) for earning his fifth win. The top four entrants each optimized their solutions for those cases where there was extra memory available. Greg McKaskle (Austin, TX) had a very strong showing for the extra memory case but his very-little-extra-memory case code came in 3rd place, preventing him from winning overall.

Here are the times and code sizes for each entry. Numbers in parens after a person’s name indicate how many times that person has finished in the top 5 places of all previous Programmer Challenges, not including this one:

Name 256K time8K time  code
Bob Boonstra (12)12422308
Greg McKaskle    11113    2012
John Schlack (1) 28551470
Wolfgang Thaller (age 13) 40929    1090
Allen Stenger (7)103 103  440
Peter Hance 1211 1211188

From reading the winning code you may notice that even a master such as Bob has picked up at least one trick from studying previous Challenge winners. He chose to borrow the ‘switch-do-while’ idea from Bill Karsh’s SwapBytes entry (a neat trick, indeed). Glad to see it. After all, this column is meant to be educational (by teaching tricks by example) as much as it is a contest.

I’ve been getting more requests than usual to have access to the current Challenge before the magazine hits the streets (especially from people outside the US). Well, this being the 90’s and all, the latest Challenge is available on-line the day the magazines go out in the mail. Check out p. 2 for where to look on each of the online services.

Hope that helps. Here is Bob’s winning solution:


Copyright (c) 1994  J Robert Boonstra

Problem Statement

Given a symbol table, decompress the Huffman encoded input stream and return the number of decompressed bytes.

Solution Strategy

Use the untimed initialization routine to create a tree structure corresponding to the sym values in the symbol table. In the timed decode routine, traverse the tree. When a leaf node is encountered, output the corresponding value, and begin traversing the tree again from the root.

We determine whether there is enough storage for the tree structure by trying to construct it. If there is not enough storage, set up a simple table of pointers into the symbol table based on symbol length. This is not especially efficient, but it produce correct results.

#pragma options(honor_register,!assign_registers)

#define ulong  unsigned long
#define ushort unsigned short
#define uchar  unsigned char

 * SymElem is the data structure provided in the problem
 * definition.  Symbols are sorted by symLength and within
 * length by sym.
typedef struct SymElem {
  unsigned short symLength;
  unsigned short sym;
  unsigned short value;
} SymElem, *SymElemPtr;

 * DecodeNode is a node in the tree used to decode the 
 * input stream.  The zeroP and oneP values are offsets
 * into the tree corresponding to reading a 0 or a 1 given
 * the prior input.  Note that the zeroP field is used at a
 * leaf node (identified by a zero in the oneP field) to 
 * represent the SymElem value.  The offsets are stored
 * relative to the current tree position for efficiency
 * in calculating the address.  Note also that 16 bits are 
 * enough to access the max available 256K (64K nodes of 
 * 4 bytes each).  In cases where only 64K storage is used,
 * the offsets are premultiplied by sizeof(DecodeNode) to
 * squeeze out a little additional efficiency at some small
 * expense in code size.
typedef struct DecodeNode {   
    ushort zeroP;   /* index of right tree node, or value */ 
    ushort oneP;    /* index of left tree node            */ 
} DecodeNode; 

typedef struct SymDecode {
        SymElemPtr symP;
        ushort numEntries;
        ushort align;
} SymDecode;


void *HuffmanDecodeInit(SymElemPtr theSymTable,
  unsigned short numSymElems,
  unsigned long maxMemoryUsage);

unsigned long HuffmanDecode(SymElemPtr theSymTable,
  unsigned short numSymElems, char *bitsPtr,
  unsigned long numBits, unsigned short *outputPtr,
  void * privateHuffDataPtr);
#define kUnused (ushort)0xFFFF
#define kTerminalNode 0
#define InitializeNewNode()                                \
{                                                          \
    if ((void *)pFree > (void *)pMax)                      \
      goto notEnoughStorage;                               \
    pFree->oneP = kUnused;                                 \
    pFree->zeroP = kUnused;                                \

#define kGMode 0
#define kSEP 4
#define kGlobalStorageSize (kSEP+16*sizeof(SymDecode))

#define gMode *(short *)((char *)privateHuffDataPtr+kGMode)


void *HuffmanDecodeInit(SymElemPtr theSymTable,
  unsigned short numSymElems,
  unsigned long maxMemoryUsage)
register DecodeNode *p;
register DecodeNode *pOrig;
register DecodeNode *pFree;
register ulong pMax;
register ushort i;
register ulong nodeNum=1;
SymDecode *theSymElemPtr;
SymElemPtr sP;
void *privateHuffDataPtr;
ulong count;
ushort sym,maxLng,maxDiff=0;

 * Allocate entire memory allocation, return if allocation
 * fails.
  if (0 == (p=privateHuffDataPtr = NewPtr(maxMemoryUsage)))
     return 0;
  gMode = 0;

 * Initialize SymElem pointers
  theSymElemPtr = (SymDecode *)((char *)privateHuffDataPtr +
  sP = theSymTable;
  count = 0;
  sym = theSymTable->sym;
  for (i=1; i<=16; ++i) {
    ushort oldCount;
    oldCount = count;
    theSymElemPtr->symP = sP;
    while ((sP->symLength==i) && (count<numSymElems))
      { ++count;  ++sP; }
    theSymElemPtr++->numEntries = count-oldCount;

 * Initialize tree pointers.
  p = (DecodeNode *)(kGlobalStorageSize + 
                                (char *)privateHuffDataPtr);
  pOrig = pFree = p;
  pMax = (ulong)((char *)p + maxMemoryUsage -
                (kGlobalStorageSize + sizeof(DecodeNode)) );

 * Initialize root of tree.

 * Loop over symbol table elements.
 * Insert each symbol into the tree.
 * Tree is traversed by following the zeroP/oneP indices 
 * corresponding to the bits of the sym field in the symbol
 * table, from most significant to least significant bit.
 * Leaves of the tree are indicated by oneP==kTerminalNode.
 * The zeroP field of leaf nodes contains the decompressed 
 * output for the bit sequence that led to the leaf when 
 * the oneP field is kTerminalNode.
  for (i=0; i<numSymElems; ++i) {
    SymElemPtr sP;
    register short sym;
    ushort value;
    register ushort symLength;
    sP = theSymTable+i;
    sym = sP->sym;
    value = sP->value;
    symLength = sP->symLength;
    p = pOrig;

 * Loop over bits in the sym field.
    sym <<= (16-symLength);
    do {
      if (0 > sym ) {
 * Process a 1, allocate a new node if one is needed.
        if (kUnused == p->oneP) { 
          p->oneP = (pFree-p);
          if (p->oneP > maxDiff) maxDiff = p->oneP;
          p = pFree++;
        } else {
          p += p->oneP;
      } else {
 * Process a 0, allocate a new node if one is needed.
 * Note that since we reuse the zeroP field later to contain
 * the value to be output, this code depends on having a
 * correct (i.e. deterministic) Huffman encoding in
 * theSymTable, and will crash spectacularly otherwise.
        if (kUnused == p->zeroP) {
          p->zeroP = (pFree-p);
          if (p->zeroP > maxDiff) maxDiff = p->zeroP;
          p = pFree++;
        } else {
          p += p->zeroP;
      sym <<= 1;
    } while (--symLength);

 * Insert value into leaf node.
    p->zeroP = value;
    p->oneP = kTerminalNode;
    maxLng = sP->symLength;

 * Premultiply offsets by node size for "fast" mode.
  if ( (1<<14)-1 > maxDiff  ) {
    gMode = 1;
    p = pFree;
    do {
      if (p->oneP != kTerminalNode) {
        if (p->zeroP != kUnused)
          p->zeroP *= sizeof(DecodeNode);
        if (p->oneP != kUnused)
          p->oneP *= sizeof(DecodeNode);
    } while (p>pOrig);
  goto done;

 * If we do not have enough storage for the tree, fall back
 * on a slower technique requiring less storage.
  gMode = 2;
  return privateHuffDataPtr;

macro ProcessBit

#define ProcessBit(mask,bitNum)                            \
{ register ulong temp;                                     \
  if (!(theChar & mask)) temp = tP->zeroP;                 \
  else                   temp = oneP;                      \
  temp *= sizeof(DecodeNode);                              \
  t += temp;                                               \
  if (kTerminalNode == (oneP = tP->oneP))  {               \
    *outP++ =  tP->zeroP;                                  \
    t = (char *)decode_tree;                               \
    oneP = tP->oneP;                                       \
  }                                                        \

macro ProcessBitFast

#define ProcessBitFast(mask,bitNum)                        \
{ register ulong temp;                                     \
  if (!(theChar & mask)) temp = tP->zeroP;                 \
  else                   temp = oneP;                      \
  t += temp;                                               \
  if (kTerminalNode == (oneP = tP->oneP))  {               \
    *outP++ =  tP->zeroP;                                  \
    t = (char *)decode_tree;                               \
    oneP = tP->oneP;                                       \
  }                                                        \

macro ProcessBitSlow

#define ProcessBitSlow(mask,bitNum,keepMask,next)          \
{ register ushort temp;                                    \
  if (!(theChar & mask)) temp = tP->zeroP;                 \
  else                   temp = oneP;                      \
  if (temp != kUnused) {                                   \
    temp *= sizeof(DecodeNode);                            \
    t += temp;                                             \
    if (kTerminalNode == (oneP = tP->oneP))  {             \
      *outP++ =  tP->zeroP;                                \
      t = (char *)decode_tree;                             \
      oneP = tP->oneP;                                     \
      theSym=0;  theSymLng=0;                              \
      theChar &= keepMask;                                 \
      bitStart = bitNum-1;                                 \
      next;                                                \
    }                                                      \
  } else {                                                 \
    theBitNum = bitNum;                                    \
    goto overflow;                                         \
  }                                                        \


unsigned long HuffmanDecode(SymElemPtr theSymTable,
  unsigned short numSymElems, char *bitsPtr,
  unsigned long numBits, unsigned short *outputPtr,
  void * privateHuffDataPtr)
register char *bitsP = bitsPtr;
register ushort *outP = outputPtr;
register char *t = (char *)privateHuffDataPtr + 
#define tP ((DecodeNode *)t)

register uchar theChar; 
register ushort oneP;
register ulong count; 
ushort state;
  oneP = ((DecodeNode *)t)[0].oneP;
  state = 0;
 * Set up loop count to loop over complete input bytes, and
 * jump past the switch statement into the loop.
 * The billKarsh-inspired switch--do subterfuge allows us  
 * to optimize the main loop and still reuse code for the 
 * leftover bits at the end.
  count = numBits>>3;
 * Select case.
    register ushort mode;
    if (0 == (mode = *(ushort *)(t - kGlobalStorageSize)) )
      goto start;
    if (1 == mode) goto startFast;
    goto slowest;

 * CASE 0
 * This section processes the case where the decode tree
 * fit into available memory, but the offsets are in units
 * of sizeof(long).
 * We jump to doLeftOverBits at the end to pick up the last byte.
  state = 1;
  count = 1;                  /* Only one byte to process */
  theChar =  *bitsP;          /* Fetch last byte */
  theChar>>=(8-numBits);      /* Shift bits into position */
  switch (numBits) {
    register ulong decode_tree;
    decode_tree = (ulong)t;
    do { 
 * Loop over the bytes in the input stream, decoding as
 * we go.  Rather than loop over the bits in each byte,
 * the bit loop is unrolled for efficiency.
        theChar =  *bitsP++;  /* get input byte */ 
case 0: ProcessBit(0x80,8);     /* process 0th bit */
case 7: ProcessBit(0x40,7);     /* process 1st bit */ 
case 6: ProcessBit(0x20,6);     /* process 2nd bit */ 
case 5: ProcessBit(0x10,5);     /* process 3rd bit */ 
case 4: ProcessBit(0x08,4);     /* process 4th bit */ 
case 3: ProcessBit(0x04,3);     /* process 5th bit */ 
case 2: ProcessBit(0x02,2);     /* process 6th bit */ 
case 1: ProcessBit(0x01,1);     /* process 7th bit */ 
    } while (--count);
 * Make another pass to process the bits in the last byte.
  if (state==0) {
    if (numBits &= 7) goto doLeftOverBits;
  goto done;

 * CASE 1
 * This section processes the case where the decode tree
 * fit into available memory, but the offsets are in units
 * of bytes.
 * We jump to doLeftOverBitsFast at the end to pick up the 
 * last byte.
  state = 1;
  count = 1;                  /* Only one byte to process */
  theChar =  *bitsP;          /* Fetch last byte */
  theChar>>=(8-numBits);      /* Shift bits into position */
  switch (numBits) {
    register ulong decode_tree;
    decode_tree = (ulong)t;
    do { 
 * Loop over the bytes in the input stream, decoding as
 * we go.  Rather than loop over the bits in each byte,
 * the bit loop is unrolled for efficiency.
        theChar =  *bitsP++;  /* get input byte */ 
case 0: ProcessBitFast(0x80,8); /* process 0th bit */
case 7: ProcessBitFast(0x40,7); /* process 1st bit */ 
case 6: ProcessBitFast(0x20,6); /* process 2nd bit */ 
case 5: ProcessBitFast(0x10,5); /* process 3rd bit */ 
case 4: ProcessBitFast(0x08,4); /* process 4th bit */ 
case 3: ProcessBitFast(0x04,3); /* process 5th bit */ 
case 2: ProcessBitFast(0x02,2); /* process 6th bit */ 
case 1: ProcessBitFast(0x01,1); /* process 7th bit */ 
    } while (--count);
 * Make another pass to process the bits in the last byte.
  if (state==0) {
    if (numBits &= 7) goto doLeftOverBitsFast;
  goto done;

 * CASE 2
 *   This code handles the case where the entire decode
 *   tree did not fit into the private storage.  In this
 *   case we use the portion of the tree that did fit, but
 *   we may have to linearly search the SymTable for the
 *   longer symbols.
  SymDecode *theSymElemPtr;
  SymElemPtr sP;
  short bitStart,theSymLng,theMask,theBitNum,saveCount,x;
  register ushort theSym;
  theSymLng = 0;
  theSym = 0;
  goto startSlow;
  state = 1;
  count = 1;                /* Only one byte to process */
  theChar =  *bitsP;        /* Fetch last byte */
  theChar>>=(8-numBits);    /* Shift bits into position */
  switch (numBits) {
    ulong decode_tree;
    decode_tree = (ulong)t;
    do { 
      theChar =  *bitsP++;  /* get input byte */ 
      bitStart = 8;
slow0:                                /* process 0th bit */
case 0: ProcessBitSlow(0x80,8,0x7F,);
slow7:                                /* process 1st bit */
case 7: ProcessBitSlow(0x40,7,0x3F,);
slow6:                                /* process 2nd bit */
case 6: ProcessBitSlow(0x20,6,0x1F,);
slow5:                                /* process 3rd bit */
case 5: ProcessBitSlow(0x10,5,0x0F,); 
slow4:                                /* process 4th bit */
case 4: ProcessBitSlow(0x08,4,0x07,);
slow3:                                /* process 5th bit */
case 3: ProcessBitSlow(0x04,3,0x03,);
slow2:                                /* process 6th bit */
case 2: ProcessBitSlow(0x02,2,0x01,); 
slow1:                                /* process 7th bit */
case 1: ProcessBitSlow(0x01,1,0x00,continue);  

      theSym <<= bitStart;
      theSym |= theChar;
      theSymLng += bitStart;
      continue; /* continue with next char */
      theSym <<= bitStart-theBitNum;
      theSym |= (theChar>>theBitNum);
      theSymLng += bitStart-theBitNum;                               
      theMask = 1<<(theBitNum-1);
      theChar &= (1<<theBitNum)-1;
      bitStart = theBitNum;

      /* search SymTab for theSym */
      saveCount = count;
      theSymElemPtr = (SymDecode *)
                        ((char *)privateHuffDataPtr + kSEP);
      theSymElemPtr += theSymLng-1;
      sP = theSymElemPtr->symP;
      count = theSymElemPtr->numEntries;
      if (count) do {
        if (sP->sym < theSym) goto nextSP;
        if (sP->sym > theSym) goto noSym;
        *outP++ = sP->value;
        if (state != 0) goto done;
        theSymLng = 0;
        theSym = 0;
        theChar &= ((1<<theBitNum)-1);
        bitStart = theBitNum;
        count = saveCount;
        t = (char *)decode_tree;
        oneP = tP->oneP;
next:   switch (theBitNum) {
        case 8:
        case 0:  count = saveCount;
                 goto nextChar0;
        case 1:  goto slow1;
        case 2:  goto slow2;
        case 3:  goto slow3;
        case 4:  goto slow4;
        case 5:  goto slow5;
        case 6:  goto slow6;
        case 7:  goto slow7;
nextSP: ++sP;
        } /* end switch */
      } while (--count);
noSym:if (0 == theBitNum) {
        if (0==--saveCount) {
          if (state!=0) goto done;
          theChar = *bitsP;
          count = 1;
          theBitNum = 8;  theMask = 0x80;
        } else {
          theChar =  *bitsP++;  /* get input byte */ 
          theBitNum = 8;  theMask = 0x80;
      if (theChar&theMask) theSym|=1;
      goto search;
      theSym <<= 8;
      theSym |= theChar;
      theSymLng += 8;
nextChar0: ;
    } while (--count);
    if ((state==0) && (numBits &= 7)) 
      goto doLeftOverBitsSlow;
    return (char *)outP-(char *)outputPtr;  


Community Search:
MacTech Search:

Software Updates via MacUpdate

MacCleanse 9.0 - $29.95
MacCleanse is the product of thousands of hours of intense research and development. It meticulously scans all of the nooks and crannies of a computer for unnecessary junk that can take up huge... Read more
MacPilot 12.0 - $15.96
MacPilot gives you the power of UNIX and the simplicity of Macintosh, which means a phenomenal amount of untapped power in your hands! Use MacPilot to unlock over 1,200 features, and access them all... Read more
NetNewsWire 5.1 - RSS and Atom news read...
NetNewsWire is the best way to keep up with the sites and authors you read most regularly. Let NetNewsWire pull down the latest articles, and read them in a distraction-free and Mac-like way. Native... Read more
FontExplorer X Pro 7.1.3 - Font manageme...
FontExplorer X Pro is optimized for professional use; it's the solution that gives you the power you need to manage all your fonts. Now you can more easily manage, activate and organize your... Read more
DiskCatalogMaker 8.2.5 - Catalog your di...
DiskCatalogMaker is a simple disk management tool which catalogs disks. Simple, light-weight, and fast Finder-like intuitive look and feel Super-fast search algorithm Can compress catalog data for... Read more
Skim 1.5.12 - PDF reader and note-taker...
Skim is a PDF reader and note-taker for OS X. It is designed to help you read and annotate scientific papers in PDF, but is also great for viewing any PDF file. Skim includes many features and has a... Read more
rekordbox - Professional DJ m...
rekordbox is the best way of preparing and managing your tracks, be it at home, in the studio, or even on the plane! It allows you to import music from other music-management software using the... Read more
iExplorer 4.4.0 - View and transfer file...
iExplorer is an iPhone browser for Mac lets you view the files on your iOS device. By using a drag and drop interface, you can quickly copy files and folders between your Mac and your iPhone or... Read more
OmniGraffle 7.17.5 - Create diagrams, fl...
OmniGraffle helps you draw beautiful diagrams, family trees, flow charts, org charts, layouts, and (mathematically speaking) any other directed or non-directed graphs. We've had people use Graffle to... Read more
Apple Configurator 2.13.1 - Configure an...
Apple Configurator makes it easy to deploy iPad, iPhone, iPod touch, and Apple TV devices in your school or business. Use Apple Configurator to quickly configure large numbers of devices connected to... Read more

Latest Forum Discussions

See All

Raziel: Dungeon Arena is a hack 'n...
Raziel: Dungeon Arena is available now on mobile and will appeal to fans of both comic books and old school dungeon crawlers. Not only will you hack 'n' slash your way through mobs of enemies but there's also fully-narrated animated comic to enjoy... | Read more »
Steam Link Spotlight - Hades
Steam Link Spotlight is a feature where we look at PC games that play exceptionally well using the Steam Link app. Our last entry was on Disco Elysium. Read about how it plays using Steam Link over here. | Read more »
Microsoft has acquired ZeniMax Media and...
In the latest of a series of blockbuster moves, Microsoft has now acquired Zenimax Media and its subsidiary, Bethesda Softworks, for $7.5 billion. [Read more] | Read more »
Infinity Mechs is an upcoming idle game...
Indie developer SkullStar studio has announced an upcoming idle mech game called Infinity Mechs. It draws inspiration from the mobile game Iron Saga and has been officially licensed by Game Duchy. It's set to launch for both iOS and Android on... | Read more »
PUBG Mobile Lite's latest update se...
PUBG Mobile Lite, the streamlined version of the popular battle royale that's designed to work on less powerful devices, sees the return of a popular game variant today, Survive Till Dawn mode. It arrives as part of the 0.19.0 content update. [... | Read more »
Matchy Catch, Jyamma Games’ new hyper-ca...
Matchy Catch is a new hyper-casual puzzler from Jyamma Games, the Italian studio behind the Pong-inspired puzzle-adventure Hi-Ball Rush. It’s only the developer’s second game for iOS and Android devices, but it promises to be every bit as fun and... | Read more »
Among Us! Imposter Guide - How to be a s...
Among Us! continues to be getting a lot of play in these parts, and since our first guide we've learned a thing or two about the game. This is especially true regarding the imposter role, as its a relatively rare opportunity that we've now put... | Read more »
Paladin's Story is an upcoming fant...
Paladin's Story is an upcoming fantasy RPG with an off-kilter sense of humour that's heading for iOS and Android. It will officially launch for both on September 16th though the game is already available on Google Play in Early Access. [Read more... | Read more »
Among Us! Guide - Tips for the uninitiat...
| Read more »
A Pretty Odd Bunny is a stealth-platform...
A Pretty Odd Bunny is a stealth-platformer from two-man team AJ Ordaz and René Rivera. It follows the story of a red-eyed rabbit who is allergic to carrots and instead has a penchant for devouring pigs. It's available now for Android devices. [... | Read more »

Price Scanner via

The cheapest Macs are back in stock today at...
Apple has restocked clearance, previous-generation, Certified Refurbished Mac minis starting at only $599. Each mini comes with free shipping plus Apple’s standard one-year warranty. These are the... Read more
Sale! Amazon has 2020 13″ 2.0GHz MacBook Pros...
Amazon has 2020 13″ MacBook Pros with 10th generation Intel CPUs back in stock on sale again today for $150-$200 off Apple’s MSRP. Shipping is free. Be sure to purchase the MacBook Pro from Amazon,... Read more
Base 13″ 1.4GHz Apple MacBook Pros on sale fo...
Apple reseller Expercom is offering a $65-$75 discount on new 2020 13″ 1.4GHz MacBook Pros, depending on configuration. Shipping is free. Expercom estimates shipping in 3-5 days, as stock of Apple’s... Read more
Price drop! Get a 44mm Apple Watch Series 5 G...
Amazon has dropped their price on the 44mm Apple Watch Series 5 GPS + Cellular by $100 to $429 shipped. That’s $100 off Apple’s original MSRP for this model. For the latest prices and sales, see our... Read more
Verizon offers $200 discount on new Apple Wat...
Verizon will take up to $200 off the purchase of a new GPS + Cellular Apple Watch Series 6 or Apple Watch SE with select trade-in and the purchase of a new iPhone with service. The fine print: “Get... Read more
Verizon offers $250 discount on new 8th gener...
Verizon will take up to $250 off the price of an 8th generation 2020 Apple Cellular iPad with select trade-ins and a new iPhone purchase. Plus get Apple News+ free for 6 months. The fine print: “Save... Read more
Apple’s Implementation Of COVID-19 Exposure...
NEWS: 09.18.20 – The latest effort by Apple to embed exposure notifications for COVID-19 contact tracing right into its mobile operating system has some iPhone users weary of being exposed to... Read more
Here’s how to get a 16″ MacBook Pro for $300...
B&H Photo has new 16″ MacBook Pros on sale today for $250-$300 off Apple’s MSRP, starting at $2099. Expedited shipping is free to many addresses in the US: – 2019 16″ 2.6GHz 6-Core MacBook Pro... Read more
Apple has Certified Refurbished 16″ MacBook P...
Apple has Certified Refurbished 2019 16″ MacBook Pros available for up to $420 off the cost of new models, starting at $2039. Each model features a new outer case, shipping is free, and an Apple 1-... Read more
Price drops! Apple reseller B&H drops App...
B&H Photo has dropped prices on Apple Watch Series 5 models by $50-$70 off Apple’s original MSRP. Shipping is free. These are the same Apple Watch models sold by Apple in their retail and online... Read more

Jobs Board

Security Officer ($23.00/Hourly) - *Apple*...
**Security Officer \($23\.00/Hourly\) \- Apple Store** **Description** About NMS Built on a culture of safety and integrity, NMSdelivers award\-winning, integrated Read more
Security Officer ($23.00/Hourly) - *Apple*...
**Security Officer \($23\.00/Hourly\) \- Apple Store** **Description** About NMS Built on a culture of safety and integrity, NMSdelivers award\-winning, integrated Read more
Platform - Workplace Eng - *Apple* Enterpri...
MORE ABOUT THIS JOB We are looking for an Apple Platform Engineer who will bring a unique engineering skill set, support, clarity, organization and above all else, Read more
*Apple* Certified Repair Technician - Utah S...
…selected candidate will work in the USU Campus Store Tech Department as an Apple Certified Repair Technician and floor associate. This position is for both summer Read more
Senior Data Engineer - *Apple* - Theorem, L...
Job Summary Apple is seeking an experienced, detail-minded data engineeringconsultant to join our worldwide business development and strategy team. If you are Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.