Guess the number/With feedback: Difference between revisions

*   [[Guess the number/With Feedback (Player)]]

<br><br>

 

=={{header|Ada}}==

 

with Ada.Text_IO;

procedure Guess_Number_Feedback is

procedure Guess_Number (Lower_Limit : Integer; Upper_Limit : Integer) is

subtype Number is Integer range Lower_Limit .. Upper_Limit;

package Number_RNG is new Ada.Numerics.Discrete_Random (Number);

Generator : Number_RNG.Generator;

My_Number : Number;

begin

Number_RNG.Reset (Generator);

Ada.Text_IO.Put_Line ("Guess my number!");

loop

exit when Your_Guess = My_Number;

if Your_Guess > My_Number then

Ada.Text_IO.Put_Line ("Well guessed!");

end Guess_Number;

Lower_Limit : Integer;

Upper_Limit : Integer;

begin

loop

exit when Lower_Limit < Upper_Limit;

Ada.Text_IO.Put_Line ("Lower limit must be lower!");

end loop;

Guess_Number (Lower_Limit, Upper_Limit);

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

 

main:(

OD;

print( ( "That's correct!", newline ) )

{{out}}

<pre>

=={{header|AppleScript}}==

 

property minLimit : 1

property maxLimit : 100

end try

end repeat

 

=={{header|AutoHotkey}}==

 

MaxNum = 99999999999

 

}

TotalTime := Round((A_TickCount - TotalTime) / 1000,1)

 

=={{header|AWK}}==

# syntax: GAWK -f GUESS_THE_NUMBER_WITH_FEEDBACK.AWK

BEGIN {

exit(0)

}

 

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

110 U% = 10

120 N% = RND(1) * (U% - L% + 1) + L%

210 Q = G% = N%

220 NEXT

 

==={{header|BASIC256}}===

{{works with|BASIC256 }}

chosen = int(rand*(Max-Min+1)) + Min

print "Guess a whole number between "+Min+" and "+Max

if guess = chosen then print "Well guessed!"

end if

Output:(example)

Enter your number 10

Sorry, your number was too high

Sorry, your number was too low

Enter your number 8

 

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

110 RANDOMIZE

120 LET UP=10:LET LO=1 ! Limits

240 PRINT "Well guessed! Numner of tips:";COUNT

250 END SELECT

 

=={{header|Batch File}}==

 

:A

echo You won! The number was %number%

pause>nul

 

=={{header|BBC BASIC}}==

Max% = 10

chosen% = RND(Max%-Min%+1) + Min% - 1

ENDCASE

UNTIL FALSE

 

=={{header|Befunge}}==

 

The number range is hardcoded at the start of the program (<tt>1:"d"</tt> being 1 to 100), but can easily be changed.

 

<*2\_$\1+%+48*">",,#v>#+:&#>#5-:!_0`00p0"hgih"00g>_0"wol"00g!>_48vv1?

\1-:^v"d correctly!"<^,,\,+55,". >"$_,#!>#:<"Your guess was too"*<>+>

 

{{out}}

 

=={{header|Brat}}==

 

p "Guess a number between 1 and 10."

}

}

 

=={{header|C}}==

#include <stdio.h>

#include <time.h>

 

printf( "Guess the number between %d and %d: ", lower_limit, upper_limit );

 

while( scanf( "%d", &guess ) == 1 ){

 

return 0;

 

Demonstration:

Try again: 59

You guessed correctly!</pre>

 

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

 

class Program

}

}

Output:

<pre>The number is between 1 and 10. Make a guess: 1

Press any key to exit.

</pre>

 

=={{header|Ceylon}}==

In you module.ceylon file put import ceylon.random "1.3.1";

 

DefaultRandom

}

}

}

 

=={{header|Clojure}}==

(let [start 1

end 100

:else true)

(println "Correct")

 

=={{header|COBOL}}==

PROGRAM-ID. Guess-With-Feedback.

 

GOBACK

 

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

(let ((num-guesses 0)

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

(= guess num)))

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

Output:

<pre>CL-USER> (guess-the-number-feedback 1 1024)

You got the number correct on the eighth guess!

</pre>

 

=={{header|D}}==

{{trans|Python}}

std.range;

 

writeln(answer < target ? " Too low." : " Too high.");

}

Sample game:

<pre>Guess my target number that is between 1 and 100 (inclusive).

Your guess #9: 83

Well Guessed.</pre>

=={{header|DCL}}==

$ count = 0

$ loop:

$ if guess .gt. rnd then $ write sys$output "too large"

$ if guess .ne. rnd then $ goto loop

