Challenge:
Input: A list of distinct positive integers within the range \$[1, \text{list-size}]\$.
Output: An integer: the amount of times the list is riffle-shuffled. For a list, this means the list is split in two halves, and these halves are interleaved (i.e. riffle-shuffling the list [1,2,3,4,5,6,7,8,9,10] once would result in [1,6,2,7,3,8,4,9,5,10], so for this challenge the input [1,6,2,7,3,8,4,9,5,10] would result in 1).
Challenge rules:
- You can assume the list will only contain positive integers in the range \$[1, \text{list-size}]\$ (or \$[0, \text{list-size}-1]\$ if you choose to have 0-indexed input-lists).
- You can assume all input-lists will either be a valid riffle-shuffled list, or a sorted list which isn't shuffled (in which case the output is
0). - You can assume the input-list will contain at least three values.
Step-by-step example:
Input: [1,3,5,7,9,2,4,6,8]
Unshuffling it once becomes: [1,5,9,4,8,3,7,2,6], because every even 0-indexed item comes first [1, ,5, ,9, ,4, ,8], and then all odd 0-indexed items after that [ ,3, ,7, ,2, ,6, ].
The list isn't ordered yet, so we continue:
Unshuffling the list again becomes: [1,9,8,7,6,5,4,3,2]
Again becomes: [1,8,6,4,2,9,7,5,3]
Then: [1,6,2,7,3,8,4,9,5]
And finally: [1,2,3,4,5,6,7,8,9], which is an ordered list, so we're done unshuffling.
We unshuffled the original [1,3,5,7,9,2,4,6,8] five times to get to [1,2,3,4,5,6,7,8,9], so the output is 5 in this case.
General rules:
- This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language. - Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
- Default Loopholes are forbidden.
- If possible, please add a link with a test for your code (i.e. TIO).
- Also, adding an explanation for your answer is highly recommended.
Test cases:
Input Output
[1,2,3] 0
[1,2,3,4,5] 0
[1,3,2] 1
[1,6,2,7,3,8,4,9,5,10] 1
[1,3,5,7,2,4,6] 2
[1,8,6,4,2,9,7,5,3,10] 2
[1,9,8,7,6,5,4,3,2,10] 3
[1,5,9,4,8,3,7,2,6,10] 4
[1,3,5,7,9,2,4,6,8] 5
[1,6,11,5,10,4,9,3,8,2,7] 6
[1,10,19,9,18,8,17,7,16,6,15,5,14,4,13,3,12,2,11,20] 10
[1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20] 17
[1,141,32,172,63,203,94,234,125,16,156,47,187,78,218,109,249,140,31,171,62,202,93,233,124,15,155,46,186,77,217,108,248,139,30,170,61,201,92,232,123,14,154,45,185,76,216,107,247,138,29,169,60,200,91,231,122,13,153,44,184,75,215,106,246,137,28,168,59,199,90,230,121,12,152,43,183,74,214,105,245,136,27,167,58,198,89,229,120,11,151,42,182,73,213,104,244,135,26,166,57,197,88,228,119,10,150,41,181,72,212,103,243,134,25,165,56,196,87,227,118,9,149,40,180,71,211,102,242,133,24,164,55,195,86,226,117,8,148,39,179,70,210,101,241,132,23,163,54,194,85,225,116,7,147,38,178,69,209,100,240,131,22,162,53,193,84,224,115,6,146,37,177,68,208,99,239,130,21,161,52,192,83,223,114,5,145,36,176,67,207,98,238,129,20,160,51,191,82,222,113,4,144,35,175,66,206,97,237,128,19,159,50,190,81,221,112,3,143,34,174,65,205,96,236,127,18,158,49,189,80,220,111,2,142,33,173,64,204,95,235,126,17,157,48,188,79,219,110,250]
45
30 Answers 30
JavaScript (ES6), 44 bytes
Shorter version suggested by @nwellnhof
Expects a deck with 1-indexed cards as input.
f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))
Given a deck \$[c_0,\ldots,c_{L-1}]\$ of length \$L\$, we define:
$$x_n=\begin{cases} 2^n\bmod L&\text{if }L\text{ is odd}\\ 2^n\bmod (L-1)&\text{if }L\text{ is even}\\ \end{cases}$$
And we look for \$n\$ such that \$c_{x_n}=2\$.
JavaScript (ES6), (削除) 57 52 (削除ここまで) 50 bytes
Expects a deck with 0-indexed cards as input.
f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)
How?
Since JS is lacking native support for extracting array slices with a custom stepping, simulating the entire riffle-shuffle would probably be rather costly (but to be honest, I didn't even try). However, the solution can also be found by just looking at the 2nd card and the total number of cards in the deck.
Given a deck of length \$L\$, this code looks for \$n\$ such that:
$$c_2\equiv\left(\frac{k+1}{2}\right)^n\pmod k$$
where \$c_2\$ is the second card and \$k\$ is defined as:
$$k=\begin{cases} L&\text{if }L\text{ is odd}\\ L-1&\text{if }L\text{ is even}\\ \end{cases}$$
-
\$\begingroup\$ Save four bytes with
f=lambda x:2!=x[1]and-~f(x[::2]+x[1::2])\$\endgroup\$Jonathan Allan– Jonathan Allan2019年03月11日 14:48:39 +00:00Commented Mar 11, 2019 at 14:48 -
\$\begingroup\$ @JonathanAllan Oh, of course! Well...
!=can be-. ;-) \$\endgroup\$Erik the Outgolfer– Erik the Outgolfer2019年03月11日 14:49:10 +00:00Commented Mar 11, 2019 at 14:49 -
\$\begingroup\$ Ah, yeah caveat emptor :D (or just
x[1]>2I guess) \$\endgroup\$Jonathan Allan– Jonathan Allan2019年03月11日 14:50:07 +00:00Commented Mar 11, 2019 at 14:50
Jelly, 8 bytes
ŒœẎ$ƬiṢ’
How?
ŒœẎ$ƬiṢ’ - Link: list of integers A
Ƭ - collect up until results are no longer unique...
$ - last two links as a monad:
Œœ - odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
Ẏ - tighten -> [a,c,...,b,d,...]
Ṣ - sort A
i - first (1-indexed) index of sorted A in collected shuffles
’ - decrement
APL (Dyalog Unicode), (削除) 35 (削除ここまで) (削除) 26 (削除ここまで) (削除) 23 (削除ここまで) 22 bytes SBCS
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
Thanks to Adám for the help, Erik the Outgolfer for -3 and ngn for -1.
The TIO link contains two test cases.
Explanation:
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]} ⍝ function takes one argument: ⍵, the array
⍵≡⍳≢⍵ ⍝ if the array is sorted:
⍵≡⍳≢⍵ ⍝ array = 1..length(array)
:0 ⍝ then return 0
⋄ ⍝ otherwise
1+ ⍝ increment
∇ ⍝ the value of the recursive call with this argument:
⍵[ ] ⍝ index into the argument with these indexes:
⍳⍴⍵ ⍝ - generate a range from 1 up to the size of ⍵
2| ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
⍒ ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.
-
1\$\begingroup\$ Count the recursion depth for -3. \$\endgroup\$Erik the Outgolfer– Erik the Outgolfer2019年03月11日 13:26:20 +00:00Commented Mar 11, 2019 at 13:26
-
\$\begingroup\$ @EriktheOutgolfer Much better, thanks! \$\endgroup\$Ven– Ven2019年03月11日 13:29:41 +00:00Commented Mar 11, 2019 at 13:29
-
1\$\begingroup\$
∧/2≤/⍵->⍵≡⍳≢⍵\$\endgroup\$ngn– ngn2019年03月12日 15:58:28 +00:00Commented Mar 12, 2019 at 15:58 -
\$\begingroup\$ @ngn didn't realize the array had no holes. Thanks! \$\endgroup\$Ven– Ven2019年03月12日 16:59:41 +00:00Commented Mar 12, 2019 at 16:59
R, (削除) 58 (削除ここまで) (削除) 55 (削除ここまで) 45 bytes
a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F
Simulates the sorting process. Input is 1-indexed, returns FALSE for 0.
-
\$\begingroup\$ Very nice! I was working on a similar approach but using a recursive function, which didn't work out as golfy. \$\endgroup\$user2390246– user23902462019年03月12日 11:55:30 +00:00Commented Mar 12, 2019 at 11:55
Perl 6, (削除) 34 (削除ここまで) 32 bytes
-2 bytes thanks to Jo King
{(.[(2 X**^$_)X%$_-1+|1]...2)-1}
Similar to Arnauld's approach. The index of the second card after n shuffles is 2**n % k with k defined as in Arnauld's answer.
Java (JDK), 59 bytes
a->{int c=0;for(;a[(1<<c)%(a.length-1|1)]>2;)c++;return c;}
Works reliably only for arrays with a size less than 31 or solutions with less than 31 iterations. For a more general solution, see the following solution with 63 bytes:
a->{int i=1,c=0;for(;a[i]>2;c++)i=i*2%(a.length-1|1);return c;}
Explanation
In a riffle, the next position is the previous one times two modulo either length if it's odd or length - 1 if it's even.
So I'm iterating over all indices using this formula until I find the value 2 in the array.
Credits
- -8 bytes thanks to Kevin Cruijssen. (Previous algorithm, using array)
- -5 bytes thanks to Arnauld.
-
\$\begingroup\$ 163 bytes by using two times
x.clone()instead ofA.copyOf(x,l). \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2019年03月11日 12:58:19 +00:00Commented Mar 11, 2019 at 12:58 -
2
-
\$\begingroup\$ @Arnauld Thanks! I had a hard time figuring how to simplify that "length if odd else length - 1" \$\endgroup\$Olivier Grégoire– Olivier Grégoire2019年03月11日 13:59:58 +00:00Commented Mar 11, 2019 at 13:59
-
\$\begingroup\$ @Arnauld Oh! My new algorithm is actually the same as yours... And I spent half an hour figuring it out by myself... \$\endgroup\$Olivier Grégoire– Olivier Grégoire2019年03月11日 14:04:39 +00:00Commented Mar 11, 2019 at 14:04
-
\$\begingroup\$ More precisely, it's equivalent to an improvement over my original algorithm found by @nwellnhof. \$\endgroup\$Arnauld– Arnauld2019年03月11日 14:10:25 +00:00Commented Mar 11, 2019 at 14:10
Perl 6, (削除) 36 34 (削除ここまで) 32 bytes
-2 bytes thanks to nwellnhof
$!={.[1]-2&&$!(.sort:{$++%2})+1}
Reverse riffle shuffles by sorting by the index modulo 2 until the list is sorted, then returns the length of the sequence.
It's funny, I don't usually try the recursive approach for Perl 6, but this time it ended up shorter than the original.
Explanation:
$!={.[1]-2&&$!(.sort:{$++%2})+1}
$!={ } # Assign the anonymous code block to $!
.[1]-2&& # While the list is not sorted
$!( ) # Recursively call the function on
.sort:{$++%2} # It sorted by the parity of each index
+1 # And return the number of shuffles
05AB1E (legacy), 9 bytes
[DāQ#ι ̃]N
Explanation
[ # ] # loop until
ā # the 1-indexed enumeration of the current list
D Q # equals a copy of the current list
ι ̃ # while false, uninterleave the current list and flatten
N # push the iteration index N as output
-
\$\begingroup\$ I didn't even knew it was possible to output the index outside the loop in the legacy. I thought it would be 0 again at that point, just like in the new 05AB1E version. Nice answer! Shorter than my 10-byter using the unshuffle-builtin
Å≠that inspired this challenge. :) \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2019年03月11日 10:31:48 +00:00Commented Mar 11, 2019 at 10:31 -
\$\begingroup\$ @KevinCruijssen: Interesting. I didn't know there was an unshuffle. In this instance it's the same as my version, but unshuffle maintains dimensions on 2D arrays. \$\endgroup\$Emigna– Emigna2019年03月11日 11:18:35 +00:00Commented Mar 11, 2019 at 11:18
-
\$\begingroup\$ Alternative 9-byter that works in both versions:
[DāQD–#ι ̃\$\endgroup\$ovs– ovs2021年01月17日 14:13:40 +00:00Commented Jan 17, 2021 at 14:13
J, (削除) 28 (削除ここまで) 26 bytes
-2 bytes thanks to Jonah!
1#@}.(\:2|#\)^:(2<1{])^:a:
Inspired be Ven's APL solution.
Explanation:
^: ^:a: while
(2<1{]) the 1-st (zero-indexed) element is greater than 2
( ) do the following and keep the intermediate results
i.@# make a list form 0 to len-1
2| find modulo 2 of each element
/: sort the argument according the list of 0's and 1's
1 }. drop the first row of the result
#@ and take the length (how many rows -> steps)
K (ngn/k), 25 bytes
Thanks to ngn for the advice and for his K interpreter!
{#1_{~2=x@1}{x@<2!!#x}\x}
-
\$\begingroup\$ converge-iterate, then drop one, and count - this leads to shorter code \$\endgroup\$ngn– ngn2019年03月12日 16:28:28 +00:00Commented Mar 12, 2019 at 16:28
-
\$\begingroup\$ @ngn. So, similar to my J solution - I'll try it later, thanks! \$\endgroup\$Galen Ivanov– Galen Ivanov2019年03月12日 18:16:26 +00:00Commented Mar 12, 2019 at 18:16
-
1\$\begingroup\$
1#@}.(\:2|#\)^:(2<1{])^:a:for 26 bytes \$\endgroup\$Jonah– Jonah2019年04月22日 03:29:49 +00:00Commented Apr 22, 2019 at 3:29 -
1\$\begingroup\$
1#@}.(\:2|#\)^:(0<A.)^:a:takes off 1 more, 6 years later! \$\endgroup\$Jonah– Jonah2025年02月12日 23:05:36 +00:00Commented Feb 12 at 23:05 -
1\$\begingroup\$
(\:2|#\)^:(<@!@#)i.#\also works for 21, but is much slower, don't want to run it on input more than 9 or 10 \$\endgroup\$Jonah– Jonah2025年02月12日 23:23:14 +00:00Commented Feb 12 at 23:23
☾, (削除) 22 (削除ここまで) 19 chars ((削除) 67 (削除ここまで) 60 bytes)
screenshot (sorry, my font is f***ed up in the screenshots, I'm a Windows user or something LOL)
🃌○しろまる←↨0%2ᐸᴍᐸ⍟≡⟞
Run the tests here.
explanation The code runs a function to undo a riffle-shuffle, and does that until the array is sorted. Then, it gets the amount of iterations that whole process took. Due to the fact that it only cares about indices in the grouping, you can feed it both 0-indexed decks and 1-indexed decks.
Thanks to Ganer (the creator of the language) for -1 char (before I posted this).
APL(NARS), chars 49, bytes 98
{0{∧/ ̄1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑ ̈i⊂⍨2∣i←⍳≢⍵]}⍵}
why use in the deepest loop, one algo that should be nlog(n), when we can use one linear n? just for few bytes more? [⍵≡⍵[⍋⍵] O(nlog n) and the confront each element for see are in order using ∧/ ̄1↓⍵≤1⌽⍵ O(n)]test:
f←{0{∧/ ̄1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑ ̈i⊂⍨2∣i←⍳≢⍵]}⍵}
f ,1
0
f 1 2 3
0
f 1,9,8,7,6,5,4,3,2,10
3
f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17
-
\$\begingroup\$ That’s the first time I’ve seen someone differentiate between characters and bytes 👍. It always bugs me when I see Unicode characters and they claim that it’s one byte per character. This 😠 is not one byte! \$\endgroup\$Indiana Kernick– Indiana Kernick2019年03月11日 21:31:45 +00:00Commented Mar 11, 2019 at 21:31
-
\$\begingroup\$ @Kerndog73 All is number, but in APL think characters are not numbers... (they seems element in AV array) \$\endgroup\$user58988– user589882019年03月11日 23:41:26 +00:00Commented Mar 11, 2019 at 23:41
Ruby, 42 bytes
f=->d,r=1{d[r]<3?0:1+f[d,r*2%(1|~-d.max)]}
How:
Search for number 2 inside the array: if it's in second position, the deck hasn't been shuffled, otherwise check the positions where successive shuffles would put it.
R, (削除) 70 (削除ここまで) 72 bytes
x=scan();i=0;while(any(x>sort(x))){x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1};i
Now handles the zero shuffle case.
-
1\$\begingroup\$ @user2390246 fair point. Adjusted accordingly \$\endgroup\$Nick Kennedy– Nick Kennedy2019年03月12日 12:03:55 +00:00Commented Mar 12, 2019 at 12:03
C (GCC) (削除) 64 (削除ここまで) 63 bytes
-1 byte from nwellnhof
i,r;f(c,v)int*v;{for(i=r=1;v[i]>2;++r)i=i*2%(c-1|1);return~-r;}
This is a drastically shorter answer based on Arnauld's and Olivier Grégoire's answers. I'll leave my old solution below since it solves the slightly more general problem of decks with cards that are not contiguous.
C (GCC) 162 bytes
a[999],b[999],i,r,o;f(c,v)int*v;{for(r=0;o=1;++r){for(i=c;i--;(i&1?b:a)[i/2]=v[i])o=(v[i]>v[i-1]|!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];}}
a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v;{ //argument list
for(r=0;o=1;++r){ //major loop, reset o (ordered) to true at beginning, increment number of shuffles at end
for(i=c;i--;(i&1?b:a)[i/2]=v[i]) //loop through v, split into halves a/b as we go
o=(v[i]>v[i-1]|!i)&o; //if out of order set o (ordered) to false
if(o) //if ordered
return r; //return number of shuffles
//note that i==-1 at this point
for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
}
}
R, 85 bytes
s=scan();u=sort(s);k=0;while(any(u[seq(s)]!=s)){k=k+1;u=as.vector(t(matrix(u,,2)))};k
Explanation
Stupid (brute force) method, much less elegant than following the card #2.
Instead of unshuffling the input s we start with a sorted vector u that we progressively shuffle until it is identical with s. This gives warnings (but shuffle counts are still correct) for odd lengths of input due to folding an odd-length vector into a 2-column matrix; in that case, in R, missing data point is filled by recycling of the first element of input.
The loop will never terminate if we provide a vector that cannot be unshuffled.
Addendum: you save one byte if unshuffling instead. Unlike the answer above, there is no need to transpose with t(), however, ordering is byrow=TRUE which is why T appears in matrix().
R, 84 bytes
s=scan();u=sort(s);k=0;while(any(s[seq(u)]!=u)){k=k+1;s=as.vector(matrix(s,,2,T))};k
-
\$\begingroup\$ I took the liberty of fixing your title and adding a TIO-link for the test cases (based on the other R answer), and also verified your answer works as intended, so +1 from me and welcome to PPCG! :) \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2019年03月13日 10:52:55 +00:00Commented Mar 13, 2019 at 10:52
PowerShell, (削除) 116 114 108 84 (削除ここまで) 78 bytes
-24 bytes thanks to Erik the Outgolfer's solution.
-6 bytes thanks to mazzy.
param($a)for(;$a[1]-2){$n++;$t=@{};$a|%{$t[$j++%2]+=,$_};$a=$t.0+$t.1;$j=0}+$n
-
\$\begingroup\$ you can save a bit more: Try it online! \$\endgroup\$mazzy– mazzy2019年03月18日 04:49:41 +00:00Commented Mar 18, 2019 at 4:49
-
\$\begingroup\$ @muzzy, you're right again :) thanks \$\endgroup\$Andrei Odegov– Andrei Odegov2019年03月18日 07:41:17 +00:00Commented Mar 18, 2019 at 7:41
Lua (LuaJIT), (削除) 119 (削除ここまで) (削除) 96 (削除ここまで) 79 bytes
n=t;while 2~=n[2]do n={}for a=1,#t*2,2 do x=a-#t n[#n+1]=t[a]or t[x+x%2]end;t=n
MATLAB, 70 bytes
function s(l),x=max(l);find(find(l==2)==1+mod(2.^(1:x),x-1))*(l(2)~=2)
explanation:
every nth shuffle, 2 will be pushed n^2 indices down from its previous position, wrapping around when it reaches the last position. That means that the function for index(n) is
1+mod(2^n,list-size-1)
for a list-size of 10, then, the indices are:
- index(1) = 3 -> [1 6 2 7 3 8 4 9 5 10]
- index(2) = 5 -> [1 8 6 4 2 9 7 5 3 10]
- index(3) = 9 -> [1 9 8 7 6 5 4 3 2 10]
- index(4) = 17 => 8 -> [1 5 9 4 8 3 7 2 6 10]
etc.
Using this, I find the index where 2 is, and find which power of 2 that is along the array. That power corresponds the the number of shuffles. To account for 0 shuffles, the whole thing is multiplied by the boolean value of l(2)~=2 to make sure that it returns 0 when 2 is in the right place, which only happens for an unshuffled array.
-
\$\begingroup\$ Welcome to CGCC! Pretty smart approach, so +1 from me. :) MATLAB doesn't have an online compiler, right? Since I don't see it in the tio.run list. Could you in that case perhaps add a screenshot as verification for the test cases? :) \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2021年03月04日 21:49:01 +00:00Commented Mar 4, 2021 at 21:49
Wolfram Language (Mathematica), 62 bytes
c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c
Explanation
The input list is a . It is unriffled and compared with the sorted list until they match.
Red, (削除) 87 (削除ここまで) (削除) 79 (削除ここまで) 78 bytes
func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]
Pyth, 18 bytes
L?SIb0hys%L2>Bb1
y
-2 thanks to @Erik the Outgolfer.
The script has two line: the first one defines a function y, the second line calls y with the implicit Q (evaluated stdin) argument.
L?SIb0hys%L2>Bb1
L function y(b)
? if...
SIb the Invariant b == sort(b) holds
0 return 0
h otherwise increment...
y ...the return of a recursive call with:
B the current argument "bifurcated", an array of:
b - the original argument
> 1 - same with the head popped off
L map...
% 2 ...take only every 2nd value in each array
s and concat them back together
PowerShell, (削除) 62 (削除ここまで) (削除) 71 (削除ここまで) (削除) 70 (削除ここまで) 66 bytes
+9 bytes when Test cases with an even number of elements added.
-1 byte with splatting.
-4 bytes: wrap the expression with $i,$j to a new scope.
for($a=$args;$a[1]-2;$a=&{($a|?{++$j%2})+($a|?{$i++%2})}){$n++}+$n
Japt, (削除) 13 (削除ここまで) (削除) 11 (削除ここまで) 10 bytes
Taking my shiny, new(削除) , very-work-in-progress (削除ここまで) interpreter for a test drive.
ÅÎÍ©ÒßUñÏu
ÅÎÍ©ÒßUñÏu :Implicit input of integer array U
Å :Slice the first element off U
Î :Get the first element
Í :Subtract from 2
© :Logical AND with
Ò : Negation of bitwise NOT of
ß : A recursive call to the programme with input
Uñ : U sorted
Ï : By 0-based indices
u : Modulo 2
-
1\$\begingroup\$ This interpreter looks super cool. \$\endgroup\$recursive– recursive2019年03月11日 23:51:55 +00:00Commented Mar 11, 2019 at 23:51
Vyxal 3, 7 bytes
ϩUJiɨγS
ϩUJiɨγS
ϩ i # Apply and collect until value is no longer unique, including initial value
UJ # Uninterleave and append
ɨγS # first index where the list is sorted (invariant after sort)
💎
Created with the help of Luminespire.
Uiua, 23 bytes
F←|1 ⨬(+1F⊏⍏◿2°⊏|0◌)≍⊸⍆.
Explained:
F←|1 ⨬(+1F⊏⍏◿2°⊏|0◌)≍⊸⍆. # F is a |1.1 function (1 in, 1 out)
⨬( | )≍⊸⍆ # if the array is sorted
0◌ . # return 0 (and discard copied input)
°⊏ # otherwise, generate 0..n
+1F⊏⍏◿2 # mod 2
⍏ # grade (returns sorted indices)
⊏ . # index into our original input, that's as shufflin'
+1F # recurse and add 1 to the recursion count
-
\$\begingroup\$ Would you mind adding a uiua.org/pad link with a Test Suite? \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2025年02月12日 14:06:28 +00:00Commented Feb 12 at 14:06
-
\$\begingroup\$ The link has 3 tests, I added asserts atop. \$\endgroup\$Ven– Ven2025年02月12日 17:21:07 +00:00Commented Feb 12 at 17:21
-
1\$\begingroup\$ Ah, didn't knew you added the test suite to the link in the header. Usually the links in the header goes to github or wiki pages and people add a separated 'try it online' link. :) But thanks for the edit nonetheless. \$\endgroup\$Kevin Cruijssen– Kevin Cruijssen2025年02月12日 19:42:21 +00:00Commented Feb 12 at 19:42
Python 3, 40 bytes
f=lambda x:x[1]-2and 1+f(x[::2]+x[1::2]) # 1-based
f=lambda x:x[1]-1and 1+f(x[::2]+x[1::2]) # 0-based
I need to refresh the page more frequently: missed Erik the Outgolfer's edit doing a similar trick =)
-
1\$\begingroup\$ -2 by removing the
f=. No need to assign the lambda to a variable, it is allowed without it; and it's still possible to call it. The "invisible" variable_is set to the last evaluated value, solambda x:x[1]-2and 1+f(x[::2]+x[1::2])would set_to that exact lambda. \$\endgroup\$Makonede– Makonede2021年01月18日 17:17:32 +00:00Commented Jan 18, 2021 at 17:17 -
\$\begingroup\$ Oh, this is brilliant! I will certainly have fun (and debugging profit) playing with it \$\endgroup\$Alex– Alex2021年01月18日 21:01:10 +00:00Commented Jan 18, 2021 at 21:01
-
\$\begingroup\$ No way to demonstrate it though: it only works in REPL mode \$\endgroup\$Alex– Alex2021年01月18日 21:17:56 +00:00Commented Jan 18, 2021 at 21:17
-
\$\begingroup\$ Never mind, I only just realized that you use recursion and need it assigned to
f. However, for answers that don't use recursion you still don't need it. \$\endgroup\$Makonede– Makonede2021年02月26日 21:55:49 +00:00Commented Feb 26, 2021 at 21:55
[1,3,5,7,9,2,4,6,8]is of length 9, but I will add a few more for lengths 7 and 11 perhaps. EDIT: Added the test cases[1,3,5,7,2,4,6] = 2(length 7) and[1,6,11,5,10,4,9,3,8,2,7] = 6(length 11). Hope that helps. \$\endgroup\$[1,6,2,7,3,8,4,9,5,10]or[6,1,7,2,8,3,9,4,10,5]are possible. In my challenge it does mean that the top card will always remain the top card, so it's indeed a bit of a con-trick.. I've never seen someone irl use only riffle-shuffles to shuffle a deck of cards however. Usually they also use other type of shuffles in between. Anyway, it's too late to change the challenge now, so for the sake of this challenge the top card will always remain the top card after a riffle-shuffle. \$\endgroup\$