20 Απριλίου, 1970

Μετατροπή γραμμών σε στήλες, για το ΛΟΤΤΟ. (Convert rows to columns for Lotto).

 

Θα μετατρέψουμε τις γραμμές των 6 αριθμών σε στήλες. Θα δημιουργηθούν 6 νεα σετ δεδομένων και στη συνέχεια θα κάνουμε πρόβλεψη σε κάθε ένα ξεχωριστά.
We will convert the rows of the 6 numbers into columns. This will create 6 new datasets, and then we will make predictions for each one separately.
import numpy as np

numbers
=
[

[
0.05, 0.07, 0.11, 0.16, 0.23, 0.29],
[0.01, 0.13, 0.14, 0.21, 0.23, 0.31],
[0.11, 0.13, 0.21, 0.34, 0.46, 0.49],
[0.15, 0.23, 0.31, 0.39, 0.41, 0.42],
[0.01, 0.03, 0.23, 0.31, 0.37, 0.42],
[0.01, 0.16, 0.21, 0.27, 0.32, 0.41],
[0.02, 0.05, 0.4, 0.41, 0.43, 0.45],
[0.06, 0.09, 0.14, 0.18, 0.3, 0.44],
[0.07, 0.12, 0.34, 0.37, 0.4, 0.43],
[0.04, 0.07, 0.17, 0.19, 0.2, 0.37],
[0.03, 0.04, 0.1, 0.41, 0.45, 0.47],
[0.05, 0.11, 0.24, 0.35, 0.42, 0.49],
[0.04, 0.07, 0.11, 0.18, 0.28, 0.42],
[0.03, 0.19, 0.23, 0.39, 0.43, 0.49],
[0.04, 0.15, 0.16, 0.42, 0.45, 0.48],
[0.04, 0.07, 0.1, 0.32, 0.33, 0.4],
[0.12, 0.17, 0.2, 0.22, 0.42, 0.45],
[0.06, 0.1, 0.15, 0.38, 0.42, 0.48],
[0.04, 0.17, 0.27, 0.34, 0.36, 0.48],
[0.19, 0.26, 0.31, 0.32, 0.45, 0.48],
[0.27, 0.3, 0.31, 0.34, 0.35, 0.47],
[0.13, 0.14, 0.23, 0.28, 0.35, 0.36],
[0.01, 0.03, 0.26, 0.37, 0.46, 0.47],
[0.02, 0.08, 0.18, 0.24, 0.29, 0.4],
[0.05, 0.15, 0.25, 0.37, 0.39, 0.41],
[0.02, 0.07, 0.2, 0.3, 0.31, 0.34],
[0.06, 0.08, 0.12, 0.15, 0.21, 0.46],
[0.06, 0.11, 0.15, 0.31, 0.35, 0.49],
[0.06, 0.14, 0.18, 0.2, 0.23, 0.3],
[0.03, 0.13, 0.19, 0.22, 0.32, 0.38],
[0.08, 0.25, 0.31, 0.38, 0.39, 0.41],
[0.23, 0.26, 0.36, 0.41, 0.43, 0.47],
[0.13, 0.23, 0.36, 0.41, 0.46, 0.48],
[0.13, 0.14, 0.17, 0.24, 0.37, 0.46],
[0.08, 0.41, 0.42, 0.43, 0.44, 0.47],
[0.03, 0.05, 0.17, 0.26, 0.32, 0.44],
[0.01, 0.06, 0.08, 0.16, 0.21, 0.23],
[0.1, 0.11, 0.17, 0.19, 0.23, 0.33],
[0.01, 0.2, 0.24, 0.32, 0.42, 0.47],
[0.03, 0.05, 0.11, 0.25, 0.39, 0.45],
[0.03, 0.05, 0.22, 0.3, 0.39, 0.48],
[0.02, 0.07, 0.26, 0.39, 0.45, 0.49],
[0.08, 0.2, 0.23, 0.24, 0.3, 0.44],
[0.09, 0.11, 0.16, 0.25, 0.31, 0.45],
[0.03, 0.13, 0.36, 0.37, 0.38, 0.48],
[0.11, 0.24, 0.26, 0.32, 0.45, 0.49],
[0.05, 0.13, 0.14, 0.16, 0.26, 0.33],
[0.13, 0.22, 0.4, 0.41, 0.47, 0.48],
[0.07, 0.09, 0.13, 0.31, 0.32, 0.44],

]

transposed = np.array(list(zip(*numbers)))

for i, column in enumerate(transposed):
globals()[f"dataset_{i}"] = np.array(column)
print(f"dataset_{i} = np.array({globals()[f'dataset_{i}'].tolist()})")



Αποτελέσματα:

