Live attempt at Every Day I'm Shuffling (Director's Cut) by Karim Awenat

Added: 2026-05-05

[00:00:00]And welcome. Today, I'm going to live stream an attempt at a case called everyday shuffling by Karim Aouana. So, it's going to be a live attempt at the director's cut only because I played the original case before.

[00:00:14]But, I'm going to do them both just for the sake of completeness. So, I've got them both here.

[00:00:20]Um Do do do do do. Yeah, so uh Oh, look at this. It even tells you do do the round two case. Make the shuffles in lambdas. Skip level if you hate it.

[00:00:32]>> [laughter] >> Okay, I have not read level eight yet, but we'll see. Win Flex complained it was [laughter] too long.

[00:00:39]Okay. Uh well, anyway. So, I'm going to start over here.

[00:00:43]Everyday shuffling.

[00:00:45]Um Let's see. I I tested this a little while this case just got played in the UK round this weekend, but I tested a little while back. So, let's just quickly refresh my memory.

[00:00:53]Uh This one is all about cards.

[00:00:57]Uh we've had card case before. We can't play decent card game without being able to shuffle the deck. In this case, we've got two simple shuffles that most people will will already know. But, actually modeling them up maybe a bit trickier than you expected. However, for the sake of everyone's sanity as well as my own personal safety when I'm due on September, we've removed the stupidly hard parts. I might still release these into the wild though. Well, that's what I'm here for.

[00:01:16]In each game, the deck of cards will start in the new deck order which can be found on the new deck and example sheet.

[00:01:21]So, here we've got new deck order which is position, card suit name, suit color, and card value.

[00:01:26]And then, we've got examples of what happens after cuts, but we'll get to those later. So, I'm just going to make this into a table.

[00:01:33]Uh ba ba ba bum. And we'll call this T cuz I like short table names.

[00:01:41]Uh and I'll just make that value.

[00:01:44]So, I think card and value are really mostly what I'm going to be using. Okay.

[00:01:48]Um ba ba ba ba bum.

[00:01:51]Okay.

[00:01:53]Your best friends in this game are likely to be sequence take drop, but it is perfectly solvable by a more model building approach. Nah, we're going to go go sell here.

[00:02:01]>> [snorts] >> Until maybe we get to the director's cut. We'll see.

[00:02:04]Text manipulation. Yes, good luck and have fun.

[00:02:06]Uh I think note explaining uh [ __ ] That Yeah, that was my last Karim card case live solve. Anyway, all right. Uh we'll start with the levels and then we'll go to the bonuses. So, we're starting with the deck in new deck order, find the card at the given position. So, that should just be index T card by this numbers.

[00:02:27]All [clears throat] good. Uh each game starts with a new deck in new deck order. The code C num tells us we're doing a cut C. Uh so, we're going to take num cards from the top of the deck and put them at the bottom of the deck in a single block. So, for this one, there are lots of different ways you can do it. Um you know, index and mod and things like that. But, um if say I'm interested in cutting the top 23 cards to the bottom of the deck, then I could do something like sequence uh sorry, sequence 52 less than or equal to 23.

[00:02:56]That will give me uh trues all the way down to uh to card number 23 and then falses thereafter.

[00:03:05]Uh and so, if I sort the list of cards by this, uh trues and falses sort in alphabetical order. So, false will come first then true. So, it'll just shift all the trues to the bottom of the pile.

[00:03:15]Uh and so, Ba ba ba ba ba. I'm just going to make this a lambda right from the start.

[00:03:23]So, I'll mark that as input. Uh and then, I'll say actually let's do T card also and make that part of the input too. Oops, move over to where we have a little more space.

[00:03:34]Uh Just mark that as input.

[00:03:37]Uh and then, we'll say um Oh, wait. I'll say sort by uh this by sequence 52 is less than or equal to Uh oops, sorry. Is less than or equal to um I guess we can say one times text after or mid or whatever. Lots of different ways you can do it. Text after this C.

[00:04:04]Uh and hopefully, we'll find that we have what? 23 cards here. So, the jack of diamonds goes to the top.

[00:04:11]Yes. And after another 29 cards, we should get that there.

[00:04:20]Yeah, right here the ace of spades after 29 cards. Good. Okay. So, then that is my uh cut shuffle I think it's called or something like that. Um So, I'm just going to actually wait. I want I want these to be in the opposite order because then it'll be handier for reduce. Uh so, I'm going to rename this to uh cut.

[00:04:43]We've got cards and cut and it does that. We say okay.

[00:04:46]And we're going to call it cut. No, no. Wait. I think cut might be a reserved name or something funny like that. I've tried to call things cut before and gotten trouble.

[00:04:55]Uh so, we'll call this I don't know.

[00:04:58]SH cut.

[00:04:59]Shuffle cut.

[00:05:01]Uh so, then we should be able to say Oh, and actually, let's let's take this a little further.

[00:05:08]Let's uh say if cards then T cards otherwise cards cuz then it'll make it a little easier to work with.

[00:05:28]And that leaves the arguments not the ideal way around to be omitting the first one and not the second one, but whatever, I guess.

[00:05:42]Um that seems to work.

[00:05:46]So, now we can say index of shuffle cut that cut by that number.

[00:05:56]And that works.

[00:06:01]And copy down. All right. Okay. Level three. That was nice warm up. Let's perform a series of cuts as before start with the new deck in new deck order each time. Okay. So, this is why I wanted to um this is why I wanted to put the arguments in that order because now it'll be much more natural to feed them into reduce. So, we can say reduce uh from T card um this for now is my array and I'll update that to handle the flexible size in a second. And the function is SH cut.

[00:06:29]Uh and that should do my shuffle as many times as I need and then we'll index on that by position six and hopefully get a two of spades. And we do.

[00:06:36]Uh and now instead of this, we'll do to call of this three. So, it'll drop the blanks.

[00:06:44]Uh and then, we should be all set on level three.

