Алгоритми в програмирането

9 май 201511 г.

Хм, нещо спомените ме предават. Но имам някакви спомени че макар и сложността и двата случая да е логаритъм от N, имаше игра с базата на логаритъма и при златно сечение се получаваше по-малко число. Освен това имаше някаква игра с вероятности. Защото логаритъма дава броя на операции в най-лошия случай, докато в най-добрия е 1. Та при дихотомия вероятността е линейна, докато при златното сечение не е. И в края на крайщата се получава по-добър резултат

Цитирай

10 май 201511 г.

Разбиване на число на сума от точни степени на 2. Функцията се вика с въпросното число и указател към масив, в който ще се съхраняват получените събираеми. Връща на изхода броя на събираемите минус 1, за удобство при нулево индексиране на масива, а в масива попълва самите събираеми.

Използвам, че сумата от точните степени на 2 е свързана с повдигнатите битове на числото по следния начин.

Например числото 7 = двоично 111 = двоично 1 + двоично 10 + двоично 100 = 2^0 + 2^1 + 2^2 = 1 + 2 + 4 = 7.

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

include <stdio.h>

int findbits(unsigned n, int* aptr)
{
	int actualarraylength = 0;
	int multiplier = 1;
	int m;
	while (true)
	{
		m = n % 2;
		n = n / 2;
		if (m == 1)
		{
			aptr[actualarraylength] = multiplier;
			if (n == 0) break;
			actualarraylength++;
		}
		multiplier = multiplier*2;
	}
	return actualarraylength;
}

int main()
{
	int i;
	int myarray[32];
	unsigned n;
	int length;
	scanf("%u",&n);
        if n == 0 return 0;
	length = findbits(n,myarray);
	for (i = length; i >= 0; i--)
	{
		printf("\n%u\t\t%u", i, myarray[i]);
	}
	return 0;
}

Редактирано 10 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

10 май 201511 г.

Разбиване на число на сума от точни степени на 2. Функцията се вика с въпросното число и указател към масив, в който ще се съхраняват получените събираеми. Връща на изхода броя на събираемите минус 1, за удобство при нулево индексиране на масива, а в масива попълва самите събираеми.

Използвам, че сумата от точните степени на 2 е свързана с повдигнатите битове на числото по следния начин.

Например числото 7 = двоично 111 = двоично 1 + двоично 10 + двоично 100 = 2^0 + 2^1 + 2^2 = 1 + 2 + 4 = 7.

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

Тази програма ще забие с 0 и също така няма да работи коректно с отрицателни числа.

Цитирай

10 май 201511 г.

Тази програма ще забие с 0 и също така няма да работи коректно с отрицателни числа.

Да, така е. Ще я коригирам с unsigned n;

Не ми трябва да разбивам нула и отрицателни числа като сума от точни степени на 2. Безсмислено е. Няма логика. Те всъщност не могат и да се разбият. Как ще се получи нула от събиране на точни степени на 2, или пък отрицателно число ?

Готово, поправих я.

Всъщност аз формата така си го и бях написал "%u" за цели числа без знак.

Разбиването на цели числа без знак като сума от точни степени на 2 има приложение при работа със статичната памет.

И при динамични масиви също върши работа. При прехвърляне на масиви също.

Редактирано 10 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

10 май 201511 г.

Да, така е. Ще я коригирам с unsigned n;

Не ми трябва да разбивам нула и отрицателни числа като сума от точни степени на 2. Безсмислено е. Няма логика. Те всъщност не могат и да се разбият. Как ще се получи нула от събиране на точни степени на 2, или пък отрицателно число ?

Готово, поправих я.

Всъщност аз формата така си го и бях написал "%u" за цели числа без знак.

Разбиването на цели числа без знак като сума от точни степени на 2 има приложение при работа със статичната памет.

И при динамични масиви също върши работа. При прехвърляне на масиви също.

Отрицателните, числа могат да се представят като сума от степени на двойката * -1.

В момента си изнесал проверката за 0 извън функцията, като според мен трябва това да ти е в условието на цикъла. Когато ти се подаде 0 като параметър, връщаш 0 от функцията и готово.

Редактирано 10 май 201511 г. от a.bozhilov (преглед на промените)

Цитирай

10 май 201511 г.

