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;

short
ComparePokerHands(hand1Ptr, hand2Ptr,
 best1Ptr, best2Ptr, 
 wildCardAllowed, wildCard, 
 straightsAndFlushesValid,
 privateDataPtr)
SevenCardHand  *hand1Ptr;
SevenCardHand  *hand2Ptr;
FiveCardHand*best1Ptr;
FiveCardHand*best2Ptr;
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,
     straightsAndFlushesValid)
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:

HuffmanDecode

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)

TYPEDEFS and DEFINES
#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;

PROTOTYPES

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)

HuffmanDecodeInit

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 +
                                                      kSEP);
  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.
 */
  InitializeNewNode();
  ++pFree;

/*
 * 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) { 
          InitializeNewNode();
          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) {
          InitializeNewNode();
          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 {
      --p;
      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;


notEnoughStorage: 
/*
 * If we do not have enough storage for the tree, fall back
 * on a slower technique requiring less storage.
 */
  gMode = 2;
done:
  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;                                         \
  }                                                        \
}

HuffmanDecode

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 + 
                                         kGlobalStorageSize;
#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.
 */
doLeftOverBits:
  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;
start:
    decode_tree = (ulong)t;
    do { 
bit0:
/*
 * 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.
 */
doLeftOverBitsFast:
  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;
startFast:
    decode_tree = (ulong)t;
    do { 
bit0Fast:
/*
 * 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.
 */
slowest:
{
  SymDecode *theSymElemPtr;
  SymElemPtr sP;
  short bitStart,theSymLng,theMask,theBitNum,saveCount,x;
  register ushort theSym;
  theSymLng = 0;
  theSym = 0;
  goto startSlow;
doLeftOverBitsSlow:
  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;
startSlow:
    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 */
overflow:
      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;
search:
      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) {
lastChar:
          if (state!=0) goto done;
          state=1;
          theChar = *bitsP;
          count = 1;
          theBitNum = 8;  theMask = 0x80;
        } else {
          theChar =  *bitsP++;  /* get input byte */ 
          theBitNum = 8;  theMask = 0x80;
        }
      }
      theSym<<=1;
      if (theChar&theMask) theSym|=1;
      --theBitNum;
      theMask>>=1;
      ++theSymElemPtr;
      goto search;
nextChar: 
      theSym <<= 8;
      theSym |= theChar;
      theSymLng += 8;
nextChar0: ;
    } while (--count);
    if ((state==0) && (numBits &= 7)) 
      goto doLeftOverBitsSlow;
  }
}
done: 
    return (char *)outP-(char *)outputPtr;  
}

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

Logic Pro X 10.3 - Music creation and au...
Logic Pro X is the most advanced version of Logic ever. Sophisticated new tools for professional songwriting, editing, and mixing are built around a modern interface that's designed to get creative... Read more
iMazing 2.1.8 - Complete iOS device mana...
iMazing (was DiskAid) is the ultimate iOS device manager with capabilities far beyond what iTunes offers. With iMazing and your iOS device (iPhone, iPad, or iPod), you can: Copy music to and from... Read more
Civilization VI 1.0.2 - 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
TurboTax 2016 - Manage your 2016 U.S. ta...
TurboTax guides you through your tax return step by step, does all the calculations, and checks your return for errors and overlooked deductions. It lets you file your return electronically to get... Read more
Microsoft Office 2016 15.30 - Popular pr...
Microsoft Office 2016 - Unmistakably Office, designed for Mac. The new versions of Word, Excel, PowerPoint, Outlook and OneNote provide the best of both worlds for Mac users - the familiar Office... Read more
FotoMagico 5.3 - Powerful slideshow crea...
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
Acorn 5.6.1 - Bitmap image editor.
Acorn is a new image editor built with one goal in mind - simplicity. Fast, easy, and fluid, Acorn provides the options you'll need without any overhead. Acorn feels right, and won't drain your bank... Read more
Dash 3.4.3 - 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
Microsoft Remote Desktop 8.0.37 - Connec...
With Microsoft Remote Desktop, you can connect to a remote PC and your work resources from almost anywhere. Experience the power of Windows with RemoteFX in a Remote Desktop client designed to help... Read more
Macs Fan Control 1.4.7.0 - Monitor and c...
Macs Fan Control allows you to monitor and control almost any aspect of your computer's fans, with support for controlling fan speed, temperature sensors pane, menu-bar icon, and autostart with... Read more

