text:
Who's that PRNG?
Given a sequence of 625 32-bit unsigned integers (that is, in the range [0, 2**32)), output which of the following pseudorandom number generators generated the sequence:

Linear Congruential Generator
Xorshift
Mersenne Twister

Specifically, the C implementations of these three generators used for this challenge are as follows:
#include <stdint.h>

/* all code adapted from the sample implementations on the following Wikipedia pages:
     https://en.wikipedia.org/wiki/Linear_congruential_generator
     https://en.wikipedia.org/wiki/Xorshift
     https://en.wikipedia.org/wiki/Mersenne_Twister
*/

uint32_t lcg_seed;
uint32_t xor_x, xor_y, xor_z, xor_w;

void lcg_srand(uint32_t seed) {
    lcg_seed = seed;
}

uint32_t lcg(void) {
    lcg_seed = ((uint64_t) lcg_seed * 1103515245 + 12345) & ( (uint64_t) 0xFFFFFFFF  );
    return (uint32_t) lcg_seed;
}

void xorshift128_srand(uint32_t x, uint32_t y, uint32_t z, uint32_t w) {
    xor_x = x;
    xor_y = y;
    xor_z = z;
    xor_w = w;
}

uint32_t xorshift128(void) {
    uint32_t t = xor_x;
    t ^= t << 11;
    t ^= t >> 8;
    xor_x = xor_y; xor_y = xor_z; xor_z = xor_w;
    xor_w ^= xor_w >> 19;
    xor_w ^= t;
    return xor_w;
}

enum {
    // Assumes W = 32 (omitting this)
    N = 624,
    M = 397,
    R = 31,
    A = 0x9908B0DF,

    F = 1812433253,

    U = 11,
    // Assumes D = 0xFFFFFFFF (omitting this)

    S = 7,
    B = 0x9D2C5680,

    T = 15,
    C = 0xEFC60000,

    L = 18,

    MASK_LOWER = (1ull << R) - 1,
    MASK_UPPER = (1ull << R)
};

static uint32_t  mt[N];
static uint16_t  index;

// Re-init with a given seed
void mt_Initialize(const uint32_t seed) {
    uint32_t  i;

    mt[0] = seed;

    for ( i = 1; i < N; i++ ) {
        mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i);
    }

    index = N;
}

static void mt_Twist() {
    uint32_t  i, x, xA;

    for ( i = 0; i < N; i++ ) {
        x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER);

        xA = x >> 1;

        if ( x & 0x1 )
            xA ^= A;

        mt[i] = mt[(i + M) % N] ^ xA;
    }

    index = 0;
}

// Obtain a 32-bit random number
uint32_t mt_ExtractU32() {
    uint32_t  y;
    int       i = index;

    if ( index >= N ) {
        mt_Twist();
        i = index;
    }

    y = mt[i];
    index = i + 1;

    y ^= (mt[i] >> U);
    y ^= (y << S) & B;
    y ^= (y << T) & C;
    y ^= (y >> L);

    return y;
}

Rules

Input and output may be in any unambiguous, consistent format. If you're not sure if a format would be allowed, feel free to ask.
All inputs are guaranteed to match exactly one PRNG's output (there will never be a case where an input sequence matches none or more than one PRNG's output).