Отрицателните, числа могат да се представят като сума от отрицателните степени на двойката.

В момента си изнесал проверката за 0 извън функцията, като според мен трябва това да ти е в условието на цикъла. Когато ти се подаде 0 като параметър, връщаш 0 от функцията и готово.

Я си помисли пак!!!

1. 2^-3 = 1/8

2. -2⁴ = 16

Така че има още да помислиш да отрицателните числа

Цитирай

10 май 201511 г.

Уф, глупости пиша. Имах предвид степените на двойката и ги умножи по -1.

Цитирай

10 май 201511 г.

Уф, глупости пиша. Имах предвид степените на двойката и ги умножи по -1.

Всъщност по-лесния вариант е да направиш в началото умножение по -1 (ако е отрицателно) и да ползваш алгоритъма за положителни числа (като си пазиш във флаг дали е отрицателно или не)

Цитирай

10 май 201511 г.

Уф, глупости пиша. Имах предвид степените на двойката и ги умножи по -1.

Това изобщо не е добра идея - работейки и с отрицателни коефициенти всяко число ще може да се представи по безброй разлини начини

премерно: 1 = 2⁰=2¹-2⁰=2²-2¹-2⁰и т.н. до безкрай

Цитирай

10 май 201511 г.

Това изобщо не е добра идея - работейки и с отрицателни коефициенти всяко число ще може да се представи по безброй разлини начини

премерно: 1 = 2⁰=2¹-2⁰=2²-2¹-2⁰и т.н. до безкрай

Има ли значение, след като в неговата програма еднозначно с логаритмична сложност намира едно такова представяне?

Цитирай

10 май 201511 г.

Това изобщо не е добра идея - работейки и с отрицателни коефициенти всяко число ще може да се представи по безброй разлини начини

премерно: 1 = 2⁰=2¹-2⁰=2²-2¹-2⁰и т.н. до безкрай

Но какъв е смисъла да се разбиват отрицателни числа.

Положителни числа е ясно. С точни степени на 2 се работи по удобно и по бързо. Но какъв е смисъла от разбиването на отрицателни числа ?

Има ли значение, след като в неговата програма еднозначно с логаритмична сложност намира едно такова представяне?

Математически е безсмислено да се разбиват отрицателни числа. Мисля, че няма и практическо приложение. Но не съм сигурен. Всяко нещо може да се използва, ако се намери някой който да му намери смисъл. Но на отрицателни числа, като сума от степени на 2 не съм чувал да имат приложение.

Цитирай

10 май 201511 г.

Обединяване на два долепени сортирани масива, така че обединеният масив също да бъде сортиран. Вземам най младшия индекс от масива, който заема старшите индекси. По метода на двоичното търсене намирам къде трябва да бъде вмъкнат в масива с младшите индекси. Изход от функцията имаме в два случая:

1. Когато най малкия член на оставащия масив, който заема старшите индекси, се оказва, че трябва да бъде вмъкнат след края на масива заемащ младшите индекси. Сиреч на своето предишно място. Тогава двата долепени масива образуват вече един обединен подреден масив.

2. Когато е извършена проверка с последния член на масива заемащ старшите индекси и той е вмъкнат на своето място по големина.

Използвам функции за преместване на група долепени числа с един индекс нагоре и за двоично търсене на мястото на число в подреден масив.

#include <stdio.h>

void shiftup(int minindex, int maxindex, int* aptr )
{
	int i;
	for (i = maxindex; i >= minindex; i--)
	{
		aptr[i + 1] = aptr[i];
	}
}


int findplace(int number, int minindex, int maxindex, int* aptr ) // the sorted array is between minindex and maxindex
{
	int midindex;                            // current average = (current minindex + current Maxindex)/2
	int minindexp = minindex;                // store the initial values of minindex and maxindex
	int maxindexp = maxindex;
	while (true)
	{
		midindex = (minindex + maxindex)/2;    // find the index of the middle array member
		if (midindex == minindex)              // check for the end of searching and doing the final stuff
		{
			if (number <= aptr[minindex])
			{
				return (minindex);
			}
			else
			{
				if (number <= aptr[maxindex])
				{
					return (maxindex);
				}
				else
				{
					return (maxindex + 1);
				}
			}
		}
		if (number > aptr[midindex])        // if the value is bigger, continue checking with the middle of 
		{                                    // the upper half
			minindex = midindex;
		}
		else if (number == aptr[midindex])
		{
			return (midindex);
		}
		else                                 // if the value is smaller, continue checking with the middle of
		{                                    // the lower half
			maxindex = midindex;
		}
		
	}
}