{{out}}

<pre>$ @guess

=={{header|Delphi}}==

 

 

{$APPTYPE CONSOLE}

 

end.

 

 

=={{header|EchoLisp}}==

;;(read <default-value> <prompt>) prompts the user with a default value using the browser dialog box.

;; we play sounds to make this look like an arcade game

(play-sound 'ok )

" 🔮 Well played!! 🍒 🍇 🍓")

 

=={{header|Ela}}==

 

 

guess () = do

ask ()

 

=={{header|Elena}}==

until(numberCorrect)

if (randomNumber == userGuess)

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def play(lower, upper) do

play(lower, upper, Enum.random(lower .. upper))

end

 

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

-module(guess_number).

-export([main/0]).

guess(N)

end.

{{out}}

<pre>1> c(guess_number).

 

=={{header|Euphoria}}==

 

constant lower_limit = 0, upper_limit = 100

puts(1,"You guessed to low.\nTry again: ")

end if

 

=={{header|Factor}}==

formatting

fry

[ unparse "Number in range %s, your guess?\n" printf flush ]

[ random '[ _ game-step ] loop ]

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

Sample game:

Well guessed!

</pre>

 

=={{header|Fortran}}==

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

implicit none

end if

end do

Output

<pre>I have chosen a number bewteen 1 and 100 and you have to try to guess it.

 

=={{header|FreeBASIC}}==

 

Randomize

End If

Loop

 

Sample input/output

Correct, well guessed!

</pre>

 

=={{header|Go}}==

 

import (

}

}

 

=={{header|Groovy}}==

Based on the Java implementation

def rand = new Random() // java.util.Random

def range = 1..100 // Range (inclusive)

}

}

Example:

The number is in 1..100

Guess the number: ghfvkghj

Guess the number: 92

Your guess is spot on!

 

=={{header|Haskell}}==

import Control.Monad

import System.Random

putStrLn "Try to guess my secret number between 1 and 100."

ask `until_` answerIs ans

 

=={{header|HolyC}}==

U8 min = 1, max = 100;

 

if (Str2I64(g) > n)

Print("Your guess was too high.\nTry again: ");

 

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

 

procedure main()

smallest := 5

}

end

 

Output:

 

=={{header|J}}==

game=: verb define

assert. y -: 1 >. <.{.y

smoutput (*x-n){::'You win.';'Too high.';'Too low.'

end.

 

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:

 

Guess my integer, which is bounded by 1 and 100

Guess: 64

Too low.

Guess: 44

 

=={{header|Java}}==

import java.util.Scanner;

public class Main

} while (guessedNumber != randomNumber);

}

Demonstration:

<pre>The number is between 1 and 100.

 

=={{header|JavaScript}}==

<form id="guessNumber">

<input type="text" name="guess">

</form>

<p id="output"></p>

function verify() {

}

 

 

=== Spidermonkey Version ===

 

function main() {

 

main();

 

Example session:

Your guess: 57

You got it in 6 tries.

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

number = rand(1:n)

print("I choose a number between 1 and $n\nYour guess? ")

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

val n = 1 + rand.nextInt(20)

println("Guess which number I've chosen in the range 1 to 20\n")

while (true) {

print(" Your guess : ")

when (guess) {

n -> { println("Correct, well guessed!") ; return }

}

}

Sample inout/output

{{out}}

Your guess : 2

Correct, well guessed!

</pre>

 

=={{header|Lasso}}==

 

local(

#status = true

}

 

With range value 8 and 73. Correct number 13

 

=={{header|LFE}}==

(defmodule guessing-game

(export (main 0)))

(: random uniform 10)

(get-player-guess)))

 

From the LFE REPL (assuming the above code was saved in the file "guessing-game.lfe"):

 

> (slurp '"guessing-game.lfe")

#(ok guessing-game)

ok

>

 

=={{header|Liberty BASIC}}==

[start]

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

if c >target then print " Your guess was too high."

wend

 

=={{header|LiveCode}}==

local tNumber, tguess, tmin, tmax

if lowN is empty or lowN < 1 then

end if

end repeat

Test

guessTheNumber --defaults to 1-10

guessTheNumber 9,12

 

=={{header|Locomotive Basic}}==

 

20 PRINT "Please specify lower and upper limits":guess=0

30 INPUT " (must be positive integers) :", first, last

110 INPUT "That's correct! Another game (y/n)? ", yn$

120 IF yn$="y" THEN 20

 

Output:

=={{header|Logo}}==

{{trans|UNIX Shell}}

local "number

make "number random :max

]

end

 

