list = []
5.times do
number = rand(5..100)
next if list.include?(number)
list.push(number)
end

1) Create an array/stack that allows pushing of variables into the array/stack
2) Create your loop for how many times you wish to loop
3) Generate your random number
4) Goto the next iteration if your number is included inside this array/stack (you may have to iterate through it based on its current length if you don't have access to such a checking function)
5) Append the data to the end of the array

1) Create an array of 1 length
2) Create your loop for how many times you wish to loop
3) Generate your random number
4) Goto the next iteration if your number is included inside this array(you may have to iterate through it based on its current length if you don't have access to such a checking function)
5) Create a new array of original array size + 1 and deallocate the original array
6) Place your number inside the newly resized array

public interface INumberReader
{
void readNumbers();
}

public interface INumberReaderConfig
{
int getMaximumNumber();
int getMinimumNumber();
int getAmountOfNumbers();
InputStream getInputer();
PrintStream getPrinter();
}

public interface INumberReaderFactory
{
INumberReader createNumberReader(INumberReaderConfig config);
}

public class StaticNumberReaderConstants
{
public static final int MAXIMUM_NUMBER = 100;
public static final int MINIMUM_NUMBER = 10;
public static final int AMOUNT_OF_NUMBERS = 5;
public static final InputStream INPUTER = System.in;
public static final PrintStream PRINTER = System.out;
}

public class StaticNumberReaderConfig implements INumberReaderConfig
{
public int getMaximumNumber() { return StaticNumberReaderConstants.MAXIMUM_NUMBER; }
public int getMinimumNumber() { return StaticNumberReaderConstants.MINIMUM_NUMBER; }
public int getAmountOfNumbers() { return StaticNumberReaderConstants.AMOUNT_OF_NUMBERS; }
public InputStream getInputer() { return StaticNumberReaderConstants.INPUTER; }
public PrintStream getPrinter() { return StaticNumberReaderConstants.PRINTER; }

}

import java.io.*;
import java.util.Scanner;

public abstract class NumberReaderBase implements INumberReader
{
private Scanner in;
private PrintStream out;
private int maximumNumber, minimumNumber, amountOfNumbers;

public NumberReaderBase(INumberReaderConfig config)
{
readConfig(config);
}

private void readConfig(INumberReaderConfig config)
{
in = new Scanner(config.getInputer());
out = config.getPrinter();
maximumNumber = config.getMaximumNumber();
minimumNumber = config.getMinimumNumber();
amountOfNumbers = config.getAmountOfNumbers();
}

protected int getMaximumNumber() { return maximumNumber; }
protected int getMinimumNumber() { return minimumNumber; }
protected int getAmountOfNumbers() { return amountOfNumbers; }

protected int readNumber()
{
String msg = String.format("Input a number between %d and %d: ", minimumNumber, maximumNumber);

int number = 0;

do
{
out.println(msg);
number = in.nextInt();

} while(!isValidNumber(number));

return number;
}

protected boolean isValidNumber(int number)
{
return number >= minimumNumber && number <= maximumNumber;
}

protected void printLine(String line)
{
out.println(line);
}

}

public class UniqueNumberReader extends NumberReaderBase
{
private int[] uniqueNumbers;
private int numUniqueNumbers;


public UniqueNumberReader(INumberReaderConfig config)
{
super(config);
}

public void readNumbers()
{
int capacity = getAmountOfNumbers();
uniqueNumbers = new int[capacity];

while(capacity-- > 0)
readUniqueNumber();

}

private boolean isUniqueNumber(int number)
{
for(int i = 0; i < numUniqueNumbers; i++)
if(uniqueNumbers[i] == number)
return false;
return true;
}

protected void readUniqueNumber()
{
int number = readNumber();

if(isUniqueNumber(number))
storeUniqueNumber(number);

}

protected int[] getUniqueNumbers()
{
int[] uniques = new int[numUniqueNumbers];
for(int i = 0; i < uniques.length; i++)
uniques[i] = uniqueNumbers[i];

return uniques;
}

protected void storeUniqueNumber(int number)
{
uniqueNumbers[numUniqueNumbers++] = number;
}
}

public class VerboseUniqueNumberReader extends UniqueNumberReader
{
public VerboseUniqueNumberReader(INumberReaderConfig config)
{
super(config);
}
protected void readUniqueNumber()
{
super.readUniqueNumber();

printUniqueNumbers();

}

protected void storeUniqueNumber(int number)
{
super.storeUniqueNumber(number);

printUniqueNumber(number);
}

private void printUniqueNumbers()
{
int[] uniques = getUniqueNumbers();

String uniqueList = new String("Unique List:");
for(int i = 0; i < uniques.length; i++)
uniqueList = String.format("%s %s",uniqueList,String.valueOf(uniques[i]));

printLine(uniqueList);

}

private void printUniqueNumber(int number)
{
String unique = new String("Unique Number:");

unique = String.format("%s %s",unique, number);

printLine(unique);

}
}

public class UniqueNumberReaderFactory implements INumberReaderFactory
{
public INumberReader createNumberReader(INumberReaderConfig config)
{
return new UniqueNumberReader(config);
}
}

public class VerboseUniqueNumberReaderFactory extends UniqueNumberReaderFactory
{
public INumberReader createNumberReader(INumberReaderConfig config)
{
return new VerboseUniqueNumberReader(config);
}
}

public abstract class NumberReaderApplicationBase
{
private INumberReaderFactory numberReaderFactory;
private INumberReaderConfig numberReaderConfig;

public NumberReaderApplicationBase(INumberReaderFactory numberReaderFactory, INumberReaderConfig numberReaderConfig)
{
this.numberReaderFactory = numberReaderFactory;
this.numberReaderConfig = numberReaderConfig;
}

public void execute()
{
INumberReader nr = numberReaderFactory.createNumberReader(numberReaderConfig);

nr.readNumbers();
}
}

public class VerboseUniqueNumberReaderApplication extends NumberReaderApplicationBase
{
VerboseUniqueNumberReaderApplication()
{
super(new VerboseUniqueNumberReaderFactory(), new StaticNumberReaderConfig());
}
}

public class VerboseUniqueNumberReaderApplicationDriver
{
public static void main(String[] args)
{
new VerboseUniqueNumberReaderApplication().execute();
}
}

List<IAnimal>

List<Animal>