{"name":"10001th prime","C":"#include\n#include\n\nint isprime( int p ) {\n int i;\n if(p==2) return 1;\n if(!(p%2)) return 0;\n for(i=3; i*i<=p; i+=2) {\n if(!(p%i)) return 0;\n }\n return 1;\n}\n\nint prime( int n ) {\n int p, pn=1;\n if(n==1) return 2;\n for(p=3;pn\n#include \n#include \n#include \n\ntypedef unsigned char u8t;\ntypedef unsigned short u16t;\nenum { NR=4, NC=4, NCELLS = NR*NC };\nenum { UP, DOWN, LEFT, RIGHT, NDIRS };\nenum { OK = 1<<8, XX = 1<<9, FOUND = 1<<10, zz=0x80 };\nenum { MAX_INT=0x7E, MAX_NODES=(16*65536)*90};\nenum { BIT_HDR=1<<0, BIT_GRID=1<<1, BIT_OTHER=1<<2 };\nenum { PHASE1,PHASE2 }; \n\ntypedef struct { u16t dn; u16t hn; }HSORT_T;\n\ntypedef struct {\n u8t data[NCELLS]; unsigned id; unsigned src;\n u8t h; u8t g; u8t udlr;\n}NODE_T; \n\nNODE_T goal44={\n {1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,0},0,0,0,0,0};\nNODE_T work; \n\nNODE_T G34={ \n {13,9,5,4, 15,6,1,8, 0,10,2,11, 14,3,7,12},0,0,0,0,0};\n\nNODE_T G52={ \n {15,13,9,5, 14,6,1,4, 10,12,0,8, 3,7,11,2},0,0,0,0,0};\n\nNODE_T G99={ \n {15,14,1,6, 9,11,4,12, 0,10,7,3, 13,8,5,2},0,0,0,0,0};\n\nstruct {\n unsigned nodes;\n unsigned gfound;\n unsigned root_visits;\n unsigned verbose;\n unsigned locks;\n unsigned phase;\n}my;\n\nu16t HybridIDA_star(NODE_T *pNode);\nu16t make_node(NODE_T *pNode, NODE_T *pNew, u8t udlr );\nu16t search(NODE_T *pNode, u16t bound);\nu16t taxi_dist( NODE_T *pNode);\nu16t tile_home( NODE_T *p44);\nvoid print_node( NODE_T *pN, const char *pMsg, short force );\nu16t goal_found(NODE_T *pNode);\nchar udlr_to_char( char udlr );\nvoid idx_to_rc( u16t idx, u16t *row, u16t *col );\nvoid sort_nodes(HSORT_T *p);\n\nint main( )\n{\n my.verbose = 0;\t\t\n \n \n \n memcpy(&work, &G99, sizeof(NODE_T)); \n if(1){ \n printf(\"Phase1: IDA* search for 1234 permutation..\\n\");\n my.phase = PHASE1;\n (void) HybridIDA_star(&work);\n }\n printf(\"Phase2: IDA* search phase1 seed..\\n\");\n my.phase = PHASE2;\n (void)HybridIDA_star(&work);\n return 0;\n}\n\n\nu16t HybridIDA_star(NODE_T *pN){\n my.nodes = 1;\n my.gfound = 0;\n my.root_visits = 0;\n pN->udlr = NDIRS;\n pN->g = 0;\n pN->h = taxi_dist(pN);\n pN->id = my.nodes;\n pN->src = 0;\n const char *pr = {\"Start\"}; \n print_node( pN,pr,1 );\n u16t depth = pN->h;\n while(1){\n depth = search(pN,depth);\n if( depth & FOUND){\n return FOUND; \n }\n if( depth & 0xFF00 ){\n\t printf(\"..error %x\\n\",depth);\n\t return XX;\n }\n my.root_visits++;\n printf(\"[root visits: %u, depth %u]\\n\",my.root_visits,depth);\n }\n return 0;\n}\n\n\nu16t search(NODE_T *pN, u16t bound){ \n if(bound & 0xff00){ return bound; }\n u16t f = pN->g + pN->h;\n if( f > bound){ return f; }\n if(goal_found(pN)){\n my.gfound = pN->g;\n memcpy(&work,pN,sizeof(NODE_T));\n printf(\"total nodes=%d, g=%u \\n\", my.nodes, my.gfound);\n const char *pr = {\"Found..\"}; \n print_node( &work,pr,1 );\n return FOUND;\n }\n NODE_T news;\n \n \n \n HSORT_T hlist[NDIRS];\n for( short i=0; i 0xff ) continue;\n temp = make_node(pN,&news, hlist[i].dn );\n if( temp & XX ) return XX;\n if( temp & OK ){\n\t news.id = my.nodes++;\n\t print_node(&news,\" succ\",0 );\n\t temp = search(&news, bound);\n\t if(temp & 0xff00){ return temp;}\n\t if(temp < min){ min = temp; }\n }\n }\n return min;\n}\n\n\nvoid sort_nodes(HSORT_T *p){\n for( short s=0; sdata[i] == 0 ) return i;\n }\n return XX;\n}\n\n\nvoid print_node( NODE_T *pN, const char *pMsg, short force ){\n const int tp1 = 0;\n if( my.verbose & BIT_HDR || force || tp1){\n char ch = udlr_to_char(pN->udlr);\n printf(\"id:%u src:%u; h=%d, g=%u, udlr=%c, %s\\n\",\n\t pN->id, pN->src, pN->h, pN->g, ch, pMsg);\n }\n if(my.verbose & BIT_GRID || force || tp1){\n for(u16t i=0; idata[i*NR+j]);\n\t }\n\t printf(\"\\n\");\n }\n printf(\"\\n\");\n }\n \n}\n\n\nu16t goal_found(NODE_T *pN) {\n if(my.phase==PHASE1){\n short tags = 0;\n for( short i=0; i<(NC); i++ ){\n\t if( pN->data[i] == i+1 ) tags++;\n }\n if( tags==4 ) return 1; \n }\n \n for( short i=0; i<(NR*NC); i++ ){\n if( pN->data[i] != goal44.data[i] ) return 0;\n }\n return 1;\n}\n\n\nchar udlr_to_char( char udlr ){\n char ch = '?';\n switch(udlr){\n case UP: ch = 'U'; break;\n case DOWN: ch = 'D'; break;\n case LEFT: ch = 'L'; break;\n case RIGHT: ch = 'R'; break;\n default: break;\n }\n return ch;\n}\n\n\nvoid idx_to_rc( u16t idx, u16t *row, u16t *col ){\n *row = idx\/NR; *col = abs( idx - (*row * NR));\n}\n\n\n\nu16t make_node(NODE_T *pSrc, NODE_T *pNew, u8t udlr ){\n u16t row,col,home_idx,idx2;\n if(udlr>=NDIRS||udlr<0 ){ printf(\"invalid udlr %u\\n\",udlr); return XX; }\n if(my.nodes > MAX_NODES ){ printf(\"excessive nodes %u\\n\",my.nodes);\n return XX; }\n memcpy(pNew,pSrc,sizeof(NODE_T));\n home_idx = tile_home(pNew);\n idx_to_rc(home_idx, &row, &col );\n\n if( udlr == LEFT) { if( col < 1 ) return 0; col--; }\n if( udlr == RIGHT ){ if( col >= (NC-1) ) return 0; col++; }\n if( udlr == DOWN ) { if(row >= (NR-1)) return 0; row++; }\n if( udlr == UP ){\t if(row < 1) return 0; row--; }\n idx2 = row * NR + col;\n if( idx2 < NCELLS ){\n u8t *p = &pNew->data[0];\n p[home_idx] = p[idx2];\n p[idx2] = 0; \n pNew->src = pSrc->id;\n pNew->g = pSrc->g + 1;\n pNew->h = taxi_dist(pNew);\n pNew->udlr = udlr; \n return OK;\n }\n return 0;\n}\n\n\nu16t taxi_dist( NODE_T *pN){\n u16t tile,sum = 0, r1,c1,r2,c2;\n u8t *p44 = &pN->data[0];\n for( short i=0; i<(NR*NC); i++ ){\n tile = p44[i];\n if( tile==0 ) continue;\n idx_to_rc(i, &r2, &c2 );\n idx_to_rc(tile-1, &r1, &c1 );\n sum += abs(r1-r2) + abs(c1-c2);\n }\n }\n return sum;\n}\n","Rust":"const NR: [i32; 16] = [3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3];\nconst NC: [i32; 16] = [3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2];\n\nconst I: u8 = 1;\nconst G: u8 = 8;\nconst E: u8 = 2;\nconst L: u8 = 4;\n\nstruct FifteenSolver {\n n: usize,\n limit: usize,\n n0: [i32; 85],\n n3: [u8; 85],\n n4: [usize; 85],\n n2: [u64; 85],\n}\n\nimpl FifteenSolver {\n fn f_y(&mut self) -> bool {\n if self.n2[self.n] == 0x123456789abcdef0 {\n return true;\n }\n if self.n4[self.n] <= self.limit {\n return self.f_n();\n }\n false\n }\n\n fn f_z(&mut self, w: u8) -> bool {\n if w & I != 0 {\n self.f_i();\n if self.f_y() {\n return true;\n }\n self.n -= 1;\n }\n if w & G != 0 {\n self.f_g();\n if self.f_y() {\n return true;\n }\n self.n -= 1;\n }\n if w & E != 0 {\n self.f_e();\n if self.f_y() {\n return true;\n }\n self.n -= 1;\n }\n if w & L != 0 {\n self.f_l();\n if self.f_y() {\n return true;\n }\n self.n -= 1;\n }\n false\n }\n\n fn f_n(&mut self) -> bool {\n self.f_z(match self.n0[self.n] {\n 0 => match self.n3[self.n] {\n b'l' => I,\n b'u' => E,\n _ => I + E,\n },\n 3 => match self.n3[self.n] {\n b'r' => I,\n b'u' => L,\n _ => I + L,\n },\n 1 | 2 => match self.n3[self.n] {\n b'l' => I + L,\n b'r' => I + E,\n b'u' => E + L,\n _ => L + E + I,\n },\n 12 => match self.n3[self.n] {\n b'l' => G,\n b'd' => E,\n _ => E + G,\n },\n 15 => match self.n3[self.n] {\n b'r' => G,\n b'd' => L,\n _ => G + L,\n },\n 13 | 14 => match self.n3[self.n] {\n b'l' => G + L,\n b'r' => E + G,\n b'd' => E + L,\n _ => G + E + L,\n },\n 4 | 8 => match self.n3[self.n] {\n b'l' => I + G,\n b'u' => G + E,\n b'd' => I + E,\n _ => I + G + E,\n },\n 7 | 11 => match self.n3[self.n] {\n b'd' => I + L,\n b'u' => G + L,\n b'r' => I + G,\n _ => I + G + L,\n },\n _ => match self.n3[self.n] {\n b'd' => I + E + L,\n b'l' => I + G + L,\n b'r' => I + G + E,\n b'u' => G + E + L,\n _ => I + G + E + L,\n },\n })\n }\n\n fn f_i(&mut self) {\n let g = (11 - self.n0[self.n]) * 4;\n let a = self.n2[self.n] & (15u64 << g);\n self.n0[self.n + 1] = self.n0[self.n] + 4;\n self.n2[self.n + 1] = self.n2[self.n] - a + (a << 16);\n self.n3[self.n + 1] = b'd';\n self.n4[self.n + 1] = self.n4[self.n];\n let cond = NR[(a >> g) as usize] <= self.n0[self.n] \/ 4;\n if !cond {\n self.n4[self.n + 1] += 1;;\n }\n self.n += 1;\n }\n\n fn f_g(&mut self) {\n let g = (19 - self.n0[self.n]) * 4;\n let a = self.n2[self.n] & (15u64 << g);\n self.n0[self.n + 1] = self.n0[self.n] - 4;\n self.n2[self.n + 1] = self.n2[self.n] - a + (a >> 16);\n self.n3[self.n + 1] = b'u';\n self.n4[self.n + 1] = self.n4[self.n];\n let cond = NR[(a >> g) as usize] >= self.n0[self.n] \/ 4;\n if !cond {\n self.n4[self.n + 1] += 1;\n }\n self.n += 1;\n }\n\n fn f_e(&mut self) {\n let g = (14 - self.n0[self.n]) * 4;\n let a = self.n2[self.n] & (15u64 << g);\n self.n0[self.n + 1] = self.n0[self.n] + 1;\n self.n2[self.n + 1] = self.n2[self.n] - a + (a << 4);\n self.n3[self.n + 1] = b'r';\n self.n4[self.n + 1] = self.n4[self.n];\n let cond = NC[(a >> g) as usize] <= self.n0[self.n] % 4;\n if !cond {\n self.n4[self.n + 1] += 1;\n }\n self.n += 1;\n }\n\n fn f_l(&mut self) {\n let g = (16 - self.n0[self.n]) * 4;\n let a = self.n2[self.n] & (15u64 << g);\n self.n0[self.n + 1] = self.n0[self.n] - 1;\n self.n2[self.n + 1] = self.n2[self.n] - a + (a >> 4);\n self.n3[self.n + 1] = b'l';\n self.n4[self.n + 1] = self.n4[self.n];\n let cond = NC[(a >> g) as usize] >= self.n0[self.n] % 4;\n if !cond {\n self.n4[self.n + 1] += 1;\n }\n self.n += 1;\n }\n\n fn new(n: i32, g: u64) -> Self {\n let mut solver = FifteenSolver {\n n: 0,\n limit: 0,\n n0: [0; 85],\n n3: [0; 85],\n n4: [0; 85],\n n2: [0; 85],\n };\n solver.n0[0] = n;\n solver.n2[0] = g;\n solver\n }\n\n fn solve(&mut self) {\n while !self.f_n() {\n self.n = 0;\n self.limit += 1;\n }\n println!(\n \"Solution found in {} moves: {}\",\n self.n,\n std::str::from_utf8(&self.n3[1..=self.n]).unwrap()\n );\n }\n}\n\nfn main() {\n FifteenSolver::new(8, 0xfe169b4c0a73d852).solve();\n}\n"} {"name":"2048","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n#define D_INVALID -1\n#define D_UP 1\n#define D_DOWN 2\n#define D_RIGHT 3\n#define D_LEFT 4\n\nconst long values[] = {\n 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048\n};\n\nconst char *colors[] = {\n \"39\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"91\", \"92\", \"93\", \"94\"\n};\n\nstruct gamestate_struct__ {\n int grid[4][4];\n int have_moved;\n long total_score;\n long score_last_move;\n int blocks_in_play;\n} game;\n\nstruct termios oldt, newt;\n\nvoid do_draw(void)\n{\n printf(\"\\033[2J\\033[HScore: %ld\", game.total_score);\n if (game.score_last_move)\n printf(\" (+%ld)\", game.score_last_move);\n printf(\"\\n\");\n\n for (int i = 0; i < 25; ++i)\n printf(\"-\");\n printf(\"\\n\");\n\n for (int y = 0; y < 4; ++y) {\n printf(\"|\");\n for (int x = 0; x < 4; ++x) {\n if (game.grid[x][y])\n printf(\"\\033[7m\\033[%sm%*zd \\033[0m|\", colors[game.grid[x][y]],\n 4, values[game.grid[x][y]]);\n else\n printf(\"%*s |\", 4, \"\");\n }\n printf(\"\\n\");\n }\n\n for (int i = 0; i < 25; ++i) {\n printf(\"-\");\n }\n printf(\"\\n\");\n}\n\nvoid do_merge(int d)\n{\n\n#define MERGE_DIRECTION(_v1, _v2, _xs, _xc, _xi, _ys, _yc, _yi, _x, _y) \\\n do { \\\n for (int _v1 = _xs; _v1 _xc; _v1 += _xi) { \\\n for (int _v2 = _ys; _v2 _yc; _v2 += _yi) { \\\n if (game.grid[x][y] && (game.grid[x][y] == \\\n game.grid[x + _x][y + _y])) { \\\n game.grid[x][y] += (game.have_moved = 1); \\\n game.grid[x + _x][y + _y] = (0 * game.blocks_in_play--);\\\n game.score_last_move += values[game.grid[x][y]]; \\\n game.total_score += values[game.grid[x][y]]; \\\n } \\\n } \\\n } \\\n } while (0)\n\n game.score_last_move = 0;\n\n switch (d) {\n case D_LEFT:\n MERGE_DIRECTION(x, y, 0, < 3, 1, 0, < 4, 1, 1, 0);\n break;\n case D_RIGHT:\n MERGE_DIRECTION(x, y, 3, > 0, -1, 0, < 4, 1, -1, 0);\n break;\n case D_DOWN:\n MERGE_DIRECTION(y, x, 3, > 0, -1, 0, < 4, 1, 0, -1);\n break;\n case D_UP:\n MERGE_DIRECTION(y, x, 0, < 3, 1, 0, < 4, 1, 0, 1);\n break;\n }\n\n#undef MERGE_DIRECTION\n}\n\nvoid do_gravity(int d)\n{\n#define GRAVITATE_DIRECTION(_v1, _v2, _xs, _xc, _xi, _ys, _yc, _yi, _x, _y) \\\n do { \\\n int break_cond = 0; \\\n while (!break_cond) { \\\n break_cond = 1; \\\n for (int _v1 = _xs; _v1 _xc; _v1 += _xi) { \\\n for (int _v2 = _ys; _v2 _yc; _v2 += _yi) { \\\n if (!game.grid[x][y] && game.grid[x + _x][y + _y]) { \\\n game.grid[x][y] = game.grid[x + _x][y + _y]; \\\n game.grid[x + _x][y + _y] = break_cond = 0; \\\n game.have_moved = 1; \\\n } \\\n } \\\n } \\\n do_draw(); usleep(40000); \\\n } \\\n } while (0)\n\n switch (d) {\n case D_LEFT:\n GRAVITATE_DIRECTION(x, y, 0, < 3, 1, 0, < 4, 1, 1, 0);\n break;\n case D_RIGHT:\n GRAVITATE_DIRECTION(x, y, 3, > 0, -1, 0, < 4, 1, -1, 0);\n break;\n case D_DOWN:\n GRAVITATE_DIRECTION(y, x, 3, > 0, -1, 0, < 4, 1, 0, -1);\n break;\n case D_UP:\n GRAVITATE_DIRECTION(y, x, 0, < 3, 1, 0, < 4, 1, 0, 1);\n break;\n }\n\n#undef GRAVITATE_DIRECTION\n}\n\nint do_check_end_condition(void)\n{\n int ret = -1;\n for (int x = 0; x < 4; ++x) {\n for (int y = 0; y < 4; ++y) {\n if (values[game.grid[x][y]] == 2048)\n return 1;\n if (!game.grid[x][y] ||\n ((x + 1 < 4) && (game.grid[x][y] == game.grid[x + 1][y])) ||\n ((y + 1 < 4) && (game.grid[x][y] == game.grid[x][y + 1])))\n ret = 0;\n }\n }\n return ret;\n}\n\nint do_tick(int d)\n{\n game.have_moved = 0;\n do_gravity(d);\n do_merge(d);\n do_gravity(d);\n return game.have_moved;\n}\n\nvoid do_newblock(void) {\n if (game.blocks_in_play >= 16) return;\n\n int bn = rand() % (16 - game.blocks_in_play);\n int pn = 0;\n\n for (int x = 0; x < 4; ++x) {\n for (int y = 0; y < 4; ++y) {\n if (game.grid[x][y])\n continue;\n\n if (pn == bn){\n game.grid[x][y] = rand() % 10 ? 1 : 2;\n game.blocks_in_play += 1;\n return;\n }\n else {\n ++pn;\n }\n }\n }\n}\n\nint main(void)\n{\n \n tcgetattr(STDIN_FILENO, &oldt);\n newt = oldt;\n newt.c_lflag &= ~(ICANON | ECHO);\n tcsetattr(STDIN_FILENO, TCSANOW, &newt);\n\n srand(time(NULL));\n memset(&game, 0, sizeof(game));\n do_newblock();\n do_newblock();\n do_draw();\n\n while (1) {\n int found_valid_key, direction, value;\n do {\n found_valid_key = 1;\n direction = D_INVALID;\n value = getchar();\n switch (value) {\n case 'h': case 'a':\n direction = D_LEFT;\n break;\n case 'l': case 'd':\n direction = D_RIGHT;\n break;\n case 'j': case 's':\n direction = D_DOWN;\n break;\n case 'k': case 'w':\n direction = D_UP;\n break;\n case 'q':\n goto game_quit;\n break;\n case 27:\n if (getchar() == 91) {\n value = getchar();\n switch (value) {\n case 65:\n direction = D_UP;\n break;\n case 66:\n direction = D_DOWN;\n break;\n case 67:\n direction = D_RIGHT;\n break;\n case 68:\n direction = D_LEFT;\n break;\n default:\n found_valid_key = 0;\n break;\n }\n }\n break;\n default:\n found_valid_key = 0;\n break;\n }\n } while (!found_valid_key);\n\n do_tick(direction);\n if (game.have_moved != 0){\n do_newblock();\n }\n do_draw();\n\n switch (do_check_end_condition()) {\n case -1:\n goto game_lose;\n case 1:\n goto game_win;\n case 0:\n break;\n }\n }\n\n if (0)\ngame_lose:\n printf(\"You lose!\\n\");\n goto game_quit;\n if (0)\ngame_win:\n printf(\"You win!\\n\");\n goto game_quit;\n if (0)\ngame_quit:\n\n \n tcsetattr(STDIN_FILENO, TCSANOW, &oldt);\n return 0;\n}\n","Rust":"use std::io::{self,BufRead};\nextern crate rand;\n\nenum Usermove {\n Up,\n Down,\n Left,\n Right,\n}\n\nfn print_game(field :& [[u32;4];4] ){\n println!(\"{:?}\",&field[0] );\n println!(\"{:?}\",&field[1] );\n println!(\"{:?}\",&field[2] );\n println!(\"{:?}\",&field[3] );\n}\n\nfn get_usermove()-> Usermove {\n let umove: Usermove ;\n loop{\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n\n match input.chars().nth(0){\n Some('a') =>{umove = Usermove::Left ;break },\n Some('w') =>{umove = Usermove::Up ;break },\n Some('s') =>{umove = Usermove::Down ;break },\n Some('d') =>{umove = Usermove::Right;break },\n _ => {println!(\"input was {}: invalid character should be a,s,w or d \",input.chars().nth(0).unwrap());} ,\n }\n }\n umove\n}\n\n\n\n\n\n\n\n\n\nfn do_game_step(step : &Usermove, field:&mut [[u32;4];4]){\n match *step {\n Usermove::Left =>{\n for array in field{\n for col in 0..4 {\n for testcol in (col+1)..4 {\n if array[testcol] != 0 {\n if array[col] == 0 {\n array[col] += array[testcol];\n array[testcol] = 0;\n }\n else if array[col] == array[testcol] {\n array[col] += array[testcol];\n array[testcol] = 0;\n break;\n } else {\n break\n }\n }\n }\n }\n }\n } ,\n Usermove::Right=>{\n for array in field{\n for col in (0..4).rev() {\n for testcol in (0..col).rev() {\n if array[testcol] != 0 {\n if array[col] == 0 {\n array[col] += array[testcol];\n array[testcol] = 0;\n }\n else if array[col] == array[testcol] {\n array[col] += array[testcol];\n array[testcol] = 0;\n break;\n }else {\n break;\n }\n }\n }\n }\n }\n } ,\n Usermove::Down =>{\n for col in 0..4 {\n for row in (0..4).rev() {\n for testrow in (0..row).rev() {\n if field[testrow][col] != 0 {\n if field[row][col] == 0 {\n field[row][col] += field[testrow][col];\n field[testrow][col] = 0;\n } else if field[row][col] == field[testrow][col] {\n field[row][col] += field[testrow][col];\n field[testrow][col] = 0;\n break;\n }else {\n break;\n }\n\n }\n }\n }\n }\n } ,\n Usermove::Up =>{\n for col in 0..4 {\n for row in 0..4{\n for testrow in (row+1)..4 {\n if field[testrow][col] != 0 {\n if field[row][col] == 0 {\n field[row][col] += field[testrow][col];\n field[testrow][col] = 0;\n } else if field[row][col] == field[testrow][col] {\n field[row][col] += field[testrow][col];\n field[testrow][col] = 0;\n break;\n }else {\n break;\n }\n }\n }\n }\n }\n },\n }\n}\n\nfn spawn( field: &mut [[u32;4];4]){\n loop{\n let x = rand::random::();\n if field[x % 4][(x\/4)%4] == 0 {\n if x % 10 == 0 {\n field[x % 4][(x\/4)%4]= 4;\n }else{\n field[x % 4][(x\/4)%4]= 2;\n }\n break;\n }\n }\n}\n\n\nfn main() {\n let mut field : [[u32; 4];4] = [[0;4];4];\n let mut test : [[u32; 4];4] ;\n 'gameloop:loop {\n \n test=field.clone();\n spawn(&mut field);\n \n \n for i in [Usermove::Up,Usermove::Down,Usermove::Left,Usermove::Right].into_iter(){\n do_game_step(i, &mut test);\n if test != field{\n break;\n }\n match *i{\n Usermove::Right=> {\n println!(\"No more valid move, you lose\");\n break 'gameloop;\n },\n _=>{},\n }\n }\n print_game(&field);\n println!(\"move the blocks\");\n\n test=field.clone();\n while test==field {\n do_game_step(&get_usermove(), &mut field);\n }\n\n for row in field.iter(){\n if row.iter().any(|x| *x == 2048){\n print_game(&field );\n println!(\"You Won!!\");\n break;\n }\n }\n }\n}\n"} {"name":"24 game","C":"#include \n#include \n#include \n#include \n#include \n \njmp_buf ctx;\nconst char *msg;\n \nenum { OP_NONE = 0, OP_NUM, OP_ADD, OP_SUB, OP_MUL, OP_DIV };\n \ntypedef struct expr_t *expr, expr_t;\nstruct expr_t {\n\tint op, val, used;\n\texpr left, right;\n};\n \n#define N_DIGITS 4\nexpr_t digits[N_DIGITS];\n \nvoid gen_digits()\n{\n\tint i;\n\tfor (i = 0; i < N_DIGITS; i++)\n\t\tdigits[i].val = 1 + rand() % 9;\n}\n \n#define MAX_INPUT 64\nchar str[MAX_INPUT];\nint pos;\n \n#define POOL_SIZE 8\nexpr_t pool[POOL_SIZE];\nint pool_ptr;\n \nvoid reset()\n{\n\tint i;\n\tmsg = 0;\n\tpool_ptr = pos = 0;\n\tfor (i = 0; i < POOL_SIZE; i++) {\n\t\tpool[i].op = OP_NONE;\n\t\tpool[i].left = pool[i].right = 0;\n\t}\n\tfor (i = 0; i < N_DIGITS; i++)\n\t\tdigits[i].used = 0;\n}\n \n\nvoid bail(const char *s)\n{\n\tmsg = s;\n\tlongjmp(ctx, 1);\n}\n \nexpr new_expr()\n{\n\tif (pool_ptr < POOL_SIZE)\n\t\treturn pool + pool_ptr++;\n\treturn 0;\n}\n \n\nint next_tok()\n{\n\twhile (isspace(str[pos])) pos++;\n\treturn str[pos];\n}\n \n\nint take()\n{\n\tif (str[pos] != '\\0') return ++pos;\n\treturn 0;\n}\n \n\n \nexpr get_fact();\nexpr get_term();\nexpr get_expr();\n \nexpr get_expr()\n{\n\tint c;\n\texpr l, r, ret;\n\tif (!(ret = get_term())) bail(\"Expected term\");\n\twhile ((c = next_tok()) == '+' || c == '-') {\n\t\tif (!take()) bail(\"Unexpected end of input\");\n\t\tif (!(r = get_term())) bail(\"Expected term\");\n \n\t\tl = ret;\n\t\tret = new_expr();\n\t\tret->op = (c == '+') ? OP_ADD : OP_SUB;\n\t\tret->left = l;\n\t\tret->right = r;\n\t}\n\treturn ret;\n}\n \nexpr get_term()\n{\n\tint c;\n\texpr l, r, ret;\n\tret = get_fact();\n\twhile((c = next_tok()) == '*' || c == '\/') {\n\t\tif (!take()) bail(\"Unexpected end of input\");\n \n\t\tr = get_fact();\n\t\tl = ret;\n\t\tret = new_expr();\n\t\tret->op = (c == '*') ? OP_MUL : OP_DIV;\n\t\tret->left = l;\n\t\tret->right = r;\n\t}\n\treturn ret;\n}\n \nexpr get_digit()\n{\n\tint i, c = next_tok();\n\texpr ret;\n\tif (c >= '0' && c <= '9') {\n\t\ttake();\n\t\tret = new_expr();\n\t\tret->op = OP_NUM;\n\t\tret->val = c - '0';\n\t\tfor (i = 0; i < N_DIGITS; i++)\n\t\t\tif (digits[i].val == ret->val && !digits[i].used) {\n\t\t\t\tdigits[i].used = 1;\n\t\t\t\treturn ret;\n\t\t\t}\n\t\tbail(\"Invalid digit\");\n\t}\n\treturn 0;\n}\n \nexpr get_fact()\n{\n\tint c;\n\texpr l = get_digit();\n\tif (l) return l;\n\tif ((c = next_tok()) == '(') {\n\t\ttake();\n\t\tl = get_expr();\n\t\tif (next_tok() != ')') bail(\"Unbalanced parens\");\n\t\ttake();\n\t\treturn l;\n\t}\n\treturn 0;\n}\n \nexpr parse()\n{\n\tint i;\n\texpr ret = get_expr();\n\tif (next_tok() != '\\0')\n\t\tbail(\"Trailing garbage\");\n\tfor (i = 0; i < N_DIGITS; i++)\n\t\tif (!digits[i].used)\n\t\t\tbail(\"Not all digits are used\");\n\treturn ret;\n}\n \ntypedef struct frac_t frac_t, *frac;\nstruct frac_t { int denom, num; };\n \nint gcd(int m, int n)\n{\n\tint t;\n\twhile (m) {\n\t\tt = m; m = n % m; n = t;\n\t}\n\treturn n;\n}\n \n\nvoid eval_tree(expr e, frac res)\n{\n\tfrac_t l, r;\n\tint t;\n\tif (e->op == OP_NUM) {\n\t\tres->num = e->val;\n\t\tres->denom = 1;\n\t\treturn;\n\t}\n \n\teval_tree(e->left, &l);\n\teval_tree(e->right, &r);\n \n\tswitch(e->op) {\n\tcase OP_ADD:\n\t\tres->num = l.num * r.denom + l.denom * r.num;\n\t\tres->denom = l.denom * r.denom;\n\t\tbreak;\n\tcase OP_SUB:\n\t\tres->num = l.num * r.denom - l.denom * r.num;\n\t\tres->denom = l.denom * r.denom;\n\t\tbreak;\n\tcase OP_MUL:\n\t\tres->num = l.num * r.num;\n\t\tres->denom = l.denom * r.denom;\n\t\tbreak;\n\tcase OP_DIV:\n\t\tres->num = l.num * r.denom;\n\t\tres->denom = l.denom * r.num;\n\t\tbreak;\n\t}\n\tif ((t = gcd(res->denom, res->num))) {\n\t\tres->denom \/= t;\n\t\tres->num \/= t;\n\t}\n}\n \nvoid get_input()\n{\n\tint i;\nreinput:\n\treset();\n\tprintf(\"\\nAvailable digits are:\");\n\tfor (i = 0; i < N_DIGITS; i++) \n\t\tprintf(\" %d\", digits[i].val);\n\tprintf(\". Type an expression and I'll check it for you, or make new numbers.\\n\"\n\t\t\"Your choice? [Expr\/n\/q] \");\n \n\twhile (1) {\n\t\tfor (i = 0; i < MAX_INPUT; i++) str[i] = '\\n';\n\t\tfgets(str, MAX_INPUT, stdin);\n\t\tif (*str == '\\0') goto reinput;\n\t\tif (str[MAX_INPUT - 1] != '\\n')\n\t\t\tbail(\"string too long\");\n \n\t\tfor (i = 0; i < MAX_INPUT; i++)\n\t\t\tif (str[i] == '\\n') str[i] = '\\0';\n\t\tif (str[0] == 'q') {\n\t\t\tprintf(\"Bye\\n\");\n\t\t\texit(0);\n\t\t}\n\t\tif (str[0] == 'n') {\n\t\t\tgen_digits();\n\t\t\tgoto reinput;\n\t\t}\n\t\treturn;\n\t}\n}\n \nint main()\n{\n\tfrac_t f;\n\tsrand(time(0));\n \n\tgen_digits();\n\twhile(1) {\n\t\tget_input();\n\t\tsetjmp(ctx); \n\t\tif (msg) {\n\t\t\t\n\t\t\tprintf(\"%s at '%.*s'\\n\", msg, pos, str);\n\t\t\tcontinue;\n\t\t}\n \n\t\teval_tree(parse(), &f);\n \n\t\tif (f.denom == 0) bail(\"Divide by zero\");\n\t\tif (f.denom == 1 && f.num == 24)\n\t\t\tprintf(\"You got 24. Very good.\\n\");\n\t\telse {\n\t\t\tif (f.denom == 1)\n\t\t\t\tprintf(\"Eval to: %d, \", f.num);\n\t\t\telse\n\t\t\t\tprintf(\"Eval to: %d\/%d, \", f.num, f.denom);\n\t\t\tprintf(\"no good. Try again.\\n\");\n\t\t}\n\t}\n\treturn 0;\n}\n","Rust":"use std::io::{self,BufRead};\nextern crate rand;\nuse rand::Rng;\n\nfn op_type(x: char) -> i32{\n match x {\n '-' | '+' => return 1,\n '\/' | '*' => return 2,\n '(' | ')' => return -1,\n _ => return 0,\n }\n}\n\nfn to_rpn(input: &mut String){\n\n let mut rpn_string : String = String::new();\n let mut rpn_stack : String = String::new();\n let mut last_token = '#';\n for token in input.chars(){\n if token.is_digit(10) {\n rpn_string.push(token);\n }\n else if op_type(token) == 0 {\n continue;\n }\n else if op_type(token) > op_type(last_token) || token == '(' {\n rpn_stack.push(token);\n last_token=token;\n }\n else {\n while let Some(top) = rpn_stack.pop() {\n if top=='(' {\n break;\n }\n rpn_string.push(top);\n }\n if token != ')'{\n rpn_stack.push(token);\n }\n }\n }\n while let Some(top) = rpn_stack.pop() {\n rpn_string.push(top);\n }\n\n println!(\"you formula results in {}\", rpn_string);\n\n *input=rpn_string;\n}\n\nfn calculate(input: &String, list : &mut [u32;4]) -> f32{\n let mut stack : Vec = Vec::new();\n let mut accumulator : f32 = 0.0;\n\n for token in input.chars(){\n if token.is_digit(10) {\n let test = token.to_digit(10).unwrap() as u32;\n match list.iter().position(|&x| x == test){\n Some(idx) => list[idx]=10 ,\n _ => println!(\" invalid digit: {} \",test),\n }\n stack.push(accumulator);\n accumulator = test as f32;\n }else{\n let a = stack.pop().unwrap();\n accumulator = match token {\n '-' => a-accumulator,\n '+' => a+accumulator,\n '\/' => a\/accumulator,\n '*' => a*accumulator,\n _ => {accumulator},\n };\n }\n }\n println!(\"you formula results in {}\",accumulator);\n accumulator\n}\n\nfn main() {\n\n let mut rng = rand::thread_rng();\n let mut list :[u32;4]=[rng.gen::()%10,rng.gen::()%10,rng.gen::()%10,rng.gen::()%10];\n\n println!(\"form 24 with using + - \/ * {:?}\",list);\n \n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n \n to_rpn(&mut input);\n let result = calculate(&input, &mut list);\n\n if list.iter().any(|&list| list !=10){\n println!(\"and you used all numbers\");\n match result {\n 24.0 => println!(\"you won\"),\n _ => println!(\"but your formulla doesn't result in 24\"),\n }\n }else{\n println!(\"you didn't use all the numbers\");\n }\n\n}\n"} {"name":"24 game_Solve","C":"#include \n\ntypedef struct {int val, op, left, right;} Node;\n\nNode nodes[10000];\nint iNodes;\n\nint b;\nfloat eval(Node x){\n if (x.op != -1){\n float l = eval(nodes[x.left]), r = eval(nodes[x.right]);\n switch(x.op){\n case 0: return l+r;\n case 1: return l-r;\n case 2: return r-l;\n case 3: return l*r;\n case 4: return r?l\/r:(b=1,0);\n case 5: return l?r\/l:(b=1,0);\n }\n }\n else return x.val*1.;\n}\n\nvoid show(Node x){\n if (x.op != -1){\n printf(\"(\");\n switch(x.op){\n case 0: show(nodes[x.left]); printf(\" + \"); show(nodes[x.right]); break;\n case 1: show(nodes[x.left]); printf(\" - \"); show(nodes[x.right]); break;\n case 2: show(nodes[x.right]); printf(\" - \"); show(nodes[x.left]); break;\n case 3: show(nodes[x.left]); printf(\" * \"); show(nodes[x.right]); break;\n case 4: show(nodes[x.left]); printf(\" \/ \"); show(nodes[x.right]); break;\n case 5: show(nodes[x.right]); printf(\" \/ \"); show(nodes[x.left]); break;\n }\n printf(\")\");\n }\n else printf(\"%d\", x.val);\n}\n\nint float_fix(float x){ return x < 0.00001 && x > -0.00001; }\n\nvoid solutions(int a[], int n, float t, int s){\n if (s == n){\n b = 0;\n float e = eval(nodes[0]); \n \n if (!b && float_fix(e-t)){\n show(nodes[0]);\n printf(\"\\n\");\n }\n }\n else{\n nodes[iNodes++] = (typeof(Node)){a[s],-1,-1,-1};\n \n for (int op = 0; op < 6; op++){ \n int k = iNodes-1;\n for (int i = 0; i < k; i++){\n nodes[iNodes++] = nodes[i];\n nodes[i] = (typeof(Node)){-1,op,iNodes-1,iNodes-2};\n solutions(a, n, t, s+1);\n nodes[i] = nodes[--iNodes];\n }\n }\n \n iNodes--;\n }\n};\n\nint main(){\n \n\n int a[4] = {8, 3, 8, 3};\n float t = 24;\n\n \n\n nodes[0] = (typeof(Node)){a[0],-1,-1,-1};\n iNodes = 1;\n\n solutions(a, sizeof(a)\/sizeof(int), t, 1);\n\n return 0;\n}\n","Rust":"#[derive(Clone, Copy, Debug)]\nenum Operator {\n Sub,\n Plus,\n Mul,\n Div,\n}\n\n#[derive(Clone, Debug)]\nstruct Factor {\n content: String,\n value: i32,\n}\n\nfn apply(op: Operator, left: &[Factor], right: &[Factor]) -> Vec {\n let mut ret = Vec::new();\n for l in left.iter() {\n for r in right.iter() {\n use Operator::*;\n ret.push(match op {\n Sub if l.value > r.value => Factor {\n content: format!(\"({} - {})\", l.content, r.content),\n value: l.value - r.value,\n },\n Plus => Factor {\n content: format!(\"({} + {})\", l.content, r.content),\n value: l.value + r.value,\n },\n Mul => Factor {\n content: format!(\"({} x {})\", l.content, r.content),\n value: l.value * r.value,\n },\n Div if l.value >= r.value && r.value > 0 && l.value % r.value == 0 => Factor {\n content: format!(\"({} \/ {})\", l.content, r.content),\n value: l.value \/ r.value,\n },\n _ => continue,\n })\n }\n }\n ret\n}\n\nfn calc(op: [Operator; 3], numbers: [i32; 4]) -> Vec {\n fn calc(op: &[Operator], numbers: &[i32], acc: &[Factor]) -> Vec {\n use Operator::*;\n if op.is_empty() {\n return Vec::from(acc)\n }\n let mut ret = Vec::new();\n let mono_factor = [Factor {\n content: numbers[0].to_string(),\n value: numbers[0],\n }];\n match op[0] {\n Mul => ret.extend_from_slice(&apply(op[0], acc, &mono_factor)),\n Div => {\n ret.extend_from_slice(&apply(op[0], acc, &mono_factor));\n ret.extend_from_slice(&apply(op[0], &mono_factor, acc));\n },\n Sub => {\n ret.extend_from_slice(&apply(op[0], acc, &mono_factor));\n ret.extend_from_slice(&apply(op[0], &mono_factor, acc));\n },\n Plus => ret.extend_from_slice(&apply(op[0], acc, &mono_factor)), \n }\n calc(&op[1..], &numbers[1..], &ret)\n }\n calc(&op, &numbers[1..], &[Factor { content: numbers[0].to_string(), value: numbers[0] }])\n}\n\nfn solutions(numbers: [i32; 4]) -> Vec {\n use std::collections::hash_set::HashSet;\n let mut ret = Vec::new();\n let mut hash_set = HashSet::new();\n \n for ops in OpIter(0) {\n for o in orders().iter() {\n let numbers = apply_order(numbers, o);\n let r = calc(ops, numbers);\n ret.extend(r.into_iter().filter(|&Factor { value, ref content }| value == 24 && hash_set.insert(content.to_owned())))\n }\n }\n ret\n}\n\nfn main() {\n let mut numbers = Vec::new();\n if let Some(input) = std::env::args().skip(1).next() {\n for c in input.chars() {\n if let Ok(n) = c.to_string().parse() {\n numbers.push(n)\n }\n if numbers.len() == 4 {\n let numbers = [numbers[0], numbers[1], numbers[2], numbers[3]];\n let solutions = solutions(numbers);\n let len = solutions.len();\n if len == 0 {\n println!(\"no solution for {}, {}, {}, {}\", numbers[0], numbers[1], numbers[2], numbers[3]);\n return\n }\n println!(\"solutions for {}, {}, {}, {}\", numbers[0], numbers[1], numbers[2], numbers[3]);\n for s in solutions {\n println!(\"{}\", s.content)\n }\n println!(\"{} solutions found\", len);\n return\n }\n }\n } else {\n println!(\"empty input\")\n }\n}\n\n\nstruct OpIter (usize);\n\nimpl Iterator for OpIter {\n type Item = [Operator; 3];\n fn next(&mut self) -> Option<[Operator; 3]> {\n use Operator::*;\n const OPTIONS: [Operator; 4] = [Mul, Sub, Plus, Div];\n if self.0 >= 1 << 6 {\n return None\n }\n let f1 = OPTIONS[(self.0 & (3 << 4)) >> 4];\n let f2 = OPTIONS[(self.0 & (3 << 2)) >> 2];\n let f3 = OPTIONS[(self.0 & (3 << 0)) >> 0];\n self.0 += 1;\n Some([f1, f2, f3])\n }\n}\n\nfn orders() -> [[usize; 4]; 24] {\n [\n [0, 1, 2, 3],\n [0, 1, 3, 2],\n [0, 2, 1, 3],\n [0, 2, 3, 1],\n [0, 3, 1, 2],\n [0, 3, 2, 1],\n [1, 0, 2, 3],\n [1, 0, 3, 2],\n [1, 2, 0, 3],\n [1, 2, 3, 0],\n [1, 3, 0, 2],\n [1, 3, 2, 0],\n [2, 0, 1, 3],\n [2, 0, 3, 1],\n [2, 1, 0, 3],\n [2, 1, 3, 0],\n [2, 3, 0, 1],\n [2, 3, 1, 0],\n [3, 0, 1, 2],\n [3, 0, 2, 1],\n [3, 1, 0, 2],\n [3, 1, 2, 0],\n [3, 2, 0, 1],\n [3, 2, 1, 0]\n ]\n}\n\nfn apply_order(numbers: [i32; 4], order: &[usize; 4]) -> [i32; 4] {\n [numbers[order[0]], numbers[order[1]], numbers[order[2]], numbers[order[3]]]\n}\n"} {"name":"Abbreviations, easy","C":"#include \n#include \n#include \n#include \n#include \n\nconst char* command_table =\n \"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy \"\n \"COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find \"\n \"NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput \"\n \"Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO \"\n \"MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT \"\n \"READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT \"\n \"RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up\";\n\ntypedef struct command_tag {\n char* cmd;\n size_t length;\n size_t min_len;\n struct command_tag* next;\n} command_t;\n\n\nbool command_match(const command_t* command, const char* str) {\n size_t olen = strlen(str);\n return olen >= command->min_len && olen <= command->length\n && strncmp(str, command->cmd, olen) == 0;\n}\n\n\nchar* uppercase(char* str, size_t n) {\n for (size_t i = 0; i < n; ++i)\n str[i] = toupper((unsigned char)str[i]);\n return str;\n}\n\nsize_t get_min_length(const char* str, size_t n) {\n size_t len = 0;\n while (len < n && isupper((unsigned char)str[len]))\n ++len;\n return len;\n}\n\nvoid fatal(const char* message) {\n fprintf(stderr, \"%s\\n\", message);\n exit(1);\n}\n\nvoid* xmalloc(size_t n) {\n void* ptr = malloc(n);\n if (ptr == NULL)\n fatal(\"Out of memory\");\n return ptr;\n}\n\nvoid* xrealloc(void* p, size_t n) {\n void* ptr = realloc(p, n);\n if (ptr == NULL)\n fatal(\"Out of memory\");\n return ptr;\n}\n\nchar** split_into_words(const char* str, size_t* count) {\n size_t size = 0;\n size_t capacity = 16;\n char** words = xmalloc(capacity * sizeof(char*));\n size_t len = strlen(str);\n for (size_t begin = 0; begin < len; ) {\n size_t i = begin;\n for (; i < len && isspace((unsigned char)str[i]); ++i) {}\n begin = i;\n for (; i < len && !isspace((unsigned char)str[i]); ++i) {}\n size_t word_len = i - begin;\n if (word_len == 0)\n break;\n char* word = xmalloc(word_len + 1);\n memcpy(word, str + begin, word_len);\n word[word_len] = 0;\n begin += word_len;\n if (capacity == size) {\n capacity *= 2;\n words = xrealloc(words, capacity * sizeof(char*));\n }\n words[size++] = word;\n }\n *count = size;\n return words;\n}\n\ncommand_t* make_command_list(const char* table) {\n command_t* cmd = NULL;\n size_t count = 0;\n char** words = split_into_words(table, &count);\n for (size_t i = 0; i < count; ++i) {\n char* word = words[i];\n command_t* new_cmd = xmalloc(sizeof(command_t));\n size_t word_len = strlen(word);\n new_cmd->length = word_len;\n new_cmd->min_len = get_min_length(word, word_len);\n new_cmd->cmd = uppercase(word, word_len);\n new_cmd->next = cmd;\n cmd = new_cmd;\n }\n free(words);\n return cmd;\n}\n\nvoid free_command_list(command_t* cmd) {\n while (cmd != NULL) {\n command_t* next = cmd->next;\n free(cmd->cmd);\n free(cmd);\n cmd = next;\n }\n}\n\nconst command_t* find_command(const command_t* commands, const char* word) {\n for (const command_t* cmd = commands; cmd != NULL; cmd = cmd->next) {\n if (command_match(cmd, word))\n return cmd;\n }\n return NULL;\n}\n\nvoid test(const command_t* commands, const char* input) {\n printf(\" input: %s\\n\", input);\n printf(\"output:\");\n size_t count = 0;\n char** words = split_into_words(input, &count);\n for (size_t i = 0; i < count; ++i) {\n char* word = words[i];\n uppercase(word, strlen(word));\n const command_t* cmd_ptr = find_command(commands, word);\n printf(\" %s\", cmd_ptr ? cmd_ptr->cmd : \"*error*\");\n free(word);\n }\n free(words);\n printf(\"\\n\");\n}\n\nint main() {\n command_t* commands = make_command_list(command_table);\n const char* input = \"riG rePEAT copies put mo rest types fup. 6 poweRin\";\n test(commands, input);\n free_command_list(commands);\n return 0;\n}\n","Rust":"use std::collections::HashMap;\n\nfn main() {\n let commands = \"\n Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy \\\n COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find \\\n NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput \\\n Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO \\\n MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT \\\n READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT \\\n RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up \\\n \";\n let split = commands.split_ascii_whitespace();\n let count_hashtable: HashMap<&str, usize> = split.map(|word| {\n (word, word.chars().take_while(|c| c.is_ascii_uppercase()).count())\n }).collect();\n\n let line = \"riG rePEAT copies put mo rest types fup. 6 poweRin\";\n let mut words_vec: Vec = vec![];\n for word in line.split_ascii_whitespace() {\n let split = commands.split_ascii_whitespace();\n let abbr = split.filter(|x| {\n x.to_ascii_lowercase().starts_with(&word.to_ascii_lowercase()) &&\n word.len() >= *count_hashtable.get(x).unwrap()\n }).next();\n words_vec.push(match abbr {\n Some(word) => word.to_ascii_uppercase(),\n None => String::from(\"*error*\"),\n });\n }\n let corrected_line = words_vec.join(\" \");\n println!(\"{}\", corrected_line);\n}\n"} {"name":"Abelian sandpile model","C":"#include\n#include\n#include\n\nint main(int argc, char** argv)\n{\n\tint i,j,sandPileEdge, centerPileHeight, processAgain = 1,top,down,left,right;\t\n\tint** sandPile;\n\tchar* fileName;\n\tstatic unsigned char colour[3];\n\n\tif(argc!=3){\n\t\tprintf(\"Usage: %s
\",argv[0]);\n\t\treturn 0;\n\t}\n\n\tsandPileEdge = atoi(argv[1]);\n\tcenterPileHeight = atoi(argv[2]);\n\n\tif(sandPileEdge<=0 || centerPileHeight<=0){\n\t\tprintf(\"Sand pile and center pile dimensions must be positive integers.\");\n\t\treturn 0;\n\t}\n\n\tsandPile = (int**)malloc(sandPileEdge * sizeof(int*));\n\n\tfor(i=0;i=4){\t\t\t\t\n\t\t\t\t\tif(i-1>=0){\n\t\t\t\t\t\ttop = 1;\n\t\t\t\t\t\tsandPile[i-1][j]+=1;\n\t\t\t\t\t\tif(sandPile[i-1][j]>=4)\n\t\t\t\t\t\t\tprocessAgain = 1;\n\t\t\t\t\t}\n\t\t\t\t\tif(i+1=4)\n\t\t\t\t\t\t\tprocessAgain = 1;\n\t\t\t\t\t}\n\t\t\t\t\tif(j-1>=0){\n\t\t\t\t\t\tleft = 1;\n\t\t\t\t\t\tsandPile[i][j-1]+=1;\n\t\t\t\t\t\tif(sandPile[i][j-1]>=4)\n\t\t\t\t\t\t\tprocessAgain = 1;\n\t\t\t\t\t}\n\t\t\t\t\tif(j+1=4)\n\t\t\t\t\t\t\tprocessAgain = 1;\n\t\t\t\t\t}\n\t\t\t\tsandPile[i][j] -= (top + down + left + right);\n\t\t\t\tif(sandPile[i][j]>=4)\n\t\t\t\t\tprocessAgain = 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprintf(\"Final sand pile\u00a0: \\n\\n\");\n\n\tfor(i=0;i>, boundary: &mut [usize; 4]) -> bool\n{ \n \n let mut done = false;\n\n for y in boundary[0]..boundary[2]\n {\n for x in boundary[1]..boundary[3]\n {\n if field[y][x] >= 4\n {\n \n \n \n\n \n \n let rem: usize = field[y][x] \/ 4;\n field[y][x] %= 4;\n\n \n \n \n if y as isize - 1 >= 0 {field[y-1][x] += rem; if y == boundary[0] {boundary[0]-=1;}}\n if x as isize - 1 >= 0 {field[y][x-1] += rem; if x == boundary[1] {boundary[1]-=1;}}\n if y+1 < field.len() {field[y+1][x] += rem; if x == boundary[2]-1 {boundary[2]+=1;}}\n if x+1 < field.len() {field[y][x+1] += rem; if y == boundary[3]-1 {boundary[3]+=1;}}\n\n done = true;\n }\n }\n }\n\n done\n}\n\n\n\n\n\n\n\nfn display(field: &Vec>)\n{\n for row in field\n {\n let char_row = {\n row.iter().map(|c| {match c {\n 0 => ' ',\n 1 => '\u2591',\n 2 => '\u2592',\n 3 => '\u2593',\n _ => '\u2588'\n }}).collect::()\n };\n println!(\"{}\", char_row);\n }\n}\n\n\n\n\n\n\n\nfn write_pile(pile: &Vec>) {\n use std::fs::File;\n use std::io::Write;\n\n \n let mut file = File::create(\".\/output.ppm\").unwrap();\n\n \n write!(file, \"P3\\n{} {}\\n255\\n\", pile.len(), pile.len()).unwrap();\n\n for row in pile {\n \n \n let mut line = String::with_capacity(row.len() * 14);\n\n \n \n for elem in row {\n line.push_str(match elem {\n 0 => \"100 40 15 \",\n 1 => \"117 87 30 \",\n 2 => \"181 134 47 \",\n 3 => \"245 182 66 \",\n _ => unreachable!(),\n });\n }\n\n \n write!(file, \"{}\\n\", line).unwrap();\n }\n}\n\nfn main() {\n \n let field_size = 16;\n let mut playfield = vec![vec![0; field_size]; field_size];\n\n \n \n \n \n \n let mut boundary = [field_size\/2-1, field_size\/2-1, field_size\/2, field_size\/2];\n playfield[field_size\/2 - 1][field_size\/2 - 1] = 16;\n\n \n \n while advance(&mut playfield, &mut boundary) {};\n\n \n \n display(&playfield);\n \n}\n"} {"name":"Active Directory_Connect","C":"#include \n...\nchar *name, *password;\n...\nLDAP *ld = ldap_init(\"ldap.somewhere.com\", 389);\nldap_simple_bind_s(ld, name, password);\n... after done with it...\nldap_unbind(ld);\n","Rust":"let conn = ldap3::LdapConn::new(\"ldap:\nconn.simple_bind(\"bind_dn\", \"bind_pass\")?.success()?;\n"} {"name":"Air mass","C":"#include \n#include \n\n#define DEG 0.017453292519943295769236907684886127134 \n#define RE 6371000.0 \n#define DD 0.001 \n#define FIN 10000000.0 \n\nstatic double rho(double a) {\n \n return exp(-a \/ 8500.0);\n}\n\nstatic double height(double a, double z, double d) {\n \n \n \n double aa = RE + a;\n double hh = sqrt(aa * aa + d * d - 2.0 * d * aa * cos((180 - z) * DEG));\n return hh - RE;\n}\n\nstatic double column_density(double a, double z) {\n \n double sum = 0.0, d = 0.0;\n while (d < FIN) {\n \n double delta = DD * d;\n if (delta < DD)\n delta = DD;\n sum += rho(height(a, z, d + 0.5 * delta)) * delta;\n d += delta;\n }\n return sum;\n}\n\nstatic double airmass(double a, double z) {\n return column_density(a, z) \/ column_density(a, 0.0);\n}\n\nint main() {\n puts(\"Angle 0 m 13700 m\");\n puts(\"------------------------------------\");\n for (double z = 0; z <= 90; z+= 5) {\n printf(\"%2.0f %11.8f %11.8f\\n\",\n z, airmass(0.0, z), airmass(13700.0, z));\n }\n}\n","Rust":"const RE: f64 = 6371000.0; \nconst DD: f64 = 0.001; \nconst FIN: f64 = 10000000.0; \n\nfn rho(a: f64) -> f64 {\n \n (-a \/ 8500.0).exp()\n}\n\nfn height(a: f64, z: f64, d: f64) -> f64 {\n \n \n \n let aa = RE + a;\n let hh = (aa * aa + d * d - 2.0 * d * aa * (180.0 - z).to_radians().cos()).sqrt();\n hh - RE\n}\n\nfn column_density(a: f64, z: f64) -> f64 {\n \n let mut sum = 0.0;\n let mut d = 0.0;\n while d < FIN {\n \n let mut delta = DD * d;\n if delta < DD {\n delta = DD;\n }\n sum += rho(height(a, z, d + 0.5 * delta)) * delta;\n d += delta;\n }\n sum\n}\n\nfn airmass(a: f64, z: f64) -> f64 {\n column_density(a, z) \/ column_density(a, 0.0)\n}\n\nfn main() {\n println!(\"Angle 0 m 13700 m\");\n println!(\"------------------------------------\");\n for a in (0..=90).step_by(5) {\n let z = a as f64;\n println!(\n \"{:2} {:11.8} {:11.8}\",\n z,\n airmass(0.0, z),\n airmass(13700.0, z)\n );\n }\n}\n"} {"name":"Aliquot sequence classifications","C":"#include\n#include\n#include\n\nunsigned long long bruteForceProperDivisorSum(unsigned long long n){\n\tunsigned long long i,sum = 0;\n\t\n\tfor(i=1;i<(n+1)\/2;i++)\n\t\tif(n%i==0 && n!=i)\n\t\t\tsum += i;\n\t\t\n\treturn sum;\n}\n\nvoid printSeries(unsigned long long* arr,int size,char* type){\n\tint i;\n\t\n\tprintf(\"\\nInteger\u00a0: %llu, Type\u00a0: %s, Series\u00a0: \",arr[0],type);\n\t\n\tfor(i=0;i\",argV[0]);\n\telse{\n\t\tif(strchr(argV[1],'.')!=NULL)\n\t\t\tprocessFile(argV[1]);\n\t\telse\n\t\t\taliquotClassifier(strtoull(argV[1],(char**)NULL,10));\n\t}\n\treturn 0;\n}\n","Rust":"#[derive(Debug)]\nenum AliquotType { Terminating, Perfect, Amicable, Sociable, Aspiring, Cyclic, NonTerminating }\n\nfn classify_aliquot(num: i64) -> (AliquotType, Vec) {\n let limit = 1i64 << 47; \n let mut terms = Some(num).into_iter().collect::>();\n for i in 0..16 {\n let n = terms[i];\n let divsum = (1..(n + 1) \/ 2 + 1).filter(|&x| n % x == 0 && n != x).fold(0, |sum, x| sum + x);\n let classification = if divsum == 0 {\n Some(AliquotType::Terminating)\n }\n else if divsum > limit {\n Some(AliquotType::NonTerminating)\n }\n else if let Some(prev_idx) = terms.iter().position(|&x| x == divsum) {\n let cycle_len = terms.len() - prev_idx;\n Some(if prev_idx == 0 {\n match cycle_len {\n 1 => AliquotType::Perfect,\n 2 => AliquotType::Amicable,\n _ => AliquotType::Sociable\n }\n }\n else {\n if cycle_len == 1 {AliquotType::Aspiring} else {AliquotType::Cyclic}\n })\n }\n else {\n None\n };\n terms.push(divsum);\n if let Some(result) = classification {\n return (result, terms);\n }\n }\n (AliquotType::NonTerminating, terms)\n}\n\nfn main() {\n let nums = [1i64, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 28, 496, 220, 1184, 12496, 1264460, 790, 909, 562, 1064, 1488];\n for num in &nums {\n println!(\"{} {:?}\", num, classify_aliquot(*num));\n }\n}\n"} {"name":"Angles (geometric), normalization and conversion","C":"#define PI 3.141592653589793\n#define TWO_PI 6.283185307179586\n\ndouble normalize2deg(double a) {\n while (a < 0) a += 360;\n while (a >= 360) a -= 360;\n return a;\n}\ndouble normalize2grad(double a) {\n while (a < 0) a += 400;\n while (a >= 400) a -= 400;\n return a;\n}\ndouble normalize2mil(double a) {\n while (a < 0) a += 6400;\n while (a >= 6400) a -= 6400;\n return a;\n}\ndouble normalize2rad(double a) {\n while (a < 0) a += TWO_PI;\n while (a >= TWO_PI) a -= TWO_PI;\n return a;\n}\n\ndouble deg2grad(double a) {return a * 10 \/ 9;}\ndouble deg2mil(double a) {return a * 160 \/ 9;}\ndouble deg2rad(double a) {return a * PI \/ 180;}\n\ndouble grad2deg(double a) {return a * 9 \/ 10;}\ndouble grad2mil(double a) {return a * 16;}\ndouble grad2rad(double a) {return a * PI \/ 200;}\n\ndouble mil2deg(double a) {return a * 9 \/ 160;}\ndouble mil2grad(double a) {return a \/ 16;}\ndouble mil2rad(double a) {return a * PI \/ 3200;}\n\ndouble rad2deg(double a) {return a * 180 \/ PI;}\ndouble rad2grad(double a) {return a * 200 \/ PI;}\ndouble rad2mil(double a) {return a * 3200 \/ PI;}\n","Rust":"use std::{\n marker::PhantomData,\n f64::consts::PI,\n};\n\npub trait AngleUnit: Copy {\n const TURN: f64;\n const NAME: &'static str;\n}\n\nmacro_rules! unit {\n ($name:ident, $value:expr, $string:expr) => (\n #[derive(Debug, Copy, Clone)]\n struct $name;\n impl AngleUnit for $name {\n const TURN: f64 = $value;\n const NAME: &'static str = $string;\n }\n );\n}\n\nunit!(Degrees, 360.0, \"Degrees\");\nunit!(Radians, PI * 2.0, \"Radians\");\nunit!(Gradians, 400.0, \"Gradians\");\nunit!(Mils, 6400.0, \"Mils\");\n\n#[derive(Copy, Clone, PartialEq, PartialOrd)]\nstruct Angle(f64, PhantomData);\n\nimpl Angle {\n pub fn new(val: f64) -> Self {\n Self(val, PhantomData)\n }\n\n pub fn normalize(self) -> Self {\n Self(self.0 % T::TURN, PhantomData)\n }\n\n pub fn val(self) -> f64 {\n self.0\n }\n\n pub fn convert(self) -> Angle {\n Angle::new(self.0 * U::TURN \/ T::TURN)\n }\n\n pub fn name(self) -> &'static str {\n T::NAME\n }\n}\n\nfn print_angles() {\n let angles = [-2.0, -1.0, 0.0, 1.0, 2.0, 6.2831853, 16.0, 57.2957795, 359.0, 399.0, 6399.0, 1000000.0];\n println!(\"{:<12} {:<12} {:<12} {:<12} {:<12} {:<12}\", \"Angle\", \"Unit\", \"Degrees\", \"Gradians\", \"Mils\", \"Radians\");\n\n for &angle in &angles {\n let deg = Angle::::new(angle).normalize();\n println!(\"{:<12} {:<12} {:<12.4} {:<12.4} {:<12.4} {:<12.4}\",\n angle,\n deg.name(),\n deg.convert::().val(),\n deg.convert::().val(),\n deg.convert::().val(),\n deg.convert::().val(),\n );\n }\n\n println!();\n}\n\nfn main() {\n print_angles::();\n print_angles::();\n print_angles::();\n print_angles::();\n}\n"} {"name":"Arena storage pool","C":"#include \n","Rust":"#![feature(rustc_private)]\n\nextern crate arena;\n\nuse arena::TypedArena;\n\nfn main() {\n \n \n \n \n let arena = TypedArena::new();\n\n \n \n \n \n let v1 = arena.alloc(1i32);\n\n \n let v2 = arena.alloc(3);\n *v2 += 38;\n println!(\"{}\", *v1 + *v2);\n\n \n \n}\n"} {"name":"Arithmetic numbers","C":"#include \n\nvoid divisor_count_and_sum(unsigned int n, unsigned int* pcount,\n unsigned int* psum) {\n unsigned int divisor_count = 1;\n unsigned int divisor_sum = 1;\n unsigned int power = 2;\n for (; (n & 1) == 0; power <<= 1, n >>= 1) {\n ++divisor_count;\n divisor_sum += power;\n }\n for (unsigned int p = 3; p * p <= n; p += 2) {\n unsigned int count = 1, sum = 1;\n for (power = p; n % p == 0; power *= p, n \/= p) {\n ++count;\n sum += power;\n }\n divisor_count *= count;\n divisor_sum *= sum;\n }\n if (n > 1) {\n divisor_count *= 2;\n divisor_sum *= n + 1;\n }\n *pcount = divisor_count;\n *psum = divisor_sum;\n}\n\nint main() {\n unsigned int arithmetic_count = 0;\n unsigned int composite_count = 0;\n\n for (unsigned int n = 1; arithmetic_count <= 1000000; ++n) {\n unsigned int divisor_count;\n unsigned int divisor_sum;\n divisor_count_and_sum(n, &divisor_count, &divisor_sum);\n if (divisor_sum % divisor_count != 0)\n continue;\n ++arithmetic_count;\n if (divisor_count > 2)\n ++composite_count;\n if (arithmetic_count <= 100) {\n printf(\"%3u \", n);\n if (arithmetic_count % 10 == 0)\n printf(\"\\n\");\n }\n if (arithmetic_count == 1000 || arithmetic_count == 10000 ||\n arithmetic_count == 100000 || arithmetic_count == 1000000) {\n printf(\"\\n%uth arithmetic number is %u\\n\", arithmetic_count, n);\n printf(\"Number of composite arithmetic numbers <= %u: %u\\n\", n,\n composite_count);\n }\n }\n return 0;\n}\n","Rust":"fn divisor_count_and_sum(mut n: u32) -> (u32, u32) {\n let mut divisor_count = 1;\n let mut divisor_sum = 1;\n let mut power = 2;\n while (n & 1) == 0 {\n divisor_count += 1;\n divisor_sum += power;\n power <<= 1;\n n >>= 1;\n }\n let mut p = 3;\n while p * p <= n {\n let mut count = 1;\n let mut sum = 1;\n power = p;\n while n % p == 0 {\n count += 1;\n sum += power;\n power *= p;\n n \/= p;\n }\n divisor_count *= count;\n divisor_sum *= sum;\n p += 2;\n }\n if n > 1 {\n divisor_count *= 2;\n divisor_sum *= n + 1;\n }\n (divisor_count, divisor_sum)\n}\n\nfn main() {\n let mut arithmetic_count = 0;\n let mut composite_count = 0;\n let mut n = 1;\n while arithmetic_count <= 1000000 {\n let (divisor_count, divisor_sum) = divisor_count_and_sum(n);\n if divisor_sum % divisor_count != 0 {\n n += 1;\n continue;\n }\n arithmetic_count += 1;\n if divisor_count > 2 {\n composite_count += 1;\n }\n if arithmetic_count <= 100 {\n print!(\"{:3} \", n);\n if arithmetic_count % 10 == 0 {\n println!();\n }\n }\n if arithmetic_count == 1000\n || arithmetic_count == 10000\n || arithmetic_count == 100000\n || arithmetic_count == 1000000\n {\n println!(\"\\n{}th arithmetic number is {}\", arithmetic_count, n);\n println!(\n \"Number of composite arithmetic numbers <= {}: {}\",\n n, composite_count\n );\n }\n n += 1;\n }\n}\n"} {"name":"Arithmetic-geometric mean_Calculate Pi","C":"#include \"gmp.h\"\n\nvoid agm (const mpf_t in1, const mpf_t in2, mpf_t out1, mpf_t out2) {\n\tmpf_add (out1, in1, in2);\n\tmpf_div_ui (out1, out1, 2);\n\tmpf_mul (out2, in1, in2);\n\tmpf_sqrt (out2, out2);\n}\n\nint main (void) {\n\tmpf_set_default_prec (300000);\n\tmpf_t x0, y0, resA, resB, Z, var;\n\n\tmpf_init_set_ui (x0, 1);\n\tmpf_init_set_d (y0, 0.5);\n\tmpf_sqrt (y0, y0);\n\tmpf_init (resA);\n\tmpf_init (resB);\n\tmpf_init_set_d (Z, 0.25);\n\tmpf_init (var);\n\n\tint n = 1;\n int i;\n\tfor(i=0; i<8; i++){\n\t\tagm(x0, y0, resA, resB);\n\t\tmpf_sub(var, resA, x0);\n\t\tmpf_mul(var, var, var);\n\t\tmpf_mul_ui(var, var, n);\n\t\tmpf_sub(Z, Z, var);\n\t\tn += n;\n\t\tagm(resA, resB, x0, y0);\n\t\tmpf_sub(var, x0, resA);\n\t\tmpf_mul(var, var, var);\n\t\tmpf_mul_ui(var, var, n);\n\t\tmpf_sub(Z, Z, var);\n\t\tn += n;\n\t}\n\tmpf_mul(x0, x0, x0);\n\tmpf_div(x0, x0, Z);\n\tgmp_printf (\"%.100000Ff\\n\", x0);\n\treturn 0;\n}\n","Rust":"\npub fn pi(n: usize) -> f64 {\n let mut a : f64 = 1.0;\n let two : f64= 2.0;\n let mut g = 1.0 \/ two.sqrt();\n let mut s = 0.0;\n let mut k = 1;\n while k<=n {\n \n let a1 = (a+g)\/two;\n let g1 = (a*g).sqrt();\n a = a1;\n g = g1;\n s += (a.powi(2)-g.powi(2)) * two.powi((k+1) as i32);\n k += 1;\n \n\n }\n\n 4.0 * a.powi(2) \/ (1.0-s)\n}\n"} {"name":"Banker's algorithm","C":"#include \n#include \n\nint main() {\n int curr[5][5];\n int max_claim[5][5];\n int avl[5];\n int alloc[5] = {0, 0, 0, 0, 0};\n int max_res[5];\n int running[5];\n\n int i, j, exec, r, p;\n int count = 0;\n bool safe = false;\n\n printf(\"\\nEnter the number of resources: \");\n scanf(\"%d\", &r);\n\n printf(\"\\nEnter the number of processes: \");\n scanf(\"%d\", &p);\n for (i = 0; i < p; i++) {\n running[i] = 1;\n count++;\n }\n\n printf(\"\\nEnter Claim Vector: \");\n for (i = 0; i < r; i++)\n scanf(\"%d\", &max_res[i]);\n\n printf(\"\\nEnter Allocated Resource Table: \");\n for (i = 0; i < p; i++) {\n for (j = 0; j < r; j++)\n scanf(\"%d\", &curr[i][j]);\n }\n\n printf(\"\\nEnter Maximum Claim table: \");\n for (i = 0; i < p; i++) {\n for (j = 0; j < r; j++)\n scanf(\"%d\", &max_claim[i][j]);\n }\n\n printf(\"\\nThe Claim Vector is: \");\n for (i = 0; i < r; i++)\n printf(\"%d \", max_res[i]);\n\n printf(\"\\nThe Allocated Resource Table:\\n\");\n for (i = 0; i < p; i++) {\n for (j = 0; j < r; j++)\n printf(\"\\t%d\", curr[i][j]);\n printf(\"\\n\");\n }\n\n printf(\"\\nThe Maximum Claim Table:\\n\");\n for (i = 0; i < p; i++) {\n for (j = 0; j < r; j++)\n printf(\"\\t%d\", max_claim[i][j]);\n printf(\"\\n\");\n }\n\n for (i = 0; i < p; i++)\n for (j = 0; j < r; j++)\n alloc[j] += curr[i][j];\n\n printf(\"\\nAllocated resources: \");\n for (i = 0; i < r; i++)\n printf(\"%d \", alloc[i]);\n for (i = 0; i < r; i++)\n avl[i] = max_res[i] - alloc[i];\n\n printf(\"\\nAvailable resources: \");\n for (i = 0; i < r; i++)\n printf(\"%d \", avl[i]);\n printf(\"\\n\");\n\n while (count != 0) {\n safe = false;\n for (i = 0; i < p; i++) {\n if (running[i]) {\n exec = 1;\n for (j = 0; j < r; j++) {\n if (max_claim[i][j] - curr[i][j] > avl[j]) {\n exec = 0;\n break;\n }\n }\n\n if (exec) {\n printf(\"\\nProcess%d is executing.\\n\", i + 1);\n running[i] = 0;\n count--;\n safe = true;\n for (j = 0; j < r; j++)\n avl[j] += curr[i][j];\n break;\n }\n }\n }\n\n if (!safe) {\n printf(\"\\nThe processes are in unsafe state.\");\n break;\n }\n\n if (safe)\n printf(\"\\nThe process is in safe state.\");\n\n printf(\"\\nAvailable vector: \");\n for (i = 0; i < r; i++)\n printf(\"%d \", avl[i]);\n }\n\n return 0;\n}\n","Rust":"fn read_numbers() -> Vec\nwhere T: std::str::FromStr {\n use std::io::Write;\n std::io::stdout().flush().unwrap();\n\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split(\" \").map(|word| word.trim().parse::().ok().unwrap()).collect()\n}\n\nfn main() {\n print!(\"Enter the number of resources: \");\n let r = read_numbers()[0];\n \n print!(\"Enter the number of processes: \");\n let p = read_numbers()[0];\n let mut running = vec![true; p];\n let mut count = p;\n \n print!(\"Enter the {}-item claim vector: \", r);\n let max_res = read_numbers::();\n\n println!(\"Enter the {}-line {}-column allocated-resource table:\", p, r);\n let mut curr = vec![vec![0; 0]; p];\n for i in 0..p {\n curr[i] = read_numbers::();\n }\n \n println!(\"Enter the {}-line {}-column maximum-claim table:\", p, r);\n let mut max_claim = vec![vec![0; 0]; p];\n for i in 0..p {\n max_claim[i] = read_numbers::();\n }\n \n print!(\"The claim vector is: \");\n for i in 0..r {\n print!(\"{} \", max_res[i]);\n }\n println!();\n\n println!(\"The allocated resources table is:\");\n for i in 0..p {\n for j in 0..r {\n print!(\"\\t{}\", curr[i][j]);\n }\n println!();\n }\n\n println!(\"The maximum claims table is:\");\n for i in 0..p {\n for j in 0..r {\n print!(\"\\t{}\", max_claim[i][j]);\n }\n println!();\n }\n \n let mut alloc = vec![0; r];\n for i in 0..p {\n for j in 0..r {\n alloc[j] += curr[i][j];\n }\n }\n \n print!(\"The allocated resources are: \");\n for i in 0..r {\n print!(\"{} \", alloc[i]);\n }\n println!();\n let mut avl = vec![0; r];\n for i in 0..r {\n avl[i] = max_res[i] - alloc[i];\n }\n\n print!(\"The available resources are: \");\n for i in 0..r {\n print!(\"{} \", avl[i]);\n }\n println!();\n\n while count != 0 {\n let mut safe = false;\n for i in 0..p {\n if running[i] {\n let mut exec = true;\n for j in 0..r {\n if max_claim[i][j] - curr[i][j] > avl[j] {\n exec = false;\n break;\n }\n }\n\n if exec {\n println!(\"Process {} is executing.\", i + 1);\n running[i] = false;\n count -= 1;\n safe = true;\n for j in 0..r {\n avl[j] += curr[i][j];\n }\n break;\n }\n }\n }\n\n if safe {\n println!(\"The process is in safe state.\");\n }\n else {\n println!(\"The processes are in unsafe state.\");\n break;\n }\n\n print!(\"The available vector is: \");\n for i in 0..r {\n print!(\"{} \", avl[i]);\n }\n println!();\n }\n}\n"} {"name":"Benford's law","C":"#include \n#include \n#include \n\nfloat *benford_distribution(void)\n{\n static float prob[9];\n for (int i = 1; i < 10; i++)\n prob[i - 1] = log10f(1 + 1.0 \/ i);\n\n return prob;\n}\n\nfloat *get_actual_distribution(char *fn)\n{\n FILE *input = fopen(fn, \"r\");\n if (!input)\n {\n perror(\"Can't open file\");\n exit(EXIT_FAILURE);\n }\n\n int tally[9] = { 0 };\n char c;\n int total = 0;\n while ((c = getc(input)) != EOF)\n {\n \n while (c < '1' || c > '9')\n c = getc(input);\n\n tally[c - '1']++;\n total++;\n\n \n while ((c = getc(input)) != '\\n' && c != EOF)\n ;\n }\n fclose(input);\n \n static float freq[9];\n for (int i = 0; i < 9; i++)\n freq[i] = tally[i] \/ (float) total;\n\n return freq;\n}\n\nint main(int argc, char **argv)\n{\n if (argc != 2)\n {\n printf(\"Usage: benford \\n\");\n return EXIT_FAILURE;\n }\n\n float *actual = get_actual_distribution(argv[1]);\n float *expected = benford_distribution(); \n\n puts(\"digit\\tactual\\texpected\");\n for (int i = 0; i < 9; i++)\n printf(\"%d\\t%.3f\\t%.3f\\n\", i + 1, actual[i], expected[i]);\n\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate num_traits;\nextern crate num;\n\nuse num::bigint::{BigInt, ToBigInt};\nuse num_traits::{Zero, One};\nuse std::collections::HashMap;\n\n\nfn fib(n: usize) -> Vec {\n let mut result = Vec::with_capacity(n);\n let mut a = BigInt::zero();\n let mut b = BigInt::one();\n\n result.push(b.clone());\n\n for i in 1..n {\n let t = b.clone();\n b = a+b;\n a = t;\n result.push(b.clone());\n }\n\n result\n}\n\n\nfn first_digit(x: &BigInt) -> u8 {\n let zero = BigInt::zero();\n assert!(x > &zero);\n\n let s = x.to_str_radix(10);\n\n \n *&s[..1].parse::().unwrap()\n}\n\nfn main() {\n const N: usize = 1000;\n let mut counter: HashMap = HashMap::new();\n for x in fib(N) {\n let d = first_digit(&x);\n *counter.entry(d).or_insert(0) += 1;\n }\n\n println!(\"{:>13} {:>10}\", \"real\", \"predicted\");\n for y in 1..10 {\n println!(\"{}: {:10.3} v. {:10.3}\", y, *counter.get(&y).unwrap_or(&0) as f32 \/ N as f32,\n (1.0 + 1.0 \/ (y as f32)).log10());\n }\n\n}\n"} {"name":"Bitcoin_public point to address","C":"#include \n#include \n#include \n#include \n#include \n\n#define COIN_VER 0\nconst char *coin_err;\n\ntypedef unsigned char byte;\n\nint is_hex(const char *s) {\n\tint i;\n\tfor (i = 0; i < 64; i++)\n\t\tif (!isxdigit(s[i])) return 0;\n\treturn 1;\n}\n\nvoid str_to_byte(const char *src, byte *dst, int n) {\n\twhile (n--) sscanf(src + n * 2, \"%2hhx\", dst + n);\n}\n\nchar* base58(byte *s, char *out) {\n\tstatic const char *tmpl = \"123456789\"\n\t\t\"ABCDEFGHJKLMNPQRSTUVWXYZ\"\n\t\t\"abcdefghijkmnopqrstuvwxyz\";\n\tstatic char buf[40];\n\n\tint c, i, n;\n\tif (!out) out = buf;\n\n\tout[n = 34] = 0;\n\twhile (n--) {\n\t\tfor (c = i = 0; i < 25; i++) {\n\t\t\tc = c * 256 + s[i];\n\t\t\ts[i] = c \/ 58;\n\t\t\tc %= 58;\n\t\t}\n\t\tout[n] = tmpl[c];\n\t}\n\n\tfor (n = 0; out[n] == '1'; n++);\n\tmemmove(out, out + n, 34 - n);\n\n\treturn out;\n}\n\nchar *coin_encode(const char *x, const char *y, char *out) {\n\tbyte s[65];\n\tbyte rmd[5 + RIPEMD160_DIGEST_LENGTH];\n\n\tif (!is_hex(x) || !(is_hex(y))) {\n\t\tcoin_err = \"bad public point string\";\n\t\treturn 0;\n\t}\n\n\ts[0] = 4;\n\tstr_to_byte(x, s + 1, 32);\n\tstr_to_byte(y, s + 33, 32);\n\n\trmd[0] = COIN_VER;\n\tRIPEMD160(SHA256(s, 65, 0), SHA256_DIGEST_LENGTH, rmd + 1);\n\n\tmemcpy(rmd + 21, SHA256(SHA256(rmd, 21, 0), SHA256_DIGEST_LENGTH, 0), 4);\n\n\treturn base58(rmd, out);\n}\n\nint main(void) {\n\tputs(coin_encode(\n\t\t\"50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352\",\n\t\t\"2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6\",\n\t\t0));\n\treturn 0;\n}\n","Rust":"use ring::digest::{digest, SHA256};\nuse ripemd160::{Digest, Ripemd160};\n\nuse hex::FromHex;\n\nstatic X: &str = \"50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352\";\nstatic Y: &str = \"2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6\";\nstatic ALPHABET: [char; 58] = [\n '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',\n 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e',\n 'f', 'g', 'h', 'i', 'j', 'k', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',\n 'z',\n];\n\nfn base58_encode(bytes: &mut [u8]) -> String {\n let base = ALPHABET.len();\n if bytes.is_empty() {\n return String::from(\"\");\n }\n let mut output: Vec = Vec::new();\n let mut num: usize;\n for _ in 0..33 {\n num = 0;\n for byte in bytes.iter_mut() {\n num = num * 256 + *byte as usize;\n *byte = (num \/ base) as u8;\n num %= base;\n }\n output.push(num as u8);\n }\n let mut string = String::new();\n for b in output.iter().rev() {\n string.push(ALPHABET[*b as usize]);\n }\n string\n}\n\n\n\nfn double_sha256(bytes: &[u8]) -> Vec {\n let digest_1 = digest(&SHA256, bytes);\n\n let digest_2 = digest(&SHA256, digest_1.as_ref());\n digest_2.as_ref().to_vec()\n}\n\nfn point_to_address(x: &str, y: &str) -> String {\n let mut addrv: Vec = Vec::with_capacity(65);\n addrv.push(4u8);\n addrv.append(&mut >::from_hex(x).unwrap());\n addrv.append(&mut >::from_hex(y).unwrap());\n \n let sha_digest = digest(&SHA256, &addrv);\n let mut ripemd_digest = Ripemd160::digest(&sha_digest.as_ref()).as_slice().to_vec();\n \n ripemd_digest.insert(0, 0);\n \n let checksum = double_sha256(&ripemd_digest);\n ripemd_digest.extend_from_slice(&checksum[..4]);\n base58_encode(&mut ripemd_digest)\n}\n\nfn main() {\n println!(\"{}\", point_to_address(X, Y));\n}\n"} {"name":"Brace expansion","C":"#include \n#include \n#include \n#include \n\n#define BUFFER_SIZE 128\n\ntypedef unsigned char character;\ntypedef character *string;\n\ntypedef struct node_t node;\nstruct node_t {\n enum tag_t {\n NODE_LEAF,\n NODE_TREE,\n NODE_SEQ,\n } tag;\n\n union {\n string str;\n node *root;\n } data;\n\n node *next;\n};\n\nnode *allocate_node(enum tag_t tag) {\n node *n = malloc(sizeof(node));\n if (n == NULL) {\n fprintf(stderr, \"Failed to allocate node for tag: %d\\n\", tag);\n exit(1);\n }\n n->tag = tag;\n n->next = NULL;\n return n;\n}\n\nnode *make_leaf(string str) {\n node *n = allocate_node(NODE_LEAF);\n n->data.str = str;\n return n;\n}\n\nnode *make_tree() {\n node *n = allocate_node(NODE_TREE);\n n->data.root = NULL;\n return n;\n}\n\nnode *make_seq() {\n node *n = allocate_node(NODE_SEQ);\n n->data.root = NULL;\n return n;\n}\n\nvoid deallocate_node(node *n) {\n if (n == NULL) {\n return;\n }\n\n deallocate_node(n->next);\n n->next = NULL;\n\n if (n->tag == NODE_LEAF) {\n free(n->data.str);\n n->data.str = NULL;\n } else if (n->tag == NODE_TREE || n->tag == NODE_SEQ) {\n deallocate_node(n->data.root);\n n->data.root = NULL;\n } else {\n fprintf(stderr, \"Cannot deallocate node with tag: %d\\n\", n->tag);\n exit(1);\n }\n\n free(n);\n}\n\nvoid append(node *root, node *elem) {\n if (root == NULL) {\n fprintf(stderr, \"Cannot append to uninitialized node.\");\n exit(1);\n }\n if (elem == NULL) {\n return;\n }\n\n if (root->tag == NODE_SEQ || root->tag == NODE_TREE) {\n if (root->data.root == NULL) {\n root->data.root = elem;\n } else {\n node *it = root->data.root;\n while (it->next != NULL) {\n it = it->next;\n }\n it->next = elem;\n }\n } else {\n fprintf(stderr, \"Cannot append to node with tag: %d\\n\", root->tag);\n exit(1);\n }\n}\n\nsize_t count(node *n) {\n if (n == NULL) {\n return 0;\n }\n\n if (n->tag == NODE_LEAF) {\n return 1;\n }\n if (n->tag == NODE_TREE) {\n size_t sum = 0;\n node *it = n->data.root;\n while (it != NULL) {\n sum += count(it);\n it = it->next;\n }\n return sum;\n }\n if (n->tag == NODE_SEQ) {\n size_t prod = 1;\n node *it = n->data.root;\n while (it != NULL) {\n prod *= count(it);\n it = it->next;\n }\n return prod;\n }\n\n fprintf(stderr, \"Cannot count node with tag: %d\\n\", n->tag);\n exit(1);\n}\n\nvoid expand(node *n, size_t pos) {\n if (n == NULL) {\n return;\n }\n\n if (n->tag == NODE_LEAF) {\n printf(n->data.str);\n } else if (n->tag == NODE_TREE) {\n node *it = n->data.root;\n while (true) {\n size_t cnt = count(it);\n if (pos < cnt) {\n expand(it, pos);\n break;\n }\n pos -= cnt;\n it = it->next;\n }\n } else if (n->tag == NODE_SEQ) {\n size_t prod = pos;\n node *it = n->data.root;\n while (it != NULL) {\n size_t cnt = count(it);\n\n size_t rem = prod % cnt;\n expand(it, rem);\n\n it = it->next;\n }\n } else {\n fprintf(stderr, \"Cannot expand node with tag: %d\\n\", n->tag);\n exit(1);\n }\n}\n\nstring allocate_string(string src) {\n size_t len = strlen(src);\n string out = calloc(len + 1, sizeof(character));\n if (out == NULL) {\n fprintf(stderr, \"Failed to allocate a copy of the string.\");\n exit(1);\n }\n strcpy(out, src);\n return out;\n}\n\nnode *parse_seq(string input, size_t *pos);\n\nnode *parse_tree(string input, size_t *pos) {\n node *root = make_tree();\n\n character buffer[BUFFER_SIZE] = { 0 };\n size_t bufpos = 0;\n size_t depth = 0;\n bool asSeq = false;\n bool allow = false;\n\n while (input[*pos] != 0) {\n character c = input[(*pos)++];\n if (c == '\\\\') {\n c = input[(*pos)++];\n if (c == 0) {\n break;\n }\n buffer[bufpos++] = '\\\\';\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n } else if (c == '{') {\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n asSeq = true;\n depth++;\n } else if (c == '}') {\n if (depth-- > 0) {\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n } else {\n if (asSeq) {\n size_t new_pos = 0;\n node *seq = parse_seq(buffer, &new_pos);\n append(root, seq);\n } else {\n append(root, make_leaf(allocate_string(buffer)));\n }\n break;\n }\n } else if (c == ',') {\n if (depth == 0) {\n if (asSeq) {\n size_t new_pos = 0;\n node *seq = parse_seq(buffer, &new_pos);\n append(root, seq);\n bufpos = 0;\n buffer[bufpos] = 0;\n asSeq = false;\n } else {\n append(root, make_leaf(allocate_string(buffer)));\n bufpos = 0;\n buffer[bufpos] = 0;\n }\n } else {\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n }\n } else {\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n }\n }\n\n return root;\n}\n\nnode *parse_seq(string input, size_t *pos) {\n node *root = make_seq();\n\n character buffer[BUFFER_SIZE] = { 0 };\n size_t bufpos = 0;\n\n while (input[*pos] != 0) {\n character c = input[(*pos)++];\n if (c == '\\\\') {\n c = input[(*pos)++];\n if (c == 0) {\n break;\n }\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n } else if (c == '{') {\n node *tree = parse_tree(input, pos);\n if (bufpos > 0) {\n append(root, make_leaf(allocate_string(buffer)));\n bufpos = 0;\n buffer[bufpos] = 0;\n }\n append(root, tree);\n } else {\n buffer[bufpos++] = c;\n buffer[bufpos] = 0;\n }\n }\n\n if (bufpos > 0) {\n append(root, make_leaf(allocate_string(buffer)));\n bufpos = 0;\n buffer[bufpos] = 0;\n }\n\n return root;\n}\n\nvoid test(string input) {\n size_t pos = 0;\n node *n = parse_seq(input, &pos);\n size_t cnt = count(n);\n size_t i;\n\n printf(\"Pattern: %s\\n\", input);\n\n for (i = 0; i < cnt; i++) {\n expand(n, i);\n printf(\"\\n\");\n }\n printf(\"\\n\");\n\n deallocate_node(n);\n}\n\nint main() {\n test(\"~\/{Downloads,Pictures}\/*.{jpg,gif,png}\");\n test(\"It{{em,alic}iz,erat}e{d,}, please.\");\n test(\"{,{,gotta have{ ,\\\\, again\\\\, }}more }cowbell!\");\n\n \n \n\n return 0;\n}\n","Rust":"const OPEN_CHAR: char = '{';\nconst CLOSE_CHAR: char = '}';\nconst SEPARATOR: char = ',';\nconst ESCAPE: char = '\\\\';\n\n#[derive(Debug, PartialEq, Clone)]\nenum Token {\n Open,\n Close,\n Separator,\n Payload(String),\n Branches(Branches),\n}\n\nimpl From for Token {\n fn from(ch: char) -> Token {\n match ch {\n OPEN_CHAR => Token::Open,\n CLOSE_CHAR => Token::Close,\n SEPARATOR => Token::Separator,\n _ => panic!(\"Non tokenizable char!\"),\n }\n }\n}\n\n#[derive(Debug, PartialEq, Clone)]\nstruct Branches {\n tokens: Vec>,\n}\n\nimpl Branches {\n fn new() -> Branches {\n Branches{\n tokens: Vec::new(),\n }\n }\n\n fn add_branch(&mut self, branch: Vec) {\n self.tokens.push(branch);\n }\n\n fn from(tokens: &Vec) -> Branches {\n let mut branches = Branches::new();\n let mut tail = tokens.clone();\n while let Some(pos) = tail.iter().position(|token| { *token == Token::Separator }) {\n let mut rest = tail.split_off(pos);\n branches.add_branch(tail);\n rest.remove(0);\n tail = rest;\n }\n branches.add_branch(tail);\n branches\n }\n}\n\nimpl From for Token {\n fn from(branches: Branches) -> Token {\n Token::Branches(branches)\n }\n}\n\nimpl From> for Branches {\n fn from(tokens: Vec) -> Branches {\n Branches::from(&tokens)\n }\n}\n\nimpl From for String {\n fn from(token: Token) -> String {\n match token {\n Token::Branches(_) => panic!(\"Cannot convert to String!\"),\n Token::Payload(text) => text,\n Token::Open => OPEN_CHAR.to_string(),\n Token::Close => CLOSE_CHAR.to_string(),\n Token::Separator => SEPARATOR.to_string(),\n }\n }\n}\n\nimpl From for Vec {\n fn from(branches: Branches) -> Vec {\n let Branches{ tokens: token_lines } = branches;\n let mut vec: Vec = Vec::new();\n let braces = { if token_lines.len() == 1 { true } else { false } };\n for tokens in token_lines {\n let mut vec_string = output(tokens);\n vec.append(&mut vec_string);\n }\n if braces {\n vec.iter()\n .map(|line| {\n format!(\"{}{}{}\", OPEN_CHAR, line, CLOSE_CHAR)\n }).\n collect::>()\n } else {\n vec\n }\n }\n}\n\nimpl From for Vec {\n fn from(token: Token) -> Vec {\n match token {\n Token::Branches(branches) => {\n branches.into()\n },\n _ => {\n let frag: String = token.into();\n vec![frag]\n },\n }\n }\n}\n\nfn tokenize(string: &str) -> Vec {\n let mut tokens: Vec = Vec::new();\n let mut chars = string.chars();\n let mut payload = String::new();\n while let Some(ch) = chars.next() {\n match ch {\n OPEN_CHAR | SEPARATOR | CLOSE_CHAR => {\n if payload.len() > 0 {\n tokens.push(Token::Payload(payload));\n }\n payload = String::new();\n if ch == CLOSE_CHAR {\n let pos = tokens.iter().rposition(|token| *token == Token::Open);\n if let Some(pos) = pos {\n let branches: Branches = {\n let mut to_branches = tokens.split_off(pos);\n to_branches.remove(0);\n to_branches\n }.into();\n tokens.push(branches.into());\n } else {\n tokens.push(ch.into());\n }\n } else {\n tokens.push(ch.into());\n }\n },\n ESCAPE => {\n payload.push(ch);\n if let Some(next_char) = chars.next() {\n payload.push(next_char);\n }\n },\n _ => payload.push(ch),\n }\n }\n let payload = payload.trim_end();\n if payload.len() > 0 {\n tokens.push(Token::Payload(payload.into()));\n }\n tokens\n}\n\nfn output(tokens: Vec) -> Vec {\n let mut output: Vec = vec![String::new()];\n for token in tokens {\n let mut aux: Vec = Vec::new();\n let strings: Vec = token.into();\n for root in &output {\n for string in &strings {\n aux.push({format!(\"{}{}\", root, string)});\n }\n }\n output = aux;\n }\n output\n}\n\nfn main() {\n let mut input: String = String::new();\n std::io::stdin().read_line(&mut input).unwrap();\n\n let tokens: Vec = tokenize(&input);\n \n\n let output = output(tokens);\n for line in &output {\n println!(\"{}\", line);\n }\n}\n"} {"name":"Brazilian numbers","C":"#include \n\ntypedef char bool;\n\n#define TRUE 1\n#define FALSE 0\n\nbool same_digits(int n, int b) {\n int f = n % b;\n n \/= b;\n while (n > 0) {\n if (n % b != f) return FALSE;\n n \/= b;\n }\n return TRUE;\n}\n\nbool is_brazilian(int n) {\n int b;\n if (n < 7) return FALSE;\n if (!(n % 2) && n >= 8) return TRUE;\n for (b = 2; b < n - 1; ++b) {\n if (same_digits(n, b)) return TRUE;\n }\n return FALSE;\n}\n\nbool is_prime(int n) {\n int d = 5;\n if (n < 2) return FALSE;\n if (!(n % 2)) return n == 2;\n if (!(n % 3)) return n == 3;\n while (d * d <= n) {\n if (!(n % d)) return FALSE;\n d += 2;\n if (!(n % d)) return FALSE;\n d += 4;\n }\n return TRUE;\n}\n\nint main() {\n int i, c, n;\n const char *kinds[3] = {\" \", \" odd \", \" prime \"}; \n for (i = 0; i < 3; ++i) {\n printf(\"First 20%sBrazilian numbers:\\n\", kinds[i]);\n c = 0;\n n = 7;\n while (TRUE) {\n if (is_brazilian(n)) {\n printf(\"%d \", n);\n if (++c == 20) {\n printf(\"\\n\\n\");\n break;\n }\n }\n switch (i) {\n case 0: n++; break;\n case 1: n += 2; break;\n case 2: \n do {\n n += 2;\n } while (!is_prime(n));\n break;\n }\n }\n }\n\n for (n = 7, c = 0; c < 100000; ++n) {\n if (is_brazilian(n)) c++; \n }\n printf(\"The 100,000th Brazilian number: %d\\n\", n - 1);\n return 0;\n}\n","Rust":"fn same_digits(x: u64, base: u64) -> bool {\n let f = x % base;\n let mut n = x;\n while n > 0 {\n if n % base != f {\n return false;\n }\n n \/= base;\n }\n\n true\n}\nfn is_brazilian(x: u64) -> bool {\n if x < 7 {\n return false;\n };\n if x % 2 == 0 {\n return true;\n };\n\n for base in 2..(x - 1) {\n if same_digits(x, base) {\n return true;\n }\n }\n false\n}\n\nfn main() {\n let mut counter = 0;\n let limit = 20;\n let big_limit = 100_000;\n let mut big_result: u64 = 0;\n let mut br: Vec = Vec::new();\n let mut o: Vec = Vec::new();\n let mut p: Vec = Vec::new();\n\n for x in 7.. {\n if is_brazilian(x) {\n counter += 1;\n if br.len() < limit {\n br.push(x);\n }\n if o.len() < limit && x % 2 == 1 {\n o.push(x);\n }\n if p.len() < limit && primes::is_prime(x) {\n p.push(x);\n }\n if counter == big_limit {\n big_result = x;\n break;\n }\n }\n }\n println!(\"First {} Brazilian numbers:\", limit);\n println!(\"{:?}\", br);\n println!(\"\\nFirst {} odd Brazilian numbers:\", limit);\n println!(\"{:?}\", o);\n println!(\"\\nFirst {} prime Brazilian numbers:\", limit);\n println!(\"{:?}\", p);\n\n println!(\"\\nThe {}th Brazilian number: {}\", big_limit, big_result);\n}\n"} {"name":"Burrows\u2013Wheeler transform","C":"#include \n#include \n#include \n\nconst char STX = '\\002', ETX = '\\003';\n\nint compareStrings(const void *a, const void *b) {\n char *aa = *(char **)a;\n char *bb = *(char **)b;\n return strcmp(aa, bb);\n}\n\nint bwt(const char *s, char r[]) {\n int i, len = strlen(s) + 2;\n char *ss, *str;\n char **table;\n if (strchr(s, STX) || strchr(s, ETX)) return 1;\n ss = calloc(len + 1, sizeof(char));\n sprintf(ss, \"%c%s%c\", STX, s, ETX);\n table = malloc(len * sizeof(const char *));\n for (i = 0; i < len; ++i) {\n str = calloc(len + 1, sizeof(char));\n strcpy(str, ss + i);\n if (i > 0) strncat(str, ss, i);\n table[i] = str;\n }\n qsort(table, len, sizeof(const char *), compareStrings);\n for(i = 0; i < len; ++i) {\n r[i] = table[i][len - 1];\n free(table[i]);\n }\n free(table);\n free(ss);\n return 0;\n}\n\nvoid ibwt(const char *r, char s[]) {\n int i, j, len = strlen(r);\n char **table = malloc(len * sizeof(const char *));\n for (i = 0; i < len; ++i) table[i] = calloc(len + 1, sizeof(char));\n for (i = 0; i < len; ++i) {\n for (j = 0; j < len; ++j) { \n memmove(table[j] + 1, table[j], len);\n table[j][0] = r[j];\n }\n qsort(table, len, sizeof(const char *), compareStrings);\n }\n for (i = 0; i < len; ++i) {\n if (table[i][len - 1] == ETX) {\n strncpy(s, table[i] + 1, len - 2);\n break;\n }\n }\n for (i = 0; i < len; ++i) free(table[i]);\n free(table);\n}\n\nvoid makePrintable(const char *s, char t[]) {\n strcpy(t, s);\n for ( ; *t != '\\0'; ++t) {\n if (*t == STX) *t = '^';\n else if (*t == ETX) *t = '|';\n }\n}\n\nint main() {\n int i, res, len;\n char *tests[6], *t, *r, *s;\n tests[0] = \"banana\";\n tests[1] = \"appellee\";\n tests[2] = \"dogwood\";\n tests[3] = \"TO BE OR NOT TO BE OR WANT TO BE OR NOT?\";\n tests[4] = \"SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES\",\n tests[5] = \"\\002ABC\\003\";\n for (i = 0; i < 6; ++i) {\n len = strlen(tests[i]);\n t = calloc(len + 1, sizeof(char));\n makePrintable(tests[i], t);\n printf(\"%s\\n\", t);\n printf(\" --> \");\n r = calloc(len + 3, sizeof(char));\n res = bwt(tests[i], r);\n if (res == 1) {\n printf(\"ERROR: String can't contain STX or ETX\\n\");\n }\n else {\n makePrintable(r, t);\n printf(\"%s\\n\", t);\n }\n s = calloc(len + 1, sizeof(char));\n ibwt(r, s);\n makePrintable(s, t);\n printf(\" --> %s\\n\\n\", t);\n free(t);\n free(r);\n free(s);\n }\n return 0;\n}\n","Rust":"use core::cmp::Ordering;\n\nconst STX: char = '\\u{0002}';\nconst ETX: char = '\\u{0003}';\n\n\n\npub fn special_cmp(lhs: &str, rhs: &str) -> Ordering {\n let mut iter1 = lhs.chars();\n let mut iter2 = rhs.chars();\n\n loop {\n match (iter1.next(), iter2.next()) {\n (Some(lhs), Some(rhs)) => {\n if lhs != rhs {\n let is_lhs_special = lhs == ETX || lhs == STX;\n let is_rhs_special = rhs == ETX || rhs == STX;\n\n let result = if is_lhs_special == is_rhs_special {\n lhs.cmp(&rhs)\n } else if is_lhs_special {\n Ordering::Greater\n } else {\n Ordering::Less\n };\n\n return result;\n }\n }\n (Some(_), None) => return Ordering::Greater,\n (None, Some(_)) => return Ordering::Less,\n (None, None) => return lhs.cmp(&rhs),\n }\n }\n}\n\nfn burrows_wheeler_transform(input: &str) -> String {\n let mut table: Vec = vec![];\n\n \n let input_string = format!(\"{}{}{}\", STX, input, ETX);\n\n \n for (i, _) in input_string.char_indices() {\n table.push(format!(\n \"{}{}\",\n &input_string[input_string.len() - 1 - i..],\n &input_string[0..input_string.len() - 1 - i]\n ));\n }\n\n \n table.sort_unstable_by(|lhs, rhs| special_cmp(&lhs, &rhs));\n\n \n table\n .iter()\n .map(|s| s.chars().nth_back(0).unwrap())\n .collect::()\n}\n\nfn inverse_burrows_wheeler_transform(input: &str) -> String {\n let mut table: Vec = vec![String::new(); input.len()];\n for _ in 0..input.len() {\n \n for (j, s) in table.iter_mut().enumerate() {\n *s = format!(\"{}{}\", input.chars().nth(j).unwrap(), s);\n }\n\n \n table.sort_unstable_by(|lhs, rhs| special_cmp(&lhs, &rhs));\n }\n\n \n table\n .into_iter()\n .filter(|s| s.ends_with(ETX))\n .collect::()\n \n .replace(STX, \"\")\n .replace(ETX, \"\")\n}\n\nfn main() {\n let input = [\n \"banana\",\n \"SIX.MIXED.PIXIES.SIFT.SIXTY.PIXIE.DUST.BOXES\",\n \"TO BE OR NOT TO BE OR WANT TO BE OR NOT?\",\n ];\n for s in input.iter() {\n let bwt = burrows_wheeler_transform(s);\n let ibwt = inverse_burrows_wheeler_transform(&bwt);\n println!(\"Input: {}\", s);\n println!(\"\\tBWT: {}\", bwt.replace(STX, \"^\").replace(ETX, \"|\"));\n println!(\"\\tInverse BWT: {}\", ibwt);\n }\n}\n"} {"name":"Canonicalize CIDR","C":"#include \n#include \n#include \n\ntypedef struct cidr_tag {\n uint32_t address;\n unsigned int mask_length;\n} cidr_t;\n\n\n\nbool cidr_parse(const char* str, cidr_t* cidr) {\n int a, b, c, d, m;\n if (sscanf(str, \"%d.%d.%d.%d\/%d\", &a, &b, &c, &d, &m) != 5)\n return false;\n if (m < 1 || m > 32\n || a < 0 || a > UINT8_MAX\n || b < 0 || b > UINT8_MAX\n || c < 0 || c > UINT8_MAX\n || d < 0 || d > UINT8_MAX)\n return false;\n uint32_t mask = ~((1 << (32 - m)) - 1);\n uint32_t address = (a << 24) + (b << 16) + (c << 8) + d;\n address &= mask;\n cidr->address = address;\n cidr->mask_length = m;\n return true;\n}\n\n\nvoid cidr_format(const cidr_t* cidr, char* str, size_t size) {\n uint32_t address = cidr->address;\n unsigned int d = address & UINT8_MAX;\n address >>= 8;\n unsigned int c = address & UINT8_MAX;\n address >>= 8;\n unsigned int b = address & UINT8_MAX;\n address >>= 8;\n unsigned int a = address & UINT8_MAX;\n snprintf(str, size, \"%u.%u.%u.%u\/%u\", a, b, c, d,\n cidr->mask_length);\n}\n\nint main(int argc, char** argv) {\n const char* tests[] = {\n \"87.70.141.1\/22\",\n \"36.18.154.103\/12\",\n \"62.62.197.11\/29\",\n \"67.137.119.181\/4\",\n \"161.214.74.21\/24\",\n \"184.232.176.184\/18\"\n };\n for (int i = 0; i < sizeof(tests)\/sizeof(tests[0]); ++i) {\n cidr_t cidr;\n if (cidr_parse(tests[i], &cidr)) {\n char out[32];\n cidr_format(&cidr, out, sizeof(out));\n printf(\"%-18s -> %s\\n\", tests[i], out);\n } else {\n fprintf(stderr, \"%s: invalid CIDR\\n\", tests[i]);\n }\n }\n return 0;\n}\n","Rust":"use std::net::Ipv4Addr;\n\nfn canonical_cidr(cidr: &str) -> Result {\n let mut split = cidr.splitn(2, '\/');\n if let (Some(addr), Some(mask)) = (split.next(), split.next()) {\n let addr = addr.parse::().map(u32::from).map_err(|_| cidr)?;\n let mask = mask.parse::().map_err(|_| cidr)?;\n let bitmask = 0xff_ff_ff_ffu32 << (32 - mask);\n let addr = Ipv4Addr::from(addr & bitmask);\n Ok(format!(\"{}\/{}\", addr, mask))\n } else {\n Err(cidr)\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n #[test]\n fn valid() {\n [\n (\"87.70.141.1\/22\", \"87.70.140.0\/22\"),\n (\"36.18.154.103\/12\", \"36.16.0.0\/12\"),\n (\"62.62.197.11\/29\", \"62.62.197.8\/29\"),\n (\"67.137.119.181\/4\", \"64.0.0.0\/4\"),\n (\"161.214.74.21\/24\", \"161.214.74.0\/24\"),\n (\"184.232.176.184\/18\", \"184.232.128.0\/18\"),\n ]\n .iter()\n .cloned()\n .for_each(|(input, expected)| {\n assert_eq!(expected, super::canonical_cidr(input).unwrap());\n });\n }\n}\n\nfn main() {\n println!(\"{}\", canonical_cidr(\"127.1.2.3\/24\").unwrap());\n}\n"} {"name":"Case-sensitivity of identifiers","C":"#include \n\nstatic const char *dog = \"Benjamin\";\nstatic const char *Dog = \"Samba\";\nstatic const char *DOG = \"Bernie\";\n\nint main()\n{\n printf(\"The three dogs are named %s, %s and %s.\\n\", dog, Dog, DOG);\n return 0;\n}\n","Rust":"fn main() {\n let dog = \"Benjamin\";\n let Dog = \"Samba\";\n let DOG = \"Bernie\";\n println!(\"The three dogs are named {}, {} and {}.\", dog, Dog, DOG);\n}\n"} {"name":"Casting out nines","C":"#include \n#include \n\nint main() {\n const int N = 2;\n int base = 10;\n int c1 = 0;\n int c2 = 0;\n int k;\n\n for (k = 1; k < pow(base, N); k++) {\n c1++;\n if (k % (base - 1) == (k * k) % (base - 1)) {\n c2++;\n printf(\"%d \", k);\n }\n }\n\n printf(\"\\nTring %d numbers instead of %d numbers saves %f%%\\n\", c2, c1, 100.0 - 100.0 * c2 \/ c1);\n return 0;\n}\n","Rust":"fn compare_co9_efficiency(base: u64, upto: u64) {\n let naive_candidates: Vec = (1u64..upto).collect();\n let co9_candidates: Vec = naive_candidates.iter().cloned()\n .filter(|&x| x % (base - 1) == (x * x) % (base - 1))\n .collect();\n for candidate in &co9_candidates {\n print!(\"{} \", candidate);\n }\n println!();\n println!(\n \"Trying {} numbers instead of {} saves {:.2}%\",\n co9_candidates.len(),\n naive_candidates.len(),\n 100.0 - 100.0 * (co9_candidates.len() as f64 \/ naive_candidates.len() as f64)\n );\n}\n\nfn main() {\n compare_co9_efficiency(10, 100);\n compare_co9_efficiency(16, 256);\n}\n"} {"name":"Chaos game","C":"#include\n#include\n#include\n#include\n#include\n\n#define pi M_PI\n\nint main(){\n\t\n\ttime_t t;\n\tdouble side, vertices[3][3],seedX,seedY,windowSide;\n\tint i,iter,choice;\n\t\n\tprintf(\"Enter triangle side length\u00a0: \");\n\tscanf(\"%lf\",&side);\n\t\n\tprintf(\"Enter number of iterations\u00a0: \");\n\tscanf(\"%d\",&iter);\n\t\n\twindowSide = 10 + 2*side;\n\n\tinitwindow(windowSide,windowSide,\"Sierpinski Chaos\");\n\t\n\tfor(i=0;i<3;i++){\n\t\tvertices[i][0] = windowSide\/2 + side*cos(i*2*pi\/3);\n\t\tvertices[i][1] = windowSide\/2 + side*sin(i*2*pi\/3);\n\t\tputpixel(vertices[i][0],vertices[i][1],15);\n\t}\n\t\n\tsrand((unsigned)time(&t));\n\t\n\tseedX = rand()%(int)(vertices[0][0]\/2 + (vertices[1][0] + vertices[2][0])\/4);\n\tseedY = rand()%(int)(vertices[0][1]\/2 + (vertices[1][1] + vertices[2][1])\/4);\n\t\n\tputpixel(seedX,seedY,15);\n\t\n\tfor(i=0;i\n#include\n\ntypedef struct{\n\tdouble x,y;\n\t}point;\n\t\ndouble distance(point p1,point p2)\n{\n\treturn sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));\n}\n\t\nvoid findCircles(point p1,point p2,double radius)\n{\n\tdouble separation = distance(p1,p2),mirrorDistance;\n\t\n\tif(separation == 0.0)\n\t{\n\t\tradius == 0.0 ? printf(\"\\nNo circles can be drawn through (%.4f,%.4f)\",p1.x,p1.y):\n\t\t\t\t\t\t\t printf(\"\\nInfinitely many circles can be drawn through (%.4f,%.4f)\",p1.x,p1.y);\n\t}\n\t\n\telse if(separation == 2*radius)\n\t{\n\t\tprintf(\"\\nGiven points are opposite ends of a diameter of the circle with center (%.4f,%.4f) and radius\u00a0%.4f\",(p1.x+p2.x)\/2,(p1.y+p2.y)\/2,radius); \n\t}\n\t\n\telse if(separation > 2*radius)\n\t{\n\t\tprintf(\"\\nGiven points are farther away from each other than a diameter of a circle with radius\u00a0%.4f\",radius);\n\t} \n\t\n\telse\n\t{\n\t\tmirrorDistance =sqrt(pow(radius,2) - pow(separation\/2,2));\n\t\t\n\t\tprintf(\"\\nTwo circles are possible.\");\n\t\tprintf(\"\\nCircle C1 with center (%.4f,%.4f), radius\u00a0%.4f and Circle C2 with center (%.4f,%.4f), radius\u00a0%.4f\",(p1.x+p2.x)\/2 + mirrorDistance*(p1.y-p2.y)\/separation,(p1.y+p2.y)\/2 + mirrorDistance*(p2.x-p1.x)\/separation,radius,(p1.x+p2.x)\/2 - mirrorDistance*(p1.y-p2.y)\/separation,(p1.y+p2.y)\/2 - mirrorDistance*(p2.x-p1.x)\/separation,radius);\n\t}\n}\n\nint main()\n{\n int i;\n\n point cases[] = \t\n {\t{0.1234, 0.9876}, {0.8765, 0.2345}, \n\t{0.0000, 2.0000}, {0.0000, 0.0000}, \n\t{0.1234, 0.9876}, {0.1234, 0.9876}, \n\t{0.1234, 0.9876}, {0.8765, 0.2345}, \n\t{0.1234, 0.9876}, {0.1234, 0.9876}\n };\n\n double radii[] = {2.0,1.0,2.0,0.5,0.0};\n\n for(i=0;i<5;i++)\n {\t\n\tprintf(\"\\nCase %d)\",i+1);\n\tfindCircles(cases[2*i],cases[2*i+1],radii[i]);\n }\n\n return 0;\n}\n","Rust":"use std::fmt;\n\n#[derive(Clone,Copy)]\nstruct Point {\n x: f64,\n y: f64\n}\n\nfn distance (p1: Point, p2: Point) -> f64 {\n ((p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sqrt()\n}\n\nimpl fmt::Display for Point {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"({:.4}, {:.4})\", self.x, self.y)\n }\n}\n\nfn describe_circle(p1: Point, p2: Point, r: f64) {\n let sep = distance(p1, p2);\n\n if sep == 0. {\n if r == 0. {\n println!(\"No circles can be drawn through {}\", p1);\n } else {\n println!(\"Infinitely many circles can be drawn through {}\", p1);\n }\n } else if sep == 2.0 * r {\n println!(\"Given points are opposite ends of a diameter of the circle with center ({:.4},{:.4}) and r {:.4}\",\n (p1.x+p2.x) \/ 2.0, (p1.y+p2.y) \/ 2.0, r);\n } else if sep > 2.0 * r {\n println!(\"Given points are farther away from each other than a diameter of a circle with r {:.4}\", r);\n } else {\n let mirror_dist = (r.powi(2) - (sep \/ 2.0).powi(2)).sqrt();\n\n println!(\"Two circles are possible.\");\n println!(\"Circle C1 with center ({:.4}, {:.4}), r {:.4} and Circle C2 with center ({:.4}, {:.4}), r {:.4}\",\n ((p1.x + p2.x) \/ 2.0) + mirror_dist * (p1.y-p2.y)\/sep, (p1.y+p2.y) \/ 2.0 + mirror_dist*(p2.x-p1.x)\/sep,\n r,\n (p1.x+p2.x) \/ 2.0 - mirror_dist*(p1.y-p2.y)\/sep, (p1.y+p2.y) \/ 2.0 - mirror_dist*(p2.x-p1.x)\/sep, r);\n }\n}\n\nfn main() {\n let points: Vec<(Point, Point)> = vec![\n (Point { x: 0.1234, y: 0.9876 }, Point { x: 0.8765, y: 0.2345 }),\n (Point { x: 0.0000, y: 2.0000 }, Point { x: 0.0000, y: 0.0000 }),\n (Point { x: 0.1234, y: 0.9876 }, Point { x: 0.1234, y: 0.9876 }),\n (Point { x: 0.1234, y: 0.9876 }, Point { x: 0.8765, y: 0.2345 }),\n (Point { x: 0.1234, y: 0.9876 }, Point { x: 0.1234, y: 0.9876 })\n ];\n let radii: Vec = vec![2.0, 1.0, 2.0, 0.5, 0.0];\n\n for (p, r) in points.into_iter().zip(radii.into_iter()) {\n println!(\"\\nPoints: ({}, {}), Radius: {:.4}\", p.0, p.1, r);\n describe_circle(p.0, p.1, r);\n }\n}\n"} {"name":"Circular primes","C":"#include \n#include \n#include \n#include \n#include \n#include \n\nbool is_prime(uint32_t n) {\n if (n == 2)\n return true;\n if (n < 2 || n % 2 == 0)\n return false;\n for (uint32_t p = 3; p * p <= n; p += 2) {\n if (n % p == 0)\n return false;\n }\n return true;\n}\n\n\nuint32_t cycle(uint32_t n) {\n uint32_t m = n, p = 1;\n while (m >= 10) {\n p *= 10;\n m \/= 10;\n }\n return m + 10 * (n % p);\n}\n\nbool is_circular_prime(uint32_t p) {\n if (!is_prime(p))\n return false;\n uint32_t p2 = cycle(p);\n while (p2 != p) {\n if (p2 < p || !is_prime(p2))\n return false;\n p2 = cycle(p2);\n }\n return true;\n}\n\nvoid test_repunit(uint32_t digits) {\n char* str = malloc(digits + 1);\n if (str == 0) {\n fprintf(stderr, \"Out of memory\\n\");\n exit(1);\n }\n memset(str, '1', digits);\n str[digits] = 0;\n mpz_t bignum;\n mpz_init_set_str(bignum, str, 10);\n free(str);\n if (mpz_probab_prime_p(bignum, 10))\n printf(\"R(%u) is probably prime.\\n\", digits);\n else\n printf(\"R(%u) is not prime.\\n\", digits);\n mpz_clear(bignum);\n}\n\nint main() {\n uint32_t p = 2;\n printf(\"First 19 circular primes:\\n\");\n for (int count = 0; count < 19; ++p) {\n if (is_circular_prime(p)) {\n if (count > 0)\n printf(\", \");\n printf(\"%u\", p);\n ++count;\n }\n }\n printf(\"\\n\");\n printf(\"Next 4 circular primes:\\n\");\n uint32_t repunit = 1, digits = 1;\n for (; repunit < p; ++digits)\n repunit = 10 * repunit + 1;\n mpz_t bignum;\n mpz_init_set_ui(bignum, repunit);\n for (int count = 0; count < 4; ) {\n if (mpz_probab_prime_p(bignum, 15)) {\n if (count > 0)\n printf(\", \");\n printf(\"R(%u)\", digits);\n ++count;\n }\n ++digits;\n mpz_mul_ui(bignum, bignum, 10);\n mpz_add_ui(bignum, bignum, 1);\n }\n mpz_clear(bignum);\n printf(\"\\n\");\n test_repunit(5003);\n test_repunit(9887);\n test_repunit(15073);\n test_repunit(25031);\n test_repunit(35317);\n test_repunit(49081);\n return 0;\n}\n","Rust":"\n\n\nfn is_prime(n: u32) -> bool {\n if n < 2 {\n return false;\n }\n if n % 2 == 0 {\n return n == 2;\n }\n if n % 3 == 0 {\n return n == 3;\n }\n let mut p = 5;\n while p * p <= n {\n if n % p == 0 {\n return false;\n }\n p += 2;\n if n % p == 0 {\n return false;\n }\n p += 4;\n }\n true\n}\n\nfn cycle(n: u32) -> u32 {\n let mut m: u32 = n;\n let mut p: u32 = 1;\n while m >= 10 {\n p *= 10;\n m \/= 10;\n }\n m + 10 * (n % p)\n}\n\nfn is_circular_prime(p: u32) -> bool {\n if !is_prime(p) {\n return false;\n }\n let mut p2: u32 = cycle(p);\n while p2 != p {\n if p2 < p || !is_prime(p2) {\n return false;\n }\n p2 = cycle(p2);\n }\n true\n}\n\nfn test_repunit(digits: usize) {\n use rug::{integer::IsPrime, Integer};\n let repunit = \"1\".repeat(digits);\n let bignum = Integer::from_str_radix(&repunit, 10).unwrap();\n if bignum.is_probably_prime(10) != IsPrime::No {\n println!(\"R({}) is probably prime.\", digits);\n } else {\n println!(\"R({}) is not prime.\", digits);\n }\n}\n\nfn main() {\n use rug::{integer::IsPrime, Integer};\n println!(\"First 19 circular primes:\");\n let mut count = 0;\n let mut p: u32 = 2;\n while count < 19 {\n if is_circular_prime(p) {\n if count > 0 {\n print!(\", \");\n }\n print!(\"{}\", p);\n count += 1;\n }\n p += 1;\n }\n println!();\n println!(\"Next 4 circular primes:\");\n let mut repunit: u32 = 1;\n let mut digits: usize = 1;\n while repunit < p {\n repunit = 10 * repunit + 1;\n digits += 1;\n }\n let mut bignum = Integer::from(repunit);\n count = 0;\n while count < 4 {\n if bignum.is_probably_prime(15) != IsPrime::No {\n if count > 0 {\n print!(\", \");\n }\n print!(\"R({})\", digits);\n count += 1;\n }\n digits += 1;\n bignum = bignum * 10 + 1;\n }\n println!();\n test_repunit(5003);\n test_repunit(9887);\n test_repunit(15073);\n test_repunit(25031);\n test_repunit(35317);\n test_repunit(49081);\n}\n"} {"name":"Colour bars_Display","C":"#include\n\n#define COLOURS 8\n\nint main()\n{\n\tint colour=0,i,j,MAXROW,MAXCOL;\n\tstruct text_info tInfo;\n\tgettextinfo(&tInfo);\n\tMAXROW = tInfo.screenheight;\n\tMAXCOL = tInfo.screenwidth;\n\ttextbackground(BLACK); \n\tclrscr();\n\t\n\tfor(colour=0;colour {\n if input.virtual_keycode == Some(VirtualKeyCode::Escape) {\n *flow = ControlFlow::Exit;\n }\n }\n Event::RedrawRequested(_) | Event::WindowEvent {\n event: WindowEvent::Focused(true), ..\n } => {\n image_buffer.render().unwrap();\n }\n _ => {}\n }\n });\n}\n"} {"name":"Comments","C":"\n\n","Rust":"\n\n\n*\/\n\n\n\n\n\n\nfn example() {\n\n \n\n \n}\n\n#[doc = \"Unsugared outer Rustdoc comments.\n (outer attributes are not terminated by a semi-colon)\"]\nfn example() {\n #[doc = \"Unsugared inner Rustdoc comments.\n (inner attributes are terminated by a semi-colon)\n See also https:\n}\n"} {"name":"Consecutive primes with ascending or descending differences","C":"#include \n#include \n#include \n#include \n\nbool *sieve(int limit) {\n int i, p;\n limit++;\n \n bool *c = calloc(limit, sizeof(bool)); \n c[0] = true;\n c[1] = true;\n for (i = 4; i < limit; i += 2) c[i] = true;\n p = 3; \n while (true) {\n int p2 = p * p;\n if (p2 >= limit) break;\n for (i = p2; i < limit; i += 2 * p) c[i] = true;\n while (true) {\n p += 2;\n if (!c[p]) break;\n }\n }\n return c;\n}\n\nvoid longestSeq(int *primes, int pc, bool asc) {\n int i, j, d, pd = 0, lls = 1, lcs = 1;\n int longSeqs[25][10] = {{2}};\n int lsl[25] = {1};\n int currSeq[10] = {2};\n const char *dir = asc ? \"ascending\" : \"descending\";\n for (i = 1; i < pc; ++i) {\n d = primes[i] - primes[i-1];\n if ((asc && d <= pd) || (!asc && d >= pd)) {\n if (lcs > lsl[0]) {\n memcpy((void *)longSeqs[0], (void *)currSeq, lcs * sizeof(int));\n lsl[0] = lcs;\n lls = 1;\n } else if (lcs == lsl[0]) {\n memcpy((void *)longSeqs[lls], (void *)currSeq, lcs * sizeof(int));\n lsl[lls++] = lcs;\n }\n currSeq[0] = primes[i-1];\n currSeq[1] = primes[i];\n lcs = 2;\n } else {\n currSeq[lcs++] = primes[i];\n }\n pd = d;\n }\n if (lcs > lsl[0]) {\n memcpy((void *)longSeqs[0], (void *)currSeq, lcs * sizeof(int));\n lsl[0] = lcs;\n lls = 1;\n } else if (lcs == lsl[0]) {\n memcpy((void *)longSeqs[lls], (void *)currSeq, lcs * sizeof(int));\n lsl[lls++] = lcs;\n }\n printf(\"Longest run(s) of primes with %s differences is %d:\\n\", dir, lsl[0]);\n for (i = 0; i < lls; ++i) {\n int *ls = longSeqs[i];\n for (j = 0; j < lsl[i]-1; ++j) printf(\"%d (%d) \", ls[j], ls[j+1] - ls[j]);\n printf(\"%d\\n\", ls[lsl[i]-1]);\n }\n printf(\"\\n\");\n}\n\nint main() {\n const int limit = 999999;\n int i, j, pc = 0;\n bool *c = sieve(limit);\n for (i = 0; i < limit; ++i) {\n if (!c[i]) ++pc;\n }\n int *primes = (int *)malloc(pc * sizeof(int));\n for (i = 0, j = 0; i < limit; ++i) {\n if (!c[i]) primes[j++] = i;\n }\n free(c);\n printf(\"For primes < 1 million:\\n\");\n longestSeq(primes, pc, true);\n longestSeq(primes, pc, false);\n free(primes);\n return 0;\n}\n","Rust":"\n\n\nfn print_diffs(vec: &[usize]) {\n for i in 0..vec.len() {\n if i > 0 {\n print!(\" ({}) \", vec[i] - vec[i - 1]);\n }\n print!(\"{}\", vec[i]);\n }\n println!();\n}\n\nfn main() {\n let limit = 1000000;\n let mut asc = Vec::new();\n let mut desc = Vec::new();\n let mut max_asc = Vec::new();\n let mut max_desc = Vec::new();\n let mut max_asc_len = 0;\n let mut max_desc_len = 0;\n for p in primal::Sieve::new(limit)\n .primes_from(2)\n .take_while(|x| *x < limit)\n {\n let alen = asc.len();\n if alen > 1 && p - asc[alen - 1] <= asc[alen - 1] - asc[alen - 2] {\n asc = asc.split_off(alen - 1);\n }\n asc.push(p);\n if asc.len() >= max_asc_len {\n if asc.len() > max_asc_len {\n max_asc_len = asc.len();\n max_asc.clear();\n }\n max_asc.push(asc.clone());\n }\n let dlen = desc.len();\n if dlen > 1 && p - desc[dlen - 1] >= desc[dlen - 1] - desc[dlen - 2] {\n desc = desc.split_off(dlen - 1);\n }\n desc.push(p);\n if desc.len() >= max_desc_len {\n if desc.len() > max_desc_len {\n max_desc_len = desc.len();\n max_desc.clear();\n }\n max_desc.push(desc.clone());\n }\n }\n println!(\"Longest run(s) of ascending prime gaps up to {}:\", limit);\n for v in max_asc {\n print_diffs(&v);\n }\n println!(\"\\nLongest run(s) of descending prime gaps up to {}:\", limit);\n for v in max_desc {\n print_diffs(&v);\n }\n}\n"} {"name":"Copy a string","C":"#include \t\n#include \t\n#include \n\nint\nmain()\n{\n\tsize_t len;\n\tchar src[] = \"Hello\";\n\tchar dst1[80], dst2[80];\n\tchar *dst3, *ref;\n\n\t\n\tstrcpy(dst1, src);\n\n\t\n\tlen = strlen(src);\n\tif (len >= sizeof dst2) {\n\t\tfputs(\"The buffer is too small!\\n\", stderr);\n\t\texit(1);\n\t}\n\tmemcpy(dst2, src, len + 1);\n\n\t\n\tdst3 = strdup(src);\n\tif (dst3 == NULL) {\n\t\t\n\t\tperror(\"strdup\");\n\t\texit(1);\n\t}\n\n\t\n\tref = src;\n\n\t\n\tmemset(src, '-', 5);\n\n\tprintf(\" src: %s\\n\", src); \n\tprintf(\"dst1: %s\\n\", dst1); \n\tprintf(\"dst2: %s\\n\", dst2); \n\tprintf(\"dst3: %s\\n\", dst3); \n\tprintf(\" ref: %s\\n\", ref); \n\n\t\n\tfree(dst3);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n let s1 = \"A String\";\n let mut s2 = s1;\n\n s2 = \"Another String\";\n\n println!(\"s1 = {}, s2 = {}\", s1, s2);\n}\n"} {"name":"Count occurrences of a substring","C":"#include \n#include \n\nint match(const char *s, const char *p, int overlap)\n{\n int c = 0, l = strlen(p);\n\n while (*s != '\\0') {\n if (strncmp(s++, p, l)) continue;\n if (!overlap) s += l - 1;\n c++;\n }\n return c;\n}\n\nint main()\n{\n printf(\"%d\\n\", match(\"the three truths\", \"th\", 0));\n printf(\"overlap:%d\\n\", match(\"abababababa\", \"aba\", 1));\n printf(\"not: %d\\n\", match(\"abababababa\", \"aba\", 0));\n return 0;\n}\n","Rust":"fn main() {\n println!(\"{}\",\"the three truths\".matches(\"th\").count());\n println!(\"{}\",\"ababababab\".matches(\"abab\").count());\n}\n"} {"name":"Create a file on magnetic tape","C":"#include\n\nint main()\n{\n\tFILE* fp = fopen(\"TAPE.FILE\",\"w\");\n\t\n\tfprintf(fp,\"This code should be able to write a file to magnetic tape.\\n\");\n\tfprintf(fp,\"The Wikipedia page on Magnetic tape data storage shows that magnetic tapes are still in use.\\n\");\n\tfprintf(fp,\"In fact, the latest format, at the time of writing this code is TS1155 released in 2017.\\n\");\n\tfprintf(fp,\"And since C is already 44, maybe 45, years old in 2017, I am sure someone somewhere did use a C compiler on magnetic tapes.\\n\");\n\tfprintf(fp,\"If you happen to have one, please try to compile and execute me on that system.\\n\");\n\tfprintf(fp,\"My creator tested me on an i5 machine with SSD and RAM that couldn't have even been dreamt of by Denis Ritchie.\\n\");\n\tfprintf(fp,\"Who knows\u00a0? Maybe he did foresee today, after all he created something which is still young after 44-45 years and counting...\\n\");\n\tfprintf(fp,\"EOF\");\n\t\n\tfclose(fp);\n\t\n\treturn 0;\n}\n","Rust":"use std::io::Write;\nuse std::fs::File;\n\nfn main() -> std::io::Result<()> {\n File::open(\"\/dev\/tape\")?.write_all(b\"Hello from Rosetta Code!\")\n}\n"} {"name":"Cuban primes","C":"#include \n#include \n#include \n#include \n#include \n\ntypedef long long llong_t;\nstruct PrimeArray {\n llong_t *ptr;\n size_t size;\n size_t capacity;\n};\n\nstruct PrimeArray allocate() {\n struct PrimeArray primes;\n\n primes.size = 0;\n primes.capacity = 10;\n primes.ptr = malloc(primes.capacity * sizeof(llong_t));\n\n return primes;\n}\n\nvoid deallocate(struct PrimeArray *primes) {\n free(primes->ptr);\n primes->ptr = NULL;\n}\n\nvoid push_back(struct PrimeArray *primes, llong_t p) {\n if (primes->size >= primes->capacity) {\n size_t new_capacity = (3 * primes->capacity) \/ 2 + 1;\n llong_t *temp = realloc(primes->ptr, new_capacity * sizeof(llong_t));\n if (NULL == temp) {\n fprintf(stderr, \"Failed to reallocate the prime array.\");\n exit(1);\n } else {\n primes->ptr = temp;\n primes->capacity = new_capacity;\n }\n }\n\n primes->ptr[primes->size++] = p;\n}\n\nint main() {\n const int cutOff = 200, bigUn = 100000, chunks = 50, little = bigUn \/ chunks;\n struct PrimeArray primes = allocate();\n int c = 0;\n bool showEach = true;\n llong_t u = 0, v = 1, i;\n\n push_back(&primes, 3);\n push_back(&primes, 5);\n\n printf(\"The first %d cuban primes:\\n\", cutOff);\n for (i = 1; i < LLONG_MAX; ++i) {\n bool found = false;\n llong_t mx = ceil(sqrt(v += (u += 6)));\n llong_t j;\n\n for (j = 0; j < primes.size; ++j) {\n if (primes.ptr[j] > mx) {\n break;\n }\n if (v % primes.ptr[j] == 0) {\n found = true;\n break;\n }\n }\n if (!found) {\n c += 1;\n if (showEach) {\n llong_t z;\n for (z = primes.ptr[primes.size - 1] + 2; z <= v - 2; z += 2) {\n bool fnd = false;\n\n for (j = 0; j < primes.size; ++j) {\n if (primes.ptr[j] > mx) {\n break;\n }\n if (z % primes.ptr[j] == 0) {\n fnd = true;\n break;\n }\n }\n if (!fnd) {\n push_back(&primes, z);\n }\n }\n push_back(&primes, v);\n printf(\"%11lld\", v);\n if (c % 10 == 0) {\n printf(\"\\n\");\n }\n if (c == cutOff) {\n showEach = false;\n printf(\"\\nProgress to the %dth cuban prime: \", bigUn);\n }\n }\n if (c % little == 0) {\n printf(\".\");\n if (c == bigUn) {\n break;\n }\n }\n }\n }\n printf(\"\\nThe %dth cuban prime is %lld\\n\", c, v);\n\n deallocate(&primes);\n return 0;\n}\n","Rust":"use std::time::Instant;\nuse separator::Separatable;\n\nconst NUMBER_OF_CUBAN_PRIMES: usize = 200;\nconst COLUMNS: usize = 10;\nconst LAST_CUBAN_PRIME: usize = 100_000;\n\nfn main() {\n println!(\"Calculating the first {} cuban primes and the {}th cuban prime...\", NUMBER_OF_CUBAN_PRIMES, LAST_CUBAN_PRIME);\n let start = Instant::now();\n\n let mut i: u64 = 0;\n let mut j: u64 = 1;\n let mut index: usize = 0;\n let mut cuban_primes = Vec::new();\n let mut cuban: u64 = 0;\n while index < 100_000 {\n cuban = {j += 1; j}.pow(3) - {i += 1; i}.pow(3);\n if primal::is_prime(cuban) {\n if index < NUMBER_OF_CUBAN_PRIMES {\n cuban_primes.push(cuban);\n }\n index += 1;\n }\n }\n\n let elapsed = start.elapsed();\n println!(\"THE {} FIRST CUBAN PRIMES:\", NUMBER_OF_CUBAN_PRIMES);\n cuban_primes\n .chunks(COLUMNS)\n .map(|chunk| {\n chunk.iter()\n .map(|item| {\n print!(\"{}\\t\", item)\n })\n .for_each(drop);\n println!(\"\");\n })\n .for_each(drop);\n println!(\"The {}th cuban prime number is {}\", LAST_CUBAN_PRIME, cuban.separated_string());\n println!(\"Elapsed time: {:?}\", elapsed);\n}\n"} {"name":"Curzon numbers","C":"#include \n#include \n#include \n#include \n\nuint64_t modPow(uint64_t base, uint64_t exp, uint64_t mod) {\n if (mod == 1) return 0;\n uint64_t result = 1;\n base %= mod;\n for (; exp > 0; exp >>= 1) {\n if ((exp & 1) == 1) result = (result * base) % mod;\n base = (base * base) % mod;\n }\n return result;\n}\n\nbool isCurzon(uint64_t n, uint64_t k) {\n const uint64_t r = k * n;\n return modPow(k, n, r+1) == r;\n}\n\nint main() {\n uint64_t k, n, count;\n setlocale(LC_NUMERIC, \"\");\n for (k = 2; k <= 10; k += 2) {\n printf(\"Curzon numbers with base %ld:\\n\", k);\n for (n = 1, count = 0; count < 50; ++n) {\n if (isCurzon(n, k)) {\n printf(\"%4ld \", n);\n if (++count % 10 == 0) printf(\"\\n\");\n }\n }\n for (;;) {\n if (isCurzon(n, k)) ++count;\n if (count == 1000) break;\n ++n;\n }\n printf(\"1,000th Curzon number with base %ld:\u00a0%'ld\\n\\n\", k, n);\n }\n return 0;\n}\n","Rust":"fn modpow(mut base: usize, mut exp: usize, n: usize) -> usize {\n if n == 1 {\n return 0;\n }\n let mut result = 1;\n base %= n;\n while exp > 0 {\n if (exp & 1) == 1 {\n result = (result * base) % n;\n }\n base = (base * base) % n;\n exp >>= 1;\n }\n result\n}\n\nfn is_curzon(n: usize, k: usize) -> bool {\n let m = k * n + 1;\n modpow(k, n, m) + 1 == m\n\n}\n\nfn main() {\n for k in (2..=10).step_by(2) {\n println!(\"Curzon numbers with base {k}:\");\n let mut count = 0;\n let mut n = 1;\n while count < 50 {\n if is_curzon(n, k) {\n count += 1;\n print!(\"{:4}{}\", n, if count % 10 == 0 { \"\\n\" } else { \" \" });\n }\n n += 1;\n }\n loop {\n if is_curzon(n, k) {\n count += 1;\n if count == 1000 {\n break;\n }\n }\n n += 1;\n }\n println!(\"1000th Curzon number with base {k}: {n}\\n\");\n }\n}\n"} {"name":"Cut a rectangle","C":"#include \n#include \n#include \n\ntypedef unsigned char byte;\nbyte *grid = 0;\n\nint w, h, len;\nunsigned long long cnt;\n\nstatic int next[4], dir[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};\nvoid walk(int y, int x)\n{\n\tint i, t;\n\n\tif (!y || y == h || !x || x == w) {\n\t\tcnt += 2;\n\t\treturn;\n\t}\n\n\tt = y * (w + 1) + x;\n\tgrid[t]++, grid[len - t]++;\n\n\tfor (i = 0; i < 4; i++)\n\t\tif (!grid[t + next[i]])\n\t\t\twalk(y + dir[i][0], x + dir[i][1]);\n\n\tgrid[t]--, grid[len - t]--;\n}\n\nunsigned long long solve(int hh, int ww, int recur)\n{\n\tint t, cx, cy, x;\n\n\th = hh, w = ww;\n\n\tif (h & 1) t = w, w = h, h = t;\n\tif (h & 1) return 0;\n\tif (w == 1) return 1;\n\tif (w == 2) return h;\n\tif (h == 2) return w;\n\n\tcy = h \/ 2, cx = w \/ 2;\n\n\tlen = (h + 1) * (w + 1);\n\tgrid = realloc(grid, len);\n\tmemset(grid, 0, len--);\n\n\tnext[0] = -1;\n\tnext[1] = -w - 1;\n\tnext[2] = 1;\n\tnext[3] = w + 1;\n\n\tif (recur) cnt = 0;\n\tfor (x = cx + 1; x < w; x++) {\n\t\tt = cy * (w + 1) + x;\n\t\tgrid[t] = 1;\n\t\tgrid[len - t] = 1;\n\t\twalk(cy - 1, x);\n\t}\n\tcnt++;\n\n\tif (h == w)\n\t\tcnt *= 2;\n\telse if (!(w & 1) && recur)\n\t\tsolve(w, h, 0);\n\n\treturn cnt;\n}\n\nint main()\n{\n\tint y, x;\n\tfor (y = 1; y <= 10; y++)\n\t\tfor (x = 1; x <= y; x++)\n\t\t\tif (!(x & 1) || !(y & 1))\n\t\t\t\tprintf(\"%d x %d: %llu\\n\", y, x, solve(y, x, 1));\n\n\treturn 0;\n}\n","Rust":"fn cwalk(mut vis: &mut Vec>, count: &mut isize, w: usize, h: usize, y: usize, x: usize, d: usize) {\n if x == 0 || y == 0 || x == w || y == h {\n *count += 1;\n return;\n }\n \n vis[y][x] = true;\n vis[h - y][w - x] = true;\n\n if x != 0 && ! vis[y][x - 1] {\n cwalk(&mut vis, count, w, h, y, x - 1, d | 1);\n }\n if d & 1 != 0 && x < w && ! vis[y][x+1] {\n cwalk(&mut vis, count, w, h, y, x + 1, d | 1);\n }\n if y != 0 && ! vis[y - 1][x] {\n cwalk(&mut vis, count, w, h, y - 1, x, d | 2);\n }\n if d & 2 != 0 && y < h && ! vis[y + 1][x] {\n cwalk(&mut vis, count, w, h, y + 1, x, d | 2);\n }\n\n vis[y][x] = false;\n vis[h - y][w - x] = false;\n}\n\nfn count_only(x: usize, y: usize) -> isize {\n let mut count = 0;\n let mut w = x;\n let mut h = y;\n \n if (h * w) & 1 != 0 {\n return count;\n }\n if h & 1 != 0 {\n std::mem::swap(&mut w, &mut h);\n }\n \n let mut vis = vec![vec![false; w + 1]; h + 1];\n vis[h \/ 2][w \/ 2] = true;\n \n if w & 1 != 0 {\n vis[h \/ 2][w \/ 2 + 1] = true;\n }\n let mut res;\n if w > 1 {\n cwalk(&mut vis, &mut count, w, h, h \/ 2, w \/ 2 - 1, 1);\n res = 2 * count - 1;\n count = 0;\n if w != h {\n cwalk(&mut vis, &mut count, w, h, h \/ 2 + 1, w \/ 2, if w & 1 != 0 { 3 } else { 2 });\n } \n res += 2 * count - if w & 1 == 0 { 1 } else { 0 };\n }\n else {\n res = 1;\n }\n \n if w == h {\n res = 2 * res + 2;\n }\n res\n}\n\nfn main() {\n for y in 1..10 {\n for x in 1..y + 1 {\n if x & 1 == 0 || y & 1 == 0 {\n println!(\"{} x {}: {}\", y, x, count_only(x, y));\n }\n }\n }\n}\n"} {"name":"Deceptive numbers","C":"#include \n\nunsigned modpow(unsigned b, unsigned e, unsigned m)\n{\n unsigned p;\n for (p = 1; e; e >>= 1) {\n if (e & 1)\n p = p * b % m;\n b = b * b % m;\n }\n return p;\n}\n\nint is_deceptive(unsigned n)\n{\n unsigned x;\n if (n & 1 && n % 3 && n % 5) {\n for (x = 7; x * x <= n; x += 6) {\n if (!(n % x && n % (x + 4)))\n return modpow(10, n - 1, n) == 1;\n }\n }\n return 0;\n}\n\nint main(void)\n{\n unsigned c, i = 49;\n for (c = 0; c != 50; ++i) {\n if (is_deceptive(i)) {\n printf(\" %u\", i);\n ++c;\n }\n }\n return 0;\n}\n","Rust":"\n\n\n\nfn main() {\n println!(\"First 100 deceptive numbers:\");\n use rug::Integer;\n let mut repunit = Integer::from(11);\n let mut n: u32 = 3;\n let mut count = 0;\n while count != 100 {\n if n % 3 != 0 && n % 5 != 0 && !primal::is_prime(n as u64) && repunit.is_divisible_u(n) {\n print!(\"{:6}\", n);\n count += 1;\n if count % 10 == 0 {\n println!();\n } else {\n print!(\" \");\n }\n }\n n += 2;\n repunit *= 100;\n repunit += 11;\n }\n}\n"} {"name":"Deepcopy","C":"#include\n\ntypedef struct{\n\tint a;\n}layer1;\n\ntypedef struct{\n\tlayer1 l1;\n\tfloat b,c;\n}layer2;\n\ntypedef struct{\n\tlayer2 l2;\n\tlayer1 l1;\n\tint d,e;\n}layer3;\n\nvoid showCake(layer3 cake){\n\tprintf(\"\\ncake.d = %d\",cake.d);\n\tprintf(\"\\ncake.e = %d\",cake.e);\n\tprintf(\"\\ncake.l1.a = %d\",cake.l1.a);\n\tprintf(\"\\ncake.l2.b = %f\",cake.l2.b);\n\tprintf(\"\\ncake.l2.l1.a = %d\",cake.l2.l1.a);\n}\n\nint main()\n{\n\tlayer3 cake1,cake2;\n\t\n\tcake1.d = 1;\n\tcake1.e = 2;\n\tcake1.l1.a = 3;\n\tcake1.l2.b = 4;\n\tcake1.l2.l1.a = 5;\n\t\n\tprintf(\"Cake 1 is\u00a0: \");\n\tshowCake(cake1);\n\t\n\tcake2 = cake1;\n\t\n\tcake2.l2.b += cake2.l2.l1.a;\n\t\n\tprintf(\"\\nCake 2 is\u00a0: \");\n\tshowCake(cake2);\n\t\n\treturn 0;\n}\n","Rust":"\n#[derive(Clone)]\nstruct Tree {\n left: Leaf,\n data: T,\n right: Leaf,\n}\n\ntype Leaf = Option>>;\n\nimpl Tree {\n fn root(data: T) -> Self {\n Self { left: None, data, right: None }\n }\n\n fn leaf(d: T) -> Leaf {\n Some(Box::new(Self::root(d)))\n }\n}\n\nfn main() {\n let mut tree = Tree::root([4, 5, 6]);\n tree.right = Tree::leaf([1, 2, 3]);\n tree.left = Tree::leaf([7, 8, 9]);\n\n let newtree = tree.clone();\n}\n"} {"name":"Determinant and permanent","C":"#include \n#include \n#include \n\ndouble det_in(double **in, int n, int perm)\n{\n\tif (n == 1) return in[0][0];\n\n\tdouble sum = 0, *m[--n];\n\tfor (int i = 0; i < n; i++)\n\t\tm[i] = in[i + 1] + 1;\n\n\tfor (int i = 0, sgn = 1; i <= n; i++) {\n\t\tsum += sgn * (in[i][0] * det_in(m, n, perm));\n\t\tif (i == n) break;\n\n\t\tm[i] = in[i] + 1;\n\t\tif (!perm) sgn = -sgn;\n\t}\n\treturn sum;\n}\n\n\ndouble det(double *in, int n, int perm)\n{\n\tdouble *m[n];\n\tfor (int i = 0; i < n; i++)\n\t\tm[i] = in + (n * i);\n\n\treturn det_in(m, n, perm);\n}\n\nint main(void)\n{\n\tdouble x[] = {\t0, 1, 2, 3, 4,\n\t\t\t5, 6, 7, 8, 9,\n\t\t\t10, 11, 12, 13, 14,\n\t\t\t15, 16, 17, 18, 19,\n\t\t\t20, 21, 22, 23, 24 };\n\n\tprintf(\"det: %14.12g\\n\", det(x, 5, 0));\n\tprintf(\"perm: %14.12g\\n\", det(x, 5, 1));\n\n\treturn 0;\n}\n","Rust":"fn main() {\nlet mut m1: Vec> = vec![vec![1.0,2.0],vec![3.0,4.0]];\n let mut r_m1 = &mut m1;\n let rr_m1 = &mut r_m1;\n let mut m2: Vec> = vec![vec![1.0, 2.0, 3.0, 4.0], vec![4.0, 5.0, 6.0, 7.0], vec![7.0, 8.0, 9.0, 10.0], vec![10.0, 11.0, 12.0, 13.0]];\n let mut r_m2 = &mut m2;\n let rr_m2 = &mut r_m2;\n let mut m3: Vec> = vec![vec![0.0, 1.0, 2.0, 3.0, 4.0],\n vec![5.0, 6.0, 7.0, 8.0, 9.0],\n vec![10.0, 11.0, 12.0, 13.0, 14.0],\n vec![15.0, 16.0, 17.0, 18.0, 19.0], \n vec![20.0, 21.0, 22.0, 23.0, 24.0]];\n let mut r_m3 = &mut m3;\n let rr_m3 = &mut r_m3;\n\n println!(\"Determinant of m1: {}\", determinant(rr_m1));\n println!(\"Permanent of m1: {}\", permanent(rr_m1));\n\n println!(\"Determinant of m2: {}\", determinant(rr_m2));\n println!(\"Permanent of m2: {}\", permanent(rr_m2));\n\n println!(\"Determinant of m3: {}\", determinant(rr_m3));\n println!(\"Permanent of m3: {}\", permanent(rr_m3));\n\n}\n\nfn minor( a: &mut Vec>, x: usize, y: usize) -> Vec> {\n let mut out_vec: Vec> = vec![vec![0.0; a.len() - 1]; a.len() -1];\n for i in 0..a.len()-1 {\n for j in 0..a.len()-1 {\n match () {\n _ if (i < x && j < y) => {\n out_vec[i][j] = a[i][j];\n },\n _ if (i >= x && j < y) => {\n out_vec[i][j] = a[i + 1][j];\n },\n _ if (i < x && j >= y) => {\n out_vec[i][j] = a[i][j + 1];\n },\n _ => { \n out_vec[i][j] = a[i + 1][j + 1];\n },\n }\n }\n }\n out_vec\n}\n\nfn determinant (matrix: &mut Vec>) -> f64 {\n match () {\n _ if (matrix.len() == 1) => {\n matrix[0][0]\n },\n _ => {\n let mut sign = 1.0;\n let mut sum = 0.0;\n for i in 0..matrix.len() {\n sum = sum + sign * matrix[0][i] * determinant(&mut minor(matrix, 0, i));\n sign = sign * -1.0;\n }\n sum\n }\n }\n}\n\nfn permanent (matrix: &mut Vec>) -> f64 {\n match () {\n _ if (matrix.len() == 1) => {\n matrix[0][0]\n },\n _ => {\n let mut sum = 0.0;\n for i in 0..matrix.len() {\n sum = sum + matrix[0][i] * permanent(&mut minor(matrix, 0, i));\n }\n sum\n }\n }\n}\n"} {"name":"Dice game probabilities","C":"#include \n#include \n\ntypedef uint32_t uint;\ntypedef uint64_t ulong;\n\nulong ipow(const uint x, const uint y) {\n ulong result = 1;\n for (uint i = 1; i <= y; i++)\n result *= x;\n return result;\n}\n\nuint min(const uint x, const uint y) {\n return (x < y) ? x : y;\n}\n\nvoid throw_die(const uint n_sides, const uint n_dice, const uint s, uint counts[]) {\n if (n_dice == 0) {\n counts[s]++;\n return;\n }\n\n for (uint i = 1; i < n_sides + 1; i++)\n throw_die(n_sides, n_dice - 1, s + i, counts);\n}\n\ndouble beating_probability(const uint n_sides1, const uint n_dice1,\n const uint n_sides2, const uint n_dice2) {\n const uint len1 = (n_sides1 + 1) * n_dice1;\n uint C1[len1];\n for (uint i = 0; i < len1; i++)\n C1[i] = 0;\n throw_die(n_sides1, n_dice1, 0, C1);\n\n const uint len2 = (n_sides2 + 1) * n_dice2;\n uint C2[len2];\n for (uint j = 0; j < len2; j++)\n C2[j] = 0;\n throw_die(n_sides2, n_dice2, 0, C2);\n\n const double p12 = (double)(ipow(n_sides1, n_dice1) * ipow(n_sides2, n_dice2));\n\n double tot = 0;\n for (uint i = 0; i < len1; i++)\n for (uint j = 0; j < min(i, len2); j++)\n tot += (double)C1[i] * C2[j] \/ p12;\n return tot;\n}\n\nint main() {\n printf(\"%1.16f\\n\", beating_probability(4, 9, 6, 6));\n printf(\"%1.16f\\n\", beating_probability(10, 5, 7, 6));\n return 0;\n}\n","Rust":"\n\nfn get_totals(dice: usize, faces: usize) -> Vec {\n let mut result = vec![1.0; faces + 1];\n for d in 2..=dice {\n let mut tmp = vec![0.0; d * faces + 1];\n for i in d - 1..result.len() {\n for j in 1..=faces {\n tmp[i + j] += result[i];\n }\n }\n result = tmp;\n }\n result\n}\n\nfn probability(dice1: usize, faces1: usize, dice2: usize, faces2: usize) -> f64 {\n let totals1 = get_totals(dice1, faces1);\n let totals2 = get_totals(dice2, faces2);\n let mut wins = 0.0;\n let mut total = 0.0;\n for i in dice1..totals1.len() {\n for j in dice2..totals2.len() {\n let n = totals1[i] * totals2[j];\n total += n;\n if j < i {\n wins += n;\n }\n }\n }\n wins \/ total\n}\n\nfn main() {\n println!(\"{}\", probability(9, 4, 6, 6));\n println!(\"{}\", probability(5, 10, 6, 7));\n}\n"} {"name":"Doomsday rule","C":"#include \n#include \n#include \n\ntypedef struct { \n uint16_t year;\n uint8_t month;\n uint8_t day;\n} Date;\n\nbool leap(uint16_t year) {\n return year%4==0 && (year%100!=0 || year%400==0);\n}\n\nconst char *weekday(Date date) {\n static const uint8_t leapdoom[] = {4,1,7,2,4,6,4,1,5,3,7,5};\n static const uint8_t normdoom[] = {3,7,7,4,2,6,4,1,5,3,7,5};\n static const char *days[] = {\n \"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\",\n \"Thursday\", \"Friday\", \"Saturday\"\n };\n \n unsigned c = date.year\/100, r = date.year%100;\n unsigned s = r\/12, t = r%12;\n \n unsigned c_anchor = (5 * (c%4) + 2) % 7;\n unsigned doom = (s + t + (t\/4) + c_anchor) % 7;\n unsigned anchor = (leap(date.year) ? leapdoom : normdoom)[date.month-1];\n return days[(doom+date.day-anchor+7)%7];\n}\n\nint main(void) {\n const char *past = \"was\", *future = \"will be\";\n const char *months[] = { \"\",\n \"January\", \"February\", \"March\", \"April\", \"May\", \"June\",\n \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"\n };\n \n const Date dates[] = {\n {1800,1,6}, {1875,3,29}, {1915,12,7}, {1970,12,23}, {2043,5,14},\n {2077,2,12}, {2101,4,2}\n };\n \n int i;\n for (i=0; i < sizeof(dates)\/sizeof(Date); i++) {\n printf(\"%s %d, %d %s on a %s.\\n\",\n months[dates[i].month], dates[i].day, dates[i].year,\n dates[i].year > 2021 ? future : past,\n weekday(dates[i]));\n }\n \n return 0;\n}\n","Rust":"fn day_of_week(year: u32, month: u32, day: u32) -> u32 {\n const LEAPYEAR_FIRSTDOOMSDAYS: [u32; 12] = [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5];\n const NONLEAPYEAR_FIRSTDOOMSDAYS: [u32; 12] = [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5];\n assert!(year > 1581 && year < 10000);\n assert!(month >= 1 && month <= 12);\n assert!(day >= 1 && day <= 31);\n let doomsday = (2 + 5 * (year % 4) + 4 * (year % 100) + 6 * (year % 400)) % 7;\n let anchorday = if year % 4 != 0 || (year % 100 == 0 && year % 400 != 0) {\n NONLEAPYEAR_FIRSTDOOMSDAYS[month as usize - 1]\n } else {\n LEAPYEAR_FIRSTDOOMSDAYS[month as usize - 1]\n };\n (doomsday + day + 7 - anchorday) % 7\n}\n\nfn print_day_of_week(year: u32, month: u32, day: u32) {\n const DAY_NAMES: [&str; 7] = [\n \"Sunday\",\n \"Monday\",\n \"Tuesday\",\n \"Wednesday\",\n \"Thursday\",\n \"Friday\",\n \"Saturday\",\n ];\n println!(\n \"{:04}-{:02}-{:02}: {}\",\n year,\n month,\n day,\n DAY_NAMES[day_of_week(year, month, day) as usize]\n );\n}\n\nfn main() {\n print_day_of_week(1800, 1, 6);\n print_day_of_week(1875, 3, 29);\n print_day_of_week(1915, 12, 7);\n print_day_of_week(1970, 12, 23);\n print_day_of_week(2043, 5, 14);\n print_day_of_week(2077, 2, 12);\n print_day_of_week(2101, 4, 2);\n}\n"} {"name":"Elementary cellular automaton_Random number generator","C":"#include \n#include \n\ntypedef unsigned long long ull;\n#define N (sizeof(ull) * CHAR_BIT)\n#define B(x) (1ULL << (x))\n\nvoid evolve(ull state, int rule)\n{\n\tint i, p, q, b;\n\n\tfor (p = 0; p < 10; p++) {\n\t\tfor (b = 0, q = 8; q--; ) {\n\t\t\tull st = state;\n\t\t\tb |= (st&1) << q;\n\n\t\t\tfor (state = i = 0; i < N; i++)\n\t\t\t\tif (rule & B(7 & (st>>(i-1) | st<<(N+1-i))))\n\t\t\t\t\tstate |= B(i);\n\t\t}\n\t\tprintf(\" %d\", b);\n\t}\n\tputchar('\\n');\n\treturn;\n}\n\nint main(void)\n{\n\tevolve(1, 30);\n\treturn 0;\n}\n","Rust":"\nfn main() {\n struct WolfGen(ElementaryCA);\n impl WolfGen {\n fn new() -> WolfGen {\n let (_, ca) = ElementaryCA::new(30);\n WolfGen(ca)\n }\n fn next(&mut self) -> u8 {\n let mut out = 0;\n for i in 0..8 {\n out |= ((1 & self.0.next())<\n#include \n#include \n#include \n#include \n\n#define MAXLEN 961 \n\nint makehist(char *S,int *hist,int len){\n\tint wherechar[256];\n\tint i,histlen;\n\thistlen=0;\n\tfor(i=0;i<256;i++)wherechar[i]=-1;\n\tfor(i=0;i>(iter: I) -> f32 {\n let mut histogram = [0u64; 256];\n let mut len = 0u64;\n\n for b in iter {\n histogram[b as usize] += 1;\n len += 1;\n }\n \n histogram\n .iter()\n .cloned()\n .filter(|&h| h > 0)\n .map(|h| h as f32 \/ len as f32)\n .map(|ratio| -ratio * ratio.log2())\n .sum()\n}\n\nfn main() {\n let name = std::env::args().nth(0).expect(\"Could not get program name.\");\n let file = BufReader::new(File::open(name).expect(\"Could not read file.\"));\n println!(\"Entropy is {}.\", entropy(file.bytes().flatten()));\n}\n"} {"name":"Erd\u0151s-primes","C":"#include \n#include \n#include \n#include \n\n#define LIMIT 1000000\n#define LOWER_LIMIT 2500\n\nbool *sieve(int limit) {\n int i, p;\n limit++;\n \n bool *c = calloc(limit, sizeof(bool)); \n c[0] = true;\n c[1] = true;\n for (i = 4; i < limit; i += 2) c[i] = true;\n p = 3; \n while (true) {\n int p2 = p * p;\n if (p2 >= limit) break;\n for (i = p2; i < limit; i += 2 * p) c[i] = true;\n while (true) {\n p += 2;\n if (!c[p]) break;\n }\n }\n return c;\n}\n\nint main() {\n int i, j, fact, ec = 0, ec2 = 0, lastErdos = 0;\n bool found;\n bool *c = sieve(LIMIT-1);\n int erdos[30];\n for (i = 2; i < LIMIT;) {\n if (!c[i]) {\n j = 1;\n fact = 1;\n found = true;\n while (fact < i) {\n if (!c[i-fact]) {\n found = false;\n break;\n }\n ++j;\n fact *= j;\n }\n if (found) {\n if (i < LOWER_LIMIT) erdos[ec2++] = i;\n lastErdos = i;\n ++ec;\n }\n }\n i = (i > 2) ? i + 2 : i + 1;\n }\n setlocale(LC_NUMERIC, \"\");\n printf(\"The\u00a0%'d Erd\u0151s primes under\u00a0%'d are:\\n\", ec2, LOWER_LIMIT);\n for (i = 0; i < ec2; ++i) {\n printf(\"%6d \", erdos[i]);\n if (!((i+1)%10)) printf(\"\\n\");\n }\n printf(\"\\n\\nThe\u00a0%'dth Erd\u0151s prime is\u00a0%'d.\\n\", ec, lastErdos);\n free(c);\n return 0;\n}\n","Rust":"\n\n\nuse std::collections::HashSet;\n\nfn erdos_primes() -> impl std::iter::Iterator {\n let mut primes = HashSet::new();\n let mut all_primes = primal::Primes::all();\n std::iter::from_fn(move || {\n 'all_primes: for p in all_primes.by_ref() {\n primes.insert(p);\n let mut k = 1;\n let mut f = 1;\n while f < p {\n if primes.contains(&(p - f)) {\n continue 'all_primes;\n }\n k += 1;\n f *= k;\n }\n return Some(p);\n }\n None\n })\n}\n\nfn main() {\n let mut count = 0;\n println!(\"Erd\\u{151}s primes less than 2500:\");\n for p in erdos_primes().take_while(|x| *x < 2500) {\n count += 1;\n if count % 10 == 0 {\n println!(\"{:4}\", p);\n } else {\n print!(\"{:4} \", p);\n }\n }\n println!();\n if let Some(p) = erdos_primes().nth(7874) {\n println!(\"\\nThe 7875th Erd\\u{151}s prime is {}.\", p);\n }\n}\n"} {"name":"Esthetic numbers","C":"#include \n#include \n#include \n\ntypedef int bool;\ntypedef unsigned long long ull;\n\n#define TRUE 1\n#define FALSE 0\n\nchar as_digit(int d) { \n return (d >= 0 && d <= 9) ? d + '0' : d - 10 + 'a'; \n}\n\nvoid revstr(char *str) { \n int i, len = strlen(str);\n char t; \n for (i = 0; i < len\/2; ++i) { \n t = str[i]; \n str[i] = str[len - i - 1]; \n str[len - i - 1] = t; \n } \n} \n\nchar* to_base(char s[], ull n, int b) { \n int i = 0; \n while (n) { \n s[i++] = as_digit(n % b); \n n \/= b; \n } \n s[i] = '\\0'; \n revstr(s);\n return s; \n} \n\null uabs(ull a, ull b) {\n return a > b ? a - b : b - a;\n}\n\nbool is_esthetic(ull n, int b) {\n int i, j;\n if (!n) return FALSE;\n i = n % b;\n n \/= b;\n while (n) {\n j = n % b;\n if (uabs(i, j) != 1) return FALSE;\n n \/= b;\n i = j;\n }\n return TRUE;\n}\n\null esths[45000];\nint le = 0;\n\nvoid dfs(ull n, ull m, ull i) {\n ull d, i1, i2;\n if (i >= n && i <= m) esths[le++] = i;\n if (i == 0 || i > m) return; \n d = i % 10;\n i1 = i * 10 + d - 1;\n i2 = i1 + 2;\n if (d == 0) {\n dfs(n, m, i2);\n } else if (d == 9) {\n dfs(n, m, i1);\n } else {\n dfs(n, m, i1);\n dfs(n, m, i2);\n }\n}\n\nvoid list_esths(ull n, ull n2, ull m, ull m2, int per_line, bool all) {\n int i;\n le = 0;\n for (i = 0; i < 10; ++i) {\n dfs(n2, m2, i);\n }\n printf(\"Base 10:\u00a0%'d esthetic numbers between\u00a0%'llu and\u00a0%'llu:\\n\", le, n, m);\n if (all) {\n for (i = 0; i < le; ++i) {\n printf(\"%llu \", esths[i]);\n if (!(i+1)%per_line) printf(\"\\n\");\n }\n } else {\n for (i = 0; i < per_line; ++i) printf(\"%llu \", esths[i]);\n printf(\"\\n............\\n\");\n for (i = le - per_line; i < le; ++i) printf(\"%llu \", esths[i]);\n }\n printf(\"\\n\\n\");\n}\n\nint main() {\n ull n;\n int b, c;\n char ch[15] = {0};\n for (b = 2; b <= 16; ++b) {\n printf(\"Base %d: %dth to %dth esthetic numbers:\\n\", b, 4*b, 6*b);\n for (n = 1, c = 0; c < 6 * b; ++n) {\n if (is_esthetic(n, b)) {\n if (++c >= 4 * b) printf(\"%s \", to_base(ch, n, b));\n }\n }\n printf(\"\\n\\n\");\n }\n char *oldLocale = setlocale(LC_NUMERIC, NULL);\n setlocale(LC_NUMERIC, \"\"); \n\n \n list_esths(1000, 1010, 9999, 9898, 16, TRUE);\n list_esths(1e8, 101010101, 13*1e7, 123456789, 9, TRUE);\n list_esths(1e11, 101010101010, 13*1e10, 123456789898, 7, FALSE);\n list_esths(1e14, 101010101010101, 13*1e13, 123456789898989, 5, FALSE);\n list_esths(1e17, 101010101010101010, 13*1e16, 123456789898989898, 4, FALSE);\n setlocale(LC_NUMERIC, oldLocale);\n return 0;\n}\n","Rust":"\n\n\n\n\nfn next_esthetic_number(base: u64, n: u64) -> u64 {\n if n + 1 < base {\n return n + 1;\n }\n let mut a = n \/ base;\n let mut b = a % base;\n if n % base + 1 == b && b + 1 < base {\n return n + 2;\n }\n a = next_esthetic_number(base, a);\n b = a % base;\n a * base + if b == 0 { 1 } else { b - 1 }\n}\n\nfn print_esthetic_numbers(min: u64, max: u64, numbers_per_line: usize) {\n let mut numbers = Vec::new();\n let mut n = next_esthetic_number(10, min - 1);\n while n <= max {\n numbers.push(n);\n n = next_esthetic_number(10, n);\n }\n let count = numbers.len();\n println!(\n \"Esthetic numbers in base 10 between {} and {} ({}):\",\n min, max, count\n );\n if count > 200 {\n for i in 0..numbers_per_line {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{}\", numbers[i]);\n }\n println!(\"\\n............\\n\");\n for i in 0..numbers_per_line {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{}\", numbers[count - numbers_per_line + i]);\n }\n println!();\n } else {\n for i in 0..count {\n print!(\"{}\", numbers[i]);\n if (i + 1) % numbers_per_line == 0 {\n println!();\n } else {\n print!(\" \");\n }\n }\n if count % numbers_per_line != 0 {\n println!();\n }\n }\n}\n\nfn main() {\n for base in 2..=16 {\n let min = base * 4;\n let max = base * 6;\n println!(\n \"Esthetic numbers in base {} from index {} through index {}:\",\n base, min, max\n );\n let mut n = 0;\n for index in 1..=max {\n n = next_esthetic_number(base, n);\n if index >= min {\n print!(\"{} \", radix_fmt::radix(n, base as u8));\n }\n }\n println!(\"\\n\");\n }\n\n let mut min = 1000;\n let mut max = 9999;\n print_esthetic_numbers(min, max, 16);\n println!();\n\n min = 100000000;\n max = 130000000;\n print_esthetic_numbers(min, max, 8);\n println!();\n\n for i in 0..3 {\n min *= 1000;\n max *= 1000;\n let numbers_per_line = match i {\n 0 => 7,\n 1 => 5,\n _ => 4,\n };\n print_esthetic_numbers(min, max, numbers_per_line);\n println!();\n }\n}\n"} {"name":"Euler's constant 0.5772...","C":"\n#include \n#include \n\n#define eps 1e-6\n\nint main(void) {\ndouble a, b, h, n2, r, u, v;\nint k, k2, m, n;\n\nprintf(\"From the definition, err. 3e-10\\n\");\n\nn = 400;\n\nh = 1;\nfor (k = 2; k <= n; k++) {\n h += 1.0 \/ k;\n}\n\na = log(n +.5 + 1.0 \/ (24*n));\n\nprintf(\"Hn \u00a0%.16f\\n\", h);\nprintf(\"gamma\u00a0%.16f\\nk = %d\\n\\n\", h - a, n);\n\n\nprintf(\"Sweeney, 1963, err. idem\\n\");\n\nn = 21;\n\ndouble s[] = {0, n};\nr = n;\nk = 1;\ndo {\n k += 1;\n r *= (double) n \/ k;\n s[k & 1] += r \/ k;\n} while (r > eps);\n\nprintf(\"gamma\u00a0%.16f\\nk = %d\\n\\n\", s[1] - s[0] - log(n), k);\n\n\nprintf(\"Bailey, 1988\\n\");\n\nn = 5;\n\na = 1;\nh = 1;\nn2 = pow(2,n);\nr = 1;\nk = 1;\ndo {\n k += 1;\n r *= n2 \/ k;\n h += 1.0 \/ k;\n b = a; a += r * h;\n} while (fabs(b - a) > eps);\na *= n2 \/ exp(n2);\n\nprintf(\"gamma\u00a0%.16f\\nk = %d\\n\\n\", a - n * log(2), k);\n\n\nprintf(\"Brent-McMillan, 1980\\n\");\n\nn = 13;\n\na = -log(n);\nb = 1;\nu = a;\nv = b;\nn2 = n * n;\nk2 = 0;\nk = 0;\ndo {\n k2 += 2*k + 1;\n k += 1;\n a *= n2 \/ k;\n b *= n2 \/ k2;\n a = (a + b) \/ k;\n u += a;\n v += b;\n} while (fabs(a) > eps);\n\nprintf(\"gamma\u00a0%.16f\\nk = %d\\n\\n\", u \/ v, k);\n\n\nprintf(\"How Euler did it in 1735\\n\");\n\ndouble B2[] = {1.0,1.0\/6,-1.0\/30,1.0\/42,-1.0\/30,\\\n 5.0\/66,-691.0\/2730,7.0\/6,-3617.0\/510,43867.0\/798};\nm = 7;\nif (m > 9) return(0);\n\nn = 10;\n\n\nh = 1;\nfor (k = 2; k <= n; k++) {\n h += 1.0 \/ k;\n}\nprintf(\"Hn \u00a0%.16f\\n\", h);\n\nh -= log(n);\nprintf(\" -ln\u00a0%.16f\\n\", h);\n\n\na = -1.0 \/ (2*n);\nn2 = n * n;\nr = 1;\nfor (k = 1; k <= m; k++) {\n r *= n2;\n a += B2[k] \/ (2*k * r);\n}\n\nprintf(\"err \u00a0%.16f\\ngamma\u00a0%.16f\\nk = %d\", a, h + a, n + m);\n\nprintf(\"\\n\\nC = 0.57721566490153286...\\n\");\n}\n","Rust":"\n\nfn gamma(N: u32) -> f64 { \n\n return 1f64 \/ 2f64 - 1f64 \/ 3f64\n + ((2..=N).map(|n| {\n let power: u32 = 2u32.pow(n);\n let mut sign: f64 = -1f64;\n let mut term: f64 = 0f64;\n\n for denominator in power..=(2 * power - 1) {\n sign *= -1f64;\n term += sign \/ f64::from(denominator);\n }\n\n return f64::from(n) * term;\n }))\n .sum::();\n}\n\nfn main() {\n println!(\"{}\", gamma(23));\n}\n"} {"name":"Exceptions","C":"#include \n \nenum { MY_EXCEPTION = 1 }; \n \njmp_buf env;\n \nvoid foo()\n{\n longjmp(env, MY_EXCEPTION); \n}\n \nvoid call_foo()\n{\n switch (setjmp(env)) {\n case 0: \n foo();\n break;\n case MY_EXCEPTION: \n \n break;\n default:\n \n \n \n \n }\n}\n","Rust":"\n\nuse std::io::{Error, ErrorKind};\n\n\n\n\nfn valid_function() -> Result {\n Ok(100)\n}\n\nfn errored_function() -> Result {\n Err(Error::new(ErrorKind::Other, \"Something wrong happened.\"))\n}\n\n\nfn panicking_function() {\n panic!(\"Unrecoverable state reached\");\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_valid_function() {\n let result = match valid_function() {\n Ok(number) => number,\n Err(_) => panic!(\"This is not going to happen\"),\n };\n assert_eq!(result, 100);\n }\n\n #[test]\n fn test_errored_function() {\n let result = match errored_function() {\n Ok(_) => panic!(\"This is not going to happen\"),\n Err(e) => {\n assert_eq!(e.to_string(), \"Something wrong happened.\");\n 0\n }\n };\n assert_eq!(result, 0);\n }\n\n #[test]\n #[should_panic]\n fn test_panicking_function() {\n panicking_function();\n }\n}\n"} {"name":"Execute Brain____","C":"#include \nint main(){\n int ptr=0, i=0, cell[7];\n for( i=0; i<7; ++i) cell[i]=0;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 8;\n while(cell[ptr])\n {\n ptr-= 1;\n if(ptr<0) perror(\"Program pointer underflow\");\n cell[ptr]+= 9;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]-= 1;\n }\n ptr-= 1;\n if(ptr<0) perror(\"Program pointer underflow\");\n putchar(cell[ptr]);\n ptr+= 2;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 1;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 1;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 2;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n while(cell[ptr])\n {\n cell[ptr]-= 1;\n }\n cell[ptr]+= 1;\n ptr-= 1;\n if(ptr<0) perror(\"Program pointer underflow\");\n while(cell[ptr])\n {\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n while(cell[ptr])\n {\n cell[ptr]-= 1;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 1;\n ptr-= 2;\n if(ptr<0) perror(\"Program pointer underflow\");\n cell[ptr]+= 4;\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n }\n ptr-= 2;\n if(ptr<0) perror(\"Program pointer underflow\");\n }\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n putchar(cell[ptr]);\n cell[ptr]+= 7;\n putchar(cell[ptr]);\n putchar(cell[ptr]);\n cell[ptr]+= 3;\n putchar(cell[ptr]);\n ptr+= 2;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 7;\n putchar(cell[ptr]);\n ptr-= 3;\n if(ptr<0) perror(\"Program pointer underflow\");\n while(cell[ptr])\n {\n while(cell[ptr])\n {\n cell[ptr]-= 1;\n }\n ptr-= 1;\n if(ptr<0) perror(\"Program pointer underflow\");\n while(cell[ptr])\n {\n cell[ptr]-= 1;\n }\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n }\n ptr-= 1;\n if(ptr<0) perror(\"Program pointer underflow\");\n cell[ptr]+= 15;\n putchar(cell[ptr]);\n ptr+= 2;\n if(ptr>=7) perror(\"Program pointer overflow\");\n putchar(cell[ptr]);\n cell[ptr]+= 3;\n putchar(cell[ptr]);\n cell[ptr]-= 6;\n putchar(cell[ptr]);\n cell[ptr]-= 8;\n putchar(cell[ptr]);\n ptr+= 2;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 1;\n putchar(cell[ptr]);\n ptr+= 1;\n if(ptr>=7) perror(\"Program pointer overflow\");\n cell[ptr]+= 4;\n putchar(cell[ptr]);\n return 0;\n}\n","Rust":"use std::collections::HashMap;\nuse std::env;\nuse std::fs::File;\nuse std::io::prelude::*;\nuse std::io::stdin;\nuse std::num::Wrapping;\n\nfn main() {\n let args: Vec<_> = env::args().collect();\n if args.len() < 2 {\n println!(\"Usage: {} [path] (--debug)\", args[0]);\n return;\n }\n\n let src: Vec = {\n let mut buf = String::new();\n match File::open(&args[1])\n {\n Ok(mut f) => { f.read_to_string(&mut buf).unwrap(); }\n Err(e) => {\n println!(\"Error opening '{}': {}\", args[1], e);\n return;\n }\n }\n\n buf.chars().collect()\n };\n\n \n let debug = args.contains(&\"--debug\".to_owned());\n\n \n let brackets: HashMap = {\n let mut m = HashMap::new();\n let mut scope_stack = Vec::new();\n for (idx, ch) in src.iter().enumerate() {\n match ch {\n &'[' => { scope_stack.push(idx); }\n &']' => { m.insert(scope_stack.pop().unwrap(), idx); }\n _ => { }\n }\n }\n\n m\n };\n\n let mut pc: usize = 0; \n let mut mem: [Wrapping;5000] = [Wrapping(0);5000]; \n let mut ptr: usize = 0; \n let mut stack: Vec = Vec::new(); \n\n let stdin_ = stdin();\n let mut reader = stdin_.lock().bytes();\n while pc < src.len() {\n let Wrapping(val) = mem[ptr];\n\n if debug {\n println!(\"(BFDB) PC: {:04} \\tPTR: {:04} \\t$PTR: {:03} \\tSTACK_DEPTH: {} \\tSYMBOL: {}\", pc, ptr, val, stack.len(), src[pc]);\n }\n\n const ONE: Wrapping = Wrapping(1);\n match src[pc] {\n '>' => { ptr += 1; }\n '<' => { ptr -= 1; }\n\n '+' => { mem[ptr] = mem[ptr] + ONE; }\n '-' => { mem[ptr] = mem[ptr] - ONE; }\n\n '[' => {\n if val == 0 {\n pc = brackets[&pc];\n } else {\n stack.push(pc);\n }\n }\n ']' => {\n let matching_bracket = stack.pop().unwrap();\n if val != 0 {\n pc = matching_bracket - 1;\n }\n }\n\n '.' => {\n if debug {\n println!(\"(BFDB) STDOUT: '{}'\", val as char); \n } else {\n print!(\"{}\", val as char);\n }\n }\n ',' => {\n mem[ptr] = Wrapping(reader.next().unwrap().unwrap());\n }\n\n _ => { }\n }\n\n pc += 1;\n }\n}\n"} {"name":"Execute HQ9+","C":"void runCode(const char *code)\n{\n int c_len = strlen(code);\n int i, bottles;\n unsigned accumulator=0;\n for(i=0;i 0 );\n break;\n\n case '+':\n \n accumulator++;\n break;\n }\n }\n};\n","Rust":"use std::env;\n\n\n#[allow(unused_variables)]\nfn execute(code: &str) {\n let mut accumulator = 0;\n\n for c in code.chars() {\n match c {\n 'Q' => println!(\"{}\", code),\n 'H' => println!(\"Hello, World!\"),\n '9' => {\n for n in (1..100).rev() {\n println!(\"{} bottles of beer on the wall\", n);\n println!(\"{} bottles of beer\", n);\n println!(\"Take one down, pass it around\");\n if (n - 1) > 1 {\n println!(\"{} bottles of beer on the wall\\n\", n - 1);\n } else {\n println!(\"1 bottle of beer on the wall\\n\");\n }\n }\n }\n '+' => accumulator += 1,\n _ => panic!(\"Invalid character '{}' found in source.\", c),\n }\n }\n}\n\nfn main() {\n execute(&env::args().nth(1).unwrap());\n}\n"} {"name":"Extra primes","C":"#include \n#include \n#include \n\nunsigned int next_prime_digit_number(unsigned int n) {\n if (n == 0)\n return 2;\n switch (n % 10) {\n case 2:\n return n + 1;\n case 3:\n case 5:\n return n + 2;\n default:\n return 2 + next_prime_digit_number(n\/10) * 10;\n }\n}\n\nbool is_prime(unsigned int n) {\n if (n < 2)\n return false;\n if ((n & 1) == 0)\n return n == 2;\n if (n % 3 == 0)\n return n == 3;\n if (n % 5 == 0)\n return n == 5;\n static const unsigned int wheel[] = { 4,2,4,2,4,6,2,6 };\n unsigned int p = 7;\n for (;;) {\n for (int w = 0; w < sizeof(wheel)\/sizeof(wheel[0]); ++w) {\n if (p * p > n)\n return true;\n if (n % p == 0)\n return false;\n p += wheel[w];\n }\n }\n}\n\nunsigned int digit_sum(unsigned int n) {\n unsigned int sum = 0;\n for (; n > 0; n \/= 10)\n sum += n % 10;\n return sum;\n}\n\nint main() {\n setlocale(LC_ALL, \"\");\n const unsigned int limit1 = 10000;\n const unsigned int limit2 = 1000000000;\n const int last = 10;\n unsigned int p = 0, n = 0;\n unsigned int extra_primes[last];\n printf(\"Extra primes under\u00a0%'u:\\n\", limit1);\n while ((p = next_prime_digit_number(p)) < limit2) {\n if (is_prime(digit_sum(p)) && is_prime(p)) {\n ++n;\n if (p < limit1)\n printf(\"%2u:\u00a0%'u\\n\", n, p);\n extra_primes[n % last] = p;\n }\n }\n printf(\"\\nLast %d extra primes under\u00a0%'u:\\n\", last, limit2);\n for (int i = last - 1; i >= 0; --i)\n printf(\"%'u:\u00a0%'u\\n\", n-i, extra_primes[(n-i) % last]);\n return 0;\n}\n","Rust":"\n\n\nfn is_prime(n: u64) -> bool {\n primal::is_prime(n)\n}\n\nfn next_prime_digit_number(n: u64) -> u64 {\n if n == 0 {\n return 2;\n }\n match n % 10 {\n 2 => n + 1,\n 3 | 5 => n + 2,\n _ => 2 + next_prime_digit_number(n \/ 10) * 10,\n }\n}\n\nfn digit_sum(mut n: u64) -> u64 {\n let mut sum = 0;\n while n > 0 {\n sum += n % 10;\n n \/= 10;\n }\n return sum;\n}\n\nfn main() {\n let limit1 = 10000;\n let limit2 = 1000000000;\n let last = 10;\n let mut p = 0;\n let mut n = 0;\n let mut extra_primes = vec![0; last];\n println!(\"Extra primes under {}:\", limit1);\n loop {\n p = next_prime_digit_number(p);\n if p >= limit2 {\n break;\n }\n if is_prime(digit_sum(p)) && is_prime(p) {\n n += 1;\n if p < limit1 {\n println!(\"{:2}: {}\", n, p);\n }\n extra_primes[n % last] = p;\n }\n }\n println!(\"\\nLast {} extra primes under {}:\", last, limit2);\n let mut i = last;\n while i > 0 {\n i -= 1;\n println!(\"{}: {}\", n - i, extra_primes[(n - i) % last]);\n }\n}\n"} {"name":"FTP","C":"#include \n\nint main(void)\n{\n netbuf *nbuf;\n\n FtpInit();\n FtpConnect(\"kernel.org\", &nbuf);\n FtpLogin(\"anonymous\", \"\", nbuf);\n FtpOptions(FTPLIB_CONNMODE, FTPLIB_PASSIVE, nbuf);\n FtpChdir(\"pub\/linux\/kernel\", nbuf);\n FtpDir((void*)0, \".\", nbuf);\n FtpGet(\"ftp.README\", \"README\", FTPLIB_ASCII, nbuf);\n FtpQuit(nbuf);\n\n return 0;\n}\n","Rust":"use std::{error::Error, fs::File, io::copy};\nuse ftp::FtpStream;\n\nfn main() -> Result<(), Box> {\n let mut ftp = FtpStream::connect(\"ftp.easynet.fr:21\")?;\n ftp.login(\"anonymous\", \"\")?;\n ftp.cwd(\"debian\")?;\n for file in ftp.list(None)? {\n println!(\"{}\", file);\n }\n let mut stream = ftp.get(\"README\")?;\n let mut file = File::create(\"README\")?;\n copy(&mut stream, &mut file)?;\n Ok(())\n}\n"} {"name":"Fairshare between two and more","C":"#include \n#include \n\nint turn(int base, int n) {\n int sum = 0;\n while (n != 0) {\n int rem = n % base;\n n = n \/ base;\n sum += rem;\n }\n return sum % base;\n}\n\nvoid fairshare(int base, int count) {\n int i;\n\n printf(\"Base %2d:\", base);\n for (i = 0; i < count; i++) {\n int t = turn(base, i);\n printf(\" %2d\", t);\n }\n printf(\"\\n\");\n}\n\nvoid turnCount(int base, int count) {\n int *cnt = calloc(base, sizeof(int));\n int i, minTurn, maxTurn, portion;\n\n if (NULL == cnt) {\n printf(\"Failed to allocate space to determine the spread of turns.\\n\");\n return;\n }\n\n for (i = 0; i < count; i++) {\n int t = turn(base, i);\n cnt[t]++;\n }\n\n minTurn = INT_MAX;\n maxTurn = INT_MIN;\n portion = 0;\n for (i = 0; i < base; i++) {\n if (cnt[i] > 0) {\n portion++;\n }\n if (cnt[i] < minTurn) {\n minTurn = cnt[i];\n }\n if (cnt[i] > maxTurn) {\n maxTurn = cnt[i];\n }\n }\n\n printf(\" With %d people: \", base);\n if (0 == minTurn) {\n printf(\"Only %d have a turn\\n\", portion);\n } else if (minTurn == maxTurn) {\n printf(\"%d\\n\", minTurn);\n } else {\n printf(\"%d or %d\\n\", minTurn, maxTurn);\n }\n\n free(cnt);\n}\n\nint main() {\n fairshare(2, 25);\n fairshare(3, 25);\n fairshare(5, 25);\n fairshare(11, 25);\n\n printf(\"How many times does each get a turn in 50000 iterations?\\n\");\n turnCount(191, 50000);\n turnCount(1377, 50000);\n turnCount(49999, 50000);\n turnCount(50000, 50000);\n turnCount(50001, 50000);\n\n return 0;\n}\n","Rust":"struct Digits {\n rest: usize,\n base: usize,\n}\n\nimpl Iterator for Digits {\n type Item = usize;\n \n fn next(&mut self) -> Option {\n if self.rest == 0 {\n return None;\n }\n let (digit, rest) = (self.rest % self.base, self.rest \/ self.base);\n self.rest = rest;\n Some(digit)\n }\n}\n\nfn digits(num: usize, base: usize) -> Digits {\n Digits { rest: num, base: base }\n}\n\nstruct FairSharing {\n participants: usize,\n index: usize,\n}\n\nimpl Iterator for FairSharing {\n type Item = usize;\n fn next(&mut self) -> Option {\n let digit_sum: usize = digits(self.index, self.participants).sum();\n let selected = digit_sum % self.participants;\n self.index += 1;\n Some(selected)\n }\n}\n\nfn fair_sharing(participants: usize) -> FairSharing {\n FairSharing { participants: participants, index: 0 }\n}\n\nfn main() {\n for i in vec![2, 3, 5, 7] {\n println!(\"{}: {:?}\", i, fair_sharing(i).take(25).collect::>());\n }\n}\n"} {"name":"Farey sequence","C":"#include \n#include \n#include \n\nvoid farey(int n)\n{\n\ttypedef struct { int d, n; } frac;\n\tfrac f1 = {0, 1}, f2 = {1, n}, t;\n\tint k;\n\n\tprintf(\"%d\/%d %d\/%d\", 0, 1, 1, n);\n\twhile (f2.n > 1) {\n\t\tk = (n + f1.n) \/ f2.n;\n\t\tt = f1, f1 = f2, f2 = (frac) { f2.d * k - t.d, f2.n * k - t.n };\n\t\tprintf(\" %d\/%d\", f2.d, f2.n);\n\t}\n\n\tputchar('\\n');\n}\n\ntypedef unsigned long long ull;\null *cache;\nsize_t ccap;\n\null farey_len(int n)\n{\n\tif (n >= ccap) {\n\t\tsize_t old = ccap;\n\t\tif (!ccap) ccap = 16;\n\t\twhile (ccap <= n) ccap *= 2;\n\t\tcache = realloc(cache, sizeof(ull) * ccap);\n\t\tmemset(cache + old, 0, sizeof(ull) * (ccap - old));\n\t} else if (cache[n])\n\t\treturn cache[n];\n\n\tull len = (ull)n*(n + 3) \/ 2;\n\tint p, q = 0;\n\tfor (p = 2; p <= n; p = q) {\n\t\tq = n\/(n\/p) + 1;\n\t\tlen -= farey_len(n\/p) * (q - p);\n\t}\n\n\tcache[n] = len;\n\treturn len;\n}\n\nint main(void)\n{\n\tint n;\n\tfor (n = 1; n <= 11; n++) {\n\t\tprintf(\"%d: \", n);\n\t\tfarey(n);\n\t}\n\n\tfor (n = 100; n <= 1000; n += 100)\n\t\tprintf(\"%d: %llu items\\n\", n, farey_len(n));\n\n\tn = 10000000;\n\tprintf(\"\\n%d: %llu items\\n\", n, farey_len(n));\n\treturn 0;\n}\n","Rust":"#[derive(Copy, Clone)]\nstruct Fraction {\n numerator: u32,\n denominator: u32,\n}\n\nuse std::fmt;\n\nimpl fmt::Display for Fraction {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{}\/{}\", self.numerator, self.denominator)\n }\n}\n\nimpl Fraction {\n fn new(n: u32, d: u32) -> Fraction {\n Fraction {\n numerator: n,\n denominator: d,\n }\n }\n}\n\nfn farey_sequence(n: u32) -> impl std::iter::Iterator {\n let mut a = 0;\n let mut b = 1;\n let mut c = 1;\n let mut d = n;\n std::iter::from_fn(move || {\n if a > n {\n return None;\n }\n let result = Fraction::new(a, b);\n let k = (n + b) \/ d;\n let next_c = k * c - a;\n let next_d = k * d - b;\n a = c;\n b = d;\n c = next_c;\n d = next_d;\n Some(result)\n })\n}\n\nfn main() {\n for n in 1..=11 {\n print!(\"{}:\", n);\n for f in farey_sequence(n) {\n print!(\" {}\", f);\n }\n println!();\n }\n for n in (100..=1000).step_by(100) {\n println!(\"{}: {}\", n, farey_sequence(n).count());\n }\n}\n"} {"name":"Fermat numbers","C":"#include \n#include \n#include \n\nvoid mpz_factors(mpz_t n) {\n int factors = 0;\n mpz_t s, m, p;\n mpz_init(s), mpz_init(m), mpz_init(p);\n\n mpz_set_ui(m, 3);\n mpz_set(p, n);\n mpz_sqrt(s, p);\n\n while (mpz_cmp(m, s) < 0) {\n if (mpz_divisible_p(p, m)) {\n gmp_printf(\"%Zd \", m);\n mpz_fdiv_q(p, p, m);\n mpz_sqrt(s, p);\n factors ++;\n }\n mpz_add_ui(m, m, 2);\n }\n\n if (factors == 0) printf(\"PRIME\\n\");\n else gmp_printf(\"%Zd\\n\", p);\n}\n\nint main(int argc, char const *argv[]) {\n mpz_t fermat;\n mpz_init_set_ui(fermat, 3);\n printf(\"F(0) = 3 -> PRIME\\n\");\n for (unsigned i = 1; i < 10; i ++) {\n mpz_sub_ui(fermat, fermat, 1);\n mpz_mul(fermat, fermat, fermat);\n mpz_add_ui(fermat, fermat, 1);\n gmp_printf(\"F(%d) = %Zd -> \", i, fermat);\n mpz_factors(fermat);\n }\n\n return 0;\n}\n","Rust":" struct DivisorGen {\n curr: u64,\n last: u64,\n}\n\nimpl Iterator for DivisorGen {\n type Item = u64;\n\n fn next(&mut self) -> Option {\n self.curr += 2u64;\n\n if self.curr < self.last{\n None\n } else {\n Some(self.curr)\n }\n }\n}\n\nfn divisor_gen(num : u64) -> DivisorGen {\n DivisorGen { curr: 0u64, last: (num \/ 2u64) + 1u64 }\n}\n\nfn is_prime(num : u64) -> bool{\n if num == 2 || num == 3 {\n return true;\n } else if num % 2 == 0 || num % 3 == 0 || num <= 1{\n return false;\n }else{\n for i in divisor_gen(num){\n if num % i == 0{\n return false;\n }\n }\n }\n return true;\n}\n\n\nfn main() {\n let fermat_closure = |i : u32| -> u64 {2u64.pow(2u32.pow(i + 1u32))};\n let mut f_numbers : Vec = Vec::new();\n \n println!(\"First 4 Fermat numbers:\");\n for i in 0..4 {\n let f = fermat_closure(i) + 1u64;\n f_numbers.push(f);\n println!(\"F{}: {}\", i, f);\n }\n \n println!(\"Factor of the first four numbers:\");\n for f in f_numbers.iter(){\n let is_prime : bool = f % 4 == 1 && is_prime(*f);\n let not_or_not = if is_prime {\" \"} else {\" not \"};\n println!(\"{} is{}prime\", f, not_or_not);\n }\n}\n"} {"name":"Fibonacci word_fractal","C":"#include \n\nint main(void)\n{\n\tputs(\t\"%!PS-Adobe-3.0 EPSF\\n\"\n\t\t\"%%BoundingBox: -10 -10 400 565\\n\"\n\t\t\"\/a{0 0 moveto 0 .4 translate 0 0 lineto stroke -1 1 scale}def\\n\"\n\t\t\"\/b{a 90 rotate}def\");\n\n\tchar i;\n\tfor (i = 'c'; i <= 'z'; i++)\n\t\tprintf(\"\/%c{%c %c}def\\n\", i, i-1, i-2);\n\n\tputs(\"0 setlinewidth z showpage\\n%%EOF\");\n\n\treturn 0;\n}\n","Rust":"\n\n\nuse svg::node::element::path::Data;\nuse svg::node::element::Path;\n\nfn fibonacci_word(n: usize) -> Vec {\n let mut f0 = vec![1];\n let mut f1 = vec![0];\n if n == 0 {\n return f0;\n } else if n == 1 {\n return f1;\n }\n let mut i = 2;\n loop {\n let mut f = Vec::with_capacity(f1.len() + f0.len());\n f.extend(&f1);\n f.extend(f0);\n if i == n {\n return f;\n }\n f0 = f1;\n f1 = f;\n i += 1;\n }\n}\n\nstruct FibwordFractal {\n current_x: f64,\n current_y: f64,\n current_angle: i32,\n line_length: f64,\n max_x: f64,\n max_y: f64,\n}\n\nimpl FibwordFractal {\n fn new(x: f64, y: f64, length: f64, angle: i32) -> FibwordFractal {\n FibwordFractal {\n current_x: x,\n current_y: y,\n current_angle: angle,\n line_length: length,\n max_x: 0.0,\n max_y: 0.0,\n }\n }\n fn execute(&mut self, n: usize) -> Path {\n let mut data = Data::new().move_to((self.current_x, self.current_y));\n for (i, byte) in fibonacci_word(n).iter().enumerate() {\n data = self.draw_line(data);\n if *byte == 0u8 {\n self.turn(if i % 2 == 1 { -90 } else { 90 });\n }\n }\n Path::new()\n .set(\"fill\", \"none\")\n .set(\"stroke\", \"black\")\n .set(\"stroke-width\", \"1\")\n .set(\"d\", data)\n }\n fn draw_line(&mut self, data: Data) -> Data {\n let theta = (self.current_angle as f64).to_radians();\n self.current_x += self.line_length * theta.cos();\n self.current_y += self.line_length * theta.sin();\n if self.current_x > self.max_x {\n self.max_x = self.current_x;\n }\n if self.current_y > self.max_y {\n self.max_y = self.current_y;\n }\n data.line_to((self.current_x, self.current_y))\n }\n fn turn(&mut self, angle: i32) {\n self.current_angle = (self.current_angle + angle) % 360;\n }\n fn save(file: &str, order: usize) -> std::io::Result<()> {\n use svg::node::element::Rectangle;\n let x = 5.0;\n let y = 5.0;\n let rect = Rectangle::new()\n .set(\"width\", \"100%\")\n .set(\"height\", \"100%\")\n .set(\"fill\", \"white\");\n let mut ff = FibwordFractal::new(x, y, 1.0, 0);\n let path = ff.execute(order);\n let document = svg::Document::new()\n .set(\"width\", 5 + ff.max_x as usize)\n .set(\"height\", 5 + ff.max_y as usize)\n .add(rect)\n .add(path);\n svg::save(file, &document)\n }\n}\n\nfn main() {\n FibwordFractal::save(\"fibword_fractal.svg\", 22).unwrap();\n}\n"} {"name":"File size distribution","C":"#include\n#include\n#include\n\n#define MAXORDER 25\n\nint main(int argC, char* argV[])\n{\n\tchar str[MAXORDER],commandString[1000],*startPath;\n\tlong int* fileSizeLog = (long int*)calloc(sizeof(long int),MAXORDER),max;\n\tint i,j,len;\n\tdouble scale;\n\tFILE* fp;\n\n\tif(argC==1)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\telse{\n\t\tif(strchr(argV[1],' ')!=NULL){\n\t\tlen = strlen(argV[1]);\n\t\tstartPath = (char*)malloc((len+2)*sizeof(char));\n\t\tstartPath[0] = '\\\"';\n\t\tstartPath[len+1]='\\\"';\n\t\tstrncpy(startPath+1,argV[1],len);\n\t\tstartPath[len+2] = argV[1][len];\n\t\tsprintf(commandString,\"forfiles \/p %s \/s \/c \\\"cmd \/c echo @fsize\\\" 2>&1\",startPath);\n\t}\n\n\telse if(strlen(argV[1])==1 && argV[1][0]=='.')\n\t\tstrcpy(commandString,\"forfiles \/s \/c \\\"cmd \/c echo @fsize\\\" 2>&1\");\n\n\telse\n\t\tsprintf(commandString,\"forfiles \/p %s \/s \/c \\\"cmd \/c echo @fsize\\\" 2>&1\",argV[1]);\n\n\tfp = popen(commandString,\"r\");\n\n\twhile(fgets(str,100,fp)!=NULL){\n\t\t\tif(str[0]=='0')\n\t\t\t\tfileSizeLog[0]++;\n\t\t\telse\n\t\t\t\tfileSizeLog[strlen(str)]++;\n\t}\n\n\tif(argC==2 || (argC==3 && (argV[2][0]=='t'||argV[2][0]=='T'))){\n\t\tfor(i=0;imax)?max=fileSizeLog[i]:max;\n\n\t\t\t\t(max < csbi.dwSize.X)?(scale=1):(scale=(1.0*(csbi.dwSize.X-50))\/max);\n\n\t\t\t\tfor(i=0;i Result<(), Box> {\n let start = time::Instant::now();\n let args: Vec = env::args().collect();\n\n let root = parse_path(&args).expect(\"not a valid path\");\n let dir = WalkDir::new(&root);\n\n let (files, dirs): (Vec, Vec) = {\n let pool = pool(dir).expect(\"unable to retrieve entries from WalkDir\");\n partition_from(pool).expect(\"unable to partition files from directories\")\n };\n\n let (fs_count, dr_count) = (files.len(), dirs.len());\n let (file_counter, total_size) = file_count(files);\n\n {\n println!(\"++ File size distribution for\u00a0: {} ++\\n\", &root.display());\n println!(\"Files @ 0B \u00a0: {:4}\", file_counter[0]);\n println!(\"Files > 1B - 1,023B \u00a0: {:4}\", file_counter[1]);\n println!(\"Files > 1KB - 1,023KB\u00a0: {:4}\", file_counter[2]);\n println!(\"Files > 1MB - 1,023MB\u00a0: {:4}\", file_counter[3]);\n println!(\"Files > 1GB - 1,023GB\u00a0: {:4}\", file_counter[4]);\n println!(\"Files > 1TB+ \u00a0: {:4}\\n\", file_counter[5]);\n\n println!(\"Files encountered: {}\", fs_count);\n println!(\"Directories traversed: {}\", dr_count);\n println!(\n \"Total size of all files: {}\\n\",\n Filesize::::from(total_size)\n );\n }\n\n let end = time::Instant::now();\n println!(\"Run time: {:?}\\n\", end.duration_since(start));\n Ok(())\n}\n\nfn parse_path(args: &[String]) -> Result<&Path, io::Error> {\n \n match args.len() {\n 1 => Ok(Path::new(&args[0])),\n _ => Ok(Path::new(&args[1])),\n }\n}\n\nfn pool(dir: WalkDir) -> Result, Box> {\n \n Ok(dir.into_iter().filter_map(|e| e.ok()).collect())\n}\n\nfn partition_from(pool: Vec) -> Result<(Vec, Vec), Box> {\n \n Ok(pool\n .into_iter()\n .map(|e| e.into_path())\n .partition(|path| path.is_file()))\n}\n\nfn file_count(files: Vec) -> ([u64; 6], u64) {\n let mut counter: [u64; 6] = [0; 6];\n for file in &files {\n match Filesize::::from(file).bytes {\n 0 => counter[0] += 1, \n 1..=1_023 => counter[1] += 1, \n 1_024..=1_048_575 => counter[2] += 1, \n 1_048_576..=1_073_741_823 => counter[3] += 1, \n 1_073_741_824..=1_099_511_627_775 => counter[4] += 1, \n 1_099_511_627_776..=std::u64::MAX => counter[5] += 1, \n }\n }\n\n let total_file_size = files\n .iter()\n .fold(0, |acc, file| acc + Filesize::::from(file).bytes);\n (counter, total_file_size)\n}\n\ntrait SizeUnit: Copy {\n fn singular_name() -> String;\n fn num_byte_in_unit() -> u64;\n}\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]\nstruct Bytes;\nimpl SizeUnit for Bytes {\n fn singular_name() -> String {\n \"B\".to_string()\n }\n fn num_byte_in_unit() -> u64 {\n 1\n }\n}\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]\nstruct Kilobytes;\nimpl SizeUnit for Kilobytes {\n fn singular_name() -> String {\n \"KB\".to_string()\n }\n fn num_byte_in_unit() -> u64 {\n 1_024\n }\n}\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]\nstruct Filesize {\n bytes: u64,\n unit: PhantomData,\n}\n\nimpl From for Filesize\nwhere\n T: SizeUnit,\n{\n fn from(n: u64) -> Self {\n Filesize {\n bytes: n * T::num_byte_in_unit(),\n unit: PhantomData,\n }\n }\n}\n\nimpl From> for u64\nwhere\n T: SizeUnit,\n{\n fn from(fsz: Filesize) -> u64 {\n ((fsz.bytes as f64) \/ (T::num_byte_in_unit() as f64)) as u64\n }\n}\n\nimpl fmt::Display for Filesize\nwhere\n T: SizeUnit,\n{\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n \n let size_val = ((self.bytes as f64) \/ (T::num_byte_in_unit() as f64)) as u64;\n\n \n let name_plural = match size_val {\n 1 => \"\",\n _ => \"s\",\n };\n\n write!(\n f,\n \"{} {}{}\",\n (self.bytes as f64) \/ (T::num_byte_in_unit() as f64),\n T::singular_name(),\n name_plural\n )\n }\n}\n\n\nimpl From<&PathBuf> for Filesize\nwhere\n T: SizeUnit,\n{\n fn from(f: &PathBuf) -> Self {\n Filesize {\n bytes: f\n .metadata()\n .expect(\"error with metadata from pathbuf into filesize\")\n .len(),\n unit: PhantomData,\n }\n }\n}\n"} {"name":"Find adjacent primes which differ by a square integer","C":"#include\n#include\n\nint isprime( int p ) {\n int i;\n if(p==2) return 1;\n if(!(p%2)) return 0;\n for(i=3; i*i<=p; i+=2) {\n if(!(p%i)) return 0;\n }\n return 1;\n}\n\nint nextprime( int p ) {\n int i=0;\n if(p==0) return 2;\n if(p<3) return p+1;\n while(!isprime(++i + p));\n return i+p;\n}\n\nint issquare( int p ) {\n int i;\n for(i=0;i*i36&&issquare(j-i)) printf( \"%d %d %d\\n\", i, j, j-i );\n }\n return 0;\n}\n","Rust":"use prime_tools ;\n\nfn is_square_number( num : u32 ) -> bool {\n let comp_num : f32 = num as f32 ;\n let root = comp_num.sqrt( ) ;\n return root == root.floor( ) ;\n}\n\nfn main() {\n let primes: Vec = prime_tools::get_primes_less_than_x(1000000_u32) ;\n let len = primes.len( ) ;\n let mut i : usize = 0 ;\n while i < len - 1 {\n let diff : u32 = primes[ i + 1 ] - primes[ i ] ;\n if diff > 36 && is_square_number( diff ) {\n println!(\"{} - {} = {}\" , primes[ i + 1 ] , primes[ i ] , diff) ;\n }\n i += 1 ;\n }\n}\n"} {"name":"Find prime n such that reversed n is also prime","C":"#include \n#include \n\nbool is_prime(unsigned int n) {\n if (n < 2)\n return false;\n if (n % 2 == 0)\n return n == 2;\n if (n % 3 == 0)\n return n == 3;\n for (unsigned int p = 5; p * p <= n; p += 4) {\n if (n % p == 0)\n return false;\n p += 2;\n if (n % p == 0)\n return false;\n }\n return true;\n}\n\nunsigned int reverse(unsigned int n) {\n unsigned int rev = 0;\n for (; n > 0; n \/= 10)\n rev = rev * 10 + n % 10;\n return rev;\n}\n\nint main() {\n unsigned int count = 0;\n for (unsigned int n = 1; n < 500; ++n) {\n if (is_prime(n) && is_prime(reverse(n)))\n printf(\"%3u%c\", n, ++count % 10 == 0 ? '\\n' : ' ');\n }\n printf(\"\\nCount = %u\\n\", count);\n return 0;\n}\n","Rust":"use prime_tools ;\n\nfn myreverse( n : u32 ) -> u32 {\n let forward : String = n.to_string( ) ;\n let numberstring = &forward[..] ;\n let mut reversed : String = String::new( ) ;\n for c in numberstring.chars( ).rev( ) {\n reversed.push( c ) ;\n }\n *&reversed[..].parse::( ).unwrap( )\n}\n\nfn main() {\n let mut reversible_primes : Vec = Vec::new( ) ;\n for num in 2..=500 {\n if prime_tools::is_u32_prime( num ) && prime_tools::is_u32_prime( \n myreverse( num )) {\n reversible_primes.push( num ) ;\n }\n }\n println!(\"{:?}\" , reversible_primes ) ;\n}\n"} {"name":"Find the last Sunday of each month","C":"#include \n#include \n\nint main(int argc, char *argv[])\n{\n int days[] = {31,29,31,30,31,30,31,31,30,31,30,31};\n int m, y, w;\n\n if (argc < 2 || (y = atoi(argv[1])) <= 1752) return 1;\n days[1] -= (y % 4) || (!(y % 100) && (y % 400));\n w = y * 365 + 97 * (y - 1) \/ 400 + 4;\n\n for(m = 0; m < 12; m++) {\n w = (w + days[m]) % 7;\n printf(\"%d-%02d-%d\\n\", y, m + 1,days[m] - w);\n }\n\n return 0;\n}\n","Rust":"use std::env::args;\nuse time::{Date, Duration};\n\nfn main() {\n let year = args().nth(1).unwrap().parse::().unwrap();\n (1..=12)\n .map(|month| Date::try_from_ymd(year + month \/ 12, ((month % 12) + 1) as u8, 1))\n .filter_map(|date| date.ok())\n .for_each(|date| {\n let days_back =\n Duration::days(((date.weekday().number_from_sunday() as i64 + 5) % 7) + 1);\n println!(\"{}\", date - days_back);\n });\n}\n"} {"name":"Finite state machine","C":"#include \n#include \n#include \n\nint main(int argc, char **argv)\n{\n typedef enum State { READY, WAITING, REFUND, DISPENSE, COLLECT, QUIT } State;\n\n typedef struct statechange {\n const int in;\n const State out;\n } statechange;\n\n#define MAXINPUTS 3\n typedef struct FSM {\n const State state;\n void (*Action)(void);\n const statechange table[MAXINPUTS]; \n } FSM;\n\n char str[10];\n void Ready(void) { fprintf(stderr, \"\\nMachine is READY. (D)eposit or (Q)uit\u00a0:\"); scanf(\"%s\", str); }\n void Waiting(void) { fprintf(stderr, \"(S)elect product or choose to (R)efund\u00a0:\"); scanf(\"%s\", str); }\n void Refund(void) { fprintf(stderr, \"Please collect refund.\\n\"); }\n void Dispense(void) { fprintf(stderr, \"Dispensing product...\\n\"); }\n void Collect(void) { fprintf(stderr, \"Please (C)ollect product.\u00a0:\"); scanf(\"%s\", str); }\n void Quit(void) { fprintf(stderr, \"Thank you, shutting down now.\\n\"); exit(0); }\n\n const FSM fsm[] = {\n { READY, &Ready, {{'D', WAITING}, {'Q', QUIT }, {-1, READY} }},\n { WAITING, &Waiting, {{'S', DISPENSE}, {'R', REFUND}, {-1, WAITING} }},\n { REFUND, &Refund, {{ -1, READY} }},\n { DISPENSE, &Dispense, {{ -1, COLLECT} }},\n { COLLECT, &Collect, {{'C', READY}, { -1, COLLECT } }},\n { QUIT, &Quit, {{ -1, QUIT} }},\n };\n\n int each;\n State state = READY;\n\n for (;;) {\n fsm[state].Action();\n each = 0;\n while (!( ((fsm[state].table[each].in == -1)\n \n || (isalpha(str[0]) && fsm[state].table[each].in == toupper(str[0]) )))) each++;\n state = fsm[state].table[each].out;\n }\n \n return 0;\n}\n","Rust":"enum State {\n Ready,\n Waiting,\n Dispense,\n Refunding,\n Exit,\n}\n\n#[methods_enum::gen(Act: run)]\nimpl State {\n pub fn set(&mut self);\n pub fn input_char(&mut self, ch: char);\n\n fn run(&mut self, act: Act) {\n match self {\n State::Ready => match act {\n Act::set() => println!(\"Ready: d - deposit \/ q - quit \"),\n Act::input_char('d') => self.set_state(State::Waiting),\n Act::input_char('q') => self.set_state(State::Exit),\n _ => self.set(),\n },\n State::Waiting => match act {\n Act::set() => println!(\"Waiting: s - select \/ r - refund \"),\n Act::input_char('s') => self.set_state(State::Dispense),\n Act::input_char('r') => self.set_state(State::Refunding),\n _ => self.set(),\n },\n State::Dispense => match act {\n Act::set() => println!(\"Dispense: r - remove \"),\n Act::input_char('r') => self.set_state(State::Ready),\n _ => self.set(),\n },\n State::Refunding => match act {\n Act::set() => {\n println!(\"Refunding: refund of the deposit...\");\n self.set_state(State::Ready)\n }\n _ => (), \n },\n State::Exit => match act {\n Act::set() => println!(\"Exit: goodbye! \"),\n _ => panic!(\"!! Invalid command for State::Exit: '{act:?}'\"),\n },\n }\n }\n\n fn set_state(&mut self, new_state: State) {\n *self = new_state;\n self.set();\n }\n}\n\nfn main() {\n let mut machine = State::Ready;\n machine.set();\n\n while !matches!(&machine, State::Exit) {\n machine.input_char(char_entered());\n }\n}\n\nfn char_entered() -> char {\n let mut text = String::new();\n std::io::stdin().read_line(&mut text).unwrap_or(0);\n text.chars().next().unwrap_or('\\x0d')\n}\n"} {"name":"First power of 2 that has leading decimal digits of 12","C":"#include \n#include \n\nint p(int l, int n) {\n int test = 0;\n double logv = log(2.0) \/ log(10.0);\n int factor = 1;\n int loop = l;\n while (loop > 10) {\n factor *= 10;\n loop \/= 10;\n }\n while (n > 0) {\n int val;\n\n test++;\n val = (int)(factor * pow(10.0, fmod(test * logv, 1)));\n if (val == l) {\n n--;\n }\n }\n return test;\n}\n\nvoid runTest(int l, int n) {\n printf(\"p(%d, %d) = %d\\n\", l, n, p(l, n));\n}\n\nint main() {\n runTest(12, 1);\n runTest(12, 2);\n runTest(123, 45);\n runTest(123, 12345);\n runTest(123, 678910);\n\n return 0;\n}\n","Rust":"fn power_of_two(l: isize, n: isize) -> isize {\n let mut test: isize = 0;\n let log: f64 = 2.0_f64.ln() \/ 10.0_f64.ln();\n let mut factor: isize = 1;\n let mut looop = l;\n let mut nn = n;\n while looop > 10 {\n factor *= 10;\n looop \/= 10;\n }\n\n while nn > 0 {\n test = test + 1;\n let val: isize = (factor as f64 * 10.0_f64.powf(test as f64 * log % 1.0)) as isize;\n\n if val == l {\n nn = nn - 1;\n }\n }\n\n test\n}\n\nfn run_test(l: isize, n: isize) {\n println!(\"p({}, {}) = {}\", l, n, power_of_two(l, n));\n}\n\nfn main() {\n run_test(12, 1);\n run_test(12, 2);\n run_test(123, 45);\n run_test(123, 12345);\n run_test(123, 678910);\n}\n"} {"name":"Four is magic","C":"#include \n#include \n#include \n\ntypedef struct named_number_tag {\n const char* name;\n uint64_t number;\n} named_number;\n\nconst named_number named_numbers[] = {\n { \"hundred\", 100 },\n { \"thousand\", 1000 },\n { \"million\", 1000000 },\n { \"billion\", 1000000000 },\n { \"trillion\", 1000000000000 },\n { \"quadrillion\", 1000000000000000ULL },\n { \"quintillion\", 1000000000000000000ULL }\n};\n\nconst named_number* get_named_number(uint64_t n) {\n const size_t names_len = sizeof(named_numbers)\/sizeof(named_number);\n for (size_t i = 0; i + 1 < names_len; ++i) {\n if (n < named_numbers[i + 1].number)\n return &named_numbers[i];\n }\n return &named_numbers[names_len - 1];\n}\n\nsize_t append_number_name(GString* str, uint64_t n) {\n static const char* small[] = {\n \"zero\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\",\n \"nine\", \"ten\", \"eleven\", \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\",\n \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\"\n };\n static const char* tens[] = {\n \"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\"\n };\n size_t len = str->len;\n if (n < 20) {\n g_string_append(str, small[n]);\n }\n else if (n < 100) {\n g_string_append(str, tens[n\/10 - 2]);\n if (n % 10 != 0) {\n g_string_append_c(str, '-');\n g_string_append(str, small[n % 10]);\n }\n } else {\n const named_number* num = get_named_number(n);\n uint64_t p = num->number;\n append_number_name(str, n\/p);\n g_string_append_c(str, ' ');\n g_string_append(str, num->name);\n if (n % p != 0) {\n g_string_append_c(str, ' ');\n append_number_name(str, n % p);\n }\n }\n return str->len - len;\n}\n\nGString* magic(uint64_t n) {\n GString* str = g_string_new(NULL);\n for (unsigned int i = 0; ; ++i) {\n size_t count = append_number_name(str, n);\n if (i == 0)\n str->str[0] = g_ascii_toupper(str->str[0]);\n if (n == 4) {\n g_string_append(str, \" is magic.\");\n break;\n }\n g_string_append(str, \" is \");\n append_number_name(str, count);\n g_string_append(str, \", \");\n n = count;\n }\n return str;\n}\n\nvoid test_magic(uint64_t n) {\n GString* str = magic(n);\n printf(\"%s\\n\", str->str);\n g_string_free(str, TRUE);\n}\n\nint main() {\n test_magic(5);\n test_magic(13);\n test_magic(78);\n test_magic(797);\n test_magic(2739);\n test_magic(4000);\n test_magic(7893);\n test_magic(93497412);\n test_magic(2673497412U);\n test_magic(10344658531277200972ULL);\n return 0;\n}\n","Rust":"fn main() {\n magic(4);\n magic(2_340);\n magic(765_000);\n magic(27_000_001);\n magic(999_123_090);\n magic(239_579_832_723_441);\n magic(std::u64::MAX);\n}\n\nfn magic(num: u64) {\n if num == 4 {\n println!(\"four is magic!\");\n println!();\n return;\n }\n let name = number_name(num);\n let len = name.len() as u64;\n print!(\"{} is {}, \", name, number_name(len));\n magic(len);\n}\n\n\nconst LOW: &'static [&'static str] = &[\n \"zero\", \"one\", \"two\", \"three\", \"four\", \"five\",\n \"six\", \"seven\", \"eight\",\"nine\", \"ten\",\n \"eleven\", \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\",\n \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\"\n];\nconst MED: &'static [&'static str] = &[\n \"twenty\", \"thirty\", \"forty\", \"fifty\",\n \"sixy\", \"seventy\", \"eighty\", \"ninety\"\n];\nconst HIGH: &'static [&'static str] = &[\n \"thousand\", \"million\", \"billion\",\n \"trillion\", \"quadrillion\", \"quintillion\"\n];\n\nfn number_name(num: u64) -> String {\n if num < 20 {\n return LOW[num as usize].to_string();\n }\n if num < 100 {\n let index = ((num \/ 10) - 2) as usize;\n let tens = MED[index].to_string();\n let remainder = num % 10;\n if remainder > 0 {\n return format!(\"{}-{}\", tens, number_name(remainder));\n }\n return tens;\n }\n if num < 1000 {\n let hundreds = LOW[(num \/ 100) as usize];\n let remainder = num % 100;\n if remainder > 0 {\n return format!(\"{} hundred {}\", hundreds, number_name(remainder));\n }\n return format!(\"{} hundred\", hundreds);\n }\n\n let mut remainder = num % 1000;\n let mut cur = if remainder > 0 { number_name(remainder) } else { \"\".to_string() };\n let mut n = num \/ 1000;\n\n for noun in HIGH.iter() {\n if n > 0 {\n remainder = n % 1000;\n if remainder > 0 {\n \n cur =\n if cur.len() > 0 { format!(\"{} {} {}\", number_name(remainder), noun, cur ) }\n else { format!(\"{} {}\", number_name(remainder), noun) }\n }\n n \/= 1000;\n }\n }\n return cur;\n}\n"} {"name":"Four is the number of letters in the ...","C":"#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef uint64_t integer;\n\ntypedef struct number_names_tag {\n const char* cardinal;\n const char* ordinal;\n} number_names;\n\nconst number_names small[] = {\n { \"zero\", \"zeroth\" }, { \"one\", \"first\" }, { \"two\", \"second\" },\n { \"three\", \"third\" }, { \"four\", \"fourth\" }, { \"five\", \"fifth\" },\n { \"six\", \"sixth\" }, { \"seven\", \"seventh\" }, { \"eight\", \"eighth\" },\n { \"nine\", \"ninth\" }, { \"ten\", \"tenth\" }, { \"eleven\", \"eleventh\" },\n { \"twelve\", \"twelfth\" }, { \"thirteen\", \"thirteenth\" },\n { \"fourteen\", \"fourteenth\" }, { \"fifteen\", \"fifteenth\" },\n { \"sixteen\", \"sixteenth\" }, { \"seventeen\", \"seventeenth\" },\n { \"eighteen\", \"eighteenth\" }, { \"nineteen\", \"nineteenth\" }\n};\n\nconst number_names tens[] = {\n { \"twenty\", \"twentieth\" }, { \"thirty\", \"thirtieth\" },\n { \"forty\", \"fortieth\" }, { \"fifty\", \"fiftieth\" },\n { \"sixty\", \"sixtieth\" }, { \"seventy\", \"seventieth\" },\n { \"eighty\", \"eightieth\" }, { \"ninety\", \"ninetieth\" }\n};\n\ntypedef struct named_number_tag {\n const char* cardinal;\n const char* ordinal;\n integer number;\n} named_number;\n\nconst named_number named_numbers[] = {\n { \"hundred\", \"hundredth\", 100 },\n { \"thousand\", \"thousandth\", 1000 },\n { \"million\", \"millionth\", 1000000 },\n { \"billion\", \"biliionth\", 1000000000 },\n { \"trillion\", \"trillionth\", 1000000000000 },\n { \"quadrillion\", \"quadrillionth\", 1000000000000000ULL },\n { \"quintillion\", \"quintillionth\", 1000000000000000000ULL }\n};\n\nconst char* get_small_name(const number_names* n, bool ordinal) {\n return ordinal ? n->ordinal : n->cardinal;\n}\n\nconst char* get_big_name(const named_number* n, bool ordinal) {\n return ordinal ? n->ordinal : n->cardinal;\n}\n\nconst named_number* get_named_number(integer n) {\n const size_t names_len = sizeof(named_numbers)\/sizeof(named_numbers[0]);\n for (size_t i = 0; i + 1 < names_len; ++i) {\n if (n < named_numbers[i + 1].number)\n return &named_numbers[i];\n }\n return &named_numbers[names_len - 1];\n}\n\ntypedef struct word_tag {\n size_t offset;\n size_t length;\n} word_t;\n\ntypedef struct word_list_tag {\n GArray* words;\n GString* str;\n} word_list;\n\nvoid word_list_create(word_list* words) {\n words->words = g_array_new(FALSE, FALSE, sizeof(word_t));\n words->str = g_string_new(NULL);\n}\n\nvoid word_list_destroy(word_list* words) {\n g_string_free(words->str, TRUE);\n g_array_free(words->words, TRUE);\n}\n\nvoid word_list_clear(word_list* words) {\n g_string_truncate(words->str, 0);\n g_array_set_size(words->words, 0);\n}\n\nvoid word_list_append(word_list* words, const char* str) {\n size_t offset = words->str->len;\n size_t len = strlen(str);\n g_string_append_len(words->str, str, len);\n word_t word;\n word.offset = offset;\n word.length = len;\n g_array_append_val(words->words, word);\n}\n\nword_t* word_list_get(word_list* words, size_t index) {\n return &g_array_index(words->words, word_t, index);\n}\n\nvoid word_list_extend(word_list* words, const char* str) {\n word_t* word = word_list_get(words, words->words->len - 1);\n size_t len = strlen(str);\n word->length += len;\n g_string_append_len(words->str, str, len);\n}\n\nsize_t append_number_name(word_list* words, integer n, bool ordinal) {\n size_t count = 0;\n if (n < 20) {\n word_list_append(words, get_small_name(&small[n], ordinal));\n count = 1;\n } else if (n < 100) {\n if (n % 10 == 0) {\n word_list_append(words, get_small_name(&tens[n\/10 - 2], ordinal));\n } else {\n word_list_append(words, get_small_name(&tens[n\/10 - 2], false));\n word_list_extend(words, \"-\");\n word_list_extend(words, get_small_name(&small[n % 10], ordinal));\n }\n count = 1;\n } else {\n const named_number* num = get_named_number(n);\n integer p = num->number;\n count += append_number_name(words, n\/p, false);\n if (n % p == 0) {\n word_list_append(words, get_big_name(num, ordinal));\n ++count;\n } else {\n word_list_append(words, get_big_name(num, false));\n ++count;\n count += append_number_name(words, n % p, ordinal);\n }\n }\n return count;\n}\n\nsize_t count_letters(word_list* words, size_t index) {\n const word_t* word = word_list_get(words, index);\n size_t letters = 0;\n const char* s = words->str->str + word->offset;\n for (size_t i = 0, n = word->length; i < n; ++i) {\n if (isalpha((unsigned char)s[i]))\n ++letters;\n }\n return letters;\n}\n\nvoid sentence(word_list* result, size_t count) {\n static const char* words[] = {\n \"Four\", \"is\", \"the\", \"number\", \"of\", \"letters\", \"in\", \"the\",\n \"first\", \"word\", \"of\", \"this\", \"sentence,\"\n };\n word_list_clear(result);\n size_t n = sizeof(words)\/sizeof(words[0]);\n for (size_t i = 0; i < n; ++i)\n word_list_append(result, words[i]);\n for (size_t i = 1; count > n; ++i) {\n n += append_number_name(result, count_letters(result, i), false);\n word_list_append(result, \"in\");\n word_list_append(result, \"the\");\n n += 2;\n n += append_number_name(result, i + 1, true);\n \n word_list_extend(result, \",\");\n }\n}\n\nsize_t sentence_length(const word_list* words) {\n size_t n = words->words->len;\n if (n == 0)\n return 0;\n return words->str->len + n - 1;\n}\n\nint main() {\n setlocale(LC_ALL, \"\");\n size_t n = 201;\n word_list result = { 0 };\n word_list_create(&result);\n sentence(&result, n);\n printf(\"Number of letters in first\u00a0%'lu words in the sequence:\\n\", n);\n for (size_t i = 0; i < n; ++i) {\n if (i != 0)\n printf(\"%c\", i % 25 == 0 ? '\\n' : ' ');\n printf(\"%'2lu\", count_letters(&result, i));\n }\n printf(\"\\nSentence length:\u00a0%'lu\\n\", sentence_length(&result));\n for (n = 1000; n <= 10000000; n *= 10) {\n sentence(&result, n);\n const word_t* word = word_list_get(&result, n - 1);\n const char* s = result.str->str + word->offset;\n printf(\"The\u00a0%'luth word is '%.*s' and has %lu letters. \", n,\n (int)word->length, s, count_letters(&result, n - 1));\n printf(\"Sentence length:\u00a0%'lu\\n\" , sentence_length(&result));\n }\n word_list_destroy(&result);\n return 0;\n}\n","Rust":"struct NumberNames {\n cardinal: &'static str,\n ordinal: &'static str,\n}\n\nimpl NumberNames {\n fn get_name(&self, ordinal: bool) -> &'static str {\n if ordinal {\n return self.ordinal;\n }\n self.cardinal\n }\n}\n\nconst SMALL_NAMES: [NumberNames; 20] = [\n NumberNames {\n cardinal: \"zero\",\n ordinal: \"zeroth\",\n },\n NumberNames {\n cardinal: \"one\",\n ordinal: \"first\",\n },\n NumberNames {\n cardinal: \"two\",\n ordinal: \"second\",\n },\n NumberNames {\n cardinal: \"three\",\n ordinal: \"third\",\n },\n NumberNames {\n cardinal: \"four\",\n ordinal: \"fourth\",\n },\n NumberNames {\n cardinal: \"five\",\n ordinal: \"fifth\",\n },\n NumberNames {\n cardinal: \"six\",\n ordinal: \"sixth\",\n },\n NumberNames {\n cardinal: \"seven\",\n ordinal: \"seventh\",\n },\n NumberNames {\n cardinal: \"eight\",\n ordinal: \"eighth\",\n },\n NumberNames {\n cardinal: \"nine\",\n ordinal: \"ninth\",\n },\n NumberNames {\n cardinal: \"ten\",\n ordinal: \"tenth\",\n },\n NumberNames {\n cardinal: \"eleven\",\n ordinal: \"eleventh\",\n },\n NumberNames {\n cardinal: \"twelve\",\n ordinal: \"twelfth\",\n },\n NumberNames {\n cardinal: \"thirteen\",\n ordinal: \"thirteenth\",\n },\n NumberNames {\n cardinal: \"fourteen\",\n ordinal: \"fourteenth\",\n },\n NumberNames {\n cardinal: \"fifteen\",\n ordinal: \"fifteenth\",\n },\n NumberNames {\n cardinal: \"sixteen\",\n ordinal: \"sixteenth\",\n },\n NumberNames {\n cardinal: \"seventeen\",\n ordinal: \"seventeenth\",\n },\n NumberNames {\n cardinal: \"eighteen\",\n ordinal: \"eighteenth\",\n },\n NumberNames {\n cardinal: \"nineteen\",\n ordinal: \"nineteenth\",\n },\n];\n\nconst TENS: [NumberNames; 8] = [\n NumberNames {\n cardinal: \"twenty\",\n ordinal: \"twentieth\",\n },\n NumberNames {\n cardinal: \"thirty\",\n ordinal: \"thirtieth\",\n },\n NumberNames {\n cardinal: \"forty\",\n ordinal: \"fortieth\",\n },\n NumberNames {\n cardinal: \"fifty\",\n ordinal: \"fiftieth\",\n },\n NumberNames {\n cardinal: \"sixty\",\n ordinal: \"sixtieth\",\n },\n NumberNames {\n cardinal: \"seventy\",\n ordinal: \"seventieth\",\n },\n NumberNames {\n cardinal: \"eighty\",\n ordinal: \"eightieth\",\n },\n NumberNames {\n cardinal: \"ninety\",\n ordinal: \"ninetieth\",\n },\n];\n\nstruct NamedNumber {\n cardinal: &'static str,\n ordinal: &'static str,\n number: usize,\n}\n\nimpl NamedNumber {\n fn get_name(&self, ordinal: bool) -> &'static str {\n if ordinal {\n return self.ordinal;\n }\n self.cardinal\n }\n}\n\nconst N: usize = 7;\nconst NAMED_NUMBERS: [NamedNumber; N] = [\n NamedNumber {\n cardinal: \"hundred\",\n ordinal: \"hundredth\",\n number: 100,\n },\n NamedNumber {\n cardinal: \"thousand\",\n ordinal: \"thousandth\",\n number: 1000,\n },\n NamedNumber {\n cardinal: \"million\",\n ordinal: \"millionth\",\n number: 1000000,\n },\n NamedNumber {\n cardinal: \"billion\",\n ordinal: \"billionth\",\n number: 1000000000,\n },\n NamedNumber {\n cardinal: \"trillion\",\n ordinal: \"trillionth\",\n number: 1000000000000,\n },\n NamedNumber {\n cardinal: \"quadrillion\",\n ordinal: \"quadrillionth\",\n number: 1000000000000000,\n },\n NamedNumber {\n cardinal: \"quintillion\",\n ordinal: \"quintillionth\",\n number: 1000000000000000000,\n },\n];\n\nfn big_name(n: usize) -> &'static NamedNumber {\n for i in 1..N {\n if n < NAMED_NUMBERS[i].number {\n return &NAMED_NUMBERS[i - 1];\n }\n }\n &NAMED_NUMBERS[N - 1]\n}\n\nfn count_letters(s: &str) -> usize {\n let mut count = 0;\n for c in s.chars() {\n if c.is_alphabetic() {\n count += 1;\n }\n }\n count\n}\n\nstruct WordList {\n words: Vec<(usize, usize)>,\n string: String,\n}\n\nimpl WordList {\n fn new() -> WordList {\n WordList {\n words: Vec::new(),\n string: String::new(),\n }\n }\n fn append(&mut self, s: &str) {\n let offset = self.string.len();\n self.string.push_str(s);\n self.words.push((offset, offset + s.len()));\n }\n fn extend(&mut self, s: &str) {\n let len = self.words.len();\n let mut w = &mut self.words[len - 1];\n w.1 += s.len();\n self.string.push_str(s);\n }\n fn len(&self) -> usize {\n self.words.len()\n }\n fn sentence_length(&self) -> usize {\n let n = self.words.len();\n if n == 0 {\n return 0;\n }\n self.string.len() + n - 1\n }\n fn get_word(&self, index: usize) -> &str {\n let w = &self.words[index];\n &self.string[w.0..w.1]\n }\n}\n\nfn append_number_name(words: &mut WordList, n: usize, ordinal: bool) -> usize {\n let mut count = 0;\n if n < 20 {\n words.append(SMALL_NAMES[n].get_name(ordinal));\n count += 1;\n } else if n < 100 {\n if n % 10 == 0 {\n words.append(TENS[n \/ 10 - 2].get_name(ordinal));\n } else {\n words.append(TENS[n \/ 10 - 2].get_name(false));\n words.extend(\"-\");\n words.extend(SMALL_NAMES[n % 10].get_name(ordinal));\n }\n count += 1;\n } else {\n let big = big_name(n);\n count += append_number_name(words, n \/ big.number, false);\n if n % big.number == 0 {\n words.append(big.get_name(ordinal));\n count += 1;\n } else {\n words.append(big.get_name(false));\n count += 1;\n count += append_number_name(words, n % big.number, ordinal);\n }\n }\n count\n}\n\nfn sentence(count: usize) -> WordList {\n let mut result = WordList::new();\n const WORDS: &'static [&'static str] = &[\n \"Four\",\n \"is\",\n \"the\",\n \"number\",\n \"of\",\n \"letters\",\n \"in\",\n \"the\",\n \"first\",\n \"word\",\n \"of\",\n \"this\",\n \"sentence,\",\n ];\n for s in WORDS {\n result.append(s);\n }\n let mut n = result.len();\n let mut i = 1;\n while count > n {\n let count = count_letters(result.get_word(i));\n n += append_number_name(&mut result, count, false);\n result.append(\"in\");\n result.append(\"the\");\n n += 2;\n n += append_number_name(&mut result, i + 1, true);\n result.extend(\",\");\n i += 1;\n }\n result\n}\n\nfn main() {\n let mut n = 201;\n let s = sentence(n);\n println!(\"Number of letters in first {} words in the sequence:\", n);\n for i in 0..n {\n if i != 0 {\n if i % 25 == 0 {\n println!();\n } else {\n print!(\" \");\n }\n }\n print!(\"{:2}\", count_letters(s.get_word(i)));\n }\n println!();\n println!(\"Sentence length: {}\", s.sentence_length());\n n = 1000;\n while n <= 10000000 {\n let s = sentence(n);\n let word = s.get_word(n - 1);\n print!(\n \"The {}th word is '{}' and has {} letters. \",\n n,\n word,\n count_letters(word)\n );\n println!(\"Sentence length: {}\", s.sentence_length());\n n *= 10;\n }\n}\n"} {"name":"Fractal tree","C":"#include \n#ifdef WITH_CAIRO\n#include \n#else\n#include \n#endif\n#include \n#include \n#include \n#include \n\n#ifdef WITH_CAIRO\n#define PI 3.1415926535\n#endif\n \n#define SIZE 800 \n#define SCALE 5 \n#define BRANCHES 14 \n#define ROTATION_SCALE 0.75 \n#define INITIAL_LENGTH 50 \n \ndouble rand_fl(){\n return (double)rand() \/ (double)RAND_MAX;\n}\n \nvoid draw_tree(SDL_Surface * surface, double offsetx, double offsety,\n double directionx, double directiony, double size,\n double rotation, int depth) {\n#ifdef WITH_CAIRO\n cairo_surface_t *surf = cairo_image_surface_create_for_data( surface->pixels,\n CAIRO_FORMAT_RGB24,\n\t\t\t\t\t\t\t surface->w, surface->h,\n\t\t\t\t\t\t\t surface->pitch );\n cairo_t *ct = cairo_create(surf);\n\n cairo_set_line_width(ct, 1);\n cairo_set_source_rgba(ct, 0,0,0,1);\n cairo_move_to(ct, (int)offsetx, (int)offsety);\n cairo_line_to(ct, (int)(offsetx + directionx * size), (int)(offsety + directiony * size));\n cairo_stroke(ct);\n#else\n sge_AALine(surface,\n (int)offsetx, (int)offsety,\n (int)(offsetx + directionx * size), (int)(offsety + directiony * size),\n SDL_MapRGB(surface->format, 0, 0, 0));\n#endif\n if (depth > 0){\n \n draw_tree(surface,\n offsetx + directionx * size,\n offsety + directiony * size,\n directionx * cos(rotation) + directiony * sin(rotation),\n directionx * -sin(rotation) + directiony * cos(rotation),\n size * rand_fl() \/ SCALE + size * (SCALE - 1) \/ SCALE,\n rotation * ROTATION_SCALE,\n depth - 1);\n \n \n draw_tree(surface,\n offsetx + directionx * size,\n offsety + directiony * size,\n directionx * cos(-rotation) + directiony * sin(-rotation),\n directionx * -sin(-rotation) + directiony * cos(-rotation),\n size * rand_fl() \/ SCALE + size * (SCALE - 1) \/ SCALE,\n rotation * ROTATION_SCALE,\n depth - 1);\n }\n}\n \nvoid render(SDL_Surface * surface){\n SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format, 255, 255, 255));\n draw_tree(surface,\n surface->w \/ 2.0,\n surface->h - 10.0,\n 0.0, -1.0,\n INITIAL_LENGTH,\n PI \/ 8,\n BRANCHES);\n SDL_UpdateRect(surface, 0, 0, 0, 0);\n}\n \nint main(){\n SDL_Surface * screen;\n SDL_Event evt;\n \n SDL_Init(SDL_INIT_VIDEO);\n \n srand((unsigned)time(NULL));\n \n screen = SDL_SetVideoMode(SIZE, SIZE, 32, SDL_HWSURFACE);\n \n render(screen);\n while(1){\n if (SDL_PollEvent(&evt)){\n if(evt.type == SDL_QUIT) break;\n }\n SDL_Delay(1);\n }\n SDL_Quit();\n return 0;\n}\n","Rust":"\n\n\n\n\n\nextern crate piston;\nextern crate graphics;\nextern crate opengl_graphics;\nextern crate glutin_window;\n\nuse piston::window::WindowSettings;\nuse piston::event_loop::{Events, EventSettings};\nuse piston::input::RenderEvent;\nuse glutin_window::GlutinWindow as Window;\nuse opengl_graphics::{GlGraphics, OpenGL};\nuse graphics::{clear, line, Context};\n\nconst ANG: f64 = 20.0;\nconst COLOR: [f32; 4] = [1.0, 0.0, 0.5, 1.0];\nconst LINE_THICKNESS: f64 = 5.0;\nconst DEPTH: u32 = 11;\n\nfn main() {\n let mut window: Window = WindowSettings::new(\"Fractal Tree\", [1024, 768])\n .opengl(OpenGL::V3_2)\n .exit_on_esc(true)\n .build()\n .unwrap();\n let mut gl = GlGraphics::new(OpenGL::V3_2);\n\n let mut events = Events::new(EventSettings::new());\n while let Some(e) = events.next(&mut window) {\n if let Some(args) = e.render_args() {\n gl.draw(args.viewport(), |c, g| {\n clear([1.0, 1.0, 1.0, 1.0], g);\n draw_fractal_tree(512.0, 700.0, 0.0, DEPTH, c, g);\n });\n }\n }\n}\n\nfn draw_fractal_tree(x1: f64, y1: f64, angle: f64, depth: u32, c: Context, g: &mut GlGraphics) {\n let x2 = x1 + angle.to_radians().sin() * depth as f64 * 10.0;\n let y2 = y1 - angle.to_radians().cos() * depth as f64 * 10.0;\n line(\n COLOR,\n LINE_THICKNESS * depth as f64 * 0.2,\n [x1, y1, x2, y2],\n c.transform,\n g,\n );\n if depth > 0 {\n draw_fractal_tree(x2, y2, angle - ANG, depth - 1, c, g);\n draw_fractal_tree(x2, y2, angle + ANG, depth - 1, c, g);\n }\n}\n"} {"name":"Frobenius numbers","C":"#include \n#include \n#include \n#define LIMIT 10000\n\n\nunsigned int sieve(unsigned int n, unsigned int **list) {\n unsigned char *sieve = calloc(n+1, 1);\n unsigned int i, j, max = 0;\n for (i = 2; i*i <= n; i++)\n if (!sieve[i])\n for (j = i+i; j <= n; j += i)\n sieve[j] = 1;\n for (i = 2; i <= n; i++) max += !sieve[i];\n *list = malloc(max * sizeof(unsigned int));\n for (i = 0, j = 2; j <= n; j++)\n if (!sieve[j]) (*list)[i++] = j;\n free(sieve);\n return i;\n}\n\n\nunsigned int frob(unsigned const int *primes, unsigned int n) {\n return primes[n] * primes[n+1] - primes[n] - primes[n+1];\n}\n\nint main() {\n \n unsigned int *primes;\n unsigned int amount = sieve(sqrt(LIMIT)+1, &primes);\n unsigned int i;\n \n for (i=0; i impl std::iter::Iterator {\n let mut primes = primal::Primes::all();\n let mut prime = primes.next().unwrap();\n std::iter::from_fn(move || {\n if let Some(p) = primes.by_ref().next() {\n let fnum = prime * p - prime - p;\n prime = p;\n return Some((fnum, primal::is_prime(fnum as u64)));\n }\n None\n })\n}\n\nfn main() {\n let limit = 1000000;\n let mut count = 0;\n println!(\n \"Frobenius numbers less than {} (asterisk marks primes):\",\n limit\n );\n for (fnum, is_prime) in frobenius_numbers().take_while(|(x, _)| *x < limit) {\n count += 1;\n let c = if is_prime { '*' } else { ' ' };\n let s = if count % 10 == 0 { '\\n' } else { ' ' };\n print!(\"{:6}{}{}\", fnum, c, s);\n }\n println!();\n}\n"} {"name":"Function definition","C":"double multiply(double a, double b)\n{\n return a * b;\n}\n","Rust":"fn multiply(a: i32, b: i32) -> i32 {\n a * b\n}\n"} {"name":"Gauss-Jordan matrix inversion","C":"\n#include \nint gjinv (double *a, int n, double *b)\n{\n\tint i, j, k, p;\n\tdouble f, g, tol;\n\tif (n < 1) return -1; \n\tf = 0.; \n\tfor (i = 0; i < n; ++i) {\n\t\tfor (j = 0; j < n; ++j) {\n\t\t\tg = a[j+i*n];\n\t\t\tf += g * g;\n\t\t}\n\t}\n\tf = sqrt(f);\n\ttol = f * 2.2204460492503131e-016;\n\tfor (i = 0; i < n; ++i) { \n\t\tfor (j = 0; j < n; ++j) {\n\t\t\tb[j+i*n] = (i == j) ? 1. : 0.;\n\t\t}\n\t}\n\tfor (k = 0; k < n; ++k) { \n\t\tf = fabs(a[k+k*n]); \n\t\tp = k;\n\t\tfor (i = k+1; i < n; ++i) {\n\t\t\tg = fabs(a[k+i*n]);\n\t\t\tif (g > f) {\n\t\t\t\tf = g;\n\t\t\t\tp = i;\n\t\t\t}\n\t\t}\n\t\tif (f < tol) return 1; \n\t\tif (p != k) { \n\t\t\tfor (j = k; j < n; ++j) {\n\t\t\t\tf = a[j+k*n];\n\t\t\t\ta[j+k*n] = a[j+p*n];\n\t\t\t\ta[j+p*n] = f;\n\t\t\t}\n\t\t\tfor (j = 0; j < n; ++j) {\n\t\t\t\tf = b[j+k*n];\n\t\t\t\tb[j+k*n] = b[j+p*n];\n\t\t\t\tb[j+p*n] = f;\n\t\t\t}\n\t\t}\n\t\tf = 1. \/ a[k+k*n]; \n\t\tfor (j = k; j < n; ++j) a[j+k*n] *= f;\n\t\tfor (j = 0; j < n; ++j) b[j+k*n] *= f;\n\t\tfor (i = 0; i < n; ++i) { \n\t\t\tif (i == k) continue;\n\t\t\tf = a[k+i*n];\n\t\t\tfor (j = k; j < n; ++j) a[j+i*n] -= a[j+k*n] * f;\n\t\t\tfor (j = 0; j < n; ++j) b[j+i*n] -= b[j+k*n] * f;\n\t\t}\n\t}\n\treturn 0;\n} \n","Rust":"fn main() {\n let mut a: Vec> = vec![vec![1.0, 2.0, 3.0],\n vec![4.0, 1.0, 6.0],\n vec![7.0, 8.0, 9.0]\n ];\n let mut b: Vec> = vec![vec![2.0, -1.0, 0.0],\n vec![-1.0, 2.0, -1.0],\n vec![0.0, -1.0, 2.0]\n ];\n\n let mut ref_a = &mut a;\n let rref_a = &mut ref_a;\n let mut ref_b = &mut b;\n let rref_b = &mut ref_b;\n\n println!(\"Matrix A:\\n\");\n print_matrix(rref_a);\n println!(\"\\nInverse of Matrix A:\\n\");\n print_matrix(&mut matrix_inverse(rref_a));\n println!(\"\\n\\nMatrix B:\\n\");\n print_matrix(rref_b);\n println!(\"\\nInverse of Matrix B:\\n\");\n print_matrix(&mut matrix_inverse(rref_b));\n}\n\n\nfn matrix_inverse(matrix: &mut Vec>) -> Vec>{\n let len = matrix.len();\n let mut aug = zero_matrix(len, len * 2);\n for i in 0..len {\n for j in 0.. len {\n aug[i][j] = matrix[i][j];\n }\n aug[i][i + len] = 1.0;\n }\n\n gauss_jordan_general(&mut aug);\n \n \n let mut unaug = zero_matrix(len, len);\n for i in 0..len {\n for j in 0..len {\n unaug[i][j] = aug[i][j+len];\n }\n }\n unaug\n}\n\n\n\nfn gauss_jordan_general(matrix: &mut Vec>) {\n let mut lead = 0;\n let row_count = matrix.len();\n let col_count = matrix[0].len();\n\n for r in 0..row_count {\n if col_count <= lead {\n break;\n }\n let mut i = r;\n while matrix[i][lead] == 0.0 {\n i = i + 1;\n if row_count == i {\n i = r;\n lead = lead + 1;\n if col_count == lead {\n break;\n }\n }\n }\n\n let temp = matrix[i].to_owned();\n matrix[i] = matrix[r].to_owned();\n matrix[r] = temp.to_owned();\n\n if matrix[r][lead] != 0.0 {\n let div = matrix[r][lead];\n for j in 0..col_count {\n matrix[r][j] = matrix[r][j] \/ div;\n }\n }\n\n for k in 0..row_count {\n if k != r {\n let mult = matrix[k][lead];\n for j in 0..col_count {\n matrix[k][j] = matrix[k][j] - matrix[r][j] * mult;\n }\n }\n }\n lead = lead + 1;\n\n }\n \n}\n\nfn zero_matrix(rows: usize, cols: usize) -> Vec> {\n let mut matrix = Vec::with_capacity(cols);\n for _ in 0..rows {\n let mut col: Vec = Vec::with_capacity(rows);\n for _ in 0..cols {\n col.push(0.0);\n }\n matrix.push(col);\n }\n matrix\n}\n\nfn print_matrix(mat: &mut Vec>) {\n for row in 0..mat.len(){\n println!(\"{:?}\", mat[row]);\n }\n}\n"} {"name":"Generate Chess960 starting position","C":"#include\n#include\n#include\n#include\n#include\n\nchar rank[9];\n\nint pos[8];\n\nvoid swap(int i,int j){\n\tint temp = pos[i];\n\tpos[i] = pos[j];\n\tpos[j] = temp;\n}\n\nvoid generateFirstRank(){\n\t int kPos,qPos,bPos1,bPos2,rPos1,rPos2,nPos1,nPos2,i;\n\t \n\t for(i=0;i<8;i++){\n\t\t rank[i] = 'e';\n\t\t pos[i] = i;\n\t }\n\t\t \n\t do{\n\t\t kPos = rand()%8;\n\t\t rPos1 = rand()%8;\n\t\t rPos2 = rand()%8;\n\t }while((rPos1-kPos<=0 && rPos2-kPos<=0)||(rPos1-kPos>=0 && rPos2-kPos>=0)||(rPos1==rPos2 || kPos==rPos1 || kPos==rPos2));\n\n\t rank[pos[rPos1]] = 'R';\n\t rank[pos[kPos]] = 'K';\n\t rank[pos[rPos2]] = 'R';\n\t \n\t swap(rPos1,7);\n\t swap(rPos2,6);\n\t swap(kPos,5);\n\t \n\t do{\n\t\t bPos1 = rand()%5;\n\t\t bPos2 = rand()%5;\n\t }while(((pos[bPos1]-pos[bPos2])%2==0)||(bPos1==bPos2));\n\n\t rank[pos[bPos1]] = 'B';\n\t rank[pos[bPos2]] = 'B';\n\t \n\t swap(bPos1,4);\n\t swap(bPos2,3);\n\t \n\t do{\n\t\t qPos = rand()%3;\n\t\t nPos1 = rand()%3;\n\t }while(qPos==nPos1);\n\t \n\t rank[pos[qPos]] = 'Q';\n\t rank[pos[nPos1]] = 'N';\n\t \n\t for(i=0;i<8;i++)\n\t\t if(rank[i]=='e'){\n\t\t\t rank[i] = 'N';\n\t\t\t break;\n\t\t }\t\t\n}\n\nvoid printRank(){\n\tint i;\n\t\n\t#ifdef _WIN32\n\t\tprintf(\"%s\\n\",rank);\n\t#else\n\t{\n\t\tsetlocale(LC_ALL,\"\");\n\t\tprintf(\"\\n\");\n\t\tfor(i=0;i<8;i++){\n\t\t\tif(rank[i]=='K')\n\t\t\t\tprintf(\"%lc\",(wint_t)9812);\n\t\t\telse if(rank[i]=='Q')\n\t\t\t\tprintf(\"%lc\",(wint_t)9813);\n\t\t\telse if(rank[i]=='R')\n\t\t\t\tprintf(\"%lc\",(wint_t)9814);\n\t\t\telse if(rank[i]=='B')\n\t\t\t\tprintf(\"%lc\",(wint_t)9815);\n\t\t\tif(rank[i]=='N')\n\t\t\t\tprintf(\"%lc\",(wint_t)9816);\n\t\t}\n\t}\n\t#endif\n}\n\nint main()\n{\n\tint i;\n\t\n\tsrand((unsigned)time(NULL));\n\t\n\tfor(i=0;i<9;i++){\n\t\tgenerateFirstRank();\n\t\tprintRank();\n\t}\n\t\n\treturn 0;\n}\n","Rust":"use std::collections::BTreeSet;\n\nstruct Chess960 ( BTreeSet );\n\nimpl Chess960 {\n fn invoke(&mut self, b: &str, e: &str) {\n if e.len() <= 1 {\n let s = b.to_string() + e;\n if Chess960::is_valid(&s) { self.0.insert(s); }\n } else {\n for (i, c) in e.char_indices() {\n let mut b = b.to_string();\n b.push(c);\n let mut e = e.to_string();\n e.remove(i);\n self.invoke(&b, &e);\n }\n }\n }\n\n fn is_valid(s: &str) -> bool {\n let k = s.find('K').unwrap();\n k > s.find('R').unwrap() && k < s.rfind('R').unwrap() && s.find('B').unwrap() % 2 != s.rfind('B').unwrap() % 2\n }\n}\n\n\nfn main() {\n let mut chess960 = Chess960(BTreeSet::new());\n chess960.invoke(\"\", \"KQRRNNBB\");\n\n for (i, p) in chess960.0.iter().enumerate() {\n println!(\"{}: {}\", i, p);\n }\n}\n"} {"name":"Generate random chess position","C":"#include \n#include \n#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\ntypedef int bool;\n\nchar grid[8][8];\n\nvoid placeKings() {\n int r1, r2, c1, c2;\n for (;;) {\n r1 = rand() % 8;\n c1 = rand() % 8;\n r2 = rand() % 8;\n c2 = rand() % 8;\n if (r1 != r2 && abs(r1 - r2) > 1 && abs(c1 - c2) > 1) {\n grid[r1][c1] = 'K';\n grid[r2][c2] = 'k';\n return;\n }\n }\n}\n\nvoid placePieces(const char *pieces, bool isPawn) {\n int n, r, c;\n int numToPlace = rand() % strlen(pieces);\n for (n = 0; n < numToPlace; ++n) {\n do {\n r = rand() % 8;\n c = rand() % 8;\n }\n while (grid[r][c] != 0 || (isPawn && (r == 7 || r == 0)));\n grid[r][c] = pieces[n];\n }\n}\n\nvoid toFen() {\n char fen[80], ch;\n int r, c, countEmpty = 0, index = 0;\n for (r = 0; r < 8; ++r) {\n for (c = 0; c < 8; ++c) {\n ch = grid[r][c];\n printf(\"%2c \", ch == 0 ? '.' : ch);\n if (ch == 0) {\n countEmpty++;\n }\n else {\n if (countEmpty > 0) {\n fen[index++] = countEmpty + 48;\n countEmpty = 0; \n }\n fen[index++] = ch;\n }\n }\n if (countEmpty > 0) {\n fen[index++] = countEmpty + 48;\n countEmpty = 0;\n }\n fen[index++]= '\/';\n printf(\"\\n\");\n }\n strcpy(fen + index, \" w - - 0 1\");\n printf(\"%s\\n\", fen);\n}\n\nchar *createFen() {\n placeKings();\n placePieces(\"PPPPPPPP\", TRUE);\n placePieces(\"pppppppp\", TRUE);\n placePieces(\"RNBQBNR\", FALSE);\n placePieces(\"rnbqbnr\", FALSE);\n toFen();\n}\n\nint main() {\n srand(time(NULL));\n createFen();\n return 0;\n}\n","Rust":"use std::fmt::Write;\n\nuse rand::{Rng, distributions::{Distribution, Standard}};\n\nconst EMPTY: u8 = b'.';\n\n#[derive(Clone, Debug)]\nstruct Board {\n grid: [[u8; 8]; 8],\n}\n\nimpl Distribution for Standard {\n fn sample(&self, rng: &mut R) -> Board {\n let mut board = Board::empty();\n board.place_kings(rng);\n board.place_pieces(rng, b\"PPPPPPPP\", true);\n board.place_pieces(rng, b\"pppppppp\", true);\n board.place_pieces(rng, b\"RNBQBNR\", false);\n board.place_pieces(rng, b\"rnbqbnr\", false);\n board\n }\n}\n\nimpl Board {\n fn empty() -> Self {\n Board { grid: [[EMPTY; 8]; 8] }\n }\n \n fn fen(&self) -> String {\n let mut fen = String::new();\n let mut count_empty = 0;\n for row in &self.grid {\n for &ch in row {\n print!(\"{} \", ch as char);\n if ch == EMPTY {\n count_empty += 1;\n } else {\n if count_empty > 0 {\n write!(fen, \"{}\", count_empty).unwrap();\n count_empty = 0;\n }\n fen.push(ch as char);\n }\n }\n if count_empty > 0 {\n write!(fen, \"{}\", count_empty).unwrap();\n count_empty = 0;\n }\n fen.push('\/');\n println!();\n }\n fen.push_str(\" w - - 0 1\");\n fen\n }\n\n fn place_kings(&mut self, rng: &mut R) {\n loop {\n let r1: i8 = rng.gen_range(0, 8);\n let c1: i8 = rng.gen_range(0, 8);\n let r2: i8 = rng.gen_range(0, 8);\n let c2: i8 = rng.gen_range(0, 8);\n if r1 != r2 && (r1 - r2).abs() > 1 && (c1 - c2).abs() > 1 {\n self.grid[r1 as usize][c1 as usize] = b'K';\n self.grid[r2 as usize][c2 as usize] = b'k';\n return;\n }\n }\n }\n\n fn place_pieces(&mut self, rng: &mut R, pieces: &[u8], is_pawn: bool) {\n let num_to_place = rng.gen_range(0, pieces.len());\n for &piece in pieces.iter().take(num_to_place) {\n let mut r = rng.gen_range(0, 8);\n let mut c = rng.gen_range(0, 8);\n while self.grid[r][c] != EMPTY || (is_pawn && (r == 7 || r == 0)) {\n r = rng.gen_range(0, 8);\n c = rng.gen_range(0, 8);\n }\n self.grid[r][c] = piece;\n }\n }\n}\n\nfn main() {\n let b: Board = rand::random();\n println!(\"{}\", b.fen());\n}\n"} {"name":"Greedy algorithm for Egyptian fractions","C":"#include \n#include \n#include \n\ntypedef int64_t integer;\n\nstruct Pair {\n integer md;\n int tc;\n};\n\ninteger mod(integer x, integer y) {\n return ((x % y) + y) % y;\n}\n\ninteger gcd(integer a, integer b) {\n if (0 == a) return b;\n if (0 == b) return a;\n if (a == b) return a;\n if (a > b) return gcd(a - b, b);\n return gcd(a, b - a);\n}\n\nvoid write0(bool show, char *str) {\n if (show) {\n printf(str);\n }\n}\n\nvoid write1(bool show, char *format, integer a) {\n if (show) {\n printf(format, a);\n }\n}\n\nvoid write2(bool show, char *format, integer a, integer b) {\n if (show) {\n printf(format, a, b);\n }\n}\n\nstruct Pair egyptian(integer x, integer y, bool show) {\n struct Pair ret;\n integer acc = 0;\n bool first = true;\n\n ret.tc = 0;\n ret.md = 0;\n\n write2(show, \"Egyptian fraction for %lld\/%lld: \", x, y);\n while (x > 0) {\n integer z = (y + x - 1) \/ x;\n if (z == 1) {\n acc++;\n } else {\n if (acc > 0) {\n write1(show, \"%lld + \", acc);\n first = false;\n acc = 0;\n ret.tc++;\n } else if (first) {\n first = false;\n } else {\n write0(show, \" + \");\n }\n if (z > ret.md) {\n ret.md = z;\n }\n write1(show, \"1\/%lld\", z);\n ret.tc++;\n }\n x = mod(-y, x);\n y = y * z;\n }\n if (acc > 0) {\n write1(show, \"%lld\", acc);\n ret.tc++;\n }\n write0(show, \"\\n\");\n\n return ret;\n}\n\nint main() {\n struct Pair p;\n integer nm = 0, dm = 0, dmn = 0, dmd = 0, den = 0;;\n int tm, i, j;\n\n egyptian(43, 48, true);\n egyptian(5, 121, true); \n egyptian(2014, 59, true);\n\n tm = 0;\n for (i = 1; i < 100; i++) {\n for (j = 1; j < 100; j++) {\n p = egyptian(i, j, false);\n if (p.tc > tm) {\n tm = p.tc;\n nm = i;\n dm = j;\n }\n if (p.md > den) {\n den = p.md;\n dmn = i;\n dmd = j;\n }\n }\n }\n printf(\"Term max is %lld\/%lld with %d terms.\\n\", nm, dm, tm); \n printf(\"Denominator max is %lld\/%lld\\n\", dmn, dmd); \n egyptian(dmn, dmd, true); \n\n return 0;\n}\n","Rust":"use num_bigint::BigInt;\nuse num_integer::Integer;\nuse num_traits::{One, Zero};\nuse std::fmt;\n\n#[derive(Debug, Clone, PartialEq, PartialOrd)]\nstruct Rational {\n nominator: BigInt,\n denominator: BigInt,\n}\n\nimpl Rational {\n fn new(n: &BigInt, d: &BigInt) -> Rational {\n assert!(!d.is_zero(), \"denominator cannot be 0\");\n \n let c = n.gcd(d);\n Rational {\n nominator: n \/ &c,\n denominator: d \/ &c,\n }\n }\n\n fn is_proper(&self) -> bool {\n self.nominator < self.denominator\n }\n fn to_egyptian(&self) -> Vec {\n let mut frac: Vec = Vec::new();\n\n let mut current: Rational;\n if !self.is_proper() {\n \n \n frac.push(Rational::new(\n &self.nominator.div_floor(&self.denominator),\n &One::one(),\n ));\n\n \n current = Rational::new(\n &self.nominator.mod_floor(&self.denominator),\n &self.denominator,\n );\n } else {\n current = self.clone();\n }\n\n while !current.nominator.is_one() {\n let div = current.denominator.div_ceil(¤t.nominator);\n\n \n frac.push(Rational::new(&One::one(), &div));\n\n current = Rational::new(\n &(-¤t.denominator).mod_floor(¤t.nominator),\n match current.denominator.checked_mul(&div).as_ref() {\n Some(r) => r,\n _ => break,\n },\n );\n }\n\n frac.push(current);\n frac\n }\n}\n\nimpl fmt::Display for Rational {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n if self.denominator.is_one() {\n \n write!(f, \"{}\", self.nominator)\n } else {\n write!(f, \"{}\/{}\", self.nominator, self.denominator)\n }\n }\n}\n\nfn rational_vec_to_string(vec: Vec) -> String {\n let mut p = vec\n .iter()\n .fold(String::new(), |acc, num| (acc + &num.to_string() + \", \"));\n\n if p.len() > 1 {\n p.truncate(p.len() - 2);\n }\n format!(\"[{}]\", p)\n}\n\nfn run_max_searches(x: usize) {\n \n let pairs = (1..x).flat_map(move |i| (i + 1..x).map(move |j| (i, j)));\n\n let mut max_length = (0, Rational::new(&BigInt::from(1), &BigInt::from(1)));\n let mut max_denom = (\n Zero::zero(),\n Rational::new(&BigInt::from(1), &BigInt::from(1)),\n );\n\n for (i, j) in pairs {\n let e = Rational::new(&BigInt::from(i), &BigInt::from(j)).to_egyptian();\n if e.len() > max_length.0 {\n max_length = (e.len(), Rational::new(&BigInt::from(i), &BigInt::from(j)));\n }\n\n if e.last().unwrap().denominator > max_denom.0 {\n max_denom = (\n e.last().unwrap().denominator.clone(),\n Rational::new(&BigInt::from(i), &BigInt::from(j)),\n );\n }\n }\n\n println!(\n \"Maximum length of terms is for {} with {} terms\",\n max_length.1, max_length.0\n );\n println!(\"{}\", rational_vec_to_string(max_length.1.to_egyptian()));\n\n println!(\n \"Maximum denominator is for {} with {} terms\",\n max_denom.1, max_denom.0\n );\n println!(\"{}\", rational_vec_to_string(max_denom.1.to_egyptian()));\n}\nfn main() {\n let tests = [\n Rational::new(&BigInt::from(43), &BigInt::from(48)),\n Rational::new(&BigInt::from(5), &BigInt::from(121)),\n Rational::new(&BigInt::from(2014), &BigInt::from(59)),\n ];\n\n for test in tests.iter() {\n println!(\"{} -> {}\", test, rational_vec_to_string(test.to_egyptian()));\n }\n\n run_max_searches(100);\n run_max_searches(1000);\n}\n"} {"name":"HTTPS_Authenticated","C":"#include \n#include \n#include \"curl\/curl.h\"\n\nint\nmain(void)\n{\n CURL *curl;\n char buffer[CURL_ERROR_SIZE];\n\n if ((curl = curl_easy_init()) != NULL) {\n curl_easy_setopt(curl, CURLOPT_URL, \"https:\n curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);\n curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, buffer);\n if (curl_easy_perform(curl) != CURLE_OK) {\n fprintf(stderr, \"%s\\n\", buffer);\n return EXIT_FAILURE;\n }\n curl_easy_cleanup(curl);\n }\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate reqwest;\n\nuse reqwest::blocking::Client;\nuse reqwest::header::CONNECTION;\n\nfn main() {\n let client = Client::new();\n\n \n let res = client\n .get(\"https:\n .basic_auth(\"user\", Some(\"password\"))\n .header(CONNECTION, \"close\")\n .send()\n .unwrap();\n\n let body = res.text().unwrap();\n\n println!(\"{}\", body);\n}\n"} {"name":"HTTPS_Client-authenticated","C":"\n\n#include \n#include \n#include \n#include \n#include \"wren.h\"\n\n\n\nvoid C_curlAllocate(WrenVM* vm) {\n CURL** pcurl = (CURL**)wrenSetSlotNewForeign(vm, 0, 0, sizeof(CURL*));\n *pcurl = curl_easy_init();\n}\n\nvoid C_easyPerform(WrenVM* vm) {\n CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);\n CURLcode cc = curl_easy_perform(curl);\n wrenSetSlotDouble(vm, 0, (double)cc);\n}\n\nvoid C_easyCleanup(WrenVM* vm) {\n CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);\n curl_easy_cleanup(curl);\n}\n\nvoid C_easySetOpt(WrenVM* vm) {\n CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);\n CURLoption opt = (CURLoption)wrenGetSlotDouble(vm, 1);\n const char *arg = wrenGetSlotString(vm, 2);\n curl_easy_setopt(curl, opt, arg);\n}\n\nWrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) {\n WrenForeignClassMethods methods;\n methods.allocate = NULL;\n methods.finalize = NULL;\n if (strcmp(module, \"main\") == 0) {\n if (strcmp(className, \"Curl\") == 0) {\n methods.allocate = C_curlAllocate;\n }\n }\n return methods;\n}\n\nWrenForeignMethodFn bindForeignMethod(\n WrenVM* vm,\n const char* module,\n const char* className,\n bool isStatic,\n const char* signature) {\n if (strcmp(module, \"main\") == 0) {\n if (strcmp(className, \"Curl\") == 0) {\n if (!isStatic && strcmp(signature, \"easySetOpt(_,_)\") == 0) return C_easySetOpt;\n if (!isStatic && strcmp(signature, \"easyPerform()\") == 0) return C_easyPerform;\n if (!isStatic && strcmp(signature, \"easyCleanup()\") == 0) return C_easyCleanup;\n }\n }\n return NULL;\n}\n\nstatic void writeFn(WrenVM* vm, const char* text) {\n printf(\"%s\", text);\n}\n\nvoid errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {\n switch (errorType) {\n case WREN_ERROR_COMPILE:\n printf(\"[%s line %d] [Error] %s\\n\", module, line, msg);\n break;\n case WREN_ERROR_STACK_TRACE:\n printf(\"[%s line %d] in %s\\n\", module, line, msg);\n break;\n case WREN_ERROR_RUNTIME:\n printf(\"[Runtime Error] %s\\n\", msg);\n break;\n }\n}\n\nchar *readFile(const char *fileName) {\n FILE *f = fopen(fileName, \"r\");\n fseek(f, 0, SEEK_END);\n long fsize = ftell(f);\n rewind(f);\n char *script = malloc(fsize + 1);\n fread(script, 1, fsize, f);\n fclose(f);\n script[fsize] = 0;\n return script;\n}\n\nint main(int argc, char **argv) {\n WrenConfiguration config;\n wrenInitConfiguration(&config);\n config.writeFn = &writeFn;\n config.errorFn = &errorFn;\n config.bindForeignClassFn = &bindForeignClass;\n config.bindForeignMethodFn = &bindForeignMethod;\n WrenVM* vm = wrenNewVM(&config);\n const char* module = \"main\";\n const char* fileName = \"https_client-authenticated.wren\";\n char *script = readFile(fileName);\n WrenInterpretResult result = wrenInterpret(vm, module, script);\n switch (result) {\n case WREN_RESULT_COMPILE_ERROR:\n printf(\"Compile Error!\\n\");\n break;\n case WREN_RESULT_RUNTIME_ERROR:\n printf(\"Runtime Error!\\n\");\n break;\n case WREN_RESULT_SUCCESS:\n break;\n }\n wrenFreeVM(vm);\n free(script);\n return 0;\n}\n","Rust":"use std::fs::File;\nuse std::io::Read;\n\nuse reqwest::blocking::Client;\nuse reqwest::Identity;\n\nfn main() -> std::io::Result<()> {\n let identity = {\n let mut buf = Vec::new();\n\n \n File::open(\"badssl.com-client.p12\")?.read_to_end(&mut buf)?;\n\n \n Identity::from_pkcs12_der(&buf, \"badssl.com\").unwrap()\n };\n\n let client = Client::builder().identity(identity).build().unwrap();\n let response = client.get(\"https:\n\n if !response.status().is_success() {\n eprintln!(\"HTTP error requesting URL: {}\", response.status());\n }\n\n println!(\"Got response from server: {}\", response.text().unwrap());\n\n Ok(())\n}\n"} {"name":"Honaker primes","C":"#include \n#include \n#include \n#include \n\n#define LIMIT 5000000\n\ntypedef struct {\n int x;\n int y;\n} pair;\n\nint *primeSieve(int limit, int *length) {\n int i, p, *primes;\n int j, pc = 0;\n limit++;\n \n bool *c = calloc(limit, sizeof(bool)); \n c[0] = true;\n c[1] = true;\n for (i = 4; i < limit; i += 2) c[i] = true;\n p = 3; \n while (true) {\n int p2 = p * p;\n if (p2 >= limit) break;\n for (i = p2; i < limit; i += 2 * p) c[i] = true;\n while (true) {\n p += 2;\n if (!c[p]) break;\n }\n }\n for (i = 0; i < limit; ++i) {\n if (!c[i]) ++pc;\n }\n primes = (int *)malloc(pc * sizeof(int));\n for (i = 0, j = 0; i < limit; ++i) {\n if (!c[i]) primes[j++] = i;\n }\n free(c);\n *length = pc;\n return primes;\n}\n\nint digitSum(int n) {\n int sum = 0;\n while (n > 0) {\n sum += n % 10;\n n \/= 10;\n }\n return sum;\n}\n\nint main() {\n int i, count, length, hc = 0;\n int *primes = (int *)primeSieve(LIMIT, &length);\n pair h[50], h10000;\n for (i = 1, count = 0; count < 10000; ++i) {\n if (digitSum(i) == digitSum(primes[i-1])) {\n ++count;\n if (count <= 50) {\n h[hc++] = (pair){i, primes[i-1]};\n } else if (count == 10000) {\n h10000.x = i;\n h10000.y = primes[i-1];\n }\n }\n }\n setlocale(LC_NUMERIC, \"\");\n printf(\"The first 50 Honaker primes (index, prime):\\n\");\n for (i = 0; i < 50; ++i) {\n printf(\"(%3d,\u00a0%'5d) \", h[i].x, h[i].y);\n if (!((i+1)%5)) printf(\"\\n\");\n }\n printf(\"\\nand the 10,000th: (%'7d,\u00a0%'9d)\\n\", h10000.x, h10000.y);\n free(primes);\n return 0;\n}\n","Rust":"\n\nfn digit_sum( mut number: usize) -> usize {\n let mut sum : usize = 0 ;\n while number != 0 {\n sum += number % 10 ;\n number \/= 10 ;\n }\n sum \n}\n\nfn main() {\n let mut count : i32 = 0 ;\n let mut pos : i32 = 1 ;\n println!(\"The first 50 Honaker primes:\") ;\n primal::Primes::all( ).enumerate( ).map( |( i , w )| (i + 1 , w) ).\n filter( |(i , w)| digit_sum( *i ) == digit_sum( *w ) ).take( 50 ).\n for_each( |(i , w )| {\n count += 1 ;\n print!(\"(p:{} ,ind:{} ,val:{}) \" , pos , i, w ) ;\n pos += 1 ;\n if count % 3 == 0 {\n println!( ) ;\n }\n }) ;\n println!( ) ;\n}\n"} {"name":"Hough transform","C":"#include \"SL_Generated.h\"\n#include \"CImg.h\"\n\nusing namespace cimg_library;\n\nint main( int argc, char** argv )\n{\n string fileName = \"Pentagon.bmp\";\n if(argc > 1) fileName = argv[1];\n int thetaAxisSize = 640; if(argc > 2) thetaAxisSize = atoi(argv[2]);\n int rAxisSize = 480; if(argc > 3) rAxisSize = atoi(argv[3]);\n int minContrast = 64; if(argc > 4) minContrast = atoi(argv[4]);\n int threads = 0; if(argc > 5) threads = atoi(argv[5]);\n char titleBuffer[200];\n SLTimer t;\n\n CImg image(fileName.c_str());\n int imageDimensions[] = {image.height(), image.width(), 0};\n Sequence > imageSeq((void*) image.data(), imageDimensions);\n Sequence< Sequence > result;\n\n sl_init(threads);\n\n t.start();\n sl_hough(imageSeq, thetaAxisSize, rAxisSize, minContrast, threads, result);\n t.stop();\n \n CImg resultImage(result[1].size(), result.size());\n for(int y = 0; y < result.size(); y++)\n for(int x = 0; x < result[y+1].size(); x++)\n resultImage(x,result.size() - 1 - y) = result[y+1][x+1];\n \n sprintf(titleBuffer, \"SequenceL Hough Transformation: %d X %d Image to %d X %d Result | %d Cores | Processed in %f sec\\0\", \n image.width(), image.height(), resultImage.width(), resultImage.height(), threads, t.getTime());\n resultImage.display(titleBuffer);\n\n sl_done();\n return 0;\n}\n","Rust":"\n\n\nuse std::fs::File;\nuse std::io::{self, BufRead, BufReader, BufWriter, Read, Write};\nuse std::iter::repeat;\n\n\nstruct ImageGray8 {\n width: usize,\n height: usize,\n data: Vec,\n}\n\nfn load_pgm(filename: &str) -> io::Result {\n \n let mut file = BufReader::new(File::open(filename)?);\n\n \n let mut magic_in = String::new();\n let _ = file.read_line(&mut magic_in)?;\n let mut width_in = String::new();\n let _ = file.read_line(&mut width_in)?;\n let mut height_in = String::new();\n let _ = file.read_line(&mut height_in)?;\n let mut maxval_in = String::new();\n let _ = file.read_line(&mut maxval_in)?;\n\n assert_eq!(magic_in, \"P5\\n\");\n assert_eq!(maxval_in, \"255\\n\");\n\n \n let width = width_in\n .trim()\n .parse::()\n .map_err(|_| io::ErrorKind::InvalidData)?;\n let height: usize = height_in\n .trim()\n .parse::()\n .map_err(|_| io::ErrorKind::InvalidData)?;\n\n println!(\"Reading pgm file {}: {} x {}\", filename, width, height);\n\n \n let mut img = ImageGray8 {\n width,\n height,\n data: vec![],\n };\n\n \n let expected_bytes = width * height;\n let bytes_read = file.read_to_end(&mut img.data)?;\n if bytes_read != expected_bytes {\n let kind = if bytes_read < expected_bytes {\n io::ErrorKind::UnexpectedEof\n } else {\n io::ErrorKind::InvalidData\n };\n let msg = format!(\"expected {} bytes\", expected_bytes);\n return Err(io::Error::new(kind, msg));\n }\n\n Ok(img)\n}\n\nfn save_pgm(img: &ImageGray8, filename: &str) {\n \n let mut file = BufWriter::new(File::create(filename).unwrap());\n\n \n if let Err(e) = writeln!(&mut file, \"P5\\n{}\\n{}\\n255\", img.width, img.height) {\n println!(\"Failed to write header: {}\", e);\n }\n\n println!(\n \"Writing pgm file {}: {} x {}\",\n filename, img.width, img.height\n );\n\n \n if let Err(e) = file.write_all(&(img.data[..])) {\n println!(\"Failed to image data: {}\", e);\n }\n}\n\n#[allow(clippy::cast_precision_loss)]\n#[allow(clippy::clippy::cast_possible_truncation)]\nfn hough(image: &ImageGray8, out_width: usize, out_height: usize) -> ImageGray8 {\n let in_width = image.width;\n let in_height = image.height;\n\n \n let out_height = ((out_height \/ 2) * 2) as usize;\n let mut accum = ImageGray8 {\n width: out_width,\n height: out_height,\n data: repeat(255).take(out_width * out_height).collect(),\n };\n\n \n let rmax = (in_width as f64).hypot(in_height as f64);\n let dr = rmax \/ (out_height \/ 2) as f64;\n let dth = std::f64::consts::PI \/ out_width as f64;\n\n \n for y in 0..in_height {\n for x in 0..in_width {\n let in_idx = y * in_width + x;\n let col = image.data[in_idx];\n if col == 255 {\n continue;\n }\n\n \n for jtx in 0..out_width {\n let th = dth * (jtx as f64);\n let r = (x as f64) * (th.cos()) + (y as f64) * (th.sin());\n\n let iry = out_height as i64 \/ 2 - (r \/ (dr as f64) + 0.5).floor() as i64;\n #[allow(clippy::clippy::cast_sign_loss)]\n let out_idx = (jtx as i64 + iry * out_width as i64) as usize;\n let col = accum.data[out_idx];\n if col > 0 {\n accum.data[out_idx] = col - 1;\n }\n }\n }\n }\n accum\n}\n\nfn main() -> io::Result<()> {\n let image = load_pgm(\"resources\/Pentagon.pgm\")?;\n let accum = hough(&image, 460, 360);\n save_pgm(&accum, \"hough.pgm\");\n Ok(())\n}\n"} {"name":"I before E except after C","C":"%{\n \n int cie, cei, ie, ei;\n%}\n \n%%\n \ncie ++cie, ++ie; \ncei ++cei, ++ei;\nie ++ie;\nei ++ei;\n.|\\n ;\n \n%%\n \nint main() {\n cie = cei = ie = ei = 0;\n yylex();\n printf(\"%s: %s\\n\",\"I before E when not preceded by C\", (2*ei < ie ? \"plausible\" : \"implausible\"));\n printf(\"%s: %s\\n\",\"E before I when preceded by C\", (2*cie < cei ? \"plausible\" : \"implausible\"));\n printf(\"%s: %s\\n\",\"Overall, the rule is\", (2*(cie+ei) < (cei+ie) ? \"plausible\" : \"implausible\"));\n return 0;\n}\n","Rust":"use std::default::Default;\nuse std::ops::AddAssign;\n\nuse itertools::Itertools;\nuse reqwest::get;\n\n#[derive(Default, Debug)]\nstruct Feature {\n pub cie: T,\n pub xie: T,\n pub cei: T,\n pub xei: T,\n}\n\nimpl AddAssign> for Feature {\n fn add_assign(&mut self, rhs: Feature) {\n self.cei += rhs.cei as u64;\n self.xei += rhs.xei as u64;\n self.cie += rhs.cie as u64;\n self.xie += rhs.xie as u64;\n }\n}\n\nfn check_feature(word: &str) -> Feature {\n let mut feature: Feature = Default::default();\n\n for window in word.chars().tuple_windows::<(char, char, char)>() {\n match window {\n ('c', 'e', 'i') => { feature.cei = true }\n ('c', 'i', 'e') => { feature.cie = true }\n (not_c, 'e', 'i') if not_c != 'c' => (feature.xei = true),\n (not_c, 'i', 'e') if not_c != 'c' => (feature.xie = true),\n _ => {}\n }\n }\n\n feature\n}\n\n\nfn maybe_is_feature_plausible(feature_count: u64, opposing_count: u64) -> Option {\n if feature_count > 2 * opposing_count { Some(true) } else if opposing_count > 2 * feature_count { Some(false) } else { None }\n}\n\nfn print_feature_plausibility(feature_plausibility: Option, feature_name: &str) {\n let plausible_msg =\n match feature_plausibility {\n None => \" is implausible\",\n Some(true) => \"is plausible\",\n Some(false) => \"is definitely implausible\",\n };\n\n println!(\"{} {}\", feature_name, plausible_msg)\n}\n\nfn main() {\n let mut res = get(\" http:\n let texts = res.text().unwrap();\n\n let mut feature_count: Feature = Default::default();\n for word in texts.lines() {\n let feature = check_feature(word);\n feature_count += feature;\n }\n\n println!(\"Counting {:#?}\", feature_count);\n\n let xie_plausibility =\n maybe_is_feature_plausible(feature_count.xie, feature_count.cie);\n let cei_plausibility =\n maybe_is_feature_plausible(feature_count.cei, feature_count.xei);\n\n print_feature_plausibility(xie_plausibility, \"I before E when not preceded by C\");\n print_feature_plausibility(cei_plausibility, \"E before I when preceded by C\");\n println!(\"The rule in general is {}\",\n if xie_plausibility.unwrap_or(false) && cei_plausibility.unwrap_or(false)\n { \"Plausible\" } else { \"Implausible\" }\n );\n}\n"} {"name":"Idiomatically determine all the lowercase and uppercase letters","C":"#include \n\nint main(int argc, char const *argv[]) {\n for (char c = 0x41; c < 0x5b; c ++) putchar(c);\n putchar('\\n');\n for (char c = 0x61; c < 0x7b; c ++) putchar(c);\n putchar('\\n');\n return 0;\n}\n","Rust":"fn main() {\n println!(\n \"Lowercase letters: {}\",\n (b'a'..=b'z').map(|c| c as char).collect::()\n );\n println!(\n \"Uppercase letters: {}\",\n (b'A'..=b'Z').map(|c| c as char).collect::()\n );\n}\n"} {"name":"Increasing gaps between consecutive Niven numbers","C":"#include \n#include \n#include \n#include \n\n\n\nuint64_t digit_sum(uint64_t n, uint64_t sum) {\n ++sum;\n while (n > 0 && n % 10 == 0) {\n sum -= 9;\n n \/= 10;\n }\n return sum;\n}\n\ninline bool divisible(uint64_t n, uint64_t d) {\n if ((d & 1) == 0 && (n & 1) == 1)\n return false;\n return n % d == 0;\n}\n\nint main() {\n setlocale(LC_ALL, \"\");\n\n uint64_t previous = 1, gap = 0, sum = 0;\n int niven_index = 0, gap_index = 1;\n\n printf(\"Gap index Gap Niven index Niven number\\n\");\n for (uint64_t niven = 1; gap_index <= 32; ++niven) {\n sum = digit_sum(niven, sum);\n if (divisible(niven, sum)) {\n if (niven > previous + gap) {\n gap = niven - previous;\n printf(\"%'9d\u00a0%'4llu\u00a0%'14d\u00a0%'15llu\\n\", gap_index++,\n gap, niven_index, previous);\n }\n previous = niven;\n ++niven_index;\n }\n }\n return 0;\n}\n","Rust":"\n\n\n\n\nfn digit_sum(mut n: u64, mut sum: u64) -> u64 {\n sum += 1;\n while n > 0 && n % 10 == 0 {\n sum -= 9;\n n \/= 10;\n }\n sum\n}\n\nfn divisible(n: u64, d: u64) -> bool {\n if (d & 1) == 0 && (n & 1) == 1 {\n return false;\n }\n n % d == 0\n}\n\nfn main() {\n use num_format::{Locale, ToFormattedString};\n let mut previous = 1;\n let mut gap = 0;\n let mut sum = 0;\n let mut niven_index = 0;\n let mut gap_index = 1;\n let mut niven = 1;\n println!(\"Gap index Gap Niven index Niven number\");\n while gap_index <= 32 {\n sum = digit_sum(niven, sum);\n if divisible(niven, sum) {\n if niven > previous + gap {\n gap = niven - previous;\n println!(\n \"{:9} {:4} {:>14} {:>15}\",\n gap_index,\n gap,\n niven_index.to_formatted_string(&Locale::en),\n previous.to_formatted_string(&Locale::en)\n );\n gap_index += 1;\n }\n previous = niven;\n niven_index += 1;\n }\n niven += 1;\n }\n}\n"} {"name":"Integer roots","C":"#include \n#include \n\ntypedef unsigned long long ulong;\n\nulong root(ulong base, ulong n) {\n ulong n1, n2, n3, c, d, e;\n\n if (base < 2) return base;\n if (n == 0) return 1;\n\n n1 = n - 1;\n n2 = n;\n n3 = n1;\n c = 1;\n d = (n3 + base) \/ n2;\n e = (n3 * d + base \/ (ulong)powl(d, n1)) \/ n2;\n\n while (c != d && c != e) {\n c = d;\n d = e;\n e = (n3*e + base \/ (ulong)powl(e, n1)) \/ n2;\n }\n\n if (d < e) return d;\n return e;\n}\n\nint main() {\n ulong b = (ulong)2e18;\n\n printf(\"3rd root of 8 = %lld\\n\", root(8, 3));\n printf(\"3rd root of 9 = %lld\\n\", root(9, 3));\n printf(\"2nd root of %lld = %lld\\n\", b, root(b, 2));\n\n return 0;\n}\n","Rust":"\n\n\nfn shorten(s: &str, digits: usize) -> String {\n if s.len() <= digits + 3 {\n return String::from(s);\n } \n format!(\"{}...{}\", &s[0..digits\/2], &s[s.len()-digits\/2..])\n}\n\nfn main() {\n use rug::{ops::Pow, Integer};\n\n let x = Integer::from(8);\n let r = Integer::from(x.root_ref(3));\n println!(\"Integer cube root of {}: {}\", x, r);\n\n let x = Integer::from(9);\n let r = Integer::from(x.root_ref(3));\n println!(\"Integer cube root of {}: {}\", x, r);\n\n let mut x = Integer::from(100).pow(2000);\n x *= 2;\n let s = Integer::from(x.root(2)).to_string();\n println!(\"First {} digits of the square root of 2:\\n{}\", s.len(), shorten(&s, 70));\n\n let mut x = Integer::from(100).pow(3000);\n x *= 2;\n let s = Integer::from(x.root(3)).to_string();\n println!(\"First {} digits of the cube root of 2:\\n{}\", s.len(), shorten(&s, 70));\n}\n"} {"name":"Jacobi symbol","C":"#include \n#include \n\n#define SWAP(a, b) (((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b)))\n\nint jacobi(unsigned long a, unsigned long n) {\n\tif (a >= n) a %= n;\n\tint result = 1;\n\twhile (a) {\n\t\twhile ((a & 1) == 0) {\n\t\t\ta >>= 1;\n\t\t\tif ((n & 7) == 3 || (n & 7) == 5) result = -result;\n\t\t}\n\t\tSWAP(a, n);\n\t\tif ((a & 3) == 3 && (n & 3) == 3) result = -result;\n\t\ta %= n;\n\t}\n\tif (n == 1) return result;\n\treturn 0;\n}\n\nvoid print_table(unsigned kmax, unsigned nmax) {\n\tprintf(\"n\\\\k|\");\n\tfor (int k = 0; k <= kmax; ++k) printf(\"%'3u\", k);\n\tprintf(\"\\n----\");\n\tfor (int k = 0; k <= kmax; ++k) printf(\"---\");\n\tputchar('\\n');\n\tfor (int n = 1; n <= nmax; n += 2) {\n\t\tprintf(\"%-2u |\", n);\n\t\tfor (int k = 0; k <= kmax; ++k)\n\t\t\tprintf(\"%'3d\", jacobi(k, n));\n\t\tputchar('\\n');\n\t}\n}\n\nint main() {\n\tprint_table(20, 21);\n\treturn 0;\n}\n","Rust":"fn jacobi(mut n: i32, mut k: i32) -> i32 {\n assert!(k > 0 && k % 2 == 1);\n n %= k;\n let mut t = 1;\n while n != 0 {\n while n % 2 == 0 {\n n \/= 2;\n let r = k % 8;\n if r == 3 || r == 5 {\n t = -t;\n }\n }\n std::mem::swap(&mut n, &mut k);\n if n % 4 == 3 && k % 4 == 3 {\n t = -t;\n }\n n %= k;\n }\n if k == 1 {\n t\n } else {\n 0\n }\n}\n\nfn print_table(kmax: i32, nmax: i32) {\n print!(\"n\\\\k|\");\n for k in 0..=kmax {\n print!(\" {:2}\", k);\n }\n print!(\"\\n----\");\n for _ in 0..=kmax {\n print!(\"---\");\n }\n println!();\n for n in (1..=nmax).step_by(2) {\n print!(\"{:2} |\", n);\n for k in 0..=kmax {\n print!(\" {:2}\", jacobi(k, n));\n }\n println!();\n }\n}\n\nfn main() {\n print_table(20, 21);\n}\n"} {"name":"Jacobsthal numbers","C":"#include \n#include \n\nvoid jacobsthal(mpz_t r, unsigned long n) {\n mpz_t s;\n mpz_init(s);\n mpz_set_ui(r, 1);\n mpz_mul_2exp(r, r, n);\n mpz_set_ui(s, 1);\n if (n % 2) mpz_neg(s, s);\n mpz_sub(r, r, s);\n mpz_div_ui(r, r, 3);\n}\n\nvoid jacobsthal_lucas(mpz_t r, unsigned long n) {\n mpz_t a;\n mpz_init(a);\n mpz_set_ui(r, 1);\n mpz_mul_2exp(r, r, n);\n mpz_set_ui(a, 1);\n if (n % 2) mpz_neg(a, a);\n mpz_add(r, r, a);\n}\n\nint main() {\n int i, count;\n mpz_t jac[30], j;\n printf(\"First 30 Jacobsthal numbers:\\n\");\n for (i = 0; i < 30; ++i) {\n mpz_init(jac[i]);\n jacobsthal(jac[i], i);\n gmp_printf(\"%9Zd \", jac[i]);\n if (!((i+1)%5)) printf(\"\\n\");\n }\n\n printf(\"\\nFirst 30 Jacobsthal-Lucas numbers:\\n\");\n mpz_init(j);\n for (i = 0; i < 30; ++i) {\n jacobsthal_lucas(j, i);\n gmp_printf(\"%9Zd \", j);\n if (!((i+1)%5)) printf(\"\\n\");\n }\n\n printf(\"\\nFirst 20 Jacobsthal oblong numbers:\\n\");\n for (i = 0; i < 20; ++i) {\n mpz_mul(j, jac[i], jac[i+1]);\n gmp_printf(\"%11Zd \", j);\n if (!((i+1)%5)) printf(\"\\n\");\n }\n\n printf(\"\\nFirst 20 Jacobsthal primes:\\n\");\n for (i = 0, count = 0; count < 20; ++i) {\n jacobsthal(j, i);\n if (mpz_probab_prime_p(j, 15) > 0) {\n gmp_printf(\"%Zd\\n\", j);\n ++count;\n }\n }\n\n return 0;\n}\n","Rust":"\n\n\nuse rug::integer::IsPrime;\nuse rug::Integer;\n\nfn jacobsthal_numbers() -> impl std::iter::Iterator {\n (0..).map(|x| ((Integer::from(1) << x) - if x % 2 == 0 { 1 } else { -1 }) \/ 3)\n}\n\nfn jacobsthal_lucas_numbers() -> impl std::iter::Iterator {\n (0..).map(|x| (Integer::from(1) << x) + if x % 2 == 0 { 1 } else { -1 })\n}\n\nfn jacobsthal_oblong_numbers() -> impl std::iter::Iterator {\n let mut jn = jacobsthal_numbers();\n let mut n0 = jn.next().unwrap();\n std::iter::from_fn(move || {\n let n1 = jn.next().unwrap();\n let result = Integer::from(&n0 * &n1);\n n0 = n1;\n Some(result)\n })\n}\n\nfn jacobsthal_primes() -> impl std::iter::Iterator {\n jacobsthal_numbers().filter(|x| x.is_probably_prime(30) != IsPrime::No)\n}\n\nfn main() {\n println!(\"First 30 Jacobsthal Numbers:\");\n for (i, n) in jacobsthal_numbers().take(30).enumerate() {\n print!(\"{:9}{}\", n, if (i + 1) % 5 == 0 { \"\\n\" } else { \" \" });\n }\n println!(\"\\nFirst 30 Jacobsthal-Lucas Numbers:\");\n for (i, n) in jacobsthal_lucas_numbers().take(30).enumerate() {\n print!(\"{:9}{}\", n, if (i + 1) % 5 == 0 { \"\\n\" } else { \" \" });\n }\n println!(\"\\nFirst 20 Jacobsthal oblong Numbers:\");\n for (i, n) in jacobsthal_oblong_numbers().take(20).enumerate() {\n print!(\"{:11}{}\", n, if (i + 1) % 5 == 0 { \"\\n\" } else { \" \" });\n }\n println!(\"\\nFirst 20 Jacobsthal primes:\");\n for n in jacobsthal_primes().take(20) {\n println!(\"{}\", n);\n }\n}\n"} {"name":"Jaro similarity","C":"#include \n#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\n#define max(a, b) ((a) > (b)\u00a0? (a)\u00a0: (b))\n#define min(a, b) ((a) < (b)\u00a0? (a)\u00a0: (b))\n\ndouble jaro(const char *str1, const char *str2) {\n \n int str1_len = strlen(str1);\n int str2_len = strlen(str2);\n\n \n \n if (str1_len == 0) return str2_len == 0 ? 1.0 : 0.0;\n\n \n \n int match_distance = (int) max(str1_len, str2_len)\/2 - 1;\n\n \n int *str1_matches = calloc(str1_len, sizeof(int));\n int *str2_matches = calloc(str2_len, sizeof(int));\n\n \n double matches = 0.0;\n double transpositions = 0.0;\n\n \n for (int i = 0; i < str1_len; i++) {\n \n int start = max(0, i - match_distance);\n int end = min(i + match_distance + 1, str2_len);\n\n for (int k = start; k < end; k++) {\n \n if (str2_matches[k]) continue;\n \n if (str1[i] != str2[k]) continue;\n \n str1_matches[i] = TRUE;\n str2_matches[k] = TRUE;\n matches++;\n break;\n }\n }\n\n \n if (matches == 0) {\n free(str1_matches);\n free(str2_matches);\n return 0.0;\n }\n\n \n int k = 0;\n for (int i = 0; i < str1_len; i++) {\n \n if (!str1_matches[i]) continue;\n \n while (!str2_matches[k]) k++;\n \n if (str1[i] != str2[k]) transpositions++;\n k++;\n }\n\n \n \n \n transpositions \/= 2.0;\n\n \n free(str1_matches);\n free(str2_matches);\n\n \n return ((matches \/ str1_len) +\n (matches \/ str2_len) +\n ((matches - transpositions) \/ matches)) \/ 3.0;\n}\n\nint main() {\n printf(\"%f\\n\", jaro(\"MARTHA\", \"MARHTA\"));\n printf(\"%f\\n\", jaro(\"DIXON\", \"DICKSONX\"));\n printf(\"%f\\n\", jaro(\"JELLYFISH\", \"SMELLYFISH\"));\n}\n","Rust":"use std::cmp;\n\npub fn jaro(s1: &str, s2: &str) -> f64 {\n let s1_len = s1.len();\n let s2_len = s2.len();\n if s1_len == 0 && s2_len == 0 { return 1.0; }\n let match_distance = cmp::max(s1_len, s2_len) \/ 2 - 1;\n let mut s1_matches = vec![false; s1_len];\n let mut s2_matches = vec![false; s2_len];\n let mut m: isize = 0;\n for i in 0..s1_len {\n let start = cmp::max(0, i as isize - match_distance as isize) as usize;\n let end = cmp::min(i + match_distance + 1, s2_len);\n for j in start..end {\n if !s2_matches[j] && s1.as_bytes()[i] == s2.as_bytes()[j] {\n s1_matches[i] = true;\n s2_matches[j] = true;\n m += 1;\n break;\n }\n }\n }\n if m == 0 { return 0.0; }\n let mut t = 0.0;\n let mut k = 0;\n for i in 0..s1_len {\n if s1_matches[i] {\n while !s2_matches[k] { k += 1; }\n if s1.as_bytes()[i] != s2.as_bytes()[k] { t += 0.5; }\n k += 1;\n }\n }\n\n let m = m as f64;\n (m \/ s1_len as f64 + m \/ s2_len as f64 + (m - t) \/ m) \/ 3.0\n}\n\nfn main() {\n let pairs = [(\"MARTHA\", \"MARHTA\"), (\"DIXON\", \"DICKSONX\"), (\"JELLYFISH\", \"SMELLYFISH\")];\n for p in pairs.iter() { println!(\"{}\/{} = {}\", p.0, p.1, jaro(p.0, p.1)); }\n}\n"} {"name":"K-d tree","C":"#include \n#include \n#include \n#include \n#include \n\n#define MAX_DIM 3\nstruct kd_node_t{\n double x[MAX_DIM];\n struct kd_node_t *left, *right;\n};\n\n inline double\ndist(struct kd_node_t *a, struct kd_node_t *b, int dim)\n{\n double t, d = 0;\n while (dim--) {\n t = a->x[dim] - b->x[dim];\n d += t * t;\n }\n return d;\n}\ninline void swap(struct kd_node_t *x, struct kd_node_t *y) {\n double tmp[MAX_DIM];\n memcpy(tmp, x->x, sizeof(tmp));\n memcpy(x->x, y->x, sizeof(tmp));\n memcpy(y->x, tmp, sizeof(tmp));\n}\n\n\n\n struct kd_node_t*\nfind_median(struct kd_node_t *start, struct kd_node_t *end, int idx)\n{\n if (end <= start) return NULL;\n if (end == start + 1)\n return start;\n\n struct kd_node_t *p, *store, *md = start + (end - start) \/ 2;\n double pivot;\n while (1) {\n pivot = md->x[idx];\n\n swap(md, end - 1);\n for (store = p = start; p < end; p++) {\n if (p->x[idx] < pivot) {\n if (p != store)\n swap(p, store);\n store++;\n }\n }\n swap(store, end - 1);\n\n \n if (store->x[idx] == md->x[idx])\n return md;\n\n if (store > md) end = store;\n else start = store;\n }\n}\n\n struct kd_node_t*\nmake_tree(struct kd_node_t *t, int len, int i, int dim)\n{\n struct kd_node_t *n;\n\n if (!len) return 0;\n\n if ((n = find_median(t, t + len, i))) {\n i = (i + 1) % dim;\n n->left = make_tree(t, n - t, i, dim);\n n->right = make_tree(n + 1, t + len - (n + 1), i, dim);\n }\n return n;\n}\n\n\nint visited;\n\nvoid nearest(struct kd_node_t *root, struct kd_node_t *nd, int i, int dim,\n struct kd_node_t **best, double *best_dist)\n{\n double d, dx, dx2;\n\n if (!root) return;\n d = dist(root, nd, dim);\n dx = root->x[i] - nd->x[i];\n dx2 = dx * dx;\n\n visited ++;\n\n if (!*best || d < *best_dist) {\n *best_dist = d;\n *best = root;\n }\n\n \n if (!*best_dist) return;\n\n if (++i >= dim) i = 0;\n\n nearest(dx > 0 ? root->left : root->right, nd, i, dim, best, best_dist);\n if (dx2 >= *best_dist) return;\n nearest(dx > 0 ? root->right : root->left, nd, i, dim, best, best_dist);\n}\n\n#define N 1000000\n#define rand1() (rand() \/ (double)RAND_MAX)\n#define rand_pt(v) { v.x[0] = rand1(); v.x[1] = rand1(); v.x[2] = rand1(); }\nint main(void)\n{\n int i;\n struct kd_node_t wp[] = {\n {{2, 3}}, {{5, 4}}, {{9, 6}}, {{4, 7}}, {{8, 1}}, {{7, 2}}\n };\n struct kd_node_t testNode = {{9, 2}};\n struct kd_node_t *root, *found, *million;\n double best_dist;\n\n root = make_tree(wp, sizeof(wp) \/ sizeof(wp[1]), 0, 2);\n\n visited = 0;\n found = 0;\n nearest(root, &testNode, 0, 2, &found, &best_dist);\n\n printf(\">> WP tree\\nsearching for (%g, %g)\\n\"\n \"found (%g, %g) dist %g\\nseen %d nodes\\n\\n\",\n testNode.x[0], testNode.x[1],\n found->x[0], found->x[1], sqrt(best_dist), visited);\n\n million =(struct kd_node_t*) calloc(N, sizeof(struct kd_node_t));\n srand(time(0));\n for (i = 0; i < N; i++) rand_pt(million[i]);\n\n root = make_tree(million, N, 0, 3);\n rand_pt(testNode);\n\n visited = 0;\n found = 0;\n nearest(root, &testNode, 0, 3, &found, &best_dist);\n\n printf(\">> Million tree\\nsearching for (%g, %g, %g)\\n\"\n \"found (%g, %g, %g) dist %g\\nseen %d nodes\\n\",\n testNode.x[0], testNode.x[1], testNode.x[2],\n found->x[0], found->x[1], found->x[2],\n sqrt(best_dist), visited);\n\n \n int sum = 0, test_runs = 100000;\n for (i = 0; i < test_runs; i++) {\n found = 0;\n visited = 0;\n rand_pt(testNode);\n nearest(root, &testNode, 0, 3, &found, &best_dist);\n sum += visited;\n }\n printf(\"\\n>> Million tree\\n\"\n \"visited %d nodes for %d random findings (%f per lookup)\\n\",\n sum, test_runs, sum\/(double)test_runs);\n\n \n\n return 0;\n}\n","Rust":"use std::cmp::Ordering;\nuse std::cmp::Ordering::Less;\nuse std::ops::Sub;\nuse std::time::Instant;\n\nuse rand::prelude::*;\n\n#[derive(Clone, PartialEq, Debug)]\nstruct Point {\n pub coords: Vec,\n}\n\nimpl<'a, 'b> Sub<&'b Point> for &'a Point {\n type Output = Point;\n\n fn sub(self, rhs: &Point) -> Point {\n assert_eq!(self.coords.len(), rhs.coords.len());\n Point {\n coords: self\n .coords\n .iter()\n .zip(rhs.coords.iter())\n .map(|(&x, &y)| x - y)\n .collect(),\n }\n }\n}\n\nimpl Point {\n fn norm_sq(&self) -> f32 {\n self.coords.iter().map(|n| n * n).sum()\n }\n}\n\nstruct KDTreeNode {\n point: Point,\n dim: usize,\n \n \n left: Option>,\n right: Option>,\n}\n\nimpl KDTreeNode {\n \n \n \n pub fn new(points: &mut [Point], dim: usize) -> KDTreeNode {\n let points_len = points.len();\n if points_len == 1 {\n return KDTreeNode {\n point: points[0].clone(),\n dim,\n left: None,\n right: None,\n };\n }\n\n \n let pivot = quickselect_by(points, points_len \/ 2, &|a, b| {\n a.coords[dim].partial_cmp(&b.coords[dim]).unwrap()\n });\n\n let left = Some(Box::new(KDTreeNode::new(\n &mut points[0..points_len \/ 2],\n (dim + 1) % pivot.coords.len(),\n )));\n let right = if points.len() >= 3 {\n Some(Box::new(KDTreeNode::new(\n &mut points[points_len \/ 2 + 1..points_len],\n (dim + 1) % pivot.coords.len(),\n )))\n } else {\n None\n };\n\n KDTreeNode {\n point: pivot,\n dim,\n left,\n right,\n }\n }\n\n pub fn find_nearest_neighbor<'a>(&'a self, point: &Point) -> (&'a Point, usize) {\n self.find_nearest_neighbor_helper(point, &self.point, (point - &self.point).norm_sq(), 1)\n }\n\n fn find_nearest_neighbor_helper<'a>(\n &'a self,\n point: &Point,\n best: &'a Point,\n best_dist_sq: f32,\n n_visited: usize,\n ) -> (&'a Point, usize) {\n let mut my_best = best;\n let mut my_best_dist_sq = best_dist_sq;\n let mut my_n_visited = n_visited;\n\n \n if self.point.coords[self.dim] < point.coords[self.dim] && self.right.is_some() {\n let (a, b) = self.right.as_ref().unwrap().find_nearest_neighbor_helper(\n point,\n my_best,\n my_best_dist_sq,\n my_n_visited,\n );\n my_best = a;\n my_n_visited = b;\n } else if self.left.is_some() {\n let (a, b) = self.left.as_ref().unwrap().find_nearest_neighbor_helper(\n point,\n my_best,\n my_best_dist_sq,\n my_n_visited,\n );\n my_best = a;\n my_n_visited = b;\n }\n\n \n let axis_dist_sq = (self.point.coords[self.dim] - point.coords[self.dim]).powi(2);\n if axis_dist_sq <= my_best_dist_sq {\n \n \n \n let self_dist_sq = (point - &self.point).norm_sq();\n if self_dist_sq < my_best_dist_sq {\n my_best = &self.point;\n my_best_dist_sq = self_dist_sq;\n }\n\n \n my_n_visited += 1;\n\n \n if self.point.coords[self.dim] < point.coords[self.dim] && self.left.is_some() {\n let (a, b) = self.left.as_ref().unwrap().find_nearest_neighbor_helper(\n point,\n my_best,\n my_best_dist_sq,\n my_n_visited,\n );\n my_best = a;\n my_n_visited = b;\n } else if self.right.is_some() {\n let (a, b) = self.right.as_ref().unwrap().find_nearest_neighbor_helper(\n point,\n my_best,\n my_best_dist_sq,\n my_n_visited,\n );\n my_best = a;\n my_n_visited = b;\n }\n }\n\n (my_best, my_n_visited)\n }\n}\n\npub fn main() {\n let mut rng = thread_rng();\n\n \n let mut wp_points: Vec = [\n [2.0, 3.0],\n [5.0, 4.0],\n [9.0, 6.0],\n [4.0, 7.0],\n [8.0, 1.0],\n [7.0, 2.0],\n ]\n .iter()\n .map(|x| Point { coords: x.to_vec() })\n .collect();\n let wp_tree = KDTreeNode::new(&mut wp_points, 0);\n\n let wp_target = Point {\n coords: vec![9.0, 2.0],\n };\n let (point, n_visited) = wp_tree.find_nearest_neighbor(&wp_target);\n println!(\"Wikipedia example data:\");\n println!(\"Point: [9, 2]\");\n println!(\"Nearest neighbor: {:?}\", point);\n println!(\"Distance: {}\", (point - &wp_target).norm_sq().sqrt());\n println!(\"Nodes visited: {}\", n_visited);\n\n \n let n_random = 1000;\n let mut make_random_point = || Point {\n coords: (0..3).map(|_| (rng.gen::() - 0.5) * 1000.0).collect(),\n };\n let mut random_points: Vec = (0..n_random).map(|_| make_random_point()).collect();\n\n let start_cons_time = Instant::now();\n let random_tree = KDTreeNode::new(&mut random_points, 0);\n let cons_time = start_cons_time.elapsed();\n println!(\n \"1,000 3d points (Construction time: {}ms)\",\n cons_time.as_millis(),\n );\n\n let random_target = make_random_point();\n\n let (point, n_visited) = random_tree.find_nearest_neighbor(&random_target);\n println!(\"Point: {:?}\", random_target);\n println!(\"Nearest neighbor: {:?}\", point);\n println!(\"Distance: {}\", (point - &random_target).norm_sq().sqrt());\n println!(\"Nodes visited: {}\", n_visited);\n\n \n let n_searches = 1000;\n let random_targets: Vec = (0..n_searches).map(|_| make_random_point()).collect();\n\n let start_search_time = Instant::now();\n let mut total_n_visited = 0;\n for target in &random_targets {\n let (_, n_visited) = random_tree.find_nearest_neighbor(target);\n total_n_visited += n_visited;\n }\n let search_time = start_search_time.elapsed();\n println!(\n \"Visited an average of {} nodes on {} searches in {} ms\",\n total_n_visited as f32 \/ n_searches as f32,\n n_searches,\n search_time.as_millis(),\n );\n}\n\nfn quickselect_by(arr: &mut [T], position: usize, cmp: &dyn Fn(&T, &T) -> Ordering) -> T\nwhere\n T: Clone,\n{\n \n let mut pivot_index = thread_rng().gen_range(0, arr.len());\n \n \n pivot_index = partition_by(arr, pivot_index, &|a: &T, b: &T| cmp(a, b));\n let array_len = arr.len();\n match position.cmp(&pivot_index) {\n Ordering::Equal => arr[position].clone(),\n Ordering::Less => quickselect_by(&mut arr[0..pivot_index], position, cmp),\n Ordering::Greater => quickselect_by(\n &mut arr[pivot_index + 1..array_len],\n position - pivot_index - 1,\n cmp,\n ),\n }\n}\n\nfn partition_by(arr: &mut [T], pivot_index: usize, cmp: &dyn Fn(&T, &T) -> Ordering) -> usize {\n let array_len = arr.len();\n arr.swap(pivot_index, array_len - 1);\n let mut store_index = 0;\n for i in 0..array_len - 1 {\n if cmp(&arr[i], &arr[array_len - 1]) == Less {\n arr.swap(i, store_index);\n store_index += 1;\n }\n }\n arr.swap(array_len - 1, store_index);\n store_index\n}\n"} {"name":"Koch curve","C":"#include\n#include\n#include\n#include\n\n#define pi M_PI\n\ntypedef struct{\n\tdouble x,y;\n}point;\n\nvoid kochCurve(point p1,point p2,int times){\n\tpoint p3,p4,p5;\n\tdouble theta = pi\/3;\n\t\n\tif(times>0){\n\t\tp3 = (point){(2*p1.x+p2.x)\/3,(2*p1.y+p2.y)\/3};\n\t\tp5 = (point){(2*p2.x+p1.x)\/3,(2*p2.y+p1.y)\/3};\n\t\t\n\t\tp4 = (point){p3.x + (p5.x - p3.x)*cos(theta) + (p5.y - p3.y)*sin(theta),p3.y - (p5.x - p3.x)*sin(theta) + (p5.y - p3.y)*cos(theta)};\n\t\t\n\t\tkochCurve(p1,p3,times-1);\n\t\tkochCurve(p3,p4,times-1);\n\t\tkochCurve(p4,p5,times-1);\n\t\tkochCurve(p5,p2,times-1);\n\t}\n\t\n\telse{\n\t\tline(p1.x,p1.y,p2.x,p2.y);\n\t}\n}\n\nint main(int argC, char** argV)\n{\n\tint w,h,r;\n\tpoint p1,p2;\n\t\n\tif(argC!=4){\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\t}\n\t\n\telse{\n\t\tw = atoi(argV[1]);\n\t\th = atoi(argV[2]);\n\t\tr = atoi(argV[3]);\n\t\t\n\t\tinitwindow(w,h,\"Koch Curve\");\n\t\t\n\t\tp1 = (point){10,h-10};\n\t\tp2 = (point){w-10,h-10};\n\t\t\n\t\tkochCurve(p1,p2,r);\n\t\t\n\t\tgetch();\n\t\n\t\tclosegraph();\n\t}\n\t\n\treturn 0;\n}\n","Rust":"\n\n\nuse svg::node::element::path::Data;\nuse svg::node::element::Path;\nuse svg::node::element::Rectangle;\n\nconst SQRT3_2: f64 = 0.86602540378444;\n\nfn koch_curve(mut data: Data, x0: f64, y0: f64, x1: f64, y1: f64, order: usize) -> Data {\n if order == 0 {\n data = data.line_to((x1, y1));\n } else {\n let dx = x1 - x0;\n let dy = y1 - y0;\n let x2 = x0 + dx \/ 3.0;\n let y2 = y0 + dy \/ 3.0;\n let x3 = x0 + dx \/ 2.0 - dy * SQRT3_2 \/ 3.0;\n let y3 = y0 + dy \/ 2.0 + dx * SQRT3_2 \/ 3.0;\n let x4 = x0 + 2.0 * dx \/ 3.0;\n let y4 = y0 + 2.0 * dy \/ 3.0;\n data = koch_curve(data, x0, y0, x2, y2, order - 1);\n data = koch_curve(data, x2, y2, x3, y3, order - 1);\n data = koch_curve(data, x3, y3, x4, y4, order - 1);\n data = koch_curve(data, x4, y4, x1, y1, order - 1);\n }\n data\n}\n\nfn write_koch_snowflake(file: &str, size: usize, order: usize) -> std::io::Result<()> {\n let length = (size as f64) * SQRT3_2 * 0.95;\n let x0 = ((size as f64) - length) \/ 2.0;\n let y0 = (size as f64) \/ 2.0 - length * SQRT3_2 \/ 3.0;\n let x1 = x0 + length \/ 2.0;\n let y1 = y0 + length * SQRT3_2;\n let x2 = x0 + length;\n\n let mut data = Data::new().move_to((x0, y0));\n data = koch_curve(data, x0, y0, x1, y1, order);\n data = koch_curve(data, x1, y1, x2, y0, order);\n data = koch_curve(data, x2, y0, x0, y0, order);\n\n let path = Path::new()\n .set(\"fill\", \"none\")\n .set(\"stroke\", \"white\")\n .set(\"stroke-width\", \"1\")\n .set(\"d\", data);\n\n let rect = Rectangle::new()\n .set(\"width\", \"100%\")\n .set(\"height\", \"100%\")\n .set(\"fill\", \"black\");\n\n let document = svg::Document::new()\n .set(\"width\", size)\n .set(\"height\", size)\n .add(rect)\n .add(path);\n\n svg::save(file, &document)\n}\n\nfn main() {\n write_koch_snowflake(\"koch_snowflake.svg\", 600, 5).unwrap();\n}\n"} {"name":"Kolakoski sequence","C":"#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\ntypedef int bool;\n\nint next_in_cycle(int *c, int len, int index) {\n return c[index % len];\n}\n\nvoid kolakoski(int *c, int *s, int clen, int slen) {\n int i = 0, j, k = 0;\n while (TRUE) {\n s[i] = next_in_cycle(c, clen, k);\n if (s[k] > 1) {\n for (j = 1; j < s[k]; ++j) {\n if (++i == slen) return;\n s[i] = s[i - 1];\n }\n }\n if (++i == slen) return;\n k++;\n }\n}\n\nbool possible_kolakoski(int *s, int len) {\n int i, j = 0, prev = s[0], count = 1;\n int *rle = calloc(len, sizeof(int));\n bool result = TRUE;\n for (i = 1; i < len; ++i) {\n if (s[i] == prev) {\n count++;\n }\n else {\n rle[j++] = count;\n count = 1;\n prev = s[i];\n }\n }\n \n for (i = 0; i < j; i++) {\n if (rle[i] != s[i]) {\n result = FALSE;\n break;\n }\n }\n free(rle);\n return result;\n}\n\nvoid print_array(int *a, int len) {\n int i;\n printf(\"[\");\n for (i = 0; i < len; ++i) {\n printf(\"%d\", a[i]);\n if (i < len - 1) printf(\", \");\n }\n printf(\"]\");\n}\n\nint main() {\n int i, clen, slen, *s;\n int c0[2] = {1, 2};\n int c1[2] = {2, 1};\n int c2[4] = {1, 3, 1, 2};\n int c3[4] = {1, 3, 2, 1};\n int *cs[4] = {c0, c1, c2, c3};\n bool p;\n int clens[4] = {2, 2, 4, 4};\n int slens[4] = {20, 20, 30, 30};\n for (i = 0; i < 4; ++i) {\n clen = clens[i];\n slen = slens[i];\n s = calloc(slen, sizeof(int));\n kolakoski(cs[i], s, clen, slen);\n printf(\"First %d members of the sequence generated by \", slen);\n print_array(cs[i], clen);\n printf(\":\\n\");\n print_array(s, slen);\n printf(\"\\n\");\n p = possible_kolakoski(s, slen);\n printf(\"Possible Kolakoski sequence? %s\\n\\n\", p ? \"True\" : \"False\");\n free(s); \n }\n return 0;\n}\n","Rust":"use itertools::Itertools;\n\nfn get_kolakoski_sequence(iseq: &[usize], size: &usize) -> Vec {\n assert!(*size > 0);\n assert!(!iseq.is_empty());\n\n let mut kseq: Vec = Vec::default();\n\n \n let repeater = iseq.iter().cloned().cycle();\n\n \n kseq.extend_from_slice(&vec![*iseq.get(0).unwrap()].repeat(*iseq.get(0).unwrap()));\n\n \n for (k_counter, elem) in repeater.enumerate().skip(1) {\n \n kseq.push(elem);\n\n \n \n kseq.extend_from_slice(&vec![elem].repeat(*kseq.get(k_counter).unwrap() - 1));\n\n \n if kseq.len() >= *size {\n break;\n }\n }\n\n \n kseq[0..*size].to_vec()\n}\n\nfn is_kolakoski(kseq: &[usize]) -> bool {\n assert!(!kseq.is_empty());\n\n \n let rle: Vec = kseq\n .iter()\n .batching(|it| {\n it.next()\n .map(|v| it.take_while_ref(|&v2| v2 == v).count() + 1)\n })\n .collect();\n\n rle.iter().zip(kseq).filter(|&(a, b)| a == b).count() == rle.len()\n}\n\nfn main() {\n let lengths = vec![20, 20, 30, 30];\n let seqs = vec![vec![1, 2], vec![2, 1], vec![1, 3, 1, 2], vec![1, 3, 2, 1]];\n\n for (seq, length) in seqs.iter().zip(&lengths) {\n let kseq = get_kolakoski_sequence(&seq, length);\n\n println!(\"Starting sequence: {:?}\", seq);\n println!(\"Kolakoski sequence: {:?}\", kseq);\n println!(\"Possible Kolakoski sequence? {:?}\", is_kolakoski(&kseq));\n }\n}\n"} {"name":"LU decomposition","C":"#include \n#include \n#include \n\n#define foreach(a, b, c) for (int a = b; a < c; a++)\n#define for_i foreach(i, 0, n)\n#define for_j foreach(j, 0, n)\n#define for_k foreach(k, 0, n)\n#define for_ij for_i for_j\n#define for_ijk for_ij for_k\n#define _dim int n\n#define _swap(x, y) { typeof(x) tmp = x; x = y; y = tmp; }\n#define _sum_k(a, b, c, s) { s = 0; foreach(k, a, b) s+= c; }\n\ntypedef double **mat;\n\n#define _zero(a) mat_zero(a, n)\nvoid mat_zero(mat x, int n) { for_ij x[i][j] = 0; }\n\n#define _new(a) a = mat_new(n)\nmat mat_new(_dim)\n{\n\tmat x = malloc(sizeof(double*) * n);\n\tx[0] = malloc(sizeof(double) * n * n);\n\n\tfor_i x[i] = x[0] + n * i;\n\t_zero(x);\n\n\treturn x;\n}\n\n#define _copy(a) mat_copy(a, n)\nmat mat_copy(void *s, _dim)\n{\n\tmat x = mat_new(n);\n\tfor_ij x[i][j] = ((double (*)[n])s)[i][j];\n\treturn x;\n}\n\n#define _del(x) mat_del(x)\nvoid mat_del(mat x) { free(x[0]); free(x); }\n\n#define _QUOT(x) #x\n#define QUOTE(x) _QUOT(x)\n#define _show(a) printf(QUOTE(a)\" =\");mat_show(a, 0, n)\nvoid mat_show(mat x, char *fmt, _dim)\n{\n\tif (!fmt) fmt = \"%8.4g\";\n\tfor_i {\n\t\tprintf(i ? \" \" : \" [ \");\n\t\tfor_j {\n\t\t\tprintf(fmt, x[i][j]);\n\t\t\tprintf(j < n - 1 ? \" \" : i == n - 1 ? \" ]\\n\" : \"\\n\");\n\t\t}\n\t}\n}\n\n#define _mul(a, b) mat_mul(a, b, n)\nmat mat_mul(mat a, mat b, _dim)\n{\n\tmat c = _new(c);\n\tfor_ijk c[i][j] += a[i][k] * b[k][j];\n\treturn c;\n}\n\n#define _pivot(a, b) mat_pivot(a, b, n)\nvoid mat_pivot(mat a, mat p, _dim)\n{\n\tfor_ij { p[i][j] = (i == j); }\n\tfor_i {\n\t\tint max_j = i;\n\t\tforeach(j, i, n)\n\t\t\tif (fabs(a[j][i]) > fabs(a[max_j][i])) max_j = j;\n\n\t\tif (max_j != i)\n\t\t\tfor_k { _swap(p[i][k], p[max_j][k]); }\n\t}\n}\n\n#define _LU(a, l, u, p) mat_LU(a, l, u, p, n)\nvoid mat_LU(mat A, mat L, mat U, mat P, _dim)\n{\n\t_zero(L); _zero(U);\n\t_pivot(A, P);\n\n\tmat Aprime = _mul(P, A);\n\n\tfor_i { L[i][i] = 1; }\n\tfor_ij {\n\t\tdouble s;\n\t\tif (j <= i) {\n\t\t\t_sum_k(0, j, L[j][k] * U[k][i], s)\n\t\t\tU[j][i] = Aprime[j][i] - s;\n\t\t}\n\t\tif (j >= i) {\n\t\t\t_sum_k(0, i, L[j][k] * U[k][i], s);\n\t\t\tL[j][i] = (Aprime[j][i] - s) \/ U[i][i];\n\t\t}\n\t}\n\n\t_del(Aprime);\n}\n\ndouble A3[][3] = {{ 1, 3, 5 }, { 2, 4, 7 }, { 1, 1, 0 }};\ndouble A4[][4] = {{11, 9, 24, 2}, {1, 5, 2, 6}, {3, 17, 18, 1}, {2, 5, 7, 1}};\n\nint main()\n{\n\tint n = 3;\n\tmat A, L, P, U;\n\n\t_new(L); _new(P); _new(U);\n\tA = _copy(A3);\n\t_LU(A, L, U, P);\n\t_show(A); _show(L); _show(U); _show(P);\n\t_del(A); _del(L); _del(U); _del(P);\n\n\tprintf(\"\\n\");\n\n\tn = 4;\n\n\t_new(L); _new(P); _new(U);\n\tA = _copy(A4);\n\t_LU(A, L, U, P);\n\t_show(A); _show(L); _show(U); _show(P);\n\t_del(A); _del(L); _del(U); _del(P);\n\n\treturn 0;\n}\n","Rust":"#![allow(non_snake_case)]\nuse ndarray::{Array, Axis, Array2, arr2, Zip, NdFloat, s};\n\nfn main() {\n println!(\"Example 1:\");\n let A: Array2 = arr2(&[\n [1.0, 3.0, 5.0],\n [2.0, 4.0, 7.0],\n [1.0, 1.0, 0.0],\n ]);\n println!(\"A \\n {}\", A);\n let (L, U, P) = lu_decomp(A);\n println!(\"L \\n {}\", L);\n println!(\"U \\n {}\", U);\n println!(\"P \\n {}\", P);\n\n println!(\"\\nExample 2:\");\n let A: Array2 = arr2(&[\n [11.0, 9.0, 24.0, 2.0],\n [1.0, 5.0, 2.0, 6.0],\n [3.0, 17.0, 18.0, 1.0],\n [2.0, 5.0, 7.0, 1.0],\n ]);\n println!(\"A \\n {}\", A);\n let (L, U, P) = lu_decomp(A);\n println!(\"L \\n {}\", L);\n println!(\"U \\n {}\", U);\n println!(\"P \\n {}\", P);\n}\n\nfn pivot(A: &Array2) -> Array2\nwhere T: NdFloat {\n let matrix_dimension = A.rows();\n let mut P: Array2 = Array::eye(matrix_dimension);\n for (i, column) in A.axis_iter(Axis(1)).enumerate() {\n \n let mut max_pos = i;\n for j in i..matrix_dimension {\n if column[max_pos].abs() < column[j].abs() {\n max_pos = j;\n }\n }\n \n if max_pos != i {\n swap_rows(&mut P, i, max_pos);\n }\n }\n P\n}\n\nfn swap_rows(A: &mut Array2, idx_row1: usize, idx_row2: usize)\nwhere T: NdFloat {\n \n \n let (.., mut matrix_rest) = A.view_mut().split_at(Axis(0), idx_row1);\n let (row0, mut matrix_rest) = matrix_rest.view_mut().split_at(Axis(0), 1);\n let (_matrix_helper, mut matrix_rest) = matrix_rest.view_mut().split_at(Axis(0), idx_row2 - idx_row1 - 1);\n let (row1, ..) = matrix_rest.view_mut().split_at(Axis(0), 1);\n Zip::from(row0).and(row1).apply(std::mem::swap);\n}\n\nfn lu_decomp(A: Array2) -> (Array2, Array2, Array2)\nwhere T: NdFloat {\n\n let matrix_dimension = A.rows();\n assert_eq!(matrix_dimension, A.cols(), \"Tried LU decomposition with a non-square matrix.\");\n let P = pivot(&A);\n let pivotized_A = P.dot(&A);\n\n let mut L: Array2 = Array::eye(matrix_dimension);\n let mut U: Array2 = Array::zeros((matrix_dimension, matrix_dimension));\n for idx_col in 0..matrix_dimension {\n \n for idx_row in 0..idx_col+1 {\n U[[idx_row, idx_col]] = pivotized_A[[idx_row, idx_col]] -\n U.slice(s![0..idx_row,idx_col]).dot(&L.slice(s![idx_row,0..idx_row]));\n }\n \n for idx_row in idx_col+1..matrix_dimension {\n L[[idx_row, idx_col]] = (pivotized_A[[idx_row, idx_col]] -\n U.slice(s![0..idx_col,idx_col]).dot(&L.slice(s![idx_row,0..idx_col]))) \/\n U[[idx_col, idx_col]];\n }\n }\n (L, U, P)\n}\n"} {"name":"Largest prime factor","C":"#include \n#include \n\nint isprime( long int n ) {\n int i=3;\n if(!(n%2)) return 0;\n while( i*i < n ) {\n if(!(n%i)) return 0;\n i+=2;\n }\n return 1;\n}\n\nint main(void) {\n long int n=600851475143, j=3;\n\n while(!isprime(n)) {\n if(!(n%j)) n\/=j;\n j+=2;\n }\n printf( \"%ld\\n\", n );\n return 0;\n}\n","Rust":"fn main( ) {\n let mut current : i64 = 600851475143 ;\n let mut latest_divisor : i64 = 2 ;\n while current != 1 {\n latest_divisor = 2 ;\n while current % latest_divisor != 0 {\n latest_divisor += 1 ;\n }\n current \/= latest_divisor ;\n }\n println!(\"{}\" , latest_divisor ) ;\n}\n"} {"name":"Left factorials","C":"#include \n#include \n#include \n#include \n\nvoid mpz_left_fac_ui(mpz_t rop, unsigned long op)\n{\n mpz_t t1;\n mpz_init_set_ui(t1, 1);\n mpz_set_ui(rop, 0);\n\n size_t i;\n for (i = 1; i <= op; ++i) {\n mpz_add(rop, rop, t1);\n mpz_mul_ui(t1, t1, i);\n }\n\n mpz_clear(t1);\n}\n\nsize_t mpz_digitcount(mpz_t op)\n{\n \n char *t = mpz_get_str(NULL, 10, op);\n size_t ret = strlen(t);\n free(t);\n return ret;\n}\n\nint main(void)\n{\n mpz_t t;\n mpz_init(t);\n size_t i;\n\n for (i = 0; i <= 110; ++i) {\n if (i <= 10 || i % 10 == 0) {\n mpz_left_fac_ui(t, i);\n gmp_printf(\"!%u = %Zd\\n\", i, t);\n }\n }\n\n for (i = 1000; i <= 10000; i += 1000) {\n mpz_left_fac_ui(t, i);\n printf(\"!%u has %u digits\\n\", i, mpz_digitcount(t));\n }\n\n mpz_clear(t);\n return 0;\n}\n","Rust":"#[cfg(target_pointer_width = \"64\")]\ntype USingle = u32;\n#[cfg(target_pointer_width = \"64\")]\ntype UDouble = u64;\n#[cfg(target_pointer_width = \"64\")]\nconst WORD_LEN: i32 = 32;\n\n#[cfg(not(target_pointer_width = \"64\"))]\ntype USingle = u16;\n#[cfg(not(target_pointer_width = \"64\"))]\ntype UDouble = u32;\n#[cfg(not(target_pointer_width = \"64\"))]\nconst WORD_LEN: i32 = 16;\n\nuse std::cmp;\n\n#[derive(Debug,Clone)]\nstruct BigNum {\n \n \n rep_: Vec,\n}\n\nimpl BigNum {\n pub fn new(n: USingle) -> BigNum {\n let mut result = BigNum { rep_: vec![] };\n if n > 0 { result.rep_.push(n); }\n result\n }\n pub fn equals(&self, n: USingle) -> bool {\n if n == 0 { return self.rep_.is_empty() }\n if self.rep_.len() > 1 { return false }\n self.rep_[0] == n\n }\n pub fn add_big(&self, addend: &BigNum) -> BigNum {\n let mut result = BigNum::new(0);\n let mut sum = 0 as UDouble;\n let sz1 = self.rep_.len();\n let sz2 = addend.rep_.len();\n for i in 0..cmp::max(sz1, sz2) {\n if i < sz1 { sum += self.rep_[i] as UDouble }\n if i < sz2 { sum += addend.rep_[i] as UDouble }\n result.rep_.push(sum as USingle);\n sum >>= WORD_LEN;\n }\n if sum > 0 { result.rep_.push(sum as USingle) }\n result\n }\n pub fn multiply(&self, factor: USingle) -> BigNum {\n let mut result = BigNum::new(0);\n let mut product = 0 as UDouble;\n for i in 0..self.rep_.len() {\n product += self.rep_[i] as UDouble * factor as UDouble;\n result.rep_.push(product as USingle);\n product >>= WORD_LEN;\n }\n if product > 0 {\n result.rep_.push(product as USingle);\n }\n result\n }\n pub fn divide(&self, divisor: USingle, quotient: &mut BigNum,\n remainder: &mut USingle) {\n quotient.rep_.truncate(0);\n let mut dividend: UDouble;\n *remainder = 0;\n for i in 0..self.rep_.len() {\n let j = self.rep_.len() - 1 - i;\n dividend = ((*remainder as UDouble) << WORD_LEN)\n + self.rep_[j] as UDouble;\n let quo = (dividend \/ divisor as UDouble) as USingle;\n *remainder = (dividend % divisor as UDouble) as USingle;\n if quo > 0 || j < self.rep_.len() - 1 {\n quotient.rep_.push(quo);\n }\n }\n quotient.rep_.reverse();\n }\n fn to_string(&self) -> String {\n let mut rep = String::new();\n let mut dividend = (*self).clone();\n let mut remainder = 0 as USingle;\n let mut quotient = BigNum::new(0);\n loop {\n dividend.divide(10, &mut quotient, &mut remainder);\n rep.push(('0' as USingle + remainder) as u8 as char);\n if quotient.equals(0) { break; }\n dividend = quotient.clone();\n }\n rep.chars().rev().collect::()\n }\n}\n\nuse std::fmt;\nimpl fmt::Display for BigNum {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{}\", self.to_string())\n }\n}\n\nfn lfact(n: USingle) -> BigNum {\n let mut result = BigNum::new(0);\n let mut f = BigNum::new(1);\n for k in 1 as USingle..n + 1 {\n result = result.add_big(&f);\n f = f.multiply(k);\n }\n result\n}\n\nfn main() {\n for i in 0..11 {\n println!(\"!{} = {}\", i, lfact(i));\n }\n for i in 2..12 {\n let j = i * 10;\n println!(\"!{} = {}\", j, lfact(j));\n }\n for i in 1..11 {\n let j = i * 1000;\n println!(\"!{} has {} digits.\", j, lfact(j).to_string().len());\n }\n}\n"} {"name":"Levenshtein distance_Alignment","C":"#include \n#include \n#include \n\ntypedef struct edit_s edit_t, *edit;\nstruct edit_s {\n\tchar c1, c2;\n\tint n;\n\tedit next;\n};\n\nvoid leven(char *a, char *b)\n{\n\tint i, j, la = strlen(a), lb = strlen(b);\n\tedit *tbl = malloc(sizeof(edit) * (1 + la));\n\ttbl[0] = calloc((1 + la) * (1 + lb), sizeof(edit_t));\n\tfor (i = 1; i <= la; i++)\n\t\ttbl[i] = tbl[i-1] + (1+lb);\n\n\tfor (i = la; i >= 0; i--) {\n\t\tchar *aa = a + i;\n\t\tfor (j = lb; j >= 0; j--) {\n\t\t\tchar *bb = b + j;\n\t\t\tif (!*aa && !*bb) continue;\n\n\t\t\tedit e = &tbl[i][j];\n\t\t\tedit repl = &tbl[i+1][j+1];\n\t\t\tedit dela = &tbl[i+1][j];\n\t\t\tedit delb = &tbl[i][j+1];\n\n\t\t\te->c1 = *aa;\n\t\t\te->c2 = *bb;\n\t\t\tif (!*aa) {\n\t\t\t\te->next = delb;\n\t\t\t\te->n = e->next->n + 1;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (!*bb) {\n\t\t\t\te->next = dela;\n\t\t\t\te->n = e->next->n + 1;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\te->next = repl;\n\t\t\tif (*aa == *bb) {\n\t\t\t\te->n = e->next->n;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif (e->next->n > delb->n) {\n\t\t\t\te->next = delb;\n\t\t\t\te->c1 = 0;\n\t\t\t}\n\t\t\tif (e->next->n > dela->n) {\n\t\t\t\te->next = dela;\n\t\t\t\te->c1 = *aa;\n\t\t\t\te->c2 = 0;\n\t\t\t}\n\t\t\te->n = e->next->n + 1;\n\t\t}\n\t}\n\n\tedit p = tbl[0];\n\tprintf(\"%s -> %s: %d edits\\n\", a, b, p->n);\n\n\twhile (p->next) {\n\t\tif (p->c1 == p->c2)\n\t\t\tprintf(\"%c\", p->c1);\n\t\telse {\n\t\t\tputchar('(');\n\t\t\tif (p->c1) putchar(p->c1);\n\t\t\tputchar(',');\n\t\t\tif (p->c2) putchar(p->c2);\n\t\t\tputchar(')');\n\t\t}\n\n\t\tp = p->next;\n\t}\n\tputchar('\\n');\n\n\tfree(tbl[0]);\n\tfree(tbl);\n}\n\nint main(void)\n{\n\tleven(\"raisethysword\", \"rosettacode\");\n\treturn 0;\n}\n","Rust":"extern crate edit_distance;\n\nedit_distance(\"rosettacode\", \"raisethysword\");\n"} {"name":"Line circle intersection","C":"#include \n#include \n#include \n\nconst double eps = 1e-14;\n\ntypedef struct point_t {\n double x, y;\n} point;\n\npoint make_point(double x, double y) {\n point p = { x, y };\n return p;\n}\n\nvoid print_point(point p) {\n double x = p.x;\n double y = p.y;\n if (x == 0) {\n x = 0;\n }\n if (y == 0) {\n y = 0;\n }\n printf(\"(%g, %g)\", x, y);\n}\n\ndouble sq(double x) {\n return x * x;\n}\n\nbool within(double x1, double y1, double x2, double y2, double x, double y) {\n double d1 = sqrt(sq(x2 - x1) + sq(y2 - y1)); \n double d2 = sqrt(sq(x - x1) + sq(y - y1)); \n double d3 = sqrt(sq(x2 - x) + sq(y2 - y)); \n double delta = d1 - d2 - d3;\n return fabs(delta) < eps; \n}\n\nint rxy(double x1, double y1, double x2, double y2, double x, double y, bool segment) {\n if (!segment || within(x1, y1, x2, y2, x, y)) {\n print_point(make_point(x, y));\n return 1;\n } else {\n return 0;\n }\n}\n\ndouble fx(double A, double B, double C, double x) {\n return -(A * x + C) \/ B;\n}\n\ndouble fy(double A, double B, double C, double y) {\n return -(B * y + C) \/ A;\n}\n\n\n\n\nvoid intersects(point p1, point p2, point cp, double r, bool segment) {\n double x0 = cp.x, y0 = cp.y;\n double x1 = p1.x, y1 = p1.y;\n double x2 = p2.x, y2 = p2.y;\n double A = y2 - y1;\n double B = x1 - x2;\n double C = x2 * y1 - x1 * y2;\n double a = sq(A) + sq(B);\n double b, c, d;\n bool bnz = true;\n int cnt = 0;\n\n if (fabs(B) >= eps) {\n \n b = 2 * (A * C + A * B * y0 - sq(B) * x0);\n c = sq(C) + 2 * B * C * y0 - sq(B) * (sq(r) - sq(x0) - sq(y0));\n } else {\n b = 2 * (B * C + A * B * x0 - sq(A) * y0);\n c = sq(C) + 2 * A * C * x0 - sq(A) * (sq(r) - sq(x0) - sq(y0));\n bnz = false;\n }\n d = sq(b) - 4 * a * c; \n if (d < 0) {\n \n printf(\"[]\\n\");\n return;\n }\n\n if (d == 0) {\n \n if (bnz) {\n double x = -b \/ (2 * a);\n double y = fx(A, B, C, x);\n cnt = rxy(x1, y1, x2, y2, x, y, segment);\n } else {\n double y = -b \/ (2 * a);\n double x = fy(A, B, C, y);\n cnt = rxy(x1, y1, x2, y2, x, y, segment);\n }\n } else {\n \n d = sqrt(d);\n if (bnz) {\n double x = (-b + d) \/ (2 * a);\n double y = fx(A, B, C, x);\n cnt = rxy(x1, y1, x2, y2, x, y, segment);\n\n x = (-b - d) \/ (2 * a);\n y = fx(A, B, C, x);\n cnt += rxy(x1, y1, x2, y2, x, y, segment);\n } else {\n double y = (-b + d) \/ (2 * a);\n double x = fy(A, B, C, y);\n cnt = rxy(x1, y1, x2, y2, x, y, segment);\n\n y = (-b - d) \/ (2 * a);\n x = fy(A, B, C, y);\n cnt += rxy(x1, y1, x2, y2, x, y, segment);\n }\n }\n\n if (cnt <= 0) {\n printf(\"[]\");\n }\n}\n\nint main() {\n point cp = make_point(3, -5);\n double r = 3.0;\n printf(\"The intersection points (if any) between:\\n\");\n printf(\" A circle, center (3, -5) with radius 3, and:\\n\");\n printf(\" a line containing the points (-10, 11) and (10, -9) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(-10, 11), make_point(10, -9), cp, r, false);\n printf(\"\\n a segment starting at (-10, 11) and ending at (-11, 12) is\/are\\n\");\n printf(\" \");\n intersects(make_point(-10, 11), make_point(-11, 12), cp, r, true);\n printf(\"\\n a horizontal line containing the points (3, -2) and (7, -2) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(3, -2), make_point(7, -2), cp, r, false);\n printf(\"\\n\");\n\n cp = make_point(0, 0);\n r = 4.0;\n printf(\" A circle, center (0, 0) with radius 4, and:\\n\");\n printf(\" a vertical line containing the points (0, -3) and (0, 6) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(0, -3), make_point(0, 6), cp, r, false);\n printf(\"\\n a vertical segment starting at (0, -3) and ending at (0, 6) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(0, -3), make_point(0, 6), cp, r, true);\n printf(\"\\n\");\n\n cp = make_point(4,2);\n r = 5.0;\n printf(\" A circle, center (4, 2) with radius 5, and:\\n\");\n printf(\" a line containing the points (6, 3) and (10, 7) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(6, 3), make_point(10, 7), cp, r, false);\n printf(\"\\n a segment starting at (7, 4) and ending at (11, 8) is\/are:\\n\");\n printf(\" \");\n intersects(make_point(7, 4), make_point(11, 8), cp, r, true);\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"use assert_approx_eq::assert_approx_eq;\n\nconst EPS: f64 = 1e-14;\n\npub struct Point {\n x: f64,\n y: f64,\n}\n\npub struct Line {\n p1: Point,\n p2: Point,\n}\n\nimpl Line {\n pub fn circle_intersections(&self, mx: f64, my: f64, r: f64, segment: bool) -> Vec {\n let mut intersections: Vec = Vec::new();\n\n let x0 = mx;\n let y0 = my;\n let x1 = self.p1.x;\n let y1 = self.p1.y;\n let x2 = self.p2.x;\n let y2 = self.p2.y;\n\n let ca = y2 - y1;\n let cb = x1 - x2;\n let cc = x2 * y1 - x1 * y2;\n\n let a = ca.powi(2) + cb.powi(2);\n let mut b = 0.0;\n let mut c = 0.0;\n let mut bnz = true;\n\n if cb.abs() >= EPS {\n b = 2.0 * (ca * cc + ca * cb * y0 - cb.powi(2) * x0);\n c = cc.powi(2) + 2.0 * cb * cc * y0\n - cb.powi(2) * (r.powi(2) - x0.powi(2) - y0.powi(2));\n } else {\n b = 2.0 * (cb * cc + ca * cb * x0 - ca.powi(2) * y0);\n c = cc.powi(2) + 2.0 * ca * cc * x0\n - ca.powi(2) * (r.powi(2) - x0.powi(2) - y0.powi(2));\n bnz = false;\n }\n let mut d = b.powi(2) - 4.0 * a * c;\n if d < 0.0 {\n return intersections;\n }\n\n fn within(x: f64, y: f64, x1: f64, y1: f64, x2: f64, y2: f64) -> bool {\n let d1 = ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt(); \n let d2 = ((x - x1).powi(2) + (y - y1).powi(2)).sqrt(); \n let d3 = ((x2 - x).powi(2) + (y2 - y).powi(2)).sqrt(); \n let delta = d1 - d2 - d3;\n return delta.abs() < EPS;\n }\n\n fn fx(x: f64, ca: f64, cb: f64, cc: f64) -> f64 {\n -(ca * x + cc) \/ cb\n }\n\n fn fy(y: f64, ca: f64, cb: f64, cc: f64) -> f64 {\n -(cb * y + cc) \/ ca\n }\n\n fn rxy(\n x: f64,\n y: f64,\n x1: f64,\n y1: f64,\n x2: f64,\n y2: f64,\n segment: bool,\n intersections: &mut Vec,\n ) {\n if !segment || within(x, y, x1, y1, x2, y2) {\n let point = Point { x: x, y: y };\n intersections.push(point);\n }\n }\n\n if d == 0.0 {\n if bnz {\n let x = -b \/ (2.0 * a);\n let y = fx(x, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n } else {\n let y = -b \/ (2.0 * a);\n let x = fy(y, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n }\n } else {\n d = d.sqrt();\n if bnz {\n let x = (-b + d) \/ (2.0 * a);\n let y = fx(x, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n let x = (-b - d) \/ (2.0 * a);\n let y = fx(x, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n } else {\n let y = (-b + d) \/ (2.0 * a);\n let x = fy(y, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n let y = (-b - d) \/ (2.0 * a);\n let x = fy(y, ca, cb, cc);\n rxy(x, y, x1, y1, x2, y2, segment, &mut intersections);\n }\n }\n\n intersections.sort_unstable_by(|a, b| a.x.partial_cmp(&b.x).unwrap());\n intersections\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_circle_line_intersections() {\n let mut p1 = Point { x: -10.0, y: 11.0 };\n let mut p2 = Point { x: 10.0, y: -9.0 };\n let mut line = Line { p1: p1, p2: p2 };\n\n let result1 = line.circle_intersections(3.0, -5.0, 3.0, false);\n assert_eq!(result1.len(), 2);\n assert_approx_eq!(result1[0].x, 3.0);\n assert_approx_eq!(result1[0].y, -2.0);\n assert_approx_eq!(result1[1].x, 6.0);\n assert_approx_eq!(result1[1].y, -5.0);\n\n p1 = Point { x: -10.0, y: 11.0 };\n p2 = Point { x: -11.0, y: -12.0 };\n line = Line { p1: p1, p2: p2 };\n let result2 = line.circle_intersections(3.0, -5.0, 3.0, true);\n assert_eq!(result2.len(), 0);\n\n p1 = Point { x: 3.0, y: -2.0 };\n p2 = Point { x: 7.0, y: -2.0 };\n line = Line { p1, p2 };\n let result3 = line.circle_intersections(3.0, -5.0, 3.0, true);\n assert_eq!(result3.len(), 1);\n assert_approx_eq!(result3[0].x, 3.0);\n assert_approx_eq!(result3[0].y, -2.0);\n\n p1 = Point { x: 0.0, y: -3.0 };\n p2 = Point { x: 0.0, y: 6.0 };\n line = Line { p1, p2 };\n let result4 = line.circle_intersections(0.0, 0.0, 4.0, false);\n assert_eq!(result4.len(), 2);\n assert_approx_eq!(result4[0].x, 0.0);\n assert_approx_eq!(result4[1].x, 0.0);\n\n let result5 = line.circle_intersections(0.0, 0.0, 4.0, true);\n assert_eq!(result5.len(), 1);\n\n p1 = Point { x: 6.0, y: 3.0 };\n p2 = Point { x: 10.0, y: 7.0 };\n line = Line { p1, p2 };\n let result6 = line.circle_intersections(4.0, 2.0, 5.0, false);\n assert_eq!(result6.len(), 2);\n assert_approx_eq!(result6[0].x, 1.0);\n assert_approx_eq!(result6[0].y, -2.0);\n assert_approx_eq!(result6[1].x, 8.0);\n assert_approx_eq!(result6[1].y, 5.0);\n\n p1 = Point { x: 7.0, y: 4.0 };\n p2 = Point { x: 11.0, y: 8.0 };\n line = Line { p1, p2 };\n let result7 = line.circle_intersections(4.0, 2.0, 5.0, true);\n assert_eq!(result7.len(), 1);\n assert_approx_eq!(result7[0].x, 8.0);\n assert_approx_eq!(result7[0].y, 5.0);\n }\n}\n"} {"name":"Long primes","C":"#include \n#include \n \n#define TRUE 1\n#define FALSE 0\n \ntypedef int bool;\n \nvoid sieve(int limit, int primes[], int *count) {\n bool *c = calloc(limit + 1, sizeof(bool)); \n \n int i, p = 3, p2, n = 0;\n p2 = p * p;\n while (p2 <= limit) {\n for (i = p2; i <= limit; i += 2 * p) \n c[i] = TRUE;\n do {\n p += 2;\n } while (c[p]);\n p2 = p * p;\n }\n for (i = 3; i <= limit; i += 2) {\n if (!c[i]) primes[n++] = i;\n }\n *count = n;\n free(c);\n}\n \n\nint findPeriod(int n) {\n int i, r = 1, rr, period = 0;\n for (i = 1; i <= n + 1; ++i) {\n r = (10 * r) % n;\n }\n rr = r;\n do {\n r = (10 * r) % n;\n period++;\n } while (r != rr);\n return period;\n}\n \nint main() {\n int i, prime, count = 0, index = 0, primeCount, longCount = 0, numberCount;\n int *primes, *longPrimes, *totals;\n int numbers[] = {500, 1000, 2000, 4000, 8000, 16000, 32000, 64000};\n \n primes = calloc(6500, sizeof(int));\n numberCount = sizeof(numbers) \/ sizeof(int);\n totals = calloc(numberCount, sizeof(int));\n sieve(64000, primes, &primeCount);\n longPrimes = calloc(primeCount, sizeof(int)); \n \n for (i = 0; i < primeCount; ++i) {\n prime = primes[i];\n if (findPeriod(prime) == prime - 1) {\n longPrimes[longCount++] = prime;\n }\n }\n for (i = 0; i < longCount; ++i, ++count) {\n if (longPrimes[i] > numbers[index]) {\n totals[index++] = count;\n }\n }\n totals[numberCount - 1] = count;\n printf(\"The long primes up to %d are:\\n\", numbers[0]);\n printf(\"[\");\n for (i = 0; i < totals[0]; ++i) {\n printf(\"%d \", longPrimes[i]);\n }\n printf(\"\\b]\\n\");\n \n printf(\"\\nThe number of long primes up to:\\n\");\n for (i = 0; i < 8; ++i) {\n printf(\" %5d is %d\\n\", numbers[i], totals[i]);\n }\n free(totals);\n free(longPrimes);\n free(primes);\n return 0;\n}\n","Rust":"\n\n\n\n\nmod bit_array;\nmod prime_sieve;\n\nuse prime_sieve::PrimeSieve;\n\nfn modpow(mut base: usize, mut exp: usize, n: usize) -> usize {\n if n == 1 {\n return 0;\n }\n let mut result = 1;\n base %= n;\n while exp > 0 {\n if (exp & 1) == 1 {\n result = (result * base) % n;\n }\n base = (base * base) % n;\n exp >>= 1;\n }\n result\n}\n\nfn is_long_prime(sieve: &PrimeSieve, prime: usize) -> bool {\n if !sieve.is_prime(prime) {\n return false;\n }\n if 10 % prime == 0 {\n return false;\n }\n let n = prime - 1;\n let mut m = n;\n let mut p = 2;\n while p * p <= n {\n if sieve.is_prime(p) && m % p == 0 {\n if modpow(10, n \/ p, prime) == 1 {\n return false;\n }\n while m % p == 0 {\n m \/= p;\n }\n }\n p += 1;\n }\n if m == 1 {\n return true;\n }\n modpow(10, n \/ m, prime) != 1\n}\n\nfn long_primes(limit1: usize, limit2: usize) {\n let sieve = PrimeSieve::new(limit2);\n let mut count = 0;\n let mut limit = limit1;\n let mut prime = 3;\n while prime < limit2 {\n if is_long_prime(&sieve, prime) {\n if prime < limit1 {\n print!(\"{} \", prime);\n }\n if prime > limit {\n print!(\"\\nNumber of long primes up to {}: {}\", limit, count);\n limit *= 2;\n }\n count += 1;\n }\n prime += 2;\n }\n println!(\"\\nNumber of long primes up to {}: {}\", limit, count);\n}\n\nfn main() {\n long_primes(500, 8192000);\n}\n"} {"name":"Longest increasing subsequence","C":"#include \n#include \n\nstruct node {\n\tint val, len;\n\tstruct node *next;\n};\n\nvoid lis(int *v, int len)\n{\n\tint i;\n\tstruct node *p, *n = calloc(len, sizeof *n);\n\tfor (i = 0; i < len; i++)\n\t\tn[i].val = v[i];\n\n\tfor (i = len; i--; ) {\n\t\t\n\t\tfor (p = n + i; p++ < n + len; ) {\n\t\t\tif (p->val > n[i].val && p->len >= n[i].len) {\n\t\t\t\tn[i].next = p;\n\t\t\t\tn[i].len = p->len + 1;\n\t\t\t}\n\t\t}\n\t}\n\n\t\n\tfor (i = 0, p = n; i < len; i++)\n\t\tif (n[i].len > p->len) p = n + i;\n\n\tdo printf(\" %d\", p->val); while ((p = p->next));\n\tputchar('\\n');\n\n\tfree(n);\n}\n\nint main(void)\n{\n\tint x[] = { 3, 2, 6, 4, 5, 1 };\n\tint y[] = { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };\n\n\tlis(x, sizeof(x) \/ sizeof(int));\n\tlis(y, sizeof(y) \/ sizeof(int));\n\treturn 0;\n}\n","Rust":"fn lis(x: &[i32])-> Vec {\n let n = x.len();\n let mut m = vec![0; n];\n let mut p = vec![0; n];\n let mut l = 0;\n\n for i in 0..n {\n let mut lo = 1;\n let mut hi = l;\n\n while lo <= hi {\n let mid = (lo + hi) \/ 2;\n\n if x[m[mid]] <= x[i] {\n lo = mid + 1;\n } else {\n hi = mid - 1;\n }\n }\n\n let new_l = lo;\n p[i] = m[new_l - 1];\n m[new_l] = i;\n\n if new_l > l {\n l = new_l;\n }\n }\n\n let mut o = vec![0; l];\n let mut k = m[l];\n for i in (0..l).rev() {\n o[i] = x[k];\n k = p[k];\n }\n\n o\n}\n\nfn main() {\n let list = vec![3, 2, 6, 4, 5, 1];\n println!(\"{:?}\", lis(&list));\n let list = vec![0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];\n println!(\"{:?}\", lis(&list));\n}\n"} {"name":"Loops_Infinite","C":"while(1) puts(\"SPAM\");\n","Rust":"fn main() {\n loop {\n println!(\"SPAM\");\n }\n}\n"} {"name":"Machine code","C":"#include \n#include \n#include \n\nint test (int a, int b)\n{\n \n char code[] = {0x8B, 0x44, 0x24, 0x4, 0x3, 0x44, 0x24, 0x8, 0xC3};\n void *buf;\n int c;\n \n buf = mmap (0,sizeof(code),PROT_READ|PROT_WRITE|PROT_EXEC,\n MAP_PRIVATE|MAP_ANON,-1,0);\n\n memcpy (buf, code, sizeof(code));\n \n c = ((int (*) (int, int))buf)(a, b);\n \n munmap (buf, sizeof(code));\n return c;\n}\n\nint main ()\n{\n printf(\"%d\\n\", test(7,12));\n return 0;\n}\n","Rust":"extern crate libc;\n\n#[cfg(all(\n target_os = \"linux\",\n any(target_pointer_width = \"32\", target_pointer_width = \"64\")\n))]\nfn main() {\n use std::mem;\n use std::ptr;\n\n let page_size: usize = 4096;\n let (bytes, size): (Vec, usize) = if cfg!(target_pointer_width = \"32\") {\n (\n vec![0x8b, 0x44, 0x24, 0x04, 0x03, 0x44, 0x24, 0x08, 0xc3],\n 9,\n )\n } else {\n (vec![0x48, 0x89, 0xf8, 0x48, 0x01, 0xf0, 0xc3], 7)\n };\n let f: fn(u8, u8) -> u8 = unsafe {\n let mut page: *mut libc::c_void = ptr::null_mut();\n libc::posix_memalign(&mut page, page_size, size);\n libc::mprotect(\n page,\n size,\n libc::PROT_EXEC | libc::PROT_READ | libc::PROT_WRITE,\n );\n let contents: *mut u8 = page as *mut u8;\n ptr::copy(bytes.as_ptr(), contents, 9);\n mem::transmute(contents)\n };\n\n let return_value = f(7, 12);\n println!(\"Returned value: {}\", return_value);\n assert_eq!(return_value, 19);\n}\n\n#[cfg(any(\n not(target_os = \"linux\"),\n not(any(target_pointer_width = \"32\", target_pointer_width = \"64\"))\n))]\nfn main() {\n println!(\"Not supported on this platform.\");\n}\n"} {"name":"Magic squares of doubly even order","C":"#include\n#include\n#include\n\nint** doublyEvenMagicSquare(int n) {\n\tif (n < 4 || n % 4 != 0)\n\t\treturn NULL;\n\n\tint bits = 38505;\n\tint size = n * n;\n\tint mult = n \/ 4,i,r,c,bitPos;\n\n\tint** result = (int**)malloc(n*sizeof(int*));\n\t\n\tfor(i=0;i=10){\n\t\tn \/= 10;\n\t\tcount++;\n\t}\n\t\n\treturn count;\n}\n\nvoid printMagicSquare(int** square,int rows){\n\tint i,j,baseWidth = numDigits(rows*rows) + 3;\n\t\n\tprintf(\"Doubly Magic Square of Order\u00a0: %d and Magic Constant\u00a0: %d\\n\\n\",rows,(rows * rows + 1) * rows \/ 2);\n\t\n\tfor(i=0;i\",argV[0]);\n\telse{\n\t\tn = atoi(argV[1]);\n\t\tprintMagicSquare(doublyEvenMagicSquare(n),n);\n\t}\n\treturn 0;\n}\n","Rust":"use std::env;\n\nfn main() {\n let n: usize = match env::args()\n .nth(1)\n .and_then(|arg| arg.parse().ok())\n .ok_or(\"Please specify the size of the magic square, as a positive multiple of 4.\")\n {\n Ok(arg) if arg >= 4 && arg % 4 == 0 => arg,\n Err(e) => panic!(e),\n _ => panic!(\"Argument must be a positive multiple of 4.\"),\n };\n\n let mc = (n * n + 1) * n \/ 2;\n println!(\"Magic constant: {}\\n\", mc);\n let bits = 0b1001_0110_0110_1001u32;\n let size = n * n;\n let width = size.to_string().len() + 1;\n let mult = n \/ 4;\n let mut i = 0;\n for r in 0..n {\n for c in 0..n {\n let bit_pos = c \/ mult + (r \/ mult) * 4;\n print!(\n \"{e:>w$}\",\n e = if bits & (1 << bit_pos) != 0 {\n i + 1\n } else {\n size - i\n },\n w = width\n );\n i += 1;\n }\n println!();\n }\n}\n"} {"name":"Magic squares of singly even order","C":" #include\n #include\n #include\n \n int** oddMagicSquare(int n) {\n if (n < 3 || n % 2 == 0)\n return NULL;\n \n int value = 0;\n int squareSize = n * n;\n int c = n \/ 2, r = 0,i;\n \n int** result = (int**)malloc(n*sizeof(int*));\n\t\t\n\t\tfor(i=0;i= n - nColsRight\n || (c == nColsLeft && r == nColsLeft)) {\n \n if (c == 0 && r == nColsLeft)\n continue;\n \n int tmp = result[r][c];\n result[r][c] = result[r + halfN][c];\n result[r + halfN][c] = tmp;\n }\n }\n \n return result;\n }\n\t\n\tint numDigits(int n){\n\t\tint count = 1;\n\t\t\n\t\twhile(n>=10){\n\t\t\tn \/= 10;\n\t\t\tcount++;\n\t\t}\n\t\t\n\t\treturn count;\n\t}\n\t\n\tvoid printMagicSquare(int** square,int rows){\n\t\tint i,j;\n\t\t\n\t\tfor(i=0;i\",argV[0]);\n\t\telse{\n\t\t\tn = atoi(argV[1]);\n\t\t\tprintMagicSquare(singlyEvenMagicSquare(n),n);\n\t\t}\n\t\treturn 0;\n\t}\n","Rust":"use std::env;\n\nfn main() {\n let n: usize =\n match env::args().nth(1).and_then(|arg| arg.parse().ok()).ok_or(\n \"Please specify the size of the magic square, as a positive multiple of 4 plus 2.\",\n ) {\n Ok(arg) if arg % 2 == 1 || arg >= 6 && (arg - 2) % 4 == 0 => arg,\n Err(e) => panic!(e),\n _ => panic!(\"Argument must be a positive multiple of 4 plus 2.\"),\n };\n\n let (ms, mc) = magic_square_singly_even(n);\n println!(\"n: {}\", n);\n println!(\"Magic constant: {}\\n\", mc);\n let width = (n * n).to_string().len() + 1;\n for row in ms {\n for elem in row {\n print!(\"{e:>w$}\", e = elem, w = width);\n }\n println!();\n }\n}\n\nfn magic_square_singly_even(n: usize) -> (Vec>, usize) {\n let size = n * n;\n let half = n \/ 2;\n let sub_square_size = size \/ 4;\n let sub_square = magic_square_odd(half);\n let quadrant_factors = [0, 2, 3, 1];\n let cols_left = half \/ 2;\n let cols_right = cols_left - 1;\n\n let ms = (0..n)\n .map(|r| {\n (0..n)\n .map(|c| {\n let localr = if (c < cols_left\n || c >= n - cols_right\n || c == cols_left && r % half == cols_left)\n && !(c == 0 && r % half == cols_left)\n {\n if r >= half {\n r - half\n } else {\n r + half\n }\n } else {\n r\n };\n let quadrant = localr \/ half * 2 + c \/ half;\n let v = sub_square[localr % half][c % half];\n v + quadrant_factors[quadrant] * sub_square_size\n })\n .collect()\n })\n .collect::>>();\n (ms, (n * n + 1) * n \/ 2)\n}\n\nfn magic_square_odd(n: usize) -> Vec> {\n (0..n)\n .map(|r| {\n (0..n)\n .map(|c| {\n n * (((c + 1) + (r + 1) - 1 + (n >> 1)) % n)\n + (((c + 1) + (2 * (r + 1)) - 2) % n)\n + 1\n })\n .collect::>()\n })\n .collect::>>()\n}\n"} {"name":"Magnanimous numbers","C":"#include \n#include \n\ntypedef int bool;\ntypedef unsigned long long ull;\n\n#define TRUE 1\n#define FALSE 0\n\n\nbool is_prime(ull n) {\n ull d;\n if (n < 2) return FALSE;\n if (!(n % 2)) return n == 2;\n if (!(n % 3)) return n == 3;\n d = 5;\n while (d * d <= n) {\n if (!(n % d)) return FALSE;\n d += 2;\n if (!(n % d)) return FALSE;\n d += 4;\n }\n return TRUE;\n}\n\nvoid ord(char *res, int n) {\n char suffix[3];\n int m = n % 100;\n if (m >= 4 && m <= 20) {\n sprintf(res,\"%dth\", n);\n return;\n }\n switch(m % 10) {\n case 1:\n strcpy(suffix, \"st\");\n break;\n case 2:\n strcpy(suffix, \"nd\");\n break;\n case 3:\n strcpy(suffix, \"rd\");\n break;\n default:\n strcpy(suffix, \"th\");\n break;\n }\n sprintf(res, \"%d%s\", n, suffix);\n}\n\nbool is_magnanimous(ull n) {\n ull p, q, r;\n if (n < 10) return TRUE;\n for (p = 10; ; p *= 10) {\n q = n \/ p;\n r = n % p;\n if (!is_prime(q + r)) return FALSE;\n if (q < 10) break;\n }\n return TRUE;\n}\n\nvoid list_mags(int from, int thru, int digs, int per_line) {\n ull i = 0;\n int c = 0;\n char res1[13], res2[13];\n if (from < 2) {\n printf(\"\\nFirst %d magnanimous numbers:\\n\", thru);\n } else {\n ord(res1, from);\n ord(res2, thru);\n printf(\"\\n%s through %s magnanimous numbers:\\n\", res1, res2);\n }\n for ( ; c < thru; ++i) {\n if (is_magnanimous(i)) {\n if (++c >= from) {\n printf(\"%*llu \", digs, i);\n if (!(c % per_line)) printf(\"\\n\");\n }\n }\n }\n}\n \nint main() {\n list_mags(1, 45, 3, 15);\n list_mags(241, 250, 1, 10);\n list_mags(391, 400, 1, 10);\n return 0;\n}\n","Rust":"fn is_prime(n: u32) -> bool {\n if n < 2 {\n return false;\n }\n if n % 2 == 0 {\n return n == 2;\n }\n if n % 3 == 0 {\n return n == 3;\n }\n let mut p = 5;\n while p * p <= n {\n if n % p == 0 {\n return false;\n }\n p += 2;\n if n % p == 0 {\n return false;\n }\n p += 4;\n }\n true\n}\n\nfn is_magnanimous(n: u32) -> bool {\n let mut p: u32 = 10;\n while n >= p {\n if !is_prime(n % p + n \/ p) {\n return false;\n }\n p *= 10;\n }\n true\n}\n\nfn main() {\n let mut m = (0..).filter(|x| is_magnanimous(*x)).take(400);\n println!(\"First 45 magnanimous numbers:\");\n for (i, n) in m.by_ref().take(45).enumerate() {\n if i > 0 && i % 15 == 0 {\n println!();\n }\n print!(\"{:3} \", n);\n }\n println!(\"\\n\\n241st through 250th magnanimous numbers:\");\n for n in m.by_ref().skip(195).take(10) {\n print!(\"{} \", n);\n }\n println!(\"\\n\\n391st through 400th magnanimous numbers:\");\n for n in m.by_ref().skip(140) {\n print!(\"{} \", n);\n }\n println!();\n}\n"} {"name":"Main step of GOST 28147-89","C":"static unsigned char const k8[16] = {\t14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 }; \nstatic unsigned char const k7[16] = {\t15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };\nstatic unsigned char const k6[16] = {\t10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };\nstatic unsigned char const k5[16] = {\t 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 };\nstatic unsigned char const k4[16] = {\t 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 };\nstatic unsigned char const k3[16] = {\t12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 };\nstatic unsigned char const k2[16] = {\t 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };\nstatic unsigned char const k1[16] = {\t13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };\n\nstatic unsigned char k87[256];\nstatic unsigned char k65[256];\nstatic unsigned char k43[256];\nstatic unsigned char k21[256];\n\nvoid\nkboxinit(void)\n{\n\tint i;\n\tfor (i = 0; i < 256; i++) {\n\t\tk87[i] = k8[i >> 4] << 4 | k7[i & 15];\n\t\tk65[i] = k6[i >> 4] << 4 | k5[i & 15];\n\t\tk43[i] = k4[i >> 4] << 4 | k3[i & 15];\n\t\tk21[i] = k2[i >> 4] << 4 | k1[i & 15];\n\t}\n}\n\nstatic word32\nf(word32 x)\n{\n\tx = k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 |\n\t k43[x>> 8 & 255] << 8 | k21[x & 255];\n\treturn x<<11 | x>>(32-11);\n}\n","Rust":"use std::convert::TryInto;\nuse std::env;\nuse std::num::Wrapping;\n\nconst REPLACEMENT_TABLE: [[u8; 16]; 8] = [\n [4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],\n [14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9],\n [5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11],\n [7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3],\n [6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2],\n [4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14],\n [13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12],\n [1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12],\n];\nconst KEYS: [u32; 8] = [\n 0xE2C1_04F9,\n 0xE41D_7CDE,\n 0x7FE5_E857,\n 0x0602_65B4,\n 0x281C_CC85,\n 0x2E2C_929A,\n 0x4746_4503,\n 0xE00_CE510,\n];\n\nfn main() {\n let args: Vec = env::args().collect();\n if args.len() < 2 {\n let plain_text: Vec = vec![0x04, 0x3B, 0x04, 0x21, 0x04, 0x32, 0x04, 0x30];\n println!(\n \"Before one step: {}\\n\",\n plain_text\n .iter()\n .cloned()\n .fold(\"\".to_string(), |b, y| b + &format!(\"{:02X} \", y))\n );\n let encoded_text = main_step(plain_text, KEYS[0]);\n println!(\n \"After one step\u00a0: {}\\n\",\n encoded_text\n .iter()\n .cloned()\n .fold(\"\".to_string(), |b, y| b + &format!(\"{:02X} \", y))\n );\n } else {\n let mut t = args[1].clone(); \n t += &\" \".repeat((8 - t.len() % 8) % 8);\n let text_bytes = t.bytes().collect::>();\n let plain_text = text_bytes.chunks(8).collect::>();\n println!(\n \"Plain text \u00a0: {}\\n\",\n plain_text.iter().cloned().fold(\"\".to_string(), |a, x| a\n + \"[\"\n + &x.iter()\n .fold(\"\".to_string(), |b, y| b + &format!(\"{:02X} \", y))[..23]\n + \"]\")\n );\n let encoded_text = plain_text\n .iter()\n .map(|c| encode(c.to_vec()))\n .collect::>();\n println!(\n \"Encoded text: {}\\n\",\n encoded_text.iter().cloned().fold(\"\".to_string(), |a, x| a\n + \"[\"\n + &x.into_iter()\n .fold(\"\".to_string(), |b, y| b + &format!(\"{:02X} \", y))[..23]\n + \"]\")\n );\n let decoded_text = encoded_text\n .iter()\n .map(|c| decode(c.to_vec()))\n .collect::>();\n println!(\n \"Decoded text: {}\\n\",\n decoded_text.iter().cloned().fold(\"\".to_string(), |a, x| a\n + \"[\"\n + &x.into_iter()\n .fold(\"\".to_string(), |b, y| b + &format!(\"{:02X} \", y))[..23]\n + \"]\")\n );\n let recovered_text =\n String::from_utf8(decoded_text.iter().cloned().flatten().collect::>()).unwrap();\n println!(\"Recovered text: {}\\n\", recovered_text);\n }\n}\n\nfn encode(text_block: Vec) -> Vec {\n let mut step = text_block;\n for i in 0..24 {\n step = main_step(step, KEYS[i % 8]);\n }\n for i in (0..8).rev() {\n step = main_step(step, KEYS[i]);\n }\n step\n}\n\nfn decode(text_block: Vec) -> Vec {\n let mut step = text_block[4..].to_vec();\n let mut temp = text_block[..4].to_vec();\n step.append(&mut temp);\n for key in &KEYS {\n step = main_step(step, *key);\n }\n for i in (0..24).rev() {\n step = main_step(step, KEYS[i % 8]);\n }\n let mut ans = step[4..].to_vec();\n let mut temp = step[..4].to_vec();\n ans.append(&mut temp);\n ans\n}\n\nfn main_step(text_block: Vec, key_element: u32) -> Vec {\n let mut n = text_block;\n let mut s = (Wrapping(\n u32::from(n[0]) << 24 | u32::from(n[1]) << 16 | u32::from(n[2]) << 8 | u32::from(n[3]),\n ) + Wrapping(key_element))\n .0;\n let mut new_s: u32 = 0;\n for mid in 0..4 {\n let cell = (s >> (mid << 3)) & 0xFF;\n new_s += (u32::from(REPLACEMENT_TABLE[(mid * 2) as usize][(cell & 0x0f) as usize])\n + (u32::from(REPLACEMENT_TABLE[(mid * 2 + 1) as usize][(cell >> 4) as usize]) << 4))\n << (mid << 3);\n }\n s = ((new_s << 11) + (new_s >> 21))\n ^ (u32::from(n[4]) << 24 | u32::from(n[5]) << 16 | u32::from(n[6]) << 8 | u32::from(n[7]));\n n[4] = n[0];\n n[5] = n[1];\n n[6] = n[2];\n n[7] = n[3];\n n[0] = (s >> 24).try_into().unwrap();\n n[1] = ((s >> 16) & 0xFF).try_into().unwrap();\n n[2] = ((s >> 8) & 0xFF).try_into().unwrap();\n n[3] = (s & 0xFF).try_into().unwrap();\n n\n}\n"} {"name":"Mayan numerals","C":"#include \n#include \n#include \n#include \n\n#define MAX(x,y) ((x) > (y)\u00a0? (x)\u00a0: (y))\n#define MIN(x,y) ((x) < (y)\u00a0? (x)\u00a0: (y)) \n\n\nsize_t base20(unsigned int n, uint8_t *out) {\n \n uint8_t *start = out;\n do {*out++ = n % 20;} while (n \/= 20);\n size_t length = out - start;\n \n \n while (out > start) {\n uint8_t x = *--out;\n *out = *start;\n *start++ = x;\n }\n return length;\n}\n\n\nvoid make_digit(int n, char *place, size_t line_length) {\n static const char *parts[] = {\" \",\" . \",\" .. \",\"... \",\"....\",\"----\"};\n int i;\n\n \n for (i=4; i>0; i--, n -= 5)\n memcpy(place + i*line_length, parts[MAX(0, MIN(5, n))], 4);\n \n \n if (n == -20) place[4 * line_length + 1] = '@';\n}\n\n\nchar *mayan(unsigned int n) {\n if (n == 0) return NULL; \n \n uint8_t digits[15]; \n size_t n_digits = base20(n, digits);\n \n \n size_t line_length = n_digits*5 + 2;\n \n \n char *str = malloc(line_length * 6 + 1);\n if (str == NULL) return NULL;\n str[line_length * 6] = 0;\n \n \n char *ptr;\n unsigned int i;\n \n for (ptr=str, i=0; i\\n\");\n return 1;\n }\n int i = atoi(argv[1]);\n if (i <= 0) {\n fprintf(stderr, \"number must be positive\\n\");\n return 1;\n }\n char *m = mayan(i);\n printf(\"%s\",m);\n free(m);\n return 0;\n}\n","Rust":"const ONE: &str = \"\u25cf\";\nconst FIVE: &str = \"\u2014\u2014\";\nconst ZERO: &str = \"\u0398\";\n\nfn main() {\n println!(\"{}\", mayan(4005));\n println!(\"{}\", mayan(8017));\n println!(\"{}\", mayan(326_205));\n println!(\"{}\", mayan(886_205));\n println!(\"{}\", mayan(69));\n println!(\"{}\", mayan(420));\n println!(\"{}\", mayan(1_063_715_456));\n}\n\nfn mayan(dec: i64) -> String {\n let mut digits = vec![];\n let mut num = dec;\n while num > 0 {\n digits.push(num % 20);\n num \/= 20;\n }\n digits = digits.into_iter().rev().collect();\n let mut boxes = vec![\"\".to_string(); 6];\n let n = digits.len();\n for (i, digit) in digits.iter().enumerate() {\n if i == 0 {\n boxes[0] = \"\u250f\u2501\u2501\u2501\u2501\".to_string();\n if i == n - 1 {\n boxes[0] += \"\u2513\";\n }\n } else if i == n - 1 {\n boxes[0] += \"\u2533\u2501\u2501\u2501\u2501\u2513\";\n } else {\n boxes[0] += \"\u2533\u2501\u2501\u2501\u2501\";\n }\n for j in 1..5 {\n boxes[j] += \"\u2503\";\n let elem = 0.max(digit - (4 - j as i64) * 5);\n if elem >= 5 {\n boxes[j] += &format!(\"{: ^4}\", FIVE);\n } else if elem > 0 {\n boxes[j] += &format!(\"{: ^4}\", ONE.repeat(elem as usize % 15));\n } else if j == 4 {\n boxes[j] += &format!(\"{: ^4}\", ZERO);\n } else {\n boxes[j] += &\" \";\n }\n if i == n - 1 {\n boxes[j] += \"\u2503\";\n }\n }\n if i == 0 {\n boxes[5] = \"\u2517\u2501\u2501\u2501\u2501\".to_string();\n if i == n - 1 {\n boxes[5] += \"\u251b\";\n }\n } else if i == n - 1 {\n boxes[5] += \"\u253b\u2501\u2501\u2501\u2501\u251b\";\n } else {\n boxes[5] += \"\u253b\u2501\u2501\u2501\u2501\";\n }\n }\n\n let mut mayan = format!(\"Mayan {}:\\n\", dec);\n for b in boxes {\n mayan += &(b + \"\\n\");\n }\n mayan\n}\n"} {"name":"McNuggets problem","C":"#include \n\nint\nmain() {\n int max = 0, i = 0, sixes, nines, twenties;\n\nloopstart: while (i < 100) {\n for (sixes = 0; sixes*6 < i; sixes++) {\n if (sixes*6 == i) {\n i++;\n goto loopstart;\n }\n\n for (nines = 0; nines*9 < i; nines++) {\n if (sixes*6 + nines*9 == i) {\n i++;\n goto loopstart;\n }\n\n for (twenties = 0; twenties*20 < i; twenties++) {\n if (sixes*6 + nines*9 + twenties*20 == i) {\n i++;\n goto loopstart;\n }\n }\n }\n }\n max = i;\n i++;\n }\n\n printf(\"Maximum non-McNuggets number is %d\\n\", max);\n\n return 0;\n}\n","Rust":"fn main() {\n let test_cases = vec![\n [6, 9, 20],\n [12, 14, 17],\n [12, 13, 34],\n [5, 9, 21],\n [10, 18, 21],\n [71, 98, 99],\n [7_074_047, 8_214_596, 9_098_139],\n [582_795_988, 1_753_241_221, 6_814_151_015],\n [4, 30, 16],\n [12, 12, 13],\n [6, 15, 1],\n ];\n for case in &test_cases {\n print!(\"g({}, {}, {}) = \", case[0], case[1], case[2]);\n println!(\n \"{}\",\n match frobenius(case.to_vec()) {\n Ok(g) => format!(\"{}\", g),\n Err(e) => e,\n }\n );\n }\n}\n\nfn frobenius(unsorted_a: Vec) -> Result {\n let mut a = unsorted_a;\n a.sort();\n assert!(a[0] >= 1);\n if gcd(gcd(a[0], a[1]), a[2]) > 1 {\n return Err(\"Undefined\".to_string());\n }\n let d12 = gcd(a[0], a[1]);\n let d13 = gcd(a[0] \/ d12, a[2]);\n let d23 = gcd(a[1] \/ d12, a[2] \/ d13);\n let mut a_prime = vec![a[0] \/ d12 \/ d13, a[1] \/ d12 \/ d23, a[2] \/ d13 \/ d23];\n a_prime.sort();\n let rod = if a_prime[0] == 1 {\n -1\n } else {\n \n let mut a1 = a_prime[0];\n let mut s0 = congruence(a_prime[1], a_prime[2], a_prime[0]);\n let mut s = vec![a1];\n let mut q: Vec = vec![];\n while s0 != 0 {\n s.push(s0);\n let s1 = if s0 == 1 { 0 } else { s0 - (a1 % s0) };\n let q1 = (a1 + s1) \/ s0;\n q.push(q1);\n a1 = s0;\n s0 = s1;\n }\n let mut p = vec![0, 1];\n let mut r = (s[1] * a_prime[1] - p[1] * a_prime[2]) \/ a_prime[0];\n let mut i = 1;\n while r > 0 {\n let p_next = q[i - 1] * p[i] - p[i - 1];\n p.push(p_next);\n r = (s[i + 1] * a_prime[1] - p_next * a_prime[2]) \/ a_prime[0];\n i += 1;\n }\n let v = i - 1;\n -a_prime[0] + a_prime[1] * (s[v] - 1) + a_prime[2] * (p[v + 1] - 1)\n - (a_prime[1] * s[v + 1]).min(a_prime[2] * p[v])\n };\n Ok(rod * d12 * d13 * d23 + a[0] * (d23 - 1) + a[1] * (d13 - 1) + a[2] * (d12 - 1))\n}\n\nfn gcd(a: i64, b: i64) -> i64 {\n if b == 0 {\n a\n } else {\n gcd(b, a % b)\n }\n}\n\nfn congruence(a: i64, c: i64, m: i64) -> i64 {\n \n let aa = a % m;\n let cc = (c + a * m) % m;\n if aa == 1 {\n cc\n } else {\n let y = congruence(m, -cc, aa);\n (m * y + cc) \/ aa\n }\n}\n"} {"name":"Metaprogramming","C":"\n#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(!!(COND))*2-1]\n\n#define COMPILE_TIME_ASSERT3(X,L) STATIC_ASSERT(X,static_assertion_at_line_##L)\n#define COMPILE_TIME_ASSERT2(X,L) COMPILE_TIME_ASSERT3(X,L)\n#define COMPILE_TIME_ASSERT(X) COMPILE_TIME_ASSERT2(X,__LINE__)\n\nCOMPILE_TIME_ASSERT(sizeof(long)==8); \nint main()\n{\n COMPILE_TIME_ASSERT(sizeof(int)==4); \n}\n","Rust":"\nuse std::ops::{Add, Mul, Sub};\n\nmacro_rules! assert_equal_len {\n \n \n ($a:ident, $b: ident, $func:ident, $op:tt) => (\n assert!($a.len() == $b.len(),\n \"{:?}: dimension mismatch: {:?} {:?} {:?}\",\n stringify!($func),\n ($a.len(),),\n stringify!($op),\n ($b.len(),));\n )\n}\n\nmacro_rules! op {\n ($func:ident, $bound:ident, $op:tt, $method:ident) => (\n fn $func + Copy>(xs: &mut Vec, ys: &Vec) {\n assert_equal_len!(xs, ys, $func, $op);\n\n for (x, y) in xs.iter_mut().zip(ys.iter()) {\n *x = $bound::$method(*x, *y);\n \n }\n }\n )\n}\n\n\nop!(add_assign, Add, +=, add);\nop!(mul_assign, Mul, *=, mul);\nop!(sub_assign, Sub, -=, sub);\n\nmod test {\n use std::iter;\n macro_rules! test {\n ($func: ident, $x:expr, $y:expr, $z:expr) => {\n #[test]\n fn $func() {\n for size in 0usize..10 {\n let mut x: Vec<_> = iter::repeat($x).take(size).collect();\n let y: Vec<_> = iter::repeat($y).take(size).collect();\n let z: Vec<_> = iter::repeat($z).take(size).collect();\n\n super::$func(&mut x, &y);\n\n assert_eq!(x, z);\n }\n }\n }\n }\n\n \n test!(add_assign, 1u32, 2u32, 3u32);\n test!(mul_assign, 2u32, 3u32, 6u32);\n test!(sub_assign, 3u32, 2u32, 1u32);\n}\n"} {"name":"Mind boggling card trick","C":"#include \n#include \n#include \n\n#define SIM_N 5 \n#define PRINT_DISCARDED 1 \n\n#define min(x,y) ((x= n);\n return out;\n}\n\n\ncard_t rand_card() {\n return rand_n(52);\n}\n\n\nvoid print_card(card_t card) {\n static char *suits = \"HCDS\"; \n static char *cards[] = {\"A\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"10\",\"J\",\"Q\",\"K\"};\n printf(\" %s%c\", cards[card>>2], suits[card&3]);\n}\n\n\nvoid shuffle(card_t *pack) {\n int card;\n card_t temp, randpos;\n for (card=0; card<52; card++) {\n randpos = rand_card();\n temp = pack[card];\n pack[card] = pack[randpos];\n pack[randpos] = temp;\n }\n}\n\n\nint trick() {\n card_t pack[52];\n card_t blacks[52\/4], reds[52\/4];\n card_t top, x, card;\n int blackn=0, redn=0, blacksw=0, redsw=0, result;\n \n \n for (card=0; card<52; card++) pack[card] = card;\n shuffle(pack);\n \n \n#if PRINT_DISCARDED\n printf(\"Discarded:\"); \n#endif\n for (card=0; card<52; card += 2) {\n top = pack[card]; \n if (top & 1) { \n blacks[blackn++] = pack[card+1];\n } else {\n reds[redn++] = pack[card+1];\n }\n#if PRINT_DISCARDED\n print_card(top); \n#endif\n }\n#if PRINT_DISCARDED\n printf(\"\\n\");\n#endif\n\n \n x = rand_n(min(blackn, redn));\n for (card=0; card = repeat(Black).take(26)\n .chain(repeat(Red).take(26))\n .collect();\n \n rng.shuffle(&mut deck);\n \n let mut black_stack = vec![];\n let mut red_stack = vec![];\n let mut discarded = vec![];\n \n \n print!(\"Discarding:\");\n while let (Some(card), Some(next)) = (deck.pop(), deck.pop()) {\n print!(\" {}\", if card == Black { \"B\" } else { \"R\" });\n match card {\n Red => red_stack.push(next),\n Black => black_stack.push(next),\n }\n discarded.push(card);\n }\n println!();\n \n \n let max = red_stack.len().min(black_stack.len());\n let num = rng.gen_range(1, max);\n println!(\"Exchanging {} cards\", num);\n \n \n for _ in 0..num {\n let red = rng.choose_mut(&mut red_stack).unwrap();\n let black = rng.choose_mut(&mut black_stack).unwrap();\n std::mem::swap(red, black);\n }\n \n \n let num_black = black_stack.iter()\n .filter(|&c| c == &Black)\n .count();\n let num_red = red_stack.iter()\n .filter(|&c| c == &Red)\n .count();\n \n println!(\"Number of black cards in black stack: {}\", num_black);\n println!(\"Number of red cards in red stack: {}\", num_red);\n}\n"} {"name":"Modulinos","C":"int meaning_of_life();\n","Rust":"#[link(name = \"scriptedmain\")];\n\nuse std;\n\nfn meaning_of_life() -> int {\n\tret 42;\n}\n\nfn main() {\n\tstd::io::println(\"Main: The meaning of life is \" + core::int::to_str(meaning_of_life(), 10u));\n}\n"} {"name":"Motzkin numbers","C":"#include \n#include \n#include \n#include \n\nbool is_prime(uint64_t n) {\n if (n < 2)\n return false;\n if (n % 2 == 0)\n return n == 2;\n if (n % 3 == 0)\n return n == 3;\n for (uint64_t p = 5; p * p <= n; p += 4) {\n if (n % p == 0)\n return false;\n p += 2;\n if (n % p == 0)\n return false;\n }\n return true;\n}\n\nint main() {\n setlocale(LC_ALL, \"\");\n printf(\" n M(n) Prime?\\n\");\n printf(\"-----------------------------------\\n\");\n uint64_t m0 = 1, m1 = 1;\n for (uint64_t i = 0; i < 42; ++i) {\n uint64_t m =\n i > 1 ? (m1 * (2 * i + 1) + m0 * (3 * i - 3)) \/ (i + 2) : 1;\n printf(\"%2llu%'25llu %s\\n\", i, m, is_prime(m) ? \"true\" : \"false\");\n m0 = m1;\n m1 = m;\n }\n}\n","Rust":"\n\n\n\nfn motzkin(n: usize) -> Vec {\n let mut m = vec![0; n];\n m[0] = 1;\n m[1] = 1;\n for i in 2..n {\n m[i] = (m[i - 1] * (2 * i + 1) + m[i - 2] * (3 * i - 3)) \/ (i + 2);\n }\n m\n}\n\nfn main() {\n use num_format::{Locale, ToFormattedString};\n let count = 42;\n let m = motzkin(count);\n println!(\" n M(n) Prime?\");\n println!(\"-----------------------------------\");\n for i in 0..count {\n println!(\n \"{:2} {:>23} {}\",\n i,\n m[i].to_formatted_string(&Locale::en),\n primal::is_prime(m[i] as u64)\n );\n }\n}\n"} {"name":"Mutex","C":"HANDLE hMutex = CreateMutex(NULL, FALSE, NULL);\n","Rust":"use std::{\n sync::{Arc, Mutex},\n thread,\n time::Duration,\n};\n\nfn main() {\n let shared = Arc::new(Mutex::new(String::new()));\n\n let handle1 = {\n let value = shared.clone();\n thread::spawn(move || {\n for _ in 0..20 {\n thread::sleep(Duration::from_millis(200));\n \n let mut guard = value.lock().unwrap();\n guard.push_str(\"A\");\n println!(\"{}\", guard);\n }\n })\n };\n\n let handle2 = {\n let value = shared.clone();\n thread::spawn(move || {\n for _ in 0..20 {\n thread::sleep(Duration::from_millis(300));\n\n {\n \n let mut guard = value.lock().unwrap();\n guard.push_str(\"B\");\n println!(\"{}\", guard);\n }\n }\n })\n };\n\n handle1.join().ok();\n handle2.join().ok();\n shared.lock().ok().map_or((), |it| println!(\"Done: {}\", it));\n}\n"} {"name":"N-smooth numbers","C":"#include \n#include \n#include \n#include \n#include \n\nvoid* xmalloc(size_t n) {\n void* ptr = malloc(n);\n if (ptr == NULL) {\n fprintf(stderr, \"Out of memory\\n\");\n exit(1);\n }\n return ptr;\n}\n\nvoid* xrealloc(void* p, size_t n) {\n void* ptr = realloc(p, n);\n if (ptr == NULL) {\n fprintf(stderr, \"Out of memory\\n\");\n exit(1);\n }\n return ptr;\n}\n\nbool is_prime(uint32_t n) {\n if (n == 2)\n return true;\n if (n < 2 || n % 2 == 0)\n return false;\n for (uint32_t p = 3; p * p <= n; p += 2) {\n if (n % p == 0)\n return false;\n }\n return true;\n}\n\n\n\nuint32_t find_primes(uint32_t from, uint32_t to, uint32_t** primes) {\n uint32_t count = 0, buffer_length = 16;\n uint32_t* buffer = xmalloc(sizeof(uint32_t) * buffer_length);\n for (uint32_t p = from; p <= to; ++p) {\n if (is_prime(p)) {\n if (count >= buffer_length) {\n uint32_t new_length = buffer_length * 2;\n if (new_length < count + 1)\n new_length = count + 1;\n buffer = xrealloc(buffer, sizeof(uint32_t) * new_length);\n buffer_length = new_length;\n }\n buffer[count++] = p;\n }\n }\n *primes = buffer;\n return count;\n}\n\nvoid free_numbers(mpz_t* numbers, size_t count) {\n for (size_t i = 0; i < count; ++i)\n mpz_clear(numbers[i]);\n free(numbers);\n}\n\n\nmpz_t* find_nsmooth_numbers(uint32_t n, uint32_t count) {\n uint32_t* primes = NULL;\n uint32_t num_primes = find_primes(2, n, &primes);\n mpz_t* numbers = xmalloc(sizeof(mpz_t) * count);\n mpz_t* queue = xmalloc(sizeof(mpz_t) * num_primes);\n uint32_t* index = xmalloc(sizeof(uint32_t) * num_primes);\n for (uint32_t i = 0; i < num_primes; ++i) {\n index[i] = 0;\n mpz_init_set_ui(queue[i], primes[i]);\n }\n for (uint32_t i = 0; i < count; ++i)\n mpz_init(numbers[i]);\n mpz_set_ui(numbers[0], 1);\n for (uint32_t i = 1; i < count; ++i) {\n for (uint32_t p = 0; p < num_primes; ++p) {\n if (mpz_cmp(queue[p], numbers[i - 1]) == 0)\n mpz_mul_ui(queue[p], numbers[++index[p]], primes[p]);\n }\n uint32_t min_index = 0;\n for (uint32_t p = 1; p < num_primes; ++p) {\n if (mpz_cmp(queue[min_index], queue[p]) > 0)\n min_index = p;\n }\n mpz_set(numbers[i], queue[min_index]);\n }\n free_numbers(queue, num_primes);\n free(primes);\n free(index);\n return numbers;\n}\n\nvoid print_nsmooth_numbers(uint32_t n, uint32_t begin, uint32_t count) {\n uint32_t num = begin + count;\n mpz_t* numbers = find_nsmooth_numbers(n, num);\n printf(\"%u: \", n);\n mpz_out_str(stdout, 10, numbers[begin]);\n for (uint32_t i = 1; i < count; ++i) {\n printf(\", \");\n mpz_out_str(stdout, 10, numbers[begin + i]);\n }\n printf(\"\\n\");\n free_numbers(numbers, num);\n}\n\nint main() {\n printf(\"First 25 n-smooth numbers for n = 2 -> 29:\\n\");\n for (uint32_t n = 2; n <= 29; ++n) {\n if (is_prime(n))\n print_nsmooth_numbers(n, 0, 25);\n }\n printf(\"\\n3 n-smooth numbers starting from 3000th for n = 3 -> 29:\\n\");\n for (uint32_t n = 3; n <= 29; ++n) {\n if (is_prime(n))\n print_nsmooth_numbers(n, 2999, 3);\n }\n printf(\"\\n20 n-smooth numbers starting from 30,000th for n = 503 -> 521:\\n\");\n for (uint32_t n = 503; n <= 521; ++n) {\n if (is_prime(n))\n print_nsmooth_numbers(n, 29999, 20);\n }\n return 0;\n}\n","Rust":"fn is_prime(n: u32) -> bool {\n if n < 2 {\n return false;\n }\n if n % 2 == 0 {\n return n == 2;\n }\n if n % 3 == 0 {\n return n == 3;\n }\n let mut p = 5;\n while p * p <= n {\n if n % p == 0 {\n return false;\n }\n p += 2;\n if n % p == 0 {\n return false;\n }\n p += 4;\n }\n true\n}\n\nfn find_primes(from: u32, to: u32) -> Vec {\n let mut primes: Vec = Vec::new();\n for p in from..=to {\n if is_prime(p) {\n primes.push(p);\n }\n }\n primes\n}\n\nfn find_nsmooth_numbers(n: u32, count: usize) -> Vec {\n let primes = find_primes(2, n);\n let num_primes = primes.len();\n let mut result = Vec::with_capacity(count);\n let mut queue = Vec::with_capacity(num_primes);\n let mut index = Vec::with_capacity(num_primes);\n for i in 0..num_primes {\n index.push(0);\n queue.push(primes[i] as u128);\n }\n result.push(1);\n for i in 1..count {\n for p in 0..num_primes {\n if queue[p] == result[i - 1] {\n index[p] += 1;\n queue[p] = result[index[p]] * primes[p] as u128;\n }\n }\n let mut min_index: usize = 0;\n for p in 1..num_primes {\n if queue[min_index] > queue[p] {\n min_index = p;\n }\n }\n result.push(queue[min_index]);\n }\n result\n}\n\nfn print_nsmooth_numbers(n: u32, begin: usize, count: usize) {\n let numbers = find_nsmooth_numbers(n, begin + count);\n print!(\"{}: {}\", n, &numbers[begin]);\n for i in 1..count {\n print!(\", {}\", &numbers[begin + i]);\n }\n println!();\n}\n\nfn main() {\n println!(\"First 25 n-smooth numbers for n = 2 -> 29:\");\n for n in 2..=29 {\n if is_prime(n) {\n print_nsmooth_numbers(n, 0, 25);\n }\n }\n println!();\n println!(\"3 n-smooth numbers starting from 3000th for n = 3 -> 29:\");\n for n in 3..=29 {\n if is_prime(n) {\n print_nsmooth_numbers(n, 2999, 3);\n }\n }\n println!();\n println!(\"20 n-smooth numbers starting from 30,000th for n = 503 -> 521:\");\n for n in 503..=521 {\n if is_prime(n) {\n print_nsmooth_numbers(n, 29999, 20);\n }\n }\n}\n"} {"name":"Next highest int from digits","C":"#include \n#include \n#include \n#include \n#include \n\nvoid swap(char* str, int i, int j) {\n char c = str[i];\n str[i] = str[j];\n str[j] = c;\n}\n\nvoid reverse(char* str, int i, int j) {\n for (; i < j; ++i, --j)\n swap(str, i, j);\n}\n\nbool next_permutation(char* str) {\n int len = strlen(str);\n if (len < 2)\n return false;\n for (int i = len - 1; i > 0; ) {\n int j = i, k;\n if (str[--i] < str[j]) {\n k = len;\n while (str[i] >= str[--k]) {}\n swap(str, i, k);\n reverse(str, j, len - 1);\n return true;\n }\n }\n return false;\n}\n\nuint32_t next_highest_int(uint32_t n) {\n char str[16];\n snprintf(str, sizeof(str), \"%u\", n);\n if (!next_permutation(str))\n return 0;\n return strtoul(str, 0, 10);\n}\n\nint main() {\n uint32_t numbers[] = {0, 9, 12, 21, 12453, 738440, 45072010, 95322020};\n const int count = sizeof(numbers)\/sizeof(int);\n for (int i = 0; i < count; ++i)\n printf(\"%d -> %d\\n\", numbers[i], next_highest_int(numbers[i]));\n \n const char big[] = \"9589776899767587796600\";\n char next[sizeof(big)];\n memcpy(next, big, sizeof(big));\n next_permutation(next);\n printf(\"%s -> %s\\n\", big, next);\n return 0;\n}\n","Rust":"fn next_permutation(array: &mut [T]) -> bool {\n let len = array.len();\n if len < 2 {\n return false;\n }\n let mut i = len - 1;\n while i > 0 {\n let j = i;\n i -= 1;\n if array[i] < array[j] {\n let mut k = len - 1;\n while array[i] >= array[k] {\n k -= 1;\n }\n array.swap(i, k);\n array[j..len].reverse();\n return true;\n }\n }\n false\n}\n\nfn next_highest_int(n: u128) -> u128 {\n use std::iter::FromIterator;\n let mut chars: Vec = n.to_string().chars().collect();\n if !next_permutation(&mut chars) {\n return 0;\n } \n String::from_iter(chars).parse::().unwrap()\n}\n\nfn main() {\n for n in &[0, 9, 12, 21, 12453, 738440, 45072010, 95322020, 9589776899767587796600] {\n println!(\"{} -> {}\", n, next_highest_int(*n));\n }\n}\n"} {"name":"Nice primes","C":"#include \n#include \n\nbool is_prime(unsigned int n) {\n if (n < 2) {\n return false;\n }\n if (n % 2 == 0) {\n return n == 2;\n }\n if (n % 3 == 0) {\n return n == 3;\n }\n for (unsigned int p = 5; p * p <= n; p += 4) {\n if (n % p == 0) {\n return false;\n }\n p += 2;\n if (n % p == 0) {\n return false;\n }\n }\n return true;\n}\n\nunsigned int digital_root(unsigned int n) {\n return n == 0 ? 0 : 1 + (n - 1) % 9;\n}\n\nint main() {\n const unsigned int from = 500, to = 1000;\n unsigned int count = 0;\n unsigned int n;\n\n printf(\"Nice primes between %d and %d:\\n\", from, to);\n for (n = from; n < to; ++n) {\n if (is_prime(digital_root(n)) && is_prime(n)) {\n ++count;\n \n printf(\"%d\", n);\n if (count % 10 == 0) {\n putc('\\n', stdout);\n } else {\n putc(' ', stdout);\n }\n }\n }\n printf(\"\\n%d nice primes found.\\n\", count);\n\n return 0;\n}\n","Rust":"\n\n\nfn digital_root(n: u64) -> u64 {\n if n == 0 {\n 0\n } else {\n 1 + (n - 1) % 9\n }\n}\n\nfn nice_primes(from: usize, to: usize) {\n primal::Sieve::new(to)\n .primes_from(from)\n .take_while(|x| *x < to)\n .filter(|x| primal::is_prime(digital_root(*x as u64)))\n .for_each(|x| println!(\"{}\", x));\n}\n\nfn main() {\n nice_primes(500, 1000);\n}\n"} {"name":"Nimber arithmetic","C":"#include \n#include \n\n\nuint32_t hpo2(uint32_t n) {\n return n & -n;\n}\n\n\nuint32_t lhpo2(uint32_t n) {\n uint32_t q = 0, m = hpo2(n);\n for (; m % 2 == 0; m >>= 1, ++q) {}\n return q;\n}\n\n\nuint32_t nimsum(uint32_t x, uint32_t y) {\n return x ^ y;\n}\n\n\nuint32_t nimprod(uint32_t x, uint32_t y) {\n if (x < 2 || y < 2)\n return x * y;\n uint32_t h = hpo2(x);\n if (x > h)\n return nimprod(h, y) ^ nimprod(x ^ h, y);\n if (hpo2(y) < y)\n return nimprod(y, x);\n uint32_t xp = lhpo2(x), yp = lhpo2(y);\n uint32_t comp = xp & yp;\n if (comp == 0)\n return x * y;\n h = hpo2(comp);\n return nimprod(nimprod(x >> h, y >> h), 3 << (h - 1));\n}\n\nvoid print_table(uint32_t n, char op, uint32_t(*func)(uint32_t, uint32_t)) {\n printf(\" %c |\", op);\n for (uint32_t a = 0; a <= n; ++a)\n printf(\"%3d\", a);\n printf(\"\\n--- -\");\n for (uint32_t a = 0; a <= n; ++a)\n printf(\"---\");\n printf(\"\\n\");\n for (uint32_t b = 0; b <= n; ++b) {\n printf(\"%2d |\", b);\n for (uint32_t a = 0; a <= n; ++a)\n printf(\"%3d\", func(a, b));\n printf(\"\\n\");\n }\n}\n\nint main() {\n print_table(15, '+', nimsum);\n printf(\"\\n\");\n print_table(15, '*', nimprod);\n const uint32_t a = 21508, b = 42689;\n printf(\"\\n%d + %d = %d\\n\", a, b, nimsum(a, b));\n printf(\"%d * %d = %d\\n\", a, b, nimprod(a, b));\n return 0;\n}\n","Rust":"\nfn hpo2(n: u32) -> u32 {\n n & (0xFFFFFFFF - n + 1)\n}\n\n\nfn lhpo2(n: u32) -> u32 {\n let mut q: u32 = 0;\n let mut m: u32 = hpo2(n);\n while m % 2 == 0 {\n m >>= 1;\n q += 1;\n }\n q\n}\n\n\nfn nimsum(x: u32, y: u32) -> u32 {\n x ^ y\n}\n\n\nfn nimprod(x: u32, y: u32) -> u32 {\n if x < 2 || y < 2 {\n return x * y;\n }\n let mut h: u32 = hpo2(x);\n if x > h {\n return nimprod(h, y) ^ nimprod(x ^ h, y);\n }\n if hpo2(y) < y {\n return nimprod(y, x);\n }\n let xp: u32 = lhpo2(x);\n let yp: u32 = lhpo2(y);\n let comp: u32 = xp & yp;\n if comp == 0 {\n return x * y;\n }\n h = hpo2(comp);\n nimprod(nimprod(x >> h, y >> h), 3 << (h - 1))\n}\n\nfn print_table(n: u32, op: char, func: fn(u32, u32) -> u32) {\n print!(\" {} |\", op);\n for a in 0..=n {\n print!(\"{:3}\", a);\n }\n print!(\"\\n--- -\");\n for _ in 0..=n {\n print!(\"---\");\n }\n println!();\n for b in 0..=n {\n print!(\"{:2} |\", b);\n for a in 0..=n {\n print!(\"{:3}\", func(a, b));\n }\n println!();\n }\n}\n\nfn main() {\n print_table(15, '+', nimsum);\n println!();\n print_table(15, '*', nimprod);\n let a: u32 = 21508;\n let b: u32 = 42689;\n println!(\"\\n{} + {} = {}\", a, b, nimsum(a, b));\n println!(\"{} * {} = {}\", a, b, nimprod(a, b));\n}\n"} {"name":"Nonoblock","C":"#include \n#include \n\nvoid nb(int cells, int total_block_size, int* blocks, int block_count,\n char* output, int offset, int* count) {\n if (block_count == 0) {\n printf(\"%2d %s\\n\", ++*count, output);\n return;\n }\n int block_size = blocks[0];\n int max_pos = cells - (total_block_size + block_count - 1);\n total_block_size -= block_size;\n cells -= block_size + 1;\n ++blocks;\n --block_count;\n for (int i = 0; i <= max_pos; ++i, --cells) {\n memset(output + offset, '.', max_pos + block_size);\n memset(output + offset + i, '#', block_size);\n nb(cells, total_block_size, blocks, block_count, output,\n offset + block_size + i + 1, count);\n }\n}\n\nvoid nonoblock(int cells, int* blocks, int block_count) {\n printf(\"%d cells and blocks [\", cells);\n for (int i = 0; i < block_count; ++i)\n printf(i == 0 ? \"%d\" : \", %d\", blocks[i]);\n printf(\"]:\\n\");\n int total_block_size = 0;\n for (int i = 0; i < block_count; ++i)\n total_block_size += blocks[i];\n if (cells < total_block_size + block_count - 1) {\n printf(\"no solution\\n\");\n return;\n }\n char output[cells + 1];\n memset(output, '.', cells);\n output[cells] = '\\0';\n int count = 0;\n nb(cells, total_block_size, blocks, block_count, output, 0, &count);\n}\n\nint main() {\n int blocks1[] = {2, 1};\n nonoblock(5, blocks1, 2);\n printf(\"\\n\");\n \n nonoblock(5, NULL, 0);\n printf(\"\\n\");\n\n int blocks2[] = {8};\n nonoblock(10, blocks2, 1);\n printf(\"\\n\");\n \n int blocks3[] = {2, 3, 2, 3};\n nonoblock(15, blocks3, 4);\n printf(\"\\n\");\n \n int blocks4[] = {2, 3};\n nonoblock(5, blocks4, 2);\n\n return 0;\n}\n","Rust":"struct Nonoblock {\n width: usize,\n config: Vec,\n spaces: Vec,\n}\n\nimpl Nonoblock {\n pub fn new(width: usize, config: Vec) -> Nonoblock {\n Nonoblock {\n width: width,\n config: config,\n spaces: Vec::new(),\n }\n }\n\n pub fn solve(&mut self) -> Vec> {\n let mut output: Vec> = Vec::new();\n self.spaces = (0..self.config.len()).fold(Vec::new(), |mut s, i| {\n s.push(match i {\n 0 => 0,\n _ => 1,\n });\n s\n });\n if self.spaces.iter().sum::() + self.config.iter().sum::() <= self.width {\n 'finished: loop {\n match self.spaces.iter().enumerate().fold((0, vec![0; self.width]), |mut a, (i, s)| {\n (0..self.config[i]).for_each(|j| a.1[a.0 + j + *s] = 1 + i as i32);\n return (a.0 + self.config[i] + *s, a.1);\n }) {\n (_, out) => output.push(out),\n }\n let mut i: usize = 1;\n 'calc: loop {\n let len = self.spaces.len();\n if i > len {\n break 'finished;\n } else {\n self.spaces[len - i] += 1\n }\n if self.spaces.iter().sum::() + self.config.iter().sum::() > self.width {\n self.spaces[len - i] = 1;\n i += 1;\n } else {\n break 'calc;\n }\n }\n }\n }\n output\n }\n}\n\nfn main() {\n let mut blocks = [\n Nonoblock::new(5, vec![2, 1]),\n Nonoblock::new(5, vec![]),\n Nonoblock::new(10, vec![8]),\n Nonoblock::new(15, vec![2, 3, 2, 3]),\n Nonoblock::new(5, vec![2, 3]),\n ];\n\n for block in blocks.iter_mut() {\n println!(\"{} cells and {:?} blocks\", block.width, block.config);\n println!(\"{}\",(0..block.width).fold(String::from(\"=\"), |a, _| a + \"==\"));\n let solutions = block.solve();\n if solutions.len() > 0 {\n for solution in solutions.iter() {\n println!(\"{}\", solution.iter().fold(String::from(\"|\"), |s, f| s + &match f {\n i if *i > 0 => (('A' as u8 + ((*i - 1) as u8) % 26) as char).to_string(),\n _ => String::from(\"_\"),\n }+ \"|\"));\n }\n } else {\n println!(\"No solutions. \");\n }\n println!();\n }\n}\n"} {"name":"Numbers divisible by their individual digits, but not by the product of their digits.","C":"#include \n\nint divisible(int n) {\n int p = 1;\n int c, d;\n \n for (c=n; c; c \/= 10) {\n d = c % 10;\n if (!d || n % d) return 0;\n p *= d;\n }\n \n return n % p;\n}\n\nint main() {\n int n, c=0;\n \n for (n=1; n<1000; n++) {\n if (divisible(n)) {\n printf(\"%5d\", n);\n if (!(++c % 10)) printf(\"\\n\");\n }\n }\n printf(\"\\n\");\n \n return 0;\n}\n","Rust":"fn to_digits( n : i32 ) -> Vec {\n let mut i : i32 = n ;\n let mut digits : Vec = Vec::new( ) ;\n while i != 0 {\n digits.push( i % 10 ) ;\n i \/= 10 ;\n }\n digits\n}\n\nfn my_condition( num : i32 ) -> bool {\n let digits : Vec = to_digits( num ) ;\n if ! digits.iter( ).any( | x | *x == 0 ) {\n let prod : i32 = digits.iter( ).product( ) ;\n return digits.iter( ).all( | x | num % x == 0 ) && \n num % prod != 0 ;\n }\n else {\n false \n }\n}\n\nfn main() {\nlet mut count : i32 = 0 ;\n for n in 10 .. 1000 {\n if my_condition( n ) {\n print!(\"{:5}\" , n) ;\n count += 1 ;\n if count % 10 == 0 {\n println!( ) ;\n }\n }\n }\n println!();\n}\n"} {"name":"Old Russian measure of length","C":"#include\n#include\n#include\n#include\n\n#define UNITS_LENGTH 13\n\nint main(int argC,char* argV[])\n{\n\tint i,reference;\n\tchar *units[UNITS_LENGTH] = {\"kilometer\",\"meter\",\"centimeter\",\"tochka\",\"liniya\",\"diuym\",\"vershok\",\"piad\",\"fut\",\"arshin\",\"sazhen\",\"versta\",\"milia\"};\n double factor, values[UNITS_LENGTH] = {1000.0,1.0,0.01,0.000254,0.00254,0.0254,0.04445,0.1778,0.3048,0.7112,2.1336,1066.8,7467.6};\n\t\n\tif(argC!=3)\n\t\tprintf(\"Usage\u00a0: %s followed by length as \");\n\telse{\n\t\tfor(i=0;argV[2][i]!=00;i++)\n\t\t\targV[2][i] = tolower(argV[2][i]);\n\t\t\n\t\tfor(i=0;i = [(\"arshin\",0.7112),(\"centimeter\",0.01),(\"diuym\",0.0254),(\"fut\",0.3048),(\"kilometer\",1000.0),(\"liniya\",0.00254),(\"meter\",1.0),(\"milia\",7467.6),(\"piad\",0.1778),(\"sazhen\",2.1336),(\"tochka\",0.000254),(\"vershok\",0.04445),(\"versta\",1066.8)].iter().cloned().collect();\n\n\tlet args: Vec = env::args().collect();\n\tif args.len() < 3 {\n\t\teprintln!(\"A correct use is oldrus [amount] [unit].\");\n\t\tprocess::exit(1);\n\t};\n\n\tlet length_float;\n\tlength_float = match args[1].parse::() {\n\t\tOk(length_float) => length_float,\n\t\tErr(..) => 1 as f32,\n\t};\n\n\tlet unit: &str = &args[2];\n\tif ! units.contains_key(unit) {\n\t\tlet mut keys: Vec<&str> = Vec::new();\n\t\tfor i in units.keys() {\n\t\t\tkeys.push(i)\n\t\t};\n\t\teprintln!(\"The correct units are: {}.\", keys.join(\", \"));\n\t\tprocess::exit(1);\n\t};\n\n\tprintln!(\"{} {} to:\", length_float, unit);\n\tfor (lunit, length) in &units {\n\t\tprintln!(\"\t{}: {:?}\", lunit, length_float * units.get(unit).unwrap() \/ length);\n\t};\n\n\n}\n"} {"name":"Optional parameters","C":"#include \n#include \n#include \n#include \n#include \n\ntypedef const char * String;\ntypedef struct sTable {\n String * *rows;\n int n_rows,n_cols;\n} *Table;\n\ntypedef int (*CompareFctn)(String a, String b);\n\nstruct {\n CompareFctn compare;\n int column;\n int reversed;\n} sortSpec;\n\nint CmprRows( const void *aa, const void *bb)\n{\n String *rA = *(String *const *)aa;\n String *rB = *(String *const *)bb;\n int sortCol = sortSpec.column;\n\n String left = sortSpec.reversed ? rB[sortCol] : rA[sortCol];\n String right = sortSpec.reversed ? rA[sortCol] : rB[sortCol];\n return sortSpec.compare( left, right );\n}\n\n\nint sortTable(Table tbl, const char* argSpec,... )\n{\n va_list vl;\n const char *p;\n int c;\n sortSpec.compare = &strcmp;\n sortSpec.column = 0;\n sortSpec.reversed = 0;\n\n va_start(vl, argSpec);\n if (argSpec)\n for (p=argSpec; *p; p++) {\n switch (*p) {\n case 'o':\n sortSpec.compare = va_arg(vl,CompareFctn);\n break;\n case 'c':\n c = va_arg(vl,int);\n if ( 0<=c && cn_cols)\n sortSpec.column = c;\n break;\n case 'r':\n sortSpec.reversed = (0!=va_arg(vl,int));\n break;\n }\n }\n va_end(vl);\n qsort( tbl->rows, tbl->n_rows, sizeof(String *), CmprRows);\n return 0;\n}\n\nvoid printTable( Table tbl, FILE *fout, const char *colFmts[])\n{\n int row, col;\n\n for (row=0; rown_rows; row++) {\n fprintf(fout, \" \");\n for(col=0; coln_cols; col++) {\n fprintf(fout, colFmts[col], tbl->rows[row][col]);\n }\n fprintf(fout, \"\\n\");\n }\n fprintf(fout, \"\\n\");\n}\n\nint ord(char v)\n{\n return v-'0';\n}\n\n\nint cmprStrgs(String s1, String s2)\n{\n const char *p1 = s1; \n const char *p2 = s2;\n const char *mrk1, *mrk2;\n while ((tolower(*p1) == tolower(*p2)) && *p1) {\n p1++; p2++;\n }\n if (isdigit(*p1) && isdigit(*p2)) {\n long v1, v2;\n if ((*p1 == '0') ||(*p2 == '0')) {\n while (p1 > s1) {\n p1--; p2--;\n if (*p1 != '0') break;\n }\n if (!isdigit(*p1)) {\n p1++; p2++;\n }\n }\n mrk1 = p1; mrk2 = p2;\n v1 = 0;\n while(isdigit(*p1)) {\n v1 = 10*v1+ord(*p1);\n p1++;\n }\n v2 = 0;\n while(isdigit(*p2)) {\n v2 = 10*v2+ord(*p2);\n p2++;\n }\n if (v1 == v2) \n return(p2-mrk2)-(p1-mrk1);\n return v1 - v2;\n }\n if (tolower(*p1) != tolower(*p2))\n return (tolower(*p1) - tolower(*p2));\n for(p1=s1, p2=s2; (*p1 == *p2) && *p1; p1++, p2++);\n return (*p1 -*p2);\n}\n\nint main()\n{\n const char *colFmts[] = {\"\u00a0%-5.5s\",\"\u00a0%-5.5s\",\"\u00a0%-9.9s\"};\n String r1[] = { \"a101\", \"red\", \"Java\" };\n String r2[] = { \"ab40\", \"gren\", \"Smalltalk\" };\n String r3[] = { \"ab9\", \"blue\", \"Fortran\" };\n String r4[] = { \"ab09\", \"ylow\", \"Python\" };\n String r5[] = { \"ab1a\", \"blak\", \"Factor\" };\n String r6[] = { \"ab1b\", \"brwn\", \"C Sharp\" };\n String r7[] = { \"Ab1b\", \"pink\", \"Ruby\" };\n String r8[] = { \"ab1\", \"orng\", \"Scheme\" };\n\n String *rows[] = { r1, r2, r3, r4, r5, r6, r7, r8 };\n struct sTable table;\n table.rows = rows;\n table.n_rows = 8;\n table.n_cols = 3;\n\n sortTable(&table, \"\");\n printf(\"sort on col 0, ascending\\n\");\n printTable(&table, stdout, colFmts);\n\n sortTable(&table, \"ro\", 1, &cmprStrgs);\n printf(\"sort on col 0, reverse.special\\n\");\n printTable(&table, stdout, colFmts);\n\n sortTable(&table, \"c\", 1);\n printf(\"sort on col 1, ascending\\n\");\n printTable(&table, stdout, colFmts);\n\n sortTable(&table, \"cr\", 2, 1);\n printf(\"sort on col 2, reverse\\n\");\n printTable(&table, stdout, colFmts);\n return 0;\n}\n","Rust":"use std::cmp::Ordering;\n\nstruct Table {\n rows: Vec>,\n ordering_function: fn(&str, &str) -> Ordering,\n ordering_column: usize,\n reverse: bool,\n}\n\nimpl Table {\n fn new(rows: Vec>) -> Table {\n Table {\n rows: rows,\n ordering_column: 0,\n reverse: false,\n ordering_function: |str1, str2| str1.cmp(str2),\n }\n }\n}\n\nimpl Table {\n fn with_ordering_column(&mut self, ordering_column: usize) -> &mut Table {\n self.ordering_column = ordering_column;\n self\n }\n\n fn with_reverse(&mut self, reverse: bool) -> &mut Table {\n self.reverse = reverse;\n self\n }\n\n fn with_ordering_fun(&mut self, compare: fn(&str, &str) -> Ordering) -> &mut Table {\n self.ordering_function = compare;\n self\n }\n\n fn sort(&mut self) {\n let fun = &mut self.ordering_function;\n let idx = self.ordering_column;\n if self.reverse {\n self.rows\n .sort_unstable_by(|vec1, vec2| (fun)(&vec1[idx], &vec2[idx]).reverse());\n } else {\n self.rows\n .sort_unstable_by(|vec1, vec2| (fun)(&vec1[idx], &vec2[idx]));\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::Table;\n\n fn generate_test_table() -> Table {\n Table::new(vec![\n vec![\"0\".to_string(), \"fff\".to_string()],\n vec![\"2\".to_string(), \"aab\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n ])\n }\n\n #[test]\n fn test_simple_sort() {\n let mut table = generate_test_table();\n table.sort();\n assert_eq!(\n table.rows,\n vec![\n vec![\"0\".to_string(), \"fff\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n vec![\"2\".to_string(), \"aab\".to_string()],\n ],\n )\n }\n\n #[test]\n fn test_ordering_column() {\n let mut table = generate_test_table();\n table.with_ordering_column(1).sort();\n assert_eq!(\n table.rows,\n vec![\n vec![\"2\".to_string(), \"aab\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n vec![\"0\".to_string(), \"fff\".to_string()],\n ],\n )\n }\n\n #[test]\n fn test_with_reverse() {\n let mut table = generate_test_table();\n table.with_reverse(true).sort();\n assert_eq!(\n table.rows,\n vec![\n vec![\"2\".to_string(), \"aab\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n vec![\"0\".to_string(), \"fff\".to_string()],\n ],\n )\n }\n\n #[test]\n fn test_custom_ordering_fun() {\n let mut table = generate_test_table();\n \n \n table.with_ordering_fun(|x, y| x.cmp(y).reverse()).sort();\n assert_eq!(\n table.rows,\n vec![\n vec![\"2\".to_string(), \"aab\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n vec![\"0\".to_string(), \"fff\".to_string()],\n ],\n )\n }\n\n #[test]\n fn test_everything_together() {\n let mut table = generate_test_table();\n \n \n table\n .with_ordering_fun(|x, y| x.cmp(y).reverse())\n .with_reverse(true)\n .with_ordering_column(1)\n .sort();\n assert_eq!(\n table.rows,\n vec![\n vec![\"2\".to_string(), \"aab\".to_string()],\n vec![\"1\".to_string(), \"ccc\".to_string()],\n vec![\"0\".to_string(), \"fff\".to_string()],\n ],\n )\n }\n}\n"} {"name":"Ormiston pairs","C":"#include \n#include \n#include \n#include \n\nbool *sieve(int limit) {\n int i, p;\n limit++;\n \n bool *c = calloc(limit, sizeof(bool)); \n c[0] = true;\n c[1] = true;\n for (i = 4; i < limit; i += 2) c[i] = true;\n p = 3; \n while (true) {\n int p2 = p * p;\n if (p2 >= limit) break;\n for (i = p2; i < limit; i += 2 * p) c[i] = true;\n while (true) {\n p += 2;\n if (!c[p]) break;\n }\n }\n return c;\n}\n\ntypedef struct {\n char digs[20];\n int count;\n} digits;\n\ndigits getDigits(int n) {\n if (n == 0) return (digits){ {0}, 1 };\n digits d;\n d.count = 0;\n while (n > 0) {\n d.digs[d.count++] = n % 10;\n n = n \/ 10;\n }\n return d; \n}\n\ntypedef struct {\n int x;\n int y;\n} pair;\n\nint main() {\n const int limit = 1000000000;\n int i, j, k, pc = 0, count = 0, count2 = 0, p1, p2, key1, key2;\n digits d;\n bool *c = sieve(limit);\n for (i = 0; i < limit; ++i) {\n if (!c[i]) ++pc;\n }\n int *primes = (int *)malloc(pc * sizeof(int));\n for (i = 0, j = 0; i < limit; ++i) {\n if (!c[i]) primes[j++] = i;\n }\n pair orm30[30];\n int counts[5];\n j = 100000;\n for (i = 0; i < pc-1; ++i) {\n p1 = primes[i];\n p2 = primes[i+1];\n if ((p2 - p1) % 18) continue;\n key1 = 1;\n d = getDigits(p1);\n for (k = 0; k < d.count; ++k) key1 *= primes[d.digs[k]];\n key2 = 1;\n d = getDigits(p2);\n for (k = 0; k < d.count; ++k) key2 *= primes[d.digs[k]];\n if (key1 == key2) {\n if (count < 30) orm30[count] = (pair){p1, p2};\n if (p1 >= j) {\n counts[count2++] = count;\n j *= 10;\n }\n ++count;\n }\n }\n counts[count2] = count;\n printf(\"First 30 Ormiston pairs:\\n\");\n setlocale(LC_NUMERIC, \"\");\n for (i = 0; i < 30; ++i) {\n printf(\"[%'6d,\u00a0%'6d] \", orm30[i].x, orm30[i].y);\n if (!((i+1) % 3)) printf(\"\\n\");\n }\n printf(\"\\n\");\n j = 100000;\n for (i = 0; i < 5; ++i) {\n printf(\"%'d Ormiston pairs before\u00a0%'d\\n\", counts[i], j);\n j *= 10;\n }\n free(c);\n free(primes);\n return 0;\n}\n","Rust":"\n\n\nfn get_digits(mut n: usize) -> [usize; 10] {\n let mut digits = [0; 10];\n while n > 0 {\n digits[n % 10] += 1;\n n \/= 10;\n }\n digits\n}\n\nfn ormiston_pairs() -> impl std::iter::Iterator {\n let mut digits = [0; 10];\n let mut prime = 0;\n let mut primes = primal::Primes::all();\n std::iter::from_fn(move || {\n for p in primes.by_ref() {\n let prime0 = prime;\n prime = p;\n let digits0 = digits;\n digits = get_digits(prime);\n if digits == digits0 {\n return Some((prime0, prime));\n }\n }\n None\n })\n}\n\nfn main() {\n let mut count = 0;\n let mut op = ormiston_pairs();\n println!(\"First 30 Ormiston pairs:\");\n for (p1, p2) in op.by_ref() {\n count += 1;\n let c = if count % 3 == 0 { '\\n' } else { ' ' };\n print!(\"({:5}, {:5}){}\", p1, p2, c);\n if count == 30 {\n break;\n }\n }\n println!();\n let mut limit = 1000000;\n for (p1, _) in op.by_ref() {\n if p1 > limit {\n println!(\"Number of Ormiston pairs < {}: {}\", limit, count);\n limit *= 10;\n if limit == 10000000000 {\n break;\n }\n }\n count += 1;\n }\n}\n"} {"name":"Padovan n-step number sequences","C":"#include \n\nvoid padovanN(int n, size_t t, int *p) {\n int i, j;\n if (n < 2 || t < 3) {\n for (i = 0; i < t; ++i) p[i] = 1;\n return;\n }\n padovanN(n-1, t, p);\n for (i = n + 1; i < t; ++i) {\n p[i] = 0;\n for (j = i - 2; j >= i - n - 1; --j) p[i] += p[j];\n }\n}\n\nint main() {\n int n, i;\n const size_t t = 15;\n int p[t];\n printf(\"First %ld terms of the Padovan n-step number sequences:\\n\", t);\n for (n = 2; n <= 8; ++n) {\n for (i = 0; i < t; ++i) p[i] = 0;\n padovanN(n, t, p);\n printf(\"%d: \", n);\n for (i = 0; i < t; ++i) printf(\"%3d \", p[i]);\n printf(\"\\n\");\n }\n return 0;\n}\n","Rust":"fn padovan(n: u64, x: u64) -> u64 {\n if n < 2 {\n return 0;\n }\n\n match n {\n 2 if x <= n + 1 => 1,\n 2 => padovan(n, x - 2) + padovan(n, x - 3),\n _ if x <= n + 1 => padovan(n - 1, x),\n _ => ((x - n - 1)..(x - 1)).fold(0, |acc, value| acc + padovan(n, value)),\n }\n}\nfn main() {\n (2..=8).for_each(|n| {\n print!(\"\\nN={}: \", n);\n (1..=15).for_each(|x| print!(\"{},\", padovan(n, x)))\n });\n}\n"} {"name":"Padovan sequence","C":"#include \n#include \n#include \n#include \n\n\nint pRec(int n) {\n static int *memo = NULL;\n static size_t curSize = 0;\n \n \n if (curSize <= (size_t) n) {\n size_t lastSize = curSize;\n while (curSize <= (size_t) n) curSize += 1024 * sizeof(int);\n memo = realloc(memo, curSize * sizeof(int));\n memset(memo + lastSize, 0, (curSize - lastSize) * sizeof(int));\n }\n \n \n if (memo[n] == 0) {\n if (n<=2) memo[n] = 1;\n else memo[n] = pRec(n-2) + pRec(n-3);\n }\n \n return memo[n];\n}\n\n\nint pFloor(int n) {\n long double p = 1.324717957244746025960908854;\n long double s = 1.0453567932525329623;\n return powl(p, n-1)\/s + 0.5;\n}\n\n\nvoid nextLSystem(const char *prev, char *buf) {\n while (*prev) {\n switch (*prev++) {\n case 'A': *buf++ = 'B'; break;\n case 'B': *buf++ = 'C'; break;\n case 'C': *buf++ = 'A'; *buf++ = 'B'; break;\n }\n }\n *buf = '\\0';\n}\n\nint main() {\n \n #define BUFSZ 8192\n char buf1[BUFSZ], buf2[BUFSZ];\n int i;\n \n \n printf(\"P_0 .. P_19: \");\n for (i=0; i<20; i++) printf(\"%d \", pRec(i));\n printf(\"\\n\");\n \n \n printf(\"The floor- and recurrence-based functions \");\n for (i=0; i<64; i++) {\n if (pRec(i) != pFloor(i)) {\n printf(\"do not match at %d: %d\u00a0!= %d.\\n\",\n i, pRec(i), pFloor(i));\n break;\n }\n }\n if (i == 64) {\n printf(\"match from P_0 to P_63.\\n\");\n }\n \n \n printf(\"\\nThe first 10 L-system strings are:\\n\"); \n for (strcpy(buf1, \"A\"), i=0; i<10; i++) {\n printf(\"%s\\n\", buf1);\n strcpy(buf2, buf1);\n nextLSystem(buf2, buf1);\n }\n \n \n printf(\"\\nThe floor- and L-system-based functions \");\n for (strcpy(buf1, \"A\"), i=0; i<32; i++) {\n if ((int)strlen(buf1) != pFloor(i)) {\n printf(\"do not match at %d: %d\u00a0!= %d\\n\",\n i, (int)strlen(buf1), pFloor(i));\n break;\n }\n strcpy(buf2, buf1);\n nextLSystem(buf2, buf1);\n }\n if (i == 32) {\n printf(\"match from P_0 to P_31.\\n\");\n }\n \n return 0;\n}\n","Rust":"fn padovan_recur() -> impl std::iter::Iterator {\n let mut p = vec![1, 1, 1];\n let mut n = 0;\n std::iter::from_fn(move || {\n let pn = if n < 3 { p[n] } else { p[0] + p[1] };\n p[0] = p[1];\n p[1] = p[2];\n p[2] = pn;\n n += 1;\n Some(pn)\n })\n}\n\nfn padovan_floor() -> impl std::iter::Iterator {\n const P: f64 = 1.324717957244746025960908854;\n const S: f64 = 1.0453567932525329623;\n (0..).map(|x| (P.powf((x - 1) as f64) \/ S + 0.5).floor() as usize)\n}\n\nfn padovan_lsystem() -> impl std::iter::Iterator {\n let mut str = String::from(\"A\");\n std::iter::from_fn(move || {\n let result = str.clone();\n let mut next = String::new();\n for ch in str.chars() {\n match ch {\n 'A' => next.push('B'),\n 'B' => next.push('C'),\n _ => next.push_str(\"AB\"),\n }\n }\n str = next;\n Some(result)\n })\n}\n\nfn main() {\n println!(\"First 20 terms of the Padovan sequence:\");\n for p in padovan_recur().take(20) {\n print!(\"{} \", p);\n }\n println!();\n\n println!(\n \"\\nRecurrence and floor functions agree for first 64 terms? {}\",\n padovan_recur().take(64).eq(padovan_floor().take(64))\n );\n\n println!(\"\\nFirst 10 strings produced from the L-system:\");\n for p in padovan_lsystem().take(10) {\n print!(\"{} \", p);\n }\n println!();\n\n println!(\n \"\\nLength of first 32 strings produced from the L-system = Padovan sequence? {}\",\n padovan_lsystem()\n .map(|x| x.len())\n .take(32)\n .eq(padovan_recur().take(32))\n );\n}\n"} {"name":"Palindromic gapful numbers","C":"#include \n#include \n#include \n\ntypedef uint64_t integer;\n\ninteger reverse(integer n) {\n integer rev = 0;\n while (n > 0) {\n rev = rev * 10 + (n % 10);\n n \/= 10;\n }\n return rev;\n}\n\ntypedef struct palgen_tag {\n integer power;\n integer next;\n int digit;\n bool even;\n} palgen_t;\n\nvoid init_palgen(palgen_t* palgen, int digit) {\n palgen->power = 10;\n palgen->next = digit * palgen->power - 1;\n palgen->digit = digit;\n palgen->even = false;\n}\n\ninteger next_palindrome(palgen_t* p) {\n ++p->next;\n if (p->next == p->power * (p->digit + 1)) {\n if (p->even)\n p->power *= 10;\n p->next = p->digit * p->power;\n p->even = !p->even;\n }\n return p->next * (p->even ? 10 * p->power : p->power)\n + reverse(p->even ? p->next : p->next\/10);\n}\n\nbool gapful(integer n) {\n integer m = n;\n while (m >= 10)\n m \/= 10;\n return n % (n % 10 + 10 * m) == 0;\n}\n\nvoid print(int len, integer array[][len]) {\n for (int digit = 1; digit < 10; ++digit) {\n printf(\"%d: \", digit);\n for (int i = 0; i < len; ++i)\n printf(\" %llu\", array[digit - 1][i]);\n printf(\"\\n\");\n }\n}\n\nint main() {\n const int n1 = 20, n2 = 15, n3 = 10;\n const int m1 = 100, m2 = 1000;\n\n integer pg1[9][n1];\n integer pg2[9][n2];\n integer pg3[9][n3];\n\n for (int digit = 1; digit < 10; ++digit) {\n palgen_t pgen;\n init_palgen(&pgen, digit);\n for (int i = 0; i < m2; ) {\n integer n = next_palindrome(&pgen);\n if (!gapful(n))\n continue;\n if (i < n1)\n pg1[digit - 1][i] = n;\n else if (i < m1 && i >= m1 - n2)\n pg2[digit - 1][i - (m1 - n2)] = n;\n else if (i >= m2 - n3)\n pg3[digit - 1][i - (m2 - n3)] = n;\n ++i;\n }\n }\n\n printf(\"First %d palindromic gapful numbers ending in:\\n\", n1);\n print(n1, pg1);\n\n printf(\"\\nLast %d of first %d palindromic gapful numbers ending in:\\n\", n2, m1);\n print(n2, pg2);\n\n printf(\"\\nLast %d of first %d palindromic gapful numbers ending in:\\n\", n3, m2);\n print(n3, pg3);\n\n return 0;\n}\n","Rust":"fn palindromicgapfuls(digit: u64, count: u64, keep: usize) -> Vec {\n let mut palcnt = 0u64; \n let to_skip = count - keep as u64; \n let mut gapfuls: Vec = vec![]; \n let nn = digit * 11; \n let (mut power, mut base) = (1, 1u64);\n loop { power += 1;\n if power & 1 == 0 { base *= 10 }; \n let base11 = base * 11; \n let this_lo = base * digit; \n let next_lo = base * (digit + 1); \n for front_half in (this_lo..next_lo-1).step_by(10) { \n let (mut left_half, mut basep) = (front_half.to_string(), 0);\n let right_half = left_half.chars().rev().collect::();\n if power & 1 == 1 { basep = base11; left_half.push_str(&right_half) }\n else { basep = base; left_half.pop(); left_half.push_str(&right_half) };\n let mut palindrome = left_half.parse::().unwrap();\n for _ in 0..10 {\n if palindrome % nn == 0 { palcnt += 1; if palcnt > to_skip { gapfuls.push(palindrome) } };\n palindrome += basep;\n } \n if gapfuls.len() >= keep { return gapfuls[0..keep].to_vec() };\n }\n }\n}\n\nfn main() {\n let t = std::time::Instant::now(); \n \n let (count, keep) = (20, 20);\n println!(\"First 20 palindromic gapful numbers ending with:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n let (count, keep) = (100, 15);\n println!(\"\\nLast 15 of first 100 palindromic gapful numbers ending in:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n let (count, keep) = (1_000, 10);\n println!(\"\\nLast 10 of first 1000 palindromic gapful numbers ending in:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n let (count, keep) = (100_000, 1);\n println!(\"\\n100,000th palindromic gapful number ending with:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n let (count, keep) = (1_000_000, 1);\n println!(\"\\n1,000,000th palindromic gapful number ending with:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n let (count, keep) = (10_000_000, 1);\n println!(\"\\n10,000,000th palindromic gapful number ending with:\");\n for digit in 1..10 { println!(\"{}\u00a0: {:?}\", digit, palindromicgapfuls(digit, count, keep)); } \n \n println!(\"{:?}\", t.elapsed())\n}\n"} {"name":"Parse an IP Address","C":"#include \n#include \n\n\nstatic unsigned int _parseDecimal ( const char** pchCursor )\n{\n unsigned int nVal = 0;\n char chNow;\n while ( chNow = **pchCursor, chNow >= '0' && chNow <= '9' )\n {\n \n nVal *= 10;\n nVal += chNow - '0';\n\n ++*pchCursor;\n }\n return nVal;\n}\n\n\n\nstatic unsigned int _parseHex ( const char** pchCursor )\n{\n unsigned int nVal = 0;\n char chNow;\n while ( chNow = **pchCursor & 0x5f, \n (chNow >= ('0'&0x5f) && chNow <= ('9'&0x5f)) || \n (chNow >= 'A' && chNow <= 'F') \n )\n {\n unsigned char nybbleValue;\n chNow -= 0x10; \n nybbleValue = ( chNow > 9 ? chNow - (0x31-0x0a) : chNow );\n \n nVal <<= 4;\n nVal += nybbleValue;\n\n ++*pchCursor;\n }\n return nVal;\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nint ParseIPv4OrIPv6 ( const char** ppszText, \n unsigned char* abyAddr, int* pnPort, int* pbIsIPv6 )\n{\n unsigned char* abyAddrLocal;\n unsigned char abyDummyAddr[16];\n\n \n const char* pchColon = strchr ( *ppszText, ':' );\n const char* pchDot = strchr ( *ppszText, '.' );\n const char* pchOpenBracket = strchr ( *ppszText, '[' );\n const char* pchCloseBracket = NULL;\n\n\n \n \n \n int bIsIPv6local = NULL != pchOpenBracket || NULL == pchDot ||\n ( NULL != pchColon && ( NULL == pchDot || pchColon < pchDot ) );\n \n if ( bIsIPv6local )\n {\n \n pchCloseBracket = strchr ( *ppszText, ']' );\n if ( NULL != pchOpenBracket && ( NULL == pchCloseBracket ||\n pchCloseBracket < pchOpenBracket ) )\n return 0;\n }\n else \n {\n \n if ( NULL == pchDot || ( NULL != pchColon && pchColon < pchDot ) )\n return 0;\n }\n\n \n if ( NULL != pbIsIPv6 )\n *pbIsIPv6 = bIsIPv6local;\n \n \n \n \n abyAddrLocal = abyAddr; \n if ( NULL == abyAddrLocal ) \n abyAddrLocal = abyDummyAddr;\n\n \n \n \n if ( ! bIsIPv6local ) \n {\n \n \n \n unsigned char* pbyAddrCursor = abyAddrLocal;\n unsigned int nVal;\n const char* pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText ); \n if ( '.' != **ppszText || nVal > 255 || pszTextBefore == *ppszText ) \n return 0;\n *(pbyAddrCursor++) = (unsigned char) nVal; \n ++(*ppszText); \n\n pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText ); \n if ( '.' != **ppszText || nVal > 255 || pszTextBefore == *ppszText )\n return 0;\n *(pbyAddrCursor++) = (unsigned char) nVal;\n ++(*ppszText); \n\n pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText ); \n if ( '.' != **ppszText || nVal > 255 || pszTextBefore == *ppszText )\n return 0;\n *(pbyAddrCursor++) = (unsigned char) nVal;\n ++(*ppszText); \n\n pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText ); \n if ( nVal > 255 || pszTextBefore == *ppszText ) \n return 0;\n *(pbyAddrCursor++) = (unsigned char) nVal;\n\n if ( ':' == **ppszText && NULL != pnPort ) \n {\n unsigned short usPortNetwork; \n ++(*ppszText); \n pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText );\n if ( nVal > 65535 || pszTextBefore == *ppszText )\n return 0;\n ((unsigned char*)&usPortNetwork)[0] = ( nVal & 0xff00 ) >> 8;\n ((unsigned char*)&usPortNetwork)[1] = ( nVal & 0xff );\n *pnPort = usPortNetwork;\n return 1;\n }\n else \n {\n if ( NULL != pnPort )\n *pnPort = 0; \n return 1;\n }\n }\n else \n {\n unsigned char* pbyAddrCursor;\n unsigned char* pbyZerosLoc;\n int bIPv4Detected;\n int nIdx;\n \n \n \n \n \n if ( NULL != pchOpenBracket ) \n *ppszText = pchOpenBracket + 1;\n pbyAddrCursor = abyAddrLocal;\n pbyZerosLoc = NULL; \n bIPv4Detected = 0;\n for ( nIdx = 0; nIdx < 8; ++nIdx ) \n {\n const char* pszTextBefore = *ppszText;\n unsigned nVal =_parseHex ( ppszText ); \n if ( pszTextBefore == *ppszText ) \n {\n if ( NULL != pbyZerosLoc ) \n {\n \n if ( pbyZerosLoc == pbyAddrCursor )\n {\n --nIdx;\n break;\n }\n return 0; \n }\n if ( ':' != **ppszText ) \n return 0;\n if ( 0 == nIdx ) \n {\n ++(*ppszText);\n if ( ':' != **ppszText )\n return 0;\n }\n\n pbyZerosLoc = pbyAddrCursor;\n ++(*ppszText);\n }\n else\n {\n if ( '.' == **ppszText ) \n {\n \n const char* pszTextlocal = pszTextBefore; \n unsigned char abyAddrlocal[16];\n int bIsIPv6local;\n int bParseResultlocal = ParseIPv4OrIPv6 ( &pszTextlocal, abyAddrlocal, NULL, &bIsIPv6local );\n *ppszText = pszTextlocal; \n if ( ! bParseResultlocal || bIsIPv6local ) \n return 0;\n \n *(pbyAddrCursor++) = abyAddrlocal[0];\n *(pbyAddrCursor++) = abyAddrlocal[1];\n *(pbyAddrCursor++) = abyAddrlocal[2];\n *(pbyAddrCursor++) = abyAddrlocal[3];\n ++nIdx; \n bIPv4Detected = 1; \n break; \n }\n\n if ( nVal > 65535 ) \n return 0;\n *(pbyAddrCursor++) = nVal >> 8; \n *(pbyAddrCursor++) = nVal & 0xff;\n if ( ':' == **ppszText ) \n {\n ++(*ppszText);\n }\n else \n {\n break;\n }\n }\n }\n \n \n if ( NULL != pbyZerosLoc )\n {\n int nHead = (int)( pbyZerosLoc - abyAddrLocal ); \n int nTail = nIdx * 2 - (int)( pbyZerosLoc - abyAddrLocal ); \n int nZeros = 16 - nTail - nHead; \n memmove ( &abyAddrLocal[16-nTail], pbyZerosLoc, nTail ); \n memset ( pbyZerosLoc, 0, nZeros ); \n }\n \n \n if ( bIPv4Detected )\n {\n static const unsigned char abyPfx[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };\n if ( 0 != memcmp ( abyAddrLocal, abyPfx, sizeof(abyPfx) ) )\n return 0;\n }\n\n \n if ( NULL != pchOpenBracket )\n {\n if ( ']' != **ppszText )\n return 0;\n ++(*ppszText);\n }\n\n if ( ':' == **ppszText && NULL != pnPort ) \n {\n const char* pszTextBefore;\n unsigned int nVal;\n unsigned short usPortNetwork; \n ++(*ppszText); \n pszTextBefore = *ppszText;\n pszTextBefore = *ppszText;\n nVal =_parseDecimal ( ppszText );\n if ( nVal > 65535 || pszTextBefore == *ppszText )\n return 0;\n ((unsigned char*)&usPortNetwork)[0] = ( nVal & 0xff00 ) >> 8;\n ((unsigned char*)&usPortNetwork)[1] = ( nVal & 0xff );\n *pnPort = usPortNetwork;\n return 1;\n }\n else \n {\n if ( NULL != pnPort )\n *pnPort = 0; \n return 1;\n }\n }\n\n}\n\n\n\nint ParseIPv4OrIPv6_2 ( const char* pszText, \n unsigned char* abyAddr, int* pnPort, int* pbIsIPv6 )\n{\n const char* pszTextLocal = pszText;\n return ParseIPv4OrIPv6 ( &pszTextLocal, abyAddr, pnPort, pbIsIPv6);\n}\n","Rust":"use std::{\n net::{IpAddr, SocketAddr},\n str::FromStr,\n};\n\n#[derive(Clone, Debug)]\nstruct Addr {\n addr: IpAddr,\n port: Option,\n}\n\nimpl std::fmt::Display for Addr {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let ipv = if self.addr.is_ipv4() { \"4\" } else { \"6\" };\n\n let hex = match self.addr {\n IpAddr::V4(addr) => u32::from(addr) as u128,\n IpAddr::V6(addr) => u128::from(addr),\n };\n\n match self.port {\n Some(p) => write!(\n f,\n \"address: {}, port: {}, hex: {:x} (IPv{})\",\n self.addr, p, hex, ipv\n ),\n\n None => write!(\n f,\n \"address: {}, port: N\/A, hex: {:x} (IPv{}) \",\n self.addr, hex, ipv\n ),\n }\n }\n}\n\nimpl FromStr for Addr {\n type Err = ();\n\n fn from_str(s: &str) -> Result {\n if let Ok(addr) = s.parse::() {\n Ok(Self { addr, port: None })\n } else if let Ok(sock) = s.parse::() {\n Ok(Self {\n addr: sock.ip(),\n port: Some(sock.port()),\n })\n } else {\n Err(())\n }\n }\n}\n\nfn print_addr(s: &str) {\n match s.parse::() {\n Ok(addr) => println!(\"{}: {}\", s, addr),\n _ => println!(\"{} not a valid address\", s),\n }\n}\n\nfn main() {\n [\n \"127.0.0.1\",\n \"127.0.0.1:80\",\n \"::1\",\n \"[::1]:80\",\n \"2605:2700:0:3::4713:93e3\",\n \"[2605:2700:0:3::4713:93e3]:80\",\n ]\n .iter()\n .cloned()\n .for_each(print_addr);\n}\n"} {"name":"Parse command-line arguments","C":"#include \nint main(int argc, char **argv){\n int i;\n const char *commands[]={\"-c\", \"-p\", \"-t\", \"-d\", \"-a\", NULL};\n enum {CREATE,PRINT,TITLE,DATE,AUTH};\n if (argc<2) {\nusage: printf (\"Usage: %s [commands]\\n\" \n \"-c Create new entry.\\n\" \n \"-p Print the latest entry.\\n\" \n \"-t Sort by title.\\n\" \n \"-d Sort by date.\\n\" \n \"-a Sort by author.\\n\",argv[0]);\n return 0;\n }\n for (i=0;commands[i]&&strcmp(argv[1],commands[i]);i++);\n switch (i) {\n case CREATE:\n...\n break;\n case PRINT:\n...\n break;\n...\n...\n default:\n printf (\"Unknown command...\" ...);\n goto usage;\n }\n return 0;\n}\n","Rust":"use structopt::StructOpt;\n\n#[derive(StructOpt)]\nstruct Opt {\n #[structopt(short)]\n b: bool,\n #[structopt(short, required = false, default_value = \"\")]\n s: String,\n #[structopt(short, required = false, default_value = \"0\")]\n n: i32,\n}\n\nfn main() {\n let opt = Opt::from_args();\n println!(\"b: {}\", opt.b);\n println!(\"s: {}\", opt.s);\n println!(\"n: {}\", opt.n);\n}\n"} {"name":"Parsing_Shunting-yard algorithm","C":"#include \n#include \n#include \n\ntypedef struct {\n\tconst char *s;\n\tint len, prec, assoc;\n} str_tok_t;\n\ntypedef struct {\n\tconst char * str;\n\tint assoc, prec;\n\tregex_t re;\n} pat_t;\n\nenum assoc { A_NONE, A_L, A_R };\npat_t pat_eos = {\"\", A_NONE, 0};\n\npat_t pat_ops[] = {\n\t{\"^\\\\)\",\tA_NONE, -1},\n\t{\"^\\\\*\\\\*\",\tA_R, 3},\n\t{\"^\\\\^\",\tA_R, 3},\n\t{\"^\\\\*\",\tA_L, 2},\n\t{\"^\/\",\t\tA_L, 2},\n\t{\"^\\\\+\",\tA_L, 1},\n\t{\"^-\",\t\tA_L, 1},\n\t{0}\n};\n\npat_t pat_arg[] = {\n\t{\"^[-+]?[0-9]*\\\\.?[0-9]+([eE][-+]?[0-9]+)?\"},\n\t{\"^[a-zA-Z_][a-zA-Z_0-9]*\"},\n\t{\"^\\\\(\", A_L, -1},\n\t{0}\n};\n\nstr_tok_t stack[256]; \nstr_tok_t queue[256];\nint l_queue, l_stack;\n#define qpush(x) queue[l_queue++] = x\n#define spush(x) stack[l_stack++] = x\n#define spop() stack[--l_stack]\n\nvoid display(const char *s)\n{\n\tint i;\n\tprintf(\"\\033[1;1H\\033[JText | %s\", s);\n\tprintf(\"\\nStack| \");\n\tfor (i = 0; i < l_stack; i++)\n\t\tprintf(\"%.*s \", stack[i].len, stack[i].s); \n\tprintf(\"\\nQueue| \");\n\tfor (i = 0; i < l_queue; i++)\n\t\tprintf(\"%.*s \", queue[i].len, queue[i].s);\n\tputs(\"\\n\\n\");\n\tgetchar();\n}\n\nint prec_booster;\n\n#define fail(s1, s2) {fprintf(stderr, \"[Error %s] %s\\n\", s1, s2); return 0;}\n\nint init(void)\n{\n\tint i;\n\tpat_t *p;\n\n\tfor (i = 0, p = pat_ops; p[i].str; i++)\n\t\tif (regcomp(&(p[i].re), p[i].str, REG_NEWLINE|REG_EXTENDED))\n\t\t\tfail(\"comp\", p[i].str);\n\n\tfor (i = 0, p = pat_arg; p[i].str; i++)\n\t\tif (regcomp(&(p[i].re), p[i].str, REG_NEWLINE|REG_EXTENDED))\n\t\t\tfail(\"comp\", p[i].str);\n\n\treturn 1;\n}\n\npat_t* match(const char *s, pat_t *p, str_tok_t * t, const char **e)\n{\n\tint i;\n\tregmatch_t m;\n\n\twhile (*s == ' ') s++;\n\t*e = s;\n\n\tif (!*s) return &pat_eos;\n\n\tfor (i = 0; p[i].str; i++) {\n\t\tif (regexec(&(p[i].re), s, 1, &m, REG_NOTEOL))\n\t\t\tcontinue;\n\t\tt->s = s;\n\t\t*e = s + (t->len = m.rm_eo - m.rm_so);\n\t\treturn p + i;\n\t}\n\treturn 0;\n}\n\nint parse(const char *s) {\n\tpat_t *p;\n\tstr_tok_t *t, tok;\n\n\tprec_booster = l_queue = l_stack = 0;\n\tdisplay(s);\n\twhile (*s) {\n\t\tp = match(s, pat_arg, &tok, &s);\n\t\tif (!p || p == &pat_eos) fail(\"parse arg\", s);\n\n\t\t\n\t\tif (p->prec == -1) {\n\t\t\tprec_booster += 100;\n\t\t\tcontinue;\n\t\t}\n\t\tqpush(tok);\n\t\tdisplay(s);\n\nre_op:\t\tp = match(s, pat_ops, &tok, &s);\n\t\tif (!p) fail(\"parse op\", s);\n\n\t\ttok.assoc = p->assoc;\n\t\ttok.prec = p->prec;\n\n\t\tif (p->prec > 0)\n\t\t\ttok.prec = p->prec + prec_booster;\n\t\telse if (p->prec == -1) {\n\t\t\tif (prec_booster < 100)\n\t\t\t\tfail(\"unmatched )\", s);\n\t\t\ttok.prec = prec_booster;\n\t\t}\n\n\t\twhile (l_stack) {\n\t\t\tt = stack + l_stack - 1;\n\t\t\tif (!(t->prec == tok.prec && t->assoc == A_L)\n\t\t\t\t\t&& t->prec <= tok.prec)\n\t\t\t\tbreak;\n\t\t\tqpush(spop());\n\t\t\tdisplay(s);\n\t\t}\n\n\t\tif (p->prec == -1) {\n\t\t\tprec_booster -= 100;\n\t\t\tgoto re_op;\n\t\t}\n\n\t\tif (!p->prec) {\n\t\t\tdisplay(s);\n\t\t\tif (prec_booster)\n\t\t\t\tfail(\"unmatched (\", s);\n\t\t\treturn 1;\n\t\t}\n\n\t\tspush(tok);\n\t\tdisplay(s);\n\t}\n\n\tif (p->prec > 0)\n\t\tfail(\"unexpected eol\", s);\n\n\treturn 1;\n}\n\nint main()\n{\n\tint i;\n\tconst char *tests[] = { \n\t\t\"3 + 4 * 2 \/ ( 1 - 5 ) ^ 2 ^ 3\",\t\n\t\t\"123\",\t\t\t\t\t\n\t\t\"3+4 * 2 \/ ( 1 - 5 ) ^ 2 ^ 3.14\",\t\n\t\t\"(((((((1+2+3**(4 + 5))))))\",\t\t\n\t\t\"a^(b + c\/d * .1e5)!\",\t\t\t\n\t\t\"(1**2)**3\",\t\t\t\t\n\t\t\"2 + 2 *\",\t\t\t\t\n\t\t0\n\t};\n\n\tif (!init()) return 1;\n\tfor (i = 0; tests[i]; i++) {\n\t\tprintf(\"Testing string `%s' \\n\", tests[i]);\n\t\tgetchar();\n\n\t\tprintf(\"string `%s': %s\\n\\n\", tests[i],\n\t\t\tparse(tests[i]) ? \"Ok\" : \"Error\");\n\t}\n\n\treturn 0;\n}\n","Rust":"type Number = f64;\n\n#[derive(Debug, Copy, Clone, PartialEq)]\nstruct Operator {\n token: char,\n operation: fn(Number, Number) -> Number,\n precedence: u8,\n is_left_associative: bool,\n}\n\n#[derive(Debug, Clone, PartialEq)]\nenum Token {\n Digit(Number),\n Operator(Operator),\n LeftParen,\n RightParen,\n}\n\nimpl Operator {\n fn new_token(\n token: char,\n precedence: u8,\n is_left_associative: bool,\n operation: fn(Number, Number) -> Number,\n ) -> Token {\n Token::Operator(Operator {\n token: token,\n operation: operation,\n precedence: precedence,\n is_left_associative,\n })\n }\n\n fn apply(&self, x: Number, y: Number) -> Number {\n (self.operation)(x, y)\n }\n}\n\ntrait Stack {\n fn top(&self) -> Option;\n}\n\nimpl Stack for Vec {\n fn top(&self) -> Option {\n if self.is_empty() {\n return None;\n }\n self.last().cloned()\n }\n}\nfn lex_token(input: char) -> Result {\n let ret = match input {\n '0'...'9' => Token::Digit(input.to_digit(10).unwrap() as Number),\n '+' => Operator::new_token('+', 1, true, |x, y| x + y),\n '-' => Operator::new_token('-', 1, true, |x, y| x - y),\n '*' => Operator::new_token('*', 2, true, |x, y| x * y),\n '\/' => Operator::new_token('\/', 2, true, |x, y| x \/ y),\n '^' => Operator::new_token('^', 3, false, |x, y| x.powf(y)),\n '(' => Token::LeftParen,\n ')' => Token::RightParen,\n _ => return Err(input),\n };\n Ok(ret)\n}\n\nfn lex(input: String) -> Result, char> {\n input\n .chars()\n .filter(|c| !c.is_whitespace())\n .map(lex_token)\n .collect()\n}\n\nfn tilt_until(operators: &mut Vec, output: &mut Vec, stop: Token) -> bool {\n while let Some(token) = operators.pop() {\n if token == stop {\n return true;\n }\n output.push(token)\n }\n false\n}\n\nfn shunting_yard(tokens: Vec) -> Result, String> {\n let mut output: Vec = Vec::new();\n let mut operators: Vec = Vec::new();\n\n for token in tokens {\n match token {\n Token::Digit(_) => output.push(token),\n Token::LeftParen => operators.push(token),\n Token::Operator(operator) => {\n while let Some(top) = operators.top() {\n match top {\n Token::LeftParen => break,\n Token::Operator(top_op) => {\n let p = top_op.precedence;\n let q = operator.precedence;\n if (p > q) || (p == q && operator.is_left_associative) {\n output.push(operators.pop().unwrap());\n } else {\n break;\n }\n }\n _ => unreachable!(\"{:?} must not be on operator stack\", token),\n }\n }\n operators.push(token);\n }\n Token::RightParen => {\n if !tilt_until(&mut operators, &mut output, Token::LeftParen) {\n return Err(String::from(\"Mismatched ')'\"));\n }\n }\n }\n }\n\n if tilt_until(&mut operators, &mut output, Token::LeftParen) {\n return Err(String::from(\"Mismatched '('\"));\n }\n\n assert!(operators.is_empty());\n Ok(output)\n}\n\nfn calculate(postfix_tokens: Vec) -> Result {\n let mut stack = Vec::new();\n\n for token in postfix_tokens {\n match token {\n Token::Digit(number) => stack.push(number),\n Token::Operator(operator) => {\n if let Some(y) = stack.pop() {\n if let Some(x) = stack.pop() {\n stack.push(operator.apply(x, y));\n continue;\n }\n }\n return Err(format!(\"Missing operand for operator '{}'\", operator.token));\n }\n _ => unreachable!(\"Unexpected token {:?} during calculation\", token),\n }\n }\n\n assert!(stack.len() == 1);\n Ok(stack.pop().unwrap())\n}\n\nfn run(input: String) -> Result {\n let tokens = match lex(input) {\n Ok(tokens) => tokens,\n Err(c) => return Err(format!(\"Invalid character: {}\", c)),\n };\n let postfix_tokens = match shunting_yard(tokens) {\n Ok(tokens) => tokens,\n Err(message) => return Err(message),\n };\n\n calculate(postfix_tokens)\n}\n"} {"name":"Partition an integer x into n primes","C":"#include \n#include \n#include \n#include \n#include \n\ntypedef struct bit_array_tag {\n uint32_t size;\n uint32_t* array;\n} bit_array;\n\nbool bit_array_create(bit_array* b, uint32_t size) {\n uint32_t* array = calloc((size + 31)\/32, sizeof(uint32_t));\n if (array == NULL)\n return false;\n b->size = size;\n b->array = array;\n return true;\n}\n\nvoid bit_array_destroy(bit_array* b) {\n free(b->array);\n b->array = NULL;\n}\n\nvoid bit_array_set(bit_array* b, uint32_t index, bool value) {\n assert(index < b->size);\n uint32_t* p = &b->array[index >> 5];\n uint32_t bit = 1 << (index & 31);\n if (value)\n *p |= bit;\n else\n *p &= ~bit;\n}\n\nbool bit_array_get(const bit_array* b, uint32_t index) {\n assert(index < b->size);\n uint32_t bit = 1 << (index & 31);\n return (b->array[index >> 5] & bit) != 0;\n}\n\ntypedef struct sieve_tag {\n uint32_t limit;\n bit_array not_prime;\n} sieve;\n\nbool sieve_create(sieve* s, uint32_t limit) {\n if (!bit_array_create(&s->not_prime, limit + 1))\n return false;\n bit_array_set(&s->not_prime, 0, true);\n bit_array_set(&s->not_prime, 1, true);\n for (uint32_t p = 2; p * p <= limit; ++p) {\n if (bit_array_get(&s->not_prime, p) == false) {\n for (uint32_t q = p * p; q <= limit; q += p)\n bit_array_set(&s->not_prime, q, true);\n }\n }\n s->limit = limit;\n return true;\n}\n\nvoid sieve_destroy(sieve* s) {\n bit_array_destroy(&s->not_prime);\n}\n\nbool is_prime(const sieve* s, uint32_t n) {\n assert(n <= s->limit);\n return bit_array_get(&s->not_prime, n) == false;\n}\n\nbool find_prime_partition(const sieve* s, uint32_t number, uint32_t count,\n uint32_t min_prime, uint32_t* p) {\n if (count == 1) {\n if (number >= min_prime && is_prime(s, number)) {\n *p = number;\n return true;\n }\n return false;\n }\n for (uint32_t prime = min_prime; prime < number; ++prime) {\n if (!is_prime(s, prime))\n continue;\n if (find_prime_partition(s, number - prime, count - 1,\n prime + 1, p + 1)) {\n *p = prime;\n return true;\n }\n }\n return false;\n}\n\nvoid print_prime_partition(const sieve* s, uint32_t number, uint32_t count) {\n assert(count > 0);\n uint32_t* primes = malloc(count * sizeof(uint32_t));\n if (primes == NULL) {\n fprintf(stderr, \"Out of memory\\n\");\n return;\n }\n if (!find_prime_partition(s, number, count, 2, primes)) {\n printf(\"%u cannot be partitioned into %u primes.\\n\", number, count);\n } else {\n printf(\"%u = %u\", number, primes[0]);\n for (uint32_t i = 1; i < count; ++i)\n printf(\" + %u\", primes[i]);\n printf(\"\\n\");\n }\n free(primes);\n}\n\nint main() {\n const uint32_t limit = 100000;\n sieve s = { 0 };\n if (!sieve_create(&s, limit)) {\n fprintf(stderr, \"Out of memory\\n\");\n return 1;\n }\n print_prime_partition(&s, 99809, 1);\n print_prime_partition(&s, 18, 2);\n print_prime_partition(&s, 19, 3);\n print_prime_partition(&s, 20, 4);\n print_prime_partition(&s, 2017, 24);\n print_prime_partition(&s, 22699, 1);\n print_prime_partition(&s, 22699, 2);\n print_prime_partition(&s, 22699, 3);\n print_prime_partition(&s, 22699, 4);\n print_prime_partition(&s, 40355, 3);\n sieve_destroy(&s);\n return 0;\n}\n","Rust":"\nmod bit_array;\nmod prime_sieve;\n\nuse prime_sieve::PrimeSieve;\n\nfn find_prime_partition(\n sieve: &PrimeSieve,\n number: usize,\n count: usize,\n min_prime: usize,\n primes: &mut Vec,\n index: usize,\n) -> bool {\n if count == 1 {\n if number >= min_prime && sieve.is_prime(number) {\n primes[index] = number;\n return true;\n }\n return false;\n }\n for p in min_prime..number {\n if sieve.is_prime(p)\n && find_prime_partition(sieve, number - p, count - 1, p + 1, primes, index + 1)\n {\n primes[index] = p;\n return true;\n }\n }\n false\n}\n\nfn print_prime_partition(sieve: &PrimeSieve, number: usize, count: usize) {\n let mut primes = vec![0; count];\n if !find_prime_partition(sieve, number, count, 2, &mut primes, 0) {\n println!(\"{} cannot be partitioned into {} primes.\", number, count);\n } else {\n print!(\"{} = {}\", number, primes[0]);\n for i in 1..count {\n print!(\" + {}\", primes[i]);\n }\n println!();\n }\n}\n\nfn main() {\n let s = PrimeSieve::new(100000);\n print_prime_partition(&s, 99809, 1);\n print_prime_partition(&s, 18, 2);\n print_prime_partition(&s, 19, 3);\n print_prime_partition(&s, 20, 4);\n print_prime_partition(&s, 2017, 24);\n print_prime_partition(&s, 22699, 1);\n print_prime_partition(&s, 22699, 2);\n print_prime_partition(&s, 22699, 3);\n print_prime_partition(&s, 22699, 4);\n print_prime_partition(&s, 40355, 3);\n}\n"} {"name":"Partition function P","C":"#include \n#include \n#include \n#include \n#include \n\nmpz_t* partition(uint64_t n) {\n\tmpz_t *pn = (mpz_t *)malloc((n + 2) * sizeof(mpz_t));\n\tmpz_init_set_ui(pn[0], 1);\n\tmpz_init_set_ui(pn[1], 1);\n\tfor (uint64_t i = 2; i < n + 2; i ++) {\n\t\tmpz_init(pn[i]);\n\t\tfor (uint64_t k = 1, penta; ; k++) {\n\t\t\tpenta = k * (3 * k - 1) >> 1;\n\t\t\tif (penta >= i) break;\n\t\t\tif (k & 1) mpz_add(pn[i], pn[i], pn[i - penta]);\n\t\t\telse mpz_sub(pn[i], pn[i], pn[i - penta]);\n\t\t\tpenta += k;\n\t\t\tif (penta >= i) break;\n\t\t\tif (k & 1) mpz_add(pn[i], pn[i], pn[i - penta]);\n\t\t\telse mpz_sub(pn[i], pn[i], pn[i - penta]);\n\t\t}\n\t}\n\tmpz_t *tmp = &pn[n + 1];\n\tfor (uint64_t i = 0; i < n + 1; i ++) mpz_clear(pn[i]);\n\tfree(pn);\n\treturn tmp;\n}\n\nint main(int argc, char const *argv[]) {\n\tclock_t start = clock();\n\tmpz_t *p = partition(6666);\n\tgmp_printf(\"%Zd\\n\", p);\n\tprintf(\"Elapsed time:\u00a0%.04f seconds\\n\",\n\t\t(double)(clock() - start) \/ (double)CLOCKS_PER_SEC);\n\treturn 0;\n}\n","Rust":"\n\n\nuse rug::Integer;\n\nfn partitions(n: usize) -> Integer {\n let mut p = Vec::with_capacity(n + 1);\n p.push(Integer::from(1));\n for i in 1..=n {\n let mut num = Integer::from(0);\n let mut k = 1;\n loop {\n let mut j = (k * (3 * k - 1)) \/ 2;\n if j > i {\n break;\n }\n if (k & 1) == 1 {\n num += &p[i - j];\n } else {\n num -= &p[i - j];\n }\n j += k;\n if j > i {\n break;\n }\n if (k & 1) == 1 {\n num += &p[i - j];\n } else {\n num -= &p[i - j];\n }\n k += 1;\n }\n p.push(num);\n }\n p[n].clone()\n}\n\nfn main() {\n use std::time::Instant;\n let n = 6666;\n let now = Instant::now();\n let result = partitions(n);\n let time = now.elapsed();\n println!(\"P({}) = {}\", n, result);\n println!(\"elapsed time: {} microseconds\", time.as_micros());\n}\n"} {"name":"Penney's game","C":"#include \n#include \n#include \n\n#define SEQLEN 3\n\nint getseq(char *s)\n{\n int r = 0;\n int i = 1 << (SEQLEN - 1);\n\n while (*s && i) {\n switch (*s++) {\n case 'H':\n case 'h':\n r |= i;\n break;\n case 'T':\n case 't':\n \n break;\n default:\n return -1;\n }\n i >>= 1;\n }\n\n return r;\n}\n\nvoid printseq(int seq)\n{\n int i;\n for (i = SEQLEN - 1; i >= 0; --i)\n printf(\"%c\", seq & (1 << i) ? 'h' : 't');\n}\n\nint getuser(void)\n{\n int user;\n char s[SEQLEN + 1];\n\n printf(\"Enter your sequence of %d (h\/t): \", SEQLEN);\n while (1) {\n \n if (scanf(\"%3s\", s) != 1) exit(1);\n if ((user = getseq(s)) != -1) return user;\n printf(\"Please enter only h\/t characters: \");\n }\n}\n\nint getai(int user)\n{\n int ai;\n\n printf(\"Computers sequence of %d is: \", SEQLEN);\n \n if (user == -1)\n ai = rand() & (1 << SEQLEN) - 1;\n else\n ai = (user >> 1) | ((~user << 1) & (1 << SEQLEN - 1));\n\n printseq(ai);\n printf(\"\\n\");\n return ai;\n}\n\nint rungame(int user, int ai)\n{\n \n int last3 = rand() & (1 << SEQLEN) - 1;\n\n printf(\"Tossed sequence: \");\n printseq(last3);\n while (1) {\n if (user == last3) {\n printf(\"\\nUser wins!\\n\");\n return 1;\n }\n\n if (ai == last3) {\n printf(\"\\nAi wins!\\n\");\n return 0;\n }\n\n last3 = ((last3 << 1) & (1 << SEQLEN) - 2) | (rand() & 1);\n printf(\"%c\", last3 & 1 ? 'h' : 't');\n }\n}\n\nint main(void)\n{\n srand(time(NULL));\n int playerwins = 0;\n int totalgames = 0;\n\n \n while (1) {\n int user = -1;\n int ai = -1;\n\n printf(\"\\n\");\n if (rand() & 1) {\n ai = getai(user);\n user = getuser();\n }\n else {\n user = getuser();\n ai = getai(user);\n }\n \n playerwins += rungame(user, ai);\n totalgames++;\n\n printf(\"You have won %d out of %d games\\n\", playerwins, totalgames);\n printf(\"=================================\\n\");\n }\n\n return 0;\n}\n","Rust":"extern crate rand;\n\nuse std::io::{stdin, stdout, Write};\nuse std::thread;\nuse std::time::Duration;\n\nuse rand::Rng;\n\nfn toss_coin(rng: &mut R, print: bool) -> char {\n let c = if rng.gen() { 'H' } else { 'T' };\n if print {\n print!(\"{}\", c);\n stdout().flush().expect(\"Could not flush stdout\");\n }\n c\n}\n\nfn gen_sequence(rng: &mut R, seed: Option<&str>) -> String {\n let mut seq = String::new();\n match seed {\n Some(s) => {\n let mut iter = s.chars();\n let c0 = iter.next().unwrap();\n let next = if c0 == 'H' { 'T' } else { 'H' };\n seq.push(next);\n seq.push(c0);\n seq.push(iter.next().unwrap());\n }\n None => {\n for _ in 0..3 {\n seq.push(toss_coin(rng, false))\n }\n }\n }\n seq\n}\n\nfn read_sequence(used_seq: Option<&str>) -> String {\n let mut seq = String::new();\n loop {\n seq.clear();\n println!(\"Please, enter sequence of 3 coins: H (heads) or T (tails): \");\n stdin().read_line(&mut seq).expect(\"failed to read line\");\n seq = seq.trim().to_uppercase();\n \n if seq.len() == 3\n && seq.chars().all(|c| c == 'H' || c == 'T')\n && seq != used_seq.unwrap_or(\"\")\n {\n return seq;\n }\n\n println!(\"Please enter correct sequence!\");\n }\n}\n\nfn main() {\n let mut rng = rand::thread_rng();\n\n println!(\"--Penney's game--\");\n loop {\n let useq: String;\n let aiseq: String;\n if rng.gen::() {\n println!(\"You choose first!\");\n useq = read_sequence(None);\n println!(\"Your sequence: {}\", useq);\n aiseq = gen_sequence(&mut rng, Some(&useq));\n println!(\"My sequence: {}\", aiseq);\n } else {\n println!(\"I choose first!\");\n aiseq = gen_sequence(&mut rng, None);\n println!(\"My sequence: {}\", aiseq);\n useq = read_sequence(Some(&aiseq));\n println!(\"Your sequence: {}\", useq);\n }\n println!(\"Tossing coins...\");\n let mut coins = String::new();\n for _ in 0..2 {\n \n coins.push(toss_coin(&mut rng, true));\n thread::sleep(Duration::from_millis(500));\n }\n loop {\n coins.push(toss_coin(&mut rng, true));\n thread::sleep(Duration::from_millis(500));\n if coins.contains(&useq) {\n println!(\"\\nYou win!\");\n break;\n }\n if coins.contains(&aiseq) {\n println!(\"\\nI win!\");\n break;\n }\n }\n\n println!(\" Play again? 'Y' to play, 'Q' to exit.\");\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"failed to read line\");\n match input.trim_start().chars().next().unwrap() {\n 'Y' | 'y' => continue,\n _ => break,\n }\n }\n}\n"} {"name":"Perfect totient numbers","C":"#include\n#include\n\nlong totient(long n){\n\tlong tot = n,i;\n\t\n\tfor(i=2;i*i<=n;i+=2){\n\t\tif(n%i==0){\n\t\t\twhile(n%i==0)\n\t\t\t\tn\/=i;\n\t\t\ttot-=tot\/i;\n\t\t}\n\t\t\n\t\tif(i==2)\n\t\t\ti=1;\n\t}\n\t\n\tif(n>1)\n\t\ttot-=tot\/n;\n\t\n\treturn tot;\n}\n\nlong* perfectTotients(long n){\n\tlong *ptList = (long*)malloc(n*sizeof(long)), m,count=0,sum,tot;\n\t\n\tfor(m=1;count\",argV[0]);\n\telse{\n\t\tn = atoi(argV[1]);\n\t\t\n\t\tptList = perfectTotients(n);\n\t\t\n\t\tprintf(\"The first %d perfect Totient numbers are\u00a0: \\n[\",n);\n\t\t\n\t\tfor(i=0;i bool {\n let mut tot = 0;\n for i in 1..n {\n if gcd(n, i) == 1 {\n tot += 1\n }\n }\n unsafe {\n let sum = tot + CACHE[tot as usize];\n CACHE[n as usize] = sum;\n return n == sum;\n }\n}\n\nfn main() {\n let mut i = 1;\n let mut count = 0;\n while count < 20 {\n if is_perfect_totient(i) {\n print!(\"{} \", i);\n count += 1;\n }\n i += 1;\n }\n println!(\"{}\", \" \")\n}\n"} {"name":"Perlin noise","C":"#include\n#include\n#include\n\nint p[512];\n\ndouble fade(double t) { return t * t * t * (t * (t * 6 - 15) + 10); }\ndouble lerp(double t, double a, double b) { return a + t * (b - a); }\ndouble grad(int hash, double x, double y, double z) {\n int h = hash & 15; \n double u = h<8 ? x : y, \n v = h<4 ? y : h==12||h==14 ? x : z;\n return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);\n }\n \ndouble noise(double x, double y, double z) {\n int X = (int)floor(x) & 255, \n Y = (int)floor(y) & 255, \n Z = (int)floor(z) & 255;\n x -= floor(x); \n y -= floor(y); \n z -= floor(z);\n double u = fade(x), \n v = fade(y), \n w = fade(z);\n int A = p[X ]+Y, AA = p[A]+Z, AB = p[A+1]+Z, \n B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z; \n \n return lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ), \n grad(p[BA ], x-1, y , z )),\n lerp(u, grad(p[AB ], x , y-1, z ), \n grad(p[BB ], x-1, y-1, z ))),\n lerp(v, lerp(u, grad(p[AA+1], x , y , z-1 ), \n grad(p[BA+1], x-1, y , z-1 )), \n lerp(u, grad(p[AB+1], x , y-1, z-1 ),\n grad(p[BB+1], x-1, y-1, z-1 ))));\n }\n\nvoid loadPermutation(char* fileName){\n\tFILE* fp = fopen(fileName,\"r\");\n\tint permutation[256],i;\n\t\n\tfor(i=0;i<256;i++)\n\t\tfscanf(fp,\"%d\",&permutation[i]);\n\t\n\tfclose(fp);\n\t\n\tfor (int i=0; i < 256 ; i++) p[256+i] = p[i] = permutation[i];\n}\n\nint main(int argC,char* argV[])\n{\n\tif(argC!=5)\n\t\tprintf(\"Usage\u00a0: %s \");\n\telse{\n\t\tloadPermutation(argV[1]);\n\t\tprintf(\"Perlin Noise for (%s,%s,%s) is\u00a0%.17lf\",argV[2],argV[3],argV[4],noise(strtod(argV[2],NULL),strtod(argV[3],NULL),strtod(argV[4],NULL)));\n\t}\n\t\n\treturn 0;\n}\n","Rust":"fn main() {\n\tprintln!(\"{}\", noise(3.14, 42.0, 7.0));\n}\n\nfn noise(x: f64, y: f64, z: f64) -> f64 {\n\tlet x0 = x.floor() as usize & 255;\n\tlet y0 = y.floor() as usize & 255;\n\tlet z0 = z.floor() as usize & 255;\n\t\n\tlet x = x - x.floor();\n\tlet y = y - y.floor();\n\tlet z = z - z.floor();\n\t\n\tlet u = fade(x);\n\tlet v = fade(y);\n\tlet w = fade(z);\n\t\n\tlet a = P[x0] + y0;\n\tlet aa = P[a] + z0;\n\tlet ab = P[a + 1] + z0;\n\tlet b = P[x0 + 1] + y0;\n\tlet ba = P[b] + z0;\n\tlet bb = P[b + 1] + z0;\n\t\n\treturn lerp(w,\n\t\tlerp(v, lerp(u, grad(P[aa], x , y , z),\n\t\t\t\tgrad(P[ba], x-1.0, y , z)),\n\t\t\tlerp(u, grad(P[ab], x , y-1.0, z),\n grad(P[bb], x-1.0, y-1.0, z))),\n\t\tlerp(v, lerp(u, grad(P[aa+1], x , y , z-1.0),\n grad(P[ba+1], x-1.0, y , z-1.0)),\n lerp(u, grad(P[ab+1], x , y-1.0, z-1.0),\n grad(P[bb+1], x-1.0, y-1.0, z-1.0))));\n}\n\nfn fade(t: f64) -> f64 {\n\tt * t * t * ( t * (t * 6.0 - 15.0) + 10.0)\n}\n\nfn lerp(t: f64, a: f64, b: f64) -> f64 {\n\ta + t * (b - a)\n}\n\nfn grad(hash: usize, x: f64, y: f64, z: f64) -> f64 {\n\tlet h = hash & 15;\n\tlet u = if h < 8 { x } else { y };\n\tlet v = if h < 4 { y } else { if h == 12 || h == 14 { x } else { z } };\n\t\n\treturn if h&1 == 0 { u } else { -u } + if h&2 == 0 { v } else { -v };\n}\n\nstatic P: [usize; 512] = [151,160,137,91,90,15,131,13,201,95,96,53,194,233,\n\t7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,190, 6,148,247,120,234,\n\t75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,88,237,149,56,87,\n\t174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,77,146,158,\n\t231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,102,\n\t143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,\n\t135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,\n\t123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,\n\t28,42,223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167,\n\t43,172,9,129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,\n\t246,97,228,251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,\n\t14,239,107,49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127,\n\t4,150,254,138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,\n\t180,151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69\n\t,142,8,99,37,240,21,10,23,190, 6,148,247,120,234,75,0,26,197,62,94,252,219,\n\t203,117,35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168, 68,175,\n\t74,165,71,134,139,48,27,166, 77,146,158,231,83,111,229,122,60,211,133,230,\n\t220,105,92,41,55,46,245,40,244,102,143,54, 65,25,63,161, 1,216,80,73,209,\n\t76,132,187,208, 89,18,169,200,196,135,130,116,188,159,86,164,100,109,198,\n\t173,186, 3,64,52,217,226,250,124,123,5,202,38,147,118,126,255,82,85,212,\n\t207,206,59,227,47,16,58,17,182,189,28,42,223,183,170,213,119,248,152, 2,\n\t44,154,163, 70,221,153,101,155,167, 43,172,9,129,22,39,253, 19,98,108,\n\t110,79,113,224,232,178,185, 112,104,218,246,97,228,251,34,242,193,238,\n\t210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107, 49,192,214, 31,\n\t181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,138,236,205,\n\t93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180];\n"} {"name":"Permutations by swapping","C":"#include\n#include\n#include\n\nint flag = 1;\n\nvoid heapPermute(int n, int arr[],int arrLen){\n\tint temp;\n\tint i;\n\t\n\tif(n==1){\n\t\tprintf(\"\\n[\");\n\t\t\n\t\tfor(i=0;i\",argV[0]);\n\telse{\n\t\twhile(argV[1][i]!=00){\n\t\t\tif(argV[1][i++]==',')\n\t\t\t\tcount++;\n\t\t}\n\t\t\n\t\tarr = (int*)malloc(count*sizeof(int));\n\t\t\n\t\ti = 0;\n\t\t\n\t\ttoken = strtok(argV[1],\",\");\n\t\t\n\t\twhile(token!=NULL){\n\t\t\tarr[i++] = atoi(token);\n\t\t\ttoken = strtok(NULL,\",\");\n\t\t}\n\t\t\n\t\theapPermute(i,arr,count);\n\t}\n\t\t\n\treturn 0;\n}\n","Rust":"\n\nfn generate(a: &mut [T], output: F)\nwhere\n F: Fn(&[T], isize),\n{\n let n = a.len();\n let mut c = vec![0; n];\n let mut i = 1;\n let mut sign = 1;\n output(a, sign);\n while i < n {\n if c[i] < i {\n if (i & 1) == 0 {\n a.swap(0, i);\n } else {\n a.swap(c[i], i);\n }\n sign = -sign;\n output(a, sign);\n c[i] += 1;\n i = 1;\n } else {\n c[i] = 0;\n i += 1;\n }\n }\n}\n\nfn print_permutation(a: &[T], sign: isize) {\n println!(\"{:?} {}\", a, sign);\n}\n\nfn main() {\n println!(\"Permutations and signs for three items:\");\n let mut a = vec![0, 1, 2];\n generate(&mut a, print_permutation);\n\n println!(\"\\nPermutations and signs for four items:\");\n let mut b = vec![0, 1, 2, 3];\n generate(&mut b, print_permutation);\n}\n"} {"name":"Plasma effect","C":"#include\n#include\n#include\n#include\n#include\n\n#define pi M_PI\n\nint main()\n{\n\tCONSOLE_SCREEN_BUFFER_INFO info;\n int cols, rows;\n\ttime_t t;\n\tint i,j;\n\n GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);\n cols = info.srWindow.Right - info.srWindow.Left + 1;\n rows = info.srWindow.Bottom - info.srWindow.Top + 1;\n\t\n\tHANDLE console;\n\t\n\tconsole = GetStdHandle(STD_OUTPUT_HANDLE);\n\t\n\tsystem(\"@clear||cls\");\n\t\n\tsrand((unsigned)time(&t));\n\t\n\tfor(i=0;i f64 {\n ((x \/ 16.0).sin()\n + (y \/ 8.0).sin()\n + ((x + y) \/ 16.0).sin()\n + ((x * x + y * y).sqrt() \/ 8.0).sin()\n + 4.0)\n \/ 8.0\n}\n\n\nfn create_plasma_lut() -> Vec {\n let mut plasma: Vec = vec![0.0; WIDTH * HEIGHT];\n for y in 0..HEIGHT {\n for x in 0..WIDTH {\n plasma[(y * WIDTH) + x] = plasma_pixel(x as f64, y as f64);\n }\n }\n plasma\n}\n\n\n\nfn hsv_to_rgb(hue: f64, saturation: f64, value: f64) -> (u8, u8, u8) {\n let c = value * saturation;\n let h = hue * 6.0;\n let x = c * (1.0 - (h % 2.0 - 1.0).abs());\n let m = value - c;\n let (red, green, blue) = match (h % 6.0).floor() as u32 {\n 0 => (c, x, 0.0),\n 1 => (x, c, 0.0),\n 2 => (0.0, c, x),\n 3 => (0.0, x, c),\n 4 => (x, 0.0, c),\n _ => (c, 0.0, x),\n };\n \n (\n ((red + m) * 255.0).round() as u8,\n ((green + m) * 255.0).round() as u8,\n ((blue + m) * 255.0).round() as u8,\n )\n}\nfn main() {\n \n let mut framebuffer: Vec = vec![0; WIDTH * HEIGHT * 3];\n \n \n let plasma_lookup_table = create_plasma_lut();\n \n for (index, rgb) in framebuffer.chunks_mut(3).enumerate() {\n \n let hue_lookup = plasma_lookup_table[index] % 1.0;\n let (red, green, blue) = hsv_to_rgb(hue_lookup, 1.0, 1.0);\n rgb[0] = red;\n rgb[1] = green;\n rgb[2] = blue;\n }\n \n let output_path = Path::new(\"out.png\");\n match image::save_buffer(\n output_path,\n framebuffer.as_slice(),\n WIDTH as u32,\n HEIGHT as u32,\n ColorType::RGB(8),\n ) {\n Err(e) => println!(\"Error writing output image:\\n{}\", e),\n Ok(_) => println!(\"Output written to:\\n{}\", output_path.to_str().unwrap()),\n }\n}\n"} {"name":"Playing cards","C":"#include \n#include \n#include \n\nint locale_ok = 0;\n\nwchar_t s_suits[] = L\"\u2660\u2665\u2666\u2663\";\n\n\n\nconst char *s_suits_ascii[] = { \"S\", \"H\", \"D\", \"C\" };\nconst char *s_nums[] = { \"WHAT\",\n\t\"A\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"J\", \"Q\", \"K\",\n\t\"OVERFLOW\"\n};\n\ntypedef struct { int suit, number, _s; } card_t, *card;\ntypedef struct { int n; card_t cards[52]; } deck_t, *deck;\n\nvoid show_card(card c)\n{\n\tif (locale_ok)\n\t\tprintf(\" %lc%s\", s_suits[c->suit], s_nums[c->number]);\n\telse\n\t\tprintf(\" %s%s\", s_suits_ascii[c->suit], s_nums[c->number]);\n}\n\ndeck new_deck()\n{\n\tint i, j, k;\n\tdeck d = malloc(sizeof(deck_t));\n\td->n = 52;\n\tfor (i = k = 0; i < 4; i++)\n\t\tfor (j = 1; j <= 13; j++, k++) {\n\t\t\td->cards[k].suit = i;\n\t\t\td->cards[k].number = j;\n\t\t}\n\treturn d;\n}\n\nvoid show_deck(deck d)\n{\n\tint i;\n\tprintf(\"%d cards:\", d->n);\n\tfor (i = 0; i < d->n; i++)\n\t\tshow_card(d->cards + i);\n\tprintf(\"\\n\");\n}\n\nint cmp_card(const void *a, const void *b)\n{\n\tint x = ((card)a)->_s, y = ((card)b)->_s;\n\treturn x < y ? -1 : x > y;\n}\n\ncard deal_card(deck d)\n{\n\tif (!d->n) return 0;\n\treturn d->cards + --d->n;\n}\n\nvoid shuffle_deck(deck d)\n{\n\tint i;\n\tfor (i = 0; i < d->n; i++)\n\t\td->cards[i]._s = rand();\n\tqsort(d->cards, d->n, sizeof(card_t), cmp_card);\n}\n\nint main()\n{\n\tint i, j;\n\tdeck d = new_deck();\n\n\tlocale_ok = (0 != setlocale(LC_CTYPE, \"\"));\n\n\tprintf(\"New deck, \"); show_deck(d);\n\n\tprintf(\"\\nShuffle and deal to three players:\\n\");\n\tshuffle_deck(d);\n\tfor (i = 0; i < 3; i++) {\n\t\tfor (j = 0; j < 5; j++)\n\t\t\tshow_card(deal_card(d));\n\t\tprintf(\"\\n\");\n\t}\n\tprintf(\"Left in deck \"); show_deck(d);\n\n\t\n\t\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse std::fmt;\nuse rand::Rng;\nuse Pip::*;\nuse Suit::*;\n\n#[derive(Copy, Clone, Debug)]\nenum Pip { Ace, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King }\n\n#[derive(Copy, Clone, Debug)]\nenum Suit { Spades, Hearts, Diamonds, Clubs }\n\nstruct Card {\n\tpip: Pip,\n\tsuit: Suit\n}\n\nimpl fmt::Display for Card {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{:?} of {:?}\", self.pip, self.suit)\n }\n}\n\nstruct Deck(Vec);\n\nimpl Deck {\n fn new() -> Deck {\n let mut cards:Vec = Vec::with_capacity(52);\n for &suit in &[Spades, Hearts, Diamonds, Clubs] {\n for &pip in &[Ace, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King] {\n cards.push( Card{pip: pip, suit: suit} );\n }\n }\n Deck(cards)\n }\n\n fn deal(&mut self) -> Option {\n self.0.pop()\n }\n\n fn shuffle(&mut self) {\n rand::thread_rng().shuffle(&mut self.0)\n }\n}\n\nimpl fmt::Display for Deck {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n for card in self.0.iter() {\n writeln!(f, \"{}\", card);\n }\n write!(f, \"\")\n }\n}\n\nfn main() {\n let mut deck = Deck::new();\n deck.shuffle();\n \n for _ in 0..5 {\n println!(\"{}\", deck.deal().unwrap());\n }\n}\n"} {"name":"Poker hand analyser","C":"#include \n#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\n#define FACES \"23456789tjqka\"\n#define SUITS \"shdc\"\n\ntypedef int bool;\n\ntypedef struct {\n int face; \n char suit;\n} card;\n\ncard cards[5];\n\nint compare_card(const void *a, const void *b) {\n card c1 = *(card *)a;\n card c2 = *(card *)b;\n return c1.face - c2.face;\n}\n\nbool equals_card(card c1, card c2) {\n if (c1.face == c2.face && c1.suit == c2.suit) return TRUE;\n return FALSE;\n}\n\nbool are_distinct() {\n int i, j;\n for (i = 0; i < 4; ++i)\n for (j = i + 1; j < 5; ++j)\n if (equals_card(cards[i], cards[j])) return FALSE;\n return TRUE;\n}\n\nbool is_straight() {\n int i;\n qsort(cards, 5, sizeof(card), compare_card);\n if (cards[0].face + 4 == cards[4].face) return TRUE;\n if (cards[4].face == 12 && cards[0].face == 0 &&\n cards[3].face == 3) return TRUE;\n return FALSE;\n}\n\nbool is_flush() {\n int i;\n char suit = cards[0].suit;\n for (i = 1; i < 5; ++i) if (cards[i].suit != suit) return FALSE;\n return TRUE;\n}\n\nconst char *analyze_hand(const char *hand) {\n int i, j, gs = 0;\n char suit, *cp;\n bool found, flush, straight;\n int groups[13];\n if (strlen(hand) != 14) return \"invalid\";\n for (i = 0; i < 14; i += 3) {\n cp = strchr(FACES, tolower(hand[i]));\n if (cp == NULL) return \"invalid\";\n j = i \/ 3;\n cards[j].face = cp - FACES;\n suit = tolower(hand[i + 1]);\n cp = strchr(SUITS, suit);\n if (cp == NULL) return \"invalid\";\n cards[j].suit = suit;\n }\n if (!are_distinct()) return \"invalid\";\n for (i = 0; i < 13; ++i) groups[i] = 0;\n for (i = 0; i < 5; ++i) groups[cards[i].face]++;\n for (i = 0; i < 13; ++i) if (groups[i] > 0) gs++;\n switch(gs) {\n case 2:\n found = FALSE;\n for (i = 0; i < 13; ++i) if (groups[i] == 4) {\n found = TRUE;\n break;\n }\n if (found) return \"four-of-a-kind\";\n return \"full-house\";\n case 3:\n found = FALSE;\n for (i = 0; i < 13; ++i) if (groups[i] == 3) {\n found = TRUE;\n break;\n }\n if (found) return \"three-of-a-kind\";\n return \"two-pairs\";\n case 4:\n return \"one-pair\";\n default:\n flush = is_flush();\n straight = is_straight();\n if (flush && straight)\n return \"straight-flush\";\n else if (flush)\n return \"flush\";\n else if (straight)\n return \"straight\";\n else\n return \"high-card\";\n }\n}\n\nint main(){\n int i;\n const char *type;\n const char *hands[10] = {\n \"2h 2d 2c kc qd\",\n \"2h 5h 7d 8c 9s\",\n \"ah 2d 3c 4c 5d\",\n \"2h 3h 2d 3c 3d\",\n \"2h 7h 2d 3c 3d\",\n \"2h 7h 7d 7c 7s\",\n \"th jh qh kh ah\",\n \"4h 4s ks 5d ts\",\n \"qc tc 7c 6c 4c\",\n \"ah ah 7c 6c 4c\"\n };\n for (i = 0; i < 10; ++i) {\n type = analyze_hand(hands[i]);\n printf(\"%s: %s\\n\", hands[i], type);\n }\n return 0;\n}\n","Rust":"fn main() {\n let hands = vec![\n \"\ud83c\udca1 \ud83c\udcae \ud83c\udcad \ud83c\udcab \ud83c\udcaa\",\n \"\ud83c\udccf \ud83c\udcc2 \ud83c\udca2 \ud83c\udcae \ud83c\udccd\",\n \"\ud83c\udccf \ud83c\udcb5 \ud83c\udcc7 \ud83c\udca8 \ud83c\udcc9\",\n \"\ud83c\udccf \ud83c\udcc2 \ud83c\udca3 \ud83c\udca4 \ud83c\udca5\",\n \"\ud83c\udccf \ud83c\udcb3 \ud83c\udcc2 \ud83c\udca3 \ud83c\udcc3\",\n \"\ud83c\udccf \ud83c\udcb7 \ud83c\udcc2 \ud83c\udca3 \ud83c\udcc3\",\n \"\ud83c\udccf \ud83c\udcb7 \ud83c\udcc7 \ud83c\udca7 \ud83c\udcd7\",\n \"\ud83c\udccf \ud83c\udcbb \ud83c\udcbd \ud83c\udcbe \ud83c\udcb1\",\n \"\ud83c\udccf \ud83c\udcd4 \ud83c\udcde \ud83c\udcc5 \ud83c\udcaa\",\n \"\ud83c\udccf \ud83c\udcde \ud83c\udcd7 \ud83c\udcd6 \ud83c\udcd4\",\n \"\ud83c\udccf \ud83c\udcc2 \ud83c\udcdf \ud83c\udca4 \ud83c\udca5\",\n \"\ud83c\udccf \ud83c\udccd \ud83c\udcdf \ud83c\udca1 \ud83c\udcaa\",\n \"\ud83c\udccf \ud83c\udccd \ud83c\udcdf \ud83c\udcc1 \ud83c\udcca\",\n \"\ud83c\udccf \ud83c\udcc2 \ud83c\udca2 \ud83c\udcdf \ud83c\udccd\",\n \"\ud83c\udccf \ud83c\udcc2 \ud83c\udca2 \ud83c\udccd \ud83c\udccd\",\n \"\ud83c\udcc2 \ud83c\udcde \ud83c\udccd \ud83c\udcc1 \ud83c\udcca\",\n ];\n for hand in hands{\n println!(\"{} {}\", hand, poker_hand(hand));\n }\n}\n\nfn poker_hand(cards: &str) -> &str {\n let mut suits = vec![0u8; 4];\n let mut faces = vec![0u8; 15];\n let mut hand = vec![];\n\n for card in cards.chars(){\n if card == ' ' { continue; }\n let values = get_card_value(card);\n if values.0 < 14 && hand.contains(&values) {\n return \"invalid\";\n }\n hand.push(values);\n faces[values.0 as usize]+=1;\n if values.1 >= 0 {\n suits[values.1 as usize]+=1;\n }\n }\n if hand.len()!=5 {\n return \"invalid\";\n }\n faces[13] = faces[0]; \n let jokers = faces[14];\n\n \n let mut colors = suits.into_iter()\n .filter(|&x| x > 0).collect::>();\n colors.sort_unstable();\n colors[0] += jokers; \n let is_flush = colors[0] == 5;\n\n \n let mut is_straight = false;\n \n \n \n let mut ptr = 14;\n while ptr>3{\n let mut jokers_left = jokers;\n let mut straight_cards = 0;\n for i in (0..ptr).rev(){\n if faces[i]==0 {\n if jokers_left == 0 {break;}\n jokers_left -= 1;\n }\n else if i==ptr-1 { ptr-=1; }\n straight_cards+=1;\n }\n ptr-=1;\n if straight_cards == 5 {\n is_straight = true;\n break;\n }\n }\n\n \n let mut values = faces.into_iter().enumerate().take(14).filter(|&x| x.1>0).collect::>();\n \n values.sort_unstable_by(|a, b| if b.1 == a.1 { (b.0).cmp(&a.0) } else { (b.1).cmp(&a.1)} );\n let first_group = values[0].1 + jokers;\n let second_group = if values.len()>1 {values[1].1} else {0};\n \n match (is_flush, is_straight, first_group, second_group){\n (_,_,5,_) => \"five-of-a-kind\",\n (true, true, _, _) => if ptr == 8 {\"royal-flush\"} else {\"straight-flush\"},\n (_,_,4,_) => \"four-of-a-kind\",\n (_,_,3,2) => \"full-house\",\n (true,_,_,_) => \"flush\",\n (_,true,_,_) => \"straight\",\n (_,_,3,_) => \"three-of-a-kind\",\n (_,_,2,2) => \"two-pair\",\n (_,_,2,_) => \"one-pair\",\n _ => \"high-card\"\n }\n}\n\nfn get_card_value(card: char) -> (i8,i8) {\n \n let base = card as u32 - 0x1F0A1;\n let mut suit = (base \/ 16) as i8;\n let mut face = (base % 16) as i8;\n if face > 11 && face < 14 { face-=1; } \n if face == 14 { suit = -1; } \n (face, suit)\n}\n"} {"name":"Prime conspiracy","C":"#include \n#include \n#include \n\ntypedef unsigned char byte;\n\nstruct Transition {\n byte a, b;\n unsigned int c;\n} transitions[100];\n\nvoid init() {\n int i, j;\n for (i = 0; i < 10; i++) {\n for (j = 0; j < 10; j++) {\n int idx = i * 10 + j;\n transitions[idx].a = i;\n transitions[idx].b = j;\n transitions[idx].c = 0;\n }\n }\n}\n\nvoid record(int prev, int curr) {\n byte pd = prev % 10;\n byte cd = curr % 10;\n int i;\n\n for (i = 0; i < 100; i++) {\n int z = 0;\n if (transitions[i].a == pd) {\n int t = 0;\n if (transitions[i].b == cd) {\n transitions[i].c++;\n break;\n }\n }\n }\n}\n\nvoid printTransitions(int limit, int last_prime) {\n int i;\n\n printf(\"%d primes, last prime considered: %d\\n\", limit, last_prime);\n\n for (i = 0; i < 100; i++) {\n if (transitions[i].c > 0) {\n printf(\"%d->%d count: %5d frequency:\u00a0%.2f\\n\", transitions[i].a, transitions[i].b, transitions[i].c, 100.0 * transitions[i].c \/ limit);\n }\n }\n}\n\nbool isPrime(int n) {\n int s, t, a1, a2;\n\n if (n % 2 == 0) return n == 2;\n if (n % 3 == 0) return n == 3;\n if (n % 5 == 0) return n == 5;\n if (n % 7 == 0) return n == 7;\n if (n % 11 == 0) return n == 11;\n if (n % 13 == 0) return n == 13;\n if (n % 17 == 0) return n == 17;\n if (n % 19 == 0) return n == 19;\n\n \n t = 23;\n a1 = 96;\n a2 = 216;\n s = t * t;\n while (s <= n) {\n if (n % t == 0) return false;\n\n \n s += a1;\n t += 2;\n a1 += 24;\n assert(t * t == s);\n\n if (s <= n) {\n if (n % t == 0) return false;\n\n \n s += a2;\n t += 4;\n a2 += 48;\n assert(t * t == s);\n }\n }\n\n return true;\n}\n\n#define LIMIT 1000000\nint main() {\n int last_prime = 3, n = 5, count = 2;\n\n init();\n record(2, 3);\n\n while (count < LIMIT) {\n if (isPrime(n)) {\n record(last_prime, n);\n last_prime = n;\n count++;\n }\n n += 2;\n\n if (count < LIMIT) {\n if (isPrime(n)) {\n record(last_prime, n);\n last_prime = n;\n count++;\n }\n n += 4;\n }\n }\n\n printTransitions(LIMIT, last_prime);\n\n return 0;\n}\n","Rust":"\nmod bit_array;\nmod prime_sieve;\n\nuse prime_sieve::PrimeSieve;\n\n\nfn upper_bound_for_nth_prime(n: usize) -> usize {\n let x = n as f64;\n (x * (x.ln() + x.ln().ln())) as usize\n}\n\nfn compute_transitions(limit: usize) {\n use std::collections::BTreeMap;\n let mut transitions = BTreeMap::new();\n let mut prev = 2;\n let mut count = 0;\n let sieve = PrimeSieve::new(upper_bound_for_nth_prime(limit));\n let mut n = 3;\n while count < limit {\n if sieve.is_prime(n) {\n count += 1;\n let digit = n % 10;\n let key = (prev, digit);\n if let Some(v) = transitions.get_mut(&key) {\n *v += 1;\n } else {\n transitions.insert(key, 1);\n }\n prev = digit;\n }\n n += 2;\n }\n println!(\"First {} prime numbers:\", limit);\n for ((from, to), c) in &transitions {\n let freq = 100.0 * (*c as f32) \/ (limit as f32);\n println!(\n \"{} -> {}: count = {:7}, frequency = {:.2}\u00a0%\",\n from, to, c, freq\n );\n }\n}\n\nfn main() {\n compute_transitions(1000000);\n println!();\n compute_transitions(100000000);\n}\n"} {"name":"Prime triangle","C":"#include \n#include \n#include \n#include \n\nbool is_prime(unsigned int n) {\n assert(n < 64);\n static bool isprime[] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0,\n 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1,\n 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0};\n return isprime[n];\n}\n\nvoid swap(unsigned int* a, size_t i, size_t j) {\n unsigned int tmp = a[i];\n a[i] = a[j];\n a[j] = tmp;\n}\n\nbool prime_triangle_row(unsigned int* a, size_t length) {\n if (length == 2)\n return is_prime(a[0] + a[1]);\n for (size_t i = 1; i + 1 < length; i += 2) {\n if (is_prime(a[0] + a[i])) {\n swap(a, i, 1);\n if (prime_triangle_row(a + 1, length - 1))\n return true;\n swap(a, i, 1);\n }\n }\n return false;\n}\n\nint prime_triangle_count(unsigned int* a, size_t length) {\n int count = 0;\n if (length == 2) {\n if (is_prime(a[0] + a[1]))\n ++count;\n } else {\n for (size_t i = 1; i + 1 < length; i += 2) {\n if (is_prime(a[0] + a[i])) {\n swap(a, i, 1);\n count += prime_triangle_count(a + 1, length - 1);\n swap(a, i, 1);\n }\n }\n }\n return count;\n}\n\nvoid print(unsigned int* a, size_t length) {\n if (length == 0)\n return;\n printf(\"%2u\", a[0]);\n for (size_t i = 1; i < length; ++i)\n printf(\" %2u\", a[i]);\n printf(\"\\n\");\n}\n\nint main() {\n clock_t start = clock();\n for (unsigned int n = 2; n < 21; ++n) {\n unsigned int a[n];\n for (unsigned int i = 0; i < n; ++i)\n a[i] = i + 1;\n if (prime_triangle_row(a, n))\n print(a, n);\n }\n printf(\"\\n\");\n for (unsigned int n = 2; n < 21; ++n) {\n unsigned int a[n];\n for (unsigned int i = 0; i < n; ++i)\n a[i] = i + 1;\n if (n > 2)\n printf(\" \");\n printf(\"%d\", prime_triangle_count(a, n));\n }\n printf(\"\\n\");\n clock_t end = clock();\n double duration = (end - start + 0.0) \/ CLOCKS_PER_SEC;\n printf(\"\\nElapsed time: %f seconds\\n\", duration);\n return 0;\n}\n","Rust":"fn is_prime(n: u32) -> bool {\n assert!(n < 64);\n ((1u64 << n) & 0x28208a20a08a28ac) != 0\n}\n\nfn prime_triangle_row(a: &mut [u32]) -> bool {\n if a.len() == 2 {\n return is_prime(a[0] + a[1]);\n }\n for i in (1..a.len() - 1).step_by(2) {\n if is_prime(a[0] + a[i]) {\n a.swap(i, 1);\n if prime_triangle_row(&mut a[1..]) {\n return true;\n }\n a.swap(i, 1);\n }\n }\n false\n}\n\nfn prime_triangle_count(a: &mut [u32]) -> u32 {\n let mut count = 0;\n if a.len() == 2 {\n if is_prime(a[0] + a[1]) {\n count += 1;\n }\n } else {\n for i in (1..a.len() - 1).step_by(2) {\n if is_prime(a[0] + a[i]) {\n a.swap(i, 1);\n count += prime_triangle_count(&mut a[1..]);\n a.swap(i, 1);\n }\n }\n }\n count\n}\n\nfn print(a: &[u32]) {\n if a.is_empty() {\n return;\n }\n print!(\"{:2}\", a[0]);\n for x in &a[1..] {\n print!(\" {:2}\", x);\n }\n println!();\n}\n\nfn main() {\n use std::time::Instant;\n let start = Instant::now();\n for n in 2..21 {\n let mut a: Vec = (1..=n).collect();\n if prime_triangle_row(&mut a) {\n print(&a);\n }\n }\n println!();\n for n in 2..21 {\n let mut a: Vec = (1..=n).collect();\n if n > 2 {\n print!(\" \");\n }\n print!(\"{}\", prime_triangle_count(&mut a));\n }\n println!();\n let time = start.elapsed();\n println!(\"\\nElapsed time: {} milliseconds\", time.as_millis());\n}\n"} {"name":"Primorial numbers","C":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nint es_check(uint32_t *sieve, uint64_t n)\n{\n if ((n != 2 && !(n & 1)) || (n < 2))\n return 0;\n else\n return !(sieve[n >> 6] & (1 << (n >> 1 & 31)));\n}\n\nuint32_t *es_sieve(const uint64_t nth, uint64_t *es_size)\n{\n *es_size = nth * log(nth) + nth * (log(log(nth)) - 0.9385f) + 1;\n uint32_t *sieve = calloc((*es_size >> 6) + 1, sizeof(uint32_t));\n\n for (uint64_t i = 3; i < sqrt(*es_size) + 1; i += 2)\n if (!(sieve[i >> 6] & (1 << (i >> 1 & 31))))\n for (uint64_t j = i * i; j < *es_size; j += (i << 1))\n sieve[j >> 6] |= (1 << (j >> 1 & 31));\n\n return sieve;\n}\n\nsize_t mpz_number_of_digits(const mpz_t op)\n{\n char *opstr = mpz_get_str(NULL, 10, op);\n const size_t oplen = strlen(opstr);\n free(opstr);\n return oplen;\n}\n\n#define PRIMORIAL_LIMIT 1000000\n\nint main(void)\n{\n \n uint64_t sieve_size;\n uint32_t *sieve = es_sieve(PRIMORIAL_LIMIT, &sieve_size);\n\n mpz_t primorial;\n mpz_init_set_ui(primorial, 1);\n\n uint64_t prime_count = 0;\n int print = 1;\n double unused;\n\n for (uint64_t i = 2; i < sieve_size && prime_count <= PRIMORIAL_LIMIT; ++i) {\n if (print) {\n if (prime_count < 10)\n gmp_printf(\"Primorial(%\" PRIu64 \") = %Zd\\n\", prime_count, primorial);\n \n else if (!modf(log10(prime_count), &unused))\n printf(\"Primorial(%\" PRIu64 \") has %zu digits\\n\", prime_count, mpz_number_of_digits(primorial));\n print = 0;\n }\n\n if (es_check(sieve, i)) {\n mpz_mul_ui(primorial, primorial, i);\n prime_count++;\n print = 1;\n }\n\n }\n\n free(sieve);\n mpz_clear(primorial);\n return 0;\n}\n","Rust":"extern crate primal;\nextern crate rayon;\nextern crate rug;\n\nuse rayon::prelude::*;\nuse rug::Integer;\n\nfn partial(p1 : usize, p2 : usize) -> String {\n let mut aux = Integer::from(1);\n let (_, hi) = primal::estimate_nth_prime(p2 as u64);\n let sieve = primal::Sieve::new(hi as usize);\n let prime1 = sieve.nth_prime(p1);\n let prime2 = sieve.nth_prime(p2);\n\n for i in sieve.primes_from(prime1).take_while(|i| *i <= prime2) {\n aux = Integer::from(aux * i as u32);\n }\n aux.to_string_radix(10)\n}\n\nfn main() {\n let mut j1 = Integer::new();\n for k in [2,3,5,7,11,13,17,19,23,29].iter() { \n j1.assign_primorial(*k);\n println!(\"Primorial\u00a0: {}\", j1);\n }\n println!(\"Digits of primorial 10\u00a0: {}\", partial(1, 10).chars().fold(0, |n, _| n + 1));\n println!(\"Digits of primorial 100\u00a0: {}\", partial(1, 100).chars().fold(0, |n, _| n + 1));\n println!(\"Digits of primorial 1_000\u00a0: {}\", partial(1, 1_000).chars().fold(0, |n, _| n + 1));\n println!(\"Digits of primorial 10_000\u00a0: {}\", partial(1, 10_000).chars().fold(0, |n, _| n + 1));\n println!(\"Digits of primorial 100_000\u00a0: {}\", partial(1, 100_000).chars().fold(0, |n, _| n + 1));\n \n let mut auxi = Integer::from(1);\n let ranges = vec![[1, 300_000], [300_001, 550_000], [550_001, 800_000], [800_001, 1_000_000]];\n let v = ranges.par_iter().map(|value| partial(value[0], value[1])).collect::>();\n for i in v.iter() {\n auxi =Integer::from(&auxi * i.parse::().unwrap());\n }\n let result = auxi.to_string_radix(10).chars().fold(0, |n, _| n+1);\n println!(\"Digits of primorial 1_000_000\u00a0: {}\",result);\n}\n"} {"name":"Pythagoras tree","C":"#include\n#include\n#include\n#include\n\ntypedef struct{\n\tdouble x,y;\n}point;\n\nvoid pythagorasTree(point a,point b,int times){\n\t\n\tpoint c,d,e;\n\t\n\tc.x = b.x - (a.y - b.y);\n\tc.y = b.y - (b.x - a.x);\n\t\n\td.x = a.x - (a.y - b.y);\n\td.y = a.y - (b.x - a.x);\n\t\n\te.x = d.x + ( b.x - a.x - (a.y - b.y) ) \/ 2;\n\te.y = d.y - ( b.x - a.x + a.y - b.y ) \/ 2;\n\t\n\tif(times>0){\n\t\tsetcolor(rand()%15 + 1);\n\t\t\n\t\tline(a.x,a.y,b.x,b.y);\n\t\tline(c.x,c.y,b.x,b.y);\n\t\tline(c.x,c.y,d.x,d.y);\n\t\tline(a.x,a.y,d.x,d.y);\n\t\t\n\t\tpythagorasTree(d,e,times-1);\n\t\tpythagorasTree(e,c,times-1);\n\t}\n}\n\nint main(){\n\t\n\tpoint a,b;\n\tdouble side;\n\tint iter;\n\t\n\ttime_t t;\n\t\n\tprintf(\"Enter initial side length\u00a0: \");\n\tscanf(\"%lf\",&side);\n\t\n\tprintf(\"Enter number of iterations\u00a0: \");\n\tscanf(\"%d\",&iter);\n\t\n\ta.x = 6*side\/2 - side\/2;\n\ta.y = 4*side;\n\tb.x = 6*side\/2 + side\/2;\n\tb.y = 4*side;\n\t\n\tinitwindow(6*side,4*side,\"Pythagoras Tree\u00a0?\");\n\t\n\tsrand((unsigned)time(&t));\n\t\n\tpythagorasTree(a,b,iter);\n\t\n\tgetch();\n\t\n\tclosegraph();\n\t\n\treturn 0;\n\n}\n","Rust":"\n\nuse svg::node::element::{Group, Polygon};\n\nfn main() {\n let mut doc = svg::Document::new().set(\"stroke\", \"white\");\n let mut base: Vec<[(f64, f64); 2]> = vec![[(-200.0, 0.0), (200.0, 0.0)]];\n for lvl in 0..12u8 {\n let rg = |step| lvl.wrapping_mul(step).wrapping_add(80 - step * 2);\n let mut group = Group::new().set(\"fill\", format!(\"#{:02X}{:02X}18\", rg(20), rg(30))); \n let mut next_base = Vec::new();\n for [a, b] in base {\n let v = (b.0 - a.0, b.1 - a.1);\n let c = (a.0 + v.1, a.1 - v.0);\n let d = (c.0 + v.0, c.1 + v.1);\n let e = (c.0 + 0.5 * (v.0 + v.1), c.1 + 0.5 * (v.1 - v.0));\n group = group.add(Polygon::new().set(\"points\", vec![a, c, e, d, c, d, b]));\n next_base.extend([[c, e], [e, d]]);\n }\n base = next_base;\n doc = doc.add(group);\n }\n let (x0, y0) = (base.iter()).fold((0.0, 0.0), |(x0, y0), [(x, y), _]| (x.min(x0), y.min(y0)));\n let file = \"pythagoras_tree.svg\";\n match svg::save(file, &doc.set(\"viewBox\", (x0, y0, -x0 * 2.0, -y0))) {\n Ok(_) => println!(\"{file} file written successfully!\"),\n Err(e) => println!(\"failed to write {file}: {e}\"),\n }\n}\n"} {"name":"Pythagorean quadruples","C":"#include \n#include \n#include \n\n#define N 2200\n\nint main(int argc, char **argv){\n int a,b,c,d;\n int r[N+1];\n memset(r,0,sizeof(r));\t\n for(a=1; a<=N; a++){\n for(b=a; b<=N; b++){\n\t int aabb;\n\t if(a&1 && b&1) continue; \n\t aabb=a*a + b*b;\n\t for(c=b; c<=N; c++){\n\t int aabbcc=aabb + c*c;\n\t d=(int)sqrt((float)aabbcc);\n\t if(aabbcc == d*d && d<=N) r[d]=1;\t\n\t }\n }\n }\n for(a=1; a<=N; a++)\n if(!r[a]) printf(\"%d \",a);\t\n printf(\"\\n\");\n}\n","Rust":"use std::collections::BinaryHeap;\n\nfn a094958_iter() -> Vec {\n (0..12)\n .map(|n| vec![1 << n, 5 * (1 << n)])\n .flatten()\n .filter(|x| x < &2200)\n .collect::>()\n .into_sorted_vec()\n}\n\nfn a094958_filter() -> Vec {\n (1..2200) \n .filter(|n| ((n & (n - 1) == 0) || (n % 5 == 0 && ((n \/ 5) & (n \/ 5 - 1) == 0))))\n .collect()\n}\n\nfn a094958_loop() -> Vec {\n let mut v = vec![];\n for n in 0..12 {\n v.push(1 << n);\n if 5 * (1 << n) < 2200 {\n v.push(5 * (1 << n));\n }\n }\n v.sort();\n return v;\n}\n\nfn main() {\n println!(\"{:?}\", a094958_iter());\n println!(\"{:?}\", a094958_loop());\n println!(\"{:?}\", a094958_filter());\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n static HAPPY: &str = \"[1, 2, 4, 5, 8, 10, 16, 20, 32, 40, 64, 80, 128, 160, 256, 320, 512, 640, 1024, 1280, 2048]\";\n #[test]\n fn test_a094958_iter() {\n assert!(format!(\"{:?}\", a094958_iter()) == HAPPY);\n }\n #[test]\n fn test_a094958_loop() {\n assert!(format!(\"{:?}\", a094958_loop()) == HAPPY);\n }\n #[test]\n fn test_a094958_filter() {\n assert!(format!(\"{:?}\", a094958_filter()) == HAPPY);\n }\n}\n"} {"name":"RPG attributes generator","C":"#include \n#include \n#include \n\nint compareInts(const void *i1, const void *i2) {\n int a = *((int *)i1);\n int b = *((int *)i2);\n return a - b;\n}\n\nint main() {\n int i, j, nsum, vsum, vcount, values[6], numbers[4];\n srand(time(NULL));\n for (;;) {\n vsum = 0;\n for (i = 0; i < 6; ++i) {\n for (j = 0; j < 4; ++j) {\n numbers[j] = 1 + rand() % 6;\n }\n qsort(numbers, 4, sizeof(int), compareInts);\n nsum = 0;\n for (j = 1; j < 4; ++j) {\n nsum += numbers[j];\n }\n values[i] = nsum;\n vsum += values[i];\n }\n if (vsum < 75) continue;\n vcount = 0;\n for (j = 0; j < 6; ++j) {\n if (values[j] >= 15) vcount++;\n }\n if (vcount < 2) continue;\n printf(\"The 6 random numbers generated are:\\n\");\n printf(\"[\");\n for (j = 0; j < 6; ++j) printf(\"%d \", values[j]);\n printf(\"\\b]\\n\");\n printf(\"\\nTheir sum is %d and %d of them are >= 15\\n\", vsum, vcount);\n break;\n }\n return 0;\n}\n","Rust":"use rand::distributions::Uniform;\nuse rand::prelude::{thread_rng, ThreadRng};\nuse rand::Rng;\n\nfn main() {\n for _ in 0..=10 {\n attributes_engine();\n }\n}\n\n#[derive(Copy, Clone, Debug)]\npub struct Dice {\n amount: i32,\n range: Uniform,\n rng: ThreadRng,\n}\n\nimpl Dice {\n \n \n \n pub fn new(amount: i32, size: i32) -> Self {\n Self {\n amount,\n range: Uniform::new(1, size + 1),\n rng: thread_rng(),\n }\n }\n\n fn roll_pool(mut self) -> Vec {\n (0..self.amount)\n .map(|_| self.rng.sample(self.range))\n .collect()\n }\n\n fn attribute_out(&self) -> i32 {\n \n let mut attribute_array: Vec = self.roll_pool();\n attribute_array.sort();\n attribute_array.drain(1..=3).sum()\n }\n}\n\nfn attributes_finalizer() -> (Vec, i32, bool) {\n let die: Dice = Dice::new(4, 6);\n let mut attributes: Vec = Vec::new();\n\n for _ in 0..6 {\n attributes.push(die.attribute_out())\n }\n \n let attributes_total: i32 = attributes.iter().sum();\n\n let numerical_condition: bool = attributes\n .iter()\n .filter(|attribute| **attribute >= 15)\n .count()\n >= 2;\n\n (attributes, attributes_total, numerical_condition)\n}\n\nfn attributes_engine() {\n loop {\n let (attributes, attributes_total, numerical_condition) = attributes_finalizer();\n if (attributes_total >= 75) && (numerical_condition) {\n println!(\n \"{:?} | sum: {:?}\",\n attributes, attributes_total\n );\n break;\n } else {\n continue;\n }\n }\n}\n"} {"name":"Ramer-Douglas-Peucker line simplification","C":"#include \n#include \n#include \n\ntypedef struct point_tag {\n double x;\n double y;\n} point_t;\n\n\ndouble perpendicular_distance(point_t p, point_t p1, point_t p2) {\n double dx = p2.x - p1.x;\n double dy = p2.y - p1.y;\n double d = sqrt(dx * dx + dy * dy);\n return fabs(p.x * dy - p.y * dx + p2.x * p1.y - p2.y * p1.x)\/d;\n}\n\n\n\nsize_t douglas_peucker(const point_t* points, size_t n, double epsilon,\n point_t* dest, size_t destlen) {\n assert(n >= 2);\n assert(epsilon >= 0);\n double max_dist = 0;\n size_t index = 0;\n for (size_t i = 1; i + 1 < n; ++i) {\n double dist = perpendicular_distance(points[i], points[0], points[n - 1]);\n if (dist > max_dist) {\n max_dist = dist;\n index = i;\n }\n }\n if (max_dist > epsilon) {\n size_t n1 = douglas_peucker(points, index + 1, epsilon, dest, destlen);\n if (destlen >= n1 - 1) {\n destlen -= n1 - 1;\n dest += n1 - 1;\n } else {\n destlen = 0;\n }\n size_t n2 = douglas_peucker(points + index, n - index, epsilon, dest, destlen);\n return n1 + n2 - 1;\n }\n if (destlen >= 2) {\n dest[0] = points[0];\n dest[1] = points[n - 1];\n }\n return 2;\n}\n\nvoid print_points(const point_t* points, size_t n) {\n for (size_t i = 0; i < n; ++i) {\n if (i > 0)\n printf(\" \");\n printf(\"(%g, %g)\", points[i].x, points[i].y);\n }\n printf(\"\\n\");\n}\n\nint main() {\n point_t points[] = {\n {0,0}, {1,0.1}, {2,-0.1}, {3,5}, {4,6},\n {5,7}, {6,8.1}, {7,9}, {8,9}, {9,9}\n };\n const size_t len = sizeof(points)\/sizeof(points[0]);\n point_t out[len];\n size_t n = douglas_peucker(points, len, 1.0, out, len);\n print_points(out, n);\n return 0;\n}\n","Rust":"#[derive(Copy, Clone)]\nstruct Point {\n x: f64,\n y: f64,\n}\n\nuse std::fmt;\n\nimpl fmt::Display for Point {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"({}, {})\", self.x, self.y)\n }\n}\n\n\nfn perpendicular_distance(p: &Point, p1: &Point, p2: &Point) -> f64 {\n let dx = p2.x - p1.x;\n let dy = p2.y - p1.y;\n (p.x * dy - p.y * dx + p2.x * p1.y - p2.y * p1.x).abs() \/ dx.hypot(dy)\n}\n\nfn rdp(points: &[Point], epsilon: f64, result: &mut Vec) {\n let n = points.len();\n if n < 2 {\n return;\n }\n let mut max_dist = 0.0;\n let mut index = 0;\n for i in 1..n - 1 {\n let dist = perpendicular_distance(&points[i], &points[0], &points[n - 1]);\n if dist > max_dist {\n max_dist = dist;\n index = i;\n }\n }\n if max_dist > epsilon {\n rdp(&points[0..=index], epsilon, result);\n rdp(&points[index..n], epsilon, result);\n } else {\n result.push(points[n - 1]);\n }\n}\n\nfn ramer_douglas_peucker(points: &[Point], epsilon: f64) -> Vec {\n let mut result = Vec::new();\n if points.len() > 0 && epsilon >= 0.0 {\n result.push(points[0]);\n rdp(points, epsilon, &mut result);\n }\n result\n}\n\nfn main() {\n let points = vec![\n Point { x: 0.0, y: 0.0 },\n Point { x: 1.0, y: 0.1 },\n Point { x: 2.0, y: -0.1 },\n Point { x: 3.0, y: 5.0 },\n Point { x: 4.0, y: 6.0 },\n Point { x: 5.0, y: 7.0 },\n Point { x: 6.0, y: 8.1 },\n Point { x: 7.0, y: 9.0 },\n Point { x: 8.0, y: 9.0 },\n Point { x: 9.0, y: 9.0 },\n ];\n for p in ramer_douglas_peucker(&points, 1.0) {\n println!(\"{}\", p);\n }\n}\n"} {"name":"Ray-casting algorithm","C":"#include \n#include \n#include \n\ntypedef struct { double x, y; } vec;\ntypedef struct { int n; vec* v; } polygon_t, *polygon;\n\n#define BIN_V(op, xx, yy) vec v##op(vec a,vec b){vec c;c.x=xx;c.y=yy;return c;}\n#define BIN_S(op, r) double v##op(vec a, vec b){ return r; }\nBIN_V(sub, a.x - b.x, a.y - b.y);\nBIN_V(add, a.x + b.x, a.y + b.y);\nBIN_S(dot, a.x * b.x + a.y * b.y);\nBIN_S(cross, a.x * b.y - a.y * b.x);\n\n\nvec vmadd(vec a, double s, vec b)\n{\n\tvec c;\n\tc.x = a.x + s * b.x;\n\tc.y = a.y + s * b.y;\n\treturn c;\n}\n\n\nint intersect(vec x0, vec x1, vec y0, vec y1, double tol, vec *sect)\n{\n\tvec dx = vsub(x1, x0), dy = vsub(y1, y0);\n\tdouble d = vcross(dy, dx), a;\n\tif (!d) return 0; \n\n\ta = (vcross(x0, dx) - vcross(y0, dx)) \/ d;\n\tif (sect)\n\t\t*sect = vmadd(y0, a, dy);\n\n\tif (a < -tol || a > 1 + tol) return -1;\n\tif (a < tol || a > 1 - tol) return 0;\n\n\ta = (vcross(x0, dy) - vcross(y0, dy)) \/ d;\n\tif (a < 0 || a > 1) return -1;\n\n\treturn 1;\n}\n\n\ndouble dist(vec x, vec y0, vec y1, double tol)\n{\n\tvec dy = vsub(y1, y0);\n\tvec x1, s;\n\tint r;\n\n\tx1.x = x.x + dy.y; x1.y = x.y - dy.x;\n\tr = intersect(x, x1, y0, y1, tol, &s);\n\tif (r == -1) return HUGE_VAL;\n\ts = vsub(s, x);\n\treturn sqrt(vdot(s, s));\n}\n\n#define for_v(i, z, p) for(i = 0, z = p->v; i < p->n; i++, z++)\n\nint inside(vec v, polygon p, double tol)\n{\n\t\n\tint i, k, crosses, intersectResult;\n\tvec *pv;\n\tdouble min_x, max_x, min_y, max_y;\n\n\tfor (i = 0; i < p->n; i++) {\n\t\tk = (i + 1) % p->n;\n\t\tmin_x = dist(v, p->v[i], p->v[k], tol);\n\t\tif (min_x < tol) return 0;\n\t}\n\n\tmin_x = max_x = p->v[0].x;\n\tmin_y = max_y = p->v[1].y;\n\n\t\n\tfor_v(i, pv, p) {\n\t\tif (pv->x > max_x) max_x = pv->x;\n\t\tif (pv->x < min_x) min_x = pv->x;\n\t\tif (pv->y > max_y) max_y = pv->y;\n\t\tif (pv->y < min_y) min_y = pv->y;\n\t}\n\tif (v.x < min_x || v.x > max_x || v.y < min_y || v.y > max_y)\n\t\treturn -1;\n\n\tmax_x -= min_x; max_x *= 2;\n\tmax_y -= min_y; max_y *= 2;\n\tmax_x += max_y;\n\n\tvec e;\n\twhile (1) {\n\t\tcrosses = 0;\n\t\t\n\t\te.x = v.x + (1 + rand() \/ (RAND_MAX + 1.)) * max_x;\n\t\te.y = v.y + (1 + rand() \/ (RAND_MAX + 1.)) * max_x;\n\n\t\tfor (i = 0; i < p->n; i++) {\n\t\t\tk = (i + 1) % p->n;\n\t\t\tintersectResult = intersect(v, e, p->v[i], p->v[k], tol, 0);\n\n\t\t\t\n\t\t\tif (!intersectResult) break;\n\n\t\t\tif (intersectResult == 1) crosses++;\n\t\t}\n\t\tif (i == p->n) break;\n\t}\n\treturn (crosses & 1) ? 1 : -1;\n}\n\nint main()\n{\n\tvec vsq[] = {\t{0,0}, {10,0}, {10,10}, {0,10},\n\t\t\t{2.5,2.5}, {7.5,0.1}, {7.5,7.5}, {2.5,7.5}};\n\n\tpolygon_t sq = { 4, vsq }, \n\t\tsq_hole = { 8, vsq }; \n\n\tvec c = { 10, 5 }; \n\tvec d = { 5, 5 };\n\n\tprintf(\"%d\\n\", inside(c, &sq, 1e-10));\n\tprintf(\"%d\\n\", inside(c, &sq_hole, 1e-10));\n\n\tprintf(\"%d\\n\", inside(d, &sq, 1e-10));\t\n\tprintf(\"%d\\n\", inside(d, &sq_hole, 1e-10)); \n\n\treturn 0;\n}\n","Rust":"use std::f64;\n\nconst _EPS: f64 = 0.00001;\nconst _MIN: f64 = f64::MIN_POSITIVE;\nconst _MAX: f64 = f64::MAX;\n\n#[derive(Clone)]\nstruct Point {\n x: f64,\n y: f64,\n}\n\n#[derive(Clone)]\nstruct Edge {\n pt1: Point,\n pt2: Point,\n}\n\nimpl Edge {\n fn new(pt1: (f64, f64), pt2: (f64, f64)) -> Edge {\n Edge {\n pt1: Point { x: pt1.0, y: pt1.1 },\n pt2: Point { x: pt2.0, y: pt2.1 },\n }\n }\n}\n\nstruct Polygon {\n edges: Vec, \n}\n\nfn pt_in_polygon(pt: &Point, poly: &Polygon) -> bool {\n let count = poly.edges\n .iter()\n .filter(|edge| ray_intersect_seg(pt, edge))\n .count();\n\n count % 2 == 1\n}\n\nfn ray_intersect_seg(p: &Point, edge: &Edge) -> bool {\n let mut pt = p.clone();\n let (mut a, mut b): (&Point, &Point) = (&edge.pt1, &edge.pt2);\n if a.y > b.y {\n std::mem::swap(&mut a, &mut b);\n }\n if pt.y == a.y || pt.y == b.y {\n pt.y += _EPS;\n }\n\n if (pt.y > b.y || pt.y < a.y) || pt.x > a.x.max(b.x) {\n false\n } else if pt.x < a.x.min(b.x) {\n true\n } else {\n let m_red = if (a.x - b.x).abs() > _MIN {\n (b.y - a.y) \/ (b.x - a.x)\n } else {\n _MAX\n };\n let m_blue = if (a.x - pt.x).abs() > _MIN {\n (pt.y - a.y) \/ (pt.x - a.x)\n } else {\n _MAX\n };\n m_blue >= m_red\n }\n}\n\nfn main() {\n let p = |x, y| Point { x, y };\n let testpoints = [p(5.0, 5.0), p(5.0, 8.0), p(-10.0, 5.0), p(0.0, 5.0), p(10.0, 5.0), p(8.0, 5.0), p(10.0, 10.0)];\n let poly_square = Polygon {\n edges: vec![\n Edge::new((0.0, 0.0), (10.0, 0.0)),\n Edge::new((10.0, 0.0), (10.0, 10.0)),\n Edge::new((10.0, 10.0), (0.0, 10.0)),\n Edge::new((0.0, 10.0), (0.0, 0.0)),\n ],\n };\n let poly_square_hole = Polygon {\n edges: vec![\n Edge::new((0.0, 0.0), (10.0, 0.0)),\n Edge::new((10.0, 0.0), (10.0, 10.0)),\n Edge::new((10.0, 10.0), (0.0, 10.0)),\n Edge::new((0.0, 10.0), (0.0, 0.0)),\n Edge::new((2.5, 2.5), (7.5, 2.5)),\n Edge::new((7.5, 2.5), (7.5, 7.5)),\n Edge::new((7.5, 7.5), (2.5, 7.5)),\n Edge::new((2.5, 7.5), (2.5, 2.5)),\n ],\n };\n let poly_strange = Polygon {\n edges: vec![\n Edge::new((0.0, 0.0), (2.5, 2.5)),\n Edge::new((2.5, 2.5), (0.0, 10.0)),\n Edge::new((0.0, 10.0), (2.5, 7.5)),\n Edge::new((2.5, 7.5), (7.5, 7.5)),\n Edge::new((7.5, 7.5), (10.0, 10.0)),\n Edge::new((10.0, 10.0), (10.0, 0.0)),\n Edge::new((10.0, 0.0), (2.5, 2.5)),\n ],\n };\n let poly_hexagon = Polygon {\n edges: vec![\n Edge::new((3.0, 0.0), (7.0, 0.0)),\n Edge::new((7.0, 0.0), (10.0, 5.0)),\n Edge::new((10.0, 5.0), (7.0, 10.0)),\n Edge::new((7.0, 10.0), (3.0, 10.0)),\n Edge::new((3.0, 10.0), (0.0, 5.0)),\n Edge::new((0.0, 5.0), (3.0, 0.0)),\n ],\n };\n print!(\"\\nSquare\u00a0:\");\n for pt in &testpoints {\n print!(\" {:?}\", pt_in_polygon(pt, &poly_square));\n }\n print!(\"\\nSquare with hole:\");\n for pt in &testpoints {\n print!(\" {:?}\", pt_in_polygon(pt, &poly_square_hole));\n }\n print!(\"\\nStrange polygon\u00a0:\");\n for pt in &testpoints {\n print!(\" {:?}\", pt_in_polygon(pt, &poly_strange));\n }\n print!(\"\\nHexagon\u00a0:\");\n for pt in &testpoints {\n print!(\" {:?}\", pt_in_polygon(pt, &poly_hexagon));\n }\n println!();\n}\n"} {"name":"Read a configuration file","C":"#include \n#include \n#include \n#include \n\n#define rosetta_uint8_t unsigned char\n\n#define FALSE 0\n#define TRUE 1\n\n#define CONFIGS_TO_READ 5\n#define INI_ARRAY_DELIMITER ','\n\n\nstruct configs {\n\tchar *fullname;\n\tchar *favouritefruit;\n\trosetta_uint8_t needspeeling;\n\trosetta_uint8_t seedsremoved;\n\tchar **otherfamily;\n\tsize_t otherfamily_len;\n\tsize_t _configs_left_;\n};\n\nstatic char ** make_array (size_t * arrlen, const char * src, const size_t buffsize, IniFormat ini_format) {\n \n\t\n\t*arrlen = ini_array_get_length(src, INI_ARRAY_DELIMITER, ini_format);\n\tchar ** const dest = *arrlen ? (char **) malloc(*arrlen * sizeof(char *) + buffsize) : NULL;\n\tif (!dest) { return NULL; }\n\tmemcpy(dest + *arrlen, src, buffsize);\n\tchar * iter = (char *) (dest + *arrlen);\n\tfor (size_t idx = 0; idx < *arrlen; idx++) {\n\t\tdest[idx] = ini_array_release(&iter, INI_ARRAY_DELIMITER, ini_format);\n\t\tini_string_parse(dest[idx], ini_format);\n\t}\n\treturn dest;\n\n}\n\nstatic int configs_member_handler (IniDispatch *this, void *v_confs) {\n\n\tstruct configs *confs = (struct configs *) v_confs;\n\n\tif (this->type != INI_KEY) {\n\n\t\treturn 0;\n\n\t}\n\n\tif (ini_string_match_si(\"FULLNAME\", this->data, this->format)) {\n\n\t\tif (confs->fullname) { return 0; }\n\t\tthis->v_len = ini_string_parse(this->value, this->format); \n\t\tconfs->fullname = strndup(this->value, this->v_len);\n\t\tconfs->_configs_left_--;\n\n\t} else if (ini_string_match_si(\"FAVOURITEFRUIT\", this->data, this->format)) {\n\n\t\tif (confs->favouritefruit) { return 0; }\n\t\tthis->v_len = ini_string_parse(this->value, this->format); \n\t\tconfs->favouritefruit = strndup(this->value, this->v_len);\n\t\tconfs->_configs_left_--;\n\n\t} else if (ini_string_match_si(\"NEEDSPEELING\", this->data, this->format)) {\n\n\t\tif (~confs->needspeeling & 0x80) { return 0; }\n\t\tconfs->needspeeling = ini_get_bool(this->value, TRUE);\n\t\tconfs->_configs_left_--;\n\n\t} else if (ini_string_match_si(\"SEEDSREMOVED\", this->data, this->format)) {\n\n\t\tif (~confs->seedsremoved & 0x80) { return 0; }\n\t\tconfs->seedsremoved = ini_get_bool(this->value, TRUE);\n\t\tconfs->_configs_left_--;\n\n\t} else if (!confs->otherfamily && ini_string_match_si(\"OTHERFAMILY\", this->data, this->format)) {\n\n\t\tif (confs->otherfamily) { return 0; }\n\t\tthis->v_len = ini_array_collapse(this->value, INI_ARRAY_DELIMITER, this->format); \n\t\tconfs->otherfamily = make_array(&confs->otherfamily_len, this->value, this->v_len + 1, this->format);\n\t\tconfs->_configs_left_--;\n\n\t}\n\n\t\n\treturn !confs->_configs_left_;\n\n}\n\nstatic int populate_configs (struct configs * confs) {\n\n\t\n\tIniFormat config_format = {\n\t\t.delimiter_symbol = INI_ANY_SPACE,\n\t\t.case_sensitive = FALSE,\n\t\t.semicolon_marker = INI_IGNORE,\n\t\t.hash_marker = INI_IGNORE,\n\t\t.multiline_nodes = INI_NO_MULTILINE,\n\t\t.section_paths = INI_NO_SECTIONS,\n\t\t.no_single_quotes = FALSE,\n\t\t.no_double_quotes = FALSE,\n\t\t.no_spaces_in_names = TRUE,\n\t\t.implicit_is_not_empty = TRUE,\n\t\t.do_not_collapse_values = FALSE,\n\t\t.preserve_empty_quotes = FALSE,\n\t\t.disabled_after_space = TRUE,\n\t\t.disabled_can_be_implicit = FALSE\n\t};\n\n\t*confs = (struct configs) { NULL, NULL, 0x80, 0x80, NULL, 0, CONFIGS_TO_READ };\n\n\tif (load_ini_path(\"rosetta.conf\", config_format, NULL, configs_member_handler, confs) & CONFINI_ERROR) {\n\n\t\tfprintf(stderr, \"Sorry, something went wrong\u00a0:-(\\n\");\n\t\treturn 1;\n\n\t}\n\n\tconfs->needspeeling &= 0x7F;\n\tconfs->seedsremoved &= 0x7F;\n\n\treturn 0;\n\n}\n\nint main () {\n\n\tstruct configs confs;\n\n\tini_global_set_implicit_value(\"YES\", 0);\n\n\tif (populate_configs(&confs)) {\n\n\t\treturn 1;\n\n\t}\n\n\t\n\n\tprintf(\n\n\t\t\"Full name: %s\\n\"\n\t\t\"Favorite fruit: %s\\n\"\n\t\t\"Need spelling: %s\\n\"\n\t\t\"Seeds removed: %s\\n\",\n\n\t\tconfs.fullname,\n\t\tconfs.favouritefruit,\n\t\tconfs.needspeeling ? \"True\" : \"False\",\n\t\tconfs.seedsremoved ? \"True\" : \"False\"\n\n\t);\n\n\tfor (size_t idx = 0; idx < confs.otherfamily_len; idx++) {\n\n\t\tprintf(\"Other family[%d]: %s\\n\", idx, confs.otherfamily[idx]);\n\n\t}\n\n\t\n\n\t#define FREE_NON_NULL(PTR) if (PTR) { free(PTR); }\n\n\tFREE_NON_NULL(confs.fullname);\n\tFREE_NON_NULL(confs.favouritefruit);\n\tFREE_NON_NULL(confs.otherfamily);\n\n\treturn 0;\n\n}\n","Rust":"use std::fs::File;\nuse std::io::BufRead;\nuse std::io::BufReader;\nuse std::iter::FromIterator;\nuse std::path::Path;\n\nfn main() {\n let path = String::from(\"file.conf\");\n let cfg = config_from_file(path);\n println!(\"{:?}\", cfg);\n}\n\nfn config_from_file(path: String) -> Config {\n let path = Path::new(&path);\n let file = File::open(path).expect(\"File not found or cannot be opened\");\n let content = BufReader::new(&file);\n let mut cfg = Config::new();\n\n for line in content.lines() {\n let line = line.expect(\"Could not read the line\");\n \n let line = line.trim();\n\n \n if line.starts_with(\"#\") || line.starts_with(\";\") || line.is_empty() {\n continue;\n }\n\n \n let tokens = Vec::from_iter(line.split_whitespace()); \n let name = tokens.first().unwrap();\n let tokens = tokens.get(1..).unwrap();\n\n \n let tokens = tokens.iter().filter(|t| !t.starts_with(\"=\"));\n \n let tokens = tokens.take_while(|t| !t.starts_with(\"#\") && !t.starts_with(\";\"));\n \n \n let mut parameters = String::new();\n tokens.for_each(|t| { parameters.push_str(t); parameters.push(' '); });\n \n let parameters = parameters.split(',').map(|s| s.trim());\n \n let parameters: Vec = parameters.map(|s| s.to_string()).collect();\n \n \n match name.to_lowercase().as_str() {\n \"fullname\" => cfg.full_name = parameters.get(0).cloned(),\n \"favouritefruit\" => cfg.favourite_fruit = parameters.get(0).cloned(),\n \"needspeeling\" => cfg.needs_peeling = true,\n \"seedsremoved\" => cfg.seeds_removed = true,\n \"otherfamily\" => cfg.other_family = Some(parameters),\n _ => (),\n }\n }\n\n cfg\n}\n\n#[derive(Clone, Debug)]\nstruct Config {\n full_name: Option,\n favourite_fruit: Option,\n needs_peeling: bool,\n seeds_removed: bool,\n other_family: Option>,\n}\n\nimpl Config {\n fn new() -> Config {\n Config {\n full_name: None,\n favourite_fruit: None,\n needs_peeling: false,\n seeds_removed: false,\n other_family: None,\n }\n }\n}\n"} {"name":"Read a file character by character_UTF8","C":"#include \n#include \n#include \n#include \n\nint main(void)\n{\n \n char *locale = setlocale(LC_ALL, \"\");\n FILE *in = fopen(\"input.txt\", \"r\");\n\n wint_t c;\n while ((c = fgetwc(in)) != WEOF)\n putwchar(c);\n fclose(in);\n\n return EXIT_SUCCESS;\n}\n","Rust":"use std::{\n convert::TryFrom,\n fmt::{Debug, Display, Formatter},\n io::Read,\n};\n\npub struct ReadUtf8 {\n source: std::iter::Peekable,\n}\n\nimpl From for ReadUtf8> {\n fn from(source: R) -> Self {\n ReadUtf8 {\n source: source.bytes().peekable(),\n }\n }\n}\n\nimpl Iterator for ReadUtf8\nwhere\n I: Iterator>,\n{\n type Item = Result>;\n\n fn next(&mut self) -> Option {\n self.source.next().map(|next| match next {\n Ok(lead) => self.complete_char(lead),\n Err(e) => Err(Error::SourceError(e)),\n })\n }\n}\n\nimpl ReadUtf8\nwhere\n I: Iterator>,\n{\n fn continuation(&mut self) -> Result> {\n if let Some(Ok(byte)) = self.source.peek() {\n let byte = *byte;\n\n return if byte & 0b1100_0000 == 0b1000_0000 {\n self.source.next();\n Ok((byte & 0b0011_1111) as u32)\n } else {\n Err(Error::InvalidByte(byte))\n };\n }\n\n match self.source.next() {\n None => Err(Error::InputTruncated),\n Some(Err(e)) => Err(Error::SourceError(e)),\n Some(Ok(_)) => unreachable!(),\n }\n }\n\n fn complete_char(&mut self, lead: u8) -> Result> {\n let a = lead as u32; \n\n let result = if a & 0b1000_0000 == 0 {\n Ok(a)\n } else if lead & 0b1110_0000 == 0b1100_0000 {\n let b = self.continuation()?;\n Ok((a & 0b0001_1111) << 6 | b)\n } else if a & 0b1111_0000 == 0b1110_0000 {\n let b = self.continuation()?;\n let c = self.continuation()?;\n Ok((a & 0b0000_1111) << 12 | b << 6 | c)\n } else if a & 0b1111_1000 == 0b1111_0000 {\n let b = self.continuation()?;\n let c = self.continuation()?;\n let d = self.continuation()?;\n Ok((a & 0b0000_0111) << 18 | b << 12 | c << 6 | d)\n } else {\n Err(Error::InvalidByte(lead))\n };\n\n Ok(char::try_from(result?).unwrap())\n }\n}\n\n#[derive(Debug, Clone)]\npub enum Error {\n InvalidByte(u8),\n InputTruncated,\n SourceError(E),\n}\n\nimpl Display for Error {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n match self {\n Self::InvalidByte(b) => write!(f, \"invalid byte 0x{:x}\", b),\n Self::InputTruncated => write!(f, \"character truncated\"),\n Self::SourceError(e) => e.fmt(f),\n }\n }\n}\n\nfn main() -> std::io::Result<()> {\n for (index, value) in ReadUtf8::from(std::fs::File::open(\"test.txt\")?).enumerate() {\n match value {\n Ok(c) => print!(\"{}\", c),\n\n Err(e) => {\n print!(\"\\u{fffd}\");\n eprintln!(\"offset {}: {}\", index, e);\n }\n }\n }\n\n Ok(())\n}\n"} {"name":"Read a specific line from a file","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n\nint read_file_line(const char *path, int line_no)\n{\n\tstruct stat s;\n\tchar *buf;\n\toff_t start = -1, end = -1;\n\tsize_t i;\n\tint ln, fd, ret = 1;\n\n\tif (line_no == 1) start = 0;\n\telse if (line_no < 1){\n\t\twarn(\"line_no too small\");\n\t\treturn 0; \n\t}\n\n\tline_no--; \n\n\tfd = open(path, O_RDONLY);\n\tfstat(fd, &s);\n\n\t\n\tbuf = mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);\n\n\t\n\tmadvise(buf, s.st_size, MADV_SEQUENTIAL);\n\n\tfor (i = ln = 0; i < s.st_size && ln <= line_no; i++) {\n\t\tif (buf[i] != '\\n') continue;\n\n\t\tif (++ln == line_no) start = i + 1;\n\t\telse if (ln == line_no + 1) end = i + 1;\n\t}\n\n\tif (start >= s.st_size || start < 0) {\n\t\twarn(\"file does not have line %d\", line_no + 1);\n\t\tret = 0;\n\t} else {\n\t\t\n\t}\n\n\tmunmap(buf, s.st_size);\n\tclose(fd);\n\n\treturn ret;\n}\n","Rust":"use std::fs::File;\nuse std::io::BufRead;\nuse std::io::BufReader;\nuse std::io::Error;\nuse std::path::Path;\n \nfn main() {\n let path = Path::new(\"file.txt\");\n let line_num = 7usize;\n let line = get_line_at(&path, line_num - 1);\n println!(\"{}\", line.unwrap());\n}\n \nfn get_line_at(path: &Path, line_num: usize) -> Result {\n let file = File::open(path).expect(\"File not found or cannot be opened\");\n let content = BufReader::new(&file);\n let mut lines = content.lines();\n lines.nth(line_num).expect(\"No line found at that position\")\n}\n"} {"name":"Rep-string","C":"#include \n#include \n\nint repstr(char *str)\n{\n if (!str) return 0;\n\n size_t sl = strlen(str) \/ 2;\n while (sl > 0) {\n if (strstr(str, str + sl) == str)\n return sl;\n --sl;\n }\n\n return 0;\n}\n\nint main(void)\n{\n char *strs[] = { \"1001110011\", \"1110111011\", \"0010010010\", \"1111111111\",\n \"0100101101\", \"0100100\", \"101\", \"11\", \"00\", \"1\" };\n\n size_t strslen = sizeof(strs) \/ sizeof(strs[0]);\n size_t i;\n for (i = 0; i < strslen; ++i) {\n int n = repstr(strs[i]);\n if (n)\n printf(\"\\\"%s\\\" = rep-string \\\"%.*s\\\"\\n\", strs[i], n, strs[i]);\n else\n printf(\"\\\"%s\\\" = not a rep-string\\n\", strs[i]);\n }\n\n return 0;\n}\n","Rust":"fn main() {\n let strings = vec![\n String::from(\"1001110011\"),\n String::from(\"1110111011\"),\n String::from(\"0010010010\"),\n String::from(\"1010101010\"),\n String::from(\"1111111111\"),\n String::from(\"0100101101\"),\n String::from(\"0100100\"),\n String::from(\"101\"),\n String::from(\"11\"),\n String::from(\"00\"),\n String::from(\"1\"),\n ];\n for string in strings {\n match rep_string(&string) {\n Some(rep_string) => println!(\n \"Longuest rep-string for '{}' is '{}' ({} chars)\",\n string,\n rep_string,\n rep_string.len(),\n ),\n None => println!(\"No rep-string found for '{}'\", string),\n };\n }\n}\n\nfn rep_string(string: &str) -> Option<&str> {\n let index = string.len() \/ 2;\n\n for split_index in (1..=index).rev() {\n let mut is_rep_string = true;\n let (first, last) = string.split_at(split_index);\n\n let inter = last.chars().collect::>();\n let mut iter = inter.chunks_exact(split_index);\n for chunk in iter.by_ref() {\n if first != chunk.iter().collect::() {\n is_rep_string = false;\n break;\n }\n }\n let rmnd = iter.remainder().iter().collect::();\n\n \n if !first.starts_with(rmnd.as_str()) {\n is_rep_string = false;\n }\n\n if is_rep_string {\n return Some(first);\n }\n }\n None\n}\n\n#[cfg(test)]\nmod tests {\n use super::rep_string;\n use std::collections::HashMap;\n\n #[test]\n fn test_rep_string() {\n let mut results = HashMap::new();\n results.insert(String::from(\"1001110011\"), Some(\"10011\"));\n results.insert(String::from(\"1110111011\"), Some(\"1110\"));\n results.insert(String::from(\"0010010010\"), Some(\"001\"));\n results.insert(String::from(\"1010101010\"), Some(\"1010\"));\n results.insert(String::from(\"1111111111\"), Some(\"11111\"));\n results.insert(String::from(\"0100101101\"), None);\n results.insert(String::from(\"0100100\"), Some(\"010\"));\n results.insert(String::from(\"101\"), None);\n results.insert(String::from(\"11\"), Some(\"1\"));\n results.insert(String::from(\"00\"), Some(\"0\"));\n results.insert(String::from(\"1\"), None);\n\n for (input, expected) in results {\n assert_eq!(expected, rep_string(&input));\n }\n }\n}\n"} {"name":"Rock-paper-scissors","C":"#include \n#include \n#define LEN 3 \n\n\nint rand_idx(double *p, int n)\n{\n\tdouble s = rand() \/ (RAND_MAX + 1.0);\n\tint i;\n\tfor (i = 0; i < n - 1 && (s -= p[i]) >= 0; i++);\n\treturn i;\n}\n\nint main()\n{\n\tint user_action, my_action;\n\tint user_rec[] = {0, 0, 0};\n\tconst char *names[] = { \"Rock\", \"Paper\", \"Scissors\" };\n\tchar str[2];\n\tconst char *winner[] = { \"We tied.\", \"Meself winned.\", \"You win.\" };\n\tdouble p[LEN] = { 1.\/3, 1.\/3, 1.\/3 };\n \n\twhile (1) {\n\t\tmy_action = rand_idx(p,LEN);\n \n\t\tprintf(\"\\nYour choice [1-3]:\\n\"\n\t\t\t\" 1. Rock\\n 2. Paper\\n 3. Scissors\\n> \");\n \n\t\t\n\t\tif (!scanf(\"%d\", &user_action)) {\n\t\t\tscanf(\"%1s\", str);\n\t\t\tif (*str == 'q') {\n\t\t\t\tprintf(\"Your choices [rock\u00a0: %d , paper\u00a0: %d , scissors %d] \",user_rec[0],user_rec[1], user_rec[2]); \n\t\t\t\treturn 0;\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\t\tuser_action --;\n\t\tif (user_action > 2 || user_action < 0) {\n\t\t\tprintf(\"invalid choice; again\\n\");\n\t\t\tcontinue;\n\t\t}\n\t\tprintf(\"You chose %s; I chose %s. %s\\n\",\n\t\t\tnames[user_action], names[my_action],\n\t\t\twinner[(my_action - user_action + 3) % 3]);\n \n\t\tuser_rec[user_action]++;\n\t}\n}\n","Rust":"extern crate rand;\n#[macro_use]\nextern crate rand_derive;\n\nuse std::io;\nuse rand::Rng;\nuse Choice::*;\n\n#[derive(PartialEq, Clone, Copy, Rand, Debug)]\nenum Choice {\n Rock,\n Paper,\n Scissors,\n}\n\nfn beats(c1: Choice, c2: Choice) -> bool {\n (c1 == Rock && c2 == Scissors) || (c1 == Scissors && c2 == Paper) || (c1 == Paper && c2 == Rock)\n}\n\nfn ai_move(rng: &mut R, v: [usize; 3]) -> Choice {\n \n let rand = rng.gen_range(0, v[0] + v[1] + v[2]);\n if rand < v[0] {\n Paper\n } else if rand < v[0] + v[1] {\n Scissors\n } else {\n Rock\n }\n}\n\nfn main() {\n let mut rng = rand::thread_rng();\n\n println!(\"Rock, paper, scissors!\");\n let mut ai_choice: Choice = rng.gen();\n let mut ucf = [0, 0, 0]; \n let mut score = [0, 0];\n\n loop {\n println!(\"Please input your move: 'r', 'p' or 's'. Type 'q' to quit\");\n\n let mut input = String::new();\n io::stdin()\n .read_line(&mut input)\n .expect(\"failed to read line\");\n let u_choice = match input.to_lowercase().trim() {\n s if s.starts_with('r') => {\n ucf[0] += 1;\n Rock\n }\n s if s.starts_with('p') => {\n ucf[1] += 1;\n Paper\n }\n s if s.starts_with('s') => {\n ucf[2] += 1;\n Scissors\n }\n s if s.starts_with('q') => break,\n _ => {\n println!(\"Please enter a correct choice!\");\n continue;\n }\n };\n println!(\"You chose {:?}, I chose {:?}.\", u_choice, ai_choice);\n if beats(u_choice, ai_choice) {\n score[0] += 1;\n println!(\"You win!\");\n } else if u_choice == ai_choice {\n println!(\"It's a tie!\");\n } else {\n score[1] += 1;\n println!(\"I win!\");\n }\n println!(\"-Score: You {}, Me {}\", score[0], score[1]);\n\n \n \n ai_choice = ai_move(&mut rng, ucf);\n }\n println!(\"Thank you for the game!\");\n}\n"} {"name":"SHA-256 Merkle tree","C":"#include \n#include \n#include \n#include \n\nguchar* sha256_merkle_tree(FILE* in, size_t block_size) {\n gchar* buffer = g_malloc(block_size);\n GPtrArray* hashes = g_ptr_array_new_with_free_func(g_free);\n gssize digest_length = g_checksum_type_get_length(G_CHECKSUM_SHA256);\n GChecksum* checksum = g_checksum_new(G_CHECKSUM_SHA256);\n size_t bytes;\n while ((bytes = fread(buffer, 1, block_size, in)) > 0) {\n g_checksum_reset(checksum);\n g_checksum_update(checksum, (guchar*)buffer, bytes);\n gsize len = digest_length;\n guchar* digest = g_malloc(len);\n g_checksum_get_digest(checksum, digest, &len);\n g_ptr_array_add(hashes, digest);\n }\n g_free(buffer);\n guint hashes_length = hashes->len;\n if (hashes_length == 0) {\n g_ptr_array_free(hashes, TRUE);\n g_checksum_free(checksum);\n return NULL;\n }\n while (hashes_length > 1) {\n guint j = 0;\n for (guint i = 0; i < hashes_length; i += 2, ++j) {\n guchar* digest1 = g_ptr_array_index(hashes, i);\n guchar* digest_out = g_ptr_array_index(hashes, j);\n if (i + 1 < hashes_length) {\n guchar* digest2 = g_ptr_array_index(hashes, i + 1);\n g_checksum_reset(checksum);\n g_checksum_update(checksum, digest1, digest_length);\n g_checksum_update(checksum, digest2, digest_length);\n gsize len = digest_length;\n g_checksum_get_digest(checksum, digest_out, &len);\n } else {\n memcpy(digest_out, digest1, digest_length);\n }\n }\n hashes_length = j;\n }\n guchar* result = g_ptr_array_steal_index(hashes, 0);\n g_ptr_array_free(hashes, TRUE);\n g_checksum_free(checksum);\n return result;\n}\n\nint main(int argc, char** argv) {\n if (argc != 2) {\n fprintf(stderr, \"usage: %s filename\\n\", argv[0]);\n return EXIT_FAILURE;\n }\n FILE* in = fopen(argv[1], \"rb\");\n if (in) {\n guchar* digest = sha256_merkle_tree(in, 1024);\n fclose(in);\n if (digest) {\n gssize length = g_checksum_type_get_length(G_CHECKSUM_SHA256);\n for (gssize i = 0; i < length; ++i)\n printf(\"%02x\", digest[i]);\n printf(\"\\n\");\n g_free(digest);\n }\n } else {\n perror(argv[1]);\n return EXIT_FAILURE;\n }\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate crypto;\n\nuse crypto::digest::Digest;\nuse crypto::sha2::Sha256;\nuse std::fs::File;\nuse std::io::prelude::*;\nuse std::io::BufReader;\n\nfn sha256_merkle_tree(filename: &str, block_size: usize) -> std::io::Result>> {\n let mut md = Sha256::new();\n let mut input = BufReader::new(File::open(filename)?);\n let mut buffer = vec![0; block_size];\n let mut digest = vec![0; md.output_bytes()];\n let mut digests = Vec::new();\n loop {\n let bytes = input.read(&mut buffer)?;\n if bytes == 0 {\n break;\n }\n md.reset();\n md.input(&buffer[0..bytes]);\n md.result(&mut digest);\n digests.push(digest.clone());\n }\n let mut len = digests.len();\n if len == 0 {\n return Ok(None);\n }\n while len > 1 {\n let mut j = 0;\n let mut i = 0;\n while i < len {\n if i + 1 < len {\n md.reset();\n md.input(&digests[i]);\n md.input(&digests[i + 1]);\n md.result(&mut digests[j]);\n } else {\n digests.swap(i, j);\n }\n i += 2;\n j += 1;\n }\n len = j;\n }\n Ok(Some(digests[0].clone()))\n}\n\nfn digest_to_string(digest: &[u8]) -> String {\n let mut result = String::new();\n for x in digest {\n result.push_str(&format!(\"{:02x}\", x));\n }\n result\n}\n\nfn main() {\n match sha256_merkle_tree(\"title.png\", 1024) {\n Ok(Some(digest)) => println!(\"{}\", digest_to_string(&digest)),\n Ok(None) => {}\n Err(error) => eprintln!(\"I\/O error: {}\", error),\n }\n}\n"} {"name":"Safe primes and unsafe primes","C":"#include \n#include \n\nint primes[] = {\n 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,\n 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,\n 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331\n};\n#define PCOUNT (sizeof(primes) \/ sizeof(int))\n\nbool isPrime(int n) {\n int i;\n\n if (n < 2) {\n return false;\n }\n\n for (i = 0; i < PCOUNT; i++) {\n if (n == primes[i]) {\n return true;\n }\n if (n % primes[i] == 0) {\n return false;\n }\n if (n < primes[i] * primes[i]) {\n return true;\n }\n }\n\n for (i = primes[PCOUNT - 1] + 2; i * i <= n; i += 2) {\n if (n % i == 0) {\n return false;\n }\n }\n\n return true;\n}\n\nint main() {\n int beg, end;\n int i, count;\n\n \n \n beg = 2;\n end = 1000000;\n count = 0;\n printf(\"First 35 safe primes:\\n\");\n for (i = beg; i < end; i++) {\n if (isPrime(i) && isPrime((i - 1) \/ 2)) {\n if (count < 35) {\n printf(\"%d \", i);\n }\n count++;\n }\n }\n printf(\"\\nThere are %d safe primes below %d\\n\", count, end);\n\n beg = end;\n end = end * 10;\n for (i = beg; i < end; i++) {\n if (isPrime(i) && isPrime((i - 1) \/ 2)) {\n count++;\n }\n }\n printf(\"There are %d safe primes below %d\\n\", count, end);\n\n \n \n beg = 2;\n end = 1000000;\n count = 0;\n printf(\"\\nFirst 40 unsafe primes:\\n\");\n for (i = beg; i < end; i++) {\n if (isPrime(i) && !isPrime((i - 1) \/ 2)) {\n if (count < 40) {\n printf(\"%d \", i);\n }\n count++;\n }\n }\n printf(\"\\nThere are %d unsafe primes below %d\\n\", count, end);\n\n beg = end;\n end = end * 10;\n for (i = beg; i < end; i++) {\n if (isPrime(i) && !isPrime((i - 1) \/ 2)) {\n count++;\n }\n }\n printf(\"There are %d unsafe primes below %d\\n\", count, end);\n\n return 0;\n}\n","Rust":"fn is_prime(n: i32) -> bool {\n\tfor i in 2..n {\n\t\tif i * i > n {\n\t\t\treturn true;\n\t\t}\n\t\tif n % i == 0 {\n\t\t\treturn false;\n\t\t}\n\t}\n\tn > 1\n}\n\nfn is_safe_prime(n: i32) -> bool {\n\tis_prime(n) && is_prime((n - 1) \/ 2)\n}\n\nfn is_unsafe_prime(n: i32) -> bool {\n\tis_prime(n) && !is_prime((n - 1) \/ 2)\n}\n\nfn next_prime(n: i32) -> i32 {\n\tfor i in (n+1).. {\n\t\tif is_prime(i) {\n\t\t\treturn i;\n\t\t}\n\t}\n\t0\n}\n\nfn main() {\n\tlet mut safe = 0;\n\tlet mut unsf = 0;\n\tlet mut p = 2;\n\n\tprint!(\"first 35 safe primes: \");\n\twhile safe < 35 {\n\t\tif is_safe_prime(p) {\n\t\t\tsafe += 1;\n\t\t\tprint!(\"{} \", p);\n\t\t}\n\t\tp = next_prime(p);\n\t}\n\tprintln!(\"\");\n\n\tp = 2;\n\n\tprint!(\"first 35 unsafe primes: \");\n\twhile unsf < 35 {\n\t\tif is_unsafe_prime(p) {\n\t\t\tunsf += 1;\n\t\t\tprint!(\"{} \", p);\n\t\t}\n\t\tp = next_prime(p);\n\t}\n\tprintln!(\"\");\n\n\tp = 2;\n\tsafe = 0;\n\tunsf = 0;\n\n\twhile p < 1000000 {\n\t\tif is_safe_prime(p) {\n\t\t\tsafe += 1;\n\t\t} else {\n\t\t\tunsf += 1;\n\t\t}\n\t\tp = next_prime(p);\n\t}\n\tprintln!(\"safe primes below 1,000,000: {}\", safe);\n\tprintln!(\"unsafe primes below 1,000,000: {}\", unsf);\n\n\twhile p < 10000000 {\n\t\tif is_safe_prime(p) {\n\t\t\tsafe += 1;\n\t\t} else {\n\t\t\tunsf += 1;\n\t\t}\n\t\tp = next_prime(p);\n\t}\n\tprintln!(\"safe primes below 10,000,000: {}\", safe);\n\tprintln!(\"unsafe primes below 10,000,000: {}\", unsf);\n}\n"} {"name":"Self-describing numbers","C":"#include \n\ninline int self_desc(unsigned long long xx)\n{\n\tregister unsigned int d, x;\n\tunsigned char cnt[10] = {0}, dig[10] = {0};\n \n\tfor (d = 0; xx > ~0U; xx \/= 10)\n\t\tcnt[ dig[d++] = xx % 10 ]++;\n \n\tfor (x = xx; x; x \/= 10)\n\t\tcnt[ dig[d++] = x % 10 ]++;\n \n\twhile(d-- && dig[x++] == cnt[d]);\n \n\treturn d == -1;\n}\n \nint main()\n{\n\tint i;\n\tfor (i = 1; i < 100000000; i++) \n\t\tif (self_desc(i)) printf(\"%d\\n\", i);\n \n\treturn 0;\n}\n","Rust":"fn is_self_desc(xx: u64) -> bool\n{\n let s: String = xx.to_string();\n let mut count_vec = vec![0; 10];\n for c in s.chars() {\n count_vec[c.to_digit(10).unwrap() as usize] += 1;\n }\n for (i, c) in s.chars().enumerate() {\n if count_vec[i] != c.to_digit(10).unwrap() as usize {\n return false;\n }\n }\n return true;\n}\n\nfn main() {\n for i in 1..100000000 {\n if is_self_desc(i) {\n println!(\"{}\", i)\n }\n }\n}\n"} {"name":"Sequence_ smallest number with exactly n divisors","C":"#include \n\n#define MAX 15\n\nint count_divisors(int n) {\n int i, count = 0;\n for (i = 1; i * i <= n; ++i) {\n if (!(n % i)) {\n if (i == n \/ i)\n count++;\n else\n count += 2;\n }\n }\n return count;\n}\n\nint main() {\n int i, k, n, seq[MAX];\n for (i = 0; i < MAX; ++i) seq[i] = 0;\n printf(\"The first %d terms of the sequence are:\\n\", MAX);\n for (i = 1, n = 0; n < MAX; ++i) {\n k = count_divisors(i);\n if (k <= MAX && seq[k - 1] == 0) {\n seq[k - 1] = i;\n ++n;\n }\n }\n for (i = 0; i < MAX; ++i) printf(\"%d \", seq[i]);\n printf(\"\\n\");\n return 0;\n}\n","Rust":"use itertools::Itertools;\n\nconst PRIMES: [u64; 15] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47];\nconst MAX_DIVISOR: usize = 64;\n\nstruct DivisorSeq {\n max_number_of_divisors: u64,\n index: u64,\n}\n\nimpl DivisorSeq {\n fn new(max_number_of_divisors: u64) -> DivisorSeq {\n DivisorSeq {\n max_number_of_divisors,\n index: 1,\n }\n }\n}\n\nimpl Iterator for DivisorSeq {\n type Item = u64;\n\n fn next(&mut self) -> Option {\n if self.max_number_of_divisors < self.index {\n return None;\n }\n #[allow(unused_mut)]\n let mut result: u64;\n let divisors_of_divisor = get_divisors(self.index);\n match divisors_of_divisor.len() {\n 1 | 2 => {\n \n result = 2_u64.pow(self.index as u32 - 1);\n self.index += 1;\n }\n 3 => {\n \n result = 6_u64.pow(divisors_of_divisor[1] as u32 - 1);\n self.index += 1;\n }\n 4 => {\n \n result = 2_u64.pow(divisors_of_divisor[2] as u32 - 1)\n * 3_u64.pow(divisors_of_divisor[1] as u32 - 1);\n self.index += 1;\n }\n 8 if divisors_of_divisor\n .iter()\n .filter(|x| PRIMES.contains(x))\n .count()\n == 3 =>\n {\n \n let first_primes = divisors_of_divisor\n .iter()\n .filter(|x| PRIMES.contains(x))\n .collect::>();\n result = 2_u64.pow(*first_primes[2] as u32 - 1)\n * 3_u64.pow(*first_primes[1] as u32 - 1)\n * 5_u64.pow(*first_primes[0] as u32 - 1);\n self.index += 1;\n }\n _ => {\n \n \n let mut x: u64 = 1;\n loop {\n if get_divisors(x).len() as u64 == self.index {\n break;\n }\n x += 1;\n }\n\n result = x;\n self.index += 1;\n }\n }\n Some(result)\n }\n}\n\nfn get_divisors(n: u64) -> Vec {\n let mut results = Vec::new();\n\n for i in 1..(n \/ 2 + 1) {\n if n % i == 0 {\n results.push(i);\n }\n }\n results.push(n);\n results\n}\n\nfn main() {\n \n \n \n let seq_iter = DivisorSeq::new(64);\n println!(\"Simple method with rules\");\n println!(\"# divisors Smallest number\");\n for (i, x) in seq_iter.enumerate() {\n println!(\"{:>10}{:20}\", i + 1, x);\n }\n\n \n \n\n \n let mut min_numbers = vec![0_u64; MAX_DIVISOR];\n (0_usize..MAX_DIVISOR).for_each(|n| min_numbers[n] = 2_u64.pow(n as u32));\n\n let prime_list = (1..15).map(|i| PRIMES[0..=i].to_vec()).collect::>();\n\n for pl in prime_list.iter() {\n \n \n let max_exponent = 1 + MAX_DIVISOR as u32 \/ 2_u32.pow(pl.len() as u32 - 1);\n\n \n let exponents = (1_usize..=pl.len())\n .map(|_| 1_u32..=max_exponent)\n .multi_cartesian_product()\n .filter(|elt| {\n let mut prev = None::<&u32>;\n elt.iter().all(|x| match prev {\n Some(n) if x > n => false,\n _ => {\n prev = Some(x);\n true\n }\n })\n });\n\n \n for exp in exponents {\n \n \n \n \n let num_of_divisors = exp.iter().map(|x| x + 1).product::() as usize;\n\n \n let num = pl.iter().zip(exp.iter()).fold(1_u64, |mut acc, (p, e)| {\n \n acc = match acc.checked_mul(p.pow(*e)) {\n Some(z) => z,\n _ => 0,\n };\n acc\n });\n\n \n \n if num > 0\n && min_numbers.len() >= num_of_divisors\n && min_numbers[num_of_divisors - 1] > num\n {\n min_numbers[num_of_divisors - 1] = num;\n }\n }\n }\n\n println!(\"Advanced method\");\n println!(\"# divisors Smallest number\");\n for (i, x) in min_numbers.iter().enumerate() {\n println!(\"{:>10}{:20}\", i + 1, x);\n }\n}\n"} {"name":"Set of real numbers","C":"#include \n#include \n#include \n#include \n\nstruct RealSet {\n bool(*contains)(struct RealSet*, struct RealSet*, double);\n struct RealSet *left;\n struct RealSet *right;\n double low, high;\n};\n\ntypedef enum {\n CLOSED,\n LEFT_OPEN,\n RIGHT_OPEN,\n BOTH_OPEN,\n} RangeType;\n\ndouble length(struct RealSet *self) {\n const double interval = 0.00001;\n double p = self->low;\n int count = 0;\n\n if (isinf(self->low) || isinf(self->high)) return -1.0;\n if (self->high <= self->low) return 0.0;\n\n do {\n if (self->contains(self, NULL, p)) count++;\n p += interval;\n } while (p < self->high);\n return count * interval;\n}\n\nbool empty(struct RealSet *self) {\n if (self->low == self->high) {\n return !self->contains(self, NULL, self->low);\n }\n return length(self) == 0.0;\n}\n\nstatic bool contains_closed(struct RealSet *self, struct RealSet *_, double d) {\n return self->low <= d && d <= self->high;\n}\n\nstatic bool contains_left_open(struct RealSet *self, struct RealSet *_, double d) {\n return self->low < d && d <= self->high;\n}\n\nstatic bool contains_right_open(struct RealSet *self, struct RealSet *_, double d) {\n return self->low <= d && d < self->high;\n}\n\nstatic bool contains_both_open(struct RealSet *self, struct RealSet *_, double d) {\n return self->low < d && d < self->high;\n}\n\nstatic bool contains_intersect(struct RealSet *self, struct RealSet *_, double d) {\n return self->left->contains(self->left, NULL, d) && self->right->contains(self->right, NULL, d);\n}\n\nstatic bool contains_union(struct RealSet *self, struct RealSet *_, double d) {\n return self->left->contains(self->left, NULL, d) || self->right->contains(self->right, NULL, d);\n}\n\nstatic bool contains_subtract(struct RealSet *self, struct RealSet *_, double d) {\n return self->left->contains(self->left, NULL, d) && !self->right->contains(self->right, NULL, d);\n}\n\nstruct RealSet* makeSet(double low, double high, RangeType type) {\n bool(*contains)(struct RealSet*, struct RealSet*, double);\n struct RealSet *rs;\n\n switch (type) {\n case CLOSED:\n contains = contains_closed;\n break;\n case LEFT_OPEN:\n contains = contains_left_open;\n break;\n case RIGHT_OPEN:\n contains = contains_right_open;\n break;\n case BOTH_OPEN:\n contains = contains_both_open;\n break;\n default:\n return NULL;\n }\n\n rs = malloc(sizeof(struct RealSet));\n rs->contains = contains;\n rs->left = NULL;\n rs->right = NULL;\n rs->low = low;\n rs->high = high;\n return rs;\n}\n\nstruct RealSet* makeIntersect(struct RealSet *left, struct RealSet *right) {\n struct RealSet *rs = malloc(sizeof(struct RealSet));\n rs->contains = contains_intersect;\n rs->left = left;\n rs->right = right;\n rs->low = fmin(left->low, right->low);\n rs->high = fmin(left->high, right->high);\n return rs;\n}\n\nstruct RealSet* makeUnion(struct RealSet *left, struct RealSet *right) {\n struct RealSet *rs = malloc(sizeof(struct RealSet));\n rs->contains = contains_union;\n rs->left = left;\n rs->right = right;\n rs->low = fmin(left->low, right->low);\n rs->high = fmin(left->high, right->high);\n return rs;\n}\n\nstruct RealSet* makeSubtract(struct RealSet *left, struct RealSet *right) {\n struct RealSet *rs = malloc(sizeof(struct RealSet));\n rs->contains = contains_subtract;\n rs->left = left;\n rs->right = right;\n rs->low = left->low;\n rs->high = left->high;\n return rs;\n}\n\nint main() {\n struct RealSet *a = makeSet(0.0, 1.0, LEFT_OPEN);\n struct RealSet *b = makeSet(0.0, 2.0, RIGHT_OPEN);\n struct RealSet *c = makeSet(1.0, 2.0, LEFT_OPEN);\n struct RealSet *d = makeSet(0.0, 3.0, RIGHT_OPEN);\n struct RealSet *e = makeSet(0.0, 1.0, BOTH_OPEN);\n struct RealSet *f = makeSet(0.0, 1.0, CLOSED);\n struct RealSet *g = makeSet(0.0, 0.0, CLOSED);\n int i;\n\n for (i = 0; i < 3; ++i) {\n struct RealSet *t;\n\n t = makeUnion(a, b);\n printf(\"(0, 1] union [0, 2) contains %d is %d\\n\", i, t->contains(t, NULL, i));\n free(t);\n\n t = makeIntersect(b, c);\n printf(\"[0, 2) intersect (1, 2] contains %d is %d\\n\", i, t->contains(t, NULL, i));\n free(t);\n\n t = makeSubtract(d, e);\n printf(\"[0, 3) - (0, 1) contains %d is %d\\n\", i, t->contains(t, NULL, i));\n free(t);\n\n t = makeSubtract(d, f);\n printf(\"[0, 3) - [0, 1] contains %d is %d\\n\", i, t->contains(t, NULL, i));\n free(t);\n\n printf(\"\\n\");\n }\n\n printf(\"[0, 0] is empty %d\\n\", empty(g));\n\n free(a);\n free(b);\n free(c);\n free(d);\n free(e);\n free(f);\n free(g);\n\n return 0;\n}\n","Rust":"#[derive(Debug)]\nenum SetOperation {\n Union,\n Intersection,\n Difference,\n}\n\n#[derive(Debug, PartialEq)]\nenum RangeType {\n Inclusive,\n Exclusive,\n}\n\n#[derive(Debug)]\nstruct CompositeSet<'a> {\n operation: SetOperation,\n a: &'a RealSet<'a>,\n b: &'a RealSet<'a>,\n}\n\n#[derive(Debug)]\nstruct RangeSet {\n range_types: (RangeType, RangeType),\n start: f64,\n end: f64,\n}\n\n#[derive(Debug)]\nenum RealSet<'a> {\n RangeSet(RangeSet),\n CompositeSet(CompositeSet<'a>),\n}\n\nimpl RangeSet {\n fn compare_start(&self, n: f64) -> bool {\n if self.range_types.0 == RangeType::Inclusive {\n self.start <= n\n } else {\n self.start < n\n }\n }\n\n fn compare_end(&self, n: f64) -> bool {\n if self.range_types.1 == RangeType::Inclusive {\n n <= self.end\n } else {\n n < self.end\n }\n }\n}\n\nimpl<'a> RealSet<'a> {\n fn new(start_type: RangeType, start: f64, end: f64, end_type: RangeType) -> Self {\n RealSet::RangeSet(RangeSet {\n range_types: (start_type, end_type),\n start,\n end,\n })\n }\n\n fn operation(&'a self, other: &'a Self, operation: SetOperation) -> Self {\n RealSet::CompositeSet(CompositeSet {\n operation,\n a: self,\n b: other,\n })\n }\n\n fn union(&'a self, other: &'a Self) -> Self {\n self.operation(other, SetOperation::Union)\n }\n\n fn intersection(&'a self, other: &'a Self) -> Self {\n self.operation(other, SetOperation::Intersection)\n }\n\n fn difference(&'a self, other: &'a Self) -> Self {\n self.operation(other, SetOperation::Difference)\n }\n\n fn contains(&self, n: f64) -> bool {\n if let RealSet::RangeSet(range) = self {\n range.compare_start(n) && range.compare_end(n)\n } else if let RealSet::CompositeSet(range) = self {\n match range.operation {\n SetOperation::Union => range.a.contains(n) || range.b.contains(n),\n SetOperation::Intersection => range.a.contains(n) && range.b.contains(n),\n SetOperation::Difference => range.a.contains(n) && !range.b.contains(n),\n }\n } else {\n unimplemented!();\n }\n }\n}\n\nfn make_contains_phrase(does_contain: bool) -> &'static str {\n if does_contain {\n \"contains\"\n } else {\n \"does not contain\"\n }\n}\n\nuse RangeType::*;\n\nfn main() {\n for (set_name, set) in [\n (\n \"(0, 1] \u222a [0, 2)\",\n RealSet::new(Exclusive, 0.0, 1.0, Inclusive)\n .union(&RealSet::new(Inclusive, 0.0, 2.0, Exclusive)),\n ),\n (\n \"[0, 2) \u2229 (1, 2]\",\n RealSet::new(Inclusive, 0.0, 2.0, Exclusive)\n .intersection(&RealSet::new(Exclusive, 1.0, 2.0, Inclusive)),\n ),\n (\n \"[0, 3) \u2212 (0, 1)\",\n RealSet::new(Inclusive, 0.0, 3.0, Exclusive)\n .difference(&RealSet::new(Exclusive, 0.0, 1.0, Exclusive)),\n ),\n (\n \"[0, 3) \u2212 [0, 1]\",\n RealSet::new(Inclusive, 0.0, 3.0, Exclusive)\n .difference(&RealSet::new(Inclusive, 0.0, 1.0, Inclusive)),\n ),\n ] {\n println!(\"Set {}\", set_name);\n\n for i in [0.0, 1.0, 2.0] {\n println!(\"- {} {}\", make_contains_phrase(set.contains(i)), i);\n }\n }\n}\n"} {"name":"Sexy primes","C":"#include \n#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\ntypedef unsigned char bool;\n\nvoid sieve(bool *c, int limit) {\n int i, p = 3, p2;\n \n c[0] = TRUE;\n c[1] = TRUE;\n \n for (;;) {\n p2 = p * p;\n if (p2 >= limit) {\n break;\n }\n for (i = p2; i < limit; i += 2*p) {\n c[i] = TRUE;\n }\n for (;;) {\n p += 2;\n if (!c[p]) {\n break;\n }\n }\n }\n}\n\nvoid printHelper(const char *cat, int len, int lim, int n) {\n const char *sp = strcmp(cat, \"unsexy primes\") ? \"sexy prime \" : \"\";\n const char *verb = (len == 1) ? \"is\" : \"are\";\n printf(\"Number of %s%s less than\u00a0%'d =\u00a0%'d\\n\", sp, cat, lim, len);\n printf(\"The last %d %s:\\n\", n, verb);\n}\n\nvoid printArray(int *a, int len) {\n int i;\n printf(\"[\");\n for (i = 0; i < len; ++i) printf(\"%d \", a[i]);\n printf(\"\\b]\");\n}\n\nint main() {\n int i, ix, n, lim = 1000035;\n int pairs = 0, trips = 0, quads = 0, quins = 0, unsexy = 2;\n int pr = 0, tr = 0, qd = 0, qn = 0, un = 2;\n int lpr = 5, ltr = 5, lqd = 5, lqn = 5, lun = 10;\n int last_pr[5][2], last_tr[5][3], last_qd[5][4], last_qn[5][5];\n int last_un[10];\n bool *sv = calloc(lim - 1, sizeof(bool)); \n setlocale(LC_NUMERIC, \"\");\n sieve(sv, lim);\n\n \n for (i = 3; i < lim; i += 2) {\n if (i > 5 && i < lim-6 && !sv[i] && sv[i-6] && sv[i+6]) {\n unsexy++;\n continue;\n }\n if (i < lim-6 && !sv[i] && !sv[i+6]) {\n pairs++;\n } else continue;\n\n if (i < lim-12 && !sv[i+12]) {\n trips++;\n } else continue;\n\n if (i < lim-18 && !sv[i+18]) {\n quads++;\n } else continue;\n\n if (i < lim-24 && !sv[i+24]) {\n quins++;\n }\n }\n if (pairs < lpr) lpr = pairs;\n if (trips < ltr) ltr = trips;\n if (quads < lqd) lqd = quads;\n if (quins < lqn) lqn = quins;\n if (unsexy < lun) lun = unsexy;\n\n \n for (i = 3; i < lim; i += 2) {\n if (i > 5 && i < lim-6 && !sv[i] && sv[i-6] && sv[i+6]) {\n un++;\n if (un > unsexy - lun) {\n last_un[un + lun - 1 - unsexy] = i;\n }\n continue;\n }\n if (i < lim-6 && !sv[i] && !sv[i+6]) {\n pr++;\n if (pr > pairs - lpr) {\n ix = pr + lpr - 1 - pairs;\n last_pr[ix][0] = i; last_pr[ix][1] = i + 6;\n }\n } else continue;\n\n if (i < lim-12 && !sv[i+12]) {\n tr++;\n if (tr > trips - ltr) {\n ix = tr + ltr - 1 - trips;\n last_tr[ix][0] = i; last_tr[ix][1] = i + 6;\n last_tr[ix][2] = i + 12;\n }\n } else continue;\n\n if (i < lim-18 && !sv[i+18]) {\n qd++;\n if (qd > quads - lqd) {\n ix = qd + lqd - 1 - quads;\n last_qd[ix][0] = i; last_qd[ix][1] = i + 6;\n last_qd[ix][2] = i + 12; last_qd[ix][3] = i + 18;\n }\n } else continue;\n\n if (i < lim-24 && !sv[i+24]) {\n qn++;\n if (qn > quins - lqn) {\n ix = qn + lqn - 1 - quins;\n last_qn[ix][0] = i; last_qn[ix][1] = i + 6;\n last_qn[ix][2] = i + 12; last_qn[ix][3] = i + 18;\n last_qn[ix][4] = i + 24;\n }\n }\n }\n\n printHelper(\"pairs\", pairs, lim, lpr);\n printf(\" [\");\n for (i = 0; i < lpr; ++i) {\n printArray(last_pr[i], 2);\n printf(\"\\b] \");\n }\n printf(\"\\b]\\n\\n\");\n\n printHelper(\"triplets\", trips, lim, ltr);\n printf(\" [\");\n for (i = 0; i < ltr; ++i) {\n printArray(last_tr[i], 3);\n printf(\"\\b] \");\n }\n printf(\"\\b]\\n\\n\");\n\n printHelper(\"quadruplets\", quads, lim, lqd);\n printf(\" [\");\n for (i = 0; i < lqd; ++i) {\n printArray(last_qd[i], 4);\n printf(\"\\b] \");\n }\n printf(\"\\b]\\n\\n\");\n\n printHelper(\"quintuplets\", quins, lim, lqn);\n printf(\" [\");\n for (i = 0; i < lqn; ++i) {\n printArray(last_qn[i], 5);\n printf(\"\\b] \");\n }\n printf(\"\\b]\\n\\n\");\n\n printHelper(\"unsexy primes\", unsexy, lim, lun);\n printf(\" [\");\n printArray(last_un, lun);\n printf(\"\\b]\\n\");\n free(sv);\n return 0;\n}\n","Rust":"\n\n\n\nuse circular_queue::CircularQueue;\n\nfn main() {\n let max = 1000035;\n let max_group_size = 5;\n let diff = 6;\n let max_groups = 5;\n let max_unsexy = 10;\n\n let sieve = primal::Sieve::new(max + diff);\n let mut group_count = vec![0; max_group_size];\n let mut unsexy_count = 0;\n let mut groups = Vec::new();\n let mut unsexy_primes = CircularQueue::with_capacity(max_unsexy);\n\n for _ in 0..max_group_size {\n groups.push(CircularQueue::with_capacity(max_groups));\n }\n\n for p in sieve.primes_from(2).take_while(|x| *x < max) {\n if !sieve.is_prime(p + diff) && (p < diff + 2 || !sieve.is_prime(p - diff)) {\n unsexy_count += 1;\n unsexy_primes.push(p);\n } else {\n let mut group = Vec::new();\n group.push(p);\n for group_size in 1..max_group_size {\n let next = p + group_size * diff;\n if next >= max || !sieve.is_prime(next) {\n break;\n }\n group.push(next);\n group_count[group_size] += 1;\n groups[group_size].push(group.clone());\n }\n }\n }\n\n for size in 1..max_group_size {\n println!(\n \"Number of groups of size {} is {}\",\n size + 1,\n group_count[size]\n );\n println!(\"Last {} groups of size {}:\", groups[size].len(), size + 1);\n println!(\n \"{}\\n\",\n groups[size]\n .asc_iter()\n .map(|g| format!(\"({})\", to_string(&mut g.iter())))\n .collect::>()\n .join(\", \")\n );\n }\n println!(\"Number of unsexy primes is {}\", unsexy_count);\n println!(\"Last {} unsexy primes:\", unsexy_primes.len());\n println!(\"{}\", to_string(&mut unsexy_primes.asc_iter()));\n}\n\nfn to_string(iter: &mut dyn std::iter::Iterator) -> String {\n iter.map(|n| n.to_string())\n .collect::>()\n .join(\", \")\n}\n"} {"name":"Shift list elements to left by 3","C":"#include \n\n\nvoid lshift(int *l, size_t n) {\n int i, f;\n if (n < 2) return;\n f = l[0];\n for (i = 0; i < n-1; ++i) l[i] = l[i+1];\n l[n-1] = f;\n}\n\nint main() {\n int l[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};\n int i;\n size_t n = 9;\n printf(\"Original list \u00a0: \");\n for (i = 0; i < n; ++i) printf(\"%d \", l[i]);\n printf(\"\\nShifted left by 3\u00a0: \");\n for (i = 0; i < 3; ++i) lshift(l, n);\n for (i = 0; i < n; ++i) printf(\"%d \", l[i]);\n printf(\"\\n\");\n return 0;\n}\n","Rust":"fn main() {\n let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];\n println!(\"Before: {:?}\", v);\n v.rotate_left(3);\n println!(\" After: {:?}\", v);\n}\n"} {"name":"Sierpinski pentagon","C":"#include\n#include\n#include\n#include\n#include\n\n#define pi M_PI\n\nint main(){\n\t\n\ttime_t t;\n\tdouble side, **vertices,seedX,seedY,windowSide = 500,sumX=0,sumY=0;\n\tint i,iter,choice,numSides;\n\t\n\tprintf(\"Enter number of sides\u00a0: \");\n\tscanf(\"%d\",&numSides);\n\t\n\tprintf(\"Enter polygon side length\u00a0: \");\n\tscanf(\"%lf\",&side);\n\t\n\tprintf(\"Enter number of iterations\u00a0: \");\n\tscanf(\"%d\",&iter);\n\n\tinitwindow(windowSide,windowSide,\"Polygon Chaos\");\n\t\n\tvertices = (double**)malloc(numSides*sizeof(double*));\n\t\n\tfor(i=0;i svg::Document {\n use std::f64::consts::PI;\n use svg::node::element::Polygon;\n\n let degrees72 = 0.4 * PI;\n let mut angle = 3.0 * degrees72;\n let scale_factor = 1.0 \/ (2.0 + degrees72.cos() * 2.0);\n\n if order == 1 {\n let mut points = Vec::new();\n points.push((x, y));\n for _ in 0..5 {\n x += angle.cos() * side;\n y -= angle.sin() * side;\n angle += degrees72;\n points.push((x, y));\n }\n let polygon = Polygon::new()\n .set(\"fill\", \"blue\")\n .set(\"stroke\", \"black\")\n .set(\"stroke-width\", \"1\")\n .set(\"points\", points);\n document = document.add(polygon);\n } else {\n side *= scale_factor;\n let distance = side + side * degrees72.cos() * 2.0;\n for _ in 0..5 {\n x += angle.cos() * distance;\n y -= angle.sin() * distance;\n angle += degrees72;\n document = sierpinski_pentagon(document, x, y, side, order - 1);\n }\n }\n document\n}\n\nfn write_sierpinski_pentagon(file: &str, size: usize, order: usize) -> std::io::Result<()> {\n use std::f64::consts::PI;\n use svg::node::element::Rectangle;\n\n let margin = 5.0;\n let radius = (size as f64) \/ 2.0 - 2.0 * margin;\n let side = radius * (0.2 * PI).sin() * 2.0;\n let height = side * ((0.2 * PI).sin() + (0.4 * PI).sin());\n let x = (size as f64) \/ 2.0;\n let y = (size as f64 - height) \/ 2.0;\n\n let rect = Rectangle::new()\n .set(\"width\", \"100%\")\n .set(\"height\", \"100%\")\n .set(\"fill\", \"white\");\n\n let mut document = svg::Document::new()\n .set(\"width\", size)\n .set(\"height\", size)\n .add(rect);\n\n document = sierpinski_pentagon(document, x, y, side, order);\n svg::save(file, &document)\n}\n\nfn main() {\n write_sierpinski_pentagon(\"sierpinski_pentagon.svg\", 600, 5).unwrap();\n}\n"} {"name":"Sierpinski triangle_Graphical","C":"#include \n#include \n#include \n#include \n \nlong long x, y, dx, dy, scale, clen, cscale;\ntypedef struct { double r, g, b; } rgb;\nrgb ** pix;\n \nvoid sc_up()\n{\n\tscale *= 2; x *= 2; y *= 2;\n\tcscale *= 3;\n}\n \nvoid h_rgb(long long x, long long y)\n{\n\trgb *p = &pix[y][x];\n \n#\tdefine SAT 1\n\tdouble h = 6.0 * clen \/ cscale;\n\tdouble VAL = 1;\n\tdouble c = SAT * VAL;\n\tdouble X = c * (1 - fabs(fmod(h, 2) - 1));\n \n\tswitch((int)h) {\n\tcase 0: p->r += c; p->g += X; return;\n\tcase 1:\tp->r += X; p->g += c; return;\n\tcase 2: p->g += c; p->b += X; return;\n\tcase 3: p->g += X; p->b += c; return;\n\tcase 4: p->r += X; p->b += c; return;\n\tdefault:\n\t\tp->r += c; p->b += X;\n\t}\n}\n \nvoid iter_string(const char * str, int d)\n{\n\tlong long len;\n\twhile (*str != '\\0') {\n\t\tswitch(*(str++)) {\n\t\tcase 'X':\n\t\t\tif (d)\titer_string(\"XHXVX\", d - 1);\n\t\t\telse{\n\t\t\t\tclen ++;\n\t\t\t\th_rgb(x\/scale, y\/scale);\n\t\t\t\tx += dx;\n\t\t\t\ty -= dy;\n\t\t\t}\n\t\t\tcontinue;\n\t\tcase 'V':\n\t\t\tlen = 1LLU << d;\n\t\t\twhile (len--) {\n\t\t\t\tclen ++;\n\t\t\t\th_rgb(x\/scale, y\/scale);\n\t\t\t\ty += dy;\n\t\t\t}\n\t\t\tcontinue;\n\t\tcase 'H':\n\t\t\tlen = 1LLU << d;\n\t\t\twhile(len --) {\n\t\t\t\tclen ++;\n\t\t\t\th_rgb(x\/scale, y\/scale);\n\t\t\t\tx -= dx;\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\t}\n}\n \nvoid sierp(long leng, int depth)\n{\n\tlong i;\n\tlong h = leng + 20, w = leng + 20;\n \n\t\n\trgb *buf = malloc(sizeof(rgb) * w * h);\n\tpix = malloc(sizeof(rgb *) * h);\n\tfor (i = 0; i < h; i++)\n\t\tpix[i] = buf + w * i;\n\tmemset(buf, 0, sizeof(rgb) * w * h);\n \n \n\tx = y = 10; dx = leng; dy = leng; scale = 1; clen = 0; cscale = 3;\n\tfor (i = 0; i < depth; i++) sc_up();\n\titer_string(\"VXH\", depth);\n \n\t\n\tunsigned char *fpix = malloc(w * h * 3);\n\tdouble maxv = 0, *dbuf = (double*)buf;\n \n\tfor (i = 3 * w * h - 1; i >= 0; i--)\n\t\tif (dbuf[i] > maxv) maxv = dbuf[i];\n\tfor (i = 3 * h * w - 1; i >= 0; i--)\n\t\tfpix[i] = 255 * dbuf[i] \/ maxv;\n \n\tprintf(\"P6\\n%ld %ld\\n255\\n\", w, h);\n\tfflush(stdout); \n\tfwrite(fpix, h * w * 3, 1, stdout);\n}\n \nint main(int c, char ** v)\n{\n\tint size, depth;\n \n\tdepth = (c > 1) ? atoi(v[1]) : 10;\n\tsize = 1 << depth;\n \n\tfprintf(stderr, \"size: %d depth: %d\\n\", size, depth);\n\tsierp(size, depth + 2);\n \n\treturn 0;\n}\n","Rust":"\n\n\nconst SQRT3_2: f64 = 0.86602540378444;\n\nfn sierpinski_triangle(\n mut document: svg::Document,\n mut x: f64,\n mut y: f64,\n mut side: f64,\n order: usize,\n) -> svg::Document {\n use svg::node::element::Polygon;\n\n if order == 1 {\n let mut points = Vec::new();\n points.push((x, y));\n y += side * SQRT3_2;\n x -= side * 0.5;\n points.push((x, y));\n x += side;\n points.push((x, y));\n let polygon = Polygon::new()\n .set(\"fill\", \"black\")\n .set(\"stroke\", \"none\")\n .set(\"points\", points);\n document = document.add(polygon);\n } else {\n side *= 0.5;\n document = sierpinski_triangle(document, x, y, side, order - 1);\n y += side * SQRT3_2;\n x -= side * 0.5;\n document = sierpinski_triangle(document, x, y, side, order - 1);\n x += side;\n document = sierpinski_triangle(document, x, y, side, order - 1);\n }\n document\n}\n\nfn write_sierpinski_triangle(file: &str, size: usize, order: usize) -> std::io::Result<()> {\n use svg::node::element::Rectangle;\n\n let margin = 20.0;\n let side = (size as f64) - 2.0 * margin;\n let y = 0.5 * ((size as f64) - SQRT3_2 * side);\n let x = margin + side * 0.5;\n\n let rect = Rectangle::new()\n .set(\"width\", \"100%\")\n .set(\"height\", \"100%\")\n .set(\"fill\", \"white\");\n\n let mut document = svg::Document::new()\n .set(\"width\", size)\n .set(\"height\", size)\n .add(rect);\n\n document = sierpinski_triangle(document, x, y, side, order);\n svg::save(file, &document)\n}\n\nfn main() {\n write_sierpinski_triangle(\"sierpinski_triangle.svg\", 600, 8).unwrap();\n}\n"} {"name":"Simulate input_Keyboard","C":"#include \n#include \n#include \n#include \n\nint main(int argc, char *argv[])\n{\n Display *dpy;\n Window win;\n GC gc;\n int scr;\n Atom WM_DELETE_WINDOW;\n XEvent ev;\n XEvent ev2;\n KeySym keysym;\n int loop;\n\n \n dpy = XOpenDisplay(NULL);\n if (dpy == NULL) {\n fputs(\"Cannot open display\", stderr);\n exit(1);\n }\n scr = XDefaultScreen(dpy);\n\n \n win = XCreateSimpleWindow(dpy,\n XRootWindow(dpy, scr),\n \n 10, 10, 300, 200, 1,\n \n XBlackPixel(dpy, scr), XWhitePixel(dpy, scr));\n\n \n XStoreName(dpy, win, argv[0]);\n\n \n XSelectInput(dpy, win, ExposureMask | KeyPressMask | ButtonPressMask);\n\n \n XMapWindow(dpy, win);\n XFlush(dpy);\n\n \n gc = XDefaultGC(dpy, scr);\n\n \n WM_DELETE_WINDOW = XInternAtom(dpy, \"WM_DELETE_WINDOW\", True);\n XSetWMProtocols(dpy, win, &WM_DELETE_WINDOW, 1);\n\n \n loop = 1;\n while (loop) {\n XNextEvent(dpy, &ev);\n switch (ev.type)\n {\n case Expose:\n \n {\n char msg1[] = \"Clic in the window to generate\";\n char msg2[] = \"a key press event\";\n XDrawString(dpy, win, gc, 10, 20, msg1, sizeof(msg1)-1);\n XDrawString(dpy, win, gc, 10, 35, msg2, sizeof(msg2)-1);\n }\n break;\n\n case ButtonPress:\n puts(\"ButtonPress event received\");\n \n ev2.type = KeyPress;\n ev2.xkey.state = ShiftMask;\n ev2.xkey.keycode = 24 + (rand() % 33);\n ev2.xkey.same_screen = True;\n XSendEvent(dpy, win, True, KeyPressMask, &ev2);\n break;\n \n case ClientMessage:\n \n if (ev.xclient.data.l[0] == WM_DELETE_WINDOW)\n loop = 0;\n break;\n \n case KeyPress:\n \n puts(\"KeyPress event received\");\n printf(\"> keycode: %d\\n\", ev.xkey.keycode);\n \n keysym = XLookupKeysym(&(ev.xkey), 0);\n if (keysym == XK_q ||\n keysym == XK_Escape) {\n loop = 0;\n } else {\n char buffer[] = \" \";\n int nchars = XLookupString(\n &(ev.xkey),\n buffer,\n 2, \n &keysym,\n NULL );\n if (nchars == 1)\n printf(\"> Key '%c' pressed\\n\", buffer[0]);\n }\n break;\n }\n }\n XDestroyWindow(dpy, win);\n \n XCloseDisplay(dpy);\n return 1;\n}\n","Rust":"extern crate autopilot;\nfn main() {\n autopilot::key::type_string(\"Hello, world!\", None, None, &[]);\n}\n"} {"name":"Simulate input_Mouse","C":"#define WINVER 0x500\n#include\n\nint main()\n{\n\tint maxX = GetSystemMetrics(SM_CXSCREEN), maxY = GetSystemMetrics(SM_CYSCREEN);\n\tint x = maxX\/2, y = maxY\/2;\n\tdouble factorX = 65536.0 \/ maxX,factorY = 65536.0 \/ maxY;\n\t\n\tINPUT ip;\n\t\n\tZeroMemory(&ip,sizeof(ip));\n\t\n\tip.type = INPUT_MOUSE;\n\t\n\twhile(x > 5 || y < maxY-5){\n\n\tip.mi.mouseData = 0;\n\tip.mi.dx = x * factorX;\n\tip.mi.dy = y * factorY;\n\tip.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;\n\t\t\n\tSendInput(1,&ip,sizeof(ip));\n\tSleep(1);\n\tif(x>3)\t\n\t\tx-=1;\n\tif(y Result<(), autopilot::mouse::MouseError> {\n let screen_size = autopilot::screen::size();\n let scoped_height = screen_size.height \/ 2.0 - 10.0; \n for x in 0..screen_size.width as u64 {\n let y = (scoped_height * ((TWO_PI * x as f64) \/ screen_size.width).sin() + scoped_height)\n .round();\n let duration: u64 = rand::thread_rng().gen_range(1, 3);\n try!(autopilot::mouse::move_to(autopilot::geometry::Point::new(\n x as f64,\n y as f64\n )));\n std::thread::sleep(std::time::Duration::from_millis(duration));\n }\n Ok(())\n}\n\nfn main() {\n sine_mouse_wave().expect(\"Unable to move mouse\");\n}\n"} {"name":"Smarandache prime-digital sequence","C":"#include \n#include \n#include \n#include \n\ntypedef uint32_t integer;\n\ninteger next_prime_digit_number(integer n) {\n if (n == 0)\n return 2;\n switch (n % 10) {\n case 2:\n return n + 1;\n case 3:\n case 5:\n return n + 2;\n default:\n return 2 + next_prime_digit_number(n\/10) * 10;\n }\n}\n\nbool is_prime(integer n) {\n if (n < 2)\n return false;\n if (n % 2 == 0)\n return n == 2;\n if (n % 3 == 0)\n return n == 3;\n if (n % 5 == 0)\n return n == 5;\n static const integer wheel[] = { 4,2,4,2,4,6,2,6 };\n integer p = 7;\n for (;;) {\n for (int i = 0; i < 8; ++i) {\n if (p * p > n)\n return true;\n if (n % p == 0)\n return false;\n p += wheel[i];\n }\n }\n}\n\nint main() {\n setlocale(LC_ALL, \"\");\n const integer limit = 1000000000;\n integer n = 0, max = 0;\n printf(\"First 25 SPDS primes:\\n\");\n for (int i = 0; n < limit; ) {\n n = next_prime_digit_number(n);\n if (!is_prime(n))\n continue;\n if (i < 25) {\n if (i > 0)\n printf(\" \");\n printf(\"%'u\", n);\n }\n else if (i == 25)\n printf(\"\\n\");\n ++i;\n if (i == 100)\n printf(\"Hundredth SPDS prime:\u00a0%'u\\n\", n);\n else if (i == 1000)\n printf(\"Thousandth SPDS prime:\u00a0%'u\\n\", n);\n else if (i == 10000)\n printf(\"Ten thousandth SPDS prime:\u00a0%'u\\n\", n);\n max = n;\n }\n printf(\"Largest SPDS prime less than\u00a0%'u:\u00a0%'u\\n\", limit, max);\n return 0;\n}\n","Rust":"fn is_prime(n: u32) -> bool {\n if n < 2 {\n return false;\n }\n if n % 2 == 0 {\n return n == 2;\n }\n if n % 3 == 0 {\n return n == 3;\n }\n if n % 5 == 0 {\n return n == 5;\n }\n let mut p = 7;\n const WHEEL: [u32; 8] = [4, 2, 4, 2, 4, 6, 2, 6];\n loop {\n for w in &WHEEL {\n if p * p > n {\n return true;\n }\n if n % p == 0 {\n return false;\n }\n p += w;\n }\n }\n}\n\nfn next_prime_digit_number(n: u32) -> u32 {\n if n == 0 {\n return 2;\n }\n match n % 10 {\n 2 => n + 1,\n 3 | 5 => n + 2,\n _ => 2 + next_prime_digit_number(n \/ 10) * 10,\n }\n}\n\nfn smarandache_prime_digital_sequence() -> impl std::iter::Iterator {\n let mut n = 0;\n std::iter::from_fn(move || {\n loop {\n n = next_prime_digit_number(n);\n if is_prime(n) {\n break;\n }\n }\n Some(n)\n })\n}\n\nfn main() {\n let limit = 1000000000;\n let mut seq = smarandache_prime_digital_sequence().take_while(|x| *x < limit);\n println!(\"First 25 SPDS primes:\");\n for i in seq.by_ref().take(25) {\n print!(\"{} \", i);\n }\n println!();\n if let Some(p) = seq.by_ref().nth(99 - 25) {\n println!(\"100th SPDS prime: {}\", p);\n }\n if let Some(p) = seq.by_ref().nth(999 - 100) {\n println!(\"1000th SPDS prime: {}\", p);\n }\n if let Some(p) = seq.by_ref().nth(9999 - 1000) {\n println!(\"10,000th SPDS prime: {}\", p);\n }\n if let Some(p) = seq.last() {\n println!(\"Largest SPDS prime less than {}: {}\", limit, p);\n }\n}\n"} {"name":"Solve a Hidato puzzle","C":"#include \n#include \n#include \n#include \n\nint *board, *flood, *known, top = 0, w, h;\n\nstatic inline int idx(int y, int x) { return y * w + x; }\n\nint neighbors(int c, int *p)\n\n{\n\tint i, j, n = 0;\n\tint y = c \/ w, x = c % w;\n\n\tfor (i = y - 1; i <= y + 1; i++) {\n\t\tif (i < 0 || i >= h) continue;\n\t\tfor (j = x - 1; j <= x + 1; j++)\n\t\t\tif (!(j < 0 || j >= w\n\t\t\t\t|| (j == x && i == y)\n\t\t\t\t|| board[ p[n] = idx(i,j) ] == -1))\n\t\t\t\tn++;\n\t}\n\n\treturn n;\n}\n\nvoid flood_fill(int c)\n\n{\n\tint i, n[8], nei;\n\n\tnei = neighbors(c, n);\n\tfor (i = 0; i < nei; i++) { \n\t\tif (board[n[i]] || flood[n[i]]) continue; \n\n\t\tflood[n[i]] = 1;\n\t\tflood_fill(n[i]);\n\t}\n}\n\n\nint check_connectity(int lowerbound)\n{\n\tint c;\n\tmemset(flood, 0, sizeof(flood[0]) * w * h);\n\tfor (c = lowerbound + 1; c <= top; c++)\n\t\tif (known[c]) flood_fill(known[c]); \n\n\tfor (c = 0; c < w * h; c++)\n\t\tif (!board[c] && !flood[c]) \n\t\t\treturn 0;\n\n\treturn 1;\n}\n\nvoid make_board(int x, int y, const char *s)\n{\n\tint i;\n\n\tw = x, h = y;\n top = 0;\n\tx = w * h;\n\n known = calloc(x + 1, sizeof(int));\n board = calloc(x, sizeof(int));\n flood = calloc(x, sizeof(int));\n\n\twhile (x--) board[x] = -1;\n\n\tfor (y = 0; y < h; y++)\n\tfor (x = 0; x < w; x++) {\n\t\ti = idx(y, x);\n\n\t\twhile (isspace(*s)) s++;\n\n\t\tswitch (*s) {\n\t\tcase '_':\tboard[i] = 0;\n\t\tcase '.':\tbreak;\n\t\tdefault:\n\t\t\tknown[ board[i] = strtol(s, 0, 10) ] = i;\n\t\t\tif (board[i] > top) top = board[i];\n\t\t}\n\n\t\twhile (*s && !isspace(*s)) s++;\n\t}\n}\n\nvoid show_board(const char *s)\n{\n\tint i, j, c;\n\n\tprintf(\"\\n%s:\\n\", s);\n\n\tfor (i = 0; i < h; i++, putchar('\\n'))\n\tfor (j = 0; j < w; j++) {\n\t\tc = board[ idx(i, j) ];\n\t\tprintf(!c ? \" __\" : c == -1 ? \" \" : \" %2d\", c);\n\t}\n}\n\nint fill(int c, int n)\n{\n\tint i, nei, p[8], ko, bo;\n\n\tif ((board[c] && board[c] != n) || (known[n] && known[n] != c))\n\t\treturn 0;\n\n\tif (n == top) return 1;\n\n\tko = known[n];\n\tbo = board[c];\n\tboard[c] = n;\n\n\tif (check_connectity(n)) {\n\t\tnei = neighbors(c, p);\n\t\tfor (i = 0; i < nei; i++)\n\t\t\tif (fill(p[i], n + 1))\n\t\t\t\treturn 1;\n\t}\n\n\tboard[c] = bo;\n\tknown[n] = ko;\n\treturn 0;\n}\n\nint main()\n{\n\tmake_board(\n#define USE_E 0\n#if (USE_E == 0)\n\t\t8,8,\t\" __ 33 35 __ __ .. .. ..\"\n\t\t\t\" __ __ 24 22 __ .. .. ..\"\n\t\t\t\" __ __ __ 21 __ __ .. ..\"\n\t\t\t\" __ 26 __ 13 40 11 .. ..\"\n\t\t\t\" 27 __ __ __ 9 __ 1 ..\"\n\t\t\t\" . . __ __ 18 __ __ ..\"\n\t\t\t\" . .. . . __ 7 __ __\"\n\t\t\t\" . .. .. .. . . 5 __\"\n#elif (USE_E == 1)\n\t3, 3,\t\" . 4 .\"\n\t\t\" _ 7 _\"\n\t\t\" 1 _ _\"\n#else\n\t50, 3,\n\t\" 1 _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . 74\"\n\t\" . . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ . _ .\"\n\t\" . . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ . . _ _ .\"\n#endif\n\t);\n\n\tshow_board(\"Before\");\n\tfill(known[1], 1);\n\tshow_board(\"After\"); \n\n\treturn 0;\n}\n","Rust":"use std::cmp::{max, min};\nuse std::fmt;\nuse std::ops;\n\n#[derive(Debug, Clone, PartialEq)]\nstruct Board {\n cells: Vec>>,\n}\n\nimpl Board {\n fn new(initial_board: Vec>) -> Self {\n let b = initial_board\n .iter()\n .map(|r| {\n r.iter()\n .map(|c| if *c == u32::MAX { None } else { Some(*c) })\n .collect()\n })\n .collect();\n\n Board { cells: b }\n }\n\n fn height(&self) -> usize {\n self.cells.len()\n }\n\n fn width(&self) -> usize {\n self.cells[0].len()\n }\n}\nimpl ops::Index<(usize, usize)> for Board {\n type Output = Option;\n\n fn index(&self, (y, x): (usize, usize)) -> &Self::Output {\n &self.cells[y][x]\n }\n}\nimpl ops::IndexMut<(usize, usize)> for Board {\n \n fn index_mut(&mut self, (y, x): (usize, usize)) -> &mut Option {\n &mut self.cells[y][x]\n }\n}\n\nimpl fmt::Display for Board {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let output: Vec = self\n .cells\n .iter()\n .map(|r| {\n let mut row = String::default();\n\n r.iter().for_each(|c| match c {\n None => row.push_str(format!(\"{:>2} \", \" \").as_ref()),\n Some(c) if c == &0 => row.push_str(format!(\"{:>2} \", \".\").as_ref()),\n Some(c) => row.push_str(format!(\"{:>2} \", c).as_ref()),\n });\n row\n })\n .collect();\n\n write!(f, \"{}\", output.join(\"\\n\"))\n }\n}\n\n\n#[derive(Clone, Debug)]\nstruct Puzzle {\n \n board: Board,\n\n \n \n fixed: Vec,\n\n \n start: (usize, usize),\n}\n\nimpl Puzzle {\n \n \n \n \n \n \n \n \n fn new(initial_board: Vec>) -> Self {\n let mut s: (usize, usize) = (0, 0);\n let mut f = initial_board\n .iter()\n .enumerate()\n .flat_map(|(y, r)| r.iter().enumerate().map(move |(x, c)| (y, x, *c)))\n .filter(|(_, _, c)| (1..u32::MAX).contains(c))\n .fold(Vec::new(), |mut fixed, (y, x, c)| {\n fixed.push(c);\n if c == 1 {\n \n s = (y, x)\n };\n fixed\n });\n\n f.sort_unstable();\n\n Puzzle {\n board: Board::new(initial_board),\n fixed: f,\n start: s,\n }\n }\n\n pub fn print_board(&self) {\n println!(\"{}\", self.board);\n }\n\n fn solver(&mut self, current: (usize, usize), n: &u32, mut next: usize) -> bool {\n \n if n > self.fixed.last().unwrap() {\n return true;\n }\n\n \n match self.board[current] {\n \n None => return false,\n\n \n Some(c) if c != 0 && c != *n => return false,\n\n \n Some(c) if c == 0 && self.fixed[next] == *n => return false,\n\n \n _ => (),\n }\n\n let mut backup: u32 = 0;\n if self.board[current] == Some(*n) {\n backup = *n;\n next += 1;\n }\n\n self.board[current] = Some(*n);\n\n for y in (max(current.0, 1) - 1)..=min(current.0 + 1, self.board.height() - 1) {\n for x in (max(current.1, 1) - 1)..=min(current.1 + 1, self.board.width() - 1) {\n if self.solver((y, x), &(n + 1), next) {\n return true;\n }\n }\n }\n\n \n self.board[current] = Some(backup);\n false\n }\n\n pub fn solve(&mut self) {\n let start = self.start;\n self.solver(start, &1, 0);\n }\n}\n\nfn main() {\n let input = vec![\n vec![0, 33, 35, 0, 0, u32::MAX, u32::MAX, u32::MAX],\n vec![0, 0, 24, 22, 0, u32::MAX, u32::MAX, u32::MAX],\n vec![0, 0, 0, 21, 0, 0, u32::MAX, u32::MAX],\n vec![0, 26, 0, 13, 40, 11, u32::MAX, u32::MAX],\n vec![27, 0, 0, 0, 9, 0, 1, u32::MAX],\n vec![u32::MAX, u32::MAX, 0, 0, 18, 0, 0, u32::MAX],\n vec![u32::MAX, u32::MAX, u32::MAX, u32::MAX, 0, 7, 0, 0],\n vec![\n u32::MAX,\n u32::MAX,\n u32::MAX,\n u32::MAX,\n u32::MAX,\n u32::MAX,\n 5,\n 0,\n ],\n ];\n\n let mut p = Puzzle::new(input);\n p.print_board();\n p.solve();\n println!(\"\\nSolution:\");\n p.print_board();\n}\n"} {"name":"Sorting Algorithms_Circle Sort","C":"#include \n\nint circle_sort_inner(int *start, int *end)\n{\n\tint *p, *q, t, swapped;\n\n\tif (start == end) return 0;\n\n\t\n\tfor (swapped = 0, p = start, q = end; p *q)\n\t\t\tt = *p, *p = *q, *q = t, swapped = 1;\n\n\t\n\treturn swapped | circle_sort_inner(start, q) | circle_sort_inner(p, end);\n}\n\n\nvoid circle_sort(int *x, int n)\n{\n\tdo {\n\t\tint i;\n\t\tfor (i = 0; i < n; i++) printf(\"%d \", x[i]);\n\t\tputchar('\\n');\n\t} while (circle_sort_inner(x, x + (n - 1)));\n}\n\nint main(void)\n{\n\tint x[] = {5, -1, 101, -4, 0, 1, 8, 6, 2, 3};\n\tcircle_sort(x, sizeof(x) \/ sizeof(*x));\n\n\treturn 0;\n}\n","Rust":"fn _circle_sort(a: &mut [T], low: usize, high: usize, swaps: usize) -> usize {\n if low == high {\n return swaps;\n }\n let mut lo = low;\n let mut hi = high;\n let mid = (hi - lo) \/ 2;\n let mut s = swaps;\n while lo < hi {\n if a[lo] > a[hi] {\n a.swap(lo, hi);\n s += 1;\n }\n lo += 1;\n hi -= 1;\n }\n if lo == hi {\n if a[lo] > a[hi + 1] {\n a.swap(lo, hi + 1);\n s += 1;\n }\n }\n s = _circle_sort(a, low, low + mid, s);\n s = _circle_sort(a, low + mid + 1, high, s);\n return s;\n}\n\nfn circle_sort(a: &mut [T]) {\n let len = a.len();\n loop {\n if _circle_sort(a, 0, len - 1, 0) == 0 {\n break;\n }\n }\n}\n\nfn main() {\n let mut v = vec![10, 8, 4, 3, 1, 9, 0, 2, 7, 5, 6];\n println!(\"before: {:?}\", v);\n circle_sort(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Sorting algorithms_Cocktail sort with shifting bounds","C":"#include \n#include \n\nvoid swap(char* p1, char* p2, size_t size) {\n for (; size-- > 0; ++p1, ++p2) {\n char tmp = *p1;\n *p1 = *p2;\n *p2 = tmp;\n }\n}\n\nvoid cocktail_shaker_sort(void* base, size_t count, size_t size,\n int (*cmp)(const void*, const void*)) {\n char* begin = base;\n char* end = base + size * count;\n if (end == begin)\n return;\n for (end -= size; begin < end; ) {\n char* new_begin = end;\n char* new_end = begin;\n for (char* p = begin; p < end; p += size) {\n char* q = p + size;\n if (cmp(p, q) > 0) {\n swap(p, q, size);\n new_end = p;\n }\n }\n end = new_end;\n for (char* p = end; p > begin; p -= size) {\n char* q = p - size;\n if (cmp(q, p) > 0) {\n swap(p, q, size);\n new_begin = p;\n }\n }\n begin = new_begin;\n }\n}\n\nint string_compare(const void* p1, const void* p2) {\n const char* const* s1 = p1;\n const char* const* s2 = p2;\n return strcmp(*s1, *s2);\n}\n\nvoid print(const char** a, size_t len) {\n for (size_t i = 0; i < len; ++i)\n printf(\"%s \", a[i]);\n printf(\"\\n\");\n}\n\nint main() {\n const char* a[] = { \"one\", \"two\", \"three\", \"four\", \"five\",\n \"six\", \"seven\", \"eight\" };\n const size_t len = sizeof(a)\/sizeof(a[0]);\n printf(\"before: \");\n print(a, len);\n cocktail_shaker_sort(a, len, sizeof(char*), string_compare);\n printf(\"after: \");\n print(a, len);\n return 0;\n}\n","Rust":"fn cocktail_shaker_sort(a: &mut [T]) {\n let mut begin = 0;\n let mut end = a.len();\n if end == 0 {\n return;\n }\n end -= 1;\n while begin < end {\n let mut new_begin = end;\n let mut new_end = begin;\n for i in begin..end {\n if a[i + 1] < a[i] {\n a.swap(i, i + 1);\n new_end = i;\n }\n }\n end = new_end;\n let mut i = end;\n while i > begin {\n if a[i] < a[i - 1] {\n a.swap(i, i - 1);\n new_begin = i;\n }\n i -= 1;\n }\n begin = new_begin;\n }\n}\n\nfn main() {\n let mut v = vec![5, 1, -6, 12, 3, 13, 2, 4, 0, 15];\n println!(\"before: {:?}\", v);\n cocktail_shaker_sort(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Sorting algorithms_Shell sort","C":"#include \n\nvoid shell_sort (int *a, int n) {\n int h, i, j, t;\n for (h = n; h \/= 2;) {\n for (i = h; i < n; i++) {\n t = a[i];\n for (j = i; j >= h && t < a[j - h]; j -= h) {\n a[j] = a[j - h];\n }\n a[j] = t;\n }\n }\n}\n\nint main (int ac, char **av) {\n int a[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1};\n int n = sizeof a \/ sizeof a[0];\n int i;\n for (i = 0; i < n; i++)\n printf(\"%d%s\", a[i], i == n - 1 ? \"\\n\" : \" \");\n shell_sort(a, n);\n for (i = 0; i < n; i++)\n printf(\"%d%s\", a[i], i == n - 1 ? \"\\n\" : \" \");\n return 0;\n}\n","Rust":"fn shell_sort(v: &mut [T]) {\n let mut gap = v.len() \/ 2;\n let len = v.len();\n while gap > 0 {\n for i in gap..len {\n let temp = v[i];\n let mut j = i;\n while j >= gap && v[j - gap] > temp {\n v[j] = v[j - gap];\n j -= gap;\n }\n v[j] = temp;\n }\n gap \/= 2;\n }\n}\n\nfn main() {\n let mut numbers = [4i32, 65, 2, -31, 0, 99, 2, 83, 782, 1];\n println!(\"Before: {:?}\", numbers);\n shell_sort(&mut numbers);\n println!(\"After: {:?}\", numbers);\n}\n"} {"name":"Sorting algorithms_Stooge sort","C":"#include \n\n#define SWAP(r,s) do{ t=r; r=s; s=t; } while(0)\n\nvoid StoogeSort(int a[], int i, int j) \n{\n int t;\n \n if (a[j] < a[i]) SWAP(a[i], a[j]);\n if (j - i > 1)\n {\n t = (j - i + 1) \/ 3;\n StoogeSort(a, i, j - t);\n StoogeSort(a, i + t, j);\n StoogeSort(a, i, j - t);\n }\n}\n \nint main(int argc, char *argv[])\n{\n int nums[] = {1, 4, 5, 3, -6, 3, 7, 10, -2, -5, 7, 5, 9, -3, 7};\n int i, n;\n \n n = sizeof(nums)\/sizeof(int);\n StoogeSort(nums, 0, n-1);\n \n for(i = 0; i <= n-1; i++)\n printf(\"%5d\", nums[i]);\n \n return 0;\n}\n","Rust":"fn stoogesort(a: &mut [E])\n where E: PartialOrd\n{\n let len = a.len();\n\n if a.first().unwrap() > a.last().unwrap() {\n a.swap(0, len - 1);\n }\n if len - 1 > 1 {\n let t = len \/ 3;\n stoogesort(&mut a[..len - 1]);\n stoogesort(&mut a[t..]);\n stoogesort(&mut a[..len - 1]);\n }\n}\n\nfn main() {\n let mut numbers = vec![1_i32, 9, 4, 7, 6, 5, 3, 2, 8];\n println!(\"Before: {:?}\", &numbers);\n stoogesort(&mut numbers);\n println!(\"After: {:?}\", &numbers);\n}\n"} {"name":"Sparkline in unicode","C":"#include\n#include\n#include\n#include\n#include\n#include\n\nint main(int argC,char* argV[])\n{\n\tdouble* arr,min,max;\n\tchar* str;\n\tint i,len;\n\tif(argC == 1)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\telse{\n\t\tarr = (double*)malloc((argC-1)*sizeof(double));\n\t\tfor(i=1;iarr[i-1]?max:arr[i-1]);\n\t\t\t}\n\t\t}\n\t\t\n\t\tprintf(\"\\n%Max\u00a0: %lf,Min\u00a0: %lf,Range\u00a0: %lf\\n\",max,min,max-min);\n\t\t\n\t\tsetlocale(LC_ALL, \"\");\n\t\t\n\t\tfor(i=1;i>();\n let line: String = s.replace(\",\", \" \").split(\" \")\n .filter(|x| !x.is_empty())\n .map(|x| v[x.parse::().unwrap().ceil() as usize - 1])\n .collect();\n println!(\"{:?}\", line);\n}\n\nfn main(){\n let s1 = \"1 2 3 4 5 6 7 8 7 6 5 4 3 2 1\";\n print_sparkline(s1);\n let s2 = \"1.5, 0.5 3.5, 2.5 5.5, 4.5 7.5, 6.5\";\n print_sparkline(s2);\n}\n"} {"name":"Spelling of ordinal numbers","C":"#include \n#include \n#include \n#include \n\ntypedef uint64_t integer;\n\ntypedef struct number_names_tag {\n const char* cardinal;\n const char* ordinal;\n} number_names;\n\nconst number_names small[] = {\n { \"zero\", \"zeroth\" }, { \"one\", \"first\" }, { \"two\", \"second\" },\n { \"three\", \"third\" }, { \"four\", \"fourth\" }, { \"five\", \"fifth\" },\n { \"six\", \"sixth\" }, { \"seven\", \"seventh\" }, { \"eight\", \"eighth\" },\n { \"nine\", \"ninth\" }, { \"ten\", \"tenth\" }, { \"eleven\", \"eleventh\" },\n { \"twelve\", \"twelfth\" }, { \"thirteen\", \"thirteenth\" },\n { \"fourteen\", \"fourteenth\" }, { \"fifteen\", \"fifteenth\" },\n { \"sixteen\", \"sixteenth\" }, { \"seventeen\", \"seventeenth\" },\n { \"eighteen\", \"eighteenth\" }, { \"nineteen\", \"nineteenth\" }\n};\n\nconst number_names tens[] = {\n { \"twenty\", \"twentieth\" }, { \"thirty\", \"thirtieth\" },\n { \"forty\", \"fortieth\" }, { \"fifty\", \"fiftieth\" },\n { \"sixty\", \"sixtieth\" }, { \"seventy\", \"seventieth\" },\n { \"eighty\", \"eightieth\" }, { \"ninety\", \"ninetieth\" }\n};\n\ntypedef struct named_number_tag {\n const char* cardinal;\n const char* ordinal;\n integer number;\n} named_number;\n\nconst named_number named_numbers[] = {\n { \"hundred\", \"hundredth\", 100 },\n { \"thousand\", \"thousandth\", 1000 },\n { \"million\", \"millionth\", 1000000 },\n { \"billion\", \"billionth\", 1000000000 },\n { \"trillion\", \"trillionth\", 1000000000000 },\n { \"quadrillion\", \"quadrillionth\", 1000000000000000ULL },\n { \"quintillion\", \"quintillionth\", 1000000000000000000ULL }\n};\n\nconst char* get_small_name(const number_names* n, bool ordinal) {\n return ordinal ? n->ordinal : n->cardinal;\n}\n\nconst char* get_big_name(const named_number* n, bool ordinal) {\n return ordinal ? n->ordinal : n->cardinal;\n}\n\nconst named_number* get_named_number(integer n) {\n const size_t names_len = sizeof(named_numbers)\/sizeof(named_numbers[0]);\n for (size_t i = 0; i + 1 < names_len; ++i) {\n if (n < named_numbers[i + 1].number)\n return &named_numbers[i];\n }\n return &named_numbers[names_len - 1];\n}\n\nvoid append_number_name(GString* gstr, integer n, bool ordinal) {\n if (n < 20)\n g_string_append(gstr, get_small_name(&small[n], ordinal));\n else if (n < 100) {\n if (n % 10 == 0) {\n g_string_append(gstr, get_small_name(&tens[n\/10 - 2], ordinal));\n } else {\n g_string_append(gstr, get_small_name(&tens[n\/10 - 2], false));\n g_string_append_c(gstr, '-');\n g_string_append(gstr, get_small_name(&small[n % 10], ordinal));\n }\n } else {\n const named_number* num = get_named_number(n);\n integer p = num->number;\n append_number_name(gstr, n\/p, false);\n g_string_append_c(gstr, ' ');\n if (n % p == 0) {\n g_string_append(gstr, get_big_name(num, ordinal));\n } else {\n g_string_append(gstr, get_big_name(num, false));\n g_string_append_c(gstr, ' ');\n append_number_name(gstr, n % p, ordinal);\n }\n }\n}\n\nGString* number_name(integer n, bool ordinal) {\n GString* result = g_string_sized_new(8);\n append_number_name(result, n, ordinal);\n return result;\n}\n\nvoid test_ordinal(integer n) {\n GString* name = number_name(n, true);\n printf(\"%llu: %s\\n\", n, name->str);\n g_string_free(name, TRUE);\n}\n\nint main() {\n test_ordinal(1);\n test_ordinal(2);\n test_ordinal(3);\n test_ordinal(4);\n test_ordinal(5);\n test_ordinal(11);\n test_ordinal(15);\n test_ordinal(21);\n test_ordinal(42);\n test_ordinal(65);\n test_ordinal(98);\n test_ordinal(100);\n test_ordinal(101);\n test_ordinal(272);\n test_ordinal(300);\n test_ordinal(750);\n test_ordinal(23456);\n test_ordinal(7891233);\n test_ordinal(8007006005004003LL);\n return 0;\n}\n","Rust":"struct NumberNames {\n cardinal: &'static str,\n ordinal: &'static str,\n}\n\nimpl NumberNames {\n fn get_name(&self, ordinal: bool) -> &'static str {\n if ordinal {\n return self.ordinal;\n }\n self.cardinal\n }\n}\n\nconst SMALL_NAMES: [NumberNames; 20] = [\n NumberNames {\n cardinal: \"zero\",\n ordinal: \"zeroth\",\n },\n NumberNames {\n cardinal: \"one\",\n ordinal: \"first\",\n },\n NumberNames {\n cardinal: \"two\",\n ordinal: \"second\",\n },\n NumberNames {\n cardinal: \"three\",\n ordinal: \"third\",\n },\n NumberNames {\n cardinal: \"four\",\n ordinal: \"fourth\",\n },\n NumberNames {\n cardinal: \"five\",\n ordinal: \"fifth\",\n },\n NumberNames {\n cardinal: \"six\",\n ordinal: \"sixth\",\n },\n NumberNames {\n cardinal: \"seven\",\n ordinal: \"seventh\",\n },\n NumberNames {\n cardinal: \"eight\",\n ordinal: \"eighth\",\n },\n NumberNames {\n cardinal: \"nine\",\n ordinal: \"ninth\",\n },\n NumberNames {\n cardinal: \"ten\",\n ordinal: \"tenth\",\n },\n NumberNames {\n cardinal: \"eleven\",\n ordinal: \"eleventh\",\n },\n NumberNames {\n cardinal: \"twelve\",\n ordinal: \"twelfth\",\n },\n NumberNames {\n cardinal: \"thirteen\",\n ordinal: \"thirteenth\",\n },\n NumberNames {\n cardinal: \"fourteen\",\n ordinal: \"fourteenth\",\n },\n NumberNames {\n cardinal: \"fifteen\",\n ordinal: \"fifteenth\",\n },\n NumberNames {\n cardinal: \"sixteen\",\n ordinal: \"sixteenth\",\n },\n NumberNames {\n cardinal: \"seventeen\",\n ordinal: \"seventeenth\",\n },\n NumberNames {\n cardinal: \"eighteen\",\n ordinal: \"eighteenth\",\n },\n NumberNames {\n cardinal: \"nineteen\",\n ordinal: \"nineteenth\",\n },\n];\n\nconst TENS: [NumberNames; 8] = [\n NumberNames {\n cardinal: \"twenty\",\n ordinal: \"twentieth\",\n },\n NumberNames {\n cardinal: \"thirty\",\n ordinal: \"thirtieth\",\n },\n NumberNames {\n cardinal: \"forty\",\n ordinal: \"fortieth\",\n },\n NumberNames {\n cardinal: \"fifty\",\n ordinal: \"fiftieth\",\n },\n NumberNames {\n cardinal: \"sixty\",\n ordinal: \"sixtieth\",\n },\n NumberNames {\n cardinal: \"seventy\",\n ordinal: \"seventieth\",\n },\n NumberNames {\n cardinal: \"eighty\",\n ordinal: \"eightieth\",\n },\n NumberNames {\n cardinal: \"ninety\",\n ordinal: \"ninetieth\",\n },\n];\n\nstruct NamedNumber {\n cardinal: &'static str,\n ordinal: &'static str,\n number: usize,\n}\n\nimpl NamedNumber {\n fn get_name(&self, ordinal: bool) -> &'static str {\n if ordinal {\n return self.ordinal;\n }\n self.cardinal\n }\n}\n\nconst N: usize = 7;\nconst NAMED_NUMBERS: [NamedNumber; N] = [\n NamedNumber {\n cardinal: \"hundred\",\n ordinal: \"hundredth\",\n number: 100,\n },\n NamedNumber {\n cardinal: \"thousand\",\n ordinal: \"thousandth\",\n number: 1000,\n },\n NamedNumber {\n cardinal: \"million\",\n ordinal: \"millionth\",\n number: 1000000,\n },\n NamedNumber {\n cardinal: \"billion\",\n ordinal: \"billionth\",\n number: 1000000000,\n },\n NamedNumber {\n cardinal: \"trillion\",\n ordinal: \"trillionth\",\n number: 1000000000000,\n },\n NamedNumber {\n cardinal: \"quadrillion\",\n ordinal: \"quadrillionth\",\n number: 1000000000000000,\n },\n NamedNumber {\n cardinal: \"quintillion\",\n ordinal: \"quintillionth\",\n number: 1000000000000000000,\n },\n];\n\nfn big_name(n: usize) -> &'static NamedNumber {\n for i in 1..N {\n if n < NAMED_NUMBERS[i].number {\n return &NAMED_NUMBERS[i - 1];\n }\n }\n &NAMED_NUMBERS[N - 1]\n}\n\nfn number_name(n: usize, ordinal: bool) -> String {\n if n < 20 {\n return String::from(SMALL_NAMES[n].get_name(ordinal));\n } else if n < 100 {\n if n % 10 == 0 {\n return String::from(TENS[n \/ 10 - 2].get_name(ordinal));\n }\n let s1 = TENS[n \/ 10 - 2].get_name(false);\n let s2 = SMALL_NAMES[n % 10].get_name(ordinal);\n return format!(\"{}-{}\", s1, s2);\n }\n let big = big_name(n);\n let mut result = number_name(n \/ big.number, false);\n result.push(' ');\n if n % big.number == 0 {\n result.push_str(big.get_name(ordinal));\n } else {\n result.push_str(big.get_name(false));\n result.push(' ');\n result.push_str(&number_name(n % big.number, ordinal));\n }\n result\n}\n\nfn test_ordinal(n: usize) {\n println!(\"{}: {}\", n, number_name(n, true));\n}\n\nfn main() {\n test_ordinal(1);\n test_ordinal(2);\n test_ordinal(3);\n test_ordinal(4);\n test_ordinal(5);\n test_ordinal(11);\n test_ordinal(15);\n test_ordinal(21);\n test_ordinal(42);\n test_ordinal(65);\n test_ordinal(98);\n test_ordinal(100);\n test_ordinal(101);\n test_ordinal(272);\n test_ordinal(300);\n test_ordinal(750);\n test_ordinal(23456);\n test_ordinal(7891233);\n test_ordinal(8007006005004003);\n}\n"} {"name":"Square-free integers","C":"#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n#define TRILLION 1000000000000\n\ntypedef unsigned char bool;\ntypedef unsigned long long uint64;\n\nvoid sieve(uint64 limit, uint64 *primes, uint64 *length) {\n uint64 i, count, p, p2;\n bool *c = calloc(limit + 1, sizeof(bool)); \n primes[0] = 2;\n count = 1;\n \n p = 3;\n for (;;) {\n p2 = p * p;\n if (p2 > limit) break;\n for (i = p2; i <= limit; i += 2 * p) c[i] = TRUE;\n for (;;) {\n p += 2;\n if (!c[p]) break;\n }\n }\n for (i = 3; i <= limit; i += 2) {\n if (!c[i]) primes[count++] = i;\n }\n *length = count;\n free(c);\n}\n\nvoid squareFree(uint64 from, uint64 to, uint64 *results, uint64 *len) { \n uint64 i, j, p, p2, np, count = 0, limit = (uint64)sqrt((double)to);\n uint64 *primes = malloc((limit + 1) * sizeof(uint64));\n bool add;\n sieve(limit, primes, &np);\n for (i = from; i <= to; ++i) {\n add = TRUE;\n for (j = 0; j < np; ++j) {\n p = primes[j];\n p2 = p * p;\n if (p2 > i) break;\n if (i % p2 == 0) {\n add = FALSE;\n break;\n }\n }\n if (add) results[count++] = i;\n }\n *len = count;\n free(primes);\n}\n\nint main() {\n uint64 i, *sf, len;\n \n sf = malloc(1000000 * sizeof(uint64));\n printf(\"Square-free integers from 1 to 145:\\n\");\n squareFree(1, 145, sf, &len);\n for (i = 0; i < len; ++i) {\n if (i > 0 && i % 20 == 0) {\n printf(\"\\n\");\n }\n printf(\"%4lld\", sf[i]);\n }\n\n printf(\"\\n\\nSquare-free integers from %ld to %ld:\\n\", TRILLION, TRILLION + 145);\n squareFree(TRILLION, TRILLION + 145, sf, &len);\n for (i = 0; i < len; ++i) {\n if (i > 0 && i % 5 == 0) {\n printf(\"\\n\");\n }\n printf(\"%14lld\", sf[i]);\n }\n\n printf(\"\\n\\nNumber of square-free integers:\\n\");\n int a[5] = {100, 1000, 10000, 100000, 1000000};\n for (i = 0; i < 5; ++i) {\n squareFree(1, a[i], sf, &len);\n printf(\" from %d to %d = %lld\\n\", 1, a[i], len);\n }\n free(sf);\n return 0; \n}\n","Rust":"fn square_free(mut n: usize) -> bool {\n if n & 3 == 0 {\n return false;\n }\n let mut p: usize = 3;\n while p * p <= n {\n let mut count = 0;\n while n % p == 0 {\n count += 1;\n if count > 1 {\n return false;\n }\n n \/= p;\n }\n p += 2;\n }\n true\n}\n\nfn print_square_free_numbers(from: usize, to: usize) {\n println!(\"Square-free numbers between {} and {}:\", from, to);\n let mut line = String::new();\n for i in from..=to {\n if square_free(i) {\n if !line.is_empty() {\n line.push_str(\" \");\n }\n line.push_str(&i.to_string());\n if line.len() >= 80 {\n println!(\"{}\", line);\n line.clear();\n }\n }\n }\n if !line.is_empty() {\n println!(\"{}\", line);\n }\n}\n\nfn print_square_free_count(from: usize, to: usize) {\n let mut count = 0;\n for i in from..=to {\n if square_free(i) {\n count += 1;\n }\n }\n println!(\n \"Number of square-free numbers between {} and {}: {}\",\n from, to, count\n )\n}\n\nfn main() {\n print_square_free_numbers(1, 145);\n print_square_free_numbers(1000000000000, 1000000000145);\n let mut n: usize = 100;\n while n <= 1000000 {\n print_square_free_count(1, n);\n n *= 10;\n }\n}\n"} {"name":"Statistics_Normal distribution","C":"\n#include \n#include \n#include \n#include \n#include \n\n\n#define NMAX 10000000\n\n\ndouble mean(double* values, int n)\n{\n int i;\n double s = 0;\n\n for ( i = 0; i < n; i++ )\n s += values[i];\n return s \/ n;\n}\n\n\ndouble stddev(double* values, int n)\n{\n int i;\n double average = mean(values,n);\n double s = 0;\n\n for ( i = 0; i < n; i++ )\n s += (values[i] - average) * (values[i] - average);\n return sqrt(s \/ (n - 1));\n}\n\n\ndouble* generate(int n)\n{\n int i;\n int m = n + n % 2;\n double* values = (double*)calloc(m,sizeof(double));\n double average, deviation;\n\n if ( values )\n {\n for ( i = 0; i < m; i += 2 )\n {\n double x,y,rsq,f;\n do {\n x = 2.0 * rand() \/ (double)RAND_MAX - 1.0;\n y = 2.0 * rand() \/ (double)RAND_MAX - 1.0;\n rsq = x * x + y * y;\n }while( rsq >= 1. || rsq == 0. );\n f = sqrt( -2.0 * log(rsq) \/ rsq );\n values[i] = x * f;\n values[i+1] = y * f;\n }\n }\n return values;\n}\n\n\nvoid printHistogram(double* values, int n)\n{\n const int width = 50; \n int max = 0;\n\n const double low = -3.05;\n const double high = 3.05;\n const double delta = 0.1;\n\n int i,j,k;\n int nbins = (int)((high - low) \/ delta);\n int* bins = (int*)calloc(nbins,sizeof(int));\n if ( bins != NULL )\n {\n for ( i = 0; i < n; i++ )\n {\n int j = (int)( (values[i] - low) \/ delta );\n if ( 0 <= j && j < nbins )\n bins[j]++;\n }\n\n for ( j = 0; j < nbins; j++ )\n if ( max < bins[j] )\n max = bins[j];\n\n for ( j = 0; j < nbins; j++ )\n {\n printf(\"(%5.2f, %5.2f) |\", low + j * delta, low + (j + 1) * delta );\n k = (int)( (double)width * (double)bins[j] \/ (double)max );\n while(k-- > 0) putchar('*');\n printf(\" \u00a0%-.1f%%\", bins[j] * 100.0 \/ (double)n);\n putchar('\\n');\n }\n\n free(bins);\n }\n}\n\n\nint main(void)\n{\n double* seq;\n\n srand((unsigned int)time(NULL));\n\n if ( (seq = generate(NMAX)) != NULL )\n {\n printf(\"mean = %g, stddev = %g\\n\\n\", mean(seq,NMAX), stddev(seq,NMAX));\n printHistogram(seq,NMAX);\n free(seq);\n\n printf(\"\\n%s\\n\", \"press enter\");\n getchar();\n return EXIT_SUCCESS;\n }\n return EXIT_FAILURE;\n}\n","Rust":"\nuse math::{histogram::Histogram, traits::ToIterator};\nuse rand;\nuse rand_distr::{Distribution, Normal};\n\n\n\n\n\nfn mean(data: &[f32]) -> Option {\n let sum: f32 = data.iter().sum();\n Some(sum \/ data.len() as f32)\n}\n\n\n\n\n\nfn standard_deviation(data: &[f32]) -> Option {\n let mean = mean(data).expect(\"invalid mean\");\n let sum = data.iter().fold(0.0, |acc, &x| acc + (x - mean).powi(2));\n Some((sum \/ data.len() as f32).sqrt())\n}\n\n\n\n\n\n\n\n\nfn print_histogram(data: &[f32], maxwidth: usize, bincount: usize, ch: char) {\n let min_val = data.iter().cloned().fold(f32::NAN, f32::min);\n let max_val = data.iter().cloned().fold(f32::NAN, f32::max);\n let histogram = Histogram::new(Some(&data.to_vec()), bincount, min_val, max_val).unwrap();\n let max_bin_value = histogram.get_counters().iter().max().unwrap();\n println!();\n for x in histogram.to_iter() {\n let (bin_min, bin_max, freq) = x;\n let bar_width = (((freq as f64) \/ (*max_bin_value as f64)) * (maxwidth as f64)) as u32;\n let bar_as_string = (1..bar_width).fold(String::new(), |b, _| b + &ch.to_string());\n println!(\n \"({:>6},{:>6}) |{} {:.2}%\",\n format!(\"{:.2}\", bin_min),\n format!(\"{:.2}\", bin_max),\n bar_as_string,\n (freq as f64) * 100.0 \/ (data.len() as f64)\n );\n }\n println!();\n}\n\n\nfn main() {\n let expected_mean: f32 = 0.0;\n let expected_std_deviation: f32 = 4.0;\n let normal = Normal::new(expected_mean, expected_std_deviation).unwrap();\n\n let mut rng = rand::thread_rng();\n for &number_of_samples in &[1000, 10_000, 1_000_000] {\n let data: Vec = normal\n .sample_iter(&mut rng)\n .take(number_of_samples)\n .collect();\n println!(\"Statistics for sample size {}:\", number_of_samples);\n println!(\"\\tMean: {:?}\", mean(&data).expect(\"invalid mean\"));\n println!(\n \"\\tStandard deviation: {:?}\",\n standard_deviation(&data).expect(\"invalid standard deviation\")\n );\n print_histogram(&data, 80, 40, '-');\n }\n}\n"} {"name":"Strange unique prime triplets","C":"#include \n#include \n#include \n\n#define LIMIT 3000\n\nvoid init_sieve(unsigned char sieve[], int limit) {\n int i, j;\n\n for (i = 0; i < limit; i++) {\n sieve[i] = 1;\n }\n sieve[0] = 0;\n sieve[1] = 0;\n\n for (i = 2; i < limit; i++) {\n if (sieve[i]) {\n for (j = i + i; j < limit; j += i) {\n sieve[j] = 0;\n }\n }\n }\n}\n\nvoid strange_unique_prime_triplets(unsigned char sieve[], int limit, bool verbose) {\n int count = 0, sum;\n int i, j, k, n, p;\n int pi, pj, pk;\n\n n = 0;\n for (i = 0; i < limit; i++) {\n if (sieve[i]) {\n n++;\n }\n }\n\n if (verbose) {\n printf(\"Strange unique prime triplets < %d:\\n\", limit);\n }\n\n for (i = 0; i + 2 < n; i++) {\n pi = 2;\n p = i;\n while (p > 0) {\n pi++;\n if (sieve[pi]) {\n p--;\n }\n }\n\n for (j = i + 1; j + 1 < n; j++) {\n pj = pi;\n p = j - i;\n while (p > 0) {\n pj++;\n if (sieve[pj]) {\n p--;\n }\n }\n\n for (k = j + 1; k < n; k++) {\n pk = pj;\n p = k - j;\n while (p > 0) {\n pk++;\n if (sieve[pk]) {\n p--;\n }\n }\n\n sum = pi + pj + pk;\n if (sum < LIMIT && sieve[sum]) {\n count++;\n if (verbose) {\n printf(\"%2d + %2d + %2d = %d\\n\", pi, pj, pk, sum);\n }\n }\n }\n }\n }\n\n printf(\"Count of strange unique prime triplets < %d is %d.\\n\\n\", limit, count);\n}\n\nint main() {\n unsigned char sieve[LIMIT];\n\n init_sieve(sieve, LIMIT);\n\n strange_unique_prime_triplets(sieve, 30, true);\n strange_unique_prime_triplets(sieve, 1000, false);\n\n return 0;\n}\n","Rust":"fn prime_sieve(limit: usize) -> Vec {\n let mut sieve = vec![true; limit];\n if limit > 0 {\n sieve[0] = false;\n }\n if limit > 1 {\n sieve[1] = false;\n }\n for i in (4..limit).step_by(2) {\n sieve[i] = false;\n }\n let mut p = 3;\n loop {\n let mut q = p * p;\n if q >= limit {\n break;\n }\n if sieve[p] {\n let inc = 2 * p;\n while q < limit {\n sieve[q] = false;\n q += inc;\n }\n }\n p += 2;\n }\n sieve\n}\n\nfn strange_unique_prime_triplets(limit: usize, verbose: bool) {\n if limit < 6 {\n return;\n }\n let mut primes = Vec::new();\n let sieve = prime_sieve(limit * 3);\n for p in (3..limit).step_by(2) {\n if sieve[p] {\n primes.push(p);\n }\n }\n if verbose {\n println!(\"Strange unique prime triplets < {}:\", limit);\n }\n let mut count = 0;\n let n = primes.len();\n for i in 0..n - 2 {\n for j in i + 1..n - 1 {\n for k in j + 1..n {\n let sum = primes[i] + primes[j] + primes[k];\n if sieve[sum] {\n count += 1;\n if verbose {\n println!(\n \"{:2} + {:2} + {:2} = {:2}\",\n primes[i], primes[j], primes[k], sum\n );\n }\n }\n }\n }\n }\n println!(\n \"Count of strange unique prime triplets < {} is {}.\",\n limit, count\n );\n}\n\nfn main() {\n strange_unique_prime_triplets(30, true);\n strange_unique_prime_triplets(1000, false);\n}\n"} {"name":"Strong and weak primes","C":"#include \n#include \n#include \n#include \n\nconst int PRIMES[] = {\n 2, 3, 5, 7,\n 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,\n 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,\n 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,\n 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769,\n 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997,\n 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217,\n 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,\n 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663,\n 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907,\n 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141,\n 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383,\n 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659,\n 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861,\n 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163\n};\n#define PRIME_LENGTH (sizeof(PRIMES) \/ sizeof(int))\n\nbool isPrime(int n) {\n int i;\n\n if (n < 2) {\n return false;\n }\n\n for (i = 0; i < PRIME_LENGTH; ++i) {\n if (n == PRIMES[i]) {\n return true;\n }\n if (n % PRIMES[i] == 0) {\n return false;\n }\n if (n < PRIMES[i] * PRIMES[i]) {\n break;\n }\n }\n\n return true;\n}\n\nint main() {\n const int MAX_LENGTH = 700000;\n int i, n, c1, c2;\n\n int *primePtr = calloc(MAX_LENGTH, sizeof(int));\n if (primePtr == 0) {\n return EXIT_FAILURE;\n }\n\n for (i = 0; i < PRIME_LENGTH; i++) {\n primePtr[i] = PRIMES[i];\n }\n\n i--;\n for (n = PRIMES[i] + 4; n < 10000100;) {\n if (isPrime(n)) {\n primePtr[i++] = n;\n }\n n += 2;\n\n if (isPrime(n)) {\n primePtr[i++] = n;\n }\n n += 4;\n\n if (i >= MAX_LENGTH) {\n printf(\"Allocate more memory.\");\n return EXIT_FAILURE;\n }\n }\n\n \n printf(\"First 36 strong primes:\");\n c1 = 0;\n c2 = 0;\n for (n = 0, i = 1; i < MAX_LENGTH - 1; i++) {\n if (2 * primePtr[i] > primePtr[i - 1] + primePtr[i + 1]) {\n if (n < 36) {\n printf(\" %d\", primePtr[i]);\n n++;\n }\n if (primePtr[i] < 1000000) {\n c1++;\n c2++;\n } else if (primePtr[i] < 10000000) {\n c2++;\n } else break;\n }\n }\n printf(\"\\nThere are %d strong primes below 1,000,000\", c1);\n printf(\"\\nThere are %d strong primes below 10,000,000\\n\\n\", c2);\n\n \n printf(\"First 37 weak primes:\");\n c1 = 0;\n c2 = 0;\n for (n = 0, i = 1; i < MAX_LENGTH - 1; i++) {\n if (2 * primePtr[i] < primePtr[i - 1] + primePtr[i + 1]) {\n if (n < 37) {\n printf(\" %d\", primePtr[i]);\n n++;\n }\n if (primePtr[i] < 1000000) {\n c1++;\n c2++;\n } else if (primePtr[i] < 10000000) {\n c2++;\n } else break;\n }\n }\n printf(\"\\nThere are %d weak primes below 1,000,000\", c1);\n printf(\"\\nThere are %d weak primes below 10,000,000\\n\\n\", c2);\n\n free(primePtr);\n return EXIT_SUCCESS;\n}\n","Rust":"fn is_prime(n: i32) -> bool {\n\tfor i in 2..n {\n\t\tif i * i > n {\n\t\t\treturn true;\n\t\t}\n\t\tif n % i == 0 {\n\t\t\treturn false;\n\t\t}\n\t}\n\tn > 1\n}\n\nfn next_prime(n: i32) -> i32 {\n\tfor i in (n+1).. {\n\t\tif is_prime(i) {\n\t\t\treturn i;\n\t\t}\n\t}\n\t0\n}\n\nfn main() {\n\tlet mut n = 0;\n\tlet mut prime_q = 5;\n\tlet mut prime_p = 3;\n\tlet mut prime_o = 2;\n\n\tprint!(\"First 36 strong primes: \");\n\twhile n < 36 {\n\t\tif prime_p > (prime_o + prime_q) \/ 2 {\n\t\t\tprint!(\"{} \",prime_p);\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"\");\n\n\twhile prime_p < 1000000 {\n\t\tif prime_p > (prime_o + prime_q) \/ 2 {\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"strong primes below 1,000,000: {}\", n);\n\n\twhile prime_p < 10000000 {\n\t\tif prime_p > (prime_o + prime_q) \/ 2 {\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"strong primes below 10,000,000: {}\", n);\n\n\tn = 0;\n\tprime_q = 5;\n\tprime_p = 3;\n\tprime_o = 2;\n\n\tprint!(\"First 36 weak primes: \");\n\twhile n < 36 {\n\t\tif prime_p < (prime_o + prime_q) \/ 2 {\n\t\t\tprint!(\"{} \",prime_p);\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"\");\n\n\twhile prime_p < 1000000 {\n\t\tif prime_p < (prime_o + prime_q) \/ 2 {\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"weak primes below 1,000,000: {}\", n);\n\n\twhile prime_p < 10000000 {\n\t\tif prime_p < (prime_o + prime_q) \/ 2 {\n\t\t\tn += 1;\n\t\t}\n\t\tprime_o = prime_p;\n\t\tprime_p = prime_q;\n\t\tprime_q = next_prime(prime_q);\n\t}\n\tprintln!(\"weak primes below 10,000,000: {}\", n);\n}\n"} {"name":"Successive prime differences","C":"#include \n#include \n#include \n\n#define PRIME_COUNT 100000\nint64_t PRIMES[PRIME_COUNT];\nsize_t primeSize = 0;\n\nbool isPrime(int n) {\n size_t i = 0;\n\n for (i = 0; i < primeSize; i++) {\n int64_t p = PRIMES[i];\n if (n == p) {\n return true;\n }\n if (n % p == 0) {\n return false;\n }\n if (p * p > n) {\n break;\n }\n }\n\n return true;\n}\n\nvoid initialize() {\n int i;\n\n PRIMES[primeSize++] = 2;\n PRIMES[primeSize++] = 3;\n PRIMES[primeSize++] = 5;\n PRIMES[primeSize++] = 7;\n PRIMES[primeSize++] = 11;\n PRIMES[primeSize++] = 13;\n PRIMES[primeSize++] = 17;\n PRIMES[primeSize++] = 19;\n\n for (i = 21; primeSize < PRIME_COUNT;) {\n if (isPrime(i)) {\n PRIMES[primeSize++] = i;\n }\n i += 2;\n\n if (primeSize < PRIME_COUNT && isPrime(i)) {\n PRIMES[primeSize++] = i;\n }\n i += 2;\n }\n}\n\nvoid diff1(size_t diff) {\n int64_t pm0, pm1;\n int64_t fg1 = 0, fg2 = 0, lg1 = 0, lg2 = 0;\n size_t pos, count = 0;\n\n if (diff == 0) {\n return;\n }\n\n pm0 = PRIMES[0];\n for (pos = 1; pos < PRIME_COUNT; pos++) {\n pm1 = pm0;\n pm0 = PRIMES[pos];\n if (pm0 > 1000000) {\n break;\n }\n if (pm0 - pm1 == diff) {\n count++;\n if (fg1 == 0) {\n fg1 = pm1;\n fg2 = pm0;\n }\n lg1 = pm1;\n lg2 = pm0;\n }\n }\n\n printf(\"%ld|%d|%lld %lld|%lld %lld|\\n\", diff, count, fg1, fg2, lg1, lg2);\n}\n\nvoid diff2(size_t d0, size_t d1) {\n int64_t pm0, pm1, pm2;\n int64_t fg1 = 0, fg2, fg3, lg1, lg2, lg3;\n size_t pos, count = 0;\n\n if (d0 == 0 || d1 == 0) {\n return;\n }\n\n pm1 = PRIMES[0];\n pm0 = PRIMES[1];\n for (pos = 2; pos < PRIME_COUNT; pos++) {\n pm2 = pm1;\n pm1 = pm0;\n pm0 = PRIMES[pos];\n if (pm0 > 1000000) {\n break;\n }\n if (pm1 - pm2 == d0 && pm0 - pm1 == d1) {\n count++;\n if (fg1 == 0) {\n fg1 = pm2;\n fg2 = pm1;\n fg3 = pm0;\n }\n lg1 = pm2;\n lg2 = pm1;\n lg3 = pm0;\n }\n }\n\n printf(\"%d %d|%d|%lld %lld %lld|%lld %lld %lld|\\n\", d0, d1, count, fg1, fg2, fg3, lg1, lg2, lg3);\n}\n\nvoid diff3(size_t d0, size_t d1, size_t d2) {\n int64_t pm0, pm1, pm2, pm3;\n int64_t fg1 = 0, fg2, fg3, fg4, lg1, lg2, lg3, lg4;\n size_t pos, count = 0;\n\n if (d0 == 0 || d1 == 0 || d2 == 0) {\n return;\n }\n\n pm2 = PRIMES[0];\n pm1 = PRIMES[1];\n pm0 = PRIMES[2];\n for (pos = 3; pos < PRIME_COUNT; pos++) {\n pm3 = pm2;\n pm2 = pm1;\n pm1 = pm0;\n pm0 = PRIMES[pos];\n if (pm0 > 1000000) {\n break;\n }\n if (pm2 - pm3 == d0 && pm1 - pm2 == d1 && pm0 - pm1 == d2) {\n count++;\n if (fg1 == 0) {\n fg1 = pm3;\n fg2 = pm2;\n fg3 = pm1;\n fg4 = pm0;\n }\n lg1 = pm3;\n lg2 = pm2;\n lg3 = pm1;\n lg4 = pm0;\n }\n }\n\n printf(\"%d %d %d|%d|%lld %lld %lld %lld|%lld %lld %lld %lld|\\n\", d0, d1, d2, count, fg1, fg2, fg3, fg4, lg1, lg2, lg3, lg4);\n}\n\nint main() {\n initialize();\n\n printf(\"differences|count|first group|last group\\n\");\n\n diff1(2);\n diff1(1);\n\n diff2(2, 2);\n diff2(2, 4);\n diff2(4, 2);\n\n diff3(6, 4, 2);\n\n return 0;\n}\n","Rust":"fn is_prime(num: u32) -> bool {\n match num {\n x if x < 4 => x > 1,\n x if x % 2 == 0 => false,\n x => { let limit = (x as f32).sqrt().ceil() as u32;\n (3..=limit).step_by(2).all(|a| x % a != 0)\n }\n } \n}\n\nfn primes_by_diffs(primes: &[u32], diffs: &[u32]) -> Vec> {\n\n fn select(diffs: &[u32], prime_win: &[u32], acc: bool) -> bool {\n if diffs.is_empty() || !acc {\n acc\n }\n else {\n let acc1 = prime_win[0] + diffs[0] == prime_win[1];\n select(&diffs[1..], &prime_win[1..], acc1)\n }\n }\n \n primes.windows(diffs.len() + 1)\n .filter(|&win| select(diffs, win, true))\n .map(|win| win.to_vec())\n .collect()\n}\n\nfn main() {\n let limit = 1_000_000u32;\n let start = std::time::Instant::now();\n let primes = (2..).filter(|&i| is_prime(i));\n let prime_list: Vec = primes.take_while(|&p| p <= limit).collect();\n let duration = start.elapsed();\n println!(\"primes time: {:?}\", duration);\n for diffs in vec!(vec!(1), vec!(2), vec!(2,2), vec!(2,4), vec!(4,2), vec!(6,4,2), vec!(2,4,6)) {\n let result_list = primes_by_diffs(&prime_list, &diffs);\n let len = result_list.len();\n println!(\"{:?} number: {}\\n\\tfirst: {:?}\", diffs, len, result_list[0]);\n if len == 1 {\n println!()\n }\n if len > 1 {\n println!(\"\\tlast: {:?}\\n\", result_list.last().unwrap())\n }\n }\n}\n"} {"name":"Sum data type","C":"#include\n\ntypedef union data{\n int i;\n float f;\n char c;\n}united;\n\nint main()\n{\n united udat;\n\n udat.i = 5;\n udat.f = 3.14159;\n udat.c = 'C';\n\n printf(\"Integer i = %d , address of i = %p\\n\",udat.i,&udat.i);\n printf(\"Float f = %f , address of f = %p\\n\",udat.f,&udat.f);\n printf(\"Character c = %c , address of c = %p\\n\",udat.c,&udat.c);\n\n return 0;\n}\n","Rust":"enum IpAddr {\n V4(u8, u8, u8, u8),\n V6(String),\n}\n\nlet home = IpAddr::V4(127, 0, 0, 1);\n\nlet loopback = IpAddr::V6(String::from(\"::1\"));\n"} {"name":"Summarize primes","C":"#include \n#include \n\nbool is_prime(int n) {\n int i = 5;\n\n if (n < 2) {\n return false;\n }\n\n if (n % 2 == 0) {\n return n == 2;\n }\n if (n % 3 == 0) {\n return n == 3;\n }\n\n while (i * i <= n) {\n if (n % i == 0) {\n return false;\n }\n i += 2;\n\n if (n % i == 0) {\n return false;\n }\n i += 4;\n }\n\n return true;\n}\n\nint main() {\n const int start = 1;\n const int stop = 1000;\n\n int sum = 0;\n int count = 0;\n int sc = 0;\n int p;\n\n for (p = start; p < stop; p++) {\n if (is_prime(p)) {\n count++;\n sum += p;\n if (is_prime(sum)) {\n printf(\"The sum of %3d primes in [2, %3d] is %5d which is also prime\\n\", count, p, sum);\n sc++;\n }\n }\n }\n printf(\"There are %d summerized primes in [%d, %d)\\n\", sc, start, stop);\n\n return 0;\n}\n","Rust":"\n\n\nfn main() {\n let limit = 1000;\n let mut sum = 0;\n println!(\"count prime sum\");\n for (n, p) in primal::Sieve::new(limit)\n .primes_from(2)\n .take_while(|x| *x < limit)\n .enumerate()\n {\n sum += p;\n if primal::is_prime(sum as u64) {\n println!(\" {:>3} {:>3} {:>5}\", n + 1, p, sum);\n }\n }\n}\n"} {"name":"Super-d numbers","C":"#include \n#include \n#include \n#include \n\nint main() {\n for (unsigned int d = 2; d <= 9; ++d) {\n printf(\"First 10 super-%u numbers:\\n\", d);\n char digits[16] = { 0 };\n memset(digits, '0' + d, d);\n mpz_t bignum;\n mpz_init(bignum);\n for (unsigned int count = 0, n = 1; count < 10; ++n) {\n mpz_ui_pow_ui(bignum, n, d);\n mpz_mul_ui(bignum, bignum, d);\n char* str = mpz_get_str(NULL, 10, bignum);\n if (strstr(str, digits)) {\n printf(\"%u \", n);\n ++count;\n }\n free(str);\n }\n mpz_clear(bignum);\n printf(\"\\n\");\n }\n return 0;\n}\n","Rust":"\n\n\nfn print_super_d_numbers(d: u32, limit: u32) {\n use rug::Assign;\n use rug::Integer;\n\n println!(\"First {} super-{} numbers:\", limit, d);\n let digits = d.to_string().repeat(d as usize);\n let mut count = 0;\n let mut n = 1;\n let mut s = Integer::new();\n while count < limit {\n s.assign(Integer::u_pow_u(n, d));\n s *= d;\n if s.to_string().contains(&digits) {\n print!(\"{} \", n);\n count += 1;\n }\n n += 1;\n }\n println!();\n}\n\nfn main() {\n for d in 2..=9 {\n print_super_d_numbers(d, 10);\n }\n}\n"} {"name":"Tarjan","C":"#include \n#include \n#include \n\n#ifndef min\n#define min(x, y) ((x)<(y)\u00a0? (x)\u00a0: (y))\n#endif\n\nstruct edge {\n\tvoid *from;\n\tvoid *to;\n};\n\nstruct components {\n\tint nnodes;\n\tvoid **nodes;\n\tstruct components *next;\n};\n\nstruct node {\n\tint index;\n\tint lowlink;\n\tbool onStack;\n\tvoid *data;\n};\n\nstruct tjstate {\n\tint index;\n\tint sp;\n\tint nedges;\n\tstruct edge *edges;\n\tstruct node **stack;\n\tstruct components *head;\n\tstruct components *tail;\n};\n\nstatic int nodecmp(const void *l, const void *r)\n{\n\treturn (ptrdiff_t)l -(ptrdiff_t)((struct node *)r)->data;\n}\n\nstatic int strongconnect(struct node *v, struct tjstate *tj)\n{\n\tstruct node *w;\n\n\t\n\tv->index = tj->index;\n\tv->lowlink = tj->index;\n\ttj->index++;\n\ttj->stack[tj->sp] = v;\n\ttj->sp++;\n\tv->onStack = true;\n\n\tfor (int i = 0; inedges; i++) {\n\t\t\n\t\tif (tj->edges[i].from != v) {\n\t\t\tcontinue;\n\t\t}\n\t\tw = tj->edges[i].to;\n\t\t\n\t\tif (w->index == -1) {\n\t\t\tint r = strongconnect(w, tj);\n\t\t\tif (r != 0)\n\t\t\t\treturn r;\n\t\t\tv->lowlink = min(v->lowlink, w->lowlink);\n\t\t\n\t\t} else if (w->onStack) {\n\t\t\tv->lowlink = min(v->lowlink, w->index);\n\t\t}\n\t}\n\n\t\n\tif (v->lowlink == v->index) {\n\t\tstruct components *ng = malloc(sizeof(struct components));\n\t\tif (ng == NULL) {\n\t\t\treturn 2;\n\t\t}\n\t\tif (tj->tail == NULL) {\n\t\t\ttj->head = ng;\n\t\t} else {\n\t\t\ttj->tail->next = ng;\n\t\t}\n\t\ttj->tail = ng;\n\t\tng->next = NULL;\n\t\tng->nnodes = 0;\n\t\tdo {\n\t\t\ttj->sp--;\n\t\t\tw = tj->stack[tj->sp];\n\t\t\tw->onStack = false;\n\t\t\tng->nnodes++;\n\t\t} while (w != v);\n\t\tng->nodes = malloc(ng->nnodes*sizeof(void *));\n\t\tif (ng == NULL) {\n\t\t\treturn 2;\n\t\t}\n\t\tfor (int i = 0; innodes; i++) {\n\t\t\tng->nodes[i] = tj->stack[tj->sp+i]->data;\n\t\t}\n\t}\n\treturn 0;\n}\n\nstatic int ptrcmp(const void *l, const void *r)\n{\n\treturn (ptrdiff_t)((struct node *)l)->data\n\t\t- (ptrdiff_t)((struct node *)r)->data;\n}\n\n\nstruct components *tarjans(\n\t\tint nnodes, void *nodedata[],\n\t\tint nedges, struct edge *edgedata[],\n\t\tint *error)\n{\n\tstruct node nodes[nnodes];\n\tstruct edge edges[nedges];\n\tstruct node *stack[nnodes];\n\tstruct node *from, *to;\n\tstruct tjstate tj = {0, 0, nedges, edges, stack, NULL, .tail=NULL};\n\n\t\n\tfor (int i = 0; ifrom, nodes, nnodes,\n\t\t\tsizeof(struct node), nodecmp);\n\t\tif (from == NULL) {\n\t\t\t*error = 1;\n\t\t\treturn NULL;\n\t\t}\n\t\tto = bsearch(edgedata[i]->to, nodes, nnodes,\n\t\t\tsizeof(struct node), nodecmp);\n\t\tif (to == NULL) {\n\t\t\t*error = 1;\n\t\t\treturn NULL;\n\t\t}\n\t\tedges[i] = (struct edge){.from=from, .to=to};\n\t}\n\n\t\n\tfor (int i = 0; i < nnodes; i++) {\n\t\tif (nodes[i].index == -1) {\n\t\t\t*error = strongconnect(&nodes[i], &tj);\n\t\t\tif (*error != 0)\n\t\t\t\treturn NULL;\n\t\t}\n\t}\n\treturn tj.head;\n}\n","Rust":"use std::collections::{BTreeMap, BTreeSet};\n\n\n#[derive(Clone, Debug)]\npub struct Graph {\n neighbors: BTreeMap>,\n}\n\nimpl Graph {\n pub fn new(size: usize) -> Self {\n Self {\n neighbors: (0..size).fold(BTreeMap::new(), |mut acc, x| {\n acc.insert(x, BTreeSet::new());\n acc\n }),\n }\n }\n\n pub fn edges<'a>(&'a self, vertex: usize) -> impl Iterator + 'a {\n self.neighbors[&vertex].iter().cloned()\n }\n\n pub fn add_edge(&mut self, from: usize, to: usize) {\n assert!(to < self.len());\n self.neighbors.get_mut(&from).unwrap().insert(to);\n }\n\n pub fn add_edges(&mut self, from: usize, to: impl IntoIterator) {\n let limit = self.len();\n\n self.neighbors\n .get_mut(&from)\n .unwrap()\n .extend(to.into_iter().filter(|x| {\n assert!(*x < limit);\n true\n }));\n }\n\n pub fn is_empty(&self) -> bool {\n self.neighbors.is_empty()\n }\n\n pub fn len(&self) -> usize {\n self.neighbors.len()\n }\n}\n\n#[derive(Clone)]\nstruct VertexState {\n index: usize,\n low_link: usize,\n on_stack: bool,\n}\n\n\n\n\npub struct Tarjan<'a> {\n graph: &'a Graph,\n index: usize,\n stack: Vec,\n state: Vec,\n components: Vec>,\n}\n\nimpl<'a> Tarjan<'a> {\n \n \n \n const INVALID_INDEX: usize = usize::MAX;\n\n pub fn walk(graph: &'a Graph) -> Vec> {\n Self {\n graph,\n index: 0,\n stack: Vec::new(),\n state: vec![\n VertexState {\n index: Self::INVALID_INDEX,\n low_link: Self::INVALID_INDEX,\n on_stack: false\n };\n graph.len()\n ],\n components: Vec::new(),\n }\n .visit_all()\n }\n\n fn visit_all(mut self) -> Vec> {\n for vertex in 0..self.graph.len() {\n if self.state[vertex].index == Self::INVALID_INDEX {\n self.visit(vertex);\n }\n }\n\n self.components\n }\n\n fn visit(&mut self, v: usize) {\n let v_ref = &mut self.state[v];\n v_ref.index = self.index;\n v_ref.low_link = self.index;\n self.index += 1;\n self.stack.push(v);\n v_ref.on_stack = true;\n\n for w in self.graph.edges(v) {\n let w_ref = &self.state[w];\n if w_ref.index == Self::INVALID_INDEX {\n self.visit(w);\n let w_low_link = self.state[w].low_link;\n let v_ref = &mut self.state[v];\n v_ref.low_link = v_ref.low_link.min(w_low_link);\n } else if w_ref.on_stack {\n let w_index = self.state[w].index;\n let v_ref = &mut self.state[v];\n v_ref.low_link = v_ref.low_link.min(w_index);\n }\n }\n\n let v_ref = &self.state[v];\n if v_ref.low_link == v_ref.index {\n let mut component = BTreeSet::new();\n\n loop {\n let w = self.stack.pop().unwrap();\n self.state[w].on_stack = false;\n component.insert(w);\n if w == v {\n break;\n }\n }\n\n self.components.push(component);\n }\n }\n}\n\nfn main() {\n let graph = {\n let mut g = Graph::new(8);\n g.add_edge(0, 1);\n g.add_edge(2, 0);\n g.add_edges(5, vec![2, 6]);\n g.add_edge(6, 5);\n g.add_edge(1, 2);\n g.add_edges(3, vec![1, 2, 4]);\n g.add_edges(4, vec![5, 3]);\n g.add_edges(7, vec![4, 7, 6]);\n g\n };\n\n for component in Tarjan::walk(&graph) {\n println!(\"{:?}\", component);\n }\n}\n"} {"name":"Tau function","C":"#include \n\n\nunsigned int divisor_count(unsigned int n) {\n unsigned int total = 1;\n \n for (; (n & 1) == 0; n >>= 1) {\n ++total;\n }\n \n for (unsigned int p = 3; p * p <= n; p += 2) {\n unsigned int count = 1;\n for (; n % p == 0; n \/= p) {\n ++count;\n }\n total *= count;\n }\n \n if (n > 1) {\n total *= 2;\n }\n return total;\n}\n\nint main() {\n const unsigned int limit = 100;\n unsigned int n;\n\n printf(\"Count of divisors for the first %d positive integers:\\n\", limit);\n for (n = 1; n <= limit; ++n) {\n printf(\"%3d\", divisor_count(n));\n if (n % 20 == 0) {\n printf(\"\\n\");\n }\n }\n\n return 0;\n}\n","Rust":"\n\nfn factor_exponent(n: i32, i: i32) -> (i32, i32) {\n\tif n % i == 0 {\n\t\tlet (a, b) = factor_exponent(n \/ i, i);\n\t\t(a + 1, b)\n\t} else {\n\t\t(0, n)\n\t}\n}\n\nfn tau(n: i32) -> i32 {\n\tfor i in 2..(n+1) {\n\t\tif n % i == 0 {\n\t\t\tlet (count, next) = factor_exponent(n, i);\n\t\t\treturn (count + 1) * tau(next);\n\t\t}\n\t}\n\treturn 1;\n}\n\nfn main() {\n\tfor i in 1..101 {\n\t\tprint!(\"{} \", tau(i));\n\t}\n}\n"} {"name":"Tau number","C":"#include \n\nunsigned int divisor_count(unsigned int n) {\n unsigned int total = 1;\n unsigned int p;\n\n \n for (; (n & 1) == 0; n >>= 1) {\n ++total;\n }\n \n for (p = 3; p * p <= n; p += 2) {\n unsigned int count = 1;\n for (; n % p == 0; n \/= p) {\n ++count;\n }\n total *= count;\n }\n \n if (n > 1) {\n total *= 2;\n }\n return total;\n}\n\nint main() {\n const unsigned int limit = 100;\n unsigned int count = 0;\n unsigned int n;\n\n printf(\"The first %d tau numbers are:\\n\", limit);\n for (n = 1; count < limit; ++n) {\n if (n % divisor_count(n) == 0) {\n printf(\"%6d\", n);\n ++count;\n if (count % 10 == 0) {\n printf(\"\\n\");\n }\n }\n }\n\n return 0;\n}\n","Rust":"\nfn get_divisors(n: u32) -> Vec {\n let mut results = Vec::new();\n\n for i in 1..(n \/ 2 + 1) {\n if n % i == 0 {\n results.push(i);\n }\n }\n results.push(n);\n results\n}\n\nfn is_tau_number(i: u32) -> bool {\n 0 == i % get_divisors(i).len() as u32\n}\n\nfn main() {\n println!(\"\\nFirst 100 Tau numbers:\");\n let mut counter: u32 = 0;\n let mut i: u32 = 1;\n while counter < 100 {\n if is_tau_number(i) {\n print!(\"{:>4}\", i);\n counter += 1;\n print!(\"{}\", if counter % 20 == 0 { \"\\n\" } else { \",\" });\n }\n i += 1;\n }\n}\n"} {"name":"Taxicab numbers","C":"#include \n#include \n\ntypedef unsigned long long xint;\ntypedef unsigned uint;\ntypedef struct {\n\tuint x, y; \n\txint value;\n} sum_t;\n\nxint *cube;\nuint n_cubes;\n\nsum_t *pq;\nuint pq_len, pq_cap;\n\nvoid add_cube(void)\n{\n\tuint x = n_cubes++;\n\tcube = realloc(cube, sizeof(xint) * (n_cubes + 1));\n\tcube[n_cubes] = (xint) n_cubes*n_cubes*n_cubes;\n\tif (x < 2) return; \n\n\tif (++pq_len >= pq_cap) {\n\t\tif (!(pq_cap *= 2)) pq_cap = 2;\n\t\tpq = realloc(pq, sizeof(*pq) * pq_cap);\n\t}\n\n\tsum_t tmp = (sum_t) { x, 1, cube[x] + 1 };\n\t\n\tuint i, j;\n\tfor (i = pq_len; i >= 1 && pq[j = i>>1].value > tmp.value; i = j)\n\t\tpq[i] = pq[j];\n\n\tpq[i] = tmp;\n}\n\nvoid next_sum(void)\n{\nredo:\twhile (!pq_len || pq[1].value >= cube[n_cubes]) add_cube();\n\n\tsum_t tmp = pq[0] = pq[1];\t\n\tif (++tmp.y >= tmp.x) {\t\t\n\t\ttmp = pq[pq_len--];\n\t\tif (!pq_len) goto redo;\t\n\t} else\n\t\ttmp.value += cube[tmp.y] - cube[tmp.y-1];\n\n\tuint i, j;\n\t\n\tfor (i = 1; (j = i<<1) <= pq_len; pq[i] = pq[j], i = j) {\n\t\tif (j < pq_len && pq[j+1].value < pq[j].value) ++j;\n\t\tif (pq[j].value >= tmp.value) break;\n\t}\n\tpq[i] = tmp;\n}\n\nuint next_taxi(sum_t *hist)\n{\n\tdo next_sum(); while (pq[0].value != pq[1].value);\n\n\tuint len = 1;\n\thist[0] = pq[0];\n\tdo {\n\t\thist[len++] = pq[1]; \n\t\tnext_sum();\n\t} while (pq[0].value == pq[1].value);\n\n\treturn len;\n}\n\nint main(void)\n{\n\tuint i, l;\n\tsum_t x[10];\n\tfor (i = 1; i <= 2006; i++) {\n\t\tl = next_taxi(x);\n\t\tif (25 < i && i < 2000) continue;\n\t\tprintf(\"%4u:%10llu\", i, x[0].value);\n\t\twhile (l--) printf(\" = %4u^3 + %4u^3\", x[l].x, x[l].y);\n\t\tputchar('\\n');\n\t}\n\treturn 0;\n}\n","Rust":"use std::collections::HashMap;\nuse itertools::Itertools;\n\nfn cubes(n: u64) -> Vec {\n\tlet mut cube_vector = Vec::new();\n\tfor i in 1..=n {\n\t\tcube_vector.push(i.pow(3));\n\t}\n\tcube_vector\n}\n\nfn main() {\n\tlet c = cubes(1201);\n\tlet it = c.iter().combinations(2);\n\tlet mut m = HashMap::new();\n\tfor x in it {\n\t\tlet sum = x[0] + x[1];\n\t\tm.entry(sum).or_insert(Vec::new()).push(x)\n\t} \n\t\n\tlet mut result = Vec::new();\n\t\n\tfor (k,v) in m.iter() {\n\t\tif v.len() > 1 {\n\t\t\tresult.push((k,v));\n\t\t}\n\t}\n\t\n\tresult.sort();\n\tfor f in result {\n\t\tprintln!(\"{:?}\", f);\n\t}\n}\n"} {"name":"Teacup rim text","C":"#include \n#include \n#include \n#include \n\nint string_compare(gconstpointer p1, gconstpointer p2) {\n const char* const* s1 = p1;\n const char* const* s2 = p2;\n return strcmp(*s1, *s2);\n}\n\nGPtrArray* load_dictionary(const char* file, GError** error_ptr) {\n GError* error = NULL;\n GIOChannel* channel = g_io_channel_new_file(file, \"r\", &error);\n if (channel == NULL) {\n g_propagate_error(error_ptr, error);\n return NULL;\n }\n GPtrArray* dict = g_ptr_array_new_full(1024, g_free);\n GString* line = g_string_sized_new(64);\n gsize term_pos;\n while (g_io_channel_read_line_string(channel, line, &term_pos,\n &error) == G_IO_STATUS_NORMAL) {\n char* word = g_strdup(line->str);\n word[term_pos] = '\\0';\n g_ptr_array_add(dict, word);\n }\n g_string_free(line, TRUE);\n g_io_channel_unref(channel);\n if (error != NULL) {\n g_propagate_error(error_ptr, error);\n g_ptr_array_free(dict, TRUE);\n return NULL;\n }\n g_ptr_array_sort(dict, string_compare);\n return dict;\n}\n\nvoid rotate(char* str, size_t len) {\n char c = str[0];\n memmove(str, str + 1, len - 1);\n str[len - 1] = c;\n}\n\nchar* dictionary_search(const GPtrArray* dictionary, const char* word) {\n char** result = bsearch(&word, dictionary->pdata, dictionary->len,\n sizeof(char*), string_compare);\n return result != NULL ? *result : NULL;\n}\n\nvoid find_teacup_words(GPtrArray* dictionary) {\n GHashTable* found = g_hash_table_new(g_str_hash, g_str_equal);\n GPtrArray* teacup_words = g_ptr_array_new();\n GString* temp = g_string_sized_new(8);\n for (size_t i = 0, n = dictionary->len; i < n; ++i) {\n char* word = g_ptr_array_index(dictionary, i);\n size_t len = strlen(word);\n if (len < 3 || g_hash_table_contains(found, word))\n continue;\n g_ptr_array_set_size(teacup_words, 0);\n g_string_assign(temp, word);\n bool is_teacup_word = true;\n for (size_t i = 0; i < len - 1; ++i) {\n rotate(temp->str, len);\n char* w = dictionary_search(dictionary, temp->str);\n if (w == NULL) {\n is_teacup_word = false;\n break;\n }\n if (strcmp(word, w) != 0 && !g_ptr_array_find(teacup_words, w, NULL))\n g_ptr_array_add(teacup_words, w);\n }\n if (is_teacup_word && teacup_words->len > 0) {\n printf(\"%s\", word);\n g_hash_table_add(found, word);\n for (size_t i = 0; i < teacup_words->len; ++i) {\n char* teacup_word = g_ptr_array_index(teacup_words, i);\n printf(\" %s\", teacup_word);\n g_hash_table_add(found, teacup_word);\n }\n printf(\"\\n\");\n }\n }\n g_string_free(temp, TRUE);\n g_ptr_array_free(teacup_words, TRUE);\n g_hash_table_destroy(found);\n}\n\nint main(int argc, char** argv) {\n if (argc != 2) {\n fprintf(stderr, \"usage: %s dictionary\\n\", argv[0]);\n return EXIT_FAILURE;\n }\n GError* error = NULL;\n GPtrArray* dictionary = load_dictionary(argv[1], &error);\n if (dictionary == NULL) {\n if (error != NULL) {\n fprintf(stderr, \"Cannot load dictionary file '%s': %s\\n\",\n argv[1], error->message);\n g_error_free(error);\n }\n return EXIT_FAILURE;\n }\n find_teacup_words(dictionary);\n g_ptr_array_free(dictionary, TRUE);\n return EXIT_SUCCESS;\n}\n","Rust":"use std::collections::BTreeSet;\nuse std::collections::HashSet;\nuse std::fs::File;\nuse std::io::{self, BufRead};\nuse std::iter::FromIterator;\n\nfn load_dictionary(filename: &str) -> std::io::Result> {\n let file = File::open(filename)?;\n let mut dict = BTreeSet::new();\n for line in io::BufReader::new(file).lines() {\n let word = line?;\n dict.insert(word);\n }\n Ok(dict)\n}\n\nfn find_teacup_words(dict: &BTreeSet) {\n let mut teacup_words: Vec<&String> = Vec::new();\n let mut found: HashSet<&String> = HashSet::new();\n for word in dict {\n let len = word.len();\n if len < 3 || found.contains(word) {\n continue;\n }\n teacup_words.clear();\n let mut is_teacup_word = true;\n let mut chars: Vec = word.chars().collect();\n for _ in 1..len {\n chars.rotate_left(1);\n if let Some(w) = dict.get(&String::from_iter(&chars)) {\n if !w.eq(word) && !teacup_words.contains(&w) {\n teacup_words.push(w);\n }\n } else {\n is_teacup_word = false;\n break;\n }\n }\n if !is_teacup_word || teacup_words.is_empty() {\n continue;\n }\n print!(\"{}\", word);\n found.insert(word);\n for w in &teacup_words {\n found.insert(w);\n print!(\" {}\", w);\n }\n println!();\n }\n}\n\nfn main() {\n let args: Vec = std::env::args().collect();\n if args.len() != 2 {\n eprintln!(\"Usage: teacup dictionary\");\n std::process::exit(1);\n }\n let dict = load_dictionary(&args[1]);\n match dict {\n Ok(dict) => find_teacup_words(&dict),\n Err(error) => eprintln!(\"Cannot open file {}: {}\", &args[1], error),\n }\n}\n"} {"name":"Terminal control_Preserve screen","C":"#include \n#include \n\nint main()\n{\n\tint i;\n\tprintf(\"\\033[?1049h\\033[H\");\n\tprintf(\"Alternate screen buffer\\n\");\n\tfor (i = 5; i; i--) {\n\t\tprintf(\"\\rgoing back in %d...\", i);\n\t\tfflush(stdout);\n\t\tsleep(1);\n\t}\n\tprintf(\"\\033[?1049l\");\n\n\treturn 0;\n}\n","Rust":"use std::io::{stdout, Write};\nuse std::time::Duration;\n\nfn main() {\n let mut output = stdout();\n\n print!(\"\\x1b[?1049h\\x1b[H\");\n println!(\"Alternate screen buffer\");\n\n for i in (1..=5).rev() {\n print!(\"\\rgoing back in {}...\", i);\n output.flush().unwrap();\n std::thread::sleep(Duration::from_secs(1));\n }\n\n print!(\"\\x1b[?1049l\");\n}\n"} {"name":"Textonyms","C":"#include \n#include \n#include \n#include \n\nchar text_char(char c) {\n switch (c) {\n case 'a': case 'b': case 'c':\n return '2';\n case 'd': case 'e': case 'f':\n return '3';\n case 'g': case 'h': case 'i':\n return '4';\n case 'j': case 'k': case 'l':\n return '5';\n case 'm': case 'n': case 'o':\n return '6';\n case 'p': case 'q': case 'r': case 's':\n return '7';\n case 't': case 'u': case 'v':\n return '8';\n case 'w': case 'x': case 'y': case 'z':\n return '9';\n default:\n return 0;\n }\n}\n\nbool text_string(const GString* word, GString* text) {\n g_string_set_size(text, word->len);\n for (size_t i = 0; i < word->len; ++i) {\n char c = text_char(g_ascii_tolower(word->str[i]));\n if (c == 0)\n return false;\n text->str[i] = c;\n }\n return true;\n}\n\ntypedef struct textonym_tag {\n const char* text;\n size_t length;\n GPtrArray* words;\n} textonym_t;\n\nint compare_by_text_length(const void* p1, const void* p2) {\n const textonym_t* t1 = p1;\n const textonym_t* t2 = p2;\n if (t1->length > t2->length)\n return -1;\n if (t1->length < t2->length)\n return 1;\n return strcmp(t1->text, t2->text);\n}\n\nint compare_by_word_count(const void* p1, const void* p2) {\n const textonym_t* t1 = p1;\n const textonym_t* t2 = p2;\n if (t1->words->len > t2->words->len)\n return -1;\n if (t1->words->len < t2->words->len)\n return 1;\n return strcmp(t1->text, t2->text);\n}\n\nvoid print_words(GPtrArray* words) {\n for (guint i = 0, n = words->len; i < n; ++i) {\n if (i > 0)\n printf(\", \");\n printf(\"%s\", g_ptr_array_index(words, i));\n }\n printf(\"\\n\");\n}\n\nvoid print_top_words(GArray* textonyms, guint top) {\n for (guint i = 0; i < top; ++i) {\n const textonym_t* t = &g_array_index(textonyms, textonym_t, i);\n printf(\"%s = \", t->text);\n print_words(t->words);\n }\n}\n\nvoid free_strings(gpointer ptr) {\n g_ptr_array_free(ptr, TRUE);\n}\n\nbool find_textonyms(const char* filename, GError** error_ptr) {\n GError* error = NULL;\n GIOChannel* channel = g_io_channel_new_file(filename, \"r\", &error);\n if (channel == NULL) {\n g_propagate_error(error_ptr, error);\n return false;\n }\n GHashTable* ht = g_hash_table_new_full(g_str_hash, g_str_equal,\n g_free, free_strings);\n GString* word = g_string_sized_new(64);\n GString* text = g_string_sized_new(64);\n guint count = 0;\n gsize term_pos;\n while (g_io_channel_read_line_string(channel, word, &term_pos,\n &error) == G_IO_STATUS_NORMAL) {\n g_string_truncate(word, term_pos);\n if (!text_string(word, text))\n continue;\n GPtrArray* words = g_hash_table_lookup(ht, text->str);\n if (words == NULL) {\n words = g_ptr_array_new_full(1, g_free);\n g_hash_table_insert(ht, g_strdup(text->str), words);\n }\n g_ptr_array_add(words, g_strdup(word->str));\n ++count;\n }\n g_io_channel_unref(channel);\n g_string_free(word, TRUE);\n g_string_free(text, TRUE);\n if (error != NULL) {\n g_propagate_error(error_ptr, error);\n g_hash_table_destroy(ht);\n return false;\n }\n\n GArray* words = g_array_new(FALSE, FALSE, sizeof(textonym_t));\n GHashTableIter iter;\n gpointer key, value;\n g_hash_table_iter_init(&iter, ht);\n while (g_hash_table_iter_next(&iter, &key, &value)) {\n GPtrArray* v = value;\n if (v->len > 1) {\n textonym_t textonym;\n textonym.text = key;\n textonym.length = strlen(key);\n textonym.words = v;\n g_array_append_val(words, textonym);\n }\n }\n\n printf(\"There are %u words in '%s' which can be represented by the digit key mapping.\\n\",\n count, filename);\n guint size = g_hash_table_size(ht);\n printf(\"They require %u digit combinations to represent them.\\n\", size);\n guint textonyms = words->len;\n printf(\"%u digit combinations represent Textonyms.\\n\", textonyms);\n\n guint top = 5;\n if (textonyms < top)\n top = textonyms;\n\n printf(\"\\nTop %u by number of words:\\n\", top);\n g_array_sort(words, compare_by_word_count);\n print_top_words(words, top);\n \n printf(\"\\nTop %u by length:\\n\", top);\n g_array_sort(words, compare_by_text_length);\n print_top_words(words, top);\n\n g_array_free(words, TRUE);\n g_hash_table_destroy(ht);\n return true;\n}\n\nint main(int argc, char** argv) {\n if (argc != 2) {\n fprintf(stderr, \"usage: %s word-list\\n\", argv[0]);\n return EXIT_FAILURE;\n }\n GError* error = NULL;\n if (!find_textonyms(argv[1], &error)) {\n if (error != NULL) {\n fprintf(stderr, \"%s: %s\\n\", argv[1], error->message);\n g_error_free(error);\n }\n return EXIT_FAILURE;\n }\n return EXIT_SUCCESS;\n}\n","Rust":"use std::collections::HashMap;\nuse std::fs::File;\nuse std::io::{self, BufRead};\n\nfn text_char(ch: char) -> Option {\n match ch {\n 'a' | 'b' | 'c' => Some('2'),\n 'd' | 'e' | 'f' => Some('3'),\n 'g' | 'h' | 'i' => Some('4'),\n 'j' | 'k' | 'l' => Some('5'),\n 'm' | 'n' | 'o' => Some('6'),\n 'p' | 'q' | 'r' | 's' => Some('7'),\n 't' | 'u' | 'v' => Some('8'),\n 'w' | 'x' | 'y' | 'z' => Some('9'),\n _ => None,\n }\n}\n\nfn text_string(s: &str) -> Option {\n let mut text = String::with_capacity(s.len());\n for c in s.chars() {\n if let Some(t) = text_char(c) {\n text.push(t);\n } else {\n return None;\n }\n }\n Some(text)\n}\n\nfn print_top_words(textonyms: &Vec<(&String, &Vec)>, top: usize) {\n for (text, words) in textonyms.iter().take(top) {\n println!(\"{} = {}\", text, words.join(\", \"));\n }\n}\n\nfn find_textonyms(filename: &str) -> std::io::Result<()> {\n let file = File::open(filename)?;\n let mut table = HashMap::new();\n let mut count = 0;\n\n for line in io::BufReader::new(file).lines() {\n let mut word = line?;\n word.make_ascii_lowercase();\n if let Some(text) = text_string(&word) {\n let words = table.entry(text).or_insert(Vec::new());\n words.push(word);\n count += 1;\n }\n }\n\n let mut textonyms: Vec<(&String, &Vec)> =\n table.iter().filter(|x| x.1.len() > 1).collect();\n\n println!(\n \"There are {} words in '{}' which can be represented by the digit key mapping.\",\n count, filename\n );\n println!(\n \"They require {} digit combinations to represent them.\",\n table.len()\n );\n println!(\n \"{} digit combinations represent Textonyms.\",\n textonyms.len()\n );\n\n let top = std::cmp::min(5, textonyms.len());\n textonyms.sort_by_key(|x| (std::cmp::Reverse(x.1.len()), x.0));\n println!(\"\\nTop {} by number of words:\", top);\n print_top_words(&textonyms, top);\n\n textonyms.sort_by_key(|x| (std::cmp::Reverse(x.0.len()), x.0));\n println!(\"\\nTop {} by length:\", top);\n print_top_words(&textonyms, top);\n\n Ok(())\n}\n\nfn main() {\n let args: Vec = std::env::args().collect();\n if args.len() != 2 {\n eprintln!(\"usage: {} word-list\", args[0]);\n std::process::exit(1);\n }\n match find_textonyms(&args[1]) {\n Ok(()) => {}\n Err(error) => eprintln!(\"{}: {}\", args[1], error),\n }\n}\n"} {"name":"The ISAAC cipher","C":"\n#include \n#include \n#include \n#ifdef _MSC_VER\n typedef unsigned __int32 uint32_t;\n#else\n #include \n#endif\n\n\ntypedef uint32_t ub4;\n\n\nub4 randrsl[256], randcnt;\n\n\nstatic ub4 mm[256];\nstatic ub4 aa=0, bb=0, cc=0;\n\nvoid isaac()\n{\n register ub4 i,x,y;\n\n cc = cc + 1; \n bb = bb + cc; \n\n for (i=0; i<256; ++i)\n {\n x = mm[i];\n switch (i%4)\n {\n case 0: aa = aa^(aa<<13); break;\n case 1: aa = aa^(aa>>6); break;\n case 2: aa = aa^(aa<<2); break;\n case 3: aa = aa^(aa>>16); break;\n }\n aa = mm[(i+128)%256] + aa;\n mm[i] = y = mm[(x>>2)%256] + aa + bb;\n randrsl[i] = bb = mm[(y>>10)%256] + x;\n }\n \n randcnt = 0;\n}\n\n\n#define mix(a,b,c,d,e,f,g,h) \\\n{ \\\n a^=b<<11; d+=a; b+=c; \\\n b^=c>>2; e+=b; c+=d; \\\n c^=d<<8; f+=c; d+=e; \\\n d^=e>>16; g+=d; e+=f; \\\n e^=f<<10; h+=e; f+=g; \\\n f^=g>>4; a+=f; g+=h; \\\n g^=h<<8; b+=g; h+=a; \\\n h^=a>>9; c+=h; a+=b; \\\n}\n\nvoid randinit(int flag)\n{\n register int i;\n ub4 a,b,c,d,e,f,g,h;\n aa=bb=cc=0;\n a=b=c=d=e=f=g=h=0x9e3779b9; \n\n for (i=0; i<4; ++i) \n {\n mix(a,b,c,d,e,f,g,h);\n }\n\n for (i=0; i<256; i+=8) \n {\n if (flag) \n\t {\n a+=randrsl[i ]; b+=randrsl[i+1]; c+=randrsl[i+2]; d+=randrsl[i+3];\n e+=randrsl[i+4]; f+=randrsl[i+5]; g+=randrsl[i+6]; h+=randrsl[i+7];\n }\n mix(a,b,c,d,e,f,g,h);\n mm[i ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;\n mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;\n }\n\n if (flag)\n { \n\t for (i=0; i<256; i+=8)\n {\n a+=mm[i ]; b+=mm[i+1]; c+=mm[i+2]; d+=mm[i+3];\n e+=mm[i+4]; f+=mm[i+5]; g+=mm[i+6]; h+=mm[i+7];\n mix(a,b,c,d,e,f,g,h);\n mm[i ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;\n mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;\n }\n }\n\n isaac(); \n randcnt=0; \n}\n\n\n\nub4 iRandom()\n{\n\tub4 r = randrsl[randcnt];\n\t++randcnt;\n\tif (randcnt >255) {\n\t\tisaac();\n\t\trandcnt = 0;\n\t}\n\treturn r;\n}\n\n\n\nchar iRandA()\n{\t\n\treturn iRandom() % 95 + 32;\n}\n\n\n\nvoid iSeed(char *seed, int flag)\n{\n\tregister ub4 i,m;\n\tfor (i=0; i<256; i++) mm[i]=0;\n\tm = strlen(seed);\n\tfor (i=0; i<256; i++)\n\t{\n\t\n if (i>m) randrsl[i]=0; else randrsl[i] = seed[i];\n\t}\n\t\n\trandinit(flag);\n}\n\n\n\n#define MAXMSG 4096\n#define MOD 95\n#define START 32\n\nenum ciphermode {\n\tmEncipher, mDecipher, mNone \n};\n\n\n\nchar v[MAXMSG];\nchar* Vernam(char *msg)\n\t{\n\t\tregister ub4 i,l;\n\t\tl = strlen(msg);\n\t\t\n\t\tmemset(v,'\\0',l+1);\n\t\t\n\t\tfor (i=0; i (\n {\n $a[0] ^= $a[1] << 11; $a[3] += $a[0]; $a[1] += $a[2];\n $a[1] ^= $a[2] >> 2; $a[4] += $a[1]; $a[2] += $a[3];\n $a[2] ^= $a[3] << 8; $a[5] += $a[2]; $a[3] += $a[4];\n $a[3] ^= $a[4] >> 16; $a[6] += $a[3]; $a[4] += $a[5];\n $a[4] ^= $a[5] << 10; $a[7] += $a[4]; $a[5] += $a[6];\n $a[5] ^= $a[6] >> 4; $a[0] += $a[5]; $a[6] += $a[7];\n $a[6] ^= $a[7] << 8; $a[1] += $a[6]; $a[7] += $a[0];\n $a[7] ^= $a[0] >> 9; $a[2] += $a[7]; $a[0] += $a[1];\n } );\n);\n\nstruct Isaac {\n mm: [w; 256],\n aa: w,\n bb: w,\n cc: w,\n rand_rsl: [w; 256],\n rand_cnt: u32,\n}\n\nimpl Isaac {\n fn new() -> Isaac {\n Isaac {\n mm: [w(0u32); 256],\n aa: w(0),\n bb: w(0),\n cc: w(0),\n rand_rsl: [w(0u32); 256],\n rand_cnt: 0,\n }\n }\n\n fn isaac(&mut self) {\n self.cc += w(1);\n self.bb += self.cc;\n\n for i in 0..256 {\n let w(x) = self.mm[i];\n match i % 4 {\n 0 => self.aa ^= self.aa << 13,\n 1 => self.aa ^= self.aa >> 6,\n 2 => self.aa ^= self.aa << 2,\n 3 => self.aa ^= self.aa >> 16,\n _ => unreachable!(),\n }\n\n self.aa += self.mm[((i + 128) % 256) as usize];\n let w(y) = self.mm[((x >> 2) % 256) as usize] + self.aa + self.bb;\n self.bb = self.mm[((y >> 10) % 256) as usize] + w(x);\n self.rand_rsl[i] = self.bb;\n }\n\n self.rand_cnt = 0;\n }\n\n fn rand_init(&mut self, flag: bool) {\n let mut a_v = [w(0x9e37_79b9u32); 8];\n\n for _ in 0..4 {\n \n mix_v!(a_v);\n }\n\n for i in (0..256).step_by(8) {\n \n if flag {\n \n for (j, value) in a_v.iter_mut().enumerate().take(8) {\n *value += self.rand_rsl[i + j];\n }\n }\n mix_v!(a_v);\n for (j, value) in a_v.iter().enumerate().take(8) {\n self.mm[i + j] = *value;\n }\n }\n\n if flag {\n \n for i in (0..256).step_by(8) {\n for (j, value) in a_v.iter_mut().enumerate().take(8) {\n *value += self.mm[i + j];\n }\n mix_v!(a_v);\n for (j, value) in a_v.iter().enumerate().take(8) {\n self.mm[i + j] = *value;\n }\n }\n }\n\n self.isaac(); \n self.rand_cnt = 0; \n }\n\n \n fn i_random(&mut self) -> u32 {\n let r = self.rand_rsl[self.rand_cnt as usize];\n self.rand_cnt += 1;\n if self.rand_cnt > 255 {\n self.isaac();\n self.rand_cnt = 0;\n }\n r.0\n }\n\n \n fn seed(&mut self, seed: &str, flag: bool) {\n for i in 0..256 {\n self.mm[i] = w(0);\n }\n for i in 0..256 {\n self.rand_rsl[i] = w(0);\n }\n\n for i in 0..seed.len() {\n self.rand_rsl[i] = w(u32::from(seed.as_bytes()[i]));\n }\n \n self.rand_init(flag);\n }\n\n \n fn i_rand_ascii(&mut self) -> u8 {\n (self.i_random() % 95 + 32) as u8\n }\n\n \n fn vernam(&mut self, msg: &[u8]) -> Vec {\n msg.iter()\n .map(|&b| (self.i_rand_ascii() ^ b))\n .collect::>()\n }\n}\n\nimpl Default for Isaac {\n fn default() -> Self {\n Isaac::new()\n }\n}\n"} {"name":"Topswops","C":"#include \n#include \n\ntypedef struct { char v[16]; } deck;\ntypedef unsigned int uint;\n\nuint n, d, best[16];\n\nvoid tryswaps(deck *a, uint f, uint s) {\n#\tdefine A a->v\n#\tdefine B b.v\n\tif (d > best[n]) best[n] = d;\n\twhile (1) {\n\t\tif ((A[s] == s || (A[s] == -1 && !(f & 1U << s)))\n\t\t\t&& (d + best[s] >= best[n] || A[s] == -1))\n\t\t\tbreak;\n\n\t\tif (d + best[s] <= best[n]) return;\n\t\tif (!--s) return;\n\t}\n\n\td++;\n\tdeck b = *a;\n\tfor (uint i = 1, k = 2; i <= s; k <<= 1, i++) {\n\t\tif (A[i] != i && (A[i] != -1 || (f & k)))\n\t\t\tcontinue;\n\n\t\tfor (uint j = B[0] = i; j--;) B[i - j] = A[j];\n\t\ttryswaps(&b, f | k, s);\n\t}\n\td--;\n}\n\nint main(void) {\n\tdeck x;\n\tmemset(&x, -1, sizeof(x));\n\tx.v[0] = 0;\n\n\tfor (n = 1; n < 13; n++) {\n\t\ttryswaps(&x, 1, n - 1);\n\t\tprintf(\"%2d: %d\\n\", n, best[n]);\n\t}\n\n\treturn 0;\n}\n","Rust":"use itertools::Itertools;\n\nfn solve(deck: &[usize]) -> usize {\n let mut counter = 0_usize;\n let mut shuffle = deck.to_vec();\n loop {\n let p0 = shuffle[0];\n if p0 == 1 {\n break;\n }\n shuffle[..p0].reverse();\n counter += 1;\n }\n\n counter\n}\n\n\nfn topswops(number: usize) -> usize {\n (1..=number)\n .permutations(number)\n .fold(0_usize, |mut acc, p| {\n let steps = solve(&p);\n if steps > acc {\n acc = steps;\n }\n acc\n })\n}\nfn main() {\n (1_usize..=10).for_each(|x| println!(\"{}: {}\", x, topswops(x)));\n}\n"} {"name":"Trabb Pardo\u2013Knuth algorithm","C":"#include\n#include\n\nint\nmain ()\n{\n double inputs[11], check = 400, result;\n int i;\n\n printf (\"\\nPlease enter 11 numbers\u00a0:\");\n\n for (i = 0; i < 11; i++)\n {\n scanf (\"%lf\", &inputs[i]);\n }\n\n printf (\"\\n\\n\\nEvaluating f(x) = |x|^0.5 + 5x^3 for the given inputs\u00a0:\");\n\n for (i = 10; i >= 0; i--)\n {\n result = sqrt (fabs (inputs[i])) + 5 * pow (inputs[i], 3);\n\n printf (\"\\nf(%lf) = \");\n\n if (result > check)\n {\n printf (\"Overflow!\");\n }\n\n else\n {\n printf (\"%lf\", result);\n }\n }\n\n return 0;\n}\n","Rust":"use std::io::{self, BufRead};\n\nfn op(x: f32) -> Option {\n let y = x.abs().sqrt() + 5.0 * x * x * x;\n if y < 400.0 {\n Some(y)\n } else {\n None\n }\n}\n\nfn main() {\n println!(\"Please enter 11 numbers (one number per line)\");\n let stdin = io::stdin();\n\n let xs = stdin\n .lock()\n .lines()\n .map(|ox| ox.unwrap().trim().to_string())\n .flat_map(|s| str::parse::(&s))\n .take(11)\n .collect::>();\n\n for x in xs.into_iter().rev() {\n match op(x) {\n Some(y) => println!(\"{}\", y),\n None => println!(\"overflow\"),\n };\n }\n}\n"} {"name":"Truncate a file","C":"#include \n#include \n#include \n\n\nvoid\noops(const wchar_t *message)\n{\n\twchar_t *buf;\n\tDWORD error;\n\n\tbuf = NULL;\n\terror = GetLastError();\n\tFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |\n\t FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,\n\t NULL, error, 0, (wchar_t *)&buf, 0, NULL);\n\n\tif (buf) {\n\t\tfwprintf(stderr, L\"%ls: %ls\", message, buf);\n\t\tLocalFree(buf);\n\t} else {\n\t\t\n\t\tfwprintf(stderr, L\"%ls: unknown error 0x%x\\n\",\n\t\t message, error);\n\t}\n}\n\nint\ndotruncate(wchar_t *fn, LARGE_INTEGER fp)\n{\n\tHANDLE fh;\n\n\tfh = CreateFileW(fn, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);\n\tif (fh == INVALID_HANDLE_VALUE) {\n\t\toops(fn);\n\t\treturn 1;\n\t}\n\n\tif (SetFilePointerEx(fh, fp, NULL, FILE_BEGIN) == 0 ||\n\t SetEndOfFile(fh) == 0) {\n\t\toops(fn);\n\t\tCloseHandle(fh);\n\t\treturn 1;\n\t}\n\n\tCloseHandle(fh);\n\treturn 0;\n}\n\n\nint\nmain()\n{\n\tLARGE_INTEGER fp;\n\tint argc;\n\twchar_t **argv, *fn, junk[2];\n\n\t\n\targv = CommandLineToArgvW(GetCommandLineW(), &argc);\n\tif (argv == NULL) {\n\t\toops(L\"CommandLineToArgvW\");\n\t\treturn 1;\n\t}\n\n\tif (argc != 3) {\n\t\tfwprintf(stderr, L\"usage: %ls filename length\\n\", argv[0]);\n\t\treturn 1;\n\t}\n\n\tfn = argv[1];\n\n\t\n\tif (swscanf(argv[2], L\"%lld%1ls\", &fp.QuadPart, &junk) != 1) {\n\t\tfwprintf(stderr, L\"%ls: not a number\\n\", argv[2]);\n\t\treturn 1;\n\t}\n\n\treturn dotruncate(fn, fp);\n}\n","Rust":"use std::path::Path;\nuse std::fs;\n\nfn truncate_file>(filename: P, filesize: usize) -> Result<(), Error> {\n use Error::*;\n let file = fs::read(&filename).or(Err(NotFound))?;\n\n if filesize > file.len() {\n return Err(FilesizeTooSmall)\n }\n\n fs::write(&filename, &file[..filesize]).or(Err(UnableToWrite))?;\n Ok(())\n}\n\n#[derive(Debug)]\nenum Error {\n \n NotFound,\n \n FilesizeTooSmall,\n \n UnableToWrite,\n}\n"} {"name":"Truth table","C":"#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n#define STACK_SIZE 80\n#define BUFFER_SIZE 100\n\ntypedef int bool;\n\ntypedef struct {\n char name;\n bool val;\n} var;\n\ntypedef struct {\n int top;\n bool els[STACK_SIZE];\n} stack_of_bool;\n\nchar expr[BUFFER_SIZE];\nint expr_len;\nvar vars[24];\nint vars_len;\n\n\n\nbool is_full(stack_of_bool *sp) {\n return sp->top == STACK_SIZE - 1;\n}\n\nbool is_empty(stack_of_bool *sp) {\n return sp->top == -1;\n}\n\nbool peek(stack_of_bool *sp) {\n if (!is_empty(sp))\n return sp->els[sp->top];\n else {\n printf(\"Stack is empty.\\n\");\n exit(1);\n }\n}\n\nvoid push(stack_of_bool *sp, bool val) {\n if (!is_full(sp)) {\n sp->els[++(sp->top)] = val;\n }\n else {\n printf(\"Stack is full.\\n\");\n exit(1);\n }\n}\n\nbool pop(stack_of_bool *sp) {\n if (!is_empty(sp))\n return sp->els[(sp->top)--];\n else {\n printf(\"\\nStack is empty.\\n\");\n exit(1);\n }\n}\n\nvoid make_empty(stack_of_bool *sp) {\n sp->top = -1; \n}\n\nint elems_count(stack_of_bool *sp) {\n return (sp->top) + 1; \n}\n\nbool is_operator(const char c) {\n return c == '&' || c == '|' || c == '!' || c == '^';\n}\n\nint vars_index(const char c) {\n int i;\n for (i = 0; i < vars_len; ++i) {\n if (vars[i].name == c) return i;\n }\n return -1;\n}\n\nbool eval_expr() {\n int i, vi;\n char e;\n stack_of_bool s;\n stack_of_bool *sp = &s;\n make_empty(sp);\n for (i = 0; i < expr_len; ++i) {\n e = expr[i];\n if (e == 'T')\n push(sp, TRUE);\n else if (e == 'F')\n push(sp, FALSE);\n else if((vi = vars_index(e)) >= 0) {\n push(sp, vars[vi].val);\n }\n else switch(e) {\n case '&':\n push(sp, pop(sp) & pop(sp));\n break;\n case '|':\n push(sp, pop(sp) | pop(sp));\n break;\n case '!':\n push(sp, !pop(sp));\n break;\n case '^':\n push(sp, pop(sp) ^ pop(sp));\n break;\n default:\n printf(\"\\nNon-conformant character '%c' in expression.\\n\", e);\n exit(1);\n }\n }\n if (elems_count(sp) != 1) {\n printf(\"\\nStack should contain exactly one element.\\n\");\n exit(1);\n }\n return peek(sp);\n}\n\nvoid set_vars(int pos) {\n int i;\n if (pos > vars_len) {\n printf(\"\\nArgument to set_vars can't be greater than the number of variables.\\n\");\n exit(1);\n }\n else if (pos == vars_len) {\n for (i = 0; i < vars_len; ++i) {\n printf((vars[i].val) ? \"T \" : \"F \");\n }\n printf(\"%c\\n\", (eval_expr()) ? 'T' : 'F');\n }\n else {\n vars[pos].val = FALSE;\n set_vars(pos + 1);\n vars[pos].val = TRUE;\n set_vars(pos + 1);\n }\n}\n\n\nvoid process_expr() {\n int i, count = 0;\n for (i = 0; expr[i]; ++i) {\n if (!isspace(expr[i])) expr[count++] = toupper(expr[i]);\n }\n expr[count] = '\\0';\n}\n\nint main() {\n int i, h;\n char e;\n printf(\"Accepts single-character variables (except for 'T' and 'F',\\n\");\n printf(\"which specify explicit true or false values), postfix, with\\n\");\n printf(\"&|!^ for and, or, not, xor, respectively; optionally\\n\");\n printf(\"seperated by whitespace. Just enter nothing to quit.\\n\");\n\n while (TRUE) {\n printf(\"\\nBoolean expression: \");\n fgets(expr, BUFFER_SIZE, stdin);\n fflush(stdin); \n process_expr();\n expr_len = strlen(expr); \n if (expr_len == 0) break;\n vars_len = 0;\n for (i = 0; i < expr_len; ++i) {\n e = expr[i];\n if (!is_operator(e) && e != 'T' && e != 'F' && vars_index(e) == -1) {\n vars[vars_len].name = e;\n vars[vars_len].val = FALSE;\n vars_len++;\n }\n }\n printf(\"\\n\");\n if (vars_len == 0) {\n printf(\"No variables were entered.\\n\");\n } \n else {\n for (i = 0; i < vars_len; ++i)\n printf(\"%c \", vars[i].name);\n printf(\"%s\\n\", expr);\n h = vars_len * 3 + expr_len;\n for (i = 0; i < h; ++i) printf(\"=\");\n printf(\"\\n\");\n set_vars(0);\n }\n }\n return 0;\n}\n","Rust":"use std::{\n collections::HashMap,\n fmt::{Display, Formatter},\n iter::FromIterator,\n};\n\n\n\n#[derive(Clone, Debug)]\npub enum EvaluationError {\n NoResults,\n TooManyResults,\n OperatorFailed(T),\n}\n\npub trait Operator {\n type Err;\n\n fn execute(&self, stack: &mut Vec) -> Result<(), Self::Err>;\n}\n\n#[derive(Clone, Copy, Debug)]\nenum Element {\n Operator(O),\n Variable(usize),\n}\n\n#[derive(Clone, Debug)]\npub struct Expression {\n elements: Vec>,\n symbols: Vec,\n}\n\nimpl Expression {\n pub fn evaluate(\n &self,\n mut bindings: impl FnMut(usize) -> T,\n ) -> Result>\n where\n O: Operator,\n {\n let mut stack = Vec::new();\n\n for element in self.elements.iter() {\n match element {\n Element::Variable(index) => stack.push(bindings(*index)),\n Element::Operator(op) => op\n .execute(&mut stack)\n .map_err(EvaluationError::OperatorFailed)?,\n }\n }\n\n match stack.pop() {\n Some(result) if stack.is_empty() => Ok(result),\n Some(_) => Err(EvaluationError::TooManyResults),\n None => Err(EvaluationError::NoResults),\n }\n }\n\n pub fn symbols(&self) -> &[String] {\n &self.symbols\n }\n\n pub fn formatted(&self) -> Result>\n where\n O: Operator,\n {\n self.evaluate(|index| Formatted(self.symbols[index].clone()))\n .map(|formatted| formatted.0)\n }\n}\n\n#[derive(Clone, Debug)]\npub struct Formatted(pub String);\n\nimpl Display for Formatted {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nimpl Display for Expression\nwhere\n O: Operator,\n{\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n match self.formatted() {\n Ok(result) => write!(f, \"{}\", result),\n Err(_) => write!(f, \"\"),\n }\n }\n}\n\n\n\n#[derive(Clone, Copy, Debug)]\npub enum Token<'a, O> {\n LBrace,\n RBrace,\n Operator(O),\n Variable(&'a str),\n Malformed(&'a str),\n}\n\npub type Symbol<'a, O> = (&'a str, bool, Token<'a, O>);\n\n#[derive(Debug)]\npub struct Tokens<'a, O> {\n source: &'a str,\n symbols: &'a [Symbol<'a, O>],\n}\n\nimpl<'a, O> Tokens<'a, O> {\n pub fn new(source: &'a str, symbols: &'a [Symbol<'a, O>]) -> Self {\n Self { source, symbols }\n }\n}\n\nimpl<'a, O: Clone> Iterator for Tokens<'a, O> {\n type Item = Token<'a, O>;\n\n fn next(&mut self) -> Option {\n self.source = self.source.trim_start();\n\n let symbol = self.symbols.iter().find_map(|(symbol, word, token)| {\n if self.source.starts_with(symbol) {\n let end = symbol.len();\n\n if *word {\n match &self.source[end..].chars().next() {\n Some(c) if !c.is_whitespace() => return None,\n _ => (),\n }\n }\n\n Some((token, end))\n } else {\n None\n }\n });\n\n if let Some((token, end)) = symbol {\n self.source = &self.source[end..];\n Some(token.clone())\n } else {\n match self.source.chars().next() {\n Some(c) if c.is_alphabetic() => {\n let end = self\n .source\n .char_indices()\n .find_map(|(i, c)| Some(i).filter(|_| !c.is_alphanumeric()))\n .unwrap_or_else(|| self.source.len());\n\n let result = &self.source[0..end];\n self.source = &self.source[end..];\n Some(Token::Variable(result))\n }\n\n Some(c) => {\n let end = c.len_utf8();\n let result = &self.source[0..end];\n self.source = &self.source[end..];\n Some(Token::Malformed(result))\n }\n\n None => None,\n }\n }\n }\n}\n\npub trait WithPriority {\n type Priority;\n\n fn priority(&self) -> Self::Priority;\n}\n\nimpl<'a, O> FromIterator> for Result, Token<'a, O>>\nwhere\n O: WithPriority,\n O::Priority: Ord,\n{\n fn from_iter>>(tokens: T) -> Self {\n let mut token_stack = Vec::new();\n let mut indices = HashMap::new();\n let mut symbols = Vec::new();\n let mut elements = Vec::new();\n\n 'outer: for token in tokens {\n match token {\n Token::Malformed(_) => return Err(token),\n Token::LBrace => token_stack.push(token),\n Token::RBrace => {\n \n while let Some(token) = token_stack.pop() {\n match token {\n Token::LBrace => continue 'outer,\n Token::Operator(op) => elements.push(Element::Operator(op)),\n _ => return Err(token),\n }\n }\n }\n\n Token::Variable(name) => {\n let index = indices.len();\n let symbol = name.to_string();\n let index = *indices.entry(symbol.clone()).or_insert_with(|| {\n symbols.push(symbol);\n index\n });\n\n elements.push(Element::Variable(index));\n }\n\n Token::Operator(ref op) => {\n while let Some(token) = token_stack.pop() {\n match token {\n Token::Operator(pop) if op.priority() < pop.priority() => {\n elements.push(Element::Operator(pop));\n }\n\n Token::Operator(pop) => {\n token_stack.push(Token::Operator(pop));\n break;\n }\n\n _ => {\n token_stack.push(token);\n break;\n }\n }\n }\n\n token_stack.push(token);\n }\n }\n }\n\n \n while let Some(token) = token_stack.pop() {\n match token {\n Token::Operator(op) => elements.push(Element::Operator(op)),\n _ => return Err(token),\n }\n }\n\n Ok(Expression { elements, symbols })\n }\n}\n\n\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub enum Boolean {\n Or,\n Xor,\n And,\n Not,\n}\n\nimpl Display for Boolean {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n let s = match self {\n Self::Or => \"\u2228\",\n Self::And => \"\u2227\",\n Self::Not => \"\u00ac\",\n Self::Xor => \"\u2a5b\",\n };\n\n write!(f, \"{}\", s)\n }\n}\n\nimpl WithPriority for Boolean {\n type Priority = u8;\n\n fn priority(&self) -> u8 {\n match self {\n Self::Or => 0,\n Self::Xor => 1,\n Self::And => 2,\n Self::Not => 3,\n }\n }\n}\n\n#[derive(Clone, Debug)]\npub enum BooleanError {\n StackUnderflow,\n}\n\nimpl Operator for Boolean {\n type Err = BooleanError;\n\n fn execute(&self, stack: &mut Vec) -> Result<(), Self::Err> {\n let mut pop = || stack.pop().ok_or(BooleanError::StackUnderflow);\n\n let result = match self {\n Boolean::Or => pop()? | pop()?,\n Boolean::And => pop()? & pop()?,\n Boolean::Xor => pop()? ^ pop()?,\n Boolean::Not => !pop()?,\n };\n\n stack.push(result);\n Ok(())\n }\n}\n\nimpl Operator for Boolean {\n type Err = BooleanError;\n\n fn execute(&self, stack: &mut Vec) -> Result<(), Self::Err> {\n let mut pop = || stack.pop().ok_or(BooleanError::StackUnderflow);\n\n let result = match self {\n Boolean::Not => format!(\"{}{}\", Boolean::Not, pop()?),\n\n binary_operator => {\n \n \n let b = pop()?;\n let a = pop()?;\n format!(\"({} {} {})\", a, binary_operator, b)\n }\n };\n\n stack.push(Formatted(result));\n Ok(())\n }\n}\n\nimpl Boolean {\n \n \n const SYMBOLS: [Symbol<'static, Boolean>; 18] = [\n (\"(\", false, Token::LBrace),\n (\")\", false, Token::RBrace),\n (\"|\", false, Token::Operator(Boolean::Or)),\n (\"\u2228\", false, Token::Operator(Boolean::Or)),\n (\"or\", true, Token::Operator(Boolean::Or)),\n (\"OR\", true, Token::Operator(Boolean::Or)),\n (\"&\", false, Token::Operator(Boolean::And)),\n (\"\u2227\", false, Token::Operator(Boolean::And)),\n (\"and\", true, Token::Operator(Boolean::And)),\n (\"AND\", true, Token::Operator(Boolean::And)),\n (\"!\", false, Token::Operator(Boolean::Not)),\n (\"\u00ac\", false, Token::Operator(Boolean::Not)),\n (\"not\", true, Token::Operator(Boolean::Not)),\n (\"NOT\", true, Token::Operator(Boolean::Not)),\n (\"^\", false, Token::Operator(Boolean::Xor)),\n (\"\u2a5b\", false, Token::Operator(Boolean::Xor)),\n (\"xor\", true, Token::Operator(Boolean::Xor)),\n (\"XOR\", true, Token::Operator(Boolean::Xor)),\n ];\n\n pub fn tokenize(s: &str) -> Tokens<'_, Boolean> {\n Tokens::new(s, &Self::SYMBOLS)\n }\n\n pub fn parse<'a>(s: &'a str) -> Result, Token<'a, Boolean>> {\n Self::tokenize(s).collect()\n }\n}\n\n\n\nfn print_truth_table(s: &str) -> Result<(), std::borrow::Cow<'_, str>> {\n let expression = Boolean::parse(s).map_err(|e| format!(\"Parsing failed at token {:?}\", e))?;\n\n let formatted = expression\n .formatted()\n .map_err(|_| \"Malformed expression detected.\")?;\n\n let var_count = expression.symbols().len();\n if var_count > 64 {\n return Err(\"Too many variables to list.\".into());\n }\n\n let column_widths = {\n \n let mut widths = Vec::with_capacity(var_count);\n\n for symbol in expression.symbols() {\n print!(\"{} \", symbol);\n widths.push(symbol.chars().count() + 2); \n }\n\n println!(\"{}\", formatted);\n let width = widths.iter().sum::() + formatted.chars().count();\n (0..width).for_each(|_| print!(\"-\"));\n println!();\n\n widths\n };\n\n \n let var_value = |input, index| (input >> (var_count - 1 - index)) & 1 ^ 1;\n \n for var_values in 0u64..(1 << var_count) {\n for (var_index, width) in column_widths.iter().enumerate() {\n let value = var_value(var_values, var_index);\n print!(\"{: println!(\"{}\", if result { \"1\" } else { \"0\" }),\n Err(e) => println!(\"{:?}\", e),\n }\n }\n\n println!();\n Ok(())\n}\n\nfn main() {\n loop {\n let input = {\n println!(\"Enter the expression to parse (or nothing to quit):\");\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).unwrap();\n println!();\n input\n };\n\n if input.trim().is_empty() {\n break;\n }\n\n if let Err(e) = print_truth_table(&input) {\n eprintln!(\"{}\\n\", e);\n }\n }\n}\n"} {"name":"Twin primes","C":"#include \n#include \n#include \n\nbool isPrime(int64_t n) {\n int64_t i;\n\n if (n < 2) return false;\n if (n % 2 == 0) return n == 2;\n if (n % 3 == 0) return n == 3;\n if (n % 5 == 0) return n == 5;\n if (n % 7 == 0) return n == 7;\n if (n % 11 == 0) return n == 11;\n if (n % 13 == 0) return n == 13;\n if (n % 17 == 0) return n == 17;\n if (n % 19 == 0) return n == 19;\n\n for (i = 23; i * i <= n; i += 2) {\n if (n % i == 0) return false;\n }\n\n return true;\n}\n\nint countTwinPrimes(int limit) {\n int count = 0;\n\n \n int64_t p3 = true, p2 = true, p1 = false;\n int64_t i;\n\n for (i = 5; i <= limit; i++) {\n p3 = p2;\n p2 = p1;\n p1 = isPrime(i);\n if (p3 && p1) {\n count++;\n }\n }\n return count;\n}\n\nvoid test(int limit) {\n int count = countTwinPrimes(limit);\n printf(\"Number of twin prime pairs less than %d is %d\\n\", limit, count);\n}\n\nint main() {\n test(10);\n test(100);\n test(1000);\n test(10000);\n test(100000);\n test(1000000);\n test(10000000);\n test(100000000);\n return 0;\n}\n","Rust":"\n\n\n\nuse num_format::{Locale, ToFormattedString};\n\nfn twin_prime_count_for_powers_of_ten(max_power: u32) {\n let mut count = 0;\n let mut previous = 0;\n let mut power = 1;\n let mut limit = 10;\n for prime in primal::Primes::all() {\n if prime > limit {\n println!(\n \"Number of twin prime pairs less than {} is {}\",\n limit.to_formatted_string(&Locale::en),\n count.to_formatted_string(&Locale::en)\n );\n limit *= 10;\n power += 1;\n if power > max_power {\n break;\n }\n }\n if previous > 0 && prime == previous + 2 {\n count += 1;\n }\n previous = prime;\n }\n}\n\nfn twin_prime_count(limit: usize) {\n let mut count = 0;\n let mut previous = 0;\n for prime in primal::Primes::all().take_while(|x| *x < limit) {\n if previous > 0 && prime == previous + 2 {\n count += 1;\n }\n previous = prime;\n }\n println!(\n \"Number of twin prime pairs less than {} is {}\",\n limit.to_formatted_string(&Locale::en),\n count.to_formatted_string(&Locale::en)\n );\n}\n\nfn main() {\n let args: Vec = std::env::args().collect();\n if args.len() > 1 {\n for i in 1..args.len() {\n if let Ok(limit) = args[i].parse::() {\n twin_prime_count(limit);\n } else {\n eprintln!(\"Cannot parse limit from string {}\", args[i]);\n }\n }\n } else {\n twin_prime_count_for_powers_of_ten(10);\n }\n}\n"} {"name":"Two sum","C":"#include\n\nint main()\n{\n\tint arr[5] = {0, 2, 11, 19, 90},sum = 21,i,j,check = 0;\n\t\n\tfor(i=0;i<4;i++){\n\t\tfor(j=i+1;j<5;j++){\n\t\t\tif(arr[i]+arr[j]==sum){\n\t\t\t\tprintf(\"[%d,%d]\",i,j);\n\t\t\t\tcheck = 1;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\t\n\tif(check==0)\n\t\tprintf(\"[]\");\n\t\n\treturn 0;\n}\n","Rust":"use std::cmp::Ordering;\nuse std::ops::Add;\n\nfn two_sum(arr: &[T], sum: T) -> Option<(usize, usize)>\nwhere\n T: Add + Ord + Copy,\n{\n if arr.len() == 0 {\n return None;\n }\n\n let mut i = 0;\n let mut j = arr.len() - 1;\n\n while i < j {\n match (arr[i] + arr[j]).cmp(&sum) {\n Ordering::Equal => return Some((i, j)),\n Ordering::Less => i += 1,\n Ordering::Greater => j -= 1,\n }\n }\n\n None\n}\n\nfn main() {\n let arr = [0, 2, 11, 19, 90];\n let sum = 21;\n\n println!(\"{:?}\", two_sum(&arr, sum));\n}\n"} {"name":"Type detection","C":"#include\n#include\n\nvoid typeDetector(char* str){\t\n\tif(isalnum(str[0])!=0)\n\t\tprintf(\"\\n%c is alphanumeric\",str[0]);\n\tif(isalpha(str[0])!=0)\n\t\tprintf(\"\\n%c is alphabetic\",str[0]);\n\tif(iscntrl(str[0])!=0)\n\t\tprintf(\"\\n%c is a control character\",str[0]);\n\tif(isdigit(str[0])!=0)\n\t\tprintf(\"\\n%c is a digit\",str[0]);\n\tif(isprint(str[0])!=0)\n\t\tprintf(\"\\n%c is printable\",str[0]);\n\tif(ispunct(str[0])!=0)\n\t\tprintf(\"\\n%c is a punctuation character\",str[0]);\n\tif(isxdigit(str[0])!=0)\n\t\tprintf(\"\\n%c is a hexadecimal digit\",str[0]);\n}\n\nint main(int argC, char* argV[])\n{\n\tint i;\n\t\n\tif(argC==1)\n\t\tprintf(\"Usage\u00a0: %s \");\n\telse{\n\t\tfor(i=1;i println!(\"Got an integer: {}\", x),\n UInt(x) => println!(\"Got an unsigned integer: {}\", x),\n Real(x) => println!(\"Got a floating-point number: {}\", x),\n Text(x) => println!(\"Got a string of text: {}\", x),\n Uncertain => println!(\"Value is uncertain\"),\n }\n }\n}\n"} {"name":"URL encoding","C":"#include \n#include \n \nchar rfc3986[256] = {0};\nchar html5[256] = {0};\n\n\nvoid encode(const char *s, char *enc, char *tb)\n{\n\tfor (; *s; s++) {\n\t\tif (tb[*s]) sprintf(enc, \"%c\", tb[*s]);\n\t\telse sprintf(enc, \"%%%02X\", *s);\n\t\twhile (*++enc);\n\t}\n}\n \nint main()\n{\n\tconst char url[] = \"http:\n\tchar enc[(strlen(url) * 3) + 1];\n \n\tint i;\n\tfor (i = 0; i < 256; i++) {\n\t\trfc3986[i] = isalnum(i)||i == '~'||i == '-'||i == '.'||i == '_'\n\t\t\t? i : 0;\n\t\thtml5[i] = isalnum(i)||i == '*'||i == '-'||i == '.'||i == '_'\n\t\t\t? i : (i == ' ') ? '+' : 0;\n\t}\n \n\tencode(url, enc, rfc3986);\n\tputs(enc);\n \n\treturn 0;\n}\n","Rust":"const INPUT: &str = \"http:\nconst MAX_CHAR_VAL: u32 = std::char::MAX as u32;\n \nfn main() {\n let mut buff = [0; 4];\n println!(\"{}\", INPUT.chars()\n .map(|ch| {\n match ch as u32 {\n 0 ..= 47 | 58 ..= 64 | 91 ..= 96 | 123 ..= MAX_CHAR_VAL => {\n ch.encode_utf8(&mut buff);\n buff[0..ch.len_utf8()].iter().map(|&byte| format!(\"%{:X}\", byte)).collect::()\n },\n _ => ch.to_string(),\n }\n })\n .collect::()\n );\n}\n"} {"name":"Ulam numbers","C":"#include \n#include \n#include \n#include \n\nvoid fatal(const char* message) {\n fprintf(stderr, \"%s\\n\", message);\n exit(1);\n}\n\nvoid* xmalloc(size_t n) {\n void* ptr = malloc(n);\n if (ptr == NULL)\n fatal(\"Out of memory\");\n return ptr;\n}\n\nvoid* xrealloc(void* p, size_t n) {\n void* ptr = realloc(p, n);\n if (ptr == NULL)\n fatal(\"Out of memory\");\n return ptr;\n}\n\nint* extend(int* array, int min_length, int* capacity) {\n int new_capacity = *capacity;\n if (new_capacity >= min_length)\n return array;\n while (new_capacity < min_length)\n new_capacity *= 2;\n array = xrealloc(array, new_capacity * sizeof(int));\n memset(array + *capacity, 0, (new_capacity - *capacity) * sizeof(int));\n *capacity = new_capacity;\n return array;\n}\n\nint ulam(int n) {\n int* ulams = xmalloc((n < 2 ? 2 : n) * sizeof(int));\n ulams[0] = 1;\n ulams[1] = 2;\n int sieve_length = 2;\n int sieve_capacity = 2;\n int* sieve = xmalloc(sieve_capacity * sizeof(int));\n sieve[0] = sieve[1] = 1;\n for (int u = 2, ulen = 2; ulen < n; ) {\n sieve_length = u + ulams[ulen - 2];\n sieve = extend(sieve, sieve_length, &sieve_capacity);\n for (int i = 0; i < ulen - 1; ++i)\n ++sieve[u + ulams[i] - 1];\n for (int i = u; i < sieve_length; ++i) {\n if (sieve[i] == 1) {\n u = i + 1;\n ulams[ulen++] = u;\n break;\n }\n }\n }\n int result = ulams[n - 1];\n free(ulams);\n free(sieve);\n return result;\n}\n\nint main() {\n clock_t start = clock();\n for (int n = 1; n <= 100000; n *= 10)\n printf(\"Ulam(%d) = %d\\n\", n, ulam(n));\n clock_t finish = clock();\n printf(\"Elapsed time:\u00a0%.3f seconds\\n\", (finish - start + 0.0)\/CLOCKS_PER_SEC);\n return 0;\n}\n","Rust":"fn ulam(n: usize) -> usize {\n let mut ulams = vec![1, 2];\n let mut sieve = vec![1, 1];\n let mut u = 2;\n while ulams.len() < n {\n sieve.resize(u + ulams[ulams.len() - 2], 0);\n for i in 0..ulams.len() - 1 {\n sieve[u + ulams[i] - 1] += 1;\n }\n for i in u..sieve.len() {\n if sieve[i] == 1 {\n u = i + 1;\n ulams.push(u);\n break;\n }\n }\n }\n ulams[n - 1]\n}\n\nfn main() {\n use std::time::Instant;\n let start = Instant::now();\n let mut n = 1;\n while n <= 100000 {\n println!(\"Ulam({}) = {}\", n, ulam(n));\n n *= 10;\n }\n println!(\"Elapsed time: {:.2?}\", start.elapsed());\n}\n"} {"name":"Unprimeable numbers","C":"#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct bit_array_tag {\n uint32_t size;\n uint32_t* array;\n} bit_array;\n\nbool bit_array_create(bit_array* b, uint32_t size) {\n uint32_t* array = calloc((size + 31)\/32, sizeof(uint32_t));\n if (array == NULL)\n return false;\n b->size = size;\n b->array = array;\n return true;\n}\n\nvoid bit_array_destroy(bit_array* b) {\n free(b->array);\n b->array = NULL;\n}\n\nvoid bit_array_set(bit_array* b, uint32_t index, bool value) {\n assert(index < b->size);\n uint32_t* p = &b->array[index >> 5];\n uint32_t bit = 1 << (index & 31);\n if (value)\n *p |= bit;\n else\n *p &= ~bit;\n}\n\nbool bit_array_get(const bit_array* b, uint32_t index) {\n assert(index < b->size);\n uint32_t* p = &b->array[index >> 5];\n uint32_t bit = 1 << (index & 31);\n return (*p & bit) != 0;\n}\n\ntypedef struct sieve_tag {\n uint32_t limit;\n bit_array not_prime;\n} sieve;\n\nbool sieve_create(sieve* s, uint32_t limit) {\n if (!bit_array_create(&s->not_prime, limit\/2))\n return false;\n for (uint32_t p = 3; p * p <= limit; p += 2) {\n if (bit_array_get(&s->not_prime, p\/2 - 1) == false) {\n uint32_t inc = 2 * p;\n for (uint32_t q = p * p; q <= limit; q += inc)\n bit_array_set(&s->not_prime, q\/2 - 1, true);\n }\n }\n s->limit = limit;\n return true;\n}\n\nvoid sieve_destroy(sieve* s) {\n bit_array_destroy(&s->not_prime);\n}\n\nbool is_prime(const sieve* s, uint32_t n) {\n assert(n <= s->limit);\n if (n == 2)\n return true;\n if (n < 2 || n % 2 == 0)\n return false;\n return bit_array_get(&s->not_prime, n\/2 - 1) == false;\n}\n\n\nuint32_t count_digits(uint32_t n) {\n uint32_t digits = 0;\n for (; n > 0; ++digits)\n n \/= 10;\n return digits;\n}\n\n\nuint32_t change_digit(uint32_t n, uint32_t index, uint32_t new_digit) {\n uint32_t p = 1;\n uint32_t changed = 0;\n for (; index > 0; p *= 10, n \/= 10, --index)\n changed += p * (n % 10);\n changed += (10 * (n\/10) + new_digit) * p;\n return changed;\n}\n\n\nbool unprimeable(const sieve* s, uint32_t n) {\n if (is_prime(s, n))\n return false;\n uint32_t d = count_digits(n);\n for (uint32_t i = 0; i < d; ++i) {\n for (uint32_t j = 0; j <= 9; ++j) {\n uint32_t m = change_digit(n, i, j);\n if (m != n && is_prime(s, m))\n return false;\n }\n }\n return true;\n}\n\nint main() {\n const uint32_t limit = 10000000;\n setlocale(LC_ALL, \"\");\n sieve s = { 0 };\n if (!sieve_create(&s, limit)) {\n fprintf(stderr, \"Out of memory\\n\");\n return 1;\n }\n printf(\"First 35 unprimeable numbers:\\n\");\n uint32_t n = 100;\n uint32_t lowest[10] = { 0 };\n for (uint32_t count = 0, found = 0; n < limit && (found < 10 || count < 600); ++n) {\n if (unprimeable(&s, n)) {\n if (count < 35) {\n if (count != 0)\n printf(\", \");\n printf(\"%'u\", n);\n }\n ++count;\n if (count == 600)\n printf(\"\\n600th unprimeable number:\u00a0%'u\\n\", n);\n uint32_t last_digit = n % 10;\n if (lowest[last_digit] == 0) {\n lowest[last_digit] = n;\n ++found;\n }\n }\n }\n sieve_destroy(&s);\n for (uint32_t i = 0; i < 10; ++i)\n printf(\"Least unprimeable number ending in %u:\u00a0%'u\\n\" , i, lowest[i]);\n return 0;\n}\n","Rust":"\nmod bit_array;\nmod prime_sieve;\n\nuse prime_sieve::PrimeSieve;\n\n\nfn count_digits(mut n: u32) -> u32 {\n let mut digits = 0;\n while n > 0 {\n n \/= 10;\n digits += 1;\n }\n digits\n}\n\n\nfn change_digit(mut n: u32, mut index: u32, new_digit: u32) -> u32 {\n let mut p = 1;\n let mut changed = 0;\n while index > 0 {\n changed += p * (n % 10);\n p *= 10;\n n \/= 10;\n index -= 1;\n }\n changed += (10 * (n \/ 10) + new_digit) * p;\n changed\n}\n\nfn unprimeable(sieve: &PrimeSieve, n: u32) -> bool {\n if sieve.is_prime(n as usize) {\n return false;\n }\n let d = count_digits(n);\n for i in 0..d {\n for j in 0..10 {\n let m = change_digit(n, i, j);\n if m != n && sieve.is_prime(m as usize) {\n return false;\n }\n }\n }\n true\n}\n\nfn main() {\n let mut count = 0;\n let mut n = 100;\n let mut lowest = vec![0; 10];\n let mut found = 0;\n let sieve = PrimeSieve::new(10000000);\n println!(\"First 35 unprimeable numbers:\");\n while count < 600 || found < 10 {\n if unprimeable(&sieve, n) {\n if count < 35 {\n if count > 0 {\n print!(\", \");\n }\n print!(\"{}\", n);\n }\n count += 1;\n if count == 600 {\n println!(\"\\n600th unprimeable number: {}\", n);\n }\n let last_digit = n as usize % 10;\n if lowest[last_digit] == 0 {\n lowest[last_digit] = n;\n found += 1;\n }\n }\n n += 1;\n }\n for i in 0..10 {\n println!(\"Least unprimeable number ending in {}: {}\", i, lowest[i]);\n }\n}\n"} {"name":"Vampire number","C":"#include \n#include \n#include \n#include \n\ntypedef uint64_t xint;\ntypedef unsigned long long ull;\n\nxint tens[20];\n\ninline xint max(xint a, xint b) { return a > b ? a : b; }\ninline xint min(xint a, xint b) { return a < b ? a : b; }\ninline int ndigits(xint x)\n{\n\tint n = 0;\n\twhile (x) n++, x \/= 10;\n\treturn n;\n}\n\ninline xint dtally(xint x)\n{\n\txint t = 0;\n\twhile (x) t += 1<<((x%10) * 6), x \/= 10;\n\n\treturn t;\n}\n\nint fangs(xint x, xint *f)\n{\n\tint n = 0;\n\tint nd = ndigits(x);\n\tif (nd & 1) return 0;\n\tnd \/= 2;\n\n\txint lo, hi;\n\tlo = max(tens[nd-1], (x + tens[nd] - 2)\/ (tens[nd] - 1));\n\thi = min(x \/ lo, sqrt(x));\n\n\txint a, b, t = dtally(x);\n\tfor (a = lo; a <= hi; a++) {\n\t\tb = x \/ a;\n\t\tif (a * b == x && ((a%10) || (b%10)) && t == dtally(a) + dtally(b))\n\t\t\tf[n++] = a;\n\t}\n\n\treturn n;\n}\n\nvoid show_fangs(xint x, xint *f, xint cnt)\n{\n\tprintf(\"%llu\", (ull)x);\n\tint i;\n\tfor (i = 0; i < cnt; i++)\n\t\tprintf(\" = %llu x %llu\", (ull)f[i], (ull)(x \/ f[i]));\n\tputchar('\\n');\n}\n\nint main(void)\n{\n\tint i, j, n;\n\txint x, f[16], bigs[] = {16758243290880ULL, 24959017348650ULL, 14593825548650ULL, 0};\n\n\ttens[0] = 1;\n\tfor (i = 1; i < 20; i++)\n\t\ttens[i] = tens[i-1] * 10;\n\n\tfor (x = 1, n = 0; n < 25; x++) {\n\t\tif (!(j = fangs(x, f))) continue;\n\t\tprintf(\"%2d: \", ++n);\n\t\tshow_fangs(x, f, j);\n\t}\n\n\tputchar('\\n');\n\tfor (i = 0; bigs[i]; i++) {\n\t\tif ((j = fangs(bigs[i], f)))\n\t\t\tshow_fangs(bigs[i], f, j);\n\t\telse\n\t\t\tprintf(\"%llu is not vampiric\\n\", (ull)bigs[i]);\n\t}\n\n\treturn 0;\n}\n","Rust":"use std::cmp::{max, min};\n\nstatic TENS: [u64; 20] = [\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000,\n 10000000000,\n 100000000000,\n 1000000000000,\n 10000000000000,\n 100000000000000,\n 1000000000000000,\n 10000000000000000,\n 100000000000000000,\n 1000000000000000000,\n 10000000000000000000,\n];\n\n\nfn ndigits(mut x: u64) -> u64 {\n let mut n = 0;\n\n while x != 0 {\n n += 1;\n x \/= 10;\n }\n\n n\n}\n\nfn dtally(mut x: u64) -> u64 {\n let mut t = 0;\n\n while x != 0 {\n t += 1 << ((x % 10) * 6);\n x \/= 10;\n }\n\n t\n}\n\n\nfn fangs(x: u64) -> Vec {\n let mut nd = ndigits(x) as usize;\n\n let mut fangs = vec![];\n\n if nd & 1 != 1 {\n nd \/= 2;\n\n let lo = max(TENS[nd - 1], (x + TENS[nd] - 2) \/ (TENS[nd] - 1));\n let hi = min(x \/ lo, (x as f64).sqrt() as u64);\n\n let t = dtally(x);\n\n for a in lo..(hi + 1) {\n let b = x \/ a;\n if a * b == x && ((a % 10) > 0 || b % 10 > 0) && t == dtally(a) + dtally(b) {\n fangs.push(a);\n }\n }\n }\n\n fangs\n}\n\n\nfn print_fangs(x: u64, fangs: Vec) {\n print!(\"{} = \", x);\n\n if fangs.is_empty() {\n print!(\"is not vampiric\");\n } else {\n for fang in fangs {\n print!(\"{} x {}, \", fang, x \/ fang);\n }\n }\n print!(\"\\n\");\n}\n\nfn main() {\n println!(\"The first 25 vampire numbers are\u00a0:\");\n\n let mut nfangs = 0;\n let mut x = 1;\n\n while nfangs < 25 {\n let fangs = fangs(x);\n if !fangs.is_empty() {\n nfangs += 1;\n print_fangs(x, fangs);\n }\n\n x += 1;\n }\n\n println!(\"\\nSpecial requests\u00a0:\");\n\n print_fangs(16758243290880, fangs(16758243290880));\n print_fangs(24959017348650, fangs(24959017348650));\n print_fangs(14593825548650, fangs(14593825548650));\n}\n\n#[test]\nfn test() {\n assert_eq!(\n fangs(16758243290880),\n vec![1982736, 2123856, 2751840, 2817360]\n );\n\n assert_eq!(\n fangs(24959017348650),\n vec![2947050, 2949705, 4125870, 4129587, 4230765]\n );\n\n assert_eq!(fangs(14593825548650), vec![]);\n}\n"} {"name":"Vector","C":"#include\n#include\n\n#define pi M_PI\n\ntypedef struct{\n\tdouble x,y;\n}vector;\n\nvector initVector(double r,double theta){\n\tvector c;\n\t\n\tc.x = r*cos(theta);\n\tc.y = r*sin(theta);\n\t\n\treturn c;\n}\n\nvector addVector(vector a,vector b){\n\tvector c;\n\t\n\tc.x = a.x + b.x;\n\tc.y = a.y + b.y;\n\t\n\treturn c;\n}\n\nvector subtractVector(vector a,vector b){\n\tvector c;\n\t\n\tc.x = a.x - b.x;\n\tc.y = a.y - b.y;\n\t\n\treturn c;\n}\n\nvector multiplyVector(vector a,double b){\n\tvector c;\n\t\n\tc.x = b*a.x;\n\tc.y = b*a.y;\n\t\n\treturn c;\n}\n\nvector divideVector(vector a,double b){\n\tvector c;\n\t\n\tc.x = a.x\/b;\n\tc.y = a.y\/b;\n\t\n\treturn c;\n}\n\nvoid printVector(vector a){\n\tprintf(\"%lf %c %c %lf %c\",a.x,140,(a.y>=0)?'+':'-',(a.y>=0)?a.y:fabs(a.y),150);\n}\n\nint main()\n{\n\tvector a = initVector(3,pi\/6);\n\tvector b = initVector(5,2*pi\/3);\n\t\n\tprintf(\"\\nVector a\u00a0: \");\n\tprintVector(a);\n\t\n\tprintf(\"\\n\\nVector b\u00a0: \");\n\tprintVector(b);\n\t\n\tprintf(\"\\n\\nSum of vectors a and b\u00a0: \");\n\tprintVector(addVector(a,b));\n\t\n\tprintf(\"\\n\\nDifference of vectors a and b\u00a0: \");\n\tprintVector(subtractVector(a,b));\n\t\n\tprintf(\"\\n\\nMultiplying vector a by 3\u00a0: \");\n\tprintVector(multiplyVector(a,3));\n\t\n\tprintf(\"\\n\\nDividing vector b by 2.5\u00a0: \");\n\tprintVector(divideVector(b,2.5));\n\t\n\treturn 0;\n}\n","Rust":"use std::fmt;\nuse std::ops::{Add, Div, Mul, Sub};\n\n#[derive(Copy, Clone, Debug)]\npub struct Vector {\n pub x: T,\n pub y: T,\n}\n\nimpl fmt::Display for Vector\nwhere\n T: fmt::Display,\n{\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n if let Some(prec) = f.precision() {\n write!(f, \"[{:.*}, {:.*}]\", prec, self.x, prec, self.y)\n } else {\n write!(f, \"[{}, {}]\", self.x, self.y)\n }\n }\n}\n\nimpl Vector {\n pub fn new(x: T, y: T) -> Self {\n Vector { x, y }\n }\n}\n\nimpl Vector {\n pub fn from_polar(r: f64, theta: f64) -> Self {\n Vector {\n x: r * theta.cos(),\n y: r * theta.sin(),\n }\n }\n}\n\nimpl Add for Vector\nwhere\n T: Add,\n{\n type Output = Self;\n\n fn add(self, other: Self) -> Self::Output {\n Vector {\n x: self.x + other.x,\n y: self.y + other.y,\n }\n }\n}\n\nimpl Sub for Vector\nwhere\n T: Sub,\n{\n type Output = Self;\n\n fn sub(self, other: Self) -> Self::Output {\n Vector {\n x: self.x - other.x,\n y: self.y - other.y,\n }\n }\n}\n\nimpl Mul for Vector\nwhere\n T: Mul + Copy,\n{\n type Output = Self;\n\n fn mul(self, scalar: T) -> Self::Output {\n Vector {\n x: self.x * scalar,\n y: self.y * scalar,\n }\n }\n}\n\nimpl Div for Vector\nwhere\n T: Div + Copy,\n{\n type Output = Self;\n\n fn div(self, scalar: T) -> Self::Output {\n Vector {\n x: self.x \/ scalar,\n y: self.y \/ scalar,\n }\n }\n}\n\nfn main() {\n use std::f64::consts::FRAC_PI_3;\n\n println!(\"{:?}\", Vector::new(4, 5));\n println!(\"{:.4}\", Vector::from_polar(3.0, FRAC_PI_3));\n println!(\"{}\", Vector::new(2, 3) + Vector::new(4, 6));\n println!(\"{:.4}\", Vector::new(5.6, 1.3) - Vector::new(4.2, 6.1));\n println!(\"{:.4}\", Vector::new(3.0, 4.2) * 2.3);\n println!(\"{:.4}\", Vector::new(3.0, 4.2) \/ 2.3);\n println!(\"{}\", Vector::new(3, 4) \/ 2);\n}\n"} {"name":"Voronoi diagram","C":"#include \n#include \n#include \n\n#define N_SITES 150\ndouble site[N_SITES][2];\nunsigned char rgb[N_SITES][3];\n\nint size_x = 640, size_y = 480;\n\ninline double sq2(double x, double y)\n{\n\treturn x * x + y * y;\n}\n\n#define for_k for (k = 0; k < N_SITES; k++)\nint nearest_site(double x, double y)\n{\n\tint k, ret = 0;\n\tdouble d, dist = 0;\n\tfor_k {\n\t\td = sq2(x - site[k][0], y - site[k][1]);\n\t\tif (!k || d < dist) {\n\t\t\tdist = d, ret = k;\n\t\t}\n\t}\n\treturn ret;\n}\n\n\nint at_edge(int *color, int y, int x)\n{\n\tint i, j, c = color[y * size_x + x];\n\tfor (i = y - 1; i <= y + 1; i++) {\n\t\tif (i < 0 || i >= size_y) continue;\n\n\t\tfor (j = x - 1; j <= x + 1; j++) {\n\t\t\tif (j < 0 || j >= size_x) continue;\n\t\t\tif (color[i * size_x + j] != c) return 1;\n\t\t}\n\t}\n\treturn 0;\n}\n\n#define AA_RES 4 \nvoid aa_color(unsigned char *pix, int y, int x)\n{\n\tint i, j, n;\n\tdouble r = 0, g = 0, b = 0, xx, yy;\n\tfor (i = 0; i < AA_RES; i++) {\n\t\tyy = y + 1. \/ AA_RES * i + .5;\n\t\tfor (j = 0; j < AA_RES; j++) {\n\t\t\txx = x + 1. \/ AA_RES * j + .5;\n\t\t\tn = nearest_site(xx, yy);\n\t\t\tr += rgb[n][0];\n\t\t\tg += rgb[n][1];\n\t\t\tb += rgb[n][2];\n\t\t}\n\t}\n\tpix[0] = r \/ (AA_RES * AA_RES);\n\tpix[1] = g \/ (AA_RES * AA_RES);\n\tpix[2] = b \/ (AA_RES * AA_RES);\n}\n\n#define for_i for (i = 0; i < size_y; i++)\n#define for_j for (j = 0; j < size_x; j++)\nvoid gen_map()\n{\n\tint i, j, k;\n\tint *nearest = malloc(sizeof(int) * size_y * size_x);\n\tunsigned char *ptr, *buf, color;\n\n\tptr = buf = malloc(3 * size_x * size_y);\n\tfor_i for_j nearest[i * size_x + j] = nearest_site(j, i);\n\n\tfor_i for_j {\n\t\tif (!at_edge(nearest, i, j))\n\t\t\tmemcpy(ptr, rgb[nearest[i * size_x + j]], 3);\n\t\telse\t\n\t\t\taa_color(ptr, i, j);\n\t\tptr += 3;\n\t}\n\n\t\n\tfor (k = 0; k < N_SITES; k++) {\n\t\tcolor = (rgb[k][0]*.25 + rgb[k][1]*.6 + rgb[k][2]*.15 > 80) ? 0 : 255;\n\n\t\tfor (i = site[k][1] - 1; i <= site[k][1] + 1; i++) {\n\t\t\tif (i < 0 || i >= size_y) continue;\n\n\t\t\tfor (j = site[k][0] - 1; j <= site[k][0] + 1; j++) {\n\t\t\t\tif (j < 0 || j >= size_x) continue;\n\n\t\t\t\tptr = buf + 3 * (i * size_x + j);\n\t\t\t\tptr[0] = ptr[1] = ptr[2] = color;\n\t\t\t}\n\t\t}\n\t}\n\n\tprintf(\"P6\\n%d %d\\n255\\n\", size_x, size_y);\n\tfflush(stdout);\n\tfwrite(buf, size_y * size_x * 3, 1, stdout);\n}\n\n#define frand(x) (rand() \/ (1. + RAND_MAX) * x)\nint main()\n{\n\tint k;\n\tfor_k {\n\t\tsite[k][0] = frand(size_x);\n\t\tsite[k][1] = frand(size_y);\n\t\trgb [k][0] = frand(256);\n\t\trgb [k][1] = frand(256);\n\t\trgb [k][2] = frand(256);\n\t}\n\n\tgen_map();\n\treturn 0;\n}\n","Rust":"extern crate piston;\nextern crate opengl_graphics;\nextern crate graphics;\nextern crate touch_visualizer;\n\n#[cfg(feature = \"include_sdl2\")]\nextern crate sdl2_window;\n\nextern crate getopts;\nextern crate voronoi;\nextern crate rand;\n\nuse touch_visualizer::TouchVisualizer;\nuse opengl_graphics::{ GlGraphics, OpenGL };\nuse graphics::{ Context, Graphics };\nuse piston::window::{ Window, WindowSettings };\nuse piston::input::*;\nuse piston::event_loop::*;\n#[cfg(feature = \"include_sdl2\")]\nuse sdl2_window::Sdl2Window as AppWindow;\nuse voronoi::{voronoi, Point, make_polygons};\nuse rand::Rng;\n\nstatic DEFAULT_WINDOW_HEIGHT: u32 = 600;\nstatic DEFAULT_WINDOW_WIDTH: u32 = 600;\n\nstruct Settings {\n lines_only: bool,\n random_count: usize\n}\n\nfn main() {\n let args: Vec = std::env::args().collect();\n let mut opts = getopts::Options::new();\n opts.optflag(\"l\", \"lines_only\", \"Don't color polygons, just outline them\");\n opts.optopt(\"r\", \"random_count\", \"On keypress \\\"R\\\", put this many random points on-screen\", \"RANDOMCOUNT\");\n let matches = opts.parse(&args[1..]).expect(\"Failed to parse args\");\n\n let settings = Settings{\n lines_only: matches.opt_present(\"l\"),\n random_count: match matches.opt_str(\"r\") {\n None => { 50 },\n Some(s) => { s.parse().expect(\"Random count of bad format\") }\n }\n };\n\n event_loop(&settings);\n\n}\n\nfn random_point() -> [f64; 2] {\n [rand::thread_rng().gen_range(0., DEFAULT_WINDOW_HEIGHT as f64), rand::thread_rng().gen_range(0., DEFAULT_WINDOW_WIDTH as f64)]\n}\n\nfn random_color() -> [f32; 4] {\n [rand::random::(), rand::random::(), rand::random::(), 1.0]\n}\n\nfn random_voronoi(dots: &mut Vec<[f64;2]>, colors: &mut Vec<[f32;4]>, num: usize) {\n dots.clear();\n colors.clear();\n\n for _ in 0..num {\n dots.push(random_point());\n colors.push(random_color());\n }\n}\n\nfn event_loop(settings: &Settings) {\n let opengl = OpenGL::V3_2;\n let mut window: AppWindow = WindowSettings::new(\"Interactive Voronoi\", [DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH])\n .exit_on_esc(true).opengl(opengl).build().unwrap();\n\n let ref mut gl = GlGraphics::new(opengl);\n let mut touch_visualizer = TouchVisualizer::new();\n let mut events = Events::new(EventSettings::new().lazy(true));\n let mut dots = Vec::new();\n let mut colors = Vec::new();\n\n let mut mx = 0.0;\n let mut my = 0.0;\n\n while let Some(e) = events.next(&mut window) {\n touch_visualizer.event(window.size(), &e);\n if let Some(button) = e.release_args() {\n match button {\n Button::Keyboard(key) => {\n if key == piston::input::keyboard::Key::N { dots.clear(); colors.clear(); }\n if key == piston::input::keyboard::Key::R { random_voronoi(&mut dots, &mut colors, settings.random_count); }\n }\n Button::Mouse(_) => {\n dots.push([mx, my]);\n colors.push(random_color());\n },\n _ => ()\n }\n };\n e.mouse_cursor(|x, y| {\n mx = x;\n my = y;\n });\n if let Some(args) = e.render_args() {\n gl.draw(args.viewport(), |c, g| {\n graphics::clear([1.0; 4], g);\n let mut vor_pts = Vec::new();\n for d in &dots {\n vor_pts.push(Point::new(d[0], d[1]));\n }\n if vor_pts.len() > 0 {\n let vor_diagram = voronoi(vor_pts, DEFAULT_WINDOW_WIDTH as f64);\n let vor_polys = make_polygons(&vor_diagram);\n for (i, poly) in vor_polys.iter().enumerate() {\n if settings.lines_only {\n draw_lines_in_polygon(poly, &c, g);\n } else {\n draw_polygon(poly, &c, g, colors[i]);\n }\n }\n }\n for d in &dots {\n draw_ellipse(&d, &c, g);\n }\n });\n }\n } \n\n}\n\nfn draw_lines_in_polygon(\n poly: &Vec,\n c: &Context,\n g: &mut G,\n)\n{\n let color = [0.0, 0.0, 1.0, 1.0];\n\n for i in 0..poly.len()-1 {\n graphics::line(\n color,\n 2.0,\n [poly[i].x.into(), poly[i].y.into(), poly[i+1].x.into(), poly[i+1].y.into()],\n c.transform,\n g\n )\n }\n}\n\nfn draw_polygon(\n poly: &Vec,\n c: &Context,\n g: &mut G,\n color: [f32; 4]\n) {\n let mut polygon_points: Vec<[f64; 2]> = Vec::new();\n\n for p in poly {\n polygon_points.push([p.x.into(), p.y.into()]);\n }\n\n graphics::polygon(\n color,\n polygon_points.as_slice(),\n c.transform,\n g\n )\n}\n\nfn draw_ellipse(\n cursor: &[f64; 2],\n c: &Context,\n g: &mut G,\n) {\n let color = [0.0, 0.0, 0.0, 1.0];\n graphics::ellipse(\n color,\n graphics::ellipse::circle(cursor[0], cursor[1], 4.0),\n c.transform,\n g\n );\n}\n"} {"name":"Wilson primes of order n","C":"#include \n#include \n#include \n#include \n\nbool *sieve(int limit) {\n int i, p;\n limit++;\n \n bool *c = calloc(limit, sizeof(bool)); \n c[0] = true;\n c[1] = true;\n for (i = 4; i < limit; i += 2) c[i] = true;\n p = 3; \n while (true) {\n int p2 = p * p;\n if (p2 >= limit) break;\n for (i = p2; i < limit; i += 2 * p) c[i] = true;\n while (true) {\n p += 2;\n if (!c[p]) break;\n }\n }\n return c;\n}\n\nint main() {\n const int limit = 11000;\n int i, j, n, pc = 0;\n unsigned long p;\n bool *c = sieve(limit);\n for (i = 0; i < limit; ++i) {\n if (!c[i]) ++pc;\n }\n unsigned long *primes = (unsigned long *)malloc(pc * sizeof(unsigned long));\n for (i = 0, j = 0; i < limit; ++i) {\n if (!c[i]) primes[j++] = i;\n }\n mpz_t *facts = (mpz_t *)malloc(limit *sizeof(mpz_t));\n for (i = 0; i < limit; ++i) mpz_init(facts[i]);\n mpz_set_ui(facts[0], 1);\n for (i = 1; i < limit; ++i) mpz_mul_ui(facts[i], facts[i-1], i);\n mpz_t f, sign;\n mpz_init(f);\n mpz_init_set_ui(sign, 1);\n printf(\" n: Wilson primes\\n\");\n printf(\"--------------------\\n\");\n for (n = 1; n < 12; ++n) {\n printf(\"%2d: \", n);\n mpz_neg(sign, sign);\n for (i = 0; i < pc; ++i) {\n p = primes[i];\n if (p < n) continue;\n mpz_mul(f, facts[n-1], facts[p-n]);\n mpz_sub(f, f, sign);\n if (mpz_divisible_ui_p(f, p*p)) printf(\"%ld \", p);\n }\n printf(\"\\n\");\n }\n free(c);\n free(primes);\n for (i = 0; i < limit; ++i) mpz_clear(facts[i]);\n free(facts);\n return 0;\n}\n","Rust":"\n\n\nuse rug::Integer;\n\nfn generate_primes(limit: usize) -> Vec {\n let mut sieve = vec![true; limit >> 1];\n let mut p = 3;\n let mut sq = p * p;\n while sq < limit {\n if sieve[p >> 1] {\n let mut q = sq;\n while q < limit {\n sieve[q >> 1] = false;\n q += p << 1;\n }\n }\n sq += (p + 1) << 2;\n p += 2;\n }\n let mut primes = Vec::new();\n if limit > 2 {\n primes.push(2);\n }\n for i in 1..sieve.len() {\n if sieve[i] {\n primes.push((i << 1) + 1);\n }\n }\n primes\n}\n\nfn factorials(limit: usize) -> Vec {\n let mut f = vec![Integer::from(1)];\n let mut factorial = Integer::from(1);\n f.reserve(limit);\n for i in 1..limit {\n factorial *= i as u64;\n f.push(factorial.clone());\n }\n f\n}\n\nfn main() {\n let limit = 11000;\n let f = factorials(limit);\n let primes = generate_primes(limit);\n println!(\" n | Wilson primes\\n--------------------\");\n let mut s = -1;\n for n in 1..=11 {\n print!(\"{:2} |\", n);\n for p in &primes {\n if *p >= n {\n let mut num = Integer::from(&f[n - 1] * &f[*p - n]);\n num -= s;\n if num % ((p * p) as u64) == 0 {\n print!(\" {}\", p);\n }\n }\n }\n println!();\n s = -s;\n }\n}\n"} {"name":"Write to Windows event log","C":"#include\n#include\n\nint main(int argC,char* argV[])\n{\n\tchar str[1000];\n\t\n\tif(argC!=5)\n\t\tprintf(\"Usage\u00a0: %s < Followed by level, id, source string and description>\",argV[0]);\n\telse{\n\t\tsprintf(str,\"EventCreate \/t %s \/id %s \/l APPLICATION \/so %s \/d \\\"%s\\\"\",argV[1],argV[2],argV[3],argV[4]);\n\t\tsystem(str);\n\t}\n\t\n\treturn 0;\n}\n","Rust":"#[cfg(windows)]\nmod bindings {\n ::windows::include_bindings!();\n}\n\n#[cfg(windows)]\nuse bindings::{\n Windows::Win32::Security::{\n GetTokenInformation, OpenProcessToken, PSID, TOKEN_ACCESS_MASK, TOKEN_INFORMATION_CLASS,\n TOKEN_USER,\n },\n Windows::Win32::SystemServices::{\n GetCurrentProcess, OpenEventLogA, ReportEventA, ReportEvent_wType, HANDLE, PSTR,\n },\n};\n\n#[cfg(windows)]\nfn main() -> windows::Result<()> {\n let ph = unsafe { GetCurrentProcess() };\n let mut th: HANDLE = HANDLE(0);\n unsafe { OpenProcessToken(ph, TOKEN_ACCESS_MASK::TOKEN_QUERY, &mut th) }.ok()?;\n\n \n let mut length = 0_u32;\n unsafe {\n GetTokenInformation(\n th,\n TOKEN_INFORMATION_CLASS::TokenUser,\n std::ptr::null_mut(),\n 0,\n &mut length,\n )\n }\n .ok()\n .unwrap_err();\n\n \n let mut token_user_bytes = vec![0u8; length as usize];\n unsafe {\n GetTokenInformation(\n th,\n TOKEN_INFORMATION_CLASS::TokenUser,\n token_user_bytes.as_mut_ptr().cast(),\n length,\n &mut length,\n )\n }\n .ok()?;\n\n \n let user_sid: PSID = unsafe { (*token_user_bytes.as_ptr().cast::()).User.Sid };\n\n \n let event_log_handle = unsafe { OpenEventLogA(PSTR::default(), \"Application\") };\n\n let mut event_msg = PSTR(b\"Hello in the event log\\0\".as_ptr() as _);\n unsafe {\n ReportEventA(\n HANDLE(event_log_handle.0), \n ReportEvent_wType::EVENTLOG_WARNING_TYPE, \n 5, \n 1, \n user_sid, \n 1, \n 0, \n &mut event_msg, \n std::ptr::null_mut(), \n )\n }\n .ok()?;\n\n Ok(())\n}\n\n#[cfg(not(windows))]\nfn main() {\n println!(\"Not implemented\");\n}\n"} {"name":"Y combinator","C":"#include \n#include \n\n\ntypedef struct func_t *func;\ntypedef struct func_t {\n func (*fn) (func, func);\n func _;\n int num;\n} func_t;\n\nfunc new(func(*f)(func, func), func _) {\n func x = malloc(sizeof(func_t));\n x->fn = f;\n x->_ = _; \n x->num = 0;\n return x;\n}\n\nfunc call(func f, func n) {\n return f->fn(f, n);\n}\n\nfunc Y(func(*f)(func, func)) {\n func g = new(f, 0);\n g->_ = g;\n return g;\n}\n\nfunc num(int n) {\n func x = new(0, 0);\n x->num = n;\n return x;\n}\n\n\nfunc fac(func self, func n) {\n int nn = n->num;\n return nn > 1 ? num(nn * call(self->_, num(nn - 1))->num)\n : num(1);\n}\n\nfunc fib(func self, func n) {\n int nn = n->num;\n return nn > 1\n ? num( call(self->_, num(nn - 1))->num +\n call(self->_, num(nn - 2))->num )\n : num(1);\n}\n\nvoid show(func n) { printf(\" %d\", n->num); }\n\nint main() {\n int i;\n func f = Y(fac);\n printf(\"fac: \");\n for (i = 1; i < 10; i++)\n show( call(f, num(i)) );\n printf(\"\\n\");\n\n f = Y(fib);\n printf(\"fib: \");\n for (i = 1; i < 10; i++)\n show( call(f, num(i)) );\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"\n\n\n\n\n\n\ntrait Apply {\n fn apply(&self, f: &dyn Apply, t: T) -> R;\n}\n\n\n\n\n\nimpl Apply for F where F: Fn(&dyn Apply, T) -> R {\n fn apply(&self, f: &dyn Apply, t: T) -> R {\n self(f, t)\n }\n}\n\n\n\n\nfn y(f: impl Fn(&dyn Fn(T) -> R, T) -> R) -> impl Fn(T) -> R {\n move |t| (&|x: &dyn Apply, y| x.apply(x, y))\n (&|x: &dyn Apply, y| f(&|z| x.apply(x, z), y), t)\n}\n\n\nfn fac(n: usize) -> usize {\n let almost_fac = |f: &dyn Fn(usize) -> usize, x| if x == 0 { 1 } else { x * f(x - 1) };\n y(almost_fac)(n)\n}\n\n\nfn fib(n: usize) -> usize {\n let almost_fib = |f: &dyn Fn((usize, usize, usize)) -> usize, (a0, a1, x)|\n match x {\n 0 => a0,\n 1 => a1,\n _ => f((a1, a0 + a1, x - 1)),\n };\n\n y(almost_fib)((1, 1, n))\n}\n\n\nfn main() {\n let n = 10;\n println!(\"fac({}) = {}\", n, fac(n));\n println!(\"fib({}) = {}\", n, fib(n));\n}\n"}