Test Cases
Due to post length limits, only 3 test cases are included. A larger list of test cases can be found here. Note that the values are provided in hexadecimal.
[CEE63876, DE7E2E77, 54EC3AE4, 92DEBB4D, D0756602, EE9D3B13, 04A42150, 0FE8BF49, 2BD7E04E, BB96756F, B9B2027C, B5750705, 9DD5B35A, E23EF98B, D15ACA68, C1C40E81, 35ABAB26, 2DA1A367, 36462514, 3CA211BD, E79753B2, A49B0F03, B3EA7E80, 64630CB9, BC22F8FE, D535985F, 14B902AC, EE9EBB75, A831A70A, 79C55B7B, F7099D98, 98AC99F1, D9CB29D6, 53C43457, 04C6FB44, 43DFE42D, 05A80D62, D86DBEF3, F9DA87B0, 99839629, 017D9DAE, 0B1B574F, A5586EDC, F2966BE5, B709E6BA, A160196B, D16B9CC8, FF46E161, 3BDFB486, 4CE4E147, BE01BD74, 6A2F329D, 99F29312, C7044AE3, 9A373CE0, 73515B99, 94E2CE5E, FA26B23F, 2883470C, 3ED31855, 7809726A, 64DE335B, 79A3C7F8, 5379E4D1, B9444B36, 92C2AA37, 6A496BA4, 84E6FD0D, FC81E4C2, 470DB2D3, 4F839E10, 45935D09, C40D8B0E, B4F6A92F, FDEC8B3C, 1C8BC0C5, D99B4A1A, E1CEA94B, 17951F28, BAECA441, 3C13EDE6, 0CDC8F27, 4CB105D4, ED1E437D, 1E210272, B8F8F6C3, FB02AB40, 63D09A79, 4178D3BE, B3EA3C1F, 58073B6C, 10B76535, BAEA6DCA, 37807B3B, 11E2A258, 93061FB1, EB299C96, 00719017, 130B8C04, EFAC05ED, 385AEC22, F6F516B3, D4B76470, 915013E9, D45FA86E, C5206B0F, 6C06579C, 4C0D05A5, 9BE1DD7A, 7702A92B, 3DEF5188, E0ED5721, DA205746, 0080AD07, 05EBFE34, 3D27445D, 7D7AA1D2, 44F112A3, 9B64C9A0, 7118C959, 08BD091E, FC7835FF, A1DCDFCC, 1B03A215, 4D2C992A, 9324331B, 0FDE2CB8, C1894A91, B9531DF6, DDC8E5F7, 38A55C64, 59E6FECD, C88B2382, 409BEA93, C48DDAD0, F5F1BAC9, DF4BF5CE, A3909CEF, C43DD3FC, 55D23A85, A035A0DA, 5074190B, CA9233E8, D980FA01, 85DCF0A6, 96C93AE7, B94AA694, 0E02353D, 4D577132, D1649E83, AC759800, D261E839, 7D876E7E, 29C89FDF, 309C342C, D06FCEF5, 1727F48A, 35415AFB, AFAE6718, C53B6571, 3998CF56, 47C0ABD7, C0AEDCC4, D54FE7AD, 486A8AE2, 187A2E73, C61F0130, E8B051A9, DDAA732E, 143F3ECF, 072B005C, CA935F65, 94EE943A, 799AF8EB, 2F95C648, 88DF8CE1, 7B21BA06, 1AAE38C7, E264FEF4, 4F67161D, AF0F7092, 60CB9A63, CB4D1660, BAE3F719, 7EB003DE, EDD379BF, 5ADD388C, 5FB3EBD5, 0D347FEA, F74FF2DB, 196B5178, 00547051, 4DD2B0B6, 3750E1B7, 3CC00D24, AF9EC08D, DF512242, 0F07E253, EC82D790, DAC3D889, 1453208E, 372450AF, 6165DCBC, F7087445, 3464B79A, 19EF48CB, CB1208A8, 4F410FC1, C1C6B366, B327A6A7, A8D30754, 2D0DE6FD, 4FFA9FF2, 919E0643, 010344C0, 59D6F5F9, 370EC93E, 5690C39F, A337ECEC, B387F8B5, 2FAA3B4A, CEC7FABB, 612CEBD8, 510C6B31, A3D8C216, 81718797, EA70ED84, 728B896D, 4096E9A2, 50BD0633, B6D15DF0, 39644F69, 141DFDEE, 8837D28F, 2B86691C, E3E97925, 44F00AFA, 74E908AB, E71EFB08, 08DD82A1, 2DA3DCC6, 632D8487, E02CBFB4, 0EAEA7DD, 6970FF52, 9E53E223, C2B02320, DA72E4D9, 1D7BBE9E, CDF87D7F, B844514C, 72A3F595, 8AE126AA, CD21729B, 870B3638, 119B5611, B5830376, D71A9D77, B3597DE4, E3CE424D, AB93E102, A6119A13, 10229450, 6DC9B649, B9E30B4E, DF71C46F, EA24A57C, 55EE6E05, 98E88E5A, EA00388B, B9D49D68, 0DECE581, 5E913626, 09B7D267, 080A2814, 980158BD, C0CA8EB2, 5D652E03, F16BB180, 63EFC3B9, F4CEE3FE, 1A02A75F, 749A65AC, FFBFE275, 3731420A, 1FD45A7B, 771E3098, 183930F1, C8A974D6, C5442357, 2D11BE44, 051EEB2D, EBA00862, 737D9DF3, 4F8E7AB0, DD2C0D29, 2E7A48AE, 70CA264F, 4DD891DC, CDCF52E5, 0EA641BA, F4ACD86B, 654AEFC8, 32A73861, C066BF86, 61BE9047, 4C034074, A8BDF99D, A75F4E12, 4149E9E3, DA4DEFE0, 19859299, CBE0395E, 5CA7413F, DED22A0C, 7993BF55, 58F28D6A, 1058B25B, 097DDAF8, B71DFBD1, EF241636, B4E61937, 9931AEA4, 1435840D, 58135FC2, B97911D3, 382D1110, E8C35409, E6BBB60E, CC38F82F, 333A2E3C, 884427C5, 9081251A, 2C66E84B, F799F228, C7447B41, 8AFC78E6, 0239BE27, 83B008D4, 5C9C8A7D, FA873D72, 587A15C3, 366EDE40, 1A6C5179, FD87BEBE, 13DE4B1F, 29839E6C, BAD78C35, 207D08CA, 04267A3B, 02423558, BC81B6B1, 06CAE796, EAF87F17, E5514F04, 8ACA0CED, D445E722, 147BF5B3, F9165770, EDC78AE9, A37F536E, DDB63A0F, A2E17A9C, 7E04ECA5, 14D1387A, 44A6682B, 6AD9A488, 97FCAE21, C22A6246, 5E215C07, 32A88134, 0B550B5D, 239A5CD2, 4D6DB1A3, 2AE67CA0, 81DC0059, 309D741E, 199FC4FF, B346C2CC, 5A434915, CA28B42A, 7CB5B21B, 11833FB8, 729C6191, B975E8F6, 887354F7, AB089F64, 1E9485CD, CF8F9E82, BCFE4993, 2D624DD0, 4570B1C9, 719D20CE, ED39EBEF, D16676FC, 63C9A185, 9DEE7BDA, 0CE3580B, A52206E8, ED07D101, 35C87BA6, C46D69E7, 8884A994, 489F7C3D, 17F0AC32, 669CBD83, 48CCCB00, 670C9F39, 57F9597E, A3E3AEDF, 06B3972C, AA8EF5F5, 9E4D8F8A, 177E59FB, D358FA18, 9FA5FC71, 7CFD1A56, 8A4E9AD7, 2FEF9FC4, C14CEEAD, 454885E2, 87780D73, DC28F430, 44F6C8A9, A9ED1E2E, 9EBC0DCF, 1F61235C, AA4A4665, 3A30EF3A, 7095B7EB, 788B1948, 8A9DE3E1, 81AEC506, 6015E7C7, 60DC81F4, E433DD1D, 58E22B92, 867F3963, 8D39C960, DD362E19, B2736EDE, 44A208BF, DA621B8C, BA7292D5, F1439AEA, 8DF871DB, CFDB6478, 85D68751, 93387BB6, C98250B7, 659E5024, A0AB478D, BCC89D42, E4614153, 78824A90, 3D91CF89, F1474B8E, F2349FAF, 19697FBC, 7E3EDB45, 03F0929A, 773587CB, A32CDBA8, B0F6E6C1, 0DB53E66, 3812D5A7, 43480A54, E9CA2DFD, F3C6DAF2, 2B8D2543, 614577C0, F390ACF9, CAE3B43E, E9D2D29F, 10EA4FEC, 54A61FB5, 2362D64A, B59BF9BB, 7B227ED8, E3660231, 0A000D16, FB067697, E9ACB084, 2667906D, 4967E4A2, E031E533, E18650F0, 7C79C669, 3883A8EE, 439BA18F, 78178C1C, C85F6025, 218565FA, 443AC7AB, CF1F4E08, 1C4AD9A1, 0DB3E7C6, 2F5C3387, 635F42B4, A11A6EDD, 81F6BA52, 703E8123, 9A07D620, B5541BD9, 7822299E, DD6E0C7F, B8E4344C, FFE19C95, A10341AA, 7FE0F19B, 35464938, F28C6D11, BB2BCE76, AFD30C77, 05B2C0E4, F839C94D, 8A7E5C02, 2361F913, 624D0750, 4AE6AD49, BC7A364E, 4AE9136F, 2003487C, 2D63D505, C547695A, 171D778B, 927A7068, 04D1BC81, 8182C126, 04EA0167, A0BA2B14, 8DDC9FBD, 28C9C9B2, 0B0B4D03, 7898E480, 29B87AB9, DD06CEFE, C56BB65F, 0CE7C8AC, FEDD0975, E27CDD0A, FA3F597B, 4A5EC398, 6981C7F1, 4C93BFD6, 54E01257, AF488144, F7D9F22D, AB640362, F2697CF3, B1EE6DB0, EE108429, 0602F3AE, 1C14F54F, 21C4B4DC, 0E0439E5, 2D8E9CBA, 4B55976B, 6F5642C8, 1EC38F61, 34F9CA86, 53B43F47, 86F0C374, 6FC8C09D, 99980912, 4E6B88E3, AA10A2E0, 53F5C999, 6869A45E, A3C3D03F, 738D0D0C, 50506655, 6C27A86A, 4E2F315B, F283EDF8, 7A7E12D1, 300FE136, 33258837, 8805F1A4, 43000B0D, 6370DAC2, 2DC070D3, F3828410, A72F4B09, E9F5E10E, 2717472F, B9F3D13C, 86F88EC5, A4B3001A, 585B274B, D3CAC528, 9A585241, BFF103E6, 92B2ED27, 4D9B0BD4, 4296D17D, 11B97872, 28D734C3, 47871140, 33440879, D522A9BE, D66E5A1F, 7F6C016C, AEF3B335, CE5BA3CA, C128793B, 51CDC858, D3B94DB1, A3783296, 6F9B6E17, DD831204, 336413ED, F5FCE222, 51DED4B3, B6214A70, B37B01E9, 892AFE6E, 37E8090F, 51289D9C, 70F8D3A5, 810C937A, D1A6272B, 19EFF788, 23C80521, 86406D46] -> LCG
[7D17504D, 9FED269B, 939C3D03, C8FCFA6C, 0FAE4E06, F9816896, 8B872680, A4878206, D92436EE, 2B133084, 9912A040, 011D96D6, F976435D, 4B53DBE7, 474F626D, AA09E774, E12E35C3, 347746E2, 0817160B, EDC0623A, 7DD0D26C, F31ECB62, 43093C44, AD3657AD, 568EB3D5, 53CE27BD, 592FDA9C, 46BB652B, 65886632, 475956F1, 60859FBC, FD8A3CBA, DB156CCF, 56764782, 1A424A8F, B681CA91, C682BB9A, 222CBE9F, 2A329E67, 925F0CF2, 41D22B48, 064DBDAB, B832DAA3, D26069CB, 023890A4, 69F3D5AD, 473AFDF2, 96C5EAEF, 50BEF523, A7171C24, 3752B059, 8E79B6CE, 29C95DCF, 362092EE, 94523C0B, D7DE2789, B49A3F98, 861F7C07, 83A8BAAB, A56C2738, C06FAAF2, BDED09BC, 7B568148, BFC73CFD, 024229CD, D73760D0, 18A4E7BF, 9E021082, 8D1D4ECE, E1408E5D, DEE614D5, 50EE898B, 37E2D666, D23584A1, 3C9B628E, 181D1647, 396DA2C4, 470339C4, A06BACB8, 503439DC, 041BCA9C, 5A881EC2, A77B7747, 567040AD, 8CE52FD5, 96814E85, EA3CD25D, 3E9D929F, 9BA3891E, 07CA0989, 0B689D17, D9B3FF8F, 5EDF76DE, 090EBACD, 46C11EDE, 00C8DE0E, A504314F, D9A02FF0, 97D9EDF4, D1A769AF, 55ADB49D, 8DAACE77, D544247B, 3F44C56D, 07759744, DC7738AB, 28E4B8A2, 31927F7E, 9AF601BF, FF21C02A, F20D56C4, 50C6AE74, 7A17A62A, 8BC619D2, 13E5C518, 76357C1E, B1D4A204, 0A673565, 3797FC34, EA9FA354, FE4FF881, CDB03630, 454E05EE, 52DC8B10, D3D6FA3A, 9F9B57C6, AACF50AE, 1CFDCAEC, 789EE463, 3DFEA9D1, ED64C4E0, 1F3CD90A, 900E9B72, 58761883, 93FE94A9, 6AF3FB55, 8EC22872, 66988B29, 01A4008F, F4787ABD, 6B665DF8, C905527E, E88493A9, DF1EB196, 86CEBE10, 65BB9A15, A96E54D0, 83D6D26A, 701BC23E, C9C9951A, 12DA9027, 27AA5594, 890E696D, 0CEA5C13, CA77AE01, BF04442E, 45BB17A2, 1BEFD1C2, 6C9F7318, F1276F91, 6CBC7010, 09B8DD84, 9E286818, 54B9C7AB, DB0A01DC, 1491B3C4, C92471E6, 533A73F6, D8B59CAC, 41231BED, AB62F96E, 2B478A37, 5F63230F, 06C6A77D, BAD38742, ADD2B41D, EBEF81F3, D8212EBC, FEEE4B6D, C6A47AF1, 51D39BCF, 80560B87, 0C6F8DC3, E9F90D4D, 2439FE5E, 1403C36D, 647255BB, 45C0AF1D, AEE062F5, A4F2C4EF, 52DB8247, 12237746, BF79483D, 8D9E3681, 03D954CF, 0A498AB5, 7F041361, 0352083E, CAE45BB7, 8CBE7C7C, D37EE991, 40FE1838, A82FCA73, D70D1E96, F31B5787, 4394AE04, 953E8857, 2A78CDC8, 03F6006F, E5F46A9B, 84E93A42, 6813B19A, DB55318F, 9DB338CC, 50453A12, A52FCEE1, D7844A82, D3F57DE6, AA195820, 719AD344, 84BF57AF, FCDD1093, 9C658F70, 3BC26F4B, 45BE45B3, 51F39C1F, E15D875E, C9CD1409, 7EE9435E, B3373BF8, BE5D3DB7, 1F911B29, 2B565836, 21B44E5F, 76537F5B, E18C6AEB, 78820904, FBC776FD, 16836779, 94DA8C70, FC787DC6, 3CC88C2A, 317D9C65, 71842F36, 4E2DFA8D, 36FC86BE, EBBFAAB0, BB12D56E, 9ACAA913, 48D10582, 5E2DCC02, 73B9DB0C, BCF46659, 7CC99950, 4CB40717, F168D436, EEB1A2EC, DE82A573, 32E28D0B, 859C2605, E6595298, 2D3BDA1D, 0B978064, 6F5F231D, 43BE71FC, B0A6A0A4, 07858274, 91540E52, 21D5BC15, A4F39B0B, 8F4E3BC3, BE5992E6, 32E0A42C, 0AF34AB8, F49DF806, 86218AD1, B1D79FFD, 21E1A5F5, 3AA73407, B05A4680, BD7F0F01, 919DDB56, 9299C26E, F095F8FB, B5D7E6EF, CAEFDC68, 9639FDE9, C9349DF5, C3DEFAA2, 7766722D, 2EE91F9D, 435FF480, 77601DA3, 33D3FE78, 55A01A68, E9E71FA8, 9E1D8A32, 329187B7, 67B7A8D7, B67CE1D6, C442A131, 7A502A31, A07BC4BC, F158F334, 20C28F07, DB38288C, A5184973, 93EFCFB7, A761D07A, BD07F052, DA336550, 374C9BD6, 9E077F45, 1C0089B7, 5D587682, 0E99C4D4, ABC16F15, B39406EB, 2DE69A7D, ED994471, 4D802710, 5E30D315, 471C9FDC, 6081E182, 2C75F225, F40524C5, 5744A7E6, 38A6D17D, BBC1E896, 663FD027, 14363091, 1A152653, AE24F8DF, 3602BBD4, 9315B73D, 20813CB2, A9EADA7D, 8A15088F, B487EAAF, 9DCA3421, 620C2CD7, 407F0169, CB26495B, 07810722, 04E8F991, BC24C42C, 45B12E62, 4A0689E1, 0961D541, 93FE75E5, 5FF09BC6, 21C75858, 260B4AFC, 463A4285, 9DCFCF2F, 86D14156, FAF1A7DA, 6E4BFC6B, 8D1EF03A, 81C9CB3E, F67163AA, C7E871AB, BD0DD64C, 72526AE8, 0F433B3B, 8BA27651, 58CE6EDF, B92A4A04, AFA624F9, 372EDFA2, 1CBDF70E, F72CE4F7, 69339707, 28A1864C, DB5701D1, 4BCC4D10, BEB260C1, 9A0502BD, F93FC1A5, D0B2B75F, FD2B71E0, 4F899412, 48BC46AF, 0DF108A8, ABF3DC87, A8D9E4EF, 02FA4665, 87CBBADA, B2E95940, D5702D6E, 056990CB, DFAEE7D6, 2775863A, 733AC4E7, 3A9CED83, 92A42D51, 196B2D69, BCD3CF5F, 61FEDDB3, D283BA78, 92C3C524, B0484914, 27CC09EB, E8532710, 643535DB, 96C7D0A0, D10310C2, A019C655, 6D4FA460, C5A53BB9, 0CE9A6CF, 62ACE269, 72D026F8, 9E44A3E8, DFDAB131, DA60BF09, 2974A55B, 9294187E, 98CD6024, 478A1CC3, CB583714, F93D91E9, 0A0202AA, 1D796B2D, 17931F01, 023476C3, 1839337D, CECF1354, 412B769B, E0089213, 317BF7B4, 8798177C, 9D1D36BA, 3921B700, D70921C7, 906DEFAD, E4B1B3FC, D01C81DD, 4E858500, B16A1BFA, D82D7078, EC0B10C9, 8EC425CD, 6F904A24, DC8D591E, 68B4971E, C7F13D88, 2ADD8E38, 9C2E67D4, 50EE1F28, 1EBD75C0, D8D79461, 37285868, 171F16FA, E2F972AC, 86E9860E, F37765A3, 1C3015F1, 357568C9, FF66419F, B77479AD, 2B776D2F, B5DA7BA8, 787DBE35, 6CD01986, FC5E1F26, 9A3F3C3E, 0F26B55A, E3D68111, EF7D1562, 8CC01A7F, B676E2D8, E1FF230E, E62EEC56, 6AB1010E, 6BD04EA2, 732FF785, E2F2E9EA, 00A93DCB, E9E5C622, E57A9744, 90B28FB8, D9BCBF00, 1EAFA6C3, 2F5ED2E5, 2B9557F9, 17EDA934, 74178CB4, AD07B129, 2CAC11EF, 5672B947, 9EC8ED11, 0ED68918, 42B9C244, 81C2F3D5, 58BB2699, E29FFADF, 6EB8AF2A, F872A573, 797CDB0A, 64289FF8, CF42ADA8, A276D00E, 3D4DEBC1, 1DBA64CF, C74FA53D, D3ADEB7A, 81EC012D, 4FBE91C3, F562B344, 492860A9, A82CE5C8, 13A74987, F3BF2024, F9983BD2, 3655838C, 1F971FB0, 1523A266, 2D5D4DBB, B78EE27F, 104301A1, 187BA15D, DF8C077C, 1FD19BE8, 1797DFBA, D223E55C, 6D2BAF83, FEB67715, 57750D76, 9AB10BC1, AAD6F8A3, E7953C33, 1874830A, 0A896CC6, 17879ED4, 59BD4CB3, E56DF85D, A4C3576A, 8F990C18, 3CF2118C, B6D7A95F, 0811C0E8, 4FAFF43E, E37DF236, E8EB2257, 6E7BA922, 5E45AED7, 52A50B6B, E3ED62F2, 506CF514, 232CDAD8, 59A87385, D1DA70B0, E629FBCA, A39607CD, B9B87C61, BBE5C416, 12BB8F0B, 01004AFE, 7B2165CB, EE71DBCD, 207CD2DF, 23283B94, 53570D07, 33981B13, F5B4DD95, 9722AC2C, 7CF6B4FA, 8F4578F4, DC4E44FC, 5E8FD095, 9717EEDA, 3331A614, 9DF66D2A, BDDD0D79, 95944526, 2B2B5086, 059AF7F4, 507984FB, 67F346A7, 162D85BF, C4DAF5D9, 5818EFE5, A5235C3F, DF593559, CC3E6756, 53C6DEF3, ECBBB210, FA5EA123, C5656DE9, A03102F0, 912B0FD4, 9E73F36B, 7097CF69, 58996509, 91059461, 90ECC581, 5ECEBC72, CDEC2B8F, 70F708CF, 86C10B9D, ADC71A1B, 01DBEC7F, C9A22DFB, 47B14AB1, D233979E, 0C5521B3, D4401837, 196924CC, 57A8CF18, F25524E7, 26001B3A, 761F1472, 67DEC5A6, 3CF7A7A6, 1A08B2C9, 943A897E, 05589DAA, 8413C030, DBD2B481, 9BE3A7FC, 5A97CCE7, 409F95C5, 0EA757EB, 88FDCD84] -> Xorshift
[4BB6DADF, 8EEF8EA3, 06E8FD49, 88A2AF49, E3269CD4, ECA4F09A, 3ADC8EFB, AA4DD059, AC3B1AAE, DA22C244, B67C2EC6, DFD9C12F, B4A6DBAF, 354C372C, 2C6CA407, 0AC93693, 725C7716, B439DF25, 7C04626F, 67824F17, 21EE364D, 77D8D72F, 4BF90371, 7BC3C716, 472A4204, B842AEFE, 38270462, 3B17B189, 22760085, 2A801D85, 8DE334B5, A72580F7, F187AA9B, 2E04DC0C, 8A701C0D, 471B61E6, 98F859D9, 9EBC2F45, 02544E96, C2785B15, 20623FAB, 8001F9B4, 0E438545, CFA2A2A5, 9DA35720, BAA84901, 908758C8, FCF5557F, F905B3B4, BE7DEBCD, FED08B1E, 7E9472CB, AC3A29C1, 5BED194F, B6932F25, 1C95E32D, 67E94371, D7CCB4CE, DF296D87, 6AAEF0F6, 8CFFF867, 093F9F79, FB280F6C, DE7735A8, 684C17B5, A0DA757E, 374EC162, 1764A62D, 82C244F6, 9E4583C7, 56F02388, 0018E400, 815A0F1E, FD80C932, 30EDD175, D37AF8D8, 7C8E4633, 7D8E4E5D, 660A7F79, 4C2C08BD, B6656A5B, CCFD6607, B0AA17FA, 060EE305, DEE9752F, B38BE439, F04EB964, D4E6C330, DCD4F7AB, DF7D83BF, 309047C6, 51FFC819, 9E59C7D6, 46821973, 01B47792, F800809B, 6050BB64, C13CB495, A305F788, 7AD27279, B7F9151F, 9F154C4F, D3F688F1, FF830866, A9C059A3, FFBF160E, EA8D827A, 1F1DA6E8, FDC52EFC, 5325CE11, 765B86EB, A852DC5C, 74ADAF62, 45BFACA5, 8E1FF6C3, 83ADCF0A, 91D6626E, 316008CC, 0DAD4110, C28EA37D, 5F077B03, AF70C5E3, 13A7C50C, 0A737B9D, E236FCBB, DDADB0C5, F4CAA3C8, 73679470, 87AE2E8E, EAA6ADA4, F30CCA79, 2B2FED65, 9B55A25D, 7317A6DB, D505929C, 0F90C693, 5CED397C, C1CB0AB9, C81895F1, 828D68BF, C2D0D855, 70585D86, 1ACD41B1, D8227B76, 1CB6DD69, B71EF185, 3EB11656, 6674378A, BA543682, 895A464E, B9E6CC48, FDAB6657, AB815F3B, A717AF55, 5826ABAB, 7CAF7DA1, 33EB26C0, 9367A48F, 32334888, 6BD35F76, 21F56A13, B7E72B51, 2B110FC2, A7A6ED6F, 1B2E72D1, 855EC1F3, A320F92E, 05609603, 5AA26082, 937BB417, F7A082EF, 370690A8, 074B4C00, EFB2EF14, A449B9F8, 9AA7E8A8, 3AEC4108, E5DDDB2A, C2CC4D30, 8589EB3D, 030ED83E, 4230E9B3, 619B03C0, E2B2BB64, 839A7C40, 2527B162, D03987D6, F8D66424, B950968F, F41E4D21, 9BAEEC89, DB8C65CD, D19F0371, 42507672, F133D6DC, 8FF10301, 6267E094, 339A1D5D, 3DD9DDE3, 139AA839, 440F8A94, 5E10CEAF, 60A1BA78, 02576968, 9AE7D81E, B9BF647E, F1698EC1, 5EC4890B, 88CF1A87, 9F3442AD, 4ED7DB9A, 08BD20C4, DA4B2F8E, 7EE018A9, 41968817, 519BE32C, 26CC3EFD, 1C3CBCBB, 551FC090, D06676D9, 02BF4E3F, 5B331917, AA121020, 840B84DD, 1C04DB26, 42DC049A, 58E92781, 95DA8984, CEDFF185, 149A43E5, 9B4CAAE7, 9E61CFFC, C33F9485, 2ABFE975, 75F8E915, 167D7A60, 1086ABF9, FE0B87DC, 095EFA20, 79FC720C, 99DB743E, 8F4B2F19, 00A9188A, B5DE7C2D, DAF3734B, CCAD1F47, 0C9DB549, 0158D55C, BCD5F151, 72A210D9, ABB80C09, 99934B39, F92DF281, A35193BD, C3CB4E8B, 322DBEE4, 26E2E30D, 36F25EDD, F1C8C5DC, 44B5C836, 878075ED, 1140849C, DEBA2848, 6B8D4AD7, 0209883A, AEFFDC8B, F7862944, F2CAE4AB, 77A1EB21, C77D6350, 4749AA23, 1ECDFD3C, 55D6943C, FC9B102A, 80363E80, C28E5369, 7E4BDC16, 8DDD321E, 46E4B844, 71169596, 6EC788CA, 508E25D4, A3249379, C5493848, 67ECFFDB, F6B03518, D4FE2A7D, D6C8D739, 7A93EC17, 84E2A797, 08CB6F22, D09D5BFF, 7FF783FD, 749A4AA7, 9EE69739, 01BB87ED, CDB15087, 32FE625F, 3C8E72C6, 2386A26E, 0F243847, F9E50890, D10F1EC5, 6E1C032D, CE27B59B, 84F2447B, 62AFD23B, 2361B77C, 1532E2F5, BC65F691, D8106771, BC9F8553, 94B67790, CE7F4B32, E36DAA85, D42336C1, 414ABF42, F5D5E7FA, B17620A4, D42A5D6C, E1118425, 17C4B3F2, EBDCB06E, 1F8F7F65, 0AD89423, 32848E5D, 0A5028D0, 463B71B1, E896017F, C1DA750C, DB89FC54, AF665A17, 11F5A446, 45F2DD58, 9C66340A, F4DB1D19, 87AFFD89, 75CA495D, DE608110, 78EC9F5C, 7840FE7C, 6F4DA231, 1CF2E830, CD521794, CE4F5EBA, 79B79437, 5A91D18E, 95F1D139, D9CA1102, E3822EB3, F7C52D20, F917AEEE, 5EDCD7BF, 4BD3725C, 94EE3441, 713CF5DF, 937E1AA9, 08926562, 084E8DD4, 41100547, 1C706FF6, 2ED60298, 0D2E30BA, 82FECB1F, 831BCCE8, 0CB829DB, 0C522998, E0AD92F6, F8969EA4, 386650CD, CA41F763, 7BB34065, D79B9F81, 967FBB17, 7C2F61B2, 7B4E9B33, 8359EDDA, 3201D25E, 5F41BAA6, D94A1FD8, 6E29F112, EDB7885C, C4F4380D, DAD428C7, 40609A88, 66DF9A6C, D61B84E4, C4C77436, D6F4B201, 1C0AD2D4, 3A69D216, 1DD70F43, C887E79C, 8579D94E, F2D069EA, 17B4926F, 55BE153C, A783F442, C03D53D2, 5ED56627, C114DB61, 9B0BFD2C, 825DDE34, 97523F35, EE476E00, EB2ED50C, 567BB078, 9B70520D, DC96668B, FCFD7253, 0197E3F8, 7785825E, 0B00322C, B510F809, 51FB92EE, B6F7D331, 2DE0AC32, 00B41A7B, A432B1FE, 94ED9578, 4B56F086, F8BEADE1, 8C899DF2, EAB17808, 240BF736, 7CBA75E0, E06E352C, 3BBD94E5, 427CB86A, 31CB345E, C1226EE3, F9F4697B, 8820CBB6, C3F9BB4C, 509D403F, 03990E8E, 6C5CCD8B, 24F235C0, C5FC6E59, 05E627C9, 4B0C0C96, 45A35E8E, BBF14335, 89B957A1, 3E272204, EC501927, 00ADCBC3, 13DC9199, A682B338, BE42D97C, F97E0F28, 8C1A6128, 76ED6951, D7D8B74F, 80A6C9D2, 87111413, 48268EB5, 69DDA6F7, 8900B2E1, DBF809E0, D50D7B42, 9716581E, A7AE9B6E, 52366624, 85BAF9A3, DE28F70A, 890E37EC, 7F82541D, 9BA2C144, 8766E737, EA8B0E73, 6BC46E1A, 04A2D3E8, F01716BB, 3D0F7338, 93282BAA, 3A9E51C0, 7B26AFBD, FA2B6A90, 36DD5832, 18161A71, FDE783A2, FF84185B, C251868E, 957CA33D, 6D2BD402, F7E61B15, BAAD0068, 8413463A, 63F0F132, 55FBBC6A, 58E3298D, 845AA664, 02D242A7, A456CEED, 2C198D04, 89A25422, 3A4CABFB, 9D24D792, DFBB850F, 76E30332, 58B59723, 1B1A6913, 9FB961E8, B363CA07, 9CC01B66, 00E9E1DF, 9AF48078, F67167D2, 5D8EBE54, F0819D2D, A003D04B, BD20E32A, 7647BD73, DE509593, E381BF67, BB5D56E0, 675636A1, 983C7C47, C7D92CF8, 335F0477, A6EE6787, F2A67D0E, 29D7F83A, 3DA85C1F, 8E31E016, 5FBEB7EA, 01F017A9, 021B93ED, 8E2AE731, 3391B82D, 6AFEC318, C1E9610D, B50DE358, 46E16C1F, D7A03E8A, 74E52044, 4797BCBC, 49FC24BC, 119F71CB, 51ADB9AC, 1F7A8641, 373911A6, 79424584, 2D69A297, 32859E0B, FF812B02, 2060307E, 6AD9173E, AFCB84DA, 4F5B70D0, 34A63D93, 6DBD6388, BBD76CFA, 94EE5483, 20214C3F, E45B9B77, 8B3192D9, 109D8CE6, 8EBA320B, 53FA8CE2, 56A4A45A, 61AB8FDB, 3ABFD0EB, F92E5F91, 3CBA25FE, C2E19318, 2E5DC1D6, 751C25DB, 572BBA47, DF53AB19, 407F623F, EB9E4EE6, C98E9BFD, DA77A48F, 79D4B4D2, E4320563, 2C1C4BA4, CDCCD4A9, 5B74662F, 3B74B8C1, B1792883, 88D53BDA, FDFAB951, D2D3F844, 199D47E1, 7500E432, B0C714BD, EC5CCDCB, EC949808, 9B39D67F, 15D138B8, 17FE54A4, AD28C768, FE473BF7, AE29CB10, C987A478, EE50D094, 10ED5447, E2BF7CCF, BDD93708, D57E6C1B, 01079D4B, 6C6C547F, 363A37F3, 6D4D828A, EE1622DE, AF1D8240, B068E4C1, 9C5901F8, 17822119, 3C7837B0, DEFFD993, 28FA9C3A, EAADDC4E, 05705400, 0046CB17, E843346D, 2F33C418, AF1A47BD, E4C12B9E, BC3F9B15, 01E90C74, DE0C8A00, 5D52587A] -> MT

