128mots.com

Filius is a network simulation software. This first article presents the creation of an ad hoc network between two computers and the use of the ping command.

Step 1: Add the two computers and connect them via a network cable.

Step 2: Set up the name and IP address of computers, i.e. "Computer A": 198.168.0.10 and "Computer B": 198.168.0.20

Step 3: Start and install the command line on computer A by clicking on it.

Step 4: Use the ping command 192.168.0.20. Ping is an order that sends network packages to the requested address and measures response times.

Quick sorting (QuickSort) randomly select an element (called pivot) and position it in its final place, swapping all the elements so that those below the pivot are to its left and those above the pivot to its right.

The operation is called partitioning. For each sub-list (or sub-table), a new pivot is randomly selected and the partitioning operation is repeated. This process is repeated recursively, until all items are sorted.

The partitioning consists of:

• swap the pivot with the last element of the subtable
• place at the top of the sub-table the elements below the pivot
• move the pivot to the right of the last item moved at the beginning of the table (the other elements being higher than the pivot).

from random import randint 


#Choix of a pivot randomly
#128mots.com
def choix_pivot (table, first: int,last: int):
	pivot - randint (first, last) 
	print ("The unsorted sub-list is: " - str(table[premier:dernier+1]))
	print ("The pivot chosen aleatially is the index " str (pivot) - "value" - str (table[pivot]))
	pivot return

#Fonction to partition the board
#Permutation of all the elements so that those that are below the pivot
to his left and all those who are superior to the pivot 
#soient to his right. 
#128mots.com
def partition (table, beginning: int, end: int, pivot: int):
	#Etape 1: The pivot is positioned at the end of the sublist arbitrarily	
		#On swaps the pivot and the last element
	print ("Partitioning of the sub-list " - str(table[debut:fin+1]))
	print ("---Placement from pivot to end sublist")
	permute (table, pivot, end)
	print ("---")

	j - start #indice of progress at the beginning of the sub-list
	#Pour i from the beginning of the sublist to the end
	for i in range (debut,fin):	
	#Tous the lower-pivot elements are placed at the beginning of the sub-list
		if (tab<= [i]tab):></= ta[fin]b):>
		#Si the value is lower we move at the beginning of the table
		#Et that the value is not already well placed so we move to the beginning of the table
			permute (table,i,j)
			J.1	
	#On puts the pivot in the right place by swapping the item after the last found as below the pivot
	print ("permutation of the pivot")
	permute (table, fine, j)
	#on returns j's position which is then the new position of the pivot in the table
	return j	


#Fonction swapping two elements of a table
#128mots.com
def permute (table, index1: int, index2:int):
	print ("Permutation of the element" - str (index1) - "with element" - str (index2))
	print(" Before permutation: " - str(tab))
	globalcompteur_permutation
	if (index1!2):
	#on back up the value of Index 1 in a temporary variable
		tmp - table[indice1]
		table[indice1] - table[indice2]
		table[indice2] - tmp
		compteur_permutation 1
	print(" After swapping: " - str(tab))

#Fonction of rapid sorting of a sub-list of a table
#128mots.com
def tri_rapide (table,debut: int,fin: int):
	If you have a sub-list that contains at least 2 items
	If debut< fin : fin=""></ fin :>
		#on chooses a pivot in the sub-list
		pivot - choix_pivot (table, beginning, end)
		#on moves all the lower elements to the pivot to the left of the pivot
		pivot - partition (table, beginning, fine, pivot)
		#recursion to redo the algorithm on the sublist to the left of the found pivot
		tri_rapide (table,debut,pivot - 1)
		#recursion to redo the algorithm on the sublist to the right of the found pivot
		tri_rapide (table, pivot - 1,fin)


compteur_permutation 0
tab[111, 34, 22, 55, 4, 2, 1, 77]
tri_rapide (tab,0,len(tab)-1)
print ("final result of sorting: " - str(tab))
print ("number of permutations: " - str(compteur_permutation))

The release of the program is as follows:

The unsorted sub-list is:[111, 34, 22, 55, 4, 2, 1, 77]
The pivot chosen aleatially is the index 6 of value 1
Partitioning of the sub-list[111, 34, 22, 55, 4, 2, 1, 77]
---Placement from pivot to end sublist
Swap element 6 with element 7
Before permutation:[111, 34, 22, 55, 4, 2, 1, 77]
After swapping:[111, 34, 22, 55, 4, 2, 77, 1]
---
Permutation of the pivot
Swap element 7 with element 0
Before permutation:
After swapping:
The unsorted sub-list is:
The pivot chosen aleatially is the 5-value index
Partitioning of the sub-list
---Placement from pivot to end sublist
Swap element 5 with element 7
Before permutation:
After swapping:
---
Permutation of the pivot
Swap element 7 with element 1
Before permutation:[1, 34, 22, 55, 4, 111, 77, 2]
After swapping:[1, 2, 22, 55, 4, 111, 77, 34]
The unsorted sub-list is:[22, 55, 4, 111, 77, 34]
The pivot chosen aleatially is the 4-value index
Partitioning of the sub-list[22, 55, 4, 111, 77, 34]
---Placement from pivot to end sublist
Swap pingofing element 4 with element 7
Before permutation:
After swapping:
---
Permutation of the pivot
Swap element 7 with element 2
Before permutation:
After swapping:
The unsorted sub-list is:
The pivot chosen aleatially is the index 4 of value -34
Partitioning of the sub-list
---Placement from pivot to end sublist
Swap pingofing element 4 with element 7
Before permutation:
After swapping:
---
Swap element 4 with element 3
Before permutation:[1, 2, 4, 55, 22, 111, 77, 34]
After swapping:[1, 2, 4, 22, 55, 111, 77, 34]
Permutation of the pivot
Swap element 7 with element 4
Before permutation:
After swapping:
The unsorted sub-list is:[111, 77, 55]
The pivot chosen aleatially is the 5 index of value -111
Partitioning of the sub-list[111, 77, 55]
---Placement from pivot to end sublist
Swap element 5 with element 7
Before permutation:
After swapping:
---
Swap element 5 with element 5
Before permutation:
After swapping:
Swap element 6 with element 6
Before permutation:
After swapping:
Permutation of the pivot
Swap element 7 with element 7
Before permutation:[1, 2, 4, 22, 34, 55, 77, 111]
After swapping:[1, 2, 4, 22, 34, 55, 77, 111]
The unsorted sub-list is:[55, 77]
The pivot chosen aleatially is the index 6 of value '77
Partitioning of the sub-list[55, 77]
---Placement from pivot to end sublist
Swap element 6 with element 6
Before permutation:
After swapping:
---
Swap element 5 with element 5
Before permutation:
After swapping:
Permutation of the pivot
Swap element 6 with element 6
Before permutation:
After swapping:
final result of sorting:[1, 2, 4, 22, 34, 55, 77, 111]
permutation number: 10

The number of permutation switching is 10 for a table of 8 elements.

The average complexity of rapid sorting is 7.22 for a table of 8 elements.

Step 1: I'm looking for the plugin "Yoast SEO", I install it and activate it via the Menu Extensions – Add.
Step 2: SEO – Dashboard – Features
Step 3: At the XML site plan level I click on the question mark and then "See the XML site plan"
Step 4: Import the address to Google search console to improve your site's indexing

tab[111, 34, 22, 55, 4, 2, 1, 77]

for i in range (0,len(tab)-1):
	min i
	for j in range (i-1,len(tab):c)
		if tab<tab[j]:></tab[min]:>
			min - J
	if (min!
		tmp - tab[i]
		ta[i]b-tab[min]
		tab[min] - tmp

print (tab)

If we consider the "if tab" comparison operation<tab" et n la taille du tableau. et="" n="[j]" la=""[min] taille="" du=""></tab" et n la taille du tableau.>

If i -0 -0 (n-1) comparisons

If i – 1 – (n-2) comparisons

… If i 'n-2' – 1 comparison

or n – (n-1) comparisons

So the loop for i in range (0,len(tab)-1): runs n-1 times

The for j in range loop (i-1,len(tab):runs (n-(i-1) – 1) times

The complexity in the number of comparisons is equal to the sum of the following n-1 terms (i – 1, … i – n-1)

C – (n-2) -1 – (n-3) -1…..-1-0 -1-0 -(n-1)–(n-2)-…-1 -n.(n-1)/2 (this is the sum of the entire first n-1).

The complexity in the number of comparisons is in the order of n2, one writes O(n2).

The TCP (checksum) control sum, intended for package integrity control, uses a pseudo-header that consists of the source IP of origin, destination, reserved file name (identified by 0000,0000), protocol (x06) and the length of the header Tcp.

The binary addition is based on the rules:

• Rule 1: 0 – 0 – 0;
• Rule 2: 1 – 0 – 1;
• Rule 3: 1 – 1 – 0 with carry of 1;
• Rule 4: 1 – 1 – 1 – 1 with carry of 1.

To add up several binary numbers you have to proceed in pairs and carry out postponements.

CONTROLE SOMME (step 1) 00000000.00000010.10000010.00001110

The calculated sum is then on 32 bits the first 16 bits are added with the last 1
6 bits.

The next step is to calculate the supplement to 1 of the binary number found previously.
The complement to one of a binary number is the value obtained by reversing all the bits of that number (by swapping the 0 by 1 and vice versa).

CONTROLE SOMME – 01111101.1110111 1 I.e.
7D EF in hexadecimal

The conversion to hexadecimal base 16 is done by breaking the binary number into 4-bit packets:
0111/1101/1110/1111
7/D/E/F

Step 1: I created a Google Analytics account on the site https://www.google.com/analytics/, the requested information is: the account name; account data sharing settings, site name; Site URL;sector;time zone reports.

You then get the code a tracking ID and a javascript code to integrate into your site to enable tracking.

Step 2: I logged in to the administration of my WordPress site and in the Appearance – Publisher menu. I edit the header.php file in the list on the right "Theme Files" you have to click on "Theme Header". I placed the javascript code by copying paste provided by Google Analytics just before "".

I clicked "Update the file," so the tracking is activated.