boolean, Scheme will treat any value that

Different AI algorithm are tested is not #f as a true value.

using lisp (LISt Processing
2.1.2  Numbers
Programming) programming
using Dr scheme application. Scheme numbers can be integers (eg, 42),
rationals (22/7), reals (3.1416), or complex
Data types (2+3i). An integer is a rational is a real is a
complex number is a number. Predicates
A data type is a collection of related exist for testing the various kinds of
values. These collections need not be numberness:
disjoint, and they are often hierarchical.
Scheme has a rich set of data types: (number? 42) => #t
some are simple (indivisible) data types (number? #t) => #f
and others are compound data types (complex? 2+3i) => #t
made by combining other data types. (real? 2+3i) => #f
(real? 3.1416) => #t
2.1  Simple data types (real? 22/7) => #t
(real? 42) => #t
The simple data types of Scheme include (rational? 2+3i) => #f
booleans, numbers, characters, and (rational? 3.1416) => #t
symbols. (rational? 22/7) => #t
(integer? 22/7) => #f
2.1.1  Booleans (integer? 42) => #t

Scheme’s booleans are #t for true and #f
for false. Scheme has a predicate
procedure called boolean? that checks if its
argument is boolean.
SANDEEP KUMAR http://san24mca.blogspot.com/
Scheme integers need not be specified in
decimal (base 10) format. They can be
specified in binary by prefixing the
numeral with #b. Thus #b1100 is the

number twelve. The octal prefix is #o and

(boolean? #t) => #t the hex prefix is #x. (The optional decimal
(boolean? "Hello, World!") => #f prefix is #d.)

The procedure not negates its argument, Numbers can tested for equality using the
considered as a boolean. general-purpose equality predicate eqv?.

(not #f) => #t (eqv? 42 42) => #t

(not #t) => #f (eqv? 42 #f) => #f
(not "Hello, World!") => #f (eqv? 42 42.0) => #f

The last expression illustrates a Scheme

convenience: In a context that requires a
 However, if you know that the arguments (abs 3) => 3
to be compared are numbers, the special (abs -4) => 4
number-equality predicate = is more apt.
This is just the tip of the iceberg. Scheme
(= 42 42) => #t provides a large and comprehensive suite
(= 42 #f) -->ERROR!!! of arithmetic and trigonometric
(= 42 42.0) => #t procedures. For instance, atan, exp, and
sqrt respectively return the arctangent,
Other number comparisons allowed are <, natural antilogarithm, and square root of
<=, >, >=. their argument.

(< 3 2) => #f 2.1.3  Characters

(>= 4.5 3) => #t
Scheme character data are represented by
Arithmetic procedures +, -, *, /, expt have prefixing the character with #\ . Thus, #\c
the expected behavior: is the character c. Some non-graphic
characters have more descriptive names,
(+ 1 2 3) => 6 eg, #\newline, #\tab. The character for
(- 5.3 2) => 3.3 space can be written #\  , or more
(- 5 2 1) => 2 readably, #\space.
(* 1 2 3) => 6
(/ 6 3) => 2 The character predicate is char?:
(/ 22 7) => 22/7
(expt 2 3) => 8 (char? #\c) => #t
(expt 4 1/2) => 2.0 (char? 1) => #f
(char? #\;) => #t
For a single argument, - and / return the
negation and the reciprocal respectively: Note that a semicolon character datum
does not trigger a comment.
(- 4) => -4
(/ 4) => 1/4 The character data type has its set of
SANDEEP KUMAR http://san24mca.blogspot.com/

comparison predicates: char=?, char<?,

The procedures max and min return the char<=?, char>?, char>=?.
maximum and minimum respectively of
the number arguments supplied to them. (char=? #\a #\a) => #t
Any number of arguments can be so (char<? #\a #\b) => #t
supplied. (char>=? #\a #\b) => #f

(max 1 3 4 2 3) => 4 To make the comparisons case-insensitive,

(min 1 3 4 2 3) => 1 use char-ci instead of char in the procedure
name:
The procedure abs returns the absolute
value of its argument. (char-ci=? #\a #\A) => #t
(char-ci<? #\a #\B) => #t

The case conversion procedures are char-
downcase and char-upcase:
(char-downcase #\A) => #\a
(char-upcase #\a) => #\A
2.1.4  Symbols
The simple data types we saw above are
self-evaluating. i.e., if you typed any
object from these data types to the listener,
the evaluated result returned by the listener
will be the same as what you typed in.
#t => #t
42 => 42
#\c => #\c
Symbols don’t behave the same way. This
is because symbols are used by Scheme
programs as identifiers for variables, and
thus will evaluate to the value that the
variable holds. Nevertheless, symbols are a
simple data type, and symbols are
legitimate values that Scheme can traffic
in, along with characters, numbers, and the
rest.
To specify a symbol without making
Scheme think it is a variable, you should
SANDEEP KUMAR http://san24mca.blogspot.com/
quote the symbol:
(quote xyz)
=> xyz
Since this type of quoting is very common
in Scheme, a convenient abbreviation is
provided. The expression
'E
will be treated by Scheme as equivalent to
(quote E)
Scheme symbols are named by a sequence
of characters. About the only limitation on
a symbol’s name is that it shouldn’t be
mistakable for some other data, eg,
characters or booleans or numbers or
compound data. Thus, this-is-a-symbol,
i18n, <=>, and $!#* are all symbols; 16, -i
(a complex number!), #t, "this-is-a-string",
and (barf) (a list) are not. The predicate for
checking symbolness is called symbol?:
(symbol? 'xyz) => #t
(symbol? 42) => #f
Scheme symbols are normally case-
insensitive. Thus the symbols Calorie and
calorie are identical:
(eqv? 'Calorie 'calorie)
=> #t
We can use the symbol xyz as a global
variable by using the form define:
(define xyz 9)
This says the variable xyz holds the value
9. If we feed xyz to the listener, the result
will be the value held by xyz:
xyz
=> 9
We can use the form set! to change the
value held by a variable:
(set! xyz #\c)
Now
xyz
=> #\c

2.2  Compound data types
Compound data types are built by
combining values from other data types in
structured ways.
2.2.1  Strings
Strings are sequences of characters (not to
be confused with symbols, which are
simple data that have a sequence of
characters as their name). You can specify
strings by enclosing the constituent
characters in double-quotes. Strings
evaluate to themselves.
"Hello, World!"
=> "Hello, World!"
The procedure string takes a bunch of
characters and returns the string made
from them:
(string #\h #\e #\l #\l #\o)
=> "hello"
Let us now define a global variable
greeting.
(define greeting "Hello; Hello!")
SANDEEP KUMAR http://san24mca.blogspot.com/
Note that a semicolon inside a string
datum does not trigger a comment.
The characters in a given string can be
individually accessed and modified. The
procedure string-ref takes a string and a (0-
based) index, and returns the character at
that index:
(string-ref greeting 0)
=> #\H
New strings can be created by appending
other strings:
(string-append "E "
"Pluribus "
"Unum")
=> "E Pluribus Unum"
You can make a string of a specified
length, and fill it with the desired
characters later.
(define a-3-char-long-string (make-string
3))
The predicate for checking stringness is
string?.
Strings obtained as a result of calls to
string, make-string, and string-append are
mutable. The procedure string-set!
replaces the character at a given index:
(define hello (string #\H #\e #\l #\l #\o))
hello
=> "Hello"
2.2.2  Vectors
Vectors are sequences like strings, but
their elements can be anything, not just
characters. Indeed, the elements can be
vectors themselves, which is a good way
to generate multidimensional vectors.
Here’s a way to create a vector of the first
five integers:
(vector 0 1 2 3 4)
=> #(0 1 2 3 4)
Note Scheme’s representation of a vector
value: a # character followed by the
vector’s contents enclosed in parentheses.
 The elements of a dotted pair can be
In analogy with make-string, the procedure replaced by the mutator procedures set-
make-vector makes a vector of a specific car! and set-cdr!:
length:
(set-car! x 2)
(define v (make-vector 5))
(set-cdr! x #f)
The procedures vector-ref and vector-set!
access and modify vector elements. The x
predicate for checking if something is a => (2 . #f)
vector is vector?.
Dotted pairs can contain other dotted pairs.
2.2.3  Dotted pairs and lists
(define y (cons (cons 1 2) 3))
A dotted pair is a compound value made
by combining any two arbitrary values into y
an ordered couple. The first element is => ((1 . 2) . 3)
called the car, the second element is called
the cdr, and the combining procedure is The car of the car of this list is 1. The cdr
cons. of the car of this list is 2. i.e.

(cons 1 #t) (car (car y))

=> (1 . #t) => 1

Dotted pairs are not self-evaluating, and so (cdr (car y))

to specify them directly as data (ie,
without producing them via a cons-call),
one must explicitly quote them:
'(1 . #t) => (1 . #t)
SANDEEP KUMAR http://san24mca.blogspot.com/
=> 2
Scheme provides procedure abbreviations
for cascaded compositions of the car and
cdr procedures. Thus, caar stands for “car
of car of”, and cdar stands for “cdr of car

(1 . #t) -->ERROR!!! of”, etc.

The accessor procedures are car and cdr: (caar y)

=> 1
(define x (cons 1 #t))
(cdar y)
(car x) => 2
=> 1
c...r-style abbreviations for upto four
(cdr x) cascades are guaranteed to exist. Thus,
=> #t cadr, cdadr, and cdaddr are all valid.
cdadadr might be pushing it.
 When nested dotting occurs along the
second element, Scheme uses a special
notation to represent the resulting
expression:
(cons 1 (cons 2 (cons 3 (cons 4 5))))
=> (1 2 3 4 . 5)
Indeed, if we know all the elements of a
list, we can use quote to specify the list:
'(1 2 3 4)
=> (1 2 3 4)
List elements can be accessed by index.

i.e. (1 2 3 4 . 5) is an abbreviation for (1 . (define y (list 1 2 3 4))

(2 . (3 . (4 . 5)))). The last cdr of this
expression is 5. (list-ref y 0) => 1
(list-ref y 3) => 4
Scheme provides a further abbreviation if
the last cdr is a special object called the (list-tail y 1) => (2 3 4)
empty list, which is represented by the (list-tail y 3) => (4)
expression (). The empty list is not
considered self-evaluating, and so one list-tail returns the tail of the list starting
should quote it when supplying it as a from the given index.
value in a program:
The predicates pair?, list?, and null? check
'( ) => ( ) if their argument is a dotted pair, list, or
the empty list, respectively:
The abbreviation for a dotted pair of the
form (1 . (2 . (3 . (4 . ( ))))) is (pair? '(1 . 2)) => #t
(pair? '(1 2)) => #t
(1 2 3 4) (pair? '()) => #f
(list? '()) => #t
This special kind of nested dotted pair is (null? '()) => #t
called a list. This particular list is four (list? '(1 2)) => #t
elements long. It could have been created (list? '(1 . 2)) => #f
by saying (null? '(1 2)) => #f
SANDEEP KUMAR http://san24mca.blogspot.com/

(null? '(1 . 2)) => #f

(cons 1 (cons 2 (cons 3 (cons 4 '()))))
but Scheme provides a procedure called
list that makes list creation more
convenient. list takes any number of
arguments and returns the list containing
them:
(list 1 2 3 4)
=> (1 2 3 4)
2.2.4  Conversions between data types
Scheme offers many procedures for
converting among the data types. We
already know how to convert between the
character cases using char-downcase and
char-upcase. Characters can be converted
into integers using char->integer, and
integers can be converted into characters
using integer->char. (The integer
 corresponding to a character is usually its
ascii code.)
(char->integer #\d) => 100
(integer->char 50) => #\2
Strings can be converted into the
corresponding list of characters.
(string->list "hello") => (#\h #\e #\l #\l
#\o)
Other conversion procedures in the same
vein are list->string, vector->list, and list-
>vector.
Numbers can be converted to strings:
(number->string 16) => "16"
Strings can be converted to numbers. If the
string corresponds to no number, #f is
returned.
(string->number "16")
=> 16
(string->number "Am I a hot number?")
=> #f
string->number takes an optional second
SANDEEP KUMAR http://san24mca.blogspot.com/
argument, the radix.
(string->number "16" 8) => 14
because 16 in base 8 is the number
fourteen.
Symbols can be converted to strings, and
vice versa:
(symbol->string 'symbol)
=> "symbol"
(string->symbol "string")
=> string
2.3  Other data types
Scheme contains some other data types.
One is the procedure. We have already
seen many procedures, eg, display, +,
cons. In reality, these are variables holding
the procedure values, which are
themselves not visible as are numbers or
characters:
cons
=> <procedure>
The procedures we have seen thus far are
primitive procedures, with standard global
variables holding them. Users can create
additional procedure values.
Yet another data type is the port. A port is
the conduit through which input and
output is performed. Ports are usually
associated with files and consoles.
In our “Hello, World!” program, we used
the procedure display to write a string to
the console. display can take two
arguments, one the value to be displayed,
and the other the output port it should be
displayed on.
In our program, display’s second argument
was implicit. The default output port used
is the standard output port. We can get the
current standard output port via the
procedure-call (current-output-port). We
could have been more explicit and written
(display "Hello, World!" (current-output-
port))
2.4  S-expressions

All the data types discussed here can be
lumped together into a single all-
encompassing data type called the s-
expression (S for symbolic). Thus 42, #\c,
(1 . 2), #(a b c), "Hello", (quote xyz),
(string->number "16"), and (begin (display
"Hello, World!") (newline)) are all s-
expressions.
Chapter 3
Forms
The reader will have noted that the
Scheme example programs provided thus
far are also s-expressions. This is true of
all Scheme programs: Programs are data.
Thus, the character datum #\c is a
program, or a form. We will use the more
general term form instead of program, so
that we can deal with program fragments
too.
Scheme evaluates the form #\c to the value
#\c, because #\c is self-evaluating. Not all
s-expressions are self-evaluating. For
instance the symbol s-expression xyz
evaluates to the value held by the variable
xyz. The list s-expression (string->number
"16") evaluates to the number 16.
SANDEEP KUMAR http://san24mca.blogspot.com/
Not all s-expressions are valid programs. If
you typed the dotted-pair s-expression (1 .
2) at the Scheme listener, you will get an
error.
Scheme evaluates a list form by examining
the first element, or head, of the form. If
the head evaluates to a procedure, the rest
of the form is evaluated to get the
procedure’s arguments, and the procedure
is applied to the arguments.
If the head of the form is a special form,
the evaluation proceeds in a manner
idiosyncratic to that form. Some special
forms we have already seen are begin,
define, and set!. begin causes its subforms
to be evaluated in order, the result of the
entire form being the result of the last
subform. define introduces and initializes a
variable. set! changes the binding of a
variable.
3.1  Procedures
We have seen quite a few primitive
Scheme procedures, eg, cons, string->list,
and the like. Users can create their own
procedures using the special form lambda.
For example, the following defines a
procedure that adds 2 to its argument:
(lambda (x) (+ x 2))
The first subform, (x), is the list of
parameters. The remaining subform(s)
constitute the procedure’s body. This
procedure can be called on an argument,
just like a primitive procedure:
((lambda (x) (+ x 2)) 5)
=> 7
If we wanted to call this same procedure
many times, we could create a replica
using lambda each time, but we can do
better. We can use a variable to hold the
procedure value:
(define add2
(lambda (x) (+ x 2)))
We can then use the variable add2 each
time we need a procedure for adding 2 to
its argument:
 (add2 4) => 6
(add2 9) => 11
3.1.1  Procedure parameters
The parameters of a lambda-procedure are
specified by its first subform (the form
immediately following the head, the
symbol lambda). add2 is a single-argument
— or unary — procedure, and so its
parameter list is the singleton list (x). The
symbol x acts as a variable holding the
procedure’s argument. Each occurrence of
x in the procedure’s body refers to the
procedure’s argument. The variable x is
said to be local to the procedure’s body.
We can use 2-element lists for 2-argument
procedures, and in general, n-element lists
for n-argument procedures. The following
is a 2-argument procedure that calculates
the area of a rectangle. Its two arguments
are the length and breadth of the rectangle.
(define area
(lambda (length breadth)
(* length breadth)))
Notice that area multiplies its arguments,
and so does the primitive procedure *. We
could have simply said:
SANDEEP KUMAR http://san24mca.blogspot.com/
(define area *)
3.1.2  Variable number of arguments
Some procedures can be called at different
times with different numbers of
arguments. To do this, the lambda
parameter list is replaced by a single
symbol. This symbol acts as a variable that
is bound to the list of the arguments that
the procedure is called on.
In general, the lambda parameter list can
be a list of the form (x ...), a symbol, or a
dotted pair of the form (x ... . z). In the
dotted-pair case, all the variables before
the dot are bound to the corresponding
arguments in the procedure call, with the
single variable after the dot picking up all
the remaining arguments as one list.
3.2  apply
The Scheme procedure apply lets us call a
procedure on a list of its arguments.
(define x '(1 2 3))
(apply + x)
=> 6
In general, apply takes a procedure,
followed by a variable number of other
arguments, the last of which must be a list.
It constructs the argument list by prefixing
the last argument with all the other
(intervening) arguments. It then returns the
result of calling the procedure on this
argument list. Eg,
(apply + 1 2 3 x)
=> 12
3.3  Sequencing
We used the begin special form to bunch
together a group of subforms that need to
be evaluated in sequence. Many Scheme
forms have implicit begins. For example,
let’s define a 3-argument procedure that
displays its three arguments, with spaces
between them. A possible definition is:
(define display3
(lambda (arg1 arg2 arg3)
(begin
 (display arg1)
(display " ") (if (< p 90)
(display arg2) 'low-pressure) ;no ``else'' branch
(display " ") => low-pressure
(display arg3)
(newline)))) Scheme provides some other conditional
forms for convenience. They can all be
In Scheme, lambda-bodies are implicit defined as macros (chap 8) that expand
begins. Thus, the begin in display3’s body into if-expressions.
isn’t needed, although it doesn’t hurt.
display3, more simply, is: 4.1  when and unless

(define display3 when and unless are convenient

(lambda (arg1 arg2 arg3) conditionals to use when only one branch
(display arg1) (the “then” or the “else” branch) of the
(display " ") basic conditional is needed.
(display arg2)
(display " ") (when (< (pressure tube) 60)
(display arg3) (open-valve tube)
(newline))) (attach floor-pump tube)
(depress floor-pump 5)
(detach floor-pump tube)
Chapter 4 (close-valve tube))
Conditionals
Assuming pressure of tube is less than 60,
Like all languages, Scheme provides this conditional will attach floor-pump to
conditionals. The basic form is the if: tube and depress it 5 times. (attach and
depress are some suitable procedures.)
(if test-expression
then-branch The same program using if would be:
SANDEEP KUMAR http://san24mca.blogspot.com/

else-branch)
(if (< (pressure tube) 60)
If test-expression evaluates to true (ie, any (begin
value other than #f), the “then” branch is (open-valve tube)
evaluated. If not, the “else” branch is (attach floor-pump tube)
evaluated. The “else” branch is optional. (depress floor-pump 5)
(detach floor-pump tube)
(define p 80) (close-valve tube)))

(if (> p 70) Note that when’s branch is an implicit

'safe begin, whereas if requires an explicit begin
'unsafe) if either of its branches has more than one
=> safe form.
 The same behavior can be written using
unless as follows:
(unless (>= (pressure tube) 60)
(open-valve tube)
(attach floor-pump tube)
(depress floor-pump 5)
(detach floor-pump tube)
(close-valve tube))
Not all Schemes provide when and unless.
If your Scheme does not have them, you
can define them as macros (see chap 8).
4.2  cond
The cond form is convenient for
expressing nested if-expressions, where
each “else” branch but the last introduces a
new if. Thus, the form
(if (char<? c #\c) -1
(if (char=? c #\c) 0
1))
can be rewritten using cond as:
(cond ((char<? c #\c) -1)
((char=? c #\c) 0)
(else 1))
SANDEEP KUMAR http://san24mca.blogspot.com/
The cond is thus a multi-branch
conditional. Each clause has a test and an
associated action. The first test that
succeeds triggers its associated action. The
final else clause is chosen if no other test
succeeded.
The cond actions are implicit begins.
4.3  case
A special case of the cond can be
compressed into a case expression. This is
when every test is a membership test.
(case c
((#\a) 1)
((#\b) 2)
((#\c) 3)
(else 4))
=> 3
The clause whose head contains the value
of c is chosen.
4.4  and and or
Scheme provides special forms for boolean
conjunction (“and”) and disjunction (“or”).
(We have already seen (sec 2.1.1)
Scheme’s boolean negation not, which is a
procedure.)
The special form and returns a true value if
all its subforms are true. The actual value
returned is the value of the final subform.
If any of the subforms are false, and
returns #f.
(and 1 2) => 2
(and #f 1) => #f
The special form or returns the value of its
first true subform. If all the subforms are
false, or returns #f.
(or 1 2) => 1
(or #f 1) => 1
Both and and or evaluate their subforms
left-to-right. As soon as the result can be
determined, and and or will ignore the
remaining subforms.
 (and 1 #f expression-guaranteed-to-cause-
error)
=> #f
(or 1 #f expression-guaranteed-to-cause-
error)
=> 1
Chapter 5
Lexical variables
Scheme’s variables have lexical scope, i.e.
they are visible only to forms within a
certain contiguous stretch of program text.
The global variables we have seen thus far
are no exception: Their scope is all
program text, which is certainly
contiguous.
We have also seen some examples of local
variables. These were the lambda
parameters, which get bound each time the
procedure is called, and whose scope is
that procedure’s body. Eg,
(define x 9)
(define add2 (lambda (x) (+ x 2)))
x => 9
SANDEEP KUMAR http://san24mca.blogspot.com/
(add2 3) => 5
(add2 x) => 11
x => 9
Here, there is a global x, and there is also a
local x, the latter introduced by procedure
add2. The global x is always 9. The local x
gets bound to 3 in the first call to add2 and
to the value of the global x, ie, 9, in the
second call to add2. When the procedure
calls return, the global x continues to be 9.
The form set! modifies the lexical binding
of a variable.
(set! x 20)
modifies the global binding of x from 9 to
20, because that is the binding of x that is
visible to set!. If the set! was inside add2’s
body, it would have modified the local x:
(define add2
(lambda (x)
(set! x (+ x 2))
x))
The set! here adds 2 to the local variable x,
and the procedure returns this new value of
the local x. (In terms of effect, this
procedure is indistinguishable from the
previous add2.) We can call add2 on the
global x, as before:
(add2 x) => 22
(Remember global x is now 20, not 9!)
The set! inside add2 affects only the local
variable used by add2. Although the local
variable x got its binding from the global
x, the latter is unaffected by the set! to the
local x.
x => 20
Note that we had all this discussion
because we used the same identifier for a
local variable and a global variable. In any
text, an identifier named x refers to the
lexically closest variable named x. This
will shadow any outer or global x’s. Eg, in
add2, the parameter x shadows the global
x.
 A procedure’s body can access and modify
variables in its surrounding scope provided
the procedure’s parameters don’t shadow
them. This can give some interesting
programs. Eg,
(define counter 0)
(define bump-counter
(lambda ()
(set! counter (+ counter 1))
counter))
The procedure bump-counter is a zero-
argument procedure (also called a thunk).
It introduces no local variables, and thus
cannot shadow anything. Each time it is
called, it modifies the global variable
counter — it increments it by 1 — and
returns its current value. Here are some
successive calls to bump-counter:
(bump-counter) => 1
(bump-counter) => 2
(bump-counter) => 3
5.1  let and let*
Local variables can be introduced without
explicitly creating a procedure. The special
form let introduces a list of local variables
SANDEEP KUMAR http://san24mca.blogspot.com/
for use within its body:
(let ((x 1)
(y 2)
(z 3))
(list x y z))
=> (1 2 3)
As with lambda, within the let-body, the
local x (bound to 1) shadows the global x
(which is bound to 20).
The local variable initializations — x to 1;
y to 2; z to 3 — are not considered part of
the let body. Therefore, a reference to x in
the initialization will refer to the global,
not the local x:
(let ((x 1)
(y x))
(+ x y))
=> 21
This is because x is bound to 1, and y is
bound to the global x, which is 20.
Sometimes, it is convenient to have let’s
list of lexical variables be introduced in
sequence, so that the initialization of a
later variable occurs in the lexical scope of
earlier variables. The form let* does this:
(let* ((x 1)
(y x))
(+ x y))
=> 2
The x in y’s initialization refers to the x
just above. The example is entirely
equivalent to — and is in fact intended to
be a convenient abbreviation for — the
following program with nested lets:
(let ((x 1))
(let ((y x))
(+ x y)))
=> 2
The values bound to lexical variables can
be procedures:
(let ((cons (lambda (x y) (+ x y))))
(cons 1 2))
=> 3
 Inside this let body, the lexical variable
cons adds its arguments. Outside, cons
continues to create dotted pairs.
5.2  fluid-let
Here is a definition of a rather more
complicated macro, fluid-let . fluid-let
specifies temporary bindings for a set of
already existing lexical variables. Given a
fluid-let expression such as
(fluid-let ((x 9) (y (+ y 1)))
(+ x y))
A lexical variable is visible throughout its
scope, provided it isn’t shadowed.
Sometimes, it is helpful to temporarily set
a lexical variable to a certain value. For
this, we use the form fluid-let.
(fluid-let ((counter 99))
(display (bump-counter)) (newline)
(display (bump-counter)) (newline)
(display (bump-counter)) (newline))
This looks similar to a let, but instead of
shadowing the global variable counter, it
temporarily sets it to 99 before continuing
with the fluid-let body. Thus the displays
in the body produce
SANDEEP KUMAR http://san24mca.blogspot.com/
100 
101  fluid-let is a nonstandard special form.
102 
After the fluid-let expression has
evaluated, the global counter reverts to the
value it had before the fluid-let.
counter => 3
Note that fluid-let has an entirely different
effect from let. fluid-let does not introduce
new lexical variables like let does. It
modifies the bindings of existing lexical
variables, and the modification ceases as
soon as the fluid-let does.
To drive home this point, consider the
program
(let ((counter 99))
(display (bump-counter)) (newline)
(display (bump-counter)) (newline)
(display (bump-counter)) (newline))
which substitutes let for fluid-let in the
previous example. The output is now
4
5
6
i.e. the global counter, which is initially 3,
is updated by each call to bump-counter.
The new lexical variable counter, with its
initialization of 99, has no impact on the
calls to bump-counter, because although
the calls to bump-counter are within the
scope of this local counter, the body of
bump-counter isn’t. The latter continues to
refer to the global counter, whose final
value is 6.
counter => 6
Chapter 6
Recursion
A procedure body can contain calls to
other procedures, not least itself:
(define factorial
 (lambda (n) This won’t quite work, because the
(if (= n 0) 1 occurrences of local-even? and local-odd?
(* n (factorial (- n 1)))))) in the initializations don’t refer to the
lexical variables themselves. Changing the
This recursive procedure calculates the let to a let* won’t work either, for while
factorial of a number. If the number is 0, the local-even? inside local-odd?’s body
the answer is 1. For any other number n, refers to the correct procedure value, the
the procedure uses itself to calculate the local-odd? in local-even?’s body still
factorial of n - 1, multiplies that subresult points elsewhere.
by n, and returns the product.
To solve problems like this, Scheme
Mutually recursive procedures are also provides the form letrec:
possible. The following predicates for
evenness and oddness use each other: (letrec ((local-even? (lambda (n)
(if (= n 0) #t
(define is-even? (local-odd? (- n 1)))))
(lambda (n) (local-odd? (lambda (n)
(if (= n 0) #t (if (= n 0) #f
(is-odd? (- n 1))))) (local-even? (- n 1))))))
(list (local-even? 23) (local-odd? 23)))
(define is-odd?
(lambda (n) The lexical variables introduced by a letrec
(if (= n 0) #f are visible not only in the letrec-body but
(is-even? (- n 1))))) also within all the initializations. letrec is
thus tailor-made for defining recursive and
These definitions are offered here only as mutually recursive local procedures.
simple illustrations of mutual recursion.
Scheme already provides the primitive 6.2  Named let
predicates even? and odd?.
A recursive procedure defined using letrec
6.1  letrec can describe loops. Let’s say we want to
SANDEEP KUMAR http://san24mca.blogspot.com/

display a countdown from 10:

If we wanted the above procedures as local
variables, we could try to use a let form: (letrec ((countdown (lambda (i)
(if (= i 0) 'liftoff
(let ((local-even? (lambda (n) (begin
(if (= n 0) #t (display i)
(local-odd? (- n 1))))) (newline)
(local-odd? (lambda (n) (countdown (- i 1)))))))
(if (= n 0) #f (countdown 10))
(local-even? (- n 1))))))
(list (local-even? 23) (local-odd? 23))) This outputs on the console the numbers
10 down to 1, and returns the result liftoff.
 Scheme allows a variant of let called iteration. So go ahead, use recursion to
named let to write this kind of loop more write loops. It’s safe.
compactly:
Here’s another example of a useful tail-
(let countdown ((i 10)) recursive procedure:
(if (= i 0) 'liftoff
(begin (define list-position
(display i) (lambda (o l)
(newline) (let loop ((i 0) (l l))
(countdown (- i 1))))) (if (null? l) #f
(if (eqv? (car l) o) i
Note the presence of a variable identifying (loop (+ i 1) (cdr l)))))))
the loop immediately after the let. This
program is equivalent to the one written list-position finds the index of the first
with letrec. You may consider the named occurrence of the object o in the list l. If
let to be a macro (chap 8) expanding to the the object is not found in the list, the
letrec form. procedure returns #f.

6.3  Iteration Here’s yet another tail-recursive

procedure, one that reverses its argument
countdown defined above is really a list “in place”, ie, by mutating the contents
recursive procedure. Scheme can define of the existing list, and without allocating
loops only through recursion. There are no a new one:
special looping or iteration constructs.
(define reverse!
Nevertheless, the loop as defined above is (lambda (s)
a genuine loop, in exactly the same way (let loop ((s s) (r '()))
that other languages bill their loops. Ie, (if (null? s) r
Scheme takes special care to ensure that (let ((d (cdr s)))
recursion of the type used above will not (set-cdr! s r)
generate the procedure call/return (loop d s))))))
SANDEEP KUMAR http://san24mca.blogspot.com/

overhead.
Scheme does this by a process called tail-
call elimination. If you look closely at the
countdown procedure, you will note that
when the recursive call occurs in
countdown’s body, it is the tail call, or the
very last thing done — each invocation of
countdown either does not call itself, or
when it does, it does so as its very last act.
To a Scheme implementation, this makes
the recursion indistinguishable from
(reverse! is a useful enough procedure that
it is provided primitively in many Scheme
dialects, eg, MzScheme and Guile.)
6.4  Mapping a procedure across a list
A special kind of iteration involves
repeating the same action for each element
of a list. Scheme offers two procedures for
this situation: map and for-each.
 The map procedure applies a given
procedure to every element of a given list,
and returns the list of the results. Eg,
(map add2 '(1 2 3))
=> (3 4 5)
The for-each procedure also applies a
procedure to each element in a list, but
returns void. The procedure application is
done purely for any side-effects it may
cause. Eg,
(for-each display
(list "one " "two " "buckle my shoe"))
has the side-effect of displaying the strings
(in the order they appear) on the console.
The procedures applied by map and for-
each need not be one-argument
procedures. For example, given an n-
argument procedure, map takes n lists and
applies the procedure to every set of n of
arguments selected from across the lists.
Eg,
(map cons '(1 2 3) '(10 20 30))
=> ((1 . 10) (2 . 20) (3 . 30))
(map + '(1 2 3) '(10 20 30))
SANDEEP KUMAR http://san24mca.blogspot.com/
=> (11 22 33)
Chapter 7
I/O
Scheme has input/output (I/O) procedures
that will let you read from an input port or
write to an output port. Ports can be
associated with the console, files or
strings.
7.1  Reading
Scheme’s reader procedures take an
optional input port argument. If the port is
not specified, the current input port
(usually the console) is assumed.
Reading can be character-, line- or s-
expression-based. Each time a read is
performed, the port’s state changes so that
the next read will read material following
what was already read. If the port has no
more material to be read, the reader
procedure returns a specific datum called
the end-of-file or eof object. This datum is
the only value that satisfies the eof-object?
predicate.
The procedure read-char reads the next
character from the port. read-line reads the
next line, returning it as a string (the final
newline is not included). The procedure
read reads the next s-expression.
7.2  Writing
Scheme’s writer procedures take the object
that is to be written and an optional output
port argument. If the port is not specified,
the current output port (usually the
console) is assumed.
Writing can be character- or s-expression-
based.
The procedure write-char writes the given
character (without the #\) to the output
port.
The procedures write and display both
write the given s-expression to the port,
with one difference: write attempts to use a
machine-readable format and display
doesn’t. Eg, write uses double quotes for
 strings and the #\ syntax for characters. j
display doesn’t. => ello

The procedure newline starts a new line on Assume the file greeting.txt does not exist
the output port. before the following programs are fed to
the listener:
7.3  File ports
(define o (open-output-file "greeting.txt"))
Scheme’s I/O procedures do not need a
port argument if the port happens to be (display "hello" o)
standard input or standard output. (write-char #\space o)
However, if you need these ports (display 'world o)
explicitly, the zero-argument procedures (newline o)
current-input-port and current-output-port
furnish them. Thus, (close-output-port o)

(display 9) The file greeting.txt will now contain the

(display 9 (current-output-port)) line:

have the same behavior. hello world 

A port is associated with a file by opening 7.3.1  Automatic opening and closing of

the file. The procedure open-input-file
takes a filename argument and returns a
new input port associated with it. The
procedure open-output-file takes a
filename argument and returns a new
output port associated with it. It is an error
to open an input file that doesn’t exist, or
to open an output file that already exists.
SANDEEP KUMAR http://san24mca.blogspot.com/
file ports
Scheme supplies the procedures call-with-
input-file and call-with-output-file that
will take care of opening a port and
closing it after you’re done with it.
The procedure call-with-input-file takes a
filename argument and a procedure. The

After you have performed I/O on a port, procedure is applied to an input port
you should close it with close-input-port or opened on the file. When the procedure
close-output-port. completes, its result is returned after
ensuring that the port is closed.
In the following, assume the file hello.txt
contains the single word hello. (call-with-input-file "hello.txt"
(lambda (i)
(define i (open-input-file "hello.txt")) (let* ((a (read-char i))
(b (read-char i))
(read-char i) (c (read-char i)))
=> #\h (list a b c))))
=> (#\h #\e #\l)
(define j (read i))
 The procedure call-with-output-file does
the analogous services for an output file. String ports need not be explicitly closed.

7.4  String ports 7.5  Loading files

It is often convenient to associate ports We have already seen the procedure load
with strings. Thus, the procedure open- that loads files containing Scheme code.
input-string associates a port with a given Loading a file consists in evaluating in
string. Reader procedures on this port will sequence every Scheme form in the file.
read off the string: The pathname argument given to load is
reckoned relative to the current working
(define i (open-input-string "hello world")) directory of Scheme, which is normally the
directory in which the Scheme executable
(read-char i) was called.
=> #\h
Files can load other files, and this is useful
(read i) in a large program spanning many files.
=> ello Unfortunately, unless full pathnames are
used, the argument file of a load is
(read i) dependent on Scheme’s current directory.
=> world Supplying full pathnames is not always
convenient, because we would like to
The procedure open-output-string creates move the program files as a unit
an output port that will eventually be used (preserving their relative pathnames),
to create a string: perhaps to many different machines.

(define o (open-output-string)) DrScheme provides the load-relative

procedure that greatly helps in fixing the
(write 'hello o) files to be loaded. load-relative, like load,
(write-char #\, o) takes a pathname argument. When a load-
(display " " o) relative call occurs in a file foo.scm, the
SANDEEP KUMAR http://san24mca.blogspot.com/

(display "world" o) path of its argument is reckoned from the

You can now use the procedure get-
output-string to get the accumulated
string in the string port o:
(get-output-string o)
=> "hello, world"
directory of the calling file foo.scm. In
particular, this pathname is reckoned
independent of Scheme’s current directory,
and thus allows convenient multifile
program development.
 ASSINGMENT -1

1) Evaluate following expressions :

a. Add 4 integers
(define ( add a b c d) ( + a b c d))
b. Multiply three numbers.
(define (mul a b c) ( * a b c))
c. Divide 20 in another three numbers in such a way that the result will
be 1. (use a single line statement.
(/ 12 3 2 2)

d. Find out the remainder of any two integer values

(define (rem a b)(remainder a b))

2. Calculate the followings in prefix form:

a) 7 *(7 + 5) /9

(* 7 ( /(+ 4 5) 9))
SANDEEP KUMAR http://san24mca.blogspot.com/

b)10 * (5 -3) + 8

(+ (* 10 ( - 5 3 )) 8)

c)10+7*15/5

(+ 9 ( * 7 (/ 15 5)))

d)(9-7) + (6-2) * (4 +7)

( + ( - 9 7 ) ( * ( - 6 2 ) ( + 4 7 )))
 3.Define two variables ‘a’ and ’ b’ and assign two values to it . Then add
and multiply the two variables to get the result.

(begin
(define a 5)
(define b 4)
(define ( add a b) ( + a b ))
)

Output
> ( add a b)
9

4.Define three variables a,b,c and assign integer values into it. Then evaluate
the expression (a +b) +(c*c)/b

(begin
(define a 5)
(define b 4)
(define c 6)
(define ( sol a b c ) ( + (+ a b )(/ ( * c c ) b)))
)
Output

> ( sol a b c )
18

5.Write a Scheme procedure to display the sum and average of three numbers.
SANDEEP KUMAR http://san24mca.blogspot.com/

(define (avg a b) (/ ( + a b )2))

Output
> (avg 4 8)
6

ASSINGMENT -2
1 Evaluate the following expression:
5 + ⅓ + (2 - (3 - (6 + ⅓)))

(/( + 5 (/ 1 3) (- 2 (- 3 (+ 6 (/ 1 3))))) (* 3 ( - 6 2 ) (- 3 7)))

 Output
-2/9

2)Utopias taxes accountants always use programs that compute income taxes
even though the tax rate is a solid never -changing 15% . define the program
tax , which determines the tax on the gross pay also define net pay . the
program determines the net pay of an employee from the number of hours
worked . Assume an hourly rate of $12.
(define (tax nhour )(/(*(* nhour 12) 15 ) 100))
(define (netpay nhour) (display "net pay is $") (-(* nhour 12) (tax nhour)))
(tax 5)

Output
9
> (netpay 5)
net pay is $51

3.An old style movie theater has simple profit program . each customer pay
$5 per ticket .every performance costs the theater $20 ,plus $50 per
attendee, .develop the program total profit it consumes the number of
attendees (of a show ) and produces how much income the attendees produce
.

(begin
(define (attende x )
(define a 0)
(set! a x)
SANDEEP KUMAR http://san24mca.blogspot.com/

(display "total no of attende ")

(display a)
(display "\nprofit $")
(display (- (- ( * a 5) 20) (* a 0.5)))
(display "\nattende produce $ ")
(display (* a 5))
))

Output
> (attende 5 )
total no of attende 5
profit $2.5
attende produce $ 25
 4) To find the volume & area of a cylinder which consumes the radius of a
cylinder base disk and its height.

(define (cylinder r h)
(display "Area::")
(display(+ (* 3.14 r h)(* 3.14 r r)))
(display "sq. unit \n Volume::")
(display (* 3.14 r r h))
(display "cubic unit")
)

Output
> (cylinder 3 5)
Area::75.36sq. unit
Volume::141.29999999999998cubic unit

5)Write a program to find the maximum of three number

(begin
(define (max a b c)
(define m 0)
(if (and (> a b)
(> a c))
(set! m a))
(if ( and (> b a)
(> b c))
(set! m b))
(if (and ( > c a)
(> c b))
SANDEEP KUMAR http://san24mca.blogspot.com/

(set! m c))
(display "max is ")
(display m)
))

Output
> (max 45 25 5)
max is 45
> (max 34 56 4)
max is 56
> (max 3 56 67)
max is 67
6)Write a program to find the minimum of threee numbers
 (begin
(define (min a b c)
(define m 0)
(if (and (< a b)
(< a c))
(set! m a))
(if ( and (< b a)
(< b c))
(set! m b))
(if (and ( < c a)
(< c b))
(set! m c))
(display "minimum is ")
(display m)
))

Output
> (min 2 4 5)
minimum is 2
> (min 56 5 7)
minimum is 5
> (min 34 56 4)
minimum is 4

7) Develop the program like interest -rate it consumes a deposit amount ,

instead of the rate ,it produces the actual amount of interest . That the money
earns in a year .the bank pays a flat 4% for deposits of up to $100 a flat
4.5%per year for deposits of up to $5000 and a flat 5 % form deposit of more
than Rs. 5000
SANDEEP KUMAR http://san24mca.blogspot.com/

(define (interest Depo_amt)

(if(> Depo_amt 5000)
(begin
(display "The Interest is = ")
(display (/ (* Depo_amt 5.0) 100))
))
(if (and (> Depo_amt 1000) (<= Depo_amt 5000))
(begin
(display "The Interest is = ")
(display (/ (* Depo_amt 4.5) 100))
))
(if (<= Depo_amt 1000)
(begin
 (display "The Interest is= ")
(display (/ (* Depo_amt 4.0) 100)))
)
)

Output
> (interest 5643)
The Interest is = 282.15
> (interest 2643)
The Interest is = 118.935
> (interest 643)
The Interest is= 25.72

ASSINGMENT -3
Use of car and cdr :
(define (vld_num lst)
(let a ((templst lst))
(if (null? templst) #t
(begin
(if (number? (car templst)) (a (cdr templst))
#f)))))

1 Write a program to print the odd number from 1 to n.

(define (odd n)
(define i 1)
(let loop()
SANDEEP KUMAR http://san24mca.blogspot.com/

(if (< i n)
(begin
(display i) (display "\n")
(set! i (+ i 2))
(loop)))))

Output
> (odd 7)
1
3
5
 2) Write a program to print the given pattern:
1
12
123
1234

(define (pattern n)
(define i 1)
(define l 1)
(let loop()
(if (<= l n)
(begin
(let loop1()
(if (<= i l)
(begin
(display i) (set! i (+ i 1)) (loop1))
(begin
(newline) (set! i 1))))
(set! l (+ l 1)) (loop)))))

Output
> (pattern 6)
1
12
123
1234
12345
123456
SANDEEP KUMAR http://san24mca.blogspot.com/

3) A local discount store has a policy of putting labels with dates on all of its
new merchandise . If as item has not sold within two weeks the store
discounts the item by 25% for the third week , 50% for the fourth week ,
and 75% for the fifth week . After that no additional discount are given .
Develop the function new-price , which takes the initial price of an item
and the number of wiiks since the item was dated and produce the selling
price of the item.
(define (new_price sp wk)
(if (= wk 3)
(begin
(set! sp (- sp (* 0.25 sp)))))
 (if (= wk 4)
(begin
(set! sp (- sp (* 0.50 sp)))))
(if (> wk 4)
(begin
(set! sp (- sp (* .75 sp)))))
sp)
Output
> (new_price 3 4)
1.5
> (new_price 3 7)
0.75
> (new_price 3 3)
2.25

4 ) A manufacturing company measured the productivity of its workers and

found that between the hour of 6 am and 10 am they could produce 30 piece
/hour /worker ,between 10 am and 2 pm they could produce 40
piece/hour/worker , and between 2 pm and 6 pm they could produce 35
piece/hr/worker . Develop a function that takes hr. of day between 6 am and 6
pm in 24 hrs. format along with the number of worker and computer the total
number of pieces produced during that hour.

(define (products hrs wrk)

(define pc 0)
(cond
[(and (> hrs 6) (< hrs 10)) = (set! pc (* 30 wrk))]
[(and (>= hrs 10) (< hrs 14)) = (set! pc (* 40 wrk))]
[(and (>= hrs 14) (< hrs 18)) = (set! pc (* 35 wrk))]
SANDEEP KUMAR http://san24mca.blogspot.com/

[else "INVALID ENTRY"])

pc)

Output
> (products 9 6)
180

5 , 6) Develop a function to print the largest element in a list of number and also
find the position of largest number.

(define (comp_list lst)

(define g (list-ref lst 0))
 (define pos 0)
(define lth (length lst))
(define i 0)
(let loop()
(if (< i lth)
(begin
(if (> (list-ref lst i) g)
(begin (set! g (list-ref lst i)) (set! pos i)))
(set! i (+ i 1))(loop))))
(display "The greatest number is:")
(display g)
(display " position=")
(display (+ pos 1)))

Output
> (define lis(list 3 23 4 23))
> (comp_list lis)
The greatest number is:23 position=2

7) First n Fibonacci series [n value to be passed as an argument]

(define (fibonacci n)
(define p 0)
(define c 1)
(define nxt 1)
(define i 2)
(display p)(display " ")(display c)
(let loop()
(if (< i n)
(begin
SANDEEP KUMAR http://san24mca.blogspot.com/

(set! p c) (set! c nxt) (set! nxt (+ c p)) (display " ") (display c) (set! i (+ i 1))
(loop)))))

Output
> (fibonacci 6)
011235

8) Enter three number through list and then display their sum.
(define (sum_list lst)
(define s 0)
(define i 0)
(define l (length lst))
 (let loop()
(if (< i l)
(begin
(set! s (+ s (list-ref lst i))) (set! i (+ i 1)) (loop))))
(display "sum =") s)

Output
> (define lst(list 3 23 4 23))
> (sum_list lst)
sum =53

9 Find the total number of occurrence of a particular digit in a given list .

(define (search lst ele)

(define l (length lst))
(define i 0)
(define c 0)
(let loop()
(if (< i l)
(begin
(if (= ele (list-ref lst i))
(set! c (+ c 1)))
(set! i (+ i 1)) (loop))))
(display ele) (display " occurs ") (display c) (display " times."))

Output
> (define lst(list 3 23 4 23 45 34 23 4 2 56 67 89 23))
> (search lst 23)
23 occurs 4 times.
SANDEEP KUMAR http://san24mca.blogspot.com/

10 Find the Greatest common divisor of two number.

(define (gcd x y)
(define rem 1)
(let loop()
(if (not (= rem 0))
(begin
(set! rem (remainder x y)) (set! x y) (set! y rem) (loop))))
(display "GCD=") x)
Output
> (gcd 45 3)
GCD=3
 ASSINGMENT - 4

1. Write a program to check the leap year

(define (leap_year a)
( if (or (and (= (remainder a 4) 0) ( not (= (remainder a 100 ) 0))) (=
(remainder a 400 ) 0))
(display "leap year")
(display "not leap year")
))

Output
> (leap_year 1978)
not leap year
> (leap_year 2004)
leap year

2. Find out the reverse of given number.

(define (reverse n)
(define r 0)
(define s 0)
(let loop()
(if (> n 0)
(begin

(set! r (remainder n 10))

(set! n (quotient n 10))
SANDEEP KUMAR http://san24mca.blogspot.com/

(set! s (+ (* s 10) r))

(loop))))
(display s))
Output
> (reverse 543)
345

2. Check whether the input number is prime or not.

(define (primechk num)

( define c 0)
( define i 1)
 (let loop()
( if ( <= i num)
( begin
( if ( =( remainder num i) 0)
(set! c ( + c 1)))
( set! i( + i 1))
(loop))))
( if (= c 2)
( display "prime number")
(display "not prime number.") ))
Output
> (primechk 41)
prime number
> (primechk 45)
not prime number.

4. Define a list of 5 numbers and find its average.

(define lst (list 10 20 30 40 50))
(define (avg_list lst)
(define s 0)
(define i 0)
(define l (length lst))
(let loop()
(if (< i l)
(begin
(set! s (+ s (list-ref lst i))) (set! i (+ i 1)) (loop))))
(display "average =" ) (/ s 5))
Output
> (avg_list lst)
average =30
SANDEEP KUMAR http://san24mca.blogspot.com/

5. Define a list of 10 elements and display the 4th element.

(define lst (list 10 20 30 40 50 45 34 56 67 5))
(define p 0)
(define (pos i)
(set! p (list-ref lst (- i 1)))
(display p))
Output
> (pos 4)
40

6. Define 2 list of 3 elements each and add a new list to it.

 (define lst1 (list 10 20 30 ))
(define lst2 (list 40 50 60 ))
(display ( append lst1 lst2))
Output
(10 20 30 40 50 60)

ASSINGMENT -5

Do Loop
Syntax:

( Do ((initialization (iteration)))
((termination condition))
( body.......
.....
......
))
Example :
(do ((i 1(+ i 1)))
((> i 5))
(begin
(display i)
(newline))
) Test output ....yourself

1. Find the factorial value of inputted number using DO Loop

(define (fact n)
SANDEEP KUMAR http://san24mca.blogspot.com/

(define b 1)
(do ((i n(- i 1)))
((< i 1))
(begin
(set! b (* b i))
)
) (display b))

Output
> (fact 5)
120
 2. Print the series 1,1/2,1/3,1/4 …..upto 1/n using DO Loop.

(define (series n )
(do ((i 1(+ i 1)))
((> i n))
(begin
(display " ")
(display (/ 1 i))
)
))

Output
> (series 5)
1 1/2 1/3 1/4 1/5

3. Input your name, age, basic salary as argument. Calculate TA=45% of

basic,DA=55% of basic, HRA= 35% of basic. Display the salary slip.

(define (salary name age sal)

(define sala 1)
(define ta (* sal (/ 45 100)))
(define da (* sal (/ 55 100)))
(define hra (* sal (/ 35 100)))
(display "Name=")(display name)(newline)
(display "Age=") (display age)(newline)
(set! sala (+ sal ta da hra))
(display "basic salary=")
(display sal)
SANDEEP KUMAR http://san24mca.blogspot.com/

(display " ta=")

(display ta)
(display " da=")
(display da)
(display " hra=")
(display hra) (newline)
(display "salary(basic salary+ta+da+hra)= ") sala)

Output
> (salary "sandeep" 22 4000)
Name=sandeep
Age=22
basic salary=4000 ta=1800 da=2200 hra=1400
 salary(basic salary+ta+da+hra)= 9400

4. Input your name, branch and 4 paper marks as argument. Calculate total and
percentage. Calculate the grade as follows
90% and above Grade ‘O’.
80% and above Grade ‘A’
70% and above Grade ‘B’
60% and above Grade ‘C’
Display the suitable mark sheet.

(define (grade name branch m1 m2 m3 m4)

(define total 1)
(define percent 1)
(display "Name=")(display name)(newline)
(display "Branch=") (display branch)(newline)
(set! total (+ m1 m2 m3 m4))
(set! percent (/ total 4.0))
(display "total= ") (display total)(newline)
(display "percent= " ) (display percent) (newline)
(if (and (> percent 59 ) (< percent 70))
(display "C grade"))
(if (and (> percent 69) (< percent 80))
(display "B grade"))
(if (and (> percent 79 ) (< percent 90))
(display "A grade "))
(if (> percent 89 )
(display "O grade"))
)
SANDEEP KUMAR http://san24mca.blogspot.com/

Output
>(grade "san" "mca" 70 70 70 70)
Name=san
Branch=mca
total= 280
percent= 70.0
B grade

ASSINGMENT -6

User input from key board:

Use of Read: Using the Read Statement we can read our data from the key
board .
 Example : Input two values from key board and display the values through a
function :
(display "enter x value")
(define x(read)) ; reading from key board
(display "enter y value")
(define y(read)) ; reading from key board

(define (disp x y) ; Defining Function and Body

(display x)
(newline)
(display y)
)
(disp x y) ; calling the function

1. Input principal, time, rate of interest from the key board and find simple
interest and absolute amount.
(display "enter pricipal value= ")
(define p(read))
(newline) (display "enter rate = ")
(define r(read))
(newline) (display "enter time= ")
(define t(read))
(define (SI p r t)
(define si 1)
(newline) (display "Principal= ") (display p)
(newline) (display "Rate= ") (display r)
(newline) (display "Time= ") (display t)
(set! si (/ (* p r t ) 100))
(newline) (display "SIMPLE INTEREST = ") (display si)
SANDEEP KUMAR http://san24mca.blogspot.com/

(newline)(display "AMOUNT= ")(display (+ p si)))

(SI p r t)

Output
enter pricipal value = 1000

enter rate = 45.5

enter time = 3

Principal= 1000
Rate= 45.5
Time= 3
 SIMPLE INTEREST = 1365.0
AMOUNT= 2365.0

2. Find out the area of rectangle ,triangle and circle using appropriate input
from the key board.

(newline) (display "enter length of rectangle") (define l(read))

(newline) (display "enter width of rectangle ") (define w(read))
(define ar 1)
(newline) (display "length of rectangle= ") (display l)
(newline) (display "Width of rectangle= ") (display w)
(set! ar (* l w))
(newline) (display "AREA OF RECTANGLE = ") (display ar)
(newline) (display " enter base of triangle= ") (define b(read))
(newline) (display " enter height of triangle= ") (define h(read))
(define area 1)
(newline) (display "entered data for triangle")
(newline) (display "Base of triangle=") (display b)
(newline) (display "Height of triangle=") (display h)
(set! area (* 0.5 b h))
(newline) (display "AREA OF TRIANGLE = ") (display area)
(newline) (display " enter the radius of circle ") (define r(read))
(define cir 1)
(set! cir ( * 3.14 r r))
(display "area of circle = ") (display cir)

Output
enter length of rectangle34
enter width of rectangle 45

length of rectangle= 34
SANDEEP KUMAR http://san24mca.blogspot.com/

Width of rectangle= 45
AREA OF RECTANGLE = 1530

enter base of triangle= 56

enter height of triangle= 78

entered data for triangle

Base of triangle=56
Height of triangle=78
AREA OF TRIANGLE = 2184.0
enter the radius of circle 67
area of circle = 14095.46
 3.Input lower bound , upper bound and display the prime numbers within the
range.
(define i 1)
(define c 0)
(display "\n Enter the lower bound ")
(define l(read))
(display "\n Enter the upper bound ")
(define n(read))
(let loop()
(if (<= l n)
(begin
(set! c 0)
(set! i 1)
(let loop()
(if (<= i l )
(begin
(if (= 0 (remainder l i ))
(set! c (+ c 1)))
(set! i (+ i 1))
(loop))))
(if (= c 2)
(begin
(display l)(display " ")))

(set! l (+ l 1))
(loop))))

Output
Enter the lower bound 4
SANDEEP KUMAR http://san24mca.blogspot.com/

Enter the upper bound 53

5 7 11 13 17 19 23 29 31 37 41 43 47 53

4. Input the number of lines and display the pattern as follows:

*
* *
* * *
* * * *
* * * * *

(display "Enter the number of lines= ") (define n(read))

;(define (pattern n)
 (define i 1)
(define l 1)
(let loop()
(if (<= l n)
(begin
(let loop1()
(if (<= i l)
(begin
(display " ") (display "*") (set! i (+ i 1)) (loop1))
(begin
(newline) (set! i 1))))
(set! l (+ l 1)) (loop))))

Output
Enter the number of lines= 5
*
* *
* * *
* * * *
* * * * *

ASSINGMENT -7
Use of Read:

Example1 :

(display "enter x value ")

(define x(read)) ;reading from the key board
(display "enter y value ")
SANDEEP KUMAR http://san24mca.blogspot.com/

(define y(read)) ;reading from the key board

(define (disp)
(display "X value ")
(display x)
(display "\n y value") ; \n for (newline)
(display y)
)

(disp) ;Calling the function (disp)

 [ Execute the program and check output ….Yourself ]
Example 2:To read the value of variables within a function body

(define p 0)
(define q 0)

(define (readx) ; The function (readx)

(display "enter value ")

(set! p(read)) ;Use of read inside a function
(display "enter value ")
(set! q(read)) ;Use of read inside a function

(display "P value is :")

(display p)
(newline)
(display "Q value is :")
(display q)
)

(readx) ; Calling of function (readx).

[ Execute the program and check output ….Yourself ]

Use of Write :
Example:
(write "enter x value ")
(define x(read)) ;reading from the key board
(write "enter y value ")
(define y(read)) ;reading from the key board
SANDEEP KUMAR http://san24mca.blogspot.com/

(define (disp)
(write "X value ")
(write x)
(newline)
(write "Y value ")
(write y)
)

(disp) ;Calling the function (disp)

[Execute the program and check output ….Yourself]

 Use of multiple functions & calling of multiple functions :

Example1:

(define ( x ) ; defining function (x)

(display "first function")
)

(define ( y ) ; defining function (y)

(display "second function")
)

(define ( xy ) ; defining function (xy)

(x) ; calling function (x)
(newline)
(y) ; calling function (y)
)

(xy) ; calling function (xy)

[Execute the program and check output ….Yourself]

Example2:
Check the difference between “display” and “write” .

(display "enter x value ")

(define x(read)) ; reading from the key board
(display "enter y value ")
(define y(read)) ; reading from the key board

(define (disp1) ; Defining function (disp1)

SANDEEP KUMAR http://san24mca.blogspot.com/

(display "X value ")

(display x)
(newline)
(display "Y value ")
(display y)
); End of function (disp1)

(write "enter x value ")

(define x(read)) ; reading from the key board
(write "enter y value ")
(define y(read)) ; reading from the key board

(define (disp2) ; Defining function (disp2)

 (write "X value ")
(write x)
(newline)
(write "Y value ")
(write y)
); End of function (disp2)

(define (disp) ; Defining function (disp) to call another functions

(disp1) ; calling of the function (disp1)
(newline)
(disp2) ; calling of the function (disp2)
)
(disp) ; calling of the function (disp)

[Execute the program and check output ….Yourself]

Lambda function :
Example1:

(define add2
(lambda (x)
(+ x 2)))

Output:
SANDEEP KUMAR http://san24mca.blogspot.com/

> (add2 5)
7

Example2:
(define area
(lambda (length breadth)
(* length breadth)))

Output:
>(area 5 7)
35

Example3:
 (define display3
(lambda (arg1 arg2 arg3)

(display arg1)
(display " ")
(display arg2)
(display " ")
(display arg3)
(newline)))

Output
>(display3 5 6 7)
5 6 7

Compare the followings :

(Doing the same calculation in different ways)
Example 4:
Using function calculation multiply, add and subtract two numbers.

(define ( calculation x y)
(display (* x y))
(newline)
(display (+ x y))
(newline)
(display (- x y))
)

Execute:
> (calculation 12 10)
SANDEEP KUMAR http://san24mca.blogspot.com/

Using lambda function multiply, add and subtract two numbers.

(define calculation
( lambda (x y)
(display (* x y))
(display (+ x y))
(display (- x y))
))

Execute:
> (calculation 12 10)
 1. Using a single lambda function calculate area and perimeter of rectangle,
square and circle

(define figures
(lambda (l b s r)
(display "Rectangle:\nArea=") (display (* l b))
(display "\tPerimeter=") (display (* (+ l b) 2 ))
(display "\nSquare:\nArea=") (display (* s s))
(display "\tPerimeter=") (display (* 4 s))
(display "\nCirle:\nArea=") (display (* 3.14 r r))
(display "\tPerimeter=") (display (* 2 3.14 r))))

Output

> (figures 4 5 6 3)
Rectangle:
Area=20 Perimeter=18
Square:
Area=36 Perimeter=24
Cirle:
Area=28.259999999999998 Perimeter=18.84 |#

2) (a) Area of rectangle

(define a_rec
(lambda (length breadth)
(display "area of rectangle= ")
(* length breadth)))

Output
> (a_rec 3 4)
SANDEEP KUMAR http://san24mca.blogspot.com/

area of rectangle= 12

(b)Perimeter of rectangle
(define p_rec
(lambda (length breadth)
(display "Perimeter of rectangle= ")
(* 2 ( + length breadth))
)
)

Output
> (p_rec 4 5)
Perimeter of rectangle= 18
 (c)Area of square
(define a_sqr
(lambda (h)
(display "area of square= ")
(* h h )))

Output
> (a_sqr 3)
area of square= 9

(d)Perimeter of square
(define p_sqr
(lambda (h)
(display "Perimeter of rectangle= ")
(* 4 h)
)
)
Output
> (p_sqr 3)
Perimeter of rectangle= 12

(e)Area of circle
(define a_cir
(lambda (r)
(display "area of circle= ")
(* 3.14 r r)
)
SANDEEP KUMAR http://san24mca.blogspot.com/

Output
> (a_cir 3)
area of circle= 28.259999999999998

(f)Perimeter of circle
(define p_cir
(lambda (r)
(display "Perimeter of circle= ")
(* 2 3.14 r )
 )
)

Output
> (p_cir 3)
Perimeter of circle= 18.84

3 .Add, multiply and subtract two numbers in separate functions and call the
functions within a single function to display the result.

(write "Enter 1st number :" )

(define x(read)) ; reading from the key board
(display "Enter 2nd number :")
(define y(read)) ; reading from the key board

(define (add) ; Defining function (add)

(display "\nADDITION= ")
(display (+ x y)))
(define (sub) ; Defining function (sub)
(display "\nSUBTRACTION= ")
(display(- x y)))
(define (mul) ; Defining function (mul)
(display "\nMULTIPLICATION= ")
(display (* x y)))
(define (disp) ; Defining function (disp) to call another functions
(add) ; calling of the function (add)
(sub) ; calling of the function (sub)
(mul) ;calling of the function (mul)
)
(disp)
SANDEEP KUMAR http://san24mca.blogspot.com/

Output

"Enter 1st number"4

Enter 2nd number3

ADDITION= 7
SUBTRACTION= 1
MULTIPLICATION= 12

4.Write three functions to

(a)to generate odd numbers within 50
(b)to generate even numbers within 50
 (c)to generate non prime numbers within 50
Call the above three functions as per your choice within another function.
(define (odd_num)
(define n 1)
(let loop()
(if (<= n 50)
(begin
(if (= (remainder n 2) 1)
(begin
(display n) (display "\t")))
(set! n (+ n 1))
(loop)))))

(define (even_num)
(define n 1)
(let loop()
(if (<= n 50)
(begin
(if (= (remainder n 2) 0)
(begin
(display n) (display "\t")))
(set! n (+ n 1))
(loop)))))

(define (prime)
(define n 1)
(define i 1)
(define c 0)
(let loop()
(if (<= n 50)
SANDEEP KUMAR http://san24mca.blogspot.com/

(begin
(let loop1()
(if (<= i (/ n 2))
(begin
(if (= (remainder n i) 0)
(set! c (+ c 1))) (set! i (+ i 1)) (loop1))))
(if (> c 1)
(begin
(display n) (display "\t")))
(set! n (+ n 1)) (set! c 0)
(set! i 1) (loop)))))
 (display "1. Odd numbers within 50.\n2. Even numbers within 50.\n3. Non-
prime numbers within 50.\nENTER CHOICE:")
(define choice(read))
(cond
[(= choice 1) = (odd_num)]
[(= choice 2) = (even_num)]
[(= choice 3) = (prime)])

Output
1. Odd numbers within 50.
2. Even numbers within 50.
3. Non-prime numbers within 50.
ENTER CHOICE:3
4 6 8 9 10 12 14 15 16 18 20 21 22
24 25 26 27 28 30 32 33 34 35 36 38
39 40 42 44 45 46 48 49 50

5. Input meter number, consumer number, previous unit reading, current

unit reading. Calculate the electric charges per month as per following
conditions:
(a) up to 100 units 50 paisa per unit
(b) from 101 to 200 units 2 Rupees per unit
(c) above 200 units Rs. 4 per unit.

(define (ebill name cno lr cr)

(define r (- cr lr))
(define bill 0)
(define gt1 0)
SANDEEP KUMAR http://san24mca.blogspot.com/

(define gt2 0)
(define ir 0)
(display name) (display "\t") (display cno)
(display "\nStart Reading:") (display lr)
(display "\nEnd Reading:") (display cr)
(if (> r 200)
(begin
(set! ir (- r 200)) (set! gt2 (* ir 4)) (set! r (- r ir)) (newline)
(display ir) (display " x 4=") (display gt2)))
(if (> r 100)
(begin
(set! ir (- r 100)) (set! gt1 (* ir 2)) (set! r (- r ir)) (newline)
(display ir) (display " x 2=") (display gt1)))
 (newline)
(display r) (display " x 0.50=") (display (* r 0.50))
(set! bill (+ gt1 gt2 (* r 0.50)))
(display "\nBill=") (display bill))

Output
> (ebill "sk" 241255 2000 2400)
sk 241255
Start Reading:2000
End Reading:2400
200 x 4=800
100 x 2=200
100 x 0.50=50.0
Bill=1050.0

ASSINGMENT -8
Structure :

(define-struct s (field_1 field_2 field_3 ....field_n) ) : => Defines a structure

and field variables.

(define instance_name (make-structure_name val1 val2 val3 ..val_n) :=> to

create the instance of structure and provide value to it. (just like constructor
operation)

make-s :=> a constructor procedure that takes n arguments and returns a new
structure value.

s? :=> a predicate procedure that returns #t for a value constructed by make-s

and #f for any other value.
SANDEEP KUMAR http://san24mca.blogspot.com/

s-field :=> for each field, an accessor procedure that takes a structure value and
extracts the value for field.

set-s-field! :=> for each field, a mutator procedure that takes a structure and a
new field value. The field value in the structure is destructively updated with the
new value, and void is returned.

(set-s-field! instance (read) ) :=> To read the value in run time .

Example #1:

(define-struct cons-cell (car cdr))

 (define x (make-cons-cell 1 2))
(cons-cell? x) ; => #t
(cons-cell-car x) ; => 1
(set-cons-cell-car! x 5)
(cons-cell-car x) ; => 5

Example #2 :
(For Structure definition, assigning value, retriving the value.)

(define-struct s (a b c d))
(define x (make-s 100 24.50 'raja "we are good"))
(define y (make-s 10 245.50 "we are good" 'ramji))

(display"a value for instance x: ") ( s-a x)

(display"b value for instance x: ") ( s-b x)
(display"c value for instance x: ") ( s-c x)
(display"d value for instance x: ") ( s-d x)

(display"a value for instance y: ") ( s-a y)

(display"b value for instance y: ") ( s-b y)
(display"c value for instance y: ") ( s-c y)
(display"d value for instance y: ") ( s-d y)

[ Check its output Yourself ]|#

1. Create a structure personal and put data in various fields like name, age,
designation, salary. Create three difference instances and assign data into it.
SANDEEP KUMAR http://san24mca.blogspot.com/

Display the information in various fields and various instances.

(define-struct personal(name age desig sal))

(define x (make-personal 'Sandeep 24 "Soft eng" 34000))
(define y (make-personal 'Rabi 23 'Manager 44000))
(define z (make-personal "Ramesh Das" 23 'CEO 524000))

(display"Name ") ( personal-name x)

(display"Age :") ( personal-age x)
(display"Designation: ") ( personal-desig x)
(display"Salary: ") ( personal-sal x)

(display"Name ") ( personal-name y)

 (display"Age :") ( personal-age y)
( display"Designation: ") ( personal-desig y)
(display"Salary:") ( personal-sal y )

(display"Name ") ( personal-name z)

(display"Age :") ( personal-age z )
(display"Designation: ") ( personal-desig z)
(display"Salary:") ( personal-sal z)

Output
Name Sandeep
Age :24
Designation: "Soft eng"
Salary: 34000
Name Rabi
Age :23
Designation: Manager
Salary:44000
Name "Ramesh Das"
Age :23
Designation: CEO
Salary:524000
2. Create a structure student and take various fields like name, date-of-birth,
branch, subject1_mark, subject2_mark, subject3_mark, subject4_mark.
Create two instances and assign values into it. Display the record
information and also total and percentage of marks for each record.

(define-struct student(name dob br sub1 sub2 sub3 sub4))

(define std1(make-student 'sandy '24dec1985 'mca 58 84 78 96))
SANDEEP KUMAR http://san24mca.blogspot.com/

(define std2(make-student 'syedul '5may1987 'mca 88 89 68 76))

(define tot 0)
(define per 0)
(set! per (/ (+ (student-sub1 std1) (student-sub2 std1) (student-sub1 std1)
(student-sub1 std1)) 4 ))
(set! tot (+ (student-sub1 std1) (student-sub2 std1) (student-sub1 std1) (student-
sub1 std1)))
(display"NAME: ") ( student-name std1)
(display"DOB: ") ( student-dob std1)
(display"BRANCH: ") ( student-br std1)
(display"TOATAL: ") tot
(display"PERCENTAGE: ") per
 (set! per (/ (+ (student-sub1 std2) (student-sub2 std2) (student-sub1 std2)
(student-sub1 std2)) 4 ))
(set! tot (+ (student-sub1 std2) (student-sub2 std2) (student-sub1 std2) (student-
sub1 std2)))
(display"NAME: ") ( student-name std2)
(display"DOB: ") ( student-dob std2)
(display"BRANCH: ") ( student-br std2)
(display"TOATAL: ") tot
(display"PERCENTAGE: ") per

Output
NAME: sandy
DOB: 24dec1985
BRANCH: mca
TOATAL: 258
PERCENTAGE: 64 1/2
NAME: syedul
DOB: 5may1987
BRANCH: mca
TOATAL: 353
PERCENTAGE: 88 1/4

3.Create a structure Sales and take various fields like sale_id, salesman_name,
Sale_date, Amount and assign initial values to it. Then re-assign the value to the
various ;fields of structure.
(define-struct Sales(sale_id sal_name sale_date amt))
(define x (make-Sales 's001 'market '23sep09 4500))
(display "INITIAL VALUE\n")
(display "SALE ID : ") (Sales-sale_id x)
SANDEEP KUMAR http://san24mca.blogspot.com/

(display "SALE NAME: ") (Sales-sal_name x)

(display "SALE DATE :" ) (Sales-sale_date x)
(display "AMOUNT :" ) (Sales-amt x)
(set-Sales-sale_id! x 's00r )
(set-Sales-sal_name! x 'fan )
(set-Sales-sale_date! x '23aug90 )
(set-Sales-amt! x 9000 )
(display "VALUE AFTER RE-ASSIGN \n")
(display "SALE ID : ") (Sales-sale_id x)
(display "SALE NAME: ") (Sales-sal_name x)
(display "SALE DATE :" ) (Sales-sale_date x)
(display "AMOUNT :" ) (Sales-amt x)
 Output
INITIAL VALUE
SALE ID : s001
SALE NAME: market
SALE DATE :23sep09
AMOUNT :4500
VALUE AFTER RE-ASSIGN
SALE ID : s00r
SALE NAME: fan
SALE DATE :23aug90
AMOUNT :9000

4. Create a structure of your own and take any 4 fields and assign the value
in run time ;to it. Display the data.
(define-struct personal(name age branch state))
(define x (make-personal 's 34 'a 'b))
(display "ENTER NAME : ") (set-personal-name! x (read) )
(display "ENTER AGE : ") (set-personal-age! x (read) )
(display "ENTER BRANCH:") (set-personal-branch! x (read) )
(display "ENTER STATE: ") (set-personal-state! x (read) )
(display"Name ") ( personal-name x)
(display"Age :") ( personal-age x)
(display"Branch: ") ( personal-branch x)
(display"State: ") ( personal-state x)

Output
ENTER NAME : SANDEEP
SANDEEP KUMAR http://san24mca.blogspot.com/

ENTER AGE : 24
ENTER BRANCH:MCA
ENTER STATE: BIHAR
Name SANDEEP
Age :24
Branch: MCA
State: BIHAR

ASSINGMENT -9
1. “findMaxNum” takes a list of numbers as input argument and returns the
maximum number from the list.
Example : (findMaxNum (list 10 20 30 70 40)) → 70
 (define (findmax l)
(define len (length l))

(define max 0)
(do ((i 1(+ i 1)))
((> i len))
(begin (if (< max (car l))
(begin (set! max (car l))
(set! l (cdr l)))
(set! l (cdr l)))))
(display max))

(define l(list 100 300 500 200 3))

(findmax l)

Output
500

2.A function "compareSalary" takes two employee structures instance and

returns "equal" if the salary is same else returns "unequal".

Employee structure contains empID, empName & salary.

(define (compare_salary)
(define-struct employee(id name sal))

(define emp1 (make-employee "emp-1" "Abhisek" 20000))

(define emp2 (make-employee "emp-2" "Sandy" 30000))
SANDEEP KUMAR http://san24mca.blogspot.com/

(display"Enter value for Emp_id: ") (set-employee-id! emp1(read))

(display"Enter value for Emp_name: ") (set-employee-name! emp1(read))
(display"Enter value for Salary: ") (set-employee-sal! emp1(read))

(display"Enter value for Emp_id: ") (set-employee-id! emp2(read))

(display"Enter value for Emp_name: ") (set-employee-name! emp2(read))
(display"Enter value for Salary: ") (set-employee-sal! emp2(read))

(if (= (employee-sal emp1) (employee-sal emp2))

(display "Salaries of both employees are same")
(display "Salaries of both employees are not same")))
 Output
(compare_salary)
(compare_salary)
Enter value for Emp_id: 1001
Enter value for Emp_name: Abihsek
Enter value for Salary: 40000
Enter value for Emp_id: 1002
Enter value for Emp_name: Sandeep
Enter value for Salary: 38000
Salaries of both employees are not same
3. Write function in scheme to add the all elements of a numeric list and
display the result.

(define add(list))
(define (addition add)
(define sum 0)(define l (length add))
(define a 0)
(do ((i 1 (+ i 1)))
((> i l))
(if (number? (car add))
(begin (set! sum (+ sum (car add)))(set! add (cdr add)))
(set! add (cdr add))))(display sum))

Output
> (define list1(list 3 34 45 3 4 15 30))
> (addition list1)
134
4. Write scheme function to find the string having maximum length from a
SANDEEP KUMAR http://san24mca.blogspot.com/

string list.

(define str(list))
(define (maxstring str)
(define max 0)
(define l (length str))
(define a "0")
(do ((i 1 (+ i 1)))
((> i l))
(if (< max (string-length (car str)))
(begin (set! max (string-length (car str)))(set! a (car str))
(set! str (cdr str)) )
(set! str (cdr str))
 ))(display "maximum length of string:")(display max)(newline)(display
"string is:=")(display a))

Output
> (define str_list (list "my" "name" "sandeep kumar" "mithilesh" "syedul"
"abhisek mohanty"))
> (maxstring str_list)
maximum length of string:15
string is:=abhisek mohanty

5. Write a scheme function to find the number of occurrence of a digit in a

multi-digit number.

(display "Enter the value of a: ")

(define a 0)
(set! a(read))(define n 0)
(set! n a)
(define (count n1)
(define c 0)
(do ((i 1(+ i 1)))
((= 0 n))
(begin
(if (= (remainder n 10) n1)
(set! c (+ c 1))))
(begin (set! n (floor(/ n 10)))))
(display n1)(display "occurs ")(display c)(display " times"))
Output
Enter the value of a: 4565754545656786774534564576
> (count 4)
4occurs 6 times
SANDEEP KUMAR http://san24mca.blogspot.com/