A great question !

Jelly, 23 bytes
^Ḋṫ4^^æ«11$æ»31ż&2\ḂS<4

Takes an array of integers; returns [0, 1] for LCG, [1, 0] for Xorshift, and [0, 0] for MT.
Try it online! (The permalink might be too long for some browsers.)
Background
The most random thing about the LCG is that it is considered a PRNG. For starters, the lower k bits of the state aren't affected by the higher 32 - k bits, making it an exceptionally poor choice for most applications. In particular, the LSB of an updated state is only affected by the LSB of the previous one, and since 1103515245 and 12345 are both odd, the generated numbers will follow an even-odd-even-odd pattern.
The flaws of Xorshift are more subtle, but the generated bits still follow simple linear equations. Given five consecutive generated words wk, wk+1, wk+2, wk+3, wk+4, the (non-linear equation)
wk+4 = wk+3 ⊕ wk+3 >> 19 ⊕ wk ⊕ wk ≪ 11 ⊕ (wk ⊕ wk ≪ 11) ≫ 8 holds by definition. If we enumerate the bits of the words (0 being the lowest, 31 being the highest), we can observe that the (linear) equation wk,20 ⊕ wk,31 ⊕wk+3,31 ⊕ wk+4,31 = 0 holds. To verify this, it suffices to observe that words that have been shifted to the right cannot affect wk+4,31, the most significant bit of wk+4.
That leaves the Mersenne Twister. While there are better (faster, less biased, or both) PRNGs, identifying data generated by MT19937 is a lot more complicated than it was with LCG and Xorshift. Fortunately, we don't have to. If the data doesn't fit any of the two previous patterns, it was generated by the Mersenne Twister.
How it works
^Ḋṫ4^^æ«11$æ»31ż&2\ḂS<4  Main link. Argument: A (array of integers)

 Ḋ                       Dequeue; drop the first integer.
