Guess the number/With feedback (player): Difference between revisions

{{trans|Python}}

V (mn, mx) = (target_min, target_max)

L.break

{{out}}

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

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

CHAR c

FI

OD

{{out}}

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

=={{header|Ada}}==

procedure Guess_Number_Player is

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

end loop;

Guess_Number (Lower_Limit, Upper_Limit);

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

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

INT lower := 1;

INT upper := 100;

FI

DO SKIP OD

=={{header|AppleScript}}==

property minLimit : 1

property maxLimit : 100

end if

end repeat

=={{header|Arturo}}==

Think of a number between 1 and 10 and wait for me to guess it.

On every guess of mine you should state whether the guess was

]

print ""

{{out}}

The instructions print in order only because the ends of the lines are aligned. If they were not, they might print in a different order. The "Impossible" error message indicates that their are no remaining logical guesses. The range of 1 to 127 was chosen because it's easy to binary-search. All numbers are floating-point integers in AsciiDots, so rounding would be needed to use a range like 1 to 100.

/.

*$"Think of a number from 1 to 127"

|#a_$01#\ /2#\ | @ \*--{=}-/\-/ |

\-------*{/}@*-*---*-----------------------------------/

=={{header|AutoHotkey}}==

Works with the AutoHotkey entry at: [[Guess the number/With feedback]]

GetParams(LowerBound,UpperBound)

Else

Return, "Too High"

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

@echo off

echo Guesses: %attempts%

pause>nul

{{out}}

<pre>

=={{header|BASIC}}==

20 INPUT "Lower limit? ",L

30 INPUT "Upper limit? ",H

90 L=(H-L)\2+L: GOTO 40

100 H=(H-L)\2+L: GOTO 40

{{out}}

<pre>Lower limit? 1

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

max% = 100

PRINT "Think of a number between "; min% " and " ;max%

UNTIL FALSE

PRINT "Goodbye."

=={{header|BCPL}}==

let reads(s) = valof

writes("Upper bound? ") ; max := readn()

writef("It took %N attempts.*N", guess(min, max, 1))

{{out}}

<pre>Lower bound? 1

=={{header|C}}==

int main(){

return 0;

Demonstration (number is 57):

The following is a hacky solution using <tt>bsearch()</tt> and pointers to represent integers. Although the pointers do not point to valid things, <tt>bsearch()</tt> doesn't actually dereference the pointers or care what they point to; it just passes them to the comparator and searches the space of pointers. We can use that to search any space of integers.

{{trans|Java}}

#include <stdlib.h>

#include <ctype.h>

printf("Your number is %d.\n", (int)(result - ZERO));

return 0;

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

using System.Collections.Generic;

using System.Linq;

}

}

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

A clever solution that takes advantage of C++'s built-in binary search function <code>lower_bound()</code>. Instead of searching a slice of a container, we search a range of numbers by implementing a specially-designed custom iterator.

{{trans|Go}}

#include <algorithm>

#include <string>

std::cout << "Your number is " << answer << ".\n";

return 0;

=={{header|Ceylon}}==

while(true) {

variable value low = 1;

}

}

=={{header|Clojure}}==

(defn guess-game [low high]

\c (println "Huzzah!")

(do (println "Invalid input.")

Output

<pre>user=> (guess-game 1 100)

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

An imperative solution using LOOP:

(defun guess-the-number (&optional (max 1000) (min 0))

(flet ((get-feedback (guess)

else do (setf max guess)

finally (write-line "I got it!"))))

A recursive solution (we use LABELS instead of FLET for the local function definitions in this version so that GUESS-LOOP will be able to call itself recursively):

(defun guess-the-number (&optional (max 1000) (min 0))

(labels ((guess-loop (min max)

(format t "Think of a number between ~a and ~a.~%" min max)

(guess-loop min max)))

=={{header|D}}==

{{trans|Python}}

void main() {

}

writeln("\nThanks for keeping score.");

{{out}}

<pre>Think of a number between 1 and 10 and wait for me to guess it.

{{libheader| system.console}}

Thanks JensBorrisholt for System.Console [https://github.com/JensBorrisholt/DelphiConsole/tree/master/Console].

program Guess_the_number;

readln;

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def guess(a..b) do

x = Enum.random(a..b)

end

end

{{out|sample}}

=={{header|Erlang}}==

-module(guess_game).

-export([main/0]).

guess(K,U,N)

end

{{out}}

<pre>Player 1 : Guess my number between 1 and and 100 until you get it right.

=={{header|Euphoria}}==

{{trans|PureBasic}}

include wildcard.e

puts(1,"I do not understand that...\n")

end if

=={{header|Factor}}==

This solution uses the <code>search</code> combinator. It performs a binary search on a sequence by placing the "guess" on top of the data stack and expecting an ordering specifier in return.

: instruct ( -- )

"I did it. Your number was %d!\n" printf ;

{{out}}

<pre>

=={{header|Fantom}}==

class Main

{

}

}

Example:

=={{header|FOCAL}}==

01.15 A "UPPER LIMIT",H

01.20 S T=0

01.70 S H=G;G 1.3

01.75 T "ATTEMPTS",T,!

{{out}}

<pre>LOWER LIMIT:1

=={{header|Fortran}}==

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

implicit none

end select

end do

Output

<pre>Think of a number between 1 and 100 and I will try to guess it.

=={{header|FreeBASIC}}==

Dim hle As String

guess = (lowest + highest)\2

Loop

Sample input/output

=={{header|Go}}==

Go's binary search function (<code>sort.Search()</code>) is general enough to be able to do this type of task, as mentioned in the documentation for the function itself.[http://golang.org/pkg/sort/#Search]

import (

})

fmt.Printf("Your number is %d.\n", lower+answer)

Manual solution:

import (

}

}

=={{header|Haskell}}==

Explicit version with arbitrary range:

main :: IO ()

main = do

"h" -> loop guess to

(_) -> putStrLn "Invalid answer." >> loop from to

Short version with set limits:

main = f 0 100

where f x y = let g = div (x + y) 2 in

"h" -> f g y

"c" -> putStrLn "Yay!"

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

{{trans|Fantom}}

procedure main ()

lower_limit := 1

}

end

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

110 LET N=100

120 TEXT 80

330 LOOP UNTIL K$>="0" AND K$<="3"

340 LET QUESTION=VAL(K$)

=={{header|J}}==

guess=:3 :0

'lo hi'=.y

end.

end.

Example session:

guessing a number between 1 and 100

is it 86? hi

guessing a number between 49 and 50

is it 49? lo

This could be made more efficient by replacing <code>guess=.lo+?hi-lo</code> with <code>guess=.<.-:lo+hi</code>. (The above example would have finished on the first guess, but the range 1..100 would never take more than 6 guesses -- the remaining answers would be determined after six guesses.)

A clever solution that uses the built-in binary search functions with a virtual list.

{{trans|Go}}

import java.util.Collections;

import java.util.Scanner;

System.out.printf("Your number is %d.\n", result);

}

=={{header|JavaScript}}==

Well, it does use recursion for the guessing function, but that's OK because the depth is bounded by LOG₂ of the range. That's not true if the user changes his number, but then he gets what he deserves.

var DONE = RIGHT = 0, HIGH = 1, LOW = -1;

main();

An example session:

This version uses the expression <math>\left\lceil-\log\left(\frac{1}{\mathrm{upper} - \mathrm{lower}}\right) / \log(2)\right\rceil</math> to calculate the maximum number of guesses it will need.

lower = 0

input = readline()

end

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

fun main(args: Array<String>) {

guess = (lowest + highest) / 2

}

Sample input/output:

{{out}}

=={{header|Lasso}}==

local(

}

}

Examples:

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

maxi=100

end select

wend

=={{header|Lua}}==

local timer = os.time()

repeat until os.time() == timer + waittime

end

end

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

DynamicModule[{min = min0, max = max0, guess, correct = False},

guess[] := Round@Mean@{min, max};

Button["too low", min = guess[]],

Button["correct", correct = True]}}]];

=={{header|MATLAB}}==

lowVal = input('Lower limit: ');

end

end

{{out}}

<pre>Lower limit: 0

=={{header|MAXScript}}==

lowRange = inclusiveRange.x

maxRange = inclusiveRange.y

default: (format "\nI don't understand your input.")

)

{{out}}

OK

Think of a number between 1 and 100 and I will try to guess it.

Yay. I guessed your number after 6 tries.

OK

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

IMPORT InOut;

InOut.WriteString ("Thanks for letting me play with you.");

InOut.WriteLn

Choose a number between 0 and 1000.

=={{header|Nim}}==

let oRange = 1..10

break

Output:

<pre>Think of a number between 1 and 10 and wait for me to guess it.

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

20 ISVALID=0

30 GUESS=5

80 IF ANSWER$="EQUAL TO" THEN PRINT "OH YES! I GUESSED CORRECTLY!":END

90 IF ISVALID=0 THEN PRINT "SORRY";", BUT THAT ANSWER IS INVALID."

=={{header|Objective-C}}==

A clever solution that uses the built-in binary search functions with a virtual list.

{{trans|Java}}

@interface GuessNumberFakeArray : NSArray {

}

return 0;

=={{header|PARI/GP}}==

guessnumber2(b)={

my(c=0,d=b,a=0);

);

}

=={{header|Pascal}}==

var

writeln ('So the number is: ', guess:4);

writeln ('It was nice to play with you.');

Output:

<pre>:> ./GuessTheNumberPlayerFeedback

=={{header|Perl}}==

my $min = 1;

} while(1);

<pre>=>> Think of a number between 1 and 99 and I'll guess it!

=={{header|Phix}}==

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

-- demo\rosetta\Guess_the_number2.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

=={{header|PicoLisp}}==

{{trans|PureBasic}}

(prinl "Think of a number between " Min " and " Max ".")

(prinl "On every guess of mine you should state whether my guess was")

("L" (setq Min Guess))

("=" (nil (prinl "I did it!")))

Output:

<pre>: (guessTheNumber 1 99)

=={{header|Prolog}}==

pick_number(Min, Max) :-

play :-

pick_number(Min, Max),

Example:

Pick a number between 1 and 10, and I will guess it...

Ready? (Enter anything when ready):y.

Am I correct (c), too low (l), or too high (h)? c.

I'm correct!

=={{header|PureBasic}}==

max=100

EndIf

ForEver

=={{header|Python}}==

