I want to make a program that returns a group of True variables that i found in my program. Like this:
1 = True
2 = True
3 = False
4 = False
5 = True
What I want is to return as a print
The true numbers are: 1, 2 and 5
Edit 1:
The code is a letter counter!
eacha letter in a group has a value.
Like
a=1
b = 2
...
If a number repeats more than 4 times, that number is a true
The group would be a name. like John in an imput.
The program reads it and gives a number for each letter.
what I am using right now is this (Preatty ugly I know, but I started programing this month...), where "a" is the amount of letter a in the name, b is the amount of b in the name....
if (a + j + s) >=4:
exe1 = 1
else:
exe1 = ""
if (b + k + t) >=4:
exe2 = 2
else:
exe2 = ""
if (c + l + u) >=4:
exe3 = 3
else:
exe3 = ""
if (d + m + v) >=4:
exe4 = 4
else:
exe4 = ""
if (e + n + w) >=4:
exe5 = 5
else:
exe5 = ""
if (f + o + x) >=4:
exe6 = 6
else:
exe6 = ""
if (g + p + y) >=4:
exe7 = 7
else:
exe7 = ""
if (h + q + z) >=4:
exe8 = 8
else:
exe8 = ""
if (i + r) >=4:
exe9 = 9
else:
exe9 = ""
print("Excesses:", exe1, exe2, exe3, exe4, exe5, exe6, exe7, exe8, exe9)
Why don't you use a dictionary? Take a look in this code as an example.
dict1 = {1:'True', 2:'True', 3:'False', 4:'False', 5:'True'}
list = []
for k, v in dict1.items():
if v == 'True':
#print(k, sep=' ', end=',')
list.append(k)
print(list)
Now you the list - although inside brackets and I don't know how to remove them since they are part of the list... Maybe iteration over it again should solve the problem, although I am not a truly expert in Python.
Related
I want to generate all possible permutations of a set of parentheses of a certain length N.
Example:
if N = 1
Output: ['()']
if N = 3
Output: ['()(())', '(())()', '(()())', '((()))', '()()()']
Credit: https://prepinsta.com/python-program/generate-all-combinations-of-balanced-parentheses/
def generateParenthesis(n, Open, close, s, ans):
if Open == n and close == n:
ans.append(s)
return
if Open < n:
generateParenthesis(n, Open + 1, close, s + "(", ans)
if close < Open:
generateParenthesis(n, Open, close + 1, s + ")", ans)
n = 3
ans = []
generateParenthesis(n, 0, 0, "", ans)
for s in ans:
print(s)
As a fresher I came up with this solution where I create all the possible combinations using the function generate_permutations and then create a new list with only valid parentheses:
def generate_permutations(current, perms, prefix=''):
if len(current) == 0:
perms.add(prefix)
for i in range(len(current)):
new_prefix = prefix + current[i]
new_current = current[:i] + current[i+1:]
generate_permutations(new_current, perms, new_prefix)
return perms
def refine(l):
os = list()
cs = list()
res = list()
for each in l:
flag = True
for e in each:
if e == '(':
os.append(e)
elif e == ')':
cs.append(e)
if os and os[-1] == '(':
os = os[:-1]
cs = cs[:-1]
else:
flag = False
break
if flag:
res.append(each)
return res
N = 3
string = "()" * N
answer_list = generate_permutations(string, set())
refined = refine(answer_list)
print(refined)
I have 3 functions.These are
A(n) = n(n+1)/2
B(n) = n(3n-1)/2
C(n) = n(2n-1)
Their first common output and indexes are:
A(285)=B(165)=C(143)=40755
I need second one,so I tried this:
def equation1(x):
return x*(x+1)/2
def equation2(x):
return x*((3*x)-1)/2
def equation3(x):
return x*((2*x)-1)
for i in range(144,30000):
x = equation3(i)
for a in range(i,2*i):
y = equation2(a)
if(x==y):
for b in range(a,2*a):
z = equation1(b)
if(x==y==z):
print("Term =" + str(x))
print("A" + str(b))
print("B" + str(a))
print("C" + str(i))
But it takes too much time to find it.How can I handle this in an easier way?
Since all three functions are increasing for positive values, you can write a loop that increases the number with the smallest value at each iteration:
a = b = c = 1
eq_a = equation1(a)
eq_b = equation2(b)
eq_c = equation3(c)
while True:
if eq_a == eq_b and eq_b == eq_c:
print("Found {}, {}, {}, result={}".format(a,b,c,eq_a))
if eq_a <= eq_b and eq_a <= eq_c:
a += 1
eq_a = equation1(a)
elif eq_b <= eq_a and eq_b <= eq_c:
b += 1
eq_b = equation2(b)
elif eq_c <= eq_a and eq_c <= eq_b:
c += 1
eq_c = equation3(c)
else:
print("Should never be here")
assert(False);
Test run:
Found 1, 1, 1, result=1
Found 285, 165, 143, result=40755
Found 55385, 31977, 27693, result=1533776805
Found 10744501, 6203341, 5372251, result=57722156241751
I'm trying to create a program which outputs how many times a specific character was used.
For example, if the sentence is I like bikes!
The output should be:
I = 1
l = 1
i = 2
k = 2
e = 2
b = 1
s = 1
! = 1
However my program does this
I = 1
l = 1
i = 2
k = 1
e = 2
b = 1
i = 2
k = 2
e = 2
s = 1
! = 1
So its doubling up the letters.
def count_char(text):
for char in text:
count = text.count(char)
print(char + ' = ' + str(count))
How can I fix this?
Instead of going through all the characters in text, go through all the characters in the alphabet, but report only those that are present:
def count_char(text):
for char in string.ascii_letters:
count = text.count(char)
if count:
print(char + ' = ' + str(count))
I suggest initializing a dictionary and updating the values as you run the for loop
def count_char(text):
answer={}
for char in text:
if char in answer:
answer[char]+=1
else:
answer[char]=1
print(answer)
this should give you the desired answer
If you want your output it ordered, you can derive a class from OrderedDict and Counter. If order does not matter, you can use Counter directly (as suggested by #user3483203 in a comment to your question).
from collections import OrderedDict, Counter
class OrderedCounter(Counter, OrderedDict):
pass
s = "I like bikes!"
c = OrderedCounter(s)
for char, count in c.items():
if char.strip(): # skip blanks
print(char + ' = ' + str(count))
Output:
I = 1
l = 1
i = 2
k = 2
e = 2
b = 1
s = 1
! = 1
You can try this:
def char_counter_printer(string):
if type(string) is not str:
return False
else:
chardict={}
charlist=[]
for char in string:
try:
chardict[char]+=1
except:
chardict[char]=1
charlist.append(char)
for ch in charlist:
if(ch.strip()):
print(ch,'=',chardict[ch])
char_counter_printer('I Like bikes!')
the output is:
I = 1
L = 1
i = 2
k = 2
e = 2
b = 1
s = 1
! = 1
as expected.
I am following Cormen Leiserson Rivest Stein (clrs) book and came across "kmp algorithm" for string matching. I implemented it using Python (as-is).
However, it doesn't seem to work for some reason. where is my fault?
The code is given below:
def kmp_matcher(t,p):
n=len(t)
m=len(p)
# pi=[0]*n;
pi = compute_prefix_function(p)
q=-1
for i in range(n):
while(q>0 and p[q]!=t[i]):
q=pi[q]
if(p[q]==t[i]):
q=q+1
if(q==m):
print "pattern occurs with shift "+str(i-m)
q=pi[q]
def compute_prefix_function(p):
m=len(p)
pi =range(m)
pi[1]=0
k=0
for q in range(2,m):
while(k>0 and p[k]!=p[q]):
k=pi[k]
if(p[k]==p[q]):
k=k+1
pi[q]=k
return pi
t = 'brownfoxlazydog'
p = 'lazy'
kmp_matcher(t,p)
This is a class I wrote based on CLRs KMP algorithm, which contains what you are after. Note that only DNA "characters" are accepted here.
class KmpMatcher(object):
def __init__(self, pattern, string, stringName):
self.motif = pattern.upper()
self.seq = string.upper()
self.header = stringName
self.prefix = []
self.validBases = ['A', 'T', 'G', 'C', 'N']
#Matches the motif pattern against itself.
def computePrefix(self):
#Initialize prefix array
self.fillPrefixList()
k = 0
for pos in range(1, len(self.motif)):
#Check valid nt
if(self.motif[pos] not in self.validBases):
self.invalidMotif()
#Unique base in motif
while(k > 0 and self.motif[k] != self.motif[pos]):
k = self.prefix[k]
#repeat in motif
if(self.motif[k] == self.motif[pos]):
k += 1
self.prefix[pos] = k
#Initialize the prefix list and set first element to 0
def fillPrefixList(self):
self.prefix = [None] * len(self.motif)
self.prefix[0] = 0
#An implementation of the Knuth-Morris-Pratt algorithm for linear time string matching
def kmpSearch(self):
#Compute prefix array
self.computePrefix()
#Number of characters matched
match = 0
found = False
for pos in range(0, len(self.seq)):
#Check valid nt
if(self.seq[pos] not in self.validBases):
self.invalidSequence()
#Next character is not a match
while(match > 0 and self.motif[match] != self.seq[pos]):
match = self.prefix[match-1]
#A character match has been found
if(self.motif[match] == self.seq[pos]):
match += 1
#Motif found
if(match == len(self.motif)):
print(self.header)
print("Match found at position: " + str(pos-match+2) + ':' + str(pos+1))
found = True
match = self.prefix[match-1]
if(found == False):
print("Sorry '" + self.motif + "'" + " was not found in " + str(self.header))
#An invalid character in the motif message to the user
def invalidMotif(self):
print("Error: motif contains invalid DNA nucleotides")
exit()
#An invalid character in the sequence message to the user
def invalidSequence(self):
print("Error: " + str(self.header) + "sequence contains invalid DNA nucleotides")
exit()
You might want to try out my code:
def recursive_find_match(i, j, pattern, pattern_track):
if pattern[i] == pattern[j]:
pattern_track.append(i+1)
return {"append":pattern_track, "i": i+1, "j": j+1}
elif pattern[i] != pattern[j] and i == 0:
pattern_track.append(i)
return {"append":pattern_track, "i": i, "j": j+1}
else:
i = pattern_track[i-1]
return recursive_find_match(i, j, pattern, pattern_track)
def kmp(str_, pattern):
len_str = len(str_)
len_pattern = len(pattern)
pattern_track = []
if len_pattern == 0:
return
elif len_pattern == 1:
pattern_track = [0]
else:
pattern_track = [0]
i = 0
j = 1
while j < len_pattern:
data = recursive_find_match(i, j, pattern, pattern_track)
i = data["i"]
j = data["j"]
pattern_track = data["append"]
index_str = 0
index_pattern = 0
match_from = -1
while index_str < len_str:
if index_pattern == len_pattern:
break
if str_[index_str] == pattern[index_pattern]:
if index_pattern == 0:
match_from = index_str
index_pattern += 1
index_str += 1
else:
if index_pattern == 0:
index_str += 1
else:
index_pattern = pattern_track[index_pattern-1]
match_from = index_str - index_pattern
Try this:
def kmp_matcher(t, d):
n=len(t)
m=len(d)
pi = compute_prefix_function(d)
q = 0
i = 0
while i < n:
if d[q]==t[i]:
q=q+1
i = i + 1
else:
if q != 0:
q = pi[q-1]
else:
i = i + 1
if q == m:
print "pattern occurs with shift "+str(i-q)
q = pi[q-1]
def compute_prefix_function(p):
m=len(p)
pi =range(m)
k=1
l = 0
while k < m:
if p[k] <= p[l]:
l = l + 1
pi[k] = l
k = k + 1
else:
if l != 0:
l = pi[l-1]
else:
pi[k] = 0
k = k + 1
return pi
t = 'brownfoxlazydog'
p = 'lazy'
kmp_matcher(t, p)
KMP stands for Knuth-Morris-Pratt it is a linear time string-matching algorithm.
Note that in python, the string is ZERO BASED, (while in the book the string starts with index 1).
So we can workaround this by inserting an empty space at the beginning of both strings.
This causes four facts:
The len of both text and pattern is augmented by 1, so in the loop range, we do NOT have to insert the +1 to the right interval. (note that in python the last step is excluded);
To avoid accesses out of range, you have to check the values of k+1 and q+1 BEFORE to give them as index to arrays;
Since the length of m is augmented by 1, in kmp_matcher, before to print the response, you have to check this instead: q==m-1;
For the same reason, to calculate the correct shift you have to compute this instead: i-(m-1)
so the correct code, based on your original question, and considering the starting code from Cormen, as you have requested, would be the following:
(note : I have inserted a matching pattern inside, and some debug text that helped me to find logical errors):
def compute_prefix_function(P):
m = len(P)
pi = [None] * m
pi[1] = 0
k = 0
for q in range(2, m):
print ("q=", q, "\n")
print ("k=", k, "\n")
if ((k+1) < m):
while (k > 0 and P[k+1] != P[q]):
print ("entered while: \n")
print ("k: ", k, "\tP[k+1]: ", P[k+1], "\tq: ", q, "\tP[q]: ", P[q])
k = pi[k]
if P[k+1] == P[q]:
k = k+1
print ("Entered if: \n")
print ("k: ", k, "\tP[k]: ", P[k], "\tq: ", q, "\tP[q]: ", P[q])
pi[q] = k
print ("Outside while or if: \n")
print ("pi[", q, "] = ", k, "\n")
print ("---next---")
print ("---end for---")
return pi
def kmp_matcher(T, P):
n = len(T)
m = len(P)
pi = compute_prefix_function(P)
q = 0
for i in range(1, n):
print ("i=", i, "\n")
print ("q=", q, "\n")
print ("m=", m, "\n")
if ((q+1) < m):
while (q > 0 and P[q+1] != T[i]):
q = pi[q]
if P[q+1] == T[i]:
q = q+1
if q == m-1:
print ("Pattern occurs with shift", i-(m-1))
q = pi[q]
print("---next---")
print("---end for---")
txt = " bacbababaabcbab"
ptn = " ababaab"
kmp_matcher(txt, ptn)
(so this would be the correct accepted answer...)
hope that it helps.
I've been trying to rearrange the string by reversing a particular strings consecutively from the given string input and the limit is given as input.
for example
limit is 3
if input is Hellothegamestarts
output must be Heltolhegemastastr
and it is saved in separate array
The code is:
while True:
t = int(input())
if t == 0:
break
string = raw_input()
string = string.encode('utf-8')
leng = len(string)
r = t/leng
m = []
leng = 0
for i in range(r):
if r % 2 == 0:
l = 0
l = leng + t
for i in range(t):
temp = string[l]
m.append(temp)
l = l - 1
r = r + 1
leng = leng + t
else:
l = 0
l = leng
for i in range(t):
temp = string[l]
m.append(temp)
l = l + 1
r = r + 1
leng = leng + t
print m
the output i got is [] and asks for next input for t.
Any help is appreciated.
Take the blocks in chunks of 3s, and reverse the odd ones, eg:
import re
s = 'Hellothegamestarts'
r = ''.join(
el if idx % 2 == 0 else el[::-1]
for idx, el in enumerate(re.findall('.{,3}', s))
)
# Heltolhegemastastr
Maybe you can try -
t = int(input())
if t == 0:
break;
string = raw_input()
m = ''
leng = len(string)
i = 0
while i < leng:
if (i/t) % 2 != 0:
m = m + string[i+t-1:i-1:-1]
else:
m = m + string[i:i+t]
i = i + t
print(m)
Alternatively you can try this
def myfunc(s, count):
return [''.join(x) for x in zip(*[list(s[z::count]) for z in range(count)])]
a='Hellothegamestarts'
lst=myfunc(a,3)
print "".join([i if lst.index(i) in range(0,len(lst),2) else i[::-1] for i in lst])
myfun i didn't write it.It's from here