[P-Like]Algoritmo

[Kyros_]

ciao a tutti, dovrei creare un algoritmo basato su questa traccia e non so come iniziare :
"Siano dati due array 2D, Tablet_negozio, di dimensione Kx2, e Tablet_deposito, di dimensione Yx2, entrambi di tipo intero. In questi array sono memorizzati,per ciascuna riga,nella colonna 1 il codice di un Tablet, e nella colonna 2 quanti Tablet di quel tipo sono presneti, rispettivamente, in negozio ed in deposito.Le righe di entrambi gli array sono ordinate per codice del Tablet.Progettare in P-like un algoritmo, sotto forma di procedure (procedureQuantita_Tablet) che fornisca come risultato un array 2D Totale_Tablet che sempre rispettando l'ordine secondo il codice-tablet nella colonna 2 indichi quanti Tablet, per ciascun tipo, sono disponbili in totale (tra negozio e deposito)

[Kyros_]

ho fatto l'esercizio in c e vorrei sapere se va bene:

#include <stdio.h>
int main(){
int k;
printf("inserire dimensione riga ");
scanf("%d",&k);
int tablet_negozio[k][2];
int tablet_deposito[k][2];
int i;
int j;
int codice_tablet;
int Quantita_tablet[k][2];
j=0;
for(i=0;i<k;i++){
printf("inserire codice tablet ");
scanf("%d",&codice_tablet);
tablet_deposito[i][j]=codice_tablet;
tablet_negozio[i][j]=codice_tablet;
Quantita_tablet[i][j]=codice_tablet;
}
for(i=0;i<k;i++){
for(j=1;j<2;j++) {
printf("codice tablet=%d presente nel negozio ",tablet_negozio[i][0]);
scanf("%d",&tablet_negozio[i][j]);
printf("codice tablet=%d presente nel deposito ",tablet_deposito[i][0]);
scanf("%d",&tablet_deposito[i][j]);    
}    
}
for(i=0;i<k;i++) {
    for(j=1;j<2;j++) {
        Quantita_tablet[i][j]=tablet_negozio[i][j]+tablet_deposito[i][j];
    }
}
for(i=0;i<k;i++) {
    for(j=1;j<2;j++){
printf("tablet codice=%d in totale=%d \n",Quantita_tablet[i][j-1],Quantita_tablet[i][j]);    
}
}
    
}

[Scara95]

No, è sbagliato, le due tabelle posso avere un numero diverso di righe, inoltre ci possono essere buchi fra due righe:
Magazzino Negozio
1 1
3 2

La tua implementazione non rispetta nessuno dei due criteri.

Oltretutto è inutile fare un ciclo su [1,2) perché l'unico valore che può assumere è 1.

Per risolvere il problema puoi scorrere contemporaneamente i due array per riga. Si possono presentare 3 casi (M codice tablet magazzino, N codice tablet negozio, qt(m/n)=quantità in magazzino o negozio):

M=N hai qtm(M)+qtn(M) tablet del modello M, avanzi entrambi

M<N hai qtm(M) tablet del modello M avanzi il magazzino

M>N hai qtn(N) tablet del modello N avanzi il negozio

I risultati possono essere al più K+Y quando tutti i modelli sono diversi.

[Kyros_]

non riesco a capire l ultima parte e non so in che dimensione devo fare l'array finale:
"
Per risolvere il problema puoi scorrere contemporaneamente i due array per riga. Si possono presentare 3 casi (M codice tablet magazzino, N codice tablet negozio, qt(m/n)=quantità in magazzino o negozio):

M=N hai qtm(M)+qtn(M) tablet del modello M, avanzi entrambi

M<N hai qtm(M) tablet del modello M avanzi il magazzino

M>N hai qtn(N) tablet del modello N avanzi il negozio

I risultati possono essere al più K+Y quando tutti i modelli sono diversi."
mi potresti fare un esempio in C?

[Kyros_]