[00:06:50]There we are. Okay.

[00:06:52]Level four. Overhand underhand shuffling free.

[00:06:55]We now move on to the overhand shuffle.

[00:06:56]Each game starts with a new deck as before. Overhand shuffles are shown by S num one num two.

[00:07:01]As with the cut, take the top num one cards from the deck. Place these to one side for now. Now, take the top num two cards from the remaining cards. What is the total found card value for this group of cards?

[00:07:10]Okay. So, we'll regex extract from here /d+.

[00:07:15]All of them multiply by one to convert to numbers. So, we're going to drop 38 cards and then take eight cards.

[00:07:20]Uh so, we can And then, we want to sum them up. So, we'll take drop starting from T card.

[00:07:29]Uh we will drop 34.

[00:07:32]And then, we'll take eight.

[00:07:34]>> [snorts] >> And then, we'll sum them up.

[00:07:36]Comes to zero. Right? Oh, right. Cuz I'm doing the cards. I should be doing the values.

[00:07:41]Uh okay. 51 looks good.

[00:07:44]>> [clears throat] >> Happy days. All right.

[00:07:54]Where are we? Level five. You now identify a single group, but we need multiple groups for the full overhand shuffle.

[00:08:02]Start as in level four, take the top num one cards and put them on side. Then, take the next num two cards to make your first group. Then, take the next num two cards from what's left. That's your second group. Repeat until there's no cards left. Your final group may be smaller than num two. That's okay.

[00:08:13]Find the total card value for each group excluding the num one cards. What is the highest total card value of all these groups?

[00:08:20]Card values can be found in the new deck tab.

[00:08:22]Okay.

[00:08:24]So, we're going to drop 34 cards. Then, we're going to take group of eight and group of eight and then the rest will be two.

[00:08:34]So, I think Just trying to think what is the cleanest way to do this.

[00:08:48]Um So, what I want is I'm going to say if sequence Well, I sorry. First, let's just quickly regex extract from here /d+.

[00:09:01]Uh plus one times one.

[00:09:05]So, I want if sequence 52 is less than or equal to this, then whatever X. Those are the ones set aside. Otherwise, I want um round up of sequence 52 minus 34 divided by eight to zero decimal places.

[00:09:30]So, I get 34 cards of X.

[00:09:32]Okay. Well, I'm just going to just plow right through that, but never mind.

[00:09:35]Then, I got a bunch of ones, a bunch of twos, and two threes. That seems good.

[00:09:39]Um So, then I'm going to say let GPs be that and I want uh to filter uh T value where GPs is not equal to X.

[00:10:02]Nah, wait.

[00:10:04]One more closing bracket.

[00:10:05]Um No, I guess I want to filter each stack.

[00:10:10]GPs and T value where GPs is not equal to X.

[00:10:17]There we go. Uh so, this is going to be to group.

[00:10:22]Uh and then I want to group by uh take to group uh first column take to group last column uh sum.

[00:10:36]And then 0 0 -2.

[00:10:40]Uh I don't even need the minus two. I do need the zero so that it doesn't do an overall total and then I just want the max of that.

[00:10:48]Cool.

[00:10:58]Okay, happy days. Uh all right. Now, overhand all the way down. We now have everything we need to do the full overhand shuffle. Take the top num one cards as before and set them aside. This is now the bottom of the deck.

[00:11:09]For the remaining cards, take the top num two cards and place those on top of the cards from the last step. Then take the next num two cards.

[00:11:15]Okay, so we're going to Yes, oh so we're going to invert our groups. So, this is the last group, second last group, first group, and then the cards that got moved to the bottom. Okay.

[00:11:23]So then, I think a quick modification on this will do the trick.

[00:11:27]Um but first, I guess I need to pull these all together.

[00:11:31]So, let uh skip me regex extract from here by /d+ * 1 uh and GP size GP SC can be 1 * text after this after colon.

[00:11:57]Uh and then just replace all of these.

[00:12:00]This is skip.

[00:12:02]Um this is skip.

[00:12:05]This is GP SC.

[00:12:09]Good.

[00:12:11]Hm, actually, let's be a little more disciplined and say uh cut is this and then we only have one reference, which makes it a lot easier to turn into a lambda.

[00:12:21]Turn into a lambda in a minute.

[00:12:25]So then, take cut, put it there, put it there.

[00:12:29]Okay.

[00:12:32]Uh and then I'm not actually interested in the two group bit.

[00:12:35]I just want two groups.

[00:12:37]Uh and I also want this to now be X. That's [snorts] going to be the first group and all the rest can be plus one.

[00:12:45]Uh and then let's just output GPS and see what it looks like.

[00:12:50]And we'll need to move it to fit it.

[00:12:52]So, we get 34 ones and then some twos.

[00:12:56]Eight twos, yes. Eight threes, yes. And two fours, yes.

[00:13:00]So, then we just want to sort in the opposite of uh yeah, in the opposite of that direction. So, we'll do sort by uh T card uh by minus GPS.

[00:13:14]And then we start with the two of hearts, then the ace of hearts, yes. And then should be the 10 of hearts.

[00:13:20]And eight cards later, the three of hearts, yes.

[00:13:23]And then the five of club, yes. The jack of hearts will be the next eight.

[00:13:30]Yes. And then next eight is ace clubs to the eight. No, no, sorry. [clears throat] Then it's into the last 34. Okay, good.

[00:13:39]So, now then that worked. So, now we're going to make this a lambda. We're just going to say lambda uh of uh cards cut uh wait, sorry. Have we used No, I haven't used cards. Okay, fine. Cards cut.

[00:13:52]Uh I can kill this.

[00:13:57]Um and then we're going to say if is omitted uh cards then T card, otherwise cards.

[00:14:12]Uh sorry, that closes there and this one closes there.

[00:14:16]Okay, and then we'll save lambda.

[00:14:20]Uh and we'll call that SH. What is this one called? I don't remember.

