SharedHomework_3.ipynbOpen in CoCalc

Задача A (1 балл).

Написать функцию times2(x), принимающую на вход число x и возвращающую это число, увеличенное в два раза.

# Внесите решение в эту ячейку
def times2(x):
    return x*2
assert(times2(1) == 2)
assert(times2(2) == 4)
assert(times2(-2) == -4)
assert(times2(0) == 0)
assert(times2(100) == 200)

Задача B (1 балла).

Написать функцию is_odd(n), проверяющую, является ли данное число n нечётным. Она должна возвращать True, если число нечётное, и False, если чётное.

# Внесите решение в эту ячейку
def is_odd(n):
    if n%2!=0: return True
    else: return False
assert(is_odd(1))
assert(not is_odd(2))
assert(not is_odd(0))
assert(is_odd(101))

Задача C (1 балл).

Написать функцию hello(n), выводящую на экран строчку Hello n раз подряд и ничего не возвращающую. Например, вызов hello(3) должен привести к выводу на экран

Hello
Hello
Hello
# Внесите решение в эту ячейку
def hello(n):
    for i in range(n):
        print('Hello')
buffer = []
passed = True
def print(*args, end = "\n", sep=" "):
    buffer.append(sep.join(map(str,args))+end)
def my_assert(q):
    global passed
    if not q:
        passed = False
def test_hello(n):
    buffer[:]=[]
    s = hello(n)
    my_assert(s == None)
    my_assert("".join(buffer).strip()==("Hello\n"*n).strip())
    buffer[:]=[]
test_hello(3)
test_hello(10)
test_hello(151)
del(print)
assert(passed)

Задача D. (2 балла)

Написать функцию num_div(n), вычисляющую, сколько у данного числа n делителей (включая 1 и само это число). Функция должна работать с целыми положительными числами.

# Внесите решение в эту ячейку
def num_div(n):
    if type(n)==int and n>0 :
        count=0
        for i in range(1,n+1):
            if n%i==0: count+=1
        return count
    else:return False
    
    
    
    
    
    
    # А по фен-шую что должна возвращать пользовательская функция при несоблюдении типа аргумента, и стоит ли прописывать такие проверки?
    
    
    
    
    
    
assert(num_div(1) == 1)
assert(num_div(2) == 2)
assert(num_div(3) == 2)
assert(num_div(100) == 9)
assert(num_div(1000) == 16)
assert(num_div(139) == 2)
assert(num_div(1289237) == 2)


assert(num_div(-1)==False)

Задача E (1 балл).

Написать функцию is_prime(n), проверяющую, является ли данное число n простым. Она должна возвращать True, если число является простым, и False в противном случае. Примечание. Можете использовать ранее написанную функцию num_div(n). (Вопрос: Является ли это самым эффективным способом решения данной задачи?)

# Внесите решение в эту ячейку
def is_prime(n):
    from math import sqrt
    if type(n)==int and n>0 :
        count=0
        for i in range(2,int(round(sqrt(n)+1,0))):
            if n%i==0: count+=1
    if count==0:return True
    else: return False
assert(is_prime(2) and 
       is_prime(3) and 
       is_prime(139) and 
       is_prime(617) and 
       is_prime(293) and 
       not is_prime(12) and 
       not is_prime(13*7))

Задача F. (2 балла)

Написать функцию med3(x,y,z), возвращающую медиану из чисел x, y, z (то есть то из этих чисел, которое будет стоять посередине, если их упорядочить). Пользоваться какими-либо библиотечными функциями нельзя!

# Внесите решение в эту ячейку
def med3(x,y,z):
    a=[x,y,z]
    a.sort()
    return a[1]
from itertools import permutations
def test_med3(x,y,z,m):
    for t in permutations([x,y,z]):
        assert(med3(*t) == m)
test_med3(1,1,1,1)
test_med3(1,1,2,1)
test_med3(1,2,2,2)
test_med3(1,2,3,2)
test_med3(0,1,2,1)
test_med3(100,200,300,200)
test_med3(100,101,1000,101)

Задача G. (2 балла)

Написать функцию mean(x1,x2,…), принимающую на вход несколько чисел и возвращающую их среднее арифметическое.

# Внесите решение в эту ячейку
def mean(*args):
    summa=0
    for i in range(len(args)):
        summa+=args[i]
    return summa/len(args)
