HKOI 2004 Team Training

HKOI 2004 Team Training

Data Processing 1 &String Functions

(Intermediate Level)

Overview Introduction Data types String functions Data processing technique I

Introduction Data Processing means to process

some data with some “general” techniques. Sorting and searching Simple calculations Manipulating data in a particular way

In HKOI, we call it DaP to avoid collision between Dynamic Programming (DyP) or other DPs.

Introduction Unlike other topics going to taught

in HKOI, there is NO general method to solve a DaP problem.

That is, DaP is not an algorithm. We classify problems which ask

you to deal with some data in a quite straight forward approach as DaP problems.

Introduction DaP is the foundation of OI

programming. (or even computer?) Trains your ability to:

Analyse and solve problems Choose the best algorithm & data structure Write programs that implement your idea

Practice makes perfect. Practice writing DaP problems is important for you to write future OI programs efficiently.

Data Types It is important to select the best

data type for writing every program. Data range Time needed for each operation Memory usage

Data Types (Overview) Categories of data types

Ordinal types: integer, char, boolean, ... Real types: real, extended, comp, ... String Array Record Others like pointer, set, enum, object, ...

Pascal and C/C++ types are similar but may not be equivalent, so do the examples given in this notes.

Data Types (Pascal) Data types taught in the CE syllabus

integer : 16-bit signed integer [215,215-1] or [-32768,32767]

real : 48-bit real number ± 2.9e-39 – 1.7e38

char : 8-bit character boolean : 8-bit true or false string : 256-byte string

1 byte length and 255 bytes characters

Data Types (Pascal) Some more useful ordinal types

integer : 16-bit, signed [-215,215-1] or [-32768,32767]

byte : 8-bit, unsigned [0,28-1] or [0,255]

longint : 32-bit, signed [-231,231-1] or [-2147483648,2147483647]

shortint : 8-bit signed word : 16-bit unsigned

Data Types (Pascal) Some more useful real types

real : 48-bit / 6-byte real number ± 2.9e-39 – 1.7e38

double : 64-bit / 8-byte real number ± 5.0e-324 – 1.7e308

extended : 80-bit / 10-byte real number ± 3.4e-4932 – 1.1e4932

comp : 64-bit signed integer -9,223,372,036,854,775,808 (-263) –

9,223,372,036,854,775,807 (263-1)

Data Types (GCC IA32/x86) C/C++ types are compiler dependent. Examples of GCC IA32 ordinal types:

boolean bool (8-bit) byte char (8-bit) integer short / short int (16-bit) longint int / long / long int (32-bit) comp long long (64-bit)

long long is an ordinal type in GCC/G++. Add “signed / unsigned” before an ordinal

type to represent [-2n-1,2n-1-1] or [0,2n-1].

Data Types (GCC IA32/x86) Examples of GCC real types:

float : 32-bit / 4-byte real number ± 3.4e-38 – 3.4e38

double : 64-bit / 8-byte real number ± 1.7e-308 – 1.7e308 double is enough for most cases.

long double : 96-bit / 12-byte real number

Very precise! (Sorry, I can’t find the range.)

Data Types (How to choose?) Use ordinal types if possible.

More accurate Faster for most operations

Use most accurate real type if possible Rounding error is unavoidable More bits means less error accumulated

Use ordinal types to replace real types

Avoid errors, useful for money calculations Multiply the “real” number by 10, 100, ...

Data Types (How to choose?) Be careful of overflow

CHECK the extreme values when you read a question. Do some calculations yourself.

Hint: To avoid careless overflows, use 32-bit integer (longint/int) for most programs, unless memory usage is highly restricted.

Turbo Pascal programs Restricted memory usage in competitions

Personal observation: Real types are seldom used in NOI/IOI.

Data Types (Array) Useful for storing and processing data. Arrays and loops usually come

together to make programming easy. Arrays can be multi-dimentional.

var a : array[1..100000] of longint; var b : array[1..10,0..20,-10..10] of string;

This array occupies 1,128,960 bytes of memory.

C/C++ arrays must be 0-based. How can you represent a and b in C/C++?

Data Types (Record) A record is to bundle some information

together into 1 big memory segment.var r : record

