Get the full ebook with Bonus Features for a Better Reading Experience on ebookgate.

com

C Programming Data Structures 4th Edition E.

Balagurusamy

https://ebookgate.com/product/c-programming-data-
structures-4th-edition-e-balagurusamy/

OR CLICK HERE

DOWLOAD NOW

Download more ebook instantly today at https://ebookgate.com

Instant digital products (PDF, ePub, MOBI) available
Download now and explore formats that suit you...

Programming in ANSI C 6th Edition E. Balagurusamy

https://ebookgate.com/product/programming-in-ansi-c-6th-edition-e-
balagurusamy/

ebookgate.com

Computer Programming 1st Edition E. Balagurusamy

https://ebookgate.com/product/computer-programming-1st-edition-e-
balagurusamy/

ebookgate.com

C Programming Program design including data structures

5ed. Edition Malik D.S.

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-5ed-edition-malik-d-s/

ebookgate.com

Data Structures and Algorithms in C 4th Edition Adam

Drozdek

https://ebookgate.com/product/data-structures-and-algorithms-in-c-4th-
edition-adam-drozdek/

ebookgate.com
C Programming Program Design Including Data Structures 7th
Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-7th-edition-d-s-malik/

ebookgate.com

C Programming Program Design Including Data Structures 6th

Edition D. S. Malik

https://ebookgate.com/product/c-programming-program-design-including-
data-structures-6th-edition-d-s-malik/

ebookgate.com

Data Structures and Other Objects Using C 4th Edition

Michael Main

https://ebookgate.com/product/data-structures-and-other-objects-
using-c-4th-edition-michael-main/

ebookgate.com

Data Structures Using C 2nd Edition D. S. Malik

https://ebookgate.com/product/data-structures-using-c-2nd-edition-d-s-
malik/

ebookgate.com

Data Structures Other Objects using Java 4th Edition

Michael Mann

https://ebookgate.com/product/data-structures-other-objects-using-
java-4th-edition-michael-mann/

ebookgate.com
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition
About the Author
E Balagurusamy, former Vice Chancellor, Anna University, Chennai, is currently Member, Union
Public Service Commission, New Delhi. He is a teacher, trainer, and consultant in the fields of Informa-
tion Technology and Management. He holds an ME (Hons) in Electrical Engineering and Ph.D in
Systems Engineering from the Indian Institute of Technology, Roorkee. His areas of interest include
Object-Oriented Software Engineering, Electronic Business, Technology Management, Business
Process Re-engineering, and Total Quality Management.
A prolific writer, he has authored a large number of research papers and several books. His best
selling books, among others include:
· Programming in C#, 2/e
· Programming in Java, 3/e
· Object-Oriented Programming with C++, 4/e
· Programming in BASIC, 3/e
· Programming in ANSI C, 4/e
· Numerical Methods
· Reliability Engineering
A recipient of numerous honours and awards, he has been listed in the Directory of Who’s Who of
Intellectuals and in the Directory of Distinguished Leaders in Education.
 As per the
Revised
Syllabus Effective
August 2007

C Programming
and
Data Structures
Fourth Edition

E Balagurusamy
Member, UPSC
New Delhi

Tata McGraw-Hill Publishing Company Limited

NEW DELHI
McGraw-Hill Offices
New Delhi New York St Louis San Francisco Auckland Bogotá Caracas
Kuala Lumpur Lisbon London Madrid Mexico City Milan Montreal
San Juan Santiago Singapore Sydney Tokyo Toronto
Published by the Tata McGraw-Hill Publishing Company Limited,
7 West Patel Nagar, New Delhi 110 008.

Copyright © 2009, by Tata McGraw-Hill Publishing Company Limited.

No part of this publication may be reproduced or distributed in any form or by any means, electronic, mechanical,
photocopying, recording, or otherwise or stored in a database or retrieval system without the prior written permis-
sion of the publishers. The program listings (if any) may be entered, stored and executed in a computer system, but
they may not be reproduced for publication.
This edition can be exported from India only by the publishers,
Tata McGraw-Hill Publishing Company Limited.
ISBN-13: 978-0-07-0084759
ISBN-10: 0-07-0084750
Managing Director—Ajay Shukla
General Manager: Publishing—SEM & Tech Ed: Vibha Mahajan
Sponsoring Editor—Shalini Jha
Senior Copy Editor—Dipika Dey
Junior Manager—Production, Anjali Razdan
Marketing General Manager—Higher Education & Sales: Michael J. Cruz
Product Manager—SEM & Tech Ed: Biju Ganesan
Controller—Production: Rajender P. Ghansela
Asst. General Manager— Production: B. L. Dogra

Information contained in this work has been obtained by Tata McGraw-Hill, from sources believed to be
reliable. However, neither Tata McGraw-Hill nor its authors guarantee the accuracy or completeness of any
information published herein, and neither Tata McGraw-Hill nor its authors shall be responsible for any
errors, omissions, or damages arising out of use of this information. This work is published with the under-
standing that Tata McGraw-Hill and its authors are supplying information but are not attempting to render
engineering or other professional services. If such services are required, the assistance of an appropriate
professional should be sought.

Typeset at Script Makers, 19, A1-B, DDA Market, Paschim Vihar, New Delhi 110 063, and printed at Shakti
Packers, 5C/9, New Rohtak Road, Karol Bagh, New Delhi-110 005
Cover: SDR Printers
DALZCRBFRAALX
 Contents

Foreword xi
Preface xiii
Road Map to the Syllabus xv
The C99 Standard xvii

UNIT I
1. Algorithms 1.3–1.15
1.1 Introduction ......................................................................................................................... 1.3
1.1.1 Algorithm/pseudocode .......................................................................................... 1.3
1.1.2 Flow Chart............................................................................................................ 1.4
1.2 Three Basic Operations ....................................................................................................... 1.5
1.2.1 Sequence .............................................................................................................. 1.5
1.2.2 Selection ............................................................................................................... 1.6
1.2.3 Iteration .............................................................................................................. 1.13
Review Questions and Exercises ..................................................................................... 1.14
2. Overview of C 2.1–2.12
2.1 Introduction ......................................................................................................................... 2.1
2.2 Importance of C .................................................................................................................. 2.1
2.3 Sample C Programs ............................................................................................................. 2.2
2.4 Program Development Steps ............................................................................................... 2.5
2.5 Structure of a C Program .................................................................................................... 2.9
Review Questions and Exercises ..................................................................................... 2.11
3. Constants, Variables, and Data Types 3.1–3.26
3.1 Introduction ........................................................................................................................ .3.1
3.2 Character Set ....................................................................................................................... 3.1
3.3 C Tokens ............................................................................................................................. 3.1
3.4 Keywords and Identifiers .................................................................................................... 3.2
3.5 Constants ............................................................................................................................. 3.3
3.6 Variables ............................................................................................................................. 3.7
3.7 Basic Data Types and Sizes ................................................................................................ 3.8
3.8 Declaration of Variables ................................................................................................... 3.11
3.9 Assigning Values to Variables .......................................................................................... 3.14
3.10 Defining Symbolic Constants ........................................................................................... 3.21
Review Questions and Exercises ................................................................................... 3.24
vi Contents
4. Operators and Expressions 4.1–4.22
4.1 Introduction ......................................................................................................................... 4.1
4.2 Arithmetic Operators .......................................................................................................... 4.1
4.3 Relational Operators ........................................................................................................... 4.4
4.4 Logical Operators ............................................................................................................... 4.5
4.5 Assignment Operators ......................................................................................................... 4.5
4.6 Increment and Decrement Operators .................................................................................. 4.7
4.7 Conditional Operator .......................................................................................................... 4.8
4.8 Bitwise Operators ............................................................................................................... 4.8
4.9 Special Operators ................................................................................................................ 4.9
4.10 Arithmetic Expressions ..................................................................................................... 4.11
4.11 Evaluation of Expressions ................................................................................................ 4.11
4.12 Precedence of Arithmetic Operators ................................................................................. 4.12
4.13 Some Computational Problems ......................................................................................... 4.14
4.14 Type Conversions in Expressions ..................................................................................... 4.15
4.15 Operator Precedence and Associativity ............................................................................ 4.18
Case Studies ..................................................................................................................... 4.19
Review Questions and Exercises ..................................................................................... 4.20
5. Managing Input and Output Operations 5.1–5.25
5.1 Introduction ......................................................................................................................... 5.1
5.1.1 Input/Output Statements and Header Files ........................................................... 5.1
5.2 Reading a Character ............................................................................................................ 5.2
5.3 Writing a Character ............................................................................................................ 5.4
5.4 Formatted Input ................................................................................................................... 5.5
5.5 Formatted Output .............................................................................................................. 5.14
Case Studies ..................................................................................................................... 5.21
Review Questions and Exercises ..................................................................................... 5.24
6. Decision Making and Branching 6.1–6.29
6.1 Introduction ......................................................................................................................... 6.1
6.2 Decision Making with If Statement .................................................................................... 6.1
6.3 Simple If Statement ............................................................................................................. 6.2
6.4 The If K Else Statement ..................................................................................................... 6.5
6.5 Nesting of If ... Else Statements .......................................................................................... 6.7
6.6 The Else If Ladder ............................................................................................................ 6.11
6.7 The Switch and Break Statements .................................................................................... 6.13
6.8 The ? : Operator ................................................................................................................ 6.17
6.9 The Goto Statement .......................................................................................................... 6.20
6.9.1 Label .................................................................................................................. 6.20
Case Studies ..................................................................................................................... 6.22
Review Questions and Exercises ..................................................................................... 6.26
7. Decision Making and Looping 7.1–7.30
7.1 Introduction ......................................................................................................................... 7.1
7.2 The While Statement ........................................................................................................... 7.3
7.3 The Do Statement ................................................................................................................ 7.4
 Contents vii
7.4 The For Statement ............................................................................................................... 7.6
7.5 Jumps in Loops ................................................................................................................. 7.14
7.6 Structured Programming ................................................................................................... 7.20
Case Studies ..................................................................................................................... 7.21
Review Questions and Exercises ..................................................................................... 7.27

UNIT II

8. Arrays 8.3–8.31
8.1 Introduction ......................................................................................................................... 8.3
8.2 One-Dimensional Arrays .................................................................................................... 8.3
8.3 Two-Dimensional Arrays.................................................................................................... 8.8
8.4 Initializing Two-Dimensional Arrays ............................................................................... 8.13
8.5 Multidimensional Arrays .................................................................................................. 8.15
Case Studies ..................................................................................................................... 8.17
Review Questions and Exercises ..................................................................................... 8.28
9. Handling of Character Strings 9.1–9.23
9.1 Introduction ......................................................................................................................... 9.1
9.2 Declaring and Initializing String Variables ........................................................................ 9.2
9.3 Reading Strings from Terminal ........................................................................................... 9.2
9.4 Writing Strings to Screen .................................................................................................... 9.5
9.5 Arithmetic Operations on Characters ................................................................................. 9.8
9.6 Putting Strings Together ................................................................................................... 9.10
9.7 Comparison of Two Strings .............................................................................................. 9.12
9.8 String-Handling Functions ................................................................................................ 9.13
9.9 Table of Strings ................................................................................................................. 9.15
Case Studies ..................................................................................................................... 9.18
Review Questions and Exercises ..................................................................................... 9.22
10. User-Defined Functions 10.1–10.50
10.1 Introduction ....................................................................................................................... 10.1
10.1.1 Standard Library Functions ................................................................................ 10.1
10.2 Need for User-Defined Functions ..................................................................................... 10.4
10.3 A Multi-Function Program ................................................................................................ 10.5
10.4 The Form of C Functions .................................................................................................. 10.7
10.5 Return Values and their Types .......................................................................................... 10.8
10.6 Calling a Function ............................................................................................................. 10.9
10.7 Category of Functions ..................................................................................................... 10.10
10.8 No Arguments and no Return Values ............................................................................. 10.10
10.9 Arguments but no Return Values .................................................................................... 10.12
10.10 Arguments with Return Values ....................................................................................... 10.14
10.11 Handling of Non-Integer Functions ................................................................................ 10.18
10.12 Nesting of Functions ....................................................................................................... 10.21
10.13 Recursion ........................................................................................................................ 10.22
10.14 Functions with Arrays ..................................................................................................... 10.23
10.15 The Scope and Lifetime of Variables in Functions—Storage Classes ............................ 10.26
viii Contents
10.16 ANSI C Functions ........................................................................................................... 10.36
10.17 The Preprocessor ............................................................................................................. 10.39
10.18 ANSI Additions .............................................................................................................. 10.42
Case Study ...................................................................................................................... 10.45
Review Questions and Exercises ................................................................................. 10.49

UNIT III

11. Pointers 11.3–11.32

11.1 Introduction ....................................................................................................................... 11.3
11.2 Understanding Pointers ..................................................................................................... 11.3
11.3 Accessing the Address of a Variable ................................................................................ 11.5
11.4 Declaring and Initializing Pointers ................................................................................... 11.6
11.5 Accessing a Variable Through its Pointer ........................................................................ 11.7
11.6 Pointer Expressions .......................................................................................................... 11.9
11.7 Pointer Increments and Scale Factor—Address Arithmetic ............................................ 11.11
11.8 Pointers and Arrays......................................................................................................... 11.12
11.9 Pointers and Character Strings ........................................................................................ 11.15
11.10 Pointers and Functions .................................................................................................... 11.17
11.11 Pointers and Structures ................................................................................................... 11.23
Case Studies ................................................................................................................... 11.25
Review Questions and Exercises ................................................................................... 11.31

UNIT IV

12. Structures and Unions 12.3–12.25

12.1 Introduction ....................................................................................................................... 12.3
12.2 Structure Definition—Declaring Structures ..................................................................... 12.3
12.3 Giving Values to Members ............................................................................................... 12.5
12.4 Structure Initialization ...................................................................................................... 12.6
12.5 Comparison of Structure Variables ................................................................................... 12.8
12.6 Arrays of Structures .......................................................................................................... 12.8
12.7 Arrays within Structures ................................................................................................. 12.11
12.8 Structures within Structures—Nested Structures ............................................................ 12.12
12.9 Structures and Functions ................................................................................................. 12.15
12.10 Unions ............................................................................................................................. 12.17
12.11 Size of Structures ............................................................................................................ 12.19
12.12 Bit Fields ......................................................................................................................... 12.19
Case Study ...................................................................................................................... 12.21
Review Questions and Exercises ................................................................................. 12.24

UNIT V

13. File Management in C 13.3–13.22

13.1 Introduction ....................................................................................................................... 13.3
13.2 Defining and Opening a File ............................................................................................. 13.7
 Contents ix