Το παρακάτω πρόγραμμα αφορά μια αναλυτική επεξεργασία δεδομένων για το παιχνίδι ΛΟΤΤΟ. Σκοπός του είναι η μετατροπή μιας δομής δεδομένων από γραμμές σε στήλες, έτσι ώστε κάθε στήλη να περιλαμβάνει τα δεδομένα από μία συγκεκριμένη θέση των αριθμών της κάθε κλήρωσης.
Αρχικά, το πρόγραμμα ξεκινά με την εισαγωγή των δεδομένων: μια λίστα με υπολίστες που κάθε μία περιέχει έξι αριθμούς. Αυτοί οι αριθμοί αντιπροσωπεύουν τα αποτελέσματα κάθε κλήρωσης του ΛΟΤΤΟ. Για την επεξεργασία και μετατροπή των δεδομένων χρησιμοποιείται η βιβλιοθήκη numpy, καθώς προσφέρει εξειδικευμένες λειτουργίες για αριθμητικές πράξεις και εύκολη διαχείριση πολυδιάστατων πινάκων.
Η κρίσιμη λειτουργία που χρησιμοποιείται είναι η zip(*), η οποία λειτουργεί ως μετασχηματιστής των αρχικών γραμμών σε στήλες. Με αυτό τον τρόπο, από την αρχική λίστα δημιουργούνται έξι νέες στήλες (δηλαδή, έξι νέα σετ δεδομένων), κάθε μία από τις οποίες περιέχει όλα τα δεδομένα της αντίστοιχης θέσης από όλες τις γραμμές.
Ακολούθως, κάθε μία από αυτές τις στήλες αποθηκεύεται σε μία ξεχωριστή μεταβλητή (dataset_0 έως dataset_5), επιτρέποντας την ξεχωριστή χρήση και ανάλυσή τους. Κάθε μεταβλητή περιέχει δεδομένα από τη συγκεκριμένη θέση του αρχικού συνόλου, διευκολύνοντας τη δημιουργία μοντέλων ή αναλύσεων που αφορούν τη συχνότητα, την πιθανότητα εμφάνισης ή άλλες στατιστικές μεταβλητές για κάθε θέση αριθμού ξεχωριστά.
Αυτή η προσέγγιση είναι πολύ χρήσιμη για τη βαθύτερη κατανόηση των δεδομένων και μπορεί να χρησιμοποιηθεί για τη βελτίωση των στρατηγικών στοιχηματισμού στο ΛΟΤΤΟ, καθώς και για τη δημιουργία προβλεπτικών μοντέλων που μπορεί να προσφέρουν υψηλότερες πιθανότητες επιτυχίας.
dataset_0 = np.array([0.05, 0.01, 0.11, 0.15, 0.01, 0.01, 0.02, 0.06, 0.07, 0.04,
 0.03, 0.05, 0.04, 0.03, 0.04, 0.04, 0.12, 0.06, 0.04, 0.19, 0.27, 0.13, 0.01, 
0.02, 0.05, 0.02, 0.06, 0.06, 0.06, 0.03, 0.08, 0.23, 0.13, 0.13, 0.08, 0.03,
 0.01, 0.1, 0.01, 0.03, 0.03, 0.02, 0.08, 0.09, 0.03, 0.11, 0.05, 0.13, 0.07])

dataset_1 = np.array([0.07, 0.13, 0.13, 0.23, 0.03, 0.16, 0.05, 0.09, 0.12, 0.07,
 0.04, 0.11, 0.07, 0.19, 0.15, 0.07, 0.17, 0.1, 0.17, 0.26, 0.3, 0.14, 0.03, 0.08,
 0.15, 0.07, 0.08, 0.11, 0.14, 0.13, 0.25, 0.26, 0.23, 0.14, 0.41, 0.05, 0.06, 
0.11, 0.2, 0.05, 0.05, 0.07, 0.2, 0.11, 0.13, 0.24, 0.13, 0.22, 0.09])

dataset_2 = np.array([0.11, 0.14, 0.21, 0.31, 0.23, 0.21, 0.4, 0.14, 0.34, 0.17,
 0.1, 0.24, 0.11, 0.23, 0.16, 0.1, 0.2, 0.15, 0.27, 0.31, 0.31, 0.23, 0.26, 0.18,
 0.25, 0.2, 0.12, 0.15, 0.18, 0.19, 0.31, 0.36, 0.36, 0.17, 0.42, 0.17, 0.08, 
0.17, 0.24, 0.11, 0.22, 0.26, 0.23, 0.16, 0.36, 0.26, 0.14, 0.4, 0.13])

dataset_3 = np.array([0.16, 0.21, 0.34, 0.39, 0.31, 0.27, 0.41, 0.18, 0.37, 0.19,
 0.41, 0.35, 0.18, 0.39, 0.42, 0.32, 0.22, 0.38, 0.34, 0.32, 0.34, 0.28, 0.37, 
0.24, 0.37, 0.3, 0.15, 0.31, 0.2, 0.22, 0.38, 0.41, 0.41, 0.24, 0.43, 0.26, 0.16,
 0.19, 0.32, 0.25, 0.3, 0.39, 0.24, 0.25, 0.37, 0.32, 0.16, 0.41, 0.31])

dataset_4 = np.array([0.23, 0.23, 0.46, 0.41, 0.37, 0.32, 0.43, 0.3, 0.4, 0.2,
0.45, 0.42, 0.28, 0.43, 0.45, 0.33, 0.42, 0.42, 0.36, 0.45, 0.35, 0.35, 0.46,
 0.29, 0.39, 0.31, 0.21, 0.35, 0.23, 0.32, 0.39, 0.43, 0.46, 0.37, 0.44, 0.32, 
0.21, 0.23, 0.42, 0.39, 0.39, 0.45, 0.3, 0.31, 0.38, 0.45, 0.26, 0.47, 0.32])

dataset_5 = np.array([0.29, 0.31, 0.49, 0.42, 0.42, 0.41, 0.45, 0.44, 0.43, 0.37,
 0.47, 0.49, 0.42, 0.49, 0.48, 0.4, 0.45, 0.48, 0.48, 0.48, 0.47, 0.36, 0.47,
 0.4, 0.41, 0.34, 0.46, 0.49, 0.3, 0.38, 0.41, 0.47, 0.48, 0.46, 0.47, 0.44, 
0.23, 0.33, 0.47, 0.45, 0.48, 0.49, 0.44, 0.45, 0.48, 0.49, 0.33, 0.48, 0.44])