<jupyter_start><jupyter_text>Exercitii: elemente de Python (Laborator 1)1. (fizz-buzz test) Sa se scrie numerele de la 1 la n; pentru fiecare multiplu de 2 se va scrie in locul numarului 'Fizz', pentru multiplu al lui 5 se va scrie 'Buzz'; daca numarul este multiplu de 10 se va scrie in locul lui 'FizzBuzz'.<jupyter_code>def fizz_buzz(n):
    for i in range(1, n+1):
        if i % 10 == 0:
            print('Fizz Buzz')
        elif i % 2 == 0:
            print('Fizz')
        elif i % 5 == 0:
            print('Buzz')
        else:
            print(i)
fizz_buzz(20)<jupyter_output>1
Fizz
3
Fizz
Buzz
Fizz
7
Fizz
9
Fizz Buzz
11
Fizz
13
Fizz
Buzz
Fizz
17
Fizz
19
Fizz Buzz<jupyter_text>2. Sa se calculeze scorul Scrabble al unui cuvant. Fiecare litera are asignata o anumita valoare (e.g. 'a' -> 3, 'f' ->7, 'z' -> 23; setati valori intr-un dictionar), iar scorul cuvantului se calculeaza ca suma scorurilor literelor componente. Literele mari si mici au aceeasi valoare.<jupyter_code>scores = {
        'a': 1,
        'b': 3,
        'c': 3,
        'd': 1,
        'e': 1,
        'f': 4,
        'g': 1,
        'h': 4,
        'i': 1,
        'j': 8,
        'k': 5,
        'l': 1,
        'm': 3,
        'n': 1,
        'o': 1,
        'p': 3,
        'q': 10,
        'r': 1,
        's': 1,
        't': 1,
        'u': 1,
        'v': 4,
        'w': 4,
        'x': 8,
        'y': 4,
        'z': 10
    }
    
    def scrabble_score(word):
        total = 0 
        for letter in word:
            letter = letter.lower()
            total += scores[letter]
        return total
    
    def scrabble_score2(word):
        return sum(scores[letter.lower()] for letter in word)

    theWord = input('Your word: ')
    print("Scrabble score of \'" + theWord + "\' is " + str(scrabble_score(theWord)))<jupyter_output>Your word:  pneumonoultramicroscopicsilicovolcanoconiosis<jupyter_text>3. Sa se determine daca doua cuvinte sunt unul anagrama celuilalt; exemplu LIBIA -> ABILI. Considerati sortarea caracterelor unui cuvant.<jupyter_code>cuv1 = input('First word: ')
cuv2 = input('Second word: ')

cuv1 = sorted(cuv1.lower())
cuv2 = sorted(cuv2.lower())

if (cuv1 == cuv2):
    print('The words are anagrams')
else:
    print('The words are NOT anagrams')<jupyter_output>First word:  libia