print('''\

break

'''Sample Game-play'''

Hacky solution using a fake list class and the <code>bisect</code> module from the standard library to do the binary search.

{{trans|Go}}

try: input = raw_input

except: pass

""" % (LOWER, UPPER))

result = bisect.bisect_left(GuessNumberFakeList(), 0, LOWER, UPPER)

;Sample output:

=={{header|Quackery}}==

[ [ $ "lower higher equal" nest$ ]

constant ] is responses ( --> $ )

cr false ] ]

do until ]

{{out}}

=={{header|R}}==

Can be fooled if you lie to it. For example, always reporting "h" for guessANumberPlayer(1, 5) will have it guess 0.

{

boundryErrorCheck(low, high)

}

=={{header|Racket}}==

(define (guess low high)

(printf "Think of a number between ~a and ~a.

Use (h)igh, (l)ow and (c)orrect to guide me.\n" low high)

Another way with loops and mutation

(define (guess minimum maximum)

(printf "Think of a number from ~a to ~a, use (h)igh, (l)ow and (c)orrect." minimum maximum)

(begin (display "OK...")

(set! minimum (add1 guess)))))

=={{header|Raku}}==

(formerly Perl 6)

multi sub MAIN($min is copy where ($min >= 0), $max is copy where ($max > $min)) {

say "Think of a number between $min and $max and I'll guess it!";

}

say "How can your number be both higher and lower than $max?!?!?";

You may execute this program with '<tt>raku program</tt>' or with '<tt>raku program min max</tt>'. Raku creates a usage for us if we don't give the right parameters. It also parses the parameters for us and provides them via <tt>$min</tt> and <tt>$max</tt>. We use multi-subs to provide two MAIN subroutines so the user is able to choose between min and max parameters and no parameters at all, in which case min is set to 0 and max to 100.

=={{header|Red}}==

lower: 1

]

{{out}}

<pre>

===with positive integers===

This version only handles positive integers up to the nine decimal digits, &nbsp; but the default HIGH is one thousand.

parse arg low high seed . /*obtain optional arguments from the CL*/

if low=='' | low=="," then low= 1 /*Not specified? Then use the default.*/

end /*try*/

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

'''output''' shown is from playing several games:

<pre style="height:70ex">

=== with positive numbers ===

This version handles decimal fractions, &nbsp; the method used can generate numbers from zero to five fractional digits.

parse arg low high frac seed . /*obtain optional arguments from the CL*/

if low=='' | low=="," then low= 1 /*Not specified? Then use the default.*/

end /*try*/

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

'''output''' will generally be about ten times longer (that is, has ten times the guesses) as the previous REXX version.

<pre style="height:35ex">

=={{header|Ring}}==

min = 1

max = 100

end

see "goodbye." + nl

Output:

<pre>

=={{header|Ruby}}==

Computer plays versus itself

num = (low + high) / 2

print "guessing #{num}\t"

puts "guess a number between #{low} and #{high}"

Example

Since Ruby 2.0 it can be done actually using a built-in binary search (output as above):

secret = rand(r)

turns = 0

low_high

end

=={{header|Rust}}==

{{works with|rustc|1.0.0-nightly}}

const MIN: isize = 1;

}

}

=={{header|Scala}}==

val n = 1 + scala.util.Random.nextInt(20)

})

=={{header|Scheme}}==

{{works with|Guile}}

(display "Enter a number from ")(display minimum)

(if (string= input "l") (begin (display "OK...")

(set! minimum (+ guess 1)))))

=={{header|Seed7}}==

and the command is not c.

$ include "keybd.s7i";

end if;

writeln("It was nice to play with you.");

Example

=={{header|Sidef}}==

var max = 99

var tries = 0

 

guess = ((min+max) // 2)

=={{header|Smalltalk}}==

Create a class like this:

instanceVariableNames: ''

classVariableNames: ''

poolDictionaries: ''

category: 'Rosettacode'

Enter these methods into it:

Transcript clear.

number := (low to: high) atRandom.

showNumberFoundAtTurnNr: turn

Transcript show: (' ==> found the number in {1} turn(s).' format: {turn asString}); cr.

If you'd rather not use <code>caseOf:</code> you can write <code>playBetween:and:atTurn:</code> like this:

playBetween: low and: high atTurn: turn

| guess |

ifTrue: [self showNumberBeing: #low. self playBetween: guess and: high atTurn: turn+1 ]

ifFalse: [self showNumberBeing: #high. self playBetween: low and: guess atTurn: turn+1]].

And evaluate this in a Workspace:

g playBetween: 1 and: 100.

Sample output:

{{works with|SML/NJ}}

{{trans|Go}}

type elem = order

type array = int * int

case GuessNumberBSearch.bsearch (fn (_, x) => x) ((), (lower, upper)) of

NONE => print "That is impossible.\n"

=={{header|Swift}}==

var found = false

high = lastGuess

}

{{out}}

<pre>

=={{header|Tcl}}==

set to 10

fconfigure stdout -buffering none

break

}

Sample run:

<pre>

=={{header|UNIX Shell}}==

{{works with|bash}}

read -p "Upper bound: " upper

moves=0

((lower>upper)) && echo "you must be cheating!"

done

=={{header|VBA}}==

Sub GuessNumberPlayer()

Dim iGuess As Integer, iLow As Integer, iHigh As Integer, iCount As Integer

MsgBox "Not possible. Were you cheating?!", vbCritical + vbOKOnly, "Rosetta Code | Guess the Number Player | ERROR!"

End Sub

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-str}}

import "/str" for Char

}

guess = ((lowest + highest)/2).floor

{{out}}

=={{header|XPL0}}==

int Hi, Lo, Guess;

[Text(0, "Think of a number between 1 and 100 then press a key.");

];

Text(0, "^M^JYippee!");

Example output:

=={{header|zkl}}==

Your basic binary search.

low,high,g := 0,100, 20;

while(True){

if(low>high){ println("I'm confused!"); break; }

g=(low + high)/2;

{{out}}

<pre>

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

{{trans|BBC_BASIC}}

20 PRINT "Think of a number between ";min;" and ";max

30 PRINT "I will try to guess your number."

80 IF a$="H" OR a$="h" THEN LET max=guess-1: GO TO 40

90 IF a$="E" OR a$="e" THEN PRINT "Goodbye.": STOP

{{omit from|GUISS}}