Sample run:<pre>? guess

=={{header|Lua}}==

 

me_win=false

my_number=math.random(1,10)

end

end

 

<pre>

That was correct.

</pre>

 

=={{header|Maple}}==

local number, input;

randomize():

end if;

end do:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Module[{number = RandomInteger[{min, max}], guess},

While[guess =!= number,

ToString@max <> "."]]];

CreateDialog[{"Well guessed!", DefaultButton[]}]];

 

=={{header|MATLAB}} / {{header|Octave}}==

{{untested|Octave}}

Tested in MATLAB. Untested in Octave.

 

if nargin < 1 || ~isnumeric(low) || length(low) > 1 || isnan(low)

gs = '';

end

=={{header|MAXScript}}==

Range = [1,100]

randomNumber = (random Range.x Range.y) as integer

)

)

 

Output:

Enter a number between 1 and 100: 5

Too low!

Well guessed!

OK

 

=={{header|Mirah}}==

s = System.console.readLine()

Integer.parseInt(s)

puts "Please enter an integer."

end

 

=={{header|Modula-2}}==

 

IMPORT InOut, Random, NumConv, Strings;

InOut.WriteString ("Thank you for playing; have a nice day!");

InOut.WriteLn

<pre>I have chosen a number below 1000; please try to guess it.

Enter your guess : 500

Your guess is spot on!

Thank you for playing; have a nice day!</pre>

 

=={{header|Nemerle}}==

using System.Console;

 

} while (guess != secret)

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

 

=={{header|NewLISP}}==

; oofoe 2012-01-19

; http://rosettacode.org/wiki/Guess_the_number/With_feedback

(println "\nWell guessed! Congratulations!")

 

 

Sample output:

 

=={{header|Nim}}==

 

randomize()

 

echo "Guess my target number that is between ", iRange.a, " and ", iRange.b, " (inclusive)."

var answer, i = 0

while answer != target:

inc i

try: answer = parseInt(txt)

except ValueError:

echo " I don't understand your input of '", txt, "'"

continue

elif answer < target: echo " Too low."

elif answer > target: echo " Too high."

else: echo " Ye-Haw!!"

 

 

=={{header|Objeck}}==

 

bundle Default {

}

}

 

=={{header|OCaml}}==

try read_int()

with _ ->

loop ()

in

 

Playing the game:

 

=={{header|Octave}}==

% Guess a number (with feedback)

% http://rosettacode.org/wiki/Guess_the_number/With_feedback

end

end

 

=={{header|Oforth}}==

 

 

: guessNumber(a, b)

g n == ifTrue: [ "You found it !" .cr return ]

g n < ifTrue: [ "Less" ] else: [ "Greater" ] . "than the target" .cr

 

=={{header|Ol}}==

(import (otus random!))

 

((= guess number)

(print "Well guessed!")))))

 

=={{header|ooRexx}}==

entering ? shows the number we are looking for

This program should, of course, also work with all other Rexxes

/*REXX program that plays the guessing (the number) game. */

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

 

ser: say; say '*** error ! ***'; say arg(1); say; return

=={{header|Pascal}}==