assert(mean(1) == 1)
assert(mean(1,2,3) == 2)
assert(mean(1,5, 8, 12) == 6.5)
assert(mean(8, 9, 1, 2, 3, 11, 15) == 7.)

Задача H. (3 балла)

(Источник: informatics.mccme.ru.) Написать функцию second_occurance(s), принимающую на вход строку s и возвращающую индекс второго вхождения символа 'f'. Если символ 'f' в данной строке встречается только один раз, функция должна вернуть число -1, а если не встречается ни разу, функция должна вернуть число -2.

# Внесите решение в эту ячейку
def second_occurance(s):
    inline=[]
    for i,q in enumerate(s):
        if q=='f': inline.append(i)
    if len(inline)==0: return -2
    elif len(inline)==1: return -1
    else: return inline[1]
assert(second_occurance("comfort") == -1)
assert(second_occurance("coffee") == 3)
assert(second_occurance("qwerty") == -2)
assert(second_occurance("f") == -1)
assert(second_occurance("oooooooooooooooooof") == -1)
assert(second_occurance("ff") == 1)
assert(second_occurance("foooooooooooooof") == 15)
assert(second_occurance("oooooooooooooff") == 14)
assert(second_occurance("ofofofofofofofofo") == 3)

Задача J. (3 балла)

Написать функцию is_increasing(L, strict), проверяющую, является ли список L монотонно возрастающим/неубывающим. Если параметр strict установлен в True, то следует осуществить проверку на строгое возрастание (то есть функция должна возвращать True только если каждый следующий элемент списка строго больше предыдущего). Если параметр strict установлен в False, то функция должна проверять неубывание списка, то есть функция должна возвращать True если каждый следующий элемент списка не меньше предыдущего. Если параметр strict не установлен (функции передан только один параметр), то нужно проводить проверку на строгое возрастание.

# Внесите решение в эту ячейку
def is_increasing(L, strict=True):
    return L==sorted(L, reverse=not strict)


# Возможно ли тут применение sorted? А то с ним уж очень красивое решение получается



def is_increasing(L, strict=True):
    count=0
    if strict==True:
        for i in range(len(L)-1):
            if L[i]>=L[i+1]:count+=1
    if strict==False:
        for i in range(len(L)-1):
            if L[i]>L[i+1]:count+=1
    if count==0:return True
    else: return False
assert(is_increasing([1,2,3]))
assert(is_increasing([1,2,2],False))
assert(not is_increasing([1,2,2]))
assert(is_increasing([1,2,5,10,100]))
assert(is_increasing([1,2,5,10,100],True))
assert(not is_increasing([2,1]))
assert(not is_increasing([2,1],True))
assert(not is_increasing([2,1],False))
assert(is_increasing([1,2]))
assert(is_increasing([1,2], True))
assert(is_increasing([1,2], False))
assert(is_increasing([0,0], False))
assert(not is_increasing([0,0], True))
assert(not is_increasing([1,2,3,4,5,5]))
assert(not is_increasing([1,1, 2, 3, 4, 5]))


assert(is_increasing([1,1.5, 2, 3, 4, 5]))

#Ваня, теперь я точно знаю, где шедевр, а где кадавр!!!!)))
#Просто посмотри на мое кол-во строк для последней задачи...

def is_increasing(L, strict=True):#по умолчанию strict=True, но переобозначить данную переменную все равно можно
    temp=[]
    #проверка на строгое возрастание
    if strict==True:
        for i in range(0,len(L)-1):
            if L[i]<L[i+1]:
                temp.append(True)
            else: 
                temp.append(False)
            #print(temp)
        if (temp.count(False))>0:
            return(False)
        else:
            return(True) 
    #проверка на возрастание или монотонность
    elif strict==False:
        for i in range(0,len(L)-1):
            if L[i]<=L[i+1]:
                temp.append(True)
            else: 
                temp.append(False)
            #print(temp)
        if (temp.count(False))>0:
            return(False)
        else:
            return(True)
#Неее - смотри решение Андрея

def is_increasing(L, strict=True):
    val=True
    if strict==True:
        for i in range(len(L)-1):
            if L[i]>=L[i+1]:
                val=False
                break
    if strict==False:
        for i in range(len(L)-1):
            if L[i]>L[i+1]:
                val=False
                break
    return val