Räkna med programmering

Vi börjar med att skapa tre listor, p1, p2 och p3, som innehåller koordinaterna för triangelns tre hörn. Vi läser av dem från figuren.

Vi låter första elementet i listorna vara x-koordinaterna och element två vara y-koordinaterna.

p1 = [-4, -3] p2 = [-2, 3] p3 = [3, 2]

Vi vill nu beräkna avstånden mellan dessa punkter och för att göra det använder vi avståndsformeln. Enligt den ges avståndet mellan två punkter (x_1, y_1) och (x_2, y_2) av d = sqrt((x_2-x_1)^2 + (y_2-y_1)^2). Vi skriver om detta på kodform. Då skrivs roten med kommandot sqrt() från modulen math, så vi måste importera modulen i början av programmet. Om vi börjar med att räkna ut sidan mellan första och andra punkten blir x_1 listelementet p1[0], y_1 blir p1[1], x_2 blir p2[0] och y_2 blir p2[1].

import math p1 = [-4, -3] p2 = [-2, 3] p3 = [3, 2]

sida1 = math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)

Vi lägger till ytterligare två rader för de andra sidorna, alltså de mellan p2 och p3 respektive p3 och p1.

import math p1 = [-4, -3] p2 = [-2, 3] p3 = [3, 2]

sida1 = math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2) sida2 = math.sqrt((p3[0] - p2[0])**2 + (p3[1] - p2[1])**2) sida3 = math.sqrt((p1[0] - p3[0])**2 + (p1[1] - p3[1])**2)

För att hitta den längsta sidan lägger vi in alla sidlängder i en lista och använder funktionen max() på den. Vi sparar detta värde i en variabel, langsta_sida, och skriver ut den.

import math p1 = [-4, -3] p2 = [-2, 3] p3 = [3, 2]

sida1 = math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2) sida2 = math.sqrt((p3[0] - p2[0])**2 + (p3[1] - p2[1])**2) sida3 = math.sqrt((p1[0] - p3[0])**2 + (p1[1] - p3[1])**2) langst_sida = max([sida1, sida2, sida3]) print(langst_sida)

> 8.602325267042627

Med hjälp av programmet kan vi alltså bestämma att den längsta sidan är ungefär 8,6 l.e. lång.

De sista tre

Vi tittar först på rad 5.

A = x % 10**n

Talet n är 3, så 10**n blir 10^3 = 1000. Beräkningen är alltså x % 1000, vilket ger resten då talet x delas med 1000. Detta blir de tre sista siffrorna, vilket man kan förstå om man delar upp talet x: 634748103 = 634748000 + 103. Talet 634748000 är ett jämnt tusental, så det går jämnt upp när man delar med 1000. Däremot är 103 för litet för att bilda ett helt tusental och blir därför en rest.

De första tre

De sista siffrorna utgör alltså en rest då man delar x med en tiopotens. På samma sätt utgör de första siffrorna en heltalskvot då man delar med en tiopotens. Det kan vi förstå genom att temporärt byta ut % mot // på rad 5.

A = x // 10**n print(A)

> 634748

När % byts mot // plockas de fem första siffrorna ut ur x, eftersom 1000 ingår i x precis 634748 gånger (med 103 i rest). // är alltså ett verktyg för att plocka ut förstasiffror, men vi måste dela med rätt tiopotens! x // 1000 ger ju mer än bara de tre första siffrorna. Det är därför vi behöver rad 6.

p = math.ceil(math.log(x, 10))

Här beräknas antal siffror i talet x. Vi kan förstå det genom att beräkna tiologaritmen math.log(x, 10) för några olika tal.

import math print(math.log(14, 10)) print(math.log(320, 10)) print(math.log(7412, 10))

> 1.1461280356782377 2.505149978319906 3.869935410646859

Kom ihåg att lg(10)=1 och att lg(100) = 2. Därför kommer tiologaritmen av varje tal mellan 10 och 100 bli ett tal mellan 1 och 2. På samma sätt har alla tal mellan 100 och 1000 en tiologaritm mellan 2 och 3. Så genom att avrunda tiologaritmen uppåt med ceil matchar variabeln p alltid antal siffror i talet x.

import math x = 634748103 n = 3

A = x % 10**n p = math.ceil(math.log(x, 10)) print(p)

> 9

Vi såg tidigare att x // 10**3 gav de siffror som blir kvar när man tar bort de sista tre. Nu vill vi ändra exponenten så att vi skalar bort så många att bara tre siffror blir kvar! Antalet som ska skalas bort blir därför 3 mindre än antal siffror i talet: p - n. Med detta som exponent får vi mycket riktigt ut talets tre första siffror.

import math x = 634748103 n = 3

A = x % 10**n p = math.ceil(math.log(x, 10)) B = x // 10**(p - n) print(A) print(B)

> 103 634

Programmet fungerar faktiskt inte riktigt som det beskrivs för alla värden på x. Se t.ex. nedan, där samma program körs med ett annat x.

import math x = 482934049 n = 3

A = x % 10**n p = math.ceil(math.log(x, 10)) B = x // 10**(p - n) print(A) print(B)

> 49 482

Här skrivs bara de två sista siffrorna ut, inte tre! Det beror på att programmet hanterar tal och inte enstaka siffror. De tre sista siffrorna 049 tolkas då som talet 49. Det går att komma runt detta, t.ex. genom att använda strängar istället för tal, men lärdomen är att inte lita blint på kod man hittat på nätet!