import random
number = random.sample(range(0,9999), 10)
print(number, file = open("output.txt","a"))
I want to add (prefix) characters to a randomly generated number.
e.g. AAA(number) so that it will become something like AAA4525. What's the best way to do it?
import random
PREFIX = 'AAA'
numbers = random.sample(range(0,10000), 10) # to include also 9999
with open("output.txt","a") as f:
for number in numbers:
f.write(f'{PREFIX}{number:0>4d}\n')
Simple Concatenation can do the trick for you ..
def converter():
string="AAA"
ans= string+str(number)
return ans
Related
how to get a list of 1000 random float numbers without dublicates and find their mean value in python?
import random
rnd_number=random.random()
def a():
l=[]
m=1
for i in range(1000):
l.append(rnd_number)
return l
for i in l:
m=m+i
return m//b
print (a())
i am probably wrong with returning l before the other operation but when the code works there are 1000 of the same float numbers on the screen
Hope this would help!
import numpy as np
import random
N=10
# number of digits you want after the .dot sign
# more digits .dot ensure mo duplication
Npts=1000
# number of random numbers
num=[]
# initialize the array
for m in range(1000):
nm=round(random.random(), N)
# local variable to take the random numbers
num.append(nm)
# append the random number nm to the original num array
print(num)
# printing the random numbers
# Let's check is there is a duplication or not
my_num=set(num)
if len(num)!=len(my_num):
print("Duplication in the array")
else:
print("NO duplication in the array")
# Calculating mean
avg=sum(num)/Npts
print(avg)
If you want to have distinct random numbers, you have to draw number on every loop iteration. To avoid duplicates you can use set, which stores unique values.
import random
def a():
mySet = set()
while len(mySet) < 1000:
mySet.add(random.random())
return mySet
print(a())
import random
def a():
s=0
m=0
l=[]
for i in range(1000):
rnd_number=random.random()
l.append(rnd_number)
for n in l:
m=m+n
m=m/len(l)
for k in l:
s=s+(k-m)**2
s=(s/len(l))**(1/2)
return l,m,s
print (a())
i did like this and got the right answers for both the mean and standart devaiation of 1000 random float numbers
(i checked it with 4 actually but i think it is gonna work for 1000 too)
Alice is taking a cryptography class and finding anagrams to be very useful. We consider two strings to be anagrams of each other if the first string's letters can be rearranged to form the second string. In other words, both strings must contain the same exact letters in the same exact frequency For example, bacdc and dcbac are anagrams, but bacdc and dcbad are not.
Alice decides on an encryption scheme involving two large strings where encryption is dependent on the minimum number of character deletions required to make the two strings anagrams. Can you help her find this number?
Given two strings, a and b, that may or may not be of the same length, determine the minimum number of character deletions required to make a and b anagrams. Any characters can be deleted from either of the strings.
For example, if a=cde and b=dcf, we can delete e from string a and f from string b so that both remaining strings are cd and dc which are anagrams.
The code I tried.
import math
import os
import random
import re
import sys
from collections import Counter
# Complete the makeAnagram function below.
def makeAnagram(str1, str2):
new= str1 + str2
unique =[]
z=0
for char in new[:]:
a = new.count(char)
if a%2!=0 and char not in unique:
z=z+(a%2)
unique.append(char)
a=0
return z
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
a = input()
b = input()
res = makeAnagram(a, b)
fptr.write(str(res) + '\n')
fptr.close()
For Input
fcrxzwscanmligyxyvym
jxwtrhvujlmrpdoqbisbwhmgpmeoke
My output is 14
As per the answers given, the output should be 30.
The function seems to work. I'm not familiar with the way you are writing to the file try using this instead:
fptr = open("MyFile.txt","w")
It turns out that this is the symmetric difference between two counters. Which can be computed more efficiently directly, but via the interface of Counter, it can be expressed as (x - y) + (y - x).
a = "fcrxzwscanmligyxyvym"
b = "jxwtrhvujlmrpdoqbisbwhmgpmeoke"
from collections import Counter
x = Counter(a)
y = Counter(b)
sum(((x - y) + (y - x)).itervalues()) # => 30
For why the Counter class doesn't have this as a method see Why is there no symmetric difference for collections.Counter?
I am trying to generate 4-6 unique numbers in python but when I do uuid.uuuid4(), it generates something like 23dfsFe823FKKS023e343431. Is there a way I can achieve this, generate 4-6 unique numbers like 19391 or 193201.
NB: Beginner with python
yes, to make life easy lets use an easy example.
#lets import random, to generate random stuff
import random
#create a result string
result = ''
nums = [1,2,3,4,5,6,7,8,9,0]
for i in range(6):
result += str(random.choice(nums))
print(result)
UUID is for generating Universally Unique Identifiers, which have a particular structure and won't be what you're after.
You can use the random module as follows
import random
id = ''.join(str(random.randint(0,10)) for x in range(6))
print(id)
What does this do?
randint generates a random number between 0 inclusive and 10 exclusive, i.e. 0-9
calling this with for x in range(6) generates six random digits
str converts the digits to strings
''.join forms a single string from the digits
Try this:
import random
nums = set()
while len(nums) < 4: # change 4 to appropriate number
nums.add(random.randint(0, 1000000))
For example:
>>> nums
set([10928, 906930, 617690, 786206])
You can use random from standard python library
random.randint(a, b)
Return a random integer N such that a <= N <= b.
https://docs.python.org/3/library/random.html#random.randint
In [1]: from random import randint
In [2]: randint(1_000, 999_999)
Out[2]: 587848
In [3]: randint(1_000, 999_999)
Out[3]: 316441
To generate N number of a random number or token by specifying a length of Token this will be an easy and feasible solution.
import random
#num[]: by the combination of this, a random number or token will be generated.
nums = [1,2,3,4,5,6,7,8,9,0]
#all the tokens or random number will be stored in a set called tokens.
#here, we are using a set, because the set will never contain duplicate values.
tokens = set()
result='' #to store temporaray values
while len(tokens) < 10000: # change 10000 to the appropriate number to define the numbers of the random numbers you want to generate.
#change 6 to appropiate number to defined the length of the random number.
for i in range(6):
result+=str(random.choice(nums))
tokens.add(result)
result=''
print(tokens)
#print(len(tokens))
#print(type(tokens))
if you want to use uuid to generate number then you can code something like this
digit = 5 # digits in number
import uuid
for i in range(6):
print(uuid.uuid4().int[:digit])
Or
from uuid import uuid4
result = [ uuid4().int[:5] for i in range(6) ]
so what I am trying to do is create a list of 5 numbers for the game mastermind, and I would like to eliminate all duplicates! The issue is that the code sometimes creates a list with 3 numbers, or 4, or sometimes 5, it seems to be random.
I should also mention we are not allowed to be usin grandom.sample, or random.shuffle
import random
def generatePassword() :
lis = []
for i in range(5) :
#This checks to see if there are duplicate numbers
r = random.randint(1,9)
if r not in lis :
lis.append(r)
i+=1
return lis
def main() :
print(generatePassword())
main()
Use numpy.random.permutation if you are looking for method that works and is faster:
import numpy as np
your_list = list(np.random.permutation(np.arange(0,10))[:5])
>>> your_list
[6, 9, 0, 1, 4]
Alternatively, you can use np.random.choice with replace=False:
your_list = list(np.random.choice(np.arange(0,10), 5, replace=False)
Try using a while loop with a condition that checks for the length of lis
while len(lis) < 5:
instead of your for loop
The function random.sample does what you want:
import random
def generatePassword():
numbers = range(0, 9)
return random.sample(numbers, 5)
def main() :
print(generatePassword())
main()
I do not recommend the solution in this answer - the best option in the standard library is probably random.sample, and there may be more efficient methods using numpy. Both of these options are suggested in other answers.
This method uses random.shuffle to shuffle a list of digits, then selects the first five. This avoids the issue of a theoretically unbounded loop (while len(nums) < 5:), but does not scale well when the range of numbers to choose from (here, 1 to 9) is significantly larger than how many numbers are needed (here, 5).
import random
population = list(range(1, 10))
random.shuffle(population)
print(population[:5])
You don't want to add random, unique integers 5 times; you want to add random, unique integers until your list contains 5 elements. This'll do it:
import random
def generatePassword() :
lis = []
while len(lis) < 5:
#This checks to see if there are duplicate numbers
r = random.randint(1,9)
if r not in lis :
lis.append(r)
return lis
So your problem:
It won't add the same number twice. But since you use a for i in range(5): it will only repeat 5 times, regardless of if it added a unique number or not.
You need to measure the length of the list, so it will always add 5 random, unique numbers to the list.
You have the code mostly right, but all you need to do is replace:
for i in range(5): with: while len(lis) < 5:
Make sure to delete the i += 1 though. It will cause an error if you don't.
Here's the code:
import random
def generatePassword() :
lis = []
while len(lis) < 5:
#This checks to see if there are duplicate numbers
r = random.randint(1,9)
if r not in lis :
lis.append(r)
return lis
def main() :
print(generatePassword())
main()
Let's say I need a 3-digit number, so it would be something like:
>>> random(3)
563
or
>>> random(5)
26748
>> random(2)
56
You can use either of random.randint or random.randrange. So to get a random 3-digit number:
from random import randint, randrange
randint(100, 999) # randint is inclusive at both ends
randrange(100, 1000) # randrange is exclusive at the stop
* Assuming you really meant three digits, rather than "up to three digits".
To use an arbitrary number of digits:
from random import randint
def random_with_N_digits(n):
range_start = 10**(n-1)
range_end = (10**n)-1
return randint(range_start, range_end)
print random_with_N_digits(2)
print random_with_N_digits(3)
print random_with_N_digits(4)
Output:
33
124
5127
If you want it as a string (for example, a 10-digit phone number) you can use this:
n = 10
''.join(["{}".format(randint(0, 9)) for num in range(0, n)])
If you need a 3 digit number and want 001-099 to be valid numbers you should still use randrange/randint as it is quicker than alternatives. Just add the neccessary preceding zeros when converting to a string.
import random
num = random.randrange(1, 10**3)
# using format
num_with_zeros = '{:03}'.format(num)
# using string's zfill
num_with_zeros = str(num).zfill(3)
Alternatively if you don't want to save the random number as an int you can just do it as a oneliner:
'{:03}'.format(random.randrange(1, 10**3))
python 3.6+ only oneliner:
f'{random.randrange(1, 10**3):03}'
Example outputs of the above are:
'026'
'255'
'512'
Implemented as a function that can support any length of digits not just 3:
import random
def n_len_rand(len_, floor=1):
top = 10**len_
if floor > top:
raise ValueError(f"Floor '{floor}' must be less than requested top '{top}'")
return f'{random.randrange(floor, top):0{len_}}'
Does 0 count as a possible first digit? If so, then you need random.randint(0,10**n-1). If not, random.randint(10**(n-1),10**n-1). And if zero is never allowed, then you'll have to explicitly reject numbers with a zero in them, or draw n random.randint(1,9) numbers.
Aside: it is interesting that randint(a,b) uses somewhat non-pythonic "indexing" to get a random number a <= n <= b. One might have expected it to work like range, and produce a random number a <= n < b. (Note the closed upper interval.)
Given the responses in the comments about randrange, note that these can be replaced with the cleaner random.randrange(0,10**n), random.randrange(10**(n-1),10**n) and random.randrange(1,10).
You could write yourself a little function to do what you want:
import random
def randomDigits(digits):
lower = 10**(digits-1)
upper = 10**digits - 1
return random.randint(lower, upper)
Basically, 10**(digits-1) gives you the smallest {digit}-digit number, and 10**digits - 1 gives you the largest {digit}-digit number (which happens to be the smallest {digit+1}-digit number minus 1!). Then we just take a random integer from that range.
import random
fixed_digits = 6
print(random.randrange(111111, 999999, fixed_digits))
out:
271533
You could create a function who consumes an list of int, transforms in string to concatenate and cast do int again, something like this:
import random
def generate_random_number(length):
return int(''.join([str(random.randint(0,10)) for _ in range(length)]))
I really liked the answer of RichieHindle, however I liked the question as an exercise. Here's a brute force implementation using strings:)
import random
first = random.randint(1,9)
first = str(first)
n = 5
nrs = [str(random.randrange(10)) for i in range(n-1)]
for i in range(len(nrs)) :
first += str(nrs[i])
print str(first)
From the official documentation, does it not seem that the sample() method is appropriate for this purpose?
import random
def random_digits(n):
num = range(0, 10)
lst = random.sample(num, n)
print str(lst).strip('[]')
Output:
>>>random_digits(5)
2, 5, 1, 0, 4
I know it's an old question, but I see many solutions throughout the years. here is my suggestion for a function that creates an n digits random string with default 6.
from random import randint
def OTP(n=6):
n = 1 if n< 1 else n
return randint(int("1"*n), int("9"*n))
of course you can change "1"*n to whatever you want the start to be.