Ir ao conteúdo
  • Cadastre-se
Leonardo Naressi

C++ Procedimento que retira os valores múltiplos de 3 da pilha

Posts recomendados

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

struct pilha{
       int dados;
       struct pilha *proximo;
};

//Constroi a pilha
void push(struct pilha **topo,int valor, int *status){
     struct pilha *p;
     p = (struct pilha *) malloc (sizeof(struct pilha));
     if (p == NULL){
           *status=0;
     }else{
           p->dados=valor;
           p->proximo=*topo;
           *topo=p;
           *status=1;
     }
}

//Desempilha a pilha
int pop(struct pilha **topo, int *status){
    struct pilha *p,*aux;
    int valor;
    
    aux=*topo;
    if(aux == NULL){
            *status=0;
    }else{
            valor=aux->dados;
            p=aux;
            aux=p->proximo;
            free(p);
            *topo=aux;
            *status=1;
            return valor;
    }
} 

//Mostrando a Pilha
void mostra_pilha(struct pilha **p1){
     struct pilha *aux;
     
     aux=*p1;
     while(aux != NULL){
               printf("\nValores Pilha -> %i\n",aux->dados);
               aux=aux->proximo;
     }
}

//Remover numeros multiplos de 3
void retira_multiplos_de_3(struct pilha *p1,struct pilha **p2){//não estou conseguindo passar os parametros de forma correta acredito ser este o erro
     
     while(p1 != NULL){
                   if(p1->dados % 3 == 0){
                               push(p2,pop(p1));//pega o topo de pilha 1 para a pilha 2
                   }else{
                              push(p3,pop(p1));//pega o topo de pilha 1 para a pilha 3
                   }
    	}
     }while(p1 != NULL){
                   push(p1,pop(p3));//coloca de volta os numeros não mutiplos de 3 para a pilha 1
     }
// PROGRAMA PRINCIPAL;
int main(){
    int valor,ok;
    struct pilha *p1=NULL;
    struct pilha *p2=NULL;
    struct pilha *p3=NULL;
    
    // Construindo PILHA 1
    printf("\nPara encerrar digite 0");
    do{
         printf("\nInforme numeros a serem empilhados na 1° pilha: ");
         scanf("%d", &valor);
         if(valor!= 0){
                push(&p1,valor,&ok);
                if(ok==0){
                     printf("\nErro de alocacao! ");
                }
         }
    }while (valor!=0);
 		printf("\n----------------------------------");
		printf("\nPilha 1° construida com sucesso!!");
    	printf("\n----------------------------------\n");
 	
   		printf("----------------------------------");
    	printf("\nPilha 1: ");
    	 mostra_pilha(&p1);
    	printf("----------------------------------");
		 retira_multiplos_de_3(&p1,&p2)//não estou conseguindo passar os parametros de forma correta acredito ser este o erro
		 printf("\nPilha 2: ");
    	 mostra_pilha(&p2);
}

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá!

 

Está apenas compartilhando o código ou tem alguma pergunta?

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
1 hora atrás, Leonardo Naressi disse:

@arfneto O procedimento que retira os valores múltiplos de 3 da pilha, não eta funcionando.

 

Olá. Vou dar uma olhada!

 

Palpite: não crie um procedimento para" retirar os múltiplos de 3". 

 

Crie um procedimento para colocar na pilha, push() é o nome clássico. Crie um procedimento para tirar da pilha, pop() é o nome clássico, Teste os caras, empilhe umas coisas e retire até ficar vazia...

 

Aí você cria uma função que extrai os que são múltiplos de 3... Assim não mistura os testes

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@arfneto Certo esta parte eu entendi, o problema esta sendo que não estou conseguindo passar os parâmetros corretamente.

 while(p1 != NULL){
                   if(p1->dados % 3 == 0){
                               push(p2,pop(p1));//pega o topo de pilha 1 para a pilha 2
                   }else{
                              push(p3,pop(p1));//pega o topo de pilha 1 para a pilha 3
                   }
        }

O que devo passar como parâmetro?

Apresenta o seguinte erro:

[Error] cannot convert 'pilha*' to 'pilha**' for argument '1' to 'int pop(pilha**, int*)'

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
40 minutos atrás, Leonardo Naressi disse:

@arfneto Certo esta parte eu entendi, o problema esta sendo que não estou conseguindo passar os parâmetros corretamente.

 while(p1 != NULL){
                   if(p1->dados % 3 == 0){
                               push(p2,pop(p1));//pega o topo de pilha 1 para a pilha 2
                   }else{
                              push(p3,pop(p1));//pega o topo de pilha 1 para a pilha 3
                   }
        }

O que devo passar como parâmetro?

Apresenta o seguinte erro:

[Error] cannot convert 'pilha*' to 'pilha**' for argument '1' to 'int pop(pilha**, int*)'

 

Olá!

Veja como declarou push():

    void push(
        struct pilha **topo, 
        int valor, 
        int *status)

e como delcarou p2:

 

    struct pilha *p2 = NULL;

e pop():

 

    int pop(struct pilha **topo, int *status)

  E aí você escreve 

     

    push(p2, pop(p1));//pega o topo de pilha 1 para a pilha 2

Só que p2 é um ponteiro para pilha e o primeiro argumento de push é um ponteiro para um ponteiro para pilha. Veja as declarações. E aí o compilador reclama...

 

struct pilha **topo é diferente de struct pilha *, certo? 

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@arfneto Isso mesmo, este é o problema estava tentando compreender e corrigir o meu erro mas realmente estou trancado.

😕

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Leonardo Naressi Vou dar uma olhada no código hoje com mais detalhe. Se sabe que está usando os parâmetros errados, o que está "trancando" você?

adicionado 25 minutos depois

Olá!

 

Esta difícil de entender o que você pretende com o procedimento
 void retira_multiplos_de_3(struct pilha *p1,struct pilha **p2)

 

Está certo de que postou o código direito? Qual seu ambiente de desenvolvimento --- o que usa para editar, programar e tal, como compiladores e sistema e editor?

 

Pode comentar melhor o que quer fazer, o porque de 3 pilhas, e em especial porque p1 é pilha* e p2 é pilha** ?

 

//Remover numeros multiplos de 3
void retira_multiplos_de_3(struct pilha *p1,struct pilha **p2)
{	//não estou conseguindo passar os parametros de forma correta acredito ser este o erro
     
     while(p1 != NULL)
     {
        if(p1->dados % 3 == 0)
        {
            push(p2,pop(p1));//pega o topo de pilha 1 para a pilha 2
        }
        else
        {
            push(p3,pop(p1));//pega o topo de pilha 1 para a pilha 3
        }	// end if
    }	// end while

    }while(p1 != NULL){
                   push(p1,pop(p3));//coloca de volta os numeros não mutiplos de 3 para a pilha 1
     }

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

@arfneto Estou tentando passar os números múltiplos de 3 da pilha1 para a pilha2 e os que não são para a pilha3, para posteriormente colocá-los de volta na pilha1.

Uso o Dev-C++.

Compartilhar este post


Link para o post
Compartilhar em outros sites
4 horas atrás, Leonardo Naressi disse:

@arfneto Estou tentando passar os números múltiplos de 3 da pilha1 para a pilha2 e os que não são para a pilha3, para posteriormente colocá-los de volta na pilha1.

Uso o Dev-C++.

 

Olá!

 