13.3 Closing a File .................................................................................................................... 13.8
13.4 Input/Output Operations on Files ...................................................................................... 13.9
13.5 Error Handling During I/O Operations ........................................................................... 13.12
13.6 Random Access to Files .................................................................................................. 13.14
13.7 Command Line Arguments ............................................................................................. 13.17
Case Study ...................................................................................................................... 13.19
Review Questions and Exercises ................................................................................... 13.21

UNIT VI

14. Data Structures 14.3–14.21

14.1 Introduction to Data Structures ......................................................................................... 14.3
14.2 Stacks ................................................................................................................................ 14.3
14.3 Queues .............................................................................................................................. 14.6
14.4 Circular Queues .............................................................................................................. 14.10
14.5 Applications of Stacks .................................................................................................... 14.11
Review Questions and Exercises ................................................................................... 14.21

UNIT VII

15. Dynamic Memory Allocation and Linked Lists 15.3–15.47

15.1 Introduction ....................................................................................................................... 15.3
15.2 Dynamic Memory Allocation ............................................................................................ 15.3
15.3 Linked Lists ...................................................................................................................... 15.9
15.3.1 Self-Referential Structure .................................................................................. 15.9
15.3.2 Singly Linked List ............................................................................................ 15.10
15.4 Advantages of Linked Lists ............................................................................................ 15.12
15.5 Types of Linked Lists...................................................................................................... 15.12
15.6 Pointers Revisited ........................................................................................................... 15.14
15.7 Basic List Operations...................................................................................................... 15.15
15.8 Application of Linked Lists ............................................................................................ 15.24
15.9 Circular Linked Lists ...................................................................................................... 15.25
15.10 Doubly Linked Lists ....................................................................................................... 15.25
15.11 Doubly Linked List Operations ...................................................................................... 15.26
15.12 Doubly Linked Circular Lists ......................................................................................... 15.35
15.13 Stacks and Queues using Linked List ............................................................................. 15.36
Case Studies ................................................................................................................... 15.40
Review Questions and Exercises ................................................................................... 15.46
16. Binary Trees and Graphs 16.1–16.25
16.1 Binary Trees—Representation and Terminology .............................................................. 16.1
16.2 Binary Tree Traversal ....................................................................................................... 16.2
16.3 Graphs ............................................................................................................................... 16.8
16.4 Graph Representation in C ................................................................................................ 16.9
16.5 Graph Traversal .............................................................................................................. 16.13
Review Questions and Exercises ................................................................................. 16.24
x Contents

UNIT VIII

17. Sorting and Searching Techniques 17.3–17.25

17.1 Introduction ....................................................................................................................... 17.3
17.2 Sorting ............................................................................................................................... 17.3
17.2.1 Sorting Efficiency .............................................................................................. 17.4
17.2.2 Exchange Sorting—Bubble Sort ........................................................................ 17.5
17.2.3 Exchange Sorting—Quick Sort .......................................................................... 17.7
17.2.4 Selection Sort ................................................................................................... 17.11
17.2.5 Merge Sort........................................................................................................ 17.13
17.2.6 Simple Insertion sort ........................................................................................ 17.15
17.2.7 Shell Sort .......................................................................................................... 17.17
17.3 Searching ........................................................................................................................ 17.18
17.3.1 Linear Search ................................................................................................... 17.18
17.3.2 Binary Search ................................................................................................... 17.20
17.3.3 Indexed Sequential Search ............................................................................... 17.23
Review Questions ........................................................................................................... 17.24
Appendix A
ASCII Values of Characters .......................................................................................A.1
Appendix B
Multiple Choice Questions .............................................................................. B.1–B.9
Appendix C
Solved Question Papers – C Programming and Data Structures
(May/June 2008) ............................................................................................... C.1–C.76
Bibliography .......................................................................................................................B.1
Chapter
1
Foreword

It gives me great pleasure to introduce C Programming and Data Structures by Dr E Balagurusamy,

publication of which heralds the completion of a book that caters completely and effectively to the
students of JNTU.
The need for a good textbook for this subject can be easily understood. Numerous books are available
to the students for the subject, but almost none of them have the right combination of simplicity, rigour,
pedagogy and syllabus compatibility. These books usually do not address one or more of the specific
problems faced by students of this subject in JNTU. There has always been a need for a good book
relevant to the requirements of the students and dealing with all aspects of the course. I am sure that the
present book will be able to fill this void.
The book has been organized and executed with lot of care and dedication. The author has been an
outstanding teacher and a pioneer of IT education in India. A conscious attempt has been made to
simplify concepts to facilitate better understanding of the subject.
Dr Balagurusamy deserves our praise and thanks for accomplishing this trying task. McGraw-Hill
Education, a prestigious publishing house, also deserves a pat on the back for doing an excellent job.

DR K. RAJAGOPAL
Vice-Chancellor
Jawaharlal Nehru Technological University
Hyderabad
Chapter
1
Preface

C is a general-purpose structured programming language that is powerful, efficient and compact. C

combines the features of high-level language with the elements of the assembler and is thus close to both
man and machine. The growth of C during the last few years has been phenomenal. It has emerged as the
language of choice for most applications due to speed, portability and compactness of code. It has now
been implemented on virtually every sort of computer, from micro to mainframe.
For many years, the de facto standard for implementing the language has been the original C Refer-
ence Manual by Kernighan and Ritchie published in 1978. During these years of growth and popularity,
C has undergone many changes. Numerous different features and facilities have been developed and
marketed. This has resulted in minor problems in terms of portability of programs. Consequently, the
American National Standard Institute (ANSI) constituted a committee to look into the language features
and produce a more comprehensive and unambiguous definition of C. The result is ANSI C. Most com-
pilers have already adopted ANSI standards.
This book incorporates all the features of ANSI C that are essential for a C programmer. The ANSI
standards are explained in detail in appropriate places. For the convenience of readers, these places
have been noted in the text by a special mention. A major highlight of this revised edition is the
inclusion of updated information on compiler C99 standard, with relevant theory and programs.
Another important addition in this edition is Appendix C containing 2008 solved question papers (4 sets).
The concept of ‘learning by example’ has been stressed throughout the book. Every important feature of
the language is treated in depth followed by a complete program example to illustrate its use. Case studies
at the end of the chapters not only describe the common ways in which C features are put together but
also show real-life applications. Wherever necessary, pictorial descriptions of concepts are included to
facilitate better understanding.
This book contains more than 100 examples and programs. All the programs have been tested using
compilers compatible to both UNIX and MS-DOS operating systems and, wherever appropriate, the
nature of output has been discussed. These programs also demonstrate the general principles of a good
programming style. 200 multiple choice questions are given to help the students test their conceptual
understanding of the subject.
The book also offers detailed discussions on Data Structures, Standard Library Functions,
Bit Fields, Linked Lists, Doubly Linked Lists, Queues, Stacks and Graphs with sample codes and
algorithms. Chapter 17 provides comprehensive information on Sorting and Searching techniques. Both
these topics are explained with sample codes. The various pros and cons of each of these techniques are
also covered.
xiv Preface
This edition comes with a CD which provides
More than 600 objective/review/debugging questions (8 units)
100 Programming exercises
Model question paper
2006 and 2007 solved question paper
Computer programs for lab
The objective of the supplementry CD is to make the students learn the programming language and
enable them to write their own programs using C and data structures.
The author is grateful to Mr A Rama Rao, Layola Institute of Technology & Management, Guntur
and Mr P Chenna Reddy, JNTU College of Engineering, Pulivendula for their useful comments and
suggestions.

E BALAGURUSAMY
Chapter
1
Road Map to the Syllabus
(Effective from August 2007)

Jawaharlal Nehru Technological University Hyderabad

I Year B.Tech T P C
4 0 6
C Programming and Data Structures
Objectives
· To make the student learn a programming language.
· To teach the student to write programs in C to solve the problems.
· To introduce the student to simple linear and non-liner data structures such as lists, stacks,
queues, trees and graphs.
Syllabus
Unit I
Algorithm / pseudo code, flowchart, program development steps, structure of C program, a simple C
program, identifiers, basic data types and sizes, constants, variables, arithmetic, relational and logical
operators, increment and decrement operators, conditional operator, bit-wise operators, assignment
operators, expressions, type conversions, conditional expressions, precedence and order of evaluation.
Input-output statements, statements and blocks, if and switch statements, loops- while, do-while and
for statements, break, continue, goto and labels, programming examples.

CHAPTER 1 – ALGORITHMS
CHAPTER 2 – OVERVIEW OF C
CHAPTER 3 – CONSTANTS, VARIABLES, AND DATA TYPES
Go To CHAPTER 4 – OPERATORS AND EXPRESSIONS
CHAPTER 5 – MANAGING INPUT AND OUTPUT OPERATIONS
CHAPTER 6 – DECISION MAKING AND BRANCHING
CHAPTER 7 – DECISION MAKING AND LOOPING

Unit II
Designing structured programs, functions, basics, parameter passing, storage classes- extern, auto,
register, static, scope rules, block structure, user-defined functions, standard library functions, recursive
functions, header files, C preprocessor, C program examples.

CHAPTER 7 – DECISION MAKING AND LOOPING

Go To
CHAPTER 10 – USER-DEFINED FUNCTIONS
xvi Road Map to the Syllabus
Unit III
Arrays- concepts, declaration, definition, accessing elements, storing elements, arrays and functions,
two-dimensional and multi-dimensional arrays, applications of arrays. pointers- concepts, initialization
of pointer variables, pointers and function arguments, address arithmetic, character pointers and
functions, pointers to pointers, pointers and multidimensional arrays, dynamic memory managements
functions, command line arguments, C program examples.

CHAPTER 8 – ARRAYS
Go To CHAPTER 9 – HANDLING OF CHARACTER
STRINGS
CHAPTER 11 – POINTERS
Unit IV
Derived types- structures- declaration, definition and initialization of structures, accessing structures,
nested structures, arrays of structures, structures and functions, pointers to structures, self-referential
structures, unions, typedef, bitfields, C program examples.

CHAPTER 12 – STRUCTURES AND UNIONS

Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit V
Input and output – concept of a file, text files and binary files, streams, standard I/o, formatted I/o, file
I/o operations, error handling, C program examples.

Go To CHAPTER 13 – FILE MANAGEMENT IN C

Unit VI
Searching – linear and binary search methods, sorting – bubble sort, selection sort, insertion sort, quick
sort, merge sort.

CHAPTER 17 – SORTING AND SEARCHING

Go To
TECHNIQUES

Unit VII
Introduction to data structures, singly linked lists, doubly linked lists, circular list, representing stacks
and queues in C using arrays and linked lists, infix to post fix conversion, postfix expression evaluation.
CHAPTER 14 – DATA STRUCTURES
Go To CHAPTER 15 – DYNAMIC MEMORY ALLOCATION
AND LINKED LISTS
Unit VIII
Trees- binary trees, terminology, representation, traversals, graphs—terminology, representation, graph
traversals (dfs and bfs)

Go To CHAPTER 16 – BINARY TREES AND GRAPHS

 The C99 Standard

Computer languages are not static; they evolve, reacting to changes in methodologies, applications gen-
erally accepted practices, and hardware. C is no exception. In the case of C, two evolutionary paths were
set in motion. The first is the continuing development of the C language. The second is C++, for which
C provided the starting point. While most of the focus of the past several years has been on C++, the
refinement of C has continued unabated.
For example, reacting to the internationalization of the computing environment, the original C89
standard was amended in 1995 to include various wide-character and multibyte functions. Once the
1995 amendment was complete, work began on updating the language, in general. The end result is, of
course, C99. In the course of creating the 1999 standard, each element of the C language was thoroughly
reexamined, usage patterns were analyzed, and future demands were anticipated. As expected, C's rela-
tionship to C++ provided a backdrop for the entire process. The resulting C99 standard is a testimonial
to the strengths of the original. Very few of the key elements of C were altered. For the most part, the
changes consist of a small number of carefully selected additions to the language and the inclusion of
several new library functions. Thus C is still C!
Here we will examine those features added by C99, and the few differences between C99 and C89.

C99

Perhaps the greatest cause for concern that accompanies the release of a new language standard is the
issue of compatibility with its predecessor. Does the new specification render old programs obsolete?
Have important constructs been altered? Do I have to change the way that I write code? The answers to
these types of questions often determine the degree to which the new standard is accepted and, in the
longer term, the viability of the language itself. Fortunately, the creation of C99 was a controlled, even-
handed process that reflects the fact that several experienced pilots were at the controls. Put simply: If
you liked C the way it was, you will like the version of C defined by C99. What many programmers
think of as the world's most elegant programming language, still is! In this chapter we will examine the
changes and additions made to C by the 1999 standard. Many of these changes were mentioned in
passing in Part One. Here they are examined in closer detail. Keep in mind, however, that as of this
writing, there are no widely used compilers that support many of C99’s new features. Thus, you may
need to wait a while before you can ‘test drive’ such exciting new constructs as variable-length arrays,
restricted pointers, and the long long data type.
xviii The C99 Standard
C89 vs. C99: AN OVERVIEW

There are three general categories of changes between C89 and C99:
· Features added to C89
· Features removed from C89
· Features that have been changed or enhanced
Many of the differences between C89 and C99 are quite small, and clarify nuances of the C language.
This book will concentrate on the larger changes that affect the way programs are written.

Features Added

Perhaps the most important features added by C99 are the new keywords:
· inline
· restrict
_Bool
_Complex
_Imaginary
Other major additions include
· Variable-length arrays
· Support for complex arithmetic
· The long long int data type
· The //comment
· The ability to intersperse code and data
· Additions to the preprocessor
· Variable declarations inside the for statement
· Compound literals
· Flexible array structure members
· Designated initializers
· Changes to the printf( ) and scanf( ) family of functions
· The _ _func_ _ predefined identifier
· New libraries and headers
Most of the features added by C99 are innovations created by the standardization committee, of
which many were based on language extensions offered by a variety of C implementations. In a few
cases, however, features were borrowed from C++. The inline keyword and // style comments are exam-
ples. It is important to understand that C99 does not add C++-style classes, inheritance, or member
functions. The consensus of the committee was to keep C as C.

Features Removed

The single most important feature removed by C99 is the ‘'implicit int’ rule. In C89, in many cases when
no explicit type specifier is present, the type int is assumed. This is not allowed by C99. Also removed
is implicit function declaration. In C89, if a function was not declared before it is used, an implicit
declaration is assumed. This is not supported by C99. Both of these changes may require existing code
to be rewritten if compatibility with C99 is desired.
 The C99 Standard xix
Features Changed