^                        XOR the k-th element of A with the k-th element of the
                         previous result, effectively computing the XOR of all
                         neighboring integers in A.
  ṫ4                     Tail; drop the first three elements of the result.
    ^                    XOR the remaining integers with the corr. integers in A.
      æ«11$              Yield the integers in A, shifted 11 times to the left.
     ^                   XOR the results to both sides.
           æ»31          Shift all results 31 times to the right.
                &2\      Yield A, pairwise reduced by bitwise AND.
               ż         Zip the results to both sides.
                   Ḃ     Bit; compute their parities.
                    S    Sum; add the parities of the results left and right to ż.
                     <4  Compare the sums with 4.
                         This is necessary since A and the various modifications
                         with dropped elements have different lengths, which
                         introduces a few garbage values.

^Ḋṫ4^^ Why do I see too much repetition here? I smell something, but I'm not sure if there is a shorter way than XOR [...] XOR XOR.

Out of curiosity, what would the solution look like if you had to identify MT19337 sequences (perhaps if the input wasn't required to be generated from one of the three PRNGs)?

@Mego A lot more complicated. I might actually have to implement MT19937.

I'd be interested in seeing such a solution, if you're interested in writing it. When I was originally writing the challenge, I considered having the input possibly match none of the three PRNGs (which would require validating against all three, rather than just two). However, I decided not to include that possibility as I worried it would make the challenge too difficult.


text:
Count down from "Infinity"
Seems like an impossible task right? Well, it's actually not that hard. If we write the word Infinity as 8-bit binary ASCII code, we'll get:
01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

This can be concatenated, and converted to the decimal value 5291279215216915577. Now that's a number we can work with...
The way you'll count down is:

Output the original string as a decimal number (as shown above)
Remove leading 0s in its binary representation (if any)
Toggle the bits in the binary representation (1->0, 0->1)
Output the number in decimal
Repeat steps 2-4 as until you reach 0.

Challenge:
Create a program or function that takes a string as input, and outputs (on any suitable format) the numbers you'll get when performing the procedure above.
Test case:
I think the challenge will be fairly easy to understand, even though it's only one test case. I'll use Inf instead of Infinity to keep this fairly short.
Inf
4812390  (10010010110111001100110)
3576217  ( 1101101001000110011001)
618086   (   10010110111001100110)
430489   (    1101001000110011001)
93798    (      10110111001100110)
37273    (       1001000110011001)
28262    (        110111001100110)
4505     (          1000110011001)
3686     (           111001100110)
409      (              110011001)
102      (                1100110)
25       (                  11001)
6        (                    110)
1        (                      1)
0        (                      0)

Input: Inf
Output:
4812390, 3576217, 618086, 430489, 93798, 37273, 28262, 4505, 3686, 409, 102, 25, 6, 1, 0

Input: Infinity
Output:
5291279215216915577, 3932092821637860230, 679593196789527673, 473328307817319302, 103132444486104185, 40982743589751686, 31074850448176249, 4953946570787718, 4053252683953273, 450346943417222, 112603010004089, 28134478351238, 7049893737593, 1746199284614, 452823970937, 96931842950, 40507110521, 28212366214, 6147372153, 2442562438, 1852404857, 295078790, 241792121, 26643334, 6911097, 1477510, 619641, 428934, 95353, 35718, 29817, 2950, 1145, 902, 121, 6, 1, 0

Your code must support strings that can be represented as a binary number up to the limit of your language. All strings will only contain printable ASCII-characters from 32-126 (space to tilde).

Leaderboard

var QUESTION_ID=98274,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Chuck Norris, 8 bytes: Inf:-1:0

@LuisMendo Chuck Norris' NARS-APL: ∞..0

@LuisMendo Are you sure you don't mean Jon Skeet?

Jelly, 15 10 bytes
-5 bytes thanks to @Dennis (convert directly from base 256 after ordinal cast)
Oḅ⁹µBCḄµÐĿ

TryItOnline!
How?
Oḅ⁹µBCḄµÐĿ - Main link: s                     e.g. "Inf"
O          - cast to ordinals                 e.g. [73,110,102]
 ḅ⁹        - convert from base 256 to integer e.g. 4812390
   µ   µ   - monadic chain separations
    B      -     convert to binary
     C     -     complement
      Ḅ    -     convert to integer
        ÐĿ - loop until no longer unique and collect results

The first part is just Oḅ⁹.

Oh my, how did I miss that?!

Python 2, 89 82 77 76 75 bytes
n=0
for c in input():n=n<<8|ord(c)
while 1:print n;n^=2**n.bit_length()-n/n

Test it on Ideone.
How it works
After initializing n to 0, the second line performs the string-to-integer conversion specified in the challenges as follows.
In each step, n is shifted 8 units to the left, then bitwise OR-ed with the the code point of the next character c. For input Inf, this goes as follows.
n                                  0
a = n<<8                           0
b = 'I'                      1001001
n = a ^ b                    1001001
a = n<<8             100100100000000
b = 'n'                      1101110
n = a ^ b            100100101101110
a = n<<8     10010010110111000000000
b = 'f'                      1100110
n = a ^ b    10010010110111001100110

Now we're ready to generate the output. To invert the bits of n, we proceed as follows.
First, we compute the bits in n's binary representation without leading zeroes. Let's call the result k. Then, we compute the kk power of 2, which has k+1 binary digits: a single 1, followed by k 0's. We subtract 1 from the result, yielding a number composed of k ones, which we then XOR with n to invert its bits. For input inf this goes as follows.
n         4812390   10010010110111001100110
k              23
t = 2**k           100000000000000000000000
t -= 1              11111111111111111111111
n ^= t    3576217    1101101001000110011001
k              22
t = 2**k            10000000000000000000000
t -= 1               1111111111111111111111
n ^= t     618086      10010110111001100110
.
.
.
n               6                       110
k               3
t = 2**k                               1000
t -= 1                                  111
n ^= t          1                         1
k               1
t = 2**k                                 10
t -= 1                                    1
n ^= t          0                         0

On additional hurdle in the implementation is that we have to print n before the first step, after the last step, and in all steps in between. Python doesn't have do-while loops and a single print statement costs 8 bytes, so we do the following instead.
In the straightforward implementation of the update step, i.e.,
while n:print n;n^=2**n.bit_length()-1
print n

we replace the loop with an infinite one (while 1) and compute the 1 in the loop as n/n. This is equivalent while n > 0.
Once n = 0, we stay in the loop, print the state once more, then try to update it. However, 0/0 triggers a ZeroDivisionError, breaking out of the loop and exiting with an error. Note that this causes stray output to STDERR, which is allowed by default.

I love that -n/n trick :-)

Can you explain than n/n trick? It's probably been explained in another answer somewhere but I haven't found it. What does it do here?

@StewieGriffin n/n is 1 until n is 0, then it throws an error and causes the program to stop.

With an error message (I hope)?

@StewieGriffin Indeed. Python is painfully verbose when it comes to error reporting. I've edited my answer to incorporate an explanation.

Nice explanation... Thanks :)

JavaScript, 82 bytes
Saved a byte thanks to @Arnuald

for(y of prompt(n=0))n=n<<8|y.charCodeAt()
for(;alert(n)|n;)for(i=1;i<=n;i*=2)n^=i

One of the very few times when a full program outperforms a function (and ES6 does not outperform ES5)...

The above supports up to 4-letter words. Add 4 bytes to support up to 6-letter words:

for(y of prompt(n=0))n=n*256+y.charCodeAt()
for(;alert(n)|n;n=i-n-1)for(i=1;i<=n;)i*=2

g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0 (-1)

@Titus Thanks! Not sure why I didn't think of that

n<<8|y.charCodeAt() should save a byte. for(;n;)for(i=!alert(n);i<=n;i*=2)n^=i would save another byte, but you won't display 0, which is probably required.

@Arnauld Thanks. I thought about doing n<<8 earlier but decided it wouldn't work because it would break for n with more than 31 bits. I suppose it doesn't matter now that I've already split it between a 31-bit version and a 53-bit version... And sadly, I don't think I can save anything on the alert while alerting both the first iteration and the last.

Actually, 14 bytes
2@├¿W■├♂≈♂Y2@¿

Try it online!
Explanation:
2@├¿W■├♂≈♂Y2@¿
 @├             encode input in binary
2  ¿            convert from binary to decimal
    W           while the number is not 0:
     ■            print the number without popping
      ├           convert number to binary
       ♂≈         convert each character to an int
         ♂Y       boolean negate each int
           2@¿    convert from binary to decimal

05AB1E, 18 bytes
Uses CP-1252 encoding.
Çžz+b€¦J[CÐ,_#bS_J

Try it online!
Explanation
Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join

PHP, 132 126 123 120 108 107 bytes
foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));

printing 0 after loop instead of initial value before loop saves 6 bytes.
unpack instead of str_split renders ord() obsolete -> -3 bytes
underscore _ as separator saves 3.
bindec instead of ltrim to remove leading zeroes: -12
echo in loop body saves 1 byte over print in loop head.

Can't $n=$n*256+$i;for(print$n;$n;) be written as for(print$n=$n*256+$i;$n;)? Since the assignment part will execute once, this should work. And instead of  echo _.$n=[...], you should use echo _,$n=[...] instead. It won't save any byte, but will speed the code a tiny tiny tiny tiny bit and will separate statements. That means that, for example, echo _,$a?5:6; can be written instead of echo _.($a?5:6);. This may be helpful in the future.

@IsmaelMiguel The assignment part is a loop. I actually use the comma when I don´t need the dot; it is a remnant from the print in this case. Alone not worth an edit; but thanks.

Oh, right... It is inside the foreach(unpack("C*",$argv[1])as$i)... Silly me... And yes, changing a period for a comma to have the same effect isn't worth the trouble.