See [[Guess_the_number#Delphi | Delphi]]

 

=={{header|Perl}}==

my $prompt = shift;

while (1) {

while ($_ = $tgt <=> prompt "Your guess");

 

 

=={{header|Phix}}==

 

=={{header|PHP}}==

<?php

 

</body>

</html>

 

=={{header|PicoLisp}}==

{{trans|PureBasic}}

(use (Low High Guess)

(until

"Your guess is too "

(if (> Number Guess) "low" "high")

Output:

<pre>: (guessTheNumber)

You got it!</pre>

 

 

=={{header|PowerShell}}==

function Get-Guess

{

 

Write-Host ("The number was {0} and it took {1} guesses to find it." -f $answer.Number, $answer.Guesses.Count)

{{Out}}

<pre>

The number was 73 and it took 6 guesses to find it.

</pre>

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|6}}

 

play_guess_number.

 

; Guess > N -> writeln('Your guess is too high.')

; Guess =:= N -> writeln("Correct!")

 

 

Input in the standard Prolog top level is terminated with a `.`: E.g.,

 

Guess an integer between 1 and 10.

Guess the number: a.

Invalid input.

Guess the number: 3.

 

=={{header|Python}}==

 

inclusive_range = (1, 100)

if answer > target: print(" Too high.")

 

 

'''Sample Game'''

I don't understand your input of 'Howdy' ?

Your guess(4): </pre>

 

=={{header|R}}==

}

 

=={{header|Racket}}==

 

(define (guess-number min max)

 

(guess-number 1 100)

 

=={{header|Retro}}==

over > [ "high" ] [ "low" ] if ;

 

think [ getToken toNumber checkGuess ] while

"You got it!\n" puts ;

 

=={{header|REXX}}==

To make the program more engaging, randomized words for the hint are used.

lows= 'too_low too_small too_little below under underneath too_puny'

highs= 'too_high too_big too_much above over over_the_top too_huge'

erm= '***error***'

@gtn= "guess the number, it's between"

/* [↓] BY 0 ─── used to LEAVE a loop*/

select

when g=='' then iterate ask

when abbrev('QUIT', g, 1) then exit /*what a whoos.*/

when \datatype(g, 'N') then say erm g "isn't numeric"

when \datatype(g, 'W') then say erm g "isn't a whole number"

end /*validate*/

 

if g=r then leave

end /*ask*/

 

=={{header|Ring}}==

while true

see "Hey There,

d = random(e)

if d >= s return d ok

 

=={{header|Ruby}}==

{{trans|Mirah}}

 

puts "Guess the number between 1 and 10"

puts "Please enter an integer."

end

 

=={{header|Rust}}==

{{libheader|rand}}

 

 

fn main() {

 

loop {

 

 

 

 

}

}

}

50

 

=={{header|Scala}}==

import java.util.Scanner

 

else if (guessedNumber < randomNumber) println("Your guess is too low!")

else println("You got it!")

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

{{works with|Guile}}

(define minimum -5)

(define number (+ (random (- (+ maximum 1) minimum)) minimum))

(if (< guess number)

(display "Too low!\n> ")))))

 

=={{header|Seed7}}==

const integer: lower_limit is 0;

writeln("You gave up!");

end if;

 

=={{header|Sidef}}==

{{trans|Ruby}}

say "Guess the number between 1 and 10";

 

default { say "Too high" }

}

 

=={{header|Small Basic}}==

TextWindow.WriteLine("I just thought of a number between 1 and 10. What is it?")

While guess<>number

EndIf

EndWhile

 

=={{header|Sparkling}}==

let lowerBound = toint(getline());

 

break;

}

=={{header|Swift}}==

 

var found = false

println("Good try but the number is less than that!")

}

 

=={{header|Tcl}}==

set to 10

set target [expr {int(rand()*($to-$from+1) + $from)}]

break

}

Sample output:

<pre>

Well done! You guessed it.

</pre>

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

PRINT "Find the luckynumber (7 tries)!"

IF (round==7) PRINT/ERROR "You've lost: luckynumber was: ",luckynumber

ENDLOOP

Output:

<pre>

{{works with|Public Domain Korn SHell}}

{{works with|Z SHell}}

[[ -n $BASH_VERSION ]] && shopt -s extglob

[[ -n $ZSH_VERSION ]] && set -o KSH_GLOB

fi

done

 

Sample run:

=={{header|Ursa}}==

{{trans|Python}}

set low 0

set high 100

end while

 

 

=={{header|Vala}}==

void main(){

const int from = 1;

}//while

} // main

 

Shorter but no error checking

int guess, x = Random.int_range(1, 10);

stdout.printf("Make a guess (1-10): ");

stdout.printf("Got it!\n");

return 0;

 

=={{header|VBA Excel}}==

The Application.InputBox display a message when input is inappropriate.

Dim Nbc&, Nbp&, m&, n&, c&

 

Loop

MsgBox "Well guessed!" & vbCrLf & "You find : " & Nbc & " in " & c & " guesses!"

 

=={{header|VBScript}}==

Dim max,min,secretnum,numtries,usernum

max=100

End If

Loop

 

=={{header|XLISP}}==

; minimum and maximum, to be supplied by the user

(defun prompt ()

(display ". Try to guess it!")

(newline)

{{out}}

<pre>[1] (guessing-game 19 36)

 

=={{header|XPL0}}==

int Lo, Hi, C, Guess, Number;

 

CrLf(0);

until Guess = Number;

 

Example output:

 

=={{header|zkl}}==

while(1){

n:=ask("Num between 1 & 10: ");

if(n==r){ println("Well guessed!"); break; }

println((n<r) and "small" or "big");

{{out}}

<pre>

Well guessed!

</pre>

 

=={{header|ZX Spectrum Basic}}==

1 LET n=INT (RND*10)+1

2 INPUT "Guess a number that is between 1 and 10: ",g: IF g=n THEN PRINT "That's my number!": STOP

3 IF g<n THEN PRINT "That guess is too low!": GO TO 2