24 game: Difference between revisions

{{trans|C++}}

 

String message

F (message)

F op(f)

I .stk.len < 2

V b = .stk.pop()

V a = .stk.pop()

E I c == ‘/’ {.op((a, b) -> a / b)}

E I c != ‘ ’

 

F get_result()

I .stk.len != 1

R .stk.last

 

 

X.catch Error error

 

{{out}}

=={{header|8th}}==

This is a fully-worked sample of the game in 8th, showing error-detection and user-restriction techniques:

\ Generate four random digits and display to the user

\ then get an expression from the user using +, -, / and * and the digits

start

 

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program game24_64.s */

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

.include "../includeARM64.inc"

=={{header|ABAP}}==

See [[24 game/ABAP]]

=={{header|Ada}}==

game24.adb:

with Ada.Text_IO;

with Ada.Numerics.Discrete_Random;

end if;

end;

 

{{out}}

You won!

Enter N for a new game, or try another solution.</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

⎕←d←?⍵⍴9

i←⍞

24≠⍎i:'nope'

'Yeah!'

{{out}}

<pre> tfgame 4

This was taken from both the [[#Commodore_BASIC|Commodore BASIC]] and [[#ZX_Spectrum_Basic|ZX Spectrum Basic]] solutions.

 

1 GOSUB 1200: CALL - 868

10 LET N$ = ""

2005 :::::::::::::

2010 RETURN

 

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

 

do

error "unclosed parenthesis"

return x

compile with:

arc 24_game.arg -o 24_game.c && gcc 24_game.c -o 24_game /usr/lib/libargrt.a

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program game24.s */

/***************************************************/

.include "../affichage.inc"

<pre>

24 Game

=={{header|Arturo}}==

 

print " Welcome to 24 Game"

print "-----------------------------"

]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

Title := "24 Game"

Gui, -MinimizeBox

FileDelete, %File%

Return, Result

 

=={{header|AutoIt}}==

;AutoIt Script Example

;by Daniel Barnes

endif

EndFunc

 

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

DIM digits%(4), check%(4)

FOR choice% = 1 TO 4

INPUT '"Play again", answer$

IF LEFT$(answer$,1) = "y" OR LEFT$(answer$,1) = "Y" THEN CLS : RUN

 

=={{header|Befunge}}==

2 2 1234

4 ^1?3^4

| -*84gg01g00<p00*84<v <

>00g:1+00p66*`#^_ "niW">:#,_@

The code functions by placing the 4 randomly generated numbers into the points labelled 1,2,3,4. In order to play, press the corresponding label to draw that number onto the stack, then press the corresponding operation (+,-,*,/) to perform it on the stack elements postfix-wise according to the rules of befunge (i.e. pop the values operate and push the answer back to the stack). When you wish to check your answer enter "=" and it will perform the checks to ensure that you haven't performed any illegal operations, that you have used all four numbers and that your final value is 24.

 

=={{header|Bracmat}}==

 

= m-w m-z 4numbers answer expr numbers

, seed get-random convertBinaryMinusToUnary

)

& 24-game$(13.14)

<pre>Enter an expression that evaluates to 24 by combining the following numbers.

You may only use the operators + - * /

=={{header|C}}==

Simple recursive descent parser. It doesn't have a real lexer, because all tokens are single character (digits, operators and parens). Code is a little too long.

#include <ctype.h>

#include <stdlib.h>

}

return 0;

{{out}}

<pre>Available digits are: 5 2 3 9. Type an expression and I'll check it for you, or make new numbers.

This uses the C++11 standard to simplify several parts of the code. Input is given in RPN format.

 

#include <iostream>

#include <stack>

}

return 0;

 

{{out}}

=={{header|Ceylon}}==

Be sure to import ceylon.random in you ceylon.module file.

DefaultRandom

}

}

}

 

=={{header|Clojure}}==

(ns rosettacode.24game)

 

; * checks prefix form, then checks to see that the numbers used

; and the numbers generated by the game are the same.

 

=={{header|COBOL}}==

*> This code is dedicated to the public domain

*> This is GNUCobol 2.0

.

end program twentyfour.

 

=={{header|CoffeeScript}}==

{{works with|node.js}}

tty.setRawMode true

 

# begin taking input

process.stdin.resume()

 

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

 

 

To get around this, this program utilizes BASIC's ability to parse expressions containing simple math operators, and is in fact technically a self-modifying program. Line 2005 is a line padded with colons which simply allow BASIC to join multiple statements on a single line, otherwise perform no operation. This reserves sufficient space in memory for inserting the user's expression&mdash;by overwriting the first several bytes of colons&mdash;which can then be evaluated in the normal course of the program's execution. The subroutine at 1400 initializes a simple translation table for exchanging the operators into their proper BASIC tokens. Parenthesis, numerals, and variable names do not need to be translated.

Since Commodore BASIC v2 was the initial target for this program, all other versions of Commodore BASIC are compatible as long as the base memory address for BASIC programs is adjusted. (BASIC tokens maintain compatibility across all versions.) Simply use the appropriate values for <code>bh</code> and <code>bl</code> in lines 11-15.

 

2 rem for rosetta code

10 rem use appropriate basic base address

2005 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

2010 return

 

{{out}}

 

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

(define-condition bad-equation (error) ())

 

(if (= 24 (eval (check (prompt)))) (win) (lose))

(error () (format t "Bad equation, try again.~%"))

 

'''Verbose Implementation'''

 

{{works with|clisp|2.47}}

(defconstant +ops+ '(* / + -))

 

(emit "Sorry, the form you entered did not ~

compute.~%~%")))))

 

Example Usage:

 

=={{header|D}}==

std.typetuple;

 

writeln("Result: ", stack[0]);

writeln(abs(stack[0] - 24) < 0.001 ? "Good job!" : "Try again.");

Example:

<pre>Make 24 with the digits: [1, 8, 9, 8]

Result: 24

Good job!</pre>

 

=={{header|EchoLisp}}==

(string-delimiter "")

;; check that nums are in expr, and only once

(writeln "24-game - Can you combine" nums "to get 24 ❓ (q to exit)")

(input-expr check-24 (string-append (string nums) " -> 24 ❓")))

{{out}}

<pre>

 

=={{header|Elena}}==

import system'collections;

import system'dynamic;

class ExpressionTree

{

constructor(s)

auto level := new Integer(0);

{

var node := new DynamicStruct();

ch =>

$40 { level.append(10); ^ self } // (

$41 { level.reduce(10); ^ self } // )

node.Leaf := ch.toString().toReal();

node.Level := level + 3

};

{

}

else

{

{

}

else

{

}

}

eval(node)

{

{

^ node.Leaf

get Value()

readLeaves(list, node)

{ InvalidArgumentException.raise() };

{

list.append(node.Leaf)

readLeaves(list)

}

 

theNumbers := new object[]

{

}

}

{

console

.writeLine()

}

prompt()

{

}

var leaves := new ArrayList();

ifnot (leaves.ascendant().sequenceEqual(theNumbers.ascendant()))

var result := tree.Value;

if (expr == "")

{

}

else

catch(Exception e)

{

}

};

}

}

 

public program()

 

while (game.prompt().playRound(console.readLine())) {}

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def main do

IO.puts "24 Game"

end

 

 

{{out}}

 

=={{header|Erlang}}==

-export([main/0]).

 

eval([X|Rest], 0) when X >= $1, X =< $9 ->

eval(Rest, X-$0).

 

The evaluator uses a simple infix scheme that doesn't care about operator precedence, but does support brackets and parentheses alike. Thus, <code>((9+1)*2)+2+2</code> is evaluated as:

 

=={{header|F_Sharp|F#}}==

open System.Text.RegularExpressions

 

loop()

 

{{out}}

<pre>Compute 24 from the following 4 numbers: 3 3 3 5

 

=={{header|Factor}}==

combinators.short-circuit

continuations

[ '[ _ step ] loop ]

bi ;

Sample:

IN: scratchpad main

Your numbers are { 4, 1, 8, 2 }, make an expression

8 4 + 2 * 1 /

You got it!

 

=={{header|Falcon}}==

 

function genRandomNumbers( amount )

end

end

 

=={{header|Fortran}}==

Indicate operator precedence by parentheses; e.g. (3+(5*6))-9. No whitespace is admissible.

The program uses [[Insertion_sort#Fortran|Insertion_sort in Fortran]].

implicit none

real :: vector(4), reals(11), result, a, b, c, d

 

end program game_24

 

===As a more general recursive descent parser:===

Permits spaces and arbitrary parentheses.

 

! implement a recursive descent parser

module evaluate_algebraic_expression

end subroutine deal

end program g24

 

Compilation and too many examples. Which would you cut?

=={{header|FreeBASIC}}==

Solución en '''RPN''':

' The 24 game en FreeBASIC

 

End

'--------------------------

{{out}}

<pre>

 

</pre>

 

=={{header|GAP}}==

Solution in '''RPN''':

local input, digits, line, c, chars, stack, stackptr, cur, p, q, ok, a, b, run;

input := InputTextUser();

[ 5, 9, 2, 7 ]

end

 

=={{header|Go}}==

RPN solution.

 

import (

fmt.Println("correct.")

}

Example game:

<pre>

 

=={{header|Gosu}}==

uses java.lang.Double

uses java.lang.Integer

print( "You lose!" )

}

 

=={{header|Groovy}}==

{{trans|Ruby}}

This solution breaks strict adherence to the rules in only one way: any line that starts with the letter "q" causes the game to quit.

final input = new Scanner(System.in)

 

println 'One more try, then?'

}

 

Sample Run:

 

=={{header|Haskell}}==

import Data.Char (isDigit)

import Data.Maybe (fromJust)

isOp v = elem v $ fmap fst ops

 

 

=={{header|HicEst}}==

CHARACTER expression*100, prompt*100, answers='Wrong,Correct,', protocol='24 game.txt'

 

DLG(TItle=prompt, Button='>2:Try again', B='>1:New game', B='Quit')

 

4 + 8 + 7 + a: Instead 4 digits you used 3

4 + 8 + 7 + a + 4: a is an illegal character

4 + 8 + 7a + 4: a is an illegal character

4 + 8 + 7 + 4:; answer=Wrong; result=23;

 

=={{header|Huginn}}==

exec huginn --no-argv -E "${0}"

#! huginn

}

return ( 0 );

 

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

This plays the game of 24 using a simplified version of the code from the [[Arithmetic_evaluation#Icon_and_Unicon|Arithmetic evaluation]] task.

link strings # for csort, deletec

 

"Combining (concatenating) digits is not allowed.\n",

"Enter 'help', 'quit', or an expression.\n")

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

 

deal=: 1 + ? bind 9 9 9 9

rules=: smoutput bind 'see http://en.wikipedia.org/wiki/24_Game'

respond=: (;:'no yes') {::~ wellformed * is24

 

 

Example use:

=={{header|Java}}==

{{works with|Java|7}}

 

public class Game24 {

return result;

}

 

{{out}}

=={{header|JavaScript}}==

 

function twentyfour(numbers, input) {

var invalidChars = /[^\d\+\*\/\s-\(\)]/;

alert(twentyfour(numbers, input));

}

 

=={{header|Julia}}==

This implementation, because it is based on the Julia parser and evaluator, allows the user to enter arbitrary infix expressions, including parentheses. (These expressions are checked to ensure that they only include the allowed operations on integer literals.)

validexpr(ex::Int) = true

validexpr(ex::Any) = false

end

end

{{out}}

<pre>

enter expression using [2,5,8,9] => (8 + 9) + (5 + 2)

you won!</pre>

 

=={{header|Kotlin}}==

import java.util.Scanner

import java.util.Stack

}

 

 

=={{header|Lasso}}==

 

If a valid expression it is evaluated, and the result and success state shown to the user.

if(sys_listunboundmethods !>> 'randoms') => {

define randoms()::array => {

[if(#exprsafe)]

<p>Result: <b>[#exprresult]</b> [#exprcorrect ? 'is CORRECT!' | 'is incorrect']</p>

 

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

dim chk(4)

print "The 24 Game"

exit function

[handler]

 

=={{header|LiveCode}}==

4. label button "StartButton"

 

put empty into fld "EvalField"

put empty into fld "AnswerField"

put random(9) & comma & random(9) & comma & random(9) & comma & random(9) into fld "YourNumbersField"

on keyDown k

local ops, nums, allowedKeys, numsCopy, expr

exit keyDown

end if

 

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

 

20 PRINT "The 24 Game"

30 PRINT "===========":PRINT

520 ' syntax error, e.g. non-matching parentheses

530 PRINT "Error in expression, please try again."

 

Note: The program needs a writable disk in the active disk drive.

=={{header|Logo}}==

{{works with|UCB_Logo|5.5}}

make "false 1=0

make "true 1=1

]]]

]

{{out}}

<pre>

 

=={{header|Lua}}==

local function help()

print [[

end

end

 

Alternately, using the <code>lpeg.re</code> module:

 

print [[

The 24 Game

end

end

 

=={{header|Maple}}==

Click [http://maplecloud.maplesoft.com/application.jsp?appId=5764927761416192 here] to try this game online.

export ModuleApply;

local cheating;

end module:

 

{{out}}

<pre>

Most of the job is already done by Mathematica (the expression conversion); in fact, it is ''too'' good&mdash;it automatically converts ex. 3/4 to Times[3, Power[4, -1]], which we have to specifically test for so that real powers don't get through.

 

Quiet[Check[

With[{h = ToExpression[x, StandardForm, HoldForm]},

"Sorry, that is invalid.", 24, "Congrats! That's 24!", _,

"Sorry, that makes " <> ToString[ToExpression@x, InputForm] <>

 

=={{header|MATLAB}} / {{header|Octave}}==

 

N = 4;

n = ceil(rand(1,N)*9);

else

fprintf('expression "%s" does not result in 24 but %i.\n',s,val);

 

=={{header|MiniScript}}==

We use a simple recursive descent parser, with a bit of extra code to make sure that only available digits are used, and all of them are used.

result = evalMultDiv

while true

result = null

while result != 24

print "Using only the digits " + availableDigits + ","

tokens = input("enter an expression that comes to 24: ").replace(" ","").values

if result != null then print "That equals " + result + "."

end while

 

{{out}}

 

=={{header|mIRC Scripting Language}}==

dialog -m 24-Game 24-Game

}

did -o 24-Game 1 1 Numbers: $rand(1,9) $rand(1,9) $rand(1,9) $rand(1,9)

}

 

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

{{libheader|Ulm's Modula-2 Library}}

 

FROM InOut IMPORT WriteString, WriteLn, Write, ReadString, WriteInt;

END;(*of CASE*)

WriteLn;

 

=={{header|MUMPS}}==

k number, operator, bracket

; generate 4 random numbers each between 1 & 9

w x

q

 

=={{header|Nanoquery}}==

import Nanoquery.Util

 

end

end

{{out}}

<pre>Your digits are: [2, 5, 4, 6]

{{trans|D}}

{{works with|Nim Compiler|1.0.0}}

from strutils import Whitespace

from algorithm import sort

raise newException(ValueError, "Wrong expression.")

echo "Result: ", stack[0]

Example game:

<pre>Make 24 with the digits: @[8, 1, 3, 1]

Source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/24_game.nit the Nit’s official repository]

 

fun is_op: Bool do return "-+/*".has(self)

end

end

 

 

=={{header|Objeck}}==

{{trans|C++}}

 

use System.Matrix;

 

alias Func {

Calc : (IntHolder, IntHolder) ~ IntHolder

 

=={{header|OCaml}}==

ocamlopt -pp camlp4o g24.ml -o g24.opt

 

| Const of float

| Sum of expression * expression (* e1 + e2 *)

else print_endline "Try again"

end

 

=={{header|Oforth}}==

 

 

: game

#null? l conform? ifFalse: [ "Sorry, all numbers must be used..." . return ]

24 if=: [ "You won !" ] else: [ "You loose..." ] .

 

=={{header|ooRexx}}==

=={{header|OpenEdge/Progress}}==

The dynamic query parser is used to evaluate the expression.

 

DEFINE VARIABLE p_deanswer AS DECIMAL NO-UNDO.

 

MESSAGE cmessage VIEW-AS ALERT-BOX.

 

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

{{untested}}

my(v=vecsort(vector(4,i,random(8)+1)));

print("Form 24 using */+-() and: "v);

1

)

 

=={{header|Perl}}==

use warnings;

use strict;

elsif ($n == 24) { say "You win!"; last; }

else { say "Sorry, your expression is $n, not 24"; }

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">-- Note this uses simple/strict left association, so for example:

-- 1+2*1*8 is ((1+2)*1)*8 not 1+((2*1)*8) [or 1+(2*(1*8))], and

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

 

=={{header|PHP}}==

{{trans|Perl}}

The 24 Game

return eval("return $expression;");

}

 

=={{header|Picat}}==

 

main =>

),

play.

 

=={{header|PicoLisp}}==

(load "@lib/frac.l")

 

(loopuntilquit)

 

{{out}}

<pre>

 

=={{header|PL/I}}==

/* Plays the game of 24. */

 

 

end TWENTYFOUR;

 

=={{header|Potion}}==

x = s ord(0)

if (x >= "0"ord && x <= "9"ord): true.

else:

(entry, " => ", expr string, " != 24") join("") say.

 

=={{header|PowerShell}}==

todo: add a validation that all given digits were used. Right now the validation is that 4 digits should be used in the expression, but not exactly the ones given. (example: if you are given the digits 2, 2, 6, 9 this program accepts the following solution: 6 * '''4''' * 2 / 2)

 

CLS

 

}

While($EndResult -ne 24)

 

=={{header|ProDOS}}==

This example uses the math module:

editvar /modify -random- = <10

printline These are your four digits: -random- -random- -random- -random-

:b

editvar /newvar /value=b /userinput=1 /title=Do you want to play again?

 

=={{header|Prolog}}==

{{Works with|GNU Prolog}}

 

 

, ( X == 10 -> Xs = [] ; Xs = [X|Ys], get_line(Ys) )

.

Example "session":

<pre>Digits: [9,4,6,9]

 

=={{header|PureBasic}}==

Global Dim digits(#digitCount - 1) ;holds random digits

 

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

CloseConsole()

{{out}}

<pre>The 24 Game

===Python: Original, with output===

Uses eval, the built-in expression evaluator of infix expressions.

The 24 Game

 

print ("Thank you and goodbye")

 

 

{{out}}

 

===Python: Alternative===

chars = ["(",")","/","+","-","*"]

while True:

print "You cannot use anthing other than", charsandints

break

 

=={{header|Quackery}}==

<code>switch</code>, <code>case</code>, and <code>otherwise</code> are defined at [[Metaprogramming#Quackery]].

 

 

0 $ "*/+-" witheach [ bit | ]

24 n->v v- v0= iff

[ say ". :-)" ] else [ say ". :-(" ]

 

{{out}}

This makes use of R's metaprogramming (parse, eval, etc.). It uses parse to obtain a parse tree, which is scanned for containing only permitted elements before evaluating.

 

selector=function() sample(1:9, 4, replace=TRUE),

arguments=selector(),

if (! isTRUE(all.equal(sort(numbers.used), sort(arguments))))

stop("Must use each number once.")

Example Session

 

Make 24 out of the numbers 1, 6, 7, 5 and the operators +, -, *, /, ( .

> q

Goodbye!

 

=={{header|Racket}}==

invalid cases.

 

#lang racket

 

result

(error "You didn`t use all numbers!")))

 

Testing the interpreter:

The program which uses the interpreter to play the game:

 

;; starting the program

(define (start)

(define (read-the-answer)

(read (open-input-string (format "(~a)" (read-line)))))

 

=={{header|Raku}}==

 

{{works with|Rakudo|2015.12}}

 

say "Here are your digits: ",

}

}

 

