Discussione Ufficiale Programmiamo con Inforge | Esercitazione 01 in C | Livello base

Not an engineer · 20 Febbraio 2021

Programmiamo con Inforge | Presentazione

Ad oggi, sul web, si trovano moltissime guide sui vari linguaggi di programmazione e sulle loro molteplici applicazioni. Tuttavia, chi si approccia a queste risorse, non sempre riesce a mettere in pratica ciò che ha appreso. Al fine di limitare queste mancanze, nasce Programmiamo con Inforge.

In questa rubrica potrai scrivere codice per la risoluzione di alcuni problemi legati alla programmazione, mettendo in pratica quanto stai apprendendo dalla teoria oppure mostrando le tue abilità e competenze nel campo dell’informatica.

Partiamo dalle Basi del C

In questa guida puoi trovare i testi per studiare e approfondire il C: I migliori libri per imparare e approfondire il C
In questa discussione puoi trovare le risposte alle domande più frequenti su come scrivere codice in C: Frequently asked questions: da dove si parte?

Esercitazione 01 in C | Livello base | [Array e operazioni]

L'esercitazione si compone di 7 esercizi nei quali ti sarà richiesto di definire una serie di funzioni utili per lo svolgimento di diverse operazioni sugli array. Una volta scritte le funzioni, dovrai richiamarle nel main() e chiedere all'utente di svolgerle.

Per vedere questo contenuto, devi Accedere o Registrarti.

Soluzioni

Nell'eventualità in cui non dovessi riuscire ad approcciarti ad uno degli esercizi proposti, prendi queste soluzioni come spunto per elaborarne una nuova versione. Tuttavia, ti consigliamo di pubblicare una tua soluzione originale in questa discussione così da poter essere aiutato passo passo ad arrivare ad un codice migliore.

Per vedere questo contenuto, devi Accedere o Registrarti.

Conclusioni

Pubblica la soluzione ottimale per risolvere gli esercizi e ricorda che puoi confrontarti con il resto della community in questo thread, chiedere aiuto o aiutare gli altri

demtor · 21 Febbraio 2021

Rispondo e grazie

Per vedere questo contenuto, devi Accedere o Registrarti.

DispatchCode · 1 Marzo 2021

Riporto alcune mie considerazioni taggando chi ha dato la propria soluzione (colgol'occasione per ringraziare anticipatamente chi ha partecipato e sta partecipando!)

Per vedere questo contenuto, devi Accedere o Registrarti.

Ciò detto, ben fatto a tutti e soprattutto grazie per la partecipazione!

Se avete domande o volete commentare qualcosa, sentitevi liberi di postare.

Sax3r28 · 24 Febbraio 2021

Sono più arrugginito di quanto pensassi ma a prima vista la logica penso di averla azzeccata, ovviamente il codice non parte mai al primo tentativo ma lo condivido lo stesso :rofl:

C++:

#include <stdio.h>
#include <math.h>
#include <iostream>
#include <fstream>
#include <malloc.h>


double array_mean(double arr_1[],int dim)
{
    double med=0,temp=0;
 
    for(int i=0;i<dim;i++)
    {
        temp+=arr_1[i];
    }
    med=temp/dim;
 
    return med; 
}


void array_print_to_screen(double arr_1[],int dim)
{
    for(int i=0;i<dim;i++)
    {
        printf("\narr_1[%d]= %f",i,arr_1[i]);
    } 
}


double array_input(double arr_1[],int dim)
{
    for(int i=0;i<dim;i++)
    {
        printf("\nInserire %do valore: ",i+1);
        scanf("%f",&arr_1[i]);
    }     
}


double* array_alloc(int dim)
{
    double* arr_1;
    arr_1=(double*)malloc(dim*sizeof(double));
    if (arr_1 == NULL) {
        printf("\nMalloc non riuscito.");
        exit(0);
    }
    else
    {
        printf("\nMalloc riuscito."); 
    }
 
    return arr_1;
}


double array_min_index(double arr_1[],int dim)
{
    double min=0;
 
    for(int i=1;i<=dim;i++)
    {
        if(arr_1[i-1]<arr_1[i])
        {
            min=arr_1[i-1];
        }
        else
        {
            min=arr_1[i];
        }
    }
 
    return min;
}


double array_sort(double arr_1[],int dim)
{
    for(int i=0; i<dim; i++)
    {
        for(int j=i+1;j<dim;j++)
        {
            if(arr_1[j]<arr_1[i])
            {
                float temp;
                temp=arr_1[j];
                arr_1[j]=arr_1[i];
                arr_1[i]=temp;                             
            }     
        }
    }
}


void array_write_to_file(double arr_1[],int dim,FILE* Wfile)
{
    for(int i=0;i<dim;i++)
    {
        fprintf(Wfile,"%d.%f\n",i+1,arr_1[i]);
    } 
}


int main()
{ 
    int dim=0;
    printf("Dimensione array: ");
    scanf("%d",&dim);
 
    double* arr_1; 
    FILE * Wfile; 
 
    arr_1=array_alloc(dim);
    array_input(arr_1,dim);
    array_print_to_screen(arr_1,dim);
 
    array_sort(arr_1,dim);
    array_print_to_screen(arr_1,dim);
 
    Wfile=fopen("values.dat","w");
    if (arr_1 != NULL)
    {
        array_write_to_file(arr_1,dim,Wfile);
    }
    fclose(Wfile);
 
    free(arr_1);
 
    return 0; 
}

ConanDP · 24 Febbraio 2021

Ecco il mio codice, spero sia almeno decente ahahah

C++:

#include <iostream>
#include <fstream>


// Calcolo media array (esercizio 1)
float array_mean(float array[], int number_of_items) {
    int i;
    float media;
    
    for(i = 0; i < number_of_items; i++) {
        media = media + array[i];
    }
    
    media = media / number_of_items;
    
    return media;
}

// Stampa array (esercizio 2)
void array_print_to_screen(float array[], int number_of_items) {
    
    using namespace std;
    
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<array[i]<<" ";
    }
}


