All Questions

Working with a free project on GitHub, I forked it, made some changes and asked for a PR, which was accepted.

I upgraded my fork upstream and kept making other changes, then did another PR again.

At that point, I realized that my new PR included all the commits I had already done, and even all the files.

I was supposed to be upstream by now, but either I missed something, or my fork never found out about the accepted PR.

To avoid that, I made a branch with only the modified files. However, the PR for that branch still includes all the commits I've made.

Not so with the files, only the modified one goes.

So what is the correct way to work when one forks a project?

Should I have run any more commands besides upstream? Or do I just have to empty my fork after each PR and go back to work as if it were from scratch?

I have a database MySQLwith the engine InnoDB, which, some tables are very large (approximately 30GB each).

When making one Backupor one Restoreof those tables from the Base de Datos, I have the problem that it takes a long time to restore the copy using Dump.

Is there any way to be able to perform the Backupsand Restoresof those tables very quickly?

NOTE:

This question is referenced from the next one, but with a different database storage engine.

I have a variable that the server gives me with a value, I need to know if the number is even or odd , but without using %2:

$.ajax({ 
    url:'/numero',
    type:'POST',
    success:function(num){
       // ¿Qué hago con num para saber qué es?
       // num.numero me da el valor del numero ej;5,7,2...
    }

})

As we already know, MySQL has two functions to concatenate strings: CONCATand CONCAT_WS.

Answering a question, I saw that CONCATit does not return the expected results when at least one of the values ​​is equal to NULL.

When is it then recommended to use CONCATand when to use CONCAT_WS?

I have to process a lot of sentences. In fact, the number of them is unlimited : they are obtained from a source on the Internet.

The goal is to count how many times a certain phrase is repeated. Since the number of them is, as I say, unlimited , it is obvious that I cannot store all of them in memory.

Additionally, certain conditions are required of me: the complexity of any operation must be O(1). There 's no mention of collisions, so I'm neglecting them for now.

An example of the expected behavior :

1. 4096 sentences are read, all of them different . Coincidentally, neither generates hash collision with another.

2. The hash table is filled . The 4096 gaps are occupied by the sentences read.

3. A new sentence is read. Its hash is the same as one of the previous phrases, but the phrase is different from all the 4096previous ones.

4. I remove from the table the item that has been unused the longest . In this case, it would be the first one I inserted . I don't remove the element with matching hash value, because it is more modern .

EDIT

Currently, I have this:

#include <string.h>

typedef struct phrase_s {
  char text[256];
  unsigned long long count;
  struct phrase_s *prev;
  struct phrase_s *next;
} Phrase;

Phrase List[4096];

// Devuelve la hash de una cadena, limitada a 12 bits ( 0 - 4095 ).
size_t makeHash( const char * );
// Devuelve la cadena MAS ANTIGUA, aquella que hay que eliminar.
Phrase *old( void );


void addString( const char *str ) {
  size_t hash = makeHash( str );

  if( !( List[hash].count ) ) {
    // Caso fácil. No hay cadenas con hash coincidente.
    memcpy( &( List[hash].text ), str, strlen( str ) );
    List[hash].count = 1;
    List[hash].prev = NULL;
    List[hash].next = NULL;

    return;
  }

  // Caso INTERESANTE. La hash COINCIDE con otra.
  // POR HACER.
}

How do I implement point 4 above? Can I continue from the code I already have, or are other modifications necessary?

I reiterate the issue of complexity. The number of operations to perform must be independent of the size of the table.

_{Note: This is a question that was posted a couple days ago and I found it interesting. It is what I could understand with some sense of it, which has been eliminated by its author.}

EDIT 2

I still find it an interesting question; surely there are more good answers, which show the logic to follow in these cases. I add the language C++to the allowed responses.

EDIT 3

As I have been told, the term must be specified O( 1 ). Normally, it would indicate a constant complexity . Since we're talking about a hash table, we'll add the mean tagline ; that is, the chosen algorithm must have, on average , complexity O( 1 ).

Also, to be able to use std::unordered_map, responses in C++11 are supported.