[00:14:26]Uh let's go Wait, it's the overhand.

[00:14:28]Right.

[00:14:29]Uh so, we'll save lambda, we'll call it SHOH.

[00:14:34]So, then we should be saying index SHOH uh that cut by that number.

[00:14:45]And we are. All right.

[00:14:48]So, take that, put it over here.

[00:14:49]Pull it down.

[00:14:54]I just noticed the clues here. These shuffles are the same shuffles as in level five. Okay.

[00:14:59]What are the clues are there?

[00:15:01]Okay, how many cards are left over after the cut? How many groups is it split into? Work out the starting card for each group and go from there.

[00:15:06]Sensible.

[00:15:08]Any other clues?

[00:15:16]Um the the thing I should have mentioned here, uh I didn't do it because of my approach, but um if you think about how the cuts work, uh any any cut followed by any other cut is just going to be a different cut. So, like you take five cards and put them to the bottom and then you take another five cards and put them to the put them to the bottom, it's the same as if you just taking 10 cards and put them put them to the bottom at the start. So, you can just like add up these numbers, I guess mod 52.

[00:15:41]Um and then you get the equivalent of of just one cut, but since I had a a cut function, it was easy to just apply it two, three, or four times.

[00:15:51]All right. So, level seven. Now, let's do multiple overhand shuffle shuffles.

[00:15:55]So, this should be very simple.

[00:15:58]So, we'll say reduce uh starting from T card uh through the array and I just like before, I'll do the two call trick just to ignore uh anything omitted and then we'll do SHOH.

[00:16:14]Uh close and the index number is going to be the position, which is here.

[00:16:19]And that works.

[00:16:21]Cool.

[00:16:22]All right, let's do bonuses and then we'll go on to the hard part. Which [snorts] suit appears most often in level one answers? Give the suit name.

[00:16:29]Okay. Um So, we'll do XLOOKUP at group by uh right of this uh this rows 0 0 -2. So, that'll I'm always torn between a desire to just write formulas the way that feels natural to me, which is this is one block versus to be vaguely more helpful and educational, I guess. Since I'm not in a rush, let's be vaguely more helpful and educational and actually spill it out.

[00:17:05]Uh so, the the inner group by uh that I was going to put the at on, uh is just counting how many of each uh suit occurs.

[00:17:14]Uh the minus the zero means no totals and the minus two means it's sorted in descending order by the count. Uh and then I put an at on that, that just gives me the first symbol and then I want to XLOOKUP that in T suit.

[00:17:25]Ooh.

[00:17:26]Ah, okay, got it. Right. Uh so, we'll look it up in T card returning from T suit.

[00:17:32]Uh I'm going to just do a uh regex match so it'll match partial.

[00:17:38]Uh so, in other words, that looking up a diamond with regex just means looking up for anything that contains diamond, so it'll just match on the first diamond.

[00:17:46]Uh whatever it comes to here, the ace of diamonds, I guess.

[00:17:49]Um which will do just fine. So, cut that out of there, bring it over here.

[00:17:55]Okay. Uh what single cut would bring the pack back to the new deck order after a C17 cut? Give your answer in C number notation. So, this is basically, if you take 17 cards and put them to the bottom, it's equivalent to taking uh 35 cards from the bottom and putting them on top. So, to reverse that, you take 35 cards from the top and put them on the bottom.

[00:18:15]Um And then, if you do all the shuffles in level three excluding examples, what single shuffle would bring the pack back to NDO?

[00:18:24]Uh so, this is one you can With my setup, it's not that hard to to do it sort of directly. Um So, uh da da da da da da da I'm trying to think.

[00:18:38]You could think about So, you could quickly figure out what is the deck's position after all this. So, we could say reduce T card uh through two call all of these three uh and the function is SH cut.

[00:18:55]And that'll give you where the deck ends up.

[00:18:57]Uh and then you can just think about uh the number of cards you need to put to the bottom is the location of the ace of hearts, I guess.

[00:19:05]Uh so, we could uh let's just copy that.

[00:19:10]Uh so, we could XMATCH that against that.

[00:19:15]Uh that would say 15 and put a C in front of it.

[00:19:22]Um I think that's the right answer, but it'll be more smooth if I prove it first. Uh the alternative is you can do um So, first we'll do sum of I just get the numbers out, so we'll regex extract from uh I guess again from two call to drop the blanks.

[00:19:44]Uh just /d+ um * 1 that gives 1337 uh and then we can take Basically, you want to think what can you add to this to get to a multiple of 52. So, equivalently you can say mod of minus that by 52.

[00:20:03]That will also give you 15. And then you can put a C in front of that.

[00:20:06]Um Yeah, it's I mean, this one is actually conceptually the easier one to to write and implement, I think. But this one is, you know, if you had 10 squillion of these or something like that, it's much more efficient to just add up the numbers. So, you know, highs and lows. Total card value of the answer cards in level six. Okay, so that's just sum of X lookup all of level six is here.

[00:20:34]In T card, oops, card returning from T value.

[00:20:41]Good. And then let's do a magic trick.

[00:20:43]You ask the audience to name a card, any card. You then perform the shuffles below from left to right starting from the new deck order. Bottom card will be the card they named. Okay. So, for this, and I suspect I'll need this in the director's cut as well, I'm going to write a function that can do both cuts.

[00:20:57]And that's just going to be Uh so, let's start with SH cut.

[00:21:03]Actually, no, let's just do lambda.

[00:21:06]Uh cards cut.

[00:21:09]Uh I'm going to say if left of cut uh equals C, then SH cut.

[00:21:20]Otherwise, SH OH.

[00:21:24]Uh I'll probably need to make this a switch later. Should I just do it now?

[00:21:28]Yeah, let's do it now.

[00:21:30]So, let's slightly differently. Let's do choose uh search left of cut in CO.

[00:21:39]Um sorry, CS even.

[00:21:41]Uh and then if I need to add more letters here, I can do that. Um and yeah, then if it matches the first one, that's cut. If it matches the second one, that's overhand.

