Javascript中递归函数的记忆

Question

I have this recursive function that takes in an array of deck cards and finds the index of the certain card:

const getCardIndex = (deck, fullCardName) => fullCardName === deck[0] ? 52 - deck.length : getCardIndex(deck.splice(1), fullCardName)

const deck = 'Ace of Hearts, Ace of Diamonds, Ace of Clubs, Ace of Spades, Two of Hearts, Two of Diamonds, Two of Clubs, Two of Spades, Three of Hearts, Three of Diamonds, Three of Clubs, Three of Spades, Four of Hearts, Four of Diamonds, Four of Clubs, Four of Spades, Five of Hearts, Five of Diamonds, Five of Clubs, Five of Spades, Six of Hearts, Six of Diamonds, Six of Clubs, Six of Spades, Seven of Hearts, Seven of Diamonds, Seven of Clubs, Seven of Spades, Eight of Hearts, Eight of Diamonds, Eight of Clubs, Eight of Spades, Nine of Hearts, Nine of Diamonds, Nine of Clubs, Nine of Spades, Ten of Hearts, Ten of Diamonds, Ten of Clubs, Ten of Spades, Jack of Hearts, Jack of Diamonds, Jack of Clubs, Jack of Spades, Queen of Hearts, Queen of Diamonds, Queen of Clubs, Queen of Spades, King of Hearts, King of Diamonds, King of Clubs, King of Spades'.split(', ')

const result = getCardIndex(deck, 'King of Spades')

console.log(result)

Is there any way it can be sped-up, ie using memoization?

Answer 1

As the comments suggest, there is little reason to do this recursively. indexOf solves this problem nicely.

But, if you're determined to write a recursive solution, there is a huge problem with your technique. You are destroying the object you are trying to search!

Array.prototype.splice is destructive . It alters the array it works on. In the end, you'll have an index and a nearly-empty deck of cards!

That this works at all is almost coincidence. If perhaps you meant to use slice , that would work and not have this problem. slice simply gives you a copy of the array starting from one index and ending at another (or at the end of the array.) splice does more. It removes a sub-list of element, inserts additional ones and the returns the removed ones. If you happen to call it with just a starting index, it removes the rest of the array and returns it. So the calls deck.slice(1) and deck.splice(1) happen to return the same thing, but the second one also removes all the returned items from your array.

So the quickest fix to your function is simply this:

const getCardIndex = (deck, fullCardName) => 
  fullCardName === deck[0] 
    ? 52 - deck.length 
    : getCardIndex (deck.slice(1), fullCardName)

But this makes little sense, honestly. It works, but on every recursive call, it builds a new array, one shorter than the previous version. That's a lot of memory for a simple search.

So here's another technique that recurses only on the index:

const getCardIndex = (deck, fullCardName, idx = 0) =>
  idx >= deck.length 
    ? -1
    : deck [idx] == fullCardName
      ? idx
      : getCardIndex (deck, fullCardName, idx + 1)

Note, however that there is nothing in this specific to decks and cards except the names of the variables and the function. So we could convert this to a more generic function like this:

const getIndex = (xs, x, idx = 0) =>
  idx >= xs.length 
    ? -1
    : xs [idx] == x
      ? idx
      : getIndex (xs, x, idx + 1)

And there we have a recursive solution for finding the index of a value in an arbitrary array.

Again, though, there is very little reason to use this function. It's a reasonable exercise for learning about recursion, but not much else. Use indexOf instead.

Answer 2

For a solution that identifies the solutions in advance ( O(52) = O(1) ) and then can look up solutions in a single operation, ditch the recursive function, turn the deck into an object, whose keys are card names and values are card indicies, and then just look up the card property on the object:

 const deck = 'Ace of Hearts, Ace of Diamonds, Ace of Clubs, Ace of Spades, Two of Hearts, Two of Diamonds, Two of Clubs, Two of Spades, Three of Hearts, Three of Diamonds, Three of Clubs, Three of Spades, Four of Hearts, Four of Diamonds, Four of Clubs, Four of Spades, Five of Hearts, Five of Diamonds, Five of Clubs, Five of Spades, Six of Hearts, Six of Diamonds, Six of Clubs, Six of Spades, Seven of Hearts, Seven of Diamonds, Seven of Clubs, Seven of Spades, Eight of Hearts, Eight of Diamonds, Eight of Clubs, Eight of Spades, Nine of Hearts, Nine of Diamonds, Nine of Clubs, Nine of Spades, Ten of Hearts, Ten of Diamonds, Ten of Clubs, Ten of Spades, Jack of Hearts, Jack of Diamonds, Jack of Clubs, Jack of Spades, Queen of Hearts, Queen of Diamonds, Queen of Clubs, Queen of Spades, King of Hearts, King of Diamonds, King of Clubs, King of Spades'.split(', ') const deckObj = Object.fromEntries(deck.map((str, i) => [str, i])); console.log(deckObj['King of Spades']) console.log(deckObj['Ace of Diamonds']) console.log(deckObj['Queen of Diamonds'])