• Sign Up
• Login
• API
• FAQ
• Tools
• Archive
SHARE
TWEET

# Untitled

a guest Oct 21st, 2019 90 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. # -*- coding: utf-8 -*-
2. #
3. #Modulo Array
4. #
5. #Author: Emilio U. Giuffrida & Students
6. #Date: 17/10/2018
7. #
8. #
9. #TODO:
10. #
11. #1- add comments
12. #2- add shell sort,insertion sort, quicksort and merge sort
13.
14. from array import *
15. import os
16. import random
17. import sys
18.
19.
20. def creaArrayIntStatico(n_Elementi):
21.     newArray=array("i", [])
22.
23.     for i in range(0, n_Elementi):
24.         newArray.append(sys.maxint)
25.
26.     return newArray
27.
28.
29. def creaArrayIntDinamico():
30.     return array("i", [])
31.
32.
33. def creaArrayFloatStatico(n_Elementi):
34.     newArray=array("f", [])
35.
36.     for i in range(0, n_Elementi):
37.         newArray.append(-1.0)
38.
39.     return newArray
40.
41. def creaArrayFloatDinamico():
42.     return array("f", [])
43.
44.
45. def stampaArray(myVector):
46.
47.     state = isEmpty_v2_0(myVector)
48.
49.     if (state == True):
50.         print ("L'array e' vuoto!")
51.
52.         return -1
53.     else:
54.         lenght = len (myVector)
55.         for i in range (0, lenght):
56.             print myVector[i],
57.
58.         print ""
59.
60.         return 0
61.
62.
63. def riempiArrayDinamico(n_Elementi, myVector):
64.
65.     for i in range(0, n_Elementi):
66.         nuovoElemento=random.randint(1,500)
67.         myVector.append(nuovoElemento)
68.
69.     return 0
70.
71.
72. def riempiArrayStatico(myVector):
73.     state = isEmpty_v2_0(myVector)
74.
75.     if (state == True):
76.         print ("L'array e' vuoto!")
77.
78.         return
79.     else:
80.         lenght = len (myVector)
81.         for i in range (0, lenght):
82.             nuovoElemento=random.randint(1,500)
83.             myVector[i]=nuovoElemento
84.             print "Elemento inserito in posizione", i,":",myVector[i]
85.
86.         print ""
87.
88.         return
89.
90. #Genera un IndexError: array index out of range
91. def svuotaArray_conErrore(n_Elementi, myVector):
92.
93.     for i in range(0, n_Elementi):
94.         elementToRemove=myVector[i]
95.         myVector.remove(elementToRemove)
96.
97.         print("Vettore aggiornato", myVector)
98.
99.     return
100.
101.
102. def svuotaArrayDinamico_con_errore(n_Elementi, myVector):
103.
104.     nElementiDecrementata = n_Elementi
105.
106.     while(nElementiDecrementata>0):
107.         headElement=myVector[0]
108.         myVector.remove(headElement)
109.         nElementiDecrementata = nElementiDecrementata -1
110.
111.         print("Vettore aggiornato", myVector)
112.
113.     return
114.
115.
116.
117. def svuotaArrayDinamico(myVector):
118.
119.     state=is_Empty_v2_0(myVector)
120.
121.     if (state==True):
122.         print ("Errore! il vettore è già vuoto!")
123.     else:
124.         nElementiDecrementata = len(myVector)
125.
126.         while(nElementiDecrementata>0):
127.             headElement=myVector[0]
128.             myVector.remove(headElement)
129.             nElementiDecrementata = nElementiDecrementata -1
130.
131.             print("Vettore aggiornato", myVector)
132.
133.     return
134.
135.
136.
137. def svuotaArrayStatico(myVector):
138.     state = isEmpty_v2_0(myVector)
139.
140.     if (state == True):
141.         print ("L'array e' vuoto!")
142.
143.         return False
144.     else:
145.         lenght = len (myVector)
146.         for i in range (0, lenght):
147.             myVector[i]=sys.maxint
148.
149.     return True
150.
151.
152. def clonaArray_conIterator(myVector):
153.     clonato=array('i',[])
154.
155.     for elemento in myVector:
156.         clonato.append(elemento)
157.
158.     return clonato
159.
160.
161. def clonaArray_conIndice(myVector):
162.     clonato=array('i',[])
163.
164.     lunghezza=len(myVector)
165.     for i in range (0, lunghezza-1):
166.         elemento=myVector[i]
167.         clonato.append(elemento)
168.
169.     return clonato
170.
171.
172. def eliminaUguali(myVector):
173.     newVector=array('i',[])
174.
175.     for elemento in myVector:
176.         if elemento not in newVector:
177.             newVector.append(elemento)
178.
179.     return newVector
180.
181.
182. def isEmpty_v1_0(myVector):
183.     lunghezza=len(myVector)
184.
185.     if (lunghezza==0) :
186.         return 1
187.     else:
188.         return 0
189.
190. def isEmpty_v1_1(myVector):
191.     lunghezza=myVector.count
192.
193.     if (lunghezza==0) :
194.         return 1
195.     else:
196.         return 0
197.
198. def isEmpty_v2_0(myVector):
199.     trueOrFalse = ( len(myVector) == 0 )
200.
201.     return trueOrFalse
202.
203. def isEmpty_v2_1(myVector):
204.     trueOrFalse = ( myVector.count == 0 )
205.
206.     return trueOrFalse
207.
208. def isEmpty_v3_0(myVector):
209.     return ( len(myVector) == 0 )
210.
211.
212. def isEmpty_v3_1(myVector):
213.     return ( myVector.count == 0 )
214.
215.
216. def isFull(myVector):
217.     for index in range (0,len(myVector)):
218.         if (myVector[index]!= sys.maxint):
219.             continue
220.         else:
221.             return 0
222.
223. def isFull_v2_0(myVector):
224.     for i in myVector:
225.         if (i != -1 and -1.0):
226.             a=True
227.         else:
228.             a=False
229.             break
230.     return a
231.
232.
233. def isFull_v2_1(myVector):
234.     for i in myVector:
235.         if (i== -1 and -1.0):
236.             return False
237.     return True
238.
239.
240. def separaElementi(myVector):
241.
242.     arrayPari=array("i",[])
243.     arrayDispari=array("i",[])
244.
245.     contaElementiPari=0
246.     contaElementiDispari=0
247.
248.     for element in myVector:
249.
250.     if ((element%2) == 0):
251.         arrayPari.append(element)
252.     else:
253.         arrayDispari.append(element)
254.
255.     return
256.
257.
258. def scambiaOrdine(myVector):
259.
260.     lunghezza=len(myVector)
261.
262.     halfLenght=lunghezza/2
263.
264.     for i in range (0, halfLenght-1):
265.
266.         aux=myVector[i]
267.         myVector[i]=myVector[(lunghezza-1)-i]
268.         myVector[(lunghezza-1)-i]=aux
269.
270.     print "L'array invertito e': ", myVector
271.
272.     return
273.
274.
275.
276. def shift_sinistra(myVector):
277.     headElement=myVector[0]
278.     myVector.remove(headElement)
279.     myVector.append(headElement)
280.
281.     print ("Vettore dopo lo shift a sinistra:", myVector)
282.     return 0
283.
284. def shift_destra(myVector):
285.     numeroElementi=len(myVector)
286.
287.     tailElement=myVector[numeroElementi-1]
288.     myVector.remove(tailElement)
289.     myVector.insert(0,tailElement)
290.
291.     print ("Vettore dopo lo shift a destra:", myVector)
292.     return 0
293.
294.
295. def rotazione_sx(myVector):
296.     for  n_Elementi in myVector:
297.         shift_sinistra (myVector)
298.
299.     return 0
300.
301.
302. def rotazione_dx(myVector):
303.     for  n_Elementi in myVector:
304.         shift_destra (myVector)
305.
306.     return 0
307.
308.
309. def shiftASinistra_C (myVector):
310.     l= len(myVector)
311.     headElement=myVector[0]
312.
313.     for i in range(0, l-1):
314.         myVector[i]=myVector[i+1]
315.
316.     myVector[l-1]=headElement
317.
318.     print ("Vettore shiftato a sx:", myVector)
319.
320.     return 0
321.
322.
323. def shiftADestra_C(myVector):
324.     l= len(myVector)
325.     tailElement = myVector[l-1]
326.
327.     #Per scandire l'array in ordine inverso
328.     for i in xrange(l - 1, -1, -1):
329.         if (i<=l-1) :
330.             myVector[i]=myVector[i-1]
331.
332.     myVector[0]=tailElement
333.
334.     print ("Vettore shiftato a dx: ", myVector)
335.
336.     return 0
337.
338.
339.
340. def selectionSort(myVector):
341.
342.     i=0
343.     j=0
344.     comodo=0
345.
346.
347.     n=len(myVector)
348.     for i in range(i, n-i):
349.         j=i+1
350.
351.         for j in range(j, n):
352.
353.             if(myVector[i]>myVector[j]):
354.                 comodo=myVector[i]
355.                 myVector[i]=myVector[j]
356.                 myVector[j]=comodo
357.
358.
359.     return
360.
361.
362. def bubbleSort(myVector):
363.
364.     N=len(myVector)
365.     Continua=True
366.
367.     while(Continua):
368.
369.         Continua=False
370.         for i in range(0, N-1):
371.             if(myVector[i]>myVector[i+1]):
372.                 comodo=myVector[i]
373.                 myVector[i]=myVector[i+1]
374.                 myVector[i+1]=comodo
375.                 Continua=True
376.
377.
378.     return
379.
380.
381. def shakerSort(myVector):
382.
383.     numeroElementi= len(myVector)
384.     continua=True
385.     while continua==True:
386.         superiore=numeroElementi
387.         continua=False
388.         for i in range(0, superiore-1):
389.             if(myVector[i]>myVector[i+1]):
390.                 aiuto=myVector[i]
391.                 myVector[i]=myVector[i+1]
392.                 myVector[i+1]=aiuto
393.
394.                 continua=True
395.                 superiore=i
396.
397.         for i in range(superiore-1, 0):
398.             if(myVector[i]>myVector[i-1]):
399.                 aiuto=myVector[i]
400.                 myVector[i]=myVector[i-1]
401.                 myVector[i-1]=aiuto
402.
403.                 continua=True
404.                 superiore=i
405.         print myVector
406.     return
407.
408.
409. def insertionSort(alist):
410.    for index in range(1,len(alist)):
411.
412.      currentvalue = alist[index]
413.      position = index
414.
415.      while position>0 and alist[position-1]>currentvalue:
416.          alist[position]=alist[position-1]
417.          position = position-1
418.
419.      alist[position]=currentvalue
420.
421. def shellSort(alist):
422.     sublistcount = len(alist)//2
423.     while sublistcount > 0:
424.
425.       for startposition in range(sublistcount):
426.         gapInsertionSort(alist,startposition,sublistcount)
427.
428.       sublistcount = sublistcount // 2
429.
430. def gapInsertionSort(alist,start,gap):
431.     for i in range(start+gap,len(alist),gap):
432.
433.         currentvalue = alist[i]
434.         position = i
435.
436.         while position>=gap and alist[position-gap]>currentvalue:
437.             alist[position]=alist[position-gap]
438.             position = position-gap
439.
440.         alist[position]=currentvalue
441.
442. def RicercaBinaria(vettore, x):
443.
444.     n=len(vettore)
445.     primo = 0
446.     ultimo = n-1
447.     trovato = False
448.     indice=0
449.
450.     while (primo <= ultimo) and (not trovato):
451.         centro = (primo + ultimo) / 2
452.
453.         if (vettore[centro] == x):
454.             trovato = True
455.             indice=centro
456.
457.             print "L'elemento ricercato e' in posizione ", indice
458.
459.         elif (vettore[centro] < x):
460.                 primo = centro + 1
461.
462.         else:
463.             ultimo = centro - 1
464.
465.     return trovato
466.
467.
468.
469. #------------
470. #Main program
471. #------------
472. def main():
473.     #Pulisce lo schermo
474.     os.system('clear')
475.
476.     numeroElementi=input("Inserisci il numero di elementi: ")
477.     staticVector = creaArrayIntStatico(numeroElementi)
478.
479.     #print ("Array di interi statico vuoto: ", staticVector)
480.     stampaArray(staticVector)
481.
482.     #dynamicVector = creaArrayIntDinamico()
483.
484.     #print ("Array di interi dinamico vuoto: ", dynamicVector)
485.     #riempiArrayDinamico(numeroElementi, vector)
486.
487.     riempiArrayStatico(staticVector)
488.     stampaArray(staticVector)
489.     #print ("Array riempito: ", staticVector)
490.
491.     #arrayClonato1= clonaArray_conIterator(vector)
492.     #print ("Array clonato con iteratore", arrayClonato1)
493.
494.     #arrayClonato2= clonaArray_conIndice(vector)
495.     #print ("Array clonato con indice", arrayClonato2)
496.
497.     #svuotaArray_conErrore(numeroElementi, vector)
498.     #svuotaArray(numeroElementi, vector)
499.
500.     #print ("Array svuotato: ", vector)
501.
502.
503. if (__name__=="__main__"):
504.     main()
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.

Top