Follow along with the video below to see how to install our site as a web app on your home screen.
Nota: This feature may not be available in some browsers.
( che comunque non fa miracoli)
mai covert... 
"#include <iostream>
#include <vector>
#include <ctime>
using namespace std;
// Funzione per generare tutte le formazioni numeriche in base al gruppo base e alla classe di sviluppo
vector<vector<int>> generate_formazioni(const vector<int>& gruppo_base, int classe_sviluppo) {
vector<vector<int>> formazioni; // Vettore che conterrà tutte le formazioni generate
int n = gruppo_base.size();
// Inizializzazione del vettore degli indici
vector<int> indices(classe_sviluppo);
for (int i = 0; i < classe_sviluppo; i++) {
indices[i] = i;
}
// Calcolo del numero totale di formazioni possibili
int total_combinations = 1;
for (int i = 0; i < classe_sviluppo; i++) {
total_combinations *= (n - i);
total_combinations /= (i + 1);
}
// Generazione delle combinazioni
for (int count = 0; count < total_combinations; count++) {
vector<int> current_combination;
for (int i = 0; i < classe_sviluppo; i++) {
current_combination.push_back(gruppo_base[indices[i]]);
}
formazioni.push_back(current_combination);
// Calcolo e visualizzazione della percentuale di completamento
double percent_complete = static_cast<double>(count + 1) / total_combinations * 100;
cout << "Formazione " << count + 1 << ": ";
for (int num : current_combination) {
cout << num << " ";
}
cout << "- Percentuale di completamento: " << percent_complete << "%" << endl;
// Calcolo delle combinazioni successive
int j = classe_sviluppo - 1;
while (j >= 0 && indices[j] == n - classe_sviluppo + j) {
j--;
}
if (j < 0) {
break;
}
indices[j]++;
for (int i = j + 1; i < classe_sviluppo; i++) {
indices[i] = indices[j] + i - j;
}
}
return formazioni;
}
int main() {
vector<int> gruppo_base;
for (int i = 1; i <= 90; i++) {
gruppo_base.push_back(i);
}
int classe_sviluppo = 5;
// Genera le formazioni e calcola il tempo di esecuzione
clock_t start_time = clock();
vector<vector<int>> formazioni_generate = generate_formazioni(gruppo_base, classe_sviluppo);
clock_t end_time = clock();
double elapsed_time = double(end_time - start_time) / CLOCKS_PER_SEC;
cout << "Tempo di esecuzione: " << elapsed_time << " secondi" << endl;
return 0;
}
" al momento dispongo di questo pc: Intel(R) Celeron(R) J4125 CPU @ 2.00GHz 2.00 GHz 16,0 GB (15,8 GB utilizzabile) Sistema operativo a 64 bit, processore basato su x64 credi sia possibile procedere alle ottimizzazioni che mi hai indicato? " "
. Non fa altro che ripetere... "la lotteria è aleatoria... l'intelligenza artificiale non può aiutare a far vincere.. ecc... " Ma se la si prende con + tatto... e le si chiede solo dei pareri riduzionali e statistici si apre.. molto di + e credo che con il tempo... possa venire enormemente in aiuto se non altro... per le nuove idee di sviluppo, di linguaggi, di programmi e di basi di codice che altrimenti rimarrebbero sotto il cuscino... Io la trovo utilissima per queste cose anche se le pesca nel suo enorme database per altro neppure aggiornato ma fermo al 2021 e non le crea ex novo. Per quanto mi riguarda la sua "potenzialità di assistenza" per noi poveri mortali... non ha niente a che vedere con i motori di ricerca classici superandoli alla grande anche per quanto concerne la semplice "comunicazione..." 
Per generare tutte le c4 by 90 ci ha messo ben 104 minuti e passa!
Condivido in toto il pensiero di SLDR, che saluto anche se ci siamo persi...occasioni per continuare a discettare! Da il fu' Blaise Pascal, che per primo affermo' che il linguaggio chiaro (senza alludere ai linguaggi con cui si scrive il codice) e' sinonimo di pensiero altrettanto chiaro, per arrivare al mio amico Emil Kirchegaard, che tra l'altro ha titolato il suo Blog "Clear Language, Clear Mind" (per non scomodare i traduttori: Pensiero chiaro, mente Lucida) e' lampante che le azioni che seguono il pensiero sono efficaci se, cio' che si pensa ha un senso pratico.
Qui sopra vi e' uno Splendido Esempio di Pensiero Chiaro e Mente Lucida! Bravo Luigi, ti confermi superbo Fulmine di guerra!!!
Concordo, secondo me questo espediente è favoloso ( soprattutto per gli storici o gli storici dei sincroni di livello ma se inserisci un estrazione sbagliata e te ne accorgi solo dopo il risultato resta falsato , ci dovrebbe essere la possibilità di rifare il ricalcolo .
g++ generate_formazioni.cpp -o nome-eseguibile-volutonome-eseguibile-voluto.exe
int main() {
vector<int> gruppo_base;
for (int i = 1; i <= 90; i++) {
gruppo_base.push_back(i);
}
int classe_sviluppo = 5;
// Genera le formazioni e calcola il tempo di esecuzione
clock_t start_time = clock();
vector<vector<int>> formazioni_generate = generate_formazioni(gruppo_base, classe_sviluppo);
clock_t end_time = clock();
// Stampa le formazioni generate (commentato per non occupare troppo spazio nell'output)
/*
for (const auto& formazione : formazioni_generate) {
for (int num : formazione) {
cout << num << " ";
}
cout << endl;
}
*/
double elapsed_time = double(end_time - start_time) / CLOCKS_PER_SEC;
cout << "Tempo di esecuzione: " << elapsed_time << " secondi" << endl;
return 0;
}
#include <iostream>
#include <vector>
#include <ctime>
using namespace std;
// Funzione per generare tutte le formazioni numeriche in base al gruppo base e alla classe di sviluppo
vector<vector<int>> generate_formazioni(const vector<int>& gruppo_base, int classe_sviluppo) {
vector<vector<int>> formazioni; // Vettore che conterrà tutte le formazioni generate
int n = gruppo_base.size();
int num_combinazioni = 1 << n; // Numero totale di combinazioni possibili (2^n)
// Generazione delle combinazioni utilizzando l'algoritmo basato sui bit
for (int i = 1; i < num_combinazioni; i++) {
vector<int> current_combination;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
current_combination.push_back(gruppo_base[j]);
}
}
if (current_combination.size() == classe_sviluppo) {
formazioni.push_back(current_combination);
}
}
return formazioni;
}
int main() {
vector<int> gruppo_base;
for (int i = 1; i <= 90; i++) {
gruppo_base.push_back(i);
}
int classe_sviluppo = 5;
// Genera le formazioni e calcola il tempo di esecuzione
clock_t start_time = clock();
vector<vector<int>> formazioni_generate = generate_formazioni(gruppo_base, classe_sviluppo);
clock_t end_time = clock();
// Stampa le formazioni generate (commentato per non occupare troppo spazio nell'output)
/*
for (const auto& formazione : formazioni_generate) {
for (int num : formazione) {
cout << num << " ";
}
cout << endl;
}
*/
double elapsed_time = double(end_time - start_time) / CLOCKS_PER_SEC;
cout << "Tempo di esecuzione: " << elapsed_time << " secondi" << endl;
return 0;
}