Entendi. Mas seu código sequer compila ainda :( 

 

push() e pop() por exemplo tem um parâmetro, status, um ponteiro para int, e você nem está passando os valores.

 

Você declarou as funções assim:

void push(struct pilha**,int, int*);
int pop(struct pilha **,int*);
void mostra_pilha(struct pilha**);
void retira_multiplos_de_3(struct pilha *p1,struct pilha **p2);

o que fez você declarar p1 e p2 de modo diferente? e depois lá na rotina você usa p3 que nem está declarado...

 

Acho que push e pop estão ok. Acho que mostra_pilha() também.  Mas o programa principal podia ser mais simples. E a rotina alvo do seu programa, a que retira os itens, está muito muito confusa.

Talvez você pudesse comentar melhor o seu código e alinhar melhor as coisas, para você ter mais facilidade em ir escrevendo depois.

 

vou te mostrar um exemplo:

 

imagine que você tenha uma rotina assim

int insere_na_pilha(struct Pilha** pilha, int quantos, int inicio, int incremento)

E essa rotina faz o simples: usa push() e insere quantos valores na pilha, com valores começando em inicio e incrementados por incremento

 

Para que isso? simples: olhe essas chamadas:

insere_na_pilha(&p1, 5, 1, 1);     
insere_na_pilha(&p1, 2, 1, 1); 
insere_na_pilha(&p1, 7, 3, 1);  
insere_na_pilha(&p1, 5, 3, 3); 

5,1,1 vai gerar 1 2 3 4 5 bem besta e voce deve ter 5 4 2 1 na saida. O comum

 

2,1,1 vai gerar 1 2 e voce deve ter 2 1 na saída e testou para quando não tem nenhum múltiplo de 3 na lista

 

7,3,1 vai gerar 3 4 5 6 7 8 9, sete valores a partir de 3. Só que essa sequencia começa e termina por multiplos de 3. Muito bom para testar seu programa porque vai apagar o começo e o fim da lista ou vai dar um p#$% erro

 

5,3,3 vai gerar 3 6 9 12 15, 5 valores multiplos de 3 e você deve terminar com uma lista vazia, certo? Ou um erro de segmentação. :D 

 

Sugiro ler esse pedaço até entender: com esse trecho de código você testa as condições mais importantes da sua rotina, sem ter que ficar no terminal digitando...

 

Só escreve isso em main() para uma pilha p1:

zera_pilha(&p1);
insere_na_pilha(&p1, 5,1,1);    // 1 2 3 4 5
mostra_pilha(&p1);

zera_pilha(&p1);
insere_na_pilha(&p1, 2,1,1);    // 1 2 
mostra_pilha(&p1);

zera_pilha(&p1);
insere_na_pilha(&p1,7,3,1);     // 3 4 5 6 7 8 9
mostra_pilha(&p1);

zera_pilha(&p1);
insere_na_pilha(&p1,5,3,3);     // 3 6 9 12 15
mostra_pilha(&p1);

zera_pilha(&p1);

Entendeu?  Essa zera_pilha() serviria apenas para liberar a memoria alocada pelas pilhas entre cada teste. Pode esquecer por enquanto.

 

E sobre a retira_multiplos_de_3(struct pilha *p1,struct pilha **p2) ?

 

Você deve usar struct** para endereçar as pilhas porque precisa de acesso ao conteúdo do valor apontado pelo ponteiro, então tem mais um nível e precisa do segundo * 

 

Mas não precisa de outras pilhas. A menos que seja o objetivo real de seu problema ou se precisasse preservar a pilha original.

 

Em resumo, um valor da pilha aponta para o próximo e assim vai. Você só tem um ponteiro, que aponta para o primeiro item, ou vale null para a lista vazia.

 

Para excluir o primeiro item: trivial: salve o endereço do segundo. exclua o primeiro e altere o ponteiro de inicio para o valor salvo.

 

Excluir no final: quase trivial, porque a pilha é de mão única. Quando chega no fim já era. Não dá pra salvar o endereço do penúltimo, excluir o último e fazer o penúltimo apontar para NULL. Mas continue lendo

 

Excluir no meio: mesmo problema: se voce tem lá na lista 5 6 7 por exemplo e precisa tirar o 6. O 5 vai ter que apontar para o 7 e ai você apaga o 6. Escrever assim fica fácil. Mas quando descobre que vai apagar o 6 o 5 já era... Seria como marcar algo para ontem :D

 

A solução para os dois casos? A mesma. Breacrumbs.Migalhas. Deixe marcas por onde o programa passa...

 

Percorra a lista mas salve o início da lista e o elemento anterior para não perder o rumo, e aí não terá problema, e pode usar uma única pilha. Eis um exemplo:

//
// a logica aqui:
//        - se um elemento aponta para um multiplo de tres:
//            - se tem um elemento anterior entao ele passa a apontar para
//              o seguinte, pulando esse
//            - se nao tem um anterior, é o primeiro e simplesmente extrai esse
//
int retira_multiplos_de_3(struct Pilha **pilha)
{
    int s1;
    int c = 0;
    int v;
    struct Pilha* pItem = *pilha;
    struct Pilha* pSalvaInicio = *pilha;    // salva
    struct Pilha* pAnterior = NULL;

    printf("\n***** retira_multiplos_de_3\n");
    // pItem comeca no topo
    while (pItem != NULL)
    {
        v = pItem->dados;
        if (v % 3 == 0)
        {    // esse deve ser excluido
            if (pAnterior != NULL)
            {    // entao tinha um antes apontando para esse
                // e agora deve apontar para o que vem depois desse
                pAnterior->proximo = pItem->proximo;    // pula esse que vai excluir
                 pop(&pItem, &s1);    // remove o item
                printf("\tMultiplo %4d: removido\n", v);
            }
            else
            {
                // vai remover o item inicial
                pSalvaInicio = pItem->proximo;
                pop(&pItem, &s1);    // remove o item
                printf("\tMultiplo %4d: removido. [Item inicial]\n", v);
            }    // end if
        }
        else
        {
            //    esse vai ficar: nao multiplo de 3
            pAnterior = pItem;
            pItem = pItem->proximo;
        }    // end if
    }    // end while
    (*pilha) = pSalvaInicio;
    return c;    // retorna o total de itens removidos
}

Leia esse com atenção e veja se faz sentido para você. Esse funciona. 

 

Agora pense no programa principal: não seria bom se pudesse digitar os parâmetros direto na linha de comando, pra não perder tempo? Já que escreveu a rotina de insere os valores, podia usar na linha de comando

 

teste 5 3 3


para testar seu programa com uma sequencia de 5 valores, começando em 3 com incremento de 3. 

bem melhor que ficar esperando ou alterando o código e compilando de novo. 

 

Como podia ser essa coisa? Exemplo:

    int argItens = 10;            // padrão 10 itens
    int argItem1 = 1;            // primeiro = 1
    int argIncremento = 1;        // e depois 2,3,4,5...
    //
    // os argumentos podem ser 3:
    //    - o numero de itens a inserir no teste. padrão 10
    //  - o valor do primeiro item. padrão 1
    //  - o valor do incremento. padrão 1
    // ex: x 6,3,3 vai grar 6 itens: 3,6,9,12,15 e 18
    //
    // so para facilitar os testes da rotina que remove os multiplos de 3
    // assim pode testar com multiplos no inicio, no fim ou na lista toda
    // so mudando a linha de comando
    //
    printf("\nIniciando %s\n", argv[0]);
    if (argc > 1) argItens = atoi(argv[1]);
    if (argc > 2) argItem1 = atoi(argv[2]);
    if (argc > 3) argIncremento = atoi(argv[3]);
    printf(
        "***** testando com %d itens a partir de %d com incremento %d\n",
        argItens, argItem1, argIncremento
    );

Esse tem até valores default: se digitar só teste vai rodar com a sequencia de 1 a 10. E pode digitar 1 2 ou 3 parametros.

 

E se quiser embutir os testes mais significativos? 

 

pode escrever algo assim para um teste interessante:

    mostra_pilha(&p1);
    insere_na_pilha(&p1,argItens,argItem1,argIncremento);
    mostra_pilha(& p1);
    // agora exclui ate esvaziar, para testar
    do 
    {
        printf("\t[-] %4d\n", pop(&p1, &ok));
    } while (p1 != NULL);
    // outros testes simples
    mostra_pilha(&p1);            // deve estar vazia
    retira_multiplos_de_3(&p1);    // nao deve fazer nada ja que esta vazia

E os testes de que falamos? Simples:

	// 2
	zera_pilha(&p1);
	insere_na_pilha(&p1,5,1,1);	// insere de novo
	mostra_pilha(&p1);			// lista de novo. deve ter 1 2 3 4 5
	retira_multiplos_de_3(&p1);	// deve remover 3
	mostra_pilha(&p1);			// mostra o resto
	// 3
	zera_pilha(&p1);
	insere_na_pilha(&p1,2,1,1);	// insere de novo
	mostra_pilha(&p1);			// lista de novo. 1 2
	retira_multiplos_de_3(&p1);	// nao deve remover nada
	mostra_pilha(&p1);			// mostra o resto
	// 4
	zera_pilha(&p1);
	insere_na_pilha(&p1,7,3,1);	// insere de novo
	mostra_pilha(&p1);			// lista de novo. 3 4 5 6 7 8 9
	retira_multiplos_de_3(&p1);	// deve remover 3 6 e 9
	mostra_pilha(&p1);			// mostra o resto
	// 5
	zera_pilha(&p1);
	insere_na_pilha(&p1,5,3,3);	// insere de novo
	mostra_pilha(&p1);			// lista de novo. 3 6 9 12 15
	retira_multiplos_de_3(&p1);	// deve remover tudo
	mostra_pilha(&p1);			// mostra o resto

Pense nessas coisas. Tente corrigir seu código. Depois posto o programa inteiro, mas acho que você não vai precisar. E se eu colocar aqui o programa agora  pode ficar tentado a não tentar... :D:D :D:D :D 

 

 

Boa sorte 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Isso tudo é mais difícil do que falar japonês...para que serve isso e qual é a modalidade do curso?

Compartilhar este post


Link para o post
Compartilhar em outros sites

@misterjohn Imagino que seja um trabalho de faculdade: o autor precisa rodar um programa para todos os arquivos de uma pasta no micro, tipo pegar uma pasta de mídia do seu servidor e fazer algum tipo de análise em TODOS os arquivos da pasta. 

 

Abraço

 

Errei. Esse era outro tópico. Esse aqui deve ser algo sobre  um curso de estruturas de dados imagino, e precisa testar essa estrutura chamada pilha. Em resumo esse tipo de pilha é como a pilha de pratos no restaurante: você coloca os elementos em cima e vai tirando primeiro os que colocou por ultimo...

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Tó fora, isso porque "estou aqui a passeio"...se fosse trabalhar com isso ai valeria a pena aprender....quem sabe em outra encarnação.....😄😄agora admiro quem detém conhecimento, esse e outros quaisquer, o meu ramo era outro, informática e computador é apenas um hobby e passatempo.

Compartilhar este post


Link para o post
Compartilhar em outros sites

@misterjohn programar computadores pode ser um hobby bacana. 

 

Mas gasta muito tempo eu acho 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Quando eu tinha meus 20 anos a moda aqui em Santos era fazer "Cobol", até hoje não sei se esse nome é de alguma linguagem de computador, programa ou é o nome da escola, ou outra coisa qualquer, só sei que era relativo a computadores, devia ter feito seja lá o que fosse...mas segui outra profissão e fiz minha vida...

Isso abaixo que linguagem é?

 

Ão^ÊlX.¥xw„ÇJEl2ëQëGƒÔ¯ k[`ÊÌ    dU9Y™ª: ØR.aÐΪåTj˜Ó™™žhëÑm@»’¸IJÌÍ·UUë6&„HdVU´ÍÀ  „WcýàJÂB'Z`CïFóËív'ê_IJâRß’K†ÞšÌw²G\2Mg±îÃfϘÄЀ Ñöeþ3¤Ž6ý€³h–äƒê·»sgYcAÐýfVh“ûdý–™G%"Å §à•wt¯¦†G\þí"­aº‡Iñu/COŸük;Ȭ0.¾½Z:D¿P¶<×L%>×F8‘yøsIîÙd¬Ú¨âpƒZK›²[&›Í+.ãxVêµÏ(v…>TØ7
IÇ[¥CZ)ÈÔRq̱T(õRl¹ÂZÓ±MiAð   „éÕ^À!X `ƒ1äÐ?3+a    4ÚQý‘ãùH†%äwi2Ñ‹nÆ%dï¥3¸’[
ç r¡-:­ô"Ë™×nzž¡c)PWOœ§AœSã÷ò
â l*r×VÆãÿPè2ñÞ~57rWÙM·Âm\Õ0_±= _žºP±nr1¶ý’C‹§ºð2ÜâÚç²k.¾ Ë­Ÿ$øôß„“—6º{Èøš'*&rÜS`ÖÍ¡QÈ­5iUÚÓ;ÄJ›ÁófÊŠ–75­kÜ´LÄML5ZFQ¸weè(ò‹LYã¿
aV†Ö¶mµÔÀ|  ÷

Compartilhar este post


Link para o post
Compartilhar em outros sites

@misterjohn Estudei COBOL nos anos 70. Nem tenho ideia de quantos programas escrevi nessa linguagem :) Sim, é uma linguagem. Bem interessante até. Hoje não é muito divulgada mas parece haver ainda uma enorme quantia de programas escritos em COBOL rodando no mundo. Vi umas matérias nos últimos dias falando sobre gente sendo treinada atualmente para programar em COBOL

 

Isso que listou não sei o que é não. Era isso mesmo? A única coisa assim cheia de símbolos que já usei foi uma linguagem chamada APL e era bem legal. Veja esse teclado com os símbolos em laranja de https://geekhack.org/index.php?topic=93923.0

190613-apl-teclado.thumb.jpg.fbc756f314846784df1183be08461b79.jpg

 

Escrevi alguns programas em APL. Eu estudava matemática afinal e tinha a ver, mas  nem me lembro o que faziam :) 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Isso é um texto salvo em bloco de notas que foi corrompido e ao invés das palavras nítidas e compreensíveis em português, passou a exibir esses caracteres.

Compartilhar este post


Link para o post
Compartilhar em outros sites
1 hora atrás, misterjohn disse:

Isso é um texto salvo em bloco de notas que foi corrompido e ao invés das palavras nítidas e compreensíveis em português, passou a exibir esses caracteres.

Muito bom :D ficou bem complexo

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
9 horas atrás, arfneto disse:

@misterjohn Estudei COBOL nos anos 70. Nem tenho ideia de quantos programas escrevi nessa linguagem :) Sim, é uma linguagem. Bem interessante até. Hoje não é muito divulgada mas parece haver ainda uma enorme quantia de programas escritos em COBOL rodando no mundo. Vi umas matérias nos últimos dias falando sobre gente sendo treinada atualmente para programar em COBOL

 

Isso que listou não sei o que é não. Era isso mesmo? A única coisa assim cheia de símbolos que já usei foi uma linguagem chamada APL e era bem legal. Veja esse teclado com os símbolos em laranja de https://geekhack.org/index.php?topic=93923.0

190613-apl-teclado.thumb.jpg.fbc756f314846784df1183be08461b79.jpg

 

Escrevi alguns programas em APL. Eu estudava matemática afinal e tinha a ver, mas  nem me lembro o que faziam :) 