The <code>MONKEY-SEE-NO-EVAL</code> pragma enables the dangerous <code>EVAL</code> function, which will compile and execute even user input. In this example, the grammar used to parse the input should ensure that only safe expressions are evaluated.

=={{header|Red}}==

 

Red []

print "Evaluation from left to right with no precedence, unless you use parenthesis." print ""

print "You got it right!"

 

Output:

<pre>

 

===Red: Alternative===

Red [

Title: "24 Game"

 

forever [main]

 

=={{header|REXX}}==

This REXX version uses an in─line documentation (for help).

 

 

╔═════════════════════════════════════════════════════════════════════════════╗

when _v\==0 then call ger 'illegal character:' substr(y, _v, 1)

otherwise nop

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

 

 

=={{header|Ring}}==

# Project : 24 game

 

ok

end

Output:

<pre>

sorry, you used the illegal digit 9

</pre>

 

=={{header|Ruby}}==

def self.play

nums = Array.new(4){rand(1..9)}

end

 

 

=={{header|Rust}}==

So if there is someone better than me please feel free to improve.

{{libheader|rand}}

extern crate rand;

use rand::Rng;

}

 

 

=={{header|Scala}}==

 

Only problems with solution are shown to the user.

def main(args: Array[String]) {

import Parser.TwentyFourParser

}

}

 

