partilhar o mais igualmente possivel os valores de uma lista entre 2 amigos

[msmsms]

olhar exemplo deixado em baixo:

etapa A - solução sôfrega:

EXEMPLO: objectivo final

dada como input por exemplo a lista {10,6,5,2}

fornecer como output as listas: amigo1: {10,5}, amigo2:{6,5}

dicas:

1 - colocar array por ordem decrescente CONSEGUIDO

2 - colocar elemento maior na lista do amigo 1 e o segundo maior na lista do amigo 2 NAO CONSEGUIDO

3 - colocar os restantes numeros em cada lista que contiver menor valor acumulado NAO CONSEGUIDO

(fazer uma segunda versão onde a aplicação vai receber como input uma lista através de ficheiro txt)

etapa B - solução recursiva:

estou a tentar a etapa A primeiro...

etapa C - solução dinâmica:

estou a tentar a etapa A primeiro...

Edited March 3, 2013 at 02:20 PM by msmsms

[Carlos7]

O teu português foi um bocadinho difícil de perceber mas o que tens de fazer para começar, será ordenar as listas por ordem decrescente tal como disseste (isto se achares necessário).

Depois percorres a lista e vês qual é o maior valor e colocas no amigo1, voltas a verificar qual o maior e colocas no amigo2 e vais sempre voltar verificar qual o maior...e ires somando os valores de cada amigo e inserires no que tiver menor soma. Isto supondo que percebi bem o que queres fazer..

[msmsms]

http://aed-fac.blogspot.pt/2013/03/tp1-desenvolvimento.html

estou a fazer nesse local

ainda estou com dificuldade na parte de colocar a lista por ordem decrescente...

encontrei um exemplo em ingles que envolver colocar 2 variaveis (i e j) e estou a tentar adaptar

Edited March 3, 2013 at 12:05 PM by msmsms

[pmg]

Para ordenar um array (o que, aparentemente, tu chamas uma lista) usa a funcao standard qsort (http://pubs.opengroup.org/onlinepubs/9699919799/functions/qsort.html).

Para usar essa funcao precisas de

a) saber o endereco do primeiro elemento do array (em principio o nome do array serve)

b) saber quantos elementos o array tem

c) saber qual o tamanho de cada elemento do array

d) de uma funcao "auxiliar" que compara elementos do array

Para o teu caso, o array é de inteiros e chama-se lista

a) endereco do primeiro elemento: &lista[0] ou apenas lista

b) usa sizeof lista / sizeof *lista

c) usa sizeof *lista

d) a funcao auxiliar pode muito bem apenas devolver a diferenca entre dois inteiros

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

int delta(const void *aa, const void *bb) {
   const int *a = aa;
   const int *b = bb;
   return *b - *a; /* devolver *a - *b para ordenar por ordem crescente */
}

int main(void) {
   size_t k;
   int lista[] = {5, 2, 10, 6};

   qsort(lista, sizeof lista / sizeof *lista, sizeof *lista, delta);
   /* pronto! array esta ordenado decrescentemente */

   printf("Lista decrescente: %d", lista[0]);
   for (k = 1; k < sizeof lista / sizeof *lista; k++) {
       printf(" %d", lista[k]);
   }
   puts("");
   return 0;
}

Edited March 3, 2013 at 12:17 PM by pmg

[msmsms]

eu acabei por fazer assim:

vou olhar e testar o teu

#include<stdio.h>
#include<conio.h>

int main(){

 int tabela[1000];
 int n;
 int i;
 int j;
 int t;
 int amigo1[0];
 int amigo2[0];

 scanf("%d",&n);

 for(i=0;i<n;i++)
   scanf("%d",&tabela[i]);

 for(i=0;i<n;i++)
   for(j=i+1;j<n;j++)

     if(tabela[i]>tabela[j]){
       t=tabela[i];
       tabela[i]=tabela[j];
       tabela[j]=t;
     }

 printf("decrescente: ");
 for(i=n-1;i>=0;i--)
   printf("%d ",tabela[i]);

 return 0;
}

o objectivo final nao é a lista descrescente total

é distribuila entre 2 amigos dando o maior valor ao 1 amigo e o segundo maior valor ao segundo amigo

e depois ir dando os restantes valores a quem tiver menos valor acumulado

http://aed-fac.blogspot.pt/2013/03/tp1-desenvolvimento.html

como é que eu faço para que o maior valor vá para uma nova lista ''amigo1''

e o segundo maior valor vá para uma segunda nova lista ''amigo2''?

[pmg]

eu acabei por fazer assim:

/* ... */
printf("decrescente: ");
for(i=n-1;i>=0;i--)
   printf("%d ",tabela[i]);
/* ... */

LOL!

Tu ordenaste a lista por ordem crescente e imprimiste-a do fim para o principio.

Nao e bem a mesma coisa 🙂

Mas podes muito bem usar a tua maneira de ordenar o array em vez do qsort.

Para resolver o problema, arranja mais dois arrays (duas "listas"), um para cada amigo.

Depois, num ciclo vais percorrendo o array inicial e metendo os valores no array de cada amigo ate chegares ao fim.

[msmsms]

LOL!

Tu ordenaste a lista por ordem crescente e imprimiste-a do fim para o principio.

