print(code)

def oneLineCombinations():

numbers = list(map(lambda x: str(x).zfill(4), [i for i in range(10000)]))

print(numbers)

while(is_exist):

try:

inputFile = input_func("File Name : ")

print(countchars(inputFile))

is_exist = False #Set False if File Name found

except FileNotFoundError:

print("File not found...Try again!")

import bs4 as bs

from urllib import request

from win10toast import ToastNotifier

toaster = ToastNotifier()

url = 'http://www.cricbuzz.com/cricket-match/live-scores'

sauce = request.urlopen(url).read()

soup = bs.BeautifulSoup(sauce,"lxml")

score = []

results = []

for div_tags in soup.find_all('div', attrs={"class": "cb-lv-scrs-col text-black"}):

score.append(div_tags.text)

for result in soup.find_all('div', attrs={"class": "cb-lv-scrs-col cb-text-complete"}):

results.append(result.text)

print(score[0],results[0])

toaster.show_toast(title=score[0],msg=results[0])

text=input("Enter text: ")

text=list(text)

values= list()

reverse=list()

def encryptChar(target):

#encrytion algorithm

target=(((target+42)*PI)-449)

return target

def decryptChar(target):

target=(((target+449)/PI)-42)

return target

def encrypt(input_text):

input_text_list=list(input_text)

col_values=list()

for i in range (len(input_text_list)):

current=ord(input_text_list[i])

current=encryptChar(current)

col_values.append(current)

return col_values

def decrypt(enc_text):

enc_list

for i in range (len(input_text_list)):

current=int(decryptChar(values[i]))

current=chr(current)

col_values.append(current)

return col_values

def readAndDecrypt(filename):

file=open(filename,"r")

data=file.read()

datalist=list()

datalistint=list()

actualdata=list()

datalist=data.split(" ")

datalist.remove('')

for i in range(len(datalist)):

datalistint.append(float(datalist[i]))

for i in range(len(datalist)):

current1=int(decryptChar(datalistint[i]))

current1=chr(current1)

actualdata.append(current1)

return actualdata

def readAndEncrypt(filename):

file=open(filename,"r")

data=file.read()

datalist=list(data)

encrypted_list=list()

encrypted_list_str=list()

for i in range(len(datalist)):

current=ord(datalist[i])

current=encryptChar(current)

encrypted_list.append(current)

return encrypted_list

def readAndEncryptAndSave(inp_file,out_file):

enc_list=readAndEncrypt(inp_file)

output=open(out_file,"w")

for i in range(len(enc_list)):

output.write(str(enc_list[i])+" ")

output.close()

def readAndDecryptAndSave(inp_file,out_file):

dec_list=readAndDecrypt(inp_file)

output=open(out_file,"w")

for i in range(len(dec_list)):

output.write(str(dec_list[i]))

output.close()

for i in range (len(text)):

current=ord(text[i])

current=encryptChar(current)

values.append(current)

for i in range (len(text)):

current=int(decryptChar(values[i]))

current=chr(current)

reverse.append(current)

print(reverse)

output=open("encrypted.txt","w")

for i in range(len(values)):

output.write(str(values[i])+" ")

output.close()

print(readAndDecrypt("encrypted.txt"))

Client=urlopen(my_url)

s_url ="https://news.google.com/news/headlines/section/topic/SPORTS.en_in/Sports?ned=in&hl=en-IN&gl=IN"

Client=urlopen(s_url)

The Koch snowflake (also known as the Koch curve, Koch star, or Koch island) is a mathematical curve and one of the earliest fractal curves

to have been described. It is based on the Koch curve, which appeared in a 1904 paper titled �On a continuous curve without tangents,

constructible from elementary geometry� by the Swedish mathematician Helge von Koch.

How to construct one:

Step 1:

Draw an equilateral triangle. You can draw it with a compass or protractor, or just eyeball it if you don't want to spend too much time draw

ing the snowflake. It's best if the length of the sides are divisible by 3, because of the nature of this fractal. This will become clear

in the next few steps.

Step 2:

Divide each side in three equal parts. This is why it is handy to have the sides divisible by three.

Step 3:

Draw an equilateral triangle on each middle part. Measure the length of the middle third to know the length of the sides of these new

triangles.

Step 4:

Divide each outer side into thirds. You can see the 2nd generation of triangles covers a bit of the first. These three line segments

shouldn't be parted in three.

Step 5:

Draw an equilateral triangle on each middle part. Note how you draw each next generation of parts that are one 3rd of the mast one.

Step 6:

Repeat until you're satisfied with the amount of iterations. It will become harder and harder to accurately draw the new triangles, but

with a fine pencil and lots of patience you can reach the 8th iteration. The one shown in the picture is a Koch snowflake of the 4th

iteration.

Step 7:

Decorate your snowflake how you like it. You can colour it, cut it out, draw more triangles on the inside, or just leave it the way it is.

Reference Links:

http://www.geeksforgeeks.org/koch-curve-koch-snowflake/

https://www.wikihow.com/Draw-the-Koch-Snowflake

https://en.wikipedia.org/wiki/Koch_snowflake

from turtle import *

def snowflake(lengthSide, levels):

if levels == 0:

forward(lengthSide)

return

lengthSide /= 3.0

snowflake(lengthSide, levels-1)

left(60)

snowflake(lengthSide, levels-1)

right(120)

snowflake(lengthSide, levels-1)

left(60)

snowflake(lengthSide, levels-1)

if __name__ == "__main__":

speed(0) #defining the speed of the turtle

length = 300.0 #

penup() #Pull the pen up – no drawing when moving.

#Move the turtle backward by distance, opposite to the direction the turtle is headed.

#Do not change the turtle’s heading.

backward(length/2.0)

pendown()

for i in range(3):

#Pull the pen down – drawing when moving.

snowflake(length, 4)

right(120)

#To control the closing windows of the turtle

mainloop()

import sys

if sys.version_info[0]==2:

version=2

else:

version=3

if version==2:

n=input('Enter number of even numbers to print: ')

printed=0

numbers=0

while printed!=n:

if numbers%2==0:

print numbers,

printed+=1

numbers+=1

if version==3:

print ([x for x in range(int(input()),int(input())) if not x%2])

def findLinear(numbers): ##find a & b of linear sequence

output=[]

a=numbers[1]-numbers[0]

a1=numbers[2]-numbers[1]

if a1==a:

b=numbers[0]-a

return (a,b)

else:

print("Sequence is not linear")

sequence=[]

first_difference=[]

second_difference=[]

for i in range(4): #input

term=str(i+1)

inp=int(input("Enter term "+term+": "))

sequence.append(inp)

for i in range(3):

gradient=sequence[i+1]-sequence[i]

first_difference.append(gradient)

for i in range(2):

gradient=first_difference[i+1]-first_difference[i]

second_difference.append(gradient)

if second_difference[0]==second_difference[1]: #checks to see if consistent

a=second_difference[0]/2

subs_diff=[]

for i in range(4):

n=i+1

num=a*(n*n)

subs_diff.append((sequence[i])-num)

b,c=findLinear(subs_diff)

print("Nth term: "+str(a)+"n^2 + "+str(b)+"n + "+str(c)) #outputs nth term

else:

print("Sequence is not quadratic")