int jointwojoinedsorted(int start1, int end1, int end2, int* aptr)
{
	int place;
	int insertindex;
	int k;
	k = end1 + 1;
	while (true)
	{
		insertindex = findplace(aptr[k], start1, end1, aptr);
		if (insertindex > end1) break;
		place = aptr[k];
		shiftup(insertindex, k - 1, aptr);
		aptr[insertindex] = place;
		k++;
		end1++;
		if (k > end2) break;
	}
	return 0;
}

int main()
{
	int i;
	int myarray[10] = {1,3,4,6,9,
	                   2,5,7,8,10};
	jointwojoinedsorted(0, 4, 9, myarray);
	for (i = 0; i <= 9; i++)
	{
		printf("\n%u\t\t%u", i, myarray[i]);
	}
	return 0;
}

Редактирано 10 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

10 май 201511 г.

Сортиране на неподреден масив с дължина точна степен на 2.

1. Приемам, че всеки един отделен член на масива е подреден масив.

2. Обединявам всеки нечетен масив със всеки четен масив, така че да са сортирани. Дължината на сортираните масиви е вече удвоена.

3. Продължавам стъпка 2 докато се получи сортиран масив с дължина равна на дължината на зададения за сортиране.

4. Тъй като дължината на масива е точна степен на числото 2, няма нужда от повече проверки. Масивът е сортиран.

#include <stdio.h>

int jointwojoinedsorted(int start1, int end1, int end2, int* aptr);

void shiftup(int minindex, int maxindex, int* aptr )
{
	int i;
	for (i = maxindex; i >= minindex; i--)
	{
		aptr[i + 1] = aptr[i];
	}
}

int findplace(int number, int minindex, int maxindex, int* aptr ) // the sorted array is between minindex and maxindex
{
	int midindex;                            // current average = (current minindex + current Maxindex)/2
	int minindexp = minindex;                // store the initial values of minindex and maxindex
	int maxindexp = maxindex;
	while (true)
	{
		midindex = (minindex + maxindex)/2;    // find the index of the middle array member
		if (midindex == minindex)              // check for the end of searching and doing the final stuff
		{
			if (number <= aptr[minindex])
			{
				return (minindex);
			}
			else
			{
				if (number <= aptr[maxindex])
				{
					return (maxindex);
				}
				else
				{
					return (maxindex + 1);
				}
			}
		}
		if (number > aptr[midindex])        // if the value is bigger, continue checking with the middle of 
		{                                    // the upper half
			minindex = midindex;
		}
		else if (number == aptr[midindex])
		{
			return (midindex);
		}
		else                                 // if the value is smaller, continue checking with the middle of
		{                                    // the lower half
			maxindex = midindex;
		}
		
	}
}



int exactsort(int startindex, int endindex, int* aptr)
{
	int k;
	int sortedlength = 1;
	int sortedcount;
	int length;
	length = endindex - startindex;
	sortedcount = (length + 1) / sortedlength;
	while (sortedlength < endindex - startindex)
	{
		for (k = 0; k <= length; k = k + 2*sortedlength)
		{
			jointwojoinedsorted(k,k+sortedlength-1,k+2*sortedlength-1,aptr);
		}
		sortedlength = sortedlength*2;
	}
	return 0;
}

int jointwojoinedsorted(int start1, int end1, int end2, int* aptr)
{
	int place;
	int insertindex;
	int k;
	k = end1 + 1;
	while (true)
	{
		insertindex = findplace(aptr[k], start1, end1, aptr);
		if (insertindex > end1) break;
		place = aptr[k];
		shiftup(insertindex, k - 1, aptr);
		aptr[insertindex] = place;
		k++;
		end1++;
		if (k > end2) break;
	}
	return 0;
}

int main()
{
	int i;
	int myarray[16] = {3,1,12,6,15,13,4,2,16,11,9,14,7,5,10,8};
	exactsort(0, 15, myarray);
	for (i = 0; i <= 15; i++)
	{
		printf("\n%u\t\t%u", i, myarray[i]);
	}
	return 0;
}

