# Guess the number/With feedback

Guess the number/With feedback
You are encouraged to solve this task according to the task description, using any language you may know.

The task is to write a game that follows the following rules:

The computer will choose a number between given set limits and asks the player for repeated guesses until the player guesses the target number correctly. At each guess, the computer responds with whether the guess was higher than, equal to, or less than the target - or signals that the input was inappropriate.

```  procedure Guess_Number (Lower_Limit : Integer; Upper_Limit : Integer) is
subtype Number is Integer range Lower_Limit .. Upper_Limit;
package Number_IO is new Ada.Text_IO.Integer_IO (Number);
package Number_RNG is new Ada.Numerics.Discrete_Random (Number);
Generator  : Number_RNG.Generator;
My_Number  : Number;
Your_Guess : Number;
begin
Number_RNG.Reset (Generator);
My_Number := Number_RNG.Random (Generator);
loop
Number_IO.Get (Your_Guess);
exit when Your_Guess = My_Number;
if Your_Guess > My_Number then
else
end if;
end loop;
end Guess_Number;
package Int_IO is new Ada.Text_IO.Integer_IO (Integer);
Lower_Limit : Integer;
Upper_Limit : Integer;
```

begin

```  loop
Int_IO.Get (Lower_Limit);
Int_IO.Get (Upper_Limit);
exit when Lower_Limit < Upper_Limit;
Ada.Text_IO.Put_Line ("Lower limit must be lower!");
end loop;
Guess_Number (Lower_Limit, Upper_Limit);
```

end Guess_Number_Feedback;</lang>

## AutoHotkey

<lang AutoHotkey>MinNum = 1 MaxNum = 99999999999

Random, RandNum, %MinNum%, %MaxNum% Loop {

```InputBox, Guess, Number Guessing, Please enter a number between %MinNum% and %MaxNum%:,, 350, 130,,,,, %Guess%
If ErrorLevel
ExitApp
If Guess Is Not Integer
{
MsgBox, 16, Error, Invalid guess.
Continue
}
If Guess Not Between %MinNum% And %MaxNum%
{
MsgBox, 16, Error, Guess must be a number between %MinNum% and %MaxNum%.
Continue
}
If A_Index = 1
TotalTime = %A_TickCount%
Tries = %A_Index%
If Guess = %RandNum%
Break
If Guess < %RandNum%
MsgBox, 64, Incorrect, The number guessed (%Guess%) was too low.
If Guess > %RandNum%
MsgBox, 64, Incorrect, The number guessed (%Guess%) was too high.
```

} TotalTime := Round((A_TickCount - TotalTime) / 1000,1) MsgBox, 64, Correct, The number %RandNum% was guessed in %Tries% tries, which took %TotalTime% seconds.</lang>

## Brat

<lang brat>number = random 10

p "Guess a number between 1 and 10."

until {

``` guess = ask("Guess: ").to_i
```
``` true? (guess.null? || { guess > 10 || guess < 1 })
{ p "Please guess a number between 1 and 10."}
{ true? guess == number
{ p "Correct!"; true }
{ true? guess < number
{ p "Too low!" }
{ p "Too high!" }
}
}
```

}</lang>

## C

<lang c>#include <stdlib.h>

1. include <stdio.h>
2. include <time.h>
1. define lower_limit 0
2. define upper_limit 100

int main(){

``` int number, guess;
```
``` srand( time( 0 ) );
number = lower_limit + rand() % (upper_limit - lower_limit + 1);
```
``` printf( "Guess the number between %d and %d: ", lower_limit, upper_limit );
```
``` while( scanf( "%d", &guess ) == 1 ){
if( number == guess ){
printf( "You guessed correctly!\n" );
break;
}
printf( "Your guess was too %s.\nTry again: ", number < guess ? "high" : "low" );
}
```
``` return 0;
```

}</lang>

Demonstration:

```Guess the number between 0 and 100: 50
Try again: 75
Try again: 63
Try again: 57
Try again: 60
Try again: 58
Try again: 59
You guessed correctly!```

## C++

<lang cpp>#include <iostream>

1. include <cstdlib>
2. include <ctime>

int main() {

```   std::srand(std::time(0));
int lower, upper, guess;
std::cout << "Enter lower limit: ";
std::cin >> lower;
std::cout << "Enter upper limit: ";
std::cin >> upper;
int random_number = lower + std::rand() % ((upper + 1) - lower);
```
```   do
{
std::cout << "Guess what number I have: ";
std::cin >> guess;
if (guess > random_number)
std::cout << "Your guess is too high\n";
else if (guess < random_number)
std::cout << "Your guess is too low\n";
else
std::cout << "You got it!\n";
} while (guess != random_number);
```
```   return 0;
```

}</lang> Output:

```Enter lower limit: 1
Enter upper limit: 100
Guess what number I have: 50
Guess what number I have: 40
Guess what number I have: 25
Guess what number I have: 10
Guess what number I have: 2
Guess what number I have: 4
Guess what number I have: 3
You got it!```

## D

Translation of: Python

<lang d>import std.stdio, std.random, std.typecons, std.conv, std.string;