Agora não estou lembrando se é esse mesmo, mas trabalhei em uma grande empresa onde tinha uma intranet com mas de 20.000 usuários, e o que tinha de terminal e computador não tá no gibi, em tudo que é canto estavam lá, um ao lado do outro, alias, vários no mesmo ambiente, o monitor do terminal é aquele menorzinho (menos de 15") com a tela verde (sem imagens) que queima a tela fácil...se tinha esses caracteres especiais eu não lembro, o windows usado ainda era o 95 e os micros em sua maioria era torre na horizontal, com monitor em cima, o processador não lembro de jeito nenhum, nesse tempo eu não me ligava em pc...

Compartilhar este post


Link para o post
Compartilhar em outros sites
3 horas atrás, misterjohn disse:

Agora não estou lembrando se é esse mesmo, mas trabalhei em uma grande empresa onde tinha uma intranet com mas de 20.000 usuários, e o que tinha de terminal e computador não tá no gibi, em tudo que é canto estavam lá, um ao lado do outro, alias, vários no mesmo ambiente, o monitor do terminal é aquele menorzinho (menos de 15") com a tela verde (sem imagens) que queima a tela fácil...se tinha esses caracteres especiais eu não lembro, o windows usado ainda era o 95 e os micros em sua maioria era torre na horizontal, com monitor em cima, o processador não lembro de jeito nenhum, nesse tempo eu não me ligava em pc...

 

Isso era de uma época anterior aos micros :( 
E anterior ao Windows. Não existia computador "pessoal".  Os computadores eram chamados de mainframes, ocupavam andares inteiros e eram acessados a partir de terminais, monitores com teclados como esse da foto.Isso os mais modernos da época. Não eram terminais gráficos nem tinham cor. Apenas fósforo verde ou ambar as vezes. Em geral tinham 24 linhas por 80 colunas apenas. Muitos não tinham letras minusculas, alguns tinham uma tecla para ativar se você precisasse mesmo de minúsculas. IBM 3278 era o clássico terminal. 

 

Os computadores em geral rodando OS/VS ou DOS/VS ou depois VM/CMS --- que era virtualização nos anos 80. As linguagens eram basicamente COBOL e FORTRAN e ASSEMBLER. Mas havia opções como APL, Algol e até Pascal dependendo do ano. Mas isso é assunto para um outro tópico :D

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Quando entrei nessa empresa que citei acima, o CPD eram salas grandes com computadores enormes, com aquelas fitas de rolo girando para um lado e outro, a sala era tão gelada que o vidro ficava molhado, depois vieram os micros, sumiu tudo aquilo....

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

GRÁTIS: minicurso “Como ganhar dinheiro montando computadores”

Gabriel TorresGabriel Torres, fundador e editor executivo do Clube do Hardware, acaba de lançar um minicurso totalmente gratuito: "Como ganhar dinheiro montando computadores".

Você aprenderá sobre o quanto pode ganhar, como cobrar, como lidar com a concorrência, como se tornar um profissional altamente qualificado e muito mais!

Inscreva-se agora!