Guess the number: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V g = Int(input(‘Guess a number that's between 1 and 10: ’))

L t != g

g = Int(input(‘Guess again! ’))

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program guessNumber.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|ABAP}}==

 

DATA prng TYPE REF TO cl_abap_random_int.

 

cl_demo_output=>display( |Well Done| ).

 

=={{header|Ada}}==

 

with Ada.Text_IO;

procedure Guess_Number is

end loop;

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

 

=={{header|Aime}}==

integer n;

text s;

}

 

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

(

INT n;

break:

puts("You have won! ")

Sample output:

<pre>

=={{header|AppleScript}}==

 

-- define the number to be guessed

set numberToGuess to (random number from 1 to 10)

end if

end repeat

 

 

Or, constraining mutation, and abstracting a little to an '''until(predicate, function, value)''' pattern

 

on run

end tell

return v

 

=={{header|Arturo}}==

 

 

 

{{out}}

 

Well guessed!</pre>

 

=={{header|AutoHotkey}}==

msgbox I am thinking of a number between 1 and 10.

 

Msgbox Try again.

}

 

=={{header|AutoIt}}==

$irnd = Random(1, 10, 1)

$iinput = -1

WEnd

MsgBox(0, "Success", "Well guessed!")

 

=={{header|AWK}}==

# syntax: GAWK -f GUESS_THE_NUMBER.AWK

BEGIN {

exit(0)

}

 

=={{header|BASIC}}==

 

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

20 PRINT "A NUMBER FROM 1 ";

30 PRINT "TO 10 HAS BEEN ";

70 Q = G% = N%

80 NEXT

 

==={{header|Commodore BASIC}}===

For the most part, identical to the Applesoft BASIC example above, except that Commodore BASIC evaluates TRUE as a value of -1 instead of 1.

 

20 print chr$(147);chr$(14)

30 print "I have chosen a number from 1 to 10."

70 q = g% = n%

80 next

 

{{out}}

 

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

110 RANDOMIZE

120 LET N=RND(10)+1

140 INPUT PROMPT "Guess a number that's between 1-10: ":G

150 LOOP UNTIL N=G

 

GOSUB initialize

GOSUB guessing

STOP

END IF

 

A more polished version of this program in QBasic/QB/VB-DOS

' OPTION EXPLICIT ' Remove remark for VB-DOS/PDS 7.1

' Var

DIM n AS INTEGER, g AS INTEGER, t AS INTEGER, a AS STRING

 

END FUNCTION

 

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

ZX Spectrum Basic has no [[:Category:Conditional loops|conditional loop]] constructs, so we have to emulate them here using IF and GO TO.

20 INPUT "Guess a number that's between 1 and 10: ",g

30 IF g=n THEN PRINT "That's my number!": STOP

40 PRINT "Guess again!"

 

=={{header|BASIC256}}==

print "I am thinking of a number from 1 to 10"

do

endif

until g = n

 

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

set /a answer=%random%%%(10-1+1)+1

set /p guess=Pick a number between 1 and 10:

if %guess%==%answer% (echo Well guessed!

pause) else (set /p guess=Nope, guess again:

 

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

REPEAT

INPUT "Guess a number between 1 and 10: " guess%

PRINT "Sorry, try again"

ENDIF

 

=={{header|Befunge}}==

{{works with|Fungus|0.28}}

{{works with|CCBI|2.1}}

> v ,,,,,,<

v?v ,

+>,,,,,,,,,,,,,,,,^

>>>>>>>>>v^"guessthenumber!"+19<

 

=={{header|Bracmat}}==

The value is generated by the <code>clk</code> function, which returns a (probably) non-integral rational number. The <code>den</code> function retrieves the denominators of this number. The rational number, multiplied by its denominator, becomes an natural number.

= mynumber

. clk$:?mynumber

)

& GuessTheNumber$

 

=={{header|Brat}}==

 

p "Guess a number between 1 and 10."

{ p "Well guessed!"; true }

{ p "Guess again!" }

 

=={{header|C}}==

 

#include <stdio.h>

#include <time.h>

puts("That's not my number. Try another guess:");

}

 

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

 

class GuessTheNumberGame

static void Main()

{

{

Console.Write("Guess: ");

}

 

 

 

 

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

 

#include <cstdlib>

#include <ctime>

}

 

 

=={{header|Clojure}}==

(def target (inc (rand-int 10))

 

(println "Try again")

(recur (inc n))))))

 

=={{header|COBOL}}==

PROGRAM-ID. Guess-The-Number.

 

GOBACK

 

=={{header|CoffeeScript}}==

guess = prompt "Guess the number. (1-10)"