void main() {

```   immutable interval = tuple(1, 100);
```
```   writefln("Guess my target number that is between " ~
"%d and %d (inclusive).\n", interval.tupleof);
immutable target = uniform!"[]"(interval.tupleof);
```
```   int answer = -1;
for (int i = 1; ; i++) {
try {
} catch (ConvException e) {
writefln("  I don't understand your input '%s'?", txt);
continue;
}
writeln("  Out of range!");
continue;
}
writeln("  Ye-Haw!!");
break;
}
writeln(answer < target ? "  Too low." : "  Too high.");
}
```
```   writeln("\nThanks for playing.");
```

}</lang> Sample game:

```Guess my target number that is between 1 and 100 (inclusive).

Too high.
Too high.
Too low.
Too high.
Too low.
Too high.
Ye-Haw!!

Thanks for playing.```

## C#

<lang csharp>using System;

class Program {

```   static void Main(string[] args)
{
const int from = 1;
const int to = 10;
```
```       int randomNumber = new Random().Next(from, to);
int guessedNumber;
```
```       Console.Write("The number is between {0} and {1}. ", from, to);
while (true)
{
Console.Write("Make a guess: ");
{
if (guessedNumber == randomNumber)
{
Console.WriteLine("You guessed the right number!");
break;
}
else
{
Console.WriteLine("Your guess was too {0}.", (guessedNumber > randomNumber) ? "high" : "low");
}
}
else
{
Console.WriteLine("Input was not an integer.");
}
}
```
```       Console.WriteLine();
Console.WriteLine("Press any key to exit.");
}
```

} </lang> Output:

```The number is between 1 and 10. Make a guess: 1
Make a guess: 9
Make a guess: 5
Make a guess: 6
Make a guess: hello, world
Input was not an integer.
Make a guess: 7
You guessed the right number!

Press any key to exit.
```

## Clojure

<lang clojure>(defn guess-run []

``` (let [start 1
```

end 100 target (+ start (rand-int (inc (- end start))))]

```   (printf "Guess a number between %d and %d" start end)
(loop [i 1]
```

(if (cond (not (number? ans)) (println "Invalid format") (or (< ans start) (> ans end)) (println "Out of range") (< ans target) (println "too low") (> ans target) (println "too high") :else true) (println "Correct") (recur (inc i)))))))</lang>

## Common Lisp

<lang lisp>(defun guess-the-number-feedback (&optional (min 1) (max 100))

``` (let ((num-guesses 0)
```

(num (+ (random (1+ (- max min))) min)) (guess nil))

```   (format t "Try to guess a number from ~:d to ~:d!~%" min max)
(loop do (format t "Guess? ")
```

(incf num-guesses) (setf guess (read)) (format t "Your guess is ~[not a number.~;too small.~;too large.~;correct!~]~%" (cond ((not (numberp guess)) 0) ((< guess num) 1) ((> guess num) 2) ((= guess num) 3))) until (and (numberp guess) (= guess num)))

```   (format t "You got the number correct on the ~:r guess!~%" num-guesses)))
```

</lang> Output:

```CL-USER> (guess-the-number-feedback 1 1024)
Try to guess a number from 1 to 1,024!
Guess? 512
Guess? 768
Guess? 896
Guess? 832
Guess? 864
Guess? 848
Guess? 840
Guess? 836
You got the number correct on the eighth guess!
```

## Delphi

<lang Delphi>program GuessTheNumber;

{\$APPTYPE CONSOLE}

uses

``` SysUtils,
Math;
```

const

``` // Set min/max limits
min: Integer = 1;
max: Integer = 10;
```

var

``` last,
val,
inp: Integer;
s: string;
```
``` // Initialise new game
procedure NewGame;
begin
// Make sure this number isn't the same as the last one
repeat
val := RandomRange(min,max);
until
val <> last;
```
```   // Save this number
last := val;
Writeln('Guess a number between ', min, ' and ', max, ' [Answer = ', val, ']');
end;
```

begin

``` // Initialise the random number generator with a random value
Randomize;
```
``` // Initialise last number
last := 0;

// Initialise user input
s := ;
```
``` // Start game
NewGame;
```
``` // Loop
repeat
// User input
```
```   // Validate - checxk if input is a number
if TryStrToInt(s,inp) then
begin
// Is it the right number?
if (inp = val) then
begin
// Yes - request a new game
Writeln('Correct! Another go? Y/N');
if SameText(s,'Y') then
// Start new game
NewGame
else
Exit;
end
else
// Input too low/high
if (inp < val) then
Writeln('Too low! Try again...')
else
if (inp > val) then
Writeln('Too high! Try again...');
end
else
// Input invalid
if not SameText(s,'bored') then
Writeln('Invalid input! Try again...');

until
SameText(s,'bored');
```

end. </lang>

## Ela

<lang ela>open Core open Con open Char open DateTime

let rnd' v = rnd s 1 v where s = milliseconds <| now!

let start () =

