Use Python and Turtle and Random library to draw the 50 random isosceles triangles as shown in the following figure.
Hints:
Make a function that draws isosceles triangle given the center of the base, length of the base, height, and the direction from the base to the top of the triangle.
Use random library’s uniform function to generate positions, size, direction, and color.
Source Code:
from turtle import *
import math
import random
title('Isosceles Triangle Madness - PythonTurtle.Academy')
setup(1000,1000)
setworldcoordinates(-500,-500,500,500)
hideturtle()
tracer(0,0)
# x,y is the center of the base, width: length of base, height: height of triangle from the top to base
# direction:direction from the center of base to top
def IsoscelesTriangle(x,y,width,height,direction,c):
up()
goto(x,y)
seth(direction-90)
fd(width/2)
p1x, p1y = xcor(), ycor() # first point: bottom right
back(width)
p2x, p2y = xcor(), ycor() # second point: bottom left
goto(x,y)
seth(direction)
fd(height)
p3x, p3y = xcor(), ycor() # third point: top
goto(p1x,p1y)
down()
fillcolor(c)
begin_fill()
goto(p2x,p2y)
goto(p3x,p3y)
goto(p1x,p1y)
end_fill()
for _ in range(50):
IsoscelesTriangle(random.uniform(-400,400),random.uniform(-400,400),
random.uniform(30,300), random.uniform(30,300),
random.uniform(0,360),
(random.uniform(0,1),random.uniform(0,1),random.uniform(0,1)))
update()
Wordle is a very popular puzzle game. Here is the source code that automatically solves the wordle problems. There isn’t too much trick. This code just randomly picks a valid word. Click on the letters to match the colors on wordle and then hit enter. This program will automatically guess new words until the word has been guessed correctly.
import random
import turtle
from tkinter import *
from tkinter import messagebox
screen = turtle.Screen()
screen.setup(1000,1000)
screen.title("Wordle Solver - PythonTurtle.Academy")
turtle.speed(0)
turtle.hideturtle()
screen.tracer(0,0)
screen.bgcolor('black')
turtle.color('white')
gs = 0
state = []
for i in range(6):
state.append([-1]*5)
def getwords(words, cs, count=False):
res = []
cnt = 0
for w in words:
t = list(w)
flag = True
cnt = dict()
# first loop checks only positions are set
for l,p in cs:
if p<0: continue
if cs[(l,p)] > 0:
if t[p] == l:
t[p] = '*'
if l in cnt: cnt[l] += 1
else: cnt[l] = 1
else:
flag = False
break
else:
if t[p] == l:
flag = False
break
if (not flag): continue
# second loop checks only positions are not set
for l,p in cs:
if p!=-1: continue
v = 0 if l not in cnt else cnt[l]
for _ in range(cs[(l,p)]-v):
try:
p = t.index(l)
t[p] = '*'
except ValueError:
flag = False
break
if (not flag): break
if (not flag): continue
# third loops checks non-existent letter
for l,p in cs:
if p!=-2: continue
if l in t:
flag = False
break
if flag:
if count: cnt += 1
else: res.append(w)
if count: return cnt
else: return res
def guess_random(words):
return random.choice(words)
def draw_square(coord,s,fc='black'):
turtle.up()
x = coord[0]
y = coord[1]
turtle.goto(x-s/2,y-s/2)
turtle.seth(0)
turtle.down()
turtle.fillcolor(fc)
turtle.begin_fill()
for _ in range(4):
turtle.fd(s)
turtle.left(90)
turtle.end_fill()
def get_coord(i,j):
return -200+100*j, 300-100*i
def draw_board():
turtle.pencolor('dark gray')
for i in range(6):
for j in range(5):
draw_square(get_coord(i,j),80)
def display_word(w):
turtle.up()
turtle.color('white')
for i in range(5):
x,y = get_coord(gs,i)
turtle.goto(x,y-23)
turtle.write(w[i].upper(),align='center',font=('Arial',40,'bold'))
def update_cell(i,j):
global w,state
x, y = get_coord(i,j)
turtle.pencolor('dark gray')
if state[i][j] == 0:
fc = 'dark gray'
elif state[i][j] == 1:
fc = 'goldenrod'
else: fc = 'green'
draw_square(get_coord(i,j),80,fc)
turtle.up()
turtle.color('white')
turtle.goto(x,y-23)
turtle.write(w[j].upper(),align='center',font=('Arial',40,'bold'))
screen.update()
def play(x,y):
flag = False
for i in range(6):
if flag: break
for j in range(5):
cx, cy = get_coord(i,j)
if (cx-x)**2 + (cy-y)**2 < 1600:
flag = True
ci = i
cj = j
break
if not flag: return
if ci != gs: return
state[ci][cj] = (state[ci][cj] + 1) % 3
update_cell(ci,cj)
def submit():
global state
global gs
global w,words
for i in range(5):
if state[gs][i] == -1: return
cs = dict()
for i in range(5):
if state[gs][i] == 0: # letter doesn't exist
cs[(w[i],-2)] = 1
else:
if (w[i],-1) not in cs:
cs[(w[i],-1)] = 1
else:
cs[(w[i],-1)] += 1
if state[gs][i] == 1: cs[(w[i],i)] = 0
else: cs[(w[i],i)] = 1
words = getwords(words,cs)
print(len(words))
w = guess_random(words)
gs += 1
display_word(w)
if len(words) == 1:
messagebox.showinfo("Done", "Congratulations!")
turtle.bye()
screen.update()
orig_words = []
f = open('wordle_words.txt','r')
for w in f:
orig_words.append(w.strip())
cs = dict()
words = getwords(orig_words,cs)
w = guess_random(words)
w = 'tesla'
draw_board()
display_word(w)
screen.update()
screen.onclick(play)
screen.onkey(submit, 'Return')
screen.listen()
screen.mainloop()
You will also need to download a list of words as ‘wordle_words.txt’.
Develop a typing game to improve keyboard skill as demonstrated in the following YouTube video.
At any moment ten random letters fall from the top of screen. When you hit a correct letter from keyboard, that letter disappears and is replaced by a new random letter dropping from the top. Also, your score will increase by 1. When you hit an incorrect letter, your score will decrease by 1.
Make these letters fall at random speeds and also let the speed increase gradually as time progresses. The game will end when a letter falls to the bottom of the screen.
You will need to use Turtle’s ontimer() and onkey() events to implement this project.
Source Code:
import turtle
import random
screen = turtle.Screen()
screen.setup(1000,1000)
screen.title('Typing Game - PythonTurtle.Academy')
screen.bgcolor('blue')
screen.tracer(0,0)
turtle.hideturtle()
turtle.up()
turtle.color('red')
score_turtle = turtle.Turtle()
score_turtle.color('red')
score_turtle.up()
score_turtle.hideturtle()
turtle.goto(350,400)
turtle.write('Score: ', align='center', font=('Courier',25,'normal'))
min_speed = 5
max_speed = 30
letters = []
speeds = []
pos = []
lts = []
n = 10
game_over = False
score = 0
def increase_difficulty():
global min_speed, max_speed
min_speed += 1
max_speed += 1
screen.ontimer(increase_difficulty,5000)
def draw_game_over():
turtle.goto(0,0)
turtle.color('red')
turtle.write('GAME OVER', align='center', font=('Courier',50,'normal'))
turtle.goto(0,-150)
turtle.color('orange')
turtle.write('Your Score is {}'.format(score), align='center', font=('Courier',40,'normal'))
screen.update()
def draw_score():
score_turtle.clear()
score_turtle.goto(420,400)
score_turtle.write('{}'.format(score),align='center',font=('Courier',25,'normal'))
screen.update()
def draw_letters():
global game_over
for i in range(len(letters)):
lts[i].clear()
lts[i].goto(pos[i])
lts[i].write(letters[i],align='center',font=('courier',20,'normal'))
pos[i][1] -= speeds[i]
if pos[i][1]<-500:
game_over = True
draw_game_over()
return
screen.update()
screen.ontimer(draw_letters,50)
def f(c): # handle keyboard press
global score
if c in letters:
score += 1
k = letters.index(c)
while True:
l = chr(ord('a')+random.randrange(26))
if l not in letters:
letters[k] = l
break
pos[k] = [random.randint(-450,450),500]
speeds[k] = random.randint(min_speed,max_speed)
else: score -= 1
draw_score()
for _ in range(n):
lts.append(turtle.Turtle())
while True:
l = chr(ord('a')+random.randrange(26))
if l not in letters:
letters.append(l)
break
speeds.append(random.randint(min_speed,max_speed))
pos.append([random.randint(-450,450),500])
for i in range(n):
lts[i].speed(0)
lts[i].hideturtle()
lts[i].up()
lts[i].color('yellow')
draw_letters()
increase_difficulty()
screen.onkey(lambda: f('a'), 'a')
screen.onkey(lambda: f('b'), 'b')
screen.onkey(lambda: f('c'), 'c')
screen.onkey(lambda: f('d'), 'd')
screen.onkey(lambda: f('e'), 'e')
screen.onkey(lambda: f('f'), 'f')
screen.onkey(lambda: f('g'), 'g')
screen.onkey(lambda: f('h'), 'h')
screen.onkey(lambda: f('i'), 'i')
screen.onkey(lambda: f('j'), 'j')
screen.onkey(lambda: f('k'), 'k')
screen.onkey(lambda: f('l'), 'l')
screen.onkey(lambda: f('m'), 'm')
screen.onkey(lambda: f('n'), 'n')
screen.onkey(lambda: f('o'), 'o')
screen.onkey(lambda: f('p'), 'p')
screen.onkey(lambda: f('q'), 'q')
screen.onkey(lambda: f('r'), 'r')
screen.onkey(lambda: f('s'), 's')
screen.onkey(lambda: f('t'), 't')
screen.onkey(lambda: f('u'), 'u')
screen.onkey(lambda: f('v'), 'v')
screen.onkey(lambda: f('w'), 'w')
screen.onkey(lambda: f('x'), 'x')
screen.onkey(lambda: f('y'), 'y')
screen.onkey(lambda: f('z'), 'z')
screen.listen()
screen.mainloop()
In a previous project, we draw a trending stock price random walk chart. Candlestick chart is a more common way of representing stock price chart. Modify the code for the previous project to draw stock price random walk with Candlestick Chart.
In a previous project, we draw a stock price random walk chart. Candlestick chart is a more common way of representing stock price chart. Modify the code for the previous to draw stock price random walk with Candlestick Chart.
In this project, you simulated stock price random walk with mean equal to 0%. What if we increase the mean of Gaussian distribution very slightly to 0.5% and also increase the standard deviation to 5%. You may see something similar to a trending stock prices of successful companies.