# Algorithms/Find approximate maximum

## Method 1

### Code Java

```  public int findApproimateMax(int[] i_aryTb) {
final int factorA = 100;
int o_intMax = i_aryTb[0];
int p_countMax = 1;
for (int p_intI = 1; p_intI < i_aryTb.length; p_intI++) {
if ( i_aryTb[p_intI] > o_intMax ) {
o_intMax = i_aryTb[p_intI];
p_countMax = 0;
} else {
p_countMax = p_countMax + 1;
if ( p_countMax >= factorA )
return o_intMax;
} // end if
} // end loop
return o_intMax;
} //end method
```

### Algorithm

Method : findApproimateMax(i_aryTb)

```  define a constant call factorA and assign 100
define o_intMax is integer and assign i_aryTb[0];
define p_countMax is integer and assign 1
for loop = 1 to (i_aryTb.length - 1) do, index
if ( i_aryTb[index] > o_intMax ) then
o_intMax   := i_aryTb[index];
p_countMax := 0;
else
p_countMax = p_countMax + 1;
if ( p_countMax bigger or equal factorA ) then
return o_intMax and terminte the method;
end if
end if
end loop
return o_intMax;
```

## Method 2

### Code java

```   public int findMax(int[] i_aryTB,int numberOfSecond) {
if ( numberOfSecond <= 0 ) {
numberOfSecond = -1;
} // end if
final int factorA = 100;
long p_logStart = System.currentTimeMillis;
long p_logFinish = p_logStart + (numberOfSecond * 1000);
int o_intMax = i_aryTb[0];
for ( int p_intI= 1; p_intI < i_aryTb.length; p_intI++) {
if ( i_aryTb[p_intI] > o_intMax ) {
o_intMax = i_aryTb[intI];
} // end if
if ( p_intI % factorA == 0 ) {
if ( p_logFinish <= System.currentTimeMillis && numberOfSecond != -1) {
return o_intMax;
} // end if
} // end if
} // end loop
o_intMax;
} // end method
```

### Algorithm

Method : findMax(i_aryTB, numberOfSecond)

```  if numberOfSecond <= 0 then
numberOfSecond := -1;
end if
define a constant factorA := 100;
define p_logStart become := current_time;
define p_logFinish := p_logStart + ( numberOfSecond );
define o_intMax := i_aryTb[0];
looping from 1 to (aryTb.length - 1), p_intI
begin
if ( aryTb[p_intI] > o_intMax ) then
o_intMax := aryTb[p_intI];
end if;
if ( the remainder of p_intI / factorA is zero ) then
begin
if ( p_logFinish <= current_time and numberofSecond not equal -1 ) then
return o_intMax;
terminate the method;
end if
end if
end looping
return o_intMax;
```

## Method 3

### Code java

```  public int findApproximateMax(int[] i_intaryTb,final int i_oneStepLength) {
int o_max = i_intaryTb[0];
for (int intI = 0; intI < i_intaryTb; intI += i_oneStepLength)
if ( i_intaryTb[intI] > o_max )
o_max = i_intaryTb[intI];
return o_max;
} // end method
```

### Algorithm

Method : findApproximateMax(i_intaryTb,i_one_stepLength)

```  define o_max and assign i_intaryTb[0];
looping from 0 to i_intaryTb.length -1 ,index += i_one_stepLength
if ( index >= i_intaryTb.length ) then
break the looping;
if ( i_intaryTb[index] > o_max ) then
o_max = i_intaryTb[index];
end if
end looping
return o_max;
```

## Method 4

### Code java

```import java.util.Random();

//Assume noOfRandom < 1_intaryTb.length;
public int findApproximateMax(int[] i_intaryTb,int noOfRanomd) {
int o_intMax      = i_intaryTb[p_intaryRes[0]];
for ( int intJ = 1; intJ < p_intaryRes.length; intJ++) {
int p_intK = p_intaryRes[intJ];
if ( p_intK >= 0 && p_intK < i_intaryTb.length ) {
if ( i_intaryTb[p_intK] > o_intMax) {
o_intMax = p_intaryRes[p_intK];
} // end if
} // end if
} // end loop
return o_intMax;
} // end method
private int[] generateTheRandomIndex(int nRandom) {
int[] o_intaryRes = new int[nRandom];
for (int i = 0; i < nRandom; i++)
o_intaryRes[i] = -1;
for ( int j = 0; j < nRandom; j++) {
int p_intK =findRandomIndex(nRandom);
while ( haveIndex(o_intaryRes,p_intK) ) {
p_intK =findRandomIndex(nRandom);
} // end while loop
o_intaryRes[j] = p_intK;
} // end loop
return o_intaryRes;
} // end method
private boolean haveIndex(int[] i_aryRes,int index) {
for (int i = 0; i < i_aryRes.length; i++)
if ( i_aryRes[i] == index)
return true;
return false;
} // end method
static Random gen = new Random();
private int findRandomIndex(int n) {
return gen.nextInt(n);
} // end method
```