Upload
hubert-booth
View
217
Download
3
Embed Size (px)
Citation preview
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!