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

LibreOffice - Free, open-source...
LibreOffice is an office suite (word processor, spreadsheet, presentations, drawing tool) compatible with other major office suites. The Document Foundation is coordinating development and... Read more
Thunderbird 68.10.0 - Email client from...
As of July 2012, Thunderbird has transitioned to a new governance model, with new features being developed by the broader free software and open source community, and security fixes and improvements... Read more
Firefox 78.0.1 - Fast, safe Web browser.
Firefox offers a fast, safe Web browsing experience. Browse quickly, securely, and effortlessly. With its industry-leading features, Firefox is the choice of Web development professionals and casual... Read more
BetterTouchTool 3.389 - 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
Slack 4.7.0 - Collaborative communicatio...
Slack brings team communication and collaboration into one place so you can get more work done, whether you belong to a large enterprise or a small business. Check off your to-do list and move your... Read more
OsiriX Lite 11.0.3 - 3D medical image pr...
OsiriX Lite is an image processing software dedicated to DICOM images (".dcm" / ".DCM" extension) produced by medical equipment (MRI, CT, PET, PET-CT, ...) and confocal microscopy (LSM and BioRAD-PIC... Read more
Wireshark 3.2.5 - Network protocol analy...
Wireshark is one of the world's foremost network protocol analyzers, and is the standard in many parts of the industry. It is the continuation of a project that started in 1998. Hundreds of... Read more
Dabble 1.6.1 - Organize your manuscript,...
Dabble organizes your manuscript, story notes, and plot. Dabble simplifies the story, leaving more room in your brain to create, which is what being a writer is really about. Organize your story.... Read more
Quicken 5.17.0 - Complete personal finan...
Quicken makes managing your money easier than ever. Whether paying bills, upgrading from Windows, enjoying more reliable downloads, or getting expert product help, Quicken's new and improved features... Read more
Tor Browser 9.5.1 - Anonymize Web browsi...
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

Latest Forum Discussions

See All

Detective Di is a point-and-click murder...
Detective Di is a point-and-click murder mystery set in Tang Dynasty-era China. You'll take on the role of China's best-known investigator, Di Renjie, as he solves a series of grisly murders that will ultimately lead him on a collision course with... | Read more »
Dissidia Final Fantasy Opera Omnia is se...
Dissidia Final Fantasy Opera Omnia, one of Square Enix's many popular mobile RPGs, has announced a plethora of in-game events that are set to take place over the summer. This will include several rewards, Free Multi Draws and more. [Read more] | Read more »
Sphaze is a neat-looking puzzler where y...
Sphaze is a neat-looking puzzler where you'll work to guide robots through increasingly elaborate mazes. It's set in a visually distinct world that's equal parts fantasy and sci-fi, and it's finally launched today for iOS and Android devices. [... | Read more »
Apple Arcade is in trouble
Yesterday, Bloomberg reported that Apple is disappointed in the performance of Apple Arcade and will be shifting their approach to the service by focusing on games that can retain subscribers and canceling other upcoming releases that don't fit... | Read more »
Pixel Petz, an inventive platform for de...
Pixel Petz has built up a sizeable player base thanks to its layered, easy-to-understand creative tools and friendly social experience. It revolves around designing, trading, and playing with a unique collection of pixel art pets, and it's out now... | Read more »
The King of Fighters Allstar's late...
The King of Fighters ALLSTAR, Netmarble's popular action RPG, has once again been updated with a plethora of new content. This includes battle cards, events and 21 new fighters, which increases the already sizeable roster even more. [Read more] | Read more »
Romancing SaGa Re;univerSe, the mobile s...
Square Enix latest mobile spin-off Romancing SaGa Re;univerSe is available now globally for both iOS and Android. It initially launched in Japan back in 2018 where it's proven to be incredibly popular, so now folks in the West can finally see what... | Read more »
Away: Journey to the Unexpected is a sto...
Away: Journey to the Unexpected looks really quite lovely. Stylish, cute, and clearly heavily inspired by Japanese animation, it's amongst the best-looking mobile games on the horizon. Developed by a two-person team, this story-driven rogue-lite... | Read more »
Black Desert Mobile is giving away free...
Pearl Abyss has just announced that it will continue to offer special in-game rewards to Black Desert Mobile players who also happen to be Amazon Prime subscribers. The rewards will be sent out over the next three months, and today's news comes... | Read more »
Golf on Mars "review"
| Read more »

Price Scanner via

July 4th Sale: $100 off every 2020 13″ MacBoo...
Apple resellers have new 2020 13″ MacBook Airs on sale for $100 off Apple’s MSRP as part of their July 4th sales. Starting at $899, these are the cheapest new 2020 MacBooks for sale anywhere: (1) B... Read more
This hidden deal on Apple’s site can save you...
Are you a local, state, or federal government employee? If so, Apple offers special government pricing on their products, including AirPods, for you as well as immediate family members. Here’s how... Read more
Apple Watch Series 3 models on sale for new l...
Amazon has Apple Watch Series 3 GPS models on sale for $30 off MSRP, starting at only $169. Their prices are the lowest available for these models from any Apple reseller. Choose Amazon as the seller... Read more
Deal Alert! Get these refurbished 2018 13″ Ma...
Apple has restocked and lowered prices on select Certified Refurbished 2018 13″ MacBook Airs, starting at only $679. Each MacBook features a new outer case, comes with a standard Apple one-year... Read more
July 4th Sale: 13″ 2.0GHz MacBook Pros for $2...
B&H Photo has new 2020 13″ 2.0GHz MacBook Pros on sale for $200 off Apple’s MSRP as part of their July 4th sale. Prices start at $1599. These are the same MacBook Pros sold by Apple in their... Read more
July 1 only: $100 off Apple iPhone 11, 11 Pro...
Boost Mobile is offering Apple iPhone 11, 11 Pro, and iPhone 11 Pro Max models for $100 off MSRP with service. Their discount reduces the cost of an iPhone 11/64GB to $599, iPhone 11 Pro to $899 for... Read more
Apple offers $50-$100 Education discount on i...
Purchase a new 12.9″ or 11″ iPad Pro at Apple using your Education discount, and Apple will take $50-$100 off their MSRP. All teachers, students, and staff of any educational institution with a .edu... Read more
Apple has Series 5 Apple Watch models availab...
Apple has Certified Refurbished Apple Watch Series 5 WiFi models available for $60 off MSRP, starting at $339. Each Watch includes Apple’s standard one-year warranty and free shipping: – 44mm Apple... Read more
Use our exclusive price trackers at MacPrices...
Looking for a new 2020 13″ MacBook Air or one of the new 2020 iPad Pros? Our Apple award-winning price trackers are the best place to look for the lowest prices and latest sales on Apple gear. Scan... Read more
Clearance Mac minis available for only $679,...
Apple reseller DataVision has clearance, previous-generation Mac minis available for up to $120 off Apple’s original MSRP, each including free shipping. Prices start at $679. DataVision charges... Read more

Jobs Board

Perioperative RN - ( *Apple* Hill Surgical C...
Perioperative RN - ( Apple Hill Surgical Center) Tracking Code 60593 Job Description Monday - Friday - Full Time Days Possible Saturdays General Summary: Under the Read more
Product Manager, *Apple* Commercial Sales -...
Product Manager, Apple Commercial Sales Austin, TX, US Requisition Number:77652 As an Apple Product Manager for the Commercial Sales team at Insight, you Read more
*Apple* Mac Product Engineer - Barclays (Uni...
Apple Mac EngineerWhippany, NJ Support the development and delivery of solutions, products, and capabilities into the Barclays environment working across technical Read more
Blue *Apple* Cafe Student Worker - Pennsylv...
…enhance your work experience. Student positions are available at the Blue Apple Cafe. Employee meal discount during working hours. Duties include food preparation, Read more
Blue *Apple* Cafe Student Worker - Fall - P...
…to enhance your work experience. Student positions are available at the Blue Apple Cafe. Employee meal discount during working hours is provided. Duties include food Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.