MATL, 13 bytes
8W:qZA`tB~XBt

Try it online!
Explanation
8W:q            % Push array [0 1 ... 255]
    ZA          % Take input string and convert it from the base defined by the
                % alphabet [0 1 ... 255] to decimal
      `         % Do...while
       t        % Duplicate
        B       % Convert to binary
         ~      % Negate
          XB    % Convert to decimal
            t   % Duplicate. Used as loop condition: exit if zero

Mathematica, 99 bytes
a=FromDigits;b=IntegerDigits;NestWhileList[a[1-#~b~2,2]&,a[Join@@b[ToCharacterCode@#,2,8],2],#>0&]&

Anonymous function. Takes a string as input, and returns a list of numbers as output.

Haskell, 109 123 118 102 97 bytes
Thanks to @nimi for saving 5 bytes!
c 0=0
c n=1-mod n 2+2*c(div n 2)
(++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum

Usage: (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"
Guaranteed to work on numbers up to 29 bits by the language, usually works up to 63-bit numbers on 64-bit systems. Use map(fromIntegral.fromEnum) instead (+14 bytes) to support arbitrarily large numbers.
Works for unicode range [0..255]. Recursively flips bits.

You can replace takeWhile(>0) with fst.span(>0). If you go pointfree you can drop the name f, so your main function is (++[0]) ... map fromEnum.

@nimi thanks, dropping the name solves the type inference problem I had with f.

Why fromIntegral? From the challenge: "must support ... up to 63bits ... or the limit of your language", so Int should be fine. If you want to keep it, move it to map, i.e. your old version of foldl1 and map(fromIntegral.fromEnum).

@nimi OP posted a comment here (since deleted), asking if this supported 63 bits, so I assumed that was his intent. Beats me.

Perl, 65 bytes
53 bytes code + 12 for -Mbigint -p.
Thanks to @Dada for saving me 13 bytes!
$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0

Fairly straightforward approach, only different to most of these is that the number is stored as binary and printed out in decimal. I'm sure it can be improved, perhaps with storing details in an array. -Mbigint is a bit inconvenient but necessary.
Usage
echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

Unpack my friend, unpack! perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0' (I have no idea how to use unpack usually, I just got lucky when googling how to convert a string to binary ;-) )

Ahhh, I always forget about unpack the syntax always blows my mind! I'll update, thank you!

There is perlpacktut that should help... I've read the first 10 line dozens of time, but I should really take the time to read the rest!

@Dada I'm sure I've read it many times, it just never stays in... Thanks again -13 is no small feat! I had to switch to echo -n is the only other change.

Pyth, 12 bytes
.usi!MjN2 2C

A program that takes input of a quoted string and prints the result as a list of integers.
Verify all test cases
How it works
.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print

Python 2, 117 115 bytes
Saving 2 bytes thanks to Cyoce.
Assumes input enclosed in quotes, e.g. "Inf"
s=input()
n=sum(ord(s[-i-1])<<i*8for i in range(len(s)))
while n:
 print n;k,m=n,1
 while k:k/=2;m*=2
 n^=m-1
print 0

m counts up to the highest digit, so m-1 is a XOR mask to perform the desired operation. The longest part is converting the input into the initial bit sequence.
Example:
"Inf"
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

"Infinity"
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

You can replace -i-1 with ~i

Python 3, 99 95 bytes
x=int.from_bytes(bytes(input(),'utf-8'),'big')
while x:print(x);x^=2**x.bit_length()-1
print(0)

Main idea is to convert string to bytes to to number. Each iteration print the output and XOR with all 1s to progress towards zero.

You don't need parentheses around 2**x.bit_length()-1. Order of operations for power and subtraction are higher than xor. Also, that while can be on a single line.

Write the while loop on one line (remove the newline and indent)

Try starting the program with P=print and then using P() instead of print()

Ruby, 104 101 100 81 80 65 bytes
19 bytes saved thanks to @WayneConrad!
15 Bytes saved thanks to @philomory!
1 byte saved thanks to @LeeW!
p n=$*[0].unpack('B*')[0].to_i(2)
p n^=2**n.bit_length-1while n>0

Takes input via command line arguments.
Inspired by @JimmyJohnson's Python answer

You may be able to save a few characters by replacing i.to_s(2).rjust 8,'0' with "%08b"%i

Also, I think inject(:+) can be replaced with join

@WayneConrad thanks for the help! Not sure how I forgot about those

Glad I could help!  Thank you for teaching me the #bit_length method, which I didn't know about.

@WayneConrad it's relatively new. I had to install ruby 2.2 to make it work

Using gsub is slightly shorter than using bytes. Also, you can shave a few bytes off by doing this as a function instead of getting command line input.

@LeeW Wrapping it in a ->s{} lambda takes two more bytes. How would I use gsub?

Instead of s.bytes.map{|i|"%08b"%i}.join, you can do s.gsub(/./){|c|"%08b"%c.ord}. It should be a byte shorter.

Switching to unpack followed by [0] rather than messing with gsub will save 11 bytes. Switching to $*[0] instead of gets.chop (using a command line argument instead of console input) will save another 9, first line becomes p n=$*[0].unpack('B*')[0].to_i(2).

Labyrinth, 104 103 bytes
'  )25 }_';:_';_2/;{
''', 6 2 1   1   { (
 ' | / _ _   _}*2_ $
 * _ :!\ }2_\     !:
 652       @'''''''

Try it Online!
Explanation:

The instruction pointer starts at the top-left most non-wall character (walls include spaces and any letter except v).
Orange:
This loop gets the input one character at a time as an ASCII code, adding it to the current value and multiplying the current value by 256.

' No-op
, Push the ascii code of the next input char to the top of the stack or -1 if EOF. At this point if input was received, the code will turn right (moving down) because the top of the stack is potive. Otherwise it will turn left because the top of the stack is negative.
| Pop the top two items from the stack and push the result of a bitwise OR.
_ Push zero
256 Each digit seen pops x and pushes x*10+digit. So this combined with the push zero previous push 256 to the top of the stack.
* Pop y, pop x, push x*y. At this point since the top of the stack is positive the code will turn right to continue around the loop.

Blue:

) Increment the top of the stack. When the end of input is reached, the code will turn left to get to this point with a -1 on the stack which will get incremented to zero.
256 Having the top of the stack 0 allows us to push this 256.
/ Pop y, pop x push x/y (integer division). Since we were multiplying the input by 256 each loop, we need to revert the last multiplication.
: Duplicate the top of the stack so we have a copy of the current value for later.
! Pop the top of the stack and print the integer value to STDOUT.
\ Print a new line.
_2 Push a two to the top of the stack.
} Move the top of the stack to the top of the auxiliary stack.

Red:
This loop flips the bits of the current value by XOR with a particular value calculated in the inner (green) loop. It then outputs the current value and exits the program if the current value is zero.

_ Push zero (control flow).
; Discard the top of the stack (control flow).
: Duplicate the current value. The copy will be used to calculate the XOR.
_ Push zero (control flow).
(Green loop)
$ Pop y, pop x, Push x XOR y.
:! Duplicate the current value and print the integer representation.
If the current value is 0, we continue straight into the @ and terminate.
\ Print a new line.
_2} Push 2 and move to the aux stack.
_1 Push 1 (control flow).

Green:
This loop calculates the value by which we need to XOR the current value. This is done by repeatedly doubling the top of the auxiliary stack while halving a copy of the current value on the stop of the main stack until it reaches 0.

_ Push zero (control flow).
; Discard the current value which is only used to enforce control flow.
_2 Push 2 in order to halve the current value.
/ Divide
{ Move the top of the aux stack to the top of the main stack.
_2* Double the top of the stack
} Move the top of the main stack back to the aux stack.
_1 Push one for control flow.
After exiting the loop:
; Discard the left over zero from calculating the XOR.
{ Move the calculated XOR to the main stack.
( Subtract one from XOR value.

PowerShell v2+, 158 bytes
for($a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)});$a){[convert]::ToInt64($a,2);$a=$a.TrimStart('0')-split0-replace1,0-join1}

Yeah, so, converting bases in PowerShell is really sucky. And we get to do it twice here.
OK, so this is just a for loop on $a -- i.e., we loop so long as $a exists. We'll eventually reach an empty string (which is falsey), so that's how we'll terminate.
The setup of the loop, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)}), takes the input $args[0], casts it as a char-array, and loops through each character. We use the .NET [convert]::ToString(int,base) to convert each to a binary string. However, that doesn't include leading zeros, so we need to re-cast that string as an [int] and call its .ToString() method with 8 zeros as the mask. Then those strings are encapsulated in parens and -joined together, then saved into $a.
Inside the loop, we [convert]::ToInt64(string,base) to convert the binary number to a decimal number. That gets left on the pipeline and is subsequently flushed when the loop resets (and therefore implicitly printed). The next section performs the calculations -- we .TrimStart() to remove any leading zeros, -split0 to split on zeros and get a string-array of 1s, -replace those ones with zeros, and finally -join the array back together with 1s. Then, the loop begins again.
PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0

CJam, 17 16 18 bytes
q256b0{_p2b:!2bj}j

Try it online!
q256b   e# read printable ascii to integer
0       e# value for terminal case
{       e# recursive function
  _p    e#   print current number
  2b    e#   create binary representation with no leading zeros
  :!    e#   flip bits
  2b    e#   convert binary back to integer
  j     e#   recursive call
}j      e# end

NOTE: The old 16 byte version didn't behave correctly with empty strings:
q256b{_p2b:!2b}h

Also, thanks to Dennis for suggesting p which saves 1 byte over N\ putting newlines into the stack.

_p2b:!2b saves a byte. Also, you should use l; r will fail if the input contains spaces.

@Dennis Thanks, though this now makes me worry if a empty string is an issue.

Right. q will work correctly with empty strings.

J, 24 bytes
256-.&.#:^:*^:a:@#.a.&i.

Explanation will come later!

Welcome to PPCG! Permalink for the interested: Try it online!

Retina, 116 bytes
Byte count assumes ISO 8859-1 encoding. Line 5 contains non-printable bytes. It's T`\x00-\xFF.
-2`
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+
$*
+`(1+)\1
${1}0
01
1

{*(`1
01
+`10
011
^0+

)M`1
^0+

T`01`10

Try it online
Don't try this with input longer than two characters. (It times out using the online interpreter.) We gotta convert the binary to unary before decimal. :D
Unfortunately, there's a trailing zero and linefeed, but I decided to assume that was okay because the output is still correct.
Explanation
-2`         # Convert ASCII to decimal (ord)
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+         # Decimal to binary
$*
+`(1+)\1
${1}0
01
1

{*(`1       # Loop; Loop print and undo; Convert binary to unary
01
+`10
011
^0+

)M`1        # Unary to decimal; End print and undo
^0+         # Remove leading zeros

T`01`10     # Flip bits; (implicit loop end)

C, 147 135 133 125 122 121 117 115 103 bytes
Saved 5 bytes thanks to @Cyoce!
Saved 2 bytes thanks to @Cyoce and @cleblanc!
Saved 12 bytes thanks to @ceilingcat
i,n;main(p,v)char**v;{while(*v[1])i=i*256+*v[1]++;for(;printf("%d\n",n=i),i;i^=p-1)for(p=2;n/=2;)p*=2;}

Ungolfed:
int i;
int main (c,v) {
    char**v;
    while (*v[1]) /* put first command line argument into i as binary */
        i = i*256 + *v[1]++;
    while (i != 0) {
        printf("%d\n",i);
        int p = 2,n = i;
        while (n /= 2) /* calculate smallest power of 2 > i */
            p *= 2;
        i ^= p - 1; /* flip bits */
    }
}

I think you can leave out the int declarations

You can also save a byte by converting the last while loop into a for loop

And you can change while(1) to for(;;)

@Cyoce I tried removing int declarations everywhere and got gcc -std=89 errors. But  thanks for the for(;;) tip. I'll keep on trying to remove the int declarations :)))

sorry, I didn't test it. I think it will work if you move them to the top (i;main(c,v)char**v;{...}). On mobile right now so I can't be sure

@Cyoce On mobile too. Will test your ideas tomorrow. Thanks so much, I've been trying to get a byte or two down for ages :)))

Can you use the same technique you used for i to save on the int declaration for p and n?

@Cyoce Unfortunately that only trades 4 bytes int  for 4 bytes ,p,n

I think you can re-write the signature for main as main(c,v)char**v;

@cleblanc Tried that and gcc with -std=c89 wouldn't compile it.

@Noodle9 try -std=c99 that works for me.  I think it's the default for my compiler gcc (GCC) 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

@Noodle9 it works for me with just gcc

Ruby - 70 bytes
λ cat inf.rb
n,=$*[0].unpack 'B*';loop{p n.to_i(2);n.tr!('10','01').sub!(/^0*/,'')}
λ ruby inf.rb Hello
310939249775
788572378000
310939249775
238816564112
36061342831
32658133904
1701604463
445879184
90991727
43226000
23882863
9671568
7105647
1282960
814191
234384
27759
5008
3183
912
111
16
15
0
inf.rb:1:in `block in <main>': undefined method `sub!' for nil:NilClass (NoMethodError)
        from inf.rb:1:in `loop'
        from inf.rb:1:in `'

The program exits with an exception after completing, but my understanding is that that is fine as long as the error output goes to STDERR rather than STDOUT (which it does).

C, 129 120 117 110 107 105 Bytes
long long i,m,n;f(char*v){for(;*v;i<<=8,i+=*v++);for(;printf("%llu,",i),n=i;i^=m-1)for(m=2;n>>=1;m<<=1);}

Tested with
main (int c, char**v) {
    f(v[1]);
}

output
5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,

I think you can move i=0 to the declaration of i and leave the initialization section of the for loop blank

@Cyoce The function needs to work each time it's called and since i is implicit global int it needs to be initialized every time f(...) is called.

@Cyoce You were right after all.  The function doesn't exit until i is zero again so it's still re-useable.

102 bytes

C#, 360 359 bytes
using w=System.Console;using q=System.Convert;s={System.Func<int,int,string>S=q.ToString;string t="",f="";for(int i=0;i<s.Length;i++)t+=i>0?S(s[i],2).PadLeft(8,'0'):S(s[i],2);w.WriteLine(q.ToInt64(t,2).ToString());while(t!="0"){f="";foreach(var n in t)f+=n=='0'?'1':'0';t=f.TrimStart(new char[]{'0'});t+=t==""?"0":"";w.WriteLine(q.ToInt64(t,2).ToString());}};

Full program:
using w = System.Console;
using q = System.Convert;

class a
{
    static void Main()
    {
        System.Action<string> b = s =>
        {
            System.Func<int,int,string> S = q.ToString;
            string t = "", f = ""; // Var does not work here
            for(int i = 0; i < s.Length; i++)
                t += i > 0 ? S(s[i], 2).PadLeft(8, '0') : S(s[i], 2);
            w.WriteLine(q.ToInt64(t, 2).ToString());
            while(t != "0")
            {
                f = "";
                foreach (var n in t) f += n== '0' ? '1' : '0';
                t = f.TrimStart(new char[] { '0' });
                t += t == "" ? "0" : "";
                w.WriteLine(q.ToInt64(t, 2).ToString());
            }
        };

        b("Inf");
        b("Infinity");
        w.Read(); // prevent close in VS
    }
}

I don't do C#, but can var t="";var f=""; be var t="",f="" instead? Saves 5 bytes.

@corsiKa Yeah I tried that but it gave me an error, I guess cause it's var and not string.

Actually, string does save one byte, so I guess I'll do it that way.

Also can you make a z variable for zero to save those nasty quotes?

Just tried, it actually raises the bytecount because I can't replace both the string "0" and char '0' :(

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Encode the simple substitution cipher
Review
First, let's review the Simple Substitution Cipher.
To encode a string in the Simple Substitution Cipher, replace each letter in your string with another letter.
A letter may not be used to replace more than one existing letter.
For example, if I was encoding the text Hello world, my name is Oliver! I like code golf! with the key zyxwvutsrqponmlkjihgfedcba (a -> z, b -> y, etc.) then the encoded text would be Svool dliow, nb mznv rh Lorevi! R orpv xlwv tlou!.
Your task
Your task is to encode the simple substitution cipher. Given a string of decoded text and a key, output the encoded text.
Remember, this is code-golf, so the code with the fewest number of bytes wins.

Given a string of encoded text and a key, output the encoded text. There should be a decoded in there shouldn't it?

reopened this as per our policy of closing older answers as dupes of older questions.

A little more details would be nice. In your example, you encode uppercase letters that do not appear in your key, yet no such thing is mentioned in the spec.

This is essentially "Implement UNIX tr", and just parameterises an existing tr question.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
A day at the Horse Races
Background
Back in the late 90's / first 00's when Flash Web Design was so much cool that noone could live without having a full Flash website, or at least an animated widget, I was hired to develop a "horse races viewer" in Flash/Actionscript, in the shape of an 80's videogame style animation, so the site's visitors could not only read the race results, but they could see it in a moving animation! WOW! Impressive!
They provided me a CSV file with all the races details: start and arrival order, horse names, driver names, prizes, etc. My Flash app read that file for each race and displayed the above said animation.
Nowadays the Flash support is significantly declined, so we must revert to ascii-art!
Task
Your task is to create a full program or function that reads the race data in CSV format from standard input and outputs an ascii-art representation of the race as shown in the example below.
INPUT
CSV data with 2 fields: 1) start order; 2) arrival time at the Finish in the format 1.13.4 (1 minute, 13 seconds, 4 tenths of second). If the time reports R means that the horse is Retreated (didn't finish the race) due to incident, fall or other reason. Note: The arrival time could be the same for 2 or more horses, in this case they share the arrival position.
1,1.13.4
2,1.13.0
3,R
4,1.12.7
5,1.11.5
6,1.13.4
7,1.12.1
8,1.17.9

OUTPUT
For each CSV row, output a racetrack like this:
1_|______________4(1.13.0)___________________________

The racetrack is composed by:

1 which is the horses start order.
_| where _ is a spacer and the | is the finish line.
50 x _ that represents 50 tenths of second.
5(1.13.4) that is the arrival position followed by the arrival time. This must be positioned respecting the time differences between horses. For example: you position the 1st arrived on the Finish line at time 1.11.5, the second arrives at time 1.12.1, the difference is 1.12.1 - 1.11.5 = 6 tenths of second, so the second horse should be positioned at the 6th character, and so on. If the time difference is more than 50 tenths of seconds (or 5 seconds) you must position the horse at the end. The same if the horse is R (Retreated).

So the whole racetrack for the CSV data above should be:
  F=Finish line
1_|____________________________5(1.13.4)_____________
2_|______________4(1.13.0)___________________________
3_|__________________________________________________R
4_|___________3(1.12.7)______________________________
5_1(1.11.5)__________________________________________
6_|____________________________5(1.13.4)_____________
7_|_____2(1.12.1)____________________________________
8_|__________________________________________________6(1.17.9)
  012345678901234567890123456789012345678901234567890

There is no need to add F=Finish line, and the last line 0123456789... that is only for explaining purpose.
Test cases
RACE:
1,1.14.9
2,R
3,R
4,1.14.2
5,1.15.2
6,1.15.3
7,1.15.3

RACE:
1,1.13.6
2,1.13.8
3,R,
4,1.15.9
5,1.13.8
6,R,
7,1.14.4
8,1.15.6
9,1.14.1
10,1.13.9
11,1.13.2
12,1.14.3
13,1.15.0

RACE:
1,1.13.4
2,1.13.0
3,R
4,1.12.7
5,1.11.5
6,1.13.4
7,1.12.1
8,1.17.9

RACE:
1,1.17.3
2,1.20.4
3,1.17.0
4,1.18.8
5,1.18.5
6,1.18.4
7,1.18.4
8,1.17.8
9,1.18.3
10,1.18.7
11,R

RACE:
1,1.17.5
2,R
3,1.17.7
4,1.16.9
5,1.16.1
6,1.18.9

RACE:
1,1.12.8
2,1.13.0
3,1.13.2
4,1.12.7
5,1.11.5
6,1.13.0
7,1.12.1
8,1.12.8

Rules

Shortest code wins.

In the example where 5th is tied, wouldn't horse 8 still place 7th?

May we assume that the minute number will always be 1?

@JonathanAllan It depends on the rules, in the example I assumed that if the horses share the 5th position, the next will be considered 6th.

@ETHproductions Yes you can assume the minute is always 1.

What range will the second be in?

Also, may we assume that there will always be a non-R horse? (I know this isn't a sensible question in real life, but this is code.)

@Pietu1998 You can assume that there will always be a non-R horse. Regarding "What range will the second be in?" I don't understand the question.

I mean, will there be times such as 1.02.3 or 1.59.3, or is there a limit to the seconds place too?

@Pietu1998 OK, you can assume that all the times will be more than 1 and under 2 minutes, referring to this type of race.

How is the start order formatted when there are more than 9 horses?

@Arnauld you should keep the finish line | vertically aligned, so you can add a space or 0 before the numbers < 10.

JavaScript (ES6), 261 bytes
Takes an array of time strings "1.ss.t" as input. The start order is implicit.
a=>a.map((t,i)=>(u='_',++i>9?'':' ')+i+u+u.repeat(x=(x=t>'9'?50:t.slice(2)*10-s[0].slice(2)*10)>50?50:x,p=s.indexOf(t)+1+`(${t})`).replace(u,'|')+(x<50?p:'')+u.repeat((x=50-p.length-x)>0?x:0)+(x>0?'':t>'9'?t:p),s=a.filter((v,i)=>a.indexOf(v)==i).sort()).join`
`

Demo

let f =

a=>a.map((t,i)=>(u='_',++i>9?'':' ')+i+u+u.repeat(x=(x=t>'9'?50:t.slice(2)*10-s[0].slice(2)*10)>50?50:x,p=s.indexOf(t)+1+`(${t})`).replace(u,'|')+(x<50?p:'')+u.repeat((x=50-p.length-x)>0?x:0)+(x>0?'':t>'9'?t:p),s=a.filter((v,i)=>a.indexOf(v)==i).sort()).join`
`

console.log(f([
  "1.13.4",
  "1.13.0",
  "R",
  "1.12.7",
  "1.11.5",
  "1.13.4",
  "1.12.1",
  "1.17.9"
]));

console.log(f([
  "1.13.6",
  "1.13.8",
  "R",
  "1.15.9",
  "1.13.8",
  "R",
  "1.14.4",
  "1.15.6",
  "1.14.1",
  "1.13.9",
  "1.13.2",
  "1.14.3",
  "1.15.0"
]));

Python 2, 282 272 246 bytes
Similar to Arnauld the input is assumed to be already stripped from the starting number since it is implicit.
H=input().split("\n")
T=[float(c[2:])if c[2:]else 99for c in H]
P=[min(int(10*(t-min(T))),50)for t in T]
S=sorted(list(set(T)))
i=0
u="_"
for h,p,t in zip(H,P,T):i+=1;s=S.index(t)+1;print`i`+u+"|"*(s>1)+u*p+[h,"%d(%s)"%(s,h)][t<99]+u*(41-p+(s<2))


text:
How many significant figures?
Given a number as input, determine how many significant figures it has. This number will should be taken as a string because you have to do some special formatting. You'll see what I mean soon (I think).
A digit is a sig-fig if at least one of the following apply:

Non-zero digits are always significant.
Any zeros between two significant digits are significant.
final zero or trailing zeros in the decimal portion only are significant.
all digits are significant if nothing follows the decimal place.
when there are only zeroes, all but the last zero are considered leading zeroes

Input
A string or string array of the number. It might have a decimal point at the end without a digit after it. It might not have a decimal point at all.
Output
How many sig-figs there are.
Examples
1.240 -> 4
0. -> 1
83900 -> 3
83900.0 -> 6
0.025 -> 2
0.0250 -> 3
2.5 -> 2
970. -> 3
0.00 -> 1

related but a) has no answers and b) is about calculating the answer to an expression

Related

You might want to mention explicitly somewhere that if there are only zeros then all but the last zero are considered leading digits (as opposed to all but the first zero being considered trailing digits).

Why does 0.00 -> 1 ? Aren't the two zeros following the decimal point significant (according to "final zero or trailing zeros in the decimal portion only are significant").

@Penguino, as Martin Ender correctly said, if there are only 0s, all but the last digit are considered leading zeroes

@MartinEnder, edited. It's definitely clearer now. Thanks.

05AB1E, 11 10 bytes
D.ïi0Ü}þïg

Try it online! or as a Test suite
Explanation
D            # duplicate
 .ïi  }      # if it is an integer
    0Ü       # remove trailing zeroes
       þ     # remove the "." if present
        ï    # convert to int
         g   # length

Retina, 29 27 bytes
Saved 2 bytes thanks to @MartinEnder
^0\.0*.|^\d(\d*?)0+$
1$1
\d

Try it online! | Test suite

Batch, 204 202 bytes
@set/ps=
:t
@if %s:.=%%s:~-1%==%s%0 set s=%s:~,-1%&goto t
@set s=%s:.=%
:l
@if not %s%==0 if %s:~,1%==0 set s=%s:~1%&goto l
@set n=0
:n
@if not "%s%"=="" set/an+=1&set s=%s:~1%&goto n
@echo %n%

Takes input on STDIN. Works by removing trailing zeros if the number does not contain a ., then removing the . and leading zeros, unless there are only zeros, in which case it leaves one zero. Finally it takes the length of the remaining string.

I've never seen so many %s in my entire life :O

@KritixiLithos I've managed 16 on one line before: http://codegolf.stackexchange.com/a/86608/17602

Scala, 90 bytes
& =>(if(&contains 46)&filter(46!=)else&.reverse dropWhile(48==)reverse)dropWhile(48==)size

Explanation:
& =>               //define an anonymous function with a parameter called &
  (
  if(&contains 46) //if & contains a '.'
    &filter(46!=)    //remove all periods
  else             //else
    &.reverse        //reverse the string
    dropWhile(48==)  //remove leading zeros
    reverse          //and reverse again
  )
  dropWhile(48==) //remove leading zeros
  size            //return the length

C#6, 163 bytes
using System.Linq;
int a(string s)=>System.Math.Max(s.Contains('.')?(s[0]<'1'?s.SkipWhile(x=>x<'1').Count():s.Length-1):s.Reverse().SkipWhile(x=>x<'1').Count(),1);

Ungolfed
int a(string s)=>
    System.Math.Max(
        s.Contains('.')                                // Has decimal place?
            ?(                                         // Has decimal place!
                s[0]<'1'                               // Start with '0' or '.'?
                    ?s.SkipWhile(x=>x<'1').Count()     // Yes: Skip leading '0' and '.', then count rest... But gives 0 for "0." and "0.00"
                    :s.Length-1)                       // No: Count length without decimal place
            :s.Reverse().SkipWhile(x=>x<'1').Count()   // No decimal place: Skip trailing '0' and count rest
    ,1);                                               // For "0." and "0.00"


text:
Ordered list of binary sequences of multiple dimensions
Given a positive integer n, output the 2^n binary sequences of length n sorted in the following precise ordering.
Test cases:
0:
0 or 1 (defining this is a matter of debate)

1:
0
1

2:
00
01
10
11

3:
000
001
010
100
011
101
110
111

4:
0000
0001
0010
0100
1000
0011
0101
1001
0110
1010
1100
0111
1011
1101
1110
1111

etc.
Additionally, the pattern of combinatorics is related to Pascal's Triangle.
0:
1 (this is given regardless of the definition given to 2^0)

1:
1
1

2:
1
2
1

3:
1
3
3
1

4:
1
4
6
4
1

etc.

For me above could be the result of one bug in a sorting algo...

Haskell, 78 bytes
import Data.List
f n=sortOn(\x->sum x:reverse(map(1-)x))$mapM id$[0,1]<$[1..n]

Usage example: f 2 -> [[0,0],[0,1],[1,0],[1,1]].
How it works:
         [0,1]<$[1..n]  -- make n copies of the list [0,1]
     mapM id            -- make all lists where the ith element is from the ith list.
                        -- that gives us all binary sequences
sortOn                  -- sort this list of list
    sum x               -- first by number of ones
      reverse(map(1-)x) -- then by the reversed list with bits flipped

I used a Haskell compiler from the Apple Store, and I'm not sure if that won't allow me to run this code. Took a screenshot of what happens when I run it: http://m.imgur.com/VIByUah

@DreadVim: it seems that you don't have the latest version of the libraries (Prelude for <$ and Data.List for sortOn). Also: my code isn't a full program, so it won't compile.

Ah. That makes sense. I'll have to do it on my laptop.

TIL about sortOn. I will miss sortBy (compare `on` f).

Python 2, 146 bytes
from itertools import*
lambda i:sum([sorted({''.join(b)for b in permutations((i-n)*"0"+"1"*n)},key=lambda x:x[::-1])[::-1]for n in range(i+1)],[])

I'm still working on this, though any suggestions would be greatly appreciated!
Ungolfed
i=input()
import itertools
p=[]
for n in range(i+1):
    x=(i-n)*"0"+"1"*n
    t=[]
    for b in itertools.permutations(x):t+=[''.join(b)] if ''.join(b) not in t else []
    p.append(sorted(t, key=lambda x:x[::-1])[::-1])

p=sum(p,[])
print
for line in p:print line

do from itertools import* and then just use permutations in the lambda. saves 1 byte

Perl, 63 bytes
-4 thanks to @Ton Hospel.
-2 thanks to @Gabriel Benamy.
say~~reverse for sort{$b=~y/0//-$a=~y/0//||$b-$a}glob"{1,0}"x<>

Run with -E (which enable the feature say) :
perl -E 'say~~reverse for sort{$b=~y/0//-$a=~y/0//||$b-$a}glob"{1,0}"x<>' <<< 5

Short explanations:

"{1,0}"x$_ creates a string composed of $_ times{1,0} ($_ is the input). For instance with 3 : {1,1}{1,0}{1,0}.
Then glob does some magic and generates all combinations of one element from each group of braces (that is, all the combinations we want to print).
And then the sort : $b=~y/1//c-$a=~y/1//c compares the number of 1 in each string, and if they have the same number, $b-$a will sort according to the second rule.

I believe you can save two bytes by changing y/1//c to y/0// both times

@GabrielBenamy Indeed, thanks. I'm too used to use y///c!

Replace <=> by -

@TonHospel edited, thanks!

Python 2, 122 120 102 98 bytes
18 bytes saved thanks to  Flp.Tkc
4 bytes saved thanks to xnor
lambda x:sorted([bin(i)[2:].zfill(x)for i in range(2**x)],key=lambda x:(sorted(x),int(x[::-1],2)))

Explanation
This makes all the binary strings of length x with:
[bin(i)[2:].xfill(x)for i in range(2**x)]

I then sort them according to:
lambda x:(sorted(x),int(x[::-1],2))

sorted(x) prioritizes the number of 1s while int(x[::-1],2) prioritizes the second condition
Lastly these are joined with newlines and printed.

This is not eligible.

@DreadVim It is now

Agreed. Good job.

This seems to trim leading zeroes.

The 106 byte version seems to give a different order for n=4. Yours gives 0110 then 1001, which is switched fro the test case. I'm not sure how the correct order is actually specified.

My mistake. It's actually flipped, and if it wasn't, it would still not match the format requirements.

Can't you just put this into a 102-byte lambda: lambda x:sorted([bin(i)[2:].rjust(x,"0")for i in range(2**x)],key=lambda x:(sorted(x),int(x[::-1],2)))

@Flp.Tkc ah yes the spec has changed a bit since I made this answer

zfill is rjust with zeroes.

@xnor Thanks! Is that on the python tips page because I think that would be a good one?  I can see myself using that quite a lot.

Perl, 116 106 105 102 bytes
sub e{sprintf"%0$%b",@_}sub f{$_=e@_;/0*$/;$%*y/1//-$-[0]}map{say e$_}sort{f($a)<=>f$b}0..2**($%=<>)-1

Readable:
sub e{
    sprintf"%0$%b",@_
}
sub f{
    $_=e@_;/0*$/;$%*y/1//-$-[0]
}
map{
    say e$_
} sort {
    f($a)<=>f$b
} 0..2**($%=<>)-1

The subroutine e converts its argument into a binary value, padded with zeros, to be the input length (e.g. input of 5 pads with zeros until it's 5 characters long).  The subroutine f takes such a binary value, and gives it sorting weight according to how it should be processed.
The range 0 .. [input]2-1 is then put through a stable sort, ordering by the weight (here, "stable" means that when two values have the same weight, they are returned in the same order they appear in the input), and then they are fed back to the subroutine e and output.
Some of you may have seen my original post, but I entirely misread the problem yesterday and deleted it immediately after I realized it.

This doesn't produce the require output for n>=5. For instance, with n>=5, 01101 comes before 10011 but it should be after.

Racket 109 bytes
(let loop((s ""))(if(= n(string-length s))(displayln s)(for((i '("0" "1")))(loop(string-append s i)))))

Ungolfed:
(define (f n)
  (let loop ((s ""))
    (if (= n (string-length s))
        (displayln s)
        (for ((i '("0" "1")))
          (loop (string-append s i))))))

Testing:
(f 2)
(println "-------------")
(f 3)
(println "-------------")
(f 4)

Output:
00
01
10
11
"-------------"
000
001
010
011
100
101
110
111
"-------------"
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

In case n=3 above is not the same to exercise text 000 001 010 100 etc

This exercise would be about to write the right function for to sort a list of numbers (and than print the binary form)

Ruby 2.x, 129 bytes
f=->(n){z='0';p=n.bit_length;(0..n).map{|i|sprintf("%0#{p}d",i.to_s(2))}.sort{|a,b|a=a.delete(z).size-(b=b.delete(z).size)||b-a}}

Welcome to Programming Puzzles & Code Golf! Unfortunately, this doesn't quite seem to do what the challenge asks for. For example, input 5 prints the first five lines of the output that corresponds to 3.

PHP, 49 bytes
while($i<1<<$n=$argv[1])printf("%0${n}b\n",$i++);

Run with -r.

MATLAB, 68 bytes
d=@(n)dec2bin(sortrows([sum(dec2bin(0:2^n-1)');0:2^n-1]')*~eye(2,1))

Bash, 65 bytes
Golfed
seq -f "obase=2;%g+2^$1-1" $[2**$1]|bc|cut -c2-|tr 0 ~|sort|tr ~ 0

Test
>./binseq 4

0000
0001
0010
0100
1000
0011
0101
0110
1001
1010
1100
0111
1011
1101
1110
1111

It is wrong... I copy and paste the above output:0011
0101
1001
0110
1010
1100 after 0101 there is 1001 and not 0110

Indeed it does http://imgur.com/a/yxBLp, my guess, is that you are probably just running a system with a different locale (I use "en_US.UTF-8"), so the different collation rules apply (which is an expected and documented "sort" behavior). Try changing the locale, or tell me yours, and I will see which char you should use in place of ~.

Another thing you may try is to enforce the dictionary order on sort with "-d" (that should produce less locale specific results)

i say your result print above for n=4
[0000 0001 0010 0100 1000 0011 0101 0110 1001 1010 1100 0111 1011 1101 1110 1111]
is different from the result of the question for n=4
[0000 0001 0010 0100 1000 0011 0101 1001 0110 1010 1100 0111 1011 1101 1110 1111]
infact the 9th position of that array has one different value

@RosLup I believe 0101 => 1001 is an error in test case data, not my implementation, see discussion on the  "Python 2" answer below:
"Yours gives 0110 then 1001, which is switched fro the test case. I'm not sure how the correct order is actually specified. – xnor"
"My mistake. It's actually flipped ... - Dread Vim" (the OP)

@RosLup, @ DreadVim has then changed the requirements from "namely in increasing order of 1s." to be just "the following precise ordering".
But honestly I'm not in the mood of re-doing my answer to fit a post-factum change in requirements.

Jelly, 14 bytes
2Ḷṗ⁸TṪ$N$ÞSÞYȯ

Try it online!
Surprised this hadn't been posted yet.


text:
Palindromize this string!
Your task is to palindromize a string as follows:
Take the string.
abcde

Reverse it.
edcba

Remove the first letter.
dcba

Glue it onto the original string.
abcdedcba

But here's the catch: since this challenge is about palindromes, your code itself also has to be a palindrome.
Remember, this is code-golf, so the code with the smallest number of bytes wins.

There should be a hefty bonus for any code that does not use comments to fulfill the palindrome requirement.

@Theo Then it would go straight to the golf-langs with the palindrome builtin. I don't really see the need for it, and doing it without a comment is more of a personal challenge.

@miles Fair enough. Although I would love to see some creativity from the non-golfing-langs in general.

Related.

@miles It´s virtually impossible for non-eso-langs to do this without a comment. You can´t just palindromize predefined function names. Maybe it can be done, but it would ridiculously blow up the size.

Can there be an exception for the program to substitute exact characters for mirrored characters in its palindrome? I.e. Allowing "(1+1)" as a palindrome. I think it would increase the competitiveness of non-golf languages.

Actually, it´s not an exact duplicate. You have to remove one character from the input here.

Python 3, 41 bytes
lambda t:t+t[-2::-1]#]1-::2-[t+t:t adbmal

Try it here.

My first Python answer

Not that it matters, but one of your reversed brackets is the wrong direction.

@xnor Thank you! Corrected

I think he means the other one

05AB1E, 1 byte
û

Try it online!

Yep. One char is a palindrome.

how do you have a built in for this

@undergroundmonorail: It is quite often useful in ascii art challenges, or really any challenge with horizontal symmetry.

@Emigna I guess that's fair. I thought "I wonder what function is being horribly abused because it happens to generate this output" but no, I checked the docs and sure enough it's called "palindromize" haha

Dip, 1 byte
B

Body must be at least 30 characters; you entered 13.

Pyth - 13 bytes
It kinda looks like its crying.
+Qt_Q " Q_tQ+

Try it online here.

+1 for almost being Q_Q

Hate to see a Qt crying

You can use z instead of Q to not need quotes in the input (Which I think you need to add 2 bytes for the required chars in input (http://pyth.herokuapp.com/?code=%2Bzt_z+%22+z_tz%2B&input=abcde&debug=0)

@Artyer actually, I don't need to add 2 bytes for the " because it is such a common and standard input format. I could have used z, but I was expecting to use the implicit input feature of Q, but ended up not using it, and didn't go back and change it.

아희(Aheui), 149 137 bytes (47 chars + 2 newlines)
붛뱐쎤붇쎡뻐처순의이멓희
빠본땨벌다따토먀의썩속썩의먀토따다벌땨본빠
희멓이의순처뻐쎡붇쎤뱐붛

Due to the nature of the Aheui language, the input must end in a double quotation mark (") (gets ignored).
Try it here! (copy and paste the code)
Bonus (each line is palindromic), 131 bytes (42 chars + 5 newlines)
밯빪반분반빪밯
쏜발뚝볃뚝발쏜
쏙툼닿뗘닿툼쏙
뽓첡순괆순첡뽓
숙쌱멈긕멈쌱숙
몋희익욥익희몋

APL -- 13 bytes.
⊣,¯1↓⌽⍝⌽↓1¯,⊣

Explanation:
⊣,¯1↓⌽
     ⌽ Reverse the argument.
  ¯1↓  Drop the last character.
⊣,     Concatenate the original to the result.

JavaScript (ES6), 86 bytes
s=>s+[...s].reverse().slice(1).join("")//)""(nioj.)1(ecils.)(esrever.]s...[+s>=s

I tried a smarter solution but it's still longer :/ even abusing [,...a]=s didn't seem to save bytes

aww you ninja'd me

You can use join\`instead ofjoin("")`

J, 17 bytes
}:,|.NB. .BN.|,:}

Takes the easy way out by using a comment to mirror the code. In J, NB. starts a line comment. I do hope to find a method that doesn't involve a comment but the digrams in J probably do make it harder.
Also forms two smileys, }: and :}.
Usage
   f =: }:,|.NB. .BN.|,:}
   f 'abcde'
abcdedcba

Explanation
Comment part removed since it is just filler.
}:,|.  Input: string S
   |.  Reverse S
}:     Curtail, get S with its last char removed
  ,    Join them and return

C#, (51 50 + 1)*2 = 104 102 bytes
saved 2 bytes to the use of .Aggregate()
s=>s+s.Aggregate("",(a,b)=>b+a,s=>s.Substring(1));//;))1(gnirtsbuS.s>=s,a+b>=)b,a(,""(etagerggA.s+s>=s

You can capture this lambda with
Func<string,string> f = <lambda here>

and call it like this
f("abcde")

Ruby, 47 bytes
->s{s+s.reverse[1..-1]}#}[1-..1]esrever.s+s{s>-

Mathematica, 67 bytes
f=#~Join~Rest@Reverse@#//Function;noitcnuF//#@esreveR@tseR~nioJ~#=f

Defines a named function f that takes a list of characters as input and returns the appropriate palindromized list as output. The bit after the semicolon (is fortunately syntactically valid and) gives a second, way more complicated name to this same function.
It was fun trying to make Mathematica make sense without any brackets!

Brachylog, 11 bytes
:Lc.r
r.cL:

Try it online!
Explanation
:Lc.         Input concatenated with a string L results in the Output
   .r(.)     The Output reversed is still the Output

The second line is a new predicate declaration that never gets called in that code.

Actually, 14 13 bytes
RiXßRkΣkRßXiR

Try it online!
Explanation
R          # reverse input
 i         # flatten
  X        # discard top of stack
   ßR      # push reversed input
     kΣ    # concatenate each
k          # wrap in list
 R         # reverse
  ß        # push input
   X       # discard it
    i      # flatten list to string
     R     # reverse string

Pyke, 1 bytes
s

Try it here!
Yes, this is the same builtin as the digital root one. This time it takes a sting and turns it into a palindrome. Added with this commit (actually on the same day as the digital root question)

PHP, 38+39=77 bytes
<?=($s=$argv[1]).substr(strrev($s),1);#;)1,)s$(verrts(rtsbus.)]1[vgra$=s$(=?<

stupid restriction ... for non-eso languages :)

your 3rd character is an =, but does not come back in the end

@nl-x Typo ... the bytecount was correct ... apart from the missing $ for argv. Thanks.

WinDbg, 142 287 bytes
db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};r$t3=@$t1-1;.for(r$t1=@$t1-3;@$t1>=@$t0;r$t1=@$t1-1;r$t3=@$t3+1){m$t1 L1 $t3};eb$t3 0;da$t0;*;0t$ad;0 3t$be;}3t$ 1L 1t$m{)1+3t$@=3t$r;1-1t$@=1t$r;0t$@=>1t$@;3-1t$@=1t$r(rof.;1-1t$@=3t$r;}1L 1t$bd{)1+1t$@=1t$r;p$@;0t$@=1t$r(rof.;1L 0t$bd

+145 bytes to make it a palindrome, nearly missed that requirement...
Input is passed in via an address in psuedo-register $t0. For example:
eza 2000000 "abcde"           * Write string "abcde" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

This may be more golfable, for example I feel like there should be an easier way to convert a memory address in a register to the value at that address.
It works by concatenating the chars from the second-to-last to the first to the end of the string.
db $t0 L1;                                      * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)      * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                   * Set $p = memory-at($t1)
};
r $t3 = @$t1 - 1;                               * Point $t3 at end of string

* From the second-to-last char, reverse through the string with $t1 back to the start ($t0)
* and continue to increment $t3 as chars are appended to the string.
.for (r $t1 = @$t1 - 3; @$t1 >= @$t0; r $t1 = @$t1 - 1; r $t3 = @$t3 + 1)
{
    m $t1 L1 $t3                                * Copy char at $t1 to end of string ($t3)
};
eb $t3 0;                                       * Null terminate the new string
da $t0;                                         * Print the palindrome string

* Comment of the previous code in reverse, making the whole thing a palindrome
*;0t$ad;0 3t$be;}3t$ 1L 1t$m{)1+3t$@=3t$r;1-1t$@=1t$r;0t$@=>1t$@;3-1t$@=1t$r(rof.;1-1t$@=3t$r;}1L 1t$bd{)1+1t$@=1t$r;p$@;0t$@=1t$r(rof.;1L 0t$bd

Output:
0:000> eza 2000000 "abcde"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};r$t3=@$t1-1;.for(r$t1=@$t1-3;@$t1>=@$t0;r$t1=@$t1-1;r$t3=@$t3+1){m$t1 L1 $t3};eb$t3 0;da$t0;*;0t$ad;0 3t$be;}3t$ 1L 1t$m{)1+3t$@=3t$r;1-1t$@=1t$r;0t$@=>1t$@;3-1t$@=1t$r(rof.;1-1t$@=3t$r;}1L 1t$bd{)1+1t$@=1t$r;p$@;0t$@=1t$r(rof.;1L 0t$bd
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  00                                               .
02000000  "abcdedcba"

Java 7, 146 bytes
(Enter is added for readibility and not part of the code.)
String c(String s){return s+new StringBuffer(s).reverse().substring(1);}/
/};)1(gnirtsbus.)(esrever.)s(reffuBgnirtS wen+s nruter{)s gnirtS(c gnirtS

Java 7, 152 bytes
String c(char[]s,int i){return s.length==i+1?s[i]+"":s[i]+c(s,++i)+s[i-1];}//};]1-i[s+)i++,s(c+]i[s:""+]i[s?1+i==htgnel.s nruter{)i tni,s][rahc(c gnirtS

Beat ya to it with a shorter answer few seconds before you. I like the manual recursive approach instead of new StringBuffer(s).reverse() though. Unfortunately I don't see anything to make it shorter this time. ;)

@KevinCruijssen you won.Actually i am weak with handling strings.I need to open my java book.

Seems like this makes it even String c(char[]s,int i){return s.length<i+2?s[i]+"":s[i]+c(s,i+1)+s[i];}

Haskell, 46 44 bytes
p s=init s++reverse s--s esrever++s tini=s p

Try it on Ideone. Saved 2 bytes thanks to Damien.
Straight forward solution. init takes everything but the last character of a string (or last element of a list). -- enables a single line comment.

init s++reverse s is shorter

R, 107 bytes
This is the boring solution which just uses comments to make it a palindrome.
cat(x<-scan(,""),rev(strsplit(x,"")[[1]])[-1],sep="")#)""=pes,]1-[)]]1[[)"",x(tilpsrts(ver,)"",(nacs-<x(tac

R with few comments, 271 bytes
While this code is longer, only 89 of the bytes (33%) are comments, rather than the 50% in the above code. R relies extensively on parentheses for function application, so this was rather difficult.
`%q%`=function
(x,y)cat(x,y,sep=e)#
`%p%`=function
(x,y)`if`(length(y),rev(y)[-1],x)#
x=strsplit(scan(,e<-""),e)[[1]]#
n=NULL
e%q%x%p%n
n%p%x%q%e
LLUN=n
#]]1[[)e,)""-<e,(nacs(tilpsrts=x
#)x,]1-[)y(ver,)y(htgnel(`fi`)y,x(
noitcnuf=`%p%`
#)e=pes,y,x(tac)y,x(
noitcnuf=`%q%`

Perl 5, 44 bytes
43 bytes, plus 1 for -pe instead of -e
s#(.*).#$&.reverse$1#e#1$esrever.&$#.)*.(#s

C, 162 bytes
f(char*c,char*d){char*e=c;while(*d++=*c++);c-=2;d-=2;do{*d++=*c--;}while(e<=c);}//};)c=<e(elihw};--c*=++d*{od;2=-d;2=-c;)++c*=++d*(elihw;c=e*rahc{)d*rahc,c*rahc(f

Ungolfed, unpalindromized:
f(char* c,char* d){
 char*e=c;
 while(*d++=*c++);
 c-=2;d-=2;
 do{*d++=*c--;}while(e<=c);
}

c is is input string, assumes output string d has sufficient length.
Usage:
int main() {
 char a[] = "abcde";
 char* b=malloc(strlen(a)*2);
 f(a,b);
 printf("%s\n",b);
}

, 16 chars / 20 bytes
ï+ïĦ⬮Đ1//1Đ⬮Ħï+ï

Try it here (ES6 browsers only).
Generated from the interpreter console using this:
c.value=`ï+ï${alias(String.prototype,'reverse')}⬮${alias(String.prototype,'slice')}1//1${alias(String.prototype,'slice')}⬮${alias(String.prototype,'reverse')}ï+ï`