[Ethereum] What’s the best way to transform bytes of a signature into v, r, s in solidity

This is not going to work in Solidity. The += operator is not implemented for strings, you need to use a library that allows to concatenate strings; I think the most popular is this one. There is an example of how to use concatenation here.

I'm not sure what you're trying to do, but that kind of concatenation is expensive. Wouldn't it be enough to have two methods:

getStringsLength() returns (uint) and getStringByIndex(uint index) returns (string), and retrieve the strings in a loop? You can then do the concatenation outside of the contract (probably cheaper).

Solidity:

string[] myArray;

function getStringsLength() returns (uint) {
    return myArray.length;
}

function getStringByIndex(uint index) returns (string) {
    if (index < myArray.length){
        return myArray[index];
    }
    return "";
}

Solidity-consumer pseudocode:

strings_to_serialize = []
for (int i=0; i<contract.getStringsLength(); i++)
    strings_to_serialize.append(contract.getStringByIndex(i))
# process the strings here

Another correction (2019-05-17): In modern Solidity version you can no longer pass multiple arguments to keccak256. It now only takes one argument of type bytes. You can still hash multiple values together like this:

function hashSeriesNumber(string calldata series, uint256 number) external pure returns (bytes32)
{
    return keccak256(abi.encode(number, series));
}

Correction thanks to @Ismael: The easiest and cheapest way is just to pass multiple arguments to the hashing function:

function hashSeriesNumber(string series, uint256 number) public pure returns (bytes32)
{
    return keccak256(number, series);
}

I think the easiest way is to take the hash of the uint256, then take the hash of the string and then xor them together:

function hasher(uint256 i, string str) public pure returns (bytes32)
{
    return keccak256(i) ^ keccak256(str);
}

Hashes are usually stored in bytes32, not in a string, because string's cost more gas and the hashing functions return a bytes32 anyways.