Number reversal game: Difference between revisions
(168 intermediate revisions by 71 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Games}} |
{{task|Games}} |
||
[[Category:Puzzles]] |
|||
Given a jumbled list of the numbers 1 to 9 that are definitely ''not'' in ascending order, show the list then |
|||
ask the player how many digits from the left to reverse. |
|||
;Task: |
|||
Reverse those digits, then ask again, until all the |
|||
Given a jumbled list of the numbers '''1''' to '''9''' that are definitely ''not'' in |
|||
digits end up in ascending order. |
|||
ascending order. |
|||
Show the list, and then ask the player how many digits from the |
|||
left to reverse. |
|||
Reverse those digits, then ask again, until all the digits end up in ascending order. |
|||
The score is the count of the reversals needed to attain the ascending order. |
The score is the count of the reversals needed to attain the ascending order. |
||
Note: Assume the players input does not need extra validation. |
|||
Note: Assume the player's input does not need extra validation. |
|||
<br>C.f: [[Sorting algorithms/Pancake sort]], [[wp:Pancake sorting|Pancake sorting]]. |
|||
;Related tasks: |
|||
* [[Sorting algorithms/Pancake sort]] |
|||
* [[wp:Pancake sorting|Pancake sorting]]. |
|||
* [[Topswops]] |
|||
<br><br> |
|||
=={{header|8080 Assembly}}== |
|||
<syntaxhighlight lang="8080asm">rawio: equ 6 |
|||
org 100h |
|||
;;; Initialize RNG from keypresses |
|||
lxi d,keys |
|||
call puts |
|||
mvi b,4 ; 4*4 = 16 bytes |
|||
rndini: mvi c,4 |
|||
lxi h,rnddat |
|||
rndin2: push b |
|||
push h |
|||
rndkey: call keyin ; Get key |
|||
ana a |
|||
jz rndkey |
|||
pop h |
|||
pop b |
|||
xra m ; XOR into random data |
|||
mov m,a |
|||
inx h |
|||
dcr c |
|||
jnz rndin2 |
|||
dcr b |
|||
jnz rndini |
|||
lxi d,done |
|||
call puts |
|||
;;; Create and shuffle array of numbers |
|||
mvi a,'1' ; Start at 1 |
|||
mvi b,9 ; 9 items |
|||
lxi h,list |
|||
mklst: mov m,a ; Store item |
|||
inr a ; Increment item |
|||
inx h ; Increment pointer |
|||
dcr b ; One fewer list |
|||
jnz mklst |
|||
mov m,b ; Zero-terminate the list |
|||
lxi d,list+8 |
|||
shuf: call rande ; Shuffle the list. E = high, L = low |
|||
mov l,a |
|||
ldax d ; Load current number |
|||
mov b,m ; Load number to swap with |
|||
mov m,a ; Store first number |
|||
mov a,b ; Store second number |
|||
stax d |
|||
dcr e ; Move pointer back |
|||
jnz shuf ; Keep going until list is shuffled |
|||
lxi h,0 ; Keep score on stack |
|||
push h |
|||
;;; Game loop |
|||
game: lxi d,list ; Print current state |
|||
call puts |
|||
lxi d,list |
|||
ldax d |
|||
check: mov b,a ; Check if list is sorted (done) |
|||
inx d |
|||
ldax d |
|||
ana a ; Reached end of list? |
|||
jz win ; Then the list is in order |
|||
cmp b ; Larger than previous? |
|||
jnc check ; Then keep going |
|||
lxi d,prompt |
|||
call puts ; Ask for a number |
|||
call getnum |
|||
mov b,a ; B = high number |
|||
dcr b |
|||
mvi c,0 ; C = low number |
|||
mvi h,listhi |
|||
swap: mov l,c ; Load high number in D |
|||
mov d,m |
|||
mov l,b ; Load high number in E |
|||
mov e,m |
|||
mov m,d ; Store low number in high place |
|||
mov l,c |
|||
mov m,e ; Store high number in low place |
|||
dcr b ; Decrement high index |
|||
inr c ; Increment low index |
|||
mov a,c ; Low < high? |
|||
cmp b |
|||
jc swap ; Then keep swapping |
|||
lxi d,nl ; Print newline |
|||
call puts |
|||
pop h ; Increment score |
|||
inx h |
|||
push h |
|||
jmp game |
|||
win: lxi d,winmsg |
|||
call puts ; Print win message |
|||
lxi h,score |
|||
xthl ; Retrieve score and push score output buffer |
|||
lxi b,-10 ; Divisor |
|||
digit: lxi d,-1 ; Quotient |
|||
dgdiv: inx d ; Find digit |
|||
dad b |
|||
jc dgdiv |
|||
mvi a,'0'+10 |
|||
add l ; Store digit |
|||
pop h ; Get pointer |
|||
dcx h ; Decrement pointer |
|||
mov m,a ; Write digit to memory |
|||
push h ; Store pointer |
|||
xchg ; Continue with quotient |
|||
mov a,h ; Done yet? |
|||
ora l |
|||
jnz digit ; If not keep going |
|||
pop d ; Retrieve pointer |
|||
;;; Print 0-terminated string |
|||
puts: ldax d ; Get character |
|||
ana a ; Is it zero? |
|||
rz ; Then stop |
|||
inx d ; Otherwise, increment buffer pointer |
|||
push d ; Save buffer pointer |
|||
mov e,a ; Print character |
|||
call io |
|||
pop d ; Restore buffer pointer |
|||
jmp puts ; Next character |
|||
;;; Read 1-9 key |
|||
gnerr: mvi e,7 |
|||
call io |
|||
getnum: call keyin |
|||
ana a |
|||
jz getnum ; If no key, wait for one |
|||
cpi '1' |
|||
jc gnerr ; Not valid - beep and try again |
|||
cpi '9'+1 |
|||
jnc gnerr |
|||
push psw ; Valid - echo |
|||
mov e,a |
|||
call io |
|||
pop psw |
|||
sui '0' |
|||
ret |
|||
keyin: mvi e,0FFh ; Read key |
|||
io: mvi c,rawio ; CP/M raw I/O call |
|||
jmp 5 |
|||
;;; Random number up to E |
|||
rande: call rand |
|||
ani 15 |
|||
cmp e |
|||
jnc rande |
|||
ret |
|||
;;; RNG |
|||
rand: push h! lxi h,rnddat! inr m! mov a,m! inx h! xra m! inx h! xra m |
|||
mov m,a! inx h! add m! mov m,a! rar! dcx h! xra m! dcx h! add m |
|||
mov m,a! pop h |
|||
ret |
|||
prompt: db 9,' - Reverse how many? ',0 |
|||
keys: db 'Please press some keys to seed the RNG...',0 |
|||
done: db 'done.' |
|||
nl: db 13,10,0 |
|||
winmsg: db 13,10,'You win! Score = ',0 |
|||
db '*****' |
|||
score: db 13,10,0 |
|||
listhi: equ $/256+1 |
|||
list: equ listhi*256 |
|||
rnddat: equ list+16 |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Please press some keys to seed the RNG...done. |
|||
295671438 - Reverse how many? 2 |
|||
925671438 - Reverse how many? 9 |
|||
834176529 - Reverse how many? 8 |
|||
256714389 - Reverse how many? 4 |
|||
765214389 - Reverse how many? 7 |
|||
341256789 - Reverse how many? 2 |
|||
431256789 - Reverse how many? 4 |
|||
213456789 - Reverse how many? 2 |
|||
123456789 |
|||
You win! Score = 8</pre> |
|||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="11l">V data = Array(‘139275486’) |
|||
V trials = 0 |
|||
L data != sorted(data) |
|||
trials++ |
|||
V flip = Int(input(‘###2: LIST: '#.' Flip how many?: ’.format(trials, data.join(‘ ’)))) |
|||
data.reverse_range(0 .< flip) |
|||
print("\nYou took #. attempts to put the digits in order!".format(trials))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
# 1: LIST: '1 3 9 2 7 5 4 8 6' Flip how many?: 9 |
|||
# 2: LIST: '6 8 4 5 7 2 9 3 1' Flip how many?: 6 |
|||
# 3: LIST: '2 7 5 4 8 6 9 3 1' Flip how many?: 8 |
|||
# 4: LIST: '3 9 6 8 4 5 7 2 1' Flip how many?: 7 |
|||
# 5: LIST: '7 5 4 8 6 9 3 2 1' Flip how many?: 3 |
|||
# 6: LIST: '4 5 7 8 6 9 3 2 1' Flip how many?: 6 |
|||
# 7: LIST: '9 6 8 7 5 4 3 2 1' Flip how many?: 2 |
|||
# 8: LIST: '6 9 8 7 5 4 3 2 1' Flip how many?: 4 |
|||
# 9: LIST: '7 8 9 6 5 4 3 2 1' Flip how many?: 3 |
|||
#10: LIST: '9 8 7 6 5 4 3 2 1' Flip how many?: 9 |
|||
You took 10 attempts to put the digits in order! |
|||
</pre> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">PROC KnuthShuffle(BYTE ARRAY tab BYTE size) |
|||
BYTE i,j,tmp |
|||
i=size-1 |
|||
WHILE i>0 |
|||
DO |
|||
j=Rand(i+1) |
|||
tmp=tab(i) |
|||
tab(i)=tab(j) |
|||
tab(j)=tmp |
|||
i==-1 |
|||
OD |
|||
RETURN |
|||
BYTE FUNC IsSorted(BYTE ARRAY tab BYTE size) |
|||
BYTE i |
|||
FOR i=0 TO size-2 |
|||
DO |
|||
IF tab(i)>tab(i+1) THEN |
|||
RETURN (0) |
|||
FI |
|||
OD |
|||
RETURN (1) |
|||
PROC Swap(BYTE ARRAY tab BYTE size,count) |
|||
BYTE i,j,tmp |
|||
i=0 j=count-1 |
|||
WHILE i<j |
|||
DO |
|||
tmp=tab(i) |
|||
tab(i)=tab(j) |
|||
tab(j)=tmp |
|||
i==+1 j==-1 |
|||
OD |
|||
RETURN |
|||
PROC Main() |
|||
DEFINE SIZE="9" |
|||
BYTE ARRAY a(SIZE) |
|||
BYTE i,j,n,tmp |
|||
BYTE LMARGIN=$52,oldLMARGIN |
|||
oldLMARGIN=LMARGIN |
|||
LMARGIN=0 ;remove left margin on the screen |
|||
Put(125) PutE() ;clear the screen |
|||
FOR i=0 TO SIZE-1 |
|||
DO |
|||
a(i)=i+1 |
|||
OD |
|||
KnuthShuffle(a,SIZE) |
|||
i=0 |
|||
DO |
|||
PrintF("%B: ",i) |
|||
FOR j=0 TO SIZE-1 |
|||
DO |
|||
PrintB(a(j)) |
|||
OD |
|||
IF IsSorted(a,SIZE) THEN |
|||
EXIT |
|||
FI |
|||
PrintF(" How many to flip (2-%B)? ",SIZE) |
|||
n=InputB() |
|||
IF n>=2 AND n<=SIZE THEN |
|||
Swap(a,SIZE,n) |
|||
i==+1 |
|||
FI |
|||
OD |
|||
PrintF("%E%EYou solved it in %B moves!",i) |
|||
LMARGIN=oldLMARGIN ;restore left margin on the screen |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Number_reversal_game.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
0: 987152346 How many to flip (2-9)? 9 |
|||
1: 643251789 How many to flip (2-9)? 6 |
|||
2: 152346789 How many to flip (2-9)? 2 |
|||
3: 512346789 How many to flip (2-9)? 5 |
|||
4: 432156789 How many to flip (2-9)? 4 |
|||
5: 123456789 |
|||
You solved it in 5 moves! |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada"> |
||
with Ada.Text_Io; use Ada.Text_Io; |
with Ada.Text_Io; use Ada.Text_Io; |
||
with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; |
with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; |
||
Line 87: | Line 388: | ||
Integer'Image(Count) & " tries."); |
Integer'Image(Count) & " tries."); |
||
end NumberReverse; |
end NumberReverse; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|ALGOL 68}}== |
|||
Using code from the [[Knuth shuffle#ALGOL 68|Knuth shuffle]] task. |
|||
<syntaxhighlight lang="algol68"> |
|||
BEGIN # play the number reversal game # |
|||
CO begin code from the Knuth shuffle task CO |
|||
PROC between = (INT a, b)INT : |
|||
( |
|||
ENTIER (random * ABS (b-a+1) + (a<b|a|b)) |
|||
); |
|||
PROC knuth shuffle = (REF[]INT a)VOID: |
|||
( |
|||
FOR i FROM LWB a TO UPB a DO |
|||
INT j = between(LWB a, UPB a); |
|||
INT t = a[i]; |
|||
a[i] := a[j]; |
|||
a[j] := t |
|||
OD |
|||
); |
|||
CO end code from the Knuth shuffle task CO |
|||
[]INT ordered digits = ( 1, 2, 3, 4, 5, 6, 7, 8, 9 ); |
|||
[ 1 : 9 ]INT digits := ordered digits; |
|||
knuth shuffle( digits ); |
|||
# ignore invalid data in stand in # |
|||
on value error( stand in, ( REF FILE f )BOOL: TRUE ); |
|||
PROC print digits = VOID: # prints the digits # |
|||
BEGIN |
|||
print( ( "The digits are:" ) ); |
|||
FOR i TO 9 DO print( ( whole( digits[ i ], -2 ) ) ) OD; |
|||
print( ( newline ) ) |
|||
END # print digits # ; |
|||
OP = = ( []INT a, b )BOOL: # returns TRUE if a = b # |
|||
IF LWB a /= LWB b OR UPB a /= UPB b THEN |
|||
FALSE # a and b have different bounds # |
|||
ELSE |
|||
# a and b ave the same bounds # |
|||
BOOL same := TRUE; |
|||
FOR i FROM LWB a TO UPB a WHILE same DO same := a[ i ] = b[ i ] OD; |
|||
same |
|||
FI # = # ; |
|||
OP /= = ( []INT a, b )BOOL: NOT ( a = b ); # returns TRUE if a not = b # |
|||
INT count := 0; |
|||
print digits; |
|||
WHILE digits /= ordered digits DO |
|||
print( ( "How many digits to reverse (2-9)? " ) ); |
|||
INT n := 0; |
|||
read( ( n, newline ) ); |
|||
IF n >= 2 AND n <= 9 THEN |
|||
# reverse the n left-most digits # |
|||
count +:= 1; |
|||
INT r pos := n; |
|||
FOR pos TO n OVER 2 DO |
|||
INT t = digits[ r pos ]; |
|||
digits[ r pos ] := digits[ pos ]; |
|||
digits[ pos ] := t; |
|||
r pos -:= 1 |
|||
OD; |
|||
print digits |
|||
FI |
|||
OD; |
|||
print( ( newline, "You ordered the digits in ", whole( count, 0 ), " moves", newline ) ) |
|||
END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
The digits are: 9 6 4 3 8 7 1 5 2 |
|||
How many digits to reverse (2-9)? 4 |
|||
The digits are: 3 4 6 9 8 7 1 5 2 |
|||
How many digits to reverse (2-9)? 6 |
|||
The digits are: 7 8 9 6 4 3 1 5 2 |
|||
How many digits to reverse (2-9)? 3 |
|||
The digits are: 9 8 7 6 4 3 1 5 2 |
|||
How many digits to reverse (2-9)? 9 |
|||
The digits are: 2 5 1 3 4 6 7 8 9 |
|||
How many digits to reverse (2-9)? 2 |
|||
The digits are: 5 2 1 3 4 6 7 8 9 |
|||
How many digits to reverse (2-9)? 5 |
|||
The digits are: 4 3 1 2 5 6 7 8 9 |
|||
How many digits to reverse (2-9)? 4 |
|||
The digits are: 2 1 3 4 5 6 7 8 9 |
|||
How many digits to reverse (2-9)? 2 |
|||
The digits are: 1 2 3 4 5 6 7 8 9 |
|||
You ordered the digits in 8 moves |
|||
</pre> |
|||
=={{header|APL}}== |
|||
{{works with|Dyalog APL}} |
|||
<syntaxhighlight lang="apl">∇numrev;list;in;swaps |
|||
list←{9?9}⍣{⍺≢⍳9}⊢⍬ |
|||
swaps←0 |
|||
read: |
|||
swaps+←1 |
|||
in←{⍞←⍵⋄(≢⍵)↓⍞}(⍕list),': swap how many? ' |
|||
list←⌽@(⍳⍎in)⊢list |
|||
→(list≢⍳9)/read |
|||
⎕←(⍕list),': Congratulations!' |
|||
⎕←'Swaps:',swaps |
|||
∇</syntaxhighlight> |
|||
{{out}} |
|||
<pre>8 7 2 6 5 3 1 9 4: swap how many? 8 |
|||
9 1 3 5 6 2 7 8 4: swap how many? 9 |
|||
4 8 7 2 6 5 3 1 9: swap how many? 3 |
|||
7 8 4 2 6 5 3 1 9: swap how many? 2 |
|||
8 7 4 2 6 5 3 1 9: swap how many? 8 |
|||
1 3 5 6 2 4 7 8 9: swap how many? 4 |
|||
6 5 3 1 2 4 7 8 9: swap how many? 6 |
|||
4 2 1 3 5 6 7 8 9: swap how many? 4 |
|||
3 1 2 4 5 6 7 8 9: swap how many? 3 |
|||
2 1 3 4 5 6 7 8 9: swap how many? 2 |
|||
1 2 3 4 5 6 7 8 9: Congratulations! |
|||
Swaps: 10</pre> |
|||
=={{header|Applesoft BASIC}}== |
|||
<syntaxhighlight lang="applesoftbasic"> 100 LET M$ = CHR$ (13) |
|||
110 LET A$ = "123456789" |
|||
120 FOR S = 0 TO 1 STEP 0 |
|||
130 LET N$ = A$ |
|||
140 FOR I = 1 TO 9 |
|||
150 LET R = INT ( RND (1) * 9 + 1) |
|||
160 GOSUB 500SWAP |
|||
170 NEXT I |
|||
180 LET S = N$ < > A$ |
|||
190 NEXT S |
|||
200 FOR S = 1 TO 1E9 |
|||
210 PRINT M$"HOW MANY DIGITS "N$M$" FROM THE LEFT ^^^^^^^^^"M$" TO REVERSE? "A$ |
|||
230 INPUT "--------------> ";N% |
|||
300 FOR I = 1 TO INT (N% / 2) |
|||
310 LET R = N% - I + 1 |
|||
320 GOSUB 500SWAP |
|||
330 NEXT I |
|||
340 IF N$ = A$ THEN PRINT M$"SCORE "S;: END |
|||
350 NEXT S |
|||
500 LET I$ = MID$ (N$,I,1) |
|||
510 LET N$ = MID$ (N$,1,I - 1) + MID$ (N$,R,1) + MID$ (N$,I + 1) |
|||
520 LET N$ = MID$ (N$,1,R - 1) + I$ + MID$ (N$,R + 1) |
|||
530 RETURN |
|||
</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
{{trans|Ruby}} |
|||
<syntaxhighlight lang="rebol">arr: 1..9 |
|||
while [arr = sort arr]-> |
|||
arr: shuffle arr |
|||
score: 0 |
|||
while [arr <> sort arr][ |
|||
prints [arr "-- "] |
|||
digits: to :integer strip input "How many digits to reverse? " |
|||
arr: (reverse slice arr 0 digits-1) ++ slice arr digits (size arr)-1 |
|||
score: score + 1 |
|||
] |
|||
print ["Your score:" score]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[6 2 5 4 1 3 9 7 8] -- How many digits to reverse? 7 |
|||
[9 3 1 4 5 2 6 7 8] -- How many digits to reverse? 9 |
|||
[8 7 6 2 5 4 1 3 9] -- How many digits to reverse? 8 |
|||
[3 1 4 5 2 6 7 8 9] -- How many digits to reverse? 4 |
|||
[5 4 1 3 2 6 7 8 9] -- How many digits to reverse? 5 |
|||
[2 3 1 4 5 6 7 8 9] -- How many digits to reverse? 2 |
|||
[3 2 1 4 5 6 7 8 9] -- How many digits to reverse? 3 |
|||
Your score: 7 </pre> |
|||
=={{header|Astro}}== |
|||
<syntaxhighlight lang="python">print '# Number reversal game' |
|||
var data, trials = list(1..9), 0 |
|||
while data == sort data: |
|||
random.shuffle data |
|||
while data != sort data: |
|||
trials += 1 |
|||
flip = int input '#${trials}: LIST: ${join data} Flip how many?: ' |
|||
data[:flip] = reverse data[:flip] |
|||
print '\nYou took ${trials} attempts to put digits in order!'</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">; Submitted by MasterFocus --- http://tiny.cc/iTunis |
||
ScrambledList := CorrectList := "1 2 3 4 5 6 7 8 9" ; Declare two identical correct sequences |
ScrambledList := CorrectList := "1 2 3 4 5 6 7 8 9" ; Declare two identical correct sequences |
||
Line 123: | Line 615: | ||
Out := A_LoopField Out |
Out := A_LoopField Out |
||
Return Out |
Return Out |
||
}</ |
}</syntaxhighlight> |
||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
< |
<syntaxhighlight lang="awk">BEGIN { |
||
print "\nWelcome to the number reversal game!\n" |
print "\nWelcome to the number reversal game!\n" |
||
Line 204: | Line 696: | ||
} |
} |
||
END { print "\n\nBye!" }</ |
END { print "\n\nBye!" }</syntaxhighlight> |
||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
Line 211: | Line 703: | ||
{{works with|FreeBASIC}} |
{{works with|FreeBASIC}} |
||
< |
<syntaxhighlight lang="qbasic">PRINT "Given a jumbled list of the numbers 1 to 9," |
||
PRINT "you must select how many digits from the left to reverse." |
PRINT "you must select how many digits from the left to reverse." |
||
PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right." |
PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right." |
||
Line 265: | Line 757: | ||
LOOP |
LOOP |
||
PRINT : PRINT "You took "; LTRIM$(RTRIM$(STR$(tries))); " tries to put the digits in order."</ |
PRINT : PRINT "You took "; LTRIM$(RTRIM$(STR$(tries))); " tries to put the digits in order."</syntaxhighlight> |
||
Sample output: |
Sample output: |
||
<pre> |
|||
Given a jumbled list of the numbers 1 to 9, |
Given a jumbled list of the numbers 1 to 9, |
||
you must select how many digits from the left to reverse. |
you must select how many digits from the left to reverse. |
||
Line 280: | Line 773: | ||
7 : 1 2 3 4 5 6 7 8 9 |
7 : 1 2 3 4 5 6 7 8 9 |
||
You took 7 tries to put the digits in order. |
You took 7 tries to put the digits in order. |
||
</pre> |
|||
=={{header|BASIC256}}== |
|||
<syntaxhighlight lang="basic256"> |
|||
print "Dada una lista aleatoria de numeros del 1 al 9," |
|||
print "indica cuantos digitos de la izquierda voltear." |
|||
print " El objetivo es obtener los digitos en orden " |
|||
print " con el 1 a la izquierda y el 9 a la derecha." + chr(10) |
|||
dim nums(10) |
|||
dim a(10) |
|||
intentos = 0: denuevo = true: colum = 6 |
|||
#valores iniciales |
|||
for i = 1 to 9 |
|||
nums[i] = i |
|||
next i |
|||
do #barajamos |
|||
for i = 9 to 2 step -1 |
|||
n = int(rand * i) + 1 |
|||
if n <> i then |
|||
a[i] = nums[i] |
|||
nums[i] = nums[n] |
|||
nums[n] = a[i] |
|||
end if |
|||
next i |
|||
for i = 1 to 8 #nos aseguramos que no estén en orden |
|||
if nums[i] > nums[i + 1] then exit do |
|||
next i |
|||
until false |
|||
do |
|||
if intentos < 10 then print " "; |
|||
print intentos; ": "; |
|||
for i = 1 to 9 |
|||
print nums[i];" "; |
|||
next i |
|||
if not denuevo then exit do |
|||
input " -- Cuantos volteamos ", volteo |
|||
if volteo < 0 or volteo > 9 then volteo = 0 |
|||
for i = 1 to (volteo \ 2) |
|||
a[i] = nums[volteo - i + 1] |
|||
nums[volteo - i + 1] = nums[i] |
|||
nums[i] = a[i] |
|||
next i |
|||
denuevo = false |
|||
#comprobamos el orden |
|||
for i = 1 to 8 |
|||
if nums[i] > nums[i + 1] then |
|||
denuevo = true |
|||
exit for |
|||
end if |
|||
next i |
|||
if volteo > 0 then intentos += 1 |
|||
until false |
|||
print chr(10) + chr(10) + " Necesitaste "; intentos; " intentos." |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Dada una lista aleatoria de numeros del 1 al 9, |
|||
indica cuantos digitos de la izquierda voltear. |
|||
El objetivo es obtener los digitos en orden |
|||
con el 1 a la izquierda y el 9 a la derecha. |
|||
0: 2 1 4 3 5 9 8 6 7 -- Cuantos volteamos 6 |
|||
1: 9 5 3 4 1 2 8 6 7 -- Cuantos volteamos 9 |
|||
2: 7 6 8 2 1 4 3 5 9 -- Cuantos volteamos 3 |
|||
3: 8 6 7 2 1 4 3 5 9 -- Cuantos volteamos 8 |
|||
4: 5 3 4 1 2 7 6 8 9 -- Cuantos volteamos 6 |
|||
5: 7 2 1 4 3 5 6 8 9 -- Cuantos volteamos 7 |
|||
6: 6 5 3 4 1 2 7 8 9 -- Cuantos volteamos 6 |
|||
7: 2 1 4 3 5 6 7 8 9 -- Cuantos volteamos 3 |
|||
8: 4 1 2 3 5 6 7 8 9 -- Cuantos volteamos 4 |
|||
9: 3 2 1 4 5 6 7 8 9 -- Cuantos volteamos 3 |
|||
10: 1 2 3 4 5 6 7 8 9 |
|||
Necesitaste 10 intentos. |
|||
</pre> |
|||
=={{header|Batch File}}== |
|||
Note that I did not use the FOR command for looping. I used Batch File labels instead. |
|||
<syntaxhighlight lang="dos"> |
|||
:: |
|||
::Number Reversal Game Task from Rosetta Code Wiki |
|||
::Batch File Implementation |
|||
:: |
|||
::Please do not open this from command prompt. |
|||
::Directly Open the Batch File to play... |
|||
:: |
|||
@echo off |
|||
setlocal enabledelayedexpansion |
|||
title Number Reversal Game |
|||
:begin |
|||
set score=0 |
|||
::The ascending list of 9 digits |
|||
set list=123456789 |
|||
::Generating a random set of 9 digits... |
|||
set cyc=9 |
|||
:gen |
|||
set /a tmp1=%random%%%%cyc% |
|||
set n%cyc%=!list:~%tmp1%,1! |
|||
set tmp2=!n%cyc%! |
|||
set list=!list:%tmp2%=! |
|||
if not %cyc%==2 ( |
|||
set /a cyc-=1 |
|||
goto :gen |
|||
) |
|||
set /a n1=%list% |
|||
::Display the Game |
|||
cls |
|||
echo. |
|||
echo ***Number Reversal Game*** |
|||
:loopgame |
|||
echo. |
|||
echo Current arrangement: %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9% |
|||
set /p move=How many digits from the left should I reverse? |
|||
::Reverse digits according to the player's input |
|||
::NOTE: The next command uses the fact that in Batch File, |
|||
::The output for the division operation is only the integer part of the quotient. |
|||
set /a lim=(%move%+1)/2 |
|||
set cyc2=1 |
|||
:reverse |
|||
set /a tmp4=%move%-%cyc2%+1 |
|||
set tmp5=!n%cyc2%! |
|||
set n%cyc2%=!n%tmp4%! |
|||
set n%tmp4%=%tmp5% |
|||
if not %cyc2%==%lim% ( |
|||
set /a cyc2+=1 |
|||
goto :reverse |
|||
) |
|||
::Increment the number of moves took by the player |
|||
set /a score+=1 |
|||
::IF already won... |
|||
if %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9%==123456789 ( |
|||
echo. |
|||
echo Set: %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9% DONE^^! |
|||
echo You took %score% moves to arrange the numbers in ascending order. |
|||
pause>nul |
|||
exit |
|||
) else ( |
|||
goto :loopgame |
|||
) |
|||
</syntaxhighlight> |
|||
Sample Output: |
|||
<pre> |
|||
***Number Reversal Game*** |
|||
Current arrangement: 349718652 |
|||
How many digits from the left should I reverse?3 |
|||
Current arrangement: 943718652 |
|||
How many digits from the left should I reverse?9 |
|||
Current arrangement: 256817349 |
|||
How many digits from the left should I reverse?4 |
|||
Current arrangement: 865217349 |
|||
How many digits from the left should I reverse?8 |
|||
Current arrangement: 437125689 |
|||
How many digits from the left should I reverse?3 |
|||
Current arrangement: 734125689 |
|||
How many digits from the left should I reverse?7 |
|||
Current arrangement: 652143789 |
|||
How many digits from the left should I reverse?6 |
|||
Current arrangement: 341256789 |
|||
How many digits from the left should I reverse?2 |
|||
Current arrangement: 431256789 |
|||
How many digits from the left should I reverse?4 |
|||
Current arrangement: 213456789 |
|||
How many digits from the left should I reverse?2 |
|||
Set: 123456789 DONE! |
|||
You took 10 moves to arrange the numbers in ascending order. |
|||
</pre> |
|||
=={{header|BBC BASIC}}== |
|||
Note the use of the MOD(array()) function to test the equality of two arrays. |
|||
<syntaxhighlight lang="bbcbasic"> DIM list%(8), done%(8), test%(8) |
|||
list%() = 1, 2, 3, 4, 5, 6, 7, 8, 9 |
|||
done%() = list%() |
|||
REM Shuffle: |
|||
REPEAT |
|||
FOR i% = 9 TO 2 STEP -1 |
|||
SWAP list%(i%-1), list%(RND(i%)-1) |
|||
NEXT |
|||
test%() = list%() - done%() |
|||
UNTIL MOD(test%()) <> 0 |
|||
REM Run the game: |
|||
tries% = 0 |
|||
REPEAT |
|||
tries% += 1 |
|||
FOR i% = 0 TO 8 : PRINT ; list%(i%) " " ; : NEXT |
|||
INPUT ": Reverse how many", n% |
|||
PROCreverse(list%(), n%) |
|||
test%() = list%() - done%() |
|||
UNTIL MOD(test%()) = 0 |
|||
PRINT "You took " ; tries% " attempts." |
|||
END |
|||
DEF PROCreverse(a%(), n%) |
|||
IF n% < 2 ENDPROC |
|||
LOCAL i% |
|||
n% -= 1 |
|||
FOR i% = 0 TO n% DIV 2 |
|||
SWAP a%(i%), a%(n%-i%) |
|||
NEXT |
|||
ENDPROC</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre> |
|||
7 2 3 1 5 8 6 4 9 : Reverse how many? 6 |
|||
8 5 1 3 2 7 6 4 9 : Reverse how many? 8 |
|||
4 6 7 2 3 1 5 8 9 : Reverse how many? 3 |
|||
7 6 4 2 3 1 5 8 9 : Reverse how many? 7 |
|||
5 1 3 2 4 6 7 8 9 : Reverse how many? 5 |
|||
4 2 3 1 5 6 7 8 9 : Reverse how many? 4 |
|||
1 3 2 4 5 6 7 8 9 : Reverse how many? 3 |
|||
2 3 1 4 5 6 7 8 9 : Reverse how many? 2 |
|||
3 2 1 4 5 6 7 8 9 : Reverse how many? 3 |
|||
You took 9 attempts. |
|||
</pre> |
|||
=={{header|Brat}}== |
=={{header|Brat}}== |
||
< |
<syntaxhighlight lang="brat">sorted = 1.to 9 |
||
length = sorted.length |
length = sorted.length |
||
numbers = sorted.shuffle |
numbers = sorted.shuffle |
||
Line 300: | Line 1,038: | ||
p numbers |
p numbers |
||
p "It took #{turns} turns to sort numbers."</ |
p "It took #{turns} turns to sort numbers."</syntaxhighlight> |
||
=={{header|C}}== |
=={{header|C}}== |
||
An example of a number reversal game could be: |
An example of a number reversal game could be: |
||
< |
<syntaxhighlight lang="c">void number_reversal_game() |
||
{ |
{ |
||
printf("Number Reversal Game. Type a number to flip the first n numbers."); |
printf("Number Reversal Game. Type a number to flip the first n numbers."); |
||
Line 335: | Line 1,073: | ||
} |
} |
||
printf("Hurray! You solved it in %d moves!\n", tries); |
printf("Hurray! You solved it in %d moves!\n", tries); |
||
}</ |
}</syntaxhighlight> |
||
Which uses the following helper functions: |
Which uses the following helper functions: |
||
< |
<syntaxhighlight lang="c">void shuffle_list(int *list, int len) |
||
{ |
{ |
||
//We'll just be swapping 100 times. Could be more/less. Doesn't matter much. |
//We'll just be swapping 100 times. Could be more/less. Doesn't matter much. |
||
Line 381: | Line 1,119: | ||
} |
} |
||
return 1; |
return 1; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
|||
The C code can be used with C++, although the following uses proper C++ iostreams: |
|||
<lang CPP>void number_reversal_game() |
|||
{ |
|||
cout << "Number Reversal Game. Type a number to flip the first n numbers."; |
|||
cout << "You win by sorting the numbers in ascending order."; |
|||
cout << "Anything besides numbers are ignored.\n"; |
|||
cout << "\t |1__2__3__4__5__6__7__8__9|\n"; |
|||
int list[9] = {1,2,3,4,5,6,7,8,9}; |
|||
do |
|||
{ |
|||
shuffle_list(list,9); |
|||
} while(check_array(list, 9)); |
|||
int tries=0; |
|||
unsigned int i; |
|||
int input; |
|||
while(!check_array(list, 9)) |
|||
{ |
|||
cout << "Round " << tries << ((tries<10) ? " : " : " : "); |
|||
for(i=0;i<9;i++)cout << list[i] << " "; |
|||
cout << " Gimme that number:"; |
|||
while(1) |
|||
{ |
|||
cin >> input; |
|||
if(input>1&&input<10) |
|||
break; |
|||
cout << "\nPlease enter a number between 2 and 9:"; |
|||
} |
|||
tries++; |
|||
do_flip(list, 9, input); |
|||
} |
|||
cout << "Hurray! You solved it in %d moves!\n"; |
|||
}</lang> |
|||
This uses the same helper functions as the C version. |
|||
=== Alternate version using the C++ standard library === |
|||
This version uses the C++ standard library (note that none of the C helper functions are needed). |
|||
<lang cpp> |
|||
#include <iostream> |
|||
#include <algorithm> |
|||
#include <functional> |
|||
#include <iterator> |
|||
#include <cstdlib> |
|||
#include <ctime> |
|||
template<typename T, int size> |
|||
bool is_sorted(T (&array)[size]) |
|||
{ |
|||
return std::adjacent_find(array, array+size, std::greater<T>()) |
|||
== array+size; |
|||
} |
|||
int main() |
|||
{ |
|||
std::srand(std::time(0)); |
|||
int list[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
|||
do |
|||
{ |
|||
std::random_shuffle(list, list+9); |
|||
} while (is_sorted(list)); |
|||
int score = 0; |
|||
do |
|||
{ |
|||
std::cout << "Current list: "; |
|||
std::copy(list, list+9, std::ostream_iterator<int>(std::cout, " ")); |
|||
int rev; |
|||
while (true) |
|||
{ |
|||
std::cout << "\nDigits to reverse? "; |
|||
std::cin >> rev; |
|||
if (rev > 1 && rev < 10) |
|||
break; |
|||
std::cout << "Please enter a value between 2 and 9."; |
|||
} |
|||
++score; |
|||
std::reverse(list, list + rev); |
|||
} while (!is_sorted(list)); |
|||
std::cout << "Congratulations, you sorted the list.\n" |
|||
<< "You needed " << score << " reversals." << std::endl; |
|||
return 0; |
|||
} |
|||
</lang> |
|||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
C# 3.0 |
C# 3.0 |
||
< |
<syntaxhighlight lang="csharp">using System; |
||
using System.Linq; |
using System.Linq; |
||
Line 509: | Line 1,153: | ||
Console.ReadLine(); |
Console.ReadLine(); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
C# 1.0 |
C# 1.0 |
||
< |
<syntaxhighlight lang="csharp">class Program |
||
{ |
{ |
||
static void Main(string[] args) |
static void Main(string[] args) |
||
Line 597: | Line 1,241: | ||
return retArray; |
return retArray; |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
|||
===Version 1 (crude)=== |
|||
The C code can be used with C++, although the following uses proper C++ iostreams: |
|||
<syntaxhighlight lang="cpp">void number_reversal_game() |
|||
{ |
|||
cout << "Number Reversal Game. Type a number to flip the first n numbers."; |
|||
cout << "You win by sorting the numbers in ascending order."; |
|||
cout << "Anything besides numbers are ignored.\n"; |
|||
cout << "\t |1__2__3__4__5__6__7__8__9|\n"; |
|||
int list[9] = {1,2,3,4,5,6,7,8,9}; |
|||
do |
|||
{ |
|||
shuffle_list(list,9); |
|||
} while(check_array(list, 9)); |
|||
int tries=0; |
|||
unsigned int i; |
|||
int input; |
|||
while(!check_array(list, 9)) |
|||
{ |
|||
cout << "Round " << tries << ((tries<10) ? " : " : " : "); |
|||
for(i=0;i<9;i++)cout << list[i] << " "; |
|||
cout << " Gimme that number:"; |
|||
while(1) |
|||
{ |
|||
cin >> input; |
|||
if(input>1&&input<10) |
|||
break; |
|||
cout << "\nPlease enter a number between 2 and 9:"; |
|||
} |
|||
tries++; |
|||
do_flip(list, 9, input); |
|||
} |
|||
cout << "Hurray! You solved it in %d moves!\n"; |
|||
}</syntaxhighlight> |
|||
This uses the same helper functions as the C version. |
|||
===Version 2 (with C++ standard library)=== |
|||
====Version 2.1==== |
|||
This version uses the C++ standard library (note that none of the C helper functions are needed). |
|||
<syntaxhighlight lang="cpp"> |
|||
#include <iostream> |
|||
#include <algorithm> |
|||
#include <functional> |
|||
#include <iterator> |
|||
#include <cstdlib> |
|||
#include <ctime> |
|||
template<typename T, int size> |
|||
bool is_sorted(T (&array)[size]) |
|||
{ |
|||
return std::adjacent_find(array, array+size, std::greater<T>()) |
|||
== array+size; |
|||
} |
|||
int main() |
|||
{ |
|||
std::srand(std::time(0)); |
|||
int list[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
|||
do |
|||
{ |
|||
std::random_shuffle(list, list+9); |
|||
} while (is_sorted(list)); |
|||
int score = 0; |
|||
do |
|||
{ |
|||
std::cout << "Current list: "; |
|||
std::copy(list, list+9, std::ostream_iterator<int>(std::cout, " ")); |
|||
int rev; |
|||
while (true) |
|||
{ |
|||
std::cout << "\nDigits to reverse? "; |
|||
std::cin >> rev; |
|||
if (rev > 1 && rev < 10) |
|||
break; |
|||
std::cout << "Please enter a value between 2 and 9."; |
|||
} |
|||
++score; |
|||
std::reverse(list, list + rev); |
|||
} while (!is_sorted(list)); |
|||
std::cout << "Congratulations, you sorted the list.\n" |
|||
<< "You needed " << score << " reversals." << std::endl; |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
====Version 2.2==== |
|||
<syntaxhighlight lang="cpp"> |
|||
// Written by Katsumi -- twitter.com/realKatsumi_vn |
|||
// Compile with: g++ -std=c++20 -Wall -Wextra -pedantic NumberReversal.cpp -o NumberReversal |
|||
#include <iostream> |
|||
#include <algorithm> |
|||
#include <utility> |
|||
#include <functional> |
|||
#include <iterator> |
|||
#include <random> |
|||
#include <vector> |
|||
#include <string> |
|||
template <class T> |
|||
bool Sorted(std::vector<T> list) { |
|||
return std::adjacent_find(list.begin(), list.end(), std::greater<T>()) == list.end(); |
|||
} |
|||
template <class T> |
|||
std::string VectorRepr(std::vector<T> list) { |
|||
auto Separate = [](std::string a, int b) { |
|||
return std::move(a) + ", " + std::to_string(b); |
|||
}; |
|||
return std::accumulate(std::next(list.begin()), list.end(), std::to_string(list[0]), Separate); |
|||
} |
|||
int main() { |
|||
const std::string IntroText = "NUMBER REVERSAL GAME\n" |
|||
"based on a \"task\" on Rosetta Code -- rosettacode.org\n" |
|||
"by Katsumi -- twitter.com/realKatsumi.vn\n\n"; |
|||
// Don't ever write this s**tty code... |
|||
// std::srand(std::time(0)); |
|||
// Do this instead: |
|||
std::random_device Device; |
|||
std::mt19937_64 Generator(Device()); |
|||
std::vector<int> List = {1, 2, 3, 4, 5, 6, 7, 8, 9}; |
|||
std::shuffle(List.begin(), List.end(), Generator); |
|||
std::cout << IntroText; |
|||
int Moves, PlayerInput; |
|||
while (!Sorted(List)) { |
|||
std::cout << "Current list: [" << VectorRepr(List) << "]\n" |
|||
"Digits to reverse? (2-9) "; |
|||
while (true) { |
|||
std::cin >> PlayerInput; |
|||
if (PlayerInput < 2 || PlayerInput > 9) |
|||
std::cout << "Please enter a value between 2 and 9.\n" |
|||
"Digits to reverse? (2-9) "; |
|||
else |
|||
break; |
|||
} |
|||
std::reverse(List.begin(), List.begin()+PlayerInput); |
|||
++Moves; |
|||
} |
|||
std::cout << "Yay! You sorted the list! You've made " << Moves << " moves.\n"; |
|||
return 0; |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="clojure">(defn flip-at [n coll] |
||
(let [[x y] (split-at n coll)] |
(let [[x y] (split-at n coll)] |
||
(concat (reverse x) y ))) |
(concat (reverse x) y ))) |
||
Line 615: | Line 1,420: | ||
(flush) |
(flush) |
||
(let [flipcount (read)] |
(let [flipcount (read)] |
||
(recur (flip-at flipcount unsorted), (inc steps))))))</ |
(recur (flip-at flipcount unsorted), (inc steps))))))</syntaxhighlight> |
||
=={{header|CLU}}== |
|||
<syntaxhighlight lang="clu">% This program uses the random number generator from PCLU's |
|||
% 'misc.lib' |
|||
% Shuffle the given array. Every item ends up in a different place, |
|||
% so if given the numbers in ascending order, it is guaranteed that |
|||
% they will not still be in ascending order at the end. |
|||
jumble = proc [T: type] (a: array[T]) |
|||
for i: int in int$from_to_by(array[T]$high(a), array[T]$low(a)+1, -1) do |
|||
j: int := array[T]$low(a) + random$next(i - array[T]$low(a)) |
|||
x: T := a[i] |
|||
a[i] := a[j] |
|||
a[j] := x |
|||
end |
|||
end jumble |
|||
% Is the array sorted? |
|||
win = proc (a: array[int]) returns (bool) |
|||
for i: int in array[int]$indexes(a) do |
|||
if i ~= a[i] then return(false) end |
|||
end |
|||
return(true) |
|||
end win |
|||
% Reverse the first N items of the array |
|||
reverse = proc (n: int, a: array[int]) |
|||
for i: int in int$from_to(1, n/2) do |
|||
j: int := n-i+1 |
|||
x: int := a[j] |
|||
a[j] := a[i] |
|||
a[i] := x |
|||
end |
|||
end reverse |
|||
% Play the game |
|||
start_up = proc () |
|||
po: stream := stream$primary_output() |
|||
pi: stream := stream$primary_input() |
|||
d: date := now() |
|||
random$seed(d.second + 60*(d.minute + 60*d.hour)) |
|||
score: int := 0 |
|||
nums: array[int] := array[int]$[1,2,3,4,5,6,7,8,9] |
|||
jumble[int](nums) |
|||
while ~win(nums) do |
|||
for i: int in array[int]$elements(nums) do |
|||
stream$puts(po, int$unparse(i)) |
|||
end |
|||
stream$puts(po, ": reverse how many? ") |
|||
n: int := int$parse(stream$getl(pi)) |
|||
reverse(n, nums) |
|||
score := score + 1 |
|||
end |
|||
for i: int in array[int]$elements(nums) do |
|||
stream$puts(po, int$unparse(i)) |
|||
end |
|||
stream$putl(po, "\nScore = " || int$unparse(score)) |
|||
end start_up</syntaxhighlight> |
|||
{{out}} |
|||
<pre>792184365: reverse how many? 2 |
|||
972184365: reverse how many? 9 |
|||
563481279: reverse how many? 5 |
|||
843651279: reverse how many? 8 |
|||
721563489: reverse how many? 7 |
|||
436512789: reverse how many? 3 |
|||
634512789: reverse how many? 6 |
|||
215436789: reverse how many? 3 |
|||
512436789: reverse how many? 5 |
|||
342156789: reverse how many? 2 |
|||
432156789: reverse how many? 4 |
|||
123456789 |
|||
Score = 11</pre> |
|||
=={{header|COBOL}}== |
|||
<syntaxhighlight lang="cobol"> |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. REVERSAL. |
|||
AUTHOR. Bill Gunshannon |
|||
INSTALLATION. Home. |
|||
DATE-WRITTEN. 11 December 2021 |
|||
**************************************************************** |
|||
** Program Abstract: |
|||
** Use a Knuth Shuffle to reate our out ot sort array. |
|||
** Use a procedure called "reverse" to pancake sort the array. |
|||
**************************************************************** |
|||
DATA DIVISION. |
|||
WORKING-STORAGE SECTION. |
|||
01 RNUM PIC 9. |
|||
01 TRIES PIC 99 VALUE 0. |
|||
01 ANSWER PIC 9(9) VALUE 123456789. |
|||
01 TBL-LEN PIC 9 VALUE 9. |
|||
01 TBL. |
|||
05 TZ PIC 9(9). |
|||
05 TA REDEFINES TZ |
|||
PIC 9 OCCURS 9 TIMES. |
|||
PROCEDURE DIVISION. |
|||
MAIN-pROGRAM. |
|||
MOVE ANSWER TO TBL |
|||
CALL 'KNUTH-SHUFFLE' |
|||
USING BY REFERENCE TBL |
|||
END-CALL. |
|||
DISPLAY "TABLE after shuffle: " TBL. |
|||
PERFORM UNTIL TBL = ANSWER |
|||
ADD 1 TO TRIES |
|||
DISPLAY "How many to reverse? " |
|||
ACCEPT RNUM |
|||
CALL 'REVERSE' USING BY CONTENT RNUM, |
|||
BY REFERENCE TBL |
|||
END-CALL |
|||
DISPLAY "Try #" TRIES " " TBL |
|||
END-PERFORM. |
|||
DISPLAY "Congratulations. You did it!" |
|||
STOP RUN. |
|||
END PROGRAM REVERSAL. |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. KNUTH-SHUFFLE. |
|||
DATA DIVISION. |
|||
LOCAL-STORAGE SECTION. |
|||
01 I PIC 9(9). |
|||
01 J PIC 9(9). |
|||
01 TEMP PIC 9(9). |
|||
01 tABLE-lEN PIC 9 value 9. |
|||
LINKAGE SECTION. |
|||
01 TTABLE-AREA. |
|||
03 TTABLE PIC 9 OCCURS 9 TIMES. |
|||
PROCEDURE DIVISION USING ttable-area. |
|||
MOVE FUNCTION RANDOM(FUNCTION CURRENT-DATE (11:6)) TO I |
|||
PERFORM VARYING i FROM Table-Len BY -1 UNTIL i = 0 |
|||
COMPUTE j = |
|||
FUNCTION MOD(FUNCTION RANDOM * 10000, Table-Len) + 1 |
|||
MOVE ttable (i) TO temp |
|||
MOVE ttable (j) TO ttable (i) |
|||
MOVE temp TO ttable (j) |
|||
END-PERFORM. |
|||
GOBACK. |
|||
END PROGRAM KNUTH-SHUFFLE. |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. REVERSE. |
|||
DATA DIVISION. |
|||
LOCAL-STORAGE SECTION. |
|||
01 I PIC 9. |
|||
01 J PIC 9. |
|||
01 X PIC 9. |
|||
01 LOOP-IDX PIC 9. |
|||
LINKAGE SECTION. |
|||
01 IDX PIC 9. |
|||
01 TTABLE-AREA. |
|||
03 TTABLE PIC 9 OCCURS 9 TIMES. |
|||
PROCEDURE DIVISION USING IDX, TTABLE-AREA. |
|||
DIVIDE IDX BY 2 GIVING LOOP-IDx |
|||
MOVE 1 TO I |
|||
MOVE IDX TO J |
|||
PERFORM LOOP-IDX TIMES |
|||
MOVE TTABLE(I) TO X |
|||
MOVE TTABLE(J) TO TTABLE(I) |
|||
MOVE X TO TTABLE(J) |
|||
ADD 1 TO I |
|||
SUBTRACT 1 FROM J |
|||
END-PERFORM. |
|||
GOBACK. |
|||
END PROGRAM REVERSE. |
|||
</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(defun shuffle! (vector) |
||
(loop for i from (1- (length vector)) downto 1 |
(loop for i from (1- (length vector)) downto 1 |
||
do (rotatef (aref vector i) |
do (rotatef (aref vector i) |
||
Line 650: | Line 1,646: | ||
(replace slice (nreverse slice)))))) |
(replace slice (nreverse slice)))))) |
||
(format t "~A~%Congratulations, you did it in ~D reversals!~%" numbers score)))) |
(format t "~A~%Congratulations, you did it in ~D reversals!~%" numbers score)))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="ruby"> |
|||
SIZE = 9 |
|||
ordered = (1..SIZE).to_a |
|||
shuffled = (1..SIZE).to_a |
|||
while shuffled == ordered |
|||
shuffled.shuffle! |
|||
end |
|||
score = 0 |
|||
until shuffled == ordered |
|||
print "#{shuffled} Enter items to reverse: " |
|||
next unless guess = gets |
|||
next unless num = guess.to_i? |
|||
next if num < 2 || num > SIZE |
|||
shuffled[0, num] = shuffled[0, num].reverse |
|||
score += 1 |
|||
end |
|||
puts "#{shuffled} Your score: #{score}" |
|||
</syntaxhighlight> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<syntaxhighlight lang="d">import std.stdio, std.random, std.string, std.conv, std.algorithm, |
||
std.range; |
|||
void main() { |
void main() { |
||
auto data = |
auto data = iota(1, 10).array; |
||
do |
do data.randomShuffle; |
||
while |
while (data.isSorted); |
||
int trial; |
int trial; |
||
while (! |
while (!data.isSorted) { |
||
writef("%d: %s How many numbers to flip? ", ++trial, data); |
writef("%d: %s How many numbers to flip? ", ++trial, data); |
||
data[0 .. to! |
data[0 .. readln.strip.to!uint].reverse; |
||
} |
} |
||
writefln("\nYou took %d attempts.", trial); |
writefln("\nYou took %d attempts.", trial); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
|||
<pre>1: [7, 2, 1, 6, 3, 8, 9, 5, 4] How many numbers to flip? 7 |
|||
2: [9, 8, 3, 6, 1, 2, 7, 5, 4] How many numbers to flip? 9 |
|||
3: [4, 5, 7, 2, 1, 6, 3, 8, 9] How many numbers to flip? 3 |
|||
4: [7, 5, 4, 2, 1, 6, 3, 8, 9] How many numbers to flip? 7 |
|||
5: [3, 6, 1, 2, 4, 5, 7, 8, 9] How many numbers to flip? 2 |
|||
6: [6, 3, 1, 2, 4, 5, 7, 8, 9] How many numbers to flip? 6 |
|||
7: [5, 4, 2, 1, 3, 6, 7, 8, 9] How many numbers to flip? 5 |
|||
8: [3, 1, 2, 4, 5, 6, 7, 8, 9] How many numbers to flip? 3 |
|||
9: [2, 1, 3, 4, 5, 6, 7, 8, 9] How many numbers to flip? 2 |
|||
You took 9 attempts.</pre> |
|||
=={{header|Delphi}}== |
|||
{{works with|Delphi|6.0}} |
|||
{{libheader|SysUtils,StdCtrls}} |
|||
This program simulates a console application in an event-drivern, GUI application. It does this by creating a special helper object that manages the TMemo control. The helper-object waits for keystrokes and returns when the user has pressed a key or the program aborts. Notice how the object is created and destroyed every time you wait for a key stroke. This a common practice in Delphi and it works because the creation of an object is a low overhead opeation. That allows you to eliminate global variables and isolate resources to specific parts of the program. |
|||
<syntaxhighlight lang="Delphi"> |
|||
type TKeyWaiter = class(TObject) |
|||
private |
|||
FControl: TWinControl; |
|||
protected |
|||
procedure HandleKeyPress(Sender: TObject; var Key: Char); |
|||
public |
|||
KeyChar: Char; |
|||
ValidKey: boolean; |
|||
Abort: boolean; |
|||
constructor Create(Control: TWinControl); |
|||
function WaitForKey: char; |
|||
end; |
|||
{ TMemoWaiter } |
|||
type TControlHack = class(TWinControl) end; |
|||
constructor TKeyWaiter.Create(Control: TWinControl); |
|||
{Save the control we want to wait on} |
|||
begin |
|||
FControl:=Control; |
|||
end; |
|||
procedure TKeyWaiter.HandleKeyPress(Sender: TObject; var Key: Char); |
|||
{Handle captured key press} |
|||
begin |
|||
KeyChar:=Key; |
|||
ValidKey:=True; |
|||
end; |
|||
function TKeyWaiter.WaitForKey: char; |
|||
{Capture keypress event and wait for key press control} |
|||
{Spends most of its time sleep and aborts if the user} |
|||
{sets the abort flag or the program terminates} |
|||
begin |
|||
ValidKey:=False; |
|||
Abort:=False; |
|||
TControlHack(FControl).OnKeyPress:=HandleKeyPress; |
|||
repeat |
|||
begin |
|||
Application.ProcessMessages; |
|||
Sleep(100); |
|||
end |
|||
until ValidKey or Application.Terminated or Abort; |
|||
Result:=KeyChar; |
|||
end; |
|||
{===========================================================} |
|||
type TNumbers = array [0..8] of integer; |
|||
function WaitForKey(Memo: TMemo; Prompt: string): char; |
|||
{Wait for key stroke on TMemo component} |
|||
var KW: TKeyWaiter; |
|||
begin |
|||
{Use custom object to wait and capture key strokes} |
|||
KW:=TKeyWaiter.Create(Memo); |
|||
try |
|||
Memo.Lines.Add(Prompt); |
|||
Memo.SelStart:=Memo.SelStart-1; |
|||
Memo.SetFocus; |
|||
Result:=KW.WaitForKey; |
|||
finally KW.Free; end; |
|||
end; |
|||
procedure ScrambleNumbers(var Numbers: TNumbers); |
|||
{Scramble numbers into a random order} |
|||
var I,I1,I2,T: integer; |
|||
begin |
|||
for I:=0 to 8 do Numbers[I]:=I+1; |
|||
for I:=1 to 100 do |
|||
begin |
|||
I1:=Random(9); |
|||
I2:=Random(9); |
|||
T:=Numbers[I1]; |
|||
Numbers[I1]:=Numbers[I2]; |
|||
Numbers[I2]:=T; |
|||
end; |
|||
end; |
|||
function GetNumbersStr(Numbers: TNumbers): string; |
|||
{Return number order as a string} |
|||
var I: integer; |
|||
begin |
|||
Result:=''; |
|||
for I:=0 to High(Numbers) do |
|||
begin |
|||
if I<>0 then Result:=Result+' '; |
|||
Result:=Result+IntToStr(Numbers[I]); |
|||
end; |
|||
end; |
|||
procedure ReverseNumbers(var Numbers: TNumbers; Count: integer); |
|||
{Reverse the specified count of numbers from the start} |
|||
var NT: TNumbers; |
|||
var I,I1: integer; |
|||
begin |
|||
NT:=Numbers; |
|||
for I:=0 to Count-1 do |
|||
begin |
|||
I1:=(Count-1) - I; |
|||
Numbers[I1]:=NT[I]; |
|||
end; |
|||
end; |
|||
function IsWinner(Numbers: TNumbers): boolean; |
|||
{Check if is number is order 1..9} |
|||
var I: integer; |
|||
begin |
|||
Result:=False; |
|||
for I:=0 to High(Numbers) do |
|||
if Numbers[I]<>(I+1) then exit; |
|||
Result:=True; |
|||
end; |
|||
procedure ReverseGame(Memo: TMemo); |
|||
{Play the reverse game on specified memo} |
|||
var C: char; |
|||
var Numbers: TNumbers; |
|||
var S: string; |
|||
var R: integer; |
|||
begin |
|||
Randomize; |
|||
ScrambleNumbers(Numbers); |
|||
while true do |
|||
begin |
|||
S:=GetNumbersStr(Numbers); |
|||
C:=WaitForKey(Memo,S+' Number To Reverse: '); |
|||
if Application.Terminated then exit; |
|||
if C in ['x','X'] then break; |
|||
R:=byte(C) - $30; |
|||
ReverseNumbers(Numbers,R); |
|||
if IsWinner(Numbers) then |
|||
begin |
|||
S:=GetNumbersStr(Numbers); |
|||
Memo.Lines.Add(S+' - WINNER!!'); |
|||
break; |
|||
end; |
|||
end; |
|||
end; |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
8 5 2 9 7 4 6 3 1 Number To Reverse: 4 |
|||
9 2 5 8 7 4 6 3 1 Number To Reverse: 9 |
|||
1 3 6 4 7 8 5 2 9 Number To Reverse: 6 |
|||
8 7 4 6 3 1 5 2 9 Number To Reverse: 8 |
|||
2 5 1 3 6 4 7 8 9 Number To Reverse: 5 |
|||
6 3 1 5 2 4 7 8 9 Number To Reverse: 6 |
|||
4 2 5 1 3 6 7 8 9 Number To Reverse: 3 |
|||
5 2 4 1 3 6 7 8 9 Number To Reverse: 5 |
|||
3 1 4 2 5 6 7 8 9 Number To Reverse: 3 |
|||
4 1 3 2 5 6 7 8 9 Number To Reverse: 4 |
|||
2 3 1 4 5 6 7 8 9 Number To Reverse: 2 |
|||
3 2 1 4 5 6 7 8 9 Number To Reverse: 3 |
|||
1 2 3 4 5 6 7 8 9 - WINNER!! |
|||
</pre> |
|||
=={{header|EasyLang}}== |
|||
{{trans|Nim}} |
|||
<syntaxhighlight lang=text> |
|||
func sorted s[] . |
|||
for c in s[] |
|||
if c < last |
|||
return 0 |
|||
. |
|||
last = c |
|||
. |
|||
return 1 |
|||
. |
|||
func$ tostr s[] . |
|||
for s in s[] |
|||
res$ &= s & " " |
|||
. |
|||
return res$ |
|||
. |
|||
proc shuffle . s[] . |
|||
for i = len s[] downto 2 |
|||
swap s[i] s[random i] |
|||
. |
|||
. |
|||
proc reverse n . s[] . |
|||
for i = 1 to n div 2 |
|||
swap s[i] s[n - i + 1] |
|||
. |
|||
. |
|||
data[] = [ 1 2 3 4 5 6 7 8 9 ] |
|||
while sorted data[] = 1 |
|||
shuffle data[] |
|||
. |
|||
while sorted data[] = 0 |
|||
print tostr data[] |
|||
score += 1 |
|||
nflip = number input |
|||
reverse nflip data[] |
|||
. |
|||
print "Score " & score |
|||
</syntaxhighlight> |
|||
=={{header|Egel}}== |
|||
<syntaxhighlight lang="egel"> |
|||
import "prelude.eg" |
|||
import "io.ego" |
|||
import "random.ego" |
|||
using System |
|||
using IO |
|||
using List |
|||
using Math |
|||
def swap = |
|||
[ (I J) XX -> insert I (nth J XX) (insert J (nth I XX) XX) ] |
|||
def shuffle = |
|||
[ XX -> |
|||
let INDICES = reverse (fromto 0 ((length XX) - 1)) in |
|||
let SWAPS = map [ I -> I (between 0 I) ] INDICES in |
|||
foldr [I J -> swap I J] XX SWAPS ] |
|||
def prompt = |
|||
[ XX TURN -> |
|||
let _ = print TURN ". " in |
|||
let _ = map [ X -> print X " " ] XX in |
|||
let _ = print " : " in |
|||
toint getline ] |
|||
def game = |
|||
[ GOAL SHUFFLE TURN -> |
|||
if SHUFFLE == GOAL then |
|||
let _ = print "the goal was " in |
|||
let _ = map [ X -> print X " " ] GOAL in |
|||
print "\nit took you " TURN " turns\n" |
|||
else |
|||
let N = prompt SHUFFLE TURN in |
|||
let YY = (reverse (take N SHUFFLE)) ++ (drop N SHUFFLE) in |
|||
game GOAL YY (TURN + 1) ] |
|||
def main = |
|||
let XX = fromto 1 9 in game XX (shuffle XX) 0</syntaxhighlight> |
|||
=={{header|Eiffel}}== |
|||
<syntaxhighlight lang="eiffel"> |
|||
class |
|||
APPLICATION |
|||
create |
|||
make |
|||
feature {NONE} |
|||
make |
|||
-- Plays Number Reversal Game. |
|||
local |
|||
count: INTEGER |
|||
do |
|||
initialize_game |
|||
io.put_string ("Let's play the number reversal game.%N") |
|||
across |
|||
numbers as ar |
|||
loop |
|||
io.put_string (ar.item.out + "%T") |
|||
end |
|||
from |
|||
until |
|||
is_sorted (numbers, 1, numbers.count) |
|||
loop |
|||
io.put_string ("%NHow many numbers should be reversed?%N") |
|||
io.read_integer |
|||
reverse_array (io.last_integer) |
|||
across |
|||
numbers as ar |
|||
loop |
|||
io.put_string (ar.item.out + "%T") |
|||
end |
|||
count := count + 1 |
|||
end |
|||
io.put_string ("%NYou needed " + count.out + " reversals.") |
|||
end |
|||
feature {NONE} |
|||
initialize_game |
|||
-- Array with numbers from 1 to 9 in a random unsorted order. |
|||
local |
|||
random: V_RANDOM |
|||
item, i: INTEGER |
|||
do |
|||
create random |
|||
create numbers.make_empty |
|||
from |
|||
i := 1 |
|||
until |
|||
numbers.count = 9 and not is_sorted (numbers, 1, numbers.count) |
|||
loop |
|||
item := random.bounded_item (1, 9) |
|||
if not numbers.has (item) then |
|||
numbers.force (item, i) |
|||
i := i + 1 |
|||
end |
|||
random.forth |
|||
end |
|||
end |
|||
numbers: ARRAY [INTEGER] |
|||
reverse_array (upper: INTEGER) |
|||
-- Array numbers with first element up to nth element reversed. |
|||
require |
|||
upper_positive: upper > 0 |
|||
ar_not_void: numbers /= Void |
|||
local |
|||
i, j: INTEGER |
|||
new_array: ARRAY [INTEGER] |
|||
do |
|||
create new_array.make_empty |
|||
new_array.deep_copy (numbers) |
|||
from |
|||
i := 1 |
|||
j := upper |
|||
until |
|||
i > j |
|||
loop |
|||
new_array [i] := numbers [j] |
|||
new_array [j] := numbers [i] |
|||
i := i + 1 |
|||
j := j - 1 |
|||
end |
|||
numbers := new_array |
|||
end |
|||
is_sorted (ar: ARRAY [INTEGER]; l, r: INTEGER): BOOLEAN |
|||
-- Is Array 'ar' sorted in ascending order? |
|||
require |
|||
ar_not_empty: not ar.is_empty |
|||
do |
|||
Result := True |
|||
across |
|||
1 |..| (r - 1) as c |
|||
loop |
|||
if ar [c.item] > ar [c.item + 1] then |
|||
Result := False |
|||
end |
|||
end |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Let's play the number reversal game. |
|||
7 8 5 6 9 6 1 4 2 |
|||
How many numbers should be reversed? |
|||
5 |
|||
9 3 5 8 7 6 1 4 2 |
|||
How many numbers should be reversed? |
|||
9 |
|||
2 4 1 6 7 8 5 3 9 |
|||
How many numbers should be reversed? |
|||
6 |
|||
8 7 6 1 4 2 5 3 9 |
|||
How many numbers should be reversed? |
|||
8 |
|||
3 5 2 4 1 6 7 8 9 |
|||
How many numbers should be reversed? |
|||
2 |
|||
5 3 2 4 1 6 7 8 9 |
|||
How many numbers should be reversed? |
|||
5 |
|||
1 4 2 3 5 6 7 8 9 |
|||
How many numbers should be reversed? |
|||
2 |
|||
4 1 2 3 5 6 7 8 9 |
|||
How many numbers should be reversed? |
|||
4 |
|||
3 2 1 4 5 6 7 8 9 |
|||
How many numbers should be reversed? |
|||
3 |
|||
1 2 3 4 5 6 7 8 9 |
|||
You needed 9 reversals. |
|||
</pre> |
|||
=={{header|Elena}}== |
|||
ELENA 6.x: |
|||
<syntaxhighlight lang="elena">import system'routines; |
|||
import extensions; |
|||
public program() |
|||
{ |
|||
var sorted := Array.allocate(9).populate::(n => n + 1 ); |
|||
var values := sorted.clone().randomize(9); |
|||
while (sorted.sequenceEqual(values)) |
|||
{ |
|||
values := sorted.randomize(9) |
|||
}; |
|||
var tries := new Integer(); |
|||
until (sorted.sequenceEqual(values)) |
|||
{ |
|||
tries.append(1); |
|||
console.print("# ",tries," : LIST : ",values," - Flip how many?"); |
|||
values.sequenceReverse(0, console.readLine().toInt()) |
|||
}; |
|||
console.printLine("You took ",tries," attempts to put the digits in order!").readChar() |
|||
}</syntaxhighlight> |
|||
=={{header|Elixir}}== |
|||
{{trans|Erlang}} |
|||
<syntaxhighlight lang="elixir">defmodule Number_reversal_game do |
|||
def start( n ) when n > 1 do |
|||
IO.puts "Usage: #{usage(n)}" |
|||
targets = Enum.to_list( 1..n ) |
|||
jumbleds = Enum.shuffle(targets) |
|||
attempt = loop( targets, jumbleds, 0 ) |
|||
IO.puts "Numbers sorted in #{attempt} atttempts" |
|||
end |
|||
defp loop( targets, targets, attempt ), do: attempt |
|||
defp loop( targets, jumbleds, attempt ) do |
|||
IO.inspect jumbleds |
|||
{n,_} = IO.gets("How many digits from the left to reverse? ") |> Integer.parse |
|||
loop( targets, Enum.reverse_slice(jumbleds, 0, n), attempt+1 ) |
|||
end |
|||
defp usage(n), do: "Given a jumbled list of the numbers 1 to #{n} that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all the digits end up in ascending order." |
|||
end |
|||
Number_reversal_game.start( 9 )</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Usage: Given a jumbled list of the numbers 1 to 9 that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all he digits end up in ascending order. |
|||
[3, 9, 4, 7, 6, 5, 1, 2, 8] |
|||
How many digits from the left to reverse? 2 |
|||
[9, 3, 4, 7, 6, 5, 1, 2, 8] |
|||
How many digits from the left to reverse? 9 |
|||
[8, 2, 1, 5, 6, 7, 4, 3, 9] |
|||
How many digits from the left to reverse? 8 |
|||
[3, 4, 7, 6, 5, 1, 2, 8, 9] |
|||
How many digits from the left to reverse? 3 |
|||
[7, 4, 3, 6, 5, 1, 2, 8, 9] |
|||
How many digits from the left to reverse? 7 |
|||
[2, 1, 5, 6, 3, 4, 7, 8, 9] |
|||
How many digits from the left to reverse? 4 |
|||
[6, 5, 1, 2, 3, 4, 7, 8, 9] |
|||
How many digits from the left to reverse? 6 |
|||
[4, 3, 2, 1, 5, 6, 7, 8, 9] |
|||
How many digits from the left to reverse? 4 |
|||
Numbers sorted in 8 atttempts |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
<syntaxhighlight lang="erlang"> |
|||
-module( number_reversal_game ). |
|||
-export( [task/0, start/1] ). |
|||
start( N ) when N > 1 -> |
|||
io:fwrite( "Usage: ~s~n", [usage(N)] ), |
|||
Targets = lists:seq( 1, N ), |
|||
Jumbleds = [X||{_,X} <- lists:sort([ {random:uniform(), Y} || Y <- Targets])], |
|||
Attempt = loop( Targets, Jumbleds, 0 ), |
|||
io:fwrite( "Numbers sorted in ~p atttempts~n", [Attempt] ). |
|||
task() -> start( 9 ). |
|||
loop( Targets, Targets, Attempt ) -> Attempt; |
|||
loop( Targets, Jumbleds, Attempt ) -> |
|||
io:fwrite( "~p~n", [Jumbleds] ), |
|||
{ok,[N]} = io:fread( "How many digits from the left to reverse? ", "~d" ), |
|||
{Lefts, Rights} = lists:split( N, Jumbleds ), |
|||
loop( Targets, lists:reverse(Lefts) ++ Rights, Attempt + 1 ). |
|||
usage(N) -> io_lib:format( "Given a jumbled list of the numbers 1 to ~p that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all the digits end up in ascending order.", [N] ). |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
Not being a very good player I show a test run with only 3 numbers. |
|||
<pre> |
|||
35> number_reversal_game:start(3). |
|||
Usage: Given a jumbled list of the numbers 1 to 3 that are definitely not in ascending order, show |
|||
the list then ask the player how many digits from the left to reverse. Reverse those digits, then |
|||
ask again, until all the digits end up in ascending order. |
|||
[2,3,1] |
|||
How many digits from the left to reverse? 3 |
|||
[1,3,2] |
|||
How many digits from the left to reverse? 3 |
|||
[2,3,1] |
|||
How many digits from the left to reverse? 2 |
|||
[3,2,1] |
|||
How many digits from the left to reverse? 3 |
|||
Numbers sorted in 4 atttempts |
|||
</pre> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">include get.e |
||
function accending(sequence s) |
function accending(sequence s) |
||
Line 723: | Line 2,272: | ||
end while |
end while |
||
printf(1,"\nYou took %d tries to put the digits in order.", tries)</ |
printf(1,"\nYou took %d tries to put the digits in order.", tries)</syntaxhighlight> |
||
Output: |
Output: |
||
Line 747: | Line 2,296: | ||
=={{header|F Sharp|F#}}== |
=={{header|F Sharp|F#}}== |
||
<syntaxhighlight lang="fsharp">let rand = System.Random() |
|||
{{incorrect|F#|Example is likely to fail if numbers are initially randomly shuffled to the ordered state. (See talk).}} |
|||
<lang fsharp>let rand = System.Random() |
|||
while true do |
while true do |
||
let rec randomNums() = |
|||
let xs = [|for i in 1..9 -> rand.Next(), i|] |> Array.sort |> Array.map snd |
|||
let xs = [|for i in 1..9 -> rand.Next(), i|] |> Array.sort |> Array.map snd |
|||
if xs = Array.sort xs then randomNums() else xs |
|||
printf "\n%A\n\nReverse how many digits?\n> " xs |
|||
let xs = randomNums() |
|||
let suffix = function | 1 -> "st" | 2 -> "nd" | 3 -> "rd" | _ -> "th" |
|||
let rec move i = |
|||
printf "\n%A\n\nReverse how many digits from the left in your %i%s move? : " xs i (suffix i) |
|||
let n = stdin.ReadLine() |> int |
let n = stdin.ReadLine() |> int |
||
Array.blit (Array.rev xs.[0..n-1]) 0 xs 0 n |
Array.blit (Array.rev xs.[0..n-1]) 0 xs 0 n |
||
if xs <> Array.sort xs then |
|||
printf "Well done!\n\n"</lang> |
|||
move (i+1) |
|||
else |
|||
printfn "\nYou took %i moves to put the digits in order!\n" i |
|||
move 1</syntaxhighlight> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor">USING: formatting io kernel math math.parser math.ranges |
||
namespaces random sequences strings ; |
namespaces random sequences strings ; |
||
IN: rosetta.number-reversal |
IN: rosetta.number-reversal |
||
Line 787: | Line 2,348: | ||
: play ( -- ) |
: play ( -- ) |
||
0 trials set |
0 trials set |
||
make-jumbled-array game-loop ;</ |
make-jumbled-array game-loop ;</syntaxhighlight> |
||
=={{header|FOCAL}}== |
|||
<syntaxhighlight lang="focal">01.10 D 3;S T=0 |
|||
01.20 F X=1,9;T %1,D(X) |
|||
01.30 T !;A "HOW MANY",R |
|||
01.40 I (R-1)1.3;I (9-R)1.3 |
|||
01.50 D 5;S T=T+1 |
|||
01.60 D 4;I (A-9)1.2 |
|||
01.70 D 1.2;T !"CORRECT! ATTEMPTS",%4,T,! |
|||
01.80 Q |
|||
02.10 S A=10*FRAN();S A=A-FITR(A) |
|||
03.10 F X=1,9;S D(X)=X |
|||
03.20 F X=1,8;D 2;S Y=X+FITR((10-X)*A);S A=D(X);S D(X)=D(Y);S D(Y)=A |
|||
03.30 D 4 |
|||
03.40 I (8-A)3.1 |
|||
04.10 S A=0 |
|||
04.20 F X=1,9;D 4.4 |
|||
04.30 R |
|||
04.40 I (D(X)-X)4.3,4.5,4.3 |
|||
04.50 S A=A+1 |
|||
05.10 F X=1,R/2;S A=D(X);S D(X)=D(R-X+1);S D(R-X+1)=A</syntaxhighlight> |
|||
{{out}} |
|||
<pre>= 1= 6= 4= 5= 8= 7= 9= 2= 3 |
|||
HOW MANY:9 |
|||
= 3= 2= 9= 7= 8= 5= 4= 6= 1 |
|||
HOW MANY:2 |
|||
= 2= 3= 9= 7= 8= 5= 4= 6= 1 |
|||
HOW MANY:8 |
|||
= 6= 4= 5= 8= 7= 9= 3= 2= 1 |
|||
HOW MANY:3 |
|||
= 5= 4= 6= 8= 7= 9= 3= 2= 1 |
|||
HOW MANY:2 |
|||
= 4= 5= 6= 8= 7= 9= 3= 2= 1 |
|||
HOW MANY:3 |
|||
= 6= 5= 4= 8= 7= 9= 3= 2= 1 |
|||
HOW MANY:3 |
|||
= 4= 5= 6= 8= 7= 9= 3= 2= 1 |
|||
HOW MANY:6 |
|||
= 9= 7= 8= 6= 5= 4= 3= 2= 1 |
|||
HOW MANY:3 |
|||
= 8= 7= 9= 6= 5= 4= 3= 2= 1 |
|||
HOW MANY:2 |
|||
= 7= 8= 9= 6= 5= 4= 3= 2= 1 |
|||
HOW MANY:3 |
|||
= 9= 8= 7= 6= 5= 4= 3= 2= 1 |
|||
HOW MANY:9 |
|||
= 1= 2= 3= 4= 5= 6= 7= 8= 9 |
|||
CORRECT! ATTEMPTS= 12</pre> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth">include random.fs |
||
variable flips |
variable flips |
||
Line 839: | Line 2,452: | ||
7 flip |
7 flip |
||
9 6 7 5 8 2 1 4 3 ok |
9 6 7 5 8 2 1 4 3 ok |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
{{works with|Fortran|95 and later}} |
{{works with|Fortran|95 and later}} |
||
< |
<syntaxhighlight lang="fortran">program Reversal_game |
||
implicit none |
implicit none |
||
Line 896: | Line 2,509: | ||
end function |
end function |
||
end program</ |
end program</syntaxhighlight> |
||
=={{header|FreeBASIC}}== |
|||
:''See [[#BASIC|BASIC]]'' |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 940: | Line 2,557: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
< |
<syntaxhighlight lang="groovy">sorted = [*(1..9)] |
||
arr = sorted.clone() |
arr = sorted.clone() |
||
Line 957: | Line 2,574: | ||
steps += 1 |
steps += 1 |
||
} |
} |
||
println "Done! That took you ${steps} steps"</ |
println "Done! That took you ${steps} steps"</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
Using Rosetta [ |
Using Rosetta [[Knuth shuffle#Haskell|Knuth Shuffle]] |
||
< |
<syntaxhighlight lang="haskell">import Data.List |
||
import Control.Arrow |
import Control.Arrow |
||
import Rosetta.Knuthshuffle |
import Rosetta.Knuthshuffle |
||
Line 995: | Line 2,612: | ||
start <- shuffle goal |
start <- shuffle goal |
||
playNRG 1 start</ |
playNRG 1 start</syntaxhighlight> |
||
Play: |
Play: |
||
<pre>*Main> numberRevGame |
<pre>*Main> numberRevGame |
||
Line 1,010: | Line 2,627: | ||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest"> WRITE(Messagebox) "You took ", Reversals(), " attempts" |
||
FUNCTION Reversals() |
FUNCTION Reversals() |
||
Line 1,032: | Line 2,649: | ||
IF( SUM(temp) == 8 ) RETURN |
IF( SUM(temp) == 8 ) RETURN |
||
ENDDO |
ENDDO |
||
END</ |
END</syntaxhighlight> |
||
=={{header|Io}}== |
|||
<lang io>withRange := method( a, z, |
|||
Range clone setRange(a,z) |
|||
) |
|||
sorted := withRange(1,9) asList |
|||
numbers := sorted clone shuffle |
|||
while( numbers==sorted, numbers = numbers shuffle) |
|||
steps :=0 |
|||
stdin := File standardInput |
|||
while( numbers != sorted, |
|||
writeln(numbers join(" ")) |
|||
write("Reverse how many? ") |
|||
flipcount := stdin readLine asNumber |
|||
withRange(0, ((flipcount-1)/2) floor) foreach( i, |
|||
numbers swapIndices(i,flipcount-1-i) |
|||
) |
|||
steps = steps+1 |
|||
) |
|||
writeln("Done! That took you ", steps, " steps")</lang> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
< |
<syntaxhighlight lang="icon">procedure main(cq) # Number Reversal Game |
||
local x,nums,R,flips |
local x,nums,R,flips |
||
Line 1,124: | Line 2,720: | ||
map(trim(read())) ? return tab(upto(' ')|0) |
map(trim(read())) ? return tab(upto(' ')|0) |
||
end |
end |
||
</syntaxhighlight> |
|||
</lang> |
|||
Sample output:<pre>Input a position. The list will be flipped left to right at that point. |
Sample output:<pre>Input a position. The list will be flipped left to right at that point. |
||
Line 1,152: | Line 2,748: | ||
=={{header|Inform 7}}== |
=={{header|Inform 7}}== |
||
< |
<syntaxhighlight lang="inform7">Number Reversal Game is a room. |
||
The current list is a list of numbers that varies. |
The current list is a list of numbers that varies. |
||
Line 1,191: | Line 2,787: | ||
say "It took you [turn count] flip[s] to sort the list." |
say "It took you [turn count] flip[s] to sort the list." |
||
The new print final score rule is listed instead of the print final score rule in the for printing the player's obituary rules.</ |
The new print final score rule is listed instead of the print final score rule in the for printing the player's obituary rules.</syntaxhighlight> |
||
=={{header|Io}}== |
|||
<syntaxhighlight lang="io">withRange := method( a, z, |
|||
Range clone setRange(a,z) |
|||
) |
|||
sorted := withRange(1,9) asList |
|||
numbers := sorted clone shuffle |
|||
while( numbers==sorted, numbers = numbers shuffle) |
|||
steps :=0 |
|||
stdin := File standardInput |
|||
while( numbers != sorted, |
|||
writeln(numbers join(" ")) |
|||
write("Reverse how many? ") |
|||
flipcount := stdin readLine asNumber |
|||
withRange(0, ((flipcount-1)/2) floor) foreach( i, |
|||
numbers swapIndices(i,flipcount-1-i) |
|||
) |
|||
steps = steps+1 |
|||
) |
|||
writeln("Done! That took you ", steps, " steps")</syntaxhighlight> |
|||
=={{header|IS-BASIC}}== |
|||
<syntaxhighlight lang="is-basic">100 PROGRAM "Reversal.bas" |
|||
110 RANDOMIZE |
|||
120 NUMERIC NR(1 TO 9) |
|||
130 LET TRIES=0 |
|||
140 TEXT :PRINT "Given a jumbled list of the numbers 1 to 9, you must select how many digits from the left to reverse.":PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right.":PRINT |
|||
150 FOR I=1 TO 9 |
|||
160 LET NR(I)=I |
|||
170 NEXT |
|||
180 DO |
|||
190 FOR I=2 TO 9 |
|||
200 LET N=RND(I)+1 |
|||
210 IF N<>I THEN CALL SWAP(N,I) |
|||
220 NEXT |
|||
230 LOOP WHILE ORDERED |
|||
240 DO |
|||
250 PRINT USING "##: ":TRIES; |
|||
260 FOR I=1 TO 9 |
|||
270 PRINT NR(I); |
|||
280 NEXT |
|||
290 PRINT |
|||
300 IF ORDERED THEN EXIT DO |
|||
310 DO |
|||
320 INPUT PROMPT "How many numbers should be flipped? ":FLIP |
|||
330 LOOP WHILE FLIP<2 OR FLIP>9 |
|||
340 FOR I=1 TO FLIP/2 |
|||
350 CALL SWAP(I,FLIP-I+1) |
|||
360 NEXT |
|||
370 LET TRIES=TRIES+1 |
|||
380 LOOP |
|||
390 PRINT :PRINT "You took";TRIES;"tries to put the digits in order." |
|||
400 DEF SWAP(A,B) |
|||
410 LET T=NR(A):LET NR(A)=NR(B):LET NR(B)=T |
|||
420 END DEF |
|||
430 DEF ORDERED |
|||
440 LET ORDERED=-1 |
|||
450 FOR J=1 TO 8 |
|||
460 IF NR(J)>NR(J+1) THEN LET ORDERED=0:EXIT FOR |
|||
470 NEXT |
|||
480 END DEF</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
'''Solution:''' |
'''Solution:''' |
||
< |
<syntaxhighlight lang="j">require 'misc' NB. for the verb prompt |
||
INTRO=: noun define |
INTRO=: noun define |
||
Line 1,216: | Line 2,874: | ||
end. |
end. |
||
'You took ',(": score), ' attempts to put the numbers in order.' |
'You took ',(": score), ' attempts to put the numbers in order.' |
||
)</ |
)</syntaxhighlight> |
||
'''Example Usage:''' |
'''Example Usage:''' |
||
< |
<syntaxhighlight lang="j"> reversegame'' |
||
Number Reversal Game |
Number Reversal Game |
||
Sort the numbers in ascending order by repeatedly |
Sort the numbers in ascending order by repeatedly |
||
Line 1,234: | Line 2,892: | ||
10: 4 1 2 3 5 6 7 8 9 How many numbers to flip?: 4 |
10: 4 1 2 3 5 6 7 8 9 How many numbers to flip?: 4 |
||
11: 3 2 1 4 5 6 7 8 9 How many numbers to flip?: 3 |
11: 3 2 1 4 5 6 7 8 9 How many numbers to flip?: 3 |
||
You took 11 attempts to put the numbers in order.</ |
You took 11 attempts to put the numbers in order.</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java5">import java.util.List; |
||
import java.util.ArrayList; |
import java.util.ArrayList; |
||
import java.util.Scanner; |
import java.util.Scanner; |
||
Line 1,309: | Line 2,967: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
Use <code>knuth_shuffle()</code> function from [[Knuth shuffle#JavaScript|here]]. |
Use <code>knuth_shuffle()</code> function from [[Knuth shuffle#JavaScript|here]]. |
||
< |
<syntaxhighlight lang="html4strict"><html> |
||
<head> |
<head> |
||
<title>Number Reversal Game</title> |
<title>Number Reversal Game</title> |
||
Line 1,323: | Line 2,981: | ||
<div id="progress"></div> |
<div id="progress"></div> |
||
<div id="score"></div> |
<div id="score"></div> |
||
<script type="text/javascript"></ |
<script type="text/javascript"></syntaxhighlight> |
||
< |
<syntaxhighlight lang="javascript">function endGame(progress) { |
||
var scoreId = progress.scoreId, |
var scoreId = progress.scoreId, |
||
result = 'You took ' + progress.count + ' attempts to put the digits in order!'; |
result = 'You took ' + progress.count + ' attempts to put the digits in order!'; |
||
Line 1,391: | Line 3,049: | ||
} |
} |
||
playGame('start', 'progress', 'score');</ |
playGame('start', 'progress', 'score');</syntaxhighlight> |
||
< |
<syntaxhighlight lang="html4strict"></script> |
||
</body> |
</body> |
||
</html></ |
</html></syntaxhighlight> |
||
=={{header|jq}}== |
|||
<syntaxhighlight lang="jq"># Input: the initial array |
|||
def play: |
|||
def sorted: . == sort; |
|||
def reverse(n): (.[0:n] | reverse) + .[n:]; |
|||
def prompt: "List: \(.list)\nEnter a pivot number: "; |
|||
def report: "Great! Your score is \(.score)"; |
|||
{list: ., score: 0} |
|||
| (if .list | sorted then "List was sorted to begin with." |
|||
else |
|||
prompt, |
|||
( label $done |
|||
| foreach inputs as $n (.; |
|||
.list |= reverse($n) | .score +=1; |
|||
if .list | sorted then report, break $done else prompt end )) |
|||
end); </syntaxhighlight> |
|||
'''Example''' |
|||
<syntaxhighlight lang="jq">[1,2,3,9,8,7,6,5,4] | play</syntaxhighlight> |
|||
'''Transcript''' |
|||
<pre>$ jq -r -n -f play.jq |
|||
List: [1,2,3,9,8,7,6,5,4] |
|||
Enter a pivot number: |
|||
9 |
|||
List: [4,5,6,7,8,9,3,2,1] |
|||
Enter a pivot number: |
|||
6 |
|||
List: [9,8,7,6,5,4,3,2,1] |
|||
Enter a pivot number: |
|||
9 |
|||
Great! Your score is 3</pre> |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia"># v0.6 |
|||
function numrevgame() |
|||
l = collect(1:9) |
|||
while issorted(l) shuffle!(l) end |
|||
score = 0 |
|||
println("# Number reversal game") |
|||
while !issorted(l) |
|||
print("$l\nInsert the index up to which to revert: ") |
|||
n = parse(Int, readline()) |
|||
reverse!(l, 1, n) |
|||
score += 1 |
|||
end |
|||
println("$l... You won!\nScore: $score") |
|||
return score |
|||
end |
|||
numrevgame()</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">// version 1.1.2 |
|||
fun isAscending(a: IntArray): Boolean { |
|||
for (i in 0..8) if (a[i] != i + 1) return false |
|||
return true |
|||
} |
|||
fun main(args: Array<String>) { |
|||
val r = java.util.Random() |
|||
var count = 0 |
|||
val numbers = IntArray(9) |
|||
numbers[0] = 2 + r.nextInt(8) // this will ensure list isn't ascending |
|||
for (i in 1..8) { |
|||
var rn: Int |
|||
do { |
|||
rn = 1 + r.nextInt(9) |
|||
} while (rn in numbers) |
|||
numbers[i] = rn |
|||
} |
|||
println("Here's your first list : ${numbers.joinToString()}") |
|||
while (true) { |
|||
var rev: Int |
|||
do { |
|||
print("How many numbers from the left are to be reversed : ") |
|||
rev = readLine()!!.toInt() |
|||
} while (rev !in 2..9) |
|||
count++ |
|||
var i = 0 |
|||
var j = rev - 1 |
|||
while (i < j) { |
|||
val temp = numbers[i] |
|||
numbers[i++] = numbers[j] |
|||
numbers[j--] = temp |
|||
} |
|||
if (isAscending(numbers)) { |
|||
println("Here's your final list : ${numbers.joinToString()}") |
|||
break |
|||
} |
|||
println("Here's your list now : ${numbers.joinToString()}") |
|||
} |
|||
println("So you've completed the game with a score of $count") |
|||
}</syntaxhighlight> |
|||
Sample game: |
|||
{{out}} |
|||
<pre> |
|||
Here's your first list : 4, 3, 2, 7, 1, 6, 5, 8, 9 |
|||
How many numbers from the left are to be reversed : 4 |
|||
Here's your list now : 7, 2, 3, 4, 1, 6, 5, 8, 9 |
|||
How many numbers from the left are to be reversed : 7 |
|||
Here's your list now : 5, 6, 1, 4, 3, 2, 7, 8, 9 |
|||
How many numbers from the left are to be reversed : 2 |
|||
Here's your list now : 6, 5, 1, 4, 3, 2, 7, 8, 9 |
|||
How many numbers from the left are to be reversed : 6 |
|||
Here's your list now : 2, 3, 4, 1, 5, 6, 7, 8, 9 |
|||
How many numbers from the left are to be reversed : 3 |
|||
Here's your list now : 4, 3, 2, 1, 5, 6, 7, 8, 9 |
|||
How many numbers from the left are to be reversed : 4 |
|||
Here's your final list : 1, 2, 3, 4, 5, 6, 7, 8, 9 |
|||
So you've completed the game with a score of 6 |
|||
</pre> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="lua">-- Initialisation |
|||
math.randomseed(os.time()) |
|||
numList = {values = {}} |
|||
-- Check whether list contains n |
|||
function numList:contains (n) |
|||
for k, v in pairs(self.values) do |
|||
if v == n then return true end |
|||
end |
|||
return false |
|||
end |
|||
-- Check whether list is in order |
|||
function numList:inOrder () |
|||
for k, v in pairs(self.values) do |
|||
if k ~=v then return false end |
|||
end |
|||
return true |
|||
end |
|||
-- Create necessarily out-of-order list |
|||
function numList:build () |
|||
local newNum |
|||
repeat |
|||
for i = 1, 9 do |
|||
repeat |
|||
newNum = math.random(1, 9) |
|||
until not numList:contains(newNum) |
|||
table.insert(self.values, newNum) |
|||
end |
|||
until not numList:inOrder() |
|||
end |
|||
-- Display list of numbers on one line |
|||
function numList:show () |
|||
for k, v in pairs(self.values) do |
|||
io.write(v .. " ") |
|||
end |
|||
io.write(":\t") |
|||
end |
|||
-- Reverse n values from left |
|||
function numList:reverse (n) |
|||
local swapList = {} |
|||
for k, v in pairs(self.values) do |
|||
table.insert(swapList, v) |
|||
end |
|||
for i = 1, n do |
|||
swapList[i] = self.values[n + 1 - i] |
|||
end |
|||
self.values = swapList |
|||
end |
|||
-- Main procedure |
|||
local score = 0 |
|||
print("\nRosetta Code Number Reversal Game in Lua") |
|||
print("========================================\n") |
|||
numList:build() |
|||
repeat |
|||
numList:show() |
|||
numList:reverse(tonumber(io.read())) |
|||
score = score + 1 |
|||
until numList:inOrder() |
|||
numList:show() |
|||
print("\n\nW00t! You scored:", score)</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
Using some ready made Print's from BASIC example |
|||
Using stack of values which we can move easy values. When we call subs and pass arguments that arguments as values stored to same stack, but because we pop them (read to variables) we leave stack with 9 values for the game. |
|||
To check if we have all values in order, we just check the difference of two items one after the other, if is one, and if not one then we leave checking returning false. |
|||
Sub CheckStack get a value by reference. Because stack of values always get values, a reference is a copy of a weak reference, so in CheckStack a new variable defined as local ok, and get the reference from weak reference in stack. When a sub exit any new,including local variables removed (deleted). Subs are always local to Module, and have same scope as module scope. |
|||
To display the values of stack we use Stack statement with no arguments. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Number_Reversal_Game { |
|||
PRINT "Given a jumbled list of the numbers 1 to 9," |
|||
PRINT "you must select how many digits from the left to reverse." |
|||
PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right." |
|||
\\ work on a new stack - old stack parked, and attached at the exit of this block |
|||
Stack New { |
|||
Data 1,2,3,4,5,6,7,8,9 |
|||
\\ Create jumbled list |
|||
For i=1 to 30: Reverse(Random(2,9)):Next i |
|||
Tries=0 |
|||
fin=false |
|||
Repeat { |
|||
\\ Show Stack |
|||
Stack |
|||
Try ok { |
|||
INPUT " -- How many numbers should be flipped:", flp% |
|||
} |
|||
if not Ok then print: Restart |
|||
if flp%<2 or flp%>9 then Restart |
|||
Reverse(flp%) |
|||
Tries++ |
|||
CheckStack(&fin) |
|||
} until Fin |
|||
\\ show stack again |
|||
Stack |
|||
PRINT "You took "; tries; " tries to put the digits in order." |
|||
} |
|||
Sub Reverse(n) |
|||
Shift 1, -n ' shift one item nth times in reverse |
|||
End Sub |
|||
Sub CheckStack(&ok) |
|||
ok=true |
|||
if stack.size<2 then exit sub |
|||
Local i |
|||
For i=2 to stack.size { |
|||
ok=stackitem(i)-stackitem(i-1)=1 |
|||
if ok else exit |
|||
} |
|||
End Sub |
|||
} |
|||
Number_Reversal_Game |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="text">Module[{array = Range@9, score = 0}, |
|||
While[array == Range@9, array = RandomSample@Range@9]; |
|||
While[array != Range@9, |
|||
Print@array; (array[[;; #]] = Reverse@array[[;; #]]) &@ |
|||
Input["How many digits would you like to reverse?"]; score++]; |
|||
Print@array; Print["Your score:", score]]</syntaxhighlight> |
|||
=={{header|MATLAB}}== |
|||
<syntaxhighlight lang="matlab">function NumberReversalGame |
|||
list = randperm(9); |
|||
while issorted(list) |
|||
list = randperm(9); |
|||
end |
|||
fprintf('Given a list of numbers, try to put them into ascending order\n') |
|||
fprintf('by sequentially reversing everything left of a point you choose\n') |
|||
fprintf('in the array. Try to do it in as few reversals as possible.\n') |
|||
fprintf('No input will quit the game.\n') |
|||
fprintf('Position Num:%s\n', sprintf(' %d', 1:length(list))) |
|||
fprintf('Current List:%s', sprintf(' %d', list)) |
|||
pivot = 1; |
|||
nTries = 0; |
|||
while ~isempty(pivot) && ~issorted(list) |
|||
pivot = input(' Enter position of reversal limit: '); |
|||
if pivot |
|||
list(1:pivot) = list(pivot:-1:1); |
|||
fprintf('Current List:%s', sprintf(' %d', list)) |
|||
nTries = nTries+1; |
|||
end |
|||
end |
|||
if issorted(list) |
|||
fprintf('\nCongratulations! You win! Only %d reversals.\n', nTries) |
|||
else |
|||
fprintf('\nPlay again soon!\n') |
|||
end |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Given a list of numbers, try to put them into ascending order |
|||
by sequentially reversing everything left of a point you choose |
|||
in the array. Try to do it in as few reversals as possible. |
|||
No input will quit the game. |
|||
Position Num: 1 2 3 4 5 6 7 8 9 |
|||
Current List: 1 6 3 2 8 7 9 4 5 Enter position of reversal limit: 7 |
|||
Current List: 9 7 8 2 3 6 1 4 5 Enter position of reversal limit: 9 |
|||
Current List: 5 4 1 6 3 2 8 7 9 Enter position of reversal limit: 7 |
|||
Current List: 8 2 3 6 1 4 5 7 9 Enter position of reversal limit: 8 |
|||
Current List: 7 5 4 1 6 3 2 8 9 Enter position of reversal limit: 7 |
|||
Current List: 2 3 6 1 4 5 7 8 9 Enter position of reversal limit: 3 |
|||
Current List: 6 3 2 1 4 5 7 8 9 Enter position of reversal limit: 6 |
|||
Current List: 5 4 1 2 3 6 7 8 9 Enter position of reversal limit: 5 |
|||
Current List: 3 2 1 4 5 6 7 8 9 Enter position of reversal limit: 3 |
|||
Current List: 1 2 3 4 5 6 7 8 9 |
|||
Congratulations! You win! Only 9 reversals.</pre> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">import random, rdstdin, strutils, algorithm |
|||
randomize() |
|||
proc isSorted[T](s: openarray[T]): bool = |
|||
var last = low(T) |
|||
for c in s: |
|||
if c < last: |
|||
return false |
|||
last = c |
|||
return true |
|||
proc toString[T](s: openarray[T]): string = |
|||
result = "" |
|||
for i, x in s: |
|||
if i > 0: |
|||
result.add " " |
|||
result.add($x) |
|||
echo """number reversal game |
|||
Given a jumbled list of the numbers 1 to 9 |
|||
Show the list. |
|||
Ask the player how many digits from the left to reverse. |
|||
Reverse those digits then ask again. |
|||
until all the digits end up in ascending order.""" |
|||
var data = @[1,2,3,4,5,6,7,8,9] |
|||
var trials = 0 |
|||
while isSorted data: |
|||
shuffle data |
|||
while not isSorted data: |
|||
inc trials |
|||
var flip = parseInt readLineFromStdin( |
|||
"#" & $trials & ": List: '" & toString(data) & "' Flip how many?: ") |
|||
reverse(data, 0, flip - 1) |
|||
echo "You took ", trials, " attempts to put the digits in order!"</syntaxhighlight> |
|||
Example: |
|||
<pre>#1: List: '6 5 8 7 2 1 9 3 4' Flip how many?: 5 |
|||
#2: List: '2 7 8 5 6 1 9 3 4' Flip how many?: 6 |
|||
#3: List: '1 6 5 8 7 2 9 3 4' Flip how many?: 9 |
|||
#4: List: '4 3 9 2 7 8 5 6 1' Flip how many?: 4 |
|||
#5: List: '2 9 3 4 7 8 5 6 1' Flip how many?: 8 |
|||
#6: List: '6 5 8 7 4 3 9 2 1' Flip how many?: 6 |
|||
#7: List: '3 4 7 8 5 6 9 2 1' Flip how many?: 7 |
|||
#8: List: '9 6 5 8 7 4 3 2 1' Flip how many?: 3 |
|||
#9: List: '5 6 9 8 7 4 3 2 1' Flip how many?: 5 |
|||
#10: List: '7 8 9 6 5 4 3 2 1' Flip how many?: 3 |
|||
#11: List: '9 8 7 6 5 4 3 2 1' Flip how many?: 9 |
|||
You took 11 attempts to put the digits in order!</pre> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
Line 1,400: | Line 3,404: | ||
=== Imperative === |
=== Imperative === |
||
< |
<syntaxhighlight lang="ocaml">let swap ar i j = |
||
let tmp = ar.(i) in |
let tmp = ar.(i) in |
||
ar.(i) <- ar.(j); |
ar.(i) <- ar.(j); |
||
Line 1,447: | Line 3,451: | ||
print_endline "Congratulations!"; |
print_endline "Congratulations!"; |
||
Printf.printf "You took %d attempts to put the digits in order.\n" !n; |
Printf.printf "You took %d attempts to put the digits in order.\n" !n; |
||
;;</ |
;;</syntaxhighlight> |
||
=== Functional === |
=== Functional === |
||
< |
<syntaxhighlight lang="ocaml">let revert li n = |
||
let rec aux acc i = function |
let rec aux acc i = function |
||
| [] -> acc |
| [] -> acc |
||
Line 1,499: | Line 3,503: | ||
in |
in |
||
loop 1 li |
loop 1 li |
||
;;</ |
;;</syntaxhighlight> |
||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">import: console |
|||
: reversalGame |
|||
| l n | |
|||
doWhile: [ |
|||
ListBuffer new ->l |
|||
while(l size 9 <>) [ 9 rand dup l include ifFalse: [ l add ] else: [ drop ] ] |
|||
l sort l == |
|||
] |
|||
0 while(l sort l <>) [ |
|||
System.Out "List is " << l << " ==> how many digits from left to reverse : " <- |
|||
System.Console askln asInteger dup ifNull: [ drop continue ] ->n |
|||
1+ l left(n) reverse l right(l size n -) + ->l |
|||
] |
|||
"You won ! Your score is :" . println ;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
>reversalGame |
|||
List is [9, 1, 3, 6, 5, 7, 8, 4, 2] ==> how many digits from left to reverse : 9 |
|||
List is [2, 4, 8, 7, 5, 6, 3, 1, 9] ==> how many digits from left to reverse : 3 |
|||
List is [8, 4, 2, 7, 5, 6, 3, 1, 9] ==> how many digits from left to reverse : 8 |
|||
List is [1, 3, 6, 5, 7, 2, 4, 8, 9] ==> how many digits from left to reverse : 5 |
|||
List is [7, 5, 6, 3, 1, 2, 4, 8, 9] ==> how many digits from left to reverse : 7 |
|||
List is [4, 2, 1, 3, 6, 5, 7, 8, 9] ==> how many digits from left to reverse : 5 |
|||
List is [6, 3, 1, 2, 4, 5, 7, 8, 9] ==> how many digits from left to reverse : 6 |
|||
List is [5, 4, 2, 1, 3, 6, 7, 8, 9] ==> how many digits from left to reverse : 5 |
|||
List is [3, 1, 2, 4, 5, 6, 7, 8, 9] ==> how many digits from left to reverse : 3 |
|||
List is [2, 1, 3, 4, 5, 6, 7, 8, 9] ==> how many digits from left to reverse : 2 |
|||
You won ! Your score is : 10 |
|||
</pre> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
< |
<syntaxhighlight lang="oz">declare |
||
proc {Main} |
proc {Main} |
||
proc {Loop N Xs} |
proc {Loop N Xs} |
||
Line 1,560: | Line 3,599: | ||
end |
end |
||
in |
in |
||
{Main}</ |
{Main}</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
|||
<syntaxhighlight lang="parigp">game()={ |
|||
my(v=numtoperm(9,random(9!-1)),score,in,t); \\ Create vector with 1..9, excluding the one sorted in ascending order |
|||
while(v!=vecsort(v), |
|||
print(concat(concat([""],v))); |
|||
in=input(); |
|||
for(i=0,in\2-1, |
|||
t=v[9-i]; |
|||
v[9-i]=v[10-in+i]; |
|||
v[10-in+i]=t |
|||
); |
|||
score++ |
|||
); |
|||
score |
|||
};</syntaxhighlight> |
|||
=={{header|Pascal}}== |
|||
<syntaxhighlight lang="pascal"> |
|||
program NumberReversalGame; |
|||
procedure PrintList(list: array of integer); |
|||
var |
|||
i: integer; |
|||
begin |
|||
for i := low(list) to high(list) do |
|||
begin |
|||
Write(list[i]); |
|||
if i < high(list) then Write(', '); |
|||
end; |
|||
WriteLn; |
|||
end; |
|||
procedure Swap(var list: array of integer; i, j: integer); |
|||
var |
|||
buf: integer; |
|||
begin |
|||
buf := list[i]; |
|||
list[i] := list[j]; |
|||
list[j] := buf; |
|||
end; |
|||
procedure ShuffleList(var list: array of integer); |
|||
var |
|||
i, j, n: integer; |
|||
begin |
|||
Randomize; |
|||
for n := 0 to 99 do |
|||
begin |
|||
i := Random(high(list)+1); |
|||
j := Random(high(list)+1); |
|||
Swap(list, i, j); |
|||
end; |
|||
end; |
|||
procedure ReverseList(var list: array of integer; j: integer); |
|||
var |
|||
i: integer; |
|||
begin |
|||
i := low(list); |
|||
while i < j do |
|||
begin |
|||
Swap(list, i, j); |
|||
i += 1; |
|||
j -= 1; |
|||
end; |
|||
end; |
|||
function IsOrdered(list: array of integer): boolean; |
|||
var |
|||
i: integer; |
|||
begin |
|||
IsOrdered := true; |
|||
i:= high(list); |
|||
while i > 0 do |
|||
begin |
|||
if list[i] <> (list[i-1] + 1) then |
|||
begin |
|||
IsOrdered:= false; |
|||
break; |
|||
end; |
|||
i -= 1; |
|||
end; |
|||
end; |
|||
var |
|||
list: array [0..8] of integer = (1, 2, 3, 4, 5, 6, 7, 8, 9); |
|||
n: integer; |
|||
moves: integer; |
|||
begin |
|||
WriteLn('Number Reversal Game'); |
|||
WriteLn; |
|||
WriteLn('Sort the following list in ascending order by reversing the first n digits'); |
|||
WriteLn('from the left.'); |
|||
WriteLn; |
|||
ShuffleList(list); |
|||
PrintList(list); |
|||
moves := 0; |
|||
while not IsOrdered(list) do |
|||
begin |
|||
WriteLn('How many digits from the left will you reverse?'); |
|||
Write('> '); |
|||
Read(n); |
|||
ReverseList(list, n-1); |
|||
PrintList(list); |
|||
moves += 1; |
|||
end; |
|||
WriteLn; |
|||
WriteLn('Congratulations you made it in just ', moves, ' moves!'); |
|||
WriteLn; |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">use List::Util qw(shuffle); |
||
my $turn = 0; |
my $turn = 0; |
||
Line 1,582: | Line 3,743: | ||
print " @jumble\n"; |
print " @jumble\n"; |
||
print "You won in $turn turns.\n";</ |
print "You won in $turn turns.\n";</syntaxhighlight> |
||
Output: |
Output: |
||
Line 1,596: | Line 3,757: | ||
You won in 8 turns.</pre> |
You won in 8 turns.</pre> |
||
=={{header| |
=={{header|Phix}}== |
||
Simplified copy of [[Number_reversal_game#Euphoria|Euphoria]] |
|||
<syntaxhighlight lang="phix">puts(1,"Given a jumbled list of the numbers 1 to 9,\n") |
|||
puts(1,"you must select how many digits from the left to reverse.\n") |
|||
puts(1,"Your goal is to get the digits in order with 1 on the left and 9 on the right.\n") |
|||
constant inums = tagset(9) |
|||
sequence nums |
|||
integer turns = 0, flip |
|||
while 1 do |
|||
nums = shuffle(inums) |
|||
if nums!=inums then exit end if |
|||
end while |
|||
while 1 do |
|||
printf(1,"%2d : %d %d %d %d %d %d %d %d %d ",turns&nums) |
|||
if nums=inums then exit end if |
|||
flip = prompt_number(" -- How many numbers should be flipped? ",{1,9}) |
|||
nums[1..flip] = reverse(nums[1..flip]) |
|||
turns += 1 |
|||
end while |
|||
printf(1,"\nYou took %d turns to put the digits in order.", turns)</syntaxhighlight> |
|||
{{out}} |
|||
<pre style="font-size: 8px"> |
|||
Given a jumbled list of the numbers 1 to 9, |
|||
you must select how many digits from the left to reverse. |
|||
Your goal is to get the digits in order with 1 on the left and 9 on the right. |
|||
0 : 3 7 8 1 6 2 5 4 9 -- How many numbers should be flipped? 3 |
|||
1 : 8 7 3 1 6 2 5 4 9 -- How many numbers should be flipped? 8 |
|||
2 : 4 5 2 6 1 3 7 8 9 -- How many numbers should be flipped? 4 |
|||
3 : 6 2 5 4 1 3 7 8 9 -- How many numbers should be flipped? 6 |
|||
4 : 3 1 4 5 2 6 7 8 9 -- How many numbers should be flipped? 4 |
|||
5 : 5 4 1 3 2 6 7 8 9 -- How many numbers should be flipped? 5 |
|||
6 : 2 3 1 4 5 6 7 8 9 -- How many numbers should be flipped? 2 |
|||
7 : 3 2 1 4 5 6 7 8 9 -- How many numbers should be flipped? 3 |
|||
8 : 1 2 3 4 5 6 7 8 9 |
|||
You took 8 turns to put the digits in order. |
|||
</pre> |
|||
=={{header|PHP}}== |
|||
Do-at-least-once loops are fairly rare, but this program wants to have two of them. We use the built-in <tt>.pick(*)</tt> method to shuffle the numbers. We use <tt>.=</tt> to dispatch a mutating method in two spots; the first is just a different way to write <tt>++</tt>, while the second of these reverses an array slice in place. The <tt>[<]</tt> is a reduction operator on less than, so it returns true if the elements of the list are strictly ordered. We also see in the first repeat loop that, although the while condition is not tested till after the loop, the while condition can in fact declare the variable that will be initialized the first time through the loop, which is a neat trick, and not half unreadable once you get used to it. |
|||
<syntaxhighlight lang="php">class ReversalGame { |
|||
<lang Perl6>repeat while [<] my @jumbled-list { |
|||
private $numbers; |
|||
@jumbled-list = (1..9).pick(*) |
|||
public function __construct() { |
|||
$this->initialize(); |
|||
} |
|||
public function play() { |
|||
$i = 0; |
|||
$moveCount = 0; |
|||
while (true) { |
|||
echo json_encode($this->numbers) . "\n"; |
|||
echo "Please enter an index to reverse from 2 to 9. Enter 99 to quit\n"; |
|||
$i = intval(rtrim(fgets(STDIN), "\n")); |
|||
if ($i == 99) { |
|||
break; |
|||
} |
|||
if ($i < 2 || $i > 9) { |
|||
echo "Invalid input\n"; |
|||
} else { |
|||
$moveCount++; |
|||
$this->reverse($i); |
|||
if ($this->isSorted()) { |
|||
echo "Congratulations you solved this in $moveCount moves!\n"; |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
private function reverse($position) { |
|||
array_splice($this->numbers, 0, $position, array_reverse(array_slice($this->numbers, 0, $position))); |
|||
} |
|||
private function isSorted() { |
|||
for ($i = 0; $i < count($this->numbers) - 1; ++$i) { |
|||
if ($this->numbers[$i] > $this->numbers[$i + 1]) { |
|||
return false; |
|||
} |
|||
} |
|||
return true; |
|||
} |
|||
private function initialize() { |
|||
$this->numbers = range(1, 9); |
|||
while ($this->isSorted()) { |
|||
shuffle($this->numbers); |
|||
} |
|||
} |
|||
} |
} |
||
$game = new ReversalGame(); |
|||
my $turn = 0; |
|||
$game->play(); |
|||
repeat until [<] @jumbled-list { |
|||
</syntaxhighlight> |
|||
my $d = prompt $turn.=succ.fmt('%2d: ') ~ |
|||
@jumbled-list ~ |
|||
" - Flip how many digits? " |
|||
or exit; |
|||
@jumbled-list[^$d] .= reverse; |
|||
} |
|||
say " @jumbled-list[]"; |
|||
say "You won in $turn turns.";</lang> |
|||
Output: |
|||
<pre> 1: 3 5 8 2 7 9 6 1 4 - Flip how many digits ? 6 |
|||
2: 9 7 2 8 5 3 6 1 4 - Flip how many digits ? 9 |
|||
3: 4 1 6 3 5 8 2 7 9 - Flip how many digits ? 6 |
|||
4: 8 5 3 6 1 4 2 7 9 - Flip how many digits ? 8 |
|||
5: 7 2 4 1 6 3 5 8 9 - Flip how many digits ? 7 |
|||
6: 5 3 6 1 4 2 7 8 9 - Flip how many digits ? 3 |
|||
7: 6 3 5 1 4 2 7 8 9 - Flip how many digits ? 6 |
|||
8: 2 4 1 5 3 6 7 8 9 - Flip how many digits ? 4 |
|||
9: 5 1 4 2 3 6 7 8 9 - Flip how many digits ? 5 |
|||
10: 3 2 4 1 5 6 7 8 9 - Flip how many digits ? 3 |
|||
11: 4 2 3 1 5 6 7 8 9 - Flip how many digits ? 4 |
|||
12: 1 3 2 4 5 6 7 8 9 - Flip how many digits ? 2 |
|||
13: 3 1 2 4 5 6 7 8 9 - Flip how many digits ? 3 |
|||
14: 2 1 3 4 5 6 7 8 9 - Flip how many digits ? 2 |
|||
1 2 3 4 5 6 7 8 9 |
|||
You won in 14 turns.</pre> |
|||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(load "@lib/simul.l") |
||
(de reversalGame () |
(de reversalGame () |
||
Line 1,646: | Line 3,869: | ||
(NIL (num? (read))) |
(NIL (num? (read))) |
||
(setq Lst (flip Lst @)) |
(setq Lst (flip Lst @)) |
||
(inc 'Cnt) ) ) )</ |
(inc 'Cnt) ) ) )</syntaxhighlight> |
||
Output: |
Output: |
||
<pre>: (reversalGame) |
<pre>: (reversalGame) |
||
Line 1,660: | Line 3,883: | ||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
<syntaxhighlight lang="pl/i"> |
|||
<lang PL/I> |
|||
digits: procedure options (main); /* 23 April 2010 */ |
digits: procedure options (main); /* 23 April 2010 */ |
||
declare s character (9) varying; |
declare s character (9) varying; |
||
Line 1,694: | Line 3,917: | ||
go to restart; |
go to restart; |
||
end digits; |
end digits; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell"> |
|||
#adding the below function to the previous users submission to prevent the small |
|||
#chance of getting an array that is in ascending order. |
|||
#Full disclosure: I am an infrastructure engineer, not a dev. My code is likely |
|||
#bad. |
|||
function generateArray{ |
|||
$fArray = 1..9 | Get-Random -Count 9 |
|||
if (-join $fArray -eq -join @(1..9)){ |
|||
generateArray |
|||
} |
|||
return $fArray |
|||
} |
|||
$array = generateArray |
|||
#everything below is untouched from original submission |
|||
$nTries = 0 |
|||
While(-join $Array -ne -join @(1..9)){ |
|||
$nTries++ |
|||
$nReverse = Read-Host -Prompt "[$Array] -- How many digits to reverse? " |
|||
[Array]::Reverse($Array,0,$nReverse) |
|||
} |
|||
"$Array" |
|||
"Your score: $nTries" |
|||
</syntaxhighlight> |
|||
=={{header|Prolog}}== |
|||
<syntaxhighlight lang="prolog">play :- random_numbers(L), do_turn(0,L), !. |
|||
do_turn(N, L) :- |
|||
print_list(L), |
|||
how_many_to_flip(F), |
|||
flip(L,F,[],Lnew), |
|||
succ(N,N1), |
|||
sorted(N1,Lnew). |
|||
how_many_to_flip(F) :- |
|||
read_line_to_codes(user_input, Line), |
|||
number_codes(F, Line), |
|||
between(1,9,F). |
|||
flip(L,0,C,R) :- append(C,L,R). |
|||
flip([Ln|T],N,C,R) :- dif(N,0), succ(N0,N), flip(T,N0,[Ln|C],R). |
|||
sorted(N,L) :- |
|||
sort(L,L) |
|||
-> print_list(L), format('-> ~p~n', N) |
|||
; do_turn(N,L). |
|||
random_numbers(L) :- random_permutation([1,2,3,4,5,6,7,8,9],L). |
|||
print_list(L) :- |
|||
atomic_list_concat(L, ' ', Lf), |
|||
format('(~w) ',Lf).</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
?- play. |
|||
(5 1 8 4 3 6 7 9 2) 8 |
|||
(9 7 6 3 4 8 1 5 2) 5 |
|||
(4 3 6 7 9 8 1 5 2) 6 |
|||
(8 9 7 6 3 4 1 5 2) 2 |
|||
(9 8 7 6 3 4 1 5 2) 9 |
|||
(2 5 1 4 3 6 7 8 9) 2 |
|||
(5 2 1 4 3 6 7 8 9) 3 |
|||
(1 2 5 4 3 6 7 8 9) 5 |
|||
(3 4 5 2 1 6 7 8 9) 2 |
|||
(4 3 5 2 1 6 7 8 9) 3 |
|||
(5 3 4 2 1 6 7 8 9) 2 |
|||
(3 5 4 2 1 6 7 8 9) 3 |
|||
(4 5 3 2 1 6 7 8 9) 2 |
|||
(5 4 3 2 1 6 7 8 9) 5 |
|||
(1 2 3 4 5 6 7 8 9) -> 14 |
|||
true. |
|||
</pre> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">Dim MyList(9) |
||
Declare is_list_sorted() |
Declare is_list_sorted() |
||
Line 1,743: | Line 4,043: | ||
Next |
Next |
||
ProcedureReturn #True |
ProcedureReturn #True |
||
EndProcedure</ |
EndProcedure</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">''' |
||
number reversal game |
number reversal game |
||
Given a jumbled list of the numbers 1 to 9 |
Given a jumbled list of the numbers 1 to 9 |
||
Line 1,767: | Line 4,067: | ||
data[:flip] = reversed(data[:flip]) |
data[:flip] = reversed(data[:flip]) |
||
print('\nYou took %2i attempts to put the digits in order!' % trials)</ |
print('\nYou took %2i attempts to put the digits in order!' % trials)</syntaxhighlight> |
||
'''Sample output:''' |
'''Sample output:''' |
||
Line 1,791: | Line 4,091: | ||
You took 10 attempts to put the digits in order!</pre> |
You took 10 attempts to put the digits in order!</pre> |
||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> [ 0 temp put |
|||
[] 9 times |
|||
[ i^ 1+ join ] |
|||
dup |
|||
[ shuffle 2dup != until ] |
|||
[ dup echo cr |
|||
2dup != while |
|||
[ $ "Reverse how many? " |
|||
input |
|||
$->n not iff |
|||
drop again ] |
|||
split dip reverse join |
|||
1 temp tally |
|||
again ] |
|||
drop cr |
|||
say "That took " |
|||
temp take echo |
|||
say " reversals." ] is play ( --> )</syntaxhighlight> |
|||
{{out}} |
|||
Playing in the Quackery shell. |
|||
<pre>/O> play |
|||
... |
|||
[ 8 6 5 9 4 1 7 2 3 ] |
|||
Reverse how many? 3 |
|||
[ 5 6 8 9 4 1 7 2 3 ] |
|||
Reverse how many? 4 |
|||
[ 9 8 6 5 4 1 7 2 3 ] |
|||
Reverse how many? 9 |
|||
[ 3 2 7 1 4 5 6 8 9 ] |
|||
Reverse how many? 3 |
|||
[ 7 2 3 1 4 5 6 8 9 ] |
|||
Reverse how many? 7 |
|||
[ 6 5 4 1 3 2 7 8 9 ] |
|||
Reverse how many? 6 |
|||
[ 2 3 1 4 5 6 7 8 9 ] |
|||
Reverse how many? 2 |
|||
[ 3 2 1 4 5 6 7 8 9 ] |
|||
Reverse how many? 3 |
|||
[ 1 2 3 4 5 6 7 8 9 ] |
|||
That took 8 reversals.</pre> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
<lang>reversalGame <- function(){ |
<syntaxhighlight lang="text">reversalGame <- function(){ |
||
cat("Welcome to the Number Reversal Game! \n") |
cat("Welcome to the Number Reversal Game! \n") |
||
cat("Sort the numbers into ascending order by repeatedly \n", |
cat("Sort the numbers into ascending order by repeatedly \n", |
||
Line 1,816: | Line 4,161: | ||
# Victory! |
# Victory! |
||
cat("Well done. You needed", trials, "flips. \n") |
cat("Well done. You needed", trials, "flips. \n") |
||
}</ |
}</syntaxhighlight> |
||
Sample output: |
Sample output: |
||
<lang>>reversalGame() |
<syntaxhighlight lang="text">>reversalGame() |
||
Welcome to the Number Reversal Game! |
Welcome to the Number Reversal Game! |
||
Sort the numbers into ascending order by repeatedly |
Sort the numbers into ascending order by repeatedly |
||
Line 1,828: | Line 4,173: | ||
Trial 03 # 9 8 7 1 2 3 4 5 6 # Flip how many? 9 |
Trial 03 # 9 8 7 1 2 3 4 5 6 # Flip how many? 9 |
||
Trial 04 # 6 5 4 3 2 1 7 8 9 # Flip how many? 6 |
Trial 04 # 6 5 4 3 2 1 7 8 9 # Flip how many? 6 |
||
Well done. You needed 4 flips.</ |
Well done. You needed 4 flips.</syntaxhighlight> |
||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket">#lang racket |
|||
(let loop ([nums (range 1 10)] [n 0]) |
|||
(cond [(apply < nums) (if (zero? n) |
|||
(loop (shuffle nums) 0) |
|||
(printf "Done in ~s steps.\n" n))] |
|||
[else (printf "Step #~s: ~s\nFlip how many? " n nums) |
|||
(define-values (l r) (split-at nums (read))) |
|||
(loop (append (reverse l) r) (add1 n))]))</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
Do-at-least-once loops are fairly rare, but this program wants to have two of them. We use the built-in <tt>.pick(*)</tt> method to shuffle the numbers. We use <tt>.=</tt> to dispatch a mutating method in two spots; the first is just a different way to write <tt>++</tt>, while the second of these reverses an array slice in place. The <tt>[<]</tt> is a reduction operator on less than, so it returns true if the elements of the list are strictly ordered. We also see in the first repeat loop that, although the while condition is not tested till after the loop, the while condition can in fact declare the variable that will be initialized the first time through the loop, which is a neat trick, and not half unreadable once you get used to it. |
|||
<syntaxhighlight lang="raku" line>repeat while [<] my @jumbled-list { |
|||
@jumbled-list = (1..9).pick(*) |
|||
} |
|||
my $turn = 0; |
|||
repeat until [<] @jumbled-list { |
|||
my $d = prompt $turn.=succ.fmt('%2d: ') ~ |
|||
@jumbled-list ~ |
|||
" - Flip how many digits? " |
|||
or exit; |
|||
@jumbled-list[^$d] .= reverse; |
|||
} |
|||
say " @jumbled-list[]"; |
|||
say "You won in $turn turns.";</syntaxhighlight> |
|||
Output: |
|||
<pre> 1: 3 5 8 2 7 9 6 1 4 - Flip how many digits ? 6 |
|||
2: 9 7 2 8 5 3 6 1 4 - Flip how many digits ? 9 |
|||
3: 4 1 6 3 5 8 2 7 9 - Flip how many digits ? 6 |
|||
4: 8 5 3 6 1 4 2 7 9 - Flip how many digits ? 8 |
|||
5: 7 2 4 1 6 3 5 8 9 - Flip how many digits ? 7 |
|||
6: 5 3 6 1 4 2 7 8 9 - Flip how many digits ? 3 |
|||
7: 6 3 5 1 4 2 7 8 9 - Flip how many digits ? 6 |
|||
8: 2 4 1 5 3 6 7 8 9 - Flip how many digits ? 4 |
|||
9: 5 1 4 2 3 6 7 8 9 - Flip how many digits ? 5 |
|||
10: 3 2 4 1 5 6 7 8 9 - Flip how many digits ? 3 |
|||
11: 4 2 3 1 5 6 7 8 9 - Flip how many digits ? 4 |
|||
12: 1 3 2 4 5 6 7 8 9 - Flip how many digits ? 2 |
|||
13: 3 1 2 4 5 6 7 8 9 - Flip how many digits ? 3 |
|||
14: 2 1 3 4 5 6 7 8 9 - Flip how many digits ? 2 |
|||
1 2 3 4 5 6 7 8 9 |
|||
You won in 14 turns.</pre> |
|||
=={{header|Rascal}}== |
|||
<syntaxhighlight lang="rascal">import Prelude; |
|||
import vis::Figure; |
|||
import vis::Render; |
|||
public void NumberReversalGame(){ |
|||
//generate randomlist |
|||
L = [1..9]; |
|||
score = 0; |
|||
randomlist = []; |
|||
while (L != []){ |
|||
temp = takeOneFrom(L); |
|||
randomlist += temp[0]; |
|||
L = temp[1]; |
|||
} |
|||
// user interaction |
|||
score = 0; |
|||
text1 = ""; |
|||
figure = |
|||
box(vcat([ |
|||
box(text(str(){ |
|||
return "<randomlist>";})), |
|||
box(textfield("Insert number of digits you would like to reverse here.", |
|||
void(str s){ |
|||
score += 1; |
|||
n = toInt(s); |
|||
spliced = slice(randomlist, 0, n); |
|||
randomlist = reverse(spliced) + (randomlist - spliced); |
|||
}, |
|||
fillColor("lightblue"))), |
|||
box(text(str(){ |
|||
return ((randomlist == [1 .. 9]) ? "Well done! Your score: <score>." : "Keep going!");})) |
|||
])); |
|||
render(figure); |
|||
}</syntaxhighlight> |
|||
Output: |
|||
[[File:NRG3.jpg]] |
|||
=={{header|REBOL}}== |
|||
<syntaxhighlight lang="rebol">REBOL [] |
|||
print "NUMBER REVERSAL GAME" |
|||
tries: 0 |
|||
goal: [1 2 3 4 5 6 7 8 9] |
|||
random/seed now |
|||
until [ |
|||
jumble: random goal |
|||
jumble != goal ; repeat in the unlikely case that jumble isn't jumbled |
|||
] |
|||
while [jumble != goal] [ |
|||
prin jumble |
|||
prin " How many to flip? " |
|||
flip-index: to-integer input ; no validation! |
|||
reverse/part jumble flip-index |
|||
tries: tries + 1 |
|||
] |
|||
print rejoin ["You took " tries " attempts."]</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
This REXX version: |
|||
:::* displays the game's objective and rules |
|||
:::* validates the input (must be a single non-zero decimal digit) |
|||
:::* allows the user to enter '''quit''' |
|||
:::* allows the user to halt the game via '''Cntl-Break''' (or equivalent) |
|||
<syntaxhighlight lang="rexx">/*REXX program (a game): reverse a jumbled set of decimal digits 'til they're in order.*/ |
|||
signal on halt /*allows the CBLF to HALT the program.*/ |
|||
___= copies('─', 9); pad=left('', 9) /*a fence used for computer's messages.*/ |
|||
say ___ "This game will show you nine random unique digits (1 ──► 9), and you'll enter" |
|||
say ___ "one of those digits which will reverse all the digits from the left-most digit" |
|||
say ___ "up to (and including) that decimal digit. The game's objective is to get all" |
|||
say ___ "of the digits in ascending order with the fewest tries. Here're your digits:" |
|||
ok= 123456789 /*the result that the string should be.*/ |
|||
$= /* ◄─── decimal target to be generated.*/ |
|||
do until length($)==9; _=random(1, 9) /*build a random unique numeric string.*/ |
|||
if pos(_, $) \== 0 then iterate /*¬ unique? Only use a decimal dig once*/ |
|||
$=$ || _ /*construct a string of unique digits. */ |
|||
if $==ok then $= /*string can't be in order, start over.*/ |
|||
end /*until*/ |
|||
do score=1 until $==ok; say /* [↓] display the digits & the prompt*/ |
|||
say ___ $ right('please enter a digit (or Quit):', 50) |
|||
parse pull ox . 1 ux . 1 x .; upper ux /*get a decimal digit (maybe) from CBLF*/ |
|||
if abbrev('QUIT', ux, 1) then signal halt /*does the CBLF want to quit this game?*/ |
|||
if length(x)>1 then do; say ___ pad '***error*** invalid input: ' ox; iterate; end |
|||
if x='' then iterate /*try again, CBLF didn't enter anything*/ |
|||
g=pos(x, $) /*validate if the input digit is legal.*/ |
|||
if g==0 then say ___ pad '***error*** invalid digit: ' ox |
|||
else $=strip(reverse(left($,g))substr($,g+1)) /*reverse some (or all) digits*/ |
|||
end /*score*/ |
|||
say; say ___ $; say; say center(' Congratulations! ', 70, "═"); say |
|||
say ___ pad 'Your score was' score; exit /*stick a fork in it, we're all done. */ |
|||
halt: say ___ pad 'quitting.'; exit /* " " " " " " " " */</syntaxhighlight> |
|||
{{out|output|text= from playing one game of the ''number reversal game'': |
|||
<pre> |
|||
───────── This game will show you nine random unique digits (1 ──► 9), and you'll enter |
|||
───────── one of those digits which will reverse all the digits from the left-most digit |
|||
───────── up to (and including) that decimal digit. The game's objective is to get all |
|||
───────── of the digits in ascending order with the fewest tries. Here're your digits: |
|||
───────── 613279548 please enter a digit (or Quit): |
|||
5 ◄■■■■■■■■■ user input |
|||
───────── 597231648 please enter a digit (or Quit): |
|||
9 ◄■■■■■■■■■ user input |
|||
───────── 957231648 please enter a digit (or Quit): |
|||
8 ◄■■■■■■■■■ user input |
|||
───────── 846132759 please enter a digit (or Quit): |
|||
5 ◄■■■■■■■■■ user input |
|||
───────── 572316489 please enter a digit (or Quit): |
|||
7 ◄■■■■■■■■■ user input |
|||
───────── 752316489 please enter a digit (or Quit): |
|||
4 ◄■■■■■■■■■ user input |
|||
───────── 461325789 please enter a digit (or Quit): |
|||
6 ◄■■■■■■■■■ user input |
|||
───────── 641325789 please enter a digit (or Quit): |
|||
5 ◄■■■■■■■■■ user input |
|||
───────── 523146789 please enter a digit (or Quit): |
|||
4 ◄■■■■■■■■■ user input |
|||
───────── 413256789 please enter a digit (or Quit): |
|||
2 ◄■■■■■■■■■ user input |
|||
───────── 231456789 please enter a digit (or Quit): |
|||
3 ◄■■■■■■■■■ user input |
|||
───────── 321456789 please enter a digit (or Quit): |
|||
1 ◄■■■■■■■■■ user input |
|||
───────── 123456789 |
|||
══════════════════════════ Congratulations! ══════════════════════════ |
|||
───────── Your score was 12 |
|||
</pre> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Number reversal game |
|||
rever = 1:9 |
|||
leftrever = [] |
|||
for n = 1 to len(rever) |
|||
rnd = random(8) + 1 |
|||
temp = rever[n] |
|||
rever[n] = rever[rnd] |
|||
rever[rnd] = temp |
|||
next |
|||
see rever |
|||
see nl |
|||
while true |
|||
num = 0 |
|||
leftrever = [] |
|||
showarray(rever) |
|||
see " : Reverse how many = " |
|||
give r |
|||
r = number(r) |
|||
for n = 1 to r |
|||
add(leftrever, rever[n]) |
|||
next |
|||
leftrever = reverse(leftrever) |
|||
for pos = 1 to r |
|||
rever[pos] = leftrever[pos] |
|||
next |
|||
for m = 1 to len(rever) |
|||
if rever[m] = m |
|||
num = num + 1 |
|||
ok |
|||
next |
|||
if num = len(rever) |
|||
exit |
|||
ok |
|||
end |
|||
see "You took " + num + " attempts." + nl |
|||
func swap(a, b) |
|||
temp = a |
|||
a = b |
|||
b = temp |
|||
return [a, b] |
|||
func showarray(vect) |
|||
svect = "" |
|||
for n = 1 to len(vect) |
|||
svect = svect + vect[n] + " " |
|||
next |
|||
svect = left(svect, len(svect) - 1) |
|||
see svect |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
7 2 3 1 5 8 6 4 9 : Reverse how many? 6 |
|||
8 5 1 3 2 7 6 4 9 : Reverse how many? 8 |
|||
4 6 7 2 3 1 5 8 9 : Reverse how many? 3 |
|||
7 6 4 2 3 1 5 8 9 : Reverse how many? 7 |
|||
5 1 3 2 4 6 7 8 9 : Reverse how many? 5 |
|||
4 2 3 1 5 6 7 8 9 : Reverse how many? 4 |
|||
1 3 2 4 5 6 7 8 9 : Reverse how many? 3 |
|||
2 3 1 4 5 6 7 8 9 : Reverse how many? 2 |
|||
3 2 1 4 5 6 7 8 9 : Reverse how many? 3 |
|||
You took 9 attempts. |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby">ary = (1..9).to_a |
||
ary.shuffle! while ary == ary.sort |
ary.shuffle! while ary == ary.sort |
||
score = 0 |
score = 0 |
||
Line 1,841: | Line 4,455: | ||
end |
end |
||
p ary |
p ary |
||
puts "Your score: #{score}"</ |
puts "Your score: #{score}"</syntaxhighlight> |
||
sample output: |
sample output: |
||
Line 1,855: | Line 4,469: | ||
[1, 2, 3, 4, 5, 6, 7, 8, 9] |
[1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
Your score: 8</pre> |
Your score: 8</pre> |
||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">for i = 1 to 9 ' get numbers 1 to 9 |
|||
n(i) = i |
|||
next i |
|||
numShuffles = 3 |
|||
' ---------------------------------- |
|||
' shuffle numbers |
|||
' ---------------------------------- |
|||
for i = 1 to 9 * numShuffles |
|||
i1 = int(rnd(1)*9) + 1 |
|||
i2 = int(rnd(1)*9) + 1 |
|||
h2 = n(i1) |
|||
n(i1) = n(i2) |
|||
n(i2) = h2 |
|||
next i |
|||
for i = 1 to 9 |
|||
a$ = a$ + str$(n(i)) + " " |
|||
next i |
|||
count = 0 |
|||
[loop] |
|||
count = count + 1 |
|||
print count;" : ";a$ |
|||
for i = 1 to 9 ' check if in sequence |
|||
j = i * 2 |
|||
if mid$(a$,j-1,1) > mid$(a$,j,1) then goto [notOrdered] |
|||
next i |
|||
print "It took ";count;" tries" |
|||
end |
|||
[notOrdered] |
|||
input "How many numbers to flip:";i |
|||
i = ((i-1) * 2) + 1 |
|||
b$ = "" |
|||
for j = i to 1 step -2 |
|||
b$ = b$ + mid$(a$,j,2) |
|||
next j |
|||
a$ = b$ + mid$(a$,i + 2) |
|||
goto [loop] |
|||
end</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
{{libheader|rand 0.7.3}} |
|||
<syntaxhighlight lang="rust">use rand::prelude::*; |
|||
use std::io::stdin; |
|||
fn is_sorted(seq: &[impl PartialOrd]) -> bool { |
|||
if seq.len() < 2 { |
|||
return true; |
|||
} |
|||
// Look for any instance where the previous number is larger than the following |
|||
!seq.iter() |
|||
.zip(seq[1..].iter()) |
|||
.any(|(prev, foll)| prev > foll) |
|||
} |
|||
fn main() { |
|||
println!( |
|||
"Number reversal game: |
|||
Given a jumbled list of the numbers 1 to 9, put the numbers in order. |
|||
Each attempt you can reverse up to n digits starting from the left. |
|||
The score is the count of the reversals needed to attain the ascending order." |
|||
); |
|||
let mut rng = thread_rng(); |
|||
let mut sequence: Vec<u8> = (1..10).collect(); |
|||
while is_sorted(&sequence) { |
|||
sequence.shuffle(&mut rng); |
|||
} |
|||
let mut attempt = 1; |
|||
while !is_sorted(&sequence) { |
|||
println!( |
|||
"Attempt {}: {:?} - How many numbers do you want to flip?", |
|||
attempt, sequence |
|||
); |
|||
let flip = { |
|||
let mut input = String::new(); |
|||
stdin().read_line(&mut input).unwrap(); |
|||
input.trim().parse().unwrap() |
|||
}; |
|||
sequence[..flip].reverse(); |
|||
attempt += 1; |
|||
} |
|||
println!( |
|||
"Congrats! It took you {} attempts to sort the sequence.", |
|||
attempt - 1 // Remove additionally counted attempt |
|||
); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Number reversal game: |
|||
Given a jumbled list of the numbers 1 to 9, put the numbers in order. |
|||
Each attempt you can reverse up to n digits starting from the left. |
|||
The score is the count of the reversals needed to attain the ascending order. |
|||
Attempt 1: [7, 1, 6, 2, 3, 4, 5, 8, 9] - How many numbers do you want to flip? |
|||
7 |
|||
Attempt 2: [5, 4, 3, 2, 6, 1, 7, 8, 9] - How many numbers do you want to flip? |
|||
5 |
|||
Attempt 3: [6, 2, 3, 4, 5, 1, 7, 8, 9] - How many numbers do you want to flip? |
|||
6 |
|||
Attempt 4: [1, 5, 4, 3, 2, 6, 7, 8, 9] - How many numbers do you want to flip? |
|||
2 |
|||
Attempt 5: [5, 1, 4, 3, 2, 6, 7, 8, 9] - How many numbers do you want to flip? |
|||
5 |
|||
Attempt 6: [2, 3, 4, 1, 5, 6, 7, 8, 9] - How many numbers do you want to flip? |
|||
3 |
|||
Attempt 7: [4, 3, 2, 1, 5, 6, 7, 8, 9] - How many numbers do you want to flip? |
|||
4 |
|||
Congrats! It took you 7 attempts to sort the sequence.</pre> |
|||
=={{header|Scala}}== |
|||
<syntaxhighlight lang="scala">object NumberReversalGame extends App { |
|||
def play(n: Int, cur: List[Int], goal: List[Int]) { |
|||
readLine(s"""$n. ${cur mkString " "} How many to flip? """) match { |
|||
case null => println |
|||
case s => scala.util.Try(s.toInt) match { |
|||
case scala.util.Success(i) if i > 0 && i <= cur.length => |
|||
(cur.take(i).reverse ++ cur.drop(i)) match { |
|||
case done if done == goal => |
|||
println(s"Congratulations! You solved "+goal.mkString(" ")) |
|||
println(s"Your score is $n (lower is better)") |
|||
case next => play(n + 1, next, goal) |
|||
} |
|||
case _ => println(s"Choose a number between 1 and ${cur.length}") |
|||
play(n + 1, cur, goal) |
|||
} |
|||
} |
|||
} |
|||
def play(size: Int) { |
|||
val goal = List.range(1, size + 1) |
|||
def init: List[Int] = scala.util.Random.shuffle(goal) match { |
|||
case repeat if repeat == goal => init |
|||
case done => done |
|||
} |
|||
play(1, init, goal) |
|||
} |
|||
play(9) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1. 8 4 2 9 6 3 7 5 1 How many to flip? 3 |
|||
2. 2 4 8 9 6 3 7 5 1 How many to flip? 8 |
|||
3. 5 7 3 6 9 8 4 2 1 How many to flip? 3 |
|||
4. 3 7 5 6 9 8 4 2 1 How many to flip? 7 |
|||
5. 4 8 9 6 5 7 3 2 1 How many to flip? 6 |
|||
6. 7 5 6 9 8 4 3 2 1 How many to flip? 2 |
|||
7. 5 7 6 9 8 4 3 2 1 How many to flip? 5 |
|||
8. 8 9 6 7 5 4 3 2 1 How many to flip? 3 |
|||
9. 6 9 8 7 5 4 3 2 1 How many to flip? 4 |
|||
10. 7 8 9 6 5 4 3 2 1 How many to flip? 3 |
|||
11. 9 8 7 6 5 4 3 2 1 How many to flip? 9 |
|||
Congratulations! You solved 1 2 3 4 5 6 7 8 9 |
|||
Your score is 11 (lower is better)</pre> |
|||
=={{header|Scheme}}== |
|||
{{libheader|Scheme/SRFIs}} |
|||
<syntaxhighlight lang="scheme"> |
|||
(import (scheme base) |
|||
(scheme read) |
|||
(scheme write) |
|||
(srfi 1) ; list functions |
|||
(srfi 27)) ; random numbers |
|||
(random-source-randomize! default-random-source) |
|||
(define (make-randomised-list) |
|||
(let ((vec (apply vector (iota 9 1)))) |
|||
(do ((c 0 (+ 1 c))) |
|||
((and (>= c 20) ; at least 20 tries |
|||
(not (apply < (vector->list vec)))) ; ensures list not in order |
|||
(vector->list vec)) |
|||
(let* ((i (random-integer 9)) ; swap two randomly chosen elements |
|||
(j (random-integer 9)) |
|||
(tmp (vector-ref vec i))) |
|||
(vector-set! vec i (vector-ref vec j)) |
|||
(vector-set! vec j tmp))))) |
|||
(define (play-game lst plays) |
|||
(define (reverse-first n lst) |
|||
(let-values (((start tail) (split-at lst n))) |
|||
(append (reverse start) tail))) |
|||
; |
|||
(display "List: ") (display lst) (newline) |
|||
(display "How many numbers should be flipped? ") |
|||
(let* ((flip (string->number (read-line))) |
|||
(new-lst (reverse-first flip lst))) |
|||
(if (apply < new-lst) |
|||
(display (string-append "Finished in " |
|||
(number->string plays) |
|||
" attempts\n")) |
|||
(play-game new-lst (+ 1 plays))))) |
|||
(play-game (make-randomised-list) 1) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
List: (1 8 3 4 9 2 7 5 6) |
|||
How many numbers should be flipped? 5 |
|||
List: (9 4 3 8 1 2 7 5 6) |
|||
How many numbers should be flipped? 9 |
|||
List: (6 5 7 2 1 8 3 4 9) |
|||
How many numbers should be flipped? 6 |
|||
List: (8 1 2 7 5 6 3 4 9) |
|||
How many numbers should be flipped? 8 |
|||
List: (4 3 6 5 7 2 1 8 9) |
|||
How many numbers should be flipped? 5 |
|||
List: (7 5 6 3 4 2 1 8 9) |
|||
How many numbers should be flipped? 7 |
|||
List: (1 2 4 3 6 5 7 8 9) |
|||
How many numbers should be flipped? 5 |
|||
List: (6 3 4 2 1 5 7 8 9) |
|||
How many numbers should be flipped? 6 |
|||
List: (5 1 2 4 3 6 7 8 9) |
|||
How many numbers should be flipped? 5 |
|||
List: (3 4 2 1 5 6 7 8 9) |
|||
How many numbers should be flipped? 2 |
|||
List: (4 3 2 1 5 6 7 8 9) |
|||
How many numbers should be flipped? 4 |
|||
Finished in 11 attempts |
|||
</pre> |
|||
=={{header|Seed7}}== |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const proc: main is func |
|||
local |
|||
const array integer: sortedList is [] ( 1, 2, 3, 4, 5, 6, 7, 8, 9); |
|||
var array integer: list is 0 times 0; |
|||
var array integer: reversedList is 0 times 0; |
|||
var integer: score is 0; |
|||
var integer: index is 0; |
|||
var integer: number is 0; |
|||
var integer: reverse is 0; |
|||
begin |
|||
for number range sortedList do |
|||
index := rand(1, succ(length(list))); |
|||
list := list[.. pred(index)] & [] (number) & list[index ..]; |
|||
end for; |
|||
repeat |
|||
write("Current list: "); |
|||
for number range list do |
|||
write(number <& " "); |
|||
end for; |
|||
repeat |
|||
write(" Digits to reverse? "); |
|||
readln(reverse); |
|||
if reverse < 2 or reverse > 9 then |
|||
write("Please enter a value between 2 and 9."); |
|||
end if; |
|||
until reverse >= 2 and reverse <= 9; |
|||
incr(score); |
|||
reversedList := 0 times 0; |
|||
for index range reverse downto 1 do |
|||
reversedList &:= list[index]; |
|||
end for; |
|||
list := reversedList & list[succ(reverse) ..]; |
|||
until list = sortedList; |
|||
writeln("Congratulations, you sorted the list in " <& score <& " reversals."); |
|||
end func;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Current list: 7 6 2 9 1 3 4 5 8 Digits to reverse? 4 |
|||
Current list: 9 2 6 7 1 3 4 5 8 Digits to reverse? 9 |
|||
Current list: 8 5 4 3 1 7 6 2 9 Digits to reverse? 8 |
|||
Current list: 2 6 7 1 3 4 5 8 9 Digits to reverse? 3 |
|||
Current list: 7 6 2 1 3 4 5 8 9 Digits to reverse? 7 |
|||
Current list: 5 4 3 1 2 6 7 8 9 Digits to reverse? 5 |
|||
Current list: 2 1 3 4 5 6 7 8 9 Digits to reverse? 2 |
|||
Congratulations, you sorted the list in 7 reversals. |
|||
</pre> |
|||
=={{header|SenseTalk}}== |
|||
<syntaxhighlight lang="sensetalk"> |
|||
// set the initial list of digits |
|||
set currentList to 1..9 sorted by random of a million |
|||
// make sure we don't start off already sorted |
|||
repeat while currentList equals 1..9 |
|||
sort currentList by random of a million |
|||
end repeat |
|||
// ask until it is solved |
|||
repeat while currentList isn't equal to 1..9 |
|||
add 1 to numberOfTurns |
|||
set headline to "Turn #" & numberOfTurns & ": You have " & currentList joined by empty |
|||
ask "How many digits do you want to reverse?" titled headline message "On each turn, specify the number of initial digits to reverse." |
|||
if it isn't a number then exit all -- allow the user to exit |
|||
sort items 1 to it of currentList descending by the counter |
|||
end repeat |
|||
answer "You sorted it in " & numberOfTurns & " turns!" titled "Congratulations!" |
|||
</syntaxhighlight> |
|||
=={{header|SETL}}== |
|||
<syntaxhighlight lang="setl">program number_reversal_game; |
|||
setrandom(0); |
|||
tries := 0; |
|||
state := shuffled_numbers(); |
|||
loop until state = "123456789" do |
|||
tries +:= 1; |
|||
swapat := read_step(tries, state); |
|||
state := reverse state(..swapat) + state(swapat+1..); |
|||
end loop; |
|||
print(state + " - You win in " + str tries + " tries."); |
|||
proc read_step(tries, state); |
|||
loop until r in [str d : d in [1..9]] do |
|||
putchar(state + " - Reverse how many? "); |
|||
flush(stdout); |
|||
r := getline(stdin); |
|||
end loop; |
|||
return val r; |
|||
end proc; |
|||
proc shuffled_numbers(); |
|||
digits := "123456789"; |
|||
loop until out /= digits do |
|||
dset := {d : d in digits}; |
|||
out := +/[[d := random dset, dset less:= d](1) : until dset = {}]; |
|||
end loop; |
|||
return out; |
|||
end proc; |
|||
end program;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>681934725 - Reverse how many? 4 |
|||
918634725 - Reverse how many? 9 |
|||
527436819 - Reverse how many? 7 |
|||
863472519 - Reverse how many? 8 |
|||
152743689 - Reverse how many? 4 |
|||
725143689 - Reverse how many? 7 |
|||
634152789 - Reverse how many? 6 |
|||
251436789 - Reverse how many? 2 |
|||
521436789 - Reverse how many? 5 |
|||
341256789 - Reverse how many? 2 |
|||
431256789 - Reverse how many? 4 |
|||
213456789 - Reverse how many? 2 |
|||
123456789 - You win in 12 tries.</pre> |
|||
=={{header|Sidef}}== |
|||
{{trans|Perl}} |
|||
<syntaxhighlight lang="ruby">var turn = 0; |
|||
var jumble = @(1..9).bshuffle; # best-shuffle |
|||
for (turn; jumble != 1..9; ++turn) { |
|||
printf("%2d: %s - Flip how many digits ? ", turn, jumble.join(' ')); |
|||
var d = read(Number) \\ break; |
|||
jumble[0 .. d-1] = [jumble[0 .. d-1]].reverse...; |
|||
} |
|||
print " #{jumble.join(' ')}\n"; |
|||
print "You won in #{turn} turns.\n";</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">package require Tcl 8.5 |
||
# Simple shuffler, not very efficient but good enough for here |
# Simple shuffler, not very efficient but good enough for here |
||
proc shuffle list { |
proc shuffle list { |
||
Line 1,899: | Line 4,876: | ||
if {$outcome ne "quit"} { |
if {$outcome ne "quit"} { |
||
puts "\nYou took $outcome attempts to put the digits in order." |
puts "\nYou took $outcome attempts to put the digits in order." |
||
}</ |
}</syntaxhighlight> |
||
Sample output: |
Sample output: |
||
<pre> |
<pre> |
||
Line 1,922: | Line 4,899: | ||
You took 11 attempts to put the digits in order. |
You took 11 attempts to put the digits in order. |
||
</pre> |
</pre> |
||
=={{header|True BASIC}}== |
|||
<syntaxhighlight lang="basic"> |
|||
RANDOMIZE |
|||
PRINT "Dada una lista aleatoria de números del 1 al 9," |
|||
PRINT "indica cuantos dígitos de la izquierda voltear." |
|||
PRINT " El objetivo es obtener los dígitos en orden " |
|||
PRINT " con el 1 a la izquierda y el 9 a la derecha." |
|||
PRINT |
|||
DIM nums(1 to 9) |
|||
DIM temp(1 to 9) |
|||
!valores iniciales |
|||
FOR x = 1 to 9 |
|||
LET nums(x) = x |
|||
NEXT x |
|||
DO !barajamos |
|||
FOR x = 9 to 2 step -1 |
|||
LET n = round(int(rnd*(x))+1) |
|||
IF n <> x then |
|||
!swap (nums(n), nums(x)) !no existe comado SWAP |
|||
LET temp(n) = nums(x) |
|||
LET nums(x) = nums(n) |
|||
LET nums(n) = temp(n) |
|||
END IF |
|||
NEXT x |
|||
FOR x = 1 to 8 !nos aseguramos que no estén en orden |
|||
IF nums(x) > nums(x+1) then EXIT DO |
|||
NEXT x |
|||
LOOP |
|||
LET denuevo = -1 |
|||
DO |
|||
IF intentos < 10 then PRINT " "; |
|||
PRINT intentos; ":"; |
|||
FOR x = 1 to 9 |
|||
PRINT nums(x); |
|||
NEXT x |
|||
IF (not denuevo <> 0) then EXIT DO |
|||
INPUT prompt " -- ¿Cuántos volteamos? ": volteo |
|||
IF volteo < 0 or volteo > 9 then LET volteo = 0 |
|||
FOR x = 1 to (ip(volteo/2)) |
|||
!swap (nums(x), nums(volteo-x+1)) !no existe SWAP |
|||
LET temp(n) = nums(volteo-x+1) |
|||
LET nums(volteo-x+1) = nums(x) |
|||
LET nums(x) = temp(n) |
|||
NEXT x |
|||
LET denuevo = 0 |
|||
!comprobamos el orden |
|||
FOR x = 1 to 8 |
|||
IF nums(x) > nums(x+1) then |
|||
LET denuevo = -1 |
|||
EXIT FOR |
|||
END IF |
|||
NEXT x |
|||
IF volteo > 0 then LET intentos = intentos+1 |
|||
LOOP |
|||
PRINT |
|||
PRINT |
|||
PRINT "Necesitaste "; ltrim$(rtrim$(str$(intentos))); " intentos." |
|||
END |
|||
</syntaxhighlight> |
|||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
numbers=RANDOM_NUMBERS (1,9,9),nr=0 |
numbers=RANDOM_NUMBERS (1,9,9),nr=0 |
||
Line 1,961: | Line 5,011: | ||
ENDIF |
ENDIF |
||
ENDLOOP |
ENDLOOP |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
<pre style='height:30ex;overflow:scroll'> |
<pre style='height:30ex;overflow:scroll'> |
||
Line 1,989: | Line 5,039: | ||
{{trans|AWK}} |
{{trans|AWK}} |
||
{{works with|pdksh|5.2.14}} |
{{works with|pdksh|5.2.14}} |
||
< |
<syntaxhighlight lang="bash">print "\nWelcome to the number reversal game!\n" |
||
print "You must put the numbers in order from 1 to 9." |
print "You must put the numbers in order from 1 to 9." |
||
Line 2,088: | Line 5,138: | ||
fi |
fi |
||
fi |
fi |
||
done</ |
done</syntaxhighlight> |
||
=={{header|VBA}}== |
|||
{{trans|Phix}}<syntaxhighlight lang="vb">Private Function shuffle(ByVal a As Variant) As Variant |
|||
Dim t As Variant, i As Integer |
|||
For i = UBound(a) To LBound(a) + 1 Step -1 |
|||
j = Int((UBound(a) - LBound(a) + 1) * Rnd + LBound(a)) |
|||
t = a(i) |
|||
a(i) = a(j) |
|||
a(j) = t |
|||
Next i |
|||
shuffle = a |
|||
End Function |
|||
Private Sub reverse(ByRef a As Variant, n As Integer) |
|||
Dim b As Variant |
|||
b = a |
|||
For i = 1 To n |
|||
a(i) = b(n + 1 - i) |
|||
Next i |
|||
End Sub |
|||
Public Sub game() |
|||
Debug.Print "Given a jumbled list of the numbers 1 to 9" |
|||
Debug.Print "you must select how many digits from the left to reverse." |
|||
Debug.Print "Your goal is to get the digits in order with 1 on the left and 9 on the right." |
|||
inums = [{1,2,3,4,5,6,7,8,9}] |
|||
Dim nums As Variant |
|||
Dim turns As Integer, flip As Integer |
|||
shuffled = False |
|||
Do While Not shuffled |
|||
nums = shuffle(inums) |
|||
For i = LBound(nums) To UBound(nums) |
|||
If nums(i) <> inums(i) Then |
|||
shuffled = True |
|||
Exit For |
|||
End If |
|||
Next i |
|||
Loop |
|||
Do While True |
|||
Debug.Print turns; ":"; |
|||
For Each x In nums: Debug.Print x;: Next x |
|||
Debug.Print |
|||
flag = False |
|||
For i = LBound(nums) To UBound(nums) |
|||
If nums(i) <> inums(i) Then |
|||
flag = True |
|||
Exit For |
|||
End If |
|||
Next i |
|||
If flag Then |
|||
flip = InputBox(" -- How many numbers should be flipped? ") |
|||
reverse nums, flip |
|||
turns = turns + 1 |
|||
Else |
|||
Exit Do |
|||
End If |
|||
Loop |
|||
Debug.Print "You took"; turns; "turns to put the digits in order." |
|||
End Sub</syntaxhighlight>{{out}} |
|||
<pre>Given a jumbled list of the numbers 1 to 9 |
|||
you must select how many digits from the left to reverse. |
|||
Your goal is to get the digits in order with 1 on the left and 9 on the right. |
|||
0 : 1 4 3 9 8 7 6 2 5 |
|||
1 : 9 3 4 1 8 7 6 2 5 |
|||
2 : 5 2 6 7 8 1 4 3 9 |
|||
3 : 8 7 6 2 5 1 4 3 9 |
|||
4 : 3 4 1 5 2 6 7 8 9 |
|||
5 : 5 1 4 3 2 6 7 8 9 |
|||
6 : 2 3 4 1 5 6 7 8 9 |
|||
7 : 4 3 2 1 5 6 7 8 9 |
|||
8 : 1 2 3 4 5 6 7 8 9 |
|||
You took 8 turns to put the digits in order.</pre> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)"> |
|||
import rand |
|||
import os |
|||
fn main() { |
|||
mut score, mut rnum := 0, 0 |
|||
mut mix, mut unmix := []int{}, []int{} |
|||
for mix.len < 9 { |
|||
rnum = rand.int_in_range(1, 10) or {println('Error: invalid number') exit(1)} |
|||
if mix.contains(rnum) == false { |
|||
mix << rnum |
|||
} |
|||
} |
|||
unmix = mix.clone() |
|||
unmix.sort() |
|||
println("Select how many digits from the left to reverse.") |
|||
for { |
|||
print("The list is: ${mix} ==> How many digits to reverse? ") |
|||
input := os.input('').str().trim_space().int() |
|||
score++ |
|||
if input == 0 || input < 2 || input > 9 { |
|||
println("\n(Enter a number from 2 to 9)") |
|||
continue |
|||
} |
|||
for idx, rdx := 0, input - 1; idx < rdx; idx, rdx = idx + 1, rdx - 1 { |
|||
mix[idx], mix[rdx] = mix[rdx], mix[idx] |
|||
} |
|||
if mix == unmix { |
|||
println("The list is: ${mix}.") |
|||
println("Your score: ${score}. Good job.") |
|||
break |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Select how many digits from the left to reverse. |
|||
The list is: [3, 4, 9, 7, 6, 1, 5, 8, 2] ==> How many digits to reverse? 8 |
|||
The list is: [8, 5, 1, 6, 7, 9, 4, 3, 2] ==> How many digits to reverse? 5 |
|||
The list is: [7, 6, 1, 5, 8, 9, 4, 3, 2] ==> How many digits to reverse? 4 |
|||
The list is: [5, 1, 6, 7, 8, 9, 4, 3, 2] ==> How many digits to reverse? 2 |
|||
The list is: [1, 5, 6, 7, 8, 9, 4, 3, 2] ==> How many digits to reverse? 9 |
|||
The list is: [2, 3, 4, 9, 8, 7, 6, 5, 1] ==> How many digits to reverse? 8 |
|||
The list is: [5, 6, 7, 8, 9, 4, 3, 2, 1] ==> How many digits to reverse? 5 |
|||
The list is: [9, 8, 7, 6, 5, 4, 3, 2, 1] ==> How many digits to reverse? 9 |
|||
The list is: [1, 2, 3, 4, 5, 6, 7, 8, 9]. |
|||
Your score: 8. Good job. |
|||
</pre> |
|||
=={{header|Wren}}== |
|||
{{trans|Kotlin}} |
|||
{{libheader|Wren-sort}}<syntaxhighlight lang="wren"> |
|||
import "./sort" for Sort |
|||
import "random" for Random |
|||
import "io" for Stdin, Stdout |
|||
var r= Random.new() |
|||
var count = 0 |
|||
var numbers = [0] * 9 |
|||
numbers[0] = r.int(2, 10) // this will ensure list isn't ascending |
|||
for (i in 1..8) { |
|||
var rn |
|||
while(true) { |
|||
rn = r.int(1, 10) |
|||
if (!numbers.contains(rn)) break |
|||
} |
|||
numbers[i] = rn |
|||
} |
|||
System.print("Here's your first list : %(numbers)") |
|||
while (true) { |
|||
var rev |
|||
while (true) { |
|||
System.write("How many numbers from the left are to be reversed : ") |
|||
Stdout.flush() |
|||
rev = Num.fromString(Stdin.readLine()) |
|||
if (rev.type == Num && rev.isInteger && rev >= 2 && rev <= 9) break |
|||
} |
|||
count = count + 1 |
|||
var i = 0 |
|||
var j = rev - 1 |
|||
while (i < j) { |
|||
var temp = numbers[i] |
|||
numbers[i] = numbers[j] |
|||
numbers[j] = temp |
|||
i = i + 1 |
|||
j = j - 1 |
|||
} |
|||
if (Sort.isSorted(numbers)) { |
|||
System.print("Here's your final list : %(numbers)") |
|||
break |
|||
} |
|||
System.print("Here's your list now : %(numbers)") |
|||
} |
|||
System.print("So you've completed the game with a score of %(count)")</syntaxhighlight> |
|||
{{out}} |
|||
Sample game: |
|||
<pre> |
|||
Here's your first list : [7, 5, 8, 3, 4, 6, 9, 2, 1] |
|||
How many numbers from the left are to be reversed : 7 |
|||
Here's your list now : [9, 6, 4, 3, 8, 5, 7, 2, 1] |
|||
How many numbers from the left are to be reversed : 9 |
|||
Here's your list now : [1, 2, 7, 5, 8, 3, 4, 6, 9] |
|||
How many numbers from the left are to be reversed : 5 |
|||
Here's your list now : [8, 5, 7, 2, 1, 3, 4, 6, 9] |
|||
How many numbers from the left are to be reversed : 8 |
|||
Here's your list now : [6, 4, 3, 1, 2, 7, 5, 8, 9] |
|||
How many numbers from the left are to be reversed : 6 |
|||
Here's your list now : [7, 2, 1, 3, 4, 6, 5, 8, 9] |
|||
How many numbers from the left are to be reversed : 7 |
|||
Here's your list now : [5, 6, 4, 3, 1, 2, 7, 8, 9] |
|||
How many numbers from the left are to be reversed : 2 |
|||
Here's your list now : [6, 5, 4, 3, 1, 2, 7, 8, 9] |
|||
How many numbers from the left are to be reversed : 6 |
|||
Here's your list now : [2, 1, 3, 4, 5, 6, 7, 8, 9] |
|||
How many numbers from the left are to be reversed : 2 |
|||
Here's your final list : [1, 2, 3, 4, 5, 6, 7, 8, 9] |
|||
So you've completed the game with a score of 9 |
|||
</pre> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang="xpl0">int Taken, I, Digit, Num, Score, Rev, Temp; |
|||
char List(9); |
|||
include c:\cxpl\codes; |
|||
\make jumbled list of digits 1 to 9 |
|||
[loop [Taken:= 0; \bit array indicates which digits are taken |
|||
for I:= 0 to 9-1 do |
|||
[repeat Digit:= Ran(9)+1 until (Taken & 1<<Digit) = 0; |
|||
Taken:= Taken + 1<<Digit; \mark digit as taken |
|||
List(I):= Digit; \add digit to the list |
|||
]; |
|||
for I:= 0 to 9-2 do if List(I) > List(I+1) then quit; |
|||
]; \quit loop when digits are not in ascending order |
|||
Score:= 0; |
|||
loop [for I:= 0 to 9-1 do [IntOut(0, List(I)); ChOut(0, ^ )]; |
|||
Num:= 0; for I:= 0 to 9-1 do Num:= Num*10 + List(I); |
|||
if Num = 123456789 then quit; |
|||
Text(0, "^M^JReverse how many digits? "); Rev:= IntIn(0); |
|||
for I:= 0 to Rev/2-1 do |
|||
[Temp:= List(I); List(I):= List(Rev-1-I); List(Rev-1-I):= Temp]; |
|||
Score:= Score+1; |
|||
]; |
|||
Text(0, "^M^JCongrats! You did it in "); IntOut(0, Score); |
|||
Text(0, " moves!!^M^J"); |
|||
]</syntaxhighlight> |
|||
Example output: |
|||
<pre> |
|||
1 3 5 4 8 9 7 2 6 |
|||
Reverse how many digits? 3 |
|||
5 3 1 4 8 9 7 2 6 |
|||
Reverse how many digits? 4 |
|||
4 1 3 5 8 9 7 2 6 |
|||
Reverse how many digits? 5 |
|||
8 5 3 1 4 9 7 2 6 |
|||
Reverse how many digits? 2 |
|||
5 8 3 1 4 9 7 2 6 |
|||
</pre> |
|||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic">// Rosetta Code problem: https://www.rosettacode.org/wiki/Number_reversal_game |
|||
// by Jjuanhdez, 06/2022 |
|||
print "Given a jumbled list of the numbers 1 to 9, " |
|||
print "you must select how many digits from the left " |
|||
print "to reverse. Your goal is to get the digits in " |
|||
print "order with 1 on the left and 9 on the right.\n" |
|||
dim nums(10) |
|||
dim a(10) |
|||
intentos = 0: denuevo = true: colum = 6 |
|||
//valores iniciales |
|||
for i = 1 to 9 |
|||
nums(i) = i |
|||
next i |
|||
for i = 9 to 2 step -1 |
|||
n = int(ran(i)) + 1 |
|||
if n <> i then |
|||
a(i) = nums(i) |
|||
nums(i) = nums(n) |
|||
nums(n) = a(i) |
|||
fi |
|||
next i |
|||
repeat |
|||
if intentos < 10 print " "; |
|||
print intentos, ": "; |
|||
for i = 1 to 9 |
|||
print nums(i), " "; |
|||
next i |
|||
if not denuevo break |
|||
input " -- How many do we flip " volteo |
|||
if volteo < 0 or volteo > 9 volteo = 0 |
|||
for i = 1 to int(volteo / 2) |
|||
a(i) = nums(volteo - i + 1) |
|||
nums(volteo - i + 1) = nums(i) |
|||
nums(i) = a(i) |
|||
next i |
|||
denuevo = false |
|||
//comprobamos el orden |
|||
for i = 1 to 8 |
|||
if nums(i) > nums(i + 1) then |
|||
denuevo = true |
|||
break |
|||
fi |
|||
next i |
|||
if volteo > 0 intentos = intentos + 1 |
|||
until false |
|||
print "\n\n You needed ", intentos, " attempts." |
|||
end</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
{{trans|AutoHotkey}} |
|||
<syntaxhighlight lang="zkl">correctList,scrambledList,N:=[1..9].walk(), correctList.shuffle(),correctList.len(); |
|||
correctList,scrambledList=correctList.concat(""), scrambledList.concat(""); // list to string |
|||
attempts:=0; |
|||
while(scrambledList!=correctList){ // Repeat until the sequence is correct |
|||
n:=ask(("[%d] %s How many numbers (from the left) should be flipped? ") |
|||
.fmt(attempts,scrambledList)); |
|||
try{ n=n.toInt() }catch{ println("Not a number"); continue; } |
|||
if(not (0<=n<N)){ println("Out of range"); continue; } |
|||
attempts+=1; |
|||
// Reverse the first part of the string and add the second part |
|||
scrambledList=scrambledList[0,n].reverse() + scrambledList[n,*]; |
|||
} |
|||
println("You took %d attempts to get the correct sequence.".fmt(attempts));</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
$ zkl bbb |
|||
[0] 145327689 How many numbers (from the left) should be flipped? 7 |
|||
[1] 672354189 How many numbers (from the left) should be flipped? 2 |
|||
[2] 762354189 How many numbers (from the left) should be flipped? 7 |
|||
[3] 145326789 How many numbers (from the left) should be flipped? 3 |
|||
[4] 541326789 How many numbers (from the left) should be flipped? 5 |
|||
[5] 231456789 How many numbers (from the left) should be flipped? 2 |
|||
[6] 321456789 How many numbers (from the left) should be flipped? 3 |
|||
You took 7 attempts to get the correct sequence. |
|||
</pre> |
Latest revision as of 19:59, 22 July 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Given a jumbled list of the numbers 1 to 9 that are definitely not in ascending order.
Show the list, and then ask the player how many digits from the left to reverse.
Reverse those digits, then ask again, until all the digits end up in ascending order.
The score is the count of the reversals needed to attain the ascending order.
Note: Assume the player's input does not need extra validation.
- Related tasks
8080 Assembly
rawio: equ 6
org 100h
;;; Initialize RNG from keypresses
lxi d,keys
call puts
mvi b,4 ; 4*4 = 16 bytes
rndini: mvi c,4
lxi h,rnddat
rndin2: push b
push h
rndkey: call keyin ; Get key
ana a
jz rndkey
pop h
pop b
xra m ; XOR into random data
mov m,a
inx h
dcr c
jnz rndin2
dcr b
jnz rndini
lxi d,done
call puts
;;; Create and shuffle array of numbers
mvi a,'1' ; Start at 1
mvi b,9 ; 9 items
lxi h,list
mklst: mov m,a ; Store item
inr a ; Increment item
inx h ; Increment pointer
dcr b ; One fewer list
jnz mklst
mov m,b ; Zero-terminate the list
lxi d,list+8
shuf: call rande ; Shuffle the list. E = high, L = low
mov l,a
ldax d ; Load current number
mov b,m ; Load number to swap with
mov m,a ; Store first number
mov a,b ; Store second number
stax d
dcr e ; Move pointer back
jnz shuf ; Keep going until list is shuffled
lxi h,0 ; Keep score on stack
push h
;;; Game loop
game: lxi d,list ; Print current state
call puts
lxi d,list
ldax d
check: mov b,a ; Check if list is sorted (done)
inx d
ldax d
ana a ; Reached end of list?
jz win ; Then the list is in order
cmp b ; Larger than previous?
jnc check ; Then keep going
lxi d,prompt
call puts ; Ask for a number
call getnum
mov b,a ; B = high number
dcr b
mvi c,0 ; C = low number
mvi h,listhi
swap: mov l,c ; Load high number in D
mov d,m
mov l,b ; Load high number in E
mov e,m
mov m,d ; Store low number in high place
mov l,c
mov m,e ; Store high number in low place
dcr b ; Decrement high index
inr c ; Increment low index
mov a,c ; Low < high?
cmp b
jc swap ; Then keep swapping
lxi d,nl ; Print newline
call puts
pop h ; Increment score
inx h
push h
jmp game
win: lxi d,winmsg
call puts ; Print win message
lxi h,score
xthl ; Retrieve score and push score output buffer
lxi b,-10 ; Divisor
digit: lxi d,-1 ; Quotient
dgdiv: inx d ; Find digit
dad b
jc dgdiv
mvi a,'0'+10
add l ; Store digit
pop h ; Get pointer
dcx h ; Decrement pointer
mov m,a ; Write digit to memory
push h ; Store pointer
xchg ; Continue with quotient
mov a,h ; Done yet?
ora l
jnz digit ; If not keep going
pop d ; Retrieve pointer
;;; Print 0-terminated string
puts: ldax d ; Get character
ana a ; Is it zero?
rz ; Then stop
inx d ; Otherwise, increment buffer pointer
push d ; Save buffer pointer
mov e,a ; Print character
call io
pop d ; Restore buffer pointer
jmp puts ; Next character
;;; Read 1-9 key
gnerr: mvi e,7
call io
getnum: call keyin
ana a
jz getnum ; If no key, wait for one
cpi '1'
jc gnerr ; Not valid - beep and try again
cpi '9'+1
jnc gnerr
push psw ; Valid - echo
mov e,a
call io
pop psw
sui '0'
ret
keyin: mvi e,0FFh ; Read key
io: mvi c,rawio ; CP/M raw I/O call
jmp 5
;;; Random number up to E
rande: call rand
ani 15
cmp e
jnc rande
ret
;;; RNG
rand: push h! lxi h,rnddat! inr m! mov a,m! inx h! xra m! inx h! xra m
mov m,a! inx h! add m! mov m,a! rar! dcx h! xra m! dcx h! add m
mov m,a! pop h
ret
prompt: db 9,' - Reverse how many? ',0
keys: db 'Please press some keys to seed the RNG...',0
done: db 'done.'
nl: db 13,10,0
winmsg: db 13,10,'You win! Score = ',0
db '*****'
score: db 13,10,0
listhi: equ $/256+1
list: equ listhi*256
rnddat: equ list+16
- Output:
Please press some keys to seed the RNG...done. 295671438 - Reverse how many? 2 925671438 - Reverse how many? 9 834176529 - Reverse how many? 8 256714389 - Reverse how many? 4 765214389 - Reverse how many? 7 341256789 - Reverse how many? 2 431256789 - Reverse how many? 4 213456789 - Reverse how many? 2 123456789 You win! Score = 8
11l
V data = Array(‘139275486’)
V trials = 0
L data != sorted(data)
trials++
V flip = Int(input(‘###2: LIST: '#.' Flip how many?: ’.format(trials, data.join(‘ ’))))
data.reverse_range(0 .< flip)
print("\nYou took #. attempts to put the digits in order!".format(trials))
- Output:
# 1: LIST: '1 3 9 2 7 5 4 8 6' Flip how many?: 9 # 2: LIST: '6 8 4 5 7 2 9 3 1' Flip how many?: 6 # 3: LIST: '2 7 5 4 8 6 9 3 1' Flip how many?: 8 # 4: LIST: '3 9 6 8 4 5 7 2 1' Flip how many?: 7 # 5: LIST: '7 5 4 8 6 9 3 2 1' Flip how many?: 3 # 6: LIST: '4 5 7 8 6 9 3 2 1' Flip how many?: 6 # 7: LIST: '9 6 8 7 5 4 3 2 1' Flip how many?: 2 # 8: LIST: '6 9 8 7 5 4 3 2 1' Flip how many?: 4 # 9: LIST: '7 8 9 6 5 4 3 2 1' Flip how many?: 3 #10: LIST: '9 8 7 6 5 4 3 2 1' Flip how many?: 9 You took 10 attempts to put the digits in order!
Action!
PROC KnuthShuffle(BYTE ARRAY tab BYTE size)
BYTE i,j,tmp
i=size-1
WHILE i>0
DO
j=Rand(i+1)
tmp=tab(i)
tab(i)=tab(j)
tab(j)=tmp
i==-1
OD
RETURN
BYTE FUNC IsSorted(BYTE ARRAY tab BYTE size)
BYTE i
FOR i=0 TO size-2
DO
IF tab(i)>tab(i+1) THEN
RETURN (0)
FI
OD
RETURN (1)
PROC Swap(BYTE ARRAY tab BYTE size,count)
BYTE i,j,tmp
i=0 j=count-1
WHILE i<j
DO
tmp=tab(i)
tab(i)=tab(j)
tab(j)=tmp
i==+1 j==-1
OD
RETURN
PROC Main()
DEFINE SIZE="9"
BYTE ARRAY a(SIZE)
BYTE i,j,n,tmp
BYTE LMARGIN=$52,oldLMARGIN
oldLMARGIN=LMARGIN
LMARGIN=0 ;remove left margin on the screen
Put(125) PutE() ;clear the screen
FOR i=0 TO SIZE-1
DO
a(i)=i+1
OD
KnuthShuffle(a,SIZE)
i=0
DO
PrintF("%B: ",i)
FOR j=0 TO SIZE-1
DO
PrintB(a(j))
OD
IF IsSorted(a,SIZE) THEN
EXIT
FI
PrintF(" How many to flip (2-%B)? ",SIZE)
n=InputB()
IF n>=2 AND n<=SIZE THEN
Swap(a,SIZE,n)
i==+1
FI
OD
PrintF("%E%EYou solved it in %B moves!",i)
LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN
- Output:
Screenshot from Atari 8-bit computer
0: 987152346 How many to flip (2-9)? 9 1: 643251789 How many to flip (2-9)? 6 2: 152346789 How many to flip (2-9)? 2 3: 512346789 How many to flip (2-9)? 5 4: 432156789 How many to flip (2-9)? 4 5: 123456789 You solved it in 5 moves!
Ada
with Ada.Text_Io; use Ada.Text_Io;
with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;
with Ada.Numerics.Discrete_Random;
procedure NumberReverse is
subtype RandRange is Integer range 1..9;
type NumArrayType is array (Integer range 1..9) of Integer;
package RandNumbers is new Ada.Numerics.Discrete_Random(RandRange);
use RandNumbers;
G : Generator;
procedure FillArray (A : in out NumArrayType) is
Temp : RandRange;
begin
A := (others => 0);
for I in 1..9 loop
Temp := Random(G);
while A(Temp) /= 0 loop
Temp := Random(G);
end loop;
A(Temp) := I;
end loop;
end FillArray;
procedure Put(A : in NumArrayType) is
begin
for I in 1..9 loop
Put(A(I), 0);
Put(" ");
end loop;
end Put;
procedure Prompt (Index : out Integer) is
begin
New_Line;
Put("How many numbers would you like to reverse: ");
Get(Index);
end Prompt;
procedure ReverseArray(Arr : in out NumArrayType;
Index : in Integer) is
Temp : RandRange;
begin
for I in 1..Index/2 loop
Temp := Arr(I);
Arr(I) := Arr(Index + 1 - I);
Arr(Index + 1 - I) := Temp;
end loop;
end ReverseArray;
Sorted : constant NumArrayType := (1,2,3,4,5,6,7,8,9);
Arr : NumArrayType;
Index : Integer;
Count : Integer := 0;
begin
Reset(G);
loop
FillArray(Arr);
exit when Sorted /= Arr;
end loop;
loop
Put(Arr);
Prompt(Index);
Count := Count + 1;
ReverseArray(Arr, Index);
exit when Sorted = Arr;
end loop;
Put(Arr);
New_Line;
Put("Congratulations! You win. It took " &
Integer'Image(Count) & " tries.");
end NumberReverse;
ALGOL 68
Using code from the Knuth shuffle task.
BEGIN # play the number reversal game #
CO begin code from the Knuth shuffle task CO
PROC between = (INT a, b)INT :
(
ENTIER (random * ABS (b-a+1) + (a<b|a|b))
);
PROC knuth shuffle = (REF[]INT a)VOID:
(
FOR i FROM LWB a TO UPB a DO
INT j = between(LWB a, UPB a);
INT t = a[i];
a[i] := a[j];
a[j] := t
OD
);
CO end code from the Knuth shuffle task CO
[]INT ordered digits = ( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
[ 1 : 9 ]INT digits := ordered digits;
knuth shuffle( digits );
# ignore invalid data in stand in #
on value error( stand in, ( REF FILE f )BOOL: TRUE );
PROC print digits = VOID: # prints the digits #
BEGIN
print( ( "The digits are:" ) );
FOR i TO 9 DO print( ( whole( digits[ i ], -2 ) ) ) OD;
print( ( newline ) )
END # print digits # ;
OP = = ( []INT a, b )BOOL: # returns TRUE if a = b #
IF LWB a /= LWB b OR UPB a /= UPB b THEN
FALSE # a and b have different bounds #
ELSE
# a and b ave the same bounds #
BOOL same := TRUE;
FOR i FROM LWB a TO UPB a WHILE same DO same := a[ i ] = b[ i ] OD;
same
FI # = # ;
OP /= = ( []INT a, b )BOOL: NOT ( a = b ); # returns TRUE if a not = b #
INT count := 0;
print digits;
WHILE digits /= ordered digits DO
print( ( "How many digits to reverse (2-9)? " ) );
INT n := 0;
read( ( n, newline ) );
IF n >= 2 AND n <= 9 THEN
# reverse the n left-most digits #
count +:= 1;
INT r pos := n;
FOR pos TO n OVER 2 DO
INT t = digits[ r pos ];
digits[ r pos ] := digits[ pos ];
digits[ pos ] := t;
r pos -:= 1
OD;
print digits
FI
OD;
print( ( newline, "You ordered the digits in ", whole( count, 0 ), " moves", newline ) )
END
- Output:
The digits are: 9 6 4 3 8 7 1 5 2 How many digits to reverse (2-9)? 4 The digits are: 3 4 6 9 8 7 1 5 2 How many digits to reverse (2-9)? 6 The digits are: 7 8 9 6 4 3 1 5 2 How many digits to reverse (2-9)? 3 The digits are: 9 8 7 6 4 3 1 5 2 How many digits to reverse (2-9)? 9 The digits are: 2 5 1 3 4 6 7 8 9 How many digits to reverse (2-9)? 2 The digits are: 5 2 1 3 4 6 7 8 9 How many digits to reverse (2-9)? 5 The digits are: 4 3 1 2 5 6 7 8 9 How many digits to reverse (2-9)? 4 The digits are: 2 1 3 4 5 6 7 8 9 How many digits to reverse (2-9)? 2 The digits are: 1 2 3 4 5 6 7 8 9 You ordered the digits in 8 moves
APL
∇numrev;list;in;swaps
list←{9?9}⍣{⍺≢⍳9}⊢⍬
swaps←0
read:
swaps+←1
in←{⍞←⍵⋄(≢⍵)↓⍞}(⍕list),': swap how many? '
list←⌽@(⍳⍎in)⊢list
→(list≢⍳9)/read
⎕←(⍕list),': Congratulations!'
⎕←'Swaps:',swaps
∇
- Output:
8 7 2 6 5 3 1 9 4: swap how many? 8 9 1 3 5 6 2 7 8 4: swap how many? 9 4 8 7 2 6 5 3 1 9: swap how many? 3 7 8 4 2 6 5 3 1 9: swap how many? 2 8 7 4 2 6 5 3 1 9: swap how many? 8 1 3 5 6 2 4 7 8 9: swap how many? 4 6 5 3 1 2 4 7 8 9: swap how many? 6 4 2 1 3 5 6 7 8 9: swap how many? 4 3 1 2 4 5 6 7 8 9: swap how many? 3 2 1 3 4 5 6 7 8 9: swap how many? 2 1 2 3 4 5 6 7 8 9: Congratulations! Swaps: 10
Applesoft BASIC
100 LET M$ = CHR$ (13)
110 LET A$ = "123456789"
120 FOR S = 0 TO 1 STEP 0
130 LET N$ = A$
140 FOR I = 1 TO 9
150 LET R = INT ( RND (1) * 9 + 1)
160 GOSUB 500SWAP
170 NEXT I
180 LET S = N$ < > A$
190 NEXT S
200 FOR S = 1 TO 1E9
210 PRINT M$"HOW MANY DIGITS "N$M$" FROM THE LEFT ^^^^^^^^^"M$" TO REVERSE? "A$
230 INPUT "--------------> ";N%
300 FOR I = 1 TO INT (N% / 2)
310 LET R = N% - I + 1
320 GOSUB 500SWAP
330 NEXT I
340 IF N$ = A$ THEN PRINT M$"SCORE "S;: END
350 NEXT S
500 LET I$ = MID$ (N$,I,1)
510 LET N$ = MID$ (N$,1,I - 1) + MID$ (N$,R,1) + MID$ (N$,I + 1)
520 LET N$ = MID$ (N$,1,R - 1) + I$ + MID$ (N$,R + 1)
530 RETURN
Arturo
arr: 1..9
while [arr = sort arr]->
arr: shuffle arr
score: 0
while [arr <> sort arr][
prints [arr "-- "]
digits: to :integer strip input "How many digits to reverse? "
arr: (reverse slice arr 0 digits-1) ++ slice arr digits (size arr)-1
score: score + 1
]
print ["Your score:" score]
- Output:
[6 2 5 4 1 3 9 7 8] -- How many digits to reverse? 7 [9 3 1 4 5 2 6 7 8] -- How many digits to reverse? 9 [8 7 6 2 5 4 1 3 9] -- How many digits to reverse? 8 [3 1 4 5 2 6 7 8 9] -- How many digits to reverse? 4 [5 4 1 3 2 6 7 8 9] -- How many digits to reverse? 5 [2 3 1 4 5 6 7 8 9] -- How many digits to reverse? 2 [3 2 1 4 5 6 7 8 9] -- How many digits to reverse? 3 Your score: 7
Astro
print '# Number reversal game'
var data, trials = list(1..9), 0
while data == sort data:
random.shuffle data
while data != sort data:
trials += 1
flip = int input '#${trials}: LIST: ${join data} Flip how many?: '
data[:flip] = reverse data[:flip]
print '\nYou took ${trials} attempts to put digits in order!'
AutoHotkey
; Submitted by MasterFocus --- http://tiny.cc/iTunis
ScrambledList := CorrectList := "1 2 3 4 5 6 7 8 9" ; Declare two identical correct sequences
While ( ScrambledList = CorrectList )
Sort, ScrambledList, Random D%A_Space% ; Shuffle one of them inside a While-loop to ensure it's shuffled
Attempts := 0
While ( ScrambledList <> CorrectList ) ; Repeat until the sequence is correct
{
InputBox, EnteredNumber, Number Reversal Game, Attempts so far: %Attempts%`n`nCurrent sequence: %ScrambledList%`n`nHow many numbers (from the left) should be flipped?, , 400, 200
If ErrorLevel
ExitApp ; Exit if user presses ESC or Cancel
If EnteredNumber is not integer
Continue ; Discard attempt if entered number is not an integer
If ( EnteredNumber <= 1 )
Continue ; Discard attempt if entered number is <= 1
Attempts++ ; Increase the number of attempts
; Reverse the first part of the string and add the second part
; The entered number is multiplied by 2 to deal with the spaces
ScrambledList := Reverse(SubStr(ScrambledList,1,(EnteredNumber*2)-1)) SubStr(ScrambledList,EnteredNumber*2)
}
MsgBox, You took %Attempts% attempts to get the correct sequence. ; Final message
Return
;-------------------
Reverse(Str) ; Auxiliar function (flips a string)
{
Loop, Parse, Str
Out := A_LoopField Out
Return Out
}
AWK
BEGIN {
print "\nWelcome to the number reversal game!\n"
print "You must put the numbers in order from 1 to 9."
print "Your only moves are to reverse groups of numbers"
print "on the left side of the list."
newgame()
prompt()
}
# start a new game
function newgame( i, j, t) {
# score = number of moves
score = 0
# list = list of numbers
split("123456789", list, "")
do {
# Knuth shuffle
for (i = 9; i > 1; i--) {
j = int(i * rand()) + 1
t = list[i]
list[i] = list[j]
list[j] = t
}
} while (win())
}
# numbers in order?
function win( i) {
# check if list[1] == 1, list[2] == 2, ...
for (i = 1; i <= 9; i++) if (list[i] != i) return 0
return 1
}
# user prompt
function prompt( i) {
printf "\nYour list: "
for (i = 1; i < 9; i++) printf "%d, ", list[i]
printf "%d\n", list[9]
if (win()) {
print "YOU WIN!"
printf "Your score is %d moves.\n", score
printf "Would you like to play again (y/n)? "
again = 1
} else {
printf "How many numbers to reverse? "
}
}
# user input in $1
{
if (again) {
again = 0
if (tolower(substr($1, 1, 1)) == "y")
newgame()
else
exit
} else {
score += 1
reverse($1)
}
prompt()
}
function reverse(right, left, t) {
left = 1
while (right > left) {
t = list[left]
list[left] = list[right]
list[right] = t
left++
right--
}
}
END { print "\n\nBye!" }
BASIC
PRINT "Given a jumbled list of the numbers 1 to 9,"
PRINT "you must select how many digits from the left to reverse."
PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right."
RANDOMIZE TIMER
DIM nums(1 TO 9) AS INTEGER
DIM L0 AS INTEGER, n AS INTEGER, flp AS INTEGER, tries AS INTEGER, again AS INTEGER
'initial values
FOR L0 = 1 TO 9
nums(L0) = L0
NEXT
DO 'shuffle
FOR L0 = 9 TO 2 STEP -1
n = INT(RND * (L0)) + 1
IF n <> L0 THEN SWAP nums(n), nums(L0)
NEXT
FOR L0 = 1 TO 8 'make sure it's not in order
IF nums(L0) > nums(L0 + 1) THEN EXIT DO
NEXT
LOOP
again = -1
DO
IF tries < 10 THEN PRINT " ";
PRINT tries; ":";
FOR L0 = 1 TO 9
PRINT nums(L0);
NEXT
IF NOT again THEN EXIT DO
INPUT " -- How many numbers should be flipped"; flp
IF flp < 0 THEN flp = 0
IF flp > 9 THEN flp = 0
FOR L0 = 1 TO (flp \ 2)
SWAP nums(L0), nums(flp - L0 + 1)
NEXT
again = 0
'check for order
FOR L0 = 1 TO 8
IF nums(L0) > nums(L0 + 1) THEN
again = -1
EXIT FOR
END IF
NEXT
IF flp > 0 THEN tries = tries + 1
LOOP
PRINT : PRINT "You took "; LTRIM$(RTRIM$(STR$(tries))); " tries to put the digits in order."
Sample output:
Given a jumbled list of the numbers 1 to 9, you must select how many digits from the left to reverse. Your goal is to get the digits in order with 1 on the left and 9 on the right. 0 : 1 4 5 3 2 7 6 8 9 -- How many numbers should be flipped? 7 1 : 6 7 2 3 5 4 1 8 9 -- How many numbers should be flipped? 2 2 : 7 6 2 3 5 4 1 8 9 -- How many numbers should be flipped? 7 3 : 1 4 5 3 2 6 7 8 9 -- How many numbers should be flipped? 3 4 : 5 4 1 3 2 6 7 8 9 -- How many numbers should be flipped? 5 5 : 2 3 1 4 5 6 7 8 9 -- How many numbers should be flipped? 2 6 : 3 2 1 4 5 6 7 8 9 -- How many numbers should be flipped? 3 7 : 1 2 3 4 5 6 7 8 9 You took 7 tries to put the digits in order.
BASIC256
print "Dada una lista aleatoria de numeros del 1 al 9,"
print "indica cuantos digitos de la izquierda voltear."
print " El objetivo es obtener los digitos en orden "
print " con el 1 a la izquierda y el 9 a la derecha." + chr(10)
dim nums(10)
dim a(10)
intentos = 0: denuevo = true: colum = 6
#valores iniciales
for i = 1 to 9
nums[i] = i
next i
do #barajamos
for i = 9 to 2 step -1
n = int(rand * i) + 1
if n <> i then
a[i] = nums[i]
nums[i] = nums[n]
nums[n] = a[i]
end if
next i
for i = 1 to 8 #nos aseguramos que no estén en orden
if nums[i] > nums[i + 1] then exit do
next i
until false
do
if intentos < 10 then print " ";
print intentos; ": ";
for i = 1 to 9
print nums[i];" ";
next i
if not denuevo then exit do
input " -- Cuantos volteamos ", volteo
if volteo < 0 or volteo > 9 then volteo = 0
for i = 1 to (volteo \ 2)
a[i] = nums[volteo - i + 1]
nums[volteo - i + 1] = nums[i]
nums[i] = a[i]
next i
denuevo = false
#comprobamos el orden
for i = 1 to 8
if nums[i] > nums[i + 1] then
denuevo = true
exit for
end if
next i
if volteo > 0 then intentos += 1
until false
print chr(10) + chr(10) + " Necesitaste "; intentos; " intentos."
end
- Output:
Dada una lista aleatoria de numeros del 1 al 9, indica cuantos digitos de la izquierda voltear. El objetivo es obtener los digitos en orden con el 1 a la izquierda y el 9 a la derecha. 0: 2 1 4 3 5 9 8 6 7 -- Cuantos volteamos 6 1: 9 5 3 4 1 2 8 6 7 -- Cuantos volteamos 9 2: 7 6 8 2 1 4 3 5 9 -- Cuantos volteamos 3 3: 8 6 7 2 1 4 3 5 9 -- Cuantos volteamos 8 4: 5 3 4 1 2 7 6 8 9 -- Cuantos volteamos 6 5: 7 2 1 4 3 5 6 8 9 -- Cuantos volteamos 7 6: 6 5 3 4 1 2 7 8 9 -- Cuantos volteamos 6 7: 2 1 4 3 5 6 7 8 9 -- Cuantos volteamos 3 8: 4 1 2 3 5 6 7 8 9 -- Cuantos volteamos 4 9: 3 2 1 4 5 6 7 8 9 -- Cuantos volteamos 3 10: 1 2 3 4 5 6 7 8 9 Necesitaste 10 intentos.
Batch File
Note that I did not use the FOR command for looping. I used Batch File labels instead.
::
::Number Reversal Game Task from Rosetta Code Wiki
::Batch File Implementation
::
::Please do not open this from command prompt.
::Directly Open the Batch File to play...
::
@echo off
setlocal enabledelayedexpansion
title Number Reversal Game
:begin
set score=0
::The ascending list of 9 digits
set list=123456789
::Generating a random set of 9 digits...
set cyc=9
:gen
set /a tmp1=%random%%%%cyc%
set n%cyc%=!list:~%tmp1%,1!
set tmp2=!n%cyc%!
set list=!list:%tmp2%=!
if not %cyc%==2 (
set /a cyc-=1
goto :gen
)
set /a n1=%list%
::Display the Game
cls
echo.
echo ***Number Reversal Game***
:loopgame
echo.
echo Current arrangement: %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9%
set /p move=How many digits from the left should I reverse?
::Reverse digits according to the player's input
::NOTE: The next command uses the fact that in Batch File,
::The output for the division operation is only the integer part of the quotient.
set /a lim=(%move%+1)/2
set cyc2=1
:reverse
set /a tmp4=%move%-%cyc2%+1
set tmp5=!n%cyc2%!
set n%cyc2%=!n%tmp4%!
set n%tmp4%=%tmp5%
if not %cyc2%==%lim% (
set /a cyc2+=1
goto :reverse
)
::Increment the number of moves took by the player
set /a score+=1
::IF already won...
if %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9%==123456789 (
echo.
echo Set: %n1%%n2%%n3%%n4%%n5%%n6%%n7%%n8%%n9% DONE^^!
echo You took %score% moves to arrange the numbers in ascending order.
pause>nul
exit
) else (
goto :loopgame
)
Sample Output:
***Number Reversal Game*** Current arrangement: 349718652 How many digits from the left should I reverse?3 Current arrangement: 943718652 How many digits from the left should I reverse?9 Current arrangement: 256817349 How many digits from the left should I reverse?4 Current arrangement: 865217349 How many digits from the left should I reverse?8 Current arrangement: 437125689 How many digits from the left should I reverse?3 Current arrangement: 734125689 How many digits from the left should I reverse?7 Current arrangement: 652143789 How many digits from the left should I reverse?6 Current arrangement: 341256789 How many digits from the left should I reverse?2 Current arrangement: 431256789 How many digits from the left should I reverse?4 Current arrangement: 213456789 How many digits from the left should I reverse?2 Set: 123456789 DONE! You took 10 moves to arrange the numbers in ascending order.
BBC BASIC
Note the use of the MOD(array()) function to test the equality of two arrays.
DIM list%(8), done%(8), test%(8)
list%() = 1, 2, 3, 4, 5, 6, 7, 8, 9
done%() = list%()
REM Shuffle:
REPEAT
FOR i% = 9 TO 2 STEP -1
SWAP list%(i%-1), list%(RND(i%)-1)
NEXT
test%() = list%() - done%()
UNTIL MOD(test%()) <> 0
REM Run the game:
tries% = 0
REPEAT
tries% += 1
FOR i% = 0 TO 8 : PRINT ; list%(i%) " " ; : NEXT
INPUT ": Reverse how many", n%
PROCreverse(list%(), n%)
test%() = list%() - done%()
UNTIL MOD(test%()) = 0
PRINT "You took " ; tries% " attempts."
END
DEF PROCreverse(a%(), n%)
IF n% < 2 ENDPROC
LOCAL i%
n% -= 1
FOR i% = 0 TO n% DIV 2
SWAP a%(i%), a%(n%-i%)
NEXT
ENDPROC
Output:
7 2 3 1 5 8 6 4 9 : Reverse how many? 6 8 5 1 3 2 7 6 4 9 : Reverse how many? 8 4 6 7 2 3 1 5 8 9 : Reverse how many? 3 7 6 4 2 3 1 5 8 9 : Reverse how many? 7 5 1 3 2 4 6 7 8 9 : Reverse how many? 5 4 2 3 1 5 6 7 8 9 : Reverse how many? 4 1 3 2 4 5 6 7 8 9 : Reverse how many? 3 2 3 1 4 5 6 7 8 9 : Reverse how many? 2 3 2 1 4 5 6 7 8 9 : Reverse how many? 3 You took 9 attempts.
Brat
sorted = 1.to 9
length = sorted.length
numbers = sorted.shuffle
#Make certain numbers are shuffled
true? numbers == sorted
{ while { sorted == numbers.shuffle! } }
turns = 0
while { numbers != sorted } {
print "#{numbers} - How many to reverse? "
num = g.to_i
numbers = numbers[0, num - 1].reverse + numbers[num, length]
turns = turns + 1
}
p numbers
p "It took #{turns} turns to sort numbers."
C
An example of a number reversal game could be:
void number_reversal_game()
{
printf("Number Reversal Game. Type a number to flip the first n numbers.");
printf("Win by sorting the numbers in ascending order.\n");
printf("Anything besides numbers are ignored.\n");
printf("\t |1__2__3__4__5__6__7__8__9|\n");
int list[9] = {1,2,3,4,5,6,7,8,9};
shuffle_list(list,9);
int tries=0;
unsigned int i;
int input;
while(!check_array(list, 9))
{
((tries<10) ? printf("Round %d : ", tries) : printf("Round %d : ", tries));
for(i=0;i<9;i++)printf("%d ",list[i]);
printf(" Gimme that number:");
while(1)
{
//Just keep asking for proper input
scanf("%d", &input);
if(input>1&&input<10)
break;
printf("\n%d - Please enter a number between 2 and 9:", (int)input);
}
tries++;
do_flip(list, 9, input);
}
printf("Hurray! You solved it in %d moves!\n", tries);
}
Which uses the following helper functions:
void shuffle_list(int *list, int len)
{
//We'll just be swapping 100 times. Could be more/less. Doesn't matter much.
int n=100;
int a=0;
int b=0;
int buf = 0;
//Random enough for common day use..
srand(time(NULL));
while(n--)
{
//Get random locations and swap
a = rand()%len;
b = rand()%len;
buf = list[a];
list[a] = list[b];
list[b] = buf;
}
// "shuffled to ordered state" fix:
if (check_array(list, len)) shuffle_list (list, len);
}
void do_flip(int *list, int length, int num)
{
//Flip a part on an array
int swap;
int i=0;
for(i;i<--num;i++)
{
swap=list[i];
list[i]=list[num];
list[num]=swap;
}
}
int check_array(int *arr, int len)
{
while(--len)
{
if(arr[len]!=(arr[len-1]+1))
return 0;
}
return 1;
}
C#
C# 3.0
using System;
using System.Linq;
class Program
{
static void Main(string[] args)
{
var r = new Random();
var tries = 1;
var sorted = Enumerable.Range(1, 9).ToList();
var values = sorted.OrderBy(x => r.Next(-1, 1)).ToList();
while (Enumerable.SequenceEqual(sorted, values)) {
values = sorted.OrderBy(x => r.Next(-1, 1)).ToList();
}
//values = "1 3 9 2 7 5 4 8 6".Split().Select(x => int.Parse(x)).ToList();
while (!Enumerable.SequenceEqual(sorted, values))
{
Console.Write("# {0}: LIST: {1} - Flip how many? ", tries, String.Join(" ", values));
values.Reverse(0, int.Parse(Console.ReadLine()));
tries += 1;
}
Console.WriteLine("\nYou took {0} attempts to put the digits in order!", tries - 1);
Console.ReadLine();
}
}
C# 1.0
class Program
{
static void Main(string[] args)
{
int[] values = new int[9];
Random tRandom = new Random();
int tries = 0;
for (int x = 0; x < values.Length; x++)
{
values[x] = x + 1;
}
values = RandomPermutation<int>(values);
do
{
Console.Write("Numbers: ");
for (int x = 0; x < values.Length; x++)
{
Console.Write(" ");
Console.Write(values[x]);
}
Console.WriteLine(". Enter number of numbers from the left to reverse: ");
string tIn = "";
do
{
tIn = Console.ReadLine();
} while (tIn.Length != 1);
int nums = Convert.ToInt32(tIn.ToString());
int[] newValues = new int[9];
for (int x = nums; x < newValues.Length; x++)
{
// Move those not reversing
newValues[x] = values[x];
}
for (int x = 0; x < nums; x++)
{
// Reverse the rest
newValues[x] = values[nums - 1 - x];
}
values = newValues;
tries++;
} while (!check(values));
Console.WriteLine("Success!");
Console.WriteLine("Attempts: " + tries);
Console.Read();
}
public static bool check(int[] p)
{
// Check all items
for (int x = 0; x < p.Length - 1; x++)
{
if (p[x + 1] <= p[x])
return false;
}
return true;
}
public static T[] RandomPermutation<T>(T[] array)
{
T[] retArray = new T[array.Length];
array.CopyTo(retArray, 0);
Random random = new Random();
for (int i = 0; i < array.Length; i += 1)
{
int swapIndex = random.Next(i, array.Length);
if (swapIndex != i)
{
T temp = retArray[i];
retArray[i] = retArray[swapIndex];
retArray[swapIndex] = temp;
}
}
return retArray;
}
}
C++
Version 1 (crude)
The C code can be used with C++, although the following uses proper C++ iostreams:
void number_reversal_game()
{
cout << "Number Reversal Game. Type a number to flip the first n numbers.";
cout << "You win by sorting the numbers in ascending order.";
cout << "Anything besides numbers are ignored.\n";
cout << "\t |1__2__3__4__5__6__7__8__9|\n";
int list[9] = {1,2,3,4,5,6,7,8,9};
do
{
shuffle_list(list,9);
} while(check_array(list, 9));
int tries=0;
unsigned int i;
int input;
while(!check_array(list, 9))
{
cout << "Round " << tries << ((tries<10) ? " : " : " : ");
for(i=0;i<9;i++)cout << list[i] << " ";
cout << " Gimme that number:";
while(1)
{
cin >> input;
if(input>1&&input<10)
break;
cout << "\nPlease enter a number between 2 and 9:";
}
tries++;
do_flip(list, 9, input);
}
cout << "Hurray! You solved it in %d moves!\n";
}
This uses the same helper functions as the C version.
Version 2 (with C++ standard library)
Version 2.1
This version uses the C++ standard library (note that none of the C helper functions are needed).
#include <iostream>
#include <algorithm>
#include <functional>
#include <iterator>
#include <cstdlib>
#include <ctime>
template<typename T, int size>
bool is_sorted(T (&array)[size])
{
return std::adjacent_find(array, array+size, std::greater<T>())
== array+size;
}
int main()
{
std::srand(std::time(0));
int list[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
do
{
std::random_shuffle(list, list+9);
} while (is_sorted(list));
int score = 0;
do
{
std::cout << "Current list: ";
std::copy(list, list+9, std::ostream_iterator<int>(std::cout, " "));
int rev;
while (true)
{
std::cout << "\nDigits to reverse? ";
std::cin >> rev;
if (rev > 1 && rev < 10)
break;
std::cout << "Please enter a value between 2 and 9.";
}
++score;
std::reverse(list, list + rev);
} while (!is_sorted(list));
std::cout << "Congratulations, you sorted the list.\n"
<< "You needed " << score << " reversals." << std::endl;
return 0;
}
Version 2.2
// Written by Katsumi -- twitter.com/realKatsumi_vn
// Compile with: g++ -std=c++20 -Wall -Wextra -pedantic NumberReversal.cpp -o NumberReversal
#include <iostream>
#include <algorithm>
#include <utility>
#include <functional>
#include <iterator>
#include <random>
#include <vector>
#include <string>
template <class T>
bool Sorted(std::vector<T> list) {
return std::adjacent_find(list.begin(), list.end(), std::greater<T>()) == list.end();
}
template <class T>
std::string VectorRepr(std::vector<T> list) {
auto Separate = [](std::string a, int b) {
return std::move(a) + ", " + std::to_string(b);
};
return std::accumulate(std::next(list.begin()), list.end(), std::to_string(list[0]), Separate);
}
int main() {
const std::string IntroText = "NUMBER REVERSAL GAME\n"
"based on a \"task\" on Rosetta Code -- rosettacode.org\n"
"by Katsumi -- twitter.com/realKatsumi.vn\n\n";
// Don't ever write this s**tty code...
// std::srand(std::time(0));
// Do this instead:
std::random_device Device;
std::mt19937_64 Generator(Device());
std::vector<int> List = {1, 2, 3, 4, 5, 6, 7, 8, 9};
std::shuffle(List.begin(), List.end(), Generator);
std::cout << IntroText;
int Moves, PlayerInput;
while (!Sorted(List)) {
std::cout << "Current list: [" << VectorRepr(List) << "]\n"
"Digits to reverse? (2-9) ";
while (true) {
std::cin >> PlayerInput;
if (PlayerInput < 2 || PlayerInput > 9)
std::cout << "Please enter a value between 2 and 9.\n"
"Digits to reverse? (2-9) ";
else
break;
}
std::reverse(List.begin(), List.begin()+PlayerInput);
++Moves;
}
std::cout << "Yay! You sorted the list! You've made " << Moves << " moves.\n";
return 0;
}
Clojure
(defn flip-at [n coll]
(let [[x y] (split-at n coll)]
(concat (reverse x) y )))
(def sorted '(1 2 3 4 5 6 7 8 9)) ; i.e. (range 1 10)
(def unsorted? #(not= % sorted))
(loop [unsorted (first (filter unsorted? (iterate shuffle sorted))), steps 0]
(if (= unsorted sorted)
(printf "Done! That took you %d steps%n" steps)
(do
(println unsorted)
(printf "Reverse how many? ")
(flush)
(let [flipcount (read)]
(recur (flip-at flipcount unsorted), (inc steps))))))
CLU
% This program uses the random number generator from PCLU's
% 'misc.lib'
% Shuffle the given array. Every item ends up in a different place,
% so if given the numbers in ascending order, it is guaranteed that
% they will not still be in ascending order at the end.
jumble = proc [T: type] (a: array[T])
for i: int in int$from_to_by(array[T]$high(a), array[T]$low(a)+1, -1) do
j: int := array[T]$low(a) + random$next(i - array[T]$low(a))
x: T := a[i]
a[i] := a[j]
a[j] := x
end
end jumble
% Is the array sorted?
win = proc (a: array[int]) returns (bool)
for i: int in array[int]$indexes(a) do
if i ~= a[i] then return(false) end
end
return(true)
end win
% Reverse the first N items of the array
reverse = proc (n: int, a: array[int])
for i: int in int$from_to(1, n/2) do
j: int := n-i+1
x: int := a[j]
a[j] := a[i]
a[i] := x
end
end reverse
% Play the game
start_up = proc ()
po: stream := stream$primary_output()
pi: stream := stream$primary_input()
d: date := now()
random$seed(d.second + 60*(d.minute + 60*d.hour))
score: int := 0
nums: array[int] := array[int]$[1,2,3,4,5,6,7,8,9]
jumble[int](nums)
while ~win(nums) do
for i: int in array[int]$elements(nums) do
stream$puts(po, int$unparse(i))
end
stream$puts(po, ": reverse how many? ")
n: int := int$parse(stream$getl(pi))
reverse(n, nums)
score := score + 1
end
for i: int in array[int]$elements(nums) do
stream$puts(po, int$unparse(i))
end
stream$putl(po, "\nScore = " || int$unparse(score))
end start_up
- Output:
792184365: reverse how many? 2 972184365: reverse how many? 9 563481279: reverse how many? 5 843651279: reverse how many? 8 721563489: reverse how many? 7 436512789: reverse how many? 3 634512789: reverse how many? 6 215436789: reverse how many? 3 512436789: reverse how many? 5 342156789: reverse how many? 2 432156789: reverse how many? 4 123456789 Score = 11
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. REVERSAL.
AUTHOR. Bill Gunshannon
INSTALLATION. Home.
DATE-WRITTEN. 11 December 2021
****************************************************************
** Program Abstract:
** Use a Knuth Shuffle to reate our out ot sort array.
** Use a procedure called "reverse" to pancake sort the array.
****************************************************************
DATA DIVISION.
WORKING-STORAGE SECTION.
01 RNUM PIC 9.
01 TRIES PIC 99 VALUE 0.
01 ANSWER PIC 9(9) VALUE 123456789.
01 TBL-LEN PIC 9 VALUE 9.
01 TBL.
05 TZ PIC 9(9).
05 TA REDEFINES TZ
PIC 9 OCCURS 9 TIMES.
PROCEDURE DIVISION.
MAIN-pROGRAM.
MOVE ANSWER TO TBL
CALL 'KNUTH-SHUFFLE'
USING BY REFERENCE TBL
END-CALL.
DISPLAY "TABLE after shuffle: " TBL.
PERFORM UNTIL TBL = ANSWER
ADD 1 TO TRIES
DISPLAY "How many to reverse? "
ACCEPT RNUM
CALL 'REVERSE' USING BY CONTENT RNUM,
BY REFERENCE TBL
END-CALL
DISPLAY "Try #" TRIES " " TBL
END-PERFORM.
DISPLAY "Congratulations. You did it!"
STOP RUN.
END PROGRAM REVERSAL.
IDENTIFICATION DIVISION.
PROGRAM-ID. KNUTH-SHUFFLE.
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 I PIC 9(9).
01 J PIC 9(9).
01 TEMP PIC 9(9).
01 tABLE-lEN PIC 9 value 9.
LINKAGE SECTION.
01 TTABLE-AREA.
03 TTABLE PIC 9 OCCURS 9 TIMES.
PROCEDURE DIVISION USING ttable-area.
MOVE FUNCTION RANDOM(FUNCTION CURRENT-DATE (11:6)) TO I
PERFORM VARYING i FROM Table-Len BY -1 UNTIL i = 0
COMPUTE j =
FUNCTION MOD(FUNCTION RANDOM * 10000, Table-Len) + 1
MOVE ttable (i) TO temp
MOVE ttable (j) TO ttable (i)
MOVE temp TO ttable (j)
END-PERFORM.
GOBACK.
END PROGRAM KNUTH-SHUFFLE.
IDENTIFICATION DIVISION.
PROGRAM-ID. REVERSE.
DATA DIVISION.
LOCAL-STORAGE SECTION.
01 I PIC 9.
01 J PIC 9.
01 X PIC 9.
01 LOOP-IDX PIC 9.
LINKAGE SECTION.
01 IDX PIC 9.
01 TTABLE-AREA.
03 TTABLE PIC 9 OCCURS 9 TIMES.
PROCEDURE DIVISION USING IDX, TTABLE-AREA.
DIVIDE IDX BY 2 GIVING LOOP-IDx
MOVE 1 TO I
MOVE IDX TO J
PERFORM LOOP-IDX TIMES
MOVE TTABLE(I) TO X
MOVE TTABLE(J) TO TTABLE(I)
MOVE X TO TTABLE(J)
ADD 1 TO I
SUBTRACT 1 FROM J
END-PERFORM.
GOBACK.
END PROGRAM REVERSE.
Common Lisp
(defun shuffle! (vector)
(loop for i from (1- (length vector)) downto 1
do (rotatef (aref vector i)
(aref vector (random i)))))
(defun slice (vector start &optional end)
(let ((end (or end (length vector))))
(make-array (- end start)
:element-type (array-element-type vector)
:displaced-to vector
:displaced-index-offset start)))
(defun orderedp (seq)
(apply #'<= (coerce seq 'list)))
(defun prompt-integer (prompt)
(format t "~A: " prompt)
(finish-output)
(clear-input)
(parse-integer (read-line)))
(defun game ()
(let ((numbers (vector 1 2 3 4 5 6 7 8 9)))
(shuffle! numbers)
(let ((score
(do ((score 0 (1+ score)))
((orderedp numbers) score)
(format t "~A~%" numbers)
(let* ((n (prompt-integer "How many numbers to reverse"))
(slice (slice numbers 0 n)))
(replace slice (nreverse slice))))))
(format t "~A~%Congratulations, you did it in ~D reversals!~%" numbers score))))
Crystal
SIZE = 9
ordered = (1..SIZE).to_a
shuffled = (1..SIZE).to_a
while shuffled == ordered
shuffled.shuffle!
end
score = 0
until shuffled == ordered
print "#{shuffled} Enter items to reverse: "
next unless guess = gets
next unless num = guess.to_i?
next if num < 2 || num > SIZE
shuffled[0, num] = shuffled[0, num].reverse
score += 1
end
puts "#{shuffled} Your score: #{score}"
D
import std.stdio, std.random, std.string, std.conv, std.algorithm,
std.range;
void main() {
auto data = iota(1, 10).array;
do data.randomShuffle;
while (data.isSorted);
int trial;
while (!data.isSorted) {
writef("%d: %s How many numbers to flip? ", ++trial, data);
data[0 .. readln.strip.to!uint].reverse;
}
writefln("\nYou took %d attempts.", trial);
}
- Output:
1: [7, 2, 1, 6, 3, 8, 9, 5, 4] How many numbers to flip? 7 2: [9, 8, 3, 6, 1, 2, 7, 5, 4] How many numbers to flip? 9 3: [4, 5, 7, 2, 1, 6, 3, 8, 9] How many numbers to flip? 3 4: [7, 5, 4, 2, 1, 6, 3, 8, 9] How many numbers to flip? 7 5: [3, 6, 1, 2, 4, 5, 7, 8, 9] How many numbers to flip? 2 6: [6, 3, 1, 2, 4, 5, 7, 8, 9] How many numbers to flip? 6 7: [5, 4, 2, 1, 3, 6, 7, 8, 9] How many numbers to flip? 5 8: [3, 1, 2, 4, 5, 6, 7, 8, 9] How many numbers to flip? 3 9: [2, 1, 3, 4, 5, 6, 7, 8, 9] How many numbers to flip? 2 You took 9 attempts.
Delphi
This program simulates a console application in an event-drivern, GUI application. It does this by creating a special helper object that manages the TMemo control. The helper-object waits for keystrokes and returns when the user has pressed a key or the program aborts. Notice how the object is created and destroyed every time you wait for a key stroke. This a common practice in Delphi and it works because the creation of an object is a low overhead opeation. That allows you to eliminate global variables and isolate resources to specific parts of the program.
type TKeyWaiter = class(TObject)
private
FControl: TWinControl;
protected
procedure HandleKeyPress(Sender: TObject; var Key: Char);
public
KeyChar: Char;
ValidKey: boolean;
Abort: boolean;
constructor Create(Control: TWinControl);
function WaitForKey: char;
end;
{ TMemoWaiter }
type TControlHack = class(TWinControl) end;
constructor TKeyWaiter.Create(Control: TWinControl);
{Save the control we want to wait on}
begin
FControl:=Control;
end;
procedure TKeyWaiter.HandleKeyPress(Sender: TObject; var Key: Char);
{Handle captured key press}
begin
KeyChar:=Key;
ValidKey:=True;
end;
function TKeyWaiter.WaitForKey: char;
{Capture keypress event and wait for key press control}
{Spends most of its time sleep and aborts if the user}
{sets the abort flag or the program terminates}
begin
ValidKey:=False;
Abort:=False;
TControlHack(FControl).OnKeyPress:=HandleKeyPress;
repeat
begin
Application.ProcessMessages;
Sleep(100);
end
until ValidKey or Application.Terminated or Abort;
Result:=KeyChar;
end;
{===========================================================}
type TNumbers = array [0..8] of integer;
function WaitForKey(Memo: TMemo; Prompt: string): char;
{Wait for key stroke on TMemo component}
var KW: TKeyWaiter;
begin
{Use custom object to wait and capture key strokes}
KW:=TKeyWaiter.Create(Memo);
try
Memo.Lines.Add(Prompt);
Memo.SelStart:=Memo.SelStart-1;
Memo.SetFocus;
Result:=KW.WaitForKey;
finally KW.Free; end;
end;
procedure ScrambleNumbers(var Numbers: TNumbers);
{Scramble numbers into a random order}
var I,I1,I2,T: integer;
begin
for I:=0 to 8 do Numbers[I]:=I+1;
for I:=1 to 100 do
begin
I1:=Random(9);
I2:=Random(9);
T:=Numbers[I1];
Numbers[I1]:=Numbers[I2];
Numbers[I2]:=T;
end;
end;
function GetNumbersStr(Numbers: TNumbers): string;
{Return number order as a string}
var I: integer;
begin
Result:='';
for I:=0 to High(Numbers) do
begin
if I<>0 then Result:=Result+' ';
Result:=Result+IntToStr(Numbers[I]);
end;
end;
procedure ReverseNumbers(var Numbers: TNumbers; Count: integer);
{Reverse the specified count of numbers from the start}
var NT: TNumbers;
var I,I1: integer;
begin
NT:=Numbers;
for I:=0 to Count-1 do
begin
I1:=(Count-1) - I;
Numbers[I1]:=NT[I];
end;
end;
function IsWinner(Numbers: TNumbers): boolean;
{Check if is number is order 1..9}
var I: integer;
begin
Result:=False;
for I:=0 to High(Numbers) do
if Numbers[I]<>(I+1) then exit;
Result:=True;
end;
procedure ReverseGame(Memo: TMemo);
{Play the reverse game on specified memo}
var C: char;
var Numbers: TNumbers;
var S: string;
var R: integer;
begin
Randomize;
ScrambleNumbers(Numbers);
while true do
begin
S:=GetNumbersStr(Numbers);
C:=WaitForKey(Memo,S+' Number To Reverse: ');
if Application.Terminated then exit;
if C in ['x','X'] then break;
R:=byte(C) - $30;
ReverseNumbers(Numbers,R);
if IsWinner(Numbers) then
begin
S:=GetNumbersStr(Numbers);
Memo.Lines.Add(S+' - WINNER!!');
break;
end;
end;
end;
- Output:
8 5 2 9 7 4 6 3 1 Number To Reverse: 4 9 2 5 8 7 4 6 3 1 Number To Reverse: 9 1 3 6 4 7 8 5 2 9 Number To Reverse: 6 8 7 4 6 3 1 5 2 9 Number To Reverse: 8 2 5 1 3 6 4 7 8 9 Number To Reverse: 5 6 3 1 5 2 4 7 8 9 Number To Reverse: 6 4 2 5 1 3 6 7 8 9 Number To Reverse: 3 5 2 4 1 3 6 7 8 9 Number To Reverse: 5 3 1 4 2 5 6 7 8 9 Number To Reverse: 3 4 1 3 2 5 6 7 8 9 Number To Reverse: 4 2 3 1 4 5 6 7 8 9 Number To Reverse: 2 3 2 1 4 5 6 7 8 9 Number To Reverse: 3 1 2 3 4 5 6 7 8 9 - WINNER!!
EasyLang
func sorted s[] .
for c in s[]
if c < last
return 0
.
last = c
.
return 1
.
func$ tostr s[] .
for s in s[]
res$ &= s & " "
.
return res$
.
proc shuffle . s[] .
for i = len s[] downto 2
swap s[i] s[random i]
.
.
proc reverse n . s[] .
for i = 1 to n div 2
swap s[i] s[n - i + 1]
.
.
data[] = [ 1 2 3 4 5 6 7 8 9 ]
while sorted data[] = 1
shuffle data[]
.
while sorted data[] = 0
print tostr data[]
score += 1
nflip = number input
reverse nflip data[]
.
print "Score " & score
Egel
import "prelude.eg"
import "io.ego"
import "random.ego"
using System
using IO
using List
using Math
def swap =
[ (I J) XX -> insert I (nth J XX) (insert J (nth I XX) XX) ]
def shuffle =
[ XX ->
let INDICES = reverse (fromto 0 ((length XX) - 1)) in
let SWAPS = map [ I -> I (between 0 I) ] INDICES in
foldr [I J -> swap I J] XX SWAPS ]
def prompt =
[ XX TURN ->
let _ = print TURN ". " in
let _ = map [ X -> print X " " ] XX in
let _ = print " : " in
toint getline ]
def game =
[ GOAL SHUFFLE TURN ->
if SHUFFLE == GOAL then
let _ = print "the goal was " in
let _ = map [ X -> print X " " ] GOAL in
print "\nit took you " TURN " turns\n"
else
let N = prompt SHUFFLE TURN in
let YY = (reverse (take N SHUFFLE)) ++ (drop N SHUFFLE) in
game GOAL YY (TURN + 1) ]
def main =
let XX = fromto 1 9 in game XX (shuffle XX) 0
Eiffel
class
APPLICATION
create
make
feature {NONE}
make
-- Plays Number Reversal Game.
local
count: INTEGER
do
initialize_game
io.put_string ("Let's play the number reversal game.%N")
across
numbers as ar
loop
io.put_string (ar.item.out + "%T")
end
from
until
is_sorted (numbers, 1, numbers.count)
loop
io.put_string ("%NHow many numbers should be reversed?%N")
io.read_integer
reverse_array (io.last_integer)
across
numbers as ar
loop
io.put_string (ar.item.out + "%T")
end
count := count + 1
end
io.put_string ("%NYou needed " + count.out + " reversals.")
end
feature {NONE}
initialize_game
-- Array with numbers from 1 to 9 in a random unsorted order.
local
random: V_RANDOM
item, i: INTEGER
do
create random
create numbers.make_empty
from
i := 1
until
numbers.count = 9 and not is_sorted (numbers, 1, numbers.count)
loop
item := random.bounded_item (1, 9)
if not numbers.has (item) then
numbers.force (item, i)
i := i + 1
end
random.forth
end
end
numbers: ARRAY [INTEGER]
reverse_array (upper: INTEGER)
-- Array numbers with first element up to nth element reversed.
require
upper_positive: upper > 0
ar_not_void: numbers /= Void
local
i, j: INTEGER
new_array: ARRAY [INTEGER]
do
create new_array.make_empty
new_array.deep_copy (numbers)
from
i := 1
j := upper
until
i > j
loop
new_array [i] := numbers [j]
new_array [j] := numbers [i]
i := i + 1
j := j - 1
end
numbers := new_array
end
is_sorted (ar: ARRAY [INTEGER]; l, r: INTEGER): BOOLEAN
-- Is Array 'ar' sorted in ascending order?
require
ar_not_empty: not ar.is_empty
do
Result := True
across
1 |..| (r - 1) as c
loop
if ar [c.item] > ar [c.item + 1] then
Result := False
end
end
end
end
- Output:
Let's play the number reversal game. 7 8 5 6 9 6 1 4 2 How many numbers should be reversed? 5 9 3 5 8 7 6 1 4 2 How many numbers should be reversed? 9 2 4 1 6 7 8 5 3 9 How many numbers should be reversed? 6 8 7 6 1 4 2 5 3 9 How many numbers should be reversed? 8 3 5 2 4 1 6 7 8 9 How many numbers should be reversed? 2 5 3 2 4 1 6 7 8 9 How many numbers should be reversed? 5 1 4 2 3 5 6 7 8 9 How many numbers should be reversed? 2 4 1 2 3 5 6 7 8 9 How many numbers should be reversed? 4 3 2 1 4 5 6 7 8 9 How many numbers should be reversed? 3 1 2 3 4 5 6 7 8 9 You needed 9 reversals.
Elena
ELENA 6.x:
import system'routines;
import extensions;
public program()
{
var sorted := Array.allocate(9).populate::(n => n + 1 );
var values := sorted.clone().randomize(9);
while (sorted.sequenceEqual(values))
{
values := sorted.randomize(9)
};
var tries := new Integer();
until (sorted.sequenceEqual(values))
{
tries.append(1);
console.print("# ",tries," : LIST : ",values," - Flip how many?");
values.sequenceReverse(0, console.readLine().toInt())
};
console.printLine("You took ",tries," attempts to put the digits in order!").readChar()
}
Elixir
defmodule Number_reversal_game do
def start( n ) when n > 1 do
IO.puts "Usage: #{usage(n)}"
targets = Enum.to_list( 1..n )
jumbleds = Enum.shuffle(targets)
attempt = loop( targets, jumbleds, 0 )
IO.puts "Numbers sorted in #{attempt} atttempts"
end
defp loop( targets, targets, attempt ), do: attempt
defp loop( targets, jumbleds, attempt ) do
IO.inspect jumbleds
{n,_} = IO.gets("How many digits from the left to reverse? ") |> Integer.parse
loop( targets, Enum.reverse_slice(jumbleds, 0, n), attempt+1 )
end
defp usage(n), do: "Given a jumbled list of the numbers 1 to #{n} that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all the digits end up in ascending order."
end
Number_reversal_game.start( 9 )
- Output:
Usage: Given a jumbled list of the numbers 1 to 9 that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all he digits end up in ascending order. [3, 9, 4, 7, 6, 5, 1, 2, 8] How many digits from the left to reverse? 2 [9, 3, 4, 7, 6, 5, 1, 2, 8] How many digits from the left to reverse? 9 [8, 2, 1, 5, 6, 7, 4, 3, 9] How many digits from the left to reverse? 8 [3, 4, 7, 6, 5, 1, 2, 8, 9] How many digits from the left to reverse? 3 [7, 4, 3, 6, 5, 1, 2, 8, 9] How many digits from the left to reverse? 7 [2, 1, 5, 6, 3, 4, 7, 8, 9] How many digits from the left to reverse? 4 [6, 5, 1, 2, 3, 4, 7, 8, 9] How many digits from the left to reverse? 6 [4, 3, 2, 1, 5, 6, 7, 8, 9] How many digits from the left to reverse? 4 Numbers sorted in 8 atttempts
Erlang
-module( number_reversal_game ).
-export( [task/0, start/1] ).
start( N ) when N > 1 ->
io:fwrite( "Usage: ~s~n", [usage(N)] ),
Targets = lists:seq( 1, N ),
Jumbleds = [X||{_,X} <- lists:sort([ {random:uniform(), Y} || Y <- Targets])],
Attempt = loop( Targets, Jumbleds, 0 ),
io:fwrite( "Numbers sorted in ~p atttempts~n", [Attempt] ).
task() -> start( 9 ).
loop( Targets, Targets, Attempt ) -> Attempt;
loop( Targets, Jumbleds, Attempt ) ->
io:fwrite( "~p~n", [Jumbleds] ),
{ok,[N]} = io:fread( "How many digits from the left to reverse? ", "~d" ),
{Lefts, Rights} = lists:split( N, Jumbleds ),
loop( Targets, lists:reverse(Lefts) ++ Rights, Attempt + 1 ).
usage(N) -> io_lib:format( "Given a jumbled list of the numbers 1 to ~p that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all the digits end up in ascending order.", [N] ).
- Output:
Not being a very good player I show a test run with only 3 numbers.
35> number_reversal_game:start(3). Usage: Given a jumbled list of the numbers 1 to 3 that are definitely not in ascending order, show the list then ask the player how many digits from the left to reverse. Reverse those digits, then ask again, until all the digits end up in ascending order. [2,3,1] How many digits from the left to reverse? 3 [1,3,2] How many digits from the left to reverse? 3 [2,3,1] How many digits from the left to reverse? 2 [3,2,1] How many digits from the left to reverse? 3 Numbers sorted in 4 atttempts
Euphoria
include get.e
function accending(sequence s)
for i = 1 to length(s)-1 do
if s[i]>s[i+1] then
return 0
end if
end for
return 1
end function
puts(1,"Given a jumbled list of the numbers 1 to 9,\n")
puts(1,"you must select how many digits from the left to reverse.\n")
puts(1,"Your goal is to get the digits in order with 1 on the left and 9 on the right.\n")
sequence nums
nums = repeat(0,9)
integer n,flp,tries,temp
-- initial values
for i = 1 to 9 do
nums[i] = i
end for
while accending(nums) do -- shuffle
for i = 1 to 9 do
n = rand(9)
temp = nums[n]
nums[n] = nums[i]
nums[i] = temp
end for
end while
tries = 0
while 1 do
printf(1,"%2d : ",tries)
for i = 1 to 9 do
printf(1,"%d ",nums[i])
end for
if accending(nums) then
exit
end if
flp = prompt_number(" -- How many numbers should be flipped? ",{1,9})
for i = 1 to flp/2 do
temp = nums[i]
nums[i] = nums[flp-i+1]
nums[flp-i+1] = temp
end for
tries += 1
end while
printf(1,"\nYou took %d tries to put the digits in order.", tries)
Output:
Given a jumbled list of the numbers 1 to 9, you must select how many digits from the left to reverse. Your goal is to get the digits in order with 1 on the left and 9 on the right. 0 : 4 8 7 5 1 6 3 9 2 -- How many numbers should be flipped? 8 1 : 9 3 6 1 5 7 8 4 2 -- How many numbers should be flipped? 9 2 : 2 4 8 7 5 1 6 3 9 -- How many numbers should be flipped? 3 3 : 8 4 2 7 5 1 6 3 9 -- How many numbers should be flipped? 8 4 : 3 6 1 5 7 2 4 8 9 -- How many numbers should be flipped? 5 5 : 7 5 1 6 3 2 4 8 9 -- How many numbers should be flipped? 7 6 : 4 2 3 6 1 5 7 8 9 -- How many numbers should be flipped? 4 7 : 6 3 2 4 1 5 7 8 9 -- How many numbers should be flipped? 6 8 : 5 1 4 2 3 6 7 8 9 -- How many numbers should be flipped? 5 9 : 3 2 4 1 5 6 7 8 9 -- How many numbers should be flipped? 3 10 : 4 2 3 1 5 6 7 8 9 -- How many numbers should be flipped? 4 11 : 1 3 2 4 5 6 7 8 9 -- How many numbers should be flipped? 2 12 : 3 1 2 4 5 6 7 8 9 -- How many numbers should be flipped? 3 13 : 2 1 3 4 5 6 7 8 9 -- How many numbers should be flipped? 2 14 : 1 2 3 4 5 6 7 8 9 You took 14 tries to put the digits in order.
F#
let rand = System.Random()
while true do
let rec randomNums() =
let xs = [|for i in 1..9 -> rand.Next(), i|] |> Array.sort |> Array.map snd
if xs = Array.sort xs then randomNums() else xs
let xs = randomNums()
let suffix = function | 1 -> "st" | 2 -> "nd" | 3 -> "rd" | _ -> "th"
let rec move i =
printf "\n%A\n\nReverse how many digits from the left in your %i%s move? : " xs i (suffix i)
let n = stdin.ReadLine() |> int
Array.blit (Array.rev xs.[0..n-1]) 0 xs 0 n
if xs <> Array.sort xs then
move (i+1)
else
printfn "\nYou took %i moves to put the digits in order!\n" i
move 1
Factor
USING: formatting io kernel math math.parser math.ranges
namespaces random sequences strings ;
IN: rosetta.number-reversal
: make-jumbled-array ( -- sorted jumbled )
CHAR: 1 CHAR: 9 [a,b] [ 1string ] map dup clone randomize
[ 2dup = ] [ randomize ] while ;
SYMBOL: trials
: prompt ( jumbled -- n )
trials get "#%2d: " printf
", " join write
" Flip how many? " write flush
readln string>number ;
: game-loop ( sorted jumbled -- )
2dup = [
2drop trials get
"\nYou took %d attempts to put the digits in order!\n" printf
flush
] [
trials [ 1 + ] change
dup dup prompt head-slice reverse! drop
game-loop
] if ;
: play ( -- )
0 trials set
make-jumbled-array game-loop ;
FOCAL
01.10 D 3;S T=0
01.20 F X=1,9;T %1,D(X)
01.30 T !;A "HOW MANY",R
01.40 I (R-1)1.3;I (9-R)1.3
01.50 D 5;S T=T+1
01.60 D 4;I (A-9)1.2
01.70 D 1.2;T !"CORRECT! ATTEMPTS",%4,T,!
01.80 Q
02.10 S A=10*FRAN();S A=A-FITR(A)
03.10 F X=1,9;S D(X)=X
03.20 F X=1,8;D 2;S Y=X+FITR((10-X)*A);S A=D(X);S D(X)=D(Y);S D(Y)=A
03.30 D 4
03.40 I (8-A)3.1
04.10 S A=0
04.20 F X=1,9;D 4.4
04.30 R
04.40 I (D(X)-X)4.3,4.5,4.3
04.50 S A=A+1
05.10 F X=1,R/2;S A=D(X);S D(X)=D(R-X+1);S D(R-X+1)=A
- Output:
= 1= 6= 4= 5= 8= 7= 9= 2= 3 HOW MANY:9 = 3= 2= 9= 7= 8= 5= 4= 6= 1 HOW MANY:2 = 2= 3= 9= 7= 8= 5= 4= 6= 1 HOW MANY:8 = 6= 4= 5= 8= 7= 9= 3= 2= 1 HOW MANY:3 = 5= 4= 6= 8= 7= 9= 3= 2= 1 HOW MANY:2 = 4= 5= 6= 8= 7= 9= 3= 2= 1 HOW MANY:3 = 6= 5= 4= 8= 7= 9= 3= 2= 1 HOW MANY:3 = 4= 5= 6= 8= 7= 9= 3= 2= 1 HOW MANY:6 = 9= 7= 8= 6= 5= 4= 3= 2= 1 HOW MANY:3 = 8= 7= 9= 6= 5= 4= 3= 2= 1 HOW MANY:2 = 7= 8= 9= 6= 5= 4= 3= 2= 1 HOW MANY:3 = 9= 8= 7= 6= 5= 4= 3= 2= 1 HOW MANY:9 = 1= 2= 3= 4= 5= 6= 7= 8= 9 CORRECT! ATTEMPTS= 12
Forth
include random.fs
variable flips
create nums 9 cells allot
: .array ( addr len -- ) 0 ?do dup @ . cell+ loop drop ;
: shuffle ( addr len -- )
2 swap do
dup i random cells +
over @ over @ swap
rot ! over !
cell+
-1 +loop drop ;
: sorted? ( addr len -- )
1- cells bounds ?do
i 2@ < if unloop false exit then
cell +loop true ;
: init
0 flips !
nums 10 1 do
i over ! cell+
loop drop
begin nums 9 shuffle nums 9 sorted? 0= until
cr nums 9 .array ;
: reverse ( addr len -- )
1- cells bounds
begin 2dup >
while over @ over @ >r over ! over r> swap !
cell+ swap 1 cells - swap
repeat 2drop ;
: flip ( n -- )
dup 2 10 within 0= if . ." must be within 2 to 9" exit then
nums swap reverse
1 flips +!
nums 9 sorted? if
cr ." Got it in " flips @ . ." tries!"
else
cr nums 9 .array
then ;
init
1 2 8 5 7 6 9 4 3 ok
7 flip
9 6 7 5 8 2 1 4 3 ok
Fortran
program Reversal_game
implicit none
integer :: list(9) = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /)
integer :: pos, attempts = 0
call random_seed
do while (sorted(list))
call Shuffle(list)
end do
write(*, "(9i5)") list
write(*,*)
do while (.not. Sorted(list))
write(*, "(a)", advance="no") "How many numbers from the left do you want to reverse? : "
read*, pos
attempts = attempts + 1
list(1:pos) = list(pos:1:-1)
write(*, "(9i5)") list
write(*,*)
end do
write(*,*)
write(*, "(a,i0,a)") "Congratulations! Solved in ", attempts, " attempts"
contains
subroutine Shuffle(a)
integer, intent(inout) :: a(:)
integer :: i, randpos, temp
real :: r
do i = size(a), 2, -1
call random_number(r)
randpos = int(r * i) + 1
temp = a(randpos)
a(randpos) = a(i)
a(i) = temp
end do
end subroutine
function Sorted(a)
logical :: Sorted
integer, intent(in) :: a(:)
integer :: i
do i = 1, size(a)-1
if(list(i+1) /= list(i)+1) then
Sorted = .false.
return
end if
end do
Sorted = .true.
end function
end program
FreeBASIC
- See BASIC
Go
package main
import (
"fmt"
"math/rand"
"sort"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
var k []int
for {
k = rand.Perm(9)
for i, r := range k {
if r == 0 {
k[i] = 9
}
}
if !sort.IntsAreSorted(k) {
break
}
}
fmt.Println("Sort digits by reversing a number of digits on the left.")
var n, score int
for {
fmt.Print("Digits: ", k, ". How many to reverse? ")
i, _ := fmt.Scanln(&n)
score++
if i == 0 || n < 2 || n > 9 {
fmt.Println("\n(Enter a number from 2 to 9)")
continue
}
for l, r := 0, n-1; l < r; l, r = l+1, r-1 {
k[l], k[r] = k[r], k[l]
}
if sort.IntsAreSorted(k) {
fmt.Print("Digits: ", k, ".\n")
fmt.Print("Your score: ", score, ". Good job.\n")
return
}
}
}
Groovy
sorted = [*(1..9)]
arr = sorted.clone()
void flipstart(n) { arr[0..<n] = arr[0..<n].reverse() }
int steps = 0
while (arr==sorted) Collections.shuffle(arr)
while (arr!=sorted) {
println arr.join(' ')
print 'Reverse how many? '
def flipcount = System.in.readLine()
flipstart( flipcount.toInteger() )
steps += 1
}
println "Done! That took you ${steps} steps"
Haskell
Using Rosetta Knuth Shuffle
import Data.List
import Control.Arrow
import Rosetta.Knuthshuffle
numberRevGame = do
let goal = [1..9]
shuffle xs =
if xs /= goal then return xs
else shuffle =<< knuthShuffle xs
prefixFlipAt k = uncurry (++). first reverse. splitAt k
prompt r ry = do
putStr $ show r ++ ". " ++ concatMap (flip (++) " ". show) ry
++ " How many to flip? "
answ <- getLine
let n = read answ
if n<10 && 0<n then return n
else do
putStrLn "Error. The number should be between 0 and 10. Try again"
prompt r ry
playNRG r nrs =
if nrs == goal then do
putStrLn $ "The answer is: " ++ concatMap (flip (++) " ". show) nrs
putStrLn $ "It took you " ++ show r ++ " attempts to sort the numbers."
putStrLn ""
else do
answ <- prompt r nrs
playNRG (succ r) (prefixFlipAt answ nrs)
start <- shuffle goal
playNRG 1 start
Play:
*Main> numberRevGame 1. 3 5 1 4 7 6 8 2 9 How many to flip? 7 2. 8 6 7 4 1 5 3 2 9 How many to flip? 8 3. 2 3 5 1 4 7 6 8 9 How many to flip? 3 4. 5 3 2 1 4 7 6 8 9 How many to flip? 6 5. 7 4 1 2 3 5 6 8 9 How many to flip? 7 6. 6 5 3 2 1 4 7 8 9 How many to flip? 6 7. 4 1 2 3 5 6 7 8 9 How many to flip? 4 8. 3 2 1 4 5 6 7 8 9 How many to flip? 3 The answer is: 1 2 3 4 5 6 7 8 9 It took you 9 attempts to sort the numbers.
HicEst
WRITE(Messagebox) "You took ", Reversals(), " attempts"
FUNCTION Reversals()
DIMENSION digits(9), temp(9)
digits = 0
DO i = 1, 9 ! create the shuffled digits
1 x = CEILING( RAN(9) )
IF( INDEX(digits, x) ) GOTO 1 ! HicEst has no WHILE
digits(i) = x
ENDDO
DO Reversals = 1, 1E6 ! HicEst needs an upper bound
DLG(NameEdit=Flips, DNum, MIn=0, MAx=9, Text=digits)
DO j = 1, Flips/2
swap = digits(j)
digits(j) = digits(Flips+1-j)
digits(Flips+1-j) = swap
ENDDO
temp = digits($+1) > digits($) ! $ = left side index
IF( SUM(temp) == 8 ) RETURN
ENDDO
END
Icon and Unicon
Sample output:
Input a position. The list will be flipped left to right at that point. You win when the list is sorted. Commands: help, h, ? - shows this new, g - new game ruler, r - shows a ruler show, s - shows the list <n> - flips the list at ruler position n quit, q - quit and various magic words. 123456789 =745361289 = Command? : 7 =216354789 = Command? : 3 =612354789 = Command? : 6 =453216789 = Command? : 2 =543216789 = Command? : 5 Congratulations you won in 5 flips! Play another game? :
Inform 7
Number Reversal Game is a room.
The current list is a list of numbers that varies.
When play begins:
now the current list is a shuffled list from 1 to 9;
now the command prompt is "Current list: [current list in brace notation].[line break]How many items to flip? ".
Definition: a list of numbers (called L) is sorted:
repeat with N running from 1 to the number of entries in L:
if entry N in L is not N, no;
yes.
To decide which list of numbers is a shuffled list from (min - number) to (max - number):
let result be a list of numbers;
repeat with N running from min to max:
add N to result;
while true is true:
sort result in random order;
if result is not sorted, decide on result.
Flipping is an action applying to one number. Understand "[number]" as flipping.
Carry out flipping:
let N be the number understood;
let L be the current list;
truncate the current list to the first N entries;
reverse the current list;
truncate L to the last (number of entries in L minus N) entries;
add L to the current list.
Report flipping: say "".
Every turn:
if the current list is sorted, end the story saying "You have won".
This is the new print final score rule:
say "It took you [turn count] flip[s] to sort the list."
The new print final score rule is listed instead of the print final score rule in the for printing the player's obituary rules.
Io
withRange := method( a, z,
Range clone setRange(a,z)
)
sorted := withRange(1,9) asList
numbers := sorted clone shuffle
while( numbers==sorted, numbers = numbers shuffle)
steps :=0
stdin := File standardInput
while( numbers != sorted,
writeln(numbers join(" "))
write("Reverse how many? ")
flipcount := stdin readLine asNumber
withRange(0, ((flipcount-1)/2) floor) foreach( i,
numbers swapIndices(i,flipcount-1-i)
)
steps = steps+1
)
writeln("Done! That took you ", steps, " steps")
IS-BASIC
100 PROGRAM "Reversal.bas"
110 RANDOMIZE
120 NUMERIC NR(1 TO 9)
130 LET TRIES=0
140 TEXT :PRINT "Given a jumbled list of the numbers 1 to 9, you must select how many digits from the left to reverse.":PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right.":PRINT
150 FOR I=1 TO 9
160 LET NR(I)=I
170 NEXT
180 DO
190 FOR I=2 TO 9
200 LET N=RND(I)+1
210 IF N<>I THEN CALL SWAP(N,I)
220 NEXT
230 LOOP WHILE ORDERED
240 DO
250 PRINT USING "##: ":TRIES;
260 FOR I=1 TO 9
270 PRINT NR(I);
280 NEXT
290 PRINT
300 IF ORDERED THEN EXIT DO
310 DO
320 INPUT PROMPT "How many numbers should be flipped? ":FLIP
330 LOOP WHILE FLIP<2 OR FLIP>9
340 FOR I=1 TO FLIP/2
350 CALL SWAP(I,FLIP-I+1)
360 NEXT
370 LET TRIES=TRIES+1
380 LOOP
390 PRINT :PRINT "You took";TRIES;"tries to put the digits in order."
400 DEF SWAP(A,B)
410 LET T=NR(A):LET NR(A)=NR(B):LET NR(B)=T
420 END DEF
430 DEF ORDERED
440 LET ORDERED=-1
450 FOR J=1 TO 8
460 IF NR(J)>NR(J+1) THEN LET ORDERED=0:EXIT FOR
470 NEXT
480 END DEF
J
Solution:
require 'misc' NB. for the verb prompt
INTRO=: noun define
Number Reversal Game
Flip groups of numbers from the left of the list until
the numbers are sorted in ascending order.
)
reversegame=: verb define
whilst. (-: /:~)nums do.
nums=. 1+9?9 NB. 1-9 in random order
end.
score=. 0
smoutput INTRO NB. Display instructions
while. -.(-: /:~)nums do.
score=. 1+ score NB. increment score
nnum=. 0".prompt (":score),': ',(":nums),' How many numbers to flip?: '
if. 0 = #nnum do. return. end. NB. exit on ENTER without number
nums=. (C.i.-nnum) C. nums NB. reverse first nnum numbers
end.
'You took ',(": score), ' attempts to put the numbers in order.'
)
Example Usage:
reversegame''
Number Reversal Game
Sort the numbers in ascending order by repeatedly
flipping sets of numbers from the left.
1: 4 7 5 6 9 1 2 8 3 How many numbers to flip?: 5
2: 9 6 5 7 4 1 2 8 3 How many numbers to flip?: 9
3: 3 8 2 1 4 7 5 6 9 How many numbers to flip?: 2
4: 8 3 2 1 4 7 5 6 9 How many numbers to flip?: 8
5: 6 5 7 4 1 2 3 8 9 How many numbers to flip?: 3
6: 7 5 6 4 1 2 3 8 9 How many numbers to flip?: 7
7: 3 2 1 4 6 5 7 8 9 How many numbers to flip?: 5
8: 6 4 1 2 3 5 7 8 9 How many numbers to flip?: 6
9: 5 3 2 1 4 6 7 8 9 How many numbers to flip?: 5
10: 4 1 2 3 5 6 7 8 9 How many numbers to flip?: 4
11: 3 2 1 4 5 6 7 8 9 How many numbers to flip?: 3
You took 11 attempts to put the numbers in order.
Java
import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Collections;
public class ReversalGame {
private List<Integer> gameList;
public ReversalGame() {
initialize();
}
public void play() throws Exception {
int i = 0;
int moveCount = 0;
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println(gameList);
System.out.println("Please enter a index to reverse from 2 to 9. Enter 99 to quit");
i = scanner.nextInt();
if (i == 99) {
break;
}
if (i < 2 || i > 9) {
System.out.println("Invalid input");
} else {
moveCount++;
reverse(i);
if (isSorted()) {
System.out.println("Congratulations you solved this in " + moveCount + " moves!");
break;
}
}
}
scanner.close();
}
private void reverse(int position) {
Collections.reverse(gameList.subList(0, position));
}
private boolean isSorted() {
for (int i=0; i < gameList.size() - 1; ++i) {
if (gameList.get(i).compareTo(gameList.get(i + 1)) > 0) {
return false;
}
}
return true;
}
private void initialize() {
this.gameList = new ArrayList<Integer>(9);
for (int i=1; i < 10; ++i) {
gameList.add(i);
}
while (isSorted()) {
Collections.shuffle(gameList);
}
}
public static void main(String[] args) {
try {
ReversalGame game = new ReversalGame();
game.play();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
JavaScript
Use knuth_shuffle()
function from here.
<html>
<head>
<title>Number Reversal Game</title>
</head>
<body>
<div id="start"></div>
<div id="progress"></div>
<div id="score"></div>
<script type="text/javascript">
function endGame(progress) {
var scoreId = progress.scoreId,
result = 'You took ' + progress.count + ' attempts to put the digits in order!';
if (progress.abort === true) {
result = 'Game aborted.';
}
document.getElementById(scoreId).innerHTML = result;
}
function reverseFirstN(arr, n) {
var reversed = arr.slice(0, n).reverse();
return reversed.concat(arr.slice(n));
}
function isSorted(arr) {
return arr.slice(0).sort().toString() === arr.toString();
}
function gameLoop(progress) {
if (isSorted(progress.arr)) {
endGame(progress);
} else {
var n = parseInt(window.prompt('How many elements to reverse?', ''), 10);
if (isNaN(n)) {
progress.abort = true;
} else {
progress.arr = reverseFirstN(progress.arr, n);
progress.innerHTML += '<p>' + progress.arr + '</p>';
progress.count += 1;
}
if (progress.abort !== true) {
// allow window to repaint before next guess
setTimeout(function () {
gameLoop(progress);
}, 1);
}
}
}
function knuth_shuffle(a) {
var n = a.length,
r,
temp;
while (n > 1) {
r = Math.floor(n * Math.random());
n -= 1;
temp = a[n];
a[n] = a[r];
a[r] = temp;
}
return a;
}
function playGame(startId, progressId, scoreId) {
var progress = document.getElementById(progressId);
progress.arr = knuth_shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9]);
document.getElementById(startId).innerHTML = '<p>' + progress.arr.toString() + '</p>';
progress.count = 0;
progress.scoreId = scoreId;
// allow window to repaint before prompting for a guess
setTimeout(function () {
gameLoop(progress);
}, 1);
}
playGame('start', 'progress', 'score');
</script>
</body>
</html>
jq
# Input: the initial array
def play:
def sorted: . == sort;
def reverse(n): (.[0:n] | reverse) + .[n:];
def prompt: "List: \(.list)\nEnter a pivot number: ";
def report: "Great! Your score is \(.score)";
{list: ., score: 0}
| (if .list | sorted then "List was sorted to begin with."
else
prompt,
( label $done
| foreach inputs as $n (.;
.list |= reverse($n) | .score +=1;
if .list | sorted then report, break $done else prompt end ))
end);
Example
[1,2,3,9,8,7,6,5,4] | play
Transcript
$ jq -r -n -f play.jq List: [1,2,3,9,8,7,6,5,4] Enter a pivot number: 9 List: [4,5,6,7,8,9,3,2,1] Enter a pivot number: 6 List: [9,8,7,6,5,4,3,2,1] Enter a pivot number: 9 Great! Your score is 3
Julia
# v0.6
function numrevgame()
l = collect(1:9)
while issorted(l) shuffle!(l) end
score = 0
println("# Number reversal game")
while !issorted(l)
print("$l\nInsert the index up to which to revert: ")
n = parse(Int, readline())
reverse!(l, 1, n)
score += 1
end
println("$l... You won!\nScore: $score")
return score
end
numrevgame()
Kotlin
// version 1.1.2
fun isAscending(a: IntArray): Boolean {
for (i in 0..8) if (a[i] != i + 1) return false
return true
}
fun main(args: Array<String>) {
val r = java.util.Random()
var count = 0
val numbers = IntArray(9)
numbers[0] = 2 + r.nextInt(8) // this will ensure list isn't ascending
for (i in 1..8) {
var rn: Int
do {
rn = 1 + r.nextInt(9)
} while (rn in numbers)
numbers[i] = rn
}
println("Here's your first list : ${numbers.joinToString()}")
while (true) {
var rev: Int
do {
print("How many numbers from the left are to be reversed : ")
rev = readLine()!!.toInt()
} while (rev !in 2..9)
count++
var i = 0
var j = rev - 1
while (i < j) {
val temp = numbers[i]
numbers[i++] = numbers[j]
numbers[j--] = temp
}
if (isAscending(numbers)) {
println("Here's your final list : ${numbers.joinToString()}")
break
}
println("Here's your list now : ${numbers.joinToString()}")
}
println("So you've completed the game with a score of $count")
}
Sample game:
- Output:
Here's your first list : 4, 3, 2, 7, 1, 6, 5, 8, 9 How many numbers from the left are to be reversed : 4 Here's your list now : 7, 2, 3, 4, 1, 6, 5, 8, 9 How many numbers from the left are to be reversed : 7 Here's your list now : 5, 6, 1, 4, 3, 2, 7, 8, 9 How many numbers from the left are to be reversed : 2 Here's your list now : 6, 5, 1, 4, 3, 2, 7, 8, 9 How many numbers from the left are to be reversed : 6 Here's your list now : 2, 3, 4, 1, 5, 6, 7, 8, 9 How many numbers from the left are to be reversed : 3 Here's your list now : 4, 3, 2, 1, 5, 6, 7, 8, 9 How many numbers from the left are to be reversed : 4 Here's your final list : 1, 2, 3, 4, 5, 6, 7, 8, 9 So you've completed the game with a score of 6
Lua
-- Initialisation
math.randomseed(os.time())
numList = {values = {}}
-- Check whether list contains n
function numList:contains (n)
for k, v in pairs(self.values) do
if v == n then return true end
end
return false
end
-- Check whether list is in order
function numList:inOrder ()
for k, v in pairs(self.values) do
if k ~=v then return false end
end
return true
end
-- Create necessarily out-of-order list
function numList:build ()
local newNum
repeat
for i = 1, 9 do
repeat
newNum = math.random(1, 9)
until not numList:contains(newNum)
table.insert(self.values, newNum)
end
until not numList:inOrder()
end
-- Display list of numbers on one line
function numList:show ()
for k, v in pairs(self.values) do
io.write(v .. " ")
end
io.write(":\t")
end
-- Reverse n values from left
function numList:reverse (n)
local swapList = {}
for k, v in pairs(self.values) do
table.insert(swapList, v)
end
for i = 1, n do
swapList[i] = self.values[n + 1 - i]
end
self.values = swapList
end
-- Main procedure
local score = 0
print("\nRosetta Code Number Reversal Game in Lua")
print("========================================\n")
numList:build()
repeat
numList:show()
numList:reverse(tonumber(io.read()))
score = score + 1
until numList:inOrder()
numList:show()
print("\n\nW00t! You scored:", score)
M2000 Interpreter
Using some ready made Print's from BASIC example
Using stack of values which we can move easy values. When we call subs and pass arguments that arguments as values stored to same stack, but because we pop them (read to variables) we leave stack with 9 values for the game.
To check if we have all values in order, we just check the difference of two items one after the other, if is one, and if not one then we leave checking returning false.
Sub CheckStack get a value by reference. Because stack of values always get values, a reference is a copy of a weak reference, so in CheckStack a new variable defined as local ok, and get the reference from weak reference in stack. When a sub exit any new,including local variables removed (deleted). Subs are always local to Module, and have same scope as module scope.
To display the values of stack we use Stack statement with no arguments.
Module Number_Reversal_Game {
PRINT "Given a jumbled list of the numbers 1 to 9,"
PRINT "you must select how many digits from the left to reverse."
PRINT "Your goal is to get the digits in order with 1 on the left and 9 on the right."
\\ work on a new stack - old stack parked, and attached at the exit of this block
Stack New {
Data 1,2,3,4,5,6,7,8,9
\\ Create jumbled list
For i=1 to 30: Reverse(Random(2,9)):Next i
Tries=0
fin=false
Repeat {
\\ Show Stack
Stack
Try ok {
INPUT " -- How many numbers should be flipped:", flp%
}
if not Ok then print: Restart
if flp%<2 or flp%>9 then Restart
Reverse(flp%)
Tries++
CheckStack(&fin)
} until Fin
\\ show stack again
Stack
PRINT "You took "; tries; " tries to put the digits in order."
}
Sub Reverse(n)
Shift 1, -n ' shift one item nth times in reverse
End Sub
Sub CheckStack(&ok)
ok=true
if stack.size<2 then exit sub
Local i
For i=2 to stack.size {
ok=stackitem(i)-stackitem(i-1)=1
if ok else exit
}
End Sub
}
Number_Reversal_Game
Mathematica /Wolfram Language
Module[{array = Range@9, score = 0},
While[array == Range@9, array = RandomSample@Range@9];
While[array != Range@9,
Print@array; (array[[;; #]] = Reverse@array[[;; #]]) &@
Input["How many digits would you like to reverse?"]; score++];
Print@array; Print["Your score:", score]]
MATLAB
function NumberReversalGame
list = randperm(9);
while issorted(list)
list = randperm(9);
end
fprintf('Given a list of numbers, try to put them into ascending order\n')
fprintf('by sequentially reversing everything left of a point you choose\n')
fprintf('in the array. Try to do it in as few reversals as possible.\n')
fprintf('No input will quit the game.\n')
fprintf('Position Num:%s\n', sprintf(' %d', 1:length(list)))
fprintf('Current List:%s', sprintf(' %d', list))
pivot = 1;
nTries = 0;
while ~isempty(pivot) && ~issorted(list)
pivot = input(' Enter position of reversal limit: ');
if pivot
list(1:pivot) = list(pivot:-1:1);
fprintf('Current List:%s', sprintf(' %d', list))
nTries = nTries+1;
end
end
if issorted(list)
fprintf('\nCongratulations! You win! Only %d reversals.\n', nTries)
else
fprintf('\nPlay again soon!\n')
end
end
- Output:
Given a list of numbers, try to put them into ascending order by sequentially reversing everything left of a point you choose in the array. Try to do it in as few reversals as possible. No input will quit the game. Position Num: 1 2 3 4 5 6 7 8 9 Current List: 1 6 3 2 8 7 9 4 5 Enter position of reversal limit: 7 Current List: 9 7 8 2 3 6 1 4 5 Enter position of reversal limit: 9 Current List: 5 4 1 6 3 2 8 7 9 Enter position of reversal limit: 7 Current List: 8 2 3 6 1 4 5 7 9 Enter position of reversal limit: 8 Current List: 7 5 4 1 6 3 2 8 9 Enter position of reversal limit: 7 Current List: 2 3 6 1 4 5 7 8 9 Enter position of reversal limit: 3 Current List: 6 3 2 1 4 5 7 8 9 Enter position of reversal limit: 6 Current List: 5 4 1 2 3 6 7 8 9 Enter position of reversal limit: 5 Current List: 3 2 1 4 5 6 7 8 9 Enter position of reversal limit: 3 Current List: 1 2 3 4 5 6 7 8 9 Congratulations! You win! Only 9 reversals.
Nim
import random, rdstdin, strutils, algorithm
randomize()
proc isSorted[T](s: openarray[T]): bool =
var last = low(T)
for c in s:
if c < last:
return false
last = c
return true
proc toString[T](s: openarray[T]): string =
result = ""
for i, x in s:
if i > 0:
result.add " "
result.add($x)
echo """number reversal game
Given a jumbled list of the numbers 1 to 9
Show the list.
Ask the player how many digits from the left to reverse.
Reverse those digits then ask again.
until all the digits end up in ascending order."""
var data = @[1,2,3,4,5,6,7,8,9]
var trials = 0
while isSorted data:
shuffle data
while not isSorted data:
inc trials
var flip = parseInt readLineFromStdin(
"#" & $trials & ": List: '" & toString(data) & "' Flip how many?: ")
reverse(data, 0, flip - 1)
echo "You took ", trials, " attempts to put the digits in order!"
Example:
#1: List: '6 5 8 7 2 1 9 3 4' Flip how many?: 5 #2: List: '2 7 8 5 6 1 9 3 4' Flip how many?: 6 #3: List: '1 6 5 8 7 2 9 3 4' Flip how many?: 9 #4: List: '4 3 9 2 7 8 5 6 1' Flip how many?: 4 #5: List: '2 9 3 4 7 8 5 6 1' Flip how many?: 8 #6: List: '6 5 8 7 4 3 9 2 1' Flip how many?: 6 #7: List: '3 4 7 8 5 6 9 2 1' Flip how many?: 7 #8: List: '9 6 5 8 7 4 3 2 1' Flip how many?: 3 #9: List: '5 6 9 8 7 4 3 2 1' Flip how many?: 5 #10: List: '7 8 9 6 5 4 3 2 1' Flip how many?: 3 #11: List: '9 8 7 6 5 4 3 2 1' Flip how many?: 9 You took 11 attempts to put the digits in order!
OCaml
Imperative
let swap ar i j =
let tmp = ar.(i) in
ar.(i) <- ar.(j);
ar.(j) <- tmp
let shuffle ar =
for i = pred(Array.length ar) downto 1 do
let j = Random.int (i + 1) in
swap ar i j
done
let reversal ar n =
for i = 0 to pred(n/2) do
let j = (pred n) - i in
swap ar i j
done
let sorted ar =
try
let prev = ref ar.(0) in
for i = 1 to pred(Array.length ar) do
if ar.(i) < !prev then raise Exit;
prev := ar.(i)
done;
(true)
with Exit ->
(false)
let () =
print_endline "\
Number Reversal Game
Sort the numbers in ascending order by repeatedly
flipping sets of numbers from the left.";
Random.self_init();
let nums = Array.init 9 (fun i -> succ i) in
while sorted nums do shuffle nums done;
let n = ref 1 in
while not(sorted nums) do
Printf.printf "#%2d: " !n;
Array.iter (Printf.printf " %d") nums;
print_newline();
let r = read_int() in
reversal nums r;
incr n;
done;
print_endline "Congratulations!";
Printf.printf "You took %d attempts to put the digits in order.\n" !n;
;;
Functional
let revert li n =
let rec aux acc i = function
| [] -> acc
| xs when i <= 0 -> acc @ xs
| x::xs -> aux (x::acc) (pred i) xs
in
aux [] n li
let take li n =
let rec aux acc i = function
| x::xs when i = n -> (x, List.rev_append acc xs)
| x::xs -> aux (x::acc) (succ i) xs
| _ -> invalid_arg "take"
in
aux [] 0 li
let shuffle li =
let rec aux acc len = function
| [] -> acc
| li ->
let x, xs = take li (Random.int len) in
aux (x::acc) (pred len) xs
in
aux [] (List.length li) li
let rec sorted = function
| [] -> (true)
| x::y::_ when x > y -> (false)
| x::xs -> sorted xs
let () =
print_endline "\
Number Reversal Game
Sort the numbers in ascending order by repeatedly
flipping sets of numbers from the left.";
Random.self_init();
let li = shuffle [1; 2; 3; 4; 5; 6; 7; 8; 9] in
let rec loop n li =
Printf.printf "#%2d: " n;
List.iter (Printf.printf " %d") li;
Printf.printf " ? %!";
let r = read_int() in
let li = revert li r in
if not(sorted li)
then loop (succ n) li
else Printf.printf "You took %d attempts to put the digits in order.\n" n;
in
loop 1 li
;;
Oforth
import: console
: reversalGame
| l n |
doWhile: [
ListBuffer new ->l
while(l size 9 <>) [ 9 rand dup l include ifFalse: [ l add ] else: [ drop ] ]
l sort l ==
]
0 while(l sort l <>) [
System.Out "List is " << l << " ==> how many digits from left to reverse : " <-
System.Console askln asInteger dup ifNull: [ drop continue ] ->n
1+ l left(n) reverse l right(l size n -) + ->l
]
"You won ! Your score is :" . println ;
- Output:
>reversalGame List is [9, 1, 3, 6, 5, 7, 8, 4, 2] ==> how many digits from left to reverse : 9 List is [2, 4, 8, 7, 5, 6, 3, 1, 9] ==> how many digits from left to reverse : 3 List is [8, 4, 2, 7, 5, 6, 3, 1, 9] ==> how many digits from left to reverse : 8 List is [1, 3, 6, 5, 7, 2, 4, 8, 9] ==> how many digits from left to reverse : 5 List is [7, 5, 6, 3, 1, 2, 4, 8, 9] ==> how many digits from left to reverse : 7 List is [4, 2, 1, 3, 6, 5, 7, 8, 9] ==> how many digits from left to reverse : 5 List is [6, 3, 1, 2, 4, 5, 7, 8, 9] ==> how many digits from left to reverse : 6 List is [5, 4, 2, 1, 3, 6, 7, 8, 9] ==> how many digits from left to reverse : 5 List is [3, 1, 2, 4, 5, 6, 7, 8, 9] ==> how many digits from left to reverse : 3 List is [2, 1, 3, 4, 5, 6, 7, 8, 9] ==> how many digits from left to reverse : 2 You won ! Your score is : 10
Oz
declare
proc {Main}
proc {Loop N Xs}
if {Not {IsSorted Xs}} then
Num NewXs
in
{System.printInfo N#": "}
{System.print Xs}
{System.printInfo " -- Reverse how many? "}
Num = {String.toInt {ReadLine}}
NewXs = {Append
{Reverse {List.take Xs Num}}
{List.drop Xs Num}}
{Loop N+1 NewXs}
else
{System.showInfo "You took "#N#" tries to put the digits in order."}
end
end
fun {EnsureShuffled Xs}
Ys = {Shuffle Xs}
in
if {Not {IsSorted Ys}} then Ys
else {EnsureShuffled Xs}
end
end
in
{Loop 0 {EnsureShuffled {List.number 1 9 1}}}
end
fun {IsSorted Xs}
{Sort Xs Value.'<'} == Xs
end
local
class TextFile from Open.file Open.text end
StdIn = {New TextFile init(name:stdin)}
in
fun {ReadLine}
{StdIn getS($)}
end
end
fun {Shuffle Xs}
{FoldL Xs
fun {$ Z _}
{Pick {Diff Xs Z}}|Z
end
nil}
end
fun {Pick Xs}
{Nth Xs {OS.rand} mod {Length Xs} + 1}
end
fun {Diff Xs Ys}
{FoldL Ys List.subtract Xs}
end
in
{Main}
PARI/GP
game()={
my(v=numtoperm(9,random(9!-1)),score,in,t); \\ Create vector with 1..9, excluding the one sorted in ascending order
while(v!=vecsort(v),
print(concat(concat([""],v)));
in=input();
for(i=0,in\2-1,
t=v[9-i];
v[9-i]=v[10-in+i];
v[10-in+i]=t
);
score++
);
score
};
Pascal
program NumberReversalGame;
procedure PrintList(list: array of integer);
var
i: integer;
begin
for i := low(list) to high(list) do
begin
Write(list[i]);
if i < high(list) then Write(', ');
end;
WriteLn;
end;
procedure Swap(var list: array of integer; i, j: integer);
var
buf: integer;
begin
buf := list[i];
list[i] := list[j];
list[j] := buf;
end;
procedure ShuffleList(var list: array of integer);
var
i, j, n: integer;
begin
Randomize;
for n := 0 to 99 do
begin
i := Random(high(list)+1);
j := Random(high(list)+1);
Swap(list, i, j);
end;
end;
procedure ReverseList(var list: array of integer; j: integer);
var
i: integer;
begin
i := low(list);
while i < j do
begin
Swap(list, i, j);
i += 1;
j -= 1;
end;
end;
function IsOrdered(list: array of integer): boolean;
var
i: integer;
begin
IsOrdered := true;
i:= high(list);
while i > 0 do
begin
if list[i] <> (list[i-1] + 1) then
begin
IsOrdered:= false;
break;
end;
i -= 1;
end;
end;
var
list: array [0..8] of integer = (1, 2, 3, 4, 5, 6, 7, 8, 9);
n: integer;
moves: integer;
begin
WriteLn('Number Reversal Game');
WriteLn;
WriteLn('Sort the following list in ascending order by reversing the first n digits');
WriteLn('from the left.');
WriteLn;
ShuffleList(list);
PrintList(list);
moves := 0;
while not IsOrdered(list) do
begin
WriteLn('How many digits from the left will you reverse?');
Write('> ');
Read(n);
ReverseList(list, n-1);
PrintList(list);
moves += 1;
end;
WriteLn;
WriteLn('Congratulations you made it in just ', moves, ' moves!');
WriteLn;
end.
Perl
use List::Util qw(shuffle);
my $turn = 0;
my @jumble = shuffle 1..9;
while ( join('', @jumble) eq '123456789' ) {
@jumble = shuffle 1..9;
}
until ( join('', @jumble) eq '123456789' ) {
$turn++;
printf "%2d: @jumble - Flip how many digits ? ", $turn;
my $d = <>;
@jumble[0..$d-1] = reverse @jumble[0..$d-1];
}
print " @jumble\n";
print "You won in $turn turns.\n";
Output:
1: 9 8 2 5 1 7 6 3 4 - Flip how many digits ? 9 2: 4 3 6 7 1 5 2 8 9 - Flip how many digits ? 4 3: 7 6 3 4 1 5 2 8 9 - Flip how many digits ? 7 4: 2 5 1 4 3 6 7 8 9 - Flip how many digits ? 2 5: 5 2 1 4 3 6 7 8 9 - Flip how many digits ? 5 6: 3 4 1 2 5 6 7 8 9 - Flip how many digits ? 2 7: 4 3 1 2 5 6 7 8 9 - Flip how many digits ? 4 8: 2 1 3 4 5 6 7 8 9 - Flip how many digits ? 2 1 2 3 4 5 6 7 8 9 You won in 8 turns.
Phix
Simplified copy of Euphoria
puts(1,"Given a jumbled list of the numbers 1 to 9,\n")
puts(1,"you must select how many digits from the left to reverse.\n")
puts(1,"Your goal is to get the digits in order with 1 on the left and 9 on the right.\n")
constant inums = tagset(9)
sequence nums
integer turns = 0, flip
while 1 do
nums = shuffle(inums)
if nums!=inums then exit end if
end while
while 1 do
printf(1,"%2d : %d %d %d %d %d %d %d %d %d ",turns&nums)
if nums=inums then exit end if
flip = prompt_number(" -- How many numbers should be flipped? ",{1,9})
nums[1..flip] = reverse(nums[1..flip])
turns += 1
end while
printf(1,"\nYou took %d turns to put the digits in order.", turns)
- Output:
Given a jumbled list of the numbers 1 to 9, you must select how many digits from the left to reverse. Your goal is to get the digits in order with 1 on the left and 9 on the right. 0 : 3 7 8 1 6 2 5 4 9 -- How many numbers should be flipped? 3 1 : 8 7 3 1 6 2 5 4 9 -- How many numbers should be flipped? 8 2 : 4 5 2 6 1 3 7 8 9 -- How many numbers should be flipped? 4 3 : 6 2 5 4 1 3 7 8 9 -- How many numbers should be flipped? 6 4 : 3 1 4 5 2 6 7 8 9 -- How many numbers should be flipped? 4 5 : 5 4 1 3 2 6 7 8 9 -- How many numbers should be flipped? 5 6 : 2 3 1 4 5 6 7 8 9 -- How many numbers should be flipped? 2 7 : 3 2 1 4 5 6 7 8 9 -- How many numbers should be flipped? 3 8 : 1 2 3 4 5 6 7 8 9 You took 8 turns to put the digits in order.
PHP
class ReversalGame {
private $numbers;
public function __construct() {
$this->initialize();
}
public function play() {
$i = 0;
$moveCount = 0;
while (true) {
echo json_encode($this->numbers) . "\n";
echo "Please enter an index to reverse from 2 to 9. Enter 99 to quit\n";
$i = intval(rtrim(fgets(STDIN), "\n"));
if ($i == 99) {
break;
}
if ($i < 2 || $i > 9) {
echo "Invalid input\n";
} else {
$moveCount++;
$this->reverse($i);
if ($this->isSorted()) {
echo "Congratulations you solved this in $moveCount moves!\n";
break;
}
}
}
}
private function reverse($position) {
array_splice($this->numbers, 0, $position, array_reverse(array_slice($this->numbers, 0, $position)));
}
private function isSorted() {
for ($i = 0; $i < count($this->numbers) - 1; ++$i) {
if ($this->numbers[$i] > $this->numbers[$i + 1]) {
return false;
}
}
return true;
}
private function initialize() {
$this->numbers = range(1, 9);
while ($this->isSorted()) {
shuffle($this->numbers);
}
}
}
$game = new ReversalGame();
$game->play();
PicoLisp
(load "@lib/simul.l")
(de reversalGame ()
(let (Lst (shuffle (range 1 9)) Cnt 0)
(while (apply < Lst)
(setq Lst (shuffle Lst)) )
(loop
(printsp Lst)
(T (apply < Lst) Cnt)
(NIL (num? (read)))
(setq Lst (flip Lst @))
(inc 'Cnt) ) ) )
Output:
: (reversalGame) (1 7 6 8 4 2 3 5 9) 4 (8 6 7 1 4 2 3 5 9) 8 (5 3 2 4 1 7 6 8 9) 6 (7 1 4 2 3 5 6 8 9) 7 (6 5 3 2 4 1 7 8 9) 6 (1 4 2 3 5 6 7 8 9) 2 (4 1 2 3 5 6 7 8 9) 4 (3 2 1 4 5 6 7 8 9) 3 (1 2 3 4 5 6 7 8 9) -> 8
PL/I
digits: procedure options (main); /* 23 April 2010 */
declare s character (9) varying;
declare i fixed binary;
declare digit character (1);
restart:
put skip list ('In this game, you are given a group of digits.');
put skip list ('You will specify one of those digits.');
put skip list ('The computer will then reverse the digits up to the one you nominate.');
put skip list ('Your task is to repeat this process a number of times until all the digits');
put skip list ('are in order, left to right, 1 to 9.');
put skip list ('Here are your digits');
redo:
s = '';
do until (length(s) = 9);
digit = trim ( fixed(trunc (1+random()*9) ) );
if index(s, digit) = 0 then s = s || digit;
end;
if s = '123456789' then go to redo;
loop:
do forever;
put skip list (s);
if s = '123456789' then leave;
get edit (digit) (a(1));
i = index(s, digit);
if i = 0 then do; put skip list ('invalid request'); iterate loop; end;
s = reverse( substr(s, 1, i) ) || substr(s, i+1, length(s)-i);
end;
put skip list ('Congratulations');
go to restart;
end digits;
PowerShell
#adding the below function to the previous users submission to prevent the small
#chance of getting an array that is in ascending order.
#Full disclosure: I am an infrastructure engineer, not a dev. My code is likely
#bad.
function generateArray{
$fArray = 1..9 | Get-Random -Count 9
if (-join $fArray -eq -join @(1..9)){
generateArray
}
return $fArray
}
$array = generateArray
#everything below is untouched from original submission
$nTries = 0
While(-join $Array -ne -join @(1..9)){
$nTries++
$nReverse = Read-Host -Prompt "[$Array] -- How many digits to reverse? "
[Array]::Reverse($Array,0,$nReverse)
}
"$Array"
"Your score: $nTries"
Prolog
play :- random_numbers(L), do_turn(0,L), !.
do_turn(N, L) :-
print_list(L),
how_many_to_flip(F),
flip(L,F,[],Lnew),
succ(N,N1),
sorted(N1,Lnew).
how_many_to_flip(F) :-
read_line_to_codes(user_input, Line),
number_codes(F, Line),
between(1,9,F).
flip(L,0,C,R) :- append(C,L,R).
flip([Ln|T],N,C,R) :- dif(N,0), succ(N0,N), flip(T,N0,[Ln|C],R).
sorted(N,L) :-
sort(L,L)
-> print_list(L), format('-> ~p~n', N)
; do_turn(N,L).
random_numbers(L) :- random_permutation([1,2,3,4,5,6,7,8,9],L).
print_list(L) :-
atomic_list_concat(L, ' ', Lf),
format('(~w) ',Lf).
- Output:
?- play. (5 1 8 4 3 6 7 9 2) 8 (9 7 6 3 4 8 1 5 2) 5 (4 3 6 7 9 8 1 5 2) 6 (8 9 7 6 3 4 1 5 2) 2 (9 8 7 6 3 4 1 5 2) 9 (2 5 1 4 3 6 7 8 9) 2 (5 2 1 4 3 6 7 8 9) 3 (1 2 5 4 3 6 7 8 9) 5 (3 4 5 2 1 6 7 8 9) 2 (4 3 5 2 1 6 7 8 9) 3 (5 3 4 2 1 6 7 8 9) 2 (3 5 4 2 1 6 7 8 9) 3 (4 5 3 2 1 6 7 8 9) 2 (5 4 3 2 1 6 7 8 9) 5 (1 2 3 4 5 6 7 8 9) -> 14 true.
PureBasic
Dim MyList(9)
Declare is_list_sorted()
If OpenConsole()
Define score, indata, i, txt$
For i=1 To 9 ;- Initiate the list
MyList(i)=i
Next
While is_list_sorted()
For i=1 To 9 ;- Do a Fisher–Yates shuffle
Swap MyList(i), MyList(Random(i)+1)
Next
Wend
;- Start the Game
Repeat
score+1
txt$=RSet(str(score), 3)+": " ;- Show current list
For i=1 To 9
txt$+str(MyList(i))+" "
Next
Repeat ;- Get input & swap
Print(txt$+"| How many numbers should be flipped? "): indata=Val(Input())
Until indata>=1 And indata<=9 ;- Verify the input
For i=1 To (indata/2)
Swap MyList(i),MyList(indata-i+1)
Next
Until is_list_sorted()
;- Present result & wait for users input before closing down
PrintN(#CRLF$+"You did it in "+str(score)+" moves")
Print("Press ENTER to exit"): Input()
CloseConsole()
EndIf
Procedure is_list_sorted()
Protected i
Shared MyList()
For i=1 To 9
If MyList(i)<>i
ProcedureReturn #False
EndIf
Next
ProcedureReturn #True
EndProcedure
Python
'''
number reversal game
Given a jumbled list of the numbers 1 to 9
Show the list.
Ask the player how many digits from the left to reverse.
Reverse those digits then ask again.
until all the digits end up in ascending order.
'''
import random
print(__doc__)
data, trials = list('123456789'), 0
while data == sorted(data):
random.shuffle(data)
while data != sorted(data):
trials += 1
flip = int(input('#%2i: LIST: %r Flip how many?: ' % (trials, ' '.join(data))))
data[:flip] = reversed(data[:flip])
print('\nYou took %2i attempts to put the digits in order!' % trials)
Sample output:
number reversal game Given a jumbled list of the numbers 1 to 9 Show the list. Ask the player how many digits from the left to reverse. Reverse those digits then ask again. until all the digits end up in ascending order. # 1: LIST: '1 3 9 2 7 5 4 8 6' Flip how many?: 9 # 2: LIST: '6 8 4 5 7 2 9 3 1' Flip how many?: 6 # 3: LIST: '2 7 5 4 8 6 9 3 1' Flip how many?: 8 # 4: LIST: '3 9 6 8 4 5 7 2 1' Flip how many?: 7 # 5: LIST: '7 5 4 8 6 9 3 2 1' Flip how many?: 3 # 6: LIST: '4 5 7 8 6 9 3 2 1' Flip how many?: 6 # 7: LIST: '9 6 8 7 5 4 3 2 1' Flip how many?: 2 # 8: LIST: '6 9 8 7 5 4 3 2 1' Flip how many?: 4 # 9: LIST: '7 8 9 6 5 4 3 2 1' Flip how many?: 3 #10: LIST: '9 8 7 6 5 4 3 2 1' Flip how many?: 9 You took 10 attempts to put the digits in order!
Quackery
[ 0 temp put
[] 9 times
[ i^ 1+ join ]
dup
[ shuffle 2dup != until ]
[ dup echo cr
2dup != while
[ $ "Reverse how many? "
input
$->n not iff
drop again ]
split dip reverse join
1 temp tally
again ]
drop cr
say "That took "
temp take echo
say " reversals." ] is play ( --> )
- Output:
Playing in the Quackery shell.
/O> play ... [ 8 6 5 9 4 1 7 2 3 ] Reverse how many? 3 [ 5 6 8 9 4 1 7 2 3 ] Reverse how many? 4 [ 9 8 6 5 4 1 7 2 3 ] Reverse how many? 9 [ 3 2 7 1 4 5 6 8 9 ] Reverse how many? 3 [ 7 2 3 1 4 5 6 8 9 ] Reverse how many? 7 [ 6 5 4 1 3 2 7 8 9 ] Reverse how many? 6 [ 2 3 1 4 5 6 7 8 9 ] Reverse how many? 2 [ 3 2 1 4 5 6 7 8 9 ] Reverse how many? 3 [ 1 2 3 4 5 6 7 8 9 ] That took 8 reversals.
R
reversalGame <- function(){
cat("Welcome to the Number Reversal Game! \n")
cat("Sort the numbers into ascending order by repeatedly \n",
"reversing the first n digits, where you specify n. \n \n", sep="")
# Generate a list that's definitely not in ascending order, per instuctions
data <- sample(1:9, 9)
while (all(data == 1:9)){
cat("What were the chances...? \n")
data <- sample(1:9, 9)
}
trials <- 0
# Play the game
while (any(data != 1:9)){
trials <- trials + 1
cat("Trial", sprintf("%02d", trials), " # ", data, " # ")
answer <- readline(paste("Flip how many? "))
data[1:answer] <- data[answer:1]
}
# Victory!
cat("Well done. You needed", trials, "flips. \n")
}
Sample output:
>reversalGame()
Welcome to the Number Reversal Game!
Sort the numbers into ascending order by repeatedly
reversing the first n digits, where you specify n.
Trial 01 # 4 3 2 1 7 9 8 5 6 # Flip how many? 7
Trial 02 # 8 9 7 1 2 3 4 5 6 # Flip how many? 2
Trial 03 # 9 8 7 1 2 3 4 5 6 # Flip how many? 9
Trial 04 # 6 5 4 3 2 1 7 8 9 # Flip how many? 6
Well done. You needed 4 flips.
Racket
#lang racket
(let loop ([nums (range 1 10)] [n 0])
(cond [(apply < nums) (if (zero? n)
(loop (shuffle nums) 0)
(printf "Done in ~s steps.\n" n))]
[else (printf "Step #~s: ~s\nFlip how many? " n nums)
(define-values (l r) (split-at nums (read)))
(loop (append (reverse l) r) (add1 n))]))
Raku
(formerly Perl 6)
Do-at-least-once loops are fairly rare, but this program wants to have two of them. We use the built-in .pick(*) method to shuffle the numbers. We use .= to dispatch a mutating method in two spots; the first is just a different way to write ++, while the second of these reverses an array slice in place. The [<] is a reduction operator on less than, so it returns true if the elements of the list are strictly ordered. We also see in the first repeat loop that, although the while condition is not tested till after the loop, the while condition can in fact declare the variable that will be initialized the first time through the loop, which is a neat trick, and not half unreadable once you get used to it.
repeat while [<] my @jumbled-list {
@jumbled-list = (1..9).pick(*)
}
my $turn = 0;
repeat until [<] @jumbled-list {
my $d = prompt $turn.=succ.fmt('%2d: ') ~
@jumbled-list ~
" - Flip how many digits? "
or exit;
@jumbled-list[^$d] .= reverse;
}
say " @jumbled-list[]";
say "You won in $turn turns.";
Output:
1: 3 5 8 2 7 9 6 1 4 - Flip how many digits ? 6 2: 9 7 2 8 5 3 6 1 4 - Flip how many digits ? 9 3: 4 1 6 3 5 8 2 7 9 - Flip how many digits ? 6 4: 8 5 3 6 1 4 2 7 9 - Flip how many digits ? 8 5: 7 2 4 1 6 3 5 8 9 - Flip how many digits ? 7 6: 5 3 6 1 4 2 7 8 9 - Flip how many digits ? 3 7: 6 3 5 1 4 2 7 8 9 - Flip how many digits ? 6 8: 2 4 1 5 3 6 7 8 9 - Flip how many digits ? 4 9: 5 1 4 2 3 6 7 8 9 - Flip how many digits ? 5 10: 3 2 4 1 5 6 7 8 9 - Flip how many digits ? 3 11: 4 2 3 1 5 6 7 8 9 - Flip how many digits ? 4 12: 1 3 2 4 5 6 7 8 9 - Flip how many digits ? 2 13: 3 1 2 4 5 6 7 8 9 - Flip how many digits ? 3 14: 2 1 3 4 5 6 7 8 9 - Flip how many digits ? 2 1 2 3 4 5 6 7 8 9 You won in 14 turns.
Rascal
import Prelude;
import vis::Figure;
import vis::Render;
public void NumberReversalGame(){
//generate randomlist
L = [1..9];
score = 0;
randomlist = [];
while (L != []){
temp = takeOneFrom(L);
randomlist += temp[0];
L = temp[1];
}
// user interaction
score = 0;
text1 = "";
figure =
box(vcat([
box(text(str(){
return "<randomlist>";})),
box(textfield("Insert number of digits you would like to reverse here.",
void(str s){
score += 1;
n = toInt(s);
spliced = slice(randomlist, 0, n);
randomlist = reverse(spliced) + (randomlist - spliced);
},
fillColor("lightblue"))),
box(text(str(){
return ((randomlist == [1 .. 9]) ? "Well done! Your score: <score>." : "Keep going!");}))
]));
render(figure);
}
Output:
REBOL
REBOL []
print "NUMBER REVERSAL GAME"
tries: 0
goal: [1 2 3 4 5 6 7 8 9]
random/seed now
until [
jumble: random goal
jumble != goal ; repeat in the unlikely case that jumble isn't jumbled
]
while [jumble != goal] [
prin jumble
prin " How many to flip? "
flip-index: to-integer input ; no validation!
reverse/part jumble flip-index
tries: tries + 1
]
print rejoin ["You took " tries " attempts."]
REXX
This REXX version:
- displays the game's objective and rules
- validates the input (must be a single non-zero decimal digit)
- allows the user to enter quit
- allows the user to halt the game via Cntl-Break (or equivalent)
/*REXX program (a game): reverse a jumbled set of decimal digits 'til they're in order.*/
signal on halt /*allows the CBLF to HALT the program.*/
___= copies('─', 9); pad=left('', 9) /*a fence used for computer's messages.*/
say ___ "This game will show you nine random unique digits (1 ──► 9), and you'll enter"
say ___ "one of those digits which will reverse all the digits from the left-most digit"
say ___ "up to (and including) that decimal digit. The game's objective is to get all"
say ___ "of the digits in ascending order with the fewest tries. Here're your digits:"
ok= 123456789 /*the result that the string should be.*/
$= /* ◄─── decimal target to be generated.*/
do until length($)==9; _=random(1, 9) /*build a random unique numeric string.*/
if pos(_, $) \== 0 then iterate /*¬ unique? Only use a decimal dig once*/
$=$ || _ /*construct a string of unique digits. */
if $==ok then $= /*string can't be in order, start over.*/
end /*until*/
do score=1 until $==ok; say /* [↓] display the digits & the prompt*/
say ___ $ right('please enter a digit (or Quit):', 50)
parse pull ox . 1 ux . 1 x .; upper ux /*get a decimal digit (maybe) from CBLF*/
if abbrev('QUIT', ux, 1) then signal halt /*does the CBLF want to quit this game?*/
if length(x)>1 then do; say ___ pad '***error*** invalid input: ' ox; iterate; end
if x='' then iterate /*try again, CBLF didn't enter anything*/
g=pos(x, $) /*validate if the input digit is legal.*/
if g==0 then say ___ pad '***error*** invalid digit: ' ox
else $=strip(reverse(left($,g))substr($,g+1)) /*reverse some (or all) digits*/
end /*score*/
say; say ___ $; say; say center(' Congratulations! ', 70, "═"); say
say ___ pad 'Your score was' score; exit /*stick a fork in it, we're all done. */
halt: say ___ pad 'quitting.'; exit /* " " " " " " " " */
{{out|output|text= from playing one game of the number reversal game:
───────── This game will show you nine random unique digits (1 ──► 9), and you'll enter ───────── one of those digits which will reverse all the digits from the left-most digit ───────── up to (and including) that decimal digit. The game's objective is to get all ───────── of the digits in ascending order with the fewest tries. Here're your digits: ───────── 613279548 please enter a digit (or Quit): 5 ◄■■■■■■■■■ user input ───────── 597231648 please enter a digit (or Quit): 9 ◄■■■■■■■■■ user input ───────── 957231648 please enter a digit (or Quit): 8 ◄■■■■■■■■■ user input ───────── 846132759 please enter a digit (or Quit): 5 ◄■■■■■■■■■ user input ───────── 572316489 please enter a digit (or Quit): 7 ◄■■■■■■■■■ user input ───────── 752316489 please enter a digit (or Quit): 4 ◄■■■■■■■■■ user input ───────── 461325789 please enter a digit (or Quit): 6 ◄■■■■■■■■■ user input ───────── 641325789 please enter a digit (or Quit): 5 ◄■■■■■■■■■ user input ───────── 523146789 please enter a digit (or Quit): 4 ◄■■■■■■■■■ user input ───────── 413256789 please enter a digit (or Quit): 2 ◄■■■■■■■■■ user input ───────── 231456789 please enter a digit (or Quit): 3 ◄■■■■■■■■■ user input ───────── 321456789 please enter a digit (or Quit): 1 ◄■■■■■■■■■ user input ───────── 123456789 ══════════════════════════ Congratulations! ══════════════════════════ ───────── Your score was 12
Ring
# Project : Number reversal game
rever = 1:9
leftrever = []
for n = 1 to len(rever)
rnd = random(8) + 1
temp = rever[n]
rever[n] = rever[rnd]
rever[rnd] = temp
next
see rever
see nl
while true
num = 0
leftrever = []
showarray(rever)
see " : Reverse how many = "
give r
r = number(r)
for n = 1 to r
add(leftrever, rever[n])
next
leftrever = reverse(leftrever)
for pos = 1 to r
rever[pos] = leftrever[pos]
next
for m = 1 to len(rever)
if rever[m] = m
num = num + 1
ok
next
if num = len(rever)
exit
ok
end
see "You took " + num + " attempts." + nl
func swap(a, b)
temp = a
a = b
b = temp
return [a, b]
func showarray(vect)
svect = ""
for n = 1 to len(vect)
svect = svect + vect[n] + " "
next
svect = left(svect, len(svect) - 1)
see svect
Output:
7 2 3 1 5 8 6 4 9 : Reverse how many? 6 8 5 1 3 2 7 6 4 9 : Reverse how many? 8 4 6 7 2 3 1 5 8 9 : Reverse how many? 3 7 6 4 2 3 1 5 8 9 : Reverse how many? 7 5 1 3 2 4 6 7 8 9 : Reverse how many? 5 4 2 3 1 5 6 7 8 9 : Reverse how many? 4 1 3 2 4 5 6 7 8 9 : Reverse how many? 3 2 3 1 4 5 6 7 8 9 : Reverse how many? 2 3 2 1 4 5 6 7 8 9 : Reverse how many? 3 You took 9 attempts.
Ruby
ary = (1..9).to_a
ary.shuffle! while ary == ary.sort
score = 0
until ary == ary.sort
print "#{ary.inspect} -- How many digits to reverse? "
num = gets.to_i # should validate input
ary[0, num] = ary[0, num].reverse
score += 1
end
p ary
puts "Your score: #{score}"
sample output:
$ ruby number_reversal_game.rb [4, 2, 1, 8, 7, 6, 3, 5, 9] -- How many digits to reverse? 4 [8, 1, 2, 4, 7, 6, 3, 5, 9] -- How many digits to reverse? 8 [5, 3, 6, 7, 4, 2, 1, 8, 9] -- How many digits to reverse? 4 [7, 6, 3, 5, 4, 2, 1, 8, 9] -- How many digits to reverse? 7 [1, 2, 4, 5, 3, 6, 7, 8, 9] -- How many digits to reverse? 4 [5, 4, 2, 1, 3, 6, 7, 8, 9] -- How many digits to reverse? 5 [3, 1, 2, 4, 5, 6, 7, 8, 9] -- How many digits to reverse? 3 [2, 1, 3, 4, 5, 6, 7, 8, 9] -- How many digits to reverse? 2 [1, 2, 3, 4, 5, 6, 7, 8, 9] Your score: 8
Run BASIC
for i = 1 to 9 ' get numbers 1 to 9
n(i) = i
next i
numShuffles = 3
' ----------------------------------
' shuffle numbers
' ----------------------------------
for i = 1 to 9 * numShuffles
i1 = int(rnd(1)*9) + 1
i2 = int(rnd(1)*9) + 1
h2 = n(i1)
n(i1) = n(i2)
n(i2) = h2
next i
for i = 1 to 9
a$ = a$ + str$(n(i)) + " "
next i
count = 0
[loop]
count = count + 1
print count;" : ";a$
for i = 1 to 9 ' check if in sequence
j = i * 2
if mid$(a$,j-1,1) > mid$(a$,j,1) then goto [notOrdered]
next i
print "It took ";count;" tries"
end
[notOrdered]
input "How many numbers to flip:";i
i = ((i-1) * 2) + 1
b$ = ""
for j = i to 1 step -2
b$ = b$ + mid$(a$,j,2)
next j
a$ = b$ + mid$(a$,i + 2)
goto [loop]
end
Rust
use rand::prelude::*;
use std::io::stdin;
fn is_sorted(seq: &[impl PartialOrd]) -> bool {
if seq.len() < 2 {
return true;
}
// Look for any instance where the previous number is larger than the following
!seq.iter()
.zip(seq[1..].iter())
.any(|(prev, foll)| prev > foll)
}
fn main() {
println!(
"Number reversal game:
Given a jumbled list of the numbers 1 to 9, put the numbers in order.
Each attempt you can reverse up to n digits starting from the left.
The score is the count of the reversals needed to attain the ascending order."
);
let mut rng = thread_rng();
let mut sequence: Vec<u8> = (1..10).collect();
while is_sorted(&sequence) {
sequence.shuffle(&mut rng);
}
let mut attempt = 1;
while !is_sorted(&sequence) {
println!(
"Attempt {}: {:?} - How many numbers do you want to flip?",
attempt, sequence
);
let flip = {
let mut input = String::new();
stdin().read_line(&mut input).unwrap();
input.trim().parse().unwrap()
};
sequence[..flip].reverse();
attempt += 1;
}
println!(
"Congrats! It took you {} attempts to sort the sequence.",
attempt - 1 // Remove additionally counted attempt
);
}
- Output:
Number reversal game: Given a jumbled list of the numbers 1 to 9, put the numbers in order. Each attempt you can reverse up to n digits starting from the left. The score is the count of the reversals needed to attain the ascending order. Attempt 1: [7, 1, 6, 2, 3, 4, 5, 8, 9] - How many numbers do you want to flip? 7 Attempt 2: [5, 4, 3, 2, 6, 1, 7, 8, 9] - How many numbers do you want to flip? 5 Attempt 3: [6, 2, 3, 4, 5, 1, 7, 8, 9] - How many numbers do you want to flip? 6 Attempt 4: [1, 5, 4, 3, 2, 6, 7, 8, 9] - How many numbers do you want to flip? 2 Attempt 5: [5, 1, 4, 3, 2, 6, 7, 8, 9] - How many numbers do you want to flip? 5 Attempt 6: [2, 3, 4, 1, 5, 6, 7, 8, 9] - How many numbers do you want to flip? 3 Attempt 7: [4, 3, 2, 1, 5, 6, 7, 8, 9] - How many numbers do you want to flip? 4 Congrats! It took you 7 attempts to sort the sequence.
Scala
object NumberReversalGame extends App {
def play(n: Int, cur: List[Int], goal: List[Int]) {
readLine(s"""$n. ${cur mkString " "} How many to flip? """) match {
case null => println
case s => scala.util.Try(s.toInt) match {
case scala.util.Success(i) if i > 0 && i <= cur.length =>
(cur.take(i).reverse ++ cur.drop(i)) match {
case done if done == goal =>
println(s"Congratulations! You solved "+goal.mkString(" "))
println(s"Your score is $n (lower is better)")
case next => play(n + 1, next, goal)
}
case _ => println(s"Choose a number between 1 and ${cur.length}")
play(n + 1, cur, goal)
}
}
}
def play(size: Int) {
val goal = List.range(1, size + 1)
def init: List[Int] = scala.util.Random.shuffle(goal) match {
case repeat if repeat == goal => init
case done => done
}
play(1, init, goal)
}
play(9)
}
- Output:
1. 8 4 2 9 6 3 7 5 1 How many to flip? 3 2. 2 4 8 9 6 3 7 5 1 How many to flip? 8 3. 5 7 3 6 9 8 4 2 1 How many to flip? 3 4. 3 7 5 6 9 8 4 2 1 How many to flip? 7 5. 4 8 9 6 5 7 3 2 1 How many to flip? 6 6. 7 5 6 9 8 4 3 2 1 How many to flip? 2 7. 5 7 6 9 8 4 3 2 1 How many to flip? 5 8. 8 9 6 7 5 4 3 2 1 How many to flip? 3 9. 6 9 8 7 5 4 3 2 1 How many to flip? 4 10. 7 8 9 6 5 4 3 2 1 How many to flip? 3 11. 9 8 7 6 5 4 3 2 1 How many to flip? 9 Congratulations! You solved 1 2 3 4 5 6 7 8 9 Your score is 11 (lower is better)
Scheme
(import (scheme base)
(scheme read)
(scheme write)
(srfi 1) ; list functions
(srfi 27)) ; random numbers
(random-source-randomize! default-random-source)
(define (make-randomised-list)
(let ((vec (apply vector (iota 9 1))))
(do ((c 0 (+ 1 c)))
((and (>= c 20) ; at least 20 tries
(not (apply < (vector->list vec)))) ; ensures list not in order
(vector->list vec))
(let* ((i (random-integer 9)) ; swap two randomly chosen elements
(j (random-integer 9))
(tmp (vector-ref vec i)))
(vector-set! vec i (vector-ref vec j))
(vector-set! vec j tmp)))))
(define (play-game lst plays)
(define (reverse-first n lst)
(let-values (((start tail) (split-at lst n)))
(append (reverse start) tail)))
;
(display "List: ") (display lst) (newline)
(display "How many numbers should be flipped? ")
(let* ((flip (string->number (read-line)))
(new-lst (reverse-first flip lst)))
(if (apply < new-lst)
(display (string-append "Finished in "
(number->string plays)
" attempts\n"))
(play-game new-lst (+ 1 plays)))))
(play-game (make-randomised-list) 1)
- Output:
List: (1 8 3 4 9 2 7 5 6) How many numbers should be flipped? 5 List: (9 4 3 8 1 2 7 5 6) How many numbers should be flipped? 9 List: (6 5 7 2 1 8 3 4 9) How many numbers should be flipped? 6 List: (8 1 2 7 5 6 3 4 9) How many numbers should be flipped? 8 List: (4 3 6 5 7 2 1 8 9) How many numbers should be flipped? 5 List: (7 5 6 3 4 2 1 8 9) How many numbers should be flipped? 7 List: (1 2 4 3 6 5 7 8 9) How many numbers should be flipped? 5 List: (6 3 4 2 1 5 7 8 9) How many numbers should be flipped? 6 List: (5 1 2 4 3 6 7 8 9) How many numbers should be flipped? 5 List: (3 4 2 1 5 6 7 8 9) How many numbers should be flipped? 2 List: (4 3 2 1 5 6 7 8 9) How many numbers should be flipped? 4 Finished in 11 attempts
Seed7
$ include "seed7_05.s7i";
const proc: main is func
local
const array integer: sortedList is [] ( 1, 2, 3, 4, 5, 6, 7, 8, 9);
var array integer: list is 0 times 0;
var array integer: reversedList is 0 times 0;
var integer: score is 0;
var integer: index is 0;
var integer: number is 0;
var integer: reverse is 0;
begin
for number range sortedList do
index := rand(1, succ(length(list)));
list := list[.. pred(index)] & [] (number) & list[index ..];
end for;
repeat
write("Current list: ");
for number range list do
write(number <& " ");
end for;
repeat
write(" Digits to reverse? ");
readln(reverse);
if reverse < 2 or reverse > 9 then
write("Please enter a value between 2 and 9.");
end if;
until reverse >= 2 and reverse <= 9;
incr(score);
reversedList := 0 times 0;
for index range reverse downto 1 do
reversedList &:= list[index];
end for;
list := reversedList & list[succ(reverse) ..];
until list = sortedList;
writeln("Congratulations, you sorted the list in " <& score <& " reversals.");
end func;
- Output:
Current list: 7 6 2 9 1 3 4 5 8 Digits to reverse? 4 Current list: 9 2 6 7 1 3 4 5 8 Digits to reverse? 9 Current list: 8 5 4 3 1 7 6 2 9 Digits to reverse? 8 Current list: 2 6 7 1 3 4 5 8 9 Digits to reverse? 3 Current list: 7 6 2 1 3 4 5 8 9 Digits to reverse? 7 Current list: 5 4 3 1 2 6 7 8 9 Digits to reverse? 5 Current list: 2 1 3 4 5 6 7 8 9 Digits to reverse? 2 Congratulations, you sorted the list in 7 reversals.
SenseTalk
// set the initial list of digits
set currentList to 1..9 sorted by random of a million
// make sure we don't start off already sorted
repeat while currentList equals 1..9
sort currentList by random of a million
end repeat
// ask until it is solved
repeat while currentList isn't equal to 1..9
add 1 to numberOfTurns
set headline to "Turn #" & numberOfTurns & ": You have " & currentList joined by empty
ask "How many digits do you want to reverse?" titled headline message "On each turn, specify the number of initial digits to reverse."
if it isn't a number then exit all -- allow the user to exit
sort items 1 to it of currentList descending by the counter
end repeat
answer "You sorted it in " & numberOfTurns & " turns!" titled "Congratulations!"
SETL
program number_reversal_game;
setrandom(0);
tries := 0;
state := shuffled_numbers();
loop until state = "123456789" do
tries +:= 1;
swapat := read_step(tries, state);
state := reverse state(..swapat) + state(swapat+1..);
end loop;
print(state + " - You win in " + str tries + " tries.");
proc read_step(tries, state);
loop until r in [str d : d in [1..9]] do
putchar(state + " - Reverse how many? ");
flush(stdout);
r := getline(stdin);
end loop;
return val r;
end proc;
proc shuffled_numbers();
digits := "123456789";
loop until out /= digits do
dset := {d : d in digits};
out := +/[[d := random dset, dset less:= d](1) : until dset = {}];
end loop;
return out;
end proc;
end program;
- Output:
681934725 - Reverse how many? 4 918634725 - Reverse how many? 9 527436819 - Reverse how many? 7 863472519 - Reverse how many? 8 152743689 - Reverse how many? 4 725143689 - Reverse how many? 7 634152789 - Reverse how many? 6 251436789 - Reverse how many? 2 521436789 - Reverse how many? 5 341256789 - Reverse how many? 2 431256789 - Reverse how many? 4 213456789 - Reverse how many? 2 123456789 - You win in 12 tries.
Sidef
var turn = 0;
var jumble = @(1..9).bshuffle; # best-shuffle
for (turn; jumble != 1..9; ++turn) {
printf("%2d: %s - Flip how many digits ? ", turn, jumble.join(' '));
var d = read(Number) \\ break;
jumble[0 .. d-1] = [jumble[0 .. d-1]].reverse...;
}
print " #{jumble.join(' ')}\n";
print "You won in #{turn} turns.\n";
Tcl
package require Tcl 8.5
# Simple shuffler, not very efficient but good enough for here
proc shuffle list {
set result {}
while {[llength $list]} {
set i [expr {int([llength $list] * rand())}]
lappend result [lindex $list $i]
set list [lreplace $list $i $i]
}
return $result
}
# Returns the list with the prefix of it reversed
proc flipfirst {list n} {
concat [lreverse [lrange $list 0 $n-1]] [lrange $list $n end]
}
# Core game engine; list to play with is optional argument
proc nrgame {{target "1 2 3 4 5 6 7 8 9"}} {
set nums $target
while {$nums eq $target} {set nums [shuffle $nums]}
set goes 0
while {$nums ne $target} {
incr goes
puts -nonewline "#${goes}: List is '[join $nums {, }]', how many to reverse? "
flush stdout
gets stdin n
if {$n eq "q"} {return quit}
# Input validation would go here
set nums [flipfirst $nums $n]
}
return $goes
}
# Print some instructions and wait for the user to win
puts "Welcome to the Number Reversal Game!"
puts "------------------------------------"
puts "I'll show you a list of numbers, you need to reverse prefixes of them"
puts "to get the whole list in ascending order. A 'q' will quit early.\n"
puts ""
set outcome [nrgame]
if {$outcome ne "quit"} {
puts "\nYou took $outcome attempts to put the digits in order."
}
Sample output:
Welcome to the Number Reversal Game! ------------------------------------ I'll show you a list of numbers, you need to reverse prefixes of them to get the whole list in ascending order. A 'q' will quit early. #1: List is '8, 6, 2, 5, 7, 9, 3, 1, 4', how many to reverse? 6 #2: List is '9, 7, 5, 2, 6, 8, 3, 1, 4', how many to reverse? 9 #3: List is '4, 1, 3, 8, 6, 2, 5, 7, 9', how many to reverse? 4 #4: List is '8, 3, 1, 4, 6, 2, 5, 7, 9', how many to reverse? 8 #5: List is '7, 5, 2, 6, 4, 1, 3, 8, 9', how many to reverse? 7 #6: List is '3, 1, 4, 6, 2, 5, 7, 8, 9', how many to reverse? 4 #7: List is '6, 4, 1, 3, 2, 5, 7, 8, 9', how many to reverse? 6 #8: List is '5, 2, 3, 1, 4, 6, 7, 8, 9', how many to reverse? 5 #9: List is '4, 1, 3, 2, 5, 6, 7, 8, 9', how many to reverse? 4 #10: List is '2, 3, 1, 4, 5, 6, 7, 8, 9', how many to reverse? 2 #11: List is '3, 2, 1, 4, 5, 6, 7, 8, 9', how many to reverse? 3 You took 11 attempts to put the digits in order.
True BASIC
RANDOMIZE
PRINT "Dada una lista aleatoria de números del 1 al 9,"
PRINT "indica cuantos dígitos de la izquierda voltear."
PRINT " El objetivo es obtener los dígitos en orden "
PRINT " con el 1 a la izquierda y el 9 a la derecha."
PRINT
DIM nums(1 to 9)
DIM temp(1 to 9)
!valores iniciales
FOR x = 1 to 9
LET nums(x) = x
NEXT x
DO !barajamos
FOR x = 9 to 2 step -1
LET n = round(int(rnd*(x))+1)
IF n <> x then
!swap (nums(n), nums(x)) !no existe comado SWAP
LET temp(n) = nums(x)
LET nums(x) = nums(n)
LET nums(n) = temp(n)
END IF
NEXT x
FOR x = 1 to 8 !nos aseguramos que no estén en orden
IF nums(x) > nums(x+1) then EXIT DO
NEXT x
LOOP
LET denuevo = -1
DO
IF intentos < 10 then PRINT " ";
PRINT intentos; ":";
FOR x = 1 to 9
PRINT nums(x);
NEXT x
IF (not denuevo <> 0) then EXIT DO
INPUT prompt " -- ¿Cuántos volteamos? ": volteo
IF volteo < 0 or volteo > 9 then LET volteo = 0
FOR x = 1 to (ip(volteo/2))
!swap (nums(x), nums(volteo-x+1)) !no existe SWAP
LET temp(n) = nums(volteo-x+1)
LET nums(volteo-x+1) = nums(x)
LET nums(x) = temp(n)
NEXT x
LET denuevo = 0
!comprobamos el orden
FOR x = 1 to 8
IF nums(x) > nums(x+1) then
LET denuevo = -1
EXIT FOR
END IF
NEXT x
IF volteo > 0 then LET intentos = intentos+1
LOOP
PRINT
PRINT
PRINT "Necesitaste "; ltrim$(rtrim$(str$(intentos))); " intentos."
END
TUSCRIPT
$$ MODE TUSCRIPT
numbers=RANDOM_NUMBERS (1,9,9),nr=0
SECTION check
LOOP o,n=numbers
IF (n!=o) THEN
DO PRINT
EXIT
ELSEIF (n==9&&o==9) THEN
DO PRINT
PRINT " You made it ... in round ",r
STOP
ELSE
CYCLE
ENDIF
ENDLOOP
ENDSECTION
SECTION print
PRINT numbers
ENDSECTION
DO PRINT
LOOP r=1,14
IF (nr>=0&&nr<10) THEN
ASK "Reverse - how many?": nr=""
i=""
LOOP n=1,nr
i=APPEND(i,n)
ENDLOOP
numbers =SPLIT (numbers)
reverse_nr=SELECT (numbers,#i,keep_nr), reverse_nr=REVERSE(reverse_nr)
numbers =APPEND (reverse_nr,keep_nr), numbers =JOIN (numbers)
DO check
ENDIF
ENDLOOP
Output:
2'1'7'8'5'6'4'9'3 Reverse - how many? >8 9'4'6'5'8'7'1'2'3 Reverse - how many? >9 3'2'1'7'8'5'6'4'9 Reverse - how many? >5 8'7'1'2'3'5'6'4'9 Reverse - how many? >8 4'6'5'3'2'1'7'8'9 Reverse - how many? >3 5'6'4'3'2'1'7'8'9 Reverse - how many? >2 6'5'4'3'2'1'7'8'9 Reverse - how many? >6 1'2'3'4'5'6'7'8'9 You made it ... in round 7
UNIX Shell
This task becomes easier if your shell has arrays and a random number generator. POSIX shells have not those. If you would do this task with a POSIX shell, then you would pretend arrays with eval, as in eval "\$array_$index=value", and you would implement your own random number generator.
This solution uses the arrays and the random number generator from the Korn shell. It also shows a few other Korn features: the (( )) and [[ ]] commands, the print statement, and some local integer variables in some function.
print "\nWelcome to the number reversal game!\n"
print "You must put the numbers in order from 1 to 9."
print "Your only moves are to reverse groups of numbers"
print "on the left side of the list."
integer list score
# start a new game
function newgame {
integer i j t
# score = number of moves
((score = 0))
# list = array of numbers
set -A list 1 2 3 4 5 6 7 8 9
while true; do
# Knuth shuffle
((i = 9))
while ((i > 1)); do
# get random j from 0 to i - 1
((j = RANDOM))
((j < 32768 % i)) && continue
((j %= i))
# decrement i, swap list[i] with list[j]
((i -= 1))
((t = list[i]))
((list[i] = list[j]))
((list[j] = t))
done
win || break
done
}
# numbers in order?
function win {
integer i
# check if list[0] == 1, list[1] == 2, ...
((i = 0))
while ((i < 9)); do
((list[i] != i + 1)) && return 1
((i += 1))
done
return 0
}
# reverse first $1 elements of list
function reverse {
integer left right t
((left = 0))
((right = $1 - 1))
while ((right > left)); do
((t = list[left]))
((list[left] = list[right]))
((list[right] = t))
((left += 1))
((right -= 1))
done
}
integer i
newgame
while true; do
print -n "\nYour list: "
((i = 0))
while ((i < 8)); do
printf "%d, " ${list[i]}
((i += 1))
done
printf "%d\n" ${list[8]}
if win; then
print "YOU WIN!"
printf "Your score is %d moves.\n" $score
print -n "Would you like to play again (y/n)? "
if read again && [[ $again = @(y|Y)* ]]; then
newgame
else
print "\n\nBye!"
exit
fi
else
print -n "How many numbers to reverse? "
if read i; then
((score += 1))
reverse $i
else
print "\n\nBye!"
exit
fi
fi
done
VBA
Private Function shuffle(ByVal a As Variant) As Variant
Dim t As Variant, i As Integer
For i = UBound(a) To LBound(a) + 1 Step -1
j = Int((UBound(a) - LBound(a) + 1) * Rnd + LBound(a))
t = a(i)
a(i) = a(j)
a(j) = t
Next i
shuffle = a
End Function
Private Sub reverse(ByRef a As Variant, n As Integer)
Dim b As Variant
b = a
For i = 1 To n
a(i) = b(n + 1 - i)
Next i
End Sub
Public Sub game()
Debug.Print "Given a jumbled list of the numbers 1 to 9"
Debug.Print "you must select how many digits from the left to reverse."
Debug.Print "Your goal is to get the digits in order with 1 on the left and 9 on the right."
inums = [{1,2,3,4,5,6,7,8,9}]
Dim nums As Variant
Dim turns As Integer, flip As Integer
shuffled = False
Do While Not shuffled
nums = shuffle(inums)
For i = LBound(nums) To UBound(nums)
If nums(i) <> inums(i) Then
shuffled = True
Exit For
End If
Next i
Loop
Do While True
Debug.Print turns; ":";
For Each x In nums: Debug.Print x;: Next x
Debug.Print
flag = False
For i = LBound(nums) To UBound(nums)
If nums(i) <> inums(i) Then
flag = True
Exit For
End If
Next i
If flag Then
flip = InputBox(" -- How many numbers should be flipped? ")
reverse nums, flip
turns = turns + 1
Else
Exit Do
End If
Loop
Debug.Print "You took"; turns; "turns to put the digits in order."
End Sub
- Output:
Given a jumbled list of the numbers 1 to 9 you must select how many digits from the left to reverse. Your goal is to get the digits in order with 1 on the left and 9 on the right. 0 : 1 4 3 9 8 7 6 2 5 1 : 9 3 4 1 8 7 6 2 5 2 : 5 2 6 7 8 1 4 3 9 3 : 8 7 6 2 5 1 4 3 9 4 : 3 4 1 5 2 6 7 8 9 5 : 5 1 4 3 2 6 7 8 9 6 : 2 3 4 1 5 6 7 8 9 7 : 4 3 2 1 5 6 7 8 9 8 : 1 2 3 4 5 6 7 8 9 You took 8 turns to put the digits in order.
V (Vlang)
import rand
import os
fn main() {
mut score, mut rnum := 0, 0
mut mix, mut unmix := []int{}, []int{}
for mix.len < 9 {
rnum = rand.int_in_range(1, 10) or {println('Error: invalid number') exit(1)}
if mix.contains(rnum) == false {
mix << rnum
}
}
unmix = mix.clone()
unmix.sort()
println("Select how many digits from the left to reverse.")
for {
print("The list is: ${mix} ==> How many digits to reverse? ")
input := os.input('').str().trim_space().int()
score++
if input == 0 || input < 2 || input > 9 {
println("\n(Enter a number from 2 to 9)")
continue
}
for idx, rdx := 0, input - 1; idx < rdx; idx, rdx = idx + 1, rdx - 1 {
mix[idx], mix[rdx] = mix[rdx], mix[idx]
}
if mix == unmix {
println("The list is: ${mix}.")
println("Your score: ${score}. Good job.")
break
}
}
}
- Output:
Select how many digits from the left to reverse. The list is: [3, 4, 9, 7, 6, 1, 5, 8, 2] ==> How many digits to reverse? 8 The list is: [8, 5, 1, 6, 7, 9, 4, 3, 2] ==> How many digits to reverse? 5 The list is: [7, 6, 1, 5, 8, 9, 4, 3, 2] ==> How many digits to reverse? 4 The list is: [5, 1, 6, 7, 8, 9, 4, 3, 2] ==> How many digits to reverse? 2 The list is: [1, 5, 6, 7, 8, 9, 4, 3, 2] ==> How many digits to reverse? 9 The list is: [2, 3, 4, 9, 8, 7, 6, 5, 1] ==> How many digits to reverse? 8 The list is: [5, 6, 7, 8, 9, 4, 3, 2, 1] ==> How many digits to reverse? 5 The list is: [9, 8, 7, 6, 5, 4, 3, 2, 1] ==> How many digits to reverse? 9 The list is: [1, 2, 3, 4, 5, 6, 7, 8, 9]. Your score: 8. Good job.
Wren
import "./sort" for Sort
import "random" for Random
import "io" for Stdin, Stdout
var r= Random.new()
var count = 0
var numbers = [0] * 9
numbers[0] = r.int(2, 10) // this will ensure list isn't ascending
for (i in 1..8) {
var rn
while(true) {
rn = r.int(1, 10)
if (!numbers.contains(rn)) break
}
numbers[i] = rn
}
System.print("Here's your first list : %(numbers)")
while (true) {
var rev
while (true) {
System.write("How many numbers from the left are to be reversed : ")
Stdout.flush()
rev = Num.fromString(Stdin.readLine())
if (rev.type == Num && rev.isInteger && rev >= 2 && rev <= 9) break
}
count = count + 1
var i = 0
var j = rev - 1
while (i < j) {
var temp = numbers[i]
numbers[i] = numbers[j]
numbers[j] = temp
i = i + 1
j = j - 1
}
if (Sort.isSorted(numbers)) {
System.print("Here's your final list : %(numbers)")
break
}
System.print("Here's your list now : %(numbers)")
}
System.print("So you've completed the game with a score of %(count)")
- Output:
Sample game:
Here's your first list : [7, 5, 8, 3, 4, 6, 9, 2, 1] How many numbers from the left are to be reversed : 7 Here's your list now : [9, 6, 4, 3, 8, 5, 7, 2, 1] How many numbers from the left are to be reversed : 9 Here's your list now : [1, 2, 7, 5, 8, 3, 4, 6, 9] How many numbers from the left are to be reversed : 5 Here's your list now : [8, 5, 7, 2, 1, 3, 4, 6, 9] How many numbers from the left are to be reversed : 8 Here's your list now : [6, 4, 3, 1, 2, 7, 5, 8, 9] How many numbers from the left are to be reversed : 6 Here's your list now : [7, 2, 1, 3, 4, 6, 5, 8, 9] How many numbers from the left are to be reversed : 7 Here's your list now : [5, 6, 4, 3, 1, 2, 7, 8, 9] How many numbers from the left are to be reversed : 2 Here's your list now : [6, 5, 4, 3, 1, 2, 7, 8, 9] How many numbers from the left are to be reversed : 6 Here's your list now : [2, 1, 3, 4, 5, 6, 7, 8, 9] How many numbers from the left are to be reversed : 2 Here's your final list : [1, 2, 3, 4, 5, 6, 7, 8, 9] So you've completed the game with a score of 9
XPL0
int Taken, I, Digit, Num, Score, Rev, Temp;
char List(9);
include c:\cxpl\codes;
\make jumbled list of digits 1 to 9
[loop [Taken:= 0; \bit array indicates which digits are taken
for I:= 0 to 9-1 do
[repeat Digit:= Ran(9)+1 until (Taken & 1<<Digit) = 0;
Taken:= Taken + 1<<Digit; \mark digit as taken
List(I):= Digit; \add digit to the list
];
for I:= 0 to 9-2 do if List(I) > List(I+1) then quit;
]; \quit loop when digits are not in ascending order
Score:= 0;
loop [for I:= 0 to 9-1 do [IntOut(0, List(I)); ChOut(0, ^ )];
Num:= 0; for I:= 0 to 9-1 do Num:= Num*10 + List(I);
if Num = 123456789 then quit;
Text(0, "^M^JReverse how many digits? "); Rev:= IntIn(0);
for I:= 0 to Rev/2-1 do
[Temp:= List(I); List(I):= List(Rev-1-I); List(Rev-1-I):= Temp];
Score:= Score+1;
];
Text(0, "^M^JCongrats! You did it in "); IntOut(0, Score);
Text(0, " moves!!^M^J");
]
Example output:
1 3 5 4 8 9 7 2 6 Reverse how many digits? 3 5 3 1 4 8 9 7 2 6 Reverse how many digits? 4 4 1 3 5 8 9 7 2 6 Reverse how many digits? 5 8 5 3 1 4 9 7 2 6 Reverse how many digits? 2 5 8 3 1 4 9 7 2 6
Yabasic
// Rosetta Code problem: https://www.rosettacode.org/wiki/Number_reversal_game
// by Jjuanhdez, 06/2022
print "Given a jumbled list of the numbers 1 to 9, "
print "you must select how many digits from the left "
print "to reverse. Your goal is to get the digits in "
print "order with 1 on the left and 9 on the right.\n"
dim nums(10)
dim a(10)
intentos = 0: denuevo = true: colum = 6
//valores iniciales
for i = 1 to 9
nums(i) = i
next i
for i = 9 to 2 step -1
n = int(ran(i)) + 1
if n <> i then
a(i) = nums(i)
nums(i) = nums(n)
nums(n) = a(i)
fi
next i
repeat
if intentos < 10 print " ";
print intentos, ": ";
for i = 1 to 9
print nums(i), " ";
next i
if not denuevo break
input " -- How many do we flip " volteo
if volteo < 0 or volteo > 9 volteo = 0
for i = 1 to int(volteo / 2)
a(i) = nums(volteo - i + 1)
nums(volteo - i + 1) = nums(i)
nums(i) = a(i)
next i
denuevo = false
//comprobamos el orden
for i = 1 to 8
if nums(i) > nums(i + 1) then
denuevo = true
break
fi
next i
if volteo > 0 intentos = intentos + 1
until false
print "\n\n You needed ", intentos, " attempts."
end
zkl
correctList,scrambledList,N:=[1..9].walk(), correctList.shuffle(),correctList.len();
correctList,scrambledList=correctList.concat(""), scrambledList.concat(""); // list to string
attempts:=0;
while(scrambledList!=correctList){ // Repeat until the sequence is correct
n:=ask(("[%d] %s How many numbers (from the left) should be flipped? ")
.fmt(attempts,scrambledList));
try{ n=n.toInt() }catch{ println("Not a number"); continue; }
if(not (0<=n<N)){ println("Out of range"); continue; }
attempts+=1;
// Reverse the first part of the string and add the second part
scrambledList=scrambledList[0,n].reverse() + scrambledList[n,*];
}
println("You took %d attempts to get the correct sequence.".fmt(attempts));
- Output:
$ zkl bbb [0] 145327689 How many numbers (from the left) should be flipped? 7 [1] 672354189 How many numbers (from the left) should be flipped? 2 [2] 762354189 How many numbers (from the left) should be flipped? 7 [3] 145326789 How many numbers (from the left) should be flipped? 3 [4] 541326789 How many numbers (from the left) should be flipped? 5 [5] 231456789 How many numbers (from the left) should be flipped? 2 [6] 321456789 How many numbers (from the left) should be flipped? 3 You took 7 attempts to get the correct sequence.
- Programming Tasks
- Games
- Puzzles
- 8080 Assembly
- 11l
- Action!
- Ada
- ALGOL 68
- APL
- Applesoft BASIC
- Arturo
- Astro
- AutoHotkey
- AWK
- BASIC
- BASIC256
- Batch File
- BBC BASIC
- Brat
- C
- C sharp
- C++
- Clojure
- CLU
- COBOL
- Common Lisp
- Crystal
- D
- Delphi
- SysUtils,StdCtrls
- EasyLang
- Egel
- Eiffel
- Elena
- Elixir
- Erlang
- Euphoria
- F Sharp
- Factor
- FOCAL
- Forth
- Fortran
- FreeBASIC
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Inform 7
- Io
- IS-BASIC
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- Lua
- M2000 Interpreter
- Mathematica
- Wolfram Language
- MATLAB
- Nim
- OCaml
- Oforth
- Oz
- PARI/GP
- Pascal
- Perl
- Phix
- PHP
- PicoLisp
- PL/I
- PowerShell
- Prolog
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- Rascal
- REBOL
- REXX
- Ring
- Ruby
- Run BASIC
- Rust
- Rand 0.7.3
- Scala
- Scheme
- Scheme/SRFIs
- Seed7
- SenseTalk
- SETL
- Sidef
- Tcl
- True BASIC
- TUSCRIPT
- UNIX Shell
- VBA
- V (Vlang)
- Wren
- Wren-sort
- XPL0
- Yabasic
- Zkl