i,j : integer;k : real;a : array[1..3] of string;end;

beginr.a[2] := 'Hello!';

end.------------------------------------------------struct RecName {

int i,j;double k;string a[3];

} r;int main() {

r.a[1] = "Hello!";return 0;

}

Data Types (Parallel Arrays) Apart from using records, we may

also use multiple arrays of different types. For the same index in these arrays, they represent different information of the same object.

name : array[1..50] of string; marks : array[1..50] of integer;

Similar C/C++ implementations are: char name[50][256]; int marks[50];

String String is implemented differently in

Pascal, C and C++ Pascal

1 byte length + 255 bytes array of characters. Total size is 256 bytes by default. If length is

specified, size is n+1 bytes. var s : string; { size = 256 bytes } var t : string[20]; { size = 21 bytes }

C Null-terminated array of characters. char s[256], t[21]; // 1 more bytes for '\0'

String C++

Provided by Standard Template Library (STL) An object with both data and functions. The memory storing the string itself is a vector

of characters. Vector is another advanced data structure

implemented using OOP code in STL! So forget it ... C++ string is a bit slower, but you may treat

C++ string as efficient as C string in terms of run time complexity.

You’ll know what is “run time complexity” later. #include <string> string s,t; // Cannot fix max length

String Operations Definitions for all examples:

Pascal var s, t, u, p : string;

C #include <string.h> or #include <cstring> char s[256], t[256], u[256], p[256];

C++ #include <string> string s, t, u, p;

s="abcde"; t="12"; u="c"; p="ab12#ab12";

String Operations (Assignment) Assignment:

Pascal: assign as normal s := 'abcde'; t := p; { assign a string } s[3] := '9'; { assign a character }

C: use strcpy() function strcpy( s, "abcde" ); // assign string s strcpy( t, p ); // assign string t s[2] = '9'; // assign a character

C++: assign as normal s = "abcde"; t = p; // assign a string s[2] = '9'; // assign a character

String Operations(Get Sub-string) Get part of a string:

Pascal: use copy() function s := copy( p, 3, 5 ); { s = '12#ab' }

C: use strncpy() function strncpy( s, &p[2], 5 ); // s == "12#ab"

You have to use some pointer stuff in C! C++: use string.substr() function

Note the 2 usages of string.substr() s = p.substr( 2, 5 ); // s == "12#ab" s = p.substr( 3 ); // s == "2#ab12"

String Operations (Get Length) Get length of string:

Pascal: use length() function k := length(s); { k = 5 } c := s[0]; { c = chr(5) }

s[0] gives the length in char data type. C: use strlen() function

k = strlen(s); // k == 5 C++: use string.length() function

k = s.length(); // k == 5

String Operations (Concatenation) Concatenate strings together:

Pascal: use concat() function or + operator

s := concat( s, t, u ); { s = 'abcde12c' } s := s+t+u;{ concat by “+” } They are totally equivalent.

C: use strcat() function strcat(s,t); strcat(s,u); // concat one by one

C++: use + operator s = s+t+u; // normal way s += t+u; // another way

String Operations (Comparison) Compare strings:

Compare the characters one by one until not equal or end of string.

Pascal: use >, <, >=, <=, =, <> s > p { true }

C: use strcmp() function =0:equal, >0:greater, <0:smaller k = strcmp(s,p); // k > 0

C++: use >, <, >=, <=, ==, != s > p // true

String Operations (Insertion) Insert another string into a string:

Pascal: use insert() procedure insert( s, t, 3 ); { s = 'ab12cde' }

C: use strcpy() and strncpy() functions I can’t find such a function. Is there any? May use a few strcpy() and strncpy()

instead. C++: use string.insert()

s.insert( 2, t ); // s == 'ab12cde' More overloaded .insert() for you to

discover!

String Operations (Deletion) Delete a part from a string:

Pascal: use delete() procedure delete( s, 2, 3 ); { s = 'ae' }

C: use strcpy() and strncpy() functions I can’t find such a function. Is there any? May use a few strcpy() and strncpy()

instead. C++: use string.erase()

s.erase( 1, 3 ); // s == 'ae' More overloaded .erase() for you to

discover!

String Operations(Search Sub-string) Find a string from a string:

Pascal: use pos() function k := pos( '12', p ); { k = 3 } k := pos( 'x', p ); { k = 0 for not found }

C: use strstr() and pointer operations r = strstr( p, "12" ); // returns &p[2] k = r – p; // k == 2 r = strstr( p, "x" ); // returns null, r == 0

C++: use string.find() function k = s.find( "12" ); // k == 2 s.find( "x" ) == string::npos // true

String Operations(Data Conversion) Data conversion:

Pascal: use val() and str() procedures val( t, k, e ) { e is an integer for error } str( k, t ) { error-free to convert k to t }

C: use atoi(), atof(), sscanf(), sprintf(), ... k = atoi( t ); // k == 12, atof() for

double Remember to #include <stdlib.h> or <cstdlib>

sscanf( t, "%d", &k ); // similar to scanf() sprintf( s, "%d", k ); // similar to printf()

Remember to #include <stdio.h> or <cstdio> C++: use string.c_str() or <sstream>

String Operations (Misc) Misc:

Pascal copy( s, 1, 1 ) <> s[1] { although both are

'a' } copy( s, 1, 1 ) is a string, s[1] is a char.

Result truncated if length exceeded. PChar is a pointer to a null-terminated

string in heap memory in Turbo Pascal. AnsiString is a null-terminated string of

unlimited length that all original string functions can be applied.

var t : ansistring; Only available in Free Pascal.

String Operations (Misc) Misc:

C Be careful not to overwrite the '\0'!

C++ s.c_str() gives the C string equivalent of

s. Find more fancy stuff yourself!

DaP Techniques (Part I) Read the question CAREFULLY.

DaP questions are often very complicated and sometimes misleading. Have a clear mind!

Think how you can process the input to give the output. Algorithm

Decide how the input should be stored. Data structure

DaP Techniques (Part I) Annoying things in DaP

Lengthy and problem description Annoying and frustrating

Dirty input Mixing strings and numbers Unknown length of data

Complicated processing part Dirty output

Strange format

DaP Techniques (Part I) Algorithm and data structure

cooperate with each other. Think both at the same time. Consider the complexity:

Run time complexity Memory complexity

Big-O notation is usually used. Again, will be taught in the future. Trying to consider the no. of operations in

the worst case is acceptable for today.

DaP Techniques (Part I) Think like a computer!

Do NOT be afraid of using lots of loopings, if-then-else’s, multi-dimensional arrays, ...

Get used to write programs with many levels of nesting NOW.

Important because you WILL have to write such programs throughout your OI training (and all other programming tasks).

DaP Techniques (Part I) Typical structure of the main body

of a program: Input Processing Output

Follow the IPO module can make your program more structural.

However, this is not a must.

DaP Techniques (Part I) Processing:

Input is usually stored for processing later.

But sometimes the values are used only once.

Then we may save time and memory by processing the data while inputting.

In the extreme case, input, processing and output may be mixed together.

DaP Techniques (Part I) OI style is often used in OI programs.

Short variable names. No need to have meaning. Usually consists of only 1 character.

No need to write comments. Write everything in the main program,

especially no procedures/functions for things that will only be executed for once.

Will be better taught by Unu in the future.

DaP Techniques (Part I) BUT OI style doesn’t mean

unstructured. Remember, DaP programs are often so

complicated. You will get lost if your program is unstructured.

Your program must be maintainable by yourself, at least during the competition!

Appropriate use of procedures and functions. Good indentation and suitable comment. Consistent variable/function naming scheme. May even use OOP technique!

Exercises (AM) Let’s do easy things before lunch

break! 30189 – Minesweeper

Example for the class. 1005 – Napster Cheating 1006 – Octopus 30300 – Ecological Premium 1015 – Parentheses Balance1015 – Parentheses Balance

Will be explained in Data Structure class.Will be explained in Data Structure class. But you may try!But you may try!

Exercises (PM) Let’s see some harder examples!

2031 – Narrow Range Broadband 2030 – Be Jeweled!

Related to DFS/BFS. Will be explained in future.

But you may try! 20413 – Up and Down Sequences 10000 – Somebody Save the Prince

Your DaP ultimate challenge!