Nao e bem a mesma coisa 🙂

Mas podes muito bem usar a tua maneira de ordenar o array em vez do qsort.

Para resolver o problema, arranja mais dois arrays (duas "listas"), um para cada amigo.

Depois, num ciclo vais percorrendo o array inicial e metendo os valores no array de cada amigo ate chegares ao fim.

- nao, eu fiz decrescente (do maior para o menor não é o descrescente?)

- eu já fiz os dois novos arrays no codigo mas o resto ''Depois, num ciclo vais percorrendo o array inicial e metendo os valores no array de cada amigo ate chegares ao fim.''

eu não estou a ver...

eu penso que tem de haver 2 procedimentos

o primeiro que é colocar o maior valor no array amigo1 e o segundo maior valor no array amigo2

se temos o array: 6,5,4,3,2,1

o amigo1 fica com o 6

e o amigo2 fica com o 5

e depois sobra 4,3,2,1

ai quem tiver menor acumulado fica com o maior numero

amigo1: 6

amigo2: 5,4

sobra 3,2,1

agora quem tem menos é o amigo 1 entao

amigo1: 6,3

amigo2: 5,4

sobra 2,1

agora quem tem menos é amigo2

amigo1: 6,3

amigo2: 5,4,2

sobra 1

agora quem tem menos é o amigo1

amigo1: 6,3,1

amigo2: 5,3,2

se não me enganei é este o procedimento

como é que vou fazer esta geringonça dando continuidade ao meu código?

Edited March 3, 2013 at 01:58 PM by msmsms

[Carlos7]

Na quarta iteração quem tem menos não é o amigo dois, têm os dois o mesmo valor (6+3=9) (5+4=9).

Para fazeres isso eu disse-te como podes fazer lá em cima, só não fiz foi o código.

Edited March 3, 2013 at 01:58 PM by Carlos7

[msmsms]

Na quarta iteração quem tem menos não é o amigo dois, têm os dois o mesmo valor (6+3=9) (5+4=9).

Para fazeres isso eu disse-te como podes fazer lá em cima, só não fiz foi o código.

- mas o procedimento de colocar o maior valor no amigo1 e o segundo maior valor no amigo2 é um

e o procedimento ir colocando os valores em cada um dos amigos conforme o valor que eles já tiverem acumulado é outro

- realmente não tinha pensado que pode haver empate e nesse caso acho que tem de ir para o amigo1

- eu preciso de algum arranque de código porque não sei passar de uma lista (já tenho uma lista completa com números descrescentes) para sublistas

- foi através de um exemplo que encontrei em inglês que consegui adaptar o meu código que já fazia os inputs para formar uma lista decrescente

- mas não tenho como encontrar exemplos que façam o restante porque nem sei se esses procedimentos têm nome.

preciso de um arrancar de código e acho que já lá chego se conseguir colocar o amigo1 a fazer algum output e o amigo2 a mesma coisa

[pmg]

Precisas tambem de contadores para os arrays extra.

Ao acrescentares a um dos arrays, aumentas o contador respectivo.

[msmsms]

Precisas tambem de contadores para os arrays extra.

Ao acrescentares a um dos arrays, aumentas o contador respectivo.

dá-me um dos teus arranca, senão não saio do sitio 😞

eu acabei por fazer os printfs para cada amigo

como vou colocar em código para dentro dos arrays amigo1 e amigo2 o primeiro e o segundo maior valor da lista decrescente que eu já fiz?

eu já ando faz 2 semanas e ainda só fiz isto!

#include<stdio.h>
#include<conio.h>
int main(){
int tabela[1000];
int n;
int i;
int j;
int t;
int amigo1[0];
int amigo2[0];
scanf("%d",&n);
for(i=0;i<n;i++)
   scanf("%d",&tabela[i]);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if(tabela[i]>tabela[j]){
   t=tabela[i];
   tabela[i]=tabela[j];
   tabela[j]=t;
}
printf("decrescente: ");
for(i=n-1;i>=0;i--)
   printf("%d ",tabela[i]);
printf("\n");
printf("amigo1: ");
printf("amigo2: ");

return 0;
}

[pmg]

int amigo1[0]: nao, nao, nao: isto cria uma "impossibilidade": um array com espaco para 0 elementos!

Tu queres criar os array amigo1 e amigo2 com "mais ou menos" metade do tamanho do array inicial. Eu sugiro exactamente o mesmo tamanho 🙂

int amigo1[1000];

Depois disso, como te disse precisas de saber quantos elementos tens em cada amigo

int namigo1 = 0;
int namigo2 = 0;

Depois, copiar um elemento da tabela inicial para um dos amigos basta uma atribuicao simples e actualizacao de contadores

amigo1[namigo1] = tabela[i];
namigo1 += 1;

Obviamente o codigo acima sera repetido para o amigo2 com as devidas alteracoes, e tem um if a controlar para qual dos amigos se vai copiar o numero.

Edited March 3, 2013 at 02:46 PM by pmg

[msmsms]

eu estive a ver melhor o enunciado original

http://aed-fac.blogspot.pt/2013/03/trabalho-1-enunciado-original.html

e é para devolver a diferença como output (a diferença que acontece entre o amigo1 e o amigo2)

vou tentar continuar com as tuas dicas pmg