Ir ao conteúdo
  • Cadastre-se

HwapX

Membro Pleno
  • Posts

    143
  • Cadastrado em

  • Última visita

posts postados por HwapX

  1. Citação

    Haveria alguma outra forma, mas podendo referenciar diretamente o elemento da array que eu quero modificar?

    Não, java passa argumentos por valor(cópia), para conseguir o que você deseja seria necessário criar algum tipo de indireção em que a variável(valor) é acessado por meio de outro como na sua solução.

     

    Veja este artigo para mais informações: https://www.javaworld.com/article/2077424/learn-java/learn-java-does-java-pass-by-reference-or-pass-by-value.html.

     

    Uma solução mais elegante poderia ser retornar o resultado, e na chamada armazenar o valor na mesma variável.

    private static void Pivo(double Matriz[], double Resultado){
        ...
    	    Resultado[Posicao]/=temp;
        ...
        return Resultado;
    }
    
    public static void main(String[] args){
        ...
        Result[0] = Pivo(Coeffs[0], Result[0]);
    }

     

  2. @UmanoBlu a função strcoll tem o mesmo funcionamento da strcmp porém ela leva em conta as regras de localização.

     

     

    E ordenar tudo de sem que você tenha nenhum trabalho não vai ser possível sem ajuda de uma biblioteca externa, você terá que realizar todas as comparações é assim que os algorítimos de ordenação(https://pt.wikipedia.org/wiki/Algoritmo_de_ordenação) mais básicos(https://pt.wikipedia.org/wiki/Bubble_sort) funcionam não é "gambiarra".

  3. Você também poderia comparar caractere a caractere utilizando um loop for ou while, algo como:

    char feminino[] = "feminino";
    int i = 0;
    
    //Compara o caractere na posição i 
    //    sexo[i] == feminino[i]
    //Se a posição i não for o final da string(0)
    //    sexo[i]
    while(sexo[i] == feminino[i] && sexo[i])
    	//Avança para a proxima posição
    	i++;
    
    //Compara novamente a última posição e armazena o resultado na variável igual
    int igual = sexo[i] == feminino[i];

    Isso poderia até ser convertido em uma função:

    int cmp(char* str1, char* str2) {
        int i = 0;
        while(str1[i] == str2[i] && str1[i])
            i++;
            
        return str1[i] == str2[i];
    }

     

    • Curtir 3
    • Obrigado 1
  4. Tentei ligar o motor diretamente a uma fonte de celular de 5v 550mA com alguns diodos para reduzir a tensão para proximo dos 2.4v que havia visto no motor porém não obtive sucesso, testei brevemente sem os diodos porém o motor teve dificuldade em arrancar.

     

    Vou tentar conseguir uma fonte de 1 Ampere como sugeriu.

     

    Obrigado @F4b10, tudo de bom!

  5. As baterias do meu barbeador não estão mais segurando carga e estou querendo remove-las e deixa-lo ligado direto. acredito que tenha que neutralizar o circuito que efetua a carga para que a corrente não seja interrompida, porém não sei como poderia fazer isso;

     

    Segue imagem da placa:

    P_20180929_170144_1_p.thumb.jpg.d0f4b48b825e4b1a06a74b6ec3e16106.jpgP_20180929_180324_1_p.thumb.jpg.0e2cfc254f6da1dfcb82ed2d0857657a.jpg

     

    A alimentação direta AC ocorre pelos dois contatos da direita, no local dos fios existiam 2 baterias NI-CD AA de 600mAh 1.2V.

  6. Vi a pergunta na semana passada e respeitando as restrições que citou iria sugerir o uso de ponteiros, mas como você chegou a uma solução antes de que eu expusesse a ideia resolvi esperar até que o exercício fosse entregue o que assumo que já ocorreu.

     

    Estou postando as soluções abaixo somente a titulo de conhecimento ao contrário de explicar ponto a ponto como normalmente aconteceria.

     

    Com ponteiros:



    #include <stdio.h> char* proximoEspaco(char *nome) { //enquanto o valor apontado por nome for diferente de zero while(*nome) //Avança o ponteiro para o proximo caractere e verifica se ele é um espaço if(*++nome == ' ') //Caso seja retorna um ponteiro para ele return nome; //Alternativamente //while(*nome != '\0') { // nome++; //ou ++nome; //ou nome = nome + 1; //nessa situação não faz diferença // if(*nome == ' ') // return nome; //} //Caso chegue ao final da string returna NULL return NULL; } void deslocar(char *de, char *para) { //Copia o valor apontado por de em para, verifica se o valor apontado por para é diferente de 0 e avança ambos os ponteiros. // Ex: Jet Von Li que este ponto seria //Passo1: Jet V.n Li // 0123456789 // ^^ // parade <- Obs: quero indicar as variaveis para e de e não a palavra parade //Passo2: Jet V. Li // 0123456789 // ^^ // parade //Passo3: Jet V. LLi // 0123456789 // ^^ // parade //Passo4: Jet V. Lii // 0123456789 // ^^ // parade //Result: Jet V. Li while(*para++ = *de++); //Alternativamente //while(*para != '\0') { // *para = *de; // de++; // para++; //} } void abreviar(char *nome) { char *proximo; //Procura o espaço a partir do valor apontado por nome e caso encontre procura // um proximo espaço a partir do ponteiro retornado //Caso encontre ambos continua while( (nome = proximoEspaco(nome)) && (proximo = proximoEspaco(nome)) ) //Se a quantidade de caracteres entre eles for igual ou superior a 3 // Pois por mais que seja improvável, caso exista menos de dois caracteres // alem do espaço não existe local nem motivo para colocar o ponto // Ex: Jon A Long // 0123456789 // nome no primeiro espaço 3, proximo no segundo espaço 5 // 5 - 3 = 2 //Avança o ponteiro nome e verifica se o valor armazenado está entre A e Z if(proximo - nome >= 3 && *++nome >= 'A' && *nome <= 'Z') { //Avança o ponteiro nome e armazena o ponto no local *++nome = '.'; //Desloca o texto do proximo espaço até a posição seguinte ao ponto(nome + 1) deslocar(proximo, nome + 1); } //Alternativamente //nome = proximoEspaco(nome); //proximo = proximoEspaco(nome); //while(nome != '\0' && proximo != '\0') { // if(proximo - nome >= 3) { // nome++; //ou ++nome; //ou nome = nome + 1; //Não faz diferença // if(*nome >= 'A' && *nome <= 'Z') { // nome++; //ou ++nome; //ou nome = nome + 1; //Não faz diferença // *nome = '.'; // deslocar(proximo, nome + 1); // } // } // nome = proximoEspaco(nome); // proximo = proximoEspaco(nome); //} } int main() { char nome[] = "Joaquim Jose da Silva Xavier"; printf("%s -> ", nome); abreviar(nome); printf("%s\n", nome); return 0; }

     

    Com índices:



    #include <stdio.h> int proximoEspaco(char *nome, int pos) { //enquanto o nome[pos] for diferente de zero while(nome[pos]) //incrementa a posição para o proximo caractere e verifica se ele é um espaço if(nome[++pos] == ' ') //Caso seja retorna um a posição dele return pos; //Alternativamente //while(nome[pos] != '\0') { // pos++; //ou ++pos; //ou pos = pos + 1; //nessa situação não faz diferença // if(nome[pos] == ' ') // return pos; //} //Caso chegue ao final da string returna 0 que embora seja uma posição valida // nunca seria um possível valor visto que 0 é o menor valido para pos // e a função busca o proximo. return 0; } void deslocar(char *nome, int de, int para) { //Copia o valor da posição de na posição para, compara o valor da posição para com 0 e incrementa ambas as posições // Ex: Jet Von Li que este ponto seria //Passo1: Jet V.n Li // 0123456789 // ^^ // parade <- Obs: quero indicar as variaveis para e de e não a palavra parade //Passo2: Jet V. Li // 0123456789 // ^^ // parade //Passo3: Jet V. LLi // 0123456789 // ^^ // parade //Passo4: Jet V. Lii // 0123456789 // ^^ // parade //Result: Jet V. Li while(nome[para++] = nome[de++]); //Alternativamente //while(nome[para] != '\0') { // nome[para] = nome[de]; // de++; // para++; //} } void abreviar(char *nome) { int atual = 0, proximo = 0; //Procura um espaço a partir da posição atual e caso encontre // procura um proximo espaço a patir da posição retornada //Caso encontre ambos continua while( (atual = proximoEspaco(nome, atual)) && (proximo = proximoEspaco(nome, atual)) ) //Se a quantidade de caracteres entre eles for igual ou superior a 3 // Pois por mais que seja improvável, caso exista menos de dois caracteres // alem do espaço não existe local nem motivo para colocar o ponto // Ex: Jon A Long // 0123456789 // atual no primeiro espaço 3, proximo no segundo espaço 5 // 5 - 3 = 2 //Avança a posição atual e verifica se nome[atual] está entre A e Z if(proximo - atual >= 3 && nome[++atual] >= 'A' && nome[atual] <= 'Z') { //Avança a posição atual e armazena o ponto em nome[atual] nome[++atual] = '.'; //Desloca o texto do proximo espaço até a posição seguinte ao ponto(atual + 1) deslocar(nome, proximo, atual + 1); } //Alternativamente //atual = proximoEspaco(nome, atual); //proximo = proximoEspaco(nome, atual); //while(atual != 0 && proximo != 0) { // if(proximo - atual >= 3) { // atual++; //ou ++atual; //ou atual = atual + 1; //Não faz diferença // if(nome[atual] >= 'A' && nome[atual] <= 'Z') { // atual++; //ou ++atual; //ou atual = atual + 1; //Não faz diferença // nome[atual] = '.'; // deslocar(nome, proximo, atual + 1); // } // } // nome = proximoEspaco(nome, atual); // proximo = proximoEspaco(nome, atual); //} } int main() { char nome[] = "Joaquim Jose da Silva Xavier"; printf("%s -> ", nome); abreviar(nome); printf("%s\n", nome); return 0; }

  7. Uma observação você diz que que os minutos que o usuário informa podem ser fracionados porém armazena eles em uma variável inteira.

     

    Talvez devido a observação acima a resposta do @WilliamNascimento tem um equivoco no calculo dos segundos que é representado pela fração.

     

    Dito isso os cálculos seriam:

     

    image.png.e6d5269bc7ae384fce11bfda8d4b1dc9.png

     

    image.png.4bf169f4a845a58bfe69a8cff478cd55.png

     

    image.png.a64a9e88a003820170470fc25e8850a3.png

     

    E o algorítimo correto seria:

    #include <stdio.h>
    
    //Assinatura basica definida pelas regras do C11 http://c0x.coding-guidelines.com/5.1.2.2.1.html
    int main(void)
    {
        int horas, minutos;
        //Tipo correto de min e segundos de acordo com os requisitos
        float min, segundos;
        
        printf("Insira a quantidade de minutos: ");
        scanf("%f", &min);
        
        //Ao armazenar o resultado da operação em uma variável do tipo inteiro a fração é descartada
        horas = min / 60;
        //É necessário converter min para inteiro( (int)min ) para utilizar o operador de modulo
        minutos = (int)min % 60;
        //min - (int)min é utilizado para extrair somente a fração do valor
        //219,6 - 219 = 0,6
        //0,6 * 60 = 36 segundos
        segundos = (min - (int)min) * 60;
        
        //Você pode arredondar os segundos com %.1f onde 1 representa a quantidade casas demais que você deseja
        printf("Isso e igual a %dh, %dmin e %fs", horas, minutos, segundos);
        
        return 0;
    }

    Você pode conferir e testar em  https://ideone.com/sN7bis.

    • Curtir 1
  8. Pelas imagens o resultado faz todo o sentido afinal todos os dados tem a mesma data e valor, você já parou para pensar se(e como) você relacionaria os dados simplesmente olhando para as duas tabelas? pois para relacionar os dados no sistema você precisa de uma regra clara e exata.

     

    De qualquer forma o ideal seria que as tabelas estivessem relacionadas por meio de uma chave estrangeira que você preencheria durante a inserção dos dados.

    • Curtir 1
  9. Nunca passei por essa situação, porém um ótimo meio de manter seus dados a salvo é realizar backup periodicamente.

     

    Quanto a checar se a restauração ocorreu, você pode ver isso no log de eventos do Windows as restaurações de sistema ficam registradas lá.

     

    Você pode abri-lo digitando eventvwr.msc no executar.

     

    Em certas condições quando á um conflito durante a restauração o Windows cria um segundo diretório no mesmo nível com a outra versão, porém não me lembro se esse diretório armazena a versão atual ou a restaurada.

     

    Outro detalhe é que normalmente é possível reverter a restauração para isso basta visitar a tela de restauração e caso alguma tenha ocorrido recentemente você terá a opção de revertê-la.

  10. Não tenho como falar nada a respeito disso, mas para confirmar se o arquivo é um VBE mesmo faça o que disse extraia somente ele e o abra com o bloco de notas.

     

    Para isso você pode clicar nele com o botão direito do mouse e selecionar editar ou abrir o bloco de notas clicar em Arquivo->Abrir selecionar todos os arquivos e buscar esse arquivo.

     

    Se ele for um VBE seu conteúdo será algumas linhas de código do contrário será um conteúdo ilegível.

  11. Como complemento veja a biblioteca Phaser(existem dezenas de outras basta pesquisar) ela permite que você crie jogos 2d interativos(Aka Mario, Sonic, flappy bird, etc...) com JavaScript.

     

    Ela possui uma boa galeria de exemplos https://phaser.io/examples e jogos feitos com ela https://phaser.io/games.

     

     

    Consulte os tutoriais dela https://phaser.io/learn eles cobrem todo o necessário e caso você queira brincar um pouco ela também conta com um editor online https://phaser.io/sandbox.

    • Curtir 1
  12. Baseado nos seus requisitos bastaria um campo select para cada categoria.

    <form method="post">
      <label>
        Comida: 
        <select name="comida" required>
          <option value="">-- Nenhuma --</option>
          <option>Pizza</option>
          <option>Hot dog</option>
        </select>
      </label>
      <label>
        Bebida: 
        <select name="bebida" required>
          <option value="">-- Nenhuma --</option>
          <option>Suco</option>
          <option>Refrigerante</option>
        </select>
      </label>
      <label>
        Cor: 
        <select name="cor" required>
          <option value="">-- Nenhuma --</option>
          <option>Rosa</option>
          <option>Azul</option>
        </select>
      </label>
      <input type="submit" value="Enviar">
    </form>

    Você pode testar em https://jsfiddle.net/up7ar3kk/7/.

     

    O usuário escolherá 1 item de cada categoria e será capaz de ver todas suas escolhas.

    • Curtir 1
  13. Existem alguns tratamentos que você deve fazer, talvez eles já resolvam seu problema:

    • Não permitir que x ou y sejam menores que zero.
    • Não permitir que x seja maior ou igual a largura da imagem.
    • Não permitir que y seja maior ou igual a altura da imagem.
    • Não permitir que a nova cor seja igual a cor do pixel inicial pois além de não ser necessário pintar pode causar recursão infinita.

    Caso não resolvam você deve ajustar seu algorítimo para não usar recursão as soluções mais comuns envolvem utilizar uma pilha própria ou uma fila, você pode conseguir todas as informações necessárias nos links abaixo da Wikipedia.

    https://en.wikipedia.org/wiki/Flood_fill

    https://en.wikipedia.org/wiki/Breadth-first_search

    https://pt.wikipedia.org/wiki/Busca_em_largura

    https://en.wikipedia.org/wiki/Depth-first_search

    https://pt.wikipedia.org/wiki/Busca_em_profundidade

     

    Caso ainda tenha dúvidas nos informe.

  14. @Luiz_Augusto_Silveira não são muitos problemas como havia dito anteriormente, você pode verificá-los em https://validator.w3.org/, os principais são:

     

    Os botões que devem exibir o sinal de > e <, devem ter o conteúdo convertido para entidades HTML(&gt; para > e &lt; para <).

    <!--
    <button class="esquerdo" onclick="meuslideshow.previous()"><</button>
    <button class="direito"  onclick="meuslideshow.next()">></button>
    -->
    <button class="esquerdo" onclick="meuslideshow.previous()">&lt;</button>
    <button class="direito"  onclick="meuslideshow.next()">&gt;</button>

    por volta da linha 150 uma div é fechada antes de fechar a section.

    	</div>
    </section>

    na linha 387 existe outra div sendo fechada sem a abertura correspondente.

    </div>

    porém não consigo afirmar qual div está sobrando se é o primeiro ou o segundo.

    • Curtir 2
  15. @Thyago Barbosa acontece parte(acredito que a maioria) dos motores de expressão regular não suportam lookbehind com quantificadores dinâmicos(?, *, +, {x,y}, {x,}).

    https://www.regular-expressions.info/lookaround.html

    Citação

    Many regex flavors, including those used by Perl, Python, and Boost only allow fixed-length strings. You can use literal text, character escapes, Unicode escapes other than \X, and character classes. You cannot use quantifiers or backreferences. You can use alternation, but only if all alternatives have the same length. These flavors evaluate lookbehind by first stepping back through the subject string for as many characters as the lookbehind needs, and then attempting the regex inside the lookbehind from left to right.

     

    E no motor utilizado pelo javascript a situação é ainda pior pois o proprio lookbehind só passou a ser suportado na especificação ES 2018(https://github.com/tc39/proposal-regexp-lookbehind) a qual ainda não foi concluída, ele é suportado no Chrome pois uma das etapas do processo de inclusão de um novo recurso na especificação exige que ao menos dois navegadores o implementem.

     

    Dito isso não é viável utilizar o lookbehind no javascript, como alternativa sugiro que extraia o texto que você deseja utilizando um grupo de captura basicamente você deveria colocar a expressão que case o conteúdo desejado entre parenteses().

     

    Exemplo:

    /era (\w{3}) vez/

    E você poderia extrair o texto entre parenteses com

    var uma = /era (\w{3}) vez/.exec('era uma vez')[1];

    Onde 1 é o índice do grupo() começando em 1.

    • Curtir 1

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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...

Ebook grátis: Aprenda a ler resistores e capacitores!

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!