Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. Algorithmus efficientiam

Multi modi et methodi sunt in processu algorithm complendi eandem quaestionem.
Sicut ab eodem loco incipiens et ad alium locum perveniens, vias ad locum attingendum plana, impedimenta, carros privatos comprehendunt... sed tempus aliud est et oeconomia etiam alia est.

1. Notio complexionis

Postquam algorithmus in programmate exsecutabili scriptus est, tempus requirit facultates et spatium (memoriae) facultates ad currendum. Qualitas igitur algorithmus generaliter mensuratur a duabus dimensionibus: tempore et spatio, scilicet temporis complexitate et multiplicitate spatii.
Tempus complexionis maxime mensurat quam celeriter algorithmus currit, dum complexitas spatii maxime mensurat spatium extra spatium ad currendum algorithmum requisitum.
Primis diebus evolutionis computatrae, computatrae parvae capacitatis repositionis habuerunt. Multum igitur de spatio multiplicitate curamus. Nihilominus, celeri progressu industriae computatrum, capacitas repono computatorum altissimum gradum pervenit. Nunc ergo non amplius opus est sedulo attentionem spatii ad algorithm multiplicitatem.

2. Magnitudo complexionis

Cum aliquos ludos ludo, telephonum meum valde calidum erit cum aliquos ludos ludeo, et aliquos ludos non calefit si eos ludo, quod est inseparabile a complexitate multiplex est ad currendum.

2. Tempus complexionem

Definitio: In scientia computatoria, tempus multiplicitatis algorithmi est formula functionis T(N), quae quantitatem temporis currentis algorithmi describit. Tempus complexionis mensurat tempus efficientiam progressionis, cur ergo cursus tempus elaborationis computare non potest?

• Quia tempus cursus programma refertur ad configurationem ambitus ambitus et machinae cursus, exempli gratia, si programmatis algorithmus cum veteri compilator vel novo compilator compilator componatur, tempus currens in eadem machina diversum erit.
• Eadem algorithmus programma diversis temporibus currit utens machina vetus humilis-figurationis et nova machina summus configurationis.
• Tempus et tempus solum probare possunt, postquam programma scriptum est, non computata et aestimata per theoricam cogitationem antequam programma scriberet.

Itaque, cum tempus assignationis gradus algorithmi diiudicat, tempus algorithm exsecutionis non consideratur, numerus instructionum tantum exsecutus est.

Causa:

// 请计算⼀下Func1中++count语句总共执⾏了多少
次？
void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N ; ++ i)
{
	for (int j = 0; j < N ; ++ j)
	{
		++count;
	}
} 
	for (int k = 0; k < 2 * N ; ++ k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Per observationes:
Numerus praecipuarum operationum per Func1:
T(N)=N²+ 2*N + 10

In praxi, cum tempus complexionem calculamus, non exiguum numerum executionis ratis computamus hoc), exactum numerum suppliciorum computare parum momenti est, quod tantum volumus conferre gradum incrementi algorithmi in calculandi temporis complexitate, hoc est, differentiam in T(N) cum N crescere pergit Supra vidimus constantes et ignobiles terminos parum momenti in eventibus habere cum N crescunt, ideo tantum opus est numerus propinquorum executionum computare quod progressio repraesentare potest ad ordinem magnitudinis augendum usus est notatione asymptotica Big O's solere usus est.

3. Spatium multiplicitate

Complicatio spatii etiam est expressio mathematica, quae additamentum spatii ad tempus collocatur propter necessitates algorithmi in operatione algorithmi.
Multiplexio spatii non est quot bytes spatii rationem occupat.
Spatium complexionis calculi regulae basically similes multiplicitati practicae sunt, et Big O asymptotica notatio etiam adhibetur.
Nota: ACERVUS spatium requiritur cum munus currit (parametrorum ac variabilium localium, nonnullae informationis registri etc.) determinatum est in compilatione, itaque spatium multiplicitatis maxime determinatur ab additamento loci expresse applicato per functionem in runtime. .
Spatium non est magni ponderis consideratio in evolutione computatrali currentis, sed nimia vastitas vitanda est.

4. Magnus Repraesentatio asymptotica O'

O magna notatio: Est symbolum mathematicum ad mores asymptotici functionum describendas.
Praecepta pro strenuo ad Big O notatio asymptotica:

• 1. In tempore multiplicitatis formulae functionis T(N), solum termini supremi ordinis retinentur et termini ordinis ignobilis removentur, quia, cum N crescere pergit,
  Ictus ignobilium ordinis terminorum in exitu minora et minora accipit, et, cum N infinitus est, negligi possunt.
• 2. Si terminus supremus ordo existat et non sit 1, removere constantem coefficientem huius vocabuli, quia, cum N crescat, coefficiens hoc.
  Ictum in eventus minor et minor est questus, et cum N infinitus est, potest negligi.
• 3. Si res in T(N) nullae N relatae sunt, sed tantum constantes item, omnes constantes additivos constantibus 1 repone.

Pessimus casus: maximus numerus currit (superior ligatus) pro qualibet magnitudine initus
Mediocris casus: expectata numerus decurrit pro quolibet initus magnitudine
Optimus casus: minimum numerus fugit (infra ligatus) pro qualibet magnitudine initus
In praxi, repraesentatio asymptotica Big O plerumque ad finem algorithmi superiorem spectat, quae est condicio pessima operativa.

5. Complexity de causis computational

1. Adice multiplicitatem Func1 functionis

void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N; ++i)
	{
		for (int j = 0; j < N; ++j)
		{
			++count;
		}
	} 
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	} 
	int M = 10;
	while (M--)
	{
		++count;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

temporis complexionem;

Omitte codicem qui semel decurrit, ut numera=0, hoc signum.
Supplicium numerum codicis servant quae magnum momentum habent in tempore currenti
Numerus suppliciorum primae ansae est duplex ansa supplicium NN
Secunda ansa est iacuit ansa executionis temporibus 2N
Tertius cyclus est X temporibus
Summa caedium numerus est T(N)=N²+2*N+10
Magnum O tempus complexionem significat, parvam impulsum abiicias et limitem accipe
O (N'²)

Spatium complexionis:

Func1 munus pro spatii magnitudine applicat. Exempli gratia, int = 0, pro magnitudine generis int int applicat.
Haec duo spatia etiam in fascias adhibentur sine spatio addito applicatione.
Applicatio spatii magnitudine constant
Spatium complexionis in Big O expressum est:
O (1)

2. Adice tempus multiplicitate Fun2

void Func2(int N)
{
	int count = 0;
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	} 
	int M = 10;
	while (M--)
	{
		++count;
	} 
	printf("%dn", count);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

temporis complexionem;

Numerus temporum in codice decurrit maior quam ansa prima, quae est N*2.
Secundum loop decurrit X temporibus
Utere magnum O ad repraesentandum tempus complexionis. Maximus ictum est 2*N.
O(N)

3. Adice tempus multiplicitate Func3

void Func3(int N, int M)
{
	int count = 0;
	for (int k = 0; k < M; ++k)
	{
		++count;
	}
	for (int k = 0; k < N; ++
			k)
	{
		++count;
	}
	printf("%dn", count);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

tempus complexionem

Duae sunt incognitae, et maior labefactio est in duabus ansulis
Primum loop decurrit M temporibus
Secundum loop decurrit N temporibus
Numerus incognitus sit. Non sum certus uter maior et quo minor est.
O (M+N)

4. Adice tempus multiplicitate Func4

void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%dn", count);
}
1
2
3
4
5
6
7
8
9

temporis complexionem;

Maximus hic dapibus cursus est
Numerus temporum fascias currit est 100
certa constant
O (1)

5. Adice tempus multiplicitatem strchr

const char* strchr(const char* str, int character)
{
	const char* p_begin = str;
	while (*p_begin != character)
	{
		if(*p_begin == '0')
			return NULL;
		p_begin++;
	}
	return p_begin;
}
1
2
3
4
5
6
7
8
9
10
11

Munus hoc munus impletum est characterem in ordine invenire subscriptum.
Numerus hic decurrit incertus
Possibile est invenire F(N)=1 in uno go
Possibile est invenire F(N)=N/2 in medio
Inveniri potest in fine, vel NULL redditur si non invenitur, F(N)=N
Magnus o sumit pessimum casum missionis;
Tempus complexionis est O (N)

6. Adice tempus multiplicitatem Func5

void func5(int n)
{
	int cnt = 1;
	while (cnt < n)
	{
		cnt *= 2;
	}
}
1
2
3
4
5
6
7
8

Hic numerus decurrit ad magnitudinem n, sed non ansa n temporibus. Sciendum est, quia ansa variabilis multiplicabitur in 2 in ansa, et ansa cito prosiliet valor ansa variabilis cnt ad 1024 perveniet.
Posito ergo numero cyclorum x, erit 2 .^x*= n
x = logn
Tempus itaque complexionis est: O (longn)

7. Adice multiplicitatem BubbleSor

void BubbleSort(int* a, int n)
{
	assert(a);
	for (size_t end = n; end > 0; --end)
	{
		int exchange = 0;
		for (size_t i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		} 
		if(exchange == 0)
			break;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Hoc munus complet bulla ascendentis diribitio
Ansa hic est.
Numerus ansarum est indeterminata
Pessimum casum missionis est quod exteriorem loop decurrit n temporibus
Tum ansa interior curret (n-1)+(n-2)+(n-3)+................+2+1+0
est arithmetica series, et summa est;

Tempus complexionis est: O (N)

Spatium complexionis:

Spatium adiectum non est, et appositum perpetuum est.
O (1)

8. De multiplicitate calculandi officinarum recursionis Fac

long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	return Fac(N - 1) * N;
}
1
2
3
4
5
6

temporis complexionem;

N temporibus
Tempus itaque complexionis est: O (N)

Spatium complexionis:

Quotienscumque recurras, spatium adhibere debes.
N tempora et applicata pro N temporibus spatii.
Complexum spatium est: O(N)