def main():
n = int(sys.argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.ORANGE)
#stddraw.point(0, 0)
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.GREEN)
#stddraw.point(1, 1)
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.BLUE)
#stddraw.point(0.5, 0.5)
#stddraw.setPenColor(stddraw.BLACK)
#stddraw.point(0.5, 0.288)
stddraw.setPenRadius(0.003)
#stddraw.setPenColor(stddraw.RED)
for i in range(n):
r = stdrandom.discrete(dist)
x0 = cx[r][0] * x + cx[r][1] * y + cx[r][2]
y0 = cy[r][0] * x + cy[r][1] * y + cy[r][2]
x = x0
y = y0
stddraw.point(x * 0.7 + 0.25, y * 0.7 + 0.25)
stddraw.show()
def rand(self, kgram):
"""
Return a random character following kgram.
"""
a = list(self._st[kgram].values())
b = list(self._st[kgram].keys())
for i in range(len(a)):
a[i] = a[i] / float(sum(a))
d = stdrandom.discrete(a)
return b[d]
def rand(self, kgram):
"""
Use stdrandom.discrete() to randomly select and return a
random character following kgram.
"""
if kgram not in self._st:
raise ValueError()
t = self._st[kgram]
s = sum(list(t.values()))
a = list(self._st[kgram].values())
# a = stdarray.create1D(len(t.values(), 0))
for i in range(len(a)):
a[i] = (list(t.values()))[i] / s
r = stdrandom.discrete(a)
return list(t.keys())[r]
def rand(self, kgram):
"""
Returns a random character following kgram. Raises an error if kgram
is not of length k or if kgram is unknown.
"""
if self._k != len(kgram):
raise ValueError('kgram ' + kgram + ' not of length ' +
str(self._k))
if kgram not in self._st:
raise ValueError('Unknown kgram ' + kgram)
k = self._st[kgram].keys()
v = self._st[kgram].values()
d = stdrandom.discrete(v)
return k[d]
def main():
n = int(sys.argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
stddraw.setPenRadius(0.0)
for i in range(n):
r = stdrandom.discrete(dist)
x0 = cx[r][0] * x + cx[r][1] * y + cx[r][2]
y0 = cy[r][0] * x + cy[r][1] * y + cy[r][2]
x = x0
y = y0
stddraw.point(x, y)
stddraw.show()
def rand(self, kgram):
"""
Returns a random character following kgram. Raises an error if kgram
is not of length k or if kgram is unknown.
"""
if self._k != len(kgram):
raise ValueError('kgram ' + kgram + ' not of length ' +
str(self._k))
if kgram not in self._st:
raise ValueError('Unknown kgram ' + kgram)
# get a, b by list _st with key(), value
a = list(self._st[kgram].keys())
b = list(self._st[kgram].values())
# return a with index of random b
return a[stdrandom.discrete(b)]
def rand(self, kgram):
"""
Returns a random character following kgram. Raises an error if kgram
is not of length k or if kgram is unknown.
"""
if self._k != len(kgram):
raise ValueError('kgram ' + kgram + ' not of length ' +
str(self._k))
if kgram not in self._st:
raise ValueError('Unknown kgram ' + kgram)
prob= []
total=self.kgram_freq(kgram)
for c in self._st[kgram].values():
prob +=[c / total]
i= stdrandom.discrete(prob)
return list(self._st[kgram].keys())[i]
def rand(self, kgram):
"""
Returns a random character following kgram. Raises an error if kgram
is not of length k or if kgram is unknown.
"""
if self._k != len(kgram):
raise ValueError('kgram ' + kgram + ' not of length ' +
str(self._k))
if kgram not in self._st:
raise ValueError('Unknown kgram ' + kgram)
a = []
for i in range(0, len(self._st[kgram])):
a.append(
float(self._st[kgram].values()[i] /
(self.kgram_freq(kgram) * 1.0)))
highest_prob_char = stdrandom.discrete(a)
return self._st[kgram].keys()[highest_prob_char]
def main(argv):
t = int(argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
#stddraw.createWindow()
for t1 in range(t):
r = stdrandom.discrete(dist)
x0 = cx[r][0] * x + cx[r][1] * y + cx[r][2]
y0 = cy[r][0] * x + cy[r][1] * y + cy[r][2]
x = x0
y = y0
stddraw.setPenRadius(0.001)
stddraw.point(x, y)
stddraw.show()
stddraw.wait()
def main(argv):
t = int(argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
#stddraw.createWindow()
for t1 in range(t):
r = stdrandom.discrete(dist)
x0 = cx[r][0]*x + cx[r][1]*y + cx[r][2]
y0 = cy[r][0]*x + cy[r][1]*y + cy[r][2]
x = x0
y = y0
stddraw.setPenRadius(0.001)
stddraw.point(x, y)
stddraw.show()
stddraw.wait()
def twoloadeddice(a=[]):
a1 = stdrandom.discrete(a)
a2 = stdrandom.discrete(a)
return a1 + a2 + 2 #a1和a2取值范围为0-5，所以加2
def main():
n = int(sys.argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.ORANGE)
#stddraw.point(0, 0)
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.GREEN)
#stddraw.point(1, 1)
#stddraw.setPenRadius(0.1)
#stddraw.setPenColor(stddraw.BLUE)
#stddraw.point(0.5, 0.5)
#stddraw.setPenColor(stddraw.BLACK)
#stddraw.point(0.5, 0.288)
stddraw.setPenRadius(0.003)
#stddraw.setPenColor(stddraw.RED)
for i in range(n):
r = stdrandom.discrete(dist)
x0 = cx[r][0] * x + cx[r][1] * y + cx[r][2]
y0 = cy[r][0] * x + cy[r][1] * y + cy[r][2]
x = x0
y = y0
#cos -sin x
#sin cos y
angle = (2 * 3.14) / 360 * i
dvd = 4
if (i % dvd == 0):
stddraw.setPenColor(stddraw.BLUE)
angle = 0
if (i % dvd == 1):
stddraw.setPenColor(stddraw.RED)
angle = 22.5
if (i % dvd == 2):
stddraw.setPenColor(stddraw.GREEN)
angle = 45
if (i % 4 == 3):
stddraw.setPenColor(stddraw.ORANGE)
angle = -22.5
x_r = x - 0.5
y_r = y - 0.288
x_1 = x_r * math.cos(angle) - y_r * math.sin(angle)
y_1 = x_r * math.sin(angle) + y_r * math.cos(angle)
stddraw.point(x_1 * 0.5 + 0.5, y_1 * 0.5 + 0.5)
#stddraw.point(x-0.5, y-0.288)
#print(str(x_1) + "_" + str(y_1))
stddraw.show()
def next_char(self, k_gram: str) -> chr:
node: Node = self._root
for ch in k_gram:
node = node.get_son(ch)
idx = stdrandom.discrete(list(node.get_letters_count().values()))
return list(node.get_letters_count().keys())[idx]
def next_char(self, k_gram: str) -> chr:
idx = stdrandom.discrete(self._k_gram_letter[k_gram])
return chr(idx)
#n = stdio.readInt()
#stdio.readInt() # Discard the second int of standard input.
# Read the transition matrix from standard input.
# p[i][j] is the probability that the surfer moves from
# page i to page j.
#p = stdarray.create2D(n, n, 0.0)
p = stdarray.readFloat2D()
# Perform the simulation, thus computing the hits array.
# hits[i] is the number of times the surfer hits page i.
n = len(p[0])
hits = stdarray.create1D(n, 0)
page = 0 # Start at page 0.
for i in range(moves):
# Make one random move.
page = stdrandom.discrete(p[page])
hits[page] += 1
# Write the page ranks.
for v in hits:
stdio.writef("%8.5f", 1.0 * v / moves)
stdio.writeln()
#-----------------------------------------------------------------------
# python transition.py < tiny.txt | python randomsurfer.py 100
# 0.26000 0.27000 0.18000 0.26000 0.03000
# python transition.py < tiny.txt | python randomsurfer.py 10000
# 0.27410 0.26500 0.14570 0.24890 0.06630
def main():
n = int(sys.argv[1])
dist = stdarray.readFloat1D()
cx = stdarray.readFloat2D()
cy = stdarray.readFloat2D()
x = 0.0
y = 0.0
stddraw.setPenRadius(0.0)
for i in range(n):
r = stdrandom.discrete(dist)
x0 = cx[r][0]*x + cx[r][1]*y + cx[r][2]
y0 = cy[r][0]*x + cy[r][1]*y + cy[r][2]
x = x0
y = y0
stddraw.point(x, y)
stddraw.show()
