model solution to exercises for Python from 12.01.2010 (POS1: 1BHIF) sure that by the terms of three lengths of a triangle is given.
two sides must always be longer than the third. You have to check this for all the possibilities, for example
a = 3, b = 4, c = 1
true though, since a + b> c (7> 1) and b + c> a (4> 3), but not a + c> b (4 == 4) !
The solution uses a loop.
ist_dreieck def (a, b, c):
"" "returns True if defined by a, b and c is a valid triangle
" "" i = 3
while i> 0: if a +
b \u0026lt;= c:
return False # no triangle
a, b, c = b, c, a
i = i - 1 return True
One could of course also the problem by logical combination of tests solve:
ist_dreieck def (a, b, c):
"" "returns True if a, b and c is a valid triangle defined
" ""
if a +> b c and b + c> , a and c + a> b:
ret = True else
:
ret = False return ret
Or even this:
ist_dreieck def (a, b, c):
"" "returns True if by a, b and c is a valid triangle defined
"" "
return a +> b c and b + c> a and c + a> b
The second task is to examine whether two pages and an angle of a square is given. The two sides must be the same length (and greater than 0) and the angle 90 °:
ist_quadrat def (a, b, w):
"" "returns True, if defined by a and b and the angle w is a square
"" is "
square = False
if a> 0: if a == b
:
if w == 90:
square = True # else
not applicable because the variable already initialized with square is false.
return
square Or get shorter with logical equation:
ist_quadrat def (a, b, w):
"" "returns True if by a and b and the angle w "
return a == b and w == 90 and a> 0
The leap year examination could take place as follows:
def ist_schaltjahr (year):
" a
square is defined "delivered" " true if the given year is a leap year. Since 1582, the end is
Gregorian calendar, applicable to the following rule for the leap year
determination:
In all years, the year is divisible by four, the 29th
February, a leap day this year and it is a leap year.
An exception, however, the full century in 1700,
1800, 1900, etc., even secular years mentioned. Of these, only get those
a leap, that year is divisible by 400.
Every fourth year is thus a secular leap year.
For all years \u0026lt;= 1582 the function to False, because since the
leap year is not defined, otherwise the above rule applies "" "
if year \u0026lt;= 1582.
leap year = False elif
year% 400 == 0 :
leap year = True elif
year% 100 == 0:
leap year = False elif
year% 4 == 0:
leap year = True
else
leap year leap year = False return
years to 1582 can not be leap years, since the Gregorian calendar was first defined in 1582. To test the leap year test, a few words, but first the test function that checks a couple of dates, of which we know they are not a leap year, and numbers, which is well known that they are leap years:
def test_ist_schaltjahr ():
for the year in (1000, 1580, 1581, 1582, 1900, 1999, 2003): assert not
ist_schaltjahr (year)
for the year in (1996, 2000, 2004):
ist_schaltjahr assert (year)
print ("ist_schaltjahr ok ")
The statement assert
is used for programmers and to check the condition, which follows close behind, thought. For example:
assert 3 \u0026lt;4
The condition is true, therefore, continues to run the program. If the condition is FALSE, the program is terminated with an error message:
>>> assert 3> 4
Traceback (most recent call last): File
"", line 1, assert in
3> 4
AssertionError
addition, a text can be specified as an error message:
>>> assert 3> 4, "3 is not larger than 4"
Traceback (most recent call last): File
"", line 1, in
assert 3> 4, "3 is not larger than 4"
AssertionError: 3 is not greater than 4
Applied to the above test function, this means that whenever
not ist_schaltjahr (year) assert the function
ist_schaltjahr (year) the value
False Leifers must and if assert ist_schaltjahr (year) stands True be geleifert, so the resulting program is not canceled. The next point for the year in (1000, 1580, 1581, 1582, 1900, 1999, 2003): line. The variable year get in turn the values 1000, 1580, 1581, 1582, 1900, 1999, 2003 and the indented block of code (one line) runs. This is the for-loop, which is explained in the book in Chapter 7 also. The function test_ist_schaltjahr () reviewed so first a few years that have not a leap year and a few leap years. The Fibonacci numbers can be determined as follows: def fib (n):
"" "returns to the Fibonacci number n. The numbers are defined as follows:
fib (0) -> 0
fib (1) -> 1
fib (2) -> 1
fib (3) -> 2
fib (4) -> 3
fib (5) -> 5
fib (6) -> 8
...
fib (10) -> 55
...
fib (15) -> 610 "" "f = 0
a = 0 b = 1
i = 0 while i \u0026lt;n: f = a + b
b, a = a, f
f + i = return 1
For n = 0 and n = 1 pre-defined the (initial) values.
fib (0) = 0 and fib (1) = 1 . then the rule is that the nth Fibonacci number is the sum of the two predecessors, is therefore
fib (n - 1) + Fib (n - 2) (See also Wikipedia:
Fibonacci sequence ). The variable f
always has the value of the current Fibonacci number and is therefore initialized with 0. The variables a and b always have the value of the two predecessors. You can see the light when you print
(...) insert statements, and can thereby indicate the end of the calculation:
def fib (n):
"" "returns the Fibonacci number to n." ""
f = 0 a = 0 b = 1
i = 0 while i \u0026lt;n: f = a + b
print (i, ": f =" f "a =" a, " b = ", b) # test output
b, a = a, f = f + i
return 1
print (fib (10))
there .. then from the following:
0: f = 1 a = 0 b = 1
1: f = 1 a = 1 b = 0
2: f = 2 a = 1 b = 1
3: f = 3 a = 2 b = 1
4: f = 5 a = 3 b = 2
5: f = 8 a = 5 b = 3
6: f = 13 a = 8 b = 5
7: f = 21 a = 13 b = 8
8: f = 34 a = 21 b = 13
9: f = 55 a b = 34 = 21 55
The output of a table by using the function
fib () is simple (or at least somewhat complicated, because to get the brackets): def
fibtab (s):
"" "creates a table of Fibonacci numbers are up as inclusive n.
fibtab (10) from the following:
[0, 1, 1, 2, 3, 5, 8]
fibtab or (100):
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Note
print to use as line break, "" when, so
print (value, end = ',')
except . of course, the last value, here is "]" demanded
"" "i = 0
print ("[", end =" ")
f = fib (i)
while f \u0026lt;= n:
print ( f, end = "") i + = 1
f = fib (i)
n if f>:
print ("]")
else
print ("," end = "")
We must ensure that first
"[" without line break is issued. The function print (...)
has an optional parameter
end that specifies what is to be issued at the end. By default, the
"\\ n" , which causes a line break. Substituting the value
end = "" , then an empty string, so nothing is printed. In the loop, you must consider is whether you get to the end and in this case
"]" (With word wrap) outputs. Normally, a comma is output without line (last line). Note
n, the parameter
n here indicates the limit of the Fibonacci numbers and which number (as in
fib (n) ). The solution, for example, the sum of multiples of 3 and 5 is less than a maximum:
def sum_3_5 (max).
"" "
frame sum of multiples of 3 and 5 is less than max
provides example sum_3_5 (10) 23 because
the multiples of 3 \u0026lt;10 are
3 + 6 + 9 = 18
the multiples of 5 \u0026lt;10 are
5 18 + 5 = 23
sum_3_5 (20) returns 78, because
3 + 6 +9 + 12 +15 +18 = 63
(15 is already included in the list above!) 5 + 10 = 15 +
sum_3_5 (25) returns 143, because
3 + 6 +9 + 12 + 18 + 21 +24 = 93 (multiples of 5 are lower)
5 + 10 + 15 + 20 = 50
sum_3_5 (100) returns in 2318 (without proof)
"" "sum =
0
i = 0
while i \u0026lt;max:
if i% 5 == 0: sum + = i
elif i% 3 == 0: sum + = i
i + = 1 return sum
The control variable
i will always be counted on to
sum if it is divisible by 5, or if it is divisible by 3. The operator calculates
% the rest of the division. If the remainder is 0, then the first number is divisible by the second. The example to find the next smaller or the same square can be solved with a tasting method:
def minquad (number):
"" "find the next smaller or equal integer, a
is square numerical examples.
minquad (16 ) -> 16 (because 4 * 4 = 16 \u0026lt;= 16)
minquad (24) -> 24 (because 4 * 4 = 16 \u0026lt;= 14)
minquad (25) -> 25 (because 5 * 5 = 25 \u0026lt;= 25)
minquad (26) -> 25 (because 5 * 5 = 25 \u0026lt;= 26)
"" "i = 0
mq = 0
while i ** 2 \u0026lt;= number.
mq = i ** 2
i + = 1 return mq
i mean i ** 2 2 You could of course also
i * i write. This function simply checks all the squares successively, until one was found, which is larger than the given number. The value
before (the variable
mq) is of course the result, because the most Value was valid for the condition. Of course it's faster and easier, if you look at a formula reflects:
from math import sqrt
from math import floor
def minquad (number):
"" "find the next smaller or equal integer, a
is square. Examples:
minquad (16) -> 16 (because 4 * 4 = 16 \u0026lt;= 16)
minquad (24) -> 16 (because 4 * 4 = 16 \u0026lt;= 24)
minquad (25) - > 25 (because 5 * 5 = 25 \u0026lt;= 25)
minquad (26) -> 25 (because 5 * 5 = 25 \u0026lt;= 26)
"" "
return int (floor (sqrt (number))) ** 2
The function floor (x) provides the nearest integer to x (for positive numbers'll cut off the fractional function of the given number). Eg
>>> from math import floor
>>> floor (3.14)
3>>> floor (3)
3>>> floor (- 3.14) -4
If one squares the nearest whole number of the root, you get the desired result. The Turtle could draw triangle function to look like and do not need further be explained:
def triangle (a, w):
"" "draws an equilateral triangle of side a, rotated by
the angle w. w = 0 means that one side is horizional w = means 90
. that the triangle is rotated to the left by 90 °, ie a page
is vertical.
The triangle should be drawn right next to the selected point.
"" "#
assume Turtle looks up (and starting)
right (90 - w)
PenDown ()
for i in range (3):
forward (a)
left (120)
penup ()
left (90 - w)
To a triangle to a to allow certain position, in addition, the function
SETPOS (x, y) which the turtle to change the position x is, y used:
dreieck_an_pos def (a, w, x, y):
"" " draws a triangle using the triangle function (a, w) at the
position x, y. "" "
penup ()
SETPOS (x, y)
triangle (a, w)
Apart from the Turtle features You can test the functions http://codepad.org directly on the site
. There you can also try some other programming languages. The Python version is unfortunately not up to date, so it could be that some but not direct how it works. These simple examples work fine.
Here to
minquad (number) to see :