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
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

{ 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

{ 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

{ 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;                              \
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;
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;

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;
--theBitNum;
++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:

Spotify 1.0.4.90. - Stream music, create...
Spotify is a streaming music service that gives you on-demand access to millions of songs. Whether you like driving rock, silky R&B, or grandiose classical music, Spotify's massive catalogue puts... Read more
djay Pro 1.1 - Transform your Mac into a...
djay Pro provides a complete toolkit for performing DJs. Its unique modern interface is built around a sophisticated integration with iTunes and Spotify, giving you instant access to millions of... Read more
Vivaldi 1.0.118.19 - Lightweight browser...
Vivaldi browser. In 1994, two programmers started working on a web browser. Our idea was to make a really fast browser, capable of running on limited hardware, keeping in mind that users are... Read more
Stacks 2.6.11 - New way to create pages...
Stacks is a new way to create pages in RapidWeaver. It's a plugin designed to combine drag-and-drop simplicity with the power of fluid layout. Features: Fluid Layout: Stacks lets you build pages... Read more
xScope 4.1.3 - Onscreen graphic measurem...
xScope is powerful set of tools that are ideal for measuring, inspecting, and testing on-screen graphics and layouts. Its tools float above your desktop windows and can be accessed via a toolbar,... Read more
Cyberduck 4.7 - FTP and SFTP browser. (F...
Cyberduck is a robust FTP/FTP-TLS/SFTP browser for the Mac whose lack of visual clutter and cleverly intuitive features make it easy to use. Support for external editors and system technologies such... Read more
Labels & Addresses 1.7 - Powerful la...
Labels & Addresses is a home and office tool for printing all sorts of labels, envelopes, inventory labels, and price tags. Merge-printing capability makes the program a great tool for holiday... Read more
teleport 1.2.1 - Use one mouse/keyboard...
teleport is a simple utility to let you use one single mouse and keyboard to control several of your Macs. Simply reach the edge of your screen, and your mouse teleports to your other Mac! The... Read more
Apple iMovie 10.0.8 - Edit personal vide...
With an all-new design, Apple iMovie lets you enjoy your videos like never before. Browse your clips more easily, instantly share your favorite moments, and create beautiful HD movies and Hollywood-... Read more
Box Sync 4.0.6233 - Online synchronizati...
Box Sync gives you a hard-drive in the Cloud for online storage. Note: You must first sign up to use Box. What if the files you need are on your laptop -- but you're on the road with your iPhone? No... Read more

## Latest Forum Discussions

Become the World's Most Important D...
Must Deliver, by cherrypick games, is a top-down endless-runner witha healthy dose of the living dead. [Read more] | Read more »
SoundHound + LiveLyrics is Making its De...
SoundHound Inc. has announced that SoundHound + LiveLyrics, will be one of the first third-party apps to hit the Apple Watch. With  SoundHound you'll be able to tap on your watch and have the app recognize the music you are listening to, then have... | Read more »
Adobe Joins the Apple Watch Lineup With...
A whole tidal wave of apps are headed for the Apple Watch, and Adobe has joined in with 3 new ways to enhance your creativity and collaborate with others. The watch apps pair with iPad/iPhone apps to give you total control over your Adobe projects... | Read more »
Z Steel Soldiers, Sequel to Kavcom'...
Kavcom has released Z Steel Soldiers, which continues the story of the comedic RTS originally created by the Bitmap Brothers. [Read more] | Read more »
Seene Lets You Create 3D Images With You...
Seene, by Obvious Engineering, is a 3D capture app that's meant to allow you to create visually stunning 3D images with a tap of your finger, and then share them as a 3D photo, video or gif. [Read more] | Read more »
Lost Within - Tips, Tricks, and Strategi...
Have you just downloaded Lost Within and are you in need of a guiding hand? While it’s not the toughest of games out there you might still want some helpful tips to get you started. [Read more] | Read more »
The Petcube Camera is a device that lets you use live video to check in on your pet, talk to them, and play with them using a laser pointer - all while you're away. And the Petcube app is coming to the Apple Watch, so you'll be able to hang out with... | Read more »
Now You Can Manage Your Line2 Calls With...
You'll be able to get your Line2 cloud phone service on the Apple Watch very soon. The watch app can send and receive messages using hands-free voice dictation, or by selecting from a list of provided responses. [Read more] | Read more »
R.B.I. Baseball 15 (Games)
R.B.I. Baseball 15 1.01 Device: iOS Universal Category: Games Price: \$4.99, Version: 1.01 (iTunes) Description: The legendary Major League Baseball franchise returns to the diamond. Make History. ** ALL iPOD Touch, the iPad 2 and the... | Read more »
Here's How You Can Tell if an App W...
The Apple Watch is pretty much here, and that means a whole lot of compatible apps and games are going to be updated or released onto the App Store. That's okay though, beacause Apple has quietly updated their app description pages to make things... | Read more »

## Price Scanner via MacPrices.net

Intel Compute Stick: A New Mini-Computing For...
The Intel Compute Stick, a new pocket-sized computer based on a quad-core Intel Atom processor running Windows 8.1 with Bing, is available now through Intel Authorized Dealers across much of the... Read more
Heal to Launch First One-Touch House Call Doc...
Santa Monica, California based Heal, a pioneer in on-demand personal health care services — will offer the first one-touch, on-demand house call doctor app for the Apple Watch. Heal’s Watch app,... Read more
Mac Notebooks: Avoiding MagSafe Power Adapter...
Apple Support says proper usage, care, and maintenance of Your Mac notebook’s MagSafe power adapter can substantially increase the the adapter’s service life. Of course, MagSafe itself is an Apple... Read more
12″ Retina MacBook In Shootout With Air And P...
BareFeats’ rob-ART morgan has posted another comparison of the 12″ MacBook with other Mac laptops, noting that the general goodness of all Mac laptops can make which one to purchase a tough decision... Read more
FileMaker Go for iPad and iPhone: Over 1.5 Mi...
FileMaker has announced that its FileMaker Go for iPad and iPhone app has surpassed 1.5 million downloads from the iTunes App Store. The milestone confirms the continued popularity of the FileMaker... Read more
Sale! 13-inch 2.7GHz Retina MacBook Pro for \$...
Best Buy has the new 2015 13″ 2.7GHz/128GB Retina MacBook Pro on sale for \$1099 – \$200 off MSRP. Choose free shipping or free local store pickup (if available). Price for online orders only, in-... Read more
Minimalist MacBook Confirms Death of Steve Jo...
ReadWrite’s Adriana Lee has posted a eulogy for the “Digital Hub” concept Steve Jobs first proposed back in 2001, declaring the new 12-inch MacBook with its single, over-subscribed USB-C port to be... Read more
13-inch 2.7GHz Retina MacBook Pro for \$1234 w...
Adorama has the 13″ 2.7GHz/128GB Retina MacBook Pro in stock for \$1234.99 (\$65 off MSRP) including free shipping plus a free LG external DVD/CD optical drive. Adorama charges sales tax in NY & NJ... Read more
13-inch 2.5GHz MacBook Pro available for \$999...
Adorama has the 13-inch 2.5GHz MacBook Pro on sale for \$999 including free shipping plus NY & NJ sales tax only. Their price is \$100 off MSRP. Read more
Save up to \$600 with Apple refurbished Mac Pr...
The Apple Store is offering Apple Certified Refurbished Mac Pros for up to \$600 off the cost of new models. An Apple one-year warranty is included with each Mac Pro, and shipping is free. The... Read more

## Jobs Board

*Apple* Client Systems Solution Specialist -...
…drive revenue and profit in assigned sales segment and/or region specific to the Apple brand and product sets. This person will work directly with CDW Account Managers Read more
*Apple* Software Support - Casper (Can work...
…experience . Full knowledge of Mac OS X and prior . Mac OSX / Server . Apple Remote Desktop . Process Documentation . Ability to prioritize multiple tasks in a fast pace Read more
*Apple* Software Support - Xerox Corporation...
…Imaging experience Full knowledge of Mac OS X and prior Mac OSX / Server Apple Remote Desktop Process Documentation Ability to prioritize multiple tasks in a fast pace Read more
*Apple* Support Technician IV - Jack Henry a...
Job Description Jack Henry & Associates is seeking an Apple Support Technician. This position while acting independently, ensures the proper day-to-day control of Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more