Anonymous user
Number reversal game: Difference between revisions
m
→{{header|Elena}}
imported>Arakov |
|||
(20 intermediate revisions by 16 users not shown) | |||
Line 3:
;Task:
Given a jumbled list of the numbers '''1''' to '''9''' that are definitely ''not'' in
ascending order.
Line 25:
=={{header|8080 Assembly}}==
<
org 100h
;;; Initialize RNG from keypresses
Line 178:
list: equ listhi*256
rnddat: equ list+16
</syntaxhighlight>
{{out}}
<pre>Please press some keys to seed the RNG...done.
Line 195:
{{trans|Python}}
<
V trials = 0
Line 203:
data.reverse_range(0 .< flip)
print("\nYou took #. attempts to put the digits in order!".format(trials))</
{{out}}
Line 219:
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}}==
<
with Ada.Text_Io; use Ada.Text_Io;
with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;
Line 298 ⟶ 388:
Integer'Image(Count) & " tries.");
end NumberReverse;
</syntaxhighlight>
=={{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}}
<
list←{9?9}⍣{⍺≢⍳9}⊢⍬
swaps←0
Line 312 ⟶ 496:
⎕←(⍕list),': Congratulations!'
⎕←'Swaps:',swaps
∇</
{{out}}
<pre>8 7 2 6 5 3 1 9 4: swap how many? 8
Line 326 ⟶ 510:
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}}
<
while [arr = sort arr]->
Line 343 ⟶ 553:
]
print ["Your score:" score]</
{{out}}
Line 357 ⟶ 567:
=={{header|Astro}}==
<
var data, trials = list(1..9), 0
Line 369 ⟶ 579:
data[:flip] = reverse data[:flip]
print '\nYou took ${trials} attempts to put digits in order!'</
=={{header|AutoHotkey}}==
<
ScrambledList := CorrectList := "1 2 3 4 5 6 7 8 9" ; Declare two identical correct sequences
Line 405 ⟶ 615:
Out := A_LoopField Out
Return Out
}</
=={{header|AWK}}==
<
print "\nWelcome to the number reversal game!\n"
Line 486 ⟶ 696:
}
END { print "\n\nBye!" }</
=={{header|BASIC}}==
Line 493 ⟶ 703:
{{works with|FreeBASIC}}
<
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."
Line 547 ⟶ 757:
LOOP
PRINT : PRINT "You took "; LTRIM$(RTRIM$(STR$(tries))); " tries to put the digits in order."</
Sample output:
Line 566 ⟶ 776:
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">
print "Dada una lista aleatoria de numeros del 1 al 9,"
print "indica cuantos digitos de la izquierda voltear."
Line 626 ⟶ 836:
print chr(10) + chr(10) + " Necesitaste "; intentos; " intentos."
end
</syntaxhighlight>
{{out}}
<pre>
Line 651 ⟶ 861:
=={{header|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
Line 722 ⟶ 932:
goto :loopgame
)
</syntaxhighlight>
Sample Output:
<pre>
Line 763 ⟶ 973:
=={{header|BBC BASIC}}==
Note the use of the MOD(array()) function to test the equality of two arrays.
<
list%() = 1, 2, 3, 4, 5, 6, 7, 8, 9
done%() = list%()
Line 794 ⟶ 1,004:
SWAP a%(i%), a%(n%-i%)
NEXT
ENDPROC</
'''Output:'''
<pre>
Line 810 ⟶ 1,020:
=={{header|Brat}}==
<
length = sorted.length
numbers = sorted.shuffle
Line 828 ⟶ 1,038:
p numbers
p "It took #{turns} turns to sort numbers."</
=={{header|C}}==
An example of a number reversal game could be:
<
{
printf("Number Reversal Game. Type a number to flip the first n numbers.");
Line 863 ⟶ 1,073:
}
printf("Hurray! You solved it in %d moves!\n", tries);
}</
Which uses the following helper functions:
<
{
//We'll just be swapping 100 times. Could be more/less. Doesn't matter much.
Line 909 ⟶ 1,119:
}
return 1;
}</
=={{header|C sharp|C#}}==
C# 3.0
<
using System.Linq;
Line 943 ⟶ 1,153:
Console.ReadLine();
}
}</
C# 1.0
<
{
static void Main(string[] args)
Line 1,031 ⟶ 1,241:
return retArray;
}
}</
=={{header|C++}}==
===Version 1 (crude)===
The C code can be used with C++, although the following uses proper C++ iostreams:
<
{
cout << "Number Reversal Game. Type a number to flip the first n numbers.";
Line 1,068 ⟶ 1,279:
}
cout << "Hurray! You solved it in %d moves!\n";
}</
This uses the same helper functions as the C version.
===Version
====Version 2.1====
This version uses the C++ standard library (note that none of the C helper functions are needed).
<
#include <iostream>
#include <algorithm>
Line 1,125 ⟶ 1,337:
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}}==
<
(let [[x y] (split-at n coll)]
(concat (reverse x) y )))
Line 1,143 ⟶ 1,420:
(flush)
(let [flipcount (read)]
(recur (flip-at flipcount unsorted), (inc steps))))))</
=={{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}}==
<
(loop for i from (1- (length vector)) downto 1
do (rotatef (aref vector i)
Line 1,178 ⟶ 1,646:
(replace slice (nreverse slice))))))
(format t "~A~%Congratulations, you did it in ~D reversals!~%" numbers score))))
</syntaxhighlight>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">
SIZE = 9
ordered = (1..SIZE).to_a
Line 1,203 ⟶ 1,671:
puts "#{shuffled} Your score: #{score}"
</syntaxhighlight>
=={{header|D}}==
<
std.range;
Line 1,220 ⟶ 1,688:
}
writefln("\nYou took %d attempts.", trial);
}</
{{out}}
<pre>1: [7, 2, 1, 6, 3, 8, 9, 5, 4] How many numbers to flip? 7
Line 1,233 ⟶ 1,701:
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|Egel}}==
<syntaxhighlight lang="egel">
import "prelude.eg"
import "io.ego"
Line 1,273 ⟶ 1,915:
def main =
let XX = fromto 1 9 in game XX (shuffle XX) 0</
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 1,381 ⟶ 2,023:
end
</syntaxhighlight>
{{out}}
Line 1,418 ⟶ 2,060:
=={{header|Elena}}==
ELENA
<
import extensions;
public program()
{
var sorted := Array.allocate(9).populate::(n => n + 1 );
var values := sorted.clone().randomize
while (sorted.sequenceEqual
{
values := sorted.randomize
};
var tries := new Integer();
until (sorted.sequenceEqual
{
tries.append
console.print("# ",tries," : LIST : ",values," - Flip how many?");
Line 1,443 ⟶ 2,085:
console.printLine("You took ",tries," attempts to put the digits in order!").readChar()
}</
=={{header|Elixir}}==
{{trans|Erlang}}
<
def start( n ) when n > 1 do
IO.puts "Usage: #{usage(n)}"
Line 1,466 ⟶ 2,108:
end
Number_reversal_game.start( 9 )</
{{out}}
Line 1,491 ⟶ 2,133:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( number_reversal_game ).
Line 1,515 ⟶ 2,157:
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.
Line 1,535 ⟶ 2,177:
=={{header|Euphoria}}==
<
function accending(sequence s)
Line 1,589 ⟶ 2,231:
end while
printf(1,"\nYou took %d tries to put the digits in order.", tries)</
Output:
Line 1,613 ⟶ 2,255:
=={{header|F Sharp|F#}}==
<
while true do
Line 1,633 ⟶ 2,275:
printfn "\nYou took %i moves to put the digits in order!\n" i
move 1</
=={{header|Factor}}==
<
namespaces random sequences strings ;
IN: rosetta.number-reversal
Line 1,665 ⟶ 2,307:
: play ( -- )
0 trials set
make-jumbled-array game-loop ;</
=={{header|FOCAL}}==
<
01.20 F X=1,9;T %1,D(X)
01.30 T !;A "HOW MANY",R
Line 1,690 ⟶ 2,332:
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</
{{out}}
<pre>= 1= 6= 4= 5= 8= 7= 9= 2= 3
Line 1,720 ⟶ 2,362:
=={{header|Forth}}==
<
variable flips
Line 1,769 ⟶ 2,411:
7 flip
9 6 7 5 8 2 1 4 3 ok
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<
implicit none
Line 1,826 ⟶ 2,468:
end function
end program</
=={{header|FreeBASIC}}==
:''See [[#BASIC|BASIC]]''
=={{header|Go}}==
<
import (
Line 1,871 ⟶ 2,516:
}
}
}</
=={{header|Groovy}}==
<
arr = sorted.clone()
Line 1,888 ⟶ 2,533:
steps += 1
}
println "Done! That took you ${steps} steps"</
=={{header|Haskell}}==
Using Rosetta [[Knuth shuffle#Haskell|Knuth Shuffle]]
<
import Control.Arrow
import Rosetta.Knuthshuffle
Line 1,926 ⟶ 2,571:
start <- shuffle goal
playNRG 1 start</
Play:
<pre>*Main> numberRevGame
Line 1,941 ⟶ 2,586:
=={{header|HicEst}}==
<
FUNCTION Reversals()
Line 1,963 ⟶ 2,608:
IF( SUM(temp) == 8 ) RETURN
ENDDO
END</
=={{header|Icon}} and {{header|Unicon}}==
<
local x,nums,R,flips
Line 2,034 ⟶ 2,679:
map(trim(read())) ? return tab(upto(' ')|0)
end
</syntaxhighlight>
Sample output:<pre>Input a position. The list will be flipped left to right at that point.
Line 2,062 ⟶ 2,707:
=={{header|Inform 7}}==
<
The current list is a list of numbers that varies.
Line 2,101 ⟶ 2,746:
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.</
=={{header|Io}}==
<
Range clone setRange(a,z)
)
Line 2,122 ⟶ 2,767:
steps = steps+1
)
writeln("Done! That took you ", steps, " steps")</
=={{header|IS-BASIC}}==
<
110 RANDOMIZE
120 NUMERIC NR(1 TO 9)
Line 2,163 ⟶ 2,808:
460 IF NR(J)>NR(J+1) THEN LET ORDERED=0:EXIT FOR
470 NEXT
480 END DEF</
=={{header|J}}==
'''Solution:'''
<
INTRO=: noun define
Line 2,188 ⟶ 2,833:
end.
'You took ',(": score), ' attempts to put the numbers in order.'
)</
'''Example Usage:'''
<
Number Reversal Game
Sort the numbers in ascending order by repeatedly
Line 2,206 ⟶ 2,851:
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.</
=={{header|Java}}==
<
import java.util.ArrayList;
import java.util.Scanner;
Line 2,281 ⟶ 2,926:
}
}
}</
=={{header|JavaScript}}==
Use <code>knuth_shuffle()</code> function from [[Knuth shuffle#JavaScript|here]].
<
<head>
<title>Number Reversal Game</title>
Line 2,295 ⟶ 2,940:
<div id="progress"></div>
<div id="score"></div>
<script type="text/javascript"></
<
var scoreId = progress.scoreId,
result = 'You took ' + progress.count + ' attempts to put the digits in order!';
Line 2,363 ⟶ 3,008:
}
playGame('start', 'progress', 'score');</
<
</body>
</html></
=={{header|jq}}==
<
def play:
def sorted: . == sort;
Line 2,387 ⟶ 3,032:
.list |= reverse($n) | .score +=1;
if .list | sorted then report, break $done else prompt end ))
end); </
'''Example'''
<
'''Transcript'''
Line 2,406 ⟶ 3,051:
=={{header|Julia}}==
<
function numrevgame()
Line 2,423 ⟶ 3,068:
end
numrevgame()</
=={{header|Kotlin}}==
<
fun isAscending(a: IntArray): Boolean {
Line 2,467 ⟶ 3,112:
}
println("So you've completed the game with a score of $count")
}</
Sample game:
{{out}}
Line 2,488 ⟶ 3,133:
=={{header|Lua}}==
<
math.randomseed(os.time())
numList = {values = {}}
Line 2,552 ⟶ 3,197:
until numList:inOrder()
numList:show()
print("\n\nW00t! You scored:", score)</
=={{header|M2000 Interpreter}}==
Line 2,565 ⟶ 3,210:
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,"
Line 2,607 ⟶ 3,252:
}
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]]</
=={{header|MATLAB}}==
<
list = randperm(9);
while issorted(list)
Line 2,644 ⟶ 3,289:
fprintf('\nPlay again soon!\n')
end
end</
{{out}}
<pre>Given a list of numbers, try to put them into ascending order
Line 2,664 ⟶ 3,309:
=={{header|Nim}}==
<
randomize()
Line 2,699 ⟶ 3,344:
reverse(data, 0, flip - 1)
echo "You took ", trials, " attempts to put the digits in order!"</
Example:
<pre>#1: List: '6 5 8 7 2 1 9 3 4' Flip how many?: 5
Line 2,718 ⟶ 3,363:
=== Imperative ===
<
let tmp = ar.(i) in
ar.(i) <- ar.(j);
Line 2,765 ⟶ 3,410:
print_endline "Congratulations!";
Printf.printf "You took %d attempts to put the digits in order.\n" !n;
;;</
=== Functional ===
<
let rec aux acc i = function
| [] -> acc
Line 2,817 ⟶ 3,462:
in
loop 1 li
;;</
=={{header|Oforth}}==
<
: reversalGame
Line 2,836 ⟶ 3,481:
1+ l left(n) reverse l right(l size n -) + ->l
]
"You won ! Your score is :" . println ;</
{{out}}
Line 2,855 ⟶ 3,500:
=={{header|Oz}}==
<
proc {Main}
proc {Loop N Xs}
Line 2,913 ⟶ 3,558:
end
in
{Main}</
=={{header|PARI/GP}}==
<
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),
Line 2,929 ⟶ 3,574:
);
score
};</
=={{header|Pascal}}==
<syntaxhighlight lang="pascal">
program NumberReversalGame;
Line 2,970 ⟶ 3,615:
end;
procedure ReverseList(var list: array of integer;
var
i
begin
i := low(list);
while i < j do
Line 3,036 ⟶ 3,680:
WriteLn;
end.
</syntaxhighlight>
=={{header|Perl}}==
<
my $turn = 0;
Line 3,058 ⟶ 3,702:
print " @jumble\n";
print "You won in $turn turns.\n";</
Output:
Line 3,074 ⟶ 3,718:
=={{header|Phix}}==
Simplified copy of [[Number_reversal_game#Euphoria|Euphoria]]
<
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")
Line 3,095 ⟶ 3,739:
end while
printf(1,"\nYou took %d turns to put the digits in order.", turns)</
{{out}}
<pre style="font-size: 8px">
Line 3,115 ⟶ 3,759:
=={{header|PHP}}==
<
private $numbers;
Line 3,170 ⟶ 3,814:
$game = new ReversalGame();
$game->play();
</syntaxhighlight>
=={{header|PicoLisp}}==
<
(de reversalGame ()
Line 3,184 ⟶ 3,828:
(NIL (num? (read)))
(setq Lst (flip Lst @))
(inc 'Cnt) ) ) )</
Output:
<pre>: (reversalGame)
Line 3,198 ⟶ 3,842:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
digits: procedure options (main); /* 23 April 2010 */
declare s character (9) varying;
Line 3,232 ⟶ 3,876:
go to restart;
end digits;
</syntaxhighlight>
=={{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.
Line 3,260 ⟶ 3,904:
"$Array"
"Your score: $nTries"
</syntaxhighlight>
=={{header|Prolog}}==
<
do_turn(N, L) :-
Line 3,289 ⟶ 3,933:
print_list(L) :-
atomic_list_concat(L, ' ', Lf),
format('(~w) ',Lf).</
{{out}}
<pre>
Line 3,312 ⟶ 3,956:
=={{header|PureBasic}}==
<
Declare is_list_sorted()
Line 3,358 ⟶ 4,002:
Next
ProcedureReturn #True
EndProcedure</
=={{header|Python}}==
<
number reversal game
Given a jumbled list of the numbers 1 to 9
Line 3,382 ⟶ 4,026:
data[:flip] = reversed(data[:flip])
print('\nYou took %2i attempts to put the digits in order!' % trials)</
'''Sample output:'''
Line 3,406 ⟶ 4,050:
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}}==
<syntaxhighlight lang="text">reversalGame <- function(){
cat("Welcome to the Number Reversal Game! \n")
cat("Sort the numbers into ascending order by repeatedly \n",
Line 3,431 ⟶ 4,120:
# Victory!
cat("Well done. You needed", trials, "flips. \n")
}</
Sample output:
<syntaxhighlight lang="text">>reversalGame()
Welcome to the Number Reversal Game!
Sort the numbers into ascending order by repeatedly
Line 3,443 ⟶ 4,132:
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.</
=={{header|Racket}}==
<
(let loop ([nums (range 1 10)] [n 0])
(cond [(apply < nums) (if (zero? n)
Line 3,453 ⟶ 4,142:
[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))]))</
=={{header|Raku}}==
Line 3,460 ⟶ 4,149:
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"
@jumbled-list = (1..9).pick(*)
}
Line 3,474 ⟶ 4,163:
say " @jumbled-list[]";
say "You won in $turn turns.";</
Output:
Line 3,495 ⟶ 4,184:
=={{header|Rascal}}==
<
import vis::Figure;
import vis::Render;
Line 3,531 ⟶ 4,220:
render(figure);
}</
Output:
Line 3,539 ⟶ 4,228:
=={{header|REBOL}}==
<
print "NUMBER REVERSAL GAME"
Line 3,560 ⟶ 4,249:
]
print rejoin ["You took " tries " attempts."]</
=={{header|REXX}}==
Line 3,568 ⟶ 4,257:
:::* allows the user to enter '''quit'''
:::* allows the user to halt the game via '''Cntl-Break''' (or equivalent)
<
signal on halt /*allows the CBLF to HALT the program.*/
___= copies('─', 9); pad=left('', 9) /*a fence used for computer's messages.*/
Line 3,596 ⟶ 4,285:
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'':
<pre>
Line 3,648 ⟶ 4,337:
=={{header|Ring}}==
<
# Project : Number reversal game
Line 3,699 ⟶ 4,388:
svect = left(svect, len(svect) - 1)
see svect
</syntaxhighlight>
Output:
<pre>
Line 3,715 ⟶ 4,404:
=={{header|Ruby}}==
<
ary.shuffle! while ary == ary.sort
score = 0
Line 3,725 ⟶ 4,414:
end
p ary
puts "Your score: #{score}"</
sample output:
Line 3,741 ⟶ 4,430:
=={{header|Run BASIC}}==
<
n(i) = i
next i
Line 3,780 ⟶ 4,469:
a$ = b$ + mid$(a$,i + 2)
goto [loop]
end</
=={{header|Rust}}==
{{libheader|rand 0.7.3}}
<
use std::io::stdin;
Line 3,829 ⟶ 4,518:
attempt - 1 // Remove additionally counted attempt
);
}</
{{out}}
<pre>Number reversal game:
Line 3,854 ⟶ 4,543:
=={{header|Scala}}==
<
def play(n: Int, cur: List[Int], goal: List[Int]) {
readLine(s"""$n. ${cur mkString " "} How many to flip? """) match {
Line 3,882 ⟶ 4,571:
play(9)
}</
{{out}}
<pre>1. 8 4 2 9 6 3 7 5 1 How many to flip? 3
Line 3,902 ⟶ 4,591:
{{libheader|Scheme/SRFIs}}
<
(import (scheme base)
(scheme read)
Line 3,939 ⟶ 4,628:
(play-game (make-randomised-list) 1)
</syntaxhighlight>
{{out}}
Line 3,969 ⟶ 4,658:
=={{header|Seed7}}==
<
const proc: main is func
Line 4,005 ⟶ 4,694:
until list = sortedList;
writeln("Congratulations, you sorted the list in " <& score <& " reversals.");
end func;</
{{out}}
Line 4,020 ⟶ 4,709:
=={{header|SenseTalk}}==
<
// set the initial list of digits
set currentList to 1..9 sorted by random of a million
Line 4,041 ⟶ 4,730:
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}}
<
var jumble = @(1..9).bshuffle; # best-shuffle
Line 4,055 ⟶ 4,790:
print " #{jumble.join(' ')}\n";
print "You won in #{turn} turns.\n";</
=={{header|Tcl}}==
<
# Simple shuffler, not very efficient but good enough for here
proc shuffle list {
Line 4,100 ⟶ 4,835:
if {$outcome ne "quit"} {
puts "\nYou took $outcome attempts to put the digits in order."
}</
Sample output:
<pre>
Line 4,123 ⟶ 4,858:
You took 11 attempts to put the digits in order.
</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}}==
<
$$ MODE TUSCRIPT
numbers=RANDOM_NUMBERS (1,9,9),nr=0
Line 4,163 ⟶ 4,970:
ENDIF
ENDLOOP
</syntaxhighlight>
Output:
<pre style='height:30ex;overflow:scroll'>
Line 4,191 ⟶ 4,998:
{{trans|AWK}}
{{works with|pdksh|5.2.14}}
<
print "You must put the numbers in order from 1 to 9."
Line 4,290 ⟶ 5,097:
fi
fi
done</
=={{header|VBA}}==
{{trans|Phix}}<
Dim t As Variant, i As Integer
For i = UBound(a) To LBound(a) + 1 Step -1
Line 4,352 ⟶ 5,159:
Debug.Print "You took"; turns; "turns to put the digits in order."
End Sub</
<pre>Given a jumbled list of the numbers 1 to 9
you must select how many digits from the left to reverse.
Line 4,366 ⟶ 5,173:
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}}<
import "./sort" for Sort
import "random" for Random
import "io" for Stdin, Stdout
Line 4,411 ⟶ 5,270:
System.print("Here's your list now : %(numbers)")
}
System.print("So you've completed the game with a score of %(count)")</
{{out}}
Line 4,439 ⟶ 5,298:
=={{header|XPL0}}==
<
char List(9);
include c:\cxpl\codes;
Line 4,462 ⟶ 5,321:
Text(0, "^M^JCongrats! You did it in "); IntOut(0, Score);
Text(0, " moves!!^M^J");
]</
Example output:
Line 4,476 ⟶ 5,335:
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}}
<
correctList,scrambledList=correctList.concat(""), scrambledList.concat(""); // list to string
attempts:=0;
Line 4,491 ⟶ 5,410:
scrambledList=scrambledList[0,n].reverse() + scrambledList[n,*];
}
println("You took %d attempts to get the correct sequence.".fmt(attempts));</
{{out}}
<pre>
|