Weblabor

var darab = 2
var szam = []
var oszto = []
var maxoszto = 0

for (var i = 0; i < darab; i++ ) {
  szam[i] = Math.round(Math.random() * 70 + 10)

  oszto[i] = 0
  for (var j = 2; j < szam[i] / 2; j++ )
    if (! (szam[i] % j))
      oszto[i]++

  maxoszto = Math.max(maxoszto, oszto[i])

  document.writeln(i + '. szam : ' + szam[i] + ', ' + oszto[i] + ' osztoja van.')
}

document.writeln('A legtobb, azaz ' + maxoszto + ' osztoja a kovetkezo szamoknak van :')

for (var i = 0; i < darab; i++ )
  if (oszto[i] == maxoszto)
    document.writeln(' - ' + i + '. szam : ' + szam[i])

var darab = 2,
    min = 10,
    max = 80,
    osztok, osztokOsszege, szam, i, j,
    maxOsztokOsszege = {szam : 0, ertek: 0},
    maxOsztokSzama = {szam : 0, ertek: 0};
  
// Generálunk megfelelő mennyiségű számot, és kiszámítjuk adatait.
for (i = 0; i < darab; i++ ) {
  // Generálunk egy véletlen számot min és max között.
  szam = Math.round(Math.random() * (max - min)) + min;
  osztok = 2; // Egy szám osztója 1 és önmaga
  osztokOsszege = szam + 1;
  // A szám felétől megyünk kettőig lefelé.
  for (j = szam >> 1; j >= 2; j -= 1) {
    if (!(szam % j)) {
      osztok++;
      osztokOsszege += j;
    }
  }

  // Megnézzük, ennek a számnak van-e több osztója
  if (osztok > maxOsztokSzama.ertek) {
    maxOsztokSzama.ertek = osztok;
    maxOsztokSzama.szam = szam;
  }
  // Megnézzük, ennek a számnak nagyobb-e az osztóinak összege
  if (osztokOsszege > maxOsztokOsszege.ertek) {
    maxOsztokOsszege.ertek = osztokOsszege;
    maxOsztokOsszege.szam = szam;
  }
  
  // Kiírjuk a szám adatait.
  console.log((i + 1) + '. szam : ' + szam + ', '
    + osztok + ' osztoja van, '
    + 'ezek összege ' + osztokOsszege);  
}

// Kiírjuk az összegzést.
console.log('A legtöbb osztóval rendelkező szám a ' + maxOsztokSzama.szam
  + ', melynek ' + maxOsztokSzama.ertek + ' osztója van.');
console.log('A szám melynek osztóinak összege a legnagyobb a ' + maxOsztokOsszege.szam
  + ', osztóinak összege ' + maxOsztokOsszege.ertek + '.');

interface RandomPositiveIntegerGeneratorInterface
{
	PositiveInteger generateRandomPositiveInteger(PositiveInteger lowerLimit, PositiveInteger upperLimit);
}

interface DivisorListInterface
{
	void countDivisors(PositiveInteger value);
	Array<PositiveInteger> divisors;
	PositiveInteger getCount();
	PositiveInteger getSummary();
}

interface PositiveIntegerSorterInterface
{
	Integer getOrder(PositiveInteger leftValue, PositiveInteger rightValue);
}

interface ExerciseInterface
{
	void doExercise();
}

interface ExerciseResultInterface
{
	PositiveInteger firstNumber;
	PositiveInteger secondNumber;
	Integer divisorCountOrder;
	Integer divisorSummaryOrder;
}

interface ExerciseViewInterface
{
	void showResult(ExerciseResultInterface exerciseResult);
}

test RandomPositiveIntegerGeneratorInterface
{
	PositiveInteger generateRandomPositiveInteger(PositiveInteger lowerLimit, PositiveInteger upperLimit);
		//az alsó és felső határnál ha rosszat adunk, akkor kivételt dob e
		//pozitív szám e az eredmény
		//az eredmény az alsó és felső határ között van e
}

test DivisorListTest
{
	void countDivisors(PositiveInteger value);
		//ha rosszat adunk meg értéknek, akkor kivételt dob e
		//kiszámolja e az osztókat
	Array<PositiveInteger> divisors;
	PositiveInteger getCount();
		//a helyes értéket adja e
	PositiveInteger getSummary();
		//a helyes értéket adja e
}

test PositiveIntegerSorterTest
{
	Integer getOrder(PositiveInteger leftValue, PositiveInteger rightValue);
		//a helyes értéket adja e: ha az első nagyobb, akkor -1, ha egyenlőek, akkor 0, ha a második nagyobb, akkor +1
}


test ExerciseTest
{
	void doExercise();
	//mockolni kell, hogy helyesen használja e a többi osztályt, érdemes tehát úgy átalakítani, hogy ez megoldható legyen, szerintem lényegtelen tesztelni
}

test ExerciseResultTest
{
	//csak setter és getter, nem kell tesztelni
	PositiveInteger firstNumber;
	PositiveInteger secondNumber;
	Integer divisorCountOrder;
	Integer divisorSummaryOrder;
}

test ExerciseViewTest
{
	//nincsenek meg az eszközök view tesztelésére, max nézni lehet, hogy jót ad e, vagy stringeket összehasonlítani, lényegtelen tesztelni
	void showResult(ExerciseResultInterface exerciseResult);
}

function isInteger(value)
{
	return !isNaN(value) && !(value%1);
}

function isPositiveInteger(value)
{
	return isInteger(value) && value>0;
}


RandomPositiveIntegerGenerator=function (){};
RandomPositiveIntegerGenerator.prototype=
{
	generateRandomPositiveInteger: function (lowerLimit, upperLimit)
	{
		if (!isPositiveInteger(lowerLimit) || !isPositiveInteger(upperLimit) || lowerLimit>=upperLimit)
		{
			throw new Error("Problems with lower and upper limit.");
		}
		var randomFloatBeetweenZeroAndOne=Math.random();
		var range=upperLimit-lowerLimit+1;
		return lowerLimit+Math.floor(range*randomFloatBeetweenZeroAndOne);
	}
};

DivisorList=function (value)
{
	this.countDivisors(value);
};
DivisorList.prototype=
{
	countDivisors: function (value)
	{
		if (!isPositiveInteger(value))
		{
			throw new TypeError("not positive integer given");
		}
		this.divisors=[];
		for (var possibleDivisor=1; possibleDivisor<=value; ++possibleDivisor)
		{
			if (isInteger(value/possibleDivisor))
			{
				this.divisors.push(possibleDivisor);
			}
		}
	},
	getCount: function ()
	{
		return this.divisors.length;
	},
	getSummary: function ()
	{
		var summary=0;
		for (var index=0, count=this.getCount(); index<count; ++index)
		{
			var divisor=this.divisors[index];
			summary+=divisor;
		}
		return summary;
	}
};

PositiveIntegerSorter=function (){};
PositiveIntegerSorter.prototype=
{
	getOrder: function (leftValue, rightValue)
	{
		if (!isPositiveInteger(leftValue) || !isPositiveInteger(rightValue))
		{
			throw new TypeError("postitive integer required for left and right values");
		}
		var difference=rightValue-leftValue;
		return (
			difference>1
			?1
			:(
				difference<1
				?-1
				:0
			)
		);
	}
};


Exercise=function (){};
Exercise.prototype=
{
	doExercise: function ()
	{
		var lowerLimit=10;
		var upperLimit=80;
			
		var generator=new RandomPositiveIntegerGenerator();
		var leftValue=generator.generateRandomPositiveInteger(lowerLimit,upperLimit);
		var rightValue=generator.generateRandomPositiveInteger(lowerLimit,upperLimit);
		
		var leftValueDivisors=new DivisorList(leftValue);
		var rightValueDivisors=new DivisorList(rightValue);
		
		var sorter=new PositiveIntegerSorter();
		var divisorCountOrder=sorter.getOrder(leftValueDivisors.getCount(), rightValueDivisors.getCount());
		var divisorSummaryOrder=sorter.getOrder(leftValueDivisors.getSummary(), rightValueDivisors.getSummary());
		
		var result=new ExerciseResult();
			result.leftValue=leftValue;
			result.rightValue=rightValue;
			result.divisorCountOrder=divisorCountOrder;
			result.divisorSummaryOrder=divisorSummaryOrder;
			
		var view=new ExerciseView();
		view.showResult(result);
	}
}

ExerciseResult=function (){};

ExerciseView=function (){};
ExerciseView.prototype=
{
	showResult: function (exerciseResult)
	{
		var newLine="\n";
		var output="results: "+newLine;
			output+="left value: "+exerciseResult.leftValue+newLine;
			output+="right value: "+exerciseResult.rightValue+newLine;
			output+="which has greater divisor count? "+(exerciseResult.divisorCountOrder==-1?exerciseResult.leftValue:exerciseResult.rightValue)+newLine;
			output+="which has greater divisor summary? "+(exerciseResult.divisorSummaryOrder==-1?exerciseResult.leftValue:exerciseResult.rightValue);
		alert(output);
	}
}

var exercise=new Exercise();
	exercise.doExercise();

		var lowerLimit=10;
		var upperLimit=80;
			
		var generator=new RandomPositiveIntegerGenerator();
		var leftValue=generator.generateRandomPositiveInteger(lowerLimit,upperLimit);
		var rightValue=generator.generateRandomPositiveInteger(lowerLimit,upperLimit);
		
		var leftValueDivisors=new DivisorList(leftValue);
		var rightValueDivisors=new DivisorList(rightValue);
		
		var sorter=new PositiveIntegerSorter();
		var divisorCountOrder=sorter.getOrder(leftValueDivisors.getCount(), rightValueDivisors.getCount());
		var divisorSummaryOrder=sorter.getOrder(leftValueDivisors.getSummary(), rightValueDivisors.getSummary());
		
		var result=new ExerciseResult();
			result.leftValue=leftValue;
			result.rightValue=rightValue;
			result.divisorCountOrder=divisorCountOrder;
			result.divisorSummaryOrder=divisorSummaryOrder;