Determine a pattern in numbers in a group

If it is a strict pattern, something like 1 4 9 16 25 36 (the square of each incrementing number) then you could hard code a function that would determine exactly the next number.

If your data is somewhat fuzzy (not exact) such as what time the train will reach the next station given the time it reached the previous station then Fuzzy Logic[^] would be the way to go.

The basic idea of fuzzy logic is that you get a series of inputs (perhaps from the same variable, and perhaps from different variables) and you apply some fuzzy logic to predict the next value or some value in the future.

If you have or can get a copy of matlab i would strongly recommend reading the matlab help manual about Fuzzy Inference Systems and work through its examples.
The implementation will be slightly different in code, but it will really help your understanding.

I will give a rough explanation of what they are tho.
I will not explain the details of techniques such as fuzzification and defuzzification, if you don't read about them in matlab then it will just confuse you.

In the case of your train example:
The train travels from station A to B then to C

The base time for the train to get from A to B is 25min and to get from B to C is 35min.
Then there are some factors that affect it.
During busy times the train spends longer at each station.
When it is raining the train cannot travel as fast.

Now we convert these into the inputs:
1. Starting station
2. Finishing station
2. Time of day (this is for how busy it is. You may include day of week as an input as well)
3. How wet it is

Each of these inputs takes a value in a specified domain and range, generally 0.0-1.0
Next we generate a function that will map each input to a weight over its range.

For "How wet it is", I would make the domain 0.0 (dry) to 1.0 (pouring rain or hail) and the range 0.0 (no delay) to 1.0 (delayed a lot)

This step can be skipped if you want, this is more for ease of use by end users.
next we create linguistic variables[^] for each input.
This is basically a word or phrase that represents a value of a specific variable. I have already done this subconsciously in the previous step to help the explanation.

In the case of "How wet it is" again, we might define:

dry      = 0.0
drizzle  = 0.1
mist     = 0.2
moderate = 0.4
heavy    = 0.8
hail     = 1.0

So that the user would select 1 of those words as the input to the variable "How wet it is", and the same would go for the other variables.

Now that we have the domain (input) of the variable we need to get the range (output) which defines a function that relates the input to the output.
For the case of "How wet it is" you want something with an incline, like linear, exponential or logarithmic. But it can be anything you want.
I would say that exponential would be a good choice in this particular case.

Finally, you need to combine the result from evaluating the function of all your inputs to produce a final answer.
You will likely need to weight each input individually based on how much it will effect the time of arrival.

The Start/Finish station inputs will take the station name as a linguistic input which would turn to an integer and output the time from the start of the route to that station, including stops at each station. This way, you can simply do "Finish Station" - "Start Station" to get the base time that it will take between any 2 stations.

Station linguistic variables:
A = 1
B = 2
C = 3

This way you can use the station name as an index into an array or in a switch statement.

The Time of day input would have a domain of 0-23 (hours) and would have 2 peaks in its graph to represent peak times (7am-9am & 3pm-6pm for example)

Once you have calculated the base time it would take, then you simply need to add on the weighted times from each of the inputs

Time = "Finish Station" - "Start Station" + "Time of day" * 2min + "How wet it is" * 5min

This explanation is not strictly a Fuzzy Inference System, but it will be much easier for you to code and understand.

I can prove mathematically, in general case, that this is theoretically impossible.
If the pattern in known in advance, the task is trivial — you don't need first 30 numbers.
If the pattern is unknown, this is theoretically impossible.

Here is the proof.

Let's assume you have the algorithm A which defined the pattern of integer numbers: for any integer I (ordering number), it returns integer value of the sequence: (I) => A(I).
Now, the formulation of the problem is: first N values of the sequence are known. How to find out A(N+1) is A is unknown? (If A is known, the answer is known for any I without knowledge of any values.)
Let's suggest that the solution is possible and A(N+1) = H. Let's now proof there is another algorithm B, so for any B(I)==A(I) for any I {0..N} and B(I) != A(I) ("!": not equal) for I = N + 1.
As A is stated to be unknown by the formulation of the problem any B satisfying the above requirement will proof that the problem is not solvable. So, for any given A and N, any B will make the proof.
Let's define B(I) = A(I) + I - (I % N), where "%" is the division by modulo. One can check up that this B(I) == A(I) for I:{0..N}, but for B(N+1) == A(I) + I > A(I) => The proof.

Now, one can wonder: there are many problems like that, typical for IQ tests, etc.! The answer is simple: they all are incorrect. The only effect of such question is purely social and psychological (or rather, belongs to cognitive abilities): average people usually follows the same pattern recognition which is usually considered as a correct answer. If you're not average (especially well above average!) you would fail IQ test!
One practical consequence is: a person fails IQ test at the moment when she or he agree to take the test. Taking or offering IQ tests is a clear indication of intellectual deficiency!

—SA

The Answer from Andrew Brock mentions MatLab. If you do not have access to that product and find it a bit expensive, there is a very good open source alternative: Octave[^]. Although it's documentation is not as good as MatLab, so if you can view that documentation it would be a good idea.

In addition to my first Answer, some further clarification may be needed in order to avoid misunderstanding possible due to different interpretations of the Question.

It's possible to prove the different related statement. What if we see first N arbitrary members and, as a suggestion for the member #N+1, put some arbitrary constant C such as C = 0, for example?
I can state: then, one can find such algorithm B that makes this suggestion correct, so for all I: {0..N} B(I) = A(I) and B(N+1) = C. The schema is the same: the algorithm should zero down A for every N-th member and add C.

I would call two my statements a "Theorem of Impossibility of Pattern Recognition". I think it can be proven in much more general assumptions (than you, Espen, for the reference!).
One could wonder: how about whole big set of technologies for Pattern Recognition?!

The answer is simple: it's all about probabilities of false positive and false negative which are never zero. If some military machine can recognize F-35 Fighter, especially during the military exercise, F-35 is much more likely than Flying Saucer.

—SA

Without knowing what the possible patterns are this is a classic np-complete[^] problem. i.e. you are likely to spend a long time trying to get a general alogrithm to figure the pattern out, but at least you'll know if you've got the answer quickly.

If you can't find a way to restrict the number of types of patterns you need to check, this is a near impossible task, so see if you can do this first. If you can't do this you might find approximation algorithms that will give you a close (but not exact) answer. You might also find genetic algorithms provide a good approximation technique.