C99 incorporates several changes to existing features. For the most part, these changes expand features
or clarify their meaning. In a few cases, the changes restrict or narrow the applicability of a feature.
Many such changes are small, but a few are quite important, including:
· Increased translation limits
· Extended integer types
· Expanded integer type promotion rules
· Tightening of the return statement
As it affects existing programs, the change to return has the most significant effect because it might
require that code be rewritten slightly.
Throughout the remainder of this chapter, we will examine the major differences between C89 and
C99.

RESTRICT-QUALIFIED POINTERS

One of the most important innovations in C99 is the restrict type qualifier. This qualifier applies only to
pointers. A pointer qualified by restrict is initially the only means by which the object it points to can be
accessed. Access to the object by another pointer can occur only if the second pointer is based on the
first. Thus, access to the object is restricted to expressions based on the restrict-qualified pointer.
Pointers qualified by restrict are primarily used as function parameters, or to point to memory allocated
via malloc( ). The restrict qualifier does not change the semantics of a program. By qualifying a
pointer with restrict, the compiler is better able to optimize certain types of routines by making the
assumption that the restrict-qualified pointer is the sole means of access to the object. For example, if
a function specifies two restrict-qualified pointer parameters, the compiler can assume that the pointers
point to different (that is, non-overlapping) objects. For example, consider what has become the classic
example of restrict: the memcpy( ) function.
In C89, it is prototyped as shown here:
void *memcpy(void *str1, const void *str2, size_t size);
The description for memcpy( ) states that if the objects pointed to by str1 and str2 overlap, the
behaviour is undefined. Thus, memcpy( ) is guaranteed to work for only non-overlapping objects. In
C99, restrict can be used to explicitly state in memcpy( )’s prototype what C89 must explain with
words.
Here is the C99 prototype for memcpy( ):
void *memcpy
(void * restrict str1, const void * restrict str2, size_t size);
By qualifying str1 and str2 with restrict, the prototype explicitly asserts that they point to non-overlap-
ping objects. Because of the potential benefits that result from using restrict, C99 has added it to the
prototypes for many of the library functions originally defined by C89.

Inline

C99 adds the keyword inline, which applies to functions. By preceding a function declaration with
inline, you are telling the compiler to optimize calls to the function. Typically, this means that the
xx The C99 Standard
function’s code will be expanded in line, rather than called. However, inline is only a request to the
compiler, and can be ignored. Specifically, C99 states that using inline ‘suggests that calls to the func-
tion be as fast as possible.’ The inline specifier is also supported by C++, and the C99 syntax for inline
is compatible with C++.
To create an in-line function, precede its definition with the inline keyword. For example, in the
following program, calls to the function max( ) are optimized:
#include <stdio.h>
inline int max(int a, int b)
{
return a > b ? a : b;
}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, max(x, y));
return 0;
}
For a typical implementation of inline, the preceding program is equivalent to this one:
#include <stdio.h>
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x, y, (x>y ? x : y));
return 0;
}
The reason that inline functions are important is that they help you create more efficient code while
maintaining a structured, function-based approach. As you probably know, each time a function is
called, a significant amount of overhead is generated by the calling and return mechanism. Typically,
arguments are pushed onto the stack and various registers are saved when a function is called, and then
restored when the function returns. The trouble is that these instructions take time.
However, when a function is expanded in line, none of those operations occur. Although expanding
function calls in line can produce faster run times, it can also result in larger code size because of
duplicated code. For this reason, it is best to inline only very small functions. Further, it is also a good
idea to inline only those functions that will have significant impact on the performance of your program.
Remember: Although inline typically causes a function’s code to be expanded in line, the com-
piler can ignore this request or use some other means to optimize calls to the function.

NEW BUILT-IN DATA TYPES

C99 adds several new built-in data types. Each is examined here.
 The C99 Standard xxi
_Bool

C99 adds the _Bool data type, which is capable of storing the values 1 and 0 (true and false). _Bool is
an integer type. As many readers know, C++ defines the keyword bool, which is different from _Bool.
Thus, C99 and C++ are incompatible on this point. Also, C++ defines the built-in Boolean constants
true and false, but C99 does not. However, C99 adds the header <stdbool.h>, which defines the macros
bool, true, and false. Thus, code that is compatible with C/C++ can be easily created.
The reason that _Bool rather than bool is specified as a keyword is that many existing C programs
have already defined their own custom versions of bool. By defining the Boolean type as _Bool, C99
avoids breaking this preexisting code. However, for new programs, it is best to include <stdbool.h> and
then use the bool macro.

_Complex and _Imaginary

C99 adds support for complex arithmetic, which includes the keywords _Complex and _Imaginary,
additional headers, and several new library functions. However, no implementation is required to imple-
ment imaginary types, and freestanding implementations (those without operating systems) do not have
to support complex types. Complex arithmetic was added to C99 to provide better support for numerical
programming.
The following complex types are defined:
· float _Complex
· float _Imaginary
· double _Complex
· double _Imaginary
· long double _Complex
· long double _Imaginary
The reason that _Complex and _Imaginary, rather than complex and imaginary, are specified as
keywords, is that many existing C programs have already defined their own custom complex data types
using the names complex and imaginary. By defining the keywords _Complex and _Imaginary, C99
avoids breaking this preexisting code.
The header <complex.h> defines (among other things) the macros complex and imaginary, which
expand to Complex and _Imaginary. Thus, for new programs, it is best to include <complex.h> and
then use the complex and imaginary macros.

The long long Integer Types

C99 adds the long long int and unsigned long long int data types. A long long int has a range of at
least–(263–1) to 263–1. An unsigned long long int has a minimal range of 0 to 264–1. The long long
types allow 64-bit integers to be supported as a built-in type.

Array Enhancements

C99 has added two important features to arrays: variable length and the ability to include type qualifiers
in their declarations.
xxii The C99 Standard
Variable-Length Arrays

In C89, array dimensions must be declared using integer constant expressions, and the size of an array is
fixed at compile time. C99 changes this for certain circumstances. In C99, you can declare an array
whose dimensions are specified by any valid integer expression, including those whose value is known
only at run time. This is called a variable-length array (VLA). However, only local arrays (that is,
those with block scope or prototype scope) can be of variable length.
Here is an example of a variable-length array:
void f(int dim1, int dim2)
{
int matrix[dim1] [dim2]; /* a variable-length, 2-D array */
/* . . . */
}
Here, the size of matrix is determined by the values passed to f( ) in dim1 and dim2. Thus, each call to
f( ) can result in matrix being created with different dimensions.
It is important to understand that variable-length arrays do not change their dimensions during their
lifetime. (That is, they are not dynamic arrays.) Rather, a variable-length array can be created with a
different size each time its declaration is encountered.
You can specify a variable-length array of an unspecified size by using * as the size.
The inclusion of variable-length arrays causes a small change in the sizeof operator. In general, sizeof is
a compile-time operator. That is, it is normally translated into an integer constant whose value is equal
to the size of the type or object when a program is compiled. However, when it is applied to a variable-
length array, sizeof is evaluated at run time. This change is necessary because the size of a variable-
length array cannot be known until run time.
One of the major reasons for the addition of variable-length arrays to C99 is to support numeric
processing. Of course, it is a feature that has widespread applicability. But remember, variable-length
arrays are not supported by C89 (or by C++).

Use of Type Qualifiers in an Array Declaration

In C99 you can use the keyword static inside the brackets of an array declaration when that declaration
is for a function parameter. It tells the compiler that the array pointed to by the parameter will always
contain at least the specified number of elements. Here is an example:
int f(char str [static 80])
{
// here, str is always a pointer to an 80-element array
// . . .
}
In this example, str is guaranteed to point to the start of an array of chars that contains at least 80
elements.
You can also use the keywords restrict, volatile, and const inside the brackets, but only for function
parameters. Using restrict specifies that the pointer is the sole initial means of access to the object.
 The C99 Standard xxiii
Using const states that the same array is always pointed to (that is, the pointer always points to the same
object). The use of volatile is allowed, but meaningless.

Single-Line Comments

C99 adds the single-line comment to C. This type of comment begins with // and runs to the end of
the line.
For example:
// This is a comment
int i; // this is another comment
Single-line comments are also supported by C++. They are convenient when only brief, single-line
remarks are needed. Many programmers use C’s traditional multiline comments for longer descriptions,
reserving single-line comments for “play-by-play” explanations.
Interspersed Code and Declarations In C89, within a block, all declarations must precede the first
code statement. This rule does not apply for C99.
For example:
#include <stdio.h>
int main(void)
{
int i;
i = 10;
int j; // wrong for C89; OK for C99 and C++
j = i;
printf(“%d %d”, i, j);
return 0;
}
Here, the statement i = 10; comes between the declaration of i and the declaration of j. This is not
allowed by C89. It is allowed by C99 (and by C++). The ability to intersperse declarations and code is
widely used in C++.
Adding this feature to C makes it easier to write code that will be used in both environments.

PREPROCESSOR CHANGES

C99 makes a number of small changes to the preprocessor.

Variable Argument Lists

Perhaps the most important change to the preprocessor is the ability to create macros that take a variable
number of arguments. This is indicated by an ellipsis (. . .) in the definition of the macro. The built-in
preprocessing identifier _ _VA_ARGS_ _ determines where the arguments will be substituted.
xxiv The C99 Standard
For example, given this definition
#define MyMax(. . .) max(__VA_ARGS__)
this statement
MyMax(a, b);
is transformed into
max(a, b);

There can be other arguments prior to the variable ones. For example, given
#define compare(compfunc, . . .) compfunc(__VA_ARGS__)
this statement
compare(strcmp, “one”, “two”);
is transformed into
strcmp(“one”, “two”);
As the example shows, _ _VA_ARGS_ _ is replaced by all of the remaining arguments.

The _Pragma Operator

C99 includes another way to specify a pragma in a program: the _Pragma operator. It has the following
general form:
_Pragma (“directive”)
Here, directive is the pragma being invoked. The addition of the _Pragma operator allows pragmas to
participate in macro replacement.

Built-in Pragmas

C99 defines the following built-in pragmas:

Pragma Meaning
STDC FP_CONTRACT ON/OFF/DEFAULT When on, floating-point expressions are
treated as indivisible units that are handled
by hardware-based methods. The default
state is implementation defined.
STDC FENV_ACCESS ON/OFF/DEFAULT Tells the compiler that the floating-point en-
vironment might be accessed. The default
state is implementation defined.
STDC CX_LIMITED_RANGE ON/OFF/DEFAULT When on, tells the compiler that certain for-
mulas involving complex values are safe. The
default state is off.
You should refer to your compiler’s documentation for details concerning these pragmas.
 The C99 Standard xxv
Additional Built-in Macros

C99 adds the following macros to those already supported by C89:

_ _STDC_HOSTED_ _ 1 if an operating system is present.

_ _STDC_VERSION_ _ 199901L or greater. Represents version of C.

_ _STDC_IEC_559_ _ 1 if IEC 60559 floating-point arithmetic is supported.

_ _STDC_IEC_599_COMPLEX_ _ 1 if IEC 60559 complex arithmetic is supported.

_ _STDC_ISO_10646_ _ A value of the form yyyymmL that states the year and
month of the ISO/IEC 10646 specification supported by the
compiler.

Declaring Variables within a for Loop

C99 enhances the for loop by allowing one or more variables to be declared within the initialization
portion of the loop. A variable declared in this way has its scope limited to the block of code controlled
by that statement. That is, a variable declared within a for loop will be local to that loop. This feature
has been included in C because often the variable that controls a for loop is needed only by that loop. By
localizing this variable to the loop, unwanted side effects can be avoided.
Here is an example that declares a variable within the initialization portion of a for loop:
#include <stdio.h>
int main(void)
{
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d ”, i);
return 0;
}
Here, i is declared within the for loop, rather than prior to it.
As mentioned, a variable declared within a for is local to that loop. Consider the following program.
Notice that the variable i is declared twice: at the start of main( ) and inside the for loop.
#include <stdio.h>
int main(void)
{
int i = -99;
// declare i within for
for(int i=0; i < 10; i++)
printf(“%d”, i);
printf(“\n”);
xxvi The C99 Standard
printf(“Value of i is: %d”, i); // displays-99
return 0;
}
This program displays the following:
0123456789
Value of i is: -99
As the output shows, once the for loop ends, the scope of the i declared within that loop ends. Thus, the
final printf( ) statement displays –99, the value of the i declared at the start of main( ).
The ability to declare a loop-control variable inside the for has been available in C++ for quite some
time, and is widely used. It is expected that most C programmers will do the same.

Compound Literals

C99 allows you to define compound literals, which are array, structure, or union expressions designat-
ing objects of the given type. A compound literal is created by specifying a parenthesized type name,
which is then followed by an initialization list, which must be enclosed between curly braces. When the
type name is an array, its size must not be specified. The object created is unnamed.
Here is an example of a compound literal:
double *fp = (double[]) {1.0, 2.0, 3.0};
This creates a pointer to double, called fp, which points to the first of a three-element array of double
values.
A compound literal created at file scope exists throughout the lifetime of the program. A compound
literal created within a block is a local object that is destroyed when the block is left.

Flexible Array Structure Members

C99 allows you to specify an unsized array as the last member of a structure. (The structure must have
at least one other member prior to the flexible array member.) This is referred to as a flexible array
member. It allows a structure to contain an array of variable size. The size of such a structure returned
by sizeof does not include memory for the flexible array.
Typically, memory to hold a structure containing a flexible array member is allocated dynamically,
using malloc( ). Extra memory must be allocated beyond the size of the structure to accommodate the
desired size of the flexible array.
For example, given
struct mystruct {
int a;
int b;
float fa[]; // flexible array
};
the following statement allocates room for a 10-element array:
 The C99 Standard xxvii
struct mystruct *p;
p = (struct mystruct *) malloc(sizeof(struct mystruct) + 10 *
sizeof(float));
Since sizeof(struct mystruct) yields a value that does not include any memory for fa, room for the 10-
element array of floats is added by the expression
10 * sizeof(float)
when malloc( ) is called.

Designated Initializers

A new feature of C99 that will be especially helpful to those programmers working with sparse arrays is
designated initializers. Designators take two forms: one for arrays and one for structures and unions.
For arrays, the following form is used,
[index] = val
where index specifies the element being initialized to the value val. For example:
int a[10] = { [0] = 100, [3] = 200 };
Here, only elements 0 and 3 are initialized.
For structure or union members, the form used is:
. member-name
Using a designator with a structure allows an easy means of initializing only selected members of a
structure.
For example:
struct mystruct {
int a;
int b;
int c;
} ob = { .c = 30, .a = 10 };
Here, b is uninitialized.
Using designators also allows you to initialize a structure without knowing the order of its members.
This is useful for predefined structures, such as div_t, or for structures defined by some third party.

