print(“Hello World”)

# Python binary search function
def binary_search(arr, target):
    left = 0
    right = len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# Usage
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
target = 7
result = binary_search(arr, target)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")

#Sets
U = {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 \/ ~q
def prob3():
    return compliment(intersection(P,R)) == union(compliment(P), compliment(R))

#~(p \/ q) = ~p /\ ~q
def 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:  True
Problem 2:  True
Problem 3:  True
Problem 4:  True
Problem 5:  True
Problem 6:  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
'''

""" Rock Paper Scissors
----------------------------------------
"""
import random
import os
import re
os.system('cls' if os.name=='nt' else 'clear')
while (1 < 2):
    print "\n"
    print "Rock, Paper, Scissors - Shoot!"
    userChoice = raw_input("Choose your weapon [R]ock], [P]aper, or [S]cissors: ")
    if not re.match("[SsRrPp]", userChoice):
        print "Please choose a letter:"
        print "[R]ock, [S]cissors or [P]aper."
        continue
    // Echo the user's choice
    print "You chose: " + userChoice
    choices = ['R', 'P', 'S']
    opponenetChoice = random.choice(choices)
    print "I chose: " + opponenetChoice
    if opponenetChoice == str.upper(userChoice):
        print "Tie! "
    #if opponenetChoice == str("R") and str.upper(userChoice) == "P"
    elif opponenetChoice == 'R' and userChoice.upper() == 'S':      
        print "Scissors beats rock, I win! "
        continue
    elif opponenetChoice == 'S' and userChoice.upper() == 'P':      
        print "Scissors beats paper! I win! "
        continue
    elif opponenetChoice == 'P' and userChoice.upper() == 'R':      
        print "Paper beat rock, I win! "
        continue
    else:       
        print "You win!"

import random
import time

def generate_maze(width, height):
    """Generate a random maze using depth-first search"""
    maze = [[1 for _ in range(width)] for _ in range(height)]
    
    def carve(x, y):
        maze[y][x] = 0
        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
        random.shuffle(directions)
        
        for dx, dy in directions:
            nx, ny = x + dx*2, y + dy*2
            if 0 <= nx < width and 0 <= ny < height and maze[ny][nx] == 1:
                maze[y + dy][x + dx] = 0
                carve(nx, ny)
    
    carve(1, 1)
    maze[0][1] = 0  # Entrance
    maze[height-1][width-2] = 0  # Exit
    return maze

def print_maze(maze, path=None):
    """Print the maze with ASCII characters"""
    if path is None:
        path = []
    
    for y in range(len(maze)):
        for x in range(len(maze[0])):
            if (x, y) in path:
                print('◍', end=' ')
            elif maze[y][x] == 0:
                print(' ', end=' ')
            else:
                print('▓', end=' ')
        print()

def solve_maze(maze, start, end):
    """Solve the maze using recursive backtracking"""
    visited = set()
    path = []
    
    def dfs(x, y):
        if (x, y) == end:
            path.append((x, y))
            return True
        
        if (x, y) in visited or maze[y][x] == 1:
            return False
            
        visited.add((x, y))
        path.append((x, y))
        
        for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            if dfs(x + dx, y + dy):
                return True
                
        path.pop()
        return False
    
    dfs(*start)
    return path

# Generate and solve a maze
width, height = 21, 11  # Should be odd numbers
maze = generate_maze(width, height)
start = (1, 0)
end = (width-2, height-1)

print("Generated Maze:")
print_maze(maze)

print("\nSolving Maze...")
time.sleep(2)
path = solve_maze(maze, start, end)

print("\nSolved Maze:")
print_maze(maze, path)

import os
import sys
import argparse
import json
import csv
import getpass
import string
import random
import re

from datetime import datetime
import ldap
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
from requests.auth import HTTPBasicAuth
import validators



def create_guac_connection(BASE_URL, auth_token, ldap_group, computer, guac_group_id):
    '''
    creates a guac connection
    '''
    json_header = {'Accept': 'application/json'}
    query_parm_payload = { 'token': auth_token }

    payload_data = {
   "parentIdentifier":guac_group_id,
   "name":computer,
   "protocol":"vnc",
   "parameters":{
      "port":"5900",
      "read-only":"",
      "swap-red-blue":"",
      "cursor":"",
      "color-depth":"",
      "clipboard-encoding":"",
      "disable-copy":"",
      "disable-paste":"",
      "dest-port":"",
      "recording-exclude-output":"",
      "recording-exclude-mouse":"",
      "recording-include-keys":"",
      "create-recording-path":"",
      "enable-sftp":"true",
      "sftp-port":"",
      "sftp-server-alive-interval":"",
      "enable-audio":"",
      "audio-servername":"",
      "sftp-directory":"",
      "sftp-root-directory":"",
      "sftp-passphrase":"",
      "sftp-private-key":"",
      "sftp-username":"",
      "sftp-password":"",
      "sftp-host-key":"",
      "sftp-hostname":"",
      "recording-name":"",
      "recording-path":"",
      "dest-host":"",
      "password":"asdasd",
      "username":"asdasd",
      "hostname":"nt72310.cvad.unt.edu"
   },
   "attributes":{
      "max-connections":"",
      "max-connections-per-user":"1",
      "weight":"",
      "failover-only":"",
      "guacd-port":"",
      "guacd-encryption":"",
      "guacd-hostname":""
   }
}
    CREATE_CONNECTION_URL = BASE_URL + "/api/session/data/mysql/connections"

    create_connection_request = requests.post(CREATE_CONNECTION_URL, headers=json_header, params=query_parm_payload, data=payload_data, verify=False)
    create_connection_result = create_connection_request.status_code


    if create_connection_result == "200":
        print("Successfully created computer: " + computer)
    else: 
        print(create_connection_request.json())

    return create_connection_result