Is there anything I can do to reduce the runtime of this program? - loops

Question

uses sysutils;
var
stringlength,querynum,i,start,tail,j,cnt:int64;
input,temp:ansistring;
querychar:char;
begin
readln(stringlength,querynum);
readln(input);
for i:=1 to querynum do begin
readln(querychar,start,tail);
temp:=copy(input,start,tail-start+1);
writeln(temp.CountChar(querychar));
end;
end.
This is a program for finding how many times a character occurs during a certain segment of a string. The input format is first line input the length of the string and the number of queries(n), then the next n lines are input the character to search for its occurence, and the section of the string (eg from 3 to 8). Sometimes the runtime for the program is very high, which I think is due to the for loop. Is there any way I could reduce the runtime?

Answer 1

Speed usually goes at the expense of memory.
If you want to gain speed, you can transform your data into a form/layout that can be even faster processed than the input.
In particular sets are suitable to achieve your goal.
Now, this is an implementation detail.
Pascal – the programming language – does not prescribe any memory layout.
Unlikely as it may be, your processor could theoretically produce even worse results when using a set.
I therefore generally recommend using the most maintainable algorithm.
Your algorithm already satisfies this criterion quite well.
program characterSubstringOccurrences(input, output);
type
{ `integer`-prefix to facilitate sorting in documentation tools. }
integerNonNegative = 0..maxInt;
{
Performs specified number of character queries on sample.
\param sample the sample to inspect for a certain character
\param queryCount the total number of queries to prompt
}
procedure processQueries(
protected sample: string;
queryCount: integerNonNegative
);
type
sampleIndex = 1..sample.capacity;
sampleIndices = set of sampleIndex;
var
c: char;
i, j: sampleIndex;
characterIndex: array[char] of sampleIndices value [otherwise []];
This is a subroutine, because it trivializes the creation of sets with non-constant bounds (here the capacity of the given sample).
We simply need to declare our data types accordingly; no invocation of new necessary.
begin
{ --- analyze `sample` step --- }
for i := 1 to length(sample) do
begin
characterIndex[sample[i]] := characterIndex[sample[i]] + [i];
end;
{ --- draw conclusions from analysis step --- }
for queryCount := 1 to queryCount do
begin
readLn(c, i, j);
writeLn(card(characterIndex[c] * [i..j]));
end;
end;
Evidently this avoids re-inspecting the sample over and over again.
All you need to do is taking the cardinality of the intersection of [start, tail] with the set of indices specified character appears at.
{ === MAIN ================================================== }
var
sample: ^string;
sampleLength: integerNonNegative;
queryCount: integerNonNegative;
begin
if EOF then
begin
writeLn('Error: Program needs input.');
halt;
end;
read(sampleLength);
if sampleLength = 0 then
begin
writeLn('Error: Sample length must be positive.');
halt;
end;
new(sample, sampleLength);
readLn(queryCount);
readLn(sample^);
if queryCount > 0 then
begin
processQueries(sample^, queryCount);
end;
end.
Now this is a program compliant to ISO standard 10206 “Extended Pascal”.
From your code’s non-standard deviations I gather you’re using some dialect, yet the general idea of extracting/transforming data into a form that’s faster to process remains.