Number_programs/Numbers_programs.py at main · BrindhaAnandhan/Number_programs · GitHub

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

import math as m

# 1. prime number

def prime(num, fcount=0):
    for f in range (1, num+1):
        if (num %f == 0):
            fcount +=1
    return fcount == 2


# 2. composite number:

def composite(num, fcount=0):
    for f in range (1, num+1):
        if(f%num == 0):
            fcount += 1
    return f!=2


# 3. perfect  number:

def perfect(num, fsum =0):
    for f in range (1, num//2+1):
        if (num%f == 0):
            fsum+=f
    return fsum == num


# 4. pronic number

def pronic(num, n = 0):
    while (n*(n+1) <= num):
        if (n*(n+1)== num):
            return True
        else:
            n+=1
    return False


# 5. Niven num:

def n_sum(num, dsum = 0):
    while (num != 0):
        dsum += num % 10
        num //= 10
    return dsum
def niven(num):
    return (num % n_sum(num) == 0)


# 6. Sunny number: (n** = num+1)

def sunny(num, n = 1):
    while (n**2 <= num+1):
        if(n**2 == num+1):
            return True
        else:
            n += 1
    return False


# 7. Spy number

def s_prod(num, pro = 1):
    while (num != 0):
        pro *= num%10
        num//=10
    return pro

def spy(num):
    return n_sum(num) == s_prod(num)

# 8. Neon number

def neon(num):
    return num == n_sum(num ** 2)

# 9.Armstrong number

def arm_sum(num , p, dsum= 0):
    while (num != 0):
         rem = num% 10
         dsum += rem ** p
         num //=10
    return dsum

def armstrong(num):
    return num == arm_sum(num, len(str(num)))


# 10. disarium number:

def dis_sum(num, p, dsum = 0):
    while (num != 0):
        rem = num % 10
        dsum += rem ** p
        num //= 10
        p-=1
    return dsum

def disarium(num):
    return num == dis_sum(num, len(str(num)))


# 11. palindrom number

def reverse(num, rev = 0):
    while(num != 0):
        rem = num % 10
        rev = rev*10 + rem
        num//=10
    return rev

def palindrom(num):
    return reverse(num) == num


#12. palyprime

def palyprime(num):
    return num == reverse(num) and prime(num)


# 13. emirp number

def emrip(num):
    return num != reverse(num) and prime(num) and prime(reverse(num))

# 14. evil number:

def binary(num, count = 0):
    count+= num %2
    num//=2
    return count

def evil(num):
    return binary(num)%2 == 0

# 15. Strong number

def strong_sum(num, dsum = 0):
    while num != 0:
        rem = num %10
        dsum += m.factorial(rem)
        num //= 10
    return dsum
def strong(num):
    return num == strong_sum(num)

# 16. Happy number

def happy_sq(num):
    if num <9:
        dsum = 0
        while num != 0:
            rem = num % 10
            dsum += rem ** 2
            num //= 10
        num = dsum
    return num

def happy(num ):
        return happy_sq(num) == 1

# 17. Automarfic number

def automarfic(num):
    return num == (num**2) % 10 ** len(str(num))

def trimarfic(num):
    return num == (num**3) % 10 ** len(str(num))