#include <stdio.h>
int main(){
int k;
int y;
printf("inserire dimensione riga negozio ");
scanf("%d",&k);
int tablet_negozio[k][2];
printf("inserire dimensione riga deposito ");
scanf("%d",&y);
int tablet_deposito[y][2];
int i;
int j;
int p;
int codice_tablet;
int Quantita_tablet[?][2];//? dimensione non definita
j=0;
for(i=0;i<k;i++){
printf("inserire codice tablet negozio");
scanf("%d",&codice_tablet);
tablet_negozio[i][j]=codice_tablet;
}
for(i=0;i<y;i++){
printf("inserire codice tablet deposito ");
scanf("%d",&codice_tablet);
tablet_deposito[i][j]=codice_tablet;
}
j=1;
for(i=0;i<k;i++){
printf("codice tablet=%d presente nel negozio ",tablet_negozio[i][j-1]);
scanf("%d",&tablet_negozio[i][j]);
}
for(i=0;i<y;i++) {
printf("codice tablet=%d presente nel deposito ",tablet_deposito[i][j-1]);
scanf("%d",&tablet_deposito[i][j]);
}
i=0;
j=0;
p=0;
do {
    if(tablet_negozio[i][j]==tablet_deposito[p][j]){
        Quantita_tablet[i][j+1]=tablet_negozio[i][j+1]+tablet_deposito[p][j+1];
        Quantita_tablet[i][j]=tablet_negozio[i][j];
    }
    if(tablet_deposito[p][j]>tablet_negozio[i][j]){
    Quantita_tablet[i][j+1]=tablet_deposito[p][j+1];
    Quantita_tablet[i][j]=tablet_deposito[y][j];
    }
    if(tablet_deposito[p][j]<tablet_negozio[i][j]) {
    Quantita_tablet[i][j+1]=tablet_negozio[i][j+1];
    Quantita_tablet[i][j]=tablet_negozio[i][j];
    }
    i++;
    p++;
}while(i<?);
j=1;
for(i=0;i<?;i++) {
    
printf("tablet codice=%d in totale=%d \n",Quantita_tablet[i][j-1],Quantita_tablet[i][j]);    

}
    
}

[Scara95]

#include <stdio.h>




const int cd = 0;
const int qt = 1;


int somma(int N[][2], int K, int M[][2], int Y, int S[][2]) {
	int k = 0, y = 0, s = 0;
	while(k < K || y < Y) {
		if(k >= K || y >= Y) { //copia gli elementi rimasti
			for( ; k < K; ++k) {
				S[s][cd] = N[k][cd];
				S[s][qt] = N[k][qt];
				++s;
			}
			for( ; y < Y; ++y) {
				S[s][cd] = M[y][cd];
				S[s][qt] = M[y][qt];
				++s;
			}
		}
		else {
			if(N[k][cd] == M[y][cd]) {
				S[s][cd] = N[k][cd];
				S[s][qt] = N[k][qt] + M[y][qt];
				++s; ++k; ++y;
			}
			else if(N[k][cd] < M[y][cd]) {
				S[s][cd] = N[k][cd];
				S[s][qt] = N[k][qt];
				++s; ++k;
			}
			else { //if(N[k][cd] > M[y][cd])
				S[s][cd] = M[y][cd];
				S[s][qt] = M[y][qt];
				++s; ++y;
			}
		}
	}
	return s;
}


int main(void) {
	int K, Y;
	printf("Numero di entry in negozio: ");
	scanf("%d", &K);
	printf("Numero di entry in magazzino: ");
	scanf("%d", &Y);
	int N[K][2];
	int M[Y][2];
	puts("Tablet in negozio:");
	for(int i = 0; i < K; ++i) {
		printf("Codice: ");
		scanf("%d", &N[i][cd]);
		printf("Quantita': ");
		scanf("%d", &N[i][qt]);
	}
	puts("Tablet in magazzino:");
	for(int i = 0; i < Y; ++i) {
		printf("Codice: ");
		scanf("%d", &M[i][cd]);
		printf("Quantita': ");
		scanf("%d", &M[i][qt]);
	}
	int S[K+Y][2];
	int H = somma(N, K, M, Y, S);
	puts("Quantita' totali:");
	for(int i = 0; i < H; ++i) {
		printf("%d: %d\n", S[i][cd], S[i][qt]);
	}
	return 0;
}

Assunzioni input: l'inserimento è ordinato per codice, altrimenti ovviamente la funzione con funziona correttamente.

Come funziona?
Essendo che le entry sono ordinate per codice, scorrendoli in ordine o uno è minore dell'altro, in questo caso non c'è un corrispettivo nell'altra tabella e puoi copiarlo subito, o sono uguali, in questo caso c'è un match.

Assunzioni sui risultati:
cds(M/N) insieme dei codici
Dimensione minima della tabella di somma = min(K, Y) nel caso in cui cds(M) contenuto cds(N) o cds(N) contenuto cds(M)
Dimensione massima della tabella di somma = K+Y nel caso in cui cds(M) e cds(N) siano disgiunti
La tabella di output resta ordinata rispetto al codice

Assunzioni sul codice: standard C99