Редактирано 10 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

10 май 201511 г.

@Реджеп Иведик опитваш се да направиш in-place merge sort и убиваш цялата скорост на сортирането с това О(N^2) сливане на двата масива. Преди време една преподавателка ме питаше дали има начин да се оптимизира сортирането чрез вмъкване като говореше за масив. Аз и казах, че дори и двоично търсене да ползва пак няма да го оптимизира, защото ще са необходими N операции за да се вмъкне елемента на правилното място. В твоя случай много по-удачно е да ползваш един допълнителен масив с дължина N и ще можеш линейно да сливаш два сортирани масива. Между другото най-лесната имплементация на merge sort с O(1) допълнителна памет е когато се сортира свързан списък. Ако ти се свиди паметта, може да ползваш или quick sort или heap sort и двете си идват с недостатъците, като quick sort най-лошото време е N^2. При heap sort ще имаш същата сложност като merge sort.

За разлика от merge sort и двете алтернативи, които ти предложих не сортират стабилно. Примерно ако имаш тесте карти, което е сортирано по бои, то ако приложиш merge sort и го сортиташ по стойности на картите в крайния си вид тестето ще е сортирано както по стойности така и по бои. При heap sort и quick sort това не е гарантирано.

Цитирай

12 май 201511 г.

@Реджеп Иведик опитваш се да направиш in-place merge sort и убиваш цялата скорост на сортирането с това О(N^2) сливане на двата масива. Преди време една преподавателка ме питаше дали има начин да се оптимизира сортирането чрез вмъкване като говореше за масив. Аз и казах, че дори и двоично търсене да ползва пак няма да го оптимизира, защото ще са необходими N операции за да се вмъкне елемента на правилното място. В твоя случай много по-удачно е да ползваш един допълнителен масив с дължина N и ще можеш линейно да сливаш два сортирани масива. Между другото най-лесната имплементация на merge sort с O(1) допълнителна памет е когато се сортира свързан списък. Ако ти се свиди паметта, може да ползваш или quick sort или heap sort и двете си идват с недостатъците, като quick sort най-лошото време е N^2. При heap sort ще имаш същата сложност като merge sort.

За разлика от merge sort и двете алтернативи, които ти предложих не сортират стабилно. Примерно ако имаш тесте карти, което е сортирано по бои, то ако приложиш merge sort и го сортиташ по стойности на картите в крайния си вид тестето ще е сортирано както по стойности така и по бои. При heap sort и quick sort това не е гарантирано.

За съжаление не знам голяма част от теорията, тъй като съм любител. Прочетох за quicksort.

Сортиране на масив по метода quicksort.

Метода куик сорт се характеризира с избиране на една стойност наречена pivot point, с която се сравняват всички елементи на масива. Масива се обхожда с два индекса, като единия избира стойности от края към началото, а другия от началото към края. Когато единия индекс стигне до стойност, която трябва да бъде разменена, спира и изчаква и индекса от другия край да достигне до такава стойност. Стойностите се разменят и сравняването продължава докато по малкия индекс стане по голям от по големия.

С горното е извършено прехвърляне на по големите стойности от пайвът пойнта в дясната страна на масива, а на по малките стойности, в лявата страна на масива.

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

# include <stdio.h>

void quicksort(int startindex, int endindex, int* aptr)
{
	int i,j,temp,pivot;
	i = startindex;
	j = endindex;
	pivot = aptr[(startindex + endindex)/2];
	while (i <= j)
	{
		while (aptr[j] > pivot) j--;
		while (aptr[i] < pivot) i++;
		if (i <= j)
		{
		    temp = aptr[j];
		    aptr[j] = aptr[i];
		    aptr[i] = temp;
		    i++;
		    j--;
		}
	}
	if (j > startindex) quicksort(startindex, j, aptr);
	if (i < endindex) quicksort(i, endindex, aptr);
}

int main()
{
	int i;
	int myarray[16] = {3,1,12,6,15,13,4,2,16,11,9,14,7,5,10,8};
	quicksort(0, 15, myarray);
	for (i = 0; i <= 15; i++)
	{
		printf("\n%u\t\t%u", i, myarray[i]);
	}
	return 0;
}

Редактирано 12 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

15 май 201511 г.

