Ir ao conteúdo
  • Cadastre-se

Plástico Bolha

Membros Plenos
  • Total de itens

    403
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

43

Sobre Plástico Bolha

  • Data de Nascimento 13-04-1991 (28 anos)

Informações gerais

  • Cidade e Estado
    Curitiba-pr
  1. Sim, é mais complicado que usar o Visual Studio do Windows, dar trocentos next(s) e ser feliz , o VS Code pro C/C++ não é tipo pro cara que acabou de começar no C/C++ (o cara já começa fritando hahahaha) . . .Têm que entender o que é esses arquivos de configuração JSON e tal, entre outras coisas . . . Mas têm uma vantagem bem legal e que as empresas de pequeno porte, Startups amam! É Barato! hahahaha Ubuntu De graça + Open Source (Github) VS Code De graça + Open Source (Github) + Funciona no MAC OS/Windows/Linux GNU C Library De graça + Open Source (Não Sei) C/C++ de Graça Não tem que pagar licença de Windows (por máquina), não precisa pagar licença de IDE (por máquina) nem nada rsrsrs . . . E depois que você se acostuma com o VS Code fica simples . . . Outro possível incômodo de usar o Visual Studio (normal, dentro do Windows com as licenças da microsoft etc etc . . .) em um Projeto real é o seguinte! Olha só que zuera forte do tio Bill! Os projetos das empresas tendem a ficar gigantescos, e obviamente tendem a durar anos . . . Até aí legal . . . Imagine que o Visual Studio têm seu próprio compilador juntamente com as suas próprias diretrizes de compilação, então aquele projeto gigante só vai funcionar caso você use o Visual Studio até porque, apenas para confirmar o que disse, segue o texto abaixo retirado do site oficial da Microsoft. O que acontece na prática, é que quando aquele projetinho ficou gigantesco, e foi totalmente feito no Visual Studio, o número de programadores cresce conforme o tamanho/porte do projeto, e quanto mais programadores + IDE(s) + Windows = Mais licenças + Custos . . . E o tio Bill fica cada vez mais rico hauhauhauh . . . E quando você quiser sair por causa do custo elevado, o projeto vai estar tão gigantesco e tão atrelado às ferramentas facilitadoras da microsoft que te ajudaram no começo, que simplesmente ficará inviável, pois a dor de cabeça de pegar um projeto gigante e trocar todas as ferramentas pra sair das licenças etc etc . . . Vai ser tão grande, que quase te obrigará a optar a ficar pagando as taxas, então o tio Bill não ganha dinheiro com os usuários comuns que baixam o Windows pirata da net . . . O Tio bill ganha dinheiro com as empresas que usam a sua tecnologia por meio das licenças . . . Pra você entender melhor o que isso significa . . . Vamos pegar por exemplo o Microsoft SQL Server . . . A versão Enterprise (Necessário para as empresas) custa apenas 14,256 dolares POR NÚCLEO, quer dizer que se você tiver um servidor que tiver um processador com 8 núcleos . . . O que pode ser considerado normal para um servidor decente, irá pagar apenas 114048 dolares hauahuahuah Estamos falando apenas de 1 server . . . Se você quiser ter 2 SQL Servers vai ter que pagar isso aí tudo de novo (por server), e ainda vai ter que pagar as licenças do Windows, caso esses servers sejam IIS (Windows Server), o que é algo bem provável, porque o SQL Server funcionará melhor no Windows do que no Linux provavelmente hahahaha . . . Olha só que lindo . . . Enfim . . . Coisas da vida : ) . . . Não sou Hipster nem nada, mas gosto do linux : ) . . . Outra coisa . . . o JAVA vai ser pago (Joguei no ventilador agora) . . . Pronto terminei já, que tópico revolts rsrsrs enfim segue a vida '-' . . .
  2. Caso você queira rodar C/C++ no VS Code no Ubuntu ou no Debian (possuem a mesma base então não haverá problema), faça o seguinte. ################# Passo 1 ################# Tenha certeza que instalou corretamente o GCC, abra o terminal e digite: gcc --version Deveria retornar algo como isso: Se te retornou algo como isso, é porque está instalado. ################# Passo 2 ################# GNU C Library Para Instalar/Baixar/Descompactar o GNU C abra seu terminal e digite os seguintes comandos: ################# Passo 3 ################# Após ter instalado o VS Code abra ele e digite: Ctrl+Shift+X No campo de busca digite: C/C++ Neste momento você deve ver algo semelhante a isto: Instale este plugin no VS Code e click em reload ou simplesmente feche e saia novamente do VS Code ################# Passo 4 ################# Sobre a estrutura de pastas do projeto VS Code, assumindo que sua distro é x64 e que está usando Debian/Ubuntu segue a instrução. No Desktop (Por exemplo) crie um diretório chamado CPP_Codes (ou o nome que quiser), dentro desse diretório (CPP_Codes) crie a seguinte estrutura de pastas: Deve ficar desta forma: Agora você precisa fazer o build do projeto: Após fazer o build o arquivo a.out será criado, caso o code esteja correto, então basta apertar F5 para entrar no modo debug. CPP_Codes.zip
  3. Teste o VS Code no Ubuntu, muito bom.
  4. package main import ( "fmt" "strconv" "strings" ) func main() { var term string = "2x+5x" var expression []string = strings.Split(term, "+") var tmpExp int var counter int = 0 var err error var idx int = 0 var _length int = len(expression) for idx < _length { if strings.Index(expression[idx], "x") != -1 { tmpExp, err = strconv.Atoi(strings.Split(expression[idx], "x")[0]) if err == nil { counter += tmpExp } } idx++ } fmt.Println("Soma de", term, ":", counter) } Veja que fiz exatamente o que pediu (alguma forma de pega o termo 2 e soma com o termo 5), a soma de 2 + 5 ... Mas esta solução é extremamente frágil . . . Para criar algo robusto, que funcione para qualquer entrada, para qualquer equação, um Parser será necessário, mais está aí a "lógica" (não em C) que faz exatamente o que foi pedido rsrs . . . https://play.golang.org/p/aHZXd_5zVYT
  5. Você precisa fazer um Parser! Não é algo trivial, mas se quer fazer algo robusto, para receber qualquer entrada e processá-la, o Parser será necessário. https://pt.wikipedia.org/wiki/Análise_sintática_(computação)
  6. Pode-se fazer por exemplo uma DLL feita em C ANSI (ou em outra linguagem), e importar ela com C#, ou alguma outra linguagem, sendo que dentro dessa DLL pode conter N funções feitas em C. Pegando como exemplo o Golang, ele é compatível com C ANSI, se você criar uma função em C pode chamar ela com GO sem precisar fazer nada de especial, é possível dar #include em alguma lib feita em C ANSI dentro do GO e chamar as funções de C dentro do GO normalmente. É possível dentro do C chamar código Assembly. É possível usar o JNI (DO JAVA) para imbutir um Wrapper de C/C++ dentro do JAVA Usar Sockets/Webserver/Endpoint/Rest API etc... + JSON é outra alternativa, geralmente utilizada na WEB para criar vários serviços/micro serviços feitos em diferentes linguagens para diferentes dominios.
  7. Sim, de fato existe um custo computacional para realizar esta operação, no entanto ... Geralmente na análise de complexidade de algoritmos é pego somente o termo de maior relevância dentro do algoritmo, e é desprezado os termos de menor relevância, se pro seu algoritmo contabilizar tal declaração se torna algo essêncial para montar a equação e fazer a análise assintótica, então sim, deve-se contabilizar, caso este termo (declaração) seja desprezível dado o resto do algoritmo, então não há porque contabilizá lo, isso depende muito do objetivo da sua análise, por exemplo: // Imagine que está função faz a soma dos elementos de uma matriz quadrada function sumMatrix(matrix: number[][]) { // Faz sentido contabilizar o custo da declaração de sum ? var sum = 0; for (var i = 0; i < matrix.length; i++) { // N - 1 for (var j = 0; j < matrix.length; j++) { // (N - 1)*(N - 1) sum += matrix[i][j]; // (N - 1)*(N - 1) } } // Faz sentido contabilizar o custo deste retorno ? return sum; } // Faz sentido contabilizar o custo desta declara + retorno ? var totalSum = sumMatrix(matrix) console.log(totalSum) //Faz sentido contabilizar o custo desta impressao deste numero no console ? Você teria algo desse tipo no final, por exemplo (Não sei fiz a análise deste algoritmo 100% correta, no entanto, nem é essa a ideia deste post) Desta forma esta equação deveria ser simplificada para que fosse possível fazer a análise assintótica do seu algoritmo, de qualquer forma, fica claro que seria uma equação de ordem 2, obivamente porque se trata de uma matriz quadrada. Então teriamos algo como no pior caso O(n²). Perceba algo interessante sobre a sua análise! Iria fazer alguma diferença se adicionar aquelas declarações ali em cima? Como por exemplo: Nâo ! Isto não mudaria a ordem 2 da equação, e a complexidade do seu Big O não deixaria de ser O(n²), portante, para este algoritmo em questão tais declarações se tornam despreziveis. Na análise assintótica de um algoritmo, cada caso é um caso, e deve-se ter total compreensão do que o seu algoritmo faz, e qual o objetivo dá análise ou qual é exatamente a métrica que se está buscando na análise. Por exemplo, se este algoritmo fosse analisado: function sumNumbers(x,y) { var result = x + y // Vale a pena contabilizar esta atribuição + operação matemática ? Sim ! return result // vale a pena contabilizar este retorno ? Sim ! } Neste caso valeria a pena contabilizar a declaração e o retorno das 2 linhas, pois a equação simplificada deste algoritmo não iria ser de ordem maior que 2 . . . Acredito que o melhor a se fazer para analisar o algoritmo seria antes de analisar o algoritmo de forma mecânica/matemática, seria compreender o contexto do algoritmo.
  8. Faz bastante tempo desde a ultima vez que usei openGL e webGL, tinha guardado este trecho de código, pode te ajudar a iniciar algo. A glut.h é legal para aprender a programar com openGL, mas se for fazer um projeto mais complexo, vai precisar usar outras coisas. OBS: para rodar este código será necessário a DLL glut32.dll e as libs glut.h e GL/gl.h. Este código gera uma animação de um cilindro 3D, esta animação termina quando a tecla "esc" for apertada. #include <stdlib.h> #include <glut.h> #include <GL/gl.h> #include <stdio.h> #include <math.h> #define ESCAPE_KEY 27 float janela; float t = 0.0f; void renderCylinder(float x1, float y1, float z1, float x2,float y2, float z2, float radius,int sub_divisao,GLUquadricObj *quadric) { float vx = x2-x1; float vy = y2-y1; float vz = z2-z1; if(vz == 0) vz = .00000001; float v = sqrt( vx*vx + vy*vy + vz*vz ); float ax = 57.2957795*acos( vz/v ); if ( vz < 0.0 ) ax = -ax; float rx = -vy*vz; float ry = vx*vz; glPushMatrix(); //CORPO CILINDRO glTranslatef( x1,y1,z1 ); glRotatef(ax, rx, ry, 0.0); gluQuadricOrientation(quadric,GLU_OUTSIDE); gluCylinder(quadric, radius, radius, v, sub_divisao, 1); //Primeiro Cap gluQuadricOrientation(quadric,GLU_INSIDE); gluDisk( quadric, 0.0, radius, sub_divisao, 1); glTranslatef( 0,0,v ); //Segundo Cap gluQuadricOrientation(quadric,GLU_OUTSIDE); gluDisk(quadric, 0.0, radius, sub_divisao, 1); glPopMatrix(); } void CILINDRO(float x1, float y1, float z1, float x2,float y2, float z2, float radius,int sub_divisao) { GLUquadricObj *quadric=gluNewQuadric(); gluQuadricNormals(quadric, GLU_SMOOTH); renderCylinder(x1,y1,z1,x2,y2,z2,radius,sub_divisao,quadric); gluDeleteQuadric(quadric); } void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0,0,-7); //Definindo o cilindro float x1 = sin(t); float y1 = sin(t/2); float z1 = cos(t*1.1); float x2 = -sin(t*1.3); float y2 = 0; float z2 = -cos(t); float radius = 0.03+(sin(t)/2+0.5)/3; CILINDRO(x1,y1,z1,x2,y2,z2,radius,32); t+=0.010; glutSwapBuffers(); } void InitGL(int Width, int Height) { glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); glShadeModel(GL_SMOOTH); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f); glMatrixMode(GL_MODELVIEW); glEnable(GL_LIGHTING); GLfloat LightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f }; GLfloat LightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f }; GLfloat LightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f }; glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); glEnable(GL_LIGHT1); } void keyPressed(unsigned char key, int x, int y) { if(key == ESCAPE_KEY) { glutDestroyWindow(janela); exit(1); } } int main( int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(640, 480); janela = glutCreateWindow(""); glutDisplayFunc(&display); glutKeyboardFunc(&keyPressed); glutFullScreen(); glutIdleFunc(&display); InitGL(640, 480); glutMainLoop(); return 1; }
  9. O que fiz, foi algo com pouca performance, no entanto, atende aos requisitos, está é apenas a ideia de como você poderia fazer: package main import ( "fmt" ) const MAX = 12 func main() { var vetA = [MAX]int{7, 2, 3, 2, 5, 2, 3, 7, 1, 2, 45, 1} var idx int = 0 var vetB [MAX]int for i := 0; i < MAX; i++ { for j := i + 1; j < MAX; j++ { if vetA[j] == vetA[i] { var flag bool = true for k := 0; k < MAX; k++ { if vetB[k] == vetA[j] { flag = false break } } if flag { vetB[idx] = vetA[j] idx++ } } } } fmt.Println("Valores repetidos: ", vetB) // Output: Valores repetidos: [7 2 3 1 0 0 0 0 0 0 0 0] }
  10. Acho que a ideia seria essa: package main import "fmt" func main() { var b float32 = -1; var h float32 = -1; var maxTry int = 3; var try int = 0; for(((b < 0) || (h < 0)) && (try < maxTry)) { fmt.Print("Digite o valor da base: "); fmt.Scanln(&b); fmt.Print("Digite o valor da altura: "); fmt.Scanln(&h); try++; if(((b < 0) || (h < 0)) && (try < maxTry)) { fmt.Print("Dados invalidos - "); fmt.Println(try); } } if(try < maxTry) { try = 0; b = (b*h) / 2; fmt.Println("Area: ", b); } else { fmt.Println("Erro !"); } } Se for proibido usar for ... teria como fazer com recursividade: package main import "fmt" func calcArea(try int, maxTry int) bool { var b float32 = -1; var h float32 = -1; var rsp bool = false; try++; if(try <= maxTry) { fmt.Print("Digite o valor da base: "); fmt.Scanln(&b); fmt.Print("Digite o valor da altura: "); fmt.Scanln(&h); if((b < 0) || (h < 0)) { fmt.Print("Dados invalidos - "); fmt.Println(try); rsp = calcArea(try, maxTry); } else { b = (b*h) / 2; fmt.Println("Area: ", b); rsp = true; } } return rsp; } func main() { var maxTry int = 3; var try int = 0; var rsp bool = calcArea(try, maxTry); if(rsp) { fmt.Println("Ok"); } else { fmt.Println("Erro"); } }
  11. Entendi! Pense em uma "label" como uma espécie de "componente" dentro do seu windows.forms ! Veja este vídeo, ele é básico e objetivo. OBS: Depois que você ver o vídeo e criar a label, basta fazer algo como
  12. Crie uma label, depois acesse a propriedade text (pelo setText).
  13. A ideia seria essa: package main import "fmt" const( MIN = 0; MAX = 12; ) func factorial(n int) int { var count, i int = n, n; for (i > 1) { count = count*(i-1); i--; } return count; } func main() { var n int; fmt.Print("Por favor digite um numero maior que ",MIN," e menor que ",MAX ,": "); fmt.Scanf("%d", &n); if((n > MIN) && (n < MAX)) { fmt.Print("Fatorial de ",n,": ", factorial(n)); } else { fmt.Print("O numero ",n," esta fora do range"); } } Att
  14. É importante que você refaça os algoritmos, para compreender a lógica de funcionamento deles, se alguém simplesmente te explicar, ou mostrar o código feito, ou se você apenas ler em uma apostila, é possível que na hora da prova o professor faça alguma distorção no algoritmo, ou apresente o exercício em um outro formato, justamente para saber se você compreendeu detalhadamente como ele funciona ou apenas decorou uma receita de bolo. Pegando como exemplo o algoritmo de busca binária: func Binary_SearchI(vet []int, key int, max int) int { var l int = 0; var r int = max-1; var mid int; for(l <= r) { mid = (l+r)/2; if(key == vet[mid]){ return mid; } else if(key < vet[mid]) { r = mid-1; } else { l = mid+1; } } return -1; } func main() { var vet []int = []int{2,5,8,12,16,23,38,56,72,91}; var max int = len(vet); var key int = 38; var pos = Binary_SearchI(vet,key,max); fmt.Println("Posicao da chave: ", pos); } Deu para perceber que este algoritmo abaixo seria um pseudo-código de um algoritmo de busca binária distorcido, para aceitar uma estrutura 'cliente'. i == 0; f == final; m == (i + f) / 2; Leia cod; Enquanto ((i <= f) e (cod != cliente[m][0])) Faça { Se (cod < cliente[m][0]){ Então {f == m - 1; Senão {i == m + 1; m == (i + f) / 2; Se (i <= f) Então {Imprima cliente[m][i]; Senão imprima "Código não existe"; } O que pode te ajudar a compreender completamente como a busca binária funciona, seria refazer ele de várias maneiras diferentes, por exemplo, pegue o busca binária original/padrão e altere ele para buscar o CPF de um array (do tipo cliente) de clientes como esta por exemplo: type Client struct { CPF int Name int Login int Password int } // ... var Clients [10]Client; //... // Acessar o CPF do cliente 0 -> Clients[0][0] // ...

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!