- Форум
- По малко от всичко
- Информационни технологии
- Visual Basic
Здравейте,случайно на някой да му се отдават упражнения във Visual Basic и да е склонен да ми помогне с някои,защото мен ме затрудняват? Ще Ви бъда много благодарна, ако някой се отзове
We are all under the sun, under the same sky, so why do I feel all alone?
*
The Vampire diaries
*
I really want you to really want me
Е дай да видим задачките. Преди съм се занимавал с него, да видим какво помня
Задача Изчислете простите числа до 5000 при натискането на бутона Calculate .
Добавете ги в текстово поле .
Ето и някои съвети, които могат да ви бъдат полезни .
Запознавайки се с материалите от курса по програмиране, вие научихте, че можете да влагате един в друг блоковете с изходен код, например оператора If . Също така можете да влагате и For оператори . Използвайте външен цикъл, който започва от 2 и приключва с 5000.
Променливата от външния цикъл е числото, което ще се проверява дали е просто. Вътрешния цикъл трябва да започва от 2 и да приключва с текущата стойност на външния цикъл намалена с 1. Защо това трябва да се направи така ? Защото променливата от вътрешния цикъл не трябва да става по-голяма от променливата във външния цикъл. Защо минус 1? Защото простите числа могат да се делят сами на себе си и следователно не е нужно това да се проверява.
Ще ви бъде необходима променлива – флаг, която ще обозначава дали стойността на променливата от външния цикъл е просто число или не. Тя трябва да приеме стойност True преди вътрешния цикъл и да се установи в False , ако условието за проверка на просто число не е изпълнено.
Във втория цикъл трябва да проверите дали съществува остатък при деление на съответното число с променливата, управляваща цикъла.
Да разгледаме числата X и Y . Как ще установите, че Y дели X без остатък? Съществуват няколко начина . Тъй като проверяваме вашите умения в конструирането на цикли, а не знанията ви по математика, ще ви дадем идея. Най-лесният начин е да използвате оператора Mod. Предположете, че сте дефинирали променлива с име Remainder , която ще приема остатъка от делението на X и Y . Следователно :
Remainder = X Mod Y
След като приключи вътрешния цикъл вие трябва да добавите съответното число в текстовото поле, ако стойността на променливата – флаг е True . Може би ще ви по някакъв начин ще трябва да отделяте визуално простите числа в текстовото поле .
Това е едната задачка, която ме затрудни. Надявам се да успееш да ми помогнеш Благодаря предварително !
We are all under the sun, under the same sky, so why do I feel all alone?
*
The Vampire diaries
*
I really want you to really want me
Ето малко идеи и от мен:
Първо можеш да запишеш извън цикълът "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
Нещо такова би трябвало да е.
Има 10 вида хора. Тези, които могат да четат двоичен код и тези, които не могат.
Отвратително огромен цикъл, излишно сложен,
Сметна ли изобщо колко ти е максималния брой итереации? При положение че имаме по дефалт 2499 итерации на j + броя на итерациите за i e = на аритметична прогресия 3+5+7+...+4999, общия брой итерации + това че извършваш допълнителни действия, закръгляне, корен, и делене със проверка за остатъка, направо майко мила..
Ами ако исках да сметна до 1 милион простите числа какво правим?
Първо като ще се пише алгоритъм и то още повече математически най-добре прочети, кой ще ти е най-изгоден от програмистка гледна точка, компютъра няма безкраен ресурс за товарене.
После вече помисли как би го завъртял със цикъл,
Най-простия алгоритъм(за числа по-малки от 10 милиона) за намиране на прости числа е на Ератостен(Eratosthenes), идеята е следната:
Числото едно не е просто, поради очевидни причини(дели се само на себе си, 1).
Започваме от числото 2, то е просто, записваме го в външен списък,
След това като първо просто число го използваме за да определим кои след него не са прости, защото ако се делят, на 2 то тогава са композитни(съставни, съставните числа са тези, които не са прости без 0,1).
Всяко число след 2 до n(числото до което търсим простите числа) трябва дабъде подложено на тази проверка, докато не стигнем до умножение x*2, което ще даде резултат по-голям от n.
Същата проверка се повтаря, когато стигнем до числото 3, ако е просто го записваме, ако е съставно го пропускаме, ако стигнем до съставно число, което сме определили вече(каквото е числото 4), то тогава минаваме направо на 5 и така.
Това е идеята на алгоритъма, ето го и нагледно:
Сега със алгоритъма на лице е време да си зададем въпроса как да го имплементираме най-добре с програмен език, как ще бъде най ефикасен и как да си спестим най-много итерации.
Започваме така(ще пиша на 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 ще разполагаш с всички прости числа. */