paulos

Sombrearla(s)

Resimula

L_i

Fa_i

Fr_i

tot:

L_i/N·Fr_i

Ver tabla de frecuencias

G2: 0
G26_1 = NaN
A = (-3, -4)
B = (6, -4)
polígono1, a, b, c, d, C, D = Polygon(A, B, 4)
N = 4 (slider from 2 to 24, step 1)
numdivisores = Divisors(N)
Factors(N)
u = Vector(A, B)
v = Vector(A, D)
listadivis = DivisorsList(N)
Factors(N)
alto = Element(listadivis, numdivisores / 2)
ancho: N / alto
v2: v / alto
u2: u / ancho
ales = Sequence((random(), random()), i, 1, N)
estrellas = Sequence(A + (x(Element[ales, k]) * u) + (y(Element[ales, k]) * v), k, 1, N)
A1: 1
A2: 2
A3 = 3
A4 = 4
A5 = 5
A6 = 6
A7 = 7
A8 = 8
A9 = 9
A10 = 10
A11 = 11
A12 = 12
A13 = 13
A14 = 14
A15 = 15
A16 = 16
A17 = 17
A18 = 18
A19 = 19
A20 = 20
A21 = 21
A22 = 22
A23 = 23
A24 = 24
polidestrellas = Sequence((floor((x(Element[ales, k]) * ancho)) * alto) + floor((y(Element[ales, k]) * alto)) + 1, k, 1, N)
C1 = Mod(A1 - 1, alto)
C2 = Mod(A2 - 1, alto)
C3 = Mod(A3 - 1, alto)
C4 = Mod(A4 - 1, alto)
C5 = Mod(A5 - 1, alto)
C6 = Mod(A6 - 1, alto)
C7 = Mod(A7 - 1, alto)
C8 = Mod(A8 - 1, alto)
C9 = Mod(A9 - 1, alto)
C10 = Mod(A10 - 1, alto)
C11 = Mod(A11 - 1, alto)
C12 = Mod(A12 - 1, alto)
B12 = Div(A12 - 1, alto)
B1 = Div(A1 - 1, alto)
B2 = Div(A2 - 1, alto)
B3 = Div(A3 - 1, alto)
B4 = Div(A4 - 1, alto)
B5 = Div(A5 - 1, alto)
B6 = Div(A6 - 1, alto)
B7 = Div(A7 - 1, alto)
B8 = Div(A8 - 1, alto)
B9 = Div(A9 - 1, alto)
B10 = Div(A10 - 1, alto)
B11 = Div(A11 - 1, alto)
C13 = Mod(A13 - 1, alto)
C14 = Mod(A14 - 1, alto)
C15 = Mod(A15 - 1, alto)
C16 = Mod(A16 - 1, alto)
C17 = Mod(A17 - 1, alto)
C18 = Mod(A18 - 1, alto)
C19 = Mod(A19 - 1, alto)
C20 = Mod(A20 - 1, alto)
C21 = Mod(A21 - 1, alto)
C22 = Mod(A22 - 1, alto)
C23 = Mod(A23 - 1, alto)
C24 = Mod(A24 - 1, alto)
D1: {Polygon[A + (B1 * u2) + (C1 * v2), A + ((B1 + 1) * u2) + (C1 * v2), A + ((B1 + 1) * u2) + ((C1 + 1) * v2), A + (B1 * u2) + ((C1 + 1) * v2)]}
D2: {Polygon[A + (B2 * u2) + (C2 * v2), A + ((B2 + 1) * u2) + (C2 * v2), A + ((B2 + 1) * u2) + ((C2 + 1) * v2), A + (B2 * u2) + ((C2 + 1) * v2)]}
D3: {Polygon[A + (B3 * u2) + (C3 * v2), A + ((B3 + 1) * u2) + (C3 * v2), A + ((B3 + 1) * u2) + ((C3 + 1) * v2), A + (B3 * u2) + ((C3 + 1) * v2)]}
D4: {Polygon[A + (B4 * u2) + (C4 * v2), A + ((B4 + 1) * u2) + (C4 * v2), A + ((B4 + 1) * u2) + ((C4 + 1) * v2), A + (B4 * u2) + ((C4 + 1) * v2)]}
D5: {Polygon[A + (B5 * u2) + (C5 * v2), A + ((B5 + 1) * u2) + (C5 * v2), A + ((B5 + 1) * u2) + ((C5 + 1) * v2), A + (B5 * u2) + ((C5 + 1) * v2)]}
D6: {Polygon[A + (B6 * u2) + (C6 * v2), A + ((B6 + 1) * u2) + (C6 * v2), A + ((B6 + 1) * u2) + ((C6 + 1) * v2), A + (B6 * u2) + ((C6 + 1) * v2)]}
D7: {Polygon[A + (B7 * u2) + (C7 * v2), A + ((B7 + 1) * u2) + (C7 * v2), A + ((B7 + 1) * u2) + ((C7 + 1) * v2), A + (B7 * u2) + ((C7 + 1) * v2)]}
D8: {Polygon[A + (B8 * u2) + (C8 * v2), A + ((B8 + 1) * u2) + (C8 * v2), A + ((B8 + 1) * u2) + ((C8 + 1) * v2), A + (B8 * u2) + ((C8 + 1) * v2)]}
D9: {Polygon[A + (B9 * u2) + (C9 * v2), A + ((B9 + 1) * u2) + (C9 * v2), A + ((B9 + 1) * u2) + ((C9 + 1) * v2), A + (B9 * u2) + ((C9 + 1) * v2)]}
D10: {Polygon[A + (B10 * u2) + (C10 * v2), A + ((B10 + 1) * u2) + (C10 * v2), A + ((B10 + 1) * u2) + ((C10 + 1) * v2), A + (B10 * u2) + ((C10 + 1) * v2)]}
D11: {Polygon[A + (B11 * u2) + (C11 * v2), A + ((B11 + 1) * u2) + (C11 * v2), A + ((B11 + 1) * u2) + ((C11 + 1) * v2), A + (B11 * u2) + ((C11 + 1) * v2)]}
D12: {Polygon[A + (B12 * u2) + (C12 * v2), A + ((B12 + 1) * u2) + (C12 * v2), A + ((B12 + 1) * u2) + ((C12 + 1) * v2), A + (B12 * u2) + ((C12 + 1) * v2)]}
B13 = Div(A13 - 1, alto)
B14 = Div(A14 - 1, alto)
B15 = Div(A15 - 1, alto)
B16 = Div(A16 - 1, alto)
B17 = Div(A17 - 1, alto)
B18 = Div(A18 - 1, alto)
B19 = Div(A19 - 1, alto)
B20 = Div(A20 - 1, alto)
B21 = Div(A21 - 1, alto)
B22 = Div(A22 - 1, alto)
B23 = Div(A23 - 1, alto)
B24 = Div(A24 - 1, alto)
segmentos = Sequence(Segment[A + (k * u2), D + (k * u2)], k, 1, ancho - 1)
lista2 = Sequence(Segment[A + (k * v2), B + (k * v2)], k, 1, alto - 1)
e = false
D13: {Polygon[A + (B13 * u2) + (C13 * v2), A + ((B13 + 1) * u2) + (C13 * v2), A + ((B13 + 1) * u2) + ((C13 + 1) * v2), A + (B13 * u2) + ((C13 + 1) * v2)]}
D14: {Polygon[A + (B14 * u2) + (C14 * v2), A + ((B14 + 1) * u2) + (C14 * v2), A + ((B14 + 1) * u2) + ((C14 + 1) * v2), A + (B14 * u2) + ((C14 + 1) * v2)]}
D15: {Polygon[A + (B15 * u2) + (C15 * v2), A + ((B15 + 1) * u2) + (C15 * v2), A + ((B15 + 1) * u2) + ((C15 + 1) * v2), A + (B15 * u2) + ((C15 + 1) * v2)]}
D16: {Polygon[A + (B16 * u2) + (C16 * v2), A + ((B16 + 1) * u2) + (C16 * v2), A + ((B16 + 1) * u2) + ((C16 + 1) * v2), A + (B16 * u2) + ((C16 + 1) * v2)]}
D17: {Polygon[A + (B17 * u2) + (C17 * v2), A + ((B17 + 1) * u2) + (C17 * v2), A + ((B17 + 1) * u2) + ((C17 + 1) * v2), A + (B17 * u2) + ((C17 + 1) * v2)]}
D18: {Polygon[A + (B18 * u2) + (C18 * v2), A + ((B18 + 1) * u2) + (C18 * v2), A + ((B18 + 1) * u2) + ((C18 + 1) * v2), A + (B18 * u2) + ((C18 + 1) * v2)]}
D19: {Polygon[A + (B19 * u2) + (C19 * v2), A + ((B19 + 1) * u2) + (C19 * v2), A + ((B19 + 1) * u2) + ((C19 + 1) * v2), A + (B19 * u2) + ((C19 + 1) * v2)]}
D20: {Polygon[A + (B20 * u2) + (C20 * v2), A + ((B20 + 1) * u2) + (C20 * v2), A + ((B20 + 1) * u2) + ((C20 + 1) * v2), A + (B20 * u2) + ((C20 + 1) * v2)]}
D21: {Polygon[A + (B21 * u2) + (C21 * v2), A + ((B21 + 1) * u2) + (C21 * v2), A + ((B21 + 1) * u2) + ((C21 + 1) * v2), A + (B21 * u2) + ((C21 + 1) * v2)]}
D22: {Polygon[A + (B22 * u2) + (C22 * v2), A + ((B22 + 1) * u2) + (C22 * v2), A + ((B22 + 1) * u2) + ((C22 + 1) * v2), A + (B22 * u2) + ((C22 + 1) * v2)]}
D23: {Polygon[A + (B23 * u2) + (C23 * v2), A + ((B23 + 1) * u2) + (C23 * v2), A + ((B23 + 1) * u2) + ((C23 + 1) * v2), A + (B23 * u2) + ((C23 + 1) * v2)]}
D24: {Polygon[A + (B24 * u2) + (C24 * v2), A + ((B24 + 1) * u2) + (C24 * v2), A + ((B24 + 1) * u2) + ((C24 + 1) * v2), A + (B24 * u2) + ((C24 + 1) * v2)]}
ocupados = Unique(polidestrellas)
libres: N - Length[ocupados]
E1 = CountIf(x ≟ A1, ocupados)
E2 = CountIf(x ≟ A2, ocupados)
E3 = CountIf(x ≟ A3, ocupados)
E4 = CountIf(x ≟ A4, ocupados)
E5 = CountIf(x ≟ A5, ocupados)
E6 = CountIf(x ≟ A6, ocupados)
E7 = CountIf(x ≟ A7, ocupados)
E8 = CountIf(x ≟ A8, ocupados)
E9 = CountIf(x ≟ A9, ocupados)
E10 = CountIf(x ≟ A10, ocupados)
E11 = CountIf(x ≟ A11, ocupados)
E12 = CountIf(x ≟ A12, ocupados)
E13 = CountIf(x ≟ A13, ocupados)
E14 = CountIf(x ≟ A14, ocupados)
E15 = CountIf(x ≟ A15, ocupados)
E16 = CountIf(x ≟ A16, ocupados)
E17 = CountIf(x ≟ A17, ocupados)
E18 = CountIf(x ≟ A18, ocupados)
E19 = CountIf(x ≟ A19, ocupados)
E20 = CountIf(x ≟ A20, ocupados)
E21 = CountIf(x ≟ A21, ocupados)
E22 = CountIf(x ≟ A22, ocupados)
E23 = CountIf(x ≟ A23, ocupados)
E24 = CountIf(x ≟ A24, ocupados)
texto1: "Quedan " + libres + " zonas libres"
miniestrellas = Sequence(A + (((2 * random()) - 0.5) * u) + (((2 * random()) - 0.3) * v), i, 1, 30)
texquedan = If(libres ≟ 1, "Queda 1 zona libre", texto1)
G3: 0
G4: 0
G5: 0
G6: 0
G7: 0
G8: 0
G9: 0
G10: 0
G11: 0
G12: 0
G13: 0
G14: 0
G15: 0
G16: 0
G17: 0
G18: 0
G19: 0
G20: 0
G21: 0
G22: 0
G23: 0
G24: 0
f = Sum(F1:F24)
F2: 0
F3: 1
F4 = 2
F5 = 3
F6 = 4
F7 = 5
F8 = 6
F9 = 7
F10 = 8
F11 = 9
F12 = 10
F13 = 11
F14 = 12
F15 = 13
F16 = 14
F17 = 15
F18 = 16
F19 = 17
F20 = 18
F21 = 19
F22 = 20
F23 = 21
F24 = 22
F25 = 23
Suma[F1:F24]: 0
G25: 0
G26 = Sum(G2:G25)
H2: G2 / G$26
G27 = NaN
H3: G3 / G$26
G28 = NaN
H4: G4 / G$26
G29 = NaN
H5: G5 / G$26
G30 = NaN
H6: G6 / G$26
G31 = NaN
H7: G7 / G$26
G32 = NaN
H8: G8 / G$26
G33 = NaN
H9: G9 / G$26
G34 = NaN
H10: G10 / G$26
G35 = NaN
H11: G11 / G$26
G36 = NaN
H12: G12 / G$26
G37 = NaN
H13: G13 / G$26
G38 = NaN
H14: G14 / G$26
G39 = NaN
H15: G15 / G$26
G40 = NaN
H16: G16 / G$26
G41 = NaN
H17: G17 / G$26
G42 = NaN
H18: G18 / G$26
G43 = NaN
H19: G19 / G$26
G44 = NaN
H20: G20 / G$26
G45 = NaN
H21: G21 / G$26
G46 = NaN
H22: G22 / G$26
G47 = NaN
H23: G23 / G$26
G48 = NaN
H24: G24 / G$26
G49 = NaN
H25: G25 / G$26
G50 = NaN
I2: (F2 * H2 / N)
I3: (F3 * H3 / N)
I4: (F4 * H4 / N)
I5: (F5 * H5 / N)
I6: (F6 * H6 / N)
I7: (F7 * H7 / N)
I8: (F8 * H8 / N)
I9: (F9 * H9 / N)
I10: (F10 * H10 / N)
I11: (F11 * H11 / N)
I12: (F12 * H12 / N)
I13: (F13 * H13 / N)
I14: (F14 * H14 / N)
I15: (F15 * H15 / N)
I16: (F16 * H16 / N)
I17: (F17 * H17 / N)
I18: (F18 * H18 / N)
I19: (F19 * H19 / N)
I20: (F20 * H20 / N)
I21: (F21 * H21 / N)
I22: (F22 * H22 / N)
I23: (F23 * H23 / N)
I24: (F24 * H24 / N)
I25: (F25 * H25 / N)
I26 = Sum(I2:I25)
simus: 0
Suma[G1:G24]: 0
H26: G26 / G$26
texto4: "Promedios: \frac{L}{N}: " + (LaTeX[I26]) + "  ; \; \; \frac{N}{L}:" + (LaTeX[1 / I26]) + ""
dd = 1.9 (slider from -5.1 to 5.1, step 0.2)
tablat = Join({{{F1, G1, H1, I1}}, Sequence[{Element[F2:F25, k], Element[G2:G25, k], Element[H2:H25, k], Element[I2:I25, k]}, k, 1, N], {{F26, G26, H26, I26}}})
texto3 = TableText(tablat, "|_")
texto2: "Proporción: \frac{L}{N}=\frac{" + (LaTeX[libres]) + "}{" + (LaTeX[N]) + "}=" + (LaTeX[libres / N]) + ""
lista1 = Sequence(A + (((2 * random()) - 0.5) * u) + (((2 * random()) - 0.3) * v), i, 1, 20)
g = false