Albero speculare(Albero a) {
Albero nuovo = (Albero) malloc(sizeof(Albero));
nuovo->element = a->element;
nuovo->left = copia(a->right);
nuovo->right = copia(a->left);
return nuovo;
}
lista* copia(lista *P, lista *Q, int *i)
{
lista *temp=NULL;
if(P == NULL)
{
P = Q;
}
else
{
if(Q != NULL)
{
if((*i) == 2)
{
temp = P->next;
P->next = Q;
(*i) = 1;
Q->next = copia(temp,Q->next,i);
}
else
{
(*i)++;
P->next = copia(P->next,Q,i);
}
}
}
return P;
}
void Fenichel_Yochelson(No **Raiz, pilha *p)
{
garbage++;
if(indice > (TAM_HEAP/2)) //do heap2 para o heap1
{
indice = 0;
*Raiz = copia(*Raiz);
}
else ////do heap1 para o heap2
{
indice = TAM_HEAP/2;
*Raiz = copia(*Raiz);
}
DecodificaOperacao(*Raiz, p); //preencher a pilha novamente
}
int add_variavel(char* palavra){
int i = 0;
while(variaveis[i][0] != '\0')
i++;
copia(variaveis[i], palavra);
return i;
}
int main()
{
int n,
i=1;
lista *Q=NULL,
*P=NULL;
printf("-- P --\n");
P = domanda(P);
printf("-- Q --\n");
Q = domanda(Q);
printf("-- STAMPO P --\n");
stampo(P);
printf("\n-- STAMPO Q --\n");
stampo(Q);
P = copia(P,Q,&i);
printf("\n-- STAMPO COPIA --\n");
stampo(P);
return 0;
}
/*converte um PNM do formato P4 para o formato P1*/
PNM * p3_2_p6(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '6';
return temp;
}
/*converte um PNM do formato P4 para o formato P1*/
PNM * p2_2_p5(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '5';
return temp;
}
/*converte um PNM do formato P1 para o formato P4*/
PNM * p1_2_p4(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '4';
return temp;
}
/*converte um PNM do formato P5 para o formato P2*/
PNM * p5_2_p2(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '2';
return temp;
}
// assegnazione profonda
Vettore& operator=(const Vettore& v) {
if(this != &v) {
delete[] a;
a = copia(v);
_size=v._size;
}
return *this;
}
main()
{
char line[MAXLINE]; char longest[MAXLINE];
while ((len = getlinea(line)) > 0){
copia(longest,line);
printf("%s", longest);}
return 0;
}
tPunteroNodo crea_nodo(char* ID,tconjunto A){
tPunteroNodo aux=NULL;
aux=(tNodo*)malloc(sizeof(tNodo));
aux->identificador=ID;
aux->conjunto=copia(A);
aux->sig=NULL;
return aux;
}/*Funciona*/
/*converte um PNM do formato P4 para o formato P1*/
PNM * p4_2_p1(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '1';
return temp;
}
/*converte um PNM do formato P6 para o formato P3*/
PNM * p6_2_p3(PNM *pnm)
{
PNM *temp = copia(pnm);
temp->tipo[1] = '3';
return temp;
}
void escriure_queue_int(queue<int> p)
{
cout << "[Primer] ";
// el paso por valor copia p correctamente ya que la clase tiene
// creadora copiadora
queue<int> copia(p);
while( not copia.empty()){
cout << copia.front() << " ";
copia.pop(); // el que no haya salto de linea entre elementos
} // solo interesa si la cola no es muy grande
cout << "[Ultim]"<<endl;
}
// Função menu
void menu()
{
short int opcao = 1;
while(opcao != 0)
{
printf("\n"
"|--------------------------|\n"
"| Bem-vindo! |\n"
"|--------------------------|\n"
"| SELECIONE UMA OPCAO: |\n"
"| 1: CONCATENAR STRING |\n"
"| 2: COMPARAR STRING |\n"
"| 3: COPIAR STRINGS |\n"
"| 4: TAMANHO DA STRING |\n"
"| 0: SAIR |\n"
);
scanf("%d", &opcao);
system("cls");
switch(opcao)
{
case 0:
printf("\nFim da execucao!\n");
return;
case 1:
printf("\n---- CONCATENAR STRING ----\n");
concatena();
break;
case 2:
printf("\n---- COMPARAR STRING ----\n");
compara();
break;
case 3:
printf("\n---- COPIA STRING ----\n");
copia();
break;
case 4:
printf("\n---- TAMANHO DA STRING ----\n");
tamanho();
break;
default:
printf("OPCAO INVALIDA!\n");
}
}
}
/**copia tudo o grafo para o outro heap**/
No* copia(No *Raiz)
{
if(Raiz == NULL)
return Raiz;
else if(Raiz->FW == NULL) //se o no ainda está no heap antigo
{
indice++;
Raiz->FW = &grafo[indice-1]; //atualiza o Forwarded
Raiz->FW->c = Raiz->c;
if(Raiz->c != '$')
{
Raiz->FW->esq = copia(Raiz->esq); //para cada filho chama-se uma copia
Raiz->FW->dir = copia(Raiz->dir);
}
else
Raiz->FW->esq = copia(Raiz->esq);
Raiz->FW->FW = NULL;
return Raiz->FW;
}
else //caso o nó ja tenha sido copiado para o novo heap
{
return Raiz->FW;
}
}
tconjunto encuentra_devuelve(tPunteroNodo* cabeza, char* ID){
tPunteroNodo aux;
tconjunto A;
aux=*cabeza;
while(aux!=NULL && strcmp(aux->identificador,ID)!=0){
aux=aux->sig;
}
if(aux!=NULL){
A=copia(aux->conjunto);
return A;
}else{
printf("La Variable No esta Declarada!\n");
exit(0);
}
}
void agrega_variable(tPunteroNodo* cabeza,tPunteroNodo nuevo){
tPunteroNodo aux,ant;
if(*cabeza==NULL){
*cabeza=nuevo;
}else{
aux=*cabeza;
while(aux->sig!=NULL && strcmp(aux->identificador,nuevo->identificador)!=0){
aux=aux->sig;
}
if(strcmp(aux->identificador,nuevo->identificador)!=0){
aux->sig=nuevo;
}else{
aux->conjunto=copia(nuevo->conjunto);
}
}
}/*funciona*/
int
main(void)
{
int tam;
extern int max;
extern char maior[];
max=0;
while((tam=lelinha())>0)
if(tam>max) {
max=tam;
copia();
}
if(max>0) /* entrada tinha uma linha */
printf("%s",maior);
return 0;
}
main(){
char texto[81], texto2[81];
printf ("Digite uma string: ");
scanf(" %80[^\n]s", texto); QL;
printf("O tamanho da cadeia: %s eh %d", texto, comprimento(texto));
QL;
imprime(texto);QL; // exibe(texto);
copia(texto2, texto); QL;
imprime(texto2);QL; imprime(texto);QL;QL;
printf ("Digite uma string: ");
scanf(" %80[^\n]s", texto2); QL;
printf("O tamanho da cadeia: %s eh %d", texto2, comprimento(texto2));
concatena(texto, texto2);QL;
imprime(texto); QL;
printf("O tamanho da cadeia: %s eh %d", texto, comprimento(texto));QL;
getchar();
}
void vizinho (Partitura *Y, Partitura *X)
/* Returns in Y, a neighbor of X */
{
int pitch, duracao, voz, semi, oitava, k, l, i, temp = 1;
voz = (int) myrand()&3;
semi = (int) myrand()&255;
pitch = (int) myrand() % 12;
if(pitch == 0)
pitch = REST;
temp = (DURACAO_ADEQUADA[voz][semi]<<1)+1;
duracao = (int) myrand() % temp;
//fprintf(stderr,"dur %d temp %d pitch %d voz %d\n",duracao,temp,pitch,voz);
//if(duracao == 0)
// duracao++;
copia(Y, X);
if (pitch != REST) {
if (semi == 0) i = (*Y)[voz][semi].pitch;
else i = (*Y)[voz][semi-1].pitch; /* i is the previous note */
if (i == REST) i = melhor_nota+(voz+3)*12;
oitava = ( int) i/12 -1; /* We choose a pitch near the pitch of i */
pitch += oitava*12; /* preserving the selected pitch class. */
while (abs(i-pitch) > 6)
if ( i > pitch) pitch += 12;
else pitch-= 12;
while(pitch < 36) pitch +=12;
while(pitch > 96) pitch -=12;
//fprintf(stderr,"voz %d pitch %d\n",voz,pitch);
}
(*Y)[voz][semi].pitch = pitch;
(*Y)[voz][semi].velocity = 100;
(*Y)[voz][semi].start = 1;
for(k=1; k<duracao && semi+k<MaxSemiColcheias; k++) {
(*Y)[voz][semi+k].pitch = pitch;
(*Y)[voz][semi+k].velocity = 100;
(*Y)[voz][semi+k].start=0;
}
if (semi+duracao<MaxSemiColcheias && !(*Y)[voz][semi+duracao].start)
(*Y)[voz][semi+duracao].start = 1;
}
int main(int argc, char const *argv[])
{
point* pares[100];
int size = 100
srand(time(NULL));
int i;
for (i = 0; i < size; i++) {
int x = rand();
int y = rand();
pares[i] = newpoint(x, y);
}
otro_y = copia(pares, size)
qsort(pares,size,sizeof(point), compareX);
qsort(pares,size,sizeof(point), compareY);
pairs* min_x = closest(pares, size);
pairs* min_y = closest(pares, size);
pairs* min_abs = min_x->dist < min_y->dist ? min_x : min_y;
printpairs (min_abs);
return 0;
}
char * stringaIntero(int tipo, char *parola) {
/*
Tipo 0 = intero,
Tipo 1 = stringa,
Tipo 2 = intero finale,
Tipo 3 = stringa finale;
*/
char * finale;
int l = size(parola);
if(tipo == 0) {
l = l+3;
finale = malloc(sizeof(char)*l);
copia(finale,parola);
strcat(finale," ,");
}
if(tipo == 1) {
l=l+5;
finale=malloc(sizeof(char)*l);
strcat(finale," '");
strcat(finale,parola);
strcat(finale,"' ,");
}
if(tipo == 2) {
finale = parola;
}
if(tipo == 3) {
l=l+3;
finale=malloc(sizeof(char)*l);
strcat(finale,"'");
strcat(finale,parola);
strcat(finale,"'");
}
return finale;
}
main()
{
tipo_fila *fila,*fila2;
int i, numero=1;
fila = (tipo_fila *) malloc (sizeof(tipo_fila));
fila2 = (tipo_fila *) malloc(sizeof(tipo_fila));
inicializar_fila(fila);
inicializar_fila(fila2);
while (numero !=0)
{
printf("Leitura do valor : ");
scanf("%d", &numero);
enqueue(numero, fila);
}
copia(fila,fila2);
printf("tamanho da fila: %d\n", tamanho(fila));
printf("tamanho da fila2: %d\n", tamanho(fila2));
imprimir_fila(fila);
imprimir_fila(fila2);
getch();
}
void Menu::reconfigureDisplay()
{
painted = true;
glViewport(0, 0, SDL_GetVideoSurface()->w, SDL_GetVideoSurface()->h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, SDL_GetVideoSurface()->w, 0, SDL_GetVideoSurface()->h);
glScalef(1, -1, 1);
glTranslatef(0, -SDL_GetVideoSurface()->h, -1);
// No Windows, eh necessario recarregar as texturas
#ifdef _WIN32
this->init();
vector<sItem> copia(iteminfo);
MenuItem *mi;
int tex;
sItem si;
for (i = 0; i < items.size(); i++) {
mi = items[i];
tex = mi->getImage();
glDeleteTextures(1, (GLuint *)&tex);
tex = mi->getHoverImage();
glDeleteTextures(1, (GLuint *)&tex);
delete mi;
}
items.clear();
iteminfo.clear();
for (i = 0; i < copia.size(); i++) {
si = copia[i];
this->addItem(si.id, si.image, si.hover_image, si.x, si.y, si.al);
}
#endif
}
int main()
{
cout << "Escribe la cola, acabada en 0:" << endl;
queue<int> p;
llegir_queue_int(p,0);
cout << "Escribe el elemento a buscar:" << endl;
int valor=readint();
queue<int> copia(p); // copiamos para no destruir p
cout << "Version iterativa o recursiva (escribe 1 o 2):" << endl;
int i =readint(); bool es_trobat;
if (i==1) es_trobat = pertqueue_it(copia, valor);
else if (i==2) es_trobat = pertqueue_rec(copia, valor);
else throw PRO2Excepcio("Hay que escribir 1 o 2");
if(es_trobat)
cout << " Está" << endl;
else
cout << " No está" << endl;
cout << "Escribimos la cola original para ver que no se ha destruido:" << endl
;
escriure_queue_int(p);
}
// costruzione di copia profonda
Vettore(const Vettore& v): a(copia(v)), _size(v._size) {}
/**
* \brief Carrega uma Empresa criada e guardada previamente num ficheiro a especificar
* \return Retorna 0;*/
int Empresa::loadEmpresa()
{
string f = this->nome;
f = f + ".txt";
char* ficheiro = &f[0];
ifstream input;
input.open(ficheiro); //abre o ficheiro com o nome da empresa
if (!input.is_open()) // se o ficheiro não estiver aberto, quer dizer que não existe
{
cout << "Nao ha ficheiro para a empresa referida." << endl;
return -1;
}
string linha; // string que vai guardar o conteúdo da linha a ser lida
char lixo; // para descartar partes desnecessárias. Ex: serparadores (";")
// Adicionar taxas e camiões à frota
getline(input, linha);
istringstream copia0(linha);
copia0 >> this->custoDist;
getline(input, linha);
istringstream copia2(linha);
copia2 >> this->custoCong;
getline(input, linha);
istringstream copia3(linha);
copia3 >> this->custoPerig;
Frota frota;
getline(input, linha);
vector <vector <int>> ids;
if (linha == "BEGIN_FROTA")
{
while (1)
{
int cam = 0;
ids.resize(cam + 1);
getline(input, linha);
if (linha == "END_FROTA")
break;
istringstream copia(linha);
int codigo, id;
unsigned int cap_max;
bool cap_cong, cap_perig;
copia >> cap_cong >> lixo >> cap_perig >> lixo >> cap_max >> lixo >> codigo >> lixo;
Camiao* camiao = new Camiao (codigo, cap_max, cap_cong, cap_perig);
getline(input, linha);
istringstream copia1(linha);
while (copia1 >> id >> lixo)
{
ids[cam].push_back(id);
}
int indice;
frota.adicionaCamiao(camiao);
}
}
this->setFrota(frota);
// Adicionar os serviços e os respetivos clientes
int indice = 0;
while (!input.eof())
{
getline(input, linha);
if (linha == "SERVICO")
{
getline(input, linha);
int id;
float preco, distancia;
vector <Cliente*> clientes;
bool status;
char waste;
istringstream copia(linha);
copia >> id >> waste >> preco >> waste >> distancia >> waste >> status;
Servico* servico = new Servico(id, preco, distancia);
this->adicionaServico(servico);
}
if (linha == "BEGIN_CLIENTES")
{
while (1)
{
getline(input, linha);
if (linha == "END_CLIENTES")
break;
else
{
string nome;
unsigned int nif;
nome = linha;
getline(input, linha);
istringstream copia(linha);
copia >> nif;
Cliente* cliente = new Cliente(nome, nif);
this->servicos[indice]->adicionaCliente(cliente);
}
}
indice++;
}
}
/*----------------------------converte----------------------------*/
PNM *converte(PNM *pnm, char*tipoDes)
{
char tipoOrig = pnm->tipo[1], tipoDest;
PNM *temp = (PNM *)malloc(sizeof(PNM));
if(strlen(tipoDes) == 2) tipoDest = tipoDes[1];
else return NULL;
switch(tipoDest)
{
case '1':
switch(tipoOrig)
{
case '1': temp = copia(pnm);
break;
case '2': temp = p2_2_p1(pnm);
break;
case '3': temp = p3_2_p1(pnm);
break;
case '4': temp = p4_2_p1(pnm);
break;
case '5': temp = p5_2_p1(pnm);
break;
case '6': temp = p6_2_p1(pnm);
break;
default: return NULL;
}
break;
case '2':
switch(tipoOrig)
{
case '1': temp = p1_2_p2(pnm);
break;
case '2': temp = copia(pnm);
break;
case '3': temp = p3_2_p2(pnm);
break;
case '4': temp = p4_2_p2(pnm);
break;
case '5': temp = p5_2_p2(pnm);
break;
case '6': temp = p6_2_p2(pnm);
break;
default: return NULL;
}
break;
case '3':
switch(tipoOrig)
{
case '1': temp = p1_2_p3(pnm);
break;
case '2': temp = p2_2_p3(pnm);
break;
case '3': temp = copia(pnm);
break;
case '4': temp = p4_2_p3(pnm);
break;
case '5': temp = p5_2_p3(pnm);
break;
case '6': temp = p6_2_p3(pnm);
break;
default: return NULL;
}
break;
case '4':
switch(tipoOrig)
{
case '1': temp = p1_2_p4(pnm);
break;
case '2': temp = p2_2_p4(pnm);
break;
case '3': temp = p3_2_p4(pnm);
break;
case '4': temp = copia(pnm);
break;
case '5': temp = p5_2_p4(pnm);
break;
case '6': temp = p6_2_p4(pnm);
break;
default: return NULL;
}
break;
case '5':
switch(tipoOrig)
{
case '1': temp = p1_2_p5(pnm);
break;
case '2': temp = p2_2_p5(pnm);
break;
case '3': temp = p3_2_p5(pnm);
break;
case '4': temp = p4_2_p5(pnm);
break;
case '5': temp = copia(pnm);
break;
case '6': temp = p6_2_p5(pnm);
break;
default: return NULL;
}
break;
case '6':
switch(tipoOrig)
{
case '1': temp = p1_2_p6(pnm);
break;
case '2': temp = p2_2_p6(pnm);
break;
case '3': temp = p3_2_p6(pnm);
break;
case '4': temp = p4_2_p6(pnm);
break;
case '5': temp = p5_2_p6(pnm);
break;
case '6': temp = copia(pnm);
break;
default: return NULL;
}
break;
default: return NULL;
}
if(pnm != NULL)
{
freePNM(pnm);
pnm = NULL;
}
return temp;
}
