Visual Basic

[sunriseee]

Здравейте,случайно на някой да му се отдават упражнения във Visual Basic и да е склонен да ми помогне с някои,защото мен ме затрудняват? Ще Ви бъда много благодарна, ако някой се отзове :)

[Cybershot]

Е дай да видим задачките. Преди съм се занимавал с него, да видим какво помня :)

[sunriseee]

Задача Изчислете простите числа до 5000 при натискането на бутона Calculate .

Добавете ги в текстово поле .

Ето и някои съвети, които могат да ви бъдат полезни .

Запознавайки се с материалите от курса по програмиране, вие научихте, че можете да влагате един в друг блоковете с изходен код, например оператора If . Също така можете да влагате и For оператори . Използвайте външен цикъл, който започва от 2 и приключва с 5000.

Променливата от външния цикъл е числото, което ще се проверява дали е просто. Вътрешния цикъл трябва да започва от 2 и да приключва с текущата стойност на външния цикъл намалена с 1. Защо това трябва да се направи така ? Защото променливата от вътрешния цикъл не трябва да става по-голяма от променливата във външния цикъл. Защо минус 1? Защото простите числа могат да се делят сами на себе си и следователно не е нужно това да се проверява.

Ще ви бъде необходима променлива – флаг, която ще обозначава дали стойността на променливата от външния цикъл е просто число или не. Тя трябва да приеме стойност True преди вътрешния цикъл и да се установи в False , ако условието за проверка на просто число не е изпълнено.

Във втория цикъл трябва да проверите дали съществува остатък при деление на съответното число с променливата, управляваща цикъла.

Да разгледаме числата X и Y . Как ще установите, че Y дели X без остатък? Съществуват няколко начина . Тъй като проверяваме вашите умения в конструирането на цикли, а не знанията ви по математика, ще ви дадем идея. Най-лесният начин е да използвате оператора Mod. Предположете, че сте дефинирали променлива с име Remainder , която ще приема остатъка от делението на X и Y . Следователно :

Remainder = X Mod Y

След като приключи вътрешния цикъл вие трябва да добавите съответното число в текстовото поле, ако стойността на променливата – флаг е True . Може би ще ви по някакъв начин ще трябва да отделяте визуално простите числа в текстовото поле .

Това е едната задачка, която ме затрудни. Надявам се да успееш да ми помогнеш :) Благодаря предварително !

[Chacho]

Ето малко идеи и от мен:

Първо можеш да запишеш извън цикълът "2" в текстовото поле. То очевидно е просто число и ще го запишем извън алгоритъмът за намиране на простите между 1 и 5000.

По този начин цикълът, който ще обхожда числата от 2 до 5000, можеш да стане от 3 до 5000 step 2. С други думи ще обхожда всички нечетни числа от 3 до 5000 (защото четните не са прости). Цикълът проверява с вътрешен цикъл дали числото е просто и го записва в текстовото поле, ако то е такова (ако flag=true).

Вътрешният цикъл за проверка на числата може да се реализира с един for. Да кажем, че проверяваш дали числото "р" е просто. Тогава цикълът може да е за i = 1 to sqrt(p) (или по-точно до закръгленото към по-малкото цяло число sqrt(p) ). На всяка стъпка проверяваш дали p mod i = 0 (ако това е вярно, то flag=false).


Псевдокод:

TekstovoPole.Zapisvane(2);

for j = 3 to 4999 step 2

begin na purvi for

for i = 1 to zakrugleno(sqrt(j))

begin na vtori for

if (j mod i = 0)

flag = false;

end na vtori for

if (flag = true)

TekstovoPole.Zapisvane(j)

flag=true;

end na purvi for


Нещо такова би трябвало да е.

[thefreak2]

Отвратително огромен цикъл, излишно сложен,
Сметна ли изобщо колко ти е максималния брой итереации? При положение че имаме по дефалт 2499 итерации на j + броя на итерациите за i e = на аритметична прогресия 3+5+7+...+4999, общия брой итерации + това че извършваш допълнителни действия, закръгляне, корен, и делене със проверка за остатъка, направо майко мила..
Ами ако исках да сметна до 1 милион простите числа какво правим?

Първо като ще се пише алгоритъм и то още повече математически най-добре прочети, кой ще ти е най-изгоден от програмистка гледна точка, компютъра няма безкраен ресурс за товарене.
После вече помисли как би го завъртял със цикъл,

Най-простия алгоритъм(за числа по-малки от 10 милиона) за намиране на прости числа е на Ератостен(Eratosthenes), идеята е следната:
Числото едно не е просто, поради очевидни причини(дели се само на себе си, 1).
Започваме от числото 2, то е просто, записваме го в външен списък,
След това като първо просто число го използваме за да определим кои след него не са прости, защото ако се делят, на 2 то тогава са композитни(съставни, съставните числа са тези, които не са прости без 0,1).
Всяко число след 2 до n(числото до което търсим простите числа) трябва дабъде подложено на тази проверка, докато не стигнем до умножение x*2, което ще даде резултат по-голям от n.
Същата проверка се повтаря, когато стигнем до числото 3, ако е просто го записваме, ако е съставно го пропускаме, ако стигнем до съставно число, което сме определили вече(каквото е числото 4), то тогава минаваме направо на 5 и така.

Това е идеята на алгоритъма, ето го и нагледно:

http://upload.wikimedia.org/wikipedia/commons/8/8c/New_Animation_Sieve_of_Eratosthenes.gif





Сега със алгоритъма на лице е време да си зададем въпроса как да го имплементираме най-добре с програмен език, как ще бъде най ефикасен и как да си спестим най-много итерации.

Започваме така(ще пиша на c++, мога да го преведа и на Delphi ако се наложи)



int top_number = 5000;
int prime_numbers[top_number];

//Записваме 2,3 като първите прости числа
prime_numbers[] = 2;
prime_numbers[] = 3;

for(int i = 4; i <= top_number; i++){

/*
Проверка за просто число, най простата проверка, а именно дали се дели на 2 без остатък, я правим винаги първа, за да е максимално бърз алгоритъма, така ако числото е четно итерацията ще минава без други проверки.
*/

//ако мине проверката продължаваме с цикъла
if(i % prime_numbers[0] == 0) continue;

/*
Ако остановим че не е минала проверката за четно число, значи имаме нечетно, но дали е просто? За да сме сигурни използваме другите прости числа вече записани в масива prime_numbers Ако не е четно и масива е само с един елемент, то тогава е ясно че сме на числото 3, всяко друго ще е по-голямо от 3 Но не е изгодно от гледна точка на ресурс на компютъра да броим всеки път колко е голям масива, тъйкато знам че след 2 веднага следва просто число за това цикъла започва от 4; с други думи записали сме вече 2 елемента в масива и продължаваме нататък. Алгоритъма ще работи и ако не го направим, но е важно да е бърз и ефикасен.
*/
/*
Ако не мине проверката, циклим простите числа, които сме записали започвайки от най-малките, тъйкато е най-голяма вероятноста числото в моментната итерация да се дели на по-малко число от колкото на по-голямо. Забележи че пропускам първия елемент, тъйкато вече съм го проверил по горе.
*/

int current_array_count = count(prime_numbers);

for(int i2 = 1; i2 < current_array_count; i2++){
//ако числото се окаже съставно спираме вътрешния цикъл
if(i % prime_numbers[i2] == 0) break;

/*
ако се окаже че не е така записвам числото, разбирам че трябва да го запиша ако цикъла е стигнал до последна итерация, без да открие деление без остатък
*/

if(i2 == current_array_count - 1) prime_numbers[] = i;
}
}


/*
В края на цикъла в масива prime_numbers ще разполагаш с всички прости числа.
*/