Second word:  abili<jupyter_text>4. Sa se verifice [conjectura Collatz](https://en.wikipedia.org/wiki/Collatz_conjecture) pentru numerele intre 1 si 1000.<jupyter_code>def collatz(number):
    while (number != 1):
        if (number % 2 == 0):
            number = number // 2
        else:
            number = 3 * number + 1

def collatzProof():
    for i in range(1, 1001):
        collatz(i)
    print('The conjecture is confirmed for numbers ranging from 1 to 1000.')
    
collatzProof()<jupyter_output>The conjecture is confirmed for numbers ranging from 1 to 1000.<jupyter_text>5. Sa se determine daca doua liste sunt una permutarea circulara a celeilalte. Exemplu: [1, 2, 3, 4] si [3, 4, 1, 2] sunt in aceasta situatie, dar nu si [1, 2, 3, 4] cu [3, 4, 2, 1].<jupyter_code>def isCircular(arr1, arr2):
    if len(arr1) != len(arr2):
        return False
    
    str1 = ' '.join(map(str, arr1))
    str2 = ' '.join(map(str, arr2))
    if len(str1) != len(str2):
        return False
    
    print(str1)
    print(str2)
    return str1 in str2 + ' ' + str2

arr1 = [1, 2, 3, 4]
arr2 = [3, 4, 1, 2]

print (isCircular(arr1, arr2))

arr1 = [1, 2, 3, 4]
arr2 = [3, 4, 2, 1]

print (isCircular(arr1, arr2))<jupyter_output>1 2 3 4
3 4 1 2
True
1 2 3 4
3 4 2 1
False<jupyter_text>6. Plecand de la o lista cu numere naturale, sa se creeze numarul obtinut prin concatenarea cifrelor existente. Exemplu: [11, 3, 24, 0, 993] -> 113240993.<jupyter_code>lista = [11, 3, 24, 0, 993]
number = ''
for item in lista:
    number += (str(item))
print(int(number))<jupyter_output>113240993<jupyter_text>7. Sa se creeze o functie care preia un numar n si returneaza un alt numar pe baza cifrelor lui n, astfel: se calculeaza numarul cifrelor pare din n (fie el si 0), numarul de cifre impare (poate fi si 0), suma lor si se formeaza numarul din acestea 2; daca exista zero nesemnificativ, acesta se va ignora. Numarul obtinut se va supune aceleiasi transformari. Exemplu: 3->11->22->202->303->123->123->123... Verificati ca dupa un numar finit de transformari se ajunge la numarul 123; faceti aceste verificari pentru numerele din intervalul [1,1000].<jupyter_code>def digitCounter(n):
    even = 0
    odd = 0
    while n != 0:
        if n % 2 == 0:
            even += 1
        else:
            odd += 1
        n = n // 10
    return (even, odd)

def _123Conjecture(n):
    while n != 123:
        (even, odd) = digitCounter(n)
        nr = ''
        if even != 0:
            nr += str(even)
        nr += str(odd)
        nr += str(even + odd)
        n = int(nr)
    return
        
for i in range(1, 1001):
    _123Conjecture(i)
print('Conjecture is verified for numbers ranging from 1 to 1000.')<jupyter_output>Conjecture is verified for numbers ranging from 1 to 1000.<jupyter_text>8. Se pleaca de la un numar intreg. Fiecare cifra a sa se scrie cu litere, in limba engleza (de exemplu 5->five). Calculati numarul total de caractere rezultate, iar pentru numarul obtinut repetati procedura. Verificati pentru numerele de la 1 la n ca se obtine intr-un numar finit de pasi numarul 4. Exemplu: 123->onetwothree->11->oneone->6->six->3->three->5->five->4->four->4->four....<jupyter_code>alpha = {
    '0':'zero',
    '1':'one',
    '2':'two',
    '3':'three',
    '4':'four',
    '5':'five',
    '6':'six',
    '7':'seven',
    '8':'eight',
    '9':'nine'
}


def fourConjecture(n):
    for number in range(1, n+1):
        word = ""; x = int(number)
        while x != 4:
            for digit in str(x):
                word += alpha[digit]
            x = len(word)
            word = ""
    print('The conjecture is confirmed for n = ' + str(n))
        
n = int(input('n = '))
fourConjecture(n)<jupyter_output>n =  456789<jupyter_text>9. Este rezultatul de mai sus valabil si pentru transcriere in limba romana/maghiara/franceza/alta limba la alegere? Contraexemplu in romana:47 (patrusapte) -> 10 (unuzero) -> 7 (sapte) -> 5 (cinci) -> 5 (cinci) ... 10. Se pleaca de la un numar n; se scriu toti divizorii sai, inclusiv 1 si n; se aduna *cifrele* tuturor acestor divizori; pentru numarul obtinut se aplica acelasi procedeu. Verificati ca procesul se stabilizeaza in numarul 15, , pentru un n initial oarecare.<jupyter_code>def digitSum(n):
    sum = 0
    while n != 0:
        sum += n % 10
        n = n // 10
    return sum

n = int(input("n = "))
stabilised = False

while not stabilised:
    sum = 0
    d = 1
    while d * d <= n:
        if (n % d == 0):
            if (n // d == d):
                sum += digitSum(d);
            else:
                sum += digitSum(d) + digitSum(n // d);
        d += 1
    if sum == n:
        print('Stabilized at sum = ' + str(sum))
        stabilised = True
    n = sum<jupyter_output>n =  48923764
{'fraction_non_alphanumeric': 0.12662889518413598, 'fraction_numerical': 0.04815864022662889, 'mean_word_length': 2.4938149430974765, 'pattern_counts': {'":': 0, '<': 29, '<?xml version=': 0, '>': 58, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '404889', 'license': 'MIT', 'n_tokens_mistral': 2905, 'n_tokens_neox': 2640, 'n_words': 851, 'path': '2020.02.07/2020.02.07.ipynb', 'repo_name': 'MateiSirbu/artificial-intelligence-basics', 'size': '7060'}