We Keep Coding

Perfect number function [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 7 days ago.
Improve this question
Write a program in Python that exercises the functional higher order functions via Python list comprehensions to determine if a number is perfect or not. Write a function named perfect(num) that returns true/false if the given number is/is not perfect.
Use the built in Python function called range(n) that returns a list of integers between 0 and n-1 inclusive.
Use map implemented as a Python List Comprehension to add one to each element of the list.
Use filter implemented as a Python List Comprehension to generate a list of proper factors of n.
Use the Python reduce to generate a sum of those factors
Not more than 4-5 lines of code
def is_perfect(num):
sum = 0
for x in range(0, num-1):
if num % x == 0:
sum += x
return sum == num
print(Is_perfect(28))

Here you go:
def is_perfect(num):
sum = 0
for i in range(1, num):
if num % i == 0:
sum += i
if sum == num:
return True
else:
return False
Now to test it:
x = 8
print(is_perfect(x))
This returns False.
x = 28
print(is_perfect(x))
This returns True.
Some correction in your code
You calling not a correct function name Is_perfect(),
There is also error of modulo by zero,
As written you would inclusive (n-1) in your for loop it is running till (n-2) not till (n-1),
Code:
from functools import reduce
def is_perfect(num):
# List comprehension which store all the number which can be divisible.
list_comprehension = [x for x in range(0, num) if x == 0 or num % x == 0]
print(list_comprehension)
# [0, 1, 2, 4, 7, 14] for number 28
# [0, 1, 2, 4] for number 8
# sum of list using reduce.
sum_of_divisible_numbers = reduce(lambda x, y: x + y, list_comprehension)
return sum_of_divisible_numbers == num
print(is_perfect(28)) # True
print(is_perfect(8)) # False

Function to find a continuous sub-array which adds up to a given number in python [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed last month.
Improve this question
I want to know what's wrong in the below code. Will it consume more time to in some certain scenarios?
Expected time complexity: O(n)
def subArraySum(self,arr, n, s):
if sum(arr[0:n]) == s:
return [1, n]
if sum(arr[0:n]) < s:
return [-1]
start = 0
i =1
sum_elements = 0
while i < n:
sum_elements = sum(arr[start:i+1])
if sum_elements == s:
return [start+1, i+1]
if sum_elements < s:
i += 1
continue
if sum_elements > s:
start += 1
continue
if sum_elements < s:
return [-1]

Instead of running sum(arr[start:i+1]) in each iteration of the while loop, you should use a variable and add or subtract the respective value that is included or excluded from the subarray in each iteration. That way you can avoid the O(n^2) complexity and stay within O(n).
Currently there is a lot of overhead for calculating the sum of a (potentially large) subarray that has only changed by one single value at the beginning or the end during each iteration.

Sum of all the perfect squares [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
Since I am new to the python, someone please help me with this problem
here are the few examples how it should work:
input: l([1,4,9])
result=14
input: l(10,11,12,15)
result= 0

According to your question, you can declare a function is_square(n) to check a number whether perfect square or not.
Then, you take a number (i.e. val) from list l using this for val in l:. If number (i.e. val) is perfect square then it will add to the sm otherwise not.
You code will be like following code :
l = [1,4,9]
def is_square(n): # function for checking a number whether perfect square or not.
return n**0.5 == int(n**0.5)
sm = 0
for val in l:
if is_square(val): # if number is perfect square then it will add to the sm otherwise not.
sm += val
print(sm)

If I understood your question right, you are asking how to write a function to loop through all the values in a list, sum the numbers that are perfect squares, and ignore the others.
Here is my code with comments explaining what is going on.
# We need to use the math module in this program.
import math
# Function declaration
def sumSquares(numbers):
# Start by defining the sum as 0
sum = 0
# Loop through each number in the list
for num in numbers:
# Check if number is a square by:
# 1. Taking the integer square root of that number
# 2. Squaring it
# 3. And checking if that is equal to the original number
if num == int(math.sqrt(num)) ** 2:
# If it is a perfect square, add it to the total sum.
sum += num
You can call this function like:
sumSquares([1, 4, 9, 30])

Try this:
list = [4,9,55]
sq = []
for i in list:
if i**0.5 == int(i**0.5):
sq.append(i)
sum = 0
for i in sq:
sum = sum + i

Try This:
import math
a=map(int,input().split())
sum1=0
for i in a:
b=math.sqrt(i)
if math.ceil(b)==math.floor(b):
sum1+=i
print (int(sum1))

How does this for loop on consecutive integers work? [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
This seems like an embarrassingly easy concept but I can't understand why this for loop is working the way it is. The question is simply asking "Given a binary array, find the maximum number of consecutive 1s in this array."
def main(nums):
count = 0
for num in nums:
if num == 1:
count+=1
else:
count = 0
main([1,1,0,1,1,1,0,0,1,1,1,1,1])
My question is, why does this for loop work? I expected the loop to print out the total count of 1's.

It just doesn't work.
You can't expect to have the sum of all the 1s because when the loop find a zero it reset the counter (the "else" part).
However, your code doesn't do what it was expected to do, add a zero at the end of the list and you will easily see that the code fails.
To do what you asked, without changing your code too much, try this
def main(nums):
count = maxcount = 0
for num in nums:
if num == 1:
count+=1
else:
maxcount=max(maxcount, count)
count = 0
return maxcount
print(main([1,1,0,1,1,1,1,1,1,0,0,1,1,1,1,0,1]))
Dave

The difference is that once it sees a zero, it sets the value of count back down to zero, saying that it's seen 0 consecutive ones. This code actually doesn't work—it only gets lucky on this input because the longest sequence is at the very end of the list.
A better practice would be to store both the lengths of the current_group of ones and the highest_total count.

It's probably hard to believe, but could it be that the reason you are wondering why this loop works at all is that you are not familiar with Python ability to iterate over all elements of a list, not needing any counter variable increasing its value?
[1,1,0,1,1,1,0,0,1,1,1,1,1]
is in Python a kind of array storing multiple number of values.
Here some "pseudo-code" for explanatory purpose only demonstrating that "for num in nums" means in Python (in terms of programming in other
languages which don't support iteration over elements of a list/array):
noOfValuesIn_nums = lengthOf/sizeOf(nums)
for i = 0 to noOfValuesIn_nums do:
# get i=th value from 'nums' and put it to a variable named 'num':
num = nums[i]
...
By the way: the loop provided in the question gives the desired result for the provided example:
main([1,1,0,1,1,1,0,0,1,1,1,1,1])
but won't work on another one as demonstrated here:
def main(nums):
count = 0
for num in nums:
if num == 1:
count+=1
else:
count = 0
return count
print( main([1,1,1,1,1,1,0,0,1,1,1,0,1]) )
# it prints 1 instead of 6
The task of finding the longest consecutive sequence of ones
solves following code:
def main1(nums):
count = 0
maxOnes = 0
for num in nums:
if num == 1:
count+=1
else:
if count > maxOnes:
maxOnes = count
count = 0
return maxOnes
print( main1([1,1,1,1,1,1,0,0,1,1,1,0,1]) )
# gives 6

How to shift list indexes by a certain value in Python [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 4 years ago.
Improve this question
I need to create a python function that right shifts values in a list by a given value.
For example if the list is [1,2,3,4] and the shift is 2 it will become [2,3,4,1]. the shift value must be a non negative integer. I can only use the len and range functions.
This is what I have so far
def shift(array, value):
if value < 0:
return
for i in range(len(array)):
arr[i] = arr[(i + shift_amount) % len(arr)]

Usually you can do this with slicing
arr = arr[shift:] + arr[:shift]
Your shifted list is only shift = 1, not 2. You can't get your output by shifting 2 positions.

I make some modifications in your code (If you have to use len and range functions) :
def shift(array, shift_amount):
if shift_amount < 0:
return
ans = []
for i in range(len(array)):
ans.append(array[(i + shift_amount) % len(array)])
print ans
shift([1,2,3,4],2)
Output:
[3, 4, 1, 2]
Note:
Your's logic is correct but your overriding values in same array, So I created another list and append value to it.
If shift value is 1 then output will be [2, 3, 4, 1]. So for value 2 it will be two shifts that's why output should be [3, 4,
1, 2]
value and shift_amount are two different variables in your code, So I use only single variable.
You can use list comprehension (If you want to check in detail about list comprehension see this article Python List Comprehensions: Explained Visually) like
def shift(array, shift_amount):
if shift_amount < 0:
return
length = len(array)
print [array[(i + shift_amount) % length] for i in range(length)]
shift([1,2,3,4],0)