```       match bound! with
Some v = writen ("Guess a number from 1 to " ++ v) \$ guess <| rnd' v
None   = start!
et bound () =
writen "What's the upper bound?" \$ bound' <| toInt <| readn!
where bound' v | v <= 0 = writen "Bound should be greater than 0." \$ None
| else   = Some v
et success v =
writen "Correct! Do you want to continue? (Y/N)" \$ ask!
et failed v n =
writen ("No, this is not " ++ v ++ ". " ++ hint) \$ guess n
where hint | v < n = "Try bigger."
| else  = "Try smaller."
et guess n = g <| toInt <| readn!
where g v | v == n = success v
| else   = failed v n
```

start!</lang>

## Euphoria

<lang euphoria>include get.e

constant lower_limit = 0, upper_limit = 100

integer number, guess number = rand(upper_limit-lower_limit+1)+lower_limit

printf(1,"Guess the number between %d and %d: ", lower_limit & upper_limit) while 1 do

```   guess = floor(prompt_number("", lower_limit & upper_limit))
if number = guess then
puts(1,"You guessed correctly!\n")
exit
elsif number < guess then
puts(1,"You guessed too high.\nTry again: ")
else
puts(1,"You guessed to low.\nTry again: ")
end if
```

end while</lang>

## Fantom

<lang fantom> class Main {

``` public static Void main ()
{
Int lowerLimit := 1
Int higherLimit := 100
```
```   Int target := (lowerLimit..higherLimit).random
Int guess
while (guess != target)
{
echo ("Enter a guess: ")
try
{
// read in a line of input, and try to interpret as an Int
if (guess == target)
{
echo ("Well guessed!")
}
else if (guess < target)
{
echo ("Failed - your guess is too small")
}
else // if (guess > target)
{
echo ("Failed - your guess is too large")
}
}
catch (Err e)
{
echo ("Your guess must be an integer")
}
}
}
```

} </lang>

Sample game:

```Enter a guess:
50
Failed - your guess is too small
Enter a guess:
75
Failed - your guess is too large
Enter a guess:
67
Failed - your guess is too large
Enter a guess:
60
Failed - your guess is too large
Enter a guess:
55
Failed - your guess is too large
Enter a guess:
53
Failed - your guess is too small
Enter a guess:
54
Well guessed!
```

## Fortran

Works with: Fortran version 95 and later

<lang fortran>program Guess_a_number

``` implicit none

integer, parameter :: limit = 100
integer :: guess, number
real :: rnum

write(*, "(a, i0, a)") "I have chosen a number between 1 and ", limit, &
" and you have to try to guess it."
write(*, "(a/)")  "I will score your guess by indicating whether it is higher, lower or the same as that number"

call random_seed
call random_number(rnum)
number = rnum * limit + 1
do
write(*, "(a)", advance="no") "Enter quess: "
if(guess < number) then
write(*, "(a/)") "That is lower"
else if(guess > number) then
write(*, "(a/)") "That is higher"
else
write(*, "(a)") "That is correct"
exit
end if
end do
```

end program</lang> Output

```I have chosen a number bewteen 1 and 100 and you have to try to guess it.
I will score your guess by indicating whether it is higher, lower or the same as that number.

Enter guess: 50
That is lower

Enter guess: 75
That is higher

Enter guess: 62
That is higher

Enter guess: 57
That is correct```

## Go

<lang go>package main

import (

```   "fmt"
"math/rand"
"time"
```

)

const lower, upper = 1, 100

func main() {

```   fmt.Printf("Guess integer number from %d to %d: ", lower, upper)
rand.Seed(time.Now().Unix())
n := rand.Intn(upper-lower+1) + lower
for guess := n; ; {
switch _, err := fmt.Scan(&guess); {
case err != nil:
fmt.Println("\n", err, "So, bye.")
return
case guess < n:
fmt.Print("Too low. Try again: ")
case guess > n:
fmt.Print("Too high. Try again: ")
default:
fmt.Println("Well guessed!")
return
}
}
```

}</lang>

-- Repeat the action until the predicate is true. until_ act pred = act >>= pred >>= flip unless (until_ act pred)

``` case compare ans guess of
LT -> putStrLn "Too high. Guess again." >> return False
EQ -> putStrLn "You got it!" >> return True
GT -> putStrLn "Too low. Guess again." >> return False
```

-- Repeatedly read until the input *starts* with a number. (Since -- we use "reads" we allow garbage to follow it, though.) ask = do line <- getLine

```        case reads line of
((num,_):_) -> return num
```

main = do

``` ans <- randomRIO (1,100) :: IO Int
putStrLn "Try to guess my secret number between 1 and 100."
```

</lang>

## Icon and Unicon

<lang Icon> procedure main()

```   smallest := 5
highest := 25
n := smallest-1 + ?(1+highest-smallest)
repeat {
writes("Pick a number from ", smallest, " through ", highest, ": ")

if n = numeric(guess)
then {
write ("Well guessed!")
exit ()
}
else if n < numeric(guess)
then write ("Your guess is too high")
else if n > numeric(guess)
then write ("Your guess is too low")
else write ("Did you enter a number?")
}
```

end </lang>

Output:

```\$ ./guess-feedback
Pick a number from 5 through 25: 10
Pick a number from 5 through 25: 16
Pick a number from 5 through 25: 20
Pick a number from 5 through 25: 23
Pick a number from 5 through 25: 22
Well guessed!
```

## J

<lang j>require 'misc' game=: verb define

``` assert. y -: 1 >. <.{.y
n=: 1 + ?y
smoutput 'Guess my integer, which is bounded by 1 and ',":y
whilst. -. x -: n do.
x=. {. 0 ". prompt 'Guess: '
if. 0 -: x do. 'Giving up.' return. end.
smoutput (*x-n){::'You win.';'Too high.';'Too low.'
end.
```

)</lang>

Note: in computational contexts, J programmers typically avoid loops. However, in contexts which involve progressive input and output and where event handlers are too powerful (too complicated), loops are probably best practice.

Example use:

<lang> game 100 Guess my integer, which is bounded by 1 and 100 Guess: 64 Too high. Guess: 32 Too low. Guess: 48 Too high. Guess: 40 Too low. Guess: 44 You win.</lang>

## Java

<lang Java>import java.util.Random; import java.util.Scanner; public class Main {

```   public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
Random random = new Random();
long from = 1;
long to = 100;
int randomNumber = random.nextInt(to - from + 1) + from;
int guessedNumber = 0;
```
```       System.out.printf("The number is between %d and %d.\n", from, to);
```
```       do
{
System.out.print("Guess what the number is: ");
guessedNumber = scan.nextInt();
if (guessedNumber > randomNumber)
else if (guessedNumber < randomNumber)
else
System.out.println("You got it!");
} while (guessedNumber != randomNumber);
}
```

}</lang> Demonstration:

```The number is between 1 and 100.
Guess what the number is: 50
Guess what the number is: 25
Guess what the number is: 17
Guess what the number is: 10
Guess what the number is: 5
Guess what the number is: 7
You got it!```

## JavaScript

<lang html4strict>

Pick a number between 1 and 100.

<form id="guessNumber">

```   <input type="text" name="guess">
<input type="submit" value="Submit Guess">
```

</form>

<script type="text/javascript"></lang> <lang javascript>var number = Math.ceil(Math.random() * 100);

function verify() {

```   var guess = Number(this.elements.guess.value),
output = document.getElementById('output');

if (isNaN(guess)) {
output.innerHTML = 'Enter a number.';
} else if (number === guess) {
output.innerHTML = 'You guessed right!';
} else if (guess > 100) {
output.innerHTML = 'Your guess is out of the 1 to 100 range.';
} else if (guess > number) {
output.innerHTML = 'Your guess is too high.';
} else if (guess < number) {
output.innerHTML = 'Your guess is too low.';
}
return false;
```

}

document.getElementById('guessNumber').onsubmit = verify;</lang> <lang html4strict></script></lang>

## Liberty BASIC

<lang lb> [start]

```   target = int( rnd( 1) * 100) +1
```

while 1

```   do
input "Guess a whole number between 1 and 100. To finish, type 'exit' "; b\$
if b\$ ="exit" then print "Thank you for playing!": end
c = val( b\$)
ok =( c =int( c)) and ( c >=1) and ( c <=100)
if ok =0 then notice "Invalid data. Integers 1 to 100 only."
loop until ok <>0
```
```   if c =target       then print "      You guessed correctly.": print: goto [start]
if c <target       then print "   Your guess was too low."
if c >target       then print "   Your guess was too high."
```

wend </lang>

## Locomotive Basic

<lang locobasic>10 CLS:RANDOMIZE TIME 20 PRINT "Please specify lower and upper limits":guess=0 30 INPUT " (must be positive integers) :", first, last 40 IF first<1 OR last<1 THEN 20 50 num=INT(RND*(last-first+1)+first) 60 WHILE num<>guess 70 INPUT "Your guess? ", guess 80 IF guess<num THEN PRINT "too small!" 90 IF guess>num THEN PRINT "too large!" 100 WEND 110 INPUT "That's correct! Another game (y/n)? ", yn\$ 120 IF yn\$="y" THEN 20 </lang>

Output:

## Logo

Translation of: UNIX Shell

<lang logo>to guess [:max 100]

``` local "number
make "number random :max
local "guesses
make "guesses 0
```
``` local "guess
forever [
(type [Guess my number! \(range 1 -\ ] :max "\):\ )
ifelse (or (not numberp :guess) (lessp :guess 1) (greaterp :guess :max)) [
print sentence [Guess must be a number between 1 and] (word :max ".)
] [
make "guesses (:guesses + 1)
ifelse lessp :guess :number [
print [Too low!]
] [ifelse equalp :guess :number [
(print [You got it in] :guesses "guesses!)
stop
] [
print [Too high!]
]]
]
]
```

end </lang>

Sample run:

```? guess
Guess my number! (range 1 - 100): 50
Too low!
Guess my number! (range 1 - 100): 75
Too high!
Guess my number! (range 1 - 100): 67
Too low!
Guess my number! (range 1 - 100): 71
Too high!
Guess my number! (range 1 - 100): 69
You got it in 5 guesses!
```

## Lua

