Guess the number/With feedback (player): Difference between revisions
Guess the number/With feedback (player) (view source)
Revision as of 16:50, 20 April 2024
, 26 days agoAdded Easylang
(Add AsciiDots solution) |
(Added Easylang) |
||
(4 intermediate revisions by 4 users not shown) | |||
Line 16:
{{trans|Python}}
<
V (mn, mx) = (target_min, target_max)
Line 44:
L.break
print("\nThanks for keeping score.")</
{{out}}
Line 62:
=={{header|Action!}}==
<
BYTE n,min=[1],max=[100]
CHAR c
Line 86:
FI
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Guess_the_number_with_feedback_(player).png Screenshot from Atari 8-bit computer]
Line 108:
=={{header|Ada}}==
<
procedure Guess_Number_Player is
procedure Guess_Number (Lower_Limit : Integer; Upper_Limit : Integer) is
Line 143:
end loop;
Guess_Number (Lower_Limit, Upper_Limit);
end Guess_Number_Player;</
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
<
INT lower := 1;
INT upper := 100;
Line 172:
FI
DO SKIP OD
END</
=={{header|AppleScript}}==
<
property minLimit : 1
property maxLimit : 100
Line 206:
end if
end repeat
end run</
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print {:
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
too high, too low, or equal to your number by typing h, l, or =
:}
rmin: 1
rmax: 10
while ø [
guess: random rmin rmax
print ["My guess is:" guess]
inputOk: false
while [not? inputOk][
hle: strip input "How did I do? (h)igh, (l)ow, (=): "
case [hle]
when? [="h"][
if? rmin =< dec guess [rmax: dec guess, inputOk: true]
else -> print "\tThat doesn't make any sense. I cannot find the number..."
]
when? [="l"][
if? (inc guess) =< rmax [rmin: inc guess, inputOk: true]
else -> print "\tThat doesn't make any sense. I cannot find the number..."
]
when? [="="][
print ""
print "Great! I found it! :)"
print "Thanks for keeping the score."
exit
]
else [
print "\tPlease, check your input; it doesn't appear to be correct!"
]
]
print ""
]</syntaxhighlight>
{{out}}
<pre>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
too high, too low, or equal to your number by typing h, l, or =
My guess is: 7
How did I do? (h)igh, (l)ow, (=): h
My guess is: 1
How did I do? (h)igh, (l)ow, (=): fff
Please, check your input; it doesn't appear to be correct!
How did I do? (h)igh, (l)ow, (=): l
My guess is: 3
How did I do? (h)igh, (l)ow, (=): h
My guess is: 2
How did I do? (h)igh, (l)ow, (=): l
That doesn't make any sense. I cannot find the number...
How did I do? (h)igh, (l)ow, (=): =
Great! I found it! :)
Thanks for keeping the score.</pre>
=={{header|AsciiDots}}==
Line 214 ⟶ 278:
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.
<syntaxhighlight lang="asciidots">
/.
*$"Think of a number from 1 to 127"
Line 227 ⟶ 291:
|#a_$01#\ /2#\ | @ \*--{=}-/\-/ |
\-------*{/}@*-*---*-----------------------------------/
</syntaxhighlight>
=={{header|AutoHotkey}}==
Line 233 ⟶ 297:
Works with the AutoHotkey entry at: [[Guess the number/With feedback]]
<
GetParams(LowerBound,UpperBound)
Line 286 ⟶ 350:
Else
Return, "Too High"
}</
=={{header|Batch File}}==
<
@echo off
Line 320 ⟶ 384:
echo Guesses: %attempts%
pause>nul
</syntaxhighlight>
{{out}}
<pre>
Line 335 ⟶ 399:
=={{header|BASIC}}==
<
20 INPUT "Lower limit? ",L
30 INPUT "Upper limit? ",H
Line 346 ⟶ 410:
90 L=(H-L)\2+L: GOTO 40
100 H=(H-L)\2+L: GOTO 40
110 PRINT "It took";T;"tries."</
{{out}}
<pre>Lower limit? 1
Line 365 ⟶ 429:
=={{header|BBC BASIC}}==
<
max% = 100
PRINT "Think of a number between "; min% " and " ;max%
Line 381 ⟶ 445:
UNTIL FALSE
PRINT "Goodbye."
END</
=={{header|BCPL}}==
<
let reads(s) = valof
Line 433 ⟶ 497:
writes("Upper bound? ") ; max := readn()
writef("It took %N attempts.*N", guess(min, max, 1))
$)</
{{out}}
<pre>Lower bound? 1
Line 446 ⟶ 510:
=={{header|C}}==
<
int main(){
Line 475 ⟶ 539:
return 0;
}</
Demonstration (number is 57):
Line 492 ⟶ 556:
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>
Line 543 ⟶ 607:
printf("Your number is %d.\n", (int)(result - ZERO));
return 0;
}</
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Linq;
Line 678 ⟶ 742:
}
}
</syntaxhighlight>
=={{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>
Line 733 ⟶ 797:
std::cout << "Your number is " << answer << ".\n";
return 0;
}</
=={{header|Ceylon}}==
<
while(true) {
variable value low = 1;
Line 774 ⟶ 838:
}
}
}</
=={{header|Clojure}}==
<
(defn guess-game [low high]
Line 791 ⟶ 855:
\c (println "Huzzah!")
(do (println "Invalid input.")
(recur guess step)))))</
Output
<pre>user=> (guess-game 1 100)
Line 811 ⟶ 875:
=={{header|Common Lisp}}==
An imperative solution using LOOP:
<syntaxhighlight lang="lisp">
(defun guess-the-number (&optional (max 1000) (min 0))
(flet ((get-feedback (guess)
Line 828 ⟶ 892:
else do (setf max guess)
finally (write-line "I got it!"))))
</syntaxhighlight>
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):
<syntaxhighlight lang="lisp">
(defun guess-the-number (&optional (max 1000) (min 0))
(labels ((guess-loop (min max)
Line 845 ⟶ 909:
(format t "Think of a number between ~a and ~a.~%" min max)
(guess-loop min max)))
</syntaxhighlight>
=={{header|D}}==
{{trans|Python}}
<
void main() {
Line 890 ⟶ 954:
}
writeln("\nThanks for keeping score.");
}</
{{out}}
<pre>Think of a number between 1 and 10 and wait for me to guess it.
Line 906 ⟶ 970:
{{libheader| system.console}}
Thanks JensBorrisholt for System.Console [https://github.com/JensBorrisholt/DelphiConsole/tree/master/Console].
<syntaxhighlight lang="delphi">
program Guess_the_number;
Line 1,067 ⟶ 1,131:
readln;
end.</
=={{header|EasyLang}}==
{{trans|Ring}}
<syntaxhighlight>
min = 1
max = 100
print "Think of a number between " & min & " and " & max
print "I will try to guess your number."
repeat
guess = (min + max) div 2
print "My guess is " & guess
write "Is it higher than, lower than or equal to your number? "
answer$ = input
print answer$
ans$ = substr answer$ 1 1
until ans$ = "e"
if ans$ = "l"
min = guess + 1
elif ans$ = "h"
max = guess - 1
else
print "Sorry, i didn't understand your answer."
.
.
print "Goodbye."
</syntaxhighlight>
=={{header|Elixir}}==
{{works with|Elixir|1.2}}
<
def guess(a..b) do
x = Enum.random(a..b)
Line 1,089 ⟶ 1,179:
end
end
Game.guess(1..100)</
{{out|sample}}
Line 1,102 ⟶ 1,192:
=={{header|Erlang}}==
<
-module(guess_game).
-export([main/0]).
Line 1,130 ⟶ 1,220:
guess(K,U,N)
end
end.</
{{out}}
<pre>Player 1 : Guess my number between 1 and and 100 until you get it right.
Line 1,147 ⟶ 1,237:
=={{header|Euphoria}}==
{{trans|PureBasic}}
<
include wildcard.e
Line 1,177 ⟶ 1,267:
puts(1,"I do not understand that...\n")
end if
end while</
=={{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 ( -- )
Line 1,196 ⟶ 1,286:
"I did it. Your number was %d!\n" printf ;
instruct play-game gloat</
{{out}}
<pre>
Line 1,214 ⟶ 1,304:
=={{header|Fantom}}==
<
class Main
{
Line 1,251 ⟶ 1,341:
}
}
</syntaxhighlight>
Example:
Line 1,286 ⟶ 1,376:
=={{header|FOCAL}}==
<
01.15 A "UPPER LIMIT",H
01.20 S T=0
Line 1,301 ⟶ 1,391:
01.70 S H=G;G 1.3
01.75 T "ATTEMPTS",T,!
01.80 Q</
{{out}}
<pre>LOWER LIMIT:1
Line 1,321 ⟶ 1,411:
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<
implicit none
Line 1,358 ⟶ 1,448:
end select
end do
end program</
Output
<pre>Think of a number between 1 and 100 and I will try to guess it.
Line 1,374 ⟶ 1,464:
=={{header|FreeBASIC}}==
<
Dim hle As String
Line 1,405 ⟶ 1,495:
guess = (lowest + highest)\2
Loop
End</
Sample input/output
Line 1,425 ⟶ 1,515:
=={{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 (
Line 1,446 ⟶ 1,536:
})
fmt.Printf("Your number is %d.\n", lower+answer)
}</
Manual solution:
<
import (
Line 1,486 ⟶ 1,576:
}
}
}</
=={{header|Haskell}}==
Explicit version with arbitrary range:
<syntaxhighlight lang="haskell">
main :: IO ()
main = do
Line 1,515 ⟶ 1,605:
"h" -> loop guess to
(_) -> putStrLn "Invalid answer." >> loop from to
</syntaxhighlight>
Short version with set limits:
<syntaxhighlight lang="haskell">
main = f 0 100
where f x y = let g = div (x + y) 2 in
Line 1,526 ⟶ 1,616:
"h" -> f g y
"c" -> putStrLn "Yay!"
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
{{trans|Fantom}}
<syntaxhighlight lang="icon">
procedure main ()
lower_limit := 1
Line 1,561 ⟶ 1,651:
}
end
</syntaxhighlight>
=={{header|IS-BASIC}}==
<
110 LET N=100
120 TEXT 80
Line 1,589 ⟶ 1,679:
330 LOOP UNTIL K$>="0" AND K$<="3"
340 LET QUESTION=VAL(K$)
350 END DEF</
=={{header|J}}==
<
guess=:3 :0
'lo hi'=.y
Line 1,607 ⟶ 1,697:
end.
end.
)</
Example session:
<syntaxhighlight lang="text"> guess 1 100
guessing a number between 1 and 100
is it 86? hi
Line 1,630 ⟶ 1,720:
guessing a number between 49 and 50
is it 49? lo
50</
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.)
Line 1,637 ⟶ 1,727:
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;
Line 1,672 ⟶ 1,762:
System.out.printf("Your number is %d.\n", result);
}
}</
=={{header|JavaScript}}==
Line 1,681 ⟶ 1,771:
Well, it does use recursion for the guessing function, but that's OK because the depth is bounded by LOG<sub>2</sub> 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;
Line 1,734 ⟶ 1,824:
main();
</syntaxhighlight>
An example session:
Line 1,761 ⟶ 1,851:
Is it 1? h
I can't guess it. Perhaps you changed your number.
=={{header|jq}}==
''Adapted from [[#Wren|Wren]]''
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq'''
<syntaxhighlight lang=jq>
# Pick an integer from $lowest through $highest ...
def play($lowest; $highest):
# Helper function for guessing
def prompt:
.guess = (((.lowest + .highest)/2)|floor)
| .emit += "\nMy guess is \(.guess)." +
"\nIs this higher/lower than or equal to your chosen number? h/l/e : " ;
"Please choose a number from \($lowest) to \($highest) inclusive and then answer the questions.",
( {$highest, $lowest}
| prompt
| .emit,
( label $out
| foreach inputs as $in (.;
.emit = null
| .hle = ($in|ascii_downcase)
| if .hle == "l" and .guess == .highest
then .emit = "It can't be more than \(highest), try again."
elif .hle == "h" and .guess == .lowest
then .emit = "It can't be less than \(.lowest), try again."
elif .hle == "e"
then .emit = "Good, thanks for playing the game with me!"
| .quit = true
elif .hle == "h"
then if (.highest > .guess - 1) then .highest = .guess - 1
else .
end
elif .hle == "l"
then if (.lowest < .guess + 1) then .lowest = .guess + 1
else .
end
else .emit = "Please try again.\n"
end
| if .quit then ., break $out else prompt end ;
.emit
) ) ) ;
def play: play(1;20);
play
</syntaxhighlight>
'''Invocation:''' jq -nRr -f guess-the-number-with-feedback-player.jq
{{output}}
<pre>
Please choose a number from 1 to 20 inclusive and then answer the questions.
My guess is 10.
Is this higher/lower than or equal to your chosen number? h/l/e :
h
My guess is 5.
Is this higher/lower than or equal to your chosen number? h/l/e :
?
Please try again.
My guess is 5.
Is this higher/lower than or equal to your chosen number? h/l/e :
0
Please try again.
My guess is 5.
Is this higher/lower than or equal to your chosen number? h/l/e :
h
My guess is 2.
Is this higher/lower than or equal to your chosen number? h/l/e :
e
Good, thanks for playing the game with me!
$
</pre>
=={{header|Julia}}==
Line 1,766 ⟶ 1,932:
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()
Line 1,813 ⟶ 1,979:
end
println("\nI win after ", attempts, attempts == 1 ? " attempt." : " attempts.")</
=={{header|Kotlin}}==
{{trans|FreeBASIC}}
<
fun main(args: Array<String>) {
Line 1,851 ⟶ 2,017:
guess = (lowest + highest) / 2
}
}</
Sample input/output:
{{out}}
Line 1,870 ⟶ 2,036:
=={{header|Lasso}}==
<
local(
Line 1,919 ⟶ 2,085:
}
}
}</
Examples:
Line 1,954 ⟶ 2,120:
=={{header|Liberty BASIC}}==
<
maxi=100
Line 1,983 ⟶ 2,149:
end select
wend
print "Thanks for playing." </
=={{header|Lua}}==
<syntaxhighlight lang="text">function wait(waittime)--wait function is used so that app will not quit immediately
local timer = os.time()
repeat until os.time() == timer + waittime
Line 2,021 ⟶ 2,187:
end
end
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="text">guessnumber[min0_, max0_] :=
DynamicModule[{min = min0, max = max0, guess, correct = False},
guess[] := Round@Mean@{min, max};
Line 2,032 ⟶ 2,198:
Button["too low", min = guess[]],
Button["correct", correct = True]}}]];
guessnumber[1, 100]</
=={{header|MATLAB}}==
<
lowVal = input('Lower limit: ');
Line 2,064 ⟶ 2,230:
end
end
end</
{{out}}
<pre>Lower limit: 0
Line 2,087 ⟶ 2,253:
=={{header|MAXScript}}==
<
lowRange = inclusiveRange.x
maxRange = inclusiveRange.y
Line 2,112 ⟶ 2,278:
default: (format "\nI don't understand your input.")
)
)</
{{out}}
<syntaxhighlight lang="maxscript">
OK
Think of a number between 1 and 100 and I will try to guess it.
Line 2,136 ⟶ 2,302:
Yay. I guessed your number after 6 tries.
OK
</syntaxhighlight>
=={{header|Modula-2}}==
<
IMPORT InOut;
Line 2,174 ⟶ 2,340:
InOut.WriteString ("Thanks for letting me play with you.");
InOut.WriteLn
END raden.</
Choose a number between 0 and 1000.
Line 2,191 ⟶ 2,357:
=={{header|Nim}}==
<
let oRange = 1..10
Line 2,219 ⟶ 2,385:
break
echo "Thanks for keeping score."</
Output:
<pre>Think of a number between 1 and 10 and wait for me to guess it.
Line 2,232 ⟶ 2,398:
=={{header|NS-HUBASIC}}==
<
20 ISVALID=0
30 GUESS=5
Line 2,241 ⟶ 2,407:
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."
100 GOTO 40</
=={{header|Objective-C}}==
A clever solution that uses the built-in binary search functions with a virtual list.
{{trans|Java}}
<
@interface GuessNumberFakeArray : NSArray {
Line 2,302 ⟶ 2,468:
}
return 0;
}</
=={{header|PARI/GP}}==
<
guessnumber2(b)={
my(c=0,d=b,a=0);
Line 2,329 ⟶ 2,495:
);
}
</syntaxhighlight>
=={{header|Pascal}}==
<
var
Line 2,363 ⟶ 2,529:
writeln ('So the number is: ', guess:4);
writeln ('It was nice to play with you.');
end.</
Output:
<pre>:> ./GuessTheNumberPlayerFeedback
Line 2,382 ⟶ 2,548:
=={{header|Perl}}==
<
my $min = 1;
Line 2,417 ⟶ 2,583:
} while(1);
}</
<pre>=>> Think of a number between 1 and 99 and I'll guess it!
Line 2,440 ⟶ 2,606:
=={{header|Phix}}==
<!--<
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\Guess_the_number2.exw
Line 2,502 ⟶ 2,668:
<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")
Line 2,524 ⟶ 2,690:
("L" (setq Min Guess))
("=" (nil (prinl "I did it!")))
(T (prinl "I do not understand that...")) ) ) ) ) )</
Output:
<pre>: (guessTheNumber 1 99)
Line 2,538 ⟶ 2,704:
=={{header|Prolog}}==
<
pick_number(Min, Max) :-
Line 2,559 ⟶ 2,725:
play :-
pick_number(Min, Max),
guess_number(Min, Max).</
Example:
<
Pick a number between 1 and 10, and I will guess it...
Ready? (Enter anything when ready):y.
Line 2,573 ⟶ 2,739:
Am I correct (c), too low (l), or too high (h)? c.
I'm correct!
true</
=={{header|PureBasic}}==
<
max=100
Line 2,599 ⟶ 2,765:
EndIf
ForEver
EndIf</
=={{header|Python}}==
<
print('''\
Line 2,630 ⟶ 2,796:
break
print("\nThanks for keeping score.")</
'''Sample Game-play'''
Line 2,649 ⟶ 2,815:
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
Line 2,667 ⟶ 2,833:
""" % (LOWER, UPPER))
result = bisect.bisect_left(GuessNumberFakeList(), 0, LOWER, UPPER)
print("Your number is %d." % result)</
;Sample output:
Line 2,691 ⟶ 2,857:
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">
[ [ $ "lower higher equal" nest$ ]
constant ] is responses ( --> $ )
Line 2,722 ⟶ 2,888:
cr false ] ]
do until ]
2drop temp release ] is play ( --> )</
{{out}}
Line 2,765 ⟶ 2,931:
=={{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)
Line 2,789 ⟶ 2,955:
}
guessResult <- function(guess) readline(paste0("My guess is ", guess, ". If it is too low, submit l. If it is too high, h. Otherwise, c. "))</
=={{header|Racket}}==
<
(define (guess low high)
Line 2,813 ⟶ 2,979:
(printf "Think of a number between ~a and ~a.
Use (h)igh, (l)ow and (c)orrect to guide me.\n" low high)
(guess-loop 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)
Line 2,831 ⟶ 2,997:
(begin (display "OK...")
(set! minimum (add1 guess)))))
(displayln "I was RIGHT!"))</
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
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!";
Line 2,849 ⟶ 3,015:
}
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
Line 2,871 ⟶ 3,037:
]
print ["I did it! Your number was" guess]</
{{out}}
<pre>
Line 2,892 ⟶ 3,058:
===with positive integers===
This version only handles positive integers up to the nine decimal digits, 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.*/
Line 2,915 ⟶ 3,081:
end /*try*/
say /*stick a fork in it, we're all done. */
say 'Congratulations! You guessed the secret number in' # "tries."</
'''output''' shown is from playing several games:
<pre style="height:70ex">
Line 3,052 ⟶ 3,218:
=== with positive numbers ===
This version handles decimal fractions, 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.*/
Line 3,077 ⟶ 3,243:
end /*try*/
say /*stick a fork in it, we're all done. */
say 'Congratulations! You guessed the secret number in' # "tries.""</
'''output''' will generally be about ten times longer (that is, has ten times the guesses) as the previous REXX version.
<pre style="height:35ex">
Line 3,228 ⟶ 3,394:
=={{header|Ring}}==
<
min = 1
max = 100
Line 3,246 ⟶ 3,412:
end
see "goodbye." + nl
</syntaxhighlight>
Output:
<pre>
Line 3,268 ⟶ 3,434:
=={{header|Ruby}}==
Computer plays versus itself
<
num = (low + high) / 2
print "guessing #{num}\t"
Line 3,291 ⟶ 3,457:
puts "guess a number between #{low} and #{high}"
play(low, high)</
Example
Line 3,304 ⟶ 3,470:
Since Ruby 2.0 it can be done actually using a built-in binary search (output as above):
<
secret = rand(r)
turns = 0
Line 3,316 ⟶ 3,482:
low_high
end
</syntaxhighlight>
=={{header|Rust}}==
{{works with|rustc|1.0.0-nightly}}
<
const MIN: isize = 1;
Line 3,360 ⟶ 3,526:
}
}
}</
=={{header|Scala}}==
<
val n = 1 + scala.util.Random.nextInt(20)
Line 3,375 ⟶ 3,541:
})
}</
=={{header|Scheme}}==
{{works with|Guile}}
<
(display "Enter a number from ")(display minimum)
Line 3,395 ⟶ 3,561:
(if (string= input "l") (begin (display "OK...")
(set! minimum (+ guess 1)))))
(display "I was RIGHT!\n")</
=={{header|Seed7}}==
Line 3,405 ⟶ 3,571:
and the command is not c.
<
$ include "keybd.s7i";
Line 3,443 ⟶ 3,609:
end if;
writeln("It was nice to play with you.");
end func;</
Example
Line 3,463 ⟶ 3,629:
=={{header|Sidef}}==
<
var max = 99
var tries = 0
Line 3,504 ⟶ 3,670:
guess = ((min+max) // 2)
}</
=={{header|Smalltalk}}==
Line 3,512 ⟶ 3,678:
Create a class like this:
<
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Rosettacode'
</syntaxhighlight>
Enter these methods into it:
<
Transcript clear.
number := (low to: high) atRandom.
Line 3,546 ⟶ 3,712:
showNumberFoundAtTurnNr: turn
Transcript show: (' ==> found the number in {1} turn(s).' format: {turn asString}); cr.
</syntaxhighlight>
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 |
Line 3,561 ⟶ 3,727:
ifTrue: [self showNumberBeing: #low. self playBetween: guess and: high atTurn: turn+1 ]
ifFalse: [self showNumberBeing: #high. self playBetween: low and: guess atTurn: turn+1]].
</syntaxhighlight>
And evaluate this in a Workspace:
<
g playBetween: 1 and: 100.
</syntaxhighlight>
Sample output:
Line 3,584 ⟶ 3,750:
{{works with|SML/NJ}}
{{trans|Go}}
<
type elem = order
type array = int * int
Line 3,641 ⟶ 3,807:
case GuessNumberBSearch.bsearch (fn (_, x) => x) ((), (lower, upper)) of
NONE => print "That is impossible.\n"
| SOME (result, _) => print ("Your number is " ^ Int.toString result ^ ".\n")</
=={{header|Swift}}==
<syntaxhighlight lang="text">import Cocoa
var found = false
Line 3,691 ⟶ 3,857:
high = lastGuess
}
}</
{{out}}
<pre>
Line 3,718 ⟶ 3,884:
=={{header|Tcl}}==
<
set to 10
fconfigure stdout -buffering none
Line 3,739 ⟶ 3,905:
break
}
}</
Sample run:
<pre>
Line 3,750 ⟶ 3,916:
=={{header|UNIX Shell}}==
{{works with|bash}}
<
read -p "Upper bound: " upper
moves=0
Line 3,767 ⟶ 3,933:
((lower>upper)) && echo "you must be cheating!"
done
echo "I guessed it in $moves guesses"</
=={{header|VBA}}==
<
Sub GuessNumberPlayer()
Dim iGuess As Integer, iLow As Integer, iHigh As Integer, iCount As Integer
Line 3,800 ⟶ 3,966:
MsgBox "Not possible. Were you cheating?!", vbCritical + vbOKOnly, "Rosetta Code | Guess the Number Player | ERROR!"
End Sub
</syntaxhighlight>
=={{header|Wren}}==
{{trans|Kotlin}}
{{libheader|Wren-str}}
<
import "./str" for Char
var hle
Line 3,839 ⟶ 4,005:
}
guess = ((lowest + highest)/2).floor
}</
{{out}}
Line 3,856 ⟶ 4,022:
=={{header|XPL0}}==
<
int Hi, Lo, Guess;
[Text(0, "Think of a number between 1 and 100 then press a key.");
Line 3,871 ⟶ 4,037:
];
Text(0, "^M^JYippee!");
]</
Example output:
Line 3,887 ⟶ 4,053:
=={{header|zkl}}==
Your basic binary search.
<
low,high,g := 0,100, 20;
while(True){
Line 3,896 ⟶ 4,062:
if(low>high){ println("I'm confused!"); break; }
g=(low + high)/2;
}</
{{out}}
<pre>
Line 3,911 ⟶ 4,077:
=={{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."
Line 3,921 ⟶ 4,087:
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
100 PRINT "Sorry, I didn't understand your answer.": GO TO 60</
{{omit from|GUISS}}
|