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

Marco - Cacao ♠ · 22 Febbraio 2021

Bella iniziativa!

Deleted member 246689 · 22 Febbraio 2021

Alle2001 · 23 Febbraio 2021

provo

OROX · 23 Febbraio 2021

Ciao

The King of BlackOut · 23 Febbraio 2021

provo anche io!

Max Fridman · 23 Febbraio 2021

Come sta andando? @demtor ha già aggiornato il suo post

GrincH-- · 23 Febbraio 2021

Good luck ragazzi!
(io sono lato Python ahimè non potrò prendere parte)

Lay fall · 23 Febbraio 2021

Bello! Un pretesto per imparare il C !

Valley · 23 Febbraio 2021

Dove sono le vostre soluzioni? Da vero inesperto di C sono curioso :onemmae:

Vi ricordo che se avete problemi a risolvere qualche esercizio potete chiedere qui senza problemi

C'è il buon @Not an engineer per voi <3

ConanDP · 23 Febbraio 2021

Io sono arrivato al 4, magari domani metto quello che ho fatto fin'ora

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;
}

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

JunkCoder · 25 Febbraio 2021

Sono curioso di vedere l'esercizio

Mr. Prodigio · 25 Febbraio 2021

È una bellissima iniziativa, che certamente mi aiuterà con la programmazione in C... grazie!

GabryBarbe · 26 Febbraio 2021

Let's go!

1mdonk3y · 26 Febbraio 2021

Buongiorno

GabryBarbe · 26 Febbraio 2021

Dove posso postare il codice? Ammesso che vada postato

Valley · 27 Febbraio 2021

GabryBarbe ha detto:
Dove posso postare il codice? Ammesso che vada postato

Postalo pure qui

Kode · 27 Febbraio 2021

Sono curioso anche io

GabryBarbe · 27 Febbraio 2021

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?

Valley · 27 Febbraio 2021

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?

Per commentare il codice passo il compito a @Not an engineer
Per lo spoiler: è disponibile al momento solo allo staff

lord of hacking · 27 Febbraio 2021

DispatchCode · 27 Febbraio 2021

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

Secondo me conviene pubblicare sotto spoiler, così da occupare meno spazio nel thread e soprattutto lasciare a chi partecipa la scelta di visualizzare una soluzione oppure no.

Ps. in teoria dovresti utilizzare C e non C++

tinytmp · 28 Febbraio 2021

provo

Cerca

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

Marco - Cacao ♠

Deleted member 246689

Alle2001

OROX

The King of BlackOut

Max Fridman

Community Manager

GrincH--

Lay fall

Valley

ConanDP

Sax3r28

ConanDP

Morabyte

JunkCoder

Mr. Prodigio

GabryBarbe

1mdonk3y

GabryBarbe

Valley

Kode

GabryBarbe

Valley

lord of hacking

DispatchCode

tinytmp

DISCUSSIONI SIMILI