So I have a list of 1s and 0s:
[1, 1, 0, 0, 1, 1, 0, 1, 1, 1]
and a list of numbers: [3, 4, 15]
I have to find all the prime factors of those numbers, and flip the states in the first list that correspond to the prime factors of those numbers.
So for the above example:
numbers[0] = 3, prime factors are just 3
So after the states were changed, the array look like:
[1, 1, 1, 0, 1, 0, 0, 1, 0, 1], so every (i + 1) % 3 == 0 positions were flipped
numbers[1] = 4, prime factors are just 2
So after the states were changed, the array look like:
[1, 0, 1, 1, 1, 1, 0, 0, 0, 0]
numbers[3] = 15, prime factors are just 3, 5
So after the states were changed, the array look like:
[1, 0, 0, 1, 1, 0, 0, 0, 1, 0]
[1, 0, 0, 1, 0, 0, 0, 0, 1, 1]
Heres what i have so far:
from collections import Counter
def prime_factors(num):
i = 2
factors = []
while i * i < = num:
if (num % i):
i += 1
else:
num //= i
factors.append(i)
if (num > 1):
factors.append(num)
return list(set(factors))
def flip(states, numbers):
factors = []
for num in numbers:
factors.extend(prime_factors(num))
facotrs = Counter(factors)
for key, val in factors.items():
if val % 2:
for i in range(len(states)):
if ((i + 1) % factor == 0):
states[i] = 1 if states[i] == 0 else 0
return states
This works fine, but for large lists, it TLEs.
How do I fix this to make it faster?
for key, val in factors.items():
if val % 2:
for i in range(len(states)):
if ((i + 1) % factor == 0):
states[i] = 1 if states[i] == 0 else 0
In the second for-loop, you don't need to start at 0 in range(len(states)). You can start with factor-1.
In states[i] = 1 if states[i] == 0 else 0,
you can replace this line with XOR operator:
states[i] = states[i]^1.
Try to optimize the prime number generator with the sieve of Eratosthenes. Should work withing a couple seconds for numbers less than 107
import math;
def sieve_primes(number):
a = [True if n>=2 and n%2==1 or n==2 else False for n in range(number+1)];
for x in range(3, (int)(math.sqrt(number))):
if a[x]:
for xx in range(x*x, number, x):
a[xx] = False;
primes = []
for i in range(len(a)):
if a[i]:
primes.append(i);
return primes;
Also, you could avoid multiple calls to the prime generator by finding the biggest number that you'll need to factorize, generating primes for it and storing them for later lookup.
This part:
for i in range(len(states)):
if ((i + 1) % factor == 0):
states[i] = 1 if states[i] == 0 else 0
seems too elaborate. How about (untested!):
for i in range(factor - 1, len(states), factor):
states[i] = 1 - states[i]
? That is, jump directly to all only the indices i such that i+1 is divisible by factor.
Making factoring very fast
Here's suitable sieve code as mentioned in a comment. If the maximum possible number "is large", of course this is an absurd approach. But you haven't told us. If it's up to a few million, this goes fast.
# Return list `sf` such that sf[i] is the smallest prime
# factor of `i`, for 2 <= i <= maxn.
def sieve(maxn):
from math import isqrt
sf = list(range(maxn + 1))
for i in range(4, len(sf), 2):
sf[i] = 2
for p in range(3, isqrt(maxn) + 1, 2):
if sf[p] == p:
for i in range(p * p, len(sf), p + p):
if sf[i] == i:
sf[i] = p
return sf
The whole thing
Here's a whole program. Code for sieve() was already given. Once that's called, it never needs to be called again.
It's often the case that successfully completing timed "programming challenges" crucially relies on the stated input constraints. You were asked several times to tell us what they were, but to no avail. My educated guess is that they put a relatively low limit on the maximum number that needs to be factored. The program here exploits that. But if they didn't put limits on it, there's scant hope for "a fast" solution, because efficient factoring of truly large integers remains a difficult, open research problem.
The method here tries to balance the time and space needed for preprocessing against the time needed to factor. It may or may not be "the best" tradeoff, depending on the still-unknown-to-us input constraints. For example, if the maximum number is "quite" small, you could fully compute - and store - the unique prime factors for every possible number in advance (although a sieve method would remain the fastest easy way to do that).
# Return list of unique prime factors of n.
def upf(n, sf):
result = []
while n > 1:
p = sf[n]
result.append(p)
n //= p
while n % p == 0:
n //= p
return result
MAXN = 1_000_000
sf = sieve(MAXN)
def crunch(nums, bits, sf):
from collections import defaultdict
pcount = defaultdict(int)
for num in nums:
for p in upf(num, sf):
pcount[p] += 1
for p, count in pcount.items():
if count & 1:
for i in range(p - 1, len(bits), p):
bits[i] = 1 - bits[i]
nums = [3, 4, 15]
bits = [1, 1, 0, 0, 1, 1, 0, 1, 1, 1]
expected = [1, 0, 0, 1, 0, 0, 0, 0, 1, 1]
crunch(nums, bits, sf)
assert bits == expected
Consider that we have an array of 1's and 0's ( a binary array).
We want to find an algorithm that finds the shortest subarray that contains k 1's.
Just to make it clear, the subarray can contain any amount of 0's but it must contain k 1's.
The algorithm must have time complexiy of O(n).
I tried to write a python code for this problem and this is what I've done so far:
def subarray(arr, k):
sp = 0 # The starting point of the subarray
ep = 0 #The ending point of the subarray
count = 0
result = (0, 0)
n = len(arr)
# Finding a sp
for i in range(0, n):
if arr[i]==1:
sp = i
count+=1
break
#finding a ep
for i in range(sp+1, n):
if arr[i]==1:
count+=1
if count==k:
ep = i
result = (sp, ep)
break
sp+=1
ep+=1
sfound = False
efound = False
while(1):
if ep>n:
break
if arr[sp]==1:
sfound = True
elif(sfound==False and arr[sp]!=1):
sp+=1
if arr[ep]==1:
efound = True
elif(efound==False and arr[ep]!=1):
ep+=1
if (ep-sp)<(result[1]-result[0]):
resut = (sp, ep)
# reseting every thing to start again
sp+=1
ep+=1
sfound = False
efound = False
return result
#main()
A=[0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1,
1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0]
k = 7
print(subarray(A,k))
But I think I wrote it in a complicated way, and it's doesn't give the right answer. I don't khow what's my mistake is?!🤔
Use two pointers, and keep track of the count of ones between them. Advance the appropriate counter to get & maintain k ones. Keep track of the min distance between pointers where you have k ones.
Suppose you have a list [1,2,3,4,5,0,0,0,7,8, ...]. Given a current index, what would be the best way to get the next non-zero index? For example, if index is 2, then the next non-zero one is 3; if 4, then 8.
a = [1,2,3,4,5,0,0,0,7,8]
def nextZeroIndex(array, start):
nextItems = array[start+1:]
for i, x in enumerate(nextItems):
if x != 0:
return 1 + start + i
print(nextZeroIndex(a, 2)) # 3
print(nextZeroIndex(a, 5)) # 8
print(nextZeroIndex(a, 4)) # 8
def get_next_index(lst, index):
try:
return next(i + index + 1 for i, n in enumerate(lst[index + 1:]) if n != 0)
except StopIteration:
return None
lst = [1, 2, 3, 4, 5, 0, 0, 0, 7, 8]
get_next_index(lst, 2) # 3
get_next_index(lst, 9) # None
get_next_index(lst, 100) # None
Iterate over the list starting from the specified index until you find a number different from zero, if the index is out of bounds or a non-zero is found return None
you could also achieve this using itertools:
from itertools import compress,count
start = 4
next = list(compress(count(),l[start+1:]))[0]+start+1
print(next)
output:
8
you can have a class where all the "valid" indices (non-zero value) are stored and when you want to find the next index for a non-zero value starting from a given index, you just search for the next valid index which is greater than your starting index
from bisect import bisect_right
class NextIndexNonZero:
def __init__(self, your_numbers: list):
# filter out the indices for zero values/numbers
valid_indices = filter(lambda x: x[1] != 0, enumerate(your_numbers))
self.valid_indices = list(map(lambda x: x[0], valid_indices))
self.max_index = self.valid_indices[-1]
def find(self, start_index: int) -> int:
if start_index >= self.max_index:
return f'There is no index non-zero greater than {start_index}'
next_index = bisect_right(self.valid_indices, start_index)
return self.valid_indices[next_index]
a = [1, 0, 0, 0, 1, 0, 0 ]
n = NextIndexNonZero(a)
print(n.find(2))
print(n.find(4))
output:
4
There is no index non-zero greater than 4
How to find the majority votes for a list that can contain -1s, 1s and 0s?
For example, given a list of:
x = [-1, -1, -1, -1, 0]
The majority is -1 , so the output should return -1
Another example, given a list of:
x = [1, 1, 1, 0, 0, -1]
The majority vote would be 1
And when we have a tie, the majority vote should return 0, e.g.:
x = [1, 1, 1, -1, -1, -1]
This should also return zero:
x = [1, 1, 0, 0, -1, -1]
The simplest case to get the majority vote seem to sum the list up and check whether it's negative, positive or 0.
>>> x = [-1, -1, -1, -1, 0]
>>> sum(x) # So majority -> 0
-4
>>> x = [-1, 1, 1, 1, 0]
>>> sum(x) # So majority -> 1
2
>>> x = [-1, -1, 1, 1, 0]
>>> sum(x) # So majority is tied, i.e. -> 0
0
After the sum, I could do this check to get the majority vote, i.e.:
>>> x = [-1, 1, 1, 1, 0]
>>> majority = -1 if sum(x) < 0 else 1 if sum(x)!=0 else 0
>>> majority
1
>>> x = [-1, -1, 1, 1, 0]
>>> majority = -1 if sum(x) < 0 else 1 if sum(x)!=0 else 0
>>> majority
0
But as noted previously, it's ugly: Python putting an if-elif-else statement on one line and not pythonic.
So the solution seems to be
>>> x = [-1, -1, 1, 1, 0]
>>> if sum(x) == 0:
... majority = 0
... else:
... majority = -1 if sum(x) < 0 else 1
...
>>> majority
0
EDITED
But there are cases that sum() won't work, #RobertB's e.g.
>>> x = [-1, -1, 0, 0, 0, 0]
>>> sum(x)
-2
But in this case the majority vote should be 0!!
I am assuming that votes for 0 count as votes. So sum is not a reasonable option.
Try a Counter:
>>> from collections import Counter
>>> x = Counter([-1,-1,-1, 1,1,1,1,0,0,0,0,0,0,0,0])
>>> x
Counter({0: 8, 1: 4, -1: 3})
>>> x.most_common(1)
[(0, 8)]
>>> x.most_common(1)[0][0]
0
So you could write code like:
from collections import Counter
def find_majority(votes):
vote_count = Counter(votes)
top_two = vote_count.most_common(2)
if len(top_two)>1 and top_two[0][1] == top_two[1][1]:
# It is a tie
return 0
return top_two[0][0]
>>> find_majority([1,1,-1,-1,0]) # It is a tie
0
>>> find_majority([1,1,1,1, -1,-1,-1,0])
1
>>> find_majority([-1,-1,0,0,0]) # Votes for zero win
0
>>> find_majority(['a','a','b',]) # Totally not asked for, but would work
'a'
You could use statistics.mode if you were using python >= 3.4 ,catching a StatisticsError for when you have no unique mode:
from statistics import mode, StatisticsError
def majority(l):
try:
return mode(l)
except StatisticsError:
return 0
The statistics implementation itself uses a Counter dict:
import collections
def _counts(data):
# Generate a table of sorted (value, frequency) pairs.
table = collections.Counter(iter(data)).most_common()
if not table:
return table
# Extract the values with the highest frequency.
maxfreq = table[0][1]
for i in range(1, len(table)):
if table[i][1] != maxfreq:
table = table[:i]
break
return table
def mode(data):
"""Return the most common data point from discrete or nominal data.
``mode`` assumes discrete data, and returns a single value. This is the
standard treatment of the mode as commonly taught in schools:
>>> mode([1, 1, 2, 3, 3, 3, 3, 4])
3
This also works with nominal (non-numeric) data:
>>> mode(["red", "blue", "blue", "red", "green", "red", "red"])
'red'
If there is not exactly one most common value, ``mode`` will raise
StatisticsError.
"""
# Generate a table of sorted (value, frequency) pairs.
table = _counts(data)
if len(table) == 1:
return table[0][0]
elif table:
raise StatisticsError(
'no unique mode; found %d equally common values' % len(table)
)
else:
raise StatisticsError('no mode for empty data')
Another way using a Counter and catching an empty list:
def majority(l):
cn = Counter(l).most_common(2)
return 0 if len(cn) > 1 and cn[0][1] == cn[1][1] else next(iter(cn),[0])[0]
You can count occurences of 0 and test if they are majority.
>>> x = [1, 1, 0, 0, 0]
>>> if sum(x) == 0 or x.count(0) >= len(x) / 2.0:
... majority = 0
... else:
... majority = -1 if (sum(x) < 0) else 1
... majority
0
This solution is based on counting occurrences and sorting:
import operator
def determineMajority(x):
'''
>>> determineMajority([-1, -1, -1, -1, 0])
-1
>>> determineMajority([1, 1, 1, 0, 0, -1])
1
>>> determineMajority([1, 1, 1, -1, -1, -1])
0
>>> determineMajority([1, 1, 1, 0, 0, 0])
0
>>> determineMajority([1, 1, 0, 0, -1, -1])
0
>>> determineMajority([-1, -1, 0, 0, 0, 0])
0
'''
# Count three times
# sort on counts
xs = sorted(
[(i, x.count(i)) for i in range(-1,2)],
key=operator.itemgetter(1),
reverse=True
)
if xs[0][1] > xs[1][1]:
return xs[0][0]
else:
# tie
return 0
if __name__ == '__main__':
import doctest
doctest.testmod()
Additionally, there is one if statements. As mentioned in the comments it is undefined what happens with
x = [1, 1, 0, 0, -1]
# These are your actual votes
votes = [-1, -1, -1, -1, 0]
# These are the options on the ballot
ballot = (-1, 0, 1)
# This is to initialize your counters
counters = {x: 0 for x in ballot}
# Count the number of votes
for vote in votes:
counters[vote] += 1
results = counters.values().sort()
if len(set(values)) < len(ballot) and values[-1] == values [-2]:
# Return 0 if there's a tie
return 0
else:
# Return your winning vote if there isn't a tie
return max(counters, key=counters.get)
A very simple approach.
a = [-1, -1, -1, -1, 0] # Example
count = {}
for i in a:
if i not in count:
count[i] = 1
else:
count[i] += 1
m_count = max(count.values())
for key in count:
if count[key] == m_count:
print key
In the above example the output will be -1,
however if there is a tie, both the keys will be printed.
I believe this works for all provided test cases. Please let me know if I did something wrong.
from collections import Counter
def fn(x):
counts = Counter(x)
num_n1 = counts.get(-1, 0)
num_p1 = counts.get(1, 0)
num_z = counts.get(0, 0)
if num_n1 > num_p1:
return -1 if num_n1 > num_z else 0
elif num_p1 > num_n1:
return 1 if num_p1 > num_z else 0
else:
return 0
from collections import Counter
result = Counter(votes).most_common(2)
result = 0 if result[0][1] == result[1][1] else result[0][0]
Error handling for empty votes lists or votes lists with a set cardinality of 1 is trivial and left as an exercise for the reader.
This works with any number of candidates. If there is a tie between two candidates it returns zero else it returns candidate with most votes.
from collections import Counter
x = [-1, -1, 0, 0, 0, 0]
counts = list((Counter(x).most_common())) ## Array in descending order by votes
if len(counts)>1 and (counts[0][1] == counts[1][1]): ## Comparing top two candidates
print 0
else:
print counts[0][0]
We compare only two candidates because if there is a tie between two candidates it should return 0 and it doesn't depend on third candidate value
An obvious approach is making a counter and updating it according to the data list x. Then you can get the list of numbers (from -1, 0, 1) that are the most frequent. If there is 1 such number, this is what you want, otherwise choose 0 (as you requested).
counter = {-1: 0, 0: 0, 1: 0}
for number in x:
counter[number] += 1
best_values = [i for i in (-1, 0, 1) if counter[i] == max(counter.values())]
if len(best_values) == 1:
majority = best_values[0]
else:
majority = 0
You don't need anything but built-in list operators and stuff, no need to import anything.
votes = [ -1,-1,0,1,0,1,-1,-1] # note that we don't care about ordering
counts = [ votes.count(-1),votes.count(0),votes.count(1)]
if (counts[0]>0 and counts.count(counts[0]) > 1) or (counts[1]>0 and counts.count(counts[1])>1):
majority=0
else:
majority=counts.index(max(counts))-1 # subtract 1 as indexes start with 0
print majority
3d line puts counts of respective votes in a new list, and counts.index() shows us which list position we find the max votes.
I would dare to say that this should be about as pythonic as it can, without getting into eye-gouging oneliners.
Upd: rewrote without text strings and updated to return 0 in case of several equal results (didnt notice this in the original post), added an IF for case if only one vote, eg votes=[-1]
from collections import Counter
def find_majority_vote(votes):
counter = Counter(votes)
most_common = counter.most_common(2)
if len(most_common)==2:
return 0 if most_common[0][1] == most_common[1][1] else most_common[0][0]
else:
return most_common[0][0]
import numpy as np
def fn(vote):
n=vote[np.where(vote<0)].size
p=vote[np.where(vote>0)].size
ret=np.sign(p-n)
z=vote.size-p-n
if z>=max(p,n):
ret=0
return ret
# some test cases
print fn(np.array([-1,-1, 1,1,1,1,0,0,0,0,0,0,0,0]))
print fn(np.array([-1, -1, -1, 1,1,1,0,0]))
print fn(np.array([0,0,0,1,1,1]))
print fn(np.array([1,1,1,1, -1,-1,-1,0]))
print fn(np.array([-1, -1, -1, -1, 1, 0]))