{{out}}

This uses read to read in a scheme expression, and eval to evaluate it, so in that sense it's not ideal (eval is evil etc.) but any expression that is valid should be safe and terminate in a timely manner.

 

(require srfi/27 srfi/1) ;; random-integer, every

 

 

(provide play)

 

{{out}}

 

=={{header|Sidef}}==

const grammar = Regex(

'^ (?&exp) \z

default { say "Sorry, your expression is #{n}, not 24" }

}

{{out}}

<pre>

 

=={{header|Simula}}==

 

CLASS EXPR;

 

END.

{{out}}

<pre>

 

=={{header|Swift}}==

import Foundation

 

println("Congratulations, you found a solution!")

}

 

=={{header|Tcl}}==

{{trans|Python}}

This version also terminates cleanly on end-of-file.

proc choose4 {} {

set digits {}

puts "Thank you and goodbye"

}

 

=={{header|TorqueScript}}==

Includes an equation parser to avoid using eval.

To use, type startTwentyFourGame(); in the console.

{

if($numbers !$= "")

}

return %equ;

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

BUILD X_TABLE blanks = ":': :"

ENDSECTION

DO game

{{out}}

<pre style='height:30ex;overflow:scroll'>

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

Tried to be POSIX. Not sure about corner-cases.

awk 'BEGIN { srand()

for(i = 1; i <= 4; i++) print 1 + int(9 * rand())

 

echo $message

 

=={{header|VBA}}==

Sub Rosetta_24game()

 

End Sub

 

 

{{trans|Go}}

import rand

import rand.seed

println("correct.")

}

 

{{out}}

{{libheader|Wren-ioutil}}

{{libheader|Wren-seq}}

 

var R = Random.new()

}

 

 

{{out}}

Make 24 using these digits: [2, 3, 5, 1]

> 23*51-*

Correct!

</pre>

=={{header|Yabasic}}==

With reverse polish notation

espacios$ = " "

 

until(testigo = false)

return cadena$

 

{{trans|ZX Spectrum Basic}}

clear screen

n$=""

return execute(mid$(c$,5,8))

end sub

 

=={{header|zkl}}==

digits := [1..4].pump(String,(0).random.fpM("11-",1,9));

exp := ask("Enter an expression using the digits ",digits,

else println("That evaled to ",r,", not 24");

}

{{out}}

<pre>

 

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

20 RANDOMIZE

30 FOR i=1 TO 4

490 DATA "(nonon)on"

495 DATA "(no(non))on"