Guess the number/With feedback: Difference between revisions

{{trans|Python}}

print("Guess my target number that is between #. and #. (inclusive).\n".format(target_min, target_max))

I answer > target {print(‘ Too high.’)}

{{out}}

=={{header|Action!}}==

BYTE x,n,min=[1],max=[100]

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Guess_the_number_with_feedback.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Text_IO;

procedure Guess_Number_Feedback is

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

while ø [

try? [

]

else -> print "\tInvalid input!"

{{out}}

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

Min = 5: Max = 15

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

end if

until guess = chosen

Output:(example)

<pre>

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

Note that <code>INPUT</code> only allows the user to type things that can fit in the variable it's storing to. Since we're storing to a byte, we don't have to worry about the user typing any non-numbers.

DIM guess AS _BYTE ' the player's guess

END SELECT

LOOP UNTIL guess%% = secretNumber%%

{{out}}

<pre>

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

static $( randstate = ? $)

wrch('*N')

play(min, max, rand(min, max))

{{out}}

<pre>Guess the number

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>

return 0;

Demonstration:

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

class Program

}

}

Output:

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

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

#include <cstdlib>

#include <ctime>

return 0;

Output:

<pre>Enter lower limit: 1

=={{header|Caché ObjectScript}}==

; get a random number between 1 and 100

set target = ($random(100) + 1) ; $r(100) gives 0-99

write !!,"You guessed the number in "_tries_" attempts."

{{out}}<pre>SAMPLES>do ^GUESSNUM^

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

po: stream := stream$primary_output()

pi: stream := stream$primary_input()

secret: int := min + random$next(max - min + 1)

play_game(min, max, secret)

{{out}}

<pre>Guess the number

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

=={{header|Crystal}}==

{{trans|Ruby}}

puts "Guess the number between 1 and 10"

puts "Please enter an integer."

end

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

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

n = random 100 + 1

repeat

until g = n

.

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

ELENA 4.x :

public program()

}

}

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

(max 100)

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

((= guess number)

(setq done t)

=={{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|F_Sharp|F#}}==

open System

0

=={{header|Factor}}==

formatting

fry

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

[ random '[ _ game-step ] loop ]

=={{header|Fantom}}==

class Main

{

}

}

Sample game:

=={{header|FOCAL}}==

01.02 A "LOWER LIMIT",L

01.03 A "UPPER LIMIT",H

01.16 T "TOO LOW!",!;G 1.1

01.17 T "CORRECT! GUESSES",%4,T,!;Q

{{out}}

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

=={{header|Frink}}==

target = random[1,100] // Min and max are both inclusive for the random function

guess = 0

println["$guess is correct! Well guessed!"]

}

{{out}}

Including an example with a non-integer entered.

=={{header|Genie}}==

/*

Number guessing with feedback, in Genie

init

var game = new NumberGuessing(1, 100)

{{out}}

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

{{works with|Julia|0.6}}

number = rand(1:n)

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

end

{{out}}

=={{header|Kotlin}}==

fun main() {

}

}

Sample inout/output

{{out}}

=={{header|Lambdatalk}}==

{def game

{game {pow 2 32}} // 2**32 = 4294967296

Sample inout/output

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

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

{{trans|BASIC256}}

Module GuessNumber {

Read Min, Max

}

GuessNumber 5, 15

{{out}}

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

=={{header|Nanoquery}}==

random = new(Random)

end

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

else: echo " Ye-Haw!!"

=={{header|NS-HUBASIC}}==

20 INPUT "I'M THINKING OF A NUMBER BETWEEN 1 AND 10. WHAT IS IT? ",GUESS

30 IF GUESS>NUMBER THEN PRINT "MY NUMBER IS LOWER THAN THAT.": GOTO 20

40 IF GUESS<NUMBER THEN PRINT "MY NUMBER IS HIGHER THAN THAT.": GOTO 20

=={{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|PARI/GP}}==

a=random(N);

print("guess the number between 0 and "N);

);

print("You guessed it correctly")

=={{header|Pascal}}==

=={{header|Perl}}==

my $prompt = shift;

while (1) {

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

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Guess_the_number3.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

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

=={{header|Plain English}}==

The high number is 100.

Convert the string to the number.

If the number is less than the low number, write " Guess can't be lower than " then the low number then "." on the console; repeat.

{{out}}

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

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

Repeat

PrintN("Your guess is to high.")

EndIf

=={{header|Python}}==

inclusive_range = (1, 100)

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

'''Sample Game'''

=={{header|Quackery}}==

cr cr

100 random 1+

say "Well done! "

echo say " is correct. " cr

{{out}}

This solution works on the assumption that the number to be found is an integer and also assumes that the upper and lower bounds are distinct integers used inclusively. For example, this means that low=4 and high=5 should be a solvable case, but low=high=4 will throw an error. See [[Talk:Guess the number/With feedback|Talk page]] entry dated 1st June 2020.

{

boundryErrorCheck(low, high)

while(!is.numeric(guess) || as.integer(guess) != guess){guess <- type.convert(readline("That wasn't an integer! Try again "))}

as.integer(guess)

=={{header|Racket}}==

(define (guess-number min max)

(guess-number 1 100)

=={{header|Raku}}==

(formerly Perl 6)

until 0 < $maxnum < Inf {

say "Oops! The upper boundary should be > 0 and not Inf";

}

}

<pre>Hello, please give me an upper boundary: 10

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

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

high= 100 /* " upper " " " " " */

/*stick a fork in it, we're all done. */

if try==1 then say 'Gadzooks!!! You guessed the number right away!'

=={{header|Ring}}==

while true