// Richiesta input dei valori float (esercizio 3)
void array_input(float array[], int number_of_items) {
    
    using namespace std;
    
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<"\nInserisci "<<i+1<<"*"<<" valore float\n";
        cin>>array[i];
    }
}

// Allocazione array dinamico (esercizio 4)
void array_alloc(float **array, int number_of_items) {
    *array = new float[number_of_items];
}

// Restituzione del numero più piccolo dell'array (esercizio 5)
void array_min_index(float *array, int number_of_items) {
    
    using namespace std;
    
    int i, j, max;
    float com;
        
    // Ordinamento array dal più piccolo al più grande
    for(j = number_of_items-1; j > 0; j--) {
        for(i=0; i<j; i++) {
            if(array[i] > array[i+1]) {
                com = array[i]; 
                array[i] = array[i+1]; 
                array[i+1] = com;
            }
        } 
    }
    // Stampa array
    cout<<"\nStampa array ordinato ";
    array_print_to_screen(array, number_of_items);
    cout<<"\n";
    
    // Stampa dell'elemento più piccolo
    cout<<"Elemento piu piccolo array: "<<array[0];
}

// Stampa vettore ordinato (esercizio 6) -> Viene già fatto nel 5


// Salvataggio vettore su un file e deallocamento dello stesso (esercizio 7)
void array_write_to_file(float array[], int number_of_items) {
    
    using namespace std;
    
    int i;
    
    ofstream OutFile;
    OutFile.open("values.dat");
    if(!OutFile) {
        cout<<"Error";
    } else {
        OutFile<<"Array:\n";
        for(i=0;i<number_of_items;i++) {
            OutFile<<array[i]<<" ";
        }
        OutFile.close();
    }
}





int main() {
    
    using namespace std;
    
    int number_of_items, i;
    float media;
    float* array;
    
    cout<<"Numero elementi array ";
    cin>>number_of_items;
    
    // Allocazione array dinamico
    array_alloc(&array, number_of_items);
    
    // Richiesta input dei valori float
    array_input(array, number_of_items);
    
    
    // Calcolo media array
    media = array_mean(array, number_of_items);
    
    // Stampa array
    cout<<"\nStampa array ";
    array_print_to_screen(array, number_of_items);
    
    // Numero più piccolo
    array_min_index(array, number_of_items);
    
    // File
    array_write_to_file(array, number_of_items);
    
    cout<<"\nMedia: " << media;
    
    // Deallocazione array (esercizio 8)
    delete[] array;
    
    return 0;
}

Kode · 2 Marzo 2021

