def generate_floyds_triangle(num_rows):
    triangle = []
    number = 1
    for row in range(num_rows):
        current_row = []
        for _ in range(row + 1):
            current_row.append(number)
            number += 1
        triangle.append(current_row)
    return triangle


def display_floyds_triangle(triangle):
    for row in triangle:
        for number in row:
            print(number, end=" ")
        print()


# Prompt the user for the number of rows
num_rows = int(input("Enter the number of rows for Floyd's Triangle: "))

# Generate Floyd's Triangle
floyds_triangle = generate_floyds_triangle(num_rows)

# Display Floyd's Triangle
display_floyds_triangle(floyds_triangle)

""" Binary Search Algorithm 
----------------------------------------
"""
#iterative implementation of binary search in Python
def binary_search(a_list, item):
    """Performs iterative binary search to find the position of an integer in a given, sorted, list.
    a_list -- sorted list of integers
    item -- integer you are searching for the position of
    """
    first = 0
    last = len(a_list) - 1
    while first <= last:
        i = (first + last) / 2
        if a_list[i] == item:
            return ' found at position '.format(item=item, i=i)
        elif a_list[i] > item:
            last = i - 1
        elif a_list[i] < item:
            first = i + 1
        else:
            return ' not found in the list'.format(item=item)
#recursive implementation of binary search in Python
def binary_search_recursive(a_list, item):
    """Performs recursive binary search of an integer in a given, sorted, list.
    a_list -- sorted list of integers
    item -- integer you are searching for the position of
    """
    first = 0
    last = len(a_list) - 1
    if len(a_list) == 0:
        return ' was not found in the list'.format(item=item)
    else:
        i = (first + last) // 2
        if item == a_list[i]:
            return ' found'.format(item=item)
        else:
            if a_list[i] < item:
                return binary_search_recursive(a_list[i+1:], item)
            else:
                return binary_search_recursive(a_list[:i], item)

string

# Python program for implementation of Radix Sort
	
# A function to do counting sort of arr[] according to
# the digit represented by exp.
def countingSort(arr, exp1):
	
	n = len(arr)
	
	# The output array elements that will have sorted arr
	output = [0] * (n)
	
	# initialize count array as 0
	count = [0] * (10)
	
	# Store count of occurrences in count[]
	for i in range(0, n):
		index = (arr[i]/exp1)
		count[int((index)%10)] += 1
	
	# Change count[i] so that count[i] now contains actual
	# position of this digit in output array
	for i in range(1,10):
		count[i] += count[i-1]
	
	# Build the output array
	i = n-1
	while i>=0:
		index = (arr[i]/exp1)
		output[ count[ int((index)%10) ] - 1] = arr[i]
		count[int((index)%10)] -= 1
		i -= 1
	
	# Copying the output array to arr[],
	# so that arr now contains sorted numbers
	i = 0
	for i in range(0,len(arr)):
		arr[i] = output[i]

# Method to do Radix Sort
def radixSort(arr):

	# Find the maximum number to know number of digits
	max1 = max(arr)

	# Do counting sort for every digit. Note that instead
	# of passing digit number, exp is passed. exp is 10^i
	# where i is current digit number
	exp = 1
	while max1/exp > 0:
		countingSort(arr,exp)
		exp *= 10

# Driver code to test above
arr = [ 170, 45, 75, 90, 802, 24, 2, 66]
radixSort(arr)

for i in range(len(arr)):
	print(arr[i]),

def Fibonacci(n): 
    if n<0: 
        print("Incorrect input") 
    # First Fibonacci number is 0 
    elif n==1: 
        return 0
    # Second Fibonacci number is 1 
    elif n==2: 
        return 1
    else: 
        return Fibonacci(n-1)+Fibonacci(n-2) 
  
# Driver Program 
  
print(Fibonacci(9))

def get_ldap_user(member_cn, user, passwrd):
    '''
    Get an LDAP user and return the SAMAccountName
    '''
    #---- Setting up the Connection
    #account used for binding - Avoid putting these in version control
    bindDN = str(user) + "@unt.ad.unt.edu"
    bindPass = passwrd

    #set some tuneables for the LDAP library.
    ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_ALLOW)
    #ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, CACERTFILE)
    
    conn = ldap.initialize('ldaps://unt.ad.unt.edu')
    conn.protocol_version = 3
    conn.set_option(ldap.OPT_REFERRALS, 0)

    #authenticate the connection so that you can make additional queries
    try:
        result = conn.simple_bind_s(bindDN, bindPass) 
    except ldap.INVALID_CREDENTIALS:
        result = "Invalid credentials for %s" % user
        sys.exit()

    #build query in the form of (uid=user)
    ldap_query = '(|(displayName=' + member_cn + ')(cn='+ member_cn + ')(name=' + member_cn + '))'
    ldap_info = conn.search_s('DC=unt,DC=ad,DC=unt,DC=edu', ldap.SCOPE_SUBTREE, filterstr=ldap_query)
    sAMAccountName = str(ldap_info[0][1]['sAMAccountName']).replace("[b'", "").replace("']","")
    return sAMAccountName