## integer to roman numeral

0 likes • Nov 19, 2022
Python

## More Python Posts

### hex to rgb

CodeCatch
0 likes • Nov 19, 2022
Python
```def hex_to_rgb(hex):  return tuple(int(hex[i:i+2], 16) for i in (0, 2, 4))
hex_to_rgb('FFA501') # (255, 165, 1)```
```#SetsU = {0,1,2,3,4,5,6,7,8,9}P = {1,2,3,4}Q = {4,5,6}R = {3,4,6,8,9}
def set2bits(xs,us) :    bs=[]    for x in us :        if x in xs :            bs.append(1)        else:            bs.append(0)    assert len(us) == len(bs)    return bs
def union(set1,set2) :    finalSet = set()    bitList1 = set2bits(set1, U)    bitList2 = set2bits(set2, U)
for i in range(len(U)) :        if(bitList1[i] or bitList2[i]) :            finalSet.add(i)
return finalSet
def intersection(set1,set2) :    finalSet = set()    bitList1 = set2bits(set1, U)    bitList2 = set2bits(set2, U)
for i in range(len(U)) :        if(bitList1[i] and bitList2[i]) :            finalSet.add(i)
return finalSet
def compliment(set1) :    finalSet = set()    bitList = set2bits(set1, U)
for i in range(len(U)) :        if(not bitList[i]) :            finalSet.add(i)
return finalSet
def implication(a,b):    return union(compliment(a), b)
#################################################################################################################         Problems 1-6         ##################################################################################################################################
#p \/ (q /\ r) = (p \/ q) /\ (p \/ r)def prob1():    return union(P, intersection(Q,R)) == intersection(union(P,Q), union(P,R))
#p /\ (q \/ r) = (p /\ q) \/ (p /\ r)def prob2():    return intersection(P, union(Q,R)) == union(intersection(P,Q), intersection(P,R))
#~(p /\ q) = ~p \/ ~qdef prob3():    return compliment(intersection(P,R)) == union(compliment(P), compliment(R))
#~(p \/ q) = ~p /\ ~qdef prob4():    return compliment(union(P,Q)) == intersection(compliment(P), compliment(Q))
#(p=>q) = (~q => ~p)def prob5():    return implication(P,Q) == implication(compliment(Q), compliment(P))
#(p => q) /\ (q => r)  =>  (p => r)def prob6():    return implication(intersection(implication(P,Q), implication(Q,R)), implication(P,R))

print("Problem 1: ", prob1())print("Problem 2: ", prob2())print("Problem 3: ", prob3())print("Problem 4: ", prob4())print("Problem 5: ", prob5())print("Problem 6: ", prob6())
'''Problem 1:  TrueProblem 2:  TrueProblem 3:  TrueProblem 4:  TrueProblem 5:  TrueProblem 6:  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}'''```
```import itertoolsimport stringimport time
def guess_password(real):    chars = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation    attempts = 0    for password_length in range(1, 9):        for guess in itertools.product(chars, repeat=password_length):            startTime = time.time()            attempts += 1            guess = ''.join(guess)            if guess == real:                return 'password is {}. found in {} guesses.'.format(guess, attempts)            loopTime = (time.time() - startTime);            print(guess, attempts, loopTime)
print("\nIt will take A REALLY LONG TIME to crack a long password. Try this out with a 3 or 4 letter password and see how this program works.\n")val = input("Enter a password you want to crack that is 9 characters or below: ")print(guess_password(val.lower()))```
`import subprocess   #for the praat callsimport os   #for ffmpeg and the pause call at the end#Even if we wanted all videos being rendered asynchronously, we couldn't see progress or errorsimport glob #for the ambiguous filesimport tempfileaudioFileDirectory = 'Audio Files'timeList = {}fileList = glob.glob(audioFileDirectory + '\\*.wav')pipeList = {}for fileName in fileList:    arglist = ['Praat.exe', '--run', 'crosscorrelateMatch.praat', 'zeussound.wav', fileName, "0" , "300"]    print(' '.join(arglist))    pipe = subprocess.Popen(arglist, stdout=subprocess.PIPE)    pipeList[fileName[len(audioFileDirectory)+1:-4]] = pipe #+1 because of back slash, -4 because .wav#for fileName, pipe in pipeList.items():#    text = pipe.communicate()[0].decode('utf-8')#    timeList[fileName] = float(text[::2])for fileName, pipe in pipeList.items():    if float(pipe.communicate()[0].decode('utf-8')[::2]) > .0003:    #.000166 is not a match, and .00073 is a perfect match. .00053 is a tested match        arglist = ['Praat.exe', '--run', 'crosscorrelate.praat', 'zeussound.wav', audioFileDirectory + '\\' + fileName + '.wav', "0" , "300"]        print(' '.join(arglist))        text = subprocess.Popen(arglist, stdout=subprocess.PIPE).communicate()[0].decode('utf-8')        timeList[fileName] = float(text[::2])clipLength = 10for fileName, time in timeList.items():    arglist = ['ffmpeg', '-i', '"'+fileName+'.mp4"', '-ss', str(time-clipLength), '-t', str(clipLength*2), '-acodec', 'copy' , '-vcodec', 'copy', '"ZEUS'+ fileName + '.mp4"']    print(' '.join(arglist))    os.system(' '.join(arglist))tempFile = tempfile.NamedTemporaryFile(delete=False)for fileName in glob.glob('ZEUS*.mp4'):    tempFile.write(("file '" + os.path.realpath(fileName) + "'\n").encode());tempFile.seek(0)print(tempFile.read())tempFile.close()arglist = ['ffmpeg', '-safe', '0', '-f', 'concat', '-i', '"'+tempFile.name+'"', '-c', 'copy', 'ZeusMontage.mp4']print(' '.join(arglist))os.system(' '.join(arglist))os.unlink(tempFile.name)    #Delete the temp file#print(timeList)os.system('PAUSE')`
```import os, json, boto3, requestsfrom flask import Flask, request, jsonifyfrom flask_cors import CORS, cross_originfrom random import shuffle
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
app.url_map.strict_slashes = FalseSECRET_KEY = os.environ.get("SECRET_KEY")

@app.route("/teks")def teks_request():    teks_file = open("teks.json", "r")    data = json.load(teks_file)    return jsonify(data)

@app.route("/teks/find/113.41.<int:teks_id>.<string:section_id>")def teks_find_request(teks_id, section_id):    teks_file = open("teks.json", "r")    data = json.load(teks_file)    for item in data:        if item["id"] == teks_id:            for child in item["children"]:                if child["id"] == section_id:                    return {"tek": item, "content": child["content"]}    return jsonify(        [            f"Something went wrong. TEKS section id of {section_id} cannot be found within TEKS section {teks_id}."        ]    )
@app.route("/lessonplan/read/<id>")def read_lesson_plan(id):    lesson_table = dynamodb.Table("Lesson_Plans")    items = lesson_table.scan()['Items']    for lesson in items:        if (lesson["uuid"] == id):            return jsonify(lesson)    return {"error": "id does not exist", "section": id}
@app.route("/teks/<int:teks_id>")def teks_id_request(teks_id):    teks_file = open("teks.json", "r")    data = json.load(teks_file)    for item in data:        if item["id"] == teks_id:            return jsonify(item)    return jsonify([f"Something went wrong. TEKS id of {teks_id} cannot be found."])

@app.route("/assessment/write", methods=["GET", "POST"])def assessment_write():    assessment_json = request.json    assessment_data = dict(assessment_json)    assessment_table = dynamodb.Table("Assessments")    assessment_table.put_item(Item=assessment_data)
if assessment_data == get_assessment(assessment_data["id"]):        return "Success"    else:        return "Failure"

@app.route("/assessment/submit/<id>", methods=["POST"])def submit_assessment(id):    assessments_table = dynamodb.Table("Assessments")    assessment = assessments_table.get_item(Key={"id": id})
if not assessment.get("Item"):        return {"error": "id does not exist", "section": id}
responses = {        question["id"]: question["response"]        for question in request.json.get("questions")    }
for response in responses:        # print(        #     (        #         responses[response],        #         find_question(assessment.get("Item").get("questions"), response).get(        #             "correctAnswer"        #         ),        #     )        # )        if responses[response] == find_question(            assessment.get("Item").get("questions"), response        ).get("correctAnswer"):
users_table = dynamodb.Table("Students")
users_table.update_item(        Key={"uuid": request.json.get("student_id")},        UpdateExpression="SET completedAssessments = list_append(completedAssessments, :i)",        ExpressionAttributeValues={            ":i": [                {                    "id": id,                    "score": round(score * 100),                }            ]        },    )
message = None    if round(score * 100) > 70:        message = f"Congratulations! You passed your assessment with a {round(score * 100)}%."    else:        message = f"You failed your assessment with a {round(score * 100)}%."
sns = boto3.client("sns", region_name="us-east-1")    number = "+15125967383"    sns.publish(PhoneNumber=number, Message=message)
return {"score": score, "message": message}

def find_question(all, id):    #print("id to find: ", id)    for question in all:        if question["id"] == id:            #print(question)            return question

def get_assessment(id):    assessment_table = dynamodb.Table("Assessments")    results = assessment_table.get_item(Key={"id": id})
if results.get("Item") is None:        return {"error": "id does not exist", "section": id}    else:        quiz = results.get("Item")        return {            "title": quiz.get("title"),            "id": quiz.get("id"),            "questions": [                {                    "id": question.get("id"),                    "title": question.get("title"),                    "options": random_answers(                        question.get("incorrectAnswers")                        + [question.get("correctAnswer")]                    ),                }                for question in quiz.get("questions")            ],        }
def get_students(id):    students_table = dynamodb.Table('Students')    results = students_table.get_item(Key = {        "uuid": id    })
if(results.get("Item") is None):        return {'error': 'id does not exist', 'section': id}    else:        student = results.get("Item")        return student
def lesson_plans_read():    student_table = dynamodb.Table("Lesson_Plans")    items = student_table.scan()['Items']    return jsonify(items)
```# Listlst = [1, 2, 3, 'Alice', 'Alice']