Bene, da Programmatore in C vi do qualche mia considerazione sui codice. Non sono un critico né un esperto in C/C++, quindi ciò che farò è dare solamente la mia opinione personale con il fine di darvi dei feedback in grado di migliorarvi nel coding.

demtor ha detto:
Rispondo e grazie

*** Hidden text: cannot be quoted. ***

Direi che @demtor abbia fatto un codice impeccabile, ottima gestione delle variabili temporanee andando ad eliminare anche delle linee di codice superflue rispetto alla soluzione ufficiale. Inoltre, io size_t lo uso solamente quando si ha un riferimento di dimensionamento cosa che non si ha ad esempio per la dichiarazione di variabili temporanee utilizzate nei cicli, quindi questo, secondo me, ti dia un punto qualitativo migliore.

Sax3r28 ha detto:

Sono più arrugginito di quanto pensassi ma a prima vista la logica penso di averla azzeccata, ovviamente il codice non parte mai al primo tentativo ma lo condivido lo stesso

C++:

#include <stdio.h>
#include <math.h>
#include <iostream>
#include <fstream>
#include <malloc.h>


double array_mean(double arr_1[],int dim)
{
    double med=0,temp=0;

    for(int i=0;i<dim;i++)
    {
        temp+=arr_1[i];
    }
    med=temp/dim;

    return med;
}


void array_print_to_screen(double arr_1[],int dim)
{
    for(int i=0;i<dim;i++)
    {
        printf("\narr_1[%d]= %f",i,arr_1[i]);
    }
}


double array_input(double arr_1[],int dim)
{
    for(int i=0;i<dim;i++)
    {
        printf("\nInserire %do valore: ",i+1);
        scanf("%f",&arr_1[i]);
    }
}


double* array_alloc(int dim)
{
    double* arr_1;
    arr_1=(double*)malloc(dim*sizeof(double));
    if (arr_1 == NULL) {
        printf("\nMalloc non riuscito.");
        exit(0);
    }
    else
    {
        printf("\nMalloc riuscito.");
    }

    return arr_1;
}


double array_min_index(double arr_1[],int dim)
{
    double min=0;

    for(int i=1;i<=dim;i++)
    {
        if(arr_1[i-1]<arr_1[i])
        {
            min=arr_1[i-1];
        }
        else
        {
            min=arr_1[i];
        }
    }

    return min;
}


double array_sort(double arr_1[],int dim)
{
    for(int i=0; i<dim; i++)
    {
        for(int j=i+1;j<dim;j++)
        {
            if(arr_1[j]<arr_1[i])
            {
                float temp;
                temp=arr_1[j];
                arr_1[j]=arr_1[i];
                arr_1[i]=temp;                        
            }
        }
    }
}


void array_write_to_file(double arr_1[],int dim,FILE* Wfile)
{
    for(int i=0;i<dim;i++)
    {
        fprintf(Wfile,"%d.%f\n",i+1,arr_1[i]);
    }
}


int main()
{
    int dim=0;
    printf("Dimensione array: ");
    scanf("%d",&dim);

    double* arr_1;
    FILE * Wfile;

    arr_1=array_alloc(dim);
    array_input(arr_1,dim);
    array_print_to_screen(arr_1,dim);

    array_sort(arr_1,dim);
    array_print_to_screen(arr_1,dim);

    Wfile=fopen("values.dat","w");
    if (arr_1 != NULL)
    {
        array_write_to_file(arr_1,dim,Wfile);
    }
    fclose(Wfile);

    free(arr_1);

    return 0;
}

Ottimo controllo per le malloc che non hai dato dentro la funzione di allocazione che sia avvenuta sempre con successo, l'unica pecca qui, rispetto al commento precedente è che non hai minimizzato l'uso di variabili temporanee che, ripeto, non è un errore ma qualitativamente non è ottimale. Nel complesso, ottimo codice @Sax3r28 anche se presenta alcuni errori semantici (provate sempre il codice mi raccomando!) e credo che è solo una bozza di una versione completa viste le chiamate a funzioni del main, o sbaglio?

ConanDP ha detto:

Ecco il mio codice, spero sia almeno decente ahahah

C++:

#include <iostream>
#include <fstream>


// Calcolo media array (esercizio 1)
float array_mean(float array[], int number_of_items) {
    int i;
    float media;
 
    for(i = 0; i < number_of_items; i++) {
        media = media + array[i];
    }
 
    media = media / number_of_items;
 
    return media;
}

// Stampa array (esercizio 2)
void array_print_to_screen(float array[], int number_of_items) {
 
    using namespace std;
 
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<array[i]<<" ";
    }
}


// Richiesta input dei valori float (esercizio 3)
void array_input(float array[], int number_of_items) {
 
    using namespace std;
 
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<"\nInserisci "<<i+1<<"*"<<" valore float\n";
        cin>>array[i];
    }
}

// Allocazione array dinamico (esercizio 4)
void array_alloc(float **array, int number_of_items) {
    *array = new float[number_of_items];
}

// Restituzione del numero più piccolo dell'array (esercizio 5)
void array_min_index(float *array, int number_of_items) {
 
    using namespace std;
 
    int i, j, max;
    float com;
     
    // Ordinamento array dal più piccolo al più grande
    for(j = number_of_items-1; j > 0; j--) {
        for(i=0; i<j; i++) {
            if(array[i] > array[i+1]) {
                com = array[i];
                array[i] = array[i+1];
                array[i+1] = com;
            }
        }
    }
    // Stampa array
    cout<<"\nStampa array ordinato ";
    array_print_to_screen(array, number_of_items);
    cout<<"\n";
 
    // Stampa dell'elemento più piccolo
    cout<<"Elemento piu piccolo array: "<<array[0];
}

// Stampa vettore ordinato (esercizio 6) -> Viene già fatto nel 5


// Salvataggio vettore su un file e deallocamento dello stesso (esercizio 7)
void array_write_to_file(float array[], int number_of_items) {
 
    using namespace std;
 
    int i;
 
    ofstream OutFile;
    OutFile.open("values.dat");
    if(!OutFile) {
        cout<<"Error";
    } else {
        OutFile<<"Array:\n";
        for(i=0;i<number_of_items;i++) {
            OutFile<<array[i]<<" ";
        }
        OutFile.close();
    }
}





int main() {
 
    using namespace std;
 
    int number_of_items, i;
    float media;
    float* array;
 
    cout<<"Numero elementi array ";
    cin>>number_of_items;
 
    // Allocazione array dinamico
    array_alloc(&array, number_of_items);
 
    // Richiesta input dei valori float
    array_input(array, number_of_items);
 
 
    // Calcolo media array
    media = array_mean(array, number_of_items);
 
    // Stampa array
    cout<<"\nStampa array ";
    array_print_to_screen(array, number_of_items);
 
    // Numero più piccolo
    array_min_index(array, number_of_items);
 
    // File
    array_write_to_file(array, number_of_items);
 
    cout<<"\nMedia: " << media;
 
    // Deallocazione array (esercizio 8)
    delete[] array;
 
    return 0;
}

Ottimo codice, ho notato giusto qualche piccola ottimizzazione possibile andando a ridurre il numero di variabili temporanee che, ripeto anche questa volta, è solo per "leggerezza del codice" e non di efficienza (in tempi computazionali. non ci sta differenza e qualche byte temporaneo usato in più non è un problema). Unica pecca @ConanDP, Il fatto che tu abbia unito due funzioni (esercizio 5 e 6) non è buono in generale, questo perché quando due funzionalità non sono separate non sono divisibile atomicamente, ergo: non sono singolarmente utilizzabili e si crea un codice meno riutilizzabile.

GabryBarbe ha detto:

C++:

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
float vet_mean(float vet[], size_t len){
    size_t i;
    float S=0;
    for(i=0;i<len;i++){
        S=S+vet[i];
    }
    return S/len;
}
void vet_print(float vet[], size_t len){
    size_t i;
    for(i=0;i<len;i++){
        cout  <<  vet[i]  <<  " ";
    }
}
void vet_input(float vet[], size_t len){
    size_t i;
    for(i=0;i<len;i++){
        cout  <<  "Inserisci valore: ";
        cin  >>  vet[i];
    }
}
float *vet_alloc(size_t len){
    return (float*)malloc(len*sizeof(float));
}
size_t vet_min_index(float vet[], size_t len){
    size_t i, m=0;
    for(i=0;i<len;i++){
        if (vet[i]<vet[m])
            m=i;
    }
    return m;
}
float vet_swap(float vet[], size_t i, size_t j){
    float tmp;
    tmp = vet[i];
    vet[i]=vet[j];
    vet[j]=tmp;
}
void vet_sort(float vet[], size_t len){
    size_t i, x;
    for(i=0;i<len;i++){
        x=vet_min_index(&vet[i], len-i);
        vet_swap(vet,i,x+i);
    }
}
void vet_output_file(float vet[], size_t len, FILE *fn, float M){
    size_t i;
    fprintf(fn,"Array ordinato\n");
    for(i=0;i<len;i++)
        fprintf(fn,"%f \n",vet[i]);
    fprintf(fn,"Media dei numeri: ");
    fprintf(fn, "%f", M);
}
int main(){
    float *vet;
    size_t len;
    FILE* fn;
    float M;
    cout  <<  "Inserisci numero di caratteri Array: ";
    cin  >>  len;
    vet=vet_alloc(len);
    cout  <<  "Riempi Array"  <<  endl;
    vet_input(vet, len);
    cout  <<  "Il tuo Array è: ";
    vet_print(vet, len);
    cout  <<  endl  <<  "Il tuo Array oridnato è: ";
    vet_sort(vet, len);
    vet_print(vet, len);
    fn = fopen("values.dat","w");
    M=vet_mean(vet, len);
    vet_output_file(vet, len, fn, M);
    fclose(fn);
}

Codice molto basico, ma fa quello che deve fare haha.

PS: già che ci sono levatemi un dubbio. Come si fa rendere i messaggi visibili solo se si risponde a 3d?

Al di la di un errore sulle firme di una funzione, come citato sopra, ci possono essere dei piccoli accorgimenti per non utilizzare variabili temporanee e render il codice più compatto, semplice e comprensibile... per il resto è perfetto. Ottimo lavoro @GabryBarbe

Veslor · 21 Febbraio 2021

Bene in bocca al lupo

Roklau · 21 Febbraio 2021

Sono pronto :rulz:

Sax3r28 · 21 Febbraio 2021

Vai così, più arrugginito della bici di mio nonno ma ci provo :rofl:

stro*** come sono sicuramente farò aggiunte mie come ho sempre fatto non rispettando la richiesta, ma mi piace personalizzare le cose.

Rayzeer · 22 Febbraio 2021

Sono molto curioso.

Antipatico · 22 Febbraio 2021

Not an engineer ha detto:
Visualizza allegato 50142

Presentazione - Programmiamo con Inforge

Ad oggi, sul web, si trovano moltissime guide sui vari linguaggi di programmazione e sulle loro molteplici applicazioni. Tuttavia, chi si approccia a queste risorse, non sempre riesce a mettere in pratica ciò che ha appreso. Al fine di limitare queste mancanze, nasce Programmiamo con Inforge.

In questa rubrica potrai scrivere codice per la risoluzione di alcuni problemi legati alla programmazione, mettendo in pratica quanto stai apprendendo dalla teoria oppure mostrando le tue abilità e competenze nel campo dell’informatica.

Esercitazione 01 in C | Livello base
L'esercitazione si compone di 7 esercizi nei quali ti sarà richiesto di definire una serie di funzioni utili per lo svolgimento di diverse operazioni sugli array. Una volta scritte le funzioni, dovrai richiamarle nel main() e chiedere all'utente di svolgerle.

*** Hidden text: cannot be quoted. ***

Soluzioni

*** Hidden text: cannot be quoted. ***

Conclusioni
Ricorda che puoi confrontarti con il resto della community in questo thread, chiedere aiuto o aiutare gli altri

davvero ottimo raga bell'inizziativa, se avessi più spicci vi [donerei] unpo cosi che lo stato nn trattenga nada

Morabyte · 25 Febbraio 2021

ConanDP ha detto:

Ecco il mio codice, spero sia almeno decente ahahah

C++:

#include <iostream>
#include <fstream>


// Calcolo media array (esercizio 1)
float array_mean(float array[], int number_of_items) {
    int i;
    float media;
   
    for(i = 0; i < number_of_items; i++) {
        media = media + array[i];
    }
   
    media = media / number_of_items;
   
    return media;
}

// Stampa array (esercizio 2)
void array_print_to_screen(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<array[i]<<" ";
    }
}


// Richiesta input dei valori float (esercizio 3)
void array_input(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<"\nInserisci "<<i+1<<"*"<<" valore float\n";
        cin>>array[i];
    }
}

// Allocazione array dinamico (esercizio 4)
void array_alloc(float **array, int number_of_items) {
    *array = new float[number_of_items];
}

// Restituzione del numero più piccolo dell'array (esercizio 5)
void array_min_index(float *array, int number_of_items) {
   
    using namespace std;
   
    int i, j, max;
    float com;
       
    // Ordinamento array dal più piccolo al più grande
    for(j = number_of_items-1; j > 0; j--) {
        for(i=0; i<j; i++) {
            if(array[i] > array[i+1]) {
                com = array[i];
                array[i] = array[i+1];
                array[i+1] = com;
            }
        }
    }
    // Stampa array
    cout<<"\nStampa array ordinato ";
    array_print_to_screen(array, number_of_items);
    cout<<"\n";
   
    // Stampa dell'elemento più piccolo
    cout<<"Elemento piu piccolo array: "<<array[0];
}

// Stampa vettore ordinato (esercizio 6) -> Viene già fatto nel 5


// Salvataggio vettore su un file e deallocamento dello stesso (esercizio 7)
void array_write_to_file(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
   
    ofstream OutFile;
    OutFile.open("values.dat");
    if(!OutFile) {
        cout<<"Error";
    } else {
        OutFile<<"Array:\n";
        for(i=0;i<number_of_items;i++) {
            OutFile<<array[i]<<" ";
        }
        OutFile.close();
    }
}





int main() {
   
    using namespace std;
   
    int number_of_items, i;
    float media;
    float* array;
   
    cout<<"Numero elementi array ";
    cin>>number_of_items;
   
    // Allocazione array dinamico
    array_alloc(&array, number_of_items);
   
    // Richiesta input dei valori float
    array_input(array, number_of_items);
   
   
    // Calcolo media array
    media = array_mean(array, number_of_items);
   
    // Stampa array
    cout<<"\nStampa array ";
    array_print_to_screen(array, number_of_items);
   
    // Numero più piccolo
    array_min_index(array, number_of_items);
   
    // File
    array_write_to_file(array, number_of_items);
   
    cout<<"\nMedia: " << media;
   
    // Deallocazione array (esercizio 8)
    delete[] array;
   
    return 0;
}
[/CODE}
[/QUOTE]
Molto bene, sei stato bravo.

Messaggio unito automaticamente: 25 Febbraio 2021

ConanDP ha detto:

Ecco il mio codice, spero sia almeno decente ahahah

C++:

#include <iostream>
#include <fstream>


// Calcolo media array (esercizio 1)
float array_mean(float array[], int number_of_items) {
    int i;
    float media;
   
    for(i = 0; i < number_of_items; i++) {
        media = media + array[i];
    }
   
    media = media / number_of_items;
   
    return media;
}

// Stampa array (esercizio 2)
void array_print_to_screen(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<array[i]<<" ";
    }
}


// Richiesta input dei valori float (esercizio 3)
void array_input(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
    for(i = 0; i < number_of_items; i++) {
        cout<<"\nInserisci "<<i+1<<"*"<<" valore float\n";
        cin>>array[i];
    }
}

// Allocazione array dinamico (esercizio 4)
void array_alloc(float **array, int number_of_items) {
    *array = new float[number_of_items];
}

// Restituzione del numero più piccolo dell'array (esercizio 5)
void array_min_index(float *array, int number_of_items) {
   
    using namespace std;
   
    int i, j, max;
    float com;
       
    // Ordinamento array dal più piccolo al più grande
    for(j = number_of_items-1; j > 0; j--) {
        for(i=0; i<j; i++) {
            if(array[i] > array[i+1]) {
                com = array[i];
                array[i] = array[i+1];
                array[i+1] = com;
            }
        }
    }
    // Stampa array
    cout<<"\nStampa array ordinato ";
    array_print_to_screen(array, number_of_items);
    cout<<"\n";
   
    // Stampa dell'elemento più piccolo
    cout<<"Elemento piu piccolo array: "<<array[0];
}

// Stampa vettore ordinato (esercizio 6) -> Viene già fatto nel 5


// Salvataggio vettore su un file e deallocamento dello stesso (esercizio 7)
void array_write_to_file(float array[], int number_of_items) {
   
    using namespace std;
   
    int i;
   
    ofstream OutFile;
    OutFile.open("values.dat");
    if(!OutFile) {
        cout<<"Error";
    } else {
        OutFile<<"Array:\n";
        for(i=0;i<number_of_items;i++) {
            OutFile<<array[i]<<" ";
        }
        OutFile.close();
    }
}





int main() {
   
    using namespace std;
   
    int number_of_items, i;
    float media;
    float* array;
   
    cout<<"Numero elementi array ";
    cin>>number_of_items;
   
    // Allocazione array dinamico
    array_alloc(&array, number_of_items);
   
    // Richiesta input dei valori float
    array_input(array, number_of_items);
   
   
    // Calcolo media array
    media = array_mean(array, number_of_items);
   
    // Stampa array
    cout<<"\nStampa array ";
    array_print_to_screen(array, number_of_items);
   
    // Numero più piccolo
    array_min_index(array, number_of_items);
   
    // File
    array_write_to_file(array, number_of_items);
   
    cout<<"\nMedia: " << media;
   
    // Deallocazione array (esercizio 8)
    delete[] array;
   
    return 0;
}

Bravoooh

DispatchCode · 2 Marzo 2021

GabryBarbe ha detto:
Grazie @Kode . Quali punti potrebbero essere snelliti?

Per quanto dice invece @DispatchCode , in che modo potrei ottimizzare lo scope delle variabili?

Puoi sia compattarlo che evitare di dare "scope" così ampi. Se tu dichiari la variabile nella parte di inizializzazione del for, quella variabile sarà locale al solo ciclo. Idem le variabili che usi solo nel corpo dei ciclo.

C:

void vet_sort(float vet[], size_t len){
    size_t i, x;
    for(i=0;i<len;i++){
        x=vet_min_index(&vet[i], len-i);
        vet_swap(vet,i,x+i);
    }
}

Quindi in questo caso questa funzione puoi modificarla così:

C:

void vet_sort(float vet[], size_t len){
    for(size_t i=0;i<len;i++){
        size_t x=vet_min_index(&vet[i], len-i);
        vet_swap(vet,i,x+i);
    }
}

DispatchCode · 3 Marzo 2021

Sax3r28 ha detto:
Il mio 'problema' è che se metto float con decimali diversi da 0, quelli vengono arrotondati per difetto. Quindi se ho un 5.2 e un 5.1, il return dà 5 e non 5.1
Si può cambiare o mi devo accontentare di stamparlo?

Forse ho capito che intendi guardando i tuoi screen li sopra. Tu il valore devi comunque stamparlo formattato (con %f), e non farlo "tornare" dal main().
Il valore di ritorno del main serve solo per capire se il processo termina andando a buon fine oppure no (e il tipo di ritorno del main infatti è un intero).

Quindi tu dovresti aggiungere il printf con la stampa a video nella funzione main().

Utente cancellato 277320 · 18 Giugno 2021

belli questi esercizi

Messaggio unito automaticamente: 19 Giugno 2021

giocato anche io

C:

/*
 * Esercizi di base, per Inforge, by kernelspace
 *
 * Da linux/gcc, compila con:
 *
 *    gcc -Wall -o base main.c
 *
 * Sintassi conforme a
 *    https://www.kernel.org/doc/html/v4.10/process/coding-style.html
 * verificata con checkpatch.pl
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

static const char filename[] = "dati.txt";

static void err(char *msg)
{
    printf("errore: %s\n", msg);
    exit(1);
}

static float array_mean(float *array, int size)
{
    float mean;
    int n = size;

    while (size--)
        mean += *array++;
    mean /= n;

    return mean;
}

static void array_print_to_screen(float *array, int size)
{
    int i = 1;

    while (size--)
        printf("%d: %f\n", i++, *array++);
}

static void array_input(float *array, int size)
{
    float f;
    int i = 1;

    printf("vai con la sequenza\n");

    while (size--) {
        printf("%d: ", i++);
        scanf("%f", &f);
        *array++ = f;
    }
}

static float *array_alloc(int size)
{
    return (float *)malloc(size * sizeof(float));
}

static int array_min_index(float *f, int size)
{
    float min;
    int n, min_idx = 0;

    for (min = *f, n = 0; n < size; ++n) {
        if (f[n] < min) {
            min = f[n];
            min_idx = n;
        }
    }

    return min_idx;
}

static void array_sort(float *f, int size)
{
    float *p;
    int items, min_idx, i = 0;

    p = array_alloc(size);
    if (!p)
        err("non posso allocare");

    for (items = size; items; items--) {
        min_idx = array_min_index(f, items);
        p[i++] = f[min_idx];
        memmove(&f[min_idx], &f[min_idx + 1],
               (size - min_idx - 1) * sizeof(float));
    }

    memcpy(f, p, size * sizeof(float));
    free(p);
}

static int array_write_to_file(float *array, int size, const char *filename)
{

    FILE *f;
    int i = 1;

    f = fopen(filename, "w+");
    if (!f)
        return -1;

    fprintf(f, "Ecco la list ordinata:\n");
    while (size--)
        fprintf(f, "%d: %f\n", i++, *array++);

    fclose(f);

    return 0;
}

int main(void)
{
    int num = 0, x;
    float mean, *f;

    printf("Ciao !\n");
    printf("calcolo media, quanti valori vuoi inserite (max 100) ? ");

    while ((x = getchar()) != '\n') {
        num *= 10;
        num += x - 48;
    }

    if (!num || num > 100)
        err("valore errato");

    f = array_alloc(num);
    if (!f)
        err("non posso allocare");

    array_input(f, num);
    printf("hai inserito:\n");
    array_print_to_screen(f, num);

    printf("ora riordino ...\n");
    array_sort(f, num);
    printf("sequenza riordinata:\n");
    array_print_to_screen(f, num);


    mean = array_mean(f, num);
    printf("media :%f\n", mean);

    if (array_write_to_file(f, num, filename))
        err("non ho potuto salvare su file");

    printf("tutto ok, dati in %s !\n", filename);

    free(f);

    return 0;
}

Tytanyu · 21 Febbraio 2021

bella iniziativa

Tralalla · 21 Febbraio 2021

Salve

machk · 21 Febbraio 2021

grazie. provo

CAGE17 · 21 Febbraio 2021

sono curioso, graziee

v1Xsy · 21 Febbraio 2021

buona fortuna

inforge-user001 · 21 Febbraio 2021

Not an engineer ha detto:
Visualizza allegato 50142

Presentazione - Programmiamo con Inforge

Ad oggi, sul web, si trovano moltissime guide sui vari linguaggi di programmazione e sulle loro molteplici applicazioni. Tuttavia, chi si approccia a queste risorse, non sempre riesce a mettere in pratica ciò che ha appreso. Al fine di limitare queste mancanze, nasce Programmiamo con Inforge.

In questa rubrica potrai scrivere codice per la risoluzione di alcuni problemi legati alla programmazione, mettendo in pratica quanto stai apprendendo dalla teoria oppure mostrando le tue abilità e competenze nel campo dell’informatica.

Esercitazione 01 in C | Livello base
L'esercitazione si compone di 7 esercizi nei quali ti sarà richiesto di definire una serie di funzioni utili per lo svolgimento di diverse operazioni sugli array. Una volta scritte le funzioni, dovrai richiamarle nel main() e chiedere all'utente di svolgerle.

*** Hidden text: cannot be quoted. ***

Soluzioni

*** Hidden text: cannot be quoted. ***

Conclusioni
Ricorda che puoi confrontarti con il resto della community in questo thread, chiedere aiuto o aiutare gli altri

Rispondo e vado

DonRaffae · 21 Febbraio 2021

Non ho le minime competenze per poter partecipare, ma rispondo perché sono curioso e voglio seguire la challenge.

ConanDP · 22 Febbraio 2021

Non sono un granche in C, ma tentar non nuoce no?

gemi123 · 22 Febbraio 2021

TheunKnoWn9512 · 22 Febbraio 2021

Mmh... vediamo...

Cerca

Discussione Ufficiale Programmiamo con Inforge | Esercitazione 01 in C | Livello base

Not an engineer

demtor

DispatchCode

Sax3r28

ConanDP

Kode

Veslor

Roklau

Sax3r28

Rayzeer

Antipatico

Morabyte

DispatchCode

DispatchCode

Utente cancellato 277320

Tytanyu

Tralalla

machk

CAGE17

v1Xsy

inforge-user001

DonRaffae

ConanDP

gemi123

TheunKnoWn9512

DISCUSSIONI SIMILI