while parseInt(guess) isnt num

guess = prompt "YOU LOSE! Guess again. (1-10)"

 

{{works_with|node.js}}

 

# This shows how to do simple REPL-like I/O in node.js.

readline = require "readline"

guess()

 

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

(format t "Try to guess a number from 1 to ~a!~%Guess? " max)

(loop with num = (1+ (random max))

(force-output)

finally (format t "Well guessed! You took ~a ~:*~[~;try~:;tries~].~%" num-guesses)))

Output:

<pre>CL-USER> (guess-the-number 10)

=={{header|Crystal}}==

{{trans|Ruby}}

puts "Guess the number: 1..10"

until gets.to_s.to_i == n; puts "Wrong! Guess again: " end

 

=={{header|D}}==

void main() {

immutable num = uniform(1, 10).text;

 

writeln("Yep, you guessed my ", num);

{{out}}

<pre>What's next guess (1 - 9)? 1

=={{header|Dart}}==

{{Trans|Kotlin}}

import 'dart:io';

 

do { stdout.write(" Your guess : "); } while (n != stdin.readLineSync());

print("\nWell guessed!");

 

=={{header|DCL}}==

$ number = f$extract( f$length( time ) - 1, 1, time ) + 1

$ loop:

$ inquire guess "enter a guess (integer 1-10) "

$ if guess .nes. number then $ goto loop

{{out}}

<pre>$ @guess_the_number

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('Congratulations' ) ;

end.

 

=={{header|Déjà Vu}}==

 

while true:

return

else:

 

=={{header|EasyLang}}==

write "Guess a number between 1 and 10: "

repeat

g = number input

until g = n

print " is wrong"

write "try again: "

.

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

The code above is simplified if we create a RANDOMIZER, which simplifies reuse (e.g. the code in RANDOMIZER does not have to be recreated for each need of a random number).

class

RANDOMIZER

 

end

{{out}}

<pre>

 

=={{header|Elena}}==

public program()

{

console.printLine("I'm thinking of a number between 1 and 10. Can you guess it?");

bool numberCorrect := false;

}

}

{{out}}

<pre>

=={{header|Elixir}}==

{{works with|Elixir|1.2}}

def play do

play(Enum.random(1..10))

end

 

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

 

=={{header|Erlang}}==

-module(guess_the_number).

-export([main/0]).

guess(N)

end.

 

=={{header|ERRE}}==

PROGRAM GUESS_NUMBER

 

END WHILE

END PROGRAM

Note: Adapted from Qbasic version.

 

=={{header|Euphoria}}==

{{trans|ZX_Spectrum_Basic}}

 

integer n,g

end while

 

 

=={{header|Factor}}==

 

USING: io random math math.parser kernel formatting ;

IN: guess-the-number

gen-number play-game

"Yes, the number was %d!\n" printf ;

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

\ tested with GForth 0.7.0

: RND ( -- n) TIME&DATE 2DROP 2DROP DROP 10 MOD ; \ crude random number

CR ." Yes it was " .

CR ." Good guess!" ;

 

=={{header|Fortran}}==

 

implicit none

 

 

end program guess_the_number

 

=={{header|FreeBASIC}}==

 

Randomize

End

End If

 

{{out}}

 

=={{header|Frink}}==

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

guess = 0

guess == target ? println["$guess is correct. Well guessed!"] : println["$guess is not correct. Guess again!"]

}

{{out}}

Including an example with a non-integer entered.

7 is correct. Well guessed!

</pre>

 

=={{header|Gambas}}==

Dim byGuess, byGos As Byte

Dim byNo As Byte = Rand(1, 10)

Me.Close

 

 

=={{header|GML}}==

n = irandom_range(1,10);

show_message("I'm thinking of a number from 1 to 10");

g = get_integer("I'm sorry "+g+" is not my number, try again. Please enter guess", 1);

}

 

=={{header|Go}}==

 

import (

}

}

 

=={{header|Groovy}}==

def random = new Random()

def keyboard = new Scanner(System.in)

}

println "Hurray! You guessed correctly!"

 

=={{header|GW-BASIC}}==

20 PRINT "Guess the number between 1 and 10."

30 WHILE N<>G

40 INPUT "Your guess? ",G

50 WEND

 

=={{header|Haskell}}==

import Control.Monad

import System.Random

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

ask `until_` answerIs ans

 

Simple version:

 

import System.Random

 

then putStrLn "You got it!"

else putStrLn "Nope. Guess again." >> gameloop r

 

=={{header|HolyC}}==

 

 

n = 1 + RandU16 % 10;

 

Print("That's not my number. Try another guess:\n");

 

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