Сортиране на масив по метода "радикс сорт". Фактически поцифрово или посимволно, ако има такива думи. Ако се сортират низове, то е ясно, че е посимволно. Ако се сортират цели числа е поцифрово. В зависимост от това как интерпретираме числата, цифрите могат да бъдат от съответстваща на интерпретацията бройна система. За това се нарича и радикс сорт.

За масив от цели числа с дължина 65536 числа, е три пъти по бърз от куик сорт и от мърдж сорт.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void radixsort(int startindex, int endindex, unsigned* aptr)
{
    int i,j,k;
    unsigned place,mlace;
    unsigned buckets[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    unsigned length;
    unsigned* aptr2;
    usigned maxdigitscount;
    length = endindex - startindex + 1;
    aptr2 = (unsigned*)malloc(length * sizeof(unsigned));
    place = aptr[0];
    for (i = startindex + 1; i <= endindex; i++)
	{
		if (place < aptr[i]) place = aptr[i]; // Намирам най голямото число
	}
	j = 0;
	while (place != 0)
	{
	    place = place >> 4;  // Намирам колко цифри има най голямото число в 16тична
		j++;
	}
	for (k = 0; k < j; k++)
	{
		for(i = startindex; i <= endindex; i++)        
		{
			buckets[(aptr[i]>>(k*4))&0xf]++;           
		}                                                  
		for (i = 1; i < 16; i++)                           
		{
			buckets[i] = buckets[i] + buckets[i - 1];
		}
		for (i = endindex; i >= startindex; i--)
		{
			buckets[(aptr[i]>>(k*4))&0xf]--;
			aptr2[buckets[(aptr[i]>>(k*4))&0xf]] = aptr[i];
		}
		for (i = 0; i < length; i++)
		{
			aptr[i + startindex] = aptr2[i];
		}
		for (i = 0; i < 16; i++) buckets[i] = 0;		
	}
	free(aptr2);
}

int main()
{
	int i;
	clock_t t;
	unsigned myarray[65536];
	srand(time(NULL));
	for (i = 0; i < 65536; i++)
	{
		myarray[i] = rand()%32768;
	}
	t = clock();
	radixsort(0, 65535, myarray);
	t = clock() - t;
	printf("\n%f", ((float)t)/CLOCKS_PER_SEC);
	for (i=65520;i<65536;i++)
	{
		printf("\n%u\t\t%u",i, myarray[i]);
	}
	return 0;
}

1. Нулират се кофите.

2. Във всяка кофа се преброява по колко числа от масива завършват на цифра равна на индекса на кофата.

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

4. Числата се разпределят съобразно кофите в помощен масив в динамичната памет, така че да са групирани по групи в съответствие с цифрата на която завършват. Разпределението става отзад напред.

5. Така подредените числа се връщат от помощния в първоначалния масив.

6. Нулират се кофите за следващата итерация с по старшата цифра.

7. Горните действия се повтарят докато се извършат и за най старшата цифра на най големите числа от масива.

Масивът е сортиран.

Редактирано 15 май 201511 г. от Реджеп Иведик (преглед на промените)

Цитирай

13 юни 201510 г.

Разменяне на местата на две променливи, без да се използва допълнително място.

Иаползва се цикличността на функцията изключващо или.

a ^ b = c

Съгласно логическия смисъл на функцията изключващо или, с е такова число, щото:

c ^ b == a e истина и c ^ a == b e истина

Програма на С

#include <stdio.h>

int main()
{
        int a = 100;
        int b = 200;
	a = a ^ b;    // магическото число с отива в а
	b = a ^ b;    // а отива в b
	a = a ^ b;    // b отива в а
	printf("\n\na = %d\t\tb = %d",a,b);
	return 0;
}

Редактирано 13 юни 201510 г. от Реджеп Иведик (преглед на промените)

Цитирай

13 юни 201510 г.

Мене по ма кефи записа:

	a ^= b; 
	b ^= a; 
	a ^= b;

Цитирай

1 август 201510 г.

Въведение в програмирането с Java. Глава 4. Вход и изход от конзолата.

Упражнение 5 и даденото от авторите решение. Цитирам:

5.Напишете програма, която чете от конзолата две цели числа и отпечатва по-голямото от тях. Реализирайте програмата без използването на сравнение. Забележка: задачата изисква малко да помислите!

5.Нека числата са a и b. Използвайте следните преобразувания: a=a-b; b=b+a; a=b-a.

Край на цитата.

Така даденото упътване не намира по голямото число, а разменя стойностите на числата, ако не се получи препълване.

Правилното решение на упражнението би трябвало да бъде следното:

a = ( |a - b| + a + b) / 2

class mistake
{
    public static void main(String[] args) 
	{
		java.util.Scanner sc = new java.util.Scanner(System.in);
		System.out.print("\nInput the first integer: ");
		int a = sc.nextInt();
		System.out.print("\nInput the second integer: ");
		int b = sc.nextInt();
		a = (java.lang.Math.abs(a - b) + a + b) / 2;
		System.out.println("\nThe bigger number is " + a);
	}
}

Редактирано 1 август 201510 г. от Реджеп Иведик (преглед на промените)

Цитирай

1 август 201510 г.

Въведение в програмирането с Java. Глава 4. Вход и изход от конзолата.

Упражнение 5 и даденото от авторите решение. Цитирам:

5.Напишете програма, която чете от конзолата две цели числа и отпечатва по-голямото от тях. Реализирайте програмата без използването на сравнение. Забележка: задачата изисква малко да помислите!

5.Нека числата са a и b. Използвайте следните преобразувания: a=a-b; b=b+a; a=b-a.

Край на цитата.

Така даденото упътване не намира по голямото число, а разменя стойностите на числата, ако не се получи препълване.

Правилното решение на упражнението би трябвало да бъде следното:

a = ( |a - b| + a + b) / 2
class mistake
{
    public static void main(String[] args) 
	{
		java.util.Scanner sc = new java.util.Scanner(System.in);
		System.out.print("\nInput the first integer: ");
		int a = sc.nextInt();
		System.out.print("\nInput the second integer: ");
		int b = sc.nextInt();
		a = (java.lang.Math.abs(a - b) + a + b) / 2;
		System.out.println("\nThe bigger number is " + a);
	}
}

И къде е алгоритъмът тук?

Цитирай

2 август 201510 г.

И къде е алгоритъмът тук?

Ами те са цели два. Един "грешен", който ако бъде приложен, ще размени стойностите на променливите. И един "верен", който ще прояви стойността на по голямата променлива, в конкретна предварително избрана променлива, което е и условието на задачата.

Не будистите разбира се, могат и да не вземат под внимание кавичките. Те са, за да се свети името на Нагарджуна.

Редактирано 2 август 201510 г. от Реджеп Иведик (преглед на промените)

Цитирай

2 август 201510 г.

5.Напишете програма, която чете от конзолата две цели числа и отпечатва по-голямото от тях. Реализирайте програмата без използването на сравнение. Забележка: задачата изисква малко да помислите!

class mistake
{
    public static void main(String[] args) 
	{
		java.util.Scanner sc = new java.util.Scanner(System.in);
		System.out.print("\nInput the first integer: ");
		int a = sc.nextInt();
		System.out.print("\nInput the second integer: ");
		int b = sc.nextInt();
		a = (java.lang.Math.abs(a - b) + a + b) / 2;
		System.out.println("\nThe bigger number is " + a);
	}
}

Първо в даденият пример е използвано сравнение и второ не работи при задаване на определени числа поради ясни причини. Което прави задачата или условието грешни.

Цитирай

2 август 201510 г.

Аз създадох алгоритъм за галерия и искам да я споделя, но е още бъгава. Писана е на Javascript, jQuery. Някой може ли да я погледне и да даде мнение как да си подобри или промени?

	

     
                            var step = 0;
                            var caption_step = 0;
     
                            var slideImages = new Array();
     
                                    slideImages[0] = new Image(); // create new instance of image object
                                    slideImages[0].src = "Gallery_photos/11659124_853719721379919_465923606_o.jpg"; // set image src property to image path, preloading image in the process
                                    slideImages[1] = new Image();
                                    slideImages[1].src = "Gallery_photos/11657419_853708204714404_2081408670_n.jpg";
                                    slideImages[2] = new Image();
                                    slideImages[2].src = "Gallery_photos/11660270_853708024714422_823277396_o.jpg";
                                    slideImages[3] = new Image();
                                    slideImages[3].src = "Gallery_photos/11664058_853708054714419_2127126124_o.jpg";
                                    slideImages[4] = new Image();
                                    slideImages[4].src = "Gallery_photos/11665051_853707994714425_2045398077_o.jpg";
                                    slideImages[5] = new Image();
                                    slideImages[5].src = "Gallery_photos/11715422_853719798046578_1687560472_o.jpg";
                                    slideImages[6] = new Image();
                                    slideImages[6].src = "Gallery_photos/11665797_853706721381219_21742223_o.jpg";
                                    slideImages[7] = new Image();
                                    slideImages[7].src = "Gallery_photos/11713451_853706798047878_1311042290_n.jpg";
                                    slideImages[8] = new Image();
                                    slideImages[8].src = "Gallery_photos/11659148_853706454714579_1436434876_o.jpg";
                                    slideImages[9] = new Image();
                                    slideImages[9].src = "Gallery_photos/11259425_853719854713239_907533031_o.jpg";
     
                                    var caption = new Array();
     
                                    caption[0] = "The manager, Simone Krustanova.";
                                    caption[1] = "Wedding ceremony";
                                    caption[2] = "Wedding jewelry and flowers.";
                                    caption[3] = "Bride, signing a document.";
                                    caption[4] = "The flowers are picked by our flower designers.";
                                    caption[5] = "Wedding limo.";
                                    caption[6] = "Wedding cake";
                                    caption[7] = "Bride with her hobby - animal love.";
                                    caption[8] = "Wedding dog";
                                    caption[9] = "Restaurant";
     
                            function slideshow(){
     
     
                                    document.getElementById('image').src = slideImages[step].src;
                                    document.getElementById('fig_caption').textContent = caption[caption_step];
     
                                    if (step<10 && caption_step<10){
                                            step++;
                                            caption_step++;
     
                                    }
                                    else{
                                            step=0;
                                            caption_step = 0;
                                    }
     
                                    setTimeout("slideshow()",2000);
     
     
     
                            }
                           
                            function nextImg(){
     
     
                                            step+=1;
                                            caption_step+=1;
                                            document.getElementById('image').src=slideImages[step].src;
                                            document.getElementById('fig_caption').textContent = caption[caption_step] + " " + step + " out of 10";
     
                                            if(step && caption_step ==10){
     
                                                    step = 0;
                                                    caption_step = 0;
     
                                            }
                            }
     
                            function prevImg(){
     
                                            step-=1;
                                            caption_step-=1;
                                            document.getElementById('image').src=slideImages[step].src;
                                            document.getElementById('fig_caption').textContent = caption[caption_step] + " " + step + " out of 10";
     
                            }
     
     
     
     
                            $(document).ready(function(){
     
                                            slideshow();
                                           
                            });

Редактирано 2 август 201510 г. от frozener (преглед на промените)

Цитирай

2 август 201510 г.

Ами те са цели два. Един "грешен", който ако бъде приложен, ще размени стойностите на променливите. И един "верен", който ще прояви стойността на по голямата променлива, в конкретна предварително избрана променлива, което е и условието на задачата.

Не будистите разбира се, могат и да не вземат под внимание кавичките. Те са, за да се свети името на Нагарджуна.

Май нещо много не си наясно що е това алгоритъм.

Но ако се пробваш да напишеш abs() метод, който да връща по-голямата стойност без да прави сравнение, може и да споделиш един алгоритъм без да разбереш, че си го направил.

Аз създадох алгоритъм за галерия и искам да я споделя, но е още бъгава. Писана е на Javascript, jQuery. Някой може ли да я погледне и да даде мнение как да си подобри или промени?

Такива алгоритми са много подходящи за тази тема.

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

Цитирай

2 август 201510 г.

В този JavaScript пътеката до файлът не може ли да се задава директно в конструктора да се спести малко писане?

Цитирай

Добре дошли!

Алгоритми в програмирането

Featured Replies

Архивирана тема

Разглеждащи това в момента 0

Дарение

Бюлетин

Профил

Навигация

Търсене

Конфигуриране на push известия в браузъра

Chrome (Android)

Chrome (Desktop)

Safari (iOS 16.4+)

Safari (macOS)

Edge (Android)

Edge (Desktop)

Firefox (Android)

Firefox (Desktop)