Turbo League Guide: How to tame the cont...
| Read more »
Fire Emblem: Heroes coming to Google Pla...
Nintendo gave us our first look at Fire Emblem: Heroes, the upcoming mobile Fire Emblem game the company hinted at last year. Revealed at the Fire Emblem Direct event held today, the game will condense the series' tactical RPG combat into bite-... | Read more »
ReSlice (Music)
ReSlice 1.0 Device: iOS Universal Category: Music Price: $9.99, Version: 1.0 (iTunes) Description: Audio Slice Machine Slice your audio samples with ReSlice and create flexible musical atoms which can be triggered by MIDI notes or... | Read more »
Stickman Surfer rides in with the tide t...
Stickson is back and this time he's taken up yet another extreme sport - surfing. Stickman Surfer is out this Thursday on both iOS and Android, so if you've been following the other Stickman adventures, you might be interested in picking this one... | Read more »
Z-Exemplar (Games)
Z-Exemplar 1.4 Device: iOS Universal Category: Games Price: $3.99, Version: 1.4 (iTunes) Description: | Read more »
5 dastardly difficult roguelikes like th...
Edmund McMillen's popular roguelike creation The Binding of Isaac: Rebirth has finally crawled onto mobile devices. It's a grotesque dual-stick shooter that tosses you into an endless, procedurally generated basement as you, the pitiable Isaac,... | Read more »
Last week on PocketGamer
Welcome to a weekly feature looking back on the past seven days of coverage on our sister website, PocketGamer. It’s taken a while for 2017 to really get going, at least when it comes to the world of portable gaming. Thank goodness, then, for... | Read more »
ROME: Total War - Barbarian Invasion set...
To the delight of mobile strategy fans, Feral Interactive released ROME: Total War just a few months ago. Now the game's expansion, Barbarian Invasion is marching onto iPads as a standalone release. [Read more] | Read more »
Yuri (Games)
Yuri 1.0 Device: iOS iPhone Category: Games Price: $3.99, Version: 1.0 (iTunes) Description: It's night. Yuri opens his eyes. He wakes up in a strange forest.The small, courageous explorer rides on his bed on casters in this... | Read more »
Space schmup Xenoraid launches on the Ap...
10Tons Xenoraid is out today on the App Store, bringing some high-speed space action to your mobile gadgets just in time for the weekend. The company's last premium title, another sci-fi game titled Neon Chrome, did quite well for itself, so... | Read more »

Price Scanner via MacPrices.net

Laptop Market – Flight To Quality? – The ‘Boo...
Preliminary quarterly PC shipments data released by Gartner Inc. last week reveal an interesting disparity between sales performance of major name PC vendors as opposed to that of less well-known... Read more
IBM and Bell Transform Canadian Enterprise Mo...
IBM and Bell Canada have announced they are joining forces to offer IBM MobileFirst for iOS market-ready enterprise applications for iPad, iPhone or Apple Watch. Bell, Canada’s largest communications... Read more
Otter Products is Closing… For a Day of Givin...
On Thursday, Feb. 9, Otter Products is closing doors to open hearts. In partnership with the OtterCares Foundation, the company is pausing operations for a day so all employees can volunteer with... Read more
15-inch 2.2GHz Retina MacBook Pro on sale for...
Amazon has 2015 15″ 2.2GHz Retina MacBook Pros (MJLQ2LL/A) available for $1799.99 including free shipping. Apple charges $1999 for this model, so Amazon’s price is represents a $200 savings. Read more
Back in stock: Apple refurbished 13-inch Reti...
Apple has Certified Refurbished 2015 13″ Retina MacBook Pros available for up to $360 off original MSRP, starting at $1099. An Apple one-year warranty is included with each model, and shipping is... Read more
CalcTape for macOS 1.2 Adding Machine App for...
schoettler Software has announced CalcTape 1.2, an update to their desktop calculator for macOS. When it comes to adding long columns of numbers, doing complex calculations or playing around with... Read more
New MacBooks And MacBook Pros WIth Kaby Lake...
Digitimes’ Joseph Tsai cites a Chinese-language Economic Daily News (EDN) report that unnamed market watchers are predicting Apple MacBook shipments to grow 10 percent in 2017, and projecting 15... Read more
New 2016 13-inch MacBook Pros on sale for up...
B&H Photo has the new 2016 13″ MacBook Pros in stock today and on sale for up to $150 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 13″ 2.9GHz/512GB Touch Bar MacBook Pro... Read more
New 15-inch Touch Bar MacBook Pros in stock a...
B&H Photo has the new 2016 15″ Apple Touch Bar MacBook Pros in stock today and on sale for up to $150 off MSRP. Shipping is free, and B&H charges NY sales tax only: - 15″ 2.7GHz Touch Bar... Read more
Opera Announces Neon Concept Browser For Mac
Opera is inviting users to get a glimpse of what Opera for computers could become with its Opera Neon browser concept. Each Opera Neon feature is described as “an alternate reality” for the Opera... Read more

Jobs Board

*Apple* Retail - Multiple Positions (Multi-L...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
*Apple* & PC Desktop Support Technician...
Apple & PC Desktop Support Technician job in Stamford, CT We have immediate job openings for several Desktop Support Technicians with one of our most well-known Read more
*Apple* macOS Systems Integration Administra...
…most exceptional support available in the industry. SCI is seeking an Junior Apple macOS systems integration administrator that will be responsible for providing Read more
*Apple* Premier Retailer - Service Technicia...
DescriptionSimply Mac is the largest premier retailer for Apple products and solutions. At Simply Mac we are all Apple , all the time. Same products. Same prices. Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.