[00:21:51]Uh That closes.

[00:21:55]Oh, wait. Why are these brackets not colored? Come on. There we go.

[00:21:58]Uh that closes the choose. And then I want to apply that to cards and cut.

[00:22:03]Uh Did I do that right? I think so.

[00:22:08]No, apparently not. Uh Oh, sorry. I missed closing bracket here. That's the problem.

[00:22:14]>> [sighs] >> Uh okay. So then if I save lambda, uh Uh what do I want to call this? I want to call this, I guess, SH.

[00:22:26]Just SH. Any shuffle.

[00:22:28]Um fine. So then I want to do all these, so I want to reduce uh T card start through this array Are there any merged cells here? No, that's fine.

[00:22:38]Uh and SH.

[00:22:42]And then the bottom card is going to be the 52nd card, I guess.

[00:22:47]Let's say index of this by 52.

[00:22:55]All right. Okay. So, that's the original. That's the easy part.

[00:23:00]Now, let's get on to the meat of this.

[00:23:03]Um So, first I'm going to go ahead and name make this a table and also name it T.

[00:23:08]Uh do that.

[00:23:12]Um Slightly sloppy design the way I had my lambdas reference a named range in here, but never mind. So, I'm just going to copy my lambdas over. H O M Bring it in here.

[00:23:28]Uh 20 is fine.

[00:23:31]I don't need to create a copy.

[00:23:33]Delete that sheet.

[00:23:34]And then I'll probably need to edit them, so let's do that.

[00:23:39]Yeah, just two. So, SH cut.

[00:23:44]Edit lambda.

[00:23:45]Should have some crazy big Yeah, there we go.

[00:23:48]External reference. Just make that T card.

[00:23:51]Save lambda.

[00:23:53]And then let's do the same thing for SH OH.

[00:23:57]Edit lambda.

[00:24:03]Mm.

[00:24:05]Boom.

[00:24:06]Boom. Mm boom boom.

[00:24:08]Okay.

[00:24:11]Cool.

[00:24:13]Save lambda.

[00:24:14]Right. So, now we are ready, I think, to dive on into this one.

[00:24:19]Uh good news everyone. For those of you recovering from my free key So, I think this is the same.

[00:24:24]Uh hopefully you're all participating in the minute of C round two. You all already know how to cut the deck and do a simple overhand shuffle. Just in case some of you've had it too easy. Welcome to the director's cut.

[00:24:33]Level eight kicks off with no new shuffling, just reusing what you learned in the main case. If you haven't already, you may want to think about converting whatever shuffling logic you have to a lambda as you'll be doing multiple shuffles from the get-go. If level eight freaks you out, stress you not, head on to level nine as it's unrelated.

[00:24:47]Uh okay, yeah. So, we've got very hard, hard, stupidly hard and go away hard.

[00:24:51]>> [laughter] >> Uh okay, I see Shannon here, so I guess this there's some entropy something going on here. Anyway, we'll get to that. Uh okay.

[00:24:59]It starts with new deck order. Yes.

[00:25:01]Yes. Good luck and have fun. Yes. Okay.

[00:25:04]So, recap. Yes. Yes. Riffle shuffle level nine onwards. Okay.

[00:25:09]>> [snorts] >> So, let's dive in. More magic tricks.

[00:25:11]You ask an audience member to pick a card and place it in the deck. While they look at the card, you swap the top and bottom of the deck, so their card is now between between card 50 two Wait, what?

[00:25:23]E.g., if they pick card 33, you'd swap the deck so cards 30 Oh, got it. Got it.

[00:25:27]Got it. Then their card Huh? Okay.

[00:25:43]Huh?

[00:25:45]>> [laughter] >> Um What?

[00:25:51]Okay.

[00:25:52]So, both examples start the same way.

[00:25:54]Card 33 is chosen. You make sure they put it back on top of cards 1 to 32.

[00:26:02]34 to 33 1 to 32. Okay.

[00:26:10]Oh, got it. Got it. Got it. Got it.

[00:26:12]Uh fine. So, if it is after the ace of hearts, then we say tada and the position number.

[00:26:20]And here, you lost the card.

[00:26:26]Okay, so the dough is how far off?

[00:26:28]Right. Okay, got it.

[00:26:30]>> [sighs] >> All right.

[00:26:32]So, So, um first things first is this this cut, uh which is not quite the same as a regular cut.

[00:26:42]So, Okay.

[00:26:45]Um Yeah, let's make that its own lambda.

[00:26:50]Uh so, do SH cut.

[00:26:54]Uh edit lambda.

[00:26:58]So, I want to sort by So, let's just see. If I do sequence 52 minus this value here, and then I do sign of that, that will give me a bunch of minus ones, where I'm less than, a zero where I'm equal to, and a one where I'm greater than.

[00:27:24]Is that the right order to then shuffle?

[00:27:27]So, one then zero then minus one. Yes, I think so. So, let's just test.

[00:27:32]We say sort by sequence 52 by this.

[00:27:39]Uh and I have my minus that. All right, so we'll flip the sign of that.

[00:27:44]Uh so, let's make it this minus that.

[00:27:48]So, we get 34 to 52, then 33, then 1 to 32. Is that what it's supposed to be?

[00:27:55]Where are we? 34 to 52, 33, 1 to 32.

[00:27:58]Yes. Okay, fine.

[00:28:00]So then I think we are good to proceed.

[00:28:04]>> [clears throat] >> So, then I want to uh sort by T card by Oops, where's that gone? Sign of that.

[00:28:19]That's my starting point for the deck.

[00:28:21]>> [snorts] >> Then, oops.

[00:28:25]I want to reduce that by all of these.

[00:28:32]Uh sorry, just those with shuffle.

[00:28:37]And then the question is where have things ended up?

[00:28:39]Uh and the things I'm interested in are is it always the same card they choose?