Additions to the printf( ) and scanf( ) Family of Functions

C99 adds to the printf( ) and scanf( ) family of functions the ability to handle the long long int and
unsigned long long int data types. The format modifier for long long is ll.
For example, the following fragment shows how to output a long long int and an unsigned long long
int:
long long int val;
unsigned long long int u_val;
printf(“%lld %llu”, val, val2);
xxviii The C99 Standard
The II can be applied to the d, i, o, u, and x format specifiers for both printf( ) and scanf( ).
C99 adds the hh modifier, which is used to specify a char argument when using the d, i, o, u, or x
format specifiers. Both the ll and hh specifiers can also be applied to the n specifier.
The format specifiers a and A, which were added to printf( ), cause a floating-point value to be
output in a hexadecimal format. The format of the value is
[-]0xh.hhhhp+d
When A is used, the x and the p are uppercase. The format specifiers a and A were also added to
scanf( ), and read a floating-point value.
In a call to printf( ), C99 allows the 1 modifier to be added to the %f specifier (as in %lf), but it has
no effect. In C89, %lf is undefined for printf( ).

NEW LIBRARIES IN C99

C99 adds several new libraries and headers. They are shown here:
Header Purpose
<complex.h> Supports complex arithmetic.
<fenv.h> Gives access to the floating-point status flags and other
aspects of the floating-point environment.
<inttypes.h> Defines a standard, portable set of integer type names.
Also supports functions that handle greatest-width inte-
gers.
<iso646.h> Added in 1995 by Amendment 1. Defines macros that
correspond to various operators, such as && and ^.
<stdbool.h> Supports Boolean data types. Defines the macros bool,
true, and false, which help with C++ compatibility.
<stdint.h> Defines a standard, portable set of integer type names.
This header is included by <inttypes.h>.
<tgmath.h> Defines type-generic floating-point macros.
<wchar.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter functions.
<wctype.h> Added in 1995 by Amendment 1. Supports multibyte and
widecharacter classification functions.

The _ _func_ _ Predefined Identifier

C99 defines _ _func_ _, which specifies the name (as a string literal) of the function in which
_ _func_ _ occurs.
For example:
void StrUpper(char *str)
 The C99 Standard xxix
{
static int i = 0;
i++;
printf(“%s has been called %d time(s).\n”, __func__, i);
while(*str) {
*str = toupper(*str);
str++;
}
}
When called the first time, StrUpper( ) will display this output:
StrUpper has been called 1 time(s).

INCREASED TRANSLATION LIMITS

The term ‘translation limits’ refers to the minimum number of various elements that a C compiler must
be able to handle. These include such things as the length of identifiers, levels of nesting, number of case
statements, and number of members allowed in a structure or union. C99 has increased several of these
limits beyond the already generous ones specified by C89.
Here are some examples:
Limit C89 C99
Nesting levels of blocks 15 127
Nesting levels of conditional inclusion 8 63
Significant characters in an internal identifier 31 63
Significant characters in an external identifier 6 31
Members of a structure or union 127 1023
Arguments in a function call 31 127

Implicit int No Longer Supported

Several years ago, C++ dropped the implicit int rule, and with the advent of C99, C follows suit. In C89,
the implicit int rule states that in the absence of an explicit type specifier, the type int is assumed. The
most common use of the implicit int rule was in the return type of functions. In the past, C programmers
often omitted the int when declaring functions that returned an int value.
For example, in the early days of C, main( ) was often written like this:
main ()
{
/* . . . */
}
xxx The C99 Standard
In this approach, the return type was simply allowed to default to int. In C99 (and in C++) this default no
longer occurs, and the int must be explicitly specified, as it is for all of the programs in
this book.
Here is another example. In the past a function such as
int isEven(int val)
{
return !(val%2);
}
would often have been written like this:
/* use integer default */
isEven (int val)
{
return !(val%2);
}
In the first instance, the return type of int is explicitly specified. In the second, it is assumed by default.
The implicit int rule does not apply only to function return values (although that was its most
common use).
For example, for C89 and earlier, the isEven( ) function could also be written like this:
isEven(const val)
{
return ! (val%2);
}
Here, the parameter val also defaults to int—in this case, const int. Again, this default to int is not
supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied ints after re-
porting a warning error. This allows old code to be compiled. However, there is no requirement
that a C99-compatible compiler accept such code.

Implicit Function Declarations Have Been Removed

In C89, if a function is called without a prior explicit declaration, then an implicit declaration of that
function is created. This implicit declaration has the following form:
extern int name( );
Implicit function declarations are no longer supported by C99.
Note Technically, a C99-compatible compiler can accept code containing implied function dec-
larations after reporting a warning error. This allows old code to be compiled. However, there is
no requirement that a C99-compatible compiler accept such code.
 The C99 Standard xxxi
Restrictions on return

In C89, a function that has a non-void return type (that is, a function that supposedly returns a value)
could use a return statement that did not include a value. Although this creates undefined behaviour, it
was not technically illegal. In C99, a non-void function must use a return statement that returns a
value. That is, in C99, if a function is specified as returning a value, any return statement within it must
have a value associated with it. Thus, the following function is technically valid for C89, but invalid for
C99:
int f(void)
{
/* . . . */
return ; // in C99, this statement must return a value
}

Extended Integer Types

C99 defines several extended integer types in <stdint.h>. Extended types include exact-width, mini-
mum-width, maximum-width, and fastest integer types.
Here is a sampling:

Extended Type Meaning

int16_t An integer consisting of exactly 16 bits

int_least16_t An integer consisting of at least 16 bits
int_fast32_t Fastest integer type that has at least 32 bits
intmax_t Largest integer type
uintmax_t Largest unsigned integer type
The extended types make it easier for you to write portable code.
For loop changes In a for-loop, the first expression may be a declaration, with a scope encompassing
only the loop.
for (decl; pred; inc)
stmt;
is equivalent to:
{
decl;
for (; pred; inc)
stmt;
}
Type specifiers or data types Type specifiers: new combinations added for:
· _Bool
· float _Complex, double _Complex, long double _Complex
· signed and unsigned long long int.
xxxii The C99 Standard
New type long long (signed and unsigned), at least 64 bits wide.
Note: It seems that these type specifiers may occur in any order, e.g, _Complex double long
or signed long int long would be legal.
The implementation of the complex types is defined by the standard to use cartesian coordinates (real
and imaginary part), i.e. forbids an implementation using polar coordinates (distance from [0,0] and an
angle). Furthermore, the same paragraph also specifies that a complex type has the same alignment
requirements as an array of two elements of the corresponding floating types, the first must be the real
part and the second the imaginary part.
Objects of the new boolean type _Bool may have one of the two values zero or one.

Format Modifiers for Printf( ) Added by C99

C99 adds several format modifiers to printf( ): hh, ll, j, z, and t. The hh modifier can be applied to d, i,
o, u, x, X, or n. It specifies that the corresponding argument is a signed or unsigned char value or, in
the case of n, a pointer to a signed char variable. The ll modifier also can be applied to d, i, o, u, x, X,
or n. It specifies that the corresponding argument is a signed or unsigned long long int value or, in the
case of n, a pointer to a long long int. C99 also allows the l to be applied to the floating-point specifiers
a, A, e, E, f, F, g, and G, but it has no effect. The j format modifier, which applies to d, i, o, u, x, X, or
n, specifies that the matching argument is of type intmax_t or uintmax_t. These types are declared in
<stdint.h> and specify greatest-width integers. The z format modifier, which applies to d, i, o, u, x, X,
or n, specifies that the matching argument is of type size_t. This type is declared in <stddef.h> and
specifies the result of sizeof.
The t format modifier, which applies to d, i, o, u, x, X, or n, specifies that the matching argument is of
type ptrdiff_t. This type is declared in <stddef.h> and specifies the difference between two pointers.

Sample code

#include <stdio.h>
int main(void)
{
/* This prints ''this is a test" left justified
in 20 character field.
*/
printf(“%-20s”, “this is a test”);
/* This prints a float with 3 decimal places in a 10
character field. The output will be " 12.235".
*/
printf(“%10.3f”, 12.234657);
return 0;
}

Changes to the Integer Promotion Rules

C99 enhances the integer promotion rules. In C89, a value of type char, short int , or an int bit-field can
be used in place of an int or unsigned int in an expression. If the promoted value can be held in an int,
the promotion is made to int; otherwise, the original value is promoted to unsigned int.
 The C99 Standard xxxiii
In C99, each of the integer types is assigned a rank. For example, the rank of long long int is greater
than int, which is greater than char, and so on. In an expression, any integer type that has a rank less
than int or unsigned int can be used in place of an int or unsigned int.

THE PRINTF( ) FORMAT SPECIFIERS

Code Format
%a Hexadecimal output in the form 0xh.hhhhp+d (C99 only).
%A Hexadecimal output in the form 0Xh.hhhhP+d (C99 only).
%c Character.
%d Signed decimal integers.
%i Signed decimal integers.
%e Scientific notation (lowercase e).
%E Scientific notation (uppercase E).
%f Decimal floating point.
%F Decimal floating point (C99 only; produces uppercase INF, INFINITY,
or NAN when applied to infinity or a value that is not a number. The %f
specifier produces lowercase equivalents.)
%g Uses %e or %f, whichever is shorter.
%G Uses %E or %F, whichever is shorter.
%o Unsigned octal.
%s String of characters.
%u Unsigned decimal integers.
%x Unsigned hexadecimal (lowercase letters).
%X Unsigned hexadecimal (uppercase letters).
%p Displays a pointer.
%n The associated argument must be a pointer to an integer. This specifier
causes the number of characters written (up to the point at which the
%n is encountered) to be stored in that integer.
%% Prints a percent sign.

RESTRICT-QUALIFIED POINTERS

The C99 standard has added a new type qualifier that applies only to pointers: restrict. A pointer
qualified by restrict is initially the only means by which the object it points to is accessed. Access to the
object by another pointer can occur only if the second pointer is based on the first. Thus, access to the
object is restricted to expressions based on the restrict-qualified pointer. Pointers qualified by restrict
are primarily used as function parameters or to point to memory allocated via malloc( ). By qualifying
a pointer with restrict, the compiler is better able to optimize certain types of routines. For example, if
a function specifies two restrict-qualified pointer parameters, then the compiler can assume that the
pointers point to different (that is, non-overlapping) objects. The restrict qualifier does not change the
semantics of a program.
xxxiv The C99 Standard

1. /* Write a program to test the given string is palindrome or not. implement the program
by using _Bool datatype */
#include<stdio.h>
#include<string.h>
enum _Bool{false,true}; // _Bool DataType which is capable of
storing the vales 0 and 1
enum _Bool IsPalindrome(char string[]) // _Bool datatype
{
int left,right,len=strlen(string);
enum _Bool matched=true; // _Bool datatype
if(len==0)
return 0;
left=0;
right=len-1;
/* Compare the first and last letter,second & second last & so
on */
while(left<right&&matched)
{
if(string[left]!=string[right])
matched=false;
else
{
left++;
right--;
}
}
return matched;
}

int main()
{
char string[40];
clrscr();
printf("****Program to test if the given string is a
palindrome****\n");
printf("Enter a string:");
scanf("%s",string);
if(IsPalindrome(string))
printf("The given string %s is a palindrome\n",string);
else
printf("The given string %s is not a palindrome\n",string);
getch();
return 0;
}
 The C99 Standard xxxv

2. /* In C89, within a block, all declarations must precede the first code statement. This rule
does not apply for C99 */
#include<stdio.h>
int main(void)
{
int i;
i=10;
int j; //wrong for c89; ok for c99
j=i;
clrscr();
printf("%d %d",i,j);
return 0;
getch();
}
3. /* Write a program to print the signed and unsigned numbers by using C99 standards*/
#include<stdio.h>
int main(void)
{
int i= -99;
{
for(int i=0; i<10; i++) //declare i within for
printf("%d",i);
printf("\n");
}
printf("Value of i is: %d",i); //display-99
return 0;
}
4. /* Write a program to open the file by using C99 standards */
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
FILE *fp;
if((fp=fopen("test","wb"))==NULL);
{
printf("cannot open file.\n");
exit(1);
fprintf(fp,"this is a test %d %f", 10,20.01); // fprintf
fclose(fp);
return 0;
}
}
xxxvi The C99 Standard

5. /* Write a C program that uses functions to perform the following operations by using
C99 standards(_Complex, _Imaginary):
(i) Reading a complex number
(ii) Writing a complex number
(iii) Addition of two complex numbers
(iv) Multiplication of two complex numbers
(Note: represent complex number using a structure.) */
#include<stdio.h>
#include<math.h>
#include<complex.h>

void _Complex(int opern);

struct comp
{
double realpart;
double _Imaginary;
};