This solution works in both languages.

 

n := ?10

repeat {

}

write("Well guessed!")

 

=={{header|J}}==

game=: verb define

n=: 1 + ?10

smoutput (guess=n){::'no.';'Well guessed!'

end.

 

Example session:

 

Guess my integer, which is bounded by 1 and 10

Guess: 1

no.

Guess: 2

 

=={{header|Java}}==

{{works with|Java|6+}}

public static void main(String[] args) throws NumberFormatException{

int n = (int)(Math.random() * 10 + 1);

System.out.println("Well guessed!");

}

For pre-Java 6, use a <code>Scanner</code> or <code>BufferedReader</code> for input instead of <code>System.console()</code> (see [[Input loop#Java]]).

 

=={{header|JavaScript}}==

function guessNumber() {

// Get a random integer from 1 to 10 inclusive

}

 

 

Requires a host environment that supports <code>prompt</code> and <code>alert</code> such as a browser.

 

jq currently does not have a built-in random number generator, so a suitable PRNG for this task is defined below. Once `rand(n)` has been defined, the task can be accomplished as follows:

{prompt: "Please enter your guess:", random: (1+rand(9)) }

| ( (while( .guess != .random; .guess = (input|tonumber) ) | .prompt),

 

'''Invocation'''

 

'''PRNG'''

# as rand() from the Microsoft C Runtime.

# Input: [ count, state, random ]

 

# A random integer in [0 ... (n-1)]:

 

=={{header|Jsish}}==

From Javascript entry.

// Get a random integer from 1 to 10 inclusive

var num = Math.ceil(Math.random() * 10);

The number was 2 it took 3 tries

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

number = dec(rand(1:10))

print("Guess my number! ")

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

do { print(" Your guess : ") } while (n != readLine())

println("\nWell guessed!")

Sample input/output:

{{out}}

 

=={{header|langur}}==

 

for {

writeln "too much bad data"

break

}

writeln "not it"

 

{{out}}

===Command Line===

The following example works when Lasso is called from a command line

number = integer_random(10, 1),

status = false,

}

 

 

===Web form===

The following example is a web page form

 

local(

[/if]

</body>

 

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

Well-guessed!!

ok

 

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

input "Guess the number I'm thinking of between 1 and 10. "; guess

while guess <> number

input "Incorrect! Try again! "; guess

wend

 

=={{header|LiveCode}}==

local tNumber, tguess

put random(10) into tNumber

end if

end repeat

 

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

 

20 PRINT "Guess the number between 1 and 10."

30 WHILE num<>guess

40 INPUT "Your guess? ", guess

50 WEND

 

=={{header|LOLCODE}}==

There is no native support for random numbers. This solution uses a simple linear congruential generator to simulate them, with the lamentable restriction that the user must first be prompted for a seed.

 

VISIBLE "SEED ME, FEMUR! "!

IM OUTTA YR guesser

 

 

=={{header|Lua}}==

n = math.random( 1, 10 )

 

print "Guess again: "

end

 

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

A copy from QBASIC, write blocks { } where needed, We use GOSUB and GOTO in a Module.

 

Module QBASIC_Based {

supervisor:

}

QBASIC_Based

 

=={{header|Maple}}==

 

local number;

randomize():

end do:

printf("Well guessed! The answer was %d.\n", number);

 

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

While[guess =!= number, guess = Input["Guess my number"]];

 

=={{header|MATLAB}}==

[guess, status] = str2num(input('Guess a number between 1 and 10: ','s'));

 

[guess, status] = str2num(input('Guess again: ','s'));

end

 

=={{header|MAXScript}}==

rand = random 1 10

clearListener()

format "\nChoose another value\n"

)

 

=={{header|Mercury}}==

Mercury does have a 'time' module in its standard library, but it offers an abstract type instead of the seconds-since-the-epoch we want to seed the RNG with. So this is also an example of how easy it is to call out to C. (It's just as easy to call out to C#, Java, and Erlang.) Also, rather than parse the input, this solution prepares the random number to match the typed input. This isn't a weakness of Mercury, just the author's desire to cheat a bit.

 

:- interface.

:- import_module io.

:- pragma foreign_proc("C", time(Int::out, _IO0::di, _IO1::uo),

[will_not_call_mercury, promise_pure],

 

=={{header|MiniScript}}==

while true

x = val(input("Your guess?"))

break

end if

 

=={{header|MIPS Assembly}}==

# WRITTEN: August 26, 2016 (at midnight...)

 

syscall

jr $ra

 

=={{header|Nanoquery}}==

{{trans|Ursa}}

target = random.getInt(9) + 1

guess = 0

end

 

 

=={{header|Nemerle}}==

using System.Console;

 

WriteLine("Well guessed!");

}

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols nobinary

 

return

 

=={{header|NewLISP}}==

; oofoe 2012-01-19

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

(println "Well guessed! Congratulations!")

 

 

Sample output:

 

=={{header|Nim}}==

randomize()

echo "I have thought of a number. Try to guess it!"

var guess = parseInt(readLine(stdin))

 

echo "Your guess was wrong. Try again!"

guess = parseInt(readLine(stdin))

 

=={{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 "INCORRECT GUESS. TRY AGAIN.": GOTO 20

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE GuessTheNumber;

IMPORT

Do;

END GuessTheNumber.

 

=={{header|Objeck}}==

use IO;

 

}

}

 

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

 

#import <Foundation/Foundation.h>

 

return 0;

}

 

=={{header|OCaml}}==

 

let () =

print_endline "The guess was wrong! Please try again!"

done;

 

=={{header|Oforth}}==

 

 

: guess

10 rand doWhile: [ "Guess :" . System.Console askln asInteger over <> ]

 

=={{header|Ol}}==

(import (otus random!))

 

(print "Well guessed!")

(loop)))

 

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

 

=={{header|Pascal}}==

 

var

writeln ('You made an excellent guess. Thank you and have a nice day.');

end.

 

=={{header|Perl}}==

do { print "Guess a number between 1 and 10: " } until <> == $number;

 

=={{header|Phix}}==

 

=={{header|PHP}}==

<?php

 

</body>

</html>

 

=={{header|PicoLisp}}==

(let Number (rand 1 9)

(loop

(T (= Number (read))

(prinl "Well guessed!") )

 

=={{header|PlainTeX}}==

This code should be compiled with etex features in console mode (for example "pdftex <name of the file>"):

\edef\tagetnumber{\number\numexpr1+\pdfuniformdeviate9}%

\message{^^JI'm thinking of a number between 1 and 10, try to guess it!}%

\ifnotguessed

\repeat

 

=={{header|PowerShell}}==

Provides a function that analyzes the provided number by its call. The second script block is important and needed inside the script so the function will be called.

{

$Number = Get-Random -min 1 -max 11

While ($Number -ne $Guess)

Write-Host "Well done! You successfully guessed the number $Guess."

 

=={{header|ProDOS}}==

Uses math module:

editvar /modify /value=-random-= <10

editvar /newvar /value=-random- /title=a

editvar /newvar /value=b /userinput=1 /title=Guess a number:

 

=={{header|Prolog}}==

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

 

random_between(1, 10, N),

repeat,

read(N),

writeln('Well guessed!'),

 

Example:

 

Guess the number: 1.

Guess the number: 2.

Guess the number: 3.

Well guessed!

 

=={{header|PureBasic}}==

Define TheNumber=Random(9)+1

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

 

=={{header|Python}}==

t,g=random.randint(1,10),0

g=int(input("Guess a number that's between 1 and 10: "))

while t!=g:g=int(input("Guess again! "))

 

=={{header|QB64}}==

''CBTJD'': 2020/04/13

CLS

RANDOMIZE TIMER

LOOP UNTIL n = num

INPUT "Well guessed! Go again"; a$

 

=={{header|R}}==

print("Guess a number between 1 and 10 until you get it right.")

n <- sample(10, 1)

}

print("You got it!")

 

=={{header|Racket}}==

(define (guess-number)

(define number (add1 (random 10)))

(if (equal? guess number)

(display "Well guessed!\n")

 

=={{header|Raku}}==

(formerly Perl 6)

repeat {} until prompt("Guess a number: ") == $number;

 

=={{header|RapidQ}}==

RANDOMIZE

number = rnd(10) + 1

print "You guessed right, well done !"

input "Press enter to quit";a$

 

=={{header|Rascal}}==

import vis::Figure;

import util::Math;

button("Start over", void(){random = arbInt(10);}) ]));

render(figure);

 

Output:

 

=={{header|Red}}==

Red []

#include %environment/console/CLI/input.red

]

print "Well guessed!"

 

=={{header|Retro}}==

over = [ drop 0 ] [ "Sorry, try again!\n" puts -1 ] if ;

 

think [ getToken toNumber checkGuess ] while

"You got it!\n" puts ;

 

=={{header|REXX}}==

===version 1===

/*REXX program to play: Guess the number */

 

 

say "Well done! You guessed it!"

 

===version 2===

 

 

=={{header|Ring}}==

 

 

### Bert Mariani

end

 

 

=={{header|RPL}}==

 

DIR

INITIALIZE

END

>>

 

=={{header|Ruby}}==

n = rand(1..10)

puts 'Guess the number: '

puts 'Wrong! Guess again: ' until gets.to_i == n

puts 'Well guessed!'

 

=={{header|Run BASIC}}==

choose = int(RND(0) * 9) + 1

while guess <> choose

end if

wend

 

=={{header|Rust}}==

{{libheader|rand}}

 

fn main() {

}

}

 

=={{header|Scala}}==

 

val n = (math.random * 10 + 1).toInt

print("Guess the number: ")

while(readInt != n) print("Wrong! Guess again: ")

println("Well guessed!")

 

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

{{works with|Guile}}

(define number (random 11))

(display "Pick a number from 1 through 10.\n> ")

(do ((guess (read) (read)))

((= guess number) (display "Well guessed!\n"))

{{Out}}

<pre>scheme> (guess)

 

=={{header|Seed7}}==

 

const proc: main is func

end while;

writeln("You have won!");

 

=={{header|Self}}==

Well factored:

 

parent* = traits clonable.

copy = (resend.copy secretNumber: random integerBetween: 1 And: 10).

hasGuessed = ( [ask = secretNumber] onReturn: [|:r| r ifTrue: [reportSuccess] False: [reportFailure]] ).

run = (sayIntroduction. [hasGuessed] whileFalse)

 

Simple method:

 

userQuery report: 'Try to guess my secret number between 1 and 10.'.

n: random integerBetween: 1 And: 10.

[(userQuery askString: 'Guess the Number.') asInteger = n] whileFalse: [

userQuery report: 'Nope. Guess again.'].

 

=={{header|Sidef}}==

}

 

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

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

While guess<>number

TextWindow.WriteLine("Guess again! ")

EndWhile

 

=={{header|SNUSP}}==

 

=={{header|Swift}}==

 

var found = false

println("Well guessed!")

}

 

=={{header|Tcl}}==

puts "I have thought of a number."

puts "Try to guess it!"

puts "Your guess was wrong. Try again!"

}

Sample output:

<pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

PRINT "Find the luckynumber (7 tries)!"

ENDLOOP

ENDCOMPILE

Output:

<pre>

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

{{works with|Bourne Shell}}

# Guess the number

# This simplified program does not check the input is valid

echo 'Sorry, the guess was wrong! Try again!'

done

 

An older version used <code>while [ "$guess" -ne "$number" ]</code>. With [[pdksh]], input like '+' or '4x' would force the test to fail, end that while loop, and act like a correct guess. With <code>until [ "$guess" -eq "$number" ]</code>, input like '+' or '4x' now continues this until loop, and acts like a wrong guess. With Heirloom's Bourne Shell, '+' acts like '0' (always a wrong guess), and '4x' acts like '4' (perhaps correct).

==={{header|C Shell}}===

{{libheader|jot}}

# Guess the number

 

@ guess = "$<"

end

 

=={{header|Ursa}}==

{{trans|Python}}

 

decl ursa.util.random random

end while

 

 

=={{header|Vala}}==

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

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

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

return 0;

 

=={{header|VBA}}==

Dim NbComputer As Integer, NbPlayer As Integer

Randomize Timer

Loop While NbComputer <> NbPlayer

MsgBox "Well guessed!"

 

=={{header|VBScript}}==

MyNum=Int(rnd*10)+1