[00:28:45]Oh, no, sorry. It's the 33rd card, of course.

[00:28:48]Uh so then I want to X match Where's my ace of hearts?

[00:28:54]Yeah.

[00:28:56]I want to X match this against that.

[00:29:00]And I want to X match index T card by 33 against that.

[00:29:12]Okay. And if I find that that this is one greater than that, then I do one thing, and otherwise I do the other thing.

[00:29:18]And I guess the question is are they ever not in the right order? We'll soon find out. So, uh let uh new order be that. Um then call it AH lock can be X match ace of hearts against new order.

[00:29:38]And trick lock can be X match index T card by Uh Then by 33 against new word.

[00:29:55]And then we want to say if Well, no. For now, let's just say H stack cuz I want to do some visual inspection here. My concern is is it ever the case that like the ace of hearts ends up in position 52 and this one ends up in position one. Do I need to think about mod or is it just Do I just not need to? Not sure. We'll soon find out. Uh 48 and 49. Yes, that makes sense.

[00:30:18]29 31. So, I guess the question is is this one always greater than this one?

[00:30:24]And the answer is no. So, let's take a quick look.

[00:30:26]All right. So, 33 17 just breaks.

[00:30:29]Although, yeah, now here there's a That's a reasonable question. How many cards are in between? Are we taking from 17 to 33 or from 33 all the way wrap around?

[00:30:38]Hm.

[00:30:38]Let's see how it's worded.

[00:30:41]Uh if you If you lose that card, return dough and how many cards between cards not counting either of the cards.

[00:30:48]Just return the number between them whichever order they appear in. Okay, that is totally clear.

[00:30:53]So, we're going to say uh if trug lock equals ax lock plus one, then return ta-da and ta-da dash and trug lock.

[00:31:10]Otherwise, return dough.

[00:31:14]Uh uh dash and absolute value of um h lock minus trug lock minus one.

[00:31:28]And I guess I might need brackets around that.

[00:31:30]And close the if and close the let.

[00:31:33]I think that's good.

[00:31:38]Let's see.

[00:31:44]Ah! One more Ah, 50. Right. Okay.

[00:31:50]So, I guess this is probably one where it's going from.

[00:31:54]It's wrapping around. So, let's just go back to my numbers where I had them all spelled out. I can't Ah, right. Because I used the macros. Stupid. Never mind.

[00:32:02]>> [snorts] >> Uh okay.

[00:32:03]Just Uh let's grab this over here and just do H stack, H lock, and new or Sorry, and trug lock.

[00:32:20]Uh ba ba ba ba ba And let's Yeah, 52 and one. Okay, fine.

[00:32:25]So, hello.

[00:32:27]Why isn't that Hm.

[00:32:30]Oh, right. Okay. So, we do need to do Fine. Okay. So, the test is what's wrong then.

[00:32:37]So, I guess it should be um H lock minus trug lock uh give me mod 52.

[00:32:51]If that's equal to one, then that.

[00:32:54]No.

[00:32:55]Uh sorry. Other way around. Trug lock's the bigger one.

[00:32:59]Or should be the bigger one.

[00:33:00]There we go.

[00:33:01]Did that break the rest? No. Good. All right.

[00:33:05]Missed the edge case, but I'll take it.

[00:33:07]Level nine.

[00:33:08]We're on to the riffle shuffle now.

[00:33:10]These are shown by the code R num.

[00:33:12]We start as with the cut. We take the first num cards and hold these in our left hand. We hold the rest of the deck in our right hand.

[00:33:17]You then alternate the cards starting with the bottom of the cards in your left hand. If you have cards left over, they fall on top while keeping their order.

[00:33:25]After the series of riffle shuffles shown below, what card is in the given position? Okay, so R 34. 1 to 34, 35 52.

[00:33:34]So, it's 34 then 52 then 33 then 51.

[00:33:41]Um 34 first. Okay.

[00:33:46]So, let's do this. We do sequence of 52.

[00:33:54]So, I want 34 to be one, let's say.

[00:34:05]I want 52 to be two.

[00:34:07]33 to be three. This to be four.

[00:34:10]>> [snorts] >> So, I guess in general the pattern I want is if sequence 52 is less than or equal to uh one times text after uh this R then actually Yeah, let's just grab this text somewhere. I'm going to use it more than once.

[00:34:38]So, let um cut num be that.

[00:34:43]Uh then we'll say if sequence 52 is less than or equal to cut num then I want I want two times cut num minus sequence 52 plus one.

[00:35:03]So, at 34 that would give me one then three. Yes, that's good. And then otherwise, I want 53 minus sequence 52.

[00:35:16]So, that That doesn't look right at all.

[00:35:21]Ah, actually that's okay. Yeah.

[00:35:24]Cuz after 18, I stop caring. So, the equivalent So, this has Oh, sorry. That needs to be doubled.

[00:35:31]That needs to be doubled. Um So, that's two times that times that.

[00:35:38]So, okay. Now, I have cards up to 36, which means that here it goes up to 35 in 18 cards. Yeah, and then it doesn't matter that these numbers get bigger than 52. So, that's fine. Yes.

[00:35:50]Okay.

[00:35:52]Uh so, then uh let's just take SH cut.

[00:35:58]Edit lambda.

[00:35:59]And we'll screw around with this lambda.

[00:36:02]Um do do do do do do do do do do do do do.

[00:36:06]So, we got sort by. Yes, that's good.

[00:36:09]So, we're just going to add let cut num be one for now and then sort by and close the let.

[00:36:17]Uh and then cut num is this.

[00:36:21]Uh uncut.

[00:36:26]Uh cool. And then here is my new and more complex sequence to sort on.

[00:36:37]Oh.

[00:36:41]So, then we'll save lambda as and this will be SH R for the riffle shuffle.

[00:36:48]Uh and then uh I can take my general SH lambda.

[00:36:54]Edit.

[00:36:55]And if we're starting with an R then we can do Yeah.

[00:37:01]SHR.

[00:37:06]So, save that. And I'm just cleaning all that up.

[00:37:10]And so, finally, uh we are interested in index of reduce of um T card through call of all of this three uh with >> [snorts] >> We just go straight to SH, I guess.

[00:37:26]Uh and index by this position and it should be the two of diamonds.

[00:37:29]It's not. Bother.

[00:37:31]Uh okay.

[00:37:32]Hm.

[00:37:36]Oh, wait. Hang on. Hang on. Hang on.

[00:37:38]Hang on. Hang on.

[00:37:39]On. Bother. Uh if you have cards left over, they fall on top while keeping their order.

[00:37:44]So, Oh, the first card down is 34. That's what I did. Okay. Um shoot.

[00:37:52]Uh >> [sighs] >> So, let's do SHR.

[00:37:57]So, do I just need to sort by the negative of that whole mad sequence?

[00:38:02]Uh I don't know. Let's see what happens if I do.

[00:38:08]Two of diamonds. What do you know? Okay.

[00:38:11]Uh so, let's just do one test with the SHR of sequence 52.

[00:38:17]Uh and on this riffle.

[00:38:23]Okay. Just put it over.

[00:38:26]Okay. So, I got 1 to 16 on top then 35 17.

[00:38:34]Oh, wait. Oh, no. Sorry. Here.

[00:38:37]1 to 16.

[00:38:39]Then 35 17.

[00:38:43]Okay. I think that's working.

[00:38:46]A little uncomfortable that we just fudged it based on the example, but I think it's working.

[00:38:52]So, put that in and carry on.

[00:38:56]Yes. Okay. Level 10. I'm a shuffle channel. We're going to calculate the Shannon entropy of a shuffled deck.

[00:39:03]Ah, the Shannon entropy is a standard measure of randomness in a data set.

[00:39:06]First, we perform the shuffles shown.

[00:39:08]Next, we find the difference between each card and the next card. If the difference is negative, add 52. Be sure to include the difference between the last card and the first card. You should have 52 values each between 1 and 52.

[00:39:18]Count how many times each difference appears, the frequency. Take each frequency and divide it by 52 to find the probability. For each probability, multiply it by its own natural log.

[00:39:26]Yes, probability times log of probability is the measure of entropy.

[00:39:30]To get the Shannon entropy, you take the sum of all the probability times log of probability values. What is the Shannon entropy after the following shuffles?

[00:39:36]Multiply by 100 and round to the nearest integer as your answer. Okay.

[00:39:40]So, these are doing here, but never mind.

[00:39:44]Uh So, so, so, so, so, let's do um reduce T card through to call of this three SH.

[00:39:57]That'll give us some stuff.

[00:40:00]Um and then let I guess ord be that.

[00:40:06]And then the index will be xmatch.

[00:40:09]Don't x Yeah, I want I think I want that. Yeah, let's just see. Uh perfect riffle shuffle.

[00:40:17]Cards 27 128 2 Uh let's just xmatch this against T card.

[00:40:25]Ooh, wait, 27 1 Is that what I said?

[00:40:30]Uh 27 128 2. Yes, good.

[00:40:33]The differences 128 are that.

[00:40:38]Therefore, 26 lots of 26, 25 lots of 25, and one lot of 51.

[00:40:43]Got it.

[00:40:44]Okay.

[00:40:46]So, in that case, I don't think I even want to start with T card. I want to start with sequence 52.

[00:40:55]Okay.

[00:40:56]Uh and then >> [snorts] >> I'll say let ord be that and uh I guess shifted ord can be sort by ord.

[00:41:11]That's what I want to do. I want to Yeah, move the first one to the end. So, we'll say sort by sequence 52 equals one.

[00:41:19]And let's just show me shifted order.

[00:41:23]And that should bump everything along by 1 128 229. Yes, that makes sense. So, it's the bottom. Good. Uh so, then I want uh ord minus SH ord.

[00:41:36]SH O, that's not the most helpful naming.

[00:41:39]Uh and then I think I want that mod 52.

[00:41:43]Should serve to do that. Yes, good.

[00:41:47]Um then uh what do I want? Well, just call that diffs.

[00:41:54]Uh and then I want to group by diffs diffs.

[00:41:59]Uh rows 0 0 and then 0 minus 2, so and then we're not interested in this part. We're just interested in this, I think.

[00:42:11]So, we'll drop the first column.

[00:42:15]Um wait a minute.

[00:42:17]Sorry. Here, drop the first column.

[00:42:20]Uh and divide by 52. That's our probabilities.

[00:42:27]So, then our entropy is sum of probs times ln of probs.

[00:42:37]And we want to round 100 times entropy to zero decimal places.

[00:42:43]Okay.

[00:42:44]Uh I suppose we're changing the sign at some point here as well.

[00:42:50]Didn't actually say that, but I do think you mean it.

[00:42:53]Oh, sorry. No, no. We've got uh we forgot All right. Well, anyway, there's definitely a minus sign comes in here somewhere. I know that.

[00:43:03]Uh so, I think it comes into the entropy calculation itself. So, we'll put it there. All right.

[00:43:11]Cool. All right. Level 11. Can I stop now, please? No, honestly, like it's longer, but I wouldn't say any of this has felt uh you know, brutal in the way that some of [ __ ] for instance, felt brutal.

[00:43:24]But anyway, okay. Let's arbitrarily say that anything above a Shannon entropy of 300 three before multiplication is well shuffled.

[00:43:32]Uh okay.

[00:43:35]Solid.

[00:43:36]Starting from the new deck order, perform the shuffles below until the deck is well shuffled, then stop. If the deck is still not well shuffled after 10 shuffles, then keep repeating the 10th shuffle until the deck is well shuffled.

[00:43:46]Find the Shannon entropy of the well shuffled deck and ensure your Shannon entropy isn't rounded or multiplied by 100 to get a whole number, then multiply this number by the number of shuffles it took to get there. What's the result?