void main()
{
int opern;
clrscr();
printf("\n\n \t\t\t***** MAIN MENU *****");
printf("\n\n Select your option: \n1 : ADD\n2 : MULTIPLY\n0 :
EXIT \n\n\t\t Enter your Option [ ]\b\b");

scanf("%d",&opern);

switch(opern)
{
case 0:
exit(0);
case 1:
case 2:
_Complex(opern);
default:
main();
}

void _Complex(int opern)

 The C99 Standard xxxvii

{
struct comp w1, w2, w;
printf("\n Enter two Complex Numbers (x+iy):\n Real Part of
First Number:");
scanf("%lf",&w1.realpart);
printf("\n Imaginary Part of First Number:");
scanf("%lf",&w1._Imaginary);
printf("\n Real Part of Second Number:");
scanf("%lf",&w2.realpart);
printf("\n Imaginary Part of Second Number:");
scanf("%lf",&w2._Imaginary);
switch(opern)
{
/*addition of complex number*/
case 1:
w.realpart = w1.realpart+w2.realpart;
w._Imaginary = w1._Imaginary+w2._Imaginary;
break;

/*multiplication of complex number*/

case 2:
w.realpart=(w1.realpart*w2.realpart)-
(w1._Imaginary*w2._Imaginary);

w._Imaginary=(w1.realpart*w2._Imaginary)+(w1._Imaginary*w2.realpart);
break;
}

if (w._Imaginary>0)
printf("\n Answer = %lf+%lfi",w.realpart,w._Imaginary);
else
printf("\n Answer = %lf%lfi",w.realpart,w._Imaginary);
getch();
main();
}
6. /* Write a program to find the maximum number by using C99 standards(inline keyword)
*/
#include <stdio.h>
inline int max(int a, int b) // inline keyword
{
return a > b ? a : b;
xxxviii The C99 Standard

}
int main(void)
{
int x=5, y=10;
printf("Max of %d and %d is: %d\n", x,y,max(x,y));

return 0;
}
7. /* Write a C program to generate Pascal's Triangle by using C99 standards */
#include<stdio.h>
#include<conio.h>

void main()
{
int bin,q,r;
clrscr();
bin=1;
q=0;

printf("Rows you want to input:");

scanf("%d",&r);

printf("\nPascal's Triangle:\n");

while(q<r)
{
for(int p=40-3*q;p>0;--p) // declare p with in for
printf(" ");
for(int x=0;x<=q;++x) // declare x with in for
{
if((x==0)||(q==0))
bin=1;
else
bin=(bin*(q-x+1))/x;
printf("%6d",bin);
}

printf("\n");
++q;
}
getch();
}
 The C99 Standard xxxix

8. /* Write a C program to generate all the prime numbers between 1 and n, where n is a
value supplied by the user by using C99 standards.(long long int,declare variables with in
for loop) */
#include <stdio.h>

void main()
{
long long int no,check; // long long int
clrscr();
printf("<-----------------------PRIME NO. SERIES--------------
---------->");
printf("\n\n\n\t\t\tINPUT THE VALUE OF N: ");
scanf("%d",&no);
printf("\n\nTHE PRIME NO. SERIES B/W 1 TO %lld : \n\n",no);

for(int counter = 1; counter <= no; counter++) // declare

counter with in for
{
check = 0;
//THIS LOOP WILL CHECK A NO TO BE PRIME NO. OR NOT.

for(int counter1 = counter-1; counter1 > 1 ; counter1--)

if(counter%counter1 == 0)
{
check++; // INCREMENT CHECK IF NO. IS NOT A PRIME NO.
break;
}
if(check == 0)
printf("%d\t",counter);
}
getch();
}
9. /* Write a program to print text and numbers by using C99 standards */
#include<stdio.h>
int main(void)
{
printf("%-20s","this is a test"); // left justified
printf("%10.3f",12.234657);
return 0;
}
xl The C99 Standard

10. /* Write a program for addition of matrices by using the restrict keyword */
void fadd(double a[static restrict 10],
const double b[static restrict 10]) // restrict keyword, restricrts a and b
{
int i;
for(i=0; i<10; i++)
{
if(a[i] < 0.0)
return;
a[i] += b[i];
}
return;
}
11. /* Write a C program to find the roots of a quadratic equation by using format modifiers
in C99. */
#include<stdio.h>
#include<conio.h>
#include<math.h>
void main()
{
float a,b,c,root1,root2;
clrscr();
printf("\n Enter values of a,b,c for finding roots of a qua-
dratic eq:\n");
scanf("%f%f%f",&a,&b,&c);
/*checking condition*/
if(b*b>4*a*c)
{
root1=-b+sqrt(b*b-4*a*c)/2*a;
root2=-b-sqrt(b*b-4*a*c)/2*a;
printf("\n*****ROOTS ARE*****\n");
printf("\nroot1=%1.3f\nroot2=%1.2f",root1,root2); //format
modifiers for printf()
}
else
printf("\n Imaginary Roots.");
getch();
}
 The C99 Standard xli

12. /* Write a C program to find the sum of individual digits of a positive integer by using long
long int in C99 standards*/
#include<stdio.h>
#include<conio.h>
void main()
{
long long int num, k=1, sum=0; // long long int
clrscr();
printf("Enter the number whose digits are to be added:");
scanf("%lld",&num);
while(num!=0)
{
k=num%10;
sum=sum+k;
k=num/10;
num=k;
}
printf("Sum of the digits:%lld",sum);
getch();
}
UNIT I
Chapter
1
Algorithms

1.1 INTRODUCTION

There is a tremendous similarity between the human actions and the way a computer performs various
functions. Nicholas Wirth—the inventor of a computer language—‘Pascal’ used to say “A program is
equal to algorithm + data”. In the next few chapters, we will explore the meaning of these terms; first
learning about and clearly analyzing human actions and then showing how computers also act similarly,
thereby demystifying the complexity that surrounds computers.
We perform hundreds of activities during a day. An activity could be anything from brushing teeth to
making tea and from going to work to having dinner. There are two basic ways to describe in detail, any
of these activities:
1. By describing the process step-by-step—called as algorithm.
2. By representing the various steps in the form of a diagram—called as flow chart.

1.1.1 Algorithm/pseudocode

The term algorithm is very popular in the computer literature. An algorithm is also called pseudocode.
At first, it might sound very complex. However, it is very simple to understand. In fact, we all perform
hundreds of algorithms in our daily life without even realizing it!
Algorithm is the step-by-step method of performing any task. When we break up a big task into
smaller steps, what we actually do is to create an algorithm. In other words, we perform hundreds of
algorithms. Brushing teeth, making tea, getting ready for school or office, are all different algorithms.
For example, when making a cup of tea, we follow the algorithm as shown in Fig. 1.1 (with a few
variations, of course!).
An interesting observation: Many steps can be further sub-divided into still smaller sub-steps. For
example, we can write an algorithm for Step 1 (Boil water) by writing detailed steps for boiling water.
However, it is up to an individual as to how detailed steps one should describe. Each step can be called
as an instruction. Also, we can notice that steps 4 and 5 can be executed in parallel, i.e. we can boil
milk while we wait. In actual life, there is a tremendous amount of parallelism in many of our actions.
We normally hear, see and feel simultaneously to comprehend a situation. Within this also, when we see
1.4 C Programming and Data Structures
a picture, for example, actually we see millions of spots of the picture to generate an image on our retina
while we compare all dots in parallel with already stored millions of images to identify an object instan-
taneously! Therefore, parallel computing was developed to speed up things and ultimately try to
imitate human actions in artificial intelligence. We need not discuss these in detail in later chapters,
but continue with serial algorithms for now.
Begin
1. Boil water.
2. Put tea powder in the kettle.
3. Pour boiled water in the kettle.
4. Wait for three minutes.
5. Boil milk.
6. Put boiled milk in a cup.
7. Add sugar to the cup.
8. Empty the kettle in the cup.
9. Stir the cup with a spoon.
End

Fig. 1.1 Algorithm for making tea

1.1.2 Flow Chart

There is another way to write the steps involved in any process. This is by making use of various
symbols. The symbols form a diagram that represents the steps in a pictorial fashion similar to an
algorithm. This is also very easy to understand. Such a diagram is called flow chart. In its simplest
form, a flow chart consists of a series of rectangles connected to each other by arrows. The rectangles
represent the various steps and the arrows designate the flow. A flow chart for our tea-making example
could be drawn as in Fig. 1.2.

Fig. 1.2 Flow chart for making tea

 Algorithms 1.5
As can be seen, these are very primary concepts that we learn since childhood. We learn to make tea
by observing someone making tea: just like any other activity. Thus, the algorithm for making tea was
recorded in our brain long back somewhere deep—in our memory. There is another part of our memory
which stores the details of our current activity or thoughts. Whenever we want to make tea, somehow
this algorithm is brought back from our deep memory into the current memory (i.e. it is ‘remembered’)
and then it is actually executed. This concept of storing something in memory, retrieving it back in the
current memory (i.e. ‘remembering’ it) whenever needed and actually performing a task is very primi-
tive, yet extremely important, as we shall see, due to its similarity with computers.

1.2 THREE BASIC OPERATIONS

The tea-making algorithm and flow chart discussed earlier were quite simple. One step followed another
in a sequential fashion. However, things are not so simple in real life! There are so many ifs and buts.
For example, consider the following statements:
∑ If it is 9 am, I must go to the office.
∑ If it is raining, take your umbrella with you.
∑ Read each line and say it loudly until the end of this page.
How do we take care of such things in an algorithm and a flow chart? And how many different kinds
of situations we must cater to? This section attempts to answer these questions.
In general, the steps in an algorithm can be divided in three basic categories as listed below:
∑ Sequence—A series of steps that we perform one after the other
∑ Selection—Making a choice from multiple available options
∑ Iteration—Performing repetitive tasks
These three basic categories of activities combined in different ways can form the basis for describ-
ing any algorithm. It might sound surprising initially. But it is true. Think of any situation in our daily
life and try to fit it in one of the three categories: it works!
Let us now look at each of the categories in more detail.

1.2.1 Sequence

A sequence is a series of steps that we follow in any algorithm without any break, i.e. unconditionally.
The algorithm for making tea described in Fig. 1.1 belongs to this category. Figure 1.3 describes another
algorithm in this category for ‘boiling water’. What this means is that we have exploded further the step
or instruction 1 in the algorithm for making tea given in Fig. 1.1. We can explode all such steps in Fig.
1.1 in the following way.
Begin
1. Take a utensil.
2. Take the utensil to the water tap.
3. Open the tap.
4. Fill the utensil with water.
5. Close the tap.
6. Put the utensil on the gas or in the oven.
7. Start the gas or the oven.
8. Wait until the water boils.
9. Switch off the gas or the oven.
End

Fig. 1.3 Algorithm for boiling water

1.6 C Programming and Data Structures

We will not draw the flow chart for boiling water. It should be clear by now that it is a matter of
writing all of the above 9 steps in rectangles one after the other; each connected to its successor by an
arrow.

1.2.2 Selection

We will quickly realize that only ‘sequence’ is not good enough to express an algorithm. Quite a few of
our actions depend on certain events. Thus, there is a need to be able to make a choice from many
available options. Therefore, there is a process of selection. A selection statement generally takes the
form as shown in Fig. 1.4.
1. If
2. Then
3. End-if

Fig. 1.4 Selection

We take so many decisions, small and big, in our daily life without even realizing it. For example, if
it is hot, we switch on the fan. We can depict this selection process as shown in Fig. 1.5.
1. If it is hot
2. Then switch on the fan
3. End-if

Fig. 1.5 Example of a selection

Note that End-if is an additional step that indicates the end of the selection process. A question may
be asked: is End-if really necessary? Let us illustrate this by the following selection process that does
not have an End-if. Refer to Fig. 1.6.
1. If the guest wants tea
2. Then make tea
3. Offer biscuits

Fig. 1.6 Importance of End-if

What do we do if the guest does not want tea? Do we offer him biscuits? It is not clear from the
selection process described above. It can be argued and proved either way. That is, we are not sure
whether the Offer biscuits portion is a part of our If condition or not. A miserly person would always say
that he considers Offer biscuits as a part of the condition, and hence would only offer biscuits to some-
one who wants tea! Hence, it is always better to end a selection process with an End-if to avoid any
confusion at least for our algorithms. Different computer programming languages have different con-
ventions.
The position and placement of End-if instructions can change the meaning of the entire algorithm as
shown in Fig. 1.7 (a) and 1.7 (b). Let us study the algorithm shown in Fig. 1.7 (a). If the guest wants tea,
the algorithm will execute step 2 after step 1 (i.e. make tea), then fall through step 3 and then step 4 (i.e.
offer biscuits). Thus, if the guest wants tea, he gets the biscuits, too! Now, let us trace the algorithm if
the guest does not want tea. In this case, the algorithm will follow step 3 after step 1 (i.e. skip the tea)
and then fall through step 4 (i.e. offer biscuits). Thus, biscuits will be offered regardless of tea. If we
study algorithm shown in Fig. 1.7 (b), we will notice that biscuits are offered only with tea. If the guest
 Algorithms 1.7
does not want tea, the algorithm will follow step 1 and directly step 4. The semicolon at the end of step
2 indicates that tea and biscuits are offered together. You will notice that the positioning of End-if
(at step 3 or 4) has made all the difference! The Figs 1.8 (a) and 1.8 (b) show the corresponding flow
charts.
Begin Begin
1. If the guest wants tea 1. If the guest wants tea
2. Then make tea 2. Then make tea;
3. End-if 3. offer biscuits
4. Offer biscuits 4. End-if
End End

Fig. 1.7(a) Offer biscuits to all guests Fig. 1.7(b) Offer biscuits only to guests who
want tea

Guest Yes Guest Yes

wants Make wants Make
tea? tea tea? tea

No No Offer biscuits

Offer biscuits

Fig. 1.8(a) Fig. 1.8(b)

In both of these cases (a and b), we have not specified the action if the guest wants coffee. Let us
modify our algorithm and also the flow chart to accommodate that possibility. Note that we are offering
coffee as an alternative to tea. We will be generous enough to offer biscuits in either case. Since we want
to offer the biscuits irrespective of the acceptance/rejection of tea/coffee offer, we should consider only
the first algorithm for modification, viz. Fig. 1.7(a). The modified algorithm and its corresponding flow
chart are shown in Figs 1.9 and 1.10 respectively.
Begin
1. If the guest wants tea
2. Then make tea
3. End-if
4. If the guest wants coffee
5. Then make coffee
6. End-if
7. Offer biscuits
End

Fig. 1.9 Algorithm for offering tea/coffee and biscuits

1.8 C Programming and Data Structures

Guest Yes
wants Make
tea? tea

No

Yes
Guest Make
wants Coffee
Coffee?

No

Offer biscuits

Fig. 1.10 Flow chart for offering tea/coffee and biscuits

Note that we offer biscuits regardless of the acceptance of the tea/coffee offer. That is exactly what
we had wanted. Consider the following algorithm as shown in Fig. 1.11(a). Figure 1.11(b) shows the
corresponding flow chart.

Begin
1. If the guest wants tea
2. Then make tea
3. Offer biscuits
Offer
4. End-if
Guest Yes
5. If the guest wants coffee
coffee Make
wants
6. Then make coffee
coffee tea
tea?
7. Offer biscuits
Offer
8. End-if
End Offer biscuits
No
(a) Algorithm

Guest Yes
wants Make
coffee? coffee

No Offer biscuits

(b) Flow chart

Fig. 1.11 Offering biscuits only if guest wants tea /coffee

 Algorithms 1.9
Can it achieve the same objective as the algorithm shown in Fig. 1.9? A close examination will reveal
that it is not the same. For instance, if the guest rejects both tea and coffee, the algorithm shown in
Fig. 1.9 offers the guest biscuits regardless. However, the algorithm shown in Fig. 1.11(a) does not offer
anything! How easily things that seem similar can mislead us, as they actually are different. These are
the things that one needs to be careful of while writing an algorithm. Otherwise, it leads to the program-
ming errors called as bugs, which programmers refer to, all the time.
We will notice some problem in the algorithm and flow charts depicted in Figs 1.9–1.11. After a
guest chooses to have tea, the algorithm still asks if the guest wants coffee. Unless a guest wants both
simultaneously, this is completely wasteful. We can avoid this by introducing a goto instruction. Using
this, we can rewrite the algorithm of Fig. 1.9 as shown in Figs 1.12 (a) and 1.12 (b).

Begin
1. If the guest wants tea
2. Then make tea
3. Goto LAST
4. End-if
5. If the guest wants coffee
coffee Guest Yes
wants Make
6. Then make coffeecoffee tea
7. End-if tea?
8. LAST:
LAST: OfOffer
fer Biscuits
End

(a) Algorithm No

Guest Yes
Make
wants
coffee
coffee?

No

Offer biscuits

(b) Flow chart

Fig. 1.12 Improved algorithm to avoid unnecessary step

In this algorithm, LAST is called label for an instruction. Offer biscuits (step 8). This allows the goto
instruction to branch to a specific instruction. However, the goto makes a program difficult to understand and
therefore, modify. So, generally, gotos are avoided. If you avoid such a goto in a program, you can read the
program starting at the top and ending at the bottom without branching up or down. This is called as goto-less
or top-down or structured programming method. Such programs are easy to understand and therefore, easy
to maintain. We will see how the same algorithm can be written in a structured fashion later.

1.2.2.1 The compound conditions

It is very easy to group different conditions into one. We generally use words like and and/or or to join
sentences. In the same way, we can combine two or more conditions into a single compound condition.
For example, take a look at the algorithm shown in Fig. 1.13.
1.10 C Programming and Data Structures

Fig. 1.13 Compound conditions with and

In this algorithm, you are doing two things together, viz. taking breakfast and going to work. However,
you perform these only if all the three conditions are met, viz. it has to be a weekday, it has to be at least 7
am and you have to be feeling good. If any of these is not valid, you will not perform both of these actions.
For instance, if it is 7 am, and you are feeling ok, but if it is a weekend, you will not perform both the
actions. But then if you take the algorithm very seriously in real life, you will notice a bug. You will not go
to work on a weekend all right, but you will also have to skip your breakfast! So, be careful!
Similarly, the algorithm in Fig. 1.14 illustrates the use of or word to join two or more conditions.
(Note that we are now assuming implicit Begin and End statements for our algorithms.)

Fig. 1.14 Compound conditions with or

In this case, even if any of the conditions is met, you have breakfast and go to work. For instance, if
your boss is angry, then even if it is a holiday and there is actually no pending work, you will still
perform these two actions. Only if all the three conditions are not met, you skip having breakfast and
going to work.

1.2.2.2 The nested conditions

Sometimes, things are not very easy to express. With a variety of situations to worry about, it becomes
really complicated. For example, if something depends on still something else to happen (or otherwise),
there will be an if within another if. We will call it a nested condition. Let us look at an example.

Fig. 1.15 Nested conditions

You will notice that there is an If at the beginning (step 1) and corresponding End-if at the bottom
(step 9), which denotes the end of that If condition. Within this, you will notice another If and End-if pair
 Algorithms 1.11
written in the same columns (steps 4 and 8). The Else provides an alternative path of execution. Let us
trace the algorithm if you are ok. In this case, the algorithm executes step 2, skips steps 3 through 8 and
goes directly to step 9. If you are not ok but you do not have fever, the algorithm goes through steps 1, 3,
4, 6, 7, 8 and 9. You will not go to work and you will just relax, but you will not consult a doctor even
if you have stomach pain. This is a bug!
If you are not ok and if you have fever, you will go through steps 1, 3, 4, 5, 8 and 9. In this case, you
will not go to work, you will not consult the doctor, but you will not relax. So, there is another bug. Try
removing it!
Let us rewrite the first algorithm of Fig. 1.6 using nested conditions. This will make the benefit of
else clearer.

Fig. 1.16 The ‘tea-coffee’ algorithm using nested conditions

As can be seen, if the guest accepts the offer for tea, we would simply make tea and offer biscuits
without bothering if he wants coffee (unless the guest wants both!). This does not happen in Fig. 1.6. It
might not make a big difference if we have just one or two conditions to check. However, as the number
of conditions increases, it is desired that the algorithm be as compact and efficient as possible.
As a further illustration, let us write an algorithm to find the largest of any three given numbers. It is
very easy to write an algorithm to find the larger of two numbers. Assuming that the two numbers are
a and b, we simply need to compare the two. However, when there are three numbers, things are a bit
complicated. The algorithm is as shown in Fig. 1.17.
1. If a > b
2. Then If a > c
3. Then choose a
4. Else choose c
5. End-if
6. Else If b > c
7. Then choose b
8. Else choose c
9. End-if
10. End-if

Fig. 1.17 Selecting the largest of three numbers

To ascertain that the algorithm indeed works as expected, we might assign values as 15, 2 and 21 to
a, b and c respectively. When we imagine these numbers in place of a, b and c in the above algorithm and
check if the algorithm works correctly, it is called as a pencil run of our algorithm. It is also termed as
a walkthrough of an algorithm. It is always a good practice to do a walkthrough of an algorithm with a
variety of values. That is, we should take a, b and c such that once a is the greatest of them all (e.g. a =
7, b = 2 and c = 1), then b (e.g. a = 13, b = 20, c = 10) and then c (e.g. a = 18, b = 24, c = 49). This will
make sure that our algorithm gives the correct result in each case. When we are doing a walkthrough of
our algorithm in this fashion, we are actually checking if it works fine.
Other documents randomly have
different content
Maar de vrouw zegde zoo: Ma Nsombi verborg mij.

De opperhoofden zegden zoo: Wel, Ma Mpingia, nu dat gij uwe

vrouw ziet, doe een andermans dag opklaren.

Maar Ma Mpingia, alzoo: Doodt eerst Ma Nsombi, dan zal ik den dag
doen opklaren.

Wanneer zij Ma Nsombi gedood hadden, nam hij zijne vrouw, en hij
zegde, alzoo: Leert wel uwe dochter; als zij een anderen jongeling
ziet, dat zij er niet mede koute. Indien ik stierf van droefheid, zoudt
gij niet berispt worden en niet moeten betalen?

De moeder die ’t meisje bezat, kwam naderbij en zegde zoo: Ziet gij,
te veel jeugdige streken, Mama, hebt gij getoond; uwe broeders zijn
van den honger gestorven, omdat Ma Mpingia ’t weder heeft duister
gemaakt. ’t Is al nacht, twee jaren lang. Wandelen, wij wandelen
niet. Vandaag zweer het ons, maak geen vriendschap meer met
jongelieden; ken uwen man, die u geld zal geven.

De moeder van het kind deed eene geit slachten, deelde ze uit aan
de opperhoofden, die de zaak van Ma Mpingia geregeld hadden.

Dan deed Ma Mpingia ’t weder weer opklaren.

Ware ’t niet geweest, dat de opperhoofden van de streek naar Ma

Nsombi gezocht hadden, dan zou de dag nu nog niet klaar geworden
zijn.

He, jongeling, en jonge dochter, zweert den eed, gaat niet meer
langs die wegen, die slecht zijn. Wat God gebonden heeft, maakt het
niet los.

Kindingi. [90]
 Mpingia = kleinste muis van Kongo. ↑
1
Ngoni = schoone muis, waarop de zwarten verlekkerd zijn. ↑
2
Ma is een eeretitel. ↑
3
Een soort van antilope. ↑
4
Als men een tooverbeeld in een dorp begraaft, dan grijpen er alle
5
soorten van rampen plaats. Zoo denken de negers. ↑
Dat is zeker een herinnering aan een lang geleden zonsverduistering. Dat
6 natuurverschijnsel moet immers fel op den geest der negers gewerkt hebben. ↑

[Inhoud]
 Nkumina

Eene vrouw ging hout rapen. Toen zij ging, zag zij de kleinen van
eenen Luipaard in ’t hol van eenen boom. Zij nam er eenen, en zij
kwam in ’t dorp. Toen zij hem voorbereid had, at zij hem op. Op een
anderen dag ging zij terug, en zij nam de twee andere kinderen van
den Luipaard. Maar toen zij op den weg was, kwam de Luipaard aan.

Hij, alzoo: Wat voor zaken liggen daar in uw korf?

Zij, alzoo: Vader, mijn maniok ligt daarin.

En hij, alzoo: Zet uwen korf op den grond neer.

En zij legde den korf neer en de Luipaard, toen hij keek, zag zijn
twee kinderen: He, he! Moeder, ik verscheur u. Ik vat u. Wat! Gij,
mijne kinderen zijt gij komen stelen!

En zij, alzoo: Vader, laat mij gaan, ik ben zwanger. Wanneer ik

gebaard heb, indien het een meisje is, ’t is uwe vrouw; indien het
een jongen is, uw naam draagt hij.

De tijd vervloog, de vrouw had gebaard. ’t Was een meisje. De

Luipaard, toen hij ’t nieuws hoorde, alzoo: Uwe schoonmoeder heeft
gebaard, ’t is een meisje.

En hij kocht vleesch en parels, en drie kruiken palmwijn.

En hij kwam tot bij de vrouw, en hij schonk haar den [91]palmwijn
uit, alzoo: Gij, gij hebt het mij beloofd; om mijne vrouw ben ik
gekomen.
En zij dronk den palmwijn; toen hij uit was, alzoo: Vader, wel, blijf
daar staan in den omtrek, ik zal ’t meisje naar ’t water sturen.

De Luipaard ging zich verbergen. Zij, de moeder, zij riep haar kind,
alzoo: Nkumin’e! Nkumin’e!

Zij, alzoo: Hier ben ik.

Zij, de moeder, alzoo: Kom hier, moeder, ga water scheppen.

Zij nam twee kruiken op, zij legde ze in haar korf. En zij ging naar ’t
water, en zij schepte; de kruik legde zij in ’t hooge gras. Zij schepte
weer water met de andere kruik. Toen de kruik vol was, legde zij ze
in haren korf. Zij wilde vertrekken, maar de Luipaard had haar gevat.

In ’t dorp waar vader en moeder waren, had men den weduwestaat

van hun verloren kind begonnen.

Nkumina waar zij gegaan was, op zekeren dag, zegde zij tot den
Luipaard, alzoo: Mijn maniok, die in mijn dorp gebleven is, ga ik in ’t
water leggen.

Hij, de Luipaard, alzoo: Ik ga u bewaken.

Zij, alzoo: Wel, gij, oude grijsaard, gij zijt oud, ik zou u moeten
dragen tot aan ’t maniokland. Gij, ga wild jagen.

Nkumina, toen zij afkwam, hadden de vrouwen, die in ’t dorp

gebleven waren, zich vereenigd, alzoo: Welaan, laat ons gaan, wij
doen onze aardnoten uit.

En zij gingen naar ’t veld. Zij, toen zij kwam, bleef staan op den
kleigrond. En zij speelde den koker, alzoo: Ke, ke, ke! Zij, de moeien,
alzoo: Luistert, wie komt daar den koker spelen?
Zij, Nkumina hief een lied aan, alzoo: Ik ben gegaan, [92]ik de arme
Nkumina. Weet ge, mama heeft mij opgeëten 1, en vader weet het
niet.

En zij zong dat lied, en zij kwam het zingen tot aan het water.

De Luipaard, waar hij gebleven was, had twee wilde geiten gevat en
twee egels ook. En hij kwam ze neerleggen, alzoo: Neem uw vleesch
aan, bereid het.

Toen zij het voorbereid had, zij aten het, ’t was klaar.

Zij, die op ’t veld waren, toen zij in ’t dorp kwamen waar de vader
was, alzoo: Uw kind komt weenen op den kleigrond, alzoo: Ik ben
gegaan, ik de arme Nkumina; weet gij, mama heeft mij opgeëten,
en vader weet het niet.

Hij, de vader, alzoo: ’t Is leugen, gij liegt.

Zij, alzoo: He, beste vader, ’t is geen leugen. Op een anderen dag,
kom, ga met ons mede, en gij zult het zelf hooren.

Zij, ’t meisje, waar zij was, dacht, alzoo: Vandaag ga ik naar ’t land,
ik ga de andere maniokwortels, die er nog overblijven, uittrekken.

En zij kwam, zij kwam dichtbij, en zij bleef daar staan.

Zij, de vrouwen kwamen ook om aardnoten uit te doen. Zij, toen zij
kwam en kwam en kwam, speelde weer den koker.

Een oude onder de vrouwen, sprak: He, gij, kinderen, houdt op met
tateren; hoort gij den koker niet?

En zij hief weer ’t lied aan: Ik ben gegaan, ik de arme Nkumina;

weet gij, mama heeft mij opgeëten en vader weet het niet.
En ’t lied weergalmde, en ’t werd droevig en droeviger, en zij
weende. [93]

Zij, de vrouwen, alzoo: Moeder, kom terug; kom uwe aardnoten

nemen.

Maar omdat zij vol schaamte was, dat zij uit haar dorp vertrokken
was met den Luipaard, durfde zij niet meer bij hen komen. En zij
ging en zij ging, zij kwam aan de rivier aan: Wacht, ik wasch mijn
aangezicht af.

De Luipaard, waar hij gebleven was, had drie reebokken gevat en

een antilope. Zij hakte ’t vleesch in stukken, zij maakte het gereed,
zij aten en ’t was klaar.

De vrouwen toen zij in ’t dorp kwamen, vertelden weer ’t nieuws,

alzoo: Gij, hoort gij, wij vertellen u ’t gebeurde, en gij, gij maakt u
slechts kwaad. Uw kind waarlijk is daar komen weenen op den
kleigrond. Wanneer wij u roepen, dat gij komet, gij wilt niet. Maar
vandaag, vooruit, neem uw kind terug.

En hij, hij nam zijn geweer, en zij gingen tot aan ’t aardnotenland.

Zij, de vrouwen, alzoo: Neem uwe aardnoten aan en eet. Misschien

zal zij niet rap komen, en uw hart zal honger lijden; dus neem uwe
aardnoten en misschien zal zij daarna afkomen.

Hij, alzoo: Neen, ik wil niet, ik eet geene aardnoten, want dat hart
van mijn kind is al lang verloren en verloren.

En zij toonden den kleigrond. En hij ging daar staan. En hij wachtte
en wachtte, zijn hart had honger. En hij kwam. En zij, Nkumina, zijn
kind, kwam hem daar vervangen. En men hoorde den koker, hij
sprak.
De vrouwen, alzoo: Luister, hoort gij den koker niet, die daar aan ’t
weergalmen is, waar gij stondt. Wel, gij, man, hebt gij geen
verstand?

Zij, ’t kind zong weer ’t lied, gelijk zij de andere dagen zong. [94]

Hij, de vader viel op den grond, en aan ’t kruipen en ’t kruipen tot

dicht bij haar. Maar zij, toen zij ’t zag, zij ging heen. En hij de vader
aan ’t volgen en volgen; ’t kind aan ’t gaan en de vader aan ’t
volgen. Toen zij gingen en gingen, toen zij ver weg waren, zij
Nkumina begon te loopen. De zon was ondergegaan, en de avond
begon te vallen.

Zij, die in ’t dorp gebleven waren, spraken, alzoo: Onze oude is

verloren, van dezen morgend vroeg is hij weggegaan. Waar hij
gegaan is, misschien heeft men hem gedood.

Maar hij, hij vervolgde het kind, waar het ging. Toen hij haar
inhaalde, toen hij haar naderde en naderde, hij legde zijn geweer
aan waar zijn kind was, alzoo: Vermits gij wegvlucht, zijt gij dood.

’t Kind bleef dan staan en ’t kwam geloopen naar zijn vader en ’t viel
in zijn armen, alzoo: Zij, de moeder, toen ik nog niet geboren was,
ging de drie kleinen van den Luipaard stelen, maar de Luipaard wilde
haar verscheuren. Zij, de moeder, alzoo: Laat mij los, ik ben
zwanger, ik zal baren. Indien het een meisje is, ’t is uwe vrouw;
indien het een jongen is, hij draagt uwen naam.

En de Luipaard ging heen. De moeder, toen zij mij gebaard had, de

Luipaard vernam ’t nieuws en hij sprak alzoo: Mijn schoonmoeder
heeft gebaard.

En hij kocht vleesch en palmwijn, en hij kwam, en hij kwam den

palmwijn uitschenken aan de moeder, alzoo: Gij hebt het mij
beloofd, indien gij een meisje baart, ’t is mijne vrouw. Indien het
een jongen is, mijn naam draagt hij.

De moeder, toen zij den palmwijn gedronken had, zegde aan den
Luipaard, alzoo: Wel, ga, verberg u.

En zij riep mij, alzoo: Vat de kruik, ga water putten, kindlief! [95]

Ik antwoordde, alzoo: Ik wil niet!

En zij, alzoo: Wel, ga, mijn kind, o moeder van smarten.

Ik, toen ik dit hoorde, ik kon niet weerstaan, en ik ging, ik putte

water. Een kruik was vol, ik legde haar in ’t hooge gras. Ik putte een
andere vol water, ik legde haar in den korf, ik wilde weggaan; maar
ik voelde iets op mijn armen, alzoo: Vo 2. ’t Was de Luipaard. Hij nam
mij mede, en ik vroeg hem, alzoo: Wel, gij, waar leidt gij mij henen?

Hij, alzoo: Uwe moeder heeft u verkocht.

En wij gingen tot in zijn dorp. En ik verbleef daar, maar ik dacht

verstand uit, alzoo: He, Luipaard, beste vader, den maniok, dien ik
geplant heb in mijn dorp, ga ik uitdoen. Hij, alzoo: Vooruit, ik ga
mede. Maar ik, ik hield hem tegen, alzoo: Blijf, gij, hier. En ik kwam
maniok uitdoen, en ik kwam mijne moeien hier tegen. Zij riepen mij;
maar ik kwam niet, omdat de schaamte mij gevat had.

De Vader was verheugd en verheugd, omdat hij zijn kind had

teruggevonden. En zij kwamen en kwamen tot in hun dorp.

Toen zij in de nabijheid van hun dorp kwamen, riep de vader. En ’t

heele dorp kwam af, om ’t opperhoofd met vreugde te ontvangen.
En zij zagen hem met zijn kind. En zij omringden hem, en zij
vroegen hem uit, alzoo: Nkumina, waar is zij geweest?
En alzoo kwamen zij tot in ’t dorp.

Maar de avond viel, en zij sliepen. Den volgenden dag ’s morgens,

deed de vader het nieuws verspreiden, en de trommels kwamen af,
en men hield groot feest; ’t feest weergalmde en weergalmde, en
men danste de glorie van [96]Nkumina; en men danste en danste wel
eene maand lang, want ’t kind, dat al zoolang verloren was, was
vandaag teruggevonden.

Kimoa. [97]

Opgeëten = verkocht. Als men een kind verkoopt, wordt ’t geld opgeëten. ↑
1
Het voelen van een greep. ↑
2

[Inhoud]
 Nkenge’s Vlucht

Eene vrouw, haar naam was Lutama, was in een dorp met hare
zuster Ntumba. Deze was de jongste.

Op zekeren dag gingen zij wandelen en zij kwamen aan ’t water.

Daar kwamen zij een jongeling tegen, die hun vroeg, alzoo: Uw
echtgenoot, wie is hij?

Zij, alzoo: Wij, wij hebben geen echtgenoot.

De Boa, alzoo: Trouwt mij, den Boa-ndongo; ik sterf in ’t droog

seizoen, ik verrijs in ’t begin van ’t regenseizoen 1.

Dan kwamen zij overeen, alzoo: Kom naar ons dorp en vraag het
aan onze moeder.

Hij kwam het vragen aan hunne moeder, alzoo: Gij, moeder, uwe
kinderen hebben geen echtgenoot.

Zij, de moeder, alzoo: Ja, ’t is waar; zij hebben geen echtgenoot.

Wel, ik wil haar trouwen.

De moeder, alzoo: ’t Is goed.

Zij dronken palmwijn, hij betaalde ’t geld van ’t huwelijk: drie

stukken van vijf frank en twee frank en half.

Zij namen ’t geld aan, en zij stelden eenen dag, waarop [98]de
vrouwen met den Boa zouden gaan. De Konso 2 was voorbij, met den
volgenden zouden zij vertrekken.
Zij, zij wisten niet dat de Boa een mensch was geworden.

Dan nam hij zijne vrouwen en zij gingen.

Toen zij gingen, kwamen zij in ’t dorp van den Boa aan. Wel twee
jaar vervlogen er. Maar hij, de Boa stierf.

Toen hij gestorven was, toen zij sliepen ’s nachts, kwam hij spreken,
alzoo: Kitzakala, kitzakala 3. Eet ik Nkenge de oudste ofwel Nkenge
de jongste?

Zoo sprak hij alle dagen, toen hij kwam spreken in den nacht.

Den volgenden dag ’s morgens vroeg, trokken zij op, alzoo: Vooruit
naar ons dorp van waar wij gekomen zijn.

Als zij op den weg waren, was Lutama’s draagband in de hut

gebleven.

Ntumba ging terug. De Padden en de Serpenten waren vereenigd in

’t huis om den Boa te beweenen. Terwijl zij weenden en weenden,
nam Ntumba den draagband en kwam terug.

Lutama had alzoo tot Ntumba gezegd: Als gij komt op den weg, daar
waar een lijn 4 is, volg dien niet; kom langs dien weg, waar geen lijn
is.

Een geest, die aan ’t water was, om zijne wonde te wasschen, toen
hij hoorde hoe die mensch daar gesproken had, veegde de lijn uit en
maakte er een, waar Lutama ging. [99]

Ntumba, toen zij afkwam, toen zij de lijn zag; in den weg waar de
lijn was, ging zij niet. Zij, toen zij den weg zonder lijn zag, alzoo: In
dezen weg is zij gegaan.
Zij ging er in. En zij kwam tot aan den doorgang der rivier. De geest
was bezig zijne wonde te wasschen. Zij Ntumba vroeg, alzoo: Mijn
oudste, is zij langs hier gegaan?

Hij, de geest, hij bedroog haar, alzoo: Kom, ik zal u overzetten.

En hij kwam, hij droeg haar en hij zette haar over aan den anderen
kant der rivier, alzoo: Wacht hier, dat ik mijne wonde wassche.

Toen hij zijne wonde had gewasschen, toen het gedaan was, alzoo:
Vooruit nu, langs hier, Mama.

Ntumba Ma Luseke begon haar weesdom en begon te weenen. Zij

kwamen in een dorp, aan een oud ingevallen huis, dat daar zoo
eenzaam alleen stond. Hij was immers alleen, de geest met zijne
twee kinderen.

Hij, de geest, toonde haar haar slaapkamer, alzoo: Slaap daar. Waar
mijne kinderen zijn, slaap daar niet, omdat gij met uw lichaam, dat
slecht is, mijne kinderen zoudt besmetten.

Hij toonde honderd zaken aan Ntumba, alzoo: He, Mama, als ik ga
wandelen, daar is uw eten, eet dat. Het eten van mijn kinderen, eet
dat niet.

Hij toonde nog zijne koophandeldoos 5 aan Ntumba, alzoo: Ik, ik drijf
koophandel op al de markten. Als gij niet ziet, Mama, wat gij eet,
daar zijn maniokvelden, ga en trek maniok uit en bereid uwen
maniok. Als gij maniok voorbereidt, dien van mijne kinderen, leg
hem afzonderlijk; dien van u, leg hem ook afzonderlijk.

Toen de zon opgestaan was, trok hij naar de markt; al [100]de

markten die hij wilde, was het een Nkenge of een Nsona 6.

Zijne kinderen, waar zij bleven, beschimpten Ntumba.

Zij, toen zij dat hoorde, begon te weenen, en zij weende en weende.

Toen nam zij de koophandeldoos en zij trok op, langs den weg naar
haar dorp van waar zij gekomen was, waar haar moeder en vader en
broeders waren. En zij ging en ging en zij kwam aan den doorgang
der rivier. Zij zegde, alzoo: He, Vader Nzonzi 7, wel, kom, kom mij
overzetten aan den anderen kant der rivier.

Maar vluchten, hij vluchtte.

Toen zag zij Vader Nkaki 7, alzoo: Kom, zet mij over.

Maar vluchten, hij vluchtte.

Toen zag zij Vader Nkonkoto 7, alzoo: Kom, draag mij over.

Maar vluchten, hij vluchtte, hij droeg haar niet over.

Zij ging rivierafwaarts, en zij zag Vader Kikkervisch; maar vluchten,

hij vluchtte.

Zij, alzoo: Over ’t water, wie zal mij overzetten?

Toen zij rivieropwaarts keek, kwam er een Blad aan. En zij riep.

Het Blad bleef stil. Zij zegde zoo: He, Blad, zet mij over; he, schoon
Blad, zet mij over.

Het Blad ging met haar tot op den oever, en zij was er over.

En zij ging en ging. [101]

De geest, waar hij was, ’t bloed bruischte hem op 8. Hij werd met
schrik bevangen. En hij ging terug naar zijn dorp, waar zijne
kinderen waren, omdat hij overal waar hij ging, zijn bloed aan ’t
bruischen en bruischen was.
En hij kwam en hij zag Ntumba niet. Hij vroeg, alzoo: Ntumba, waar
is zij?

De kinderen, alzoo: Ntumba, waar wij waren, zij had maniok

voorbereid, zij kwam ons maar een klein stuksken maniok geven; wij
vroegen haar: ’t Is het uwe niet, Mama. Bezit gij het?

Ntumba, toen zij dat hoorde, begon te weenen en te weenen. Toen

zij weende, nam zij de koophandeldoos en zij is opgetrokken, den
weg naar de rivier.

De geest, toen hij dat hoorde, ging haar volgen. En hij kwam aan de
rivier. Toen hij ’t Blad zag, riep hij het en vroeg, alzoo: Ntumba, waar
is zij gegaan?

Het Blad, alzoo: Ntumba is langs hier gegaan met de

koophandeldoos.

Hij, alzoo: Zet mij over, dat ik haar volge.

Toen ’t Blad hem had overgezet, volgde hij haar. En hij ging en ging
en ging. Ntumba was ver vooruit. Toen hij in een dorp aankwam,
vroeg hij, alzoo: Langs hier, gaat hier geen mensch?

Een mensch gaat langs hier, zij houdt iets in hare handen: zeker een
koophandeldoos; maar zij kan toch zoo schoon zingen. Toen zij hier
aan ’t dansen was, hebben wij haar twee slaven en twee geiten
gegeven.

Hij, alzoo: Dus vooruit, ik volg haar.

Toen hij verder aankwam, vroeg hij, alzoo: Langs hier gaat er geen
mensch?
Ja, een mensch gaat langs hier, haar naam is Ntumba, [102]maar zij
kan toch zoo wel dansen. Twee verkens hebben wij haar gegeven en
een geit.

Toen hij dit dorp verliet, alzoo: Mijn koophandeldoos heeft zij
gestolen, en aldus heeft zij al mijn geld en goed.

De geest volgde en volgde haar, hij zag haar niet. Hij had grooten
honger en om te eten, niets. Hij, alzoo: He, gij, jonge dochter, geef
mij mijn koophandeldoos terug, mijn liefste.

Maar Ntumba was heengegaan. Hij, aan ’t volgen en ’t volgen, aan ’t

weenen was hij en hij stierf onderweg.

Toen hij stierf, was Ntumba in haar dorp aangekomen bij Vader en
Moeder.

Makanga. [103]

Spreekwoord van den boa, volgens de negers.

1
Een boa verteert zijn eten in ’t droog seizoen. Dan gaat hij liggen in ’t hooge
gras, aan den boord der rivier. Met de eerste regens, gaat hij weer op zoek. ↑
Tweede dag van de kongoleesche week. ↑
2
Gerucht van den boa. ↑
3
Een karavaan negers zullen een teeken maken met hun draagstok in ’t
4 begin der wegen, die men niet mag volgen.
Degene die achteraan komen zullen alzoo weten, welke de goede weg is. ↑
In de koophandeldoos lag al zijn geld en goed. ↑
5
De namen van de kongoleesche week worden ook gegeven aan de markten.
6
—Als er een markt op den Nsona valt, dan wordt die markt Nsona
geheeten. ↑
Namen van kleine visschen. ↑ a b c
7
’t Is een teeken bij de negers, dat er iets voorgevallen is. ↑
8
 KOMISCHE VERHALEN

[105]

[Inhoud]
 De Zot met het Rolleken

Die echtgenoot was een echte zot.

Op zekeren dag, toen hij wilde naar de markt gaan, nam hij zijn
zaksken; hij zag niet of er een gat in was. Hij trok zoo op.

Hij kwam op de markt aan, hij kocht een rolleken darmen 1, stak het
in zijn zaksken, kwam terug.

Maar bij ’t terugkomen, ’t rolleken viel er uit.

Hij, aldus: Ik heb een rolleken gekocht, ik raap dit op; nu heb ik er
twee.

Maar in zijn zotheid, zag hij naar den zak niet. Zoo telde hij reeds
drie keeren. Toen hij nog een rolleken op den grond zag, zegde hij:
Ik heb er een gekocht, ik heb er reeds vier opgeraapt; nu zijn er vijf.

Toen hij in zijn dorp kwam, beval hij aan zijne vrouw den pot met
water op te zetten, om ’t vleesch te bereiden.

De vrouw zette den pot op ’t vuur; toen de pot aan ’t koken was,
vroeg zij ’t vleesch. De man schudde ’t vleesch uit en ’t rolleken was
vol kleiaarde.

En hij loog aan zijne vrouw, alzoo: ’t Vleesch is onder weg verloren.

Maar de vrouw, toen zij naar ’t vleesch keek, dat vol [106]kleiaarde
was, sprak, alzoo: Mijn man is nu gansch zot geworden.

Zij zag naar den zak, en toonde ’t gat aan haren man.
Hij, alzoo: De zak was niet sterk genoeg en ’t vleesch is er uit
gevallen.

Kisantu. [107]

Ingewanden van ’t verken of de geit. ↑

1

[Inhoud]
 De twee Broeders

Eene moeder had twee kinderen gebaard, Heer Zot, de oudste, Heer
Verstand-om-te-Tellen, de jongste. Zij beiden, toen zij groot
geworden waren, scheidden van malkander; de eene ging zijn dorp
bouwen; de andere ook zijn dorp.

Heer Verstand-om-te-Tellen, als hij zijn oudsten broer tegenkwam,

lachte zijnen oudste uit, alzoo: Gij, die Heer Zot zijt, gij hebt geen
geiten, gij hebt geen verkens; heden zijn ’t schatten van den
mensch. Geiten ik, verkens ik.

Alle dagen lachte hij zoo zijnen oudste uit.

Hij, Heer Verstand-om-te-Tellen, ging zijne echtgenoote trouwen. Op

zekeren dag ontving hij eene uitnoodiging van zijn schoonvader; hij
aarzelde niet. Hij spoedde zich, ging, vroeg: He, schoonvader, een
uitnoodiging heb ik gehoord, wat is ’t?

Zijn schoonvader antwoordde, alzoo: He, Vader, dit, waarom ik u

doen komen heb; maar als gij mijn geld zult nemen, koop mij een
verken; maar wanneer gij het verken koopt, koop noch zeug, koop
noch beer.

Zoo nam Heer Verstand-om-te-Tellen ’t geld aan; hij vertrok naar zijn
dorp. Hij ging naar de markt om het verken te koopen, dat zijn
schoonvader bevolen had. Maar hoe zijn schoonvader het hem
bevolen had: koop noch zeug, koop noch beer. [108]

Hij ging naar alle markten, hij zag slechts zeugen en beeren. Hij
werd een stuk vod 1 van zijn veel wandelen.
Dan dacht hij verstand. Hij vereenigde de ouden der menschen. Hij
vertelde hun, alzoo: Ziet, gij ouden, indien gij het kunt oplossen.
Schoonvader heeft mij bevolen, alzoo: Ga, koop mij een verken;
maar koop noch zeug noch beer. Welnu, gij, ouden, ik, hoe moet ik
doen?

De ouden ook dachten en dachten, toen zij zegden: Wij weten niet,
hoe gij moet doen.

Maar er was een oude, die hem vroeg: Gij, hebt gij geen ouderen
broer?

En hij zegde: Ja, ik ben met een ouderen broeder; maar ’t is een
zot.

Die oude zegde hem: He! Sta op, ga het hem vragen.

Heer Verstand-om-te-Tellen ging. Toen hij kwam aan ’t dorp van

Heer Zot, de kinderen van Heer Zot zagen hem, wijl zij vroegen: A!
Wie is ’t, die daar aankomt?

Hij antwoordde, alzoo: Ik, Heer Verstand-om-te-Tellen; ik tel den

hemel, ik tel de aarde. Terwijl gij, Heer Zot, gij hebt geen geiten, gij
hebt geen verkens, heden zijn ’t de schatten van den mensch.
Geiten ik, verkens ik.

Hij kwam ’t dorp van Heer Zot binnen. Heer Zot was bezig zijn
banaanplanten aan ’t hakken. Heer Verstand-om-te-Tellen kwam op
het plein, vroeg aan de kinderen: He, uw vader, waar is hij?

De kinderen antwoordden: Vader is daar zijne banaanplanten aan ’t

hakken.

Hij beval hem te verwittigen, dat hij kome. Zij gingen Heer Zot
roepen; hij kwam. Zij groetten malkander bij handgeklap. Heer
Verstand-om-te-Tellen bracht Palmwijn te voorschijn, gaf een goeden
dag aan zijn oudere, terwijl [109]hij sprak: Dit kruiksken, u heb ik het
medegebracht, iets ben ik komen vragen.

Heer Zot weigerde niet, zij dronken den palmwijn.

Heer Verstand-om-te-Tellen zegde ’t geen hij kwam vragen, alzoo:

Ziehier waarom ik gekomen ben. Schoonvader heeft mij bevolen,
alzoo: Kom, neem geld, koop mij een verken. Maar als gij een
verken koopt, koop noch zeug, koop noch beer. De markten ging ik
af, om zulk een verken te zoeken. Verkens waren daar, zeugen en
beeren. Maar ’k zag ’t verken niet, dat ik koopen moest. Toen ik in
mijn dorp terugkwam, vereenigde al de ouden; ik legde deze zaak
uit, zij wisten niet. Maar er was een oude, toen hij mij vroeg: Gij,
hebt gij geen ouderen broer, sta op, ga het hem vragen. ’t Is daarom
dat ik gekomen ben. Hoe moet ik doen?

Hij, Heer Zot, antwoordde hem: Breng mij een geit in ’t jaar
geboren, ’t eenigste jongsken van haar moeder en negen kruiken
palmwijn. Dan zal ik het u zeggen, hoe gij doet? Ik ben een zot, gij
lachte mij altijd uit, als wij malkander tegenkwamen. Ik, uw oudste
broer, heb medelijden met u. Ga, trek naar uw dorp terug.

Hij ging terug, hij zocht die geit en negen kruiken palmwijn.

Hij is gekomen. De kinderen vroegen hem weer: A! Wie komt daar

aan?

Hij sprak: Ik, de broer van Heer Zot.

Hij beval den ouden man 2, Heer Zot, te gaan zeggen, alzoo: Uw
broer is gekomen.

En hij kwam. Hij nam de geit en den palmwijn, toen hij zegde, alzoo:
Mijn broerken, ’t is niets, ik zal u wel toonen hoe gij zegt aan uw
schoonvader. Alzoo zal hij u niets [110]kunnen antwoorden. En ik, uw
oudste, ik heb medelijden met u. Dus, beveel iemand, dat hij naar
uw schoonvader ga, dat hij zegge, alzoo: Uw verken heb ik gekocht,
maar als gij komt, kom in den nacht niet, kom in den dag niet.

Zoo gezegd, zoo gedaan. Iemand vertrok naar schoonvader, die

zegde: Uw verken heeft hij gekocht, maar kom het halen; maar als
gij komt, kom in den nacht niet, kom in den dag niet.

De schoonvader werd bedroefd. Hoe kan ik gaan? Terwijl hij zegde:

Mijn schoonzoon heeft verstand.

En hij ging naar zijn schoonzoon in den dag, om daar vóór den
avond aan te komen. Hij was halfweg. De zon was ondergegaan en
de avond begon te vallen. Hij dacht, alzoo: Hij, heeft hij niet
bevolen: Kom in den dag niet, kom in den nacht niet. Hoe ga ik?

En hij trok terug naar zijn dorp. Hij zond iemand naar zijn
schoonzoon, alzoo: ’t Verken dat hij het opete, vader.

Kianika. [111]

Zijn kleederen (paan) versleten, hingen aan flarden. ↑

1
Eeretitel. ↑
2

[Inhoud]
 De Zot en het Tooverbeeld

In ’t dorp zijn er veel menschen; er is ook een lichtzinnige man, die

een schoone vrouw getrouwd heeft. Eindelijk werd zij zwanger en
baarde hem een meisje, maar slechts een meisje; een jongen, dat
konden zij niet.

Die vrouw ook was rijk, en zij zegde zoo: Gij, man, leg daar vijf
duizend mitakos; ik, de vrouw, ik leg er ook vijf duizend, ga ons een
klein jongsken koopen.

De man redetwistte met haar niet. Den dag van den Nsona ging hij
naar de markt. De man zegde tot de vrouw, alzoo: Maak
maniokbrooden gereed; de kleine, als hij komt, dat hij ete.

De vrouw antwoordde: Ja, ga maar!

En de man ging.

De vrouw, waar zij gebleven was, was maniok aan ’t stampen.

De man, toen hij op de markt gekomen was, zocht en zocht en hij

zag geen kleine. Hij ging zoeken in ’t omliggende van de markt, hij
zag niets; hij ging op een andere plaats, en hij zag een stuk hout,
dat men gesneden had gelijk een mensch, waaraan men den naam
gegeven had van Mimbumbu 1. [112]

Hij, toen hij dat zag, zijn bloed bruischte, en hij vroeg: Wie heeft
dien kleine daar gezet?

De man, die dat stuk hout daar gezet had, kwam te voorschijn, toen
hij zegde: Ik bezit hem!
Hij vroeg, alzoo: Verkoop hem mij!

De bezitter van dien kleine stelde hem den prijs: Twintig duizend
mitakos.

Maar hij vervolgde: Neen, ik wil niet. Neem er tien duizend aan.

’t Was aangenomen. De verkooper nam zijn geld aan. Toen hij zijn
geld genomen had, trok hij heel rap op naar zijn dorp! De man, in
zijn zotheid, hij, hij vroeg niets aan den kleine, dien hij gekocht had.
Hij kwam op de markt terug, hij kocht vleesch en maniokbrood; hij
kwam terug, hij sprak zijn kleine aan: Vooruit! Wij trekken op.

Maar de kleine antwoordde hem niet; hij, hij sprak niet; hij, hij uitte
niet een woord. Hij bleef zwijgen.

De zot droeg hem, en zij trokken op; zij kwamen aan een rivier, en
hij vroeg: Drinkt gij geen water?

De kleine, dien hij gekocht had, bleef zwijgen; hij zette hem neer op
den grond. Maar om neer te zitten, hij wist het niet; hij zette hem
recht, schepte water in een flesch, en gaf het hem. Hij, hij sprak
niet. Hij gaf hem te drinken, maar ’t water liep van zijn mond af.

Hij werd kwaad, toen hij zegde: Vooruit, jongen, maak u niet kwaad!
Waar gij gaat, zult gij niet eten? Uwe moeder heeft maniokbrooden
gereed gemaakt.

Maar de kleine, hij trok niet op.

Hij droeg hem, kwam thuis en ging hem binnenleiden in zijn

geheimkamer, legde hem neer op ’t bed, en kwam er uit; legde het
vleesch dat hij gekocht had op een teenen vlechtsel. Eindelijk kwam
zijn vrouw.
De vrouw vroeg hem: Wel! Hebt gij den kleine gekocht? [113]

De man antwoordde: Bereid eerst uw maniok, dan zal ik den kleine

halen. Indien gij geen eten voorbereidt, dan toon ik hem niet. Hij op
de markt, hij heeft niets geëten, en toen wij op den weg waren, at
hij ook niet. Veel schaamte is met hem. Misschien bij u, moeder, zal
hij eten. Hij met mij, hij is vol schaamte.

De vrouw stampte maniok; bereidde hem voor; ’t was klaar.

Zij doodden een kieken, bereidden het; ’t was gedaan.

De vrouw zegde, alzoo: Wel, ga hem halen, dat hij kome eten.

De man ging, maakte hem wakker: Sta op!

Maar hij, hij zegde niets.

De vrouw, alzoo: Draag hem, misschien is hij in slaap.

En hij droeg hem, en hij plaatste hem in de kamer, waar de vrouw

was. Om hem recht te zetten, hij kon niet recht.

De vrouw sloeg in hare handen: He moeder, man van een zot, gij
koopt een stuk hout; de gasten hebben u bedrogen, gij zijt een
tooverbeeld gaan koopen. De gasten hebben uw geld gestolen. He,
mijn man, wist gij dat niet? Binnen vier dagen, met den Nsona, ga
dat tooverbeeld terugdragen; neem ons geld terug.

Maar de man wilde niet.

Op zekeren dag in ’t dorp had een vrouw een geit verloren. Zij kwam
tot bij den zot, alzoo: Laat ons gaan, vader, mijn geit is verloren;
betoover dengene, die ze gestolen heeft!
En de zot, hij ging.

Toen hij betooverd had, hechtte het toovermiddel zich vast aan den
man, die de geit genomen had. [114]

De ouden, die hun kind bezaten, gingen onderzoeken, waarom het

ziek was. ’t Tooverbeeld werd gevonden; hun kind was ziek, omdat
het betooverd was door ’t tooverbeeld, dat men Mimbumbu noemt.

Zij gingen den man opzoeken, die dit tooverbeeld bezat. Zij vonden
hem en hij kwam. Hij vroeg twee palmnoten en een soort van kruid,
dat men dinsusu noemt. Hij bestreek hem; daarna vroeg hij een
kieken om het te dooden; zij vatten een kieken, hij sneed het in
stukken, en het bloed liet hij loopen op ’t tooverbeeld. Hij bereidde
het kieken, dat de zieke ete. De toovenaar beval dan: Als hij zijn
eten voorbereidt, de menschen, dat zij het niet zien. Bananen, dat
hij ze niet aanneme, noch aardnoten, noch hanen.

Maar de ouden kochten dat verbod van geen hanen te eten af, want
zij zegden: Veel wandelen wandelen wij op al de wegen. Misschien
zal men ons met hanen spijzen. Wie zou dan ander vleesch zoeken?

De toovenaar zegde dan: ’t Is wel, koopt dit verbod af. Zij gaven
hem negen mitakos. Dit verbod was nu afgekocht en daarmee
mocht hij hanen eten.

En de toovenaar ging heen.

Hij, de man, waar hij gebleven was, genas. De toovenaar vroeg:

Mijn kikumbi 2 is hij gezond?

Zij antwoordden: Hij is gezond!

De ouden, die hun kind bezaten, deden den toovenaar komen om

hun jongen van ’t tooverbeeld te verlossen, en om ’t verbod te
Welcome to Our Bookstore - The Ultimate Destination for Book Lovers
Are you passionate about books and eager to explore new worlds of
knowledge? At our website, we offer a vast collection of books that
cater to every interest and age group. From classic literature to
specialized publications, self-help books, and children’s stories, we
have it all! Each book is a gateway to new adventures, helping you
expand your knowledge and nourish your soul
Experience Convenient and Enjoyable Book Shopping Our website is more
than just an online bookstore—it’s a bridge connecting readers to the
timeless values of culture and wisdom. With a sleek and user-friendly
interface and a smart search system, you can find your favorite books
quickly and easily. Enjoy special promotions, fast home delivery, and
a seamless shopping experience that saves you time and enhances your
love for reading.
Let us accompany you on the journey of exploring knowledge and
personal growth!

ebookgate.com