Do

wscript.quit

end if

 

=={{header|Visual Basic .NET}}==

Sub Main()

Dim random As New Random()

Loop Until gameOver

End Sub

{{Out}}

<pre>I am thinking of a number from 1 to 10. Can you guess it?

Well guessed!</pre>

 

import os

 

fn main() {

}

{{out}}

</pre>

 

=={{header|Wee Basic}}==

Due to how the code works, any key has to be entered to generate the random number.

let mxnumber=10

let number=mnnumber

endif

wend

 

=={{header|Wortel}}==

{{trans|JavaScript}}

num 10Wc

guess 0

!alert "Congratulations!\nThe number was {num}."

]

 

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

 

 

 

 

 

=={{header|XLISP}}==

(defun prompt ()

(display "What is your guess? ")

(display "I have thought of a number between 1 and 10. Try to guess it!")

(newline)

{{out}}

<pre>[1] (guessing-game)

 

=={{header|XPL0}}==

int N, G;

[N:= Ran(10)+1;

];

Text(0, "Well guessed!^M^J");

 

=={{header|zkl}}==

Strings are used to avoid dealing with error handling

while(1){

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

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

println("Nope")

 

=={{header|Zoomscript}}==

For typing:

var guess

randnum & random 1 10

endif

endwhile

 

For importing: