Розробка програмної моделі та моделювання високоточної комп’ютерної системи

 

ВСТУП

Сучасний стан представлення кодування даних у компютерному середовищі може характеризуватися як невідповідний між теоретичними результатами та їх практичним використанням. Якщо у теоретичному плані отримано цілий ряд дуже ефективних розвязань, то на практиці застосовується невелика кількість кодів.

Системи числення визначають структури даних, що використовуються у ЕОМ для обробки інформації. Саме різні показники, які визначають ефективність процесу обробки в цілому, складають графічні умови застосування деякої системи числення.

Однією з основних тенденцій розвитку засобів обчислювальної техніки є застосування нетрадиційного кодування - зображення даних. Незважаючи на принципові відмінності між непозиційним та позиційним кодуванням, доведена можливість обєднання цих систем в таку,якій властиві позитивні ознаки складових. Дослідниками можливостей застосування нетрадиційних кодів для реалізації мультиплікативних операцій, а також загальних вимог до конструктивності кодування даних, було запропоновано оригінальне кодування даних, що отримало назву розрядно-логарифмічне.

1. РОЗРЯДНО-ЛОГАРИФМІЧНА АРИФМЕТИКА

1.1 Алгоритм додавання

Додавання починається з кодів, що мають найменшу вагу. Алгоритм додавання чисел у РЛ представленні в змістовій формі може мати такі етапи:

)Перевірка операндів на рівність нулеві. Якщо один з операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення іншого операнда і додавання закінчується (перехід до пункту 6). Якщо обидва операнда дорівнюють нулеві, у РЛ структуру результату записується значення нуля і додавання закінчується (перехід до пункту 6);

)Обєднання РЛ структур операндів у РЛ структуру результату;

)Сортування РЛ структури результату;

)Приведення подібних у РЛ структурі результату;

)Присвоєння знака першого опера дна знакові результату;

)Кінець.

.2 АЛГОРИТМ ВІДНІМАННЯ

Етапи віднімання:

)Перевірка операндів на рівність нулеві. Якщо один із операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення іншого операнда з відповідним знаком і віднімання закінчується. Якщо обидва операнда дорівнюють нулеві,у РЛ структуру результату записується значення нуля і віднімання закінчується;

)Визначення більшого операнда шляхом порівняння операндів;

)Віднімання з більшого оперна меншого;

)Визначення знака результата;

)Кінець.

1.3 Алгоритм множення

Під час виконання операції множення треба врахувати рівність кожного значення розрядно-логарифмічного коду логарифму від ваги ненульового розряду в операнді.

Процес РЛ множення двох чисел складається з етапів:

)Кожний елемент першого числа складається з кожним елементом другого числа;

2)Здійснюється упорядкування елементів добутку;

)Серед елементів добутку виконується приведення подібних.

Алгоритм множення:

)Перевірка операндів на рівність нулеві. Якщо один з операндів дорівнює нулеві, то в РЛ структуру результату записується РЛ значення нуля і множення закінчується;

2)Знаходження часткових добутків шляхом додавання кожної цифри множника з кожною цифрою множеного. Часткові добутки поєднуються в РЛ структуру результату;

)Сортування РЛ структури добутку;

)Приведення подібних у РЛ структурі добутку;

)Визначення знака результату;

)Кінець.

1.4 Алгоритм ділення

Ділення у РЛ формі близьке до ділення кутом і виконується з автоматичним визначенням пробної цифри частки як різниці між старшою значущою одиницею РЛ форми діленого або залишку від ділення і старшою значущою одиницею РЛ форми дільника.

Алгоритм ділення чисел у РЛ представленні в змістовній формі такий:

)Перевірка операндів на рівність нулеві. Якщо ділене дорівнює нулеві, то в РЛ структуру результату записується РЛ значення нуля і ділення закінчується. Якщо дільник дорівнює нулеві, то видається повідомлення про помилку і ділення закінчується;

2)Знаходження першої цифри частки шляхом віднімання старшого розряду дільника від старшого розряду РЛ коду діленого;

)Множення цифри часки на дільник, шляхом додавання її до кожного розряду РЛ коду дільника;

)Порівняння діленого з отриманим добутком. Якщо ділене більше або дорівнює добуткові, то виконуються дії пункту 5. Якщо ділене менше добутку, то поточна цифра частки зменшується на одиницю і виконується перехід до дій пункту 2;

)Віднімання з діленого отриманого добутку;

)Перевірка критерію закінчення ділення відповідно до обраного методу обробки на основі застосування РЛ представлення. Якщо критерій виконується перехід до пункту 7. Якщо критерій не виконується, то виконується пошук наступної цифри частки шляхом віднімання старшого розряду дільника зі старшого розряду РЛ коду залишку від ділення і перехід до дій з пункту 2;

)Визначення знака результату;

)Кінець.

2. Код програми

.1 Розрахунок оберненої матриці за методом Крамера

=1-10**-10=[[a,-1,1,-1,1,0,0,0],

[1,-1,1,-1,0,1,0,0],

[1,-1,0,0,0,0,1,0],

[1,0,0,1,0,0,0,1]]=0element in m[2]:[2][i]=m[2][i]-m[1][i]=i+1=0element in m[1]:[1][i]=m[1][i]-m[3][i]=i+1=0element in m[0]:[0][i]=m[0][i]-m[1][i]=i+1=0element in m[0]:[0][i]=m[0][i]-m[3][i]=i+1=0element in m[0]:[0][i]=element/(a-1)=i+1=0element in m[3]:[3][i]=m[3][i]-m[0][i]=i+1=0element in m[1]:[1][i]=element*-1=i+1=0element in m[1]:[1][i]=m[1][i]-m[2][i]=i+1=0element in m[1]:[1][i]=m[1][i]-m[3][i]=i+1=0element in m[2]:[2][i]=(m[2][i]-m[3][i])*-1=i+1=[m[0][4:],m[1][4:],m[2][4:],m[3][4:]]('Обратная матриця',p)

2.2 Перевірка оберненої матриці за допомогою одиничної

=[[a,-1,1,-1,],

[1,-1,1,-1,],

[1,-1,0,0,],

[1,0,0,1,]]=[[-9999999999, 9999999999, -0.0, -0.0],

[-9999999999, 9999999999, -1.0, 0.0],

[9999999999, -9999999998, -1.0, 1.0],

[9999999999, -9999999999, 0.0, 1_new[0][0]=[m[0][i]*k[i][0] for i in range(len(m[0]))]_new[0][0]=sum(m_new[0][0])_new[0][1]=[m[0][i]*k[i][1] for i in range(len(m[0]))]_new[0][1]=sum(m_new[0][1])_new[0][2]=[m[0][i]*k[i][2] for i in range(len(m[0]))]_new[0][2]=sum(m_new[0][2])_new[0][3]=[m[0][i]*k[i][3] for i in range(len(m[0]))]_new[0][3]=sum(m_new[0][3])_new[1][0]=[m[1][i]*k[i][0] for i in range(len(m[0]))]_new[1][0]=sum(m_new[1][0])_new[1][1]=[m[1][i]*k[i][1] for i in range(len(m[0]))]_new[1][1]=sum(m_new[1][1])_new[1][2]=[m[1][i]*k[i][2] for i in range(len(m[0]))]_new[1][2]=sum(m_new[1][2])_new[1][3]=[m[1][i]*k[i][3] for i in range(len(m[0]))]_new[1][3]=sum(m_new[1][3])_new[2][0]=[m[2][i]*k[i][0] for i in range(len(m[0]))]_new[2][0]=sum(m_new[2][0])_new[2][1]=[m[2][i]*k[i][1] for i in range(len(m[0]))]_new[2][1]=sum(m_new[2][1])_new[2][2]=[m[2][i]*k[i][2] for i in range(len(m[0]))]_new[2][2]=sum(m_new[2][2])_new[2][3]=[m[2][i]*k[i][3] for i in range(len(m[0]))]_new[2][3]=sum(m_new[2][3])_new[3][0]=[m[3][i]*k[i][0] for i in range(len(m[0]))]_new[3][0]=sum(m_new[3][0])_new[3][1]=[m[3][i]*k[i][1] for i in range(len(m[0]))]_new[3][1]=sum(m_new[3][1])_new[3][2]=[m[3][i]*k[i][2] for i in range(len(m[0]))]_new[3][2]=sum(m_new[3][2])_new[3][3]=[m[3][i]*k[i][3] for i in range(len(m[0]))]_new[3][3]=sum(m_new[3][3])

print('проверка',m_new)

2.3 Код розрахунку оберненої матриці за методом Крамера у розрядно-логарифмічній формі

matr():

'''(list, list) -> list

>>> matr()

'0.5.5.2.1.7.3.'

'''=[['0.5.-1.-2.-3.-4.-5.-6.-7.-8.-9.-10.-11.-12.-13.-14.-15.-16.-17.-18.-19.-20.-21.-22.-23.-24.-25.-26.-27.-28.-29.-30.','1.1.0.','0.1.0.','1.1.0.','0.1.0.','0.0.','0.0.','0.0.'],

['0.1.0.','1.1.0.','0.1.0.','1.1.0.','0.0.','0.1.0.','0.0.','0.0.'],

['0.1.0.','1.1.0.','0.0.','0.0.','0.0.','0.0.','0.1.0.','0.0.'],

['0.1.0.','0.0.','0.0.','0.1.0.','0.0.','0.0.','0.0.','0.1.0.']]=0element in m[2]:[2][i]=minus(m[2][i],m[1][i])=i+1

#print(m[2])=0element in m[1]:[1][i]=minus(m[1][i],m[3][i])=i+1=0element in m[0]:[0][i]=minus(m[0][i],m[1][i])=i+1=0element in m[0]:[0][i]=minus(m[0][i],m[3][i])=i+1element in m[0]:[0][i]=delen(m[0][i],k)=i+1

#print(m[0])=0element in m[3]:[3][i]=minus(m[3][i],m[0][i])=i+1=0element in m[1]:[1][i]=mnog(element,'1.1.0.')=i+1

i=0element in m[1]:[1][i]=minus(m[1][i],m[2][i])=i+1=0element in m[1]:[1][i]=minus(m[1][i],m[3][i])=i+1=0element in m[2]:[2][i]=mnog(minus(m[2][i],m[3][i]),'1.1.0.')=i+1=[m[0][4:],m[1][4:],m[2][4:],m[3][4:]]('Обратная матриця',p)

2.4 Перевірка оберненої матриці за допомогою одиничної у розрядно-логарифмічній формі

odmatr():

'''(list, list) -> list

>>> odmatr()

'0.5.5.2.1.7.3.'

'''=[['0.30.-1.-2.-3.-4.-5.-6.-7.-8.-9.-10.-11.-12.-13.-14.-15.-16.-17.-18.-19.-20.-21.-22.-23.-24.-25.-26.-27.-28.-29.-30.','1.1.0.','0.1.0.','1.1.0.'],

['0.1.0.','1.1.0.','0.1.0.','1.1.0.'],

['0.1.0.','1.1.0.','0.0.','0.0.'],

['0.1.0.','0.0.','0.0.','0.1.0.']]_m=[['1.4.29.28.27.26.', '0.4.29.28.27.26.', '0.0.', '0.0.'],

['1.4.29.28.27.26.', '0.4.29.28.27.26.', '1.1.0.', '0.0.'],

['0.4.29.28.27.26.', '1.29.29.28.27.25.24.23.22.21.20.19.18.17.16.15.14.13.12.11.10.9.8.7.6.5.4.3.2.1.0.', '1.1.0.', '0.1.0.'],

['0.4.29.28.27.26.', '1.4.29.28.27.26.', '0.0.', '0.1.0.']]

_new=[['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.'],['0.0.','0.0.','0.0.','0.0.']]=0_new[0][0]=[mnog(m[0][i],ob_m[i][0]) for i in range(len(m[0]))][0]=summa(m_new[0][0][0],m_new[0][0][1])[1]=summa(m_new[0][0][2],m_new[0][0][3])[0][0]=summa(k[0],k[1])[0][0]='0.1.0.'_new[0][1]=[mnog(m[0][i],ob_m[i][1]) for i in range(len(m[0]))][0]=summa(m_new[0][1][0],m_new[0][1][1])[1]=summa(m_new[0][1][2],m_new[0][1][3])[0][1]=summa(k1[0],k1[1])[0][1]='0.0.'_new[0][2]=[mnog(m[0][i],ob_m[i][2]) for i in range(len(m[0]))][0]=summa(m_new[0][2][0],m_new[0][2][1])[1]=summa(m_new[0][2][2],m_new[0][2][3])[0][2]=summa(k2[0],k2[1])_new[0][3]=[mnog(m[0][i],ob_m[i][3]) for i in range(len(m[0]))][0]=summa(m_new[0][3][0],m_new[0][3][1])[1]=summa(m_new[0][3][2],m_new[0][3][3])[0][3]=summa(k3[0],k3[1])

k4[0]=summa(m_new[1][0][0],m_new[1][0][1])[1]=summa(m_new[1][0][2],m_new[1][0][3])[1][0]=summa(k4[0],k4[1])_new[1][1]=[mnog(m[1][i],ob_m[i][1]) for i in range(len(m[0]))][0]=summa(m_new[1][1][0],m_new[1][1][1])[1]=summa(m_new[1][1][2],m_new[1][1][3])[1][1]=summa(k5[0],k5[1])_new[1][2]=[mnog(m[1][i],ob_m[i][2]) for i in range(len(m[0]))][0]=summa(m_new[1][2][0],m_new[1][2][1])[1]=summa(m_new[1][2][2],m_new[1][2][3])[1][2]=summa(k6[0],k6[1])_new[1][3]=[mnog(m[1][i],ob_m[i][3]) for i in range(len(m[0]))][0]=summa(m_new[1][3][0],m_new[1][3][1])[1]=summa(m_new[1][3][2],m_new[1][3][3])[1][3]=summa(k7[0],k7[1])_new[2][0]=[mnog(m[2][i],ob_m[i][0]) for i in range(len(m[0]))][0]=summa(m_new[1][0][0],m_new[1][0][1])[1]=summa(m_new[1][0][2],m_new[1][0][3])[2][0]=summa(k8[0],k8[1])_new[2][1]=[mnog(m[2][i],ob_m[i][1]) for i in range(len(m[0]))][2][1]=summa(m_new[1][1][0],m_new[1][1][1])_new[2][2]=[mnog(m[2][i],ob_m[i][2]) for i in range(len(m[0]))][2][2]=summa(m_new[1][2][0],m_new[1][2][1])_new[2][3]=[mnog(m[2][i],ob_m[i][3]) for i in range(len(m[0]))][0]=summa(m_new[1][3][0],m_new[1][3][1])[1]=summa(m_new[1][3][2],m_new[1][3][3])[2][3]=summa(k11[0],k11[1])_new[3][0]=[mnog(m[3][i],ob_m[i][0]) for i in range(len(m[0]))][0]=summa(m_new[1][0][0],m_new[1][0][1])[1]=summa(m_new[1][0][2],m_new[1][0][3])[3][0]=summa(k12[0],k12[1])_new[3][1]=[mnog(m[3][i],ob_m[i][1]) for i in range(len(m[0]))][3][1]=minus(m_new[1][1][0],m_new[1][1][3])_new[3][3]=[mnog(m[3][i],ob_m[i][3]) for i in range(len(m[0]))][3][3]=minus(m_new[1][3][0],m_new[1][3][3])_new[3][2]=[mnog(m[3][i],ob_m[i][2]) for i in range(len(m[0]))][0]=summa(m_new[1][2][0],m_new[1][2][1])[1]=summa(m_new[1][2][2],m_new[1][2][3])[3][2]=summa(k14[0],k14[1])

print(new)

алгоритм логарифмічний бібліотека код

3. Бібліотеки для дій з розрядно-логарифмічними діями

.1 Операція додавання

summa(first,second):

'''(str,str)->strnumbers

>>>summa('0.4.7.6.5.4.','0.2.7.5.')

'0.3.8.7.4.'

>>>summa('1.4.3.2.1.0.','0.2.3.2.')

'1.2.1.0.'

>>>summa('0.4.8.4.5.6.','1.2.3.4.')

'0.4.8.6.4.3.'

>>>summa('1.2.3.4.','0.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''first=='0.0.':=secondsecond=='0.0.':=firstfirst[0]=='1' and second[0]=='0' and first[2:]==second[2:]:='0.0.'resultfirst[0]=='0' and second[0]=='1'and first[2:]==second[2:]:='0.0.'resultfirst=='0.0.' and second=='0.0.':='0.0.'result:=C(first,second)first[0]==second[0]:=ConcatRl(first,second)=numberRL(sum)=equal_to_one(sum)result

second==h:=summa1(first,second)resultfirst==h:=summa2(first,second)result

summa1(first, second):

'''(str,str)->str1 and 0'

>>>summa1('1.2.3.4.','0.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''=''=''=second[0]n in range(0, len(first)):+= str(first[n])n in range(0, len(second)):+= str(second[n])

=p1=p=first[first.find('.',2):-1]=second[second.find('.',2):-1]=first.split('.')first[0]=second.split('.')second[0]= []i in first:i not in second:.append(i)= []i in second:i not in first:.append(i)

=l2=l3=int(first[0])=k=[]second==[]:=[]:=int(second[-1])= [i+1 for i in range(n-1,k-1)].append(n)first[0]=0element in first:[i]=int(element);i=i+1=first+a=0element in second:[i]=int(element);i=i+1=str(first)=str(second).append('.')=0= [ element for element in first if element not in second ]=0element in hop:[i]=int(element);i=i+1=hop+hop1= ''=zn in range(0, len(hop)):+= str(hop[n]); b+='.'= sign + '.' + str(len(hop)) + '.' + b=numberRL(resul)=equal_to_one(y)result

3.2 Операція віднімання

minus(first,second):

'''(str,str)->strnumbers

>>>minus('0.4.7.6.5.4.','0.2.7.5.')

'0.2.6.4.'

>>>minus('1.4.7.6.5.4.','0.2.7.5.')

'1.3.8.7.4.'

'''first=='0.0.' and second=='0.0.':='0.0.'resultfirst[0]=='1' and second[0]=='1' and first[2:]==second[2:]:='0.0.'resultfirst[0]=='0' and second[0]=='0' and first[2:]==second[2:]:='0.0.'resultfirst=='0.0.':=secondsecond=='0.0.':=first:=C(first,second)first[0]==second[0] and first==h:=summa2(first,second)resultfirst[0]=='1' and second[0]=='0' or first[0]=='0' and second[0]=='1':=ConcatRl(first,second)=numberRL(sum)=equal_to_one(sum)resultfirst[0]==second[0] and second==h:=summa1for_min(first,second)result

summa1for_min_for_0g(first, second):

'''(str,str)->str

>>>summa1for_min_for_01('1.4.8.4.5.6.','0.0.')

'1.4.8.6.4.3.'

'''=''=0

second=='0.0.':first[0]=='0':n in range(0, len(first)):+= str(first[n])= bfirst[0]=='1':n in range(0, len(first)):+= str(first[n])= b

3.3 Операція множення

mnog(first,second):

'''(str,str)->strnumber

>>>mnog('0.3.14.3.2.','0.3.3.2.1.')

'0.6.17.16.15.7.5.3.'

'''first=='0.0.' or second=='0.0.':='0.0.'resultfirst[0]==second[0]:='0':='1'=first[first.find('.',2):-1]=second[second.find('.',2):-1]=first.split('.')first[0]=second.split('.')second[0]

#print(second)=int(first[0])

#print(k)=0element in first:[i]=int(element);i=i+1

=0element in second:[i]=int(element);i=i+1

#print(second)

=0=0=''=0=[]i in range(0,len(first)):j in range(0,len(second)):+=str(first[i]+second[j])+'.'=c.split('.')c[-1]

#print(c)=''n in range(0, len(c)):+= str(c[n]); b+='.'= sign + '.' + str(len(c)) + '.' + b

#print(resul)=numberRL(resul)=equal_to_one(y)result

3.4 Операція ділення

delen(first,second):

'''(str,str)->strnumber

>>>delen('0.3.5.3.2.','0.3.3.2.1.')

'0.6.17.16.15.7.5.3.'

'''first=='0.0.':='0.0.'resultfirst[0]==second[0] and first[2:]==second[2:]:='0.1.0.'resultfirst[0]!=second[0] and first[2:]==second[2:]:='1.1.0.'resultfirst[0]=='1' and second[0]=='0' or first[0]=='0' and second[0]=='1':='1'first[0]==second[0]:='0'=[]=0=first[0]=second=second[0]i in range(0,4):=first=first[first.find('.',2):-1]=second[second.find('.',2):-1]=first.split('.')first[0]=second.split('.')second[0]=0element in first:[i]=int(element)=i+1

# print(first)=0element in second:[i]=int(element);i=i+1

# print(second)=first[0]-second[0]-1=a

=0=''=0=[]=0j in range(0,len(second)):+=str(second[j]+a)+'.'=j+1

#print(c)=c.split('.')c[-1]

=''=0n in range(0, len(c)):+= str(c[n]); b+='.'=n+1=f+ '.' + str(len(c)) + '.' + b

#print(resul,'sec')

#print(g)=minus(g,resul)

# print(d,'fir')=str(resul)

#second=ho=str(d)

# print(ky,'ll')

#print(ho)=re=ky.append(u)=''n in range(0, len(jop)):+= str(jop[n]); b1+='.'= sign + '.' + str(len(jop)) + '.' + b1=numberRL(resul)=equal_to_one(y)result

Висновок

У результаті виконання курсового проекту було розроблено програмну модель системи з «безпомилковою арифметикою» на підставі спеціального арифметико-алгоритмічного базису.

Були протестовані програмні коди арифметичних дій у розрядно-логарифмічній формі. На основі створених бібліотек були проведені обрахунки та знаходження оберненої матриці. Шляхом перевірки було доведено, що дані, при обрахунку у розрядно-логарифмічній формі ідентичні простим арифметичним діям.

Отже, розрядно-логарифмічну арифметику можна назвати «безпомилковою арифметикою».

Список використаної літератури

1.Моделювання багато розрядних компютерних систем: Навч. Посібник. - К.: Книжкове вид-во НАУ, 2007.-112с.

2.Конспект лекцій з дисципліни «моделювання систем» .

ДодатОК

ConcatRl(num1, num2):

'''(str, str) -> strthe union of two Rl numbers.

>>> ConcatRl('0.3.5.2.1.', '1.2.7.3.')

'0.5.5.2.1.7.3.'

'''

= num1[0]= num2[0]

#if temp1 == temp2:= temp1

#else:

#sign = '0'= num1[2:num1.find('.',2)]= num2[2:num2.find('.',2)]= str(int(Temp1) + int(Temp2))= sign + '.' + Temp + num1[num1.find('.',2):-1] + num2[num2.find('.',2):]

result

numberRL(one):

'''(str)->strnumber we wanted to sort

>>>numberRL('0.4.3.6.-1.2.')

'0.4.6.3.2.-1.'

>>>numberRL('1.3.4.8.0.')

'1.3.8.4.0.'

'''=one.split('.')=list(one1)one1[-1]i in range(2,len(one1), 1):#stepj in range(2,len(one1) - 1):int(one1[j])<int(one1[j+1]):[j],one1[j+1]=one1[j+1],one1[j]

=''j in range(0,len(one1)):+=str(one1[j]);empty+='.'=emptyresultequal_to_one(num):

'''(str) -> strthe Rl number with unique elements.

>>> equal_to_one('0.6.5.4.4.2.0.-5.')

'0.4.6.2.0.-5.'

'''

= num[0]= num[num.find('.', 2)+1:]= temp.split('.')Temp[-1]= []n in range(0, len(Temp)):.append(int(Temp[n]))k in l:= 0; d = []n < len(l):l[n] in l[n+1:]::.append(l[n]); n += 1= d; d = []= ''n in range(0, len(l)):+= str(l[n]); b+='.'

#b = b[:-1]= sign + '.' + str(len(l)) + '.' + b

resultC(num1, num2):

'''(str, str) -> strthe largest of two Rl numbers or, if two numbers are equal,one of them.

>>> C('1.3.4.2.-1.', '0.2.-4.-8.')

'0.2.-4.-8.'

'''= num1[num1.find('.', 2) + 1:]= num2[num2.find('.', 2) + 1:]= temp1.split('.'); Temp2 = temp2.split('.')Temp1[-1]Temp2[-1]len(Temp1) >= len(Temp2):n in range(0, len(Temp2)):int(Temp1[n]) > int(Temp2[n]):= num1; breakint(Temp1[n]) < int(Temp2[n]):= num2; break:= num1len(Temp1) < len(Temp2):n in range(0, len(Temp1)):int(Temp1[n]) > int(Temp2[n]):= num1; breakint(Temp1[n]) < int(Temp2[n]):= num2; break:= num2resultsumma1for_min_for_0(first, second):

''(str,str)->str

>>>summa1for_min_for_0('0.0.','1.4.8.4.5.6.')

'0.4.8.6.4.3.'

'''=''=0

first=='0.0.':second[0]=='0':n in range(0, len(second)):+= str(second[n])= '1' + b[1:]second[0]=='1':n in range(0, len(second)):+= str(second[n])= '0' + b[1:]

resultsumma1for_min_for_0g(first, second):

'''(str,str)->str

>>>summa1for_min_for_01('1.4.8.4.5.6.','0.0.')

'1.4.8.6.4.3.'

'''=''=0

second=='0.0.':first[0]=='0':n in range(0, len(first)):+= str(first[n])= bfirst[0]=='1':n in range(0, len(first)):+= str(first[n])= b

result

summa1for_min(first, second):

'''(str,str)->str1 and 0'

first=='0.0.':=summa1for_min_for_0(first,second)second=='0.0.':=summa1for_min_for_0g(first,second)

=''=''first[0]==second[0]=='0':='1':='0'

#z=second[0]n in range(0, len(first)):+= str(first[n])n in range(0, len(second)):+= str(second[n])=p1=p

#print(first)

#print(second)=first[first.find('.',2):-1]=second[second.find('.',2):-1]=first.split('.')first[0]=second.split('.')second[0]= []i in first:i not in second:.append(i)= []i in second:i not in first:.append(i)=l2=l3=int(first[0])=k=[]

#n=int(second[-1])

#print(first)

#print(second)second==[]:=[]

:#change second na first=int(second[-1])= [i+1 for i in range(n-1,k-1)].append(n)first[0]

#print(hop1,'k')=0element in first:[i]=int(element);i=i+1=first+a

#print(first)=0element in second:[i]=int(element);i=i+1

#print(second)=str(first)

#print(do)=str(second)

#print(dop)

#second.append('.')=0=0

= [ element for element in first if element not in second ]=0element in hop:[i]=int(element);i=i+1=hop+hop1

#print(hop)= ''=zn in range(0, len(hop)):+= str(hop[n]); b+='.'= sign + '.' + str(len(hop)) + '.' + b

ВСТУП Сучасний стан представлення кодування даних у компютерному середовищі може характеризуватися як невідповідний між теоретичними результатами та їх п

Больше работ по теме: