Number reversal game: Difference between revisions

 

;Task:

ascending order.

 

 

=={{header|8080 Assembly}}==

org 100h

;;; Initialize RNG from keypresses

list: equ listhi*256

rnddat: equ list+16

{{out}}

<pre>Please press some keys to seed the RNG...done.

{{trans|Python}}

 

V trials = 0

 

data.reverse_range(0 .< flip)

 

 

{{out}}

 

You took 10 attempts to put the digits in order!

</pre>

 

=={{header|Ada}}==

with Ada.Text_Io; use Ada.Text_Io;

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

Integer'Image(Count) & " tries.");

end NumberReverse;

 

=={{header|APL}}==

{{works with|Dyalog APL}}

list←{9?9}⍣{⍺≢⍳9}⊢⍬

swaps←0

⎕←(⍕list),': Congratulations!'

⎕←'Swaps:',swaps

{{out}}

<pre>8 7 2 6 5 3 1 9 4: swap how many? 8

1 2 3 4 5 6 7 8 9: Congratulations!

Swaps: 10</pre>

=={{header|Arturo}}==

 

{{trans|Ruby}}

 

 

while [arr = sort arr]->

]

 

 

{{out}}

 

=={{header|Astro}}==

 

var data, trials = list(1..9), 0

data[:flip] = reverse data[:flip]

 

 

=={{header|AutoHotkey}}==

 

ScrambledList := CorrectList := "1 2 3 4 5 6 7 8 9" ; Declare two identical correct sequences

Out := A_LoopField Out

Return Out

 

=={{header|AWK}}==

print "\nWelcome to the number reversal game!\n"

 

}

 

 

=={{header|BASIC}}==

{{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."

LOOP

 

 

Sample output:

 

=={{header|BASIC256}}==

print "Dada una lista aleatoria de numeros del 1 al 9,"

print "indica cuantos digitos de la izquierda voltear."

print chr(10) + chr(10) + " Necesitaste "; intentos; " intentos."

end

{{out}}

<pre>

=={{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

goto :loopgame

)

Sample Output:

<pre>

=={{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%()

SWAP a%(i%), a%(n%-i%)

NEXT

'''Output:'''

<pre>

 

=={{header|Brat}}==

length = sorted.length

numbers = sorted.shuffle

 

p 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.");

}

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.

}

return 1;

 

=={{header|C sharp|C#}}==

C# 3.0

using System.Linq;

 

Console.ReadLine();

}

 

C# 1.0

{

static void Main(string[] args)

return retArray;

}

 

=={{header|C++}}==

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.";

}

cout << "Hurray! You solved it in %d moves!\n";

 

This uses the same helper functions as the C version.

 

This version uses the C++ standard library (note that none of the C helper functions are needed).

#include <iostream>

#include <algorithm>

return 0;

}

 

=={{header|Clojure}}==

(let [[x y] (split-at n coll)]

(concat (reverse x) y )))

(flush)

(let [flipcount (read)]

 

=={{header|Common Lisp}}==

(loop for i from (1- (length vector)) downto 1

do (rotatef (aref vector i)

(replace slice (nreverse slice))))))

(format t "~A~%Congratulations, you did it in ~D reversals!~%" numbers score))))

 

=={{header|Crystal}}==

SIZE = 9

ordered = (1..SIZE).to_a

 

puts "#{shuffled} Your score: #{score}"

 

=={{header|D}}==

std.range;

 

}

writefln("\nYou took %d attempts.", trial);

{{out}}

<pre>1: [7, 2, 1, 6, 3, 8, 9, 5, 4] How many numbers to flip? 7

 

You took 9 attempts.</pre>

 

=={{header|Egel}}==

import "prelude.eg"

import "io.ego"

 

def main =

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

 

{{out}}

 

=={{header|Elena}}==

import extensions;

public program()

{

{

};

var tries := new Integer();

{

console.print("# ",tries," : LIST : ",values," - Flip how many?");

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)}"

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( number_reversal_game ).

 

 

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] ).

{{out}}

Not being a very good player I show a test run with only 3 numbers.

 

=={{header|Euphoria}}==

 

function accending(sequence s)

end while

 

 

Output:

 

=={{header|F Sharp|F#}}==

 

while true do

printfn "\nYou took %i moves to put the digits in order!\n" i

 

 

=={{header|Factor}}==

namespaces random sequences strings ;

IN: rosetta.number-reversal

: play ( -- )

0 trials set

 

=={{header|FOCAL}}==

01.20 F X=1,9;T %1,D(X)

01.30 T !;A "HOW MANY",R

04.50 S A=A+1

 

{{out}}

<pre>= 1= 6= 4= 5= 8= 7= 9= 2= 3

 

=={{header|Forth}}==

 

variable flips

7 flip

9 6 7 5 8 2 1 4 3 ok

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

end function

 

=={{header|Go}}==

 

import (

}

}

 

=={{header|Groovy}}==

arr = sorted.clone()

 

steps += 1

}

 

=={{header|Haskell}}==

Using Rosetta [[Knuth shuffle#Haskell|Knuth Shuffle]]

import Control.Arrow

import Rosetta.Knuthshuffle

start <- shuffle goal

Play:

<pre>*Main> numberRevGame

 

=={{header|HicEst}}==

 

FUNCTION Reversals()

IF( SUM(temp) == 8 ) RETURN

ENDDO

 

=={{header|Icon}} and {{header|Unicon}}==

local x,nums,R,flips

 

map(trim(read())) ? return tab(upto(' ')|0)

end

 

Sample output:<pre>Input a position. The list will be flipped left to right at that point.

 

=={{header|Inform 7}}==

 

The current list is a list of numbers that varies.

say "It took you [turn count] flip[s] to sort the list."

 

 

=={{header|Io}}==

Range clone setRange(a,z)

)

steps = steps+1

)

 

=={{header|IS-BASIC}}==

110 RANDOMIZE

120 NUMERIC NR(1 TO 9)

460 IF NR(J)>NR(J+1) THEN LET ORDERED=0:EXIT FOR

470 NEXT

 

=={{header|J}}==

'''Solution:'''

INTRO=: noun define

end.

'You took ',(": score), ' attempts to put the numbers in order.'

'''Example Usage:'''

Number Reversal Game

Sort the numbers in ascending order by repeatedly

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

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Scanner;

}

}

 

=={{header|JavaScript}}==

Use <code>knuth_shuffle()</code> function from [[Knuth shuffle#JavaScript|here]].

 

<head>

<title>Number Reversal Game</title>

<div id="progress"></div>

<div id="score"></div>

var scoreId = progress.scoreId,

result = 'You took ' + progress.count + ' attempts to put the digits in order!';

}

 

</body>

 

=={{header|jq}}==

def play:

def sorted: . == sort;

.list |= reverse($n) | .score +=1;

if .list | sorted then report, break $done else prompt end ))

 

'''Example'''

 

'''Transcript'''

 

=={{header|Julia}}==

 

function numrevgame()

end

 

 

=={{header|Kotlin}}==

 

fun isAscending(a: IntArray): Boolean {

}

println("So you've completed the game with a score of $count")

Sample game:

{{out}}

 

=={{header|Lua}}==

math.randomseed(os.time())

numList = {values = {}}

until numList:inOrder()

numList:show()

 

=={{header|M2000 Interpreter}}==

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,"

}

Number_Reversal_Game

 

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++];

 

=={{header|MATLAB}}==

list = randperm(9);

while issorted(list)

fprintf('\nPlay again soon!\n')

end

{{out}}

<pre>Given a list of numbers, try to put them into ascending order

 

=={{header|Nim}}==

randomize()

 

reverse(data, 0, flip - 1)

 

Example:

<pre>#1: List: '6 5 8 7 2 1 9 3 4' Flip how many?: 5

=== Imperative ===

 

let tmp = ar.(i) in

ar.(i) <- ar.(j);

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

in

loop 1 li

 

=={{header|Oforth}}==

 

 

: reversalGame

1+ l left(n) reverse l right(l size n -) + ->l

]

 

{{out}}

 

=={{header|Oz}}==

proc {Main}

proc {Loop N Xs}

end

in

 

=={{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),

);

score

 

=={{header|Pascal}}==

program NumberReversalGame;

 

WriteLn;

end.

 

=={{header|Perl}}==

 

my $turn = 0;

 

print " @jumble\n";

 

Output:

=={{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")

end while

{{out}}

<pre style="font-size: 8px">

=={{header|PHP}}==

 

private $numbers;

$game = new ReversalGame();

$game->play();

 

=={{header|PicoLisp}}==

 

(de reversalGame ()

(NIL (num? (read)))

(setq Lst (flip Lst @))

Output:

<pre>: (reversalGame)

 

=={{header|PL/I}}==

digits: procedure options (main); /* 23 April 2010 */

declare s character (9) varying;

go to restart;

end digits;

 

=={{header|PowerShell}}==

#adding the below function to the previous users submission to prevent the small

#chance of getting an array that is in ascending order.

"$Array"

"Your score: $nTries"

 

=={{header|Prolog}}==

 

do_turn(N, L) :-

print_list(L) :-

atomic_list_concat(L, ' ', Lf),

{{out}}

<pre>

 

=={{header|PureBasic}}==

 

Declare is_list_sorted()

Next

ProcedureReturn #True

 

=={{header|Python}}==

number reversal game

Given a jumbled list of the numbers 1 to 9

data[:flip] = reversed(data[:flip])

 

 

'''Sample output:'''

 

You took 10 attempts to put the digits in order!</pre>

 

=={{header|R}}==

cat("Welcome to the Number Reversal Game! \n")

cat("Sort the numbers into ascending order by repeatedly \n",

# Victory!

cat("Well done. You needed", trials, "flips. \n")

 

Sample output:

Welcome to the Number Reversal Game!

Sort the numbers into ascending order by repeatedly

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

 

=={{header|Racket}}==

(let loop ([nums (range 1 10)] [n 0])

(cond [(apply < nums) (if (zero? n)

[else (printf "Step #~s: ~s\nFlip how many? " n nums)

(define-values (l r) (split-at nums (read)))

 

=={{header|Raku}}==

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.

 

@jumbled-list = (1..9).pick(*)

}

 

say " @jumbled-list[]";

 

Output:

 

=={{header|Rascal}}==

import vis::Figure;

import vis::Render;

render(figure);

 

Output:

=={{header|REBOL}}==

 

 

print "NUMBER REVERSAL GAME"

]

 

 

=={{header|REXX}}==

:::* &nbsp; allows the user to enter &nbsp; '''quit'''

:::* &nbsp; allows the user to halt the game via &nbsp; '''Cntl-Break''' &nbsp; (or equivalent)

signal on halt /*allows the CBLF to HALT the program.*/

___= copies('─', 9); pad=left('', 9) /*a fence used for computer's messages.*/

say; say ___ $; say; say center(' Congratulations! ', 70, "═"); say

say ___ pad 'Your score was' score; exit /*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; from playing one game of the &nbsp; ''number reversal game'':

<pre>

 

=={{header|Ring}}==

# Project : Number reversal game

 

svect = left(svect, len(svect) - 1)

see svect

Output:

<pre>

 

=={{header|Ruby}}==

ary.shuffle! while ary == ary.sort

score = 0

end

p ary

 

sample output:

 

=={{header|Run BASIC}}==

n(i) = i

next i

a$ = b$ + mid$(a$,i + 2)

goto [loop]

 

=={{header|Rust}}==

{{libheader|rand 0.7.3}}

use std::io::stdin;

 

attempt - 1 // Remove additionally counted attempt

);

{{out}}

<pre>Number reversal game:

 

=={{header|Scala}}==

def play(n: Int, cur: List[Int], goal: List[Int]) {

readLine(s"""$n. ${cur mkString " "} How many to flip? """) match {

 

play(9)

{{out}}

<pre>1. 8 4 2 9 6 3 7 5 1 How many to flip? 3

{{libheader|Scheme/SRFIs}}

 

(import (scheme base)

(scheme read)

 

(play-game (make-randomised-list) 1)

 

{{out}}

 

=={{header|Seed7}}==

 

const proc: main is func

until list = sortedList;

writeln("Congratulations, you sorted the list in " <& score <& " reversals.");

 

{{out}}

 

=={{header|SenseTalk}}==

// set the initial list of digits

set currentList to 1..9 sorted by random of a million

 

answer "You sorted it in " & numberOfTurns & " turns!" titled "Congratulations!"

 

=={{header|Sidef}}==

{{trans|Perl}}

var jumble = @(1..9).bshuffle; # best-shuffle

 

 

print " #{jumble.join(' ')}\n";

 

=={{header|Tcl}}==

# Simple shuffler, not very efficient but good enough for here

proc shuffle list {

if {$outcome ne "quit"} {

puts "\nYou took $outcome attempts to put the digits in order."

Sample output:

<pre>

 

=={{header|True BASIC}}==

RANDOMIZE

 

PRINT "Necesitaste "; ltrim$(rtrim$(str$(intentos))); " intentos."

END

 

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

numbers=RANDOM_NUMBERS (1,9,9),nr=0

ENDIF

ENDLOOP

Output:

<pre style='height:30ex;overflow:scroll'>

{{trans|AWK}}

{{works with|pdksh|5.2.14}}

 

print "You must put the numbers in order from 1 to 9."

fi

fi

 

=={{header|VBA}}==

Dim t As Variant, i As Integer

For i = UBound(a) To LBound(a) + 1 Step -1

Debug.Print "You took"; turns; "turns to put the digits in order."

<pre>Given a jumbled list of the numbers 1 to 9

you must select how many digits from the left to reverse.

8 : 1 2 3 4 5 6 7 8 9

You took 8 turns to put the digits in order.</pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

import "random" for Random

import "io" for Stdin, Stdout

System.print("Here's your list now : %(numbers)")

}

 

{{out}}

 

=={{header|XPL0}}==

char List(9);

include c:\cxpl\codes;

Text(0, "^M^JCongrats! You did it in "); IntOut(0, Score);

Text(0, " moves!!^M^J");

 

Example output:

5 8 3 1 4 9 7 2 6

</pre>

 

=={{header|zkl}}==

{{trans|AutoHotkey}}

correctList,scrambledList=correctList.concat(""), scrambledList.concat(""); // list to string

attempts:=0;

scrambledList=scrambledList[0,n].reverse() + scrambledList[n,*];

}

{{out}}

<pre>