<lang Lua>math.randomseed(os.time()) me_win=false my_number=math.random(1,10) while me_win==false do print "Guess my number from 1 to 10:" your_number = io.stdin:read'*l' if type(tonumber(your_number))=="number" then your_number=tonumber(your_number) if your_number>10 or your_number<1 then print "Your number was not between 1 and 10, try again." elseif your_number>my_number then print "Your number is greater than mine, try again." elseif your_number<my_number then print "Your number is smaller than mine, try again." elseif your_number==my_number then print "That was correct." me_win=true end else print "Your input was not a number, try again." end end </lang>

```Output:

Guess my number from 1 to 10:
4
Your number is smaller than mine, try again.
Guess my number from 1 to 10:
8
Your number is greater than mine, try again.
Guess my number from 1 to 10:
5
That was correct.
```

## Mirah

<lang mirah>def getInput:int

``` s = System.console.readLine()
Integer.parseInt(s)
```

end

number = int(Math.random() * 10 + 1)

puts "Guess the number between 1 and 10"

guessed = false

while !guessed do

``` begin
userNumber = getInput
if userNumber == number
guessed = true
puts "You guessed it."
elsif userNumber > number
puts "Too high."
else
puts "Too low."
end
rescue NumberFormatException => e
end
```

end</lang>

## Modula-2

<lang modula2>MODULE guessf;

IMPORT InOut, Random, NumConv, Strings;

VAR number, guess  : CARDINAL;

```       input                   : Strings.String;
OK, Done                : BOOLEAN;
```

BEGIN

``` number := Random.nr (1000);
InOut.WriteString ("I have chosen a number below 1000; please try to guess it.");
InOut.WriteLn;
REPEAT
REPEAT
InOut.WriteString ("Enter your guess : ");        InOut.WriteBf;
NumConv.Str2Num (guess, 10, input, OK);
IF  NOT OK  THEN
InOut.WriteString (input);
InOut.WriteString (" is not a valid number...");
InOut.WriteLn
END
UNTIL  OK;
IF  number = guess  THEN
Done := TRUE;
InOut.WriteString ("spot on!")
ELSE
Done := FALSE;
IF  guess > number  THEN
InOut.WriteString ("too high.")
ELSE
InOut.WriteString ("too low.")
END
END;
InOut.WriteLn
UNTIL  Done;
InOut.WriteString ("Thank you for playing; have a nice day!");
InOut.WriteLn
```

END guessf.</lang>

```I have chosen a number below 1000; please try to guess it.
kwak is not a valid number...
Thank you for playing; have a nice day!```

## Nemerle

<lang Nemerle>using System; using System.Console;

module GuessHints {

```   Main() : void
{
def     rand   = Random();
def     secret = rand.Next(1, 101);
mutable guess  = 0;

WriteLine("Guess a number between 1 and 100:");

do
{
guess = GetGuess();
match(guess.CompareTo(secret))
{
|(-1) => WriteLine("Too low! Guess again:")
|1    => WriteLine("Too high! Guess again:")
|0    => WriteLine("Well guessed!")
}
} while (guess != secret)
}
```

}</lang>

## NewLISP

<lang NewLISP>; guess-number-feedback.lsp

oofoe 2012-01-19
http://rosettacode.org/wiki/Guess_the_number/With_feedback

(seed (time-of-day)) ; Initialize random number generator from clock. (setq low -5

```     high 62
number (+ low (rand (- high low)))
found nil
```

)

(print "I'm thinking of a number between " low " and " high ".")

``` (print " What's your guess? ")
(print (cond ((= 'bad guess) "That's not a number! Try again!")
((or (< guess low) (> guess high))
(string "My number is between " low
" and " high ". Try again!"))
((< number guess) "Try a little lower...")
((> number guess) "Maybe a bit higher...")
((= number guess) (setq found true) "Exactly right!")))
)
```

(println "\nWell guessed! Congratulations!")

(exit)</lang>

Sample output:

```I'm thinking of a number between -5 and 62. What's your guess? No idea.
That's not a number! Try again! What's your guess? 99
My number is between -5 and 62. Try again! What's your guess? -5
Maybe a bit higher... What's your guess? 30
Try a little lower... What's your guess? 15
Try a little lower... What's your guess? 0
Maybe a bit higher... What's your guess? 3
Try a little lower... What's your guess? 1
Exactly right!
Well guessed! Congratulations!

```

## OCaml

``` try read_int()
with _ ->
print_endline "Please give a cardinal numbers.";
(* TODO: what is the correct word? cipher, digit, figure or numeral? *)
```

let () =

``` print_endline "Please give a set limits (two integers):";
let a, b =
if a < b
then (a, b)
else (b, a)
in
Random.self_init();
let target = a + Random.int (b - a) in
Printf.printf "I have choosen a number between %d and %d\n%!" a b;
let rec loop () =
if guess = target then
begin
print_endline "The guess was equal to the target.\nCongratulation!";
exit 0
end;
if guess < a || guess > b then
print_endline "The input was inappropriate."
else if guess > target then
print_endline "The guess was higher than the target."
else if guess < target then
print_endline "The guess was less than the target.";
loop ()
in
loop ()</lang>
```