[00:43:57]Okay.

[00:44:02]So, [snorts] All right. I have some ideas. First, I should probably just lambdafy this Shannon thingy thing thing thing.

[00:44:12]Um So, >> [snorts] >> yeah.

[00:44:20]Um All right.

[00:44:27]So, everything downstream of here is calculated as that. Yes, it's fine.

[00:44:32]So, let's say lambda of ord.

[00:44:39]Let SH ord be that, diffs be that, probs be that, entropy be that, and let's just return entropy.

[00:44:51]I think.

[00:44:52]Um Okay.

[00:44:55]So, we'll save lambda.

[00:44:58]We'll call that entropy.

[00:45:00]Ent for entropy.

[00:45:02]Keep it tight.

[00:45:03]Uh okay.

[00:45:04]So, then I want to reduce sequence 52.

[00:45:12]Um and I don't know. We'll need to figure out what the biggest number of shuffles we might need will be, but for now, let's say sequence 20, and we can make it bigger if we need to.

[00:45:22]Um lambda A V.

[00:45:26]Okay. So, I want to apply the shuffle. Well, I want to calculate the entropy.

[00:45:32]I want to apply the shuffle.

[00:45:34]Sorry. I'm going to calculate the entropy.

[00:45:36]If the entropy is low, then stop and return the entropy times the step number.

[00:45:41]Which really means the first thing needs to be if.

[00:45:44]So, an input at a step here is either going to be uh a column of 52 numbers, 1 to 52 in some shuffled order, or it's going to be a single value, which is entropy times step number or whatever it is.

[00:45:59]Uh and are we Okay, so we are rounding by Okay, fine.

[00:46:07]So, we're going to say if row I'm going to Stop. Stop being noisy. If rows of A uh equals one, then just keep A.

[00:46:18]Otherwise, uh we're going to say let NXT be um SH of A and index this by the minimum of V and 10.

[00:46:38]So, that just means if V goes beyond 10, we just keep doing the 10th shuffle.

[00:46:43]Uh okay. So, shuffle A by that. Uh and then we'll say if ent of A is greater than three 300 I can't remember what exactly I included in ent. Let's pause and check.

[00:47:03]Um Yeah, so if we're going to Let me just double check quickly.

[00:47:15]Rounded and multiplied by 100 to get a whole number. All right, let me just quickly check if there's anything up here for which I would require the unrounded entropy. Otherwise, we can just go on.

[00:47:23]This is at level eight. Using two decks of cards uh each of which is in NDO and one on top of the other. Is the card on top of Yeah, fine.

[00:47:30]On a single NDO, if you perform R26 10 times or this 100 times or this serves the highest resulting Shannon entropy.

[00:47:37]Okay.

[00:47:38]>> [laughter] >> Uh cool. Fine.

[00:47:41]So, then the answer is I don't need Shannon entropy uh to be rounded. So, we'll say round of 100 times ent to zero decimal places, and then that'll just simplify things.

[00:47:54]Save lambda.

[00:47:56]Okay. So, then here uh what are we saying? We're saying Yeah, if the above 300 is well shuffled, define.

[00:48:08]So, we'll say if ent A is greater than 300, then return ent of A times V, I think. Times the position number.

[00:48:19]Shuffle five with Shannon Okay.

[00:48:22]Otherwise, return NXT.

[00:48:25]I have a bunch of closing brackets, I think.

[00:48:28]Uh it turns out it's 1824.

[00:48:30]It's not what I wanted.

[00:48:31]It's probably [snorts] something times six.

[00:48:33]Ah, wait.

[00:48:37]So, that should be shuffle So, I did one two Right. Yes, yes, yes, yes, yes, because No, it says right.

[00:48:50]So, [snorts] it seems like it wants me to say V minus one, but I'm not satisfied as why I would be saying V minus one.

[00:48:57]Um Let's just output some debugging stuff that I can look at here. If I H stack it, then it'll still only have one row, and it'll still terminate the calculation. So, let's do index of uh this by V.

[00:49:19]So, that says C23, which is the sixth shuffle.

[00:49:22]So, 1 2 3 4 5 6.

[00:49:30]Huh.

[00:49:31]Oh, sorry. Sorry. Sorry. I see it. I see it. I see it. I'm doing ent of A, but I should be doing ent of NXT.

[00:49:38]There we go. Uh okay, so now we're not multiplying by Ooh, wait. What?

[00:49:45]That's not good.

[00:49:49]Oh, sorry. Because again, it needs to be end of NXT.

[00:49:53]Okay, there we go.

[00:49:54]Um shouldn't really be calculating that entropy twice, so let's not.

[00:49:59]Uh call it NXT int.

[00:50:03]So, NXT int can be that.

[00:50:08]Uh if that, then then just return that cuz we don't need to check anymore.

[00:50:14]Uh oops, sorry. Uh times V.

[00:50:17]Cool.

[00:50:18]Okay, and then that should just work unless we need to up the number of turns it's going through some of the time.

[00:50:25]Uh so, if any of these returns are split Oh.

[00:50:27]Okay.

[00:50:28]Well, I was going to say if any of these returns are split, I'll crank up the number, but none of them did, so it's fine. Okay. Um All right, you want to make the magic trick from level eight work more often.

[00:50:37]For each of the games, limit the number of shuffles you do with 10 shuffles, you should average success 40% of the time.

[00:50:45]Uh Oh, got it. Got it. Got it. You should average success 40% of the time. Is that right? Um do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do do That's yes, eight out of 20. Cool. Um Limit the number of shuffles you do with 10 shuffles, you should average success rate.

[00:51:04]After how many shuffles should you stop to make sure you astound your audience at least two-thirds of the time across the 20 games?

[00:51:10]That means you need 14 successes. Um Is there a smart way to do this, I find myself wondering?

[00:51:19]>> [snorts] >> Um Hm.

[00:51:30]Um I think I'm just going to do what happens after each of the 10 steps.

