Guess the number/With feedback: Difference between revisions

 

 

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

That's correct!

</pre>

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

 

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

 

 

{$APPTYPE CONSOLE}

 

end.

 

=={{header|Ela}}==

 

 

=={{header|Elixir}}==

def play(lower, upper) do

defp play(lower, upper, number) do

guess = Integer.parse(IO.gets "Guess a number (#{lower}-#{upper}): ")

case guess do

IO.puts "Well guessed!"

play(lower, upper, number)

_ ->

play(lower, upper, number)

end

end

 

 

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

Enter guess: 57

That is correct</pre>

 

=={{header|Go}}==

 

import (

}

}

 

=={{header|Haskell}}==

import Control.Monad

import System.Random

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

ask `until_` answerIs ans

 

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

 

 

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

</pre>

 

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:

</pre>

 

 

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)

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|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|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|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|Racket}}==

 

 

 

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

select

iterate ask

 

if g=r then leave

 

 

=={{header|Ruby}}==

{{trans|Mirah}}

 

puts "Guess the number between 1 and 10"

puts "Please enter an integer."

end

 

=={{header|Rust}}==

 

 

fn main() {

loop {

 

}

}

50

 

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

You got it in 5 guesses!

</pre>

 

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

</pre>