# Function to check Armstrong number
def is_armstrong_number(number):
    # Convert number to string to iterate over its digits
    num_str = str(number)
    
    # Calculate the sum of the cubes of each digit
    digit_sum = sum(int(digit) ** len(num_str) for digit in num_str)
    
    # Compare the sum with the original number
    if digit_sum == number:
        return True
    else:
        return False

# Prompt user for a number
number = int(input("Enter a number: "))

# Check if the number is an Armstrong number
if is_armstrong_number(number):
    print(number, "is an Armstrong number.")
else:
    print(number, "is not an Armstrong number.")

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

import ipdb

# ldap functions
def get_ldap_group_members(ldap_group, user, passwrd, DOMAIN, DOMAIN_SEARCH_BASE):
    #DOMAIN_GROUP, DOMAIN_USER, DOMAIN_PASS, DOMAIN, DOMAIN_SEARCH_BASE
    '''
    Input a user name and search the directory
    '''
    #---- Setting up the Connection
    #account used for binding - Avoid putting these in version control
    bindDN = str(user)
    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://'+str(DOMAIN))
    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 = '(cn=' + ldap_group + ')'

    query_result = []  
    lencount = True
    range_start = 0
    total_active_students_count = 0
    
    while lencount:
        #print(len(query_result))
        range_end = range_start + 1499
        member_range = ['member;range=' + str(range_start) + '-' + str(range_end)]
        #print(member_range)
        ldap_info = conn.search_s(str(DOMAIN_SEARCH_BASE), ldap.SCOPE_SUBTREE, filterstr=ldap_query, attrlist=member_range)
        member_range = next(iter(ldap_info[0][1].keys()))
        ldap_objects = ldap_info[0][1][member_range]
        print("\n")
        for ldap_object in ldap_objects:
            decoded_member_string = ldap_object.decode("utf-8")
            member_cn = re.split('=|,', decoded_member_string)[1]
            print(f"User number: {total_active_students_count} in {ldap_group}: {member_cn}")
            query_result.append(member_cn)
            total_active_students_count = total_active_students_count + 1
        
        if len(ldap_objects) == 1500:
            lencount = True
            range_start += 1500
            range_end += 1500
        
        else:
            lencount = False
        
    print(f"TOTAL USERS IN ActiveStudents: {total_active_students_count}")
    return query_result


def main():
    user = input("Enter a UNT bind username: ") + "@students.ad.unt.edu"
    passwrd = getpass.getpass(prompt='Enter UNT bind password: ', stream=None)
    get_ldap_group_members("ActiveStudents", user, passwrd, "students.ad.unt.edu", "DC=students,DC=ad,DC=unt,DC=edu")


if __name__ == "__main__":
    main()

# Python program for Plotting Fibonacci 
# spiral fractal using Turtle 
import turtle 
import math 
  
def fiboPlot(n): 
    a = 0
    b = 1
    square_a = a 
    square_b = b 
  
    # Setting the colour of the plotting pen to blue 
    x.pencolor("blue") 
  
    # Drawing the first square 
    x.forward(b * factor) 
    x.left(90) 
    x.forward(b * factor) 
    x.left(90) 
    x.forward(b * factor) 
    x.left(90) 
    x.forward(b * factor) 
  
    # Proceeding in the Fibonacci Series 
    temp = square_b 
    square_b = square_b + square_a 
    square_a = temp 
      
    # Drawing the rest of the squares 
    for i in range(1, n): 
        x.backward(square_a * factor) 
        x.right(90) 
        x.forward(square_b * factor) 
        x.left(90) 
        x.forward(square_b * factor) 
        x.left(90) 
        x.forward(square_b * factor) 
  
        # Proceeding in the Fibonacci Series 
        temp = square_b 
        square_b = square_b + square_a 
        square_a = temp 
  
    # Bringing the pen to starting point of the spiral plot 
    x.penup() 
    x.setposition(factor, 0) 
    x.seth(0) 
    x.pendown() 
  
    # Setting the colour of the plotting pen to red 
    x.pencolor("red") 
  
    # Fibonacci Spiral Plot 
    x.left(90) 
    for i in range(n): 
        print(b) 
        fdwd = math.pi * b * factor / 2
        fdwd /= 90
        for j in range(90): 
            x.forward(fdwd) 
            x.left(1) 
        temp = a 
        a = b 
        b = temp + b 
  
  
# Here 'factor' signifies the multiplicative  
# factor which expands or shrinks the scale 
# of the plot by a certain factor. 
factor = 1
  
# Taking Input for the number of  
# Iterations our Algorithm will run 
n = int(input('Enter the number of iterations (must be > 1): ')) 
  
# Plotting the Fibonacci Spiral Fractal  
# and printing the corresponding Fibonacci Number 
if n > 0: 
    print("Fibonacci series for", n, "elements :") 
    x = turtle.Turtle() 
    x.speed(100) 
    fiboPlot(n) 
    turtle.done() 
else: 
    print("Number of iterations must be > 0")

def generate_pascals_triangle(num_rows):
    triangle = []
    for row in range(num_rows):
        # Initialize the row with 1
        current_row = [1]

        # Calculate the values for the current row
        if row > 0:
            previous_row = triangle[row - 1]
            for i in range(len(previous_row) - 1):
                current_row.append(previous_row[i] + previous_row[i + 1])

        # Append 1 at the end of the row
        current_row.append(1)

        # Add the current row to the triangle
        triangle.append(current_row)

    return triangle


def display_pascals_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 Pascal's Triangle: "))

# Generate Pascal's Triangle
pascals_triangle = generate_pascals_triangle(num_rows)

# Display Pascal's Triangle
display_pascals_triangle(pascals_triangle)

filename = "data.txt"
with open(filename, "r") as file:
    file_contents = file.readlines()
    file_contents = [line.strip() for line in file_contents]

print("File contents:")
for line in file_contents:
    print(line)

import copy
begining = [False,False,False,False,False,None,True,True,True,True,True]
#False = black True = white
its = [0]
def swap(layout, step):
    layoutCopy = copy.deepcopy(layout)
    layoutCopy[(step[0]+step[1])], layoutCopy[step[1]] = layoutCopy[step[1]], layoutCopy[(step[0]+step[1])]
    return layoutCopy
def isSolved(layout):
    for i in range(len(layout)):
        if(layout[i] == False):
            return (i >= (len(layout)/2))
def recurse(layout, its, steps = []):
    if isSolved(layout):
        its[0] += 1
        print(layout,list(x[0] for x in steps))
        return
    step = None
    for i in range(len(layout)):
        if(layout[i] == None):
            if(i >= 1): #If the empty space could have something to the left
                if(layout[i - 1] == False):
                    step = [-1,i]
                    recurse(swap(layout,step), its, (steps+[step]))
                if(i > 1): #If the empty space could have something 2 to the left
                    if(layout[i - 2] == False):
                        step = [-2,i]
                        recurse(swap(layout,step), its, (steps+[step]))
            if(i < (len(layout)-1)): #If the empty space could have something to the right
                if(layout[i + 1] == True):
                    step = [1,i]
                    recurse(swap(layout,step), its, (steps+[step]))
                if(i < (len(layout)-2)): #If the empty space could have something to the right
                    if(layout[i + 2] == True):
                        step = [2,i]
                        recurse(swap(layout,step), its, (steps+[step]))
    its[0] += 1
    #return None
recurse(begining,its,[])
print(its[0])