[00:51:39]There might be a smarter way to do it, but I'm not seeing it right now. Uh so, we do sequence comma 10.

[00:51:45]Uh and we'll take most of this.

[00:51:51]But, I just want to say one, otherwise zero.

[00:51:55]Actually, we can just therefore make it one big minus minus.

[00:52:01]Uh and now, this should become take from here by this many columns.

[00:52:16]Okay.

[00:52:18]So, you sometimes lose even on the very first one. Okay.

[00:52:23]Uh ooh, you didn't like that. Uh probably cuz I didn't lock some stuff.

[00:52:26]Let's lock some stuff. Uh so, yes, that be locked. This should be locked. This should be locked.

[00:52:32]Uh that's locked the way it should be.

[00:52:34]That should be locked.

[00:52:36]Cool.

[00:52:38]Okay.

[00:52:39]Uh so, then I need average of these.

[00:52:47]And so, it looks like wow, you can only shuffle twice. That's pretty bad.

[00:52:52]Uh but okay.

[00:52:53]So, what was the question?

[00:52:56]Uh for each of the games, limit the number of shuffles that you do.

[00:52:59]After how many shuffles should you stop?

[00:53:01]Really, only two? Yes, okay.

[00:53:04]All right, using two decks of cards, each of which is in India, one on top of the other, what is the result after performing consecutive riffles of R50?

[00:53:11]Okay, so I think I need to change SHR to not use a constant 52. So, we'll do rows of cards.

[00:53:22]Um Ah.

[00:53:26]Hm.

[00:53:27]Okay, yeah.

[00:53:28]Uh so, let's Is this if I do rows of cards, it'll break when cards is omitted, which is some of the use case stuff set up. So, let's do cards use will be this.

[00:53:46]Uh and then we'll do rows of cards use.

[00:53:52]Um Uh there and there.

[00:53:56]And oh, this should be uh rows of card use plus one.

[00:54:02]Anything else to change? No, I think that's good.

[00:54:05]Uh I guess I'll just save it differently just to be safe. Uh so, we'll do SHR flex.

[00:54:17]So, then uh equals reduce equals reduce uh V stack T card with T card.

[00:54:27]Um Do do do do do do do do do do do do do do if sequence five R50 Yes, R50.

[00:54:39]Um Uh SHR flex.

[00:54:49]Uh and then I want the top card, which I assume is just index one.

[00:54:58]Now, ah crap.

[00:55:05]Um >> [snorts] >> Okay, well, let's check the basics, I guess.

[00:55:17]Hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm hm Uh so, I start with one.

[00:55:27]Uh Let's do What am I trying to do here? Um Can't tell a thing from looking at that.

[00:55:41]Uh so, let's do sequence.

[00:55:43]Let's just do the whole thing as sequence 104.

[00:55:51]That's not great.

[00:55:54]What?

[00:55:55]So, when I flex, these are the cards.

[00:55:58]The cut is R50.

[00:56:02]Not doing anything. That's not good.

[00:56:06]I also broken it.

[00:56:08]Uh if I guess Yes.

[00:56:12]>> [snorts] >> Cards use, yes.

[00:56:17]What the heck am I doing wrong? I don't know. Oh, hang on. Rows of rows of cards use. No, what? Ah, right, yeah. I remember now. I was copying and pasting rows of card use instead of card use.

[00:56:28]Okay, so that would totally break that, and that maybe makes sense.

[00:56:33]52 53 54 55 51 51 52 52 Yeah.

[00:56:41]Okay. All right, so save lambda and save that rescues it. Uh sorry, no. What?

[00:56:49]Save lambda, not save lambda as There we go.

[00:56:52]Okay.

[00:56:53]So, that certainly changes the answer.

[00:56:56]There we go. Phew. Okay.

[00:56:59]Just a silly mistake. Okay, on a single Indio, if you perform R26 10 times or S263 100 times or C26 1,000 times, what is the highest resulting Shannon entropy multiplied by 100 and round to the nearest whole number? Okay, I'm not going to take the bait of doing C26 1,000 times, because if you do C26 twice, you're back to where you started.

[00:57:19]So, C26 1,000 times is definitely back to where you started. Although, just out of curiosity, let's see if we can handle doing it 1,000 times uh the dumb way.

[00:57:28]Uh so, we say if sequence 1,000 uh then C26 uh and I want to shuffle I guess we'll allow myself to use SH cut.

[00:57:41]All right, well, that was actually pretty much instantaneous, so no complaints. Anyway, okay, so uh what's the highest resulting Shannon entropy?

[00:57:49]So, we'll do max of three things, which is going to be reduced T card.

[00:57:55]Uh sorry. Uh entropy.

[00:57:58]Uh I guess we want to just do it on sequence 52.

[00:58:03]So, we're going to reduce that uh through Okay, R26 10 times. So, we say if sequence 10 then R26 uh and we'll do SHR.

[00:58:15]And that's the reduce. That's the entropy.

[00:58:21]And then here, we're going to say uh 100 times of S263.

[00:58:29]And here, we're going to say 1,000 times, given that we know the answer, but I think we don't. Uh sorry.

[00:58:37]Just make all of these SH.

[00:58:40]Uh okay.

[00:58:43]Go.

[00:58:45]Boom. Perfect score. Very happy with that. Uh that was that was pretty smooth sailing uh for for a Karim director's cut, I was expecting uh it to be more traumatizing. Uh but, lovely case. Uh love the idea, like the you know, kind of where do you go with uh with shuffling, you think about all the different shuffles you could do for tricks, and then you think about how random are you actually getting it through the shuffling. Uh awesome idea for a case. Really enjoyed it. Uh even if it wasn't or because it wasn't, I don't know.

[00:59:21]Because despite uh adjacent to it not being as hard as the last one, uh super fun case. Thanks, Karim, for that. And that's all I got for today. Thanks for watching. See you next time.

[00:59:30]And in.