Playing the game:

```\$ ocaml inapropriate.ml
Please give a set limits (two integers):
3
7
I have choosen a number between 3 and 7
6
The guess was higher than the target.
7
The guess was higher than the target.
8
The input was inappropriate.
3
The guess was less than the target.
4
The guess was equal to the target.
Congratulation!```
```\$ ocaml inapropriate.ml
Please give a set limits (two integers):
2
6
I have choosen a number between 2 and 6
three
```

## PARI/GP

<lang parigp>guess_the_number(N=10)={ a=random(N); print("guess the number between 0 and "N); for(x=1,N, if(x>1, if(b>a, print("guess again lower") , print("guess again higher") ); b=input(); if(b==a,break()) ); print("You guessed it correctly") };</lang>

See Delphi

## Perl

<lang Perl>sub prompt { my \$prompt = shift; while (1) { print "\n", \$prompt, ": "; # type ^D, q, quit, quagmire, etc to quit defined(\$_ = <STDIN>) and !/^\s*q/ or exit;

return \$_ if /^\s*\d+\s*\$/s; \$prompt = "Please give a non-negative integer"; } }

my \$tgt = int(rand prompt("Hola! Please tell me the upper bound") + 1); my \$tries = 1;

\$tries++, print "You guessed too ", (\$_ == -1 ? "high" : "low"), ".\n" while (\$_ = \$tgt <=> prompt "Your guess");

print "Correct! You guessed it after \$tries tries.\n";</lang>

## Perl 6

<lang perl6>my \$maxnum = prompt("Hello, please give me an upper boundary: "); until 0 < \$maxnum < Inf {

```   say "Oops! The upper boundary should be > 0 and not Inf";
\$maxnum = prompt("Please give me a valid upper boundary: ");
```

}

my \$count = 0; my \$number = (1..\$maxnum).pick;

say "I'm thinking of a number from 1 to \$maxnum, try to guess it!"; repeat until my \$guessed-right {

```   given prompt("Your guess: ") {
when /^[e|q]/ { say 'Goodbye.'; exit; }
when not 1 <= \$_ <= \$maxnum {
say "You really should give me a number from 1 to \$maxnum."
}
\$count++;
when \$number { \$guessed-right = True }
when \$number < \$_ { say "Sorry, my number is smaller." }
when \$number > \$_ { say "Sorry, my number is bigger." }
}
```

} say "Great you guessed right after \$count attempts!";</lang>

```Hello, please give me an upper boundary: 10
I'm thinking of a number from 1 to 10, try to guess it!
Sorry, my number is bigger.
Sorry, my number is smaller.
Great you guessed right after 3 attempts!```

## PHP

<lang php> <?php

session_start();

if(isset(\$_SESSION['number'])) {

```  \$number = \$_SESSION['number'];
```

} else {

```  \$_SESSION['number'] = rand(1,10);
```

}

if(\$_POST["guess"]){

```   \$guess  = htmlspecialchars(\$_POST['guess']);
```

echo \$guess . "
";

```   if (\$guess < \$number)
```

{

```       echo "Your guess is too low";
}
```

elseif(\$guess > \$number) {

```       echo "Your guess is too high";
}
```

elseif(\$guess == \$number) {

```       echo "You got the correct number!";
}

```

} ?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>Guess A Number</title> </head>

<body> <form action="<?=\$_SERVER['PHP_SELF'] ?>" method="post" name="guess-a-number"> <label for="guess">Guess A Number:</label>
<input type="text" name="guess" /> <input name="number" type="hidden" value="<?= \$number ?>" /> <input name="submit" type="submit" /> </form> </body> </html> </lang>

## PicoLisp

Translation of: PureBasic

<lang PicoLisp>(de guessTheNumber ()

```  (use (Low High Guess)
(until
(and
(prin "Enter low limit : ")
(prin "Enter high limit: ")
(> High Low) ) )
(seed (time))
(let Number (rand Low High)
(loop
(prin "Guess what number I have: ")
(T (= Number (setq Guess (read)))
(prinl "You got it!") )
(prinl
(if (> Number Guess) "low" "high")
"." ) ) ) ) )</lang>
```

Output:

```: (guessTheNumber)
Enter low limit : 1
Enter high limit: 64
Guess what number I have: 32
Guess what number I have: 16
Guess what number I have: 24
You got it!```

## PureBasic

<lang PureBasic>OpenConsole()

Repeat

``` ; Ask for limits, with sanity check
Print("Enter low limit : "): low  =Val(Input())
Print("Enter high limit: "): High =Val(Input())
```

Until High>low

TheNumber=Random(High-low)+low Debug TheNumber Repeat

``` Print("Guess what number I have: "): Guess=Val(Input())
If Guess=TheNumber
PrintN("You got it!"): Break
ElseIf Guess < TheNumber
Else
EndIf
```

ForEver</lang>

## Python

<lang python>import random

inclusive_range = (1, 100)

print("Guess my target number that is between %i and %i (inclusive).\n"

```     % inclusive_range)
```

target = random.randint(*inclusive_range) answer, i = None, 0 while answer != target:

```   i += 1
txt = input("Your guess(%i): " % i)
try:
except ValueError:
print("  I don't understand your input of '%s' ?" % txt)
continue
print("  Out of range!")
continue
print("  Ye-Haw!!")
break
if answer < target: print("  Too low.")
if answer > target: print("  Too high.")
```

print("\nThanks for playing.")</lang>

Sample Game

```Guess my target number that is between 1 and 100 (inclusive).

Too high.
Too low.
Too high.
Too low.
Too high.
Too high.
Too high.
Ye-Haw!!

Thanks for playing.```

Sample trapped Errors

```Guess my target number that is between 1 and 100 (inclusive).

Out of range!
Out of range!
I don't understand your input of 'Howdy' ?

## Retro

<lang Retro>: high|low ( gn-g\$ )

``` over > [ "high" ] [ "low" ] if ;
```
checkGuess ( gn-gf || f )
``` 2over = [ "You guessed correctly!\n" puts 2drop 0 ]
[ high|low "Sorry, your guess was too %s.\nTry again.\n" puts -1 ] if ;
```
think ( -n )
``` random abs 100 mod 1+ ;
```
guess ( - )
``` "I'm thinking of a number between 1 and 100.\n" puts
"Try to guess it!\n" puts
think [ getToken toNumber checkGuess ] while
"You got it!\n" puts ;
```

</lang>

## REXX

<lang rexx>/*REXX program that plays the guessing (the number) game. */

```low=1                /*lower range for the guessing game.*/
```

high=100 /*upper range for the guessing game.*/ try=0 /*number of valid attempts. */ r=random(1,100) /*get a random number (low-->high). */

```lows='low small below puny'
```

highs='high big above huge'

``` do forever
say
say "guess the number, it's between" low 'and',
high '(inclusive)   ---or---  QUIT:'
say
pull g
say
g=space(g)
if g== then iterate
if g=='QUIT' then exit
```
``` if \datatype(g,'W') then do
call ser g "isn't a whole number"
iterate
end
if g<low then do
call ser g 'is below the lower limit of' low
iterate
end
```
``` if g>high then do
call ser g 'is above the higher limit of' low
iterate
end
```
``` try=try+1
if g==r then leave
if g>r then what=word(highs,random(1,words(highs)))
else what=word( lows,random(1,words( lows)))
say 'your guess of' g "is" what'.'
end
```

tries='tries' if try==1 then do; try='one'; tries="try"; end say say 'Congratulations!, you guessed the number in' try tries"." say exit

ser: say; say '*** error ! ***'; say arg(1); say; return</lang>

## Ruby

Translation of: Mirah

<lang ruby>number = rand(1..10)

puts "Guess the number between 1 and 10"

guessed = false

until guessed do

``` begin
user_number = Integer(gets)
if user_number == number
guessed = true
puts "You guessed it."
elsif user_number > number
puts "Too high."
else
puts "Too low."
end
rescue ArgumentError => e
end
```

end</lang>

## Scheme

Works with: Chicken Scheme
Works with: Guile

<lang scheme>(define maximum 5) (define minimum -5) (define number (+ (random (- (+ maximum 1) minimum)) minimum))

(display "Pick a number from ") (display minimum) (display " through ") (display maximum) (display ".\n> ") (do ((guess (read) (read))) ((eq? guess number))

```       (if (or (>= guess maximum) (< guess minimum))
(display "Out of range!\n> ")
(begin
(if (> guess number)
(display "Too high!\n> "))
(if (< guess number)
(display "Too low!\n> ")))))
```

(display "Correct!\n")</lang>

## Seed7

<lang seed7>\$ include "seed7_05.s7i";

const integer: lower_limit is 0; const integer: upper_limit is 100;

const proc: main is func

``` local
var integer: number is 0;
var integer: guess is 0;
begin
number := rand(lower_limit, upper_limit);
write("Guess the number between " <& lower_limit <& " and " <& upper_limit <& ": ");
while IN.io_ok and number <> guess do
if number < guess then
writeln("high.");
else
writeln("low.");
end if;
write("Try again: ");
end while;
if number = guess then
writeln("You guessed correctly!");
else
writeln("You gave up!");
end if;
end func;</lang>
```

## Tcl

<lang tcl>set from 1 set to 10 set target [expr {int(rand()*(\$to-\$from+1) + \$from)}] puts "I have thought of a number from \$from to \$to." puts "Try to guess it!" while 1 {

```   puts -nonewline "Enter your guess: "
flush stdout
gets stdin guess
if {![string is int -strict \$guess] || \$guess < \$from || \$guess > \$to} {
```

puts "Your guess should be an integer from \$from to \$to (inclusive)."

```   } elseif {\$guess > \$target} {
```

puts "Your guess was too high. Try again!"

```   } elseif {\$guess < \$target} {
```

puts "Your guess was too low. Try again!"

```   } else {
```

puts "Well done! You guessed it." break

```   }
```

}</lang> Sample output:

```I have thought of a number from 1 to 10.
Try to guess it!

Your guess was too low. Try again!
Your guess should be an integer from 1 to 10 (inclusive).
Your guess was too high. Try again!
Your guess was too low. Try again!
Your guess was too high. Try again!
Well done! You guessed it.
```

## TUSCRIPT

<lang tuscript> \$\$ MODE TUSCRIPT PRINT "Find the luckynumber (7 tries)!" SET luckynumber=RANDOM NUMBERS (1,100,1) LOOP round=1,7 SET message=CONCAT ("[",round,"] Please insert a number") ASK \$message: n=""

```IF (n!='digits') THEN
PRINT "wrong insert: ",n," Please insert a digit"
ELSEIF (n>100.or.n<1) THEN
PRINT "wrong insert: ",n," Please insert a number between 1-100"
ELSEIF (n==#luckynumber) THEN
PRINT "BINGO"
EXIT
ELSEIF (n.gt.#luckynumber) THEN
PRINT "too big"
ELSEIF (n.lt.#luckynumber) THEN
PRINT "too small"
```

ENDIF IF (round==7) PRINT/ERROR "You've lost: luckynumber was: ",luckynumber ENDLOOP </lang> Output:

```Find the luckynumber (7 tries)!
[1] Please insert a number >51
too small
[2] Please insert a number >76
too small
[3] Please insert a number >89
too big
[4] Please insert a number >80
too small
[5] Please insert a number >84
too small
[6] Please insert a number >86
too small
[7] Please insert a number >88
too big
@@@@@@@@  You've lost: luckynumber was: 87
```

## UNIX Shell

Works with: Bourne Again SHell
Works with: Z SHell

<lang sh>function guess {

``` -n \$BASH_VERSION  && shopt -s extglob
-n \$ZSH_VERSION  && set -o KSH_GLOB
local -i max=\${1:-100}
local -i number=RANDOM%max+1
local -i guesses=0
```
``` local guess
while true; do
echo -n "Guess my number! (range 1 - \$max): "
if [[ "\$guess" != +([0-9]) ]] || (( guess < 1 || guess > max )); then
echo "Guess must be a number between 1 and \$max."
continue
fi
let guesses+=1
if (( guess < number )); then
echo "Too low!"
elif (( guess == number )); then
echo "You got it in \$guesses guesses!"
break
else
echo "Too high!"
fi
done
```

}</lang>

Sample run:

```\$ guess
Guess my number! (range 1 - 100): 50
Too low!
Guess my number! (range 1 - 100): 75
Too high!
Guess my number! (range 1 - 100): 62
Too low!
Guess my number! (range 1 - 100): 69
Too low!
Guess my number! (range 1 - 100): 72
You got it in 5 guesses!
```

## Vala

<lang vala> void main(){ const int from = 1; const int to = 100;

int random = Random.int_range(from, to); int guess = 0;

while (guess != random){ stdout.printf("Guess the target number that's between %d and %d.\n", from, to);

string? num = stdin.read_line (); num.canon("0123456789", '!'); // replaces any character in num that's not in "0123456789" with "!"

if ("!" in num) stdout.printf("Please enter a number!\n");

else{ guess = int.parse(num);

if (guess > random && guess <= to) stdout.printf("Too high!\n"); if (guess < random && guess >= from) stdout.printf("Too low!\n"); if (guess == random) stdout.printf("You guess it! You win!\n"); if (guess < from || guess > to) stdout.printf("%d Your guess isn't even in the right range!\n", guess); }

}//while } // main </lang>

Shorter but no error checking <lang vala>int main() {

```       int guess, x = Random.int_range(1, 10);
stdout.printf("Make a guess (1-10): ");
while((guess = int.parse(stdin.read_line())) != x) {
stdout.printf("%s! Try again: ", x < guess ? "Lower" : "Higher");
}
stdout.printf("Got it!\n");
return 0;
```

}</lang>

## XPL0

<lang XPL0>include c:\cxpl\codes; int Lo, Hi, C, Guess, Number;

[loop [Text(0, "Low limit: "); Lo:= IntIn(0);

```       Text(0, "High limit: ");  Hi:= IntIn(0);
if Lo < Hi then quit;
Text(0, "Low limit must be lower!^M^J^G");
];
```

Number:= Ran(Hi-Lo+1)+Lo; Text(0, "I'm thinking of a number between "); IntOut(0, Lo); Text(0, " and "); IntOut(0, Hi); Text(0, ".^M^J"); repeat Text(0, "Can you guess the number? ");

```       loop    [C:= ChIn(0);
if C>=^0 & C<=^9 then quit;
Text(0, "Please enter a number in the given range.^M^J");
OpenI(0);
];
Backup;  Guess:= IntIn(0);
Text(0, if Guess = Number then "Correct!"
else if Guess > Number then "Nope, too high."
else "You're too low.");
CrLf(0);
```

until Guess = Number; ]</lang>

Example output:

```Low  limit: 1
High limit: 10
I'm thinking of a number between 1 and 10.
Can you guess the number? maybe
Please enter a number in the given range.
3
You're too low.
Can you guess the number? 6
You're too low.
Can you guess the number? 8
Correct!
```