{"name":"100 doors","C":"#include \n\nint main()\n{\n char is_open[100] = { 0 };\n int pass, door;\n\n \n for (pass = 0; pass < 100; ++pass)\n for (door = pass; door < 100; door += pass+1)\n is_open[door] = !is_open[door];\n\n \n for (door = 0; door < 100; ++door)\n printf(\"door #%d is %s.\\n\", door+1, (is_open[door]? \"open\" : \"closed\"));\n\n return 0;\n}\n","Rust":"fn main() {\n let mut door_open = [false; 100];\n for pass in 1..101 {\n let mut door = pass;\n while door <= 100 {\n door_open[door - 1] = !door_open[door - 1];\n door += pass;\n }\n }\n for (i, &is_open) in door_open.iter().enumerate() {\n println!(\n \"Door {} is {}.\",\n i + 1,\n if is_open { \"open\" } else { \"closed\" }\n );\n }\n}\n"} {"name":"100 prisoners","C":"#include\n#include\n#include\n#include\n\n#define LIBERTY false\n#define DEATH true\n\ntypedef struct{\n\tint cardNum;\n\tbool hasBeenOpened;\n}drawer;\n\ndrawer *drawerSet;\n\nvoid initialize(int prisoners){\n\tint i,j,card;\n\tbool unique;\n\n\tdrawerSet = ((drawer*)malloc(prisoners * sizeof(drawer))) -1;\n\n\tcard = rand()%prisoners + 1;\n\tdrawerSet[1] = (drawer){.cardNum = card, .hasBeenOpened = false};\n\n\tfor(i=1 + 1;i \",argv[0]);\n\n\tprisoners = atoi(argv[1]);\n\tchances = atoi(argv[2]);\n\ttrials = strtoull(argv[3],&end,10);\n\n\tsrand(time(NULL));\n\n\tprintf(\"Running random trials...\");\n\tfor(i=0;i bool {\n let checks = {\n let mut b: Vec = (1u8..=100u8).collect();\n b.shuffle(&mut rand::thread_rng());\n b\n };\n checks.into_iter().take(50).any(|check| boxes[check as usize - 1] == prisoner)\n}\n\n\nfn check_ordered_boxes(prisoner: u8, boxes: &[u8]) -> bool {\n let mut next_check = prisoner;\n (0..50).any(|_| {\n next_check = boxes[next_check as usize - 1];\n next_check == prisoner\n })\n}\n\nfn main() {\n let mut boxes: Vec = (1u8..=100u8).collect();\n\n let trials = 100000;\n\n let ordered_successes = (0..trials).filter(|_| {\n boxes.shuffle(&mut rand::thread_rng());\n (1u8..=100u8).all(|prisoner| check_ordered_boxes(prisoner, &boxes))\n }).count();\n\n let random_successes = (0..trials).filter(|_| {\n boxes.shuffle(&mut rand::thread_rng());\n (1u8..=100u8).all(|prisoner| check_random_boxes(prisoner, &boxes))\n }).count();\n\n println!(\"{} \/ {} ({:.02}%) successes in ordered\", ordered_successes, trials, ordered_successes as f64 * 100.0 \/ trials as f64);\n println!(\"{} \/ {} ({:.02}%) successes in random\", random_successes, trials, random_successes as f64 * 100.0 \/ trials as f64);\n\n}\n"} {"name":"15 puzzle game","C":"\n#define _CRT_SECURE_NO_WARNINGS\n#include \n#include \n#include \n#define N 4\n#define M 4\nenum Move{UP,DOWN,LEFT,RIGHT};int hR;int hC;int cc[N][M];const int nS=100;int\nupdate(enum Move m){const int dx[]={0,0,-1,1};const int dy[]={-1,1,0,0};int i=hR\n+dy[m];int j=hC+dx[m];if(i>= 0&&i=0&&j Self {\n let mut board = EMPTY;\n for (i, cell) in board.iter_mut().enumerate().skip(1) {\n *cell = Cell::Card(i);\n }\n\n let mut rng = rand::thread_rng();\n\n board.shuffle(&mut rng);\n if !Self::is_valid(board) {\n \n let i = rng.gen_range(0..16);\n let mut j = rng.gen_range(0..16);\n while j == i {\n j = rng.gen_range(0..16);\n }\n board.swap(i, j);\n }\n\n Self { board }\n }\n\n fn is_valid(mut board: Board) -> bool {\n \n let mut permutations = 0;\n\n let pos = board.iter().position(|&cell| cell == Cell::Empty).unwrap();\n\n if pos != 15 {\n board.swap(pos, 15);\n permutations += 1;\n }\n\n for i in 1..16 {\n let pos = board\n .iter()\n .position(|&cell| match cell {\n Cell::Card(value) if value == i => true,\n _ => false,\n })\n .unwrap();\n\n if pos + 1 != i {\n board.swap(pos, i - 1);\n permutations += 1;\n }\n }\n\n permutations % 2 == 0\n }\n\n fn get_empty_position(&self) -> usize {\n self.board.iter().position(|&c| c == Cell::Empty).unwrap()\n }\n\n fn get_moves(&self) -> HashMap {\n let mut moves = HashMap::new();\n let i = self.get_empty_position();\n\n if i > 3 {\n moves.insert(Direction::Up, self.board[i - 4]);\n }\n if i % 4 != 0 {\n moves.insert(Direction::Left, self.board[i - 1]);\n }\n if i < 12 {\n moves.insert(Direction::Down, self.board[i + 4]);\n }\n if i % 4 != 3 {\n moves.insert(Direction::Right, self.board[i + 1]);\n }\n moves\n }\n\n fn play(&mut self, direction: &Direction) {\n let i = self.get_empty_position();\n \n match *direction {\n Direction::Up => self.board.swap(i, i - 4),\n Direction::Left => self.board.swap(i, i - 1),\n Direction::Right => self.board.swap(i, i + 1),\n Direction::Down => self.board.swap(i, i + 4),\n };\n }\n\n fn is_complete(&self) -> bool {\n self.board.iter().enumerate().all(|(i, &cell)| match cell {\n Cell::Card(value) => value == i + 1,\n Cell::Empty => i == 15,\n })\n }\n}\n\nimpl fmt::Display for P15 {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n (writeln!(f, \"+----+----+----+----+\"))?;\n for (i, &cell) in self.board.iter().enumerate() {\n match cell {\n Cell::Card(value) => (write!(f, \"| {value:2} \"))?,\n Cell::Empty => (write!(f, \"| \"))?,\n }\n\n if i % 4 == 3 {\n (writeln!(f, \"|\"))?;\n (writeln!(f, \"+----+----+----+----+\"))?;\n }\n }\n Ok(())\n }\n}\n\nfn main() {\n let mut p15 = P15::new();\n\n for turns in 1.. {\n println!(\"{p15}\");\n match ask_action(&p15.get_moves()) {\n Action::Move(direction) => {\n p15.play(&direction);\n print!(\"\\x1B[2J\\x1B[1;1H\");\n }\n Action::Quit => {\n print!(\"\\x1B[2J\\x1B[1;1H\");\n\n println!(\"Bye\u00a0!\");\n break;\n }\n }\n\n if p15.is_complete() {\n println!(\"Well done\u00a0! You won in {turns} turns\");\n break;\n }\n }\n}\n\nfn ask_action(moves: &HashMap) -> Action {\n use std::io::{self, Write};\n use Action::*;\n use Direction::*;\n\n println!(\"Possible moves:\");\n\n if let Some(&Cell::Card(value)) = moves.get(&Up) {\n println!(\"\\tU) {value}\");\n }\n if let Some(&Cell::Card(value)) = moves.get(&Left) {\n println!(\"\\tL) {value}\");\n }\n if let Some(&Cell::Card(value)) = moves.get(&Right) {\n println!(\"\\tR) {value}\");\n }\n if let Some(&Cell::Card(value)) = moves.get(&Down) {\n println!(\"\\tD) {value}\");\n }\n println!(\"\\tQ) Quit\");\n print!(\"Choose your move\u00a0: \");\n io::stdout().flush().unwrap();\n\n let mut action = String::new();\n io::stdin().read_line(&mut action).expect(\"read error\");\n match action.to_uppercase().trim() {\n \"U\" if moves.contains_key(&Up) => Move(Up),\n \"L\" if moves.contains_key(&Left) => Move(Left),\n \"R\" if moves.contains_key(&Right) => Move(Right),\n \"D\" if moves.contains_key(&Down) => Move(Down),\n \"Q\" => Quit,\n _ => {\n println!(\"Unknown action: {action}\");\n ask_action(moves)\n }\n }\n}\n"} {"name":"21 game","C":"\n\n\n\n#define _CRT_SECURE_NO_WARNINGS\n\n#include \n#include \n#include \n\n\n#if __STDC_VERSION__ >= 199901L || _MSC_VER >= 1800\n#include \n#else\n#define bool int\n#define true 1\n#define false 0\n#endif\n\n#define GOAL 21\n#define NUMBER_OF_PLAYERS 2\n#define MIN_MOVE 1\n#define MAX_MOVE 3\n#define BUFFER_SIZE 256\n\n#define _(STRING) STRING\n\n\n\nstatic char DESCRIPTION[] = \n \"21 Game \\n\"\n \" \\n\"\n \"21 is a two player game, the game is played by choosing a number \\n\"\n \"(1, 2, or 3) to be added to the running total. The game is won by\\n\"\n \"the player whose chosen number causes the running total to reach \\n\"\n \"exactly 21. The running total starts at zero. \\n\\n\";\n\nstatic int total;\n\n\nvoid update(char* player, int move)\n{\n printf(\"%8s: %d = %d + %d\\n\\n\", player, total + move, total, move);\n total += move;\n if (total == GOAL)\n printf(_(\"The winner is %s.\\n\\n\"), player);\n}\n\n\nint ai()\n{\n\n#if GOAL < 32 && MIN_MOVE == 1 && MAX_MOVE == 3\n static const int precomputed[] = { 1, 1, 3, 2, 1, 1, 3, 2, 1, 1, 3, 2, 1, 1,\n 3, 2, 1, 1, 3, 2, 1, 1, 3, 2, 1, 1, 3, 2, 1, 1, 3 };\n update(_(\"ai\"), precomputed[total]);\n#elif MIN_MOVE == 1 && MAX_MOVE == 3\n static const int precomputed[] = { 1, 1, 3, 2};\n update(_(\"ai\"), precomputed[total % (MAX_MOVE + 1)]);\n#else\n int i;\n int move = 1;\n for (i = MIN_MOVE; i <= MAX_MOVE; i++)\n if ((total + i - 1) % (MAX_MOVE + 1) == 0)\n move = i;\n for (i = MIN_MOVE; i <= MAX_MOVE; i++)\n if (total + i == GOAL)\n move = i;\n update(_(\"ai\"), move);\n#endif\n}\n\n\nvoid human(void)\n{\n char buffer[BUFFER_SIZE];\n int move;\n \n while ( printf(_(\"enter your move to play (or enter 0 to exit game): \")),\n fgets(buffer, BUFFER_SIZE, stdin), \n sscanf(buffer, \"%d\", &move) != 1 ||\n (move && (move < MIN_MOVE || move > MAX_MOVE || total+move > GOAL)))\n puts(_(\"\\nYour answer is not a valid choice.\\n\"));\n putchar('\\n');\n if (!move) exit(EXIT_SUCCESS);\n update(_(\"human\"), move);\n}\n\n\nint main(int argc, char* argv[])\n{\n srand(time(NULL));\n puts(_(DESCRIPTION));\n while (true)\n {\n puts(_(\"\\n---- NEW GAME ----\\n\"));\n puts(_(\"\\nThe running total is currently zero.\\n\"));\n total = 0;\n\n if (rand() % NUMBER_OF_PLAYERS)\n {\n puts(_(\"The first move is AI move.\\n\"));\n ai();\n }\n else\n puts(_(\"The first move is human move.\\n\"));\n\n while (total < GOAL)\n {\n human();\n ai();\n }\n }\n}\n","Rust":"use rand::Rng;\nuse std::io;\n\n#[derive(Clone)]\nenum PlayerType {\n Human,\n Computer,\n}\n\n#[derive(Clone)]\nstruct Player {\n name: String,\n wins: u32, \n level: u32, \n player_type: PlayerType, \n}\n\ntrait Choose {\n fn choose(&self, game: &Game) -> u8;\n}\n\nimpl Player {\n fn new(name: &str, player_type: PlayerType, level: u32) -> Player {\n Player {\n name: String::from(name),\n wins: 0,\n level,\n player_type,\n }\n }\n fn get_name(&self) -> &str {\n &self.name[..]\n }\n fn get_level(&self) -> u32 {\n self.level\n }\n fn add_win(&mut self) {\n self.wins += 1\n }\n fn level_up(&mut self) {\n self.level += 1\n }\n}\n\nimpl Choose for Player {\n fn choose(&self, game: &Game) -> u8 {\n match self.player_type {\n PlayerType::Human => loop {\n let max_choice = game.max_choice();\n match max_choice {\n 1 => println!(\"Enter a number 1 to win (or quit):\"),\n _ => println!(\"Enter a number between 1 and {} (or quit):\", max_choice)\n }\n let mut guess = String::new();\n io::stdin()\n .read_line(&mut guess)\n .expect(\"Failed to read line\");\n if guess.trim() == \"quit\" {\n return 0\n }\n let guess: u8 = match guess.trim().parse() {\n Ok(num) if num >= 1 && num <= max_choice => num,\n Ok(_) => continue,\n Err(_) => continue,\n };\n return guess;\n },\n PlayerType::Computer => match self.level {\n 5 => match game.get_total() {\n total if total == 20 => 1,\n total if total == 19 => 2,\n total if total == 18 => 3,\n _ => 1,\n },\n 4 => match game.get_total() {\n total if total == 20 => 1,\n total if total == 19 => 2,\n total if total == 18 => 3,\n _ => rand::thread_rng().gen_range(1, 3),\n },\n 3 => match game.get_total() {\n total if total == 20 => 1,\n total if total == 19 => 2,\n total if total == 18 => 3,\n _ => rand::thread_rng().gen_range(1, 4),\n },\n 2 => match game.get_total() {\n total if total == 20 => 1,\n total if total == 19 => 2,\n _ => rand::thread_rng().gen_range(1, 3),\n },\n 1 => 1,\n _ => match game.get_total() {\n total if total == 20 => 1,\n total if total == 19 => 2,\n total if total == 18 => 3,\n _ => match game.get_remaining() % 4 {\n 0 => rand::thread_rng().gen_range(1, 4),\n _ => game.get_remaining() % 4,\n },\n },\n },\n }\n }\n}\n\nstruct Game {\n players: Vec,\n turn: u8, \n total: u8, \n start: u8, \n}\n\nimpl Game {\n fn init(players: &Vec) -> Game {\n Game {\n players: players.to_vec(),\n turn: 1,\n total: 0,\n start: rand::thread_rng().gen_range(0, 2),\n }\n }\n fn play(&mut self) -> &Player {\n loop {\n println!(\n \"Total now {} (remaining: {})\",\n self.get_total(),\n self.get_remaining()\n );\n {\n let player = self.whose_turn();\n println!(\"Turn: {} ({} turn)\", self.get_turn(), player.get_name());\n let choice = player.choose(&self);\n if choice == 0 {\n self.next_turn();\n break; \n }\n println!(\"{} choose {}\", player.get_name(), choice);\n self.add_total(choice)\n }\n if self.get_total() >= 21 {\n break;\n }\n println!(\"\");\n self.next_turn();\n }\n self.whose_turn()\n }\n fn add_total(&mut self, choice: u8) {\n self.total += choice;\n }\n fn next_turn(&mut self) {\n self.turn += 1;\n }\n fn whose_turn(&self) -> &Player {\n let index: usize = ((self.turn + self.start) % 2).into();\n &self.players[index]\n }\n fn get_total(&self) -> u8 {\n self.total\n }\n fn get_remaining(&self) -> u8 {\n 21 - self.total\n }\n fn max_choice(&self) -> u8 {\n match self.get_remaining() {\n 1 => 1,\n 2 => 2,\n _ => 3\n }\n }\n fn get_turn(&self) -> u8 {\n self.turn\n }\n}\n\nfn main() {\n let mut game_count = 0;\n let mut players = vec![\n Player::new(\"human\", PlayerType::Human, 0),\n Player::new(\"computer\", PlayerType::Computer, 1),\n ];\n println!(\"21 Game\");\n println!(\"Press enter key to start\");\n {\n let _ = io::stdin().read_line(&mut String::new());\n }\n loop {\n game_count += 1;\n let mut game = Game::init(&players);\n let winner = game.play();\n {\n let mut index = 0;\n while index < players.len() {\n if players[index].get_name() == winner.get_name() {\n players[index].add_win();\n }\n index += 1\n }\n }\n println!(\"\\n{} won game {}\\n\", winner.get_name(), game_count);\n \n if game_count >= 10000 {\n break;\n }\n \n println!(\"Press enter key to play again (or quit):\");\n let mut reply = String::new();\n io::stdin()\n .read_line(&mut reply)\n .expect(\"Failed to read line\");\n if reply.trim() == \"quit\" {\n break;\n }\n \n if winner.get_name() != \"computer\" {\n println!(\"Computer leveling up ...\");\n players[1].level_up();\n println!(\"Computer now level {}!\", players[1].get_level());\n println!(\"Beware!\\n\");\n }\n }\n println!(\"player: {} win: {}\", players[0].get_name(), players[0].wins);\n println!(\"player: {} win: {}\", players[1].get_name(), players[1].wins);\n}\n"} {"name":"4-rings or 4-squares puzzle","C":"#include \n\n#define TRUE 1\n#define FALSE 0\n\nint a,b,c,d,e,f,g;\nint lo,hi,unique,show;\nint solutions;\n\nvoid\nbf()\n{\n for (f = lo;f <= hi; f++)\n if ((!unique) ||\n ((f != a) && (f != c) && (f != d) && (f != g) && (f != e)))\n {\n b = e + f - c;\n if ((b >= lo) && (b <= hi) &&\n ((!unique) || ((b != a) && (b != c) &&\n (b != d) && (b != g) && (b != e) && (b != f))))\n {\n solutions++;\n if (show)\n printf(\"%d %d %d %d %d %d %d\\n\",a,b,c,d,e,f,g);\n }\n }\n}\n\n\nvoid\nge()\n{\n for (e = lo;e <= hi; e++)\n if ((!unique) || ((e != a) && (e != c) && (e != d)))\n {\n g = d + e;\n if ((g >= lo) && (g <= hi) &&\n ((!unique) || ((g != a) && (g != c) &&\n (g != d) && (g != e))))\n bf();\n }\n}\n\nvoid\nacd()\n{\n for (c = lo;c <= hi; c++)\n for (d = lo;d <= hi; d++)\n if ((!unique) || (c != d))\n {\n a = c + d;\n if ((a >= lo) && (a <= hi) &&\n ((!unique) || ((c != 0) && (d != 0))))\n ge();\n }\n}\n\n\nvoid\nfoursquares(int plo,int phi, int punique,int pshow)\n{\n lo = plo;\n hi = phi;\n unique = punique;\n show = pshow;\n solutions = 0;\n\n printf(\"\\n\");\n\n acd();\n\n if (unique)\n printf(\"\\n%d unique solutions in %d to %d\\n\",solutions,lo,hi);\n else\n printf(\"\\n%d non-unique solutions in %d to %d\\n\",solutions,lo,hi);\n}\n\nmain()\n{\n foursquares(1,7,TRUE,TRUE);\n foursquares(3,9,TRUE,TRUE);\n foursquares(0,9,FALSE,FALSE);\n}\n","Rust":"#![feature(inclusive_range_syntax)]\n\nfn is_unique(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8) -> bool {\n a != b && a != c && a != d && a != e && a != f && a != g &&\n b != c && b != d && b != e && b != f && b != g &&\n c != d && c != e && c != f && c != g &&\n d != e && d != f && d != g &&\n e != f && e != g &&\n f != g\n}\n\nfn is_solution(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8) -> bool {\n a + b == b + c + d &&\n b + c + d == d + e + f &&\n d + e + f == f + g\n}\n\nfn four_squares(low: u8, high: u8, unique: bool) -> Vec> {\n let mut results: Vec> = Vec::new();\n\n for a in low..=high {\n for b in low..=high {\n for c in low..=high {\n for d in low..=high {\n for e in low..=high {\n for f in low..=high {\n for g in low..=high {\n if (!unique || is_unique(a, b, c, d, e, f, g)) &&\n is_solution(a, b, c, d, e, f, g) {\n results.push(vec![a, b, c, d, e, f, g]);\n }\n }\n }\n }\n }\n }\n }\n }\n results\n}\n\nfn print_results(solutions: &Vec>) {\n for solution in solutions {\n println!(\"{:?}\", solution)\n }\n}\n\nfn print_results_summary(solutions: usize, low: u8, high: u8, unique: bool) {\n let uniqueness = if unique {\n \"unique\"\n } else {\n \"non-unique\"\n };\n println!(\"{} {} solutions in {} to {} range\", solutions, uniqueness, low, high)\n}\n\nfn uniques(low: u8, high: u8) {\n let solutions = four_squares(low, high, true);\n print_results(&solutions);\n print_results_summary(solutions.len(), low, high, true);\n}\n\nfn nonuniques(low: u8, high: u8) {\n let solutions = four_squares(low, high, false);\n print_results_summary(solutions.len(), low, high, false);\n}\n\nfn main() {\n uniques(1, 7);\n println!();\n uniques(3, 9);\n println!();\n nonuniques(0, 9);\n}\n"} {"name":"9 billion names of God the integer","C":"#include \n#include \n\n#define N 100000\nmpz_t p[N + 1];\n\nvoid calc(int n)\n{\n\tmpz_init_set_ui(p[n], 0);\n\n\tfor (int k = 1; k <= n; k++) {\n\t\tint d = n - k * (3 * k - 1) \/ 2;\n\t\tif (d < 0) break;\n\n\t\tif (k&1)mpz_add(p[n], p[n], p[d]);\n\t\telse\tmpz_sub(p[n], p[n], p[d]);\n\n\t\td -= k;\n\t\tif (d < 0) break;\n\n\t\tif (k&1)mpz_add(p[n], p[n], p[d]);\n\t\telse\tmpz_sub(p[n], p[n], p[d]);\n\t}\n}\n\nint main(void)\n{\n\tint idx[] = { 23, 123, 1234, 12345, 20000, 30000, 40000, 50000, N, 0 };\n\tint at = 0;\n\n\tmpz_init_set_ui(p[0], 1);\n\n\tfor (int i = 1; idx[at]; i++) {\n\t\tcalc(i);\n\t\tif (i != idx[at]) continue;\n\n\t\tgmp_printf(\"%2d:\\t%Zd\\n\", i, p[i]);\n\t\tat++;\n\t}\n}\n","Rust":"extern crate num;\n\nuse std::cmp;\nuse num::bigint::BigUint;\n\nfn cumu(n: usize, cache: &mut Vec>) {\n for l in cache.len()..n+1 {\n let mut r = vec![BigUint::from(0u32)];\n for x in 1..l+1 {\n let prev = r[r.len() - 1].clone();\n r.push(prev + cache[l-x][cmp::min(x, l-x)].clone());\n }\n cache.push(r);\n }\n}\n\nfn row(n: usize, cache: &mut Vec>) -> Vec {\n cumu(n, cache);\n let r = &cache[n];\n let mut v: Vec = Vec::new();\n\n for i in 0..n {\n v.push(&r[i+1] - &r[i]);\n }\n v\n}\n\nfn main() {\n let mut cache = vec![vec![BigUint::from(1u32)]];\n\n println!(\"rows:\");\n for x in 1..26 {\n let v: Vec = row(x, &mut cache).iter().map(|e| e.to_string()).collect();\n let s: String = v.join(\" \");\n println!(\"{}: {}\", x, s);\n }\n\n println!(\"sums:\");\n for x in vec![23, 123, 1234, 12345] {\n cumu(x, &mut cache);\n let v = &cache[x];\n let s = v[v.len() - 1].to_string();\n println!(\"{}: {}\", x, s);\n }\n}\n"} {"name":"99 bottles of beer","C":"const bottle = \" bottle\"\nconst plural = \"s\"\nconst ofbeer = \" of beer\"\nconst wall = \" on the wall\"\nconst sep = \", \"\nconst takedown = \"Take one down and pass it around, \"\nconst u_no = \"No\"\nconst l_no = \"no\"\nconst more = \" more bottles of beer\"\nconst store = \"Go to the store and buy some more, \"\nconst dotnl = \".\\n\"\nconst nl = \"\\n\"\n\n\nvar x 1024\n\n\nfun printnum\n b = a\n a >= 10\n a \/= 10\n \n b = d\n a += 48 \n print(chr(a))\n end\n a = b\n a += 48 \n print(chr(a))\nend\n\nfun main\n loop 99\n \n c -> stack\n c -> stack\n\n \n a = c\n printnum()\n\n \n x = bottle\n x += plural\n x += ofbeer\n x += wall\n x += sep\n print(x)\n\n \n stack -> a\n printnum()\n\n \n x = bottle\n x += plural\n x += ofbeer\n x += dotnl\n x += takedown\n print(x)\n\n \n stack -> a\n a--\n\n \n a -> stack\n printnum()\n print(bottle)\n\n \n stack -> a\n\n \n a != 1\n print(plural)\n end\n\n \n x = ofbeer\n x += wall\n x += dotnl\n x += nl\n print(x)\n\n \n continue (c >= 2)\n\n \n\n \n a = 1\n printnum()\n x = bottle\n x += ofbeer\n x += wall\n x += sep\n print(x)\n\n \n a = 1\n printnum()\n\n \n \n \n \n \n \n x = bottle\n x += ofbeer\n x += dotnl\n x += takedown\n x += l_no\n x += more\n x += wall\n x += dotnl\n x += nl\n x += u_no\n x += more\n x += wall\n x += sep\n x += l_no\n x += more\n x += dotnl\n x += store\n print(x)\n\n \n a = 99\n printnum()\n\n \n x = bottle\n x += plural\n x += ofbeer\n x += wall\n x += dotnl\n print(x)\n end\nend\n\n\n","Rust":"fn main() {\n\tfor n in (0..100).rev() {\n\t\tmatch n {\n\t\t\t0 => {\n\t\t\t\tprintln!(\"No more bottles of beer on the wall, no more bottles of beer.\");\n\t\t\t\tprintln!(\"Go to the store and buy some more, 99 bottles of beer on the wall.\");\n\t\t\t},\n\t\t\t1 => {\n\t\t\t\tprintln!(\"1 bottle of beer on the wall, 1 bottle of beer.\");\n\t\t\t\tprintln!(\"Take one down and pass it around, no more bottles of beer on the wall.\\n\");\n\t\t\t},\n\t\t\t_ => {\n\t\t\t\tprintln!(\"{0:?} bottles of beer on the wall, {0:?} bottles of beer.\", n);\n\t\t\t\tprintln!(\"Take one down and pass it around, {} bottles of beer on the wall.\\n\", n-1);\n\t\t\t},\n\t\t}\n\t}\n}\n"} {"name":"A+B","C":"\n#include \nint main()\n{\n int a, b;\n scanf(\"%d%d\", &a, &b);\n printf(\"%d\\n\", a + b);\n return 0;\n}\n","Rust":"use std::io;\n\nfn main() {\n let mut line = String::new();\n io::stdin().read_line(&mut line).expect(\"reading stdin\");\n\n let mut i: i64 = 0;\n for word in line.split_whitespace() {\n i += word.parse::().expect(\"trying to interpret your input as numbers\");\n }\n println!(\"{}\", i);\n}\n"} {"name":"ABC problem","C":"#include \n#include \n\nint can_make_words(char **b, char *word)\n{\n\tint i, ret = 0, c = toupper(*word);\n\n#define SWAP(a, b) if (a\u00a0!= b) { char * tmp = a; a = b; b = tmp; }\n\n\tif (!c) return 1;\n\tif (!b[0]) return 0;\n\n\tfor (i = 0; b[i] && !ret; i++) {\n\t\tif (b[i][0] != c && b[i][1] != c) continue;\n\t\tSWAP(b[i], b[0]);\n\t\tret = can_make_words(b + 1, word + 1);\n\t\tSWAP(b[i], b[0]);\n\t}\n\n\treturn ret;\n}\n\nint main(void)\n{\n\tchar* blocks[] = {\n\t\t\"BO\", \"XK\", \"DQ\", \"CP\", \"NA\", \n\t\t\"GT\", \"RE\", \"TG\", \"QD\", \"FS\", \n\t\t\"JW\", \"HU\", \"VI\", \"AN\", \"OB\", \n\t\t\"ER\", \"FS\", \"LY\", \"PC\", \"ZM\",\n\t\t0 };\n\n\tchar *words[] = {\n\t\t\"\", \"A\", \"BARK\", \"BOOK\", \"TREAT\", \"COMMON\", \"SQUAD\", \"Confuse\", 0\n\t};\n\n\tchar **w;\n\tfor (w = words; *w; w++)\n\t\tprintf(\"%s\\t%d\\n\", *w, can_make_words(blocks, *w));\n\n\treturn 0;\n}\n","Rust":"use std::iter::repeat;\n\nfn rec_can_make_word(index: usize, word: &str, blocks: &[&str], used: &mut[bool]) -> bool {\n let c = word.chars().nth(index).unwrap().to_uppercase().next().unwrap();\n for i in 0..blocks.len() {\n if !used[i] && blocks[i].chars().any(|s| s == c) {\n used[i] = true;\n if index == 0 || rec_can_make_word(index - 1, word, blocks, used) {\n return true;\n }\n used[i] = false;\n }\n }\n false\n}\n\nfn can_make_word(word: &str, blocks: &[&str]) -> bool {\n return rec_can_make_word(word.chars().count() - 1, word, blocks, \n &mut repeat(false).take(blocks.len()).collect::>());\n}\n\nfn main() {\n let blocks = [(\"BO\"), (\"XK\"), (\"DQ\"), (\"CP\"), (\"NA\"), (\"GT\"), (\"RE\"), (\"TG\"), (\"QD\"), (\"FS\"), \n (\"JW\"), (\"HU\"), (\"VI\"), (\"AN\"), (\"OB\"), (\"ER\"), (\"FS\"), (\"LY\"), (\"PC\"), (\"ZM\")];\n let words = [\"A\", \"BARK\", \"BOOK\", \"TREAT\", \"COMMON\", \"SQUAD\", \"CONFUSE\"];\n for word in &words {\n println!(\"{} -> {}\", word, can_make_word(word, &blocks))\n }\n}\n"} {"name":"AKS test for primes","C":"#include \n#include \n\nlong long c[100];\n\nvoid coef(int n)\n{\n\tint i, j;\n\n\tif (n < 0 || n > 63) abort(); \n\n\tfor (c[i=0] = 1; i < n; c[0] = -c[0], i++)\n\t\tfor (c[1 + (j=i)] = 1; j > 0; j--)\n\t\t\tc[j] = c[j-1] - c[j];\n}\n\nint is_prime(int n)\n{\n\tint i;\n\n\tcoef(n);\n\tc[0] += 1, c[i=n] -= 1;\n\twhile (i-- && !(c[i] % n));\n\n\treturn i < 0;\n}\n\nvoid show(int n)\n{\n\tdo printf(\"%+lldx^%d\", c[n], n); while (n--);\n}\n\nint main(void)\n{\n\tint n;\n\n\tfor (n = 0; n < 10; n++) {\n\t\tcoef(n);\n\t\tprintf(\"(x-1)^%d = \", n);\n\t\tshow(n);\n\t\tputchar('\\n');\n\t}\n\n\tprintf(\"\\nprimes (never mind the 1):\");\n\tfor (n = 1; n <= 63; n++)\n\t\tif (is_prime(n))\n\t\t\tprintf(\" %d\", n);\n\n\tputchar('\\n');\n\treturn 0;\n}\n","Rust":"fn aks_coefficients(k: usize) -> Vec {\n let mut coefficients = vec![0i64; k + 1];\n coefficients[0] = 1;\n for i in 1..(k + 1) {\n coefficients[i] = -(1..i).fold(coefficients[0], |prev, j|{\n let old = coefficients[j];\n coefficients[j] = old - prev;\n old\n });\n }\n coefficients\n}\n\nfn is_prime(p: usize) -> bool {\n if p < 2 {\n false\n } else {\n let c = aks_coefficients(p);\n (1..p \/ 2 + 1).all(|i| c[i] % p as i64 == 0)\n }\n}\n\nfn main() {\n for i in 0..8 {\n println!(\"{}: {:?}\", i, aks_coefficients(i));\n }\n for i in (1..=50).filter(|&i| is_prime(i)) {\n print!(\"{} \", i);\n }\n}\n"} {"name":"Abstract type","C":"#ifndef INTERFACE_ABS\n#define INTERFACE_ABS\n\ntypedef struct sAbstractCls *AbsCls;\n\ntypedef struct sAbstractMethods {\n int (*method1)(AbsCls c, int a);\n const char *(*method2)(AbsCls c, int b);\n void (*method3)(AbsCls c, double d);\n} *AbstractMethods, sAbsMethods;\n\nstruct sAbstractCls {\n AbstractMethods klass;\n void *instData;\n};\n\n#define ABSTRACT_METHODS( cName, m1, m2, m3 ) \\\n static sAbsMethods cName ## _Iface = { &m1, &m2, &m3 }; \\\n AbsCls cName ## _Instance( void *clInst) { \\\n AbsCls ac = malloc(sizeof(struct sAbstractCls)); \\\n if (ac) { \\\n ac->klass = &cName ## _Iface; \\\n ac->instData = clInst; \\\n }\\\n return ac; }\n\n#define Abs_Method1( c, a) (c)->klass->method1(c, a)\n#define Abs_Method2( c, b) (c)->klass->method2(c, b)\n#define Abs_Method3( c, d) (c)->klass->method3(c, d)\n#define Abs_Free(c) \\\n do { if (c) { free((c)->instData); free(c); } } while(0);\n \n#endif\n","Rust":"trait Shape {\n fn area(self) -> i32;\n}\n"} {"name":"Abundant odd numbers","C":"#include \n#include \n\n\n\nunsigned sum_proper_divisors(const unsigned n) {\n unsigned sum = 1;\n for (unsigned i = 3, j; i < sqrt(n)+1; i += 2) if (n % i == 0) sum += i + (i == (j = n \/ i) ? 0 : j);\n return sum;\n}\n\nint main(int argc, char const *argv[]) {\n unsigned n, c;\n for (n = 1, c = 0; c < 25; n += 2) if (n < sum_proper_divisors(n)) printf(\"%u: %u\\n\", ++c, n);\n\n for ( ; c < 1000; n += 2) if (n < sum_proper_divisors(n)) c ++;\n printf(\"\\nThe one thousandth abundant odd number is: %u\\n\", n);\n\n for (n = 1000000001 ;; n += 2) if (n < sum_proper_divisors(n)) break;\n printf(\"The first abundant odd number above one billion is: %u\\n\", n);\n \n return 0;\n}\n","Rust":"fn divisors(n: u64) -> Vec {\n let mut divs = vec![1];\n let mut divs2 = Vec::new();\n\n for i in (2..).take_while(|x| x * x <= n).filter(|x| n % x == 0) {\n divs.push(i);\n let j = n \/ i;\n if i != j {\n divs2.push(j);\n }\n }\n divs.extend(divs2.iter().rev());\n\n divs\n}\n\nfn sum_string(v: Vec) -> String {\n v[1..]\n .iter()\n .fold(format!(\"{}\", v[0]), |s, i| format!(\"{} + {}\", s, i))\n}\n\nfn abundant_odd(search_from: u64, count_from: u64, count_to: u64, print_one: bool) -> u64 {\n let mut count = count_from;\n for n in (search_from..).step_by(2) {\n let divs = divisors(n);\n let total: u64 = divs.iter().sum();\n if total > n {\n count += 1;\n let s = sum_string(divs);\n if !print_one {\n println!(\"{}. {} < {} = {}\", count, n, s, total);\n } else if count == count_to {\n println!(\"{} < {} = {}\", n, s, total);\n }\n }\n if count == count_to {\n break;\n }\n }\n count_to\n}\n\nfn main() {\n let max = 25;\n println!(\"The first {} abundant odd numbers are:\", max);\n let n = abundant_odd(1, 0, max, false);\n\n println!(\"The one thousandth abundant odd number is:\");\n abundant_odd(n, 25, 1000, true);\n\n println!(\"The first abundant odd number above one billion is:\");\n abundant_odd(1e9 as u64 + 1, 0, 1, true);\n}\n"} {"name":"Abundant, deficient and perfect number classifications","C":"#include\n#define de 0\n#define pe 1\n#define ab 2\n\nint main(){\n\tint sum = 0, i, j;\n\tint try_max = 0;\n\t\n\tint count_list[3] = {1,0,0};\n\tfor(i=2; i <= 20000; i++){\n\t\t\n\t\ttry_max = i\/2;\n\t\t\n\t\tsum = 1;\n\t\tfor(j=2; j i){\n\t\t\tcount_list[ab]++;\n\t\t\tcontinue;\n\t\t}\n\t\tcount_list[pe]++;\n\t}\n\tprintf(\"\\nThere are %d deficient,\" ,count_list[de]);\n\tprintf(\" %d perfect,\" ,count_list[pe]);\n\tprintf(\" %d abundant numbers between 1 and 20000.\\n\" ,count_list[ab]);\nreturn 0;\n}\n","Rust":"fn main() {\n \n \n let (mut abundant, mut deficient, mut perfect) = (0u32, 1u32, 0u32);\n for i in 1..20_001 {\n if let Some(divisors) = i.proper_divisors() {\n let sum: u64 = divisors.iter().sum();\n if sum < i {\n deficient += 1\n } else if sum > i {\n abundant += 1\n } else {\n perfect += 1\n }\n }\n }\n println!(\"deficient:\\t{:5}\\nperfect:\\t{:5}\\nabundant:\\t{:5}\",\n deficient, perfect, abundant);\n}\n"} {"name":"Accumulator factory","C":"#include \n\n#define ACCUMULATOR(name,n) __typeof__(n) name (__typeof__(n) i) { \\\n static __typeof__(n) _n=n; LOGIC; }\n\n#define LOGIC return _n+=i\nACCUMULATOR(x,1.0)\nACCUMULATOR(y,3)\nACCUMULATOR(z,'a')\n#undef LOGIC\nint main (void) {\n printf (\"%f\\n\", x(5)); \n printf (\"%f\\n\", x(2.3)); \n printf (\"%i\\n\", y(5.0)); \n printf (\"%i\\n\", y(3.3)); \n printf (\"%c\\n\", z(5)); \n return 0;\n}\n","Rust":"\n\nuse std::ops::Add;\n\nfn foo(n: Num) -> impl FnMut(Num) -> Num\n where Num: Add + Copy + 'static {\n let mut acc = n;\n move |i: Num| {\n acc = acc + i;\n acc\n }\n}\n\nfn main() {\n let mut x = foo(1.);\n x(5.);\n foo(3.);\n println!(\"{}\", x(2.3));\n}\n"} {"name":"Ackermann function","C":"#include \n\nint ackermann(int m, int n)\n{\n if (!m) return n + 1;\n if (!n) return ackermann(m - 1, 1);\n return ackermann(m - 1, ackermann(m, n - 1));\n}\n\nint main()\n{\n int m, n;\n for (m = 0; m <= 4; m++)\n for (n = 0; n < 6 - m; n++)\n printf(\"A(%d, %d) = %d\\n\", m, n, ackermann(m, n));\n\n return 0;\n}\n","Rust":"fn ack(m: isize, n: isize) -> isize {\n if m == 0 {\n n + 1\n } else if n == 0 {\n ack(m - 1, 1)\n } else {\n ack(m - 1, ack(m, n - 1))\n }\n}\n\nfn main() {\n let a = ack(3, 4);\n println!(\"{}\", a); \n}\n"} {"name":"Active object","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n\ntypedef struct {\n\tdouble (*func)(double);\n\tstruct timeval start;\n\tdouble v, last_v, last_t;\n\tpthread_t id;\n} integ_t, *integ;\n\nvoid update(integ x)\n{\n\tstruct timeval tv;\n\tdouble t, v, (*f)(double);\n\n\tf = x->func;\n\tgettimeofday(&tv, 0);\n\tt = ((tv.tv_sec - x->start.tv_sec) * 1000000\n\t\t+ tv.tv_usec - x->start.tv_usec) * 1e-6;\n\tv = f ? f(t) : 0;\n\tx->v += (x->last_v + v) * (t - x->last_t) \/ 2;\n\tx->last_t = t;\n}\n\nvoid* tick(void *a)\n{\n\tinteg x = a;\n\twhile (1) {\n\t\tusleep(100000); \n\t\tupdate(x);\n\t}\n}\n\nvoid set_input(integ x, double (*func)(double))\n{\n\tupdate(x);\n\tx->func = func;\n\tx->last_t = 0;\n\tx->last_v = func ? func(0) : 0;\n}\n\ninteg new_integ(double (*func)(double))\n{\n\tinteg x = malloc(sizeof(integ_t));\n\tx->v = x->last_v = 0;\n\tx->func = 0;\n\tgettimeofday(&x->start, 0);\n\tset_input(x, func);\n\tpthread_create(&x->id, 0, tick, x);\n\treturn x;\n}\n\ndouble sine(double t) { return sin(4 * atan2(1, 1) * t); }\n\nint main()\n{\n\tinteg x = new_integ(sine);\n\tsleep(2);\n\tset_input(x, 0);\n\tusleep(500000);\n\tprintf(\"%g\\n\", x->v);\n\n\treturn 0;\n}\n","Rust":"#![feature(mpsc_select)]\n\nextern crate num;\nextern crate schedule_recv;\n\nuse num::traits::Zero;\nuse num::Float;\nuse schedule_recv::periodic_ms;\nuse std::f64::consts::PI;\nuse std::ops::Mul;\nuse std::sync::mpsc::{self, SendError, Sender};\nuse std::sync::{Arc, Mutex};\nuse std::thread;\nuse std::time::Duration;\n\npub type Actor = Sender S + Send>>;\npub type ActorResult = Result<(), SendError S + Send>>>;\n\n\n\n\n\n\n\n\n\n\npub struct Integrator {\n input: Actor,\n output: Arc>,\n}\n\n\n\n\n\n\n\n\nimpl Integrator\nwhere\n S: Mul + Float + Zero,\n T: 'static + Clone + Send + Float,\n{\n pub fn new(frequency: u32) -> Integrator {\n \n \n \n let (tx, input) = mpsc::channel();\n \n \n \n \n \n let s: Arc> = Arc::new(Mutex::new(Zero::zero()));\n let integrator = Integrator {\n input: tx,\n \n \n \n output: Arc::clone(&s),\n };\n thread::spawn(move || -> () {\n \n \n \n \n \n let periodic = periodic_ms(frequency);\n let mut t = 0;\n let mut k: Box S + Send> = Box::new(|_| Zero::zero());\n let mut k_0: S = Zero::zero();\n loop {\n \n \n \n \n \n \n \n select! {\n res = periodic.recv() => match res {\n Ok(_) => {\n t += frequency;\n let k_1: S = k(t);\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n let mut s = s.lock().unwrap();\n *s = *s + (k_1 + k_0) * (f64::from(frequency) \/ 2.);\n k_0 = k_1;\n }\n Err(_) => break,\n },\n res = input.recv() => match res {\n Ok(k_new) => k = k_new,\n Err(_) => break,\n }\n }\n }\n });\n integrator\n }\n\n pub fn input(&self, k: Box S + Send>) -> ActorResult {\n \n \n self.input.send(k)\n }\n\n pub fn output(&self) -> T {\n \n \n \n \n \n *self.output.lock().unwrap()\n }\n}\n\n\n\nfn integrate() -> f64 {\n let object = Integrator::new(10);\n object\n .input(Box::new(|t: u32| {\n let two_seconds_ms = 2 * 1000;\n let f = 1. \/ f64::from(two_seconds_ms);\n (2. * PI * f * f64::from(t)).sin()\n }))\n .expect(\"Failed to set input\");\n thread::sleep(Duration::from_secs(2));\n object.input(Box::new(|_| 0.)).expect(\"Failed to set input\");\n thread::sleep(Duration::from_millis(500));\n object.output()\n}\n\nfn main() {\n println!(\"{}\", integrate());\n}\n\n\n#[test]\n#[ignore]\nfn solution() {\n \n \n \n let object = Integrator::new(10);\n object\n .input(Box::new(|t: u32| {\n let two_seconds_ms = 2 * 1000;\n let f = 1. \/ (two_seconds_ms \/ 10) as f64;\n (2. * PI * f * t as f64).sin()\n }))\n .expect(\"Failed to set input\");\n thread::sleep(Duration::from_millis(200));\n object.input(Box::new(|_| 0.)).expect(\"Failed to set input\");\n thread::sleep(Duration::from_millis(100));\n assert_eq!(object.output() as u32, 0)\n}\n"} {"name":"Almost prime","C":"#include \n\nint kprime(int n, int k)\n{\n\tint p, f = 0;\n\tfor (p = 2; f < k && p*p <= n; p++)\n\t\twhile (0 == n % p)\n\t\t\tn \/= p, f++;\n\n\treturn f + (n > 1) == k;\n}\n\nint main(void)\n{\n\tint i, c, k;\n\n\tfor (k = 1; k <= 5; k++) {\n\t\tprintf(\"k = %d:\", k);\n\n\t\tfor (i = 2, c = 0; c < 10; i++)\n\t\t\tif (kprime(i, k)) {\n\t\t\t\tprintf(\" %d\", i);\n\t\t\t\tc++;\n\t\t\t}\n\n\t\tputchar('\\n');\n\t}\n\n\treturn 0;\n}\n","Rust":"fn is_kprime(n: u32, k: u32) -> bool {\n let mut primes = 0;\n let mut f = 2;\n let mut rem = n;\n while primes < k && rem > 1{\n while (rem % f) == 0 && rem > 1{\n rem \/= f;\n primes += 1;\n }\n f += 1;\n }\n rem == 1 && primes == k\n}\n\nstruct KPrimeGen {\n k: u32,\n n: u32,\n}\n\nimpl Iterator for KPrimeGen {\n type Item = u32;\n fn next(&mut self) -> Option {\n self.n += 1;\n while !is_kprime(self.n, self.k) {\n self.n += 1;\n }\n Some(self.n)\n }\n}\n\nfn kprime_generator(k: u32) -> KPrimeGen {\n KPrimeGen {k: k, n: 1}\n}\n\nfn main() {\n for k in 1..6 {\n println!(\"{}: {:?}\", k, kprime_generator(k).take(10).collect::>());\n }\n}\n"} {"name":"Amb","C":"typedef const char * amb_t;\n\namb_t amb(size_t argc, ...)\n{\n amb_t *choices;\n va_list ap;\n int i;\n \n if(argc) {\n choices = malloc(argc*sizeof(amb_t));\n va_start(ap, argc);\n i = 0;\n do { choices[i] = va_arg(ap, amb_t); } while(++i < argc);\n va_end(ap);\n \n i = 0;\n do { TRY(choices[i]); } while(++i < argc);\n free(choices);\n }\n \n FAIL;\n}\n\nint joins(const char *left, const char *right) { return left[strlen(left)-1] == right[0]; }\n\nint _main() {\n const char *w1,*w2,*w3,*w4;\n \n w1 = amb(3, \"the\", \"that\", \"a\");\n w2 = amb(3, \"frog\", \"elephant\", \"thing\");\n w3 = amb(3, \"walked\", \"treaded\", \"grows\");\n w4 = amb(2, \"slowly\", \"quickly\");\n \n if(!joins(w1, w2)) amb(0);\n if(!joins(w2, w3)) amb(0);\n if(!joins(w3, w4)) amb(0);\n \n printf(\"%s %s %s %s\\n\", w1, w2, w3, w4);\n \n return EXIT_SUCCESS;\n}\n","Rust":"use std::ops::Add;\nstruct Amb<'a> {\n list: Vec>,\n}\nfn main() {\n let amb = Amb {\n list: vec![\n vec![\"the\", \"that\", \"a\"],\n vec![\"frog\", \"elephant\", \"thing\"],\n vec![\"walked\", \"treaded\", \"grows\"],\n vec![\"slowly\", \"quickly\"],\n ],\n };\n match amb.do_amb(0, 0 as char) {\n Some(text) => println!(\"{}\", text),\n None => println!(\"Nothing found\"),\n }\n}\nimpl<'a> Amb<'a> {\n fn do_amb(&self, level: usize, last_char: char) -> Option {\n if self.list.is_empty() {\n panic!(\"No word list\");\n }\n if self.list.len() <= level {\n return Some(String::new());\n }\n let mut res = String::new();\n let word_list = &self.list[level];\n for word in word_list {\n if word.chars().next().unwrap() == last_char || last_char == 0 as char {\n res = res.add(word).add(\" \");\n let answ = self.do_amb(level + 1, word.chars().last().unwrap());\n match answ {\n Some(x) => {\n res = res.add(&x);\n return Some(res);\n }\n None => res.clear(),\n }\n }\n }\n None\n }\n}\n"} {"name":"Amicable pairs","C":"#include \n#include \n\ntypedef unsigned int uint;\n\nint main(int argc, char **argv)\n{\n uint top = atoi(argv[1]);\n uint *divsum = malloc((top + 1) * sizeof(*divsum));\n uint pows[32] = {1, 0};\n\n for (uint i = 0; i <= top; i++) divsum[i] = 1;\n\n \n \n for (uint p = 2; p+p <= top; p++) {\n if (divsum[p] > 1) {\n divsum[p] -= p;\n continue;} \n\n uint x; \n \n for (x = 1; pows[x - 1] <= top\/p; x++)\n pows[x] = p*pows[x - 1];\n\n \n \n \n uint k= p-1;\n for (uint n = p+p; n <= top; n += p) {\n uint s=1+pows[1];\n k--;\n \n if ( k==0) {\n for (uint i = 2; i < x && !(n%pows[i]); s += pows[i++]);\n k = p; }\n divsum[n] *= s;\n }\n }\n\n \n for (uint p = (top >> 1)+1; p <= top; p++) {\n if (divsum[p] > 1){\n divsum[p] -= p;}\n }\n\n uint cnt = 0;\n for (uint a = 1; a <= top; a++) {\n uint b = divsum[a];\n if (b > a && b <= top && divsum[b] == a){\n printf(\"%u %u\\n\", a, b);\n cnt++;}\n }\n printf(\"\\nTop %u count\u00a0: %u\\n\",top,cnt);\n return 0;\n}\n","Rust":"fn sum_of_divisors(val: u32) -> u32 {\n (1..val\/2+1).filter(|n| val % n == 0)\n .fold(0, |sum, n| sum + n)\n}\n\nfn main() {\n let iter = (1..20_000).map(|i| (i, sum_of_divisors(i)))\n .filter(|&(i, div_sum)| i > div_sum);\n\n for (i, sum1) in iter {\n if sum_of_divisors(sum1) == i {\n println!(\"{} {}\", i, sum1);\n }\n }\n}\n"} {"name":"Anagrams","C":"#include \n#include \n#include \n#include \n#include \n\nchar *sortedWord(const char *word, char *wbuf)\n{\n char *p1, *p2, *endwrd;\n char t;\n int swaps;\n\n strcpy(wbuf, word);\n endwrd = wbuf+strlen(wbuf);\n do {\n swaps = 0;\n p1 = wbuf; p2 = endwrd-1;\n while (p1 *p1) {\n t = *p2; *p2 = *p1; *p1 = t;\n swaps = 1;\n }\n p1++; p2--;\n }\n p1 = wbuf; p2 = p1+1;\n while(p2 < endwrd) {\n if (*p2 > *p1) {\n t = *p2; *p2 = *p1; *p1 = t;\n swaps = 1;\n }\n p1++; p2++;\n }\n } while (swaps);\n return wbuf;\n}\n\nstatic\nshort cxmap[] = {\n 0x06, 0x1f, 0x4d, 0x0c, 0x5c, 0x28, 0x5d, 0x0e, 0x09, 0x33, 0x31, 0x56,\n 0x52, 0x19, 0x29, 0x53, 0x32, 0x48, 0x35, 0x55, 0x5e, 0x14, 0x27, 0x24,\n 0x02, 0x3e, 0x18, 0x4a, 0x3f, 0x4c, 0x45, 0x30, 0x08, 0x2c, 0x1a, 0x03,\n 0x0b, 0x0d, 0x4f, 0x07, 0x20, 0x1d, 0x51, 0x3b, 0x11, 0x58, 0x00, 0x49,\n 0x15, 0x2d, 0x41, 0x17, 0x5f, 0x39, 0x16, 0x42, 0x37, 0x22, 0x1c, 0x0f,\n 0x43, 0x5b, 0x46, 0x4b, 0x0a, 0x26, 0x2e, 0x40, 0x12, 0x21, 0x3c, 0x36,\n 0x38, 0x1e, 0x01, 0x1b, 0x05, 0x4e, 0x44, 0x3d, 0x04, 0x10, 0x5a, 0x2a,\n 0x23, 0x34, 0x25, 0x2f, 0x2b, 0x50, 0x3a, 0x54, 0x47, 0x59, 0x13, 0x57,\n };\n#define CXMAP_SIZE (sizeof(cxmap)\/sizeof(short))\n\n\nint Str_Hash( const char *key, int ix_max )\n{\n const char *cp;\n short mash;\n int hash = 33501551;\n for (cp = key; *cp; cp++) {\n mash = cxmap[*cp % CXMAP_SIZE];\n hash = (hash >>4) ^ 0x5C5CF5C ^ ((hash<<1) + (mash<<5));\n hash &= 0x3FFFFFFF;\n }\n return hash % ix_max;\n}\n\ntypedef struct sDictWord *DictWord;\nstruct sDictWord {\n const char *word;\n DictWord next;\n};\n\ntypedef struct sHashEntry *HashEntry;\nstruct sHashEntry {\n const char *key;\n HashEntry next;\n DictWord words;\n HashEntry link;\n short wordCount;\n};\n\n#define HT_SIZE 8192\n\nHashEntry hashTable[HT_SIZE];\n\nHashEntry mostPerms = NULL;\n\nint buildAnagrams( FILE *fin )\n{\n char buffer[40];\n char bufr2[40];\n char *hkey;\n int hix;\n HashEntry he, *hep;\n DictWord we;\n int maxPC = 2;\n int numWords = 0;\n \n while ( fgets(buffer, 40, fin)) {\n for(hkey = buffer; *hkey && (*hkey!='\\n'); hkey++);\n *hkey = 0;\n hkey = sortedWord(buffer, bufr2);\n hix = Str_Hash(hkey, HT_SIZE);\n he = hashTable[hix]; hep = &hashTable[hix];\n while( he && strcmp(he->key , hkey) ) {\n hep = &he->next;\n he = he->next;\n }\n if ( ! he ) {\n he = malloc(sizeof(struct sHashEntry));\n he->next = NULL;\n he->key = strdup(hkey);\n he->wordCount = 0;\n he->words = NULL;\n he->link = NULL;\n *hep = he;\n }\n we = malloc(sizeof(struct sDictWord));\n we->word = strdup(buffer);\n we->next = he->words;\n he->words = we;\n he->wordCount++;\n if ( maxPC < he->wordCount) {\n maxPC = he->wordCount;\n mostPerms = he;\n he->link = NULL;\n }\n else if (maxPC == he->wordCount) {\n he->link = mostPerms;\n mostPerms = he;\n }\n \n numWords++;\n }\n printf(\"%d words in dictionary max ana=%d\\n\", numWords, maxPC);\n return maxPC;\n}\n\n\nint main( ) \n{\n HashEntry he;\n DictWord we;\n FILE *f1;\n \n f1 = fopen(\"unixdict.txt\",\"r\");\n buildAnagrams(f1);\n fclose(f1);\n \n f1 = fopen(\"anaout.txt\",\"w\");\n\n\n for (he = mostPerms; he; he = he->link) {\n fprintf(f1,\"%d:\", he->wordCount);\n for(we = he->words; we; we = we->next) {\n fprintf(f1,\"%s, \", we->word);\n }\n fprintf(f1, \"\\n\");\n }\n\n fclose(f1);\n return 0;\n}\n","Rust":"use std::collections::HashMap;\nuse std::fs::File;\nuse std::io::{BufRead,BufReader};\nuse std::borrow::ToOwned;\n\nextern crate unicode_segmentation;\nuse unicode_segmentation::{UnicodeSegmentation};\n\nfn main () {\n let file = BufReader::new(File::open(\"unixdict.txt\").unwrap());\n let mut map = HashMap::new();\n for line in file.lines() {\n let s = line.unwrap();\n \n \n let mut sorted = s.trim().graphemes(true).map(ToOwned::to_owned).collect::>();\n sorted.sort();\n\n map.entry(sorted).or_insert_with(Vec::new).push(s);\n }\n\n if let Some(max_len) = map.values().map(|v| v.len()).max() {\n for anagram in map.values().filter(|v| v.len() == max_len) {\n for word in anagram {\n print!(\"{} \", word);\n }\n println!();\n }\n }\n}\n"} {"name":"Anagrams_Deranged anagrams","C":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nconst char *freq = \"zqxjkvbpygfwmucldrhsnioate\";\nint char_to_idx[128];\n\n\nstruct word {\n\tconst char *w;\n\tstruct word *next;\n};\n\nunion node {\n\tunion node *down[10];\n\tstruct word *list[10];\n};\n\nint deranged(const char *s1, const char *s2)\n{\n\tint i;\n\tfor (i = 0; s1[i]; i++)\n\t\tif (s1[i] == s2[i]) return 0;\n\treturn 1;\n}\n\nint count_letters(const char *s, unsigned char *c)\n{\n\tint i, len;\n\tmemset(c, 0, 26);\n\tfor (len = i = 0; s[i]; i++) {\n\t\tif (s[i] < 'a' || s[i] > 'z')\n\t\t\treturn 0;\n\t\tlen++, c[char_to_idx[(unsigned char)s[i]]]++;\n\t}\n\treturn len;\n}\n\nconst char * insert(union node *root, const char *s, unsigned char *cnt)\n{\n\tint i;\n\tunion node *n;\n\tstruct word *v, *w = 0;\n\n\tfor (i = 0; i < 25; i++, root = n) {\n\t\tif (!(n = root->down[cnt[i]]))\n\t\t\troot->down[cnt[i]] = n = calloc(1, sizeof(union node));\n\t}\n\n\tw = malloc(sizeof(struct word));\n\tw->w = s;\n\tw->next = root->list[cnt[25]];\n\troot->list[cnt[25]] = w;\n\n\tfor (v = w->next; v; v = v->next) {\n\t\tif (deranged(w->w, v->w))\n\t\t\treturn v->w;\n\t}\n\treturn 0;\n}\n\nint main(int c, char **v)\n{\n\tint i, j = 0;\n\tchar *words;\n\tstruct stat st;\n\n\tint fd = open(c < 2 ? \"unixdict.txt\" : v[1], O_RDONLY);\n\tif (fstat(fd, &st) < 0) return 1;\n\n\twords = malloc(st.st_size);\n\tread(fd, words, st.st_size);\n\tclose(fd);\n\n\tunion node root = {{0}};\n\tunsigned char cnt[26];\n\tint best_len = 0;\n\tconst char *b1, *b2;\n\n\tfor (i = 0; freq[i]; i++)\n\t\tchar_to_idx[(unsigned char)freq[i]] = i;\n\n\t\n\tfor (i = j = 0; i < st.st_size; i++) {\n\t\tif (words[i] != '\\n') continue;\n\t\twords[i] = '\\0';\n\n\t\tif (i - j > best_len) {\n\t\t\tcount_letters(words + j, cnt);\n\t\t\tconst char *match = insert(&root, words + j, cnt);\n\n\t\t\tif (match) {\n\t\t\t\tbest_len = i - j;\n\t\t\t\tb1 = words + j;\n\t\t\t\tb2 = match;\n\t\t\t}\n\t\t}\n\n\t\tj = ++i;\n\t}\n\n\tif (best_len) printf(\"longest derangement: %s %s\\n\", b1, b2);\n\n\treturn 0;\n}\n","Rust":"\nuse std::cmp::Ordering;\nuse std::collections::HashMap;\nuse std::fs::File;\nuse std::io;\nuse std::io::BufReader;\nuse std::io::BufRead;\nuse std::usize::MAX;\n\n\npub fn get_words() -> Result, io::Error> {\n let mut words = vec!();\n \n let f = File::open(\"data\/unixdict.txt\")?;\n \n let reader = BufReader::new(&f);\n for line in reader.lines() {\n words.push(line?)\n }\n Ok(words)\n}\n\n\npub fn longest_deranged(v: &mut Vec) -> Option<(String,String)>{\n \n v.sort_by(|s1, s2| {\n let mut c = s2.len().cmp(&s1.len());\n if c == Ordering::Equal {\n c = s1.cmp(s2);\n }\n c\n });\n \n let mut signatures : HashMap, Vec<&String>> = HashMap::new();\n \n let mut previous_length = MAX;\n for s in v {\n \n if s.len()>();\n sorted_chars.sort();\n let anagrams = signatures.entry(sorted_chars).or_insert(vec!());\n \n if let Some(a) = anagrams.iter().filter(|anagram| is_deranged(anagram, s)).next(){\n return Some(((*a).clone(), s.clone()));\n }\n anagrams.push(s);\n }\n None\n}\n\n\npub fn is_deranged(s1: &String, s2: &String) -> bool {\n \n s1.chars().zip(s2.chars()).filter(|(a,b)| a == b).next().is_none()\n}\n\n\nfn main() {\n let r = get_words();\n match r {\n Ok(mut v) => {\n let od = longest_deranged(&mut v);\n match od {\n None => println!(\"No deranged anagrams found!\"),\n Some((s1,s2)) => println!(\"{} {}\",s1,s2),\n }\n },\n Err(e) => panic!(\"Could not read words: {}\",e)\n } \n}\n"} {"name":"Angle difference between two bearings","C":"#include\n#include\n#include\n\nvoid processFile(char* name){\n\t\n\tint i,records;\n\tdouble diff,b1,b2;\n\tFILE* fp = fopen(name,\"r\");\n\t\n\tfscanf(fp,\"%d\\n\",&records);\n\t\n\tfor(i=0;i=180)?diff-360:diff));\t\n\t}\n\t\n\tfclose(fp);\n}\n\nint main(int argC,char* argV[])\n{\n\tdouble diff;\n\t\n\tif(argC < 2)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\telse if(argC == 2)\n\t\tprocessFile(argV[1]);\n\telse{\n\t\tdiff = fmod(atof(argV[2])-atof(argV[1]),360.0);\n\t\tprintf(\"Difference between b2(%s) and b1(%s) is %lf\",argV[2],argV[1],(diff<-180)?diff+360:((diff>=180)?diff-360:diff));\n\t}\n\n\treturn 0;\n}\n","Rust":"\npub fn angle_difference(bearing1: f64, bearing2: f64) -> f64 {\n let diff = (bearing2 - bearing1) % 360.0;\n if diff < -180.0 {\n 360.0 + diff\n } else if diff > 180.0 {\n -360.0 + diff\n } else {\n diff\n }\n\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_angle_difference() {\n assert_eq!(25.00, angle_difference(20.00, 45.00));\n assert_eq!(90.00, angle_difference(-45.00, 45.00));\n assert_eq!(175.00, angle_difference(-85.00, 90.00));\n assert_eq!(-175.00, angle_difference(-95.00, 90.00));\n assert_eq!(170.00, angle_difference(-45.00, 125.00));\n assert_eq!(-170.00, angle_difference(-45.00, 145.00));\n approx_eq(-118.1184, angle_difference(29.4803, -88.6381));\n approx_eq(-80.7109, angle_difference(-78.3251 , -159.036));\n approx_eq(-139.5832, angle_difference(-70099.74233810938, 29840.67437876723));\n approx_eq(-72.3439, angle_difference(-165313.6666297357, 33693.9894517456));\n approx_eq(-161.5029, angle_difference(1174.8380510598456, -154146.66490124757));\n approx_eq(37.2988, angle_difference(60175.77306795546, 42213.07192354373));\n }\n\n \n \n fn approx_eq(f1: f64, f2: f64) {\n assert!((f2-f1).abs() < 0.0001, \"{}\u00a0!= {}\", f1, f2)\n }\n}\n"} {"name":"Animate a pendulum","C":"#include \n#include \n#include \n#include \n#include \n\n#define length 5\n#define g 9.8\ndouble alpha, accl, omega = 0, E;\nstruct timeval tv;\n\ndouble elappsed() {\n\tstruct timeval now;\n\tgettimeofday(&now, 0);\n\tint ret = (now.tv_sec - tv.tv_sec) * 1000000\n\t\t+ now.tv_usec - tv.tv_usec;\n\ttv = now;\n\treturn ret \/ 1.e6;\n}\n\nvoid resize(int w, int h)\n{\n\tglViewport(0, 0, w, h);\n\tglMatrixMode(GL_PROJECTION);\n\tglLoadIdentity();\n\n\tglMatrixMode(GL_MODELVIEW);\n\tglLoadIdentity();\n\tglOrtho(0, w, h, 0, -1, 1);\n}\n\nvoid render()\n{\n\tdouble x = 320 + 300 * sin(alpha), y = 300 * cos(alpha);\n\tresize(640, 320);\n \tglClear(GL_COLOR_BUFFER_BIT);\n\n\tglBegin(GL_LINES);\n\tglVertex2d(320, 0);\n\tglVertex2d(x, y);\n\tglEnd();\n\tglFlush();\n\n\tdouble us = elappsed();\n\talpha += (omega + us * accl \/ 2) * us;\n\tomega += accl * us;\n\n\t\n\tif (length * g * (1 - cos(alpha)) >= E) {\n\t\talpha = (alpha < 0 ? -1 : 1) * acos(1 - E \/ length \/ g);\n\t\tomega = 0;\n\t}\n\taccl = -g \/ length * sin(alpha);\n}\n\nvoid init_gfx(int *c, char **v)\n{\n\tglutInit(c, v);\n\tglutInitDisplayMode(GLUT_RGB);\n\tglutInitWindowSize(640, 320);\n\tglutIdleFunc(render);\n\tglutCreateWindow(\"Pendulum\");\n}\n\nint main(int c, char **v)\n{\n\talpha = 4 * atan2(1, 1) \/ 2.1;\n\tE = length * g * (1 - cos(alpha));\n\n\taccl = -g \/ length * sin(alpha);\n\tomega = 0;\n\n\tgettimeofday(&tv, 0);\n\tinit_gfx(&c, v);\n\tglutMainLoop();\n\treturn 0;\n}\n","Rust":"\nuse piston_window::{clear, ellipse, line_from_to, PistonWindow, WindowSettings};\n\nconst PI: f64 = std::f64::consts::PI;\nconst WIDTH: u32 = 640;\nconst HEIGHT: u32 = 480;\n\nconst ANCHOR_X: f64 = WIDTH as f64 \/ 2. - 12.;\nconst ANCHOR_Y: f64 = HEIGHT as f64 \/ 4.;\nconst ANCHOR_ELLIPSE: [f64; 4] = [ANCHOR_X - 3., ANCHOR_Y - 3., 6., 6.];\n\nconst ROPE_ORIGIN: [f64; 2] = [ANCHOR_X, ANCHOR_Y];\nconst ROPE_LENGTH: f64 = 200.;\nconst ROPE_THICKNESS: f64 = 1.;\n\nconst DELTA: f64 = 0.05;\nconst STANDARD_GRAVITY_VALUE: f64 = -9.81;\n\n\nconst BLACK: [f32; 4] = [0., 0., 0., 1.];\nconst RED: [f32; 4] = [1., 0., 0., 1.];\nconst GOLD: [f32; 4] = [216. \/ 255., 204. \/ 255., 36. \/ 255., 1.0];\nfn main() {\n let mut window: PistonWindow = WindowSettings::new(\"Pendulum\", [WIDTH, HEIGHT])\n .exit_on_esc(true)\n .build()\n .unwrap();\n\n let mut angle = PI \/ 2.;\n let mut angular_vel = 0.;\n\n while let Some(event) = window.next() {\n let (angle_sin, angle_cos) = angle.sin_cos();\n let ball_x = ANCHOR_X + angle_sin * ROPE_LENGTH;\n let ball_y = ANCHOR_Y + angle_cos * ROPE_LENGTH;\n\n let angle_accel = STANDARD_GRAVITY_VALUE \/ ROPE_LENGTH * angle_sin;\n angular_vel += angle_accel * DELTA;\n angle += angular_vel * DELTA;\n let rope_end = [ball_x, ball_y];\n let ball_ellipse = [ball_x - 7., ball_y - 7., 14., 14.];\n\n window.draw_2d(&event, |context, graphics, _device| {\n clear([1.0; 4], graphics);\n line_from_to(\n BLACK,\n ROPE_THICKNESS,\n ROPE_ORIGIN,\n rope_end,\n context.transform,\n graphics,\n );\n ellipse(RED, ANCHOR_ELLIPSE, context.transform, graphics);\n ellipse(GOLD, ball_ellipse, context.transform, graphics);\n });\n }\n}\n"} {"name":"Animation","C":"#include \n#include \n#include \n\nconst gchar *hello = \"Hello World! \";\ngint direction = -1;\ngint cx=0;\ngint slen=0;\n\nGtkLabel *label;\n\nvoid change_dir(GtkLayout *o, gpointer d)\n{\n direction = -direction;\n}\n\ngchar *rotateby(const gchar *t, gint q, gint l)\n{\n gint i, cl = l, j;\n gchar *r = malloc(l+1);\n for(i=q, j=0; cl > 0; cl--, i = (i + 1)%l, j++)\n r[j] = t[i];\n r[l] = 0;\n return r;\n}\n\ngboolean scroll_it(gpointer data)\n{\n if ( direction > 0 )\n cx = (cx + 1) % slen;\n else\n cx = (cx + slen - 1 ) % slen;\n gchar *scrolled = rotateby(hello, cx, slen);\n gtk_label_set_text(label, scrolled);\n free(scrolled);\n return TRUE;\n}\n\n\nint main(int argc, char **argv)\n{\n GtkWidget *win;\n GtkButton *button;\n PangoFontDescription *pd;\n\n gtk_init(&argc, &argv);\n win = gtk_window_new(GTK_WINDOW_TOPLEVEL);\n gtk_window_set_title(GTK_WINDOW(win), \"Basic Animation\");\n g_signal_connect(G_OBJECT(win), \"delete-event\", gtk_main_quit, NULL);\n\n label = (GtkLabel *)gtk_label_new(hello);\n\n \n \n pd = pango_font_description_new();\n pango_font_description_set_family(pd, \"monospace\");\n gtk_widget_modify_font(GTK_WIDGET(label), pd);\n\n button = (GtkButton *)gtk_button_new();\n gtk_container_add(GTK_CONTAINER(button), GTK_WIDGET(label));\n\n gtk_container_add(GTK_CONTAINER(win), GTK_WIDGET(button));\n g_signal_connect(G_OBJECT(button), \"clicked\", G_CALLBACK(change_dir), NULL);\n\n slen = strlen(hello);\n\n g_timeout_add(125, scroll_it, NULL);\n \n gtk_widget_show_all(GTK_WIDGET(win));\n gtk_main();\n return 0;\n}\n","Rust":"#[cfg(feature = \"gtk\")]\nmod graphical {\n extern crate gtk;\n\n use self::gtk::traits::*;\n use self::gtk::{Inhibit, Window, WindowType};\n use std::ops::Not;\n use std::sync::{Arc, RwLock};\n\n pub fn create_window() {\n gtk::init().expect(\"Failed to initialize GTK\");\n\n let window = Window::new(WindowType::Toplevel);\n window.connect_delete_event(|_, _| {\n gtk::main_quit();\n Inhibit(false)\n });\n let button = gtk::Button::new_with_label(\"Hello World! \");\n window.add(&button);\n\n let lock = Arc::new(RwLock::new(false));\n\n let lock_button = lock.clone();\n button.connect_clicked(move |_| {\n let mut reverse = lock_button.write().unwrap();\n *reverse = reverse.not();\n });\n\n let lock_thread = lock.clone();\n gtk::timeout_add(100, move || {\n let reverse = lock_thread.read().unwrap();\n let mut text = button.get_label().unwrap();\n let len = &text.len();\n\n if *reverse {\n let begin = &text.split_off(1);\n text.insert_str(0, begin);\n } else {\n let end = &text.split_off(len - 1);\n text.insert_str(0, end);\n }\n\n button.set_label(&text);\n\n gtk::Continue(true)\n });\n\n window.show_all();\n gtk::main();\n }\n}\n\n\n#[cfg(feature = \"gtk\")]\nfn main() {\n graphical::create_window();\n}\n\n#[cfg(not(feature = \"gtk\"))]\nfn main() {}\n"} {"name":"Anonymous recursion","C":"#include \n\nlong fib(long x)\n{\n long fib_i(long n) { return n < 2 ? n : fib_i(n - 2) + fib_i(n - 1); };\n if (x < 0) {\n printf(\"Bad argument: fib(%ld)\\n\", x);\n return -1;\n }\n return fib_i(x);\n}\n\nlong fib_i(long n) \n{\n printf(\"This is not the fib you are looking for\\n\");\n return -1;\n}\n\nint main()\n{\n long x;\n for (x = -1; x < 4; x ++)\n printf(\"fib %ld = %ld\\n\", x, fib(x));\n\n printf(\"calling fib_i from outside fib:\\n\");\n fib_i(3);\n\n return 0;\n}\n","Rust":"fn fib(n: i64) -> Option {\n \n fn actual_fib(n: i64) -> i64 {\n if n < 2 {\n n\n } else {\n actual_fib(n - 1) + actual_fib(n - 2)\n }\n }\n\n if n < 0 {\n None\n } else {\n Some(actual_fib(n))\n }\n}\n\nfn main() {\n println!(\"Fib(-1) = {:?}\", fib(-1));\n println!(\"Fib(0) = {:?}\", fib(0));\n println!(\"Fib(1) = {:?}\", fib(1));\n println!(\"Fib(2) = {:?}\", fib(2));\n println!(\"Fib(3) = {:?}\", fib(3));\n println!(\"Fib(4) = {:?}\", fib(4));\n println!(\"Fib(5) = {:?}\", fib(5));\n println!(\"Fib(10) = {:?}\", fib(10));\n}\n\n#[test]\nfn test_fib() {\n assert_eq!(fib(0).unwrap(), 0);\n assert_eq!(fib(1).unwrap(), 1);\n assert_eq!(fib(2).unwrap(), 1);\n assert_eq!(fib(3).unwrap(), 2);\n assert_eq!(fib(4).unwrap(), 3);\n assert_eq!(fib(5).unwrap(), 5);\n assert_eq!(fib(10).unwrap(), 55);\n}\n\n#[test]\nfn test_invalid_argument() {\n assert_eq!(fib(-1), None);\n}\n"} {"name":"Anti-primes","C":"#include \n\nint countDivisors(int n) {\n int i, count;\n if (n < 2) return 1;\n count = 2; \n for (i = 2; i <= n\/2; ++i) {\n if (n%i == 0) ++count;\n }\n return count;\n}\n\nint main() {\n int n, d, maxDiv = 0, count = 0;\n printf(\"The first 20 anti-primes are:\\n\");\n for (n = 1; count < 20; ++n) {\n d = countDivisors(n); \n if (d > maxDiv) {\n printf(\"%d \", n);\n maxDiv = d;\n count++;\n }\n }\n printf(\"\\n\"); \n return 0;\n}\n","Rust":"fn count_divisors(n: u64) -> usize {\n if n < 2 {\n return 1;\n }\n 2 + (2..=(n \/ 2)).filter(|i| n % i == 0).count()\n}\n\nfn main() {\n println!(\"The first 20 anti-primes are:\");\n (1..)\n .scan(0, |max, n| {\n let d = count_divisors(n);\n Some(if d > *max {\n *max = d;\n Some(n)\n } else {\n None\n })\n })\n .flatten()\n .take(20)\n .for_each(|n| print!(\"{} \", n));\n println!();\n}\n"} {"name":"Append a record to the end of a text file","C":"#include \n#include \n\ntypedef const char *STRING;\ntypedef struct{STRING fullname, office, extension, homephone, email; } gecos_t;\ntypedef struct{STRING account, password; int uid, gid; gecos_t gecos; STRING directory, shell; } passwd_t;\n\n#define GECOS_FMT \"%s,%s,%s,%s,%s\"\n#define PASSWD_FMT \"%s:%s:%d:%d:\"GECOS_FMT\":%s:%s\"\n\npasswd_t passwd_list[]={\n {\"jsmith\", \"x\", 1001, 1000, \n {\"Joe Smith\", \"Room 1007\", \"(234)555-8917\", \"(234)555-0077\", \"jsmith@rosettacode.org\"},\n \"\/home\/jsmith\", \"\/bin\/bash\"},\n {\"jdoe\", \"x\", 1002, 1000,\n {\"Jane Doe\", \"Room 1004\", \"(234)555-8914\", \"(234)555-0044\", \"jdoe@rosettacode.org\"},\n \"\/home\/jdoe\", \"\/bin\/bash\"}\n};\n\nmain(){\n\n FILE *passwd_text=fopen(\"passwd.txt\", \"w\");\n int rec_num;\n for(rec_num=0; rec_num < sizeof passwd_list\/sizeof(passwd_t); rec_num++)\n fprintf(passwd_text, PASSWD_FMT\"\\n\", passwd_list[rec_num]);\n fclose(passwd_text);\n\n\n passwd_text=fopen(\"passwd.txt\", \"a+\");\n char passwd_buf[BUFSIZ]; \n passwd_t new_rec =\n {\"xyz\", \"x\", 1003, 1000, \n {\"X Yz\", \"Room 1003\", \"(234)555-8913\", \"(234)555-0033\", \"xyz@rosettacode.org\"},\n \"\/home\/xyz\", \"\/bin\/bash\"};\n sprintf(passwd_buf, PASSWD_FMT\"\\n\", new_rec);\n\n write(fileno(passwd_text), passwd_buf, strlen(passwd_buf));\n close(passwd_text);\n\n\n passwd_text=fopen(\"passwd.txt\", \"r\");\n while(!feof(passwd_text))\n fscanf(passwd_text, \"%[^\\n]\\n\", passwd_buf, \"\\n\");\n if(strstr(passwd_buf, \"xyz\"))\n printf(\"Appended record: %s\\n\", passwd_buf);\n}\n","Rust":"use std::fs::File;\nuse std::fs::OpenOptions;\nuse std::io::BufRead;\nuse std::io::BufReader;\nuse std::io::BufWriter;\nuse std::io::Result;\nuse std::io::Write;\nuse std::path::Path;\n\n\n#[derive(Eq, PartialEq, Debug)]\npub struct PasswordRecord {\n pub account: String,\n pub password: String,\n pub uid: u64,\n pub gid: u64,\n pub gecos: Vec,\n pub directory: String,\n pub shell: String,\n}\n\n\nimpl PasswordRecord {\n \n pub fn new(\n account: &str,\n password: &str,\n uid: u64,\n gid: u64,\n gecos: Vec<&str>,\n directory: &str,\n shell: &str,\n ) -> PasswordRecord {\n PasswordRecord {\n account: account.to_string(),\n password: password.to_string(),\n uid,\n gid,\n gecos: gecos.iter().map(|s| s.to_string()).collect(),\n directory: directory.to_string(),\n shell: shell.to_string(),\n }\n }\n\n \n pub fn to_line(&self) -> String {\n let gecos = self.gecos.join(\",\");\n format!(\n \"{}:{}:{}:{}:{}:{}:{}\",\n self.account, self.password, self.uid, self.gid, gecos, self.directory, self.shell\n )\n }\n\n \n pub fn from_line(line: &str) -> PasswordRecord {\n let sp: Vec<&str> = line.split(\":\").collect();\n if sp.len() < 7 {\n panic!(\"Less than 7 fields found\");\n } else {\n let uid = sp[2].parse().expect(\"Cannot parse uid\");\n let gid = sp[3].parse().expect(\"Cannot parse gid\");\n let gecos = sp[4].split(\",\").collect();\n PasswordRecord::new(sp[0], sp[1], uid, gid, gecos, sp[5], sp[6])\n }\n }\n}\n\n\npub fn read_password_file(file_name: &str) -> Result> {\n let p = Path::new(file_name);\n if !p.exists() {\n Ok(vec![])\n } else {\n let f = OpenOptions::new().read(true).open(p)?;\n Ok(BufReader::new(&f)\n .lines()\n .map(|l| PasswordRecord::from_line(&l.unwrap()))\n .collect())\n }\n}\n\n\npub fn overwrite_password_file(file_name: &str, recs: &Vec) -> Result<()> {\n let f = OpenOptions::new()\n .create(true)\n .write(true)\n .open(file_name)?;\n write_records(f, recs)\n}\n\n\npub fn append_password_file(file_name: &str, recs: &Vec) -> Result<()> {\n let f = OpenOptions::new()\n .create(true)\n .append(true)\n .open(file_name)?;\n write_records(f, recs)\n}\n\n\nfn write_records(f: File, recs: &Vec) -> Result<()> {\n let mut writer = BufWriter::new(f);\n for rec in recs {\n write!(writer, \"{}\\n\", rec.to_line())?;\n }\n Ok(())\n}\n\nfn main(){\n let recs1 = vec![\n PasswordRecord::new(\n \"jsmith\",\n \"x\",\n 1001,\n 1000,\n vec![\n \"Joe Smith\",\n \"Room 1007\",\n \"(234)555-8917\",\n \"(234)555-0077\",\n \"jsmith@rosettacode.org\",\n ],\n \"\/home\/jsmith\",\n \"\/bin\/bash\",\n ),\n PasswordRecord::new(\n \"jdoe\",\n \"x\",\n 1002,\n 1000,\n vec![\n \"Jane Doe\",\n \"Room 1004\",\n \"(234)555-8914\",\n \"(234)555-0044\",\n \"jdoe@rosettacode.org\",\n ],\n \"\/home\/jdoe\",\n \"\/bin\/bash\",\n ),\n ];\n\n overwrite_password_file(\"passwd\", &recs1).expect(\"cannot write file\");\n let recs2 = read_password_file(\"passwd\").expect(\"cannot read file\");\n println!(\"Original file:\");\n for r in recs2 {\n println!(\"{}\",r.to_line());\n }\n let append0 = vec![PasswordRecord::new(\n \"xyz\",\n \"x\",\n 1003,\n 1000,\n vec![\n \"X Yz\",\n \"Room 1003\",\n \"(234)555-8913\",\n \"(234)555-0033\",\n \"xyz@rosettacode.org\",\n ],\n \"\/home\/xyz\",\n \"\/bin\/bash\",\n )];\n append_password_file(\"passwd\", &append0).expect(\"cannot append to file\");\n let recs2 = read_password_file(\"passwd\").expect(\"cannot read file\");\n println!(\"\");\n println!(\"Appended file:\");\n for r in recs2 {\n println!(\"{}\",r.to_line());\n }\n}\n"} {"name":"Apply a callback to an array","C":"#ifndef CALLBACK_H\n#define CALLBACK_H\n\n\nvoid map(int* array, int len, void(*callback)(int,int));\n\n#endif\n","Rust":"fn echo(n: &i32) {\n println!(\"{}\", n);\n}\n\nfn main() {\n let a: [i32; 5];\n a = [1, 2, 3, 4, 5];\n let _: Vec<_> = a.into_iter().map(echo).collect();\n}\n"} {"name":"Apply a digital filter (direct form II transposed)","C":"#include\n#include\n#include\n\n#define MAX_LEN 1000\n\ntypedef struct{\n\tfloat* values;\n\tint size;\n}vector;\n\nvector extractVector(char* str){\n\tvector coeff;\n\tint i=0,count = 1;\n\tchar* token;\n\t\n\twhile(str[i]!=00){\n\t\tif(str[i++]==' ')\n\t\t\tcount++;\n\t}\n\t\n\tcoeff.values = (float*)malloc(count*sizeof(float));\n\tcoeff.size = count;\n\t\n\ttoken = strtok(str,\" \");\n\t\n\ti = 0;\n\t\n\twhile(token!=NULL){\n\t\tcoeff.values[i++] = atof(token);\n\t\ttoken = strtok(NULL,\" \");\n\t}\n\t\n\treturn coeff;\n}\n\nvector processSignalFile(char* fileName){\n\tint i,j;\n\tfloat sum;\n\tchar str[MAX_LEN];\n\tvector coeff1,coeff2,signal,filteredSignal;\n\t\n\tFILE* fp = fopen(fileName,\"r\");\n\t\n\tfgets(str,MAX_LEN,fp);\n\tcoeff1 = extractVector(str);\n\t\n\tfgets(str,MAX_LEN,fp);\n\tcoeff2 = extractVector(str);\n\t\n\tfgets(str,MAX_LEN,fp);\n\tsignal = extractVector(str);\n\n fclose(fp);\n\t\n\tfilteredSignal.values = (float*)calloc(signal.size,sizeof(float));\n\tfilteredSignal.size = signal.size;\n\t\n\tfor(i=0;i=0)\n\t\t\t\tsum += coeff2.values[j]*signal.values[i-j];\n\t\t}\n\t\t\n\t\tfor(j=0;j=0)\n\t\t\t\tsum -= coeff1.values[j]*filteredSignal.values[i-j];\n\t\t}\n\t\t\n\t\tsum \/= coeff1.values[0];\n\t\tfilteredSignal.values[i] = sum;\n\t}\n\t\n\treturn filteredSignal;\n}\n\nvoid printVector(vector v, char* outputFile){\n\tint i;\n\t\n\tif(outputFile==NULL){\n\t\tprintf(\"[\");\n\t\tfor(i=0;i3)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\telse{\n\t\tif(argC!=2){\n\t\t\tstr = (char*)malloc((strlen(argV[2]) + strlen(str) + 1)*sizeof(char));\n\t\t\tstrcpy(str,\"written to \");\n\t\t}\n\t\tprintf(\"Filtered signal %s\",(argC==2)?\"is:\\n\":strcat(str,argV[2]));\n\t\tprintVector(processSignalFile(argV[1]),argV[2]);\n\t}\n\treturn 0;\n}\n","Rust":"use std::cmp::Ordering;\n\nstruct IIRFilter<'f>(&'f [f32], &'f [f32]);\n\nimpl<'f> IIRFilter<'f> {\n pub fn with_coefficients(a: &'f [f32], b: &'f [f32]) -> IIRFilter<'f> {\n IIRFilter(a, b)\n }\n\n \n pub fn apply + 'f>(\n &self,\n samples: I,\n ) -> impl Iterator + 'f {\n \n let a_coeff = self.0;\n let b_coeff = self.1;\n\n let mut prev_results = Vec::::new();\n let mut prev_samples = Vec::::new();\n\n \n samples.enumerate() \n .map(move |(i, sample)| { \n prev_samples.push(*sample);\n prev_results.push(0f32); \n\n let sum_b: f32 = b_coeff.iter() \n .enumerate() \n .map(|(j, c)| { \n if i >= j {\n (*c) * prev_samples[i-j]\n } else {\n 0f32\n }\n })\n .sum(); \n\n let sum_a: f32 = a_coeff.iter() \n .enumerate() \n .map(|(j, c)| { \n if i >= j {\n (*c) * prev_results[i-j]\n } else {\n 0f32\n }\n })\n .sum(); \n\n \n let result = (sum_b - sum_a) \/ a_coeff[0];\n\n \n prev_results[i] = result;\n\n \n result\n }\n )\n }\n}\n\nfn main() {\n let a: &[f32] = &[1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17];\n let b: &[f32] = &[0.16666667, 0.5, 0.5, 0.16666667];\n\n let samples: Vec = vec![\n -0.917843918645,\n 0.141984778794,\n 1.20536903482,\n 0.190286794412,\n -0.662370894973,\n -1.00700480494,\n -0.404707073677,\n 0.800482325044,\n 0.743500089861,\n 1.01090520172,\n 0.741527555207,\n 0.277841675195,\n 0.400833448236,\n -0.2085993586,\n -0.172842103641,\n -0.134316096293,\n 0.0259303398477,\n 0.490105989562,\n 0.549391221511,\n 0.9047198589,\n ];\n\n for (i, result) in IIRFilter::with_coefficients(a, b)\n .apply(samples.iter())\n .enumerate()\n {\n print!(\"{:.8}\", result);\n if (i + 1) % 5 != 0 {\n print!(\", \");\n } else {\n println!();\n }\n }\n println!();\n}\n"} {"name":"Approximate equality","C":"#include \n#include \n#include \n\nbool approxEquals(double value, double other, double epsilon) {\n return fabs(value - other) < epsilon;\n}\n\nvoid test(double a, double b) {\n double epsilon = 1e-18;\n printf(\"%f, %f => %d\\n\", a, b, approxEquals(a, b, epsilon));\n}\n\nint main() {\n test(100000000000000.01, 100000000000000.011);\n test(100.01, 100.011);\n test(10000000000000.001 \/ 10000.0, 1000000000.0000001000);\n test(0.001, 0.0010000001);\n test(0.000000000000000000000101, 0.0);\n test(sqrt(2.0) * sqrt(2.0), 2.0);\n test(-sqrt(2.0) * sqrt(2.0), -2.0);\n test(3.14159265358979323846, 3.14159265358979324);\n return 0;\n}\n","Rust":"\n\n\n\nfn isclose(a: f64, b: f64, epsilon: f64) -> bool {\n (a - b).abs() <= a.abs().max(b.abs()) * epsilon\n}\n\nfn main() {\n fn sqrt(x: f64) -> f64 { x.sqrt() }\n macro_rules! test {\n ($a: expr, $b: expr) => {\n let operator = if isclose($a, $b, 1.0e-9) { '\u2248' } else { '\u2249' };\n println!(\"{:>28} {} {}\", stringify!($a), operator, stringify!($b))\n }\n }\n\n test!(100000000000000.01, 100000000000000.011);\n test!(100.01, 100.011);\n test!(10000000000000.001\/10000.0, 1000000000.0000001000);\n test!(0.001, 0.0010000001);\n test!(0.000000000000000000000101, 0.0);\n test!( sqrt(2.0) * sqrt(2.0), 2.0);\n test!(-sqrt(2.0) * sqrt(2.0), -2.0);\n test!(3.14159265358979323846, 3.14159265358979324);\n}\n"} {"name":"Arbitrary-precision integers (included)","C":"#include \n#include \n#include \n\nint main()\n{\n\tmpz_t a;\n\tmpz_init_set_ui(a, 5);\n\tmpz_pow_ui(a, a, 1 << 18); \n\n\tint len = mpz_sizeinbase(a, 10);\n\tprintf(\"GMP says size is: %d\\n\", len);\n\n\t\n\tchar *s = mpz_get_str(0, 10, a);\n\tprintf(\"size really is %d\\n\", len = strlen(s));\n\tprintf(\"Digits:\u00a0%.20s...%s\\n\", s, s + len - 20);\n\n\t\n\treturn 0;\n}\n","Rust":"extern crate num;\nuse num::bigint::BigUint;\nuse num::FromPrimitive;\nuse num::pow::pow;\n\nfn main() {\n let big = BigUint::from_u8(5).unwrap();\n let answer_as_string = format!(\"{}\", pow(big,pow(4,pow(3,2))));\n \n \n let first_twenty: String = answer_as_string.chars().take(20).collect();\n let last_twenty_reversed: Vec = answer_as_string.chars().rev().take(20).collect();\n let last_twenty: String = last_twenty_reversed.into_iter().rev().collect();\n println!(\"Number of digits: {}\", answer_as_string.len());\n println!(\"First and last digits: {:?}..{:?}\", first_twenty, last_twenty);\n}\n"} {"name":"Archimedean spiral","C":"#include \n\nMain\n Set break\n a=1.5, b=1.5, r=0, origen x=200, origen y=105\n total = 0, Let ( total := Mul(20, M_PI) )\n Cls\n Loop for ( t=0, var 't' Is less equal to 'total', Let (t := Add (t, 0.005)) )\n #( r = a + b * t )\n Set 'origen x, origen y', # ( 200 + (2*r*sin(t)) ) \u00bb 'origen x', #( 105 + (r*cos(t)) ) \u00bb 'origen y', \n Gosub 'Dibuja un segmento'\n Next\n Pause\nEnd\n\nSubrutines\n\nDefine (Dibuja un segmento, x1, y1, x2, y2)\n dx=0, dy=0, paso=0, i=0, DX=0, DY=0\n\n Sub(x2, x1), Sub (y2, y1), Move to ' dx, dy '\n\n Let( paso := Get if( Greater equal ( Abs(dx) \u00bb (DX), Abs(dy)\u00bb(DY) ), DX, DY ) )\n\n \n Div(dx, paso), Div(dy, paso), Move to ( dx, dy )\n\n Color back (13)\n \n i = 0\n Loop if ( Less equal (i, paso) )\n Locate( y1, x1 ), Printnl( \" \" )\n Add ( x1, dx), Add( y1, dy ), Move to ( x1, y1 )\n ++i\n Back\n Printnl(\"\\OFF\")\nReturn\n","Rust":"#[macro_use(px)]\nextern crate bmp;\n\nuse bmp::{Image, Pixel};\nuse std::f64;\n\nfn main() {\n let width = 600u32;\n let half_width = (width \/ 2) as i32;\n let mut img = Image::new(width, width);\n let draw_color = px!(255, 128, 128);\n\n \n let a = 1.0_f64;\n let b = 9.0_f64;\n\n \n let max_angle = 5.0_f64 * 2.0_f64 * f64::consts::PI;\n\n let mut theta = 0.0_f64;\n while theta < max_angle {\n theta = theta + 0.002_f64;\n\n let r = a + b * theta;\n let x = (r * theta.cos()) as i32 + half_width;\n let y = (r * theta.sin()) as i32 + half_width;\n img.set_pixel(x as u32, y as u32, draw_color);\n }\n\n \n let _ = img.save(\"archimedean_spiral.bmp\").unwrap_or_else(|e| panic!(\"Failed to save: {}\", e));\n}\n"} {"name":"Arithmetic-geometric mean","C":"#include\n#include\n#include\n\ndouble agm( double a, double g ) {\n \n double iota = 1.0E-16;\n double a1, g1;\n \n if( a*g < 0.0 ) {\n printf( \"arithmetic-geometric mean undefined when x*y<0\\n\" );\n exit(1);\n }\n\n while( fabs(a-g)>iota ) {\n a1 = (a + g) \/ 2.0;\n g1 = sqrt(a * g);\n\n a = a1;\n g = g1;\n }\n \n return a;\n}\n\nint main( void ) {\n double x, y;\n printf( \"Enter two numbers: \" );\n scanf( \"%lf%lf\", &x, &y );\n printf( \"The arithmetic-geometric mean is %lf\\n\", agm(x, y) );\n return 0;\n}\n","Rust":"\n\n\nfn main () {\n let mut args = std::env::args();\n\n let x = args.nth(1).expect(\"First argument not specified.\").parse::().unwrap();\n let y = args.next().expect(\"Second argument not specified.\").parse::().unwrap();\n\n let result = agm(x,y);\n println!(\"The arithmetic-geometric mean is {}\", result);\n}\n\nfn agm (x: f32, y: f32) -> f32 {\n let e: f32 = 0.000001;\n let mut a = x;\n let mut g = y;\n let mut a1: f32;\n let mut g1: f32;\n\n if a * g < 0f32 { panic!(\"The arithmetric-geometric mean is undefined for numbers less than zero!\"); }\n else {\n loop {\n a1 = (a + g) \/ 2.;\n g1 = (a * g).sqrt();\n a = a1;\n g = g1;\n if (a - g).abs() < e { return a; }\n }\n }\n}\n"} {"name":"Arithmetic_Complex","C":"#include \n#include \n\nvoid cprint(double complex c)\n{\n printf(\"%f%+fI\", creal(c), cimag(c));\n}\nvoid complex_operations() {\n double complex a = 1.0 + 1.0I;\n double complex b = 3.14159 + 1.2I;\n\n double complex c;\n\n printf(\"\\na=\"); cprint(a);\n printf(\"\\nb=\"); cprint(b);\n\n \n c = a + b;\n printf(\"\\na+b=\"); cprint(c);\n \n c = a * b;\n printf(\"\\na*b=\"); cprint(c);\n \n c = 1.0 \/ a;\n printf(\"\\n1\/c=\"); cprint(c);\n \n c = -a;\n printf(\"\\n-a=\"); cprint(c);\n \n c = conj(a);\n printf(\"\\nconj a=\"); cprint(c); printf(\"\\n\");\n}\n","Rust":"extern crate num;\nuse num::complex::Complex;\n\nfn main() {\n \n let a = Complex {re:-4.0, im: 5.0};\n let b = Complex::new(1.0, 1.0);\n\n println!(\" a = {}\", a);\n println!(\" b = {}\", b);\n println!(\" a + b = {}\", a + b);\n println!(\" a * b = {}\", a * b);\n println!(\" 1 \/ a = {}\", a.inv());\n println!(\" -a = {}\", -a);\n println!(\"conj(a) = {}\", a.conj());\n}\n"} {"name":"Arithmetic_Integer","C":"#include \n#include \n\nint main(int argc, char *argv[])\n{\n int a, b;\n if (argc < 3) exit(1);\n b = atoi(argv[--argc]);\n if (b == 0) exit(2);\n a = atoi(argv[--argc]);\n printf(\"a+b = %d\\n\", a+b);\n printf(\"a-b = %d\\n\", a-b);\n printf(\"a*b = %d\\n\", a*b);\n printf(\"a\/b = %d\\n\", a\/b); \n printf(\"a%%b = %d\\n\", a%b); \n return 0;\n}\n","Rust":"use std::env;\n\nfn main() {\n let args: Vec<_> = env::args().collect();\n let a = args[1].parse::().unwrap();\n let b = args[2].parse::().unwrap();\n\n println!(\"sum: {}\", a + b);\n println!(\"difference: {}\", a - b);\n println!(\"product: {}\", a * b);\n println!(\"integer quotient: {}\", a \/ b); \n println!(\"remainder: {}\", a % b); \n}\n"} {"name":"Arithmetic_Rational","C":"#include \n#include \n#define FMT \"%lld\"\ntypedef long long int fr_int_t;\ntypedef struct { fr_int_t num, den; } frac;\n\nfr_int_t gcd(fr_int_t m, fr_int_t n)\n{\n\tfr_int_t t;\n\twhile (n) { t = n; n = m % n; m = t; }\n\treturn m;\n}\n\nfrac frac_new(fr_int_t num, fr_int_t den)\n{\n\tfrac a;\n\tif (!den) {\n\t\tprintf(\"divide by zero: \"FMT\"\/\"FMT\"\\n\", num, den);\n\t\tabort();\n\t}\n\n\tint g = gcd(num, den);\n\n\tif (g)\t{ num \/= g; den \/= g; }\n\telse\t{ num = 0; den = 1; }\n\n\tif (den < 0) {\n\t\tden = -den;\n\t\tnum = -num;\n\t}\n\ta.num = num; a.den = den;\n\treturn a;\n}\n\n#define BINOP(op, n, d) frac frac_##op(frac a, frac b) { return frac_new(n,d); }\nBINOP(add, a.num * b.den + b.num * a.den, a.den * b.den);\nBINOP(sub, a.num * b.den - b.num + a.den, a.den * b.den);\nBINOP(mul, a.num * b.num, a.den * b.den);\nBINOP(div, a.num * b.den, a.den * b.num);\n\nint frac_cmp(frac a, frac b) {\n\tint l = a.num * b.den, r = a.den * b.num;\n\treturn l < r ? -1 : l > r;\n}\n#define frac_cmp_int(a, b) frac_cmp(a, frac_new(b, 1))\nint frtoi(frac a) { return a.den \/ a.num; }\ndouble frtod(frac a) { return (double)a.den \/ a.num; }\n\nint main()\n{\n\tint n, k;\n\tfrac sum, kf;\n\n\tfor (n = 2; n < 1<<19; n++) {\n\t\tsum = frac_new(1, n);\n\n\t\tfor (k = 2; k * k < n; k++) {\n\t\t\tif (n % k) continue;\n\t\t\tkf = frac_new(1, k);\n\t\t\tsum = frac_add(sum, kf);\n\n\t\t\tkf = frac_new(1, n \/ k);\n\t\t\tsum = frac_add(sum, kf);\n\t\t}\n\t\tif (frac_cmp_int(sum, 1) == 0) printf(\"%d\\n\", n);\n\t}\n\n\treturn 0;\n}\n","Rust":"use std::cmp::Ordering;\nuse std::ops::{Add, AddAssign, Sub, SubAssign, Mul, MulAssign, Div, DivAssign, Neg};\n\nfn gcd(a: i64, b: i64) -> i64 {\n match b {\n 0 => a,\n _ => gcd(b, a % b),\n }\n}\n\nfn lcm(a: i64, b: i64) -> i64 {\n a \/ gcd(a, b) * b\n}\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord)]\npub struct Rational {\n numerator: i64,\n denominator: i64,\n}\n\nimpl Rational {\n fn new(numerator: i64, denominator: i64) -> Self {\n let divisor = gcd(numerator, denominator);\n Rational {\n numerator: numerator \/ divisor,\n denominator: denominator \/ divisor,\n }\n }\n}\n\nimpl Add for Rational {\n type Output = Self;\n\n fn add(self, other: Self) -> Self {\n let multiplier = lcm(self.denominator, other.denominator);\n Rational::new(self.numerator * multiplier \/ self.denominator +\n other.numerator * multiplier \/ other.denominator,\n multiplier)\n }\n}\n\nimpl AddAssign for Rational {\n fn add_assign(&mut self, other: Self) {\n *self = *self + other;\n }\n}\n\nimpl Sub for Rational {\n type Output = Self;\n\n fn sub(self, other: Self) -> Self {\n self + -other\n }\n}\n\nimpl SubAssign for Rational {\n fn sub_assign(&mut self, other: Self) {\n *self = *self - other;\n }\n}\n\nimpl Mul for Rational {\n type Output = Self;\n\n fn mul(self, other: Self) -> Self {\n Rational::new(self.numerator * other.numerator,\n self.denominator * other.denominator)\n }\n}\n\nimpl MulAssign for Rational {\n fn mul_assign(&mut self, other: Self) {\n *self = *self * other;\n }\n}\n\nimpl Div for Rational {\n type Output = Self;\n\n fn div(self, other: Self) -> Self {\n self *\n Rational {\n numerator: other.denominator,\n denominator: other.numerator,\n }\n }\n}\n\nimpl DivAssign for Rational {\n fn div_assign(&mut self, other: Self) {\n *self = *self \/ other;\n }\n}\n\nimpl Neg for Rational {\n type Output = Self;\n\n fn neg(self) -> Self {\n Rational {\n numerator: -self.numerator,\n denominator: self.denominator,\n }\n }\n}\n\nimpl PartialOrd for Rational {\n fn partial_cmp(&self, other: &Self) -> Option {\n (self.numerator * other.denominator).partial_cmp(&(self.denominator * other.numerator))\n }\n}\n\nimpl> From for Rational {\n fn from(value: T) -> Self {\n Rational::new(value.into(), 1)\n }\n}\n\nfn main() {\n let max = 1 << 19;\n for candidate in 2..max {\n let mut sum = Rational::new(1, candidate);\n for factor in 2..(candidate as f64).sqrt().ceil() as i64 {\n if candidate % factor == 0 {\n sum += Rational::new(1, factor);\n sum += Rational::new(1, candidate \/ factor);\n }\n }\n\n if sum == 1.into() {\n println!(\"{} is perfect\", candidate);\n }\n }\n}\n"} {"name":"Array concatenation","C":"#include \n#include \n#include \n\n#define ARRAY_CONCAT(TYPE, A, An, B, Bn) \\\n (TYPE *)array_concat((const void *)(A), (An), (const void *)(B), (Bn), sizeof(TYPE));\n\nvoid *array_concat(const void *a, size_t an,\n const void *b, size_t bn, size_t s)\n{\n char *p = malloc(s * (an + bn));\n memcpy(p, a, an*s);\n memcpy(p + an*s, b, bn*s);\n return p;\n}\n\n\nconst int a[] = { 1, 2, 3, 4, 5 };\nconst int b[] = { 6, 7, 8, 9, 0 };\n\nint main(void)\n{\n unsigned int i;\n\n int *c = ARRAY_CONCAT(int, a, 5, b, 5);\n\n for(i = 0; i < 10; i++)\n printf(\"%d\\n\", c[i]);\n\n free(c);\n return EXIT_SUCCCESS;\n}\n","Rust":"fn main() {\n let a_vec = vec![1, 2, 3, 4, 5];\n let b_vec = vec![6; 5];\n\n let c_vec = concatenate_arrays(&a_vec, &b_vec);\n\n println!(\"{:?} ~ {:?} => {:?}\", a_vec, b_vec, c_vec);\n}\n\nfn concatenate_arrays(x: &[T], y: &[T]) -> Vec {\n let mut concat = x.to_vec();\n concat.extend_from_slice(y);\n\n concat\n}\n"} {"name":"Array length","C":"#include \n\nint main()\n{ \n const char *fruit[2] = { \"apples\", \"oranges\" };\n\n \n \n\n \n \n \n\n \n \n int length = sizeof(fruit) \/ sizeof(fruit[0]);\n\n printf(\"%d\\n\", length);\n\n return 0;\n}\n","Rust":"fn main() {\n let array = [\"foo\", \"bar\", \"baz\", \"biff\"];\n println!(\"the array has {} elements\", array.len());\n}\n"} {"name":"Arrays","C":" char foo()\n{\nchar array[5] = {3,6,9,12,15};\nreturn array[2];\n}\n","Rust":"let a = [1, 2, 3]; \nlet mut m = [1, 2, 3]; \nlet zeroes = [0; 200]; \n"} {"name":"Assertions","C":"#include \n\nint main(){\n int a;\n \n assert(a == 42); \n\n return 0;\n}\n","Rust":"let x = 42;\nassert!(x == 42);\nassert_eq!(x, 42);\n"} {"name":"Atomic updates","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n#define N_BUCKETS 15\n\npthread_mutex_t bucket_mutex[N_BUCKETS];\nint buckets[N_BUCKETS];\n\npthread_t equalizer;\npthread_t randomizer;\n\nvoid transfer_value(int from, int to, int howmuch)\n{\n bool swapped = false;\n\n if ( (from == to) || ( howmuch < 0 ) ||\n (from < 0 ) || (to < 0) || (from >= N_BUCKETS) || (to >= N_BUCKETS) ) return;\n \n if ( from > to ) {\n int temp1 = from;\n from = to;\n to = temp1;\n swapped = true;\n howmuch = -howmuch;\n }\n\n pthread_mutex_lock(&bucket_mutex[from]);\n pthread_mutex_lock(&bucket_mutex[to]);\n\n if ( howmuch > buckets[from] && !swapped )\n howmuch = buckets[from];\n if ( -howmuch > buckets[to] && swapped )\n howmuch = -buckets[to];\n \n buckets[from] -= howmuch;\n buckets[to] += howmuch;\n\n pthread_mutex_unlock(&bucket_mutex[from]);\n pthread_mutex_unlock(&bucket_mutex[to]);\n}\n\nvoid print_buckets()\n{\n int i;\n int sum=0;\n\n for(i=0; i < N_BUCKETS; i++) pthread_mutex_lock(&bucket_mutex[i]);\n for(i=0; i < N_BUCKETS; i++) {\n printf(\"%3d \", buckets[i]);\n sum += buckets[i];\n }\n printf(\"= %d\\n\", sum);\n for(i=0; i < N_BUCKETS; i++) pthread_mutex_unlock(&bucket_mutex[i]);\n}\n\nvoid *equalizer_start(void *t)\n{\n for(;;) {\n int b1 = rand()%N_BUCKETS;\n int b2 = rand()%N_BUCKETS;\n int diff = buckets[b1] - buckets[b2];\n if ( diff < 0 )\n transfer_value(b2, b1, -diff\/2);\n else\n transfer_value(b1, b2, diff\/2);\n }\n return NULL;\n}\n\nvoid *randomizer_start(void *t)\n{\n for(;;) {\n int b1 = rand()%N_BUCKETS;\n int b2 = rand()%N_BUCKETS;\n int diff = rand()%(buckets[b1]+1);\n transfer_value(b1, b2, diff);\n }\n return NULL;\n}\n\nint main()\n{\n int i, total=0;\n\n for(i=0; i < N_BUCKETS; i++) pthread_mutex_init(&bucket_mutex[i], NULL);\n\n for(i=0; i < N_BUCKETS; i++) {\n buckets[i] = rand() % 100;\n total += buckets[i];\n printf(\"%3d \", buckets[i]);\n }\n printf(\"= %d\\n\", total);\n\n \n pthread_create(&equalizer, NULL, equalizer_start, NULL);\n pthread_create(&randomizer, NULL, randomizer_start, NULL);\n\n for(;;) {\n sleep(1);\n print_buckets();\n }\n\n \n \n for(i=0; i < N_BUCKETS; i++) pthread_mutex_destroy(bucket_mutex+i);\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate rand;\n\nuse std::sync::{Arc, Mutex};\nuse std::thread;\nuse std::cmp;\nuse std::time::Duration;\n\nuse rand::Rng;\nuse rand::distributions::{IndependentSample, Range};\n\ntrait Buckets {\n fn equalize(&mut self, rng: &mut R);\n fn randomize(&mut self, rng: &mut R);\n fn print_state(&self);\n}\n\nimpl Buckets for [i32] {\n fn equalize(&mut self, rng: &mut R) {\n let range = Range::new(0,self.len()-1);\n let src = range.ind_sample(rng);\n let dst = range.ind_sample(rng);\n if dst != src {\n let amount = cmp::min(((dst + src) \/ 2) as i32, self[src]);\n let multiplier = if amount >= 0 { -1 } else { 1 };\n self[src] += amount * multiplier;\n self[dst] -= amount * multiplier;\n }\n }\n fn randomize(&mut self, rng: &mut R) {\n let ind_range = Range::new(0,self.len()-1);\n let src = ind_range.ind_sample(rng);\n let dst = ind_range.ind_sample(rng);\n if dst != src {\n let amount = cmp::min(Range::new(0,20).ind_sample(rng), self[src]);\n self[src] -= amount;\n self[dst] += amount;\n\n }\n }\n fn print_state(&self) {\n println!(\"{:?} = {}\", self, self.iter().sum::());\n }\n}\n\nfn main() {\n let e_buckets = Arc::new(Mutex::new([10; 10]));\n let r_buckets = e_buckets.clone();\n let p_buckets = e_buckets.clone();\n\n thread::spawn(move || { \n let mut rng = rand::thread_rng();\n loop {\n let mut buckets = e_buckets.lock().unwrap();\n buckets.equalize(&mut rng);\n }\n });\n thread::spawn(move || {\n let mut rng = rand::thread_rng();\n loop {\n let mut buckets = r_buckets.lock().unwrap();\n buckets.randomize(&mut rng);\n }\n });\n\n let sleep_time = Duration::new(1,0);\n loop {\n {\n let buckets = p_buckets.lock().unwrap();\n buckets.print_state();\n }\n thread::sleep(sleep_time);\n }\n}\n"} {"name":"Attractive numbers","C":"#include \n\n#define TRUE 1\n#define FALSE 0\n#define MAX 120\n\ntypedef int bool;\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 count_prime_factors(int n) {\n int count = 0, f = 2;\n if (n == 1) return 0;\n if (is_prime(n)) return 1;\n while (TRUE) {\n if (!(n % f)) {\n count++;\n n \/= f;\n if (n == 1) return count;\n if (is_prime(n)) f = n;\n } \n else if (f >= 3) f += 2;\n else f = 3;\n }\n}\n\nint main() { \n int i, n, count = 0;\n printf(\"The attractive numbers up to and including %d are:\\n\", MAX);\n for (i = 1; i <= MAX; ++i) {\n n = count_prime_factors(i);\n if (is_prime(n)) {\n printf(\"%4d\", i);\n if (!(++count % 20)) printf(\"\\n\");\n }\n }\n printf(\"\\n\");\n return 0; \n}\n","Rust":"use primal::Primes;\n\nconst MAX: u64 = 120;\n\n\n\nfn extract_prime_factor(num: u64) -> Option<(u64, u64)> {\n let mut i = 0;\n if primal::is_prime(num) {\n None\n } else {\n loop {\n let prime = Primes::all().nth(i).unwrap() as u64;\n if num % prime == 0 {\n return Some((prime, num \/ prime));\n } else {\n i += 1;\n }\n }\n }\n}\n\n\nfn factorize(num: u64) -> Vec {\n let mut factorized = Vec::new();\n let mut rest = num;\n while let Some((prime, factorizable_rest)) = extract_prime_factor(rest) {\n factorized.push(prime);\n rest = factorizable_rest;\n }\n factorized.push(rest);\n factorized\n}\n\nfn main() {\n let mut output: Vec = Vec::new();\n for num in 4 ..= MAX {\n if primal::is_prime(factorize(num).len() as u64) {\n output.push(num);\n }\n }\n println!(\"The attractive numbers up to and including 120 are\\n{:?}\", output);\n}\n"} {"name":"Average loop length","C":"#include \n#include \n#include \n#include \n\n#define MAX_N 20\n#define TIMES 1000000\n\ndouble factorial(int n) {\n\tdouble f = 1;\n\tint i;\n\tfor (i = 1; i <= n; i++) f *= i;\n\treturn f;\n}\n\ndouble expected(int n) {\n\tdouble sum = 0;\n\tint i;\n\tfor (i = 1; i <= n; i++)\n\t\tsum += factorial(n) \/ pow(n, i) \/ factorial(n - i);\n\treturn sum;\n}\n\nint randint(int n) {\n\tint r, rmax = RAND_MAX \/ n * n;\n\twhile ((r = rand()) >= rmax);\n\treturn r \/ (RAND_MAX \/ n);\n}\n\nint test(int n, int times) {\n\tint i, count = 0;\n\tfor (i = 0; i < times; i++) {\n\t\tint x = 1, bits = 0;\n\t\twhile (!(bits & x)) {\n\t\t\tcount++;\n\t\t\tbits |= x;\n\t\t\tx = 1 << randint(n);\n\t\t}\n\t}\n\treturn count;\n}\n\nint main(void) {\n\tsrand(time(0));\n\tputs(\" n\\tavg\\texp.\\tdiff\\n-------------------------------\");\n\n\tint n;\n\tfor (n = 1; n <= MAX_N; n++) {\n\t\tint cnt = test(n, TIMES);\n\t\tdouble avg = (double)cnt \/ TIMES;\n\t\tdouble theory = expected(n);\n\t\tdouble diff = (avg \/ theory - 1) * 100;\n\t\tprintf(\"%2d %8.4f %8.4f %6.3f%%\\n\", n, avg, theory, diff);\n\t}\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::{ThreadRng, thread_rng};\nuse rand::distributions::{IndependentSample, Range};\nuse std::collections::HashSet;\nuse std::env;\nuse std::process;\n\nfn help() {\n println!(\"usage: average_loop_length \");\n}\n\nfn main() {\n let args: Vec = env::args().collect();\n let mut max_n: u32 = 20;\n let mut trials: u32 = 1000;\n\n match args.len() {\n 1 => {}\n 3 => {\n max_n = args[1].parse::().unwrap();\n trials = args[2].parse::().unwrap();\n }\n _ => {\n help();\n process::exit(0);\n }\n }\n\n let mut rng = thread_rng();\n\n println!(\" N average analytical (error)\");\n println!(\"=== ========= ============ =========\");\n for n in 1..(max_n + 1) {\n let the_analytical = analytical(n);\n let the_empirical = empirical(n, trials, &mut rng);\n println!(\" {:>2} {:3.4} {:3.4} ( {:>+1.2}%)\",\n n,\n the_empirical,\n the_analytical,\n 100f64 * (the_empirical \/ the_analytical - 1f64));\n }\n}\n\nfn factorial(n: u32) -> f64 {\n (1..n + 1).fold(1f64, |p, n| p * n as f64)\n}\n\nfn analytical(n: u32) -> f64 {\n let sum: f64 = (1..(n + 1))\n .map(|i| factorial(n) \/ (n as f64).powi(i as i32) \/ factorial(n - i))\n .fold(0f64, |a, v| a + v);\n sum\n}\n\nfn empirical(n: u32, trials: u32, rng: &mut ThreadRng) -> f64 {\n let sum: f64 = (0..trials)\n .map(|_t| {\n let mut item = 1u32;\n let mut seen = HashSet::new();\n let range = Range::new(1u32, n + 1);\n\n for step in 0..n {\n if seen.contains(&item) {\n return step as f64;\n }\n seen.insert(item);\n item = range.ind_sample(rng);\n }\n n as f64\n })\n .fold(0f64, |a, v| a + v);\n sum \/ trials as f64\n}\n"} {"name":"Averages_Arithmetic mean","C":"#include \n\ndouble mean(double *v, int len)\n{\n\tdouble sum = 0;\n\tint i;\n\tfor (i = 0; i < len; i++)\n\t\tsum += v[i];\n\treturn sum \/ len;\n}\n\nint main(void)\n{\n\tdouble v[] = {1, 2, 2.718, 3, 3.142};\n\tint i, len;\n\tfor (len = 5; len >= 0; len--) {\n\t\tprintf(\"mean[\");\n\t\tfor (i = 0; i < len; i++)\n\t\t\tprintf(i ? \", %g\" : \"%g\", v[i]);\n\t\tprintf(\"] = %g\\n\", mean(v, len));\n\t}\n\n\treturn 0;\n}\n","Rust":"fn sum(arr: &[f64]) -> f64 {\n arr.iter().fold(0.0, |p,&q| p + q)\n}\n\nfn mean(arr: &[f64]) -> f64 {\n sum(arr) \/ arr.len() as f64\n}\n\nfn main() {\n let v = &[2.0, 3.0, 5.0, 7.0, 13.0, 21.0, 33.0, 54.0];\n println!(\"mean of {:?}: {:?}\", v, mean(v));\n\n let w = &[];\n println!(\"mean of {:?}: {:?}\", w, mean(w));\n}\n"} {"name":"Averages_Mean angle","C":"#include\n#include\n\ndouble\nmeanAngle (double *angles, int size)\n{\n double y_part = 0, x_part = 0;\n int i;\n\n for (i = 0; i < size; i++)\n {\n x_part += cos (angles[i] * M_PI \/ 180);\n y_part += sin (angles[i] * M_PI \/ 180);\n }\n\n return atan2 (y_part \/ size, x_part \/ size) * 180 \/ M_PI;\n}\n\nint\nmain ()\n{\n double angleSet1[] = { 350, 10 };\n double angleSet2[] = { 90, 180, 270, 360};\n double angleSet3[] = { 10, 20, 30};\n\n printf (\"\\nMean Angle for 1st set\u00a0: %lf degrees\", meanAngle (angleSet1, 2));\n printf (\"\\nMean Angle for 2nd set\u00a0: %lf degrees\", meanAngle (angleSet2, 4));\n printf (\"\\nMean Angle for 3rd set\u00a0: %lf degrees\\n\", meanAngle (angleSet3, 3));\n return 0;\n}\n","Rust":"use std::f64;\n\n\n\nfn mean_angle(angles: &[f64]) -> f64 {\n let length: f64 = angles.len() as f64;\n let cos_mean: f64 = angles.iter().fold(0.0, |sum, i| sum + i.to_radians().cos()) \/ length;\n let sin_mean: f64 = angles.iter().fold(0.0, |sum, i| sum + i.to_radians().sin()) \/ length;\n (sin_mean).atan2(cos_mean).to_degrees()\n}\n\nfn main() {\n let angles1 = [350.0_f64, 10.0];\n let angles2 = [90.0_f64, 180.0, 270.0, 360.0];\n let angles3 = [10.0_f64, 20.0, 30.0];\n println!(\"Mean Angle for {:?} is {:.5} degrees\",\n &angles1,\n mean_angle(&angles1));\n println!(\"Mean Angle for {:?} is {:.5} degrees\",\n &angles2,\n mean_angle(&angles2));\n println!(\"Mean Angle for {:?} is {:.5} degrees\",\n &angles3,\n mean_angle(&angles3));\n}\n\nmacro_rules! assert_diff{\n ($x: expr,$y : expr, $diff :expr)=>{\n if ( $x - $y ).abs() > $diff {\n panic!(\"floating point difference is to big {}\", $x - $y );\n }\n }\n}\n\n#[test]\nfn calculate() {\n let angles1 = [350.0_f64, 10.0];\n let angles2 = [90.0_f64, 180.0, 270.0, 360.0];\n let angles3 = [10.0_f64, 20.0, 30.0];\n assert_diff!(0.0, mean_angle(&angles1), 0.001);\n assert_diff!(-90.0, mean_angle(&angles2), 0.001);\n assert_diff!(20.0, mean_angle(&angles3), 0.001);\n}\n"} {"name":"Averages_Mean time of day","C":"#include\n#include\n#include\n\ntypedef struct\n{\n int hour, minute, second;\n} digitime;\n\ndouble\ntimeToDegrees (digitime time)\n{\n return (360 * time.hour \/ 24.0 + 360 * time.minute \/ (24 * 60.0) +\n 360 * time.second \/ (24 * 3600.0));\n}\n\ndigitime\ntimeFromDegrees (double angle)\n{\n digitime d;\n double totalSeconds = 24 * 60 * 60 * angle \/ 360;\n\n d.second = (int) totalSeconds % 60;\n d.minute = ((int) totalSeconds % 3600 - d.second) \/ 60;\n d.hour = (int) totalSeconds \/ 3600;\n\n return d;\n}\n\ndouble\nmeanAngle (double *angles, int size)\n{\n double y_part = 0, x_part = 0;\n int i;\n\n for (i = 0; i < size; i++)\n {\n x_part += cos (angles[i] * M_PI \/ 180);\n y_part += sin (angles[i] * M_PI \/ 180);\n }\n\n return atan2 (y_part \/ size, x_part \/ size) * 180 \/ M_PI;\n}\n\nint\nmain ()\n{\n digitime *set, meanTime;\n int inputs, i;\n double *angleSet, angleMean;\n\n printf (\"Enter number of inputs\u00a0: \");\n scanf (\"%d\", &inputs);\n set = malloc (inputs * sizeof (digitime));\n angleSet = malloc (inputs * sizeof (double));\n printf (\"\\n\\nEnter the data separated by a space between each unit\u00a0: \");\n\n for (i = 0; i < inputs; i++)\n {\n scanf (\"%d:%d:%d\", &set[i].hour, &set[i].minute, &set[i].second);\n angleSet[i] = timeToDegrees (set[i]);\n }\n\n meanTime = timeFromDegrees (360 + meanAngle (angleSet, inputs));\n\n printf (\"\\n\\nThe mean time is\u00a0: %d:%d:%d\", meanTime.hour, meanTime.minute,\n meanTime.second);\n return 0;\n}\n","Rust":"use std::f64::consts::PI;\n\n#[derive(Debug, PartialEq, Eq)]\nstruct Time {\n h: u8,\n m: u8,\n s: u8,\n}\n\nimpl Time {\n \n fn from_radians(mut rads: f64) -> Time {\n rads %= 2.0 * PI;\n if rads < 0.0 {\n rads += 2.0 * PI\n }\n Time {\n h: (rads * 12.0 \/ PI) as u8,\n m: ((rads * 720.0 \/ PI) % 60.0) as u8,\n s: ((rads * 43200.0 \/ PI) % 60.0).round() as u8,\n }\n }\n\n \n fn from_parts(h: u8, m: u8, s: u8) -> Result {\n if h > 23 || m > 59 || s > 59 {\n return Err(());\n }\n Ok(Time { h, m, s })\n }\n\n \n fn as_radians(&self) -> f64 {\n ((self.h as f64 \/ 12.0) + (self.m as f64 \/ 720.0) + (self.s as f64 \/ 43200.0)) * PI\n }\n}\n\n\nfn mean_time(times: &[Time]) -> Time {\n \n let (ss, sc) = times\n .iter()\n .map(Time::as_radians)\n .map(|a| (a.sin(), a.cos()))\n .fold((0.0, 0.0), |(ss, sc), (s, c)| (ss + s, sc + c));\n \n Time::from_radians(ss.atan2(sc))\n}\n\nfn main() {\n let times = [\n Time::from_parts(23, 00, 17).unwrap(),\n Time::from_parts(23, 40, 20).unwrap(),\n Time::from_parts(00, 12, 45).unwrap(),\n Time::from_parts(00, 17, 19).unwrap(),\n ];\n\n let mean = mean_time(×);\n\n println!(\"{:02}:{:02}:{:02}\", mean.h, mean.m, mean.s);\n}\n"} {"name":"Averages_Median","C":"#include \n#include \n\ntypedef struct floatList {\n float *list;\n int size;\n} *FloatList;\n\nint floatcmp( const void *a, const void *b) {\n if (*(const float *)a < *(const float *)b) return -1;\n else return *(const float *)a > *(const float *)b;\n}\n\nfloat median( FloatList fl )\n{\n qsort( fl->list, fl->size, sizeof(float), floatcmp);\n return 0.5 * ( fl->list[fl->size\/2] + fl->list[(fl->size-1)\/2]);\n}\n\nint main()\n{\n static float floats1[] = { 5.1, 2.6, 6.2, 8.8, 4.6, 4.1 };\n static struct floatList flist1 = { floats1, sizeof(floats1)\/sizeof(float) };\n\n static float floats2[] = { 5.1, 2.6, 8.8, 4.6, 4.1 };\n static struct floatList flist2 = { floats2, sizeof(floats2)\/sizeof(float) };\n\n printf(\"flist1 median is %7.2f\\n\", median(&flist1)); \n printf(\"flist2 median is %7.2f\\n\", median(&flist2)); \n return 0;\n}\n","Rust":"fn median(mut xs: Vec) -> f64 {\n \n xs.sort_by(|x,y| x.partial_cmp(y).unwrap() );\n let n = xs.len();\n if n % 2 == 0 {\n (xs[n\/2] + xs[n\/2 - 1]) \/ 2.0\n } else {\n xs[n\/2]\n }\n}\n\nfn main() {\n let nums = vec![2.,3.,5.,0.,9.,82.,353.,32.,12.];\n println!(\"{:?}\", median(nums))\n}\n"} {"name":"Averages_Mode","C":"#include \n#include \n\ntypedef struct { double v; int c; } vcount;\n\nint cmp_dbl(const void *a, const void *b)\n{\n\tdouble x = *(const double*)a - *(const double*)b;\n\treturn x < 0 ? -1 : x > 0;\n}\n\nint vc_cmp(const void *a, const void *b)\n{\n\treturn ((const vcount*)b)->c - ((const vcount*)a)->c;\n}\n\nint get_mode(double* x, int len, vcount **list)\n{\n\tint i, j;\n\tvcount *vc;\n\n\t\n\tqsort(x, len, sizeof(double), cmp_dbl);\n\n\t\n\tfor (i = 0, j = 1; i < len - 1; i++, j += (x[i] != x[i + 1]));\n\n\t*list = vc = malloc(sizeof(vcount) * j);\n\tvc[0].v = x[0];\n\tvc[0].c = 1;\n\n\t\n\tfor (i = j = 0; i < len - 1; i++, vc[j].c++)\n\t\tif (x[i] != x[i + 1]) vc[++j].v = x[i + 1];\n\n\t\n\tqsort(vc, j + 1, sizeof(vcount), vc_cmp);\n\n\t\n\tfor (i = 0; i <= j && vc[i].c == vc[0].c; i++);\n\n\treturn i;\n}\n\nint main()\n{\n\tdouble values[] = { 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 12, 12, 17 };\n#\tdefine len sizeof(values)\/sizeof(double)\n\tvcount *vc;\n\n\tint i, n_modes = get_mode(values, len, &vc);\n\n\tprintf(\"got %d modes:\\n\", n_modes);\n\tfor (i = 0; i < n_modes; i++)\n\t\tprintf(\"\\tvalue = %g, count = %d\\n\", vc[i].v, vc[i].c);\n\n\tfree(vc);\n\treturn 0;\n}\n","Rust":"use std::collections::HashMap;\n\nfn main() {\n let mode_vec1 = mode(vec![ 1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]);\n let mode_vec2 = mode(vec![ 1, 1, 2, 4, 4]);\n\n println!(\"Mode of vec1 is: {:?}\", mode_vec1);\n println!(\"Mode of vec2 is: {:?}\", mode_vec2);\n\n assert!( mode_vec1 == [6], \"Error in mode calculation\");\n assert!( (mode_vec2 == [1, 4]) || (mode_vec2 == [4,1]), \"Error in mode calculation\" );\n}\n\nfn mode(vs: Vec) -> Vec {\n let mut vec_mode = Vec::new();\n let mut seen_map = HashMap::new();\n let mut max_val = 0;\n for i in vs{\n let ctr = seen_map.entry(i).or_insert(0);\n *ctr += 1;\n if *ctr > max_val{\n max_val = *ctr;\n }\n }\n for (key, val) in seen_map {\n if val == max_val{\n vec_mode.push(key);\n }\n }\n vec_mode\n}\n"} {"name":"Averages_Pythagorean means","C":"#include \n#include \n#include \n\nint main(int argc, char* argv[])\n{\n int i, count=0;\n double f, sum=0.0, prod=1.0, resum=0.0;\n\n for (i=1; i= gmean) && (gmean >= hmean) ), \"Incorrect calculation\");\n\n}\n"} {"name":"Averages_Root mean square","C":"#include \n#include \n\ndouble rms(double *v, int n)\n{\n int i;\n double sum = 0.0;\n for(i = 0; i < n; i++)\n sum += v[i] * v[i];\n return sqrt(sum \/ n);\n}\n\nint main(void)\n{\n double v[] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};\n printf(\"%f\\n\", rms(v, sizeof(v)\/sizeof(double)));\n return 0;\n}\n","Rust":"fn root_mean_square(vec: Vec) -> f32 {\n let sum_squares = vec.iter().fold(0, |acc, &x| acc + x.pow(2));\n return ((sum_squares as f32)\/(vec.len() as f32)).sqrt();\n}\n\nfn main() {\n let vec = (1..11).collect();\n println!(\"The root mean square is: {}\", root_mean_square(vec));\n}\n"} {"name":"Averages_Simple moving average","C":"#include \n#include \n#include \n\ntypedef struct sma_obj {\n double sma;\n double sum;\n int period;\n double *values;\n int lv;\n} sma_obj_t;\n\ntypedef union sma_result {\n sma_obj_t *handle;\n double sma;\n double *values;\n} sma_result_t;\n\nenum Action { SMA_NEW, SMA_FREE, SMA_VALUES, SMA_ADD, SMA_MEAN };\nsma_result_t sma(enum Action action, ...)\n{\n va_list vl;\n sma_result_t r;\n sma_obj_t *o;\n double v;\n\n va_start(vl, action);\n switch(action) {\n case SMA_NEW: \n r.handle = malloc(sizeof(sma_obj_t));\n r.handle->sma = 0.0;\n r.handle->period = va_arg(vl, int);\n r.handle->values = malloc(r.handle->period * sizeof(double));\n r.handle->lv = 0;\n r.handle->sum = 0.0;\n break;\n case SMA_FREE: \n r.handle = va_arg(vl, sma_obj_t *);\n free(r.handle->values);\n free(r.handle);\n r.handle = NULL;\n break;\n case SMA_VALUES: \n o = va_arg(vl, sma_obj_t *);\n r.values = o->values;\n break;\n case SMA_MEAN: \n o = va_arg(vl, sma_obj_t *);\n r.sma = o->sma;\n break;\n case SMA_ADD: \n o = va_arg(vl, sma_obj_t *);\n v = va_arg(vl, double);\n if ( o->lv < o->period ) {\n o->values[o->lv++] = v;\n o->sum += v;\n o->sma = o->sum \/ o->lv;\n } else {\n o->sum -= o->values[ o->lv % o->period];\n o->sum += v;\n o->sma = o->sum \/ o->period;\n o->values[ o->lv % o->period ] = v; o->lv++;\n }\n r.sma = o->sma;\n break;\n }\n va_end(vl);\n return r;\n}\n","Rust":"struct SimpleMovingAverage {\n period: usize,\n numbers: Vec\n}\n\nimpl SimpleMovingAverage {\n fn new(p: usize) -> SimpleMovingAverage {\n SimpleMovingAverage {\n period: p,\n numbers: Vec::new()\n }\n }\n\n fn add_number(&mut self, number: usize) -> f64 {\n self.numbers.push(number);\n \n if self.numbers.len() > self.period {\n self.numbers.remove(0);\n }\n \n if self.numbers.is_empty() {\n return 0f64;\n }else {\n let sum = self.numbers.iter().fold(0, |acc, x| acc+x);\n return sum as f64 \/ self.numbers.len() as f64;\n }\n }\n}\n\nfn main() {\n for period in [3, 5].iter() {\n println!(\"Moving average with period {}\", period);\n\n let mut sma = SimpleMovingAverage::new(*period);\n for i in [1, 2, 3, 4, 5, 5, 4, 3, 2, 1].iter() {\n println!(\"Number: {} | Average: {}\", i, sma.add_number(*i));\n }\n }\n}\n"} {"name":"Babbage problem","C":"\n\n#include \n#include \n#include \n \nint main() {\n\tint current = 0, \t\n\t square;\t\t\n\n\t\n\t\n\twhile (((square=current*current) % 1000000 != 269696) && (square+INT_MAX)\n\t printf(\"Condition not satisfied before INT_MAX reached.\");\n\telse\t\t \n\t printf (\"The smallest number whose square ends in 269696 is %d\\n\", current);\n\t \n \n\treturn 0 ;\n}\n","Rust":"fn main() {\n let mut current = 0;\n while (current * current) % 1_000_000 != 269_696 {\n current += 1;\n }\n println!(\n \"The smallest number whose square ends in 269696 is {}\",\n current\n );\n}\n"} {"name":"Balanced brackets","C":"#include\n#include\n#include\n\nint isBal(const char*s,int l){\n signed c=0;\n while(l--)\n\tif(s[l]==']') ++c;\n\telse if(s[l]=='[') if(--c<0) break;\n return !c;\n}\n\nvoid shuffle(char*s,int h){\n int x,t,i=h;\n while(i--){\n\tt=s[x=rand()%h];\n\ts[x]=s[i];\n\ts[i]=t;\n }\n}\n\nvoid genSeq(char*s,int n){\n if(n){\n\tmemset(s,'[',n);\n\tmemset(s+n,']',n);\n\tshuffle(s,n*2);\n }\n s[n*2]=0;\n}\n\nvoid doSeq(int n){\n char s[64];\n const char *o=\"False\";\n genSeq(s,n);\n if(isBal(s,n*2)) o=\"True\";\n printf(\"'%s': %s\\n\",s,o);\n}\n\nint main(){\n int n=0;\n while(n<9) doSeq(n++);\n return 0;\n}\n","Rust":"extern crate rand;\n\ntrait Balanced {\n \n fn is_balanced(&self) -> bool;\n}\n\nimpl<'a> Balanced for str {\n fn is_balanced(&self) -> bool {\n let mut count = 0;\n\n for bracket in self.chars() {\n let change = match bracket {\n '[' => 1,\n ']' => -1,\n _ => panic!(\"Strings should only contain brackets\")\n };\n\n count += change;\n if count < 0 { return false; }\n }\n\n count == 0\n }\n}\n\n\nfn generate_brackets(num: usize) -> String {\n use rand::random;\n\n (0..num).map(|_| if random() { '[' } else { ']' }).collect()\n}\n\nfn main() {\n for i in (0..10) {\n let brackets = generate_brackets(i);\n\n println!(\"{} {}\", brackets, brackets.is_balanced())\n }\n}\n"} {"name":"Balanced ternary","C":"#include \n#include \n\nvoid reverse(char *p) {\n size_t len = strlen(p);\n char *r = p + len - 1;\n while (p < r) {\n *p ^= *r;\n *r ^= *p;\n *p++ ^= *r--;\n }\n}\n\nvoid to_bt(int n, char *b) {\n static char d[] = { '0', '+', '-' };\n static int v[] = { 0, 1, -1 };\n\n char *ptr = b;\n *ptr = 0;\n\n while (n) {\n int r = n % 3;\n if (r < 0) {\n r += 3;\n }\n\n *ptr = d[r];\n *(++ptr) = 0;\n\n n -= v[r];\n n \/= 3;\n }\n\n reverse(b);\n}\n\nint from_bt(const char *a) {\n int n = 0;\n\n while (*a != '\\0') {\n n *= 3;\n if (*a == '+') {\n n++;\n } else if (*a == '-') {\n n--;\n }\n a++;\n }\n\n return n;\n}\n\nchar last_char(char *ptr) {\n char c;\n\n if (ptr == NULL || *ptr == '\\0') {\n return '\\0';\n }\n\n while (*ptr != '\\0') {\n ptr++;\n }\n ptr--;\n\n c = *ptr;\n *ptr = 0;\n return c;\n}\n\nvoid add(const char *b1, const char *b2, char *out) {\n if (*b1 != '\\0' && *b2 != '\\0') {\n char c1[16];\n char c2[16];\n char ob1[16];\n char ob2[16];\n char d[3] = { 0, 0, 0 };\n char L1, L2;\n\n strcpy(c1, b1);\n strcpy(c2, b2);\n L1 = last_char(c1);\n L2 = last_char(c2);\n if (L2 < L1) {\n L2 ^= L1;\n L1 ^= L2;\n L2 ^= L1;\n }\n\n if (L1 == '-') {\n if (L2 == '0') {\n d[0] = '-';\n }\n if (L2 == '-') {\n d[0] = '+';\n d[1] = '-';\n }\n }\n if (L1 == '+') {\n if (L2 == '0') {\n d[0] = '+';\n }\n if (L2 == '-') {\n d[0] = '0';\n }\n if (L2 == '+') {\n d[0] = '-';\n d[1] = '+';\n }\n }\n if (L1 == '0') {\n if (L2 == '0') {\n d[0] = '0';\n }\n }\n\n add(c1, &d[1], ob1);\n add(ob1, c2, ob2);\n strcpy(out, ob2);\n\n d[1] = 0;\n strcat(out, d);\n } else if (*b1 != '\\0') {\n strcpy(out, b1);\n } else if (*b2 != '\\0') {\n strcpy(out, b2);\n } else {\n *out = '\\0';\n }\n}\n\nvoid unary_minus(const char *b, char *out) {\n while (*b != '\\0') {\n if (*b == '-') {\n *out++ = '+';\n b++;\n } else if (*b == '+') {\n *out++ = '-';\n b++;\n } else {\n *out++ = *b++;\n }\n }\n *out = '\\0';\n}\n\nvoid subtract(const char *b1, const char *b2, char *out) {\n char buf[16];\n unary_minus(b2, buf);\n add(b1, buf, out);\n}\n\nvoid mult(const char *b1, const char *b2, char *out) {\n char r[16] = \"0\";\n char t[16];\n char c1[16];\n char c2[16];\n char *ptr = c2;\n\n strcpy(c1, b1);\n strcpy(c2, b2);\n\n reverse(c2);\n\n while (*ptr != '\\0') {\n if (*ptr == '+') {\n add(r, c1, t);\n strcpy(r, t);\n }\n if (*ptr == '-') {\n subtract(r, c1, t);\n strcpy(r, t);\n }\n strcat(c1, \"0\");\n\n ptr++;\n }\n\n ptr = r;\n while (*ptr == '0') {\n ptr++;\n }\n strcpy(out, ptr);\n}\n\nint main() {\n const char *a = \"+-0++0+\";\n char b[16];\n const char *c = \"+-++-\";\n char t[16];\n char d[16];\n\n to_bt(-436, b);\n subtract(b, c, t);\n mult(a, t, d);\n\n printf(\" a: %14s %10d\\n\", a, from_bt(a));\n printf(\" b: %14s %10d\\n\", b, from_bt(b));\n printf(\" c: %14s %10d\\n\", c, from_bt(c));\n printf(\"a*(b-c): %14s %10d\\n\", d, from_bt(d));\n\n return 0;\n}\n","Rust":"use std::{\n cmp::min,\n convert::{TryFrom, TryInto},\n fmt,\n ops::{Add, Mul, Neg},\n str::FromStr,\n};\n\nfn main() -> Result<(), &'static str> {\n let a = BalancedTernary::from_str(\"+-0++0+\")?;\n let b = BalancedTernary::from(-436);\n let c = BalancedTernary::from_str(\"+-++-\")?;\n println!(\"a = {} = {}\", a, i128::try_from(a.clone())?);\n println!(\"b = {} = {}\", b, i128::try_from(b.clone())?);\n println!(\"c = {} = {}\", c, i128::try_from(c.clone())?);\n\n let d = a * (b + -c);\n println!(\"a * (b - c) = {} = {}\", d, i128::try_from(d.clone())?);\n\n let e = BalancedTernary::from_str(\n \"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\",\n )?;\n assert_eq!(i128::try_from(e).is_err(), true);\n\n Ok(())\n}\n\n#[derive(Clone, Copy, PartialEq)]\nenum Trit {\n Zero,\n Pos,\n Neg,\n}\n\nimpl TryFrom for Trit {\n type Error = &'static str;\n\n fn try_from(value: char) -> Result {\n match value {\n '0' => Ok(Self::Zero),\n '+' => Ok(Self::Pos),\n '-' => Ok(Self::Neg),\n _ => Err(\"Invalid character for balanced ternary\"),\n }\n }\n}\n\nimpl From for char {\n fn from(x: Trit) -> Self {\n match x {\n Trit::Zero => '0',\n Trit::Pos => '+',\n Trit::Neg => '-',\n }\n }\n}\n\nimpl Add for Trit {\n \n type Output = (Self, Self);\n\n fn add(self, rhs: Self) -> Self::Output {\n use Trit::{Neg, Pos, Zero};\n match (self, rhs) {\n (Zero, x) | (x, Zero) => (Zero, x),\n (Pos, Neg) | (Neg, Pos) => (Zero, Zero),\n (Pos, Pos) => (Pos, Neg),\n (Neg, Neg) => (Neg, Pos),\n }\n }\n}\n\nimpl Mul for Trit {\n type Output = Self;\n\n fn mul(self, rhs: Self) -> Self::Output {\n use Trit::{Neg, Pos, Zero};\n match (self, rhs) {\n (Zero, _) | (_, Zero) => Zero,\n (Pos, Pos) | (Neg, Neg) => Pos,\n (Pos, Neg) | (Neg, Pos) => Neg,\n }\n }\n}\n\nimpl Neg for Trit {\n type Output = Self;\n\n fn neg(self) -> Self::Output {\n match self {\n Trit::Zero => Trit::Zero,\n Trit::Pos => Trit::Neg,\n Trit::Neg => Trit::Pos,\n }\n }\n}\n\n\n\n#[derive(Clone)]\nstruct BalancedTernary(Vec);\n\nimpl fmt::Display for BalancedTernary {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(\n f,\n \"{}\",\n self.0\n .iter()\n .rev()\n .map(|&d| char::from(d))\n .collect::()\n )\n }\n}\n\nimpl Add for BalancedTernary {\n type Output = Self;\n\n fn add(self, rhs: Self) -> Self::Output {\n use Trit::Zero;\n\n \n fn trim(v: &mut Vec) {\n while let Some(last_elem) = v.pop() {\n if last_elem != Zero {\n v.push(last_elem);\n break;\n }\n }\n }\n\n if rhs.0.is_empty() {\n \n if self.0.is_empty() {\n return BalancedTernary(vec![Zero]);\n }\n return self;\n }\n\n let length = min(self.0.len(), rhs.0.len());\n let mut sum = Vec::new();\n let mut carry = vec![Zero];\n\n for i in 0..length {\n let (carry_dig, digit) = self.0[i] + rhs.0[i];\n sum.push(digit);\n carry.push(carry_dig);\n }\n \n for i in length..self.0.len() {\n sum.push(self.0[i]);\n }\n for i in length..rhs.0.len() {\n sum.push(rhs.0[i]);\n }\n\n trim(&mut sum);\n trim(&mut carry);\n\n BalancedTernary(sum) + BalancedTernary(carry)\n }\n}\n\n\nimpl Mul for BalancedTernary {\n type Output = Self;\n\n fn mul(self, rhs: Self) -> Self::Output {\n let mut results = Vec::with_capacity(rhs.0.len());\n for i in 0..rhs.0.len() {\n let mut digits = vec![Trit::Zero; i];\n for j in 0..self.0.len() {\n digits.push(self.0[j] * rhs.0[i]);\n }\n results.push(BalancedTernary(digits));\n }\n #[allow(clippy::suspicious_arithmetic_impl)]\n results\n .into_iter()\n .fold(BalancedTernary(vec![Trit::Zero]), |acc, x| acc + x)\n }\n}\n\nimpl Neg for BalancedTernary {\n type Output = Self;\n\n fn neg(self) -> Self::Output {\n BalancedTernary(self.0.iter().map(|&x| -x).collect())\n }\n}\n\nimpl FromStr for BalancedTernary {\n type Err = &'static str;\n\n fn from_str(s: &str) -> Result {\n s.chars()\n .rev()\n .map(|c| c.try_into())\n .collect::>()\n .map(BalancedTernary)\n }\n}\n\nimpl From for BalancedTernary {\n fn from(x: i128) -> Self {\n let mut v = Vec::new();\n let mut curr = x;\n\n loop {\n let rem = curr % 3;\n\n match rem {\n 0 => v.push(Trit::Zero),\n 1 | -2 => v.push(Trit::Pos),\n 2 | -1 => v.push(Trit::Neg),\n _ => unreachable!(),\n }\n\n let offset = (rem as f64 \/ 3.0).round() as i128;\n curr = curr \/ 3 + offset;\n\n if curr == 0 {\n break;\n }\n }\n\n BalancedTernary(v)\n }\n}\n\nimpl TryFrom for i128 {\n type Error = &'static str;\n\n fn try_from(value: BalancedTernary) -> Result {\n value\n .0\n .iter()\n .enumerate()\n .try_fold(0_i128, |acc, (i, character)| {\n let size_err = \"Balanced ternary string is too large to fit into 16 bytes\";\n let index: u32 = i.try_into().map_err(|_| size_err)?;\n\n match character {\n Trit::Zero => Ok(acc),\n Trit::Pos => 3_i128\n .checked_pow(index)\n .and_then(|x| acc.checked_add(x))\n .ok_or(size_err),\n Trit::Neg => 3_i128\n .checked_pow(index)\n .and_then(|x| acc.checked_sub(x))\n .ok_or(size_err),\n }\n })\n }\n}\n"} {"name":"Barnsley fern","C":"#include\n#include\n#include\n#include\n\nvoid barnsleyFern(int windowWidth, unsigned long iter){\n\t\n\tdouble x0=0,y0=0,x1,y1;\n\tint diceThrow;\n\ttime_t t;\n\tsrand((unsigned)time(&t));\n\t\n\twhile(iter>0){\n\t\tdiceThrow = rand()%100;\n\t\t\n\t\tif(diceThrow==0){\n\t\t\tx1 = 0;\n\t\t\ty1 = 0.16*y0;\n\t\t}\n\t\t\n\t\telse if(diceThrow>=1 && diceThrow<=7){\n\t\t\tx1 = -0.15*x0 + 0.28*y0;\n\t\t\ty1 = 0.26*x0 + 0.24*y0 + 0.44;\n\t\t}\n\t\t\n\t\telse if(diceThrow>=8 && diceThrow<=15){\n\t\t\tx1 = 0.2*x0 - 0.26*y0;\n\t\t\ty1 = 0.23*x0 + 0.22*y0 + 1.6;\n\t\t}\n\t\t\n\t\telse{\n\t\t\tx1 = 0.85*x0 + 0.04*y0;\n\t\t\ty1 = -0.04*x0 + 0.85*y0 + 1.6;\n\t\t}\n\t\t\n\t\tputpixel(30*x1 + windowWidth\/2.0,30*y1,GREEN);\n\t\t\n\t\tx0 = x1;\n\t\ty0 = y1;\n\t\t\n\t\titer--;\n\t}\n\n}\n\nint main()\n{\n\tunsigned long num;\n\t\n\tprintf(\"Enter number of iterations\u00a0: \");\n\tscanf(\"%ld\",&num);\n\t\n\tinitwindow(500,500,\"Barnsley Fern\");\n\t\n\tbarnsleyFern(500,num);\n\t\n\tgetch();\n\t\n\tclosegraph();\n\t\n\treturn 0;\n}\n","Rust":"extern crate rand;\nextern crate raster;\n\nuse rand::Rng;\n\nfn main() {\n let max_iterations = 200_000u32;\n let height = 640i32;\n let width = 640i32;\n\n let mut rng = rand::thread_rng();\n let mut image = raster::Image::blank(width, height);\n raster::editor::fill(&mut image, raster::Color::white()).unwrap();\n\n let mut x = 0.;\n let mut y = 0.;\n for _ in 0..max_iterations {\n let r = rng.gen::();\n let cx: f64;\n let cy: f64;\n\n if r <= 0.01 {\n cx = 0f64;\n cy = 0.16 * y as f64;\n } else if r <= 0.08 {\n cx = 0.2 * x as f64 - 0.26 * y as f64;\n cy = 0.23 * x as f64 + 0.22 * y as f64 + 1.6;\n } else if r <= 0.15 {\n cx = -0.15 * x as f64 + 0.28 * y as f64;\n cy = 0.26 * x as f64 + 0.26 * y as f64 + 0.44;\n } else {\n cx = 0.85 * x as f64 + 0.04 * y as f64;\n cy = -0.04 * x as f64 + 0.85 * y as f64 + 1.6;\n }\n x = cx;\n y = cy;\n\n let _ = image.set_pixel(\n ((width as f64) \/ 2. + x * (width as f64) \/ 11.).round() as i32,\n ((height as f64) - y * (height as f64) \/ 11.).round() as i32,\n raster::Color::rgb(50, 205, 50));\n }\n\n raster::save(&image, \"fractal.png\").unwrap();\n}\n"} {"name":"Base64 decode data","C":"#include \n#include \n\ntypedef unsigned char ubyte;\nconst ubyte BASE64[] = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+\/\";\n\nint findIndex(const ubyte val) {\n if ('A' <= val && val <= 'Z') {\n return val - 'A';\n }\n if ('a' <= val && val <= 'z') {\n return val - 'a' + 26;\n }\n if ('0' <= val && val <= '9') {\n return val - '0' + 52;\n }\n if (val == '+') {\n return 62;\n }\n if (val == '\/') {\n return 63;\n }\n return -1;\n}\n\nint decode(const ubyte source[], ubyte sink[]) {\n const size_t length = strlen(source);\n const ubyte *it = source;\n const ubyte *end = source + length;\n int acc;\n\n if (length % 4 != 0) {\n return 1;\n }\n\n while (it != end) {\n const ubyte b1 = *it++;\n const ubyte b2 = *it++;\n const ubyte b3 = *it++; \n const ubyte b4 = *it++; \n\n const int i1 = findIndex(b1);\n const int i2 = findIndex(b2);\n\n acc = i1 << 2; \n acc |= i2 >> 4; \n *sink++ = acc; \n\n if (b3 != '=') {\n const int i3 = findIndex(b3);\n\n acc = (i2 & 0xF) << 4; \n acc += i3 >> 2; \n *sink++ = acc; \n\n if (b4 != '=') {\n const int i4 = findIndex(b4);\n\n acc = (i3 & 0x3) << 6; \n acc |= i4; \n *sink++ = acc; \n }\n }\n }\n\n *sink = '\\0'; \n return 0;\n}\n\nint main() {\n ubyte data[] = \"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo\";\n ubyte decoded[1024];\n\n printf(\"%s\\n\\n\", data);\n decode(data, decoded);\n printf(\"%s\\n\\n\", decoded);\n\n return 0;\n}\n","Rust":"use std::str;\n\nconst INPUT: &str = \"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo\";\nconst UPPERCASE_OFFSET: i8 = -65;\nconst LOWERCASE_OFFSET: i8 = 26 - 97;\nconst NUM_OFFSET: i8 = 52 - 48;\n\nfn main() {\n println!(\"Input: {}\", INPUT);\n\n let result = INPUT.chars()\n .filter(|&ch| ch != '=') \n .map(|ch| { \n let ascii = ch as i8; \n let convert = match ch {\n '0' ... '9' => ascii + NUM_OFFSET,\n 'a' ... 'z' => ascii + LOWERCASE_OFFSET,\n 'A' ... 'Z' => ascii + UPPERCASE_OFFSET,\n '+' => 62,\n '\/' => 63,\n _ => panic!(\"Not a valid base64 encoded string\")\n };\n format!(\"{:#08b}\", convert)[2..].to_string() \n })\n .collect::() \n .chars()\n .collect::>()\n .chunks(8) \n .map(|chunk| {\n let num_str = chunk.iter().collect::();\n usize::from_str_radix(&num_str, 2).unwrap() as u8 \n })\n .collect::>();\n\n let result = str::from_utf8(&result).unwrap(); \n\n println!(\"Output: {}\", result);\n}\n"} {"name":"Bell numbers","C":"#include \n#include \n\n\nsize_t bellIndex(int row, int col) {\n return row * (row - 1) \/ 2 + col;\n}\n\nint getBell(int *bellTri, int row, int col) {\n size_t index = bellIndex(row, col);\n return bellTri[index];\n}\n\nvoid setBell(int *bellTri, int row, int col, int value) {\n size_t index = bellIndex(row, col);\n bellTri[index] = value;\n}\n\nint *bellTriangle(int n) {\n size_t length = n * (n + 1) \/ 2;\n int *tri = calloc(length, sizeof(int));\n int i, j;\n\n setBell(tri, 1, 0, 1);\n for (i = 2; i <= n; ++i) {\n setBell(tri, i, 0, getBell(tri, i - 1, i - 2));\n for (j = 1; j < i; ++j) {\n int value = getBell(tri, i, j - 1) + getBell(tri, i - 1, j - 1);\n setBell(tri, i, j, value);\n }\n }\n\n return tri;\n}\n\nint main() {\n const int rows = 15;\n int *bt = bellTriangle(rows);\n int i, j;\n\n printf(\"First fifteen Bell numbers:\\n\");\n for (i = 1; i <= rows; ++i) {\n printf(\"%2d: %d\\n\", i, getBell(bt, i, 0));\n }\n\n printf(\"\\nThe first ten rows of Bell's triangle:\\n\");\n for (i = 1; i <= 10; ++i) {\n printf(\"%d\", getBell(bt, i, 0));\n for (j = 1; j < i; ++j) {\n printf(\", %d\", getBell(bt, i, j));\n }\n printf(\"\\n\");\n }\n\n free(bt);\n return 0;\n}\n","Rust":"use num::BigUint;\n\nfn main() {\n let bt = bell_triangle(51);\n \n for i in 1..=15 {\n println!(\"{}: {}\", i, bt[i][0]);\n }\n\n \n println!(\"50: {}\", bt[50][0])\n}\n\nfn bell_triangle(n: usize) -> Vec> {\n let mut tri: Vec> = Vec::with_capacity(n);\n for i in 0..n {\n let v = vec![BigUint::from(0u32); i];\n tri.push(v);\n }\n tri[1][0] = BigUint::from(1u32);\n\n for i in 2..n {\n tri[i][0] = BigUint::from_bytes_be(&tri[i - 1][i - 2].to_bytes_be());\n for j in 1..i {\n let added_big_uint = &tri[i][j - 1] + &tri[i - 1][j - 1];\n tri[i][j] = BigUint::from_bytes_be(&added_big_uint.to_bytes_be());\n }\n }\n\n tri\n}\n"} {"name":"Bernoulli numbers","C":"#include \n#include \n\n#define mpq_for(buf, op, n)\\\n do {\\\n size_t i;\\\n for (i = 0; i < (n); ++i)\\\n mpq_##op(buf[i]);\\\n } while (0)\n\nvoid bernoulli(mpq_t rop, unsigned int n)\n{\n unsigned int m, j;\n mpq_t *a = malloc(sizeof(mpq_t) * (n + 1));\n mpq_for(a, init, n + 1);\n\n for (m = 0; m <= n; ++m) {\n mpq_set_ui(a[m], 1, m + 1);\n for (j = m; j > 0; --j) {\n mpq_sub(a[j-1], a[j], a[j-1]);\n mpq_set_ui(rop, j, 1);\n mpq_mul(a[j-1], a[j-1], rop);\n }\n }\n\n mpq_set(rop, a[0]);\n mpq_for(a, clear, n + 1);\n free(a);\n}\n\nint main(void)\n{\n mpq_t rop;\n mpz_t n, d;\n mpq_init(rop);\n mpz_inits(n, d, NULL);\n\n unsigned int i;\n for (i = 0; i <= 60; ++i) {\n bernoulli(rop, i);\n if (mpq_cmp_ui(rop, 0, 1)) {\n mpq_get_num(n, rop);\n mpq_get_den(d, rop);\n gmp_printf(\"B(%-2u) = %44Zd \/ %Zd\\n\", i, n, d);\n }\n }\n\n mpz_clears(n, d, NULL);\n mpq_clear(rop);\n return 0;\n}\n","Rust":"\n\n\n\n#![feature(test)]\n\nextern crate num;\nextern crate test;\n\nuse num::bigint::{BigInt, ToBigInt};\nuse num::rational::{BigRational};\nuse std::cmp::max;\nuse std::env;\nuse std::ops::{Mul, Sub};\nuse std::process;\n\nstruct Bn {\n value: BigRational,\n index: i32\n}\n\nstruct Context {\n bigone_const: BigInt,\n a: Vec,\n index: i32 \n}\n\nimpl Context {\n pub fn new() -> Context {\n let bigone = 1.to_bigint().unwrap();\n let a_vec: Vec = vec![];\n Context {\n bigone_const: bigone,\n a: a_vec,\n index: -1\n }\n }\n}\n\nimpl Iterator for Context {\n type Item = Bn;\n\n fn next(&mut self) -> Option {\n self.index += 1;\n Some(Bn { value: bernoulli(self.index as usize, self), index: self.index })\n }\n}\n\nfn help() {\n println!(\"Usage: bernoulli_numbers \");\n}\n\nfn main() {\n let args: Vec = env::args().collect();\n let mut up_to: usize = 60;\n\n match args.len() {\n 1 => {},\n 2 => {\n up_to = args[1].parse::().unwrap();\n },\n _ => {\n help();\n process::exit(0);\n }\n }\n\n let context = Context::new();\n \n \n let res = context.take(up_to + 1).collect::>();\n let width = res.iter().fold(0, |a, r| max(a, r.value.numer().to_string().len()));\n\n for r in res.iter().filter(|r| *r.value.numer() != ToBigInt::to_bigint(&0).unwrap()) {\n println!(\"B({:>2}) = {:>2$} \/ {denom}\", r.index, r.value.numer(), width,\n denom = r.value.denom());\n }\n}\n\n\nfn _bernoulli_naive(n: usize, c: &mut Context) -> BigRational {\n for m in 0..n + 1 {\n c.a.push(BigRational::new(c.bigone_const.clone(), (m + 1).to_bigint().unwrap()));\n for j in (1..m + 1).rev() {\n c.a[j - 1] = (c.a[j - 1].clone().sub(c.a[j].clone())).mul(\n BigRational::new(j.to_bigint().unwrap(), c.bigone_const.clone())\n );\n }\n }\n c.a[0].reduced()\n}\n\n\nfn bernoulli(n: usize, c: &mut Context) -> BigRational {\n for i in 0..n + 1 {\n if i >= c.a.len() {\n c.a.push(BigRational::new(c.bigone_const.clone(), (i + 1).to_bigint().unwrap()));\n for j in (1..i + 1).rev() {\n c.a[j - 1] = (c.a[j - 1].clone().sub(c.a[j].clone())).mul(\n BigRational::new(j.to_bigint().unwrap(), c.bigone_const.clone())\n );\n }\n }\n }\n c.a[0].reduced()\n}\n\n\n#[cfg(test)]\nmod tests {\n use super::{Bn, Context, bernoulli, _bernoulli_naive};\n use num::rational::{BigRational};\n use std::str::FromStr;\n use test::Bencher;\n\n \n\n #[bench]\n fn bench_bernoulli_naive(b: &mut Bencher) {\n let mut context = Context::new();\n b.iter(|| {\n let mut res: Vec = vec![];\n for n in 0..30 + 1 {\n let b = _bernoulli_naive(n, &mut context);\n res.push(Bn { value:b.clone(), index: n as i32});\n }\n });\n }\n\n #[bench]\n fn bench_bernoulli(b: &mut Bencher) {\n let mut context = Context::new();\n b.iter(|| {\n let mut res: Vec = vec![];\n for n in 0..30 + 1 {\n let b = bernoulli(n, &mut context);\n res.push(Bn { value:b.clone(), index: n as i32});\n }\n });\n }\n\n #[bench]\n fn bench_bernoulli_iter(b: &mut Bencher) {\n b.iter(|| {\n let context = Context::new();\n let _res = context.take(30 + 1).collect::>();\n });\n }\n}\n"} {"name":"Best shuffle","C":"#include \n#include \n#include \n#include \n#include \n\n#define DEBUG\n\nvoid best_shuffle(const char* txt, char* result) {\n const size_t len = strlen(txt);\n if (len == 0)\n return;\n\n#ifdef DEBUG\n \n assert(len == strlen(result));\n#endif\n\n \n size_t counts[UCHAR_MAX];\n memset(counts, '\\0', UCHAR_MAX * sizeof(int));\n size_t fmax = 0;\n for (size_t i = 0; i < len; i++) {\n counts[(unsigned char)txt[i]]++;\n const size_t fnew = counts[(unsigned char)txt[i]];\n if (fmax < fnew)\n fmax = fnew;\n }\n assert(fmax > 0 && fmax <= len);\n\n \n size_t *ndx1 = malloc(len * sizeof(size_t));\n if (ndx1 == NULL)\n exit(EXIT_FAILURE);\n for (size_t ch = 0, i = 0; ch < UCHAR_MAX; ch++)\n if (counts[ch])\n for (size_t j = 0; j < len; j++)\n if (ch == (unsigned char)txt[j]) {\n ndx1[i] = j;\n i++;\n }\n\n \n size_t *ndx2 = malloc(len * sizeof(size_t));\n if (ndx2 == NULL)\n exit(EXIT_FAILURE);\n for (size_t i = 0, n = 0, m = 0; i < len; i++) {\n ndx2[i] = ndx1[n];\n n += fmax;\n if (n >= len) {\n m++;\n n = m;\n }\n }\n\n \n const size_t grp = 1 + (len - 1) \/ fmax;\n assert(grp > 0 && grp <= len);\n\n \n const size_t lng = 1 + (len - 1) % fmax;\n assert(lng > 0 && lng <= len);\n\n \n for (size_t i = 0, j = 0; i < fmax; i++) {\n const size_t first = ndx2[j];\n const size_t glen = grp - (i < lng ? 0 : 1);\n for (size_t k = 1; k < glen; k++)\n ndx1[j + k - 1] = ndx2[j + k];\n ndx1[j + glen - 1] = first;\n j += glen;\n }\n\n \n result[len] = '\\0';\n for (size_t i = 0; i < len; i++)\n result[ndx2[i]] = txt[ndx1[i]];\n\n free(ndx1);\n free(ndx2);\n}\n\nvoid display(const char* txt1, const char* txt2) {\n const size_t len = strlen(txt1);\n assert(len == strlen(txt2));\n int score = 0;\n for (size_t i = 0; i < len; i++)\n if (txt1[i] == txt2[i])\n score++;\n (void)printf(\"%s, %s, (%u)\\n\", txt1, txt2, score);\n}\n\nint main() {\n const char* data[] = {\"abracadabra\", \"seesaw\", \"elk\", \"grrrrrr\",\n \"up\", \"a\", \"aabbbbaa\", \"\", \"xxxxx\"};\n const size_t data_len = sizeof(data) \/ sizeof(data[0]);\n for (size_t i = 0; i < data_len; i++) {\n const size_t shuf_len = strlen(data[i]) + 1;\n char shuf[shuf_len];\n\n#ifdef DEBUG\n memset(shuf, 0xFF, sizeof shuf);\n shuf[shuf_len - 1] = '\\0';\n#endif\n\n best_shuffle(data[i], shuf);\n display(data[i], shuf);\n }\n\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate permutohedron;\nextern crate rand;\n\nuse std::cmp::{min, Ordering};\nuse std::env;\nuse rand::{thread_rng, Rng};\nuse std::str;\n\nconst WORDS: &'static [&'static str] = &[\"abracadabra\", \"seesaw\", \"elk\", \"grrrrrr\", \"up\", \"a\"];\n\n#[derive(Eq)]\nstruct Solution {\n original: String,\n shuffled: String,\n score: usize,\n}\n\n\nimpl PartialOrd for Solution {\n fn partial_cmp(&self, other: &Solution) -> Option {\n match (self.score, other.score) {\n (s, o) if s < o => Some(Ordering::Less),\n (s, o) if s > o => Some(Ordering::Greater),\n (s, o) if s == o => Some(Ordering::Equal),\n _ => None,\n }\n }\n}\n\n\nimpl PartialEq for Solution {\n fn eq(&self, other: &Solution) -> bool {\n match (self.score, other.score) {\n (s, o) if s == o => true,\n _ => false,\n }\n }\n}\n\nimpl Ord for Solution {\n fn cmp(&self, other: &Solution) -> Ordering {\n match (self.score, other.score) {\n (s, o) if s < o => Ordering::Less,\n (s, o) if s > o => Ordering::Greater,\n _ => Ordering::Equal,\n }\n }\n}\n\nfn _help() {\n println!(\"Usage: best_shuffle ...\");\n}\n\nfn main() {\n let args: Vec = env::args().collect();\n let mut words: Vec = vec![];\n\n match args.len() {\n 1 => {\n for w in WORDS.iter() {\n words.push(String::from(*w));\n }\n }\n _ => {\n for w in args.split_at(1).1 {\n words.push(w.clone());\n }\n }\n }\n\n let solutions = words.iter().map(|w| best_shuffle(w)).collect::>();\n\n for s in solutions {\n println!(\"{}, {}, ({})\", s.original, s.shuffled, s.score);\n }\n}\n\n\nfn _best_shuffle_perm(w: &String) -> Solution {\n let mut soln = Solution {\n original: w.clone(),\n shuffled: w.clone(),\n score: w.len(),\n };\n let w_bytes: Vec = w.clone().into_bytes();\n let mut permutocopy = w_bytes.clone();\n let mut permutations = permutohedron::Heap::new(&mut permutocopy);\n while let Some(p) = permutations.next_permutation() {\n let hamm = hamming(&w_bytes, p);\n soln = min(soln,\n Solution {\n original: w.clone(),\n shuffled: String::from(str::from_utf8(p).unwrap()),\n score: hamm,\n });\n \n if hamm == 0 {\n break;\n }\n }\n soln\n}\n\n\nfn best_shuffle(w: &String) -> Solution {\n let w_bytes: Vec = w.clone().into_bytes();\n let mut shuffled_bytes: Vec = w.clone().into_bytes();\n\n \n let sh: &mut [u8] = shuffled_bytes.as_mut_slice();\n thread_rng().shuffle(sh);\n\n \n for i in 0..sh.len() {\n for j in 0..sh.len() {\n if (i == j) | (sh[i] == w_bytes[j]) | (sh[j] == w_bytes[i]) | (sh[i] == sh[j]) {\n continue;\n }\n sh.swap(i, j);\n break;\n }\n }\n\n let res = String::from(str::from_utf8(sh).unwrap());\n let res_bytes: Vec = res.clone().into_bytes();\n Solution {\n original: w.clone(),\n shuffled: res,\n score: hamming(&w_bytes, &res_bytes),\n }\n}\n\nfn hamming(w0: &Vec, w1: &Vec) -> usize {\n w0.iter().zip(w1.iter()).filter(|z| z.0 == z.1).count()\n}\n"} {"name":"Bin given limits","C":"#include \n#include \n\nsize_t upper_bound(const int* array, size_t n, int value) {\n size_t start = 0;\n while (n > 0) {\n size_t step = n \/ 2;\n size_t index = start + step;\n if (value >= array[index]) {\n start = index + 1;\n n -= step + 1;\n } else {\n n = step;\n }\n }\n return start;\n}\n\nint* bins(const int* limits, size_t nlimits, const int* data, size_t ndata) {\n int* result = calloc(nlimits + 1, sizeof(int));\n if (result == NULL)\n return NULL;\n for (size_t i = 0; i < ndata; ++i)\n ++result[upper_bound(limits, nlimits, data[i])];\n return result;\n}\n\nvoid print_bins(const int* limits, size_t n, const int* bins) {\n if (n == 0)\n return;\n printf(\" < %3d: %2d\\n\", limits[0], bins[0]);\n for (size_t i = 1; i < n; ++i)\n printf(\">= %3d and < %3d: %2d\\n\", limits[i - 1], limits[i], bins[i]);\n printf(\">= %3d \u00a0: %2d\\n\", limits[n - 1], bins[n]);\n}\n\nint main() {\n const int limits1[] = {23, 37, 43, 53, 67, 83};\n const int data1[] = {95, 21, 94, 12, 99, 4, 70, 75, 83, 93, 52, 80, 57,\n 5, 53, 86, 65, 17, 92, 83, 71, 61, 54, 58, 47, 16,\n 8, 9, 32, 84, 7, 87, 46, 19, 30, 37, 96, 6, 98,\n 40, 79, 97, 45, 64, 60, 29, 49, 36, 43, 55};\n\n printf(\"Example 1:\\n\");\n size_t n = sizeof(limits1) \/ sizeof(int);\n int* b = bins(limits1, n, data1, sizeof(data1) \/ sizeof(int));\n if (b == NULL) {\n fprintf(stderr, \"Out of memory\\n\");\n return EXIT_FAILURE;\n }\n print_bins(limits1, n, b);\n free(b);\n\n const int limits2[] = {14, 18, 249, 312, 389, 392, 513, 591, 634, 720};\n const int data2[] = {\n 445, 814, 519, 697, 700, 130, 255, 889, 481, 122, 932, 77, 323, 525,\n 570, 219, 367, 523, 442, 933, 416, 589, 930, 373, 202, 253, 775, 47,\n 731, 685, 293, 126, 133, 450, 545, 100, 741, 583, 763, 306, 655, 267,\n 248, 477, 549, 238, 62, 678, 98, 534, 622, 907, 406, 714, 184, 391,\n 913, 42, 560, 247, 346, 860, 56, 138, 546, 38, 985, 948, 58, 213,\n 799, 319, 390, 634, 458, 945, 733, 507, 916, 123, 345, 110, 720, 917,\n 313, 845, 426, 9, 457, 628, 410, 723, 354, 895, 881, 953, 677, 137,\n 397, 97, 854, 740, 83, 216, 421, 94, 517, 479, 292, 963, 376, 981,\n 480, 39, 257, 272, 157, 5, 316, 395, 787, 942, 456, 242, 759, 898,\n 576, 67, 298, 425, 894, 435, 831, 241, 989, 614, 987, 770, 384, 692,\n 698, 765, 331, 487, 251, 600, 879, 342, 982, 527, 736, 795, 585, 40,\n 54, 901, 408, 359, 577, 237, 605, 847, 353, 968, 832, 205, 838, 427,\n 876, 959, 686, 646, 835, 127, 621, 892, 443, 198, 988, 791, 466, 23,\n 707, 467, 33, 670, 921, 180, 991, 396, 160, 436, 717, 918, 8, 374,\n 101, 684, 727, 749};\n\n printf(\"\\nExample 2:\\n\");\n n = sizeof(limits2) \/ sizeof(int);\n b = bins(limits2, n, data2, sizeof(data2) \/ sizeof(int));\n if (b == NULL) {\n fprintf(stderr, \"Out of memory\\n\");\n return EXIT_FAILURE;\n }\n print_bins(limits2, n, b);\n free(b);\n\n return EXIT_SUCCESS;\n}\n","Rust":"fn make_bins(limits: &Vec, data: &Vec) -> Vec> {\n let mut bins: Vec> = Vec::with_capacity(limits.len() + 1);\n for _ in 0..=limits.len() {bins.push(Vec::new());}\n\n limits.iter().enumerate().for_each(|(idx, limit)| {\n data.iter().for_each(|elem| {\n if idx == 0 && elem < limit { bins[0].push(*elem); } \n else if idx == limits.len()-1 && elem >= limit { bins[limits.len()].push(*elem); } \n else if elem < limit && elem >= &limits[idx-1] { bins[idx].push(*elem); } \n });\n });\n\n bins\n}\n\nfn print_bins(limits: &Vec, bins: &Vec>) {\n for (idx, bin) in bins.iter().enumerate() {\n if idx == 0 {\n println!(\" < {:3}\u00a0:= {:3}\", limits[idx], bin.len());\n } else if idx == limits.len() {\n println!(\">= {:3} \u00a0:= {:3}\", limits[idx-1], bin.len());\n }else {\n println!(\">= {:3} .. < {:3}\u00a0:= {:3}\", limits[idx-1], limits[idx], bin.len());\n }\n };\n}\n\nfn main() {\n let limits1 = vec![23, 37, 43, 53, 67, 83];\n let data1 = vec![95,21,94,12,99,4,70,75,83,93,52,80,57,5,53,86,65,17,92,83,71,61,54,58,47,\n 16, 8, 9,32,84,7,87,46,19,30,37,96,6,98,40,79,97,45,64,60,29,49,36,43,55];\n\n let limits2 = vec![14, 18, 249, 312, 389, 392, 513, 591, 634, 720];\n let data2 = vec![\n 445,814,519,697,700,130,255,889,481,122,932, 77,323,525,570,219,367,523,442,933,\n 416,589,930,373,202,253,775, 47,731,685,293,126,133,450,545,100,741,583,763,306,\n 655,267,248,477,549,238, 62,678, 98,534,622,907,406,714,184,391,913, 42,560,247,\n 346,860, 56,138,546, 38,985,948, 58,213,799,319,390,634,458,945,733,507,916,123,\n 345,110,720,917,313,845,426, 9,457,628,410,723,354,895,881,953,677,137,397, 97,\n 854,740, 83,216,421, 94,517,479,292,963,376,981,480, 39,257,272,157, 5,316,395,\n 787,942,456,242,759,898,576, 67,298,425,894,435,831,241,989,614,987,770,384,692,\n 698,765,331,487,251,600,879,342,982,527,736,795,585, 40, 54,901,408,359,577,237,\n 605,847,353,968,832,205,838,427,876,959,686,646,835,127,621,892,443,198,988,791,\n 466, 23,707,467, 33,670,921,180,991,396,160,436,717,918, 8,374,101,684,727,749\n ];\n\n\n \n println!(\"RC FIRST EXAMPLE\");\n let bins1 = make_bins(&limits1, &data1);\n print_bins(&limits1, &bins1);\n\n println!(\"\\nRC SECOND EXAMPLE\");\n let bins2 = make_bins(&limits2, &data2);\n print_bins(&limits2, &bins2);\n}\n"} {"name":"Binary digits","C":"#define _CRT_SECURE_NO_WARNINGS \n#define _CRT_NONSTDC_NO_DEPRECATE \n\n#include \n#include \n\n\nchar* bin2str(unsigned value, char* buffer)\n{\n \n \n \n \n \n \n \n\n const unsigned N_DIGITS = sizeof(unsigned) * 8;\n unsigned mask = 1 << (N_DIGITS - 1);\n char* ptr = buffer;\n\n for (int i = 0; i < N_DIGITS; i++)\n {\n *ptr++ = '0' + !!(value & mask);\n mask >>= 1;\n }\n *ptr = '\\0';\n\n \n \n for (ptr = buffer; *ptr == '0'; ptr++)\n ;\n\n return ptr;\n}\n\n\nchar* bin2strNaive(unsigned value, char* buffer)\n{\n \n\n unsigned n, m, p;\n\n n = 0;\n p = 1; \n while (p <= value \/ 2)\n {\n n = n + 1;\n p = p * 2;\n }\n\n m = 0;\n while (n > 0)\n {\n buffer[m] = '0' + value \/ p;\n value = value % p;\n m = m + 1;\n n = n - 1;\n p = p \/ 2;\n }\n\n buffer[m + 1] = '\\0';\n return buffer;\n}\n\n\nint main(int argc, char* argv[])\n{\n const unsigned NUMBERS[] = { 5, 50, 9000 };\n\n const int RADIX = 2;\n char buffer[(sizeof(unsigned)*8 + 1)];\n\n \n \n \n \n \n \n \n for (int i = 0; i < sizeof(NUMBERS) \/ sizeof(unsigned); i++)\n {\n unsigned value = NUMBERS[i];\n itoa(value, buffer, RADIX);\n printf(\"itoa: %u decimal = %s binary\\n\", value, buffer);\n }\n\n \n \n \n for (int i = 0; i < sizeof(NUMBERS) \/ sizeof(unsigned); i++)\n {\n unsigned value = NUMBERS[i];\n printf(\"bin2str: %u decimal = %s binary\\n\", value, bin2str(value, buffer));\n }\n\n \n \n for (int i = 0; i < sizeof(NUMBERS) \/ sizeof(unsigned); i++)\n {\n unsigned value = NUMBERS[i];\n printf(\"bin2strNaive: %u decimal = %s binary\\n\", value, bin2strNaive(value, buffer));\n }\n\n return EXIT_SUCCESS;\n}\n","Rust":"fn main() {\n for i in 0..8 {\n println!(\"{:b}\", i)\n }\n}\n"} {"name":"Binary search","C":"#include \n\nint bsearch (int *a, int n, int x) {\n int i = 0, j = n - 1;\n while (i <= j) {\n int k = i + ((j - i) \/ 2);\n if (a[k] == x) {\n return k;\n }\n else if (a[k] < x) {\n i = k + 1;\n }\n else {\n j = k - 1;\n }\n }\n return -1;\n}\n\nint bsearch_r (int *a, int x, int i, int j) {\n if (j < i) {\n return -1;\n }\n int k = i + ((j - i) \/ 2);\n if (a[k] == x) {\n return k;\n }\n else if (a[k] < x) {\n return bsearch_r(a, x, k + 1, j);\n }\n else {\n return bsearch_r(a, x, i, k - 1);\n }\n}\n\nint main () {\n int a[] = {-31, 0, 1, 2, 2, 4, 65, 83, 99, 782};\n int n = sizeof a \/ sizeof a[0];\n int x = 2;\n int i = bsearch(a, n, x);\n if (i >= 0) \n printf(\"%d is at index %d.\\n\", x, i);\n else\n printf(\"%d is not found.\\n\", x);\n x = 5;\n i = bsearch_r(a, x, 0, n - 1);\n if (i >= 0) \n printf(\"%d is at index %d.\\n\", x, i);\n else\n printf(\"%d is not found.\\n\", x);\n return 0;\n}\n","Rust":"fn binary_search(v: &[T], searchvalue: T) -> Option {\n let mut lower = 0 as usize;\n let mut upper = v.len() - 1;\n\n while upper >= lower {\n let mid = (upper + lower) \/ 2;\n if v[mid] == searchvalue {\n return Some(searchvalue);\n } else if searchvalue < v[mid] {\n upper = mid - 1;\n } else {\n lower = mid + 1;\n }\n }\n\n None\n}\n"} {"name":"Binary strings","C":"#include \n#include \n#include \n\ntypedef struct str_t {\n\tsize_t len, alloc;\n\tunsigned char *s;\n} bstr_t, *bstr;\n\n#define str_len(s) ((s)->len)\nbstr str_new(size_t len)\n{\n\tbstr s = malloc(sizeof(bstr_t));\n\tif (len < 8) len = 8;\n\ts->alloc = len;\n\ts->s = malloc(len);\n\ts->len = 0;\n\treturn s;\n}\n\nvoid str_extend(bstr s)\n{\n\tsize_t ns = s->alloc * 2;\n\tif (ns - s->alloc > 1024) ns = s->alloc + 1024;\n\ts->s = realloc(s->s, ns);\n\ts->alloc = ns;\n}\n\nvoid str_del(bstr s)\n{\n\tfree(s->s), free(s);\n}\n\nint str_cmp(bstr l, bstr r)\n{\n\tint res, len = l->len;\n\tif (len > r->len) len = r->len;\n\n\tif ((res = memcmp(l->s, r->s, len))) return res;\n\treturn l->len > r->len ? 1 : -1;\n}\n\nbstr str_dup(bstr src)\n{\n\tbstr x = str_new(src->len);\n\tmemcpy(x->s, src->s, src->len);\n\tx->len = src->len;\n\treturn x;\n}\n\nbstr str_from_chars(const char *t)\n{\n\tif (!t) return str_new(0);\n\tsize_t l = strlen(t);\n\tbstr x = str_new(l + 1);\n\tx->len = l;\n\tmemcpy(x->s, t, l);\n\treturn x;\n}\n\nvoid str_append(bstr s, unsigned char b)\n{\n\tif (s->len >= s->alloc) str_extend(s);\n\ts->s[s->len++] = b;\n}\n\nbstr str_substr(bstr s, int from, int to)\n{\n\tif (!to) to = s->len;\n\tif (from < 0) from += s->len;\n\tif (from < 0 || from >= s->len)\n\t\treturn 0;\n\tif (to < from) to = from + 1;\n\tbstr x = str_new(to - from);\n\tx->len = to - from;\n\tmemcpy(x->s, s->s + from, x->len);\n\treturn x;\n}\n\nbstr str_cat(bstr s, bstr s2)\n{\n\twhile (s->alloc < s->len + s2->len) str_extend(s);\n\tmemcpy(s->s + s->len, s2->s, s2->len);\n\ts->len += s2->len;\n\treturn s;\n}\n\nvoid str_swap(bstr a, bstr b)\n{\n\tsize_t tz;\n\tunsigned char *ts;\n\ttz = a->alloc; a->alloc = b->alloc; b->alloc = tz;\n\ttz = a->len; a->len = b->len; b->len = tz;\n\tts = a->s; a->s = b->s; b->s = ts;\n}\n\nbstr str_subst(bstr tgt, bstr pat, bstr repl)\n{\n\tbstr tmp = str_new(0);\n\tint i;\n\tfor (i = 0; i + pat->len <= tgt->len;) {\n\t\tif (memcmp(tgt->s + i, pat->s, pat->len)) {\n\t\t\tstr_append(tmp, tgt->s[i]);\n\t\t\ti++;\n\t\t} else {\n\t\t\tstr_cat(tmp, repl);\n\t\t\ti += pat->len;\n\t\t\tif (!pat->len) str_append(tmp, tgt->s[i++]);\n\t\t}\n\t}\n\twhile (i < tgt->len) str_append(tmp, tgt->s[i++]);\n\tstr_swap(tmp, tgt);\n\tstr_del(tmp);\n\treturn tgt;\n}\n\nvoid str_set(bstr dest, bstr src)\n{\n\twhile (dest->len < src->len) str_extend(dest);\n\tmemcpy(dest->s, src->s, src->len);\n\tdest->len = src->len;\n}\n\nint main()\n{\n\tbstr s = str_from_chars(\"aaaaHaaaaaFaaaaHa\");\n\tbstr s2 = str_from_chars(\"___.\");\n\tbstr s3 = str_from_chars(\"\");\n\n\tstr_subst(s, s3, s2);\n\tprintf(\"%.*s\\n\", s->len, s->s);\n\n\tstr_del(s);\n\tstr_del(s2);\n\tstr_del(s3);\n\n\treturn 0;\n}\n","Rust":"use std::str;\n\nfn main() {\n \n let string = String::from(\"Hello world!\");\n println!(\"{}\", string);\n assert_eq!(string, \"Hello world!\", \"Incorrect string text\");\n\n \n let mut assigned_str = String::new();\n assert_eq!(assigned_str, \"\", \"Incorrect string creation\");\n assigned_str += \"Text has been assigned!\";\n println!(\"{}\", assigned_str);\n assert_eq!(assigned_str, \"Text has been assigned!\",\"Incorrect string text\");\n\n \n if string == \"Hello world!\" && assigned_str == \"Text has been assigned!\" {\n println!(\"Strings are equal\");\n }\n\n \n let clone_str = string.clone();\n println!(\"String is:{} and Clone string is: {}\", string, clone_str);\n assert_eq!(clone_str, string, \"Incorrect string creation\");\n\n \n let copy_str = string;\n println!(\"String copied now: {}\", copy_str);\n\n \n let empty_str = String::new();\n assert!(empty_str.is_empty(), \"Error, string should be empty\");\n\n \n let byte_vec = [65]; \n let byte_str = str::from_utf8(&byte_vec).unwrap();\n assert_eq!(byte_str, \"A\", \"Incorrect byte append\");\n\n \n let test_str = \"Blah String\";\n let mut sub_str = &test_str[0..11];\n assert_eq!(sub_str, \"Blah String\", \"Error in slicing\");\n sub_str = &test_str[1..5];\n assert_eq!(sub_str, \"lah \", \"Error in slicing\");\n sub_str = &test_str[3..];\n assert_eq!(sub_str, \"h String\", \"Error in slicing\");\n sub_str = &test_str[..2];\n assert_eq!(sub_str, \"Bl\", \"Error in slicing\");\n\n \n let org_str = \"Hello\";\n assert_eq!(org_str.replace(\"l\", \"a\"), \"Heaao\", \"Error in replacement\");\n assert_eq!(org_str.replace(\"ll\", \"r\"), \"Hero\", \"Error in replacement\");\n\n \n let str1 = \"Hi\";\n let str2 = \" There\";\n let fin_str = str1.to_string() + str2;\n assert_eq!(fin_str, \"Hi There\", \"Error in concatenation\");\n\n \n let str1 = \"Hi\";\n let str2 = \" There\";\n let fin_str = str1.to_string() + str2;\n assert_eq!(fin_str, \"Hi There\", \"Error in concatenation\");\n\n \n let f_str = \"Pooja and Sundar are up in Tumkur\";\n let split_str: Vec<_> = f_str.split(' ').collect();\n assert_eq!(split_str, [\"Pooja\", \"and\", \"Sundar\", \"are\", \"up\", \"in\", \"Tumkur\"], \"Error in string split\");\n}\n"} {"name":"Bitcoin_address validation","C":"#include \n#include \n#include \n\nconst char *coin_err;\n#define bail(s) { coin_err = s; return 0; }\n\nint unbase58(const char *s, unsigned char *out) {\n\tstatic const char *tmpl = \"123456789\"\n\t\t\"ABCDEFGHJKLMNPQRSTUVWXYZ\"\n\t\t\"abcdefghijkmnopqrstuvwxyz\";\n\tint i, j, c;\n\tconst char *p;\n\n\tmemset(out, 0, 25);\n\tfor (i = 0; s[i]; i++) {\n\t\tif (!(p = strchr(tmpl, s[i])))\n\t\t\tbail(\"bad char\");\n\n\t\tc = p - tmpl;\n\t\tfor (j = 25; j--; ) {\n\t\t\tc += 58 * out[j];\n\t\t\tout[j] = c % 256;\n\t\t\tc \/= 256;\n\t\t}\n\n\t\tif (c) bail(\"address too long\");\n\t}\n\n\treturn 1;\n}\n\nint valid(const char *s) {\n\tunsigned char dec[32], d1[SHA256_DIGEST_LENGTH], d2[SHA256_DIGEST_LENGTH];\n\n\tcoin_err = \"\";\n\tif (!unbase58(s, dec)) return 0;\n\n\tSHA256(SHA256(dec, 21, d1), SHA256_DIGEST_LENGTH, d2);\n\n\tif (memcmp(dec + 21, d2, 4))\n\t\tbail(\"bad digest\");\n\n\treturn 1;\n}\n\nint main (void) {\n\tconst char *s[] = {\n\t\t\"1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9\",\n\t\t\"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\",\n\t\t\"1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nJ9\",\n\t\t\"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I\",\n\t\t0 };\n\tint i;\n\tfor (i = 0; s[i]; i++) {\n\t\tint status = valid(s[i]);\n\t\tprintf(\"%s: %s\\n\", s[i], status ? \"Ok\" : coin_err);\n\t}\n\n\treturn 0;\n}\n","Rust":"extern crate crypto;\n\nuse crypto::digest::Digest;\nuse crypto::sha2::Sha256;\n\nconst DIGITS58: [char; 58] = ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];\n\nfn main() {\n println!(\"{}\", validate_address(\"1AGNa15ZQXAZUgFiqJ3i7Z2DPU2J6hW62i\"));\n println!(\"{}\", validate_address(\"1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i\"));\n println!(\"{}\", validate_address(\"17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j\"));\n println!(\"{}\", validate_address(\"17NdbrSGoUotzeGCcMMC?nFkEvLymoou9j\"));\n}\n\nfn validate_address(address: &str) -> bool {\n let decoded = match from_base58(address, 25) {\n Ok(x) => x,\n Err(_) => return false\n };\n if decoded[0] != 0 {\n return false;\n }\n let mut sha = Sha256::new();\n sha.input(&decoded[0..21]);\n let mut first_round = vec![0u8; sha.output_bytes()];\n sha.result(&mut first_round);\n sha.reset();\n \n sha.input(&first_round);\n let mut second_round = vec![0u8; sha.output_bytes()];\n sha.result(&mut second_round);\n if second_round[0..4] != decoded[21..25] {\n return false\n }\n true\n}\n\nfn from_base58(encoded: &str, size: usize) -> Result, String> {\n let mut res: Vec = vec![0; size];\n for base58_value in encoded.chars() {\n let mut value: u32 = match DIGITS58\n .iter()\n .position(|x| *x == base58_value){\n Some(x) => x as u32,\n None => return Err(String::from(\"Invalid character found in encoded string.\"))\n };\n for result_index in (0..size).rev() {\n value += 58 * res[result_index] as u32;\n res[result_index] = (value % 256) as u8;\n value \/= 256;\n }\n }\n Ok(res)\n}\n"} {"name":"Bitmap","C":"#ifndef _IMGLIB_0\n#define _IMGLIB_0\n\n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef unsigned char color_component;\ntypedef color_component pixel[3];\ntypedef struct {\n unsigned int width;\n unsigned int height;\n pixel * buf;\n} image_t;\ntypedef image_t * image;\n\nimage alloc_img(unsigned int width, unsigned int height);\nvoid free_img(image);\nvoid fill_img(image img,\n color_component r,\n color_component g,\n color_component b );\nvoid put_pixel_unsafe(\n \timage img,\n unsigned int x,\n unsigned int y,\n color_component r,\n color_component g,\n color_component b );\nvoid put_pixel_clip(\n \timage img,\n unsigned int x,\n unsigned int y,\n color_component r,\n color_component g,\n color_component b );\n#define GET_PIXEL(IMG, X, Y) (IMG->buf[ ((Y) * IMG->width + (X)) ])\n#endif\n","Rust":"#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub struct Rgb {\n pub r: u8,\n pub g: u8,\n pub b: u8,\n}\n\nimpl Rgb {\n pub fn new(r: u8, g: u8, b: u8) -> Self {\n Rgb { r, g, b }\n }\n\n pub const BLACK: Rgb = Rgb { r: 0, g: 0, b: 0 };\n pub const RED: Rgb = Rgb { r: 255, g: 0, b: 0 };\n pub const GREEN: Rgb = Rgb { r: 0, g: 255, b: 0 };\n pub const BLUE: Rgb = Rgb { r: 0, g: 0, b: 255 };\n}\n\n#[derive(Clone, Debug)]\npub struct Image {\n width: usize,\n height: usize,\n pixels: Vec,\n}\n\nimpl Image {\n pub fn new(width: usize, height: usize) -> Self {\n Image {\n width,\n height,\n pixels: vec![Rgb::BLACK; width * height],\n }\n }\n \n pub fn width(&self) -> usize {\n self.width\n }\n \n pub fn height(&self) -> usize {\n self.height\n }\n\n pub fn fill(&mut self, color: Rgb) {\n for pixel in &mut self.pixels {\n *pixel = color;\n }\n }\n\n pub fn get(&self, row: usize, col: usize) -> Option<&Rgb> {\n if row >= self.width {\n return None;\n }\n self.pixels.get(row * self.width + col)\n }\n\n pub fn get_mut(&mut self, row: usize, col: usize) -> Option<&mut Rgb> {\n if row >= self.width {\n return None;\n }\n self.pixels.get_mut(row * self.width + col)\n }\n}\n\nfn main() {\n let mut image = Image::new(16, 9);\n assert_eq!(Some(&Rgb::BLACK), image.get(3, 4));\n assert!(image.get(22, 3).is_none());\n\n image.fill(Rgb::RED);\n assert_eq!(Some(&Rgb::RED), image.get(3, 4));\n\n if let Some(pixel) = image.get_mut(3, 4) {\n *pixel = Rgb::GREEN;\n }\n assert_eq!(Some(&Rgb::GREEN), image.get(3, 4));\n\n if let Some(pixel) = image.get_mut(3, 4) {\n pixel.g -= 100;\n pixel.b = 20;\n }\n assert_eq!(Some(&Rgb::new(0, 155, 20)), image.get(3, 4));\n}\n"} {"name":"Bitmap_Bresenham's line algorithm","C":"void line(int x0, int y0, int x1, int y1) {\n\n int dx = abs(x1-x0), sx = x0dy ? dx : -dy)\/2, e2;\n\n for(;;){\n setPixel(x0,y0);\n if (x0==x1 && y0==y1) break;\n e2 = err;\n if (e2 >-dx) { err -= dy; x0 += sx; }\n if (e2 < dy) { err += dx; y0 += sy; }\n }\n}\n","Rust":"struct Point {\n x: i32,\n y: i32\n}\n\nfn main() {\n let mut points: Vec = Vec::new();\n points.append(&mut get_coordinates(1, 20, 20, 28));\n points.append(&mut get_coordinates(20, 28, 69, 0));\n draw_line(points, 70, 30);\n}\n\nfn get_coordinates(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec {\n let mut coordinates: Vec = vec![];\n let dx:i32 = i32::abs(x2 - x1);\n let dy:i32 = i32::abs(y2 - y1);\n let sx:i32 = { if x1 < x2 { 1 } else { -1 } };\n let sy:i32 = { if y1 < y2 { 1 } else { -1 } };\n\n let mut error:i32 = (if dx > dy { dx } else { -dy }) \/ 2 ;\n let mut current_x:i32 = x1;\n let mut current_y:i32 = y1;\n loop {\n coordinates.push(Point { x : current_x, y: current_y });\n\n if current_x == x2 && current_y == y2 { break; }\n\n let error2:i32 = error;\n\n if error2 > -dx {\n error -= dy;\n current_x += sx;\n }\n if error2 < dy {\n error += dx;\n current_y += sy;\n }\n }\n coordinates\n}\n\nfn draw_line(line: std::vec::Vec, width: i32, height: i32) {\n for col in 0..height {\n for row in 0..width {\n let is_point_in_line = line.iter().any(| point| point.x == row && point.y == col);\n match is_point_in_line {\n true => print!(\"@\"),\n _ => print!(\".\")\n };\n }\n print!(\"\\n\");\n }\n}\n"} {"name":"Bitmap_Flood fill","C":"\n#define _CRT_SECURE_NO_WARNINGS \n#include \n#include \n\n#define MAXSIZE 2048\n#define BYTE unsigned char\n\nstatic int width, height;\nstatic BYTE bitmap[MAXSIZE][MAXSIZE];\nstatic BYTE oldColor;\nstatic BYTE newColor;\n\nvoid floodFill(int i, int j)\n{ \n if ( 0 <= i && i < height \n && 0 <= j && j < width \n && bitmap[i][j] == oldColor )\n {\n bitmap[i][j] = newColor;\n floodFill(i-1,j);\n floodFill(i+1,j);\n floodFill(i,j-1);\n floodFill(i,j+1);\n }\n}\n\n\n\nvoid skipLine(FILE* file)\n{\n while(!ferror(file) && !feof(file) && fgetc(file) != '\\n')\n ;\n}\n\nvoid skipCommentLines(FILE* file)\n{\n int c;\n int comment = '#';\n\n while ((c = fgetc(file)) == comment) \n skipLine(file);\n ungetc(c,file);\n}\n\nreadPortableBitMap(FILE* file)\n{\n int i,j;\n\n skipLine(file);\n skipCommentLines(file); fscanf(file,\"%d\",&width);\n skipCommentLines(file); fscanf(file,\"%d\",&height);\n skipCommentLines(file);\n\n if ( width <= MAXSIZE && height <= MAXSIZE )\n for ( i = 0; i < height; i++ )\n for ( j = 0; j < width; j++ )\n fscanf(file,\"%1d\",&(bitmap[i][j]));\n else exit(EXIT_FAILURE);\n}\n\nvoid writePortableBitMap(FILE* file)\n{\n int i,j;\n fprintf(file,\"P1\\n\");\n fprintf(file,\"%d %d\\n\", width, height);\n for ( i = 0; i < height; i++ )\n {\n for ( j = 0; j < width; j++ )\n fprintf(file,\"%1d\", bitmap[i][j]);\n fprintf(file,\"\\n\");\n }\n}\n\n\n\nint main(void)\n{\n oldColor = 1;\n newColor = oldColor ? 0 : 1;\n readPortableBitMap(stdin);\n floodFill(height\/2,width\/2);\n writePortableBitMap(stdout);\n return EXIT_SUCCESS;\n}\n","Rust":"\n\nuse std::fs::File; \nuse std::io::{BufReader, BufRead, Write}; \n\nfn read_image(filename: String) -> Vec> {\n let file = File::open(filename).unwrap();\n let reader = BufReader::new(file);\n let mut lines = reader.lines();\n\n let _ = lines.next().unwrap(); \n let _ = lines.next().unwrap(); \n\n let dimensions: (usize, usize) = {\n let line = lines.next().unwrap().unwrap();\n let values = line.split_whitespace().collect::>();\n\n \n (values[0].parse::().unwrap(),values[1].parse::().unwrap())\n };\n\n let _ = lines.next().unwrap(); \n\n let mut image_data = Vec::with_capacity(dimensions.1);\n\n for y in 0..dimensions.1 {\n image_data.push(Vec::new());\n for _ in 0..dimensions.0 {\n \n image_data[y].push((lines.next().unwrap().unwrap().parse::().unwrap(),\n lines.next().unwrap().unwrap().parse::().unwrap(),\n lines.next().unwrap().unwrap().parse::().unwrap()));\n }\n }\n\n image_data\n}\n\nfn write_image(image_data: Vec>) {\n let mut file = File::create(format!(\".\/output.ppm\")).unwrap();\n\n \n write!(file, \"P3\\n{} {}\\n255\\n\", image_data.len(), image_data[0].len()).unwrap();\n\n for row in &image_data {\n \n \n\n let mut line = String::with_capacity(row.len()*6); \n for (r,g,b) in row {\n\n \n line.push_str(&*format!(\"{} {} {} \", r,g,b));\n }\n\n write!(file, \"{}\", line).unwrap();\n }\n\n}\n\nfn flood_fill(x: usize, y: usize, target: &(u8,u8,u8), replacement: &(u8,u8,u8), image_data: &mut Vec>) {\n if &image_data[y][x] == target {\n image_data[y][x] = *replacement;\n\n if y > 0 {flood_fill(x,y-1, &target, &replacement, image_data);}\n if x > 0 {flood_fill(x-1,y, &target, &replacement, image_data);}\n if y < image_data.len()-1 {flood_fill(x,y+1, &target, &replacement, image_data);}\n if x < image_data[0].len()-1 {flood_fill(x+1,y, &target, &replacement, image_data);}\n }\n}\n\nfn main() {\n let mut data = read_image(String::from(\".\/input.ppm\"));\n\n flood_fill(1,50, &(255,255,255), &(0,255,0), &mut data); \n flood_fill(40,35, &(0,0,0), &(255,0,0), &mut data); \n\n write_image(data);\n\n}\n"} {"name":"Bitmap_Read a PPM file","C":"image get_ppm(FILE *pf);\n","Rust":"parser.rs:\nuse super::{Color, ImageFormat};\nuse std::str::from_utf8;\nuse std::str::FromStr;\n\npub fn parse_version(input: &[u8]) -> nom::IResult<&[u8], ImageFormat> {\n use nom::branch::alt;\n use nom::bytes::complete::tag;\n use nom::character::complete::line_ending;\n use nom::combinator::map;\n use nom::sequence::terminated;\n\n \n terminated(\n alt((\n map(tag(\"P3\".as_bytes()), |_| ImageFormat::P3),\n map(tag(\"P6\".as_bytes()), |_| ImageFormat::P6),\n )),\n line_ending,\n )(input)\n}\n\npub fn parse_image_attributes(input: &[u8]) -> nom::IResult<&[u8], (usize, usize, usize)> {\n use nom::character::complete::line_ending;\n use nom::character::complete::{digit1, space1};\n use nom::sequence::terminated;\n use nom::sequence::tuple;\n\n \n terminated(tuple((digit1, space1, digit1, space1, digit1)), line_ending)(input).map(\n |(next_input, result)| {\n (\n next_input,\n (\n usize::from_str_radix(from_utf8(result.0).unwrap(), 10).unwrap(),\n usize::from_str_radix(from_utf8(result.2).unwrap(), 10).unwrap(),\n usize::from_str_radix(from_utf8(result.4).unwrap(), 10).unwrap(),\n ),\n )\n },\n )\n}\n\npub fn parse_color_binary(input: &[u8]) -> nom::IResult<&[u8], Color> {\n use nom::number::complete::u8 as nom_u8;\n use nom::sequence::tuple;\n\n tuple((nom_u8, nom_u8, nom_u8))(input).map(|(next_input, res)| {\n (\n next_input,\n Color {\n red: res.0,\n green: res.1,\n blue: res.2,\n },\n )\n })\n}\n\npub fn parse_data_binary(input: &[u8]) -> nom::IResult<&[u8], Vec> {\n use nom::multi::many0;\n many0(parse_color_binary)(input)\n}\n\npub fn parse_color_ascii(input: &[u8]) -> nom::IResult<&[u8], Color> {\n use nom::character::complete::{digit1, space0, space1};\n use nom::sequence::tuple;\n\n tuple((digit1, space1, digit1, space1, digit1, space0))(input).map(|(next_input, res)| {\n (\n next_input,\n Color {\n red: u8::from_str(from_utf8(res.0).unwrap()).unwrap(),\n green: u8::from_str(from_utf8(res.2).unwrap()).unwrap(),\n blue: u8::from_str(from_utf8(res.4).unwrap()).unwrap(),\n },\n )\n })\n}\n\npub fn parse_data_ascii(input: &[u8]) -> nom::IResult<&[u8], Vec> {\n use nom::multi::many0;\n many0(parse_color_ascii)(input)\n}\n\n\nlib.rs:\nextern crate nom;\nextern crate thiserror;\nmod parser;\n\nuse std::default::Default;\nuse std::fmt;\nuse std::io::{BufWriter, Error, Write};\nuse std::ops::{Index, IndexMut};\nuse std::{fs::File, io::Read};\nuse thiserror::Error;\n\n#[derive(Copy, Clone, Default, PartialEq, Debug)]\npub struct Color {\n pub red: u8,\n pub green: u8,\n pub blue: u8,\n}\n\n#[derive(Copy, Clone, PartialEq, Debug)]\npub enum ImageFormat {\n P3,\n P6,\n}\n\nimpl From<&str> for ImageFormat {\n fn from(i: &str) -> Self {\n match i.to_lowercase().as_str() {\n \"p3\" => ImageFormat::P3,\n \"p6\" => ImageFormat::P6,\n _ => unimplemented!(\"no other formats supported\"),\n }\n }\n}\n\nimpl fmt::Display for ImageFormat {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n match self {\n ImageFormat::P3 => {\n write!(f, \"P3\")\n }\n ImageFormat::P6 => {\n write!(f, \"P6\")\n }\n }\n }\n}\n\n#[derive(Error, Debug)]\npub enum ImageError {\n #[error(\"File not found\")]\n FileNotFound,\n #[error(\"File not readable\")]\n FileNotReadable,\n #[error(\"Invalid header information\")]\n InvalidHeader,\n #[error(\"Invalid information in the data block\")]\n InvalidData,\n #[error(\"Invalid max color information\")]\n InvalidMaxColor,\n #[error(\"File is incomplete\")]\n IncompleteFile,\n #[error(\"unknown data store error\")]\n Unknown,\n}\npub struct Image {\n pub format: ImageFormat,\n pub width: usize,\n pub height: usize,\n pub data: Vec,\n}\n\nimpl Image {\n #[must_use]\n pub fn new(width: usize, height: usize) -> Self {\n Self {\n format: ImageFormat::P6,\n width,\n height,\n data: vec![Color::default(); width * height],\n }\n }\n\n pub fn fill(&mut self, color: Color) {\n for elem in &mut self.data {\n *elem = color;\n }\n }\n\n \n \n \n \n pub fn write_ppm(&self, filename: &str) -> Result<(), Error> {\n let file = File::create(filename)?;\n let mut writer = BufWriter::new(file);\n writeln!(&mut writer, \"{}\", self.format.to_string())?;\n writeln!(&mut writer, \"{} {} 255\", self.width, self.height)?;\n match self.format {\n ImageFormat::P3 => {\n writer.write_all(\n &self\n .data\n .iter()\n .flat_map(|color| {\n vec![\n color.red.to_string(),\n color.green.to_string(),\n color.blue.to_string(),\n ]\n })\n .collect::>()\n .join(\" \")\n .as_bytes(),\n )?;\n }\n ImageFormat::P6 => {\n writer.write_all(\n &self\n .data\n .iter()\n .flat_map(|color| vec![color.red, color.green, color.blue])\n .collect::>(),\n )?;\n }\n }\n Ok(())\n }\n\n \n \n \n \n \n \n \n \n pub fn read_ppm(filename: &str) -> Result {\n let mut file = File::open(filename).map_err(|_| ImageError::FileNotFound)?;\n let mut data: Vec = Vec::new();\n file.read_to_end(&mut data)\n .map_err(|_| ImageError::FileNotReadable)?;\n\n let (i, format) = parser::parse_version(&data).map_err(|_| ImageError::InvalidHeader)?;\n let (i, (width, height, max_color)) =\n parser::parse_image_attributes(i).map_err(|_| ImageError::InvalidHeader)?;\n\n if max_color != 255 {\n return Err(ImageError::InvalidMaxColor);\n }\n\n let (_, data) = match format {\n ImageFormat::P3 => parser::parse_data_ascii(i).map_err(|_| ImageError::InvalidData)?,\n ImageFormat::P6 => parser::parse_data_binary(i).map_err(|_| ImageError::InvalidData)?,\n };\n\n if data.len() != height * width {\n return Err(ImageError::IncompleteFile);\n };\n\n Ok(Image {\n format,\n width,\n height,\n data,\n })\n }\n}\n\nimpl Index<(usize, usize)> for Image {\n type Output = Color;\n\n fn index(&self, (x, y): (usize, usize)) -> &Color {\n &self.data[x + y * self.width]\n }\n}\n\nimpl IndexMut<(usize, usize)> for Image {\n fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Color {\n &mut self.data[x + y * self.width]\n }\n}\n\n\nuse bitmap::Image;\n\n\n\npub fn main() {\n \n let image = Image::read_ppm(\".\/test_image.ppm\").unwrap();\n\n println!(\"Read using nom parsing:\");\n println!(\"Format: {:?}\", image.format);\n println!(\"Dimensions: {} x {}\", image.height, image.width);\n}\n"} {"name":"Bitmap_Write a PPM file","C":"#include \n#include \n\nint main(void)\n{\n const int dimx = 800, dimy = 800;\n int i, j;\n FILE *fp = fopen(\"first.ppm\", \"wb\"); \n (void) fprintf(fp, \"P6\\n%d %d\\n255\\n\", dimx, dimy);\n for (j = 0; j < dimy; ++j)\n {\n for (i = 0; i < dimx; ++i)\n {\n static unsigned char color[3];\n color[0] = i % 256; \n color[1] = j % 256; \n color[2] = (i * j) % 256; \n (void) fwrite(color, 1, 3, fp);\n }\n }\n (void) fclose(fp);\n return EXIT_SUCCESS;\n}\n","Rust":"use std::path::Path;\nuse std::io::Write;\nuse std::fs::File;\n\npub struct RGB {\n r: u8,\n g: u8,\n b: u8,\n}\n\npub struct PPM {\n height: u32,\n width: u32,\n data: Vec,\n}\n\nimpl PPM {\n pub fn new(height: u32, width: u32) -> PPM {\n let size = 3 * height * width;\n let buffer = vec![0; size as usize];\n PPM { height: height, width: width, data: buffer }\n }\n\n fn buffer_size(&self) -> u32 {\n 3 * self.height * self.width\n }\n\n fn get_offset(&self, x: u32, y: u32) -> Option {\n let offset = (y * self.width * 3) + (x * 3);\n if offset < self.buffer_size() {\n Some(offset as usize)\n } else {\n None\n }\n }\n\n pub fn get_pixel(&self, x: u32, y: u32) -> Option {\n match self.get_offset(x, y) {\n Some(offset) => {\n let r = self.data[offset];\n let g = self.data[offset + 1];\n let b = self.data[offset + 2];\n Some(RGB {r: r, g: g, b: b})\n },\n None => None\n }\n }\n\n pub fn set_pixel(&mut self, x: u32, y: u32, color: RGB) -> bool {\n match self.get_offset(x, y) {\n Some(offset) => {\n self.data[offset] = color.r;\n self.data[offset + 1] = color.g;\n self.data[offset + 2] = color.b;\n true\n },\n None => false\n }\n }\n\n pub fn write_file(&self, filename: &str) -> std::io::Result<()> {\n let path = Path::new(filename);\n let mut file = File::create(&path)?;\n let header = format!(\"P6 {} {} 255\\n\", self.width, self.height);\n file.write(header.as_bytes())?;\n file.write(&self.data)?;\n Ok(())\n }\n}\n"} {"name":"Bitwise IO","C":"#include \n#include \n#include \n#include \n\ntypedef uint8_t byte;\ntypedef struct {\n FILE *fp;\n uint32_t accu;\n int bits;\n} bit_io_t, *bit_filter;\n\nbit_filter b_attach(FILE *f)\n{\n bit_filter b = malloc(sizeof(bit_io_t));\n b->bits = b->accu = 0;\n b->fp = f;\n return b;\n}\n\nvoid b_write(byte *buf, size_t n_bits, size_t shift, bit_filter bf)\n{\n uint32_t accu = bf->accu;\n int bits = bf->bits;\n\n buf += shift \/ 8;\n shift %= 8;\n\n while (n_bits || bits >= 8) {\n while (bits >= 8) {\n bits -= 8;\n fputc(accu >> bits, bf->fp);\n accu &= (1 << bits) - 1;\n }\n while (bits < 8 && n_bits) {\n accu = (accu << 1) | (((128 >> shift) & *buf) >> (7 - shift));\n --n_bits;\n bits++;\n if (++shift == 8) {\n shift = 0;\n buf++;\n }\n }\n }\n bf->accu = accu;\n bf->bits = bits;\n}\n\nsize_t b_read(byte *buf, size_t n_bits, size_t shift, bit_filter bf)\n{\n uint32_t accu = bf->accu;\n int bits = bf->bits;\n int mask, i = 0;\n\n buf += shift \/ 8;\n shift %= 8;\n\n while (n_bits) {\n while (bits && n_bits) {\n mask = 128 >> shift;\n if (accu & (1 << (bits - 1))) *buf |= mask;\n else *buf &= ~mask;\n\n n_bits--;\n bits--;\n\n if (++shift >= 8) {\n shift = 0;\n buf++;\n }\n }\n if (!n_bits) break;\n accu = (accu << 8) | fgetc(bf->fp);\n bits += 8;\n }\n bf->accu = accu;\n bf->bits = bits;\n\n return i;\n}\n\nvoid b_detach(bit_filter bf)\n{\n if (bf->bits) {\n bf->accu <<= 8 - bf->bits;\n fputc(bf->accu, bf->fp);\n }\n free(bf);\n}\n\nint main()\n{\n unsigned char s[] = \"abcdefghijk\";\n unsigned char s2[11] = {0};\n int i;\n\n FILE *f = fopen(\"test.bin\", \"wb\");\n bit_filter b = b_attach(f);\n \n for (i = 0; i < 10; i++) b_write(s + i, 7, 1, b);\n b_detach(b);\n fclose(f);\n\n \n f = fopen(\"test.bin\", \"rb\");\n b = b_attach(f);\n for (i = 0; i < 10; i++) b_read(s2 + i, 7, 1, b);\n b_detach(b);\n fclose(f);\n\n printf(\"%10s\\n\", s2); \n\n return 0;\n}\n","Rust":"pub trait Codec {\n type Output: Iterator;\n\n fn accept(&mut self, input: Input) -> Self::Output;\n fn finish(self) -> Self::Output;\n}\n\n#[derive(Debug)]\npub struct BitDiscard {\n buf: u16, \n buf_bits: u8, \n valid_len: u8, \n shift_len: u8, \n}\n\nimpl BitDiscard {\n pub fn new(discard: u8) -> Self {\n assert!(discard < 8);\n\n BitDiscard {\n buf: 0,\n buf_bits: 0,\n valid_len: 8 - discard,\n shift_len: 8 + discard,\n }\n }\n}\n\nimpl Codec for BitDiscard {\n type Output = std::option::IntoIter;\n\n fn accept(&mut self, input: u8) -> Self::Output {\n let add = ((input as u16) << self.shift_len) >> self.buf_bits;\n self.buf |= add;\n self.buf_bits += self.valid_len;\n\n let result = if self.buf_bits >= 8 {\n let result = (self.buf >> 8) as u8;\n self.buf <<= 8;\n self.buf_bits -= 8;\n Some(result)\n } else {\n None\n };\n\n result.into_iter()\n }\n\n fn finish(self) -> Self::Output {\n let result = if self.buf_bits > 0 {\n Some((self.buf >> 8) as u8)\n } else {\n None\n };\n\n result.into_iter()\n }\n}\n\n#[derive(Debug)]\npub struct BitExpand {\n buf: u16, \n buf_bits: u8, \n valid_len: u8, \n shift_len: u8, \n}\n\nimpl BitExpand {\n pub fn new(expand: u8) -> Self {\n assert!(expand < 8);\n\n Self {\n buf: 0,\n buf_bits: 0,\n valid_len: 8 - expand,\n shift_len: 8 + expand,\n }\n }\n}\n\nimpl Codec for BitExpand {\n type Output = BitExpandIter;\n\n fn accept(&mut self, input: u8) -> Self::Output {\n let add = ((input as u16) << 8) >> self.buf_bits;\n self.buf |= add;\n self.buf_bits += 8;\n let buf = self.buf;\n let leftover = self.buf_bits % self.valid_len;\n let buf_bits = self.buf_bits - leftover;\n self.buf <<= buf_bits;\n self.buf_bits = leftover;\n\n Self::Output {\n buf,\n buf_bits,\n shift_len: self.shift_len,\n valid_len: self.valid_len,\n }\n }\n\n fn finish(self) -> Self::Output {\n Self::Output {\n buf: 0,\n buf_bits: 0,\n shift_len: 0,\n valid_len: self.valid_len,\n }\n }\n}\n\n#[derive(Debug)]\npub struct BitExpandIter {\n buf: u16,\n buf_bits: u8,\n valid_len: u8,\n shift_len: u8,\n}\n\nimpl Iterator for BitExpandIter {\n type Item = u8;\n\n fn next(&mut self) -> Option {\n if self.buf_bits < self.valid_len {\n None\n } else {\n let result = (self.buf >> self.shift_len) as u8;\n self.buf <<= self.valid_len;\n self.buf_bits -= self.valid_len;\n Some(result)\n }\n }\n}\n\nfn process_bytes(mut codec: C, bytes: &[u8]) -> Vec {\n let mut result: Vec = bytes.iter().flat_map(|byte| codec.accept(*byte)).collect();\n codec.finish().for_each(|byte| result.push(byte));\n result\n}\n\nfn print_bytes(bytes: &[u8]) {\n for byte in bytes {\n print!(\"{:08b} \", byte);\n }\n println!();\n\n for byte in bytes {\n print!(\"{:02x} \", byte);\n }\n println!();\n}\n\nfn main() {\n let original = b\"STRINGIFY!\";\n let discard = 1;\n print_bytes(&original[..]);\n let compressed = process_bytes(BitDiscard::new(discard), &original[..]);\n print_bytes(&compressed);\n let decompressed = process_bytes(BitExpand::new(discard), &compressed);\n print_bytes(&decompressed);\n}\n"} {"name":"Bitwise operations","C":"void bitwise(int a, int b)\n{\n printf(\"a and b: %d\\n\", a & b);\n printf(\"a or b: %d\\n\", a | b);\n printf(\"a xor b: %d\\n\", a ^ b);\n printf(\"not a: %d\\n\", ~a);\n printf(\"a << n: %d\\n\", a << b); \n printf(\"a >> n: %d\\n\", a >> b); \n \n unsigned int c = a;\n printf(\"c >> b: %d\\n\", c >> b); \n \n return 0;\n}\n","Rust":"fn main() {\n let a: u8 = 105;\n let b: u8 = 91;\n println!(\"a = {:0>8b}\", a);\n println!(\"b = {:0>8b}\", b);\n println!(\"a | b = {:0>8b}\", a | b);\n println!(\"a & b = {:0>8b}\", a & b);\n println!(\"a ^ b = {:0>8b}\", a ^ b);\n println!(\"!a = {:0>8b}\", !a);\n println!(\"a << 3 = {:0>8b}\", a << 3);\n println!(\"a >> 3 = {:0>8b}\", a >> 3);\n}\n"} {"name":"Box the compass","C":"#include \n\nint main()\n{\n int i, j;\n double degrees[] = { 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5,\n 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88,\n 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12,\n 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5,\n 354.37, 354.38 };\n const char * names = \"North \"\n \"North by east \"\n \"North-northeast \"\n \"Northeast by north \"\n \"Northeast \"\n \"Northeast by east \"\n \"East-northeast \"\n \"East by north \"\n \"East \"\n \"East by south \"\n \"East-southeast \"\n \"Southeast by east \"\n \"Southeast \"\n \"Southeast by south \"\n \"South-southeast \"\n \"South by east \"\n \"South \"\n \"South by west \"\n \"South-southwest \"\n \"Southwest by south \"\n \"Southwest \"\n \"Southwest by west \"\n \"West-southwest \"\n \"West by south \"\n \"West \"\n \"West by north \"\n \"West-northwest \"\n \"Northwest by west \"\n \"Northwest \"\n \"Northwest by north \"\n \"North-northwest \"\n \"North by west \"\n \"North \";\n\n for (i = 0; i < 33; i++) {\n j = .5 + degrees[i] * 32 \/ 360;\n\n printf(\"%2d \u00a0%.22s %6.2f\\n\", (j % 32) + 1, names + (j % 32) * 22,\n degrees[i]);\n }\n\n return 0;\n}\n","Rust":"fn expand(cp: &str) -> String {\n let mut out = String::new();\n for c in cp.chars() {\n out.push_str(match c {\n 'N' => \"north\",\n 'E' => \"east\",\n 'S' => \"south\",\n 'W' => \"west\",\n 'b' => \" by \",\n _ => \"-\",\n });\n }\n out\n}\n\nfn main() {\n let cp = [\n \"N\", \"NbE\", \"N-NE\", \"NEbN\", \"NE\", \"NEbE\", \"E-NE\", \"EbN\",\n \"E\", \"EbS\", \"E-SE\", \"SEbE\", \"SE\", \"SEbS\", \"S-SE\", \"SbE\",\n \"S\", \"SbW\", \"S-SW\", \"SWbS\", \"SW\", \"SWbW\", \"W-SW\", \"WbS\",\n \"W\", \"WbN\", \"W-NW\", \"NWbW\", \"NW\", \"NWbN\", \"N-NW\", \"NbW\"\n ];\n println!(\"Index Degrees Compass point\");\n println!(\"----- ------- -------------\");\n for i in 0..=32 {\n let index = i % 32;\n let heading = i as f32 * 11.25\n + match i % 3 {\n 1 => 5.62,\n 2 => -5.62,\n _ => 0.0,\n };\n println!(\n \"{:2} {:6.2} {}\",\n index + 1,\n heading,\n expand(cp[index])\n );\n }\n}\n"} {"name":"Brownian tree","C":"#include \n#include \n#include \n#include \n#include \n\n#define NUM_PARTICLES 1000\n#define SIZE 800\n\nvoid draw_brownian_tree(int world[SIZE][SIZE]){\n int px, py; \n int dx, dy; \n int i;\n \n \n world[rand() % SIZE][rand() % SIZE] = 1;\n\n for (i = 0; i < NUM_PARTICLES; i++){\n \n px = rand() % SIZE;\n py = rand() % SIZE;\n\n while (1){\n \n dx = rand() % 3 - 1;\n dy = rand() % 3 - 1;\n\n if (dx + px < 0 || dx + px >= SIZE || dy + py < 0 || dy + py >= SIZE){\n \n px = rand() % SIZE;\n py = rand() % SIZE;\n }else if (world[py + dy][px + dx] != 0){\n \n world[py][px] = 1;\n break;\n }else{\n py += dy;\n px += dx;\n }\n }\n }\n}\n\nint main(){\n int world[SIZE][SIZE];\n FIBITMAP * img;\n RGBQUAD rgb;\n int x, y;\n \n memset(world, 0, sizeof world);\n srand((unsigned)time(NULL));\n\n draw_brownian_tree(world);\n\n img = FreeImage_Allocate(SIZE, SIZE, 32, 0, 0, 0);\n\n for (y = 0; y < SIZE; y++){\n for (x = 0; x < SIZE; x++){\n rgb.rgbRed = rgb.rgbGreen = rgb.rgbBlue = (world[y][x] ? 255 : 0);\n FreeImage_SetPixelColor(img, x, y, &rgb);\n }\n }\n FreeImage_Save(FIF_BMP, img, \"brownian_tree.bmp\", 0);\n FreeImage_Unload(img);\n}\n","Rust":"extern crate image;\nextern crate rand;\n\nuse image::ColorType;\n\nuse std::cmp::{min, max};\nuse std::env;\nuse std::path::Path;\nuse std::process;\nuse rand::Rng;\n\nfn help() {\n println!(\"Usage: brownian_tree \");\n}\n\nfn main() {\n let args: Vec = env::args().collect();\n let mut output_path = Path::new(\"out.png\");\n let mut mote_count: u32 = 10000;\n let mut width: usize = 512;\n let mut height: usize = 512;\n\n match args.len() {\n 1 => {}\n 4 => {\n output_path = Path::new(&args[1]);\n mote_count = args[2].parse::().unwrap();\n width = args[3].parse::().unwrap();\n height = width;\n }\n _ => {\n help();\n process::exit(0);\n }\n }\n\n assert!(width >= 2);\n\n \n let mut field_raw = vec![0u8; width * height];\n populate_tree(&mut field_raw, width, height, mote_count);\n\n \n let our_max = field_raw.iter().fold(0u8, |champ, e| max(champ, *e));\n let fudge = std::u8::MAX \/ our_max;\n let balanced: Vec = field_raw.iter().map(|e| e * fudge).collect();\n\n match image::save_buffer(output_path,\n &balanced,\n width as u32,\n height as u32,\n ColorType::L8) {\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\n\nfn populate_tree(raw: &mut Vec, width: usize, height: usize, mc: u32) {\n \n let mut field_base: Vec<_> = raw.as_mut_slice().chunks_mut(width).collect();\n \n let field: &mut [&mut [u8]] = field_base.as_mut_slice();\n\n \n field[width \/ 2][height \/ 2] = 1;\n\n let mut rng = rand::thread_rng();\n\n for i in 0..mc {\n if i % 100 == 0 {\n println!(\"{}\", i)\n }\n\n let mut x=rng.gen_range(1usize..width-1);\n let mut y=rng.gen_range(1usize..height-1);\n\n \n if field[x][y] > 0 {\n field[x][y] = min(field[x][y] as u32 + 1, std::u8::MAX as u32) as u8;\n continue;\n }\n\n loop {\n let contacts = field[x - 1][y - 1] + field[x][y - 1] + field[x + 1][y - 1] +\n field[x - 1][y] + field[x + 1][y] +\n field[x - 1][y + 1] + field[x][y + 1] +\n field[x + 1][y + 1];\n\n if contacts > 0 {\n field[x][y] = 1;\n break;\n } else {\n let xw = rng.gen_range(-1..2) + x as i32;\n let yw = rng.gen_range(-1..2) + y as i32;\n if xw < 1 || xw >= (width as i32 - 1) || yw < 1 || yw >= (height as i32 - 1) {\n break;\n }\n x = xw as usize;\n y = yw as usize;\n }\n }\n }\n}\n"} {"name":"Bulls and cows","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n#define MAX_NUM_TRIES 72\n#define LINE_BEGIN 7\n#define LAST_LINE 18\n\nint yp=LINE_BEGIN, xp=0;\n\nchar number[5];\nchar guess[5];\n\n#define MAX_STR 256\nvoid mvaddstrf(int y, int x, const char *fmt, ...)\n{\n va_list args;\n char buf[MAX_STR];\n \n va_start(args, fmt);\n vsprintf(buf, fmt, args);\n move(y, x);\n clrtoeol();\n addstr(buf);\n va_end(args);\n}\n\nvoid ask_for_a_number()\n{\n int i=0;\n char symbols[] = \"123456789\";\n\n move(5,0); clrtoeol();\n addstr(\"Enter four digits: \");\n while(i<4) {\n int c = getch();\n if ( (c >= '1') && (c <= '9') && (symbols[c-'1']!=0) ) {\n addch(c);\n symbols[c-'1'] = 0;\n guess[i++] = c;\n }\n }\n}\n\nvoid choose_the_number()\n{\n int i=0, j;\n char symbols[] = \"123456789\";\n\n while(i<4) {\n j = rand() % 9;\n if ( symbols[j] != 0 ) {\n number[i++] = symbols[j];\n symbols[j] = 0;\n }\n }\n}\n","Rust":"use std::io;\nuse rand::{Rng,thread_rng};\n\nextern crate rand;\n\nconst NUMBER_OF_DIGITS: usize = 4;\n\nstatic DIGITS: [char; 9] = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];\n\nfn generate_digits() -> Vec {\n let mut temp_digits: Vec<_> = (&DIGITS[..]).into();\n thread_rng().shuffle(&mut temp_digits);\n return temp_digits.iter().take(NUMBER_OF_DIGITS).map(|&a| a).collect();\n}\n\nfn parse_guess_string(guess: &str) -> Result, String> {\n let chars: Vec = (&guess).chars().collect();\n\n if !chars.iter().all(|c| DIGITS.contains(c)) {\n return Err(\"only digits, please\".to_string());\n }\n\n if chars.len() != NUMBER_OF_DIGITS {\n return Err(format!(\"you need to guess with {} digits\", NUMBER_OF_DIGITS));\n }\n\n let mut uniques: Vec = chars.clone();\n uniques.dedup();\n if uniques.len() != chars.len() {\n return Err(\"no duplicates, please\".to_string());\n }\n\n return Ok(chars);\n}\n\nfn calculate_score(given_digits: &[char], guessed_digits: &[char]) -> (usize, usize) {\n let mut bulls = 0;\n let mut cows = 0;\n for i in 0..NUMBER_OF_DIGITS {\n let pos: Option = guessed_digits.iter().position(|&a| -> bool {a == given_digits[i]});\n match pos {\n None => (),\n Some(p) if p == i => bulls += 1,\n Some(_) => cows += 1\n }\n }\n return (bulls, cows);\n}\n\nfn main() {\n let reader = io::stdin();\n\n loop {\n let given_digits = generate_digits();\n println!(\"I have chosen my {} digits. Please guess what they are\", NUMBER_OF_DIGITS);\n\n loop {\n let guess_string: String = {\n let mut buf = String::new();\n reader.read_line(&mut buf).unwrap();\n buf.trim().into()\n };\n\n let digits_maybe = parse_guess_string(&guess_string);\n match digits_maybe {\n Err(msg) => {\n println!(\"{}\", msg);\n continue;\n },\n Ok(guess_digits) => {\n match calculate_score(&given_digits, &guess_digits) {\n (NUMBER_OF_DIGITS, _) => {\n println!(\"you win!\");\n break;\n },\n (bulls, cows) => println!(\"bulls: {}, cows: {}\", bulls, cows)\n }\n }\n }\n }\n }\n}\n"} {"name":"CRC-32","C":"#include \n#include \n#include \n \nint main()\n{\n\tconst char *s = \"The quick brown fox jumps over the lazy dog\";\n\tprintf(\"%lX\\n\", crc32(0, (const void*)s, strlen(s)));\n\n\treturn 0;\n}\n","Rust":"fn crc32_compute_table() -> [u32; 256] {\n let mut crc32_table = [0; 256];\n\n for n in 0..256 {\n crc32_table[n as usize] = (0..8).fold(n as u32, |acc, _| {\n match acc & 1 {\n 1 => 0xedb88320 ^ (acc >> 1),\n _ => acc >> 1,\n }\n });\n }\n\n crc32_table\n}\n\nfn crc32(buf: &str) -> u32 {\n let crc_table = crc32_compute_table();\n\n !buf.bytes().fold(!0, |acc, octet| {\n (acc >> 8) ^ crc_table[((acc & 0xff) ^ octet as u32) as usize]\n })\n}\n\nfn main() {\n println!(\"{:x}\", crc32(\"The quick brown fox jumps over the lazy dog\"));\n}\n"} {"name":"CSV data manipulation","C":"#define TITLE \"CSV data manipulation\"\n#define URL \"http:\n\n#define _GNU_SOURCE\n#define bool int\n#include \n#include \n#include \n#include \n#include \n\n\n\n\n\ntypedef struct {\n\tchar * delim;\n\tunsigned int rows;\n\tunsigned int cols;\n\tchar ** table;\n} CSV;\n\n\n\nint trim(char ** str) {\n\tint trimmed;\n\tint n;\n\tint len;\n\t\n\tlen = strlen(*str);\n\tn = len - 1;\n\t\n\twhile((n>=0) && isspace((*str)[n])) {\n\t\t(*str)[n] = '\\0'; \n\t\ttrimmed += 1;\n\t\tn--;\n\t}\n\n\t\n\tn = 0;\n\twhile((n < len) && (isspace((*str)[0]))) {\n\t\t(*str)[0] = '\\0'; \n\t\t*str = (*str)+1;\n\t\ttrimmed += 1;\n\t\tn++;\n\t}\n\treturn trimmed;\n}\n\n\n\nint csv_destroy(CSV * csv) {\n\tif (csv == NULL) { return 0; }\n\tif (csv->table != NULL) { free(csv->table); }\n\tif (csv->delim != NULL) { free(csv->delim); }\n\tfree(csv);\n\treturn 0;\n}\n\n\n\nCSV * csv_create(unsigned int cols, unsigned int rows) {\n\tCSV * csv;\n\t\n\tcsv = malloc(sizeof(CSV));\n\tcsv->rows = rows;\n\tcsv->cols = cols;\n\tcsv->delim = strdup(\",\");\n\n\tcsv->table = malloc(sizeof(char *) * cols * rows);\n\tif (csv->table == NULL) { goto error; }\n\n\tmemset(csv->table, 0, sizeof(char *) * cols * rows);\n\n\treturn csv;\n\nerror:\n\tcsv_destroy(csv);\n\treturn NULL;\n}\n\n\n\nchar * csv_get(CSV * csv, unsigned int col, unsigned int row) {\n\tunsigned int idx;\n\tidx = col + (row * csv->cols);\n\treturn csv->table[idx];\n}\n\n\n\nint csv_set(CSV * csv, unsigned int col, unsigned int row, char * value) {\n\tunsigned int idx;\n\tidx = col + (row * csv->cols);\n\tcsv->table[idx] = value;\n\treturn 0;\n}\n\nvoid csv_display(CSV * csv) {\n\tint row, col;\n\tchar * content;\n\tif ((csv->rows == 0) || (csv->cols==0)) {\n\t\tprintf(\"[Empty table]\\n\");\n\t\treturn ;\n\t}\n\n\tprintf(\"\\n[Table cols=%d rows=%d]\\n\", csv->cols, csv->rows);\n\tfor (row=0; rowrows; row++) {\n\t\tprintf(\"[|\");\n\t\tfor (col=0; colcols; col++) {\n\t\t\tcontent = csv_get(csv, col, row);\n printf(\"%s\\t|\", content);\n\t\t}\n printf(\"]\\n\");\n\t}\n\tprintf(\"\\n\");\n}\n\n\nint csv_resize(CSV * old_csv, unsigned int new_cols, unsigned int new_rows) {\n\tunsigned int cur_col, \n\t\t\t\t cur_row, \n\t\t\t\t max_cols,\n\t\t\t\t max_rows;\n\tCSV * new_csv;\n\tchar * content;\n\tbool in_old, in_new;\n\n\t\n\tnew_csv = csv_create(new_cols, new_rows);\n\tif (new_csv == NULL) { goto error; }\n\n\tnew_csv->rows = new_rows;\n\tnew_csv->cols = new_cols;\n\n\n\tmax_cols = (new_cols > old_csv->cols)? new_cols : old_csv->cols;\n\tmax_rows = (new_rows > old_csv->rows)? new_rows : old_csv->rows;\n\n\tfor (cur_col=0; cur_colcols) && (cur_row < old_csv->rows);\n\t\t\tin_new = (cur_col < new_csv->cols) && (cur_row < new_csv->rows);\n\n\t\t\tif (in_old && in_new) {\n\t\t\t\t\n\t\t\t\tcontent = csv_get(old_csv, cur_col, cur_row);\n\t\t\t\tcsv_set(new_csv, cur_col, cur_row, content);\n\t\t\t} else if (in_old) {\n\t\t\t\t\n\t\t\t\tcontent = csv_get(old_csv, cur_col, cur_row);\n\t\t\t\tfree(content);\n\t\t\t} else { }\n\t\t}\n\t}\n\t\t\t\n\tfree(old_csv->table);\n\told_csv->rows = new_rows;\n\told_csv->cols = new_cols;\n\told_csv->table = new_csv->table;\n\tnew_csv->table = NULL;\n\tcsv_destroy(new_csv);\n\n\treturn 0;\n\nerror:\n\tprintf(\"Unable to resize CSV table: error %d - %s\\n\", errno, strerror(errno));\n\treturn -1;\n}\n\n\n\nint csv_open(CSV * csv, char * filename) {\n\tFILE * fp;\n\tunsigned int m_rows;\n\tunsigned int m_cols, cols;\n\tchar line[2048];\n\tchar * lineptr;\n\tchar * token;\n\n\n\tfp = fopen(filename, \"r\");\n\tif (fp == NULL) { goto error; }\n\n\tm_rows = 0;\n\tm_cols = 0;\n\twhile(fgets(line, sizeof(line), fp) != NULL) {\n \t\tm_rows += 1;\n \t\tcols = 0;\n \t\tlineptr = line;\n \t\twhile ((token = strtok(lineptr, csv->delim)) != NULL) {\n \t\t\tlineptr = NULL;\n \t\t\ttrim(&token);\n cols += 1;\n \tif (cols > m_cols) { m_cols = cols; }\n csv_resize(csv, m_cols, m_rows);\n csv_set(csv, cols-1, m_rows-1, strdup(token));\n }\n\t}\n\n\tfclose(fp);\n\tcsv->rows = m_rows;\n\tcsv->cols = m_cols;\n\treturn 0;\n\nerror:\n\tfclose(fp);\n\tprintf(\"Unable to open %s for reading.\", filename);\n\treturn -1;\n}\n\n\n\nint csv_save(CSV * csv, char * filename) {\n\tFILE * fp;\n\tint row, col;\n\tchar * content;\n\n\tfp = fopen(filename, \"w\");\n\tfor (row=0; rowrows; row++) {\n\t\tfor (col=0; colcols; col++) {\n\t\t\tcontent = csv_get(csv, col, row);\n fprintf(fp, \"%s%s\", content, \n \t\t((col == csv->cols-1) ? \"\" : csv->delim) );\n\t\t}\n fprintf(fp, \"\\n\");\n\t}\n\n\tfclose(fp);\n\treturn 0;\n}\n\n\n\nint main(int argc, char ** argv) {\n\tCSV * csv;\n\n\tprintf(\"%s\\n%s\\n\\n\",TITLE, URL);\n\n\tcsv = csv_create(0, 0);\n\tcsv_open(csv, \"fixtures\/csv-data-manipulation.csv\");\n\tcsv_display(csv);\n\n\tcsv_set(csv, 0, 0, \"Column0\");\n\tcsv_set(csv, 1, 1, \"100\");\n\tcsv_set(csv, 2, 2, \"200\");\n\tcsv_set(csv, 3, 3, \"300\");\n\tcsv_set(csv, 4, 4, \"400\");\n\tcsv_display(csv);\n\n\tcsv_save(csv, \"tmp\/csv-data-manipulation.result.csv\");\n\tcsv_destroy(csv);\n\n\treturn 0;\n}\n","Rust":"use std::error::Error;\nuse std::num::ParseIntError;\nuse csv::{Reader, Writer};\n\nfn main() -> Result<(), Box> {\n let mut reader = Reader::from_path(\"data.csv\")?;\n let mut writer = Writer::from_path(\"output.csv\")?;\n\n \n let mut headers = reader.headers()?.clone();\n headers.push_field(\"SUM\");\n writer.write_record(headers.iter())?;\n\n for row in reader.records() {\n let mut row = row?;\n\n \n let sum: Result<_, ParseIntError> = row.iter().try_fold(0, |accum, s| {\n Ok(accum + s.parse::()?)\n });\n\n row.push_field(&sum?.to_string());\n writer.write_record(row.iter())?;\n }\n\n writer.flush()?;\n Ok(())\n}\n"} {"name":"CUSIP","C":"#include\n#include\n\nint cusipCheck(char str[10]){\n\tint sum=0,i,v;\n\t\n\tfor(i=0;i<8;i++){\n\t\tif(str[i]>='0'&&str[i]<='9')\n\t\t\tv = str[i]-'0';\n\t\telse if(str[i]>='A'&&str[i]<='Z')\n\t\t\tv = (str[i] - 'A' + 10);\n\t\telse if(str[i]=='*')\n\t\t\tv = 36;\n\t\telse if(str[i]=='@')\n\t\t\tv = 37;\n\t\telse if(str[i]=='#')\n\t\t\tv = 38;\n\t\tif(i%2!=0)\n\t\t\tv*=2;\n\t\t\n\t\tsum += ((int)(v\/10) + v%10);\n\t}\n\treturn ((10 - (sum%10))%10);\n}\n\nint main(int argC,char* argV[])\n{\n\tchar cusipStr[10];\n\t\n\tint i,numLines;\n\t\n\tif(argC==1)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\t\n\telse{\n\t\tFILE* fp = fopen(argV[1],\"r\");\n\t\n\t\tfscanf(fp,\"%d\",&numLines);\n\t\t\n\t\tprintf(\"CUSIP Verdict\\n\");\n\t\tprintf(\"-------------------\");\n\t\t\n\t\tfor(i=0;i bool {\n if cusip.len() != 9 {\n return false;\n }\n\n let mut v = 0;\n let capital_cusip = cusip.to_uppercase();\n let char_indices = capital_cusip.as_str().char_indices().take(7);\n\n let total = char_indices.fold(0, |total, (i, c)| {\n v = match c {\n '*' => 36,\n '@' => 37,\n '#' => 38,\n _ if c.is_digit(10) => c.to_digit(10).unwrap() as u8,\n _ if c.is_alphabetic() => (c as u8) - b'A' + 1 + 9,\n _ => v,\n };\n\n if i % 2 != 0 {\n v *= 2\n }\n total + (v \/ 10) + v % 10\n });\n\n let check = (10 - (total % 10)) % 10;\n (check.to_string().chars().nth(0).unwrap()) == cusip.chars().nth(cusip.len() - 1).unwrap()\n}\n\nfn main() {\n let codes = [\n \"037833100\",\n \"17275R102\",\n \"38259P508\",\n \"594918104\",\n \"68389X106\",\n \"68389X105\",\n ];\n for code in &codes {\n println!(\"{} -> {}\", code, cusip_check(code))\n }\n}\n"} {"name":"Caesar cipher","C":"#include \n#include \n#include \n#include \n\n#define caesar(x) rot(13, x)\n#define decaesar(x) rot(13, x)\n#define decrypt_rot(x, y) rot((26-x), y)\n\nvoid rot(int c, char *str)\n{\n\tint l = strlen(str);\n \n const char* alpha_low = \"abcdefghijklmnopqrstuvwxyz\"; \n\n const char* alpha_high = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n \n \n char subst; \n int idx; \n\n int i; \n\n\tfor (i = 0; i < l; i++) \n\t{\n\t\tif( 0 == isalpha(str[i]) ) continue; \n\n idx = (int) (tolower(str[i]) - 'a') + c) % 26; \n\n\t\tif( isupper(str[i]) )\n subst = alpha_high[idx]; \n else\n subst = alpha_low[idx]; \n\n str[i] = subst;\n\n\t}\n}\n\n\nint main(int argc, char** argv)\n{\n\tchar str[] = \"This is a top secret text message!\";\n\t\n\tprintf(\"Original: %s\\n\", str);\n\tcaesar(str);\n\tprintf(\"Encrypted: %s\\n\", str);\n\tdecaesar(str);\n\tprintf(\"Decrypted: %s\\n\", str);\n\t\n\treturn 0;\n}\n","Rust":"use std::io::{self, Write};\nuse std::fmt::Display;\nuse std::{env, process};\n\nfn main() {\n let shift: u8 = env::args().nth(1)\n .unwrap_or_else(|| exit_err(\"No shift provided\", 2))\n .parse()\n .unwrap_or_else(|e| exit_err(e, 3));\n\n let plain = get_input()\n .unwrap_or_else(|e| exit_err(&e, e.raw_os_error().unwrap_or(-1)));\n\n let cipher = plain.chars()\n .map(|c| {\n let case = if c.is_uppercase() {'A'} else {'a'} as u8;\n if c.is_alphabetic() { (((c as u8 - case + shift) % 26) + case) as char } else { c }\n }).collect::();\n\n println!(\"Cipher text: {}\", cipher.trim());\n}\n\n\nfn get_input() -> io::Result {\n print!(\"Plain text: \");\n try!(io::stdout().flush());\n\n let mut buf = String::new();\n try!(io::stdin().read_line(&mut buf));\n Ok(buf)\n}\n\nfn exit_err(msg: T, code: i32) -> ! {\n let _ = writeln!(&mut io::stderr(), \"ERROR: {}\", msg);\n process::exit(code);\n}\n"} {"name":"Calculating the value of e","C":"#include \n#include \n\nint main(void)\n{\n double e;\n\n puts(\"The double precision in C give about 15 significant digits.\\n\"\n \"Values below are presented with 16 digits after the decimal point.\\n\");\n\n \n \n e = exp(1);\n printf(\"Euler constant e =\u00a0%.16lf\\n\", e);\n\n \n \n e = 1.0 + 0x1p-26;\n for (int i = 0; i < 26; i++)\n e *= e;\n printf(\"Euler constant e =\u00a0%.16lf\\n\", e);\n\n \n \n \n const int N = 1000;\n double a[1000];\n a[0] = 1.0;\n for (int i = 1; i < N; i++)\n {\n a[i] = a[i-1] \/ i;\n }\n e = 1.;\n for (int i = N - 1; i > 0; i--)\n e += a[i];\n printf(\"Euler constant e =\u00a0%.16lf\\n\", e);\n\n return 0;\n}\n","Rust":"const EPSILON: f64 = 1e-15;\n\nfn main() {\n let mut fact: u64 = 1;\n let mut e: f64 = 2.0;\n let mut n: u64 = 2;\n loop {\n let e0 = e;\n fact *= n;\n n += 1;\n e += 1.0 \/ fact as f64;\n if (e - e0).abs() < EPSILON {\n break;\n }\n }\n println!(\"e = {:.15}\", e);\n}\n"} {"name":"Calendar","C":"#include \n#include \n#include \n\nint width = 80, year = 1969;\nint cols, lead, gap;\n\nconst char *wdays[] = { \"Su\", \"Mo\", \"Tu\", \"We\", \"Th\", \"Fr\", \"Sa\" };\nstruct months {\n\tconst char *name;\n\tint days, start_wday, at;\n} months[12] = {\n\t{ \"January\",\t31, 0, 0 },\n\t{ \"February\",\t28, 0, 0 },\n\t{ \"March\",\t31, 0, 0 },\n\t{ \"April\",\t30, 0, 0 },\n\t{ \"May\",\t31, 0, 0 },\n\t{ \"June\",\t30, 0, 0 },\n\t{ \"July\",\t31, 0, 0 },\n\t{ \"August\",\t31, 0, 0 },\n\t{ \"September\",\t30, 0, 0 },\n\t{ \"October\",\t31, 0, 0 },\n\t{ \"November\",\t30, 0, 0 },\n\t{ \"December\",\t31, 0, 0 }\n};\n\nvoid space(int n) { while (n-- > 0) putchar(' '); }\n\nvoid init_months()\n{\n\tint i;\n\n\tif ((!(year % 4) && (year % 100)) || !(year % 400))\n\t\tmonths[1].days = 29;\n\n\tyear--;\n\tmonths[0].start_wday\n\t\t= (year * 365 + year\/4 - year\/100 + year\/400 + 1) % 7;\n\n\tfor (i = 1; i < 12; i++)\n\t\tmonths[i].start_wday =\n\t\t\t(months[i-1].start_wday + months[i-1].days) % 7;\n\n\tcols = (width + 2) \/ 22;\n\twhile (12 % cols) cols--;\n\tgap = cols - 1 ? (width - 20 * cols) \/ (cols - 1) : 0;\n\tif (gap > 4) gap = 4;\n\tlead = (width - (20 + gap) * cols + gap + 1) \/ 2;\n year++;\n}\n\nvoid print_row(int row)\n{\n\tint c, i, from = row * cols, to = from + cols;\n\tspace(lead);\n\tfor (c = from; c < to; c++) {\n\t\ti = strlen(months[c].name);\n\t\tspace((20 - i)\/2);\n\t\tprintf(\"%s\", months[c].name);\n\t\tspace(20 - i - (20 - i)\/2 + ((c == to - 1) ? 0 : gap));\n\t}\n\tputchar('\\n');\n\n\tspace(lead);\n\tfor (c = from; c < to; c++) {\n\t\tfor (i = 0; i < 7; i++)\n\t\t\tprintf(\"%s%s\", wdays[i], i == 6 ? \"\" : \" \");\n\t\tif (c < to - 1) space(gap);\n\t\telse putchar('\\n');\n\t}\n\n\twhile (1) {\n\t\tfor (c = from; c < to; c++)\n\t\t\tif (months[c].at < months[c].days) break;\n\t\tif (c == to) break;\n\n\t\tspace(lead);\n\t\tfor (c = from; c < to; c++) {\n\t\t\tfor (i = 0; i < months[c].start_wday; i++) space(3);\n\t\t\twhile(i++ < 7 && months[c].at < months[c].days) {\n\t\t\t\tprintf(\"%2d\", ++months[c].at);\n\t\t\t\tif (i < 7 || c < to - 1) putchar(' ');\n\t\t\t}\n\t\t\twhile (i++ <= 7 && c < to - 1) space(3);\n\t\t\tif (c < to - 1) space(gap - 1);\n\t\t\tmonths[c].start_wday = 0;\n\t\t}\n\t\tputchar('\\n');\n\t}\n\tputchar('\\n');\n}\n\nvoid print_year()\n{\n\tint row;\n\tchar buf[32];\n\tsprintf(buf, \"%d\", year);\n\tspace((width - strlen(buf)) \/ 2);\n\tprintf(\"%s\\n\\n\", buf);\n\tfor (row = 0; row * cols < 12; row++)\n\t\tprint_row(row);\n}\n\nint main(int c, char **v)\n{\n\tint i, year_set = 0;\n\tfor (i = 1; i < c; i++) {\n\t\tif (!strcmp(v[i], \"-w\")) {\n\t\t\tif (++i == c || (width = atoi(v[i])) < 20)\n\t\t\t\tgoto bail;\n\t\t} else if (!year_set) {\n\t\t\tif (!sscanf(v[i], \"%d\", &year) || year <= 0)\n\t\t\t\tyear = 1969;\n\t\t\tyear_set = 1;\n\t\t} else\n\t\t\tgoto bail;\n\t}\n\n\tinit_months();\n\tprint_year();\n\treturn 0;\n\nbail:\tfprintf(stderr, \"bad args\\nUsage: %s year [-w width (>= 20)]\\n\", v[0]);\n\texit(1);\n}\n","Rust":"\n\n\n\n\n\nextern crate chrono;\n\nuse std::{env, cmp};\nuse chrono::{NaiveDate, Datelike};\n\nconst MONTH_WIDTH: usize = 22;\n\nfn print_header(months: &[&str]) {\n const DAYS_OF_WEEK: &str = \"SU MO TU WE TH FR SA \";\n println!();\n for m in months {\n print!(\"{:^20} \", m);\n }\n println!(\"\\n{}\", DAYS_OF_WEEK.repeat(months.len()));\n}\n\nfn get_week_str(days: i32, week_num: i32, start_day_of_week: i32) -> Option {\n let start = week_num * 7 - start_day_of_week + 1;\n let end = (week_num + 1) * 7 - start_day_of_week;\n let mut ret = String::with_capacity(MONTH_WIDTH);\n if start > days {\n None\n } else {\n for i in start..(end + 1) {\n if i <= 0 || i > days {\n ret.push_str(\" \");\n } else {\n if i < 10 {\n ret.push_str(\" \");\n }\n ret.push_str(&i.to_string());\n }\n ret.push_str(\" \");\n }\n ret.push_str(\" \");\n Some(ret)\n }\n}\n\nfn main() {\n const MONTH_NAMES: [&str; 12] = [\"JANUARY\", \"FEBRUARY\", \"MARCH\", \"APRIL\", \"MAY\", \"JUNE\", \"JULY\",\n \"AUGUST\", \"SEPTEMBER\", \"OCTOBER\", \"NOVEMBER\", \"DECEMBER\"];\n const DEFAULT_TEXT_WIDTH: usize = 100;\n\n let args: Vec = env::args().collect();\n let year: i32 = args[1].parse().expect(\"The first argument must be a year\");\n let width: usize = if args.len() > 2 {\n cmp::max(MONTH_WIDTH, args[2].parse().expect(\"The second argument should be text width\"))\n } else {\n DEFAULT_TEXT_WIDTH\n };\n let months_in_row = width \/ MONTH_WIDTH;\n let month_rows = if MONTH_NAMES.len() % months_in_row == 0 {\n MONTH_NAMES.len() \/ months_in_row\n } else {\n MONTH_NAMES.len() \/ months_in_row + 1\n };\n\n let start_days_of_week: Vec =\n (1..13).map(|x| NaiveDate::from_ymd(year, x, 1).weekday().num_days_from_sunday() as i32).collect();\n\n let month_days: [i32; 12] = if NaiveDate::from_ymd_opt(year, 2, 29).is_some() {\n [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n } else {\n [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n };\n\n println!(\"{year:^w$}\", w=width, year=year.to_string());\n for i in 0..month_rows {\n let start = i * months_in_row;\n let end = cmp::min((i + 1) * months_in_row, MONTH_NAMES.len());\n print_header(&MONTH_NAMES[start..end]);\n let mut count = 0;\n let mut row_num = 0;\n while count < months_in_row {\n let mut row_str = String::with_capacity(width);\n for j in start..end {\n match get_week_str(month_days[j], row_num, start_days_of_week[j]) {\n None => {\n count += 1;\n row_str.push_str(&\" \".repeat(MONTH_WIDTH));\n },\n Some(week_str) => row_str.push_str(&week_str)\n }\n }\n if count < months_in_row {\n println!(\"{}\", row_str);\n }\n row_num += 1;\n }\n }\n}\n"} {"name":"Call a function in a shared library","C":"#include \n#include \n#include \n\nint myopenimage(const char *in)\n{\n static int handle=0;\n fprintf(stderr, \"internal openimage opens %s...\\n\", in);\n return handle++;\n}\n\nint main()\n{\n void *imglib;\n int (*extopenimage)(const char *);\n int imghandle;\n\n imglib = dlopen(\".\/fakeimglib.so\", RTLD_LAZY);\n if ( imglib != NULL ) {\n \n *(void **)(&extopenimage) = dlsym(imglib, \"openimage\");\n \n \n imghandle = extopenimage(\"fake.img\");\n } else {\n imghandle = myopenimage(\"fake.img\");\n }\n printf(\"opened with handle %d\\n\", imghandle);\n \n if (imglib != NULL ) dlclose(imglib);\n return EXIT_SUCCESS;\n}\n","Rust":"#![allow(unused_unsafe)]\nextern crate libc;\n\nuse std::io::{self,Write};\nuse std::{mem,ffi,process};\n\nuse libc::{c_double, RTLD_NOW};\n\n\n\nmacro_rules! to_cstr {\n ($s:expr) => {unsafe {ffi::CStr::from_bytes_with_nul_unchecked(concat!($s, \"\\0\").as_bytes()).as_ptr()}}\n}\n\nmacro_rules! from_cstr {\n ($p:expr) => {ffi::CStr::from_ptr($p).to_string_lossy().as_ref() }\n}\n\nfn main() {\n unsafe {\n let handle = libc::dlopen(to_cstr!(\"libm.so.6\"), RTLD_NOW);\n\n if handle.is_null() {\n writeln!(&mut io::stderr(), \"{}\", from_cstr!(libc::dlerror())).unwrap();\n process::exit(1);\n }\n\n let extern_cos = libc::dlsym(handle, to_cstr!(\"cos\"))\n .as_ref()\n .map(mem::transmute::<_,fn (c_double) -> c_double)\n .unwrap_or(builtin_cos);\n println!(\"{}\", extern_cos(4.0));\n }\n}\n\nfn builtin_cos(x: c_double) -> c_double {\n x.cos()\n}\n"} {"name":"Call an object method","C":"#include\n#include\n\ntypedef struct{\n int x;\n int (*funcPtr)(int);\n}functionPair;\n\nint factorial(int num){\n if(num==0||num==1)\n return 1;\n else\n return num*factorial(num-1);\n}\n\nint main(int argc,char** argv)\n{\n functionPair response;\n\n if(argc!=2)\n return printf(\"Usage\u00a0: %s \",argv[0]);\n else{\n response = (functionPair){.x = atoi(argv[1]),.funcPtr=&factorial};\n printf(\"\\nFactorial of %d is %d\\n\",response.x,response.funcPtr(response.x));\n }\n return 0;\n}\n","Rust":"struct Foo;\n\nimpl Foo {\n \n \n fn get_the_answer_to_life(&self) -> i32 {\n 42\n }\n\n \n \n fn new() -> Foo {\n println!(\"Hello, world!\");\n Foo \n }\n}\n\nfn main() {\n \n \n let foo = Foo::new();\n\n \n \n println!(\"The answer to life is {}.\", foo.get_the_answer_to_life());\n \n \n \n let lots_of_references = &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&foo;\n println!(\"The answer to life is still {}.\" lots_of_references.get_the_answer_to_life());\n}\n"} {"name":"Cantor set","C":"#include \n\n#define WIDTH 81\n#define HEIGHT 5\n\nchar lines[HEIGHT][WIDTH];\n\nvoid init() {\n int i, j;\n for (i = 0; i < HEIGHT; ++i) {\n for (j = 0; j < WIDTH; ++j) lines[i][j] = '*';\n }\n}\n\nvoid cantor(int start, int len, int index) {\n int i, j, seg = len \/ 3;\n if (seg == 0) return;\n for (i = index; i < HEIGHT; ++i) {\n for (j = start + seg; j < start + seg * 2; ++j) lines[i][j] = ' ';\n }\n cantor(start, seg, index + 1);\n cantor(start + seg * 2, seg, index + 1);\n}\n\nvoid print() {\n int i, j;\n for (i = 0; i < HEIGHT; ++i) {\n for (j = 0; j < WIDTH; ++j) printf(\"%c\", lines[i][j]);\n printf(\"\\n\");\n }\n}\n\nint main() {\n init();\n cantor(0, WIDTH, 1);\n print();\n return 0;\n}\n","Rust":"use convert_base::Convert;\nuse std::fmt;\n\nstruct CantorSet {\n cells: Vec>,\n}\nfn number_to_vec(n: usize) -> Vec {\n \n \n n.to_string()\n .chars()\n .rev()\n .map(|c| c.to_digit(10).unwrap())\n .collect()\n}\n\nimpl CantorSet {\n fn new(lines: usize) -> CantorSet {\n \n let mut base = Convert::new(10, 3);\n let mut cells: Vec> = vec![];\n\n for line in 0..lines {\n \n let segment_size = 3_usize.pow((lines - line - 1) as u32);\n let segment: Vec = (0..3_usize.pow(line as u32))\n .map(|n| {\n let output = base.convert::(&number_to_vec(n));\n \n \n !output.contains(&1)\n })\n .collect();\n\n \n let mut accum: Vec = Vec::with_capacity(segment.len() * segment_size);\n for c in segment.iter() {\n accum.extend(std::iter::repeat(*c).take(segment_size))\n }\n\n cells.push(accum);\n }\n\n CantorSet { cells }\n }\n}\n\nimpl fmt::Display for CantorSet {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n for line in self.cells.iter() {\n for c in line {\n write!(f, \"{}\", if *c { \"\u2588\" } else { \" \" })?\n }\n writeln!(f)?;\n }\n\n Ok(())\n }\n}\nfn main() {\n let cs = CantorSet::new(5);\n println!(\"Cantor set:\");\n println!(\"{}\", cs);\n}\n"} {"name":"Cartesian product of two or more lists","C":"#include\n#include\n#include\n\nvoid cartesianProduct(int** sets, int* setLengths, int* currentSet, int numSets, int times){\n\tint i,j;\n\t\n\tif(times==numSets){\n\t\tprintf(\"(\");\n\t\tfor(i=0;i='0' && token[i]<='9')\n\t\t\t\tholder[j++] = token[i];\n\t\t\telse if(token[i]==',')\n\t\t\t\tholder[j++] = ' ';\n\t\t}\n\t\tholder[j] = 00;\n\t\t\n\t\tsetLength = 0;\n\t\t\n\t\tfor(i=0;holder[i]!=00;i++)\n\t\t\tif(holder[i]==' ')\n\t\t\t\tsetLength++;\n\t\t\t\n\t\tif(setLength==0 && strlen(holder)==0){\n\t\t\tprintf(\"\\n{}\");\n\t\t\treturn;\n\t\t}\n\t\t\n\t\tsetLengths[counter] = setLength+1;\n\t\t\n\t\tsets[counter] = (int*)malloc((1+setLength)*sizeof(int));\n\t\t\n\t\tk = 0;\n\t\t\n\t\tstart = 0;\n\t\t\n\t\tfor(l=0;holder[l]!=00;l++){\n\t\t\tif(holder[l+1]==' '||holder[l+1]==00){\n\t\t\t\tholderToken = (char*)malloc((l+1-start)*sizeof(char));\n\t\t\t\tstrncpy(holderToken,holder + start,l+1-start);\n\t\t\t\tsets[counter][k++] = atoi(holderToken);\n\t\t\t\tstart = l+2;\n\t\t\t}\n\t\t}\n\t\t\n\t\tcounter++;\n\t\ttoken = strtok(NULL,\"x\");\n\t}\n\t\n\tprintf(\"\\n{\");\n\tcartesianProduct(sets,setLengths,currentSet,numSets + 1,0);\n\tprintf(\"\\b}\");\n\t\n}\n\nint main(int argC,char* argV[])\n{\n\tif(argC!=2)\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\telse\n\t\tprocessInputString(argV[1]);\n\t\n\treturn 0;\n}\n","Rust":"fn cartesian_product(lists: &Vec>) -> Vec> {\n let mut res = vec![];\n\n let mut list_iter = lists.iter();\n if let Some(first_list) = list_iter.next() {\n for &i in first_list {\n res.push(vec![i]);\n }\n }\n for l in list_iter {\n let mut tmp = vec![];\n for r in res {\n for &el in l {\n let mut tmp_el = r.clone();\n tmp_el.push(el);\n tmp.push(tmp_el);\n }\n }\n res = tmp;\n }\n res\n}\n \nfn main() {\n let cases = vec![\n vec![vec![1, 2], vec![3, 4]],\n vec![vec![3, 4], vec![1, 2]],\n vec![vec![1, 2], vec![]],\n vec![vec![], vec![1, 2]],\n vec![vec![1776, 1789], vec![7, 12], vec![4, 14, 23], vec![0, 1]],\n vec![vec![1, 2, 3], vec![30], vec![500, 100]],\n vec![vec![1, 2, 3], vec![], vec![500, 100]],\n ];\n for case in cases {\n println!(\n \"{}\\n{:?}\\n\",\n case.iter().map(|c| format!(\"{:?}\", c)).collect::>().join(\" \u00d7 \"),\n cartesian_product(&case)\n )\n }\n}\n"} {"name":"Catalan numbers","C":"#include \n\ntypedef unsigned long long ull;\n\null binomial(ull m, ull n)\n{\n\tull r = 1, d = m - n;\n\tif (d > n) { n = d; d = m - n; }\n\n\twhile (m > n) {\n\t\tr *= m--;\n\t\twhile (d > 1 && ! (r%d) ) r \/= d--;\n\t}\n\n\treturn r;\n}\n\null catalan1(int n) {\n\treturn binomial(2 * n, n) \/ (1 + n);\n}\n\null catalan2(int n) {\n\tint i;\n\tull r = !n;\n\n\tfor (i = 0; i < n; i++)\n\t\tr += catalan2(i) * catalan2(n - 1 - i);\n\treturn r;\n}\n\null catalan3(int n)\n{\n\treturn n ? 2 * (2 * n - 1) * catalan3(n - 1) \/ (1 + n) : 1;\n}\n\nint main(void)\n{\n\tint i;\n\tputs(\"\\tdirect\\tsumming\\tfrac\");\n\tfor (i = 0; i < 16; i++) {\n\t\tprintf(\"%d\\t%llu\\t%llu\\t%llu\\n\", i,\n\t\t\tcatalan1(i), catalan2(i), catalan3(i));\n\t}\n\n\treturn 0;\n}\n","Rust":"fn c_n(n: u64) -> u64 {\n match n {\n 0 => 1,\n _ => c_n(n - 1) * 2 * (2 * n - 1) \/ (n + 1)\n }\n}\n\nfn main() {\n for i in 1..16 {\n println!(\"c_n({}) = {}\", i, c_n(i));\n }\n}\n"} {"name":"Catalan numbers_Pascal's triangle","C":"\n\n\n\n\n\n#include \n#include \n\n\nconst int N = 15;\n\nint main()\n{\n \n register int k, n;\n\n \n unsigned long long int num, den;\n\n \n int catalan;\n\n \n printf(\"1 \");\n\n \n for (n=2; n<=N; ++n) {\n \n num = den = 1;\n \n for (k=2; k<=n; ++k) {\n num *= (n+k);\n den *= k;\n catalan = num \/den;\n }\n \n \n printf(\"%d \", catalan);\n }\n\n \n printf(\"\\n\");\n return 0;\n}\n","Rust":"fn main()\n{let n=15usize;\n let mut t= [0; 17];\n t[1]=1;\n let mut j:usize;\n for i in 1..n+1\n {\n\tj=i;\n\tloop{\n\t if j==1{\n\t\t break; \n\t\t}\n\t\tt[j]=t[j] + t[j-1];\n\t\tj=j-1;\n\t}\n\tt[i+1]= t[i];\n\tj=i+1;\n\tloop{\n\t\tif j==1{\n\t\tbreak;\n\t\t}\n\t\tt[j]=t[j] + t[j-1];\n\t\tj=j-1;\n\t}\n\tprint!(\"{} \", t[i+1]-t[i]);\n }\n}\n"} {"name":"Catamorphism","C":"#include \n\ntypedef int (*intFn)(int, int);\n\nint reduce(intFn fn, int size, int *elms)\n{\n int i, val = *elms;\n for (i = 1; i < size; ++i)\n val = fn(val, elms[i]);\n return val;\n}\n\nint add(int a, int b) { return a + b; }\nint sub(int a, int b) { return a - b; }\nint mul(int a, int b) { return a * b; }\n\nint main(void)\n{\n int nums[] = {1, 2, 3, 4, 5};\n printf(\"%d\\n\", reduce(add, 5, nums));\n printf(\"%d\\n\", reduce(sub, 5, nums));\n printf(\"%d\\n\", reduce(mul, 5, nums));\n return 0;\n}\n","Rust":"fn main() {\n println!(\"Sum: {}\", (1..10).fold(0, |acc, n| acc + n));\n println!(\"Product: {}\", (1..10).fold(1, |acc, n| acc * n));\n let chars = ['a', 'b', 'c', 'd', 'e'];\n println!(\"Concatenation: {}\",\n chars.iter().map(|&c| (c as u8 + 1) as char).collect::());\n}\n"} {"name":"Chaocipher","C":"#include \n#include \n#include \n\n#define TRUE 1\n#define FALSE 0\n\ntypedef int bool;\ntypedef enum { ENCRYPT, DECRYPT } cmode;\n\nconst char *l_alphabet = \"HXUCZVAMDSLKPEFJRIGTWOBNYQ\";\nconst char *r_alphabet = \"PTLNBQDEOYSFAVZKGJRIHWXUMC\";\n\nvoid chao(const char *in, char *out, cmode mode, bool show_steps) {\n int i, j, index;\n char store;\n size_t len = strlen(in);\n char left[27], right[27], temp[27];\n strcpy(left, l_alphabet);\n strcpy(right, r_alphabet);\n temp[26] = '\\0';\n\n for (i = 0; i < len; ++i ) {\n if (show_steps) printf(\"%s %s\\n\", left, right);\n if (mode == ENCRYPT) {\n index = strchr(right, in[i]) - right;\n out[i] = left[index];\n }\n else {\n index = strchr(left, in[i]) - left;\n out[i] = right[index];\n }\n if (i == len - 1) break;\n\n \n\n for (j = index; j < 26; ++j) temp[j - index] = left[j];\n for (j = 0; j < index; ++j) temp[26 - index + j] = left[j];\n store = temp[1];\n for (j = 2; j < 14; ++j) temp[j - 1] = temp[j];\n temp[13] = store;\n strcpy(left, temp);\n\n \n\n for (j = index; j < 26; ++j) temp[j - index] = right[j];\n for (j = 0; j < index; ++j) temp[26 - index + j] = right[j];\n store = temp[0];\n for (j = 1; j < 26; ++j) temp[j - 1] = temp[j];\n temp[25] = store;\n store = temp[2];\n for (j = 3; j < 14; ++j) temp[j - 1] = temp[j];\n temp[13] = store;\n strcpy(right, temp);\n }\n}\n\nint main() {\n const char *plain_text = \"WELLDONEISBETTERTHANWELLSAID\";\n char *cipher_text = malloc(strlen(plain_text) + 1);\n char *plain_text2 = malloc(strlen(plain_text) + 1);\n printf(\"The original plaintext is\u00a0: %s\\n\", plain_text);\n printf(\"\\nThe left and right alphabets after each permutation\"\n \" during encryption are\u00a0:\\n\\n\");\n chao(plain_text, cipher_text, ENCRYPT, TRUE);\n printf(\"\\nThe ciphertext is\u00a0: %s\\n\", cipher_text);\n chao(cipher_text, plain_text2, DECRYPT, FALSE);\n printf(\"\\nThe recovered plaintext is\u00a0: %s\\n\", plain_text2);\n free(cipher_text);\n free(plain_text2);\n return 0;\n}\n","Rust":"const LEFT_ALPHABET_CT: &str = \"HXUCZVAMDSLKPEFJRIGTWOBNYQ\";\nconst RIGHT_ALPHABET_PT: &str = \"PTLNBQDEOYSFAVZKGJRIHWXUMC\";\nconst ZENITH: usize = 0;\nconst NADIR: usize = 12;\nconst SEQUENCE: &str = \"WELLDONEISBETTERTHANWELLSAID\";\n\nfn cipher(letter: &char, left: &String, right: &String) -> (usize, char) {\n let pos = right.find(*letter).unwrap();\n let cipher = left.chars().nth(pos).unwrap();\n (pos, cipher)\n}\n\nfn main() {\n let mut left = LEFT_ALPHABET_CT.to_string();\n let mut right = RIGHT_ALPHABET_PT.to_string();\n\n let ciphertext = SEQUENCE.chars()\n .map(|letter| {\n let (pos, cipher_char) = cipher(&letter, &left, &right);\n left = format!(\"{}{}\", &left[pos..], &left[..pos]);\n left = format!(\"{}{}{}{}\", &left[ZENITH..1], &left[2..NADIR+2], &left[1..2], &left[NADIR+2..]);\n if pos != right.len() - 1 {\n right = format!(\"{}{}\", &right[pos + 1..], &right[..pos + 1]);\n }\n right = format!(\"{}{}{}{}\", &right[ZENITH..2], &right[3..NADIR+2], &right[2..3], &right[NADIR+2..]);\n cipher_char\n })\n .collect::();\n\n println!(\"Plaintext: {}\", SEQUENCE);\n println!(\"Ciphertext: {}\", ciphertext);\n}\n"} {"name":"Character codes","C":"#include \n\nint main() {\n printf(\"%d\\n\", 'a'); \n printf(\"%c\\n\", 97); \n return 0;\n}\n","Rust":"use std::char::from_u32;\n\nfn main() {\n \n println!(\"{}\", 'a' as u8);\n println!(\"{}\", 97 as char);\n\n \n println!(\"{}\", '\u03c0' as u32);\n println!(\"{}\", from_u32(960).unwrap());\n}\n"} {"name":"Chat server","C":"#include \n#include \n#include \n#include \n#include \n#include \n\nint tsocket;\nstruct sockaddr_in tsockinfo;\nfd_set status, current;\nvoid ClientText(int handle, char *buf, int buf_len);\n\nstruct client\n{\n char buffer[4096];\n int pos;\n char name[32];\n} *connections[FD_SETSIZE];\n\nvoid AddConnection(int handle)\n{\n connections[handle] = malloc(sizeof(struct client));\n connections[handle]->buffer[0] = '\\0';\n connections[handle]->pos = 0;\n connections[handle]->name[0] = '\\0';\n}\n\nvoid CloseConnection(int handle)\n{\n char buf[512];\n int j;\n\n FD_CLR(handle, &status);\n \n if (connections[handle]->name[0])\n {\n sprintf(buf, \"* Disconnected: %s\\r\\n\", connections[handle]->name);\n\n for (j = 0; j < FD_SETSIZE; j++)\n {\n if (handle != j && j != tsocket && FD_ISSET(j, &status))\n {\n if (write(j, buf, strlen(buf)) < 0)\n {\n CloseConnection(j);\n }\n }\n }\n } else\n {\n printf (\"-- Connection %d disconnected\\n\", handle);\n }\n if (connections[handle])\n {\n free(connections[handle]);\n }\n close(handle);\n}\n\nvoid strip(char *buf)\n{\n char *x;\n \n x = strchr(buf, '\\n');\n if (x) { *x='\\0'; }\n x = strchr(buf, '\\r');\n if (x) { *x='\\0'; }\n}\n\nint RelayText(int handle)\n{\n char *begin, *end;\n int ret = 0;\n begin = connections[handle]->buffer;\n if (connections[handle]->pos == 4000)\n {\n if (begin[3999] != '\\n')\n begin[4000] = '\\0';\n else {\n begin[4000] = '\\n';\n begin[4001] = '\\0';\n }\n } else {\n begin[connections[handle]->pos] = '\\0';\n }\n \n end = strchr(begin, '\\n');\n while (end != NULL)\n {\n char output[8000];\n output[0] = '\\0';\n if (!connections[handle]->name[0])\n {\n strncpy(connections[handle]->name, begin, 31);\n connections[handle]->name[31] = '\\0';\n \n strip(connections[handle]->name);\n sprintf(output, \"* Connected: %s\\r\\n\", connections[handle]->name);\n ret = 1;\n } else \n {\n sprintf(output, \"%s:\u00a0%.*s\\r\\n\", connections[handle]->name, \n end-begin, begin);\n ret = 1;\n }\n \n if (output[0])\n {\n int j;\n for (j = 0; j < FD_SETSIZE; j++)\n {\n if (handle != j && j != tsocket && FD_ISSET(j, &status))\n {\n if (write(j, output, strlen(output)) < 0)\n {\n CloseConnection(j);\n }\n }\n }\n }\n begin = end+1;\n end = strchr(begin, '\\n');\n }\n \n strcpy(connections[handle]->buffer, begin);\n connections[handle]->pos -= begin - connections[handle]->buffer;\n return ret;\n}\n\nvoid ClientText(int handle, char *buf, int buf_len)\n{\n int i, j;\n if (!connections[handle])\n return;\n j = connections[handle]->pos; \n \n for (i = 0; i < buf_len; ++i, ++j)\n {\n connections[handle]->buffer[j] = buf[i];\n \n if (j == 4000)\n {\n while (RelayText(handle));\n j = connections[handle]->pos;\n }\n }\n connections[handle]->pos = j;\n \n while (RelayText(handle));\n}\n\n\nint ChatLoop()\n{\n int i, j;\n FD_ZERO(&status);\n\n FD_SET(tsocket, &status);\n FD_SET(0, &status);\n\n while(1)\n {\n current = status;\n if (select(FD_SETSIZE, ¤t, NULL, NULL, NULL)==-1)\n {\n perror(\"Select\");\n return 0;\n }\n for (i = 0; i < FD_SETSIZE; ++i)\n {\n if (FD_ISSET(i, ¤t))\n {\n if (i == tsocket)\n {\n struct sockaddr_in cliinfo;\n socklen_t addrlen = sizeof(cliinfo);\n int handle;\n handle = accept(tsocket, &cliinfo, &addrlen);\n if (handle == -1)\n {\n perror (\"Couldn't accept connection\");\n } else if (handle > FD_SETSIZE)\n {\n printf (\"Unable to accept new connection.\\n\");\n close(handle);\n }\n else\n {\n if (write(handle, \"Enter name: \", 12) >= 0)\n {\n printf(\"-- New connection %d from %s:%hu\\n\",\n handle, \n inet_ntoa (cliinfo.sin_addr),\n ntohs(cliinfo.sin_port));\n FD_SET(handle, &status);\n\n AddConnection(handle);\n }\n }\n } \n else\n {\n char buf[512];\n int b;\n\n b = read(i, buf, 500);\n if (b <= 0)\n {\n CloseConnection(i);\n }\n else\n {\n ClientText(i, buf, b);\n }\n }\n }\n }\n } \n}\n\nint main (int argc, char*argv[])\n{\n tsocket = socket(PF_INET, SOCK_STREAM, 0);\n\n tsockinfo.sin_family = AF_INET;\n tsockinfo.sin_port = htons(7070);\n if (argc > 1)\n {\n tsockinfo.sin_port = htons(atoi(argv[1]));\n }\n tsockinfo.sin_addr.s_addr = htonl(INADDR_ANY);\n printf (\"Socket %d on port %hu\\n\", tsocket, ntohs(tsockinfo.sin_port));\n\n if (bind(tsocket, &tsockinfo, sizeof(tsockinfo)) == -1)\n {\n perror(\"Couldn't bind socket\");\n return -1;\n }\n\n if (listen(tsocket, 10) == -1)\n {\n perror(\"Couldn't listen to port\");\n }\n\n ChatLoop();\n\n return 0;\n}\n","Rust":"use std::collections::HashMap;\nuse std::io;\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::net::{TcpListener, TcpStream};\nuse std::sync::{Arc, RwLock};\nuse std::thread;\n\ntype Username = String;\n\n\nfn broadcast_message(\n user: &str,\n clients: &mut HashMap,\n message: &str,\n) -> io::Result<()> {\n for (client, stream) in clients.iter_mut() {\n if client != user {\n writeln!(stream, \"{}\", message)?;\n }\n }\n\n Ok(())\n}\n\nfn chat_loop(listener: &TcpListener) -> io::Result<()> {\n let local_clients: Arc>> =\n Arc::new(RwLock::new(HashMap::new()));\n\n println!(\"Accepting connections on {}\", listener.local_addr()?.port());\n\n for stream in listener.incoming() {\n match stream {\n Ok(stream) => {\n let client_clients = Arc::clone(&local_clients);\n thread::spawn(move || -> io::Result<()> {\n let mut reader = BufReader::new(stream.try_clone()?);\n let mut writer = stream;\n\n let mut name = String::new();\n loop {\n write!(writer, \"Please enter a username: \")?;\n reader.read_line(&mut name)?;\n name = name.trim().to_owned();\n\n let clients = client_clients.read().unwrap();\n if !clients.contains_key(&name) {\n writeln!(writer, \"Welcome, {}!\", &name)?;\n break;\n }\n\n writeln!(writer, \"That username is taken.\")?;\n name.clear();\n }\n\n {\n let mut clients = client_clients.write().unwrap();\n clients.insert(name.clone(), writer);\n broadcast_message(\n &name,\n &mut *clients,\n &format!(\"{} has joined the chat room.\", &name),\n )?;\n }\n\n for line in reader.lines() {\n let mut clients = client_clients.write().unwrap();\n broadcast_message(&name, &mut *clients, &format!(\"{}: {}\", &name, line?))?;\n }\n\n {\n let mut clients = client_clients.write().unwrap();\n clients.remove(&name);\n broadcast_message(\n &name,\n &mut *clients,\n &format!(\"{} has left the chat room.\", &name),\n )?;\n }\n\n Ok(())\n });\n }\n Err(e) => {\n println!(\"Connection failed: {}\", e);\n }\n }\n }\n\n Ok(())\n}\n\nfn main() {\n let listener = TcpListener::bind((\"localhost\", 7000)).unwrap();\n chat_loop(&listener).unwrap();\n}\n"} {"name":"Check output device is a terminal","C":"#include \n#include \n\nint main()\n{\n puts(isatty(fileno(stdout))\n ? \"stdout is tty\"\n : \"stdout is not tty\");\n return 0;\n}\n","Rust":"f = File.open(\"test.txt\")\np f.isatty # => false\np STDOUT.isatty # => true\n"} {"name":"Check that file exists","C":"#include \n#include \n#include \n#include \n\n\nint check_reg(const char *path) {\n\tstruct stat sb;\n\treturn stat(path, &sb) == 0 && S_ISREG(sb.st_mode);\n}\n\n\nint check_dir(const char *path) {\n\tstruct stat sb;\n\treturn stat(path, &sb) == 0 && S_ISDIR(sb.st_mode);\n}\n\nint main() {\n\tprintf(\"input.txt is a regular file? %s\\n\",\n\t check_reg(\"input.txt\") ? \"yes\" : \"no\");\n\tprintf(\"docs is a directory? %s\\n\",\n\t check_dir(\"docs\") ? \"yes\" : \"no\");\n\tprintf(\"\/input.txt is a regular file? %s\\n\",\n\t check_reg(\"\/input.txt\") ? \"yes\" : \"no\");\n\tprintf(\"\/docs is a directory? %s\\n\",\n\t check_dir(\"\/docs\") ? \"yes\" : \"no\");\n\treturn 0;\n}\n","Rust":"use std::fs;\n\nfn main() {\n for file in [\"input.txt\", \"docs\", \"\/input.txt\", \"\/docs\"].iter() {\n match fs::metadata(file) {\n Ok(attr) => {\n if attr.is_dir() {\n println!(\"{} is a directory\", file);\n }else {\n println!(\"{} is a file\", file);\n }\n },\n Err(_) => {\n println!(\"{} does not exist\", file);\n }\n };\n }\n}\n"} {"name":"Checkpoint synchronization","C":"#include \n#include \n#include \n#include \n\nint main()\n{\n int jobs = 41, tid;\n omp_set_num_threads(5);\n\n #pragma omp parallel shared(jobs) private(tid)\n {\n tid = omp_get_thread_num();\n while (jobs > 0) {\n \n #pragma omp barrier\n if (!jobs) break;\n\n printf(\"%d: taking job %d\\n\", tid, jobs--);\n usleep(100000 + rand() \/ (double) RAND_MAX * 3000000);\n printf(\"%d: done job\\n\", tid);\n }\n\n printf(\"[%d] leaving\\n\", tid);\n\n \n #pragma omp barrier\n }\n\n return 0;\n}\n","Rust":"\n\n\n\n\n\nuse std::sync::atomic::{AtomicBool, Ordering};\nuse std::sync::mpsc::channel;\nuse std::sync::{Arc, Barrier};\nuse std::thread::spawn;\n\nuse array_init::array_init;\n\npub fn checkpoint() {\n const NUM_TASKS: usize = 10;\n const NUM_ITERATIONS: u8 = 10;\n\n let barrier = Barrier::new(NUM_TASKS);\n let events: [AtomicBool; NUM_TASKS] = array_init(|_| AtomicBool::new(false));\n\n \n let arc = Arc::new((barrier, events));\n \n let (tx, rx) = channel();\n for i in 0..NUM_TASKS {\n let arc = Arc::clone(&arc);\n let tx = tx.clone();\n \n spawn(move || {\n let (ref barrier, ref events) = *arc;\n \n let event = &events[i];\n \n for _ in 0..NUM_ITERATIONS {\n \n event.store(true, Ordering::Release);\n \n barrier.wait();\n \n assert!(events.iter().all(|e| e.load(Ordering::Acquire)));\n \n barrier.wait();\n \n event.store(false, Ordering::Release);\n \n barrier.wait();\n \n assert!(events.iter().all(|e| !e.load(Ordering::Acquire)));\n \n barrier.wait();\n }\n \n tx.send(()).unwrap();\n });\n }\n drop(tx);\n \n for _ in 0..NUM_TASKS {\n rx.recv().unwrap();\n }\n}\n\nfn main() {\n checkpoint();\n}\n"} {"name":"Cheryl's birthday","C":"#include \n#include \n\nchar *months[] = {\n \"ERR\", \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"\n};\n\nstruct Date {\n int month, day;\n bool active;\n} dates[] = {\n {5,15,true}, {5,16,true}, {5,19,true},\n {6,17,true}, {6,18,true},\n {7,14,true}, {7,16,true},\n {8,14,true}, {8,15,true}, {8,17,true}\n};\n#define UPPER_BOUND (sizeof(dates) \/ sizeof(struct Date))\n\nvoid printRemaining() {\n int i, c;\n for (i = 0, c = 0; i < UPPER_BOUND; i++) {\n if (dates[i].active) {\n c++;\n }\n }\n printf(\"%d remaining.\\n\", c);\n}\n\nvoid printAnswer() {\n int i;\n for (i = 0; i < UPPER_BOUND; i++) {\n if (dates[i].active) {\n printf(\"%s, %d\\n\", months[dates[i].month], dates[i].day);\n }\n }\n}\n\nvoid firstPass() {\n \n int i, j, c;\n for (i = 0; i < UPPER_BOUND; i++) {\n c = 0;\n\n for (j = 0; j < UPPER_BOUND; j++) {\n if (dates[j].day == dates[i].day) {\n c++;\n }\n }\n\n if (c == 1) {\n for (j = 0; j < UPPER_BOUND; j++) {\n if (!dates[j].active) continue;\n if (dates[j].month == dates[i].month) {\n dates[j].active = false;\n }\n }\n }\n }\n}\n\nvoid secondPass() {\n \n int i, j, c;\n for (i = 0; i < UPPER_BOUND; i++) {\n if (!dates[i].active) continue;\n c = 0;\n\n for (j = 0; j < UPPER_BOUND; j++) {\n if (!dates[j].active) continue;\n if (dates[j].day == dates[i].day) {\n c++;\n }\n }\n\n if (c > 1) {\n for (j = 0; j < UPPER_BOUND; j++) {\n if (!dates[j].active) continue;\n if (dates[j].day == dates[i].day) {\n dates[j].active = false;\n }\n }\n }\n }\n}\n\nvoid thirdPass() {\n \n int i, j, c;\n for (i = 0; i < UPPER_BOUND; i++) {\n if (!dates[i].active) continue;\n c = 0;\n\n for (j = 0; j < UPPER_BOUND; j++) {\n if (!dates[j].active) continue;\n if (dates[j].month == dates[i].month) {\n c++;\n }\n }\n\n if (c > 1) {\n for (j = 0; j < UPPER_BOUND; j++) {\n if (!dates[j].active) continue;\n if (dates[j].month == dates[i].month) {\n dates[j].active = false;\n }\n }\n }\n }\n}\n\nint main() {\n printRemaining();\n \n firstPass();\n\n printRemaining();\n \n secondPass();\n\n printRemaining();\n \n thirdPass();\n\n printAnswer();\n return 0;\n}\n","Rust":"\n\n#[derive(PartialEq, Debug, Copy, Clone)]\nenum Month {\n May,\n June,\n July,\n August,\n}\n\n#[derive(PartialEq, Debug, Copy, Clone)]\nstruct Birthday {\n month: Month,\n day: u8,\n}\n\nimpl Birthday {\n fn month_unique_in(&self, birthdays: &[Birthday]) -> bool {\n birthdays\n .iter()\n .filter(|birthday| birthday.month == self.month)\n .count()\n == 1\n }\n\n fn day_unique_in(&self, birthdays: &[Birthday]) -> bool {\n birthdays\n .iter()\n .filter(|birthday| birthday.day == self.day)\n .count()\n == 1\n }\n\n fn month_with_unique_day_in(&self, birthdays: &[Birthday]) -> bool {\n birthdays\n .iter()\n .any(|birthday| self.month == birthday.month && birthday.day_unique_in(birthdays))\n }\n}\n\nfn solution() -> Option {\n let mut choices: Vec = vec![\n Birthday {\n month: Month::May,\n day: 15,\n },\n Birthday {\n month: Month::May,\n day: 16,\n },\n Birthday {\n month: Month::May,\n day: 19,\n },\n Birthday {\n month: Month::June,\n day: 17,\n },\n Birthday {\n month: Month::June,\n day: 18,\n },\n Birthday {\n month: Month::July,\n day: 14,\n },\n Birthday {\n month: Month::July,\n day: 16,\n },\n Birthday {\n month: Month::August,\n day: 14,\n },\n Birthday {\n month: Month::August,\n day: 15,\n },\n Birthday {\n month: Month::August,\n day: 17,\n },\n ];\n\n \n \n let choices_copy = choices.clone();\n choices.retain(|birthday| !(&birthday.month_unique_in(&choices_copy)));\n\n \n \n let choices_copy = choices.clone();\n choices.retain(|birthday| !(birthday.month_with_unique_day_in(&choices_copy)));\n\n \n \n let choices_copy = choices.clone();\n choices.retain(|birthday| birthday.day_unique_in(&choices_copy));\n\n \n \n let choices_copy = choices.clone();\n choices.retain(|birthday| birthday.month_unique_in(&choices_copy));\n\n if choices.len() == 1 {\n Some(choices[0])\n } else {\n None\n }\n}\n\nfn main() {\n match solution() {\n Some(solution) => println!(\"Cheryl's birthday is {:?}\", solution),\n None => panic!(\"Didn't work!\"),\n }\n}\n"} {"name":"Chinese remainder theorem","C":"#include \n\n\nint mul_inv(int a, int b)\n{\n\tint b0 = b, t, q;\n\tint x0 = 0, x1 = 1;\n\tif (b == 1) return 1;\n\twhile (a > 1) {\n\t\tq = a \/ b;\n\t\tt = b, b = a % b, a = t;\n\t\tt = x0, x0 = x1 - q * x0, x1 = t;\n\t}\n\tif (x1 < 0) x1 += b0;\n\treturn x1;\n}\n\nint chinese_remainder(int *n, int *a, int len)\n{\n\tint p, i, prod = 1, sum = 0;\n\n\tfor (i = 0; i < len; i++) prod *= n[i];\n\n\tfor (i = 0; i < len; i++) {\n\t\tp = prod \/ n[i];\n\t\tsum += a[i] * mul_inv(p, n[i]) * p;\n\t}\n\n\treturn sum % prod;\n}\n\nint main(void)\n{\n\tint n[] = { 3, 5, 7 };\n\tint a[] = { 2, 3, 2 };\n\n\tprintf(\"%d\\n\", chinese_remainder(n, a, sizeof(n)\/sizeof(n[0])));\n\treturn 0;\n}\n","Rust":"fn egcd(a: i64, b: i64) -> (i64, i64, i64) {\n if a == 0 {\n (b, 0, 1)\n } else {\n let (g, x, y) = egcd(b % a, a);\n (g, y - (b \/ a) * x, x)\n }\n}\n\nfn mod_inv(x: i64, n: i64) -> Option {\n let (g, x, _) = egcd(x, n);\n if g == 1 {\n Some((x % n + n) % n)\n } else {\n None\n }\n}\n\nfn chinese_remainder(residues: &[i64], modulii: &[i64]) -> Option {\n let prod = modulii.iter().product::();\n\n let mut sum = 0;\n\n for (&residue, &modulus) in residues.iter().zip(modulii) {\n let p = prod \/ modulus;\n sum += residue * mod_inv(p, modulus)? * p\n }\n\n Some(sum % prod)\n}\n\nfn main() {\n let modulii = [3,5,7];\n let residues = [2,3,2];\n\n match chinese_remainder(&residues, &modulii) {\n Some(sol) => println!(\"{}\", sol),\n None => println!(\"modulii not pairwise coprime\")\n }\n\n}\n"} {"name":"Chinese zodiac","C":"#include \n#include \n\nconst char* animals[] = { \"Rat\",\"Ox\",\"Tiger\",\"Rabbit\",\"Dragon\",\"Snake\",\"Horse\",\"Goat\",\"Monkey\",\"Rooster\",\"Dog\",\"Pig\" };\nconst char* elements[] = { \"Wood\",\"Fire\",\"Earth\",\"Metal\",\"Water\" };\n\nconst char* getElement(int year) {\n int element = (int)floor((year - 4) % 10 \/ 2);\n return elements[element];\n}\n\nconst char* getAnimal(int year) {\n return animals[(year - 4) % 12];\n}\n\nconst char* getYY(int year) {\n if (year % 2 == 0) {\n return \"yang\";\n } else {\n return \"yin\";\n }\n}\n\nint main() {\n int years[] = { 1935, 1938, 1968, 1972, 1976, 2017 };\n int i;\n\n \n for (i = 0; i < 6; ++i) {\n int year = years[i];\n printf(\"%d is the year of the %s %s (%s).\\n\", year, getElement(year), getAnimal(year), getYY(year));\n }\n\n return 0;\n}\n","Rust":"fn chinese_zodiac(year: usize) -> String {\n static ANIMALS: [&str; 12] = [\n \"Rat\", \"Ox\", \"Tiger\", \"Rabbit\", \"Dragon\", \"Snake\",\n \"Horse\", \"Goat\", \"Monkey\", \"Rooster\", \"Dog\", \"Pig\",\n ];\n static ASPECTS: [&str; 2] = [\"Yang\", \"Yin\"];\n static ELEMENTS: [&str; 5] = [\"Wood\", \"Fire\", \"Earth\", \"Metal\", \"Water\"];\n static STEMS: [char; 10] = [\n '\u7532', '\u4e59', '\u4e19', '\u4e01', '\u620a', '\u5df1', '\u5e9a', '\u8f9b', '\u58ec', '\u7678',\n ];\n static BRANCHES: [char; 12] = [\n '\u5b50', '\u4e11', '\u5bc5', '\u536f', '\u8fb0', '\u5df3', '\u5348', '\u672a', '\u7533', '\u9149', '\u620c', '\u4ea5',\n ];\n static S_NAMES: [&str; 10] = [\n \"ji\u0103\", \"y\u012d\", \"b\u012dng\", \"d\u012bng\", \"w\u00f9\", \"j\u012d\", \"g\u0113ng\", \"x\u012bn\", \"r\u00e9n\", \"g\u016di\",\n ];\n static B_NAMES: [&str; 12] = [\n \"z\u012d\", \"ch\u014fu\", \"y\u00edn\", \"m\u0103o\", \"ch\u00e9n\", \"s\u00ec\",\n \"w\u016d\", \"w\u00e8i\", \"sh\u0113n\", \"y\u014fu\", \"x\u016b\", \"h\u00e0i\",\n ];\n\n let y = year - 4;\n let s = y % 10;\n let b = y % 12;\n\n let stem = STEMS[s];\n let branch = BRANCHES[b];\n let s_name = S_NAMES[s];\n let b_name = B_NAMES[b];\n let element = ELEMENTS[s \/ 2];\n let animal = ANIMALS[b];\n let aspect = ASPECTS[s % 2];\n let cycle = y % 60 + 1;\n\n format!(\n \"{} {}{} {:9} {:7} {:7} {:6} {:02}\/60\",\n year,\n stem,\n branch,\n format!(\"{}-{}\", s_name, b_name),\n element,\n animal,\n aspect,\n cycle\n )\n}\n\nfn main() {\n let years = [1935, 1938, 1968, 1972, 1976, 1984, 2017];\n println!(\"Year Chinese Pinyin Element Animal Aspect Cycle\");\n println!(\"---- ------- --------- ------- ------- ------ -----\");\n for &year in &years {\n println!(\"{}\", chinese_zodiac(year));\n }\n}\n"} {"name":"Cholesky decomposition","C":"#include \n#include \n#include \n\ndouble *cholesky(double *A, int n) {\n double *L = (double*)calloc(n * n, sizeof(double));\n if (L == NULL)\n exit(EXIT_FAILURE);\n\n for (int i = 0; i < n; i++)\n for (int j = 0; j < (i+1); j++) {\n double s = 0;\n for (int k = 0; k < j; k++)\n s += L[i * n + k] * L[j * n + k];\n L[i * n + j] = (i == j) ?\n sqrt(A[i * n + i] - s) :\n (1.0 \/ L[j * n + j] * (A[i * n + j] - s));\n }\n\n return L;\n}\n\nvoid show_matrix(double *A, int n) {\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++)\n printf(\"%2.5f \", A[i * n + j]);\n printf(\"\\n\");\n }\n}\n\nint main() {\n int n = 3;\n double m1[] = {25, 15, -5,\n 15, 18, 0,\n -5, 0, 11};\n double *c1 = cholesky(m1, n);\n show_matrix(c1, n);\n printf(\"\\n\");\n free(c1);\n\n n = 4;\n double m2[] = {18, 22, 54, 42,\n 22, 70, 86, 62,\n 54, 86, 174, 134,\n 42, 62, 134, 106};\n double *c2 = cholesky(m2, n);\n show_matrix(c2, n);\n free(c2);\n\n return 0;\n}\n","Rust":"fn cholesky(mat: Vec, n: usize) -> Vec {\n let mut res = vec![0.0; mat.len()];\n for i in 0..n {\n for j in 0..(i+1){\n let mut s = 0.0;\n for k in 0..j {\n s += res[i * n + k] * res[j * n + k];\n }\n res[i * n + j] = if i == j { (mat[i * n + i] - s).sqrt() } else { (1.0 \/ res[j * n + j] * (mat[i * n + j] - s)) };\n }\n }\n res\n}\n\nfn show_matrix(matrix: Vec, n: usize){\n for i in 0..n {\n for j in 0..n {\n print!(\"{:.4}\\t\", matrix[i * n + j]);\n }\n println!(\"\");\n }\n println!(\"\");\n}\n\nfn main(){\n let dimension = 3 as usize;\n let m1 = vec![25.0, 15.0, -5.0,\n 15.0, 18.0, 0.0,\n -5.0, 0.0, 11.0];\n let res1 = cholesky(m1, dimension);\n show_matrix(res1, dimension);\n\n let dimension = 4 as usize;\n let m2 = vec![18.0, 22.0, 54.0, 42.0,\n 22.0, 70.0, 86.0, 62.0,\n 54.0, 86.0, 174.0, 134.0,\n 42.0, 62.0, 134.0, 106.0];\n let res2 = cholesky(m2, dimension);\n show_matrix(res2, dimension);\n}\n"} {"name":"Classes","C":"#include \n\ntypedef struct sMyClass\n{\n int variable;\n} *MyClass;\n\nMyClass MyClass_new()\n{\n MyClass pthis = malloc(sizeof *pthis);\n pthis->variable = 0;\n return pthis;\n}\n\nvoid MyClass_delete(MyClass* pthis)\n{\n if (pthis)\n {\n free(*pthis);\n *pthis = NULL;\n }\n}\n\nvoid MyClass_someMethod(MyClass pthis)\n{\n pthis->variable = 1;\n}\n\nMyClass obj = MyClass_new();\nMyClass_someMethod(obj);\nMyClass_delete(&obj);\n","Rust":"struct MyClass {\n variable: i32, \n}\n\nimpl MyClass {\n \n fn some_method(&mut self) {\n self.variable = 1;\n }\n\n \n fn new() -> MyClass {\n \n MyClass { variable: 0 }\n }\n}\n\nfn main () {\n \n let mut instance = MyClass::new();\n\n \n let mut p_instance = Box::new(MyClass::new());\n\n \n instance.some_method();\n p_instance.some_method();\n\n \n}\n"} {"name":"Closures_Value capture","C":"#include \n#include \n#include \n#include \n\ntypedef int (*f_int)();\n \n#define TAG 0xdeadbeef\nint _tmpl() { \n\tvolatile int x = TAG;\n\treturn x * x;\n}\n\n#define PROT (PROT_EXEC | PROT_WRITE)\n#define FLAGS (MAP_PRIVATE | MAP_ANONYMOUS) \nf_int dupf(int v)\n{\n\tsize_t len = (void*)dupf - (void*)_tmpl;\n\tf_int ret = mmap(NULL, len, PROT, FLAGS, 0, 0);\n\tchar *p;\n\tif(ret == MAP_FAILED) {\n\t\tperror(\"mmap\");\n\t\texit(-1);\n\t}\n\tmemcpy(ret, _tmpl, len);\n\tfor (p = (char*)ret; p < (char*)ret + len - sizeof(int); p++)\n\t\tif (*(int *)p == TAG) *(int *)p = v;\n\treturn ret;\n}\n \nint main()\n{\n\tf_int funcs[10];\n\tint i;\n\tfor (i = 0; i < 10; i++) funcs[i] = dupf(i);\n \n\tfor (i = 0; i < 9; i++)\n\t\tprintf(\"func[%d]: %d\\n\", i, funcs[i]());\n \n\treturn 0;\n}\n","Rust":"fn main() {\n let fs: Vec<_> = (0..10).map(|i| {move || i*i} ).collect();\n println!(\"7th val: {}\", fs[7]());\n}\n"} {"name":"Collections","C":"#define cSize( a ) ( sizeof(a)\/sizeof(a[0]) ) \nint ar[10]; \nar[0] = 1; \nar[1] = 2;\n\nint* p; \nfor (p=ar; \n p<(ar+cSize(ar)); \n p++) { \n printf(\"%d\\n\",*p); \n} \n","Rust":"let a = [1u8,2,3,4,5]; \nlet b = [0;256] \n"} {"name":"Combinations","C":"#include \n\n\ntypedef unsigned long marker;\nmarker one = 1;\n\nvoid comb(int pool, int need, marker chosen, int at)\n{\n\tif (pool < need + at) return; \n\n\tif (!need) {\n\t\t\n\t\tfor (at = 0; at < pool; at++)\n\t\t\tif (chosen & (one << at)) printf(\"%d \", at);\n\t\tprintf(\"\\n\");\n\t\treturn;\n\t}\n\t\n\tcomb(pool, need - 1, chosen | (one << at), at + 1);\n\tcomb(pool, need, chosen, at + 1); \n}\n\nint main()\n{\n\tcomb(5, 3, 0, 0);\n\treturn 0;\n}\n","Rust":"fn comb(arr: &[T], n: uint) {\n let mut incl_arr: ~[bool] = std::vec::from_elem(arr.len(), false);\n comb_intern(arr, n, incl_arr, 0);\n}\n\nfn comb_intern(arr: &[T], n: uint, incl_arr: &mut [bool], index: uint) {\n if (arr.len() < n + index) { return; }\n if (n == 0) {\n let mut it = arr.iter().zip(incl_arr.iter()).filter_map(|(val, incl)|\n if (*incl) { Some(val) } else { None }\n );\n for val in it { print!(\"{} \", *val); }\n print(\"\\n\");\n return;\n }\n\n incl_arr[index] = true;\n comb_intern(arr, n-1, incl_arr, index+1);\n incl_arr[index] = false;\n\n comb_intern(arr, n, incl_arr, index+1);\n}\n\nfn main() {\n let arr1 = ~[1, 2, 3, 4, 5];\n comb(arr1, 3);\n\n let arr2 = ~[\"A\", \"B\", \"C\", \"D\", \"E\"];\n comb(arr2, 3);\n}\n"} {"name":"Combinations with repetitions","C":"#include \n\nconst char *donuts[] = {\"iced\", \"jam\", \"plain\",\n \"something completely different\"};\nint pos[] = {0, 0, 0, 0};\n\nvoid printDonuts(int k) {\n for (size_t i = 1; i < k + 1; i += 1) \n printf(\"%s\\t\", donuts[pos[i]]); \n printf(\"\\n\");\n}\n\n\nvoid combination_with_repetiton(int n, int k) {\n while (1) {\n for (int i = k; i > 0; i -= 1) {\n if (pos[i] > n - 1) \n {\n pos[i - 1] += 1; \n for (int j = i; j <= k; j += 1)\n pos[j] = pos[j - 1]; \n }\n }\n if (pos[0] > 0) \n break;\n printDonuts(k);\n pos[k] += 1; \n }\n}\n\nint main() {\n combination_with_repetiton(3, 2);\n return 0;\n}\n","Rust":"\n\nstruct CombinationsWithRepetitions<'a, T: 'a> {\n \n arr: &'a [T],\n \n k: u32,\n \n counts: Vec,\n \n remaining: bool,\n}\n\nimpl<'a, T> CombinationsWithRepetitions<'a, T> {\n fn new(arr: &[T], k: u32) -> CombinationsWithRepetitions {\n let mut counts = vec![0; arr.len()];\n counts[arr.len() - 1] = k;\n CombinationsWithRepetitions {\n arr,\n k,\n counts,\n remaining: true,\n }\n }\n}\n\nimpl<'a, T> Iterator for CombinationsWithRepetitions<'a, T> {\n type Item = Vec<&'a T>;\n\n fn next(&mut self) -> Option> {\n if !self.remaining {\n return None;\n }\n let mut comb = Vec::new();\n for (count, item) in self.counts.iter().zip(self.arr.iter()) {\n for _ in 0..*count {\n comb.push(item);\n }\n }\n \n if self.counts[0] == self.k {\n self.remaining = false;\n } else {\n let n = self.counts.len();\n for i in (1..n).rev() {\n if self.counts[i] > 0 {\n let original_value = self.counts[i];\n self.counts[i - 1] += 1;\n for j in i..(n - 1) {\n self.counts[j] = 0;\n }\n self.counts[n - 1] = original_value - 1;\n break;\n }\n }\n }\n Some(comb)\n }\n}\n\nfn main() {\n let collection = vec![\"iced\", \"jam\", \"plain\"];\n for comb in CombinationsWithRepetitions::new(&collection, 2) {\n for item in &comb {\n print!(\"{} \", item)\n }\n println!()\n }\n}\n"} {"name":"Comma quibbling","C":"#include \n#include \n#include \n\nchar *quib(const char **strs, size_t size)\n{\n\n size_t len = 3 + ((size > 1) ? (2 * size + 1) : 0);\n size_t i;\n\n for (i = 0; i < size; i++)\n len += strlen(strs[i]);\n\n char *s = malloc(len * sizeof(*s));\n if (!s)\n {\n perror(\"Can't allocate memory!\\n\");\n exit(EXIT_FAILURE);\n }\n\n strcpy(s, \"{\");\n switch (size) {\n case 0: break;\n case 1: strcat(s, strs[0]);\n break;\n default: for (i = 0; i < size - 1; i++)\n {\n strcat(s, strs[i]);\n if (i < size - 2)\n strcat(s, \", \");\n else\n strcat(s, \" and \");\n }\n strcat(s, strs[i]);\n break;\n } \n strcat(s, \"}\");\n return s;\n}\n\nint main(void)\n{\n const char *test[] = {\"ABC\", \"DEF\", \"G\", \"H\"};\n char *s;\n\n for (size_t i = 0; i < 5; i++)\n {\n s = quib(test, i);\n printf(\"%s\\n\", s);\n free(s);\n }\n return EXIT_SUCCESS;\n}\n","Rust":"fn quibble(seq: &[&str]) -> String {\n match seq.len() {\n 0 => \"{}\".to_string(),\n 1 => format!(\"{{{}}}\", seq[0]),\n _ => {\n format!(\"{{{} and {}}}\",\n seq[..seq.len() - 1].join(\", \"),\n seq.last().unwrap())\n }\n }\n}\n\nfn main() {\n println!(\"{}\", quibble(&[]));\n println!(\"{}\", quibble(&[\"ABC\"]));\n println!(\"{}\", quibble(&[\"ABC\", \"DEF\"]));\n println!(\"{}\", quibble(&[\"ABC\", \"DEF\", \"G\", \"H\"]));\n}\n"} {"name":"Command-line arguments","C":"#include \n#include \n\nint main(int argc, char* argv[])\n{\n int i;\n (void) printf(\"This program is named %s.\\n\", argv[0]);\n for (i = 1; i < argc; ++i)\n (void) printf(\"the argument #%d is %s\\n\", i, argv[i]);\n return EXIT_SUCCESS;\n}\n","Rust":"use std::env;\n\nfn main(){\n let args: Vec<_> = env::args().collect();\n println!(\"{:?}\", args);\n}\n"} {"name":"Compare a list of strings","C":"#include \n#include \n\nstatic bool\nstrings_are_equal(const char **strings, size_t nstrings)\n{\n for (size_t i = 1; i < nstrings; i++)\n if (strcmp(strings[0], strings[i]) != 0)\n return false;\n return true;\n}\n\nstatic bool\nstrings_are_in_ascending_order(const char **strings, size_t nstrings)\n{\n for (size_t i = 1; i < nstrings; i++)\n if (strcmp(strings[i - 1], strings[i]) >= 0)\n return false;\n return true;\n}\n","Rust":"fn strings_are_equal(seq: &[&str]) -> bool {\n match seq {\n &[] | &[_] => true,\n &[x, y, ref tail\u00a0@ ..] if x == y => strings_are_equal(&[&[y], tail].concat()),\n _ => false\n }\n}\n\nfn asc_strings(seq: &[&str]) -> bool {\n match seq {\n &[] | &[_] => true,\n &[x, y, ref tail @ ..] if x < y => asc_strings(&[&[y], tail].concat()),\n _ => false\n }\n}\n"} {"name":"Compare length of two strings","C":"#include \n#include \n#include \n\nint cmp(const int* a, const int* b)\n{\n return *b - *a; \n}\n\nvoid compareAndReportStringsLength(const char* strings[], const int n)\n{\n if (n > 0)\n {\n char* has_length = \"has length\";\n char* predicate_max = \"and is the longest string\";\n char* predicate_min = \"and is the shortest string\";\n char* predicate_ave = \"and is neither the longest nor the shortest string\";\n\n int* si = malloc(2 * n * sizeof(int));\n if (si != NULL)\n {\n for (int i = 0; i < n; i++)\n {\n si[2 * i] = strlen(strings[i]);\n si[2 * i + 1] = i;\n }\n qsort(si, n, 2 * sizeof(int), cmp);\n\n int max = si[0];\n int min = si[2 * (n - 1)];\n\n for (int i = 0; i < n; i++)\n {\n int length = si[2 * i];\n char* string = strings[si[2 * i + 1]];\n char* predicate;\n if (length == max)\n predicate = predicate_max;\n else if (length == min)\n predicate = predicate_min;\n else\n predicate = predicate_ave;\n printf(\"\\\"%s\\\" %s %d %s\\n\",\n string, has_length, length, predicate);\n }\n\n free(si);\n }\n else\n {\n fputs(\"unable allocate memory buffer\", stderr);\n }\n }\n}\n\nint main(int argc, char* argv[])\n{\n char* list[] = { \"abcd\", \"123456789\", \"abcdef\", \"1234567\" };\n\n compareAndReportStringsLength(list, 4);\n\n return EXIT_SUCCESS;\n}\n","Rust":"fn compare_and_report(string1: T, string2: T) -> String {\n let strings = [string1.to_string(), string2.to_string()];\n let difference = strings[0].len() as i32 - strings[1].len() as i32;\n if difference == 0 { \n format!(\"\\\"{}\\\" and \\\"{}\\\" are of equal length, {}\", strings[0], strings[1], strings[0].len())\n } else if difference > 1 { \n format!(\"\\\"{}\\\" has length {} and is the longest\\n\\\"{}\\\" has length {} and is the shortest\", strings[0], strings[0].len(), strings[1], strings[1].len())\n } else { \n format!(\"\\\"{}\\\" has length {} and is the longest\\n\\\"{}\\\" has length {} and is the shortest\", strings[1], strings[1].len(), strings[0], strings[0].len())\n }\n}\n\nfn main() {\n println!(\"{}\", compare_and_report(\"a\", \"b\"));\n println!(\"\\n{}\", compare_and_report(\"cd\", \"e\"));\n println!(\"\\n{}\", compare_and_report(\"f\", \"gh\"));\n}\n"} {"name":"Compile-time calculation","C":"#include \n#include \n\n#define ORDER_PP_DEF_8fac ORDER_PP_FN( \\\n8fn(8X, 8seq_fold(8times, 1, 8seq_iota(1, 8inc(8X)))) )\n\nint main(void) {\n\tprintf(\"10! = %d\\n\", ORDER_PP( 8to_lit( 8fac(10) ) ) );\n\treturn 0;\n}\n","Rust":"fn factorial(n: i64) -> i64 {\n let mut total = 1;\n for i in 1..n+1 {\n total *= i;\n }\n return total;\n}\n\nfn main() {\n println!(\"Factorial of 10 is {}.\", factorial(10));\n}\n"} {"name":"Compound data type","C":"typedef struct Point\n{\n int x;\n int y;\n} Point;\n","Rust":" \nstruct Point {\n x: T,\n y: T,\n}\nfn main() {\n let p = Point { x: 1.0, y: 2.5 }; \n println!(\"{}, {}\", p.x, p.y);\n}\n"} {"name":"Concurrent computing","C":"#include \n#include \n#include \n\npthread_mutex_t condm = PTHREAD_MUTEX_INITIALIZER;\npthread_cond_t cond = PTHREAD_COND_INITIALIZER;\nint bang = 0;\n\n#define WAITBANG() do { \\\n pthread_mutex_lock(&condm); \\\n while( bang == 0 ) \\\n { \\\n pthread_cond_wait(&cond, &condm); \\\n } \\\n pthread_mutex_unlock(&condm); } while(0);\\\n\nvoid *t_enjoy(void *p)\n{\n WAITBANG();\n printf(\"Enjoy\\n\");\n pthread_exit(0);\n}\n\nvoid *t_rosetta(void *p)\n{\n WAITBANG();\n printf(\"Rosetta\\n\");\n pthread_exit(0);\n}\n\nvoid *t_code(void *p)\n{\n WAITBANG();\n printf(\"Code\\n\");\n pthread_exit(0);\n}\n\ntypedef void *(*threadfunc)(void *);\nint main()\n{\n int i;\n pthread_t a[3];\n threadfunc p[3] = {t_enjoy, t_rosetta, t_code};\n \n for(i=0;i<3;i++)\n {\n pthread_create(&a[i], NULL, p[i], NULL);\n }\n sleep(1);\n bang = 1;\n pthread_cond_broadcast(&cond);\n for(i=0;i<3;i++)\n {\n pthread_join(a[i], NULL);\n }\n}\n","Rust":"extern crate rand; \nuse std::thread;\nuse rand::thread_rng;\nuse rand::distributions::{Range, IndependentSample};\n\nfn main() {\n let mut rng = thread_rng();\n let rng_range = Range::new(0u32, 100);\n for word in \"Enjoy Rosetta Code\".split_whitespace() {\n let snooze_time = rng_range.ind_sample(&mut rng);\n let local_word = word.to_owned();\n std::thread::spawn(move || {\n thread::sleep_ms(snooze_time);\n println!(\"{}\", local_word);\n });\n }\n thread::sleep_ms(1000);\n}\n"} {"name":"Conditional structures","C":"int a = 3;\n\n\nif (a == 2) {\n puts (\"a is 2\"); \n} else if (a == 3) {\n puts (\"a is 3\");\n} else {\n puts(\"a is 4\");\n}\n\n\nunless (a == 2) { \n puts (\"a is 2\"); \n} else if (a == 3) {\n puts (\"a is 3\");\n} else {\n puts(\"a is 4\");\n} \n\n\nswitch (a) {\n case 2:\n puts (\"a is 2\"); \n break;\n case 3:\n puts (\"a is 3\");\n break;\n case 4:\n puts (\"a is 4\");\n break;\n default: \n puts(\"is neither\");\n}\n","Rust":"\n#[cfg(target_os = \"linux\")]\nfn running_linux() {\n println!(\"This is linux\");\n}\n#[cfg(not(target_os = \"linux\"))]\nfn running_linux() {\n println!(\"This is not linux\");\n}\n\n\n#[cfg_attr(target_os = \"linux\", target_env = \"gnu\")]\n\n\n#[cfg(all(\n any(target_arch = \"arm\", target_endian = \"little\"),\n not(target_pointer_width = \"32\"),\n unix,\n test\n ))]\nfn highly_specific_function() {}\n"} {"name":"Constrained random points on a circle","C":"#include \n#include \n\ninline\nint randn(int m)\n{\n\tint rand_max = RAND_MAX - (RAND_MAX % m);\n\tint r;\n\twhile ((r = rand()) > rand_max);\n\treturn r \/ (rand_max \/ m);\n}\n\nint main()\n{\n\tint i, x, y, r2;\n\tunsigned long buf[31] = {0}; \n\n\tfor (i = 0; i < 100; ) {\n\t\tx = randn(31) - 15;\n\t\ty = randn(31) - 15;\n\t\tr2 = x * x + y * y;\n\t\tif (r2 >= 100 && r2 <= 225) {\n\t\t\tbuf[15 + y] |= 1 << (x + 15);\n\t\t\ti++;\n\t\t}\n\t}\n\n\tfor (y = 0; y < 31; y++) {\n\t\tfor (x = 0; x < 31; x++)\n\t\t\tprintf((buf[y] & 1 << x) ? \". \" : \" \");\n\t\tprintf(\"\\n\");\n\t}\n\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::Rng;\n\nconst POINTS_N: usize = 100;\n\nfn generate_point(rng: &mut R) -> (i32, i32) {\n loop {\n let x = rng.gen_range(-15, 16); \n let y = rng.gen_range(-15, 16);\n\n let r2 = x * x + y * y;\n if r2 >= 100 && r2 <= 225 {\n return (x, y);\n }\n }\n}\n\nfn filtering_method(rng: &mut R) {\n let mut rows = [[\" \"; 62]; 31];\n\n \n for _ in 0..POINTS_N {\n let (x, y) = generate_point(rng);\n rows[(y + 15) as usize][(x + 15) as usize * 2] = \"*\";\n }\n\n \n for row in &rows {\n println!(\"{}\", row.concat());\n }\n}\n\nfn precalculating_method(rng: &mut R) {\n \n let mut possible_points = Vec::with_capacity(404);\n for y in -15..=15 {\n for x in -15..=15 {\n let r2 = x * x + y * y;\n if r2 >= 100 && r2 <= 225 {\n possible_points.push((x, y));\n }\n }\n }\n\n \n let len = possible_points.len();\n for i in (len - POINTS_N..len).rev() {\n let j = rng.gen_range(0, i + 1);\n possible_points.swap(i, j);\n }\n\n \n let mut rows = [[\" \"; 62]; 31];\n for &(x, y) in &possible_points[len - POINTS_N..] {\n rows[(y + 15) as usize][(x + 15) as usize * 2] = \"*\";\n }\n\n \n for row in &rows {\n println!(\"{}\", row.concat());\n }\n}\n\nfn main() {\n let mut rng = rand::weak_rng();\n\n filtering_method(&mut rng);\n\n precalculating_method(&mut rng);\n}\n"} {"name":"Continued fraction","C":"\n#include \n\n\ntypedef double (*coeff_func)(unsigned n);\n\n\ndouble calc(coeff_func f_a, coeff_func f_b, unsigned expansions)\n{\n\tdouble a, b, r;\n\ta = b = r = 0.0;\n\n\tunsigned i;\n\tfor (i = expansions; i > 0; i--) {\n\t\ta = f_a(i);\n\t\tb = f_b(i);\n\t\tr = b \/ (a + r);\n\t}\n\ta = f_a(0);\n\n\treturn a + r;\n}\n\n\ndouble sqrt2_a(unsigned n)\n{\n\treturn n ? 2.0 : 1.0;\n}\n\ndouble sqrt2_b(unsigned n)\n{\n\treturn 1.0;\n}\n\n\ndouble napier_a(unsigned n)\n{\n\treturn n ? n : 2.0;\n}\n\ndouble napier_b(unsigned n)\n{\n\treturn n > 1.0 ? n - 1.0 : 1.0;\n}\n\n\ndouble pi_a(unsigned n)\n{\n\treturn n ? 6.0 : 3.0;\n}\n\ndouble pi_b(unsigned n)\n{\n\tdouble c = 2.0 * n - 1.0;\n\n\treturn c * c;\n}\n\nint main(void)\n{\n\tdouble sqrt2, napier, pi;\n\n\tsqrt2 = calc(sqrt2_a, sqrt2_b, 1000);\n\tnapier = calc(napier_a, napier_b, 1000);\n\tpi = calc(pi_a, pi_b, 1000);\n\n\tprintf(\"%12.10g\\n%12.10g\\n%12.10g\\n\", sqrt2, napier, pi);\n\n\treturn 0;\n}\n","Rust":"use std::iter;\n\n\n\n\n\n\n\n\n\n\n\n\nmacro_rules! continued_fraction {\n ($a:expr, $b:expr ; $iterations:expr) => (\n ($a).zip($b)\n .take($iterations)\n .collect::>().iter()\n .rev()\n .fold(0 as f64, |acc: f64, &(x, y)| {\n x as f64 + (y as f64 \/ acc)\n })\n );\n\n ($a:expr, $b:expr) => (continued_fraction!($a, $b ; 1000));\n}\n\nfn main() {\n \n let sqrt2a = (1..2).chain(iter::repeat(2));\n let sqrt2b = iter::repeat(1);\n println!(\"{}\", continued_fraction!(sqrt2a, sqrt2b));\n\n\n \n let napiera = (2..3).chain(1..);\n let napierb = (1..2).chain(1..);\n println!(\"{}\", continued_fraction!(napiera, napierb));\n\n\n \n let pia = (3..4).chain(iter::repeat(6));\n let pib = (1i64..).map(|x| (2 * x - 1).pow(2));\n println!(\"{}\", continued_fraction!(pia, pib));\n}\n"} {"name":"Continued fraction_Arithmetic_Construct from rational number","C":"#include\n\ntypedef struct{\n\tint num,den;\n\t}fraction;\n\nfraction examples[] = {{1,2}, {3,1}, {23,8}, {13,11}, {22,7}, {-151,77}}; \nfraction sqrt2[] = {{14142,10000}, {141421,100000}, {1414214,1000000}, {14142136,10000000}};\nfraction pi[] = {{31,10}, {314,100}, {3142,1000}, {31428,10000}, {314285,100000}, {3142857,1000000}, {31428571,10000000}, {314285714,100000000}};\n\nint r2cf(int *numerator,int *denominator)\n{\n\tint quotient=0,temp;\n\t\n\tif(denominator != 0)\n\t{\n\t\tquotient = *numerator \/ *denominator;\n\t\t\n\t\ttemp = *numerator;\n\t\t\n\t\t*numerator = *denominator;\n\t\t\n\t\t*denominator = temp % *denominator;\n\t}\n\t\n\treturn quotient;\n}\n\nint main()\n{\n\tint i;\n\t\n\tprintf(\"Running the examples\u00a0:\");\n\t\n\tfor(i=0;i Option {\n if self.n2 == 0 {\n None\n }\n else {\n let t1 = self.n1 \/ self.n2;\n let t2 = self.n2;\n self.n2 = self.n1 - t1 * t2;\n self.n1 = t2;\n Some(t1)\n }\n }\n}\n\nfn r2cf(n1: i64, n2: i64) -> R2cf {\n R2cf { n1: n1, n2: n2 }\n}\n\nmacro_rules! printcf {\n ($x:expr, $y:expr) => (println!(\"{:?}\", r2cf($x, $y).collect::>()));\n}\n\nfn main() {\n printcf!(1, 2);\n printcf!(3, 1);\n printcf!(23, 8);\n printcf!(13, 11);\n printcf!(22, 7);\n printcf!(-152, 77);\n\n printcf!(14_142, 10_000);\n printcf!(141_421, 100_000);\n printcf!(1_414_214, 1_000_000);\n printcf!(14_142_136, 10_000_000);\n\n printcf!(31, 10);\n printcf!(314, 100);\n printcf!(3142, 1000);\n printcf!(31_428, 10_000);\n printcf!(314_285, 100_000);\n printcf!(3_142_857, 1_000_000);\n printcf!(31_428_571, 10_000_000);\n printcf!(314_285_714, 100_000_000);\n}\n"} {"name":"Convert seconds to compound duration","C":"\n\n#define _CRT_SECURE_NO_WARNINGS \n\n#include \n#include \n\n\nchar* seconds2string(unsigned long seconds) \n{\n int i;\n\n const unsigned long s = 1;\n const unsigned long m = 60 * s;\n const unsigned long h = 60 * m;\n const unsigned long d = 24 * h;\n const unsigned long w = 7 * d;\n\n const unsigned long coeff[5] = { w, d, h, m, s };\n const char units[5][4] = { \"wk\", \"d\", \"hr\", \"min\", \"sec\" };\n\n static char buffer[256];\n char* ptr = buffer;\n\n for ( i = 0; i < 5; i++ )\n {\n unsigned long value;\n value = seconds \/ coeff[i];\n seconds = seconds % coeff[i];\n if ( value )\n {\n if ( ptr != buffer ) \n ptr += sprintf(ptr, \", \");\n ptr += sprintf(ptr,\"%lu %s\",value,units[i]);\n }\n }\n\n return buffer;\n}\n\n\nint main(int argc, char argv[])\n{\n unsigned long seconds;\n\n if ( (argc < 2) && scanf( \"%lu\", &seconds ) \n || (argc >= 2) && sscanf( argv[1], \"%lu\", & seconds ) )\n {\n printf( \"%s\\n\", seconds2string(seconds) );\n return EXIT_SUCCESS;\n }\n\n return EXIT_FAILURE;\n}\n","Rust":"use std::fmt;\n\n\nstruct CompoundTime {\n w: usize,\n d: usize,\n h: usize,\n m: usize,\n s: usize,\n}\n\nmacro_rules! reduce {\n ($s: ident, $(($from: ident, $to: ident, $factor: expr)),+) => {{\n $(\n $s.$to += $s.$from \/ $factor;\n $s.$from %= $factor;\n )+\n }}\n}\n\nimpl CompoundTime {\n #[inline]\n fn new(w: usize, d: usize, h: usize, m: usize, s: usize) -> Self{\n CompoundTime { w: w, d: d, h: h, m: m, s: s, }\n }\n\n #[inline]\n fn balance(&mut self) {\n reduce!(self, (s, m, 60), (m, h, 60),\n (h, d, 24), (d, w, 7));\n }\n}\n\nimpl fmt::Display for CompoundTime {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{}w {}d {}h {}m {}s\", \n self.w, self.d, self.h, self.m, self.s)\n }\n}\n\nfn main() {\n let mut ct = CompoundTime::new(0,3,182,345,2412);\n println!(\"Before: {}\", ct);\n ct.balance();\n println!(\"After: {}\", ct);\n}\n"} {"name":"Convex hull","C":"#include \n#include \n#include \n#include \n \ntypedef struct tPoint {\n int x, y;\n} Point;\n \nbool ccw(const Point *a, const Point *b, const Point *c) {\n return (b->x - a->x) * (c->y - a->y)\n > (b->y - a->y) * (c->x - a->x);\n}\n \nint comparePoints(const void *lhs, const void *rhs) {\n const Point* lp = lhs;\n const Point* rp = rhs;\n if (lp->x < rp->x)\n return -1;\n if (rp->x < lp->x)\n return 1;\n if (lp->y < rp->y)\n return -1;\n if (rp->y < lp->y)\n return 1;\n return 0;\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\nvoid printPoints(const Point* points, int len) {\n printf(\"[\");\n if (len > 0) {\n const Point* ptr = points;\n const Point* end = points + len;\n printf(\"(%d, %d)\", ptr->x, ptr->y);\n ++ptr;\n for (; ptr < end; ++ptr)\n printf(\", (%d, %d)\", ptr->x, ptr->y);\n }\n printf(\"]\");\n}\n \nPoint* convexHull(Point p[], int len, int* hsize) {\n if (len == 0) {\n *hsize = 0;\n return NULL;\n }\n\n int i, size = 0, capacity = 4;\n Point* hull = xmalloc(capacity * sizeof(Point));\n\n qsort(p, len, sizeof(Point), comparePoints);\n \n \n for (i = 0; i < len; ++i) {\n while (size >= 2 && !ccw(&hull[size - 2], &hull[size - 1], &p[i]))\n --size;\n if (size == capacity) {\n capacity *= 2;\n hull = xrealloc(hull, capacity * sizeof(Point));\n }\n assert(size >= 0 && size < capacity);\n hull[size++] = p[i];\n }\n \n \n int t = size + 1;\n for (i = len - 1; i >= 0; i--) {\n while (size >= t && !ccw(&hull[size - 2], &hull[size - 1], &p[i]))\n --size;\n if (size == capacity) {\n capacity *= 2;\n hull = xrealloc(hull, capacity * sizeof(Point));\n }\n assert(size >= 0 && size < capacity);\n hull[size++] = p[i];\n }\n --size;\n assert(size >= 0);\n hull = xrealloc(hull, size * sizeof(Point));\n *hsize = size;\n return hull;\n}\n \nint main() {\n Point points[] = {\n {16, 3}, {12, 17}, { 0, 6}, {-4, -6}, {16, 6},\n {16, -7}, {16, -3}, {17, -4}, { 5, 19}, {19, -8},\n { 3, 16}, {12, 13}, { 3, -4}, {17, 5}, {-3, 15},\n {-3, -9}, { 0, 11}, {-9, -3}, {-4, -2}, {12, 10}\n };\n int hsize;\n Point* hull = convexHull(points, sizeof(points)\/sizeof(Point), &hsize);\n printf(\"Convex Hull: \");\n printPoints(hull, hsize);\n printf(\"\\n\");\n free(hull);\n \n return 0;\n}\n","Rust":"#[derive(Debug, Clone)]\nstruct Point {\n x: f32,\n y: f32\n}\n\nfn calculate_convex_hull(points: &Vec) -> Vec {\n \n if points.len() < 3 { return points.clone(); }\n\n let mut hull = vec![];\n\n \n let (left_most_idx, _) = points.iter()\n .enumerate()\n .min_by(|lhs, rhs| lhs.1.x.partial_cmp(&rhs.1.x).unwrap())\n .expect(\"No left most point\");\n\n \n let mut p = left_most_idx;\n let mut q = 0_usize;\n\n loop {\n \n hull.push(points[p].clone());\n\n q = (p + 1) % points.len();\n\n for i in 0..points.len() {\n if orientation(&points[p], &points[i], &points[q]) == 2 {\n q = i;\n }\n }\n\n p = q;\n\n \n if p == left_most_idx { break; }\n }\n\n return hull;\n}\n\n\n\n\n\nfn orientation(p: &Point, q: &Point, r: &Point) -> usize {\n let val = (q.y - p.y) * (r.x - q.x) -\n (q.x - p.x) * (r.y - q.y);\n\n if val == 0. { return 0 };\n if val > 0. { return 1; } else { return 2; }\n}\n\nfn main(){\n let points = vec![pt(16,3), pt(12,17), pt(0,6), pt(-4,-6), pt(16,6), pt(16,-7), pt(16,-3), pt(17,-4), pt(5,19), pt(19,-8), pt(3,16), pt(12,13), pt(3,-4), pt(17,5), pt(-3,15), pt(-3,-9), pt(0,11), pt(-9,-3), pt(-4,-2), pt(12,10)];\n let hull = calculate_convex_hull(&points);\n \n hull.iter()\n .for_each(|pt| println!(\"{:?}\", pt));\n}\n\nfn pt(x: i32, y: i32) -> Point {\n return Point {x:x as f32, y:y as f32};\n}\n"} {"name":"Conway's Game of Life","C":"#include \n#include \n#include \n\n#define for_x for (int x = 0; x < w; x++)\n#define for_y for (int y = 0; y < h; y++)\n#define for_xy for_x for_y\nvoid show(void *u, int w, int h)\n{\n\tint (*univ)[w] = u;\n\tprintf(\"\\033[H\");\n\tfor_y {\n\t\tfor_x printf(univ[y][x] ? \"\\033[07m \\033[m\" : \" \");\n\t\tprintf(\"\\033[E\");\n\t}\n\tfflush(stdout);\n}\n\nvoid evolve(void *u, int w, int h)\n{\n\tunsigned (*univ)[w] = u;\n\tunsigned new[h][w];\n\n\tfor_y for_x {\n\t\tint n = 0;\n\t\tfor (int y1 = y - 1; y1 <= y + 1; y1++)\n\t\t\tfor (int x1 = x - 1; x1 <= x + 1; x1++)\n\t\t\t\tif (univ[(y1 + h) % h][(x1 + w) % w])\n\t\t\t\t\tn++;\n\n\t\tif (univ[y][x]) n--;\n\t\tnew[y][x] = (n == 3 || (n == 2 && univ[y][x]));\n\t}\n\tfor_y for_x univ[y][x] = new[y][x];\n}\n\nvoid game(int w, int h)\n{\n\tunsigned univ[h][w];\n\tfor_xy univ[y][x] = rand() < RAND_MAX \/ 10 ? 1 : 0;\n\twhile (1) {\n\t\tshow(univ, w, h);\n\t\tevolve(univ, w, h);\n\t\tusleep(200000);\n\t}\n}\n\nint main(int c, char **v)\n{\n\tint w = 0, h = 0;\n\tif (c > 1) w = atoi(v[1]);\n\tif (c > 2) h = atoi(v[2]);\n\tif (w <= 0) w = 30;\n\tif (h <= 0) h = 30;\n\tgame(w, h);\n}\n","Rust":"use std::collections::HashMap;\nuse std::collections::HashSet;\n\ntype Cell = (i32, i32);\ntype Colony = HashSet;\n\nfn print_colony(col: &Colony, width: i32, height: i32) {\n for y in 0..height {\n for x in 0..width {\n print!(\"{} \",\n if col.contains(&(x, y)) {\"O\"}\n else {\".\"}\n );\n }\n println!();\n }\n}\n\nfn neighbours(&(x,y): &Cell) -> Vec {\n vec![\n (x-1,y-1), (x,y-1), (x+1,y-1),\n (x-1,y), (x+1,y),\n (x-1,y+1), (x,y+1), (x+1,y+1),\n ]\n}\n\nfn neighbour_counts(col: &Colony) -> HashMap {\n let mut ncnts = HashMap::new();\n for cell in col.iter().flat_map(neighbours) {\n *ncnts.entry(cell).or_insert(0) += 1;\n }\n ncnts\n}\n\nfn generation(col: Colony) -> Colony {\n neighbour_counts(&col)\n .into_iter()\n .filter_map(|(cell, cnt)|\n match (cnt, col.contains(&cell)) {\n (2, true) |\n (3, ..) => Some(cell),\n _ => None\n })\n .collect()\n}\n\nfn life(init: Vec, iters: i32, width: i32, height: i32) {\n let mut col: Colony = init.into_iter().collect(); \n for i in 0..iters+1\n {\n println!(\"({})\", &i);\n if i != 0 {\n col = generation(col);\n }\n print_colony(&col, width, height);\n }\n}\n\nfn main() {\n let blinker = vec![\n (1,0),\n (1,1),\n (1,2)];\n\n life(blinker, 3, 3, 3);\n\n let glider = vec![\n (1,0),\n (2,1),\n (0,2), (1,2), (2,2)];\n\n life(glider, 20, 8, 8);\n}\n"} {"name":"Copy stdin to stdout","C":"#include \n\nint main(){\n char c;\n while ( (c=getchar()) != EOF ){\n putchar(c);\n }\n return 0;\n}\n","Rust":"use std::io;\n\nfn main() {\n io::copy(&mut io::stdin().lock(), &mut io::stdout().lock());\n}\n"} {"name":"Count in factors","C":"#include \n#include \n\ntypedef unsigned long long ULONG;\n\nULONG get_prime(int idx)\n{\n static long n_primes = 0, alloc = 0;\n static ULONG *primes = 0;\n ULONG last, p;\n int i;\n\n if (idx >= n_primes) {\n if (n_primes >= alloc) {\n alloc += 16; \n primes = realloc(primes, sizeof(ULONG) * alloc);\n }\n if (!n_primes) {\n primes[0] = 2;\n primes[1] = 3;\n n_primes = 2;\n }\n\n last = primes[n_primes-1];\n while (idx >= n_primes) {\n last += 2;\n for (i = 0; i < n_primes; i++) {\n p = primes[i];\n if (p * p > last) {\n primes[n_primes++] = last;\n break;\n }\n if (last % p == 0) break;\n }\n }\n }\n return primes[idx];\n}\n\nint main()\n{\n ULONG n, x, p;\n int i, first;\n\n for (x = 1; ; x++) {\n printf(\"%lld = \", n = x);\n\n for (i = 0, first = 1; ; i++) {\n p = get_prime(i);\n while (n % p == 0) {\n n \/= p;\n if (!first) printf(\" x \");\n first = 0;\n printf(\"%lld\", p);\n }\n if (n <= p * p) break;\n }\n\n if (first) printf(\"%lld\\n\", n);\n else if (n > 1) printf(\" x %lld\\n\", n);\n else printf(\"\\n\");\n }\n return 0;\n}\n","Rust":"use std::env;\n\nfn main() {\n let args: Vec<_> = env::args().collect();\n let n = if args.len() > 1 {\n args[1].parse().expect(\"Not a valid number to count to\")\n }\n else {\n 20\n };\n count_in_factors_to(n);\n}\n\nfn count_in_factors_to(n: u64) {\n println!(\"1\");\n let mut primes = vec![];\n for i in 2..=n {\n let fs = factors(&primes, i);\n if fs.len() <= 1 {\n primes.push(i);\n println!(\"{}\", i);\n }\n else {\n println!(\"{} = {}\", i, fs.iter().map(|f| f.to_string()).collect::>().join(\" x \"));\n }\n }\n}\n\nfn factors(primes: &[u64], mut n: u64) -> Vec {\n let mut result = Vec::new();\n for p in primes {\n while n % p == 0 {\n result.push(*p);\n n \/= p;\n }\n if n == 1 {\n return result;\n }\n }\n vec![n]\n}\n"} {"name":"Count in octal","C":"#include \n\nint main()\n{\n unsigned int i = 0;\n do { printf(\"%o\\n\", i++); } while(i);\n return 0;\n}\n","Rust":"fn main() {\n for i in 0..std::usize::MAX {\n println!(\"{:o}\", i);\n }\n}\n"} {"name":"Count the coins","C":"#include \n#include \n#include \n\n\n\ntypedef struct { uint64_t x[2]; } i128;\n\n\nvoid show(i128 v) {\n\tuint32_t x[4] = {v.x[0], v.x[0] >> 32, v.x[1], v.x[1] >> 32};\n\tint i, j = 0, len = 4;\n\tchar buf[100];\n\tdo {\n\t\tuint64_t c = 0;\n\t\tfor (i = len; i--; ) {\n\t\t\tc = (c << 32) + x[i];\n\t\t\tx[i] = c \/ 10, c %= 10;\n\t\t}\n\n\t\tbuf[j++] = c + '0';\n\t\tfor (len = 4; !x[len - 1]; len--);\n\t} while (len);\n\n\twhile (j--) putchar(buf[j]);\n\tputchar('\\n');\n}\n\ni128 count(int sum, int *coins)\n{\n\tint n, i, k;\n\tfor (n = 0; coins[n]; n++);\n\n\ti128 **v = malloc(sizeof(int*) * n);\n\tint *idx = malloc(sizeof(int) * n);\n\n\tfor (i = 0; i < n; i++) {\n\t\tidx[i] = coins[i];\n\t\t\n\t\tv[i] = calloc(sizeof(i128), coins[i]);\n\t}\n\n\tv[0][coins[0] - 1] = (i128) {{1, 0}};\n\n\tfor (k = 0; k <= sum; k++) {\n\t\tfor (i = 0; i < n; i++)\n\t\t\tif (!idx[i]--) idx[i] = coins[i] - 1;\n\n\t\ti128 c = v[0][ idx[0] ];\n\n\t\tfor (i = 1; i < n; i++) {\n\t\t\ti128 *p = v[i] + idx[i];\n\n\t\t\t\n\t\t\tp->x[0] += c.x[0];\n\t\t\tp->x[1] += c.x[1];\n\t\t\tif (p->x[0] < c.x[0]) \n\t\t\t\tp->x[1] ++;\n\t\t\tc = *p;\n\t\t}\n\t}\n\n\ti128 r = v[n - 1][idx[n-1]];\n\n\tfor (i = 0; i < n; i++) free(v[i]);\n\tfree(v);\n\tfree(idx);\n\n\treturn r;\n}\n\n\nint count2(int sum, int *coins)\n{\n\tif (!*coins || sum < 0) return 0;\n\tif (!sum) return 1;\n\treturn count2(sum - *coins, coins) + count2(sum, coins + 1);\n}\n\nint main(void)\n{\n\tint us_coins[] = { 100, 50, 25, 10, 5, 1, 0 };\n\tint eu_coins[] = { 200, 100, 50, 20, 10, 5, 2, 1, 0 };\n\n\tshow(count( 100, us_coins + 2));\n\tshow(count( 1000, us_coins));\n\n\tshow(count( 1000 * 100, us_coins));\n\tshow(count( 10000 * 100, us_coins));\n\tshow(count(100000 * 100, us_coins));\n\n\tputchar('\\n');\n\n\tshow(count( 1 * 100, eu_coins));\n\tshow(count( 1000 * 100, eu_coins));\n\tshow(count( 10000 * 100, eu_coins));\n\tshow(count(100000 * 100, eu_coins));\n\n\treturn 0;\n}\n","Rust":"fn make_change(coins: &[usize], cents: usize) -> usize {\n let size = cents + 1;\n let mut ways = vec![0; size];\n ways[0] = 1;\n for &coin in coins {\n for amount in coin..size {\n ways[amount] += ways[amount - coin];\n }\n }\n ways[cents]\n}\n\nfn main() {\n println!(\"{}\", make_change(&[1,5,10,25], 100));\n println!(\"{}\", make_change(&[1,5,10,25,50,100], 100_000));\n}\n"} {"name":"Cramer's rule","C":"#include \n#include \n#include \n\ntypedef struct {\n int n;\n double **elems;\n} SquareMatrix;\n\nSquareMatrix init_square_matrix(int n, double elems[n][n]) {\n SquareMatrix A = {\n .n = n,\n .elems = malloc(n * sizeof(double *))\n };\n for(int i = 0; i < n; ++i) {\n A.elems[i] = malloc(n * sizeof(double));\n for(int j = 0; j < n; ++j)\n A.elems[i][j] = elems[i][j];\n }\n\n return A;\n}\n\nSquareMatrix copy_square_matrix(SquareMatrix src) {\n SquareMatrix dest;\n dest.n = src.n;\n dest.elems = malloc(dest.n * sizeof(double *));\n for(int i = 0; i < dest.n; ++i) {\n dest.elems[i] = malloc(dest.n * sizeof(double));\n for(int j = 0; j < dest.n; ++j)\n dest.elems[i][j] = src.elems[i][j];\n }\n\n return dest;\n}\n\ndouble det(SquareMatrix A) {\n double det = 1;\n\n for(int j = 0; j < A.n; ++j) {\n int i_max = j;\n for(int i = j; i < A.n; ++i)\n if(A.elems[i][j] > A.elems[i_max][j])\n i_max = i;\n\n if(i_max != j) {\n for(int k = 0; k < A.n; ++k) {\n double tmp = A.elems[i_max][k];\n A.elems[i_max][k] = A.elems[j][k];\n A.elems[j][k] = tmp;\n }\n\n det *= -1;\n }\n\n if(abs(A.elems[j][j]) < 1e-12) {\n puts(\"Singular matrix!\");\n return NAN;\n }\n\n for(int i = j + 1; i < A.n; ++i) {\n double mult = -A.elems[i][j] \/ A.elems[j][j];\n for(int k = 0; k < A.n; ++k)\n A.elems[i][k] += mult * A.elems[j][k];\n }\n }\n\n for(int i = 0; i < A.n; ++i)\n det *= A.elems[i][i];\n\n return det;\n}\n\nvoid deinit_square_matrix(SquareMatrix A) {\n for(int i = 0; i < A.n; ++i)\n free(A.elems[i]);\n free(A.elems);\n}\n\ndouble cramer_solve(SquareMatrix A, double det_A, double *b, int var) {\n SquareMatrix tmp = copy_square_matrix(A);\n for(int i = 0; i < tmp.n; ++i)\n tmp.elems[i][var] = b[i];\n\n double det_tmp = det(tmp);\n deinit_square_matrix(tmp);\n\n return det_tmp \/ det_A;\n}\n\nint main(int argc, char **argv) {\n#define N 4\n double elems[N][N] = {\n { 2, -1, 5, 1},\n { 3, 2, 2, -6},\n { 1, 3, 3, -1},\n { 5, -2, -3, 3}\n };\n SquareMatrix A = init_square_matrix(N, elems);\n\n SquareMatrix tmp = copy_square_matrix(A);\n int det_A = det(tmp);\n deinit_square_matrix(tmp);\n\n double b[] = {-3, -32, -47, 49};\n\n for(int i = 0; i < N; ++i)\n printf(\"%7.3lf\\n\", cramer_solve(A, det_A, b, i));\n\n deinit_square_matrix(A);\n return EXIT_SUCCESS;\n}\n","Rust":"use std::ops::{Index, IndexMut};\n\nfn main() {\n let m = matrix(\n vec![\n 2., -1., 5., 1., 3., 2., 2., -6., 1., 3., 3., -1., 5., -2., -3., 3.,\n ],\n 4,\n );\n let mm = m.solve(&vec![-3., -32., -47., 49.]);\n println!(\"{:?}\", mm);\n}\n\n#[derive(Clone)]\nstruct Matrix {\n elts: Vec,\n dim: usize,\n}\n\nimpl Matrix {\n \n \n \n fn det(&self) -> f64 {\n match self.dim {\n 0 => 0.,\n 1 => self[0][0],\n 2 => self[0][0] * self[1][1] - self[0][1] * self[1][0],\n d => {\n let mut acc = 0.;\n let mut signature = 1.;\n for k in 0..d {\n acc += signature * self[0][k] * self.comatrix(0, k).det();\n signature *= -1.\n }\n acc\n }\n }\n }\n\n \n fn solve(&self, target: &Vec) -> Vec {\n let mut solution: Vec = vec![0.; self.dim];\n let denominator = self.det();\n for j in 0..self.dim {\n let mut mm = self.clone();\n for i in 0..self.dim {\n mm[i][j] = target[i]\n }\n solution[j] = mm.det() \/ denominator\n }\n solution\n }\n\n \n fn comatrix(&self, k: usize, l: usize) -> Matrix {\n let mut v: Vec = vec![];\n for i in 0..self.dim {\n for j in 0..self.dim {\n if i != k && j != l {\n v.push(self[i][j])\n }\n }\n }\n matrix(v, self.dim - 1)\n }\n}\n\nfn matrix(elts: Vec, dim: usize) -> Matrix {\n assert_eq!(elts.len(), dim * dim);\n Matrix { elts, dim }\n}\n\nimpl Index for Matrix {\n type Output = [f64];\n\n fn index(&self, i: usize) -> &Self::Output {\n let m = self.dim;\n &self.elts[m * i..m * (i + 1)]\n }\n}\n\nimpl IndexMut for Matrix {\n fn index_mut(&mut self, i: usize) -> &mut Self::Output {\n let m = self.dim;\n &mut self.elts[m * i..m * (i + 1)]\n }\n}\n"} {"name":"Create a file","C":"#include \n\nint main() {\n FILE *fh = fopen(\"output.txt\", \"w\");\n fclose(fh);\n\n return 0;\n}\n","Rust":"use std::io::{self, Write};\nuse std::fs::{DirBuilder, File};\nuse std::path::Path;\nuse std::{process,fmt};\n\nconst FILE_NAME: &'static str = \"output.txt\";\nconst DIR_NAME : &'static str = \"docs\";\n\nfn main() {\n create(\".\").and(create(\"\/\"))\n .unwrap_or_else(|e| error_handler(e,1));\n}\n\n\nfn create

(root: P) -> io::Result\n where P: AsRef\n{\n let f_path = root.as_ref().join(FILE_NAME);\n let d_path = root.as_ref().join(DIR_NAME);\n DirBuilder::new().create(d_path).and(File::create(f_path))\n}\n\nfn error_handler(error: E, code: i32) -> ! {\n let _ = writeln!(&mut io::stderr(), \"Error: {}\", error);\n process::exit(code)\n}\n"} {"name":"Create a two-dimensional array at runtime","C":"#include \n\nint main(int argc, char **argv) {\n\n int user1 = 0, user2 = 0;\n printf(\"Enter two integers. Space delimited, please: \");\n scanf(\"%d %d\",&user1, &user2);\n int array[user1][user2];\n array[user1\/2][user2\/2] = user1 + user2;\n printf(\"array[%d][%d] is %d\\n\",user1\/2,user2\/2,array[user1\/2][user2\/2]);\n\n return 0;\n}\n","Rust":"use std::env;\n\nfn main() {\n let mut args = env::args().skip(1).flat_map(|num| num.parse());\n let rows = args.next().expect(\"Expected number of rows as first argument\");\n let cols = args.next().expect(\"Expected number of columns as second argument\");\n\n assert_ne!(rows, 0, \"rows were zero\");\n assert_ne!(cols, 0, \"cols were zero\");\n\n \n let mut v = vec![vec![0; cols]; rows];\n v[0][0] = 1;\n println!(\"{}\", v[0][0]);\n}\n"} {"name":"Create an HTML table","C":"#include \n#include \n\nint main()\n{\n\tint i;\n\tprintf(\"
<\/th>\"\n\t\t\"X<\/th>Y<\/th>Z<\/th>\");\n\tfor (i = 0; i < 4; i++) {\n\t\tprintf(\"
%d<\/th>%d<\/td>%d<\/td>%d<\/td><\/tr>\", i,\n\t\t\trand() % 10000, rand() % 10000, rand() % 10000);\n\t}\n\tprintf(\"<\/table>\");\n\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::Rng;\n\nfn random_cell(rng: &mut R) -> u32 {\n \n \n \n \n rng.gen_range(0, 10_000)\n}\n\nfn main() {\n let mut rng = rand::thread_rng(); \n\n println!(\"
<\/th>X<\/td>Y<\/td>Z<\/td><\/tr><\/thead>\");\n\n for row in 0..3 {\n let x = random_cell(&mut rng);\n let y = random_cell(&mut rng);\n let z = random_cell(&mut rng);\n println!(\"
{}<\/th>{}<\/td>{}<\/td>{}<\/td><\/tr>\", row, x, y, z);\n }\n\n println!(\"<\/table>\");\n}\n"} {"name":"Cumulative standard deviation","C":"#include \n#include \n#include \n\ntypedef enum Action { STDDEV, MEAN, VAR, COUNT } Action;\n\ntypedef struct stat_obj_struct {\n double sum, sum2;\n size_t num;\n Action action; \n} sStatObject, *StatObject;\n\nStatObject NewStatObject( Action action )\n{\n StatObject so;\n\n so = malloc(sizeof(sStatObject));\n so->sum = 0.0;\n so->sum2 = 0.0;\n so->num = 0;\n so->action = action;\n return so;\n}\n#define FREE_STAT_OBJECT(so) \\\n free(so); so = NULL\ndouble stat_obj_value(StatObject so, Action action)\n{\n double num, mean, var, stddev;\n \n if (so->num == 0.0) return 0.0;\n num = so->num;\n if (action==COUNT) return num;\n mean = so->sum\/num;\n if (action==MEAN) return mean;\n var = so->sum2\/num - mean*mean;\n if (action==VAR) return var;\n stddev = sqrt(var);\n if (action==STDDEV) return stddev;\n return 0;\n}\n\ndouble stat_object_add(StatObject so, double v)\n{\n so->num++;\n so->sum += v;\n so->sum2 += v*v;\n return stat_obj_value(so, so->action);\n}\n","Rust":"pub struct CumulativeStandardDeviation {\n n: f64,\n sum: f64,\n sum_sq: f64\n}\n\nimpl CumulativeStandardDeviation {\n pub fn new() -> Self {\n CumulativeStandardDeviation {\n n: 0.,\n sum: 0.,\n sum_sq: 0.\n }\n }\n\n fn push(&mut self, x: f64) -> f64 {\n self.n += 1.;\n self.sum += x;\n self.sum_sq += x * x;\n\n (self.sum_sq \/ self.n - self.sum * self.sum \/ self.n \/ self.n).sqrt()\n }\n}\n\nfn main() {\n let nums = [2, 4, 4, 4, 5, 5, 7, 9];\n\n let mut cum_stdev = CumulativeStandardDeviation::new();\n for num in nums.iter() {\n println!(\"{}\", cum_stdev.push(*num as f64));\n }\n}\n"} {"name":"Currency","C":"\tmpf_set_d(burgerUnitPrice,5.50);\n\tmpf_set_d(milkshakePrice,2 * 2.86);\n\tmpf_set_d(burgerNum,4000000000000000);\n\tmpf_set_d(milkshakeNum,2);\n","Rust":"extern crate num_bigint; \nextern crate num_rational; \n\nuse num_bigint::BigInt;\nuse num_rational::BigRational;\n\n\nuse std::ops::{Add, Mul};\nuse std::fmt;\n\nfn main() {\n let hamburger = Currency::new(5.50);\n let milkshake = Currency::new(2.86);\n let pre_tax = hamburger * 4_000_000_000_000_000 + milkshake * 2;\n println!(\"Price before tax: {}\", pre_tax);\n let tax = pre_tax.calculate_tax();\n println!(\"Tax: {}\", tax);\n let post_tax = pre_tax + tax;\n println!(\"Price after tax: {}\", post_tax);\n}\n\n#[derive(Debug)]\nstruct Currency {\n amount: BigRational,\n}\n\nimpl Add for Currency {\n\n type Output = Self;\n\n fn add(self, other: Self) -> Self {\n Self {\n amount: self.amount + other.amount,\n }\n } \n}\n\nimpl Mul for Currency {\n \n type Output = Self;\n \n fn mul(self, other: u64) -> Self {\n Self {\n amount: self.amount * BigInt::from(other),\n }\n }\n}\n\nimpl fmt::Display for Currency {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let cents = (&self.amount * BigInt::from(100)).to_integer();\n write!(f, \"${}.{}\", ¢s \/ 100, ¢s % 100)\n }\n}\n\nimpl Currency {\n \n fn new(num: f64) -> Self {\n Self {\n amount: BigRational::new(((num * 100.0) as i64).into(), 100.into())\n }\n }\n\n fn calculate_tax(&self) -> Self {\n let tax_val = BigRational::new(765.into(), 100.into());\n let amount = (&self.amount * tax_val).ceil() \/ BigInt::from(100); \n Self {\n amount\n }\n }\n}\n"} {"name":"Currying","C":"#include\n#include\n\nlong int factorial(int n){\n\tif(n>1)\n\t\treturn n*factorial(n-1);\n\treturn 1;\n}\n\nlong int sumOfFactorials(int num,...){\n\tva_list vaList;\n\tlong int sum = 0;\n\t\n\tva_start(vaList,num);\n\t\n\twhile(num--)\n\t\tsum += factorial(va_arg(vaList,int));\n\t\n\tva_end(vaList);\n\t\n\treturn sum;\n}\n\nint main()\n{\n\tprintf(\"\\nSum of factorials of [1,5]\u00a0: %ld\",sumOfFactorials(5,1,2,3,4,5));\n\tprintf(\"\\nSum of factorials of [3,5]\u00a0: %ld\",sumOfFactorials(3,3,4,5));\n\tprintf(\"\\nSum of factorials of [1,3]\u00a0: %ld\",sumOfFactorials(3,1,2,3));\n\t\n\treturn 0;\n}\n","Rust":"fn add_n(n : i32) -> impl Fn(i32) -> i32 {\n move |x| n + x\n}\n\nfn main() {\n let adder = add_n(40);\n println!(\"The answer to life is {}.\", adder(2));\n}\n"} {"name":"DNS query","C":"#include \n#include \n#include \t\t\n#include \t\t\n#include \t\t\n#include \t\t\n\nint\nmain()\n{\n\tstruct addrinfo hints, *res, *res0;\n\tint error;\n\tchar host[NI_MAXHOST];\n\n\t\n\tmemset(&hints, 0, sizeof hints);\n\thints.ai_family = PF_UNSPEC; \n\thints.ai_socktype = SOCK_DGRAM; \n\n\t\n\terror = getaddrinfo(\"www.kame.net\", NULL, &hints, &res0);\n\tif (error) {\n\t\tfprintf(stderr, \"%s\\n\", gai_strerror(error));\n\t\texit(1);\n\t}\n\n\t\n\tfor (res = res0; res; res = res->ai_next) {\n\t\t\n\t\terror = getnameinfo(res->ai_addr, res->ai_addrlen,\n\t\t host, sizeof host, NULL, 0, NI_NUMERICHOST);\n\n\t\tif (error) {\n\t\t\tfprintf(stderr, \"%s\\n\", gai_strerror(error));\n\t\t} else {\n\t\t\t\n\t\t\tprintf(\"%s\\n\", host);\n\t\t}\n\t}\n\n\t\n\tfreeaddrinfo(res0);\n\n\treturn 0;\n}\n","Rust":"use std::net::ToSocketAddrs;\n\nfn main() {\n let host = \"www.kame.net\";\n \n \n \n \n let host_port = (host, 0);\n let ip_iter = host_port.to_socket_addrs().unwrap();\n\n\n for ip_port in ip_iter {\n println!(\"{}\", ip_port.ip());\n }\n}\n"} {"name":"Damm algorithm","C":"#include \n#include \n#include \n\nbool damm(unsigned char *input, size_t length) {\n static const unsigned char table[10][10] = {\n {0, 3, 1, 7, 5, 9, 8, 6, 4, 2},\n {7, 0, 9, 2, 1, 5, 4, 8, 6, 3},\n {4, 2, 0, 6, 8, 7, 1, 3, 5, 9},\n {1, 7, 5, 0, 9, 8, 3, 4, 2, 6},\n {6, 1, 2, 3, 0, 4, 5, 9, 7, 8},\n {3, 6, 7, 4, 2, 0, 9, 5, 8, 1},\n {5, 8, 6, 9, 7, 2, 0, 1, 3, 4},\n {8, 9, 4, 5, 3, 6, 2, 0, 1, 7},\n {9, 4, 3, 8, 6, 1, 7, 2, 0, 5},\n {2, 5, 8, 1, 4, 3, 6, 7, 9, 0},\n };\n \n unsigned char interim = 0;\n for (size_t i = 0; i < length; i++) {\n interim = table[interim][input[i]];\n }\n return interim == 0;\n}\n\nint main() {\n unsigned char input[4] = {5, 7, 2, 4};\n puts(damm(input, 4) ? \"Checksum correct\" : \"Checksum incorrect\");\n return 0;\n}\n","Rust":"fn damm(number: &str) -> u8 {\n static TABLE: [[u8; 10]; 10] = [\n [0, 3, 1, 7, 5, 9, 8, 6, 4, 2],\n [7, 0, 9, 2, 1, 5, 4, 8, 6, 3],\n [4, 2, 0, 6, 8, 7, 1, 3, 5, 9],\n [1, 7, 5, 0, 9, 8, 3, 4, 2, 6],\n [6, 1, 2, 3, 0, 4, 5, 9, 7, 8],\n [3, 6, 7, 4, 2, 0, 9, 5, 8, 1],\n [5, 8, 6, 9, 7, 2, 0, 1, 3, 4],\n [8, 9, 4, 5, 3, 6, 2, 0, 1, 7],\n [9, 4, 3, 8, 6, 1, 7, 2, 0, 5],\n [2, 5, 8, 1, 4, 3, 6, 7, 9, 0],\n ];\n\n number.chars().fold(0, |row, digit| {\n let digit = digit.to_digit(10).unwrap();\n TABLE[row as usize][digit as usize]\n })\n}\n\nfn damm_validate(number: &str) -> bool {\n damm(number) == 0\n}\n\nfn main() {\n let numbers = &[\"5724\", \"5727\", \"112946\"];\n for number in numbers {\n let is_valid = damm_validate(number);\n if is_valid {\n println!(\"{:>6} is valid\", number);\n } else {\n println!(\"{:>6} is invalid\", number);\n }\n }\n}\n"} {"name":"Date format","C":"#include \n#include \n#include \n#define MAX_BUF 50\n\nint main(void)\n{\n char buf[MAX_BUF];\n time_t seconds = time(NULL);\n struct tm *now = localtime(&seconds);\n const char *months[] = {\"January\", \"February\", \"March\", \"April\", \"May\", \"June\",\n \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"};\n\n const char *days[] = {\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"};\n\n (void) printf(\"%d-%d-%d\\n\", now->tm_year + 1900, now->tm_mon + 1, now->tm_mday);\n (void) printf(\"%s, %s %d, %d\\n\",days[now->tm_wday], months[now->tm_mon],\n now->tm_mday, now->tm_year + 1900);\n \n (void) strftime(buf, MAX_BUF, \"%A, %B %e, %Y\", now);\n (void) printf(\"%s\\n\", buf);\n return EXIT_SUCCESS;\n}\n","Rust":"fn main() {\n let now = chrono::Utc::now();\n println!(\"{}\", now.format(\"%Y-%m-%d\"));\n println!(\"{}\", now.format(\"%A, %B %d, %Y\"));\n}\n"} {"name":"Date manipulation","C":"#include \n#include \n#include \n\nint main()\n{\n struct tm ts;\n time_t t;\n const char *d = \"March 7 2009 7:30pm EST\";\n \n strptime(d, \"%B %d %Y %I:%M%p %Z\", &ts);\n \n t = mktime(&ts);\n t += 12*60*60;\n printf(\"%s\", ctime(&t));\n\n return EXIT_SUCCESS;\n}\n","Rust":"use chrono::prelude::*;\nuse chrono::Duration;\n\nfn main() {\n \n \n \n \n \n let ndt =\n NaiveDateTime::parse_from_str(\"March 7 2009 7:30pm EST\", \"%B %e %Y %l:%M%P %Z\").unwrap();\n\n \n let dt = chrono_tz::EST.from_local_datetime(&ndt).unwrap();\n println!(\"Date parsed: {:?}\", dt);\n\n let new_date = dt + Duration::hours(12);\n println!(\"+12 hrs in EST: {:?}\", new_date);\n println!(\n \"+12 hrs in CET: {:?}\",\n new_date.with_timezone(&chrono_tz::CET)\n );\n}\n"} {"name":"Day of the week","C":"#include \n\n\nint wday(int year, int month, int day)\n{\n\tint adjustment, mm, yy;\n\n\tadjustment = (14 - month) \/ 12;\n\tmm = month + 12 * adjustment - 2;\n\tyy = year - adjustment;\n\treturn (day + (13 * mm - 1) \/ 5 +\n\t\tyy + yy \/ 4 - yy \/ 100 + yy \/ 400) % 7;\n}\n\nint main()\n{\n\tint y;\n\n\tfor (y = 2008; y <= 2121; y++) {\n\t\tif (wday(y, 12, 25) == 0) printf(\"%04d-12-25\\n\", y);\n\t}\n\n\treturn 0;\n}\n","Rust":"extern crate chrono;\n\nuse chrono::prelude::*;\n\nfn main() {\n let years = (2008..2121).filter(|&y| Local.ymd(y, 12, 25).weekday() == Weekday::Sun).collect::>();\n println!(\"Years = {:?}\", years);\n}\n"} {"name":"Days between dates","C":"#include\n#include\n#include\n\ntypedef struct{\n int year, month, day;\n}date;\n\ndate extractDate(char* str){\n return (date){.year = 1000 * (str[0]-'0') + 100 * (str[1]-'0') + 10 * (str[2]-'0') + (str[3]-'0'), .month = 10*(str[5]-'0') + (str[6]-'0'), .day = 10*(str[8]-'0') + (str[9]-'0')};\n}\n\nbool isValidDate(char* str){\n date newDate;\n \n if(strlen(str)!=10 && str[4]!='-' && str[7]!='-'){\n return false;\n }\n\n newDate = extractDate(str);\n\n if(newDate.year<=0 || newDate.month<=0 || newDate.day<=0 || newDate.month>12 || (newDate.month==2 && newDate.day>29) || \n ((newDate.month==1 || newDate.month==3 || newDate.month==5 || newDate.month==7 || newDate.month==8 || newDate.month==10 || newDate.month==12) && newDate.day>31) || \n newDate.day>30 || (newDate.year%4==0 && newDate.month==2 && newDate.month>28)){\n return false;\n }\n\n return true;\n}\n\nint diffDays(date date1,date date2){\n int days1, days2;\n \n date1.month = (date1.month + 9)%12;\n date1.year = date1.year - date1.month\/10;\n\n date2.month = (date2.month + 9)%12;\n date2.year = date2.year - date2.month\/10;\n\n days1 = 365*date1.year + date1.year\/4 - date1.year\/100 + date1.year\/400 + (date1.month*306 + 5)\/10 + ( date1.day - 1 );\n days2 = 365*date2.year + date2.year\/4 - date2.year\/100 + date2.year\/400 + (date2.month*306 + 5)\/10 + ( date2.day - 1 );\n\n return days2 - days1;\n}\n\nint main(int argc,char** argv)\n{\n if(argc!=3){\n return printf(\"Usage\u00a0: %s \",argv[0]);\n }\n\n if(isValidDate(argv[1])&&isValidDate(argv[2]) == false){\n return printf(\"Dates are invalid.\\n\");\n }\n\n printf(\"Days Difference\u00a0: %d\\n\", diffDays(extractDate(argv[1]),extractDate(argv[2])));\n\n return 0;\n}\n","Rust":"\n\n\nuse chrono::NaiveDate;\n\nfn main() {\n let args: Vec = std::env::args().collect();\n if args.len() != 3 {\n eprintln!(\"usage: {} start-date end-date\", args[0]);\n std::process::exit(1);\n }\n if let Ok(start_date) = NaiveDate::parse_from_str(&args[1], \"%F\") {\n if let Ok(end_date) = NaiveDate::parse_from_str(&args[2], \"%F\") {\n let d = end_date.signed_duration_since(start_date);\n println!(\"{}\", d.num_days());\n } else {\n eprintln!(\"Can't parse end date\");\n std::process::exit(1);\n } \n } else {\n eprintln!(\"Can't parse start date\");\n std::process::exit(1);\n }\n}\n"} {"name":"Deal cards for FreeCell","C":"#include \n#include \n#include \n\nwchar_t s_suits[] = L\"\u2663\u2666\u2665\u2660\", s_nums[] = L\"A23456789TJQK\";\n\n#define RMAX32 ((1U << 31) - 1)\nstatic int seed = 1;\nint rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }\nvoid srnd(int x) { seed = x; }\n\nvoid show(const int *c)\n{\n\tint i;\n\tfor (i = 0; i < 52; c++) {\n\t\tprintf(\" \\033[%dm%lc\\033[m%lc\", 32 - (1 + *c) % 4 \/ 2,\n\t\t\ts_suits[*c % 4], s_nums[*c \/ 4]);\n\t\tif (!(++i % 8) || i == 52) putchar('\\n');\n\t}\n}\n\nvoid deal(int s, int *t)\n{\n\tint i, j;\n\tsrnd(s);\n\n\tfor (i = 0; i < 52; i++) t[i] = 51 - i;\n\tfor (i = 0; i < 51; i++) {\n\t\tj = 51 - rnd() % (52 - i);\n\t\ts = t[i], t[i] = t[j], t[j] = s;\n\t}\n}\n\nint main(int c, char **v)\n{\n\tint s, card[52];\n\tif (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;\n\n\tsetlocale(LC_ALL, \"\");\n\n\tdeal(s, card);\n\tprintf(\"Hand %d\\n\", s);\n\tshow(card);\n\n\treturn 0;\n}\n","Rust":"\nextern crate linear_congruential_generator;\n\nuse linear_congruential_generator::{MsLcg, Rng, SeedableRng};\n\n\n\n\nfn shuffle(rng: &mut MsLcg, deck: &mut [T]) {\n let len = deck.len() as u32;\n for i in (1..len).rev() {\n let j = rng.next_u32() % (i + 1);\n deck.swap(i as usize, j as usize);\n }\n}\n\nfn gen_deck() -> Vec {\n const RANKS: [char; 13] = ['A','2','3','4','5','6','7','8','9','T','J','Q','K'];\n const SUITS: [char; 4] = ['C', 'D', 'H', 'S'];\n\n let render_card = |card: usize| {\n let (suit, rank) = (card % 4, card \/ 4);\n format!(\"{}{}\", RANKS[rank], SUITS[suit])\n };\n\n (0..52).map(render_card).collect()\n}\n\nfn deal_ms_fc_board(seed: u32) -> Vec {\n let mut rng = MsLcg::from_seed(seed);\n let mut deck = gen_deck();\n\n shuffle(&mut rng, &mut deck);\n deck.reverse();\n\n deck.chunks(8).map(|row| row.join(\" \")).collect::>()\n}\n\nfn main() {\n let seed = std::env::args()\n .nth(1)\n .and_then(|n| n.parse().ok())\n .expect(\"A 32-bit seed is required\");\n\n for row in deal_ms_fc_board(seed) {\n println!(\": {}\", row);\n }\n}\n"} {"name":"Delegates","C":"#include \n#include \n#include \n\ntypedef const char * (*Responder)( int p1);\n\ntypedef struct sDelegate {\n Responder operation;\n} *Delegate;\n\n\nDelegate NewDelegate( Responder rspndr )\n{\n Delegate dl = malloc(sizeof(struct sDelegate));\n dl->operation = rspndr;\n return dl;\n}\n\n\nconst char *DelegateThing(Delegate dl, int p1)\n{\n return (dl->operation)? (*dl->operation)(p1) : NULL;\n}\n\n\ntypedef struct sDelegator {\n int param;\n char *phrase;\n Delegate delegate;\n} *Delegator;\n\nconst char * defaultResponse( int p1)\n{\n return \"default implementation\";\n}\n\nstatic struct sDelegate defaultDel = { &defaultResponse };\n\n\nDelegator NewDelegator( int p, char *phrase)\n{\n Delegator d = malloc(sizeof(struct sDelegator));\n d->param = p;\n d->phrase = phrase;\n d->delegate = &defaultDel;\t\n return d;\n}\n\n\nconst char *Delegator_Operation( Delegator theDelegator, int p1, Delegate delroy)\n{\n const char *rtn;\n if (delroy) {\n rtn = DelegateThing(delroy, p1);\n if (!rtn) {\t\t\t\n rtn = DelegateThing(theDelegator->delegate, p1);\n }\n }\n else \t\t\n rtn = DelegateThing(theDelegator->delegate, p1);\n\n printf(\"%s\\n\", theDelegator->phrase );\n return rtn;\n}\n\n\nconst char *thing1( int p1)\n{\n printf(\"We're in thing1 with value %d\\n\" , p1);\n return \"delegate implementation\";\n}\n\nint main()\n{\n Delegate del1 = NewDelegate(&thing1);\n Delegate del2 = NewDelegate(NULL);\n Delegator theDelegator = NewDelegator( 14, \"A stellar vista, Baby.\");\n\n printf(\"Delegator returns %s\\n\\n\", \n Delegator_Operation( theDelegator, 3, NULL));\n printf(\"Delegator returns %s\\n\\n\", \n Delegator_Operation( theDelegator, 3, del1));\n printf(\"Delegator returns %s\\n\\n\",\n Delegator_Operation( theDelegator, 3, del2));\n return 0;\n}\n","Rust":"trait Thingable {\n fn thing(&self) -> &str;\n}\n\nstruct Delegator(Option);\n\nstruct Delegate {}\n\nimpl Thingable for Delegate {\n fn thing(&self) -> &'static str {\n \"Delegate implementation\"\n }\n}\n\nimpl Thingable for Delegator {\n fn thing(&self) -> &str {\n self.0.as_ref().map(|d| d.thing()).unwrap_or(\"Default implmementation\")\n }\n}\n\nfn main() {\n let d: Delegator = Delegator(None);\n println!(\"{}\", d.thing());\n \n let d: Delegator = Delegator(Some(Delegate {}));\n println!(\"{}\", d.thing());\n}\n"} {"name":"Delete a file","C":"#include \n\nint main() {\n remove(\"input.txt\");\n remove(\"\/input.txt\");\n remove(\"docs\");\n remove(\"\/docs\");\n return 0;\n}\n","Rust":"use std::io::{self, Write};\nuse std::fs::{remove_file,remove_dir};\nuse std::path::Path;\nuse std::{process,display};\n \nconst FILE_NAME: &'static str = \"output.txt\";\nconst DIR_NAME : &'static str = \"docs\";\n \nfn main() {\n delete(\".\").and(delete(\"\/\"))\n .unwrap_or_else(|e| error_handler(e,1));\n}\n \n \nfn delete

(root: P) -> io::Result<()>\n where P: AsRef\n{\n remove_file(root.as_ref().join(FILE_NAME))\n .and(remove_dir(root.as_ref().join(DIR_NAME)))\n}\n \nfn error_handler(error: E, code: i32) -> ! {\n let _ = writeln!(&mut io::stderr(), \"{:?}\", error);\n process::exit(code)\n}\n"} {"name":"Department numbers","C":"#include\n\nint main()\n{\n\tint police,sanitation,fire;\n\t\n\tprintf(\"Police Sanitation Fire\\n\");\n\tprintf(\"----------------------------------\");\n\t\n\tfor(police=2;police<=6;police+=2){\n\t\tfor(sanitation=1;sanitation<=7;sanitation++){\n\t\t\tfor(fire=1;fire<=7;fire++){\n\t\t\t\tif(police!=sanitation && sanitation!=fire && fire!=police && police+fire+sanitation==12){\n\t\t\t\t\tprintf(\"\\n%d\\t\\t%d\\t\\t%d\",police,sanitation,fire);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\treturn 0;\n}\n","Rust":"extern crate num_iter;\nfn main() {\n println!(\"Police Sanitation Fire\");\n println!(\"----------------------\");\n\n for police in num_iter::range_step(2, 7, 2) {\n for sanitation in 1..8 {\n for fire in 1..8 {\n if police != sanitation\n && sanitation != fire\n && fire != police\n && police + fire + sanitation == 12\n {\n println!(\"{:6}{:11}{:4}\", police, sanitation, fire);\n }\n }\n }\n }\n}\n"} {"name":"Detect division by zero","C":"#include \t\n#include \t\n#include \t\n#include \t\n#include \t\n\nstatic sigjmp_buf fpe_env;\n\n\nstatic void\nfpe_handler(int signal, siginfo_t *w, void *a)\n{\n\tsiglongjmp(fpe_env, w->si_code);\n\t\n}\n\n\nvoid\ntry_division(int x, int y)\n{\n\tstruct sigaction act, old;\n\tint code;\n\t\n\tvolatile int result;\n\n\t\n\tcode = sigsetjmp(fpe_env, 1);\n\tif (code == 0) {\n\t\t\n\t\tact.sa_sigaction = fpe_handler;\n\t\tsigemptyset(&act.sa_mask);\n\t\tact.sa_flags = SA_SIGINFO;\n\t\tif (sigaction(SIGFPE, &act, &old) < 0) {\n\t\t\tperror(\"sigaction\");\n\t\t\texit(1);\n\t\t}\n\n\t\t\n\t\tresult = x \/ y;\n\n\t\t\n\t\tif (sigaction(SIGFPE, &old, NULL) < 0) {\n\t\t\tperror(\"sigaction\");\n\t\t\texit(1);\n\t\t}\n\n\t\tprintf(\"%d \/ %d is %d\\n\", x, y, result);\n\t} else {\n\t\t\n\t\tif (sigaction(SIGFPE, &old, NULL) < 0) {\n\t\t\tperror(\"sigaction\");\n\t\t\texit(1);\n\t\t}\n\n\t\t\n\t\tswitch (code) {\n\t\tcase FPE_INTDIV: \n\t\tcase FPE_FLTDIV: \n\t\t\tprintf(\"%d \/ %d: caught division by zero!\\n\", x, y);\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tprintf(\"%d \/ %d: caught mysterious error!\\n\", x, y);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\n\nint\nmain()\n{\n\ttry_division(-44, 0);\n\ttry_division(-44, 5);\n\ttry_division(0, 5);\n\ttry_division(0, 0);\n\ttry_division(INT_MIN, -1);\n\treturn 0;\n}\n","Rust":"fn test_division(numerator: u32, denominator: u32) {\n match numerator.checked_div(denominator) {\n Some(result) => println!(\"{} \/ {} = {}\", numerator, denominator, result),\n None => println!(\"{} \/ {} results in a division by zero\", numerator, denominator)\n }\n}\n\nfn main() {\n test_division(5, 4);\n test_division(4, 0);\n}\n"} {"name":"Determine if a string has all the same characters","C":"#include\n#include\n\nint main(int argc,char** argv)\n{\n int i,len;\n char reference;\n \n if(argc>2){\n printf(\"Usage\u00a0: %s \\n\",argv[0]);\n return 0;\n }\n\n if(argc==1||strlen(argv[1])==1){\n printf(\"Input string\u00a0: \\\"%s\\\"\\nLength\u00a0: %d\\nAll characters are identical.\\n\",argc==1?\"\":argv[1],argc==1?0:(int)strlen(argv[1]));\n return 0;\n }\n\n reference = argv[1][0];\n len = strlen(argv[1]);\n\n for(i=1;i {\n if let Some((character, pos)) = chars.zip(2..).filter(|(c, _)| *c != first).next() {\n println!(\"\\tNot all characters are the same.\");\n println!(\"\\t{:?} (0x{:X}) at position {} differs.\", character, character as u32, pos);\n\n return;\n }\n },\n None => {}\n }\n\n println!(\"\\tAll characters in the string are the same\");\n}\n\nfn main() {\n let tests = [\"\", \" \", \"2\", \"333\", \".55\", \"tttTTT\", \"4444 444k\", \"p\u00e9p\u00e9\", \"\ud83d\udc36\ud83d\udc36\ud83d\udc3a\ud83d\udc36\", \"\ud83c\udf84\ud83c\udf84\ud83c\udf84\ud83c\udf84\"];\n\n for string in &tests {\n test_string(string);\n }\n}\n"} {"name":"Determine if a string has all unique characters","C":"#include\n#include\n#include\n#include\n\ntypedef struct positionList{\n int position;\n struct positionList *next;\n}positionList;\n\ntypedef struct letterList{\n char letter;\n int repititions;\n positionList* positions;\n struct letterList *next;\n}letterList;\n\nletterList* letterSet;\nbool duplicatesFound = false;\n\nvoid checkAndUpdateLetterList(char c,int pos){\n bool letterOccurs = false;\n letterList *letterIterator,*newLetter;\n positionList *positionIterator,*newPosition;\n\n if(letterSet==NULL){\n letterSet = (letterList*)malloc(sizeof(letterList));\n letterSet->letter = c;\n letterSet->repititions = 0;\n\n letterSet->positions = (positionList*)malloc(sizeof(positionList));\n letterSet->positions->position = pos;\n letterSet->positions->next = NULL;\n\n letterSet->next = NULL;\n }\n\n else{\n letterIterator = letterSet;\n\n while(letterIterator!=NULL){\n if(letterIterator->letter==c){\n letterOccurs = true;\n duplicatesFound = true;\n\n letterIterator->repititions++;\n positionIterator = letterIterator->positions;\n\n while(positionIterator->next!=NULL)\n positionIterator = positionIterator->next;\n \n newPosition = (positionList*)malloc(sizeof(positionList));\n newPosition->position = pos;\n newPosition->next = NULL;\n\n positionIterator->next = newPosition;\n }\n if(letterOccurs==false && letterIterator->next==NULL)\n break;\n else\n letterIterator = letterIterator->next;\n }\n\n if(letterOccurs==false){\n newLetter = (letterList*)malloc(sizeof(letterList));\n newLetter->letter = c;\n\n newLetter->repititions = 0;\n\n newLetter->positions = (positionList*)malloc(sizeof(positionList));\n newLetter->positions->position = pos;\n newLetter->positions->next = NULL;\n\n newLetter->next = NULL;\n\n letterIterator->next = newLetter;\n } \n }\n}\n\nvoid printLetterList(){\n positionList* positionIterator;\n letterList* letterIterator = letterSet;\n\n while(letterIterator!=NULL){\n if(letterIterator->repititions>0){\n printf(\"\\n'%c' (0x%x) at positions\u00a0:\",letterIterator->letter,letterIterator->letter);\n\n positionIterator = letterIterator->positions;\n\n while(positionIterator!=NULL){\n printf(\"%3d\",positionIterator->position + 1);\n positionIterator = positionIterator->next;\n }\n }\n\n letterIterator = letterIterator->next;\n }\n printf(\"\\n\");\n}\n\nint main(int argc,char** argv)\n{\n int i,len;\n \n if(argc>2){\n printf(\"Usage\u00a0: %s \\n\",argv[0]);\n return 0;\n }\n\n if(argc==1||strlen(argv[1])==1){\n printf(\"\\\"%s\\\" - Length %d - Contains only unique characters.\\n\",argc==1?\"\":argv[1],argc==1?0:1);\n return 0;\n }\n\n len = strlen(argv[1]);\n\n for(i=0;i Option<(usize, usize, char)> {\n s.chars().enumerate().find_map(|(i, c)| {\n s.chars()\n .enumerate()\n .skip(i + 1)\n .find(|(_, other)| c == *other)\n .map(|(j, _)| (i, j, c))\n })\n}\n\nfn main() {\n let strings = [\n \"\",\n \".\",\n \"abcABC\",\n \"XYZ ZYX\",\n \"1234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ\",\n \"01234567890ABCDEFGHIJKLMN0PQRSTUVWXYZ0X\",\n \"h\u00e9t\u00e9rog\u00e9n\u00e9it\u00e9\",\n \"\ud83c\udf86\ud83c\udf83\ud83c\udf87\ud83c\udf88\",\n \"\ud83d\ude0d\ud83d\ude00\ud83d\ude4c\ud83d\udc83\ud83d\ude0d\ud83d\ude4c\",\n \"\ud83d\udc20\ud83d\udc1f\ud83d\udc21\ud83e\udd88\ud83d\udc2c\ud83d\udc33\ud83d\udc0b\ud83d\udc21\",\n ];\n\n for string in &strings {\n print!(\"\\\"{}\\\" (length {})\", string, string.chars().count());\n match unique(string) {\n None => println!(\" is unique\"),\n Some((i, j, c)) => println!(\n \" is not unique\\n\\tfirst duplicate: \\\"{}\\\" (U+{:0>4X}) at indices {} and {}\",\n c, c as usize, i, j\n ),\n }\n }\n}\n"} {"name":"Determine if a string is collapsible","C":"#include\n#include\n#include\n\n#define COLLAPSE 0\n#define SQUEEZE 1\n\ntypedef struct charList{\n char c;\n struct charList *next;\n} charList;\n\n\n\nint strcmpi(char* str1,char* str2){\n int len1 = strlen(str1), len2 = strlen(str2), i;\n\n if(len1!=len2){\n return 1;\n }\n\n else{\n for(i=0;i='A'&&str1[i]<='Z')&&(str2[i]>='a'&&str2[i]<='z')&&(str2[i]-65!=str1[i]))\n return 1;\n else if((str2[i]>='A'&&str2[i]<='Z')&&(str1[i]>='a'&&str1[i]<='z')&&(str1[i]-65!=str2[i]))\n return 1;\n else if(str1[i]!=str2[i])\n return 1;\n }\n }\n\n return 0;\n}\n\ncharList *strToCharList(char* str){\n int len = strlen(str),i;\n\n charList *list, *iterator, *nextChar;\n\n list = (charList*)malloc(sizeof(charList));\n list->c = str[0];\n list->next = NULL;\n\n iterator = list;\n\n for(i=1;ic = str[i];\n nextChar->next = NULL;\n\n iterator->next = nextChar;\n iterator = nextChar;\n }\n\n return list;\n}\n\nchar* charListToString(charList* list){\n charList* iterator = list;\n int count = 0,i;\n char* str;\n\n while(iterator!=NULL){\n count++;\n iterator = iterator->next;\n }\n\n str = (char*)malloc((count+1)*sizeof(char));\n iterator = list;\n\n for(i=0;ic;\n iterator = iterator->next;\n }\n\n free(list);\n str[i] = '\\0';\n\n return str;\n}\n\nchar* processString(char str[100],int operation, char squeezeChar){\n charList *strList = strToCharList(str),*iterator = strList, *scout;\n\n if(operation==SQUEEZE){\n while(iterator!=NULL){\n if(iterator->c==squeezeChar){\n scout = iterator->next;\n\n while(scout!=NULL && scout->c==squeezeChar){\n iterator->next = scout->next;\n scout->next = NULL;\n free(scout);\n scout = iterator->next;\n }\n }\n iterator = iterator->next;\n }\n }\n\n else{\n while(iterator!=NULL && iterator->next!=NULL){\n if(iterator->c == (iterator->next)->c){\n scout = iterator->next;\n squeezeChar = iterator->c;\n\n while(scout!=NULL && scout->c==squeezeChar){\n iterator->next = scout->next;\n scout->next = NULL;\n free(scout);\n scout = iterator->next;\n }\n }\n iterator = iterator->next;\n }\n }\n\n return charListToString(strList);\n}\n\nvoid printResults(char originalString[100], char finalString[100], int operation, char squeezeChar){\n if(operation==SQUEEZE){\n printf(\"Specified Operation\u00a0: SQUEEZE\\nTarget Character\u00a0: %c\",squeezeChar);\n }\n\n else\n printf(\"Specified Operation\u00a0: COLLAPSE\");\n\n printf(\"\\nOriginal %c%c%c%s%c%c%c\\nLength\u00a0: %d\",174,174,174,originalString,175,175,175,(int)strlen(originalString));\n printf(\"\\nFinal %c%c%c%s%c%c%c\\nLength\u00a0: %d\\n\",174,174,174,finalString,175,175,175,(int)strlen(finalString));\n}\n\nint main(int argc, char** argv){\n int operation;\n char squeezeChar;\n\n if(argc<3||argc>4){\n printf(\"Usage\u00a0: %s \\n\",argv[0]);\n return 0;\n }\n\n if(strcmpi(argv[1],\"SQUEEZE\")==0 && argc!=4){\n scanf(\"Please enter characted to be squeezed\u00a0: %c\",&squeezeChar);\n operation = SQUEEZE;\n }\n\n else if(argc==4){\n operation = SQUEEZE;\n squeezeChar = argv[3][0];\n }\n\n else if(strcmpi(argv[1],\"COLLAPSE\")==0){\n operation = COLLAPSE;\n }\n\n if(strlen(argv[2])<2){\n printResults(argv[2],argv[2],operation,squeezeChar);\n }\n\n else{\n printResults(argv[2],processString(argv[2],operation,squeezeChar),operation,squeezeChar);\n }\n \n return 0;\n}\n","Rust":"fn collapse_string(val: &str) -> String {\n let mut output = String::new();\n let mut chars = val.chars().peekable();\n\n while let Some(c) = chars.next() {\n while let Some(&b) = chars.peek() {\n if b == c {\n chars.next();\n } else {\n break;\n }\n }\n\n output.push(c);\n }\n\n output\n}\n\nfn main() {\n let tests = [\n \"122333444455555666666777777788888888999999999\",\n \"\",\n \"\\\"If I were two-faced, would I be wearing this one?\\\" --- Abraham Lincoln \",\n \"..1111111111111111111111111111111111111111111111111111111111111117777888\",\n \"I never give 'em hell, I just tell the truth, and they think it's hell. \",\n \" --- Harry S Truman \",\n \"The better the 4-wheel drive, the further you'll be from help when ya get stuck!\",\n \"headmistressship\",\n ];\n\n for s in &tests {\n println!(\"Old: {:>3} <<<{}>>>\", s.len(), s);\n let collapsed = collapse_string(s);\n println!(\"New: {:>3} <<<{}>>>\", collapsed.len(), collapsed);\n\n println!();\n }\n}\n"} {"name":"Determine if a string is numeric","C":"#include \n#include \nint isNumeric (const char * s)\n{\n if (s == NULL || *s == '\\0' || isspace(*s))\n return 0;\n char * p;\n strtod (s, &p);\n return *p == '\\0';\n}\n","Rust":"\nfn parsable(s: &str) -> bool {\n s.parse::().is_ok()\n}\n"} {"name":"Determine if a string is squeezable","C":"#include\n#include\n#include\n\n#define COLLAPSE 0\n#define SQUEEZE 1\n\ntypedef struct charList{\n char c;\n struct charList *next;\n} charList;\n\n\n\nint strcmpi(char str1[100],char str2[100]){\n int len1 = strlen(str1), len2 = strlen(str2), i;\n\n if(len1!=len2){\n return 1;\n }\n\n else{\n for(i=0;i='A'&&str1[i]<='Z')&&(str2[i]>='a'&&str2[i]<='z')&&(str2[i]-65!=str1[i]))\n return 1;\n else if((str2[i]>='A'&&str2[i]<='Z')&&(str1[i]>='a'&&str1[i]<='z')&&(str1[i]-65!=str2[i]))\n return 1;\n else if(str1[i]!=str2[i])\n return 1;\n }\n }\n\n return 0;\n}\n\ncharList *strToCharList(char* str){\n int len = strlen(str),i;\n\n charList *list, *iterator, *nextChar;\n\n list = (charList*)malloc(sizeof(charList));\n list->c = str[0];\n list->next = NULL;\n\n iterator = list;\n\n for(i=1;ic = str[i];\n nextChar->next = NULL;\n\n iterator->next = nextChar;\n iterator = nextChar;\n }\n\n return list;\n}\n\nchar* charListToString(charList* list){\n charList* iterator = list;\n int count = 0,i;\n char* str;\n\n while(iterator!=NULL){\n count++;\n iterator = iterator->next;\n }\n\n str = (char*)malloc((count+1)*sizeof(char));\n iterator = list;\n\n for(i=0;ic;\n iterator = iterator->next;\n }\n\n free(list);\n str[i] = '\\0';\n\n return str;\n}\n\nchar* processString(char str[100],int operation, char squeezeChar){\n charList *strList = strToCharList(str),*iterator = strList, *scout;\n\n if(operation==SQUEEZE){\n while(iterator!=NULL){\n if(iterator->c==squeezeChar){\n scout = iterator->next;\n\n while(scout!=NULL && scout->c==squeezeChar){\n iterator->next = scout->next;\n scout->next = NULL;\n free(scout);\n scout = iterator->next;\n }\n }\n iterator = iterator->next;\n }\n }\n\n else{\n while(iterator!=NULL && iterator->next!=NULL){\n if(iterator->c == (iterator->next)->c){\n scout = iterator->next;\n squeezeChar = iterator->c;\n\n while(scout!=NULL && scout->c==squeezeChar){\n iterator->next = scout->next;\n scout->next = NULL;\n free(scout);\n scout = iterator->next;\n }\n }\n iterator = iterator->next;\n }\n }\n\n return charListToString(strList);\n}\n\nvoid printResults(char originalString[100], char finalString[100], int operation, char squeezeChar){\n if(operation==SQUEEZE){\n printf(\"Specified Operation\u00a0: SQUEEZE\\nTarget Character\u00a0: %c\",squeezeChar);\n }\n\n else\n printf(\"Specified Operation\u00a0: COLLAPSE\");\n\n printf(\"\\nOriginal %c%c%c%s%c%c%c\\nLength\u00a0: %d\",174,174,174,originalString,175,175,175,(int)strlen(originalString));\n printf(\"\\nFinal %c%c%c%s%c%c%c\\nLength\u00a0: %d\\n\",174,174,174,finalString,175,175,175,(int)strlen(finalString));\n}\n\nint main(int argc, char** argv){\n int operation;\n char squeezeChar;\n\n if(argc<3||argc>4){\n printf(\"Usage\u00a0: %s \\n\",argv[0]);\n return 0;\n }\n\n if(strcmpi(argv[1],\"SQUEEZE\")==0 && argc!=4){\n scanf(\"Please enter characted to be squeezed\u00a0: %c\",&squeezeChar);\n operation = SQUEEZE;\n }\n\n else if(argc==4){\n operation = SQUEEZE;\n squeezeChar = argv[3][0];\n }\n\n else if(strcmpi(argv[1],\"COLLAPSE\")==0){\n operation = COLLAPSE;\n }\n\n if(strlen(argv[2])<2){\n printResults(argv[2],argv[2],operation,squeezeChar);\n }\n\n else{\n printResults(argv[2],processString(argv[2],operation,squeezeChar),operation,squeezeChar);\n }\n \n return 0;\n}\n","Rust":"fn squeezable_string<'a>(s: &'a str, squeezable: char) -> impl Iterator + 'a {\n let mut previous = None;\n\n s.chars().filter(move |c| match previous {\n Some(p) if p == squeezable && p == *c => false,\n _ => {\n previous = Some(*c);\n true\n }\n })\n}\n\nfn main() {\n fn show(input: &str, c: char) {\n println!(\"Squeeze: '{}'\", c);\n println!(\"Input ({} chars): \\t{}\", input.chars().count(), input);\n let output: String = squeezable_string(input, c).collect();\n println!(\"Output ({} chars): \\t{}\", output.chars().count(), output);\n println!();\n }\n\n let harry = r#\"I never give 'em hell, I just tell the truth, and they think it's hell.\n --- Harry S Truman\"#;\n\n #[rustfmt::skip]\n let inputs = [\n (\"\", ' '),\n (r#\"\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln \"#, '-'),\n (\"..1111111111111111111111111111111111111111111111111111111111111117777888\", '7'),\n (harry, ' '),\n (harry, '-'),\n (harry, 'r'),\n (\"The better the 4-wheel drive, the further you'll be from help when ya get stuck!\", 'e'),\n (\"headmistressship\", 's'),\n ];\n\n inputs.iter().for_each(|(input, c)| show(input, *c));\n}\n"} {"name":"Determine if only one instance is running","C":"#include \t\n#include \t\n#include \t\n#include \t\n#include \t\n\n\n#define INSTANCE_LOCK \"rosetta-code-lock\"\n\nvoid\nfail(const char *message)\n{\n\tperror(message);\n\texit(1);\n}\n\n\nstatic char *ooi_path;\n\nvoid\nooi_unlink(void)\n{\n\tunlink(ooi_path);\n}\n\n\nvoid\nonly_one_instance(void)\n{\n\tstruct flock fl;\n\tsize_t dirlen;\n\tint fd;\n\tchar *dir;\n\n\t\n\tdir = getenv(\"HOME\");\n\tif (dir == NULL || dir[0] != '\/') {\n\t\tfputs(\"Bad home directory.\\n\", stderr);\n\t\texit(1);\n\t}\n\tdirlen = strlen(dir);\n\n\tooi_path = malloc(dirlen + sizeof(\"\/\" INSTANCE_LOCK));\n\tif (ooi_path == NULL)\n\t\tfail(\"malloc\");\n\tmemcpy(ooi_path, dir, dirlen);\n\tmemcpy(ooi_path + dirlen, \"\/\" INSTANCE_LOCK,\n\t sizeof(\"\/\" INSTANCE_LOCK)); \n\n\tfd = open(ooi_path, O_RDWR | O_CREAT, 0600);\n\tif (fd < 0)\n\t\tfail(ooi_path);\n\n\tfl.l_start = 0;\n\tfl.l_len = 0;\n\tfl.l_type = F_WRLCK;\n\tfl.l_whence = SEEK_SET;\n\tif (fcntl(fd, F_SETLK, &fl) < 0) {\n\t\tfputs(\"Another instance of this program is running.\\n\",\n\t\t stderr);\n\t\texit(1);\n\t}\n\n\t\n\tatexit(ooi_unlink);\n}\n\n\nint\nmain()\n{\n\tint i;\n\n\tonly_one_instance();\n\n\t\n\tfor(i = 10; i > 0; i--) {\n\t\tprintf(\"%d...%s\", i, i % 5 == 1 ? \"\\n\" : \" \");\n\t\tfflush(stdout);\n\t\tsleep(1);\n\t}\n\tputs(\"Fin!\");\n\treturn 0;\n}\n","Rust":"use std::net::TcpListener;\n\nfn create_app_lock(port: u16) -> TcpListener {\n match TcpListener::bind((\"0.0.0.0\", port)) {\n Ok(socket) => {\n socket\n },\n Err(_) => {\n panic!(\"Couldn't lock port {}: another instance already running?\", port);\n }\n }\n}\n\nfn remove_app_lock(socket: TcpListener) {\n drop(socket);\n}\n\nfn main() {\n let lock_socket = create_app_lock(12345);\n \n \n \n remove_app_lock(lock_socket);\n}\n"} {"name":"Digital root","C":"#include \n\nint droot(long long int x, int base, int *pers)\n{\n\tint d = 0;\n\tif (pers)\n\t\tfor (*pers = 0; x >= base; x = d, (*pers)++)\n\t\t\tfor (d = 0; x; d += x % base, x \/= base);\n\telse if (x && !(d = x % (base - 1)))\n\t\t\td = base - 1;\n\n\treturn d;\n}\n\nint main(void)\n{\n\tint i, d, pers;\n\tlong long x[] = {627615, 39390, 588225, 393900588225LL};\n\n\tfor (i = 0; i < 4; i++) {\n\t\td = droot(x[i], 10, &pers);\n\t\tprintf(\"%lld: pers %d, root %d\\n\", x[i], pers, d);\n\t}\n\n\treturn 0;\n}\n","Rust":"fn sum_digits(mut n: u64, base: u64) -> u64 {\n let mut sum = 0u64;\n while n > 0 {\n sum = sum + (n % base);\n n = n \/ base;\n }\n sum\n}\n\n\nfn digital_root(mut num: u64, base: u64) -> (u64, u64) {\n let mut pers = 0;\n while num >= base {\n pers = pers + 1;\n num = sum_digits(num, base);\n }\n (pers, num)\n}\n\nfn main() {\n\n \n let values = [627615u64, 39390u64, 588225u64, 393900588225u64];\n for &value in values.iter() {\n let (pers, root) = digital_root(value, 10);\n println!(\"{} has digital root {} and additive persistance {}\",\n value,\n root,\n pers);\n }\n\n println!(\"\");\n\n \n let values_base16 = [0x7e0, 0x14e344, 0xd60141, 0x12343210];\n for &value in values_base16.iter() {\n let (pers, root) = digital_root(value, 16);\n println!(\"0x{:x} has digital root 0x{:x} and additive persistance 0x{:x}\",\n value,\n root,\n pers);\n }\n}\n"} {"name":"Discordian date","C":"#include \n#include \n#include \n \n#define day_of_week( x ) ((x) == 1\u00a0? \"Sweetmorn\"\u00a0:\\\n (x) == 2\u00a0? \"Boomtime\"\u00a0:\\\n (x) == 3\u00a0? \"Pungenday\"\u00a0:\\\n (x) == 4\u00a0? \"Prickle-Prickle\"\u00a0:\\\n \"Setting Orange\")\n \n#define season( x ) ((x) == 0\u00a0? \"Chaos\"\u00a0:\\\n (x) == 1\u00a0? \"Discord\"\u00a0:\\\n (x) == 2\u00a0? \"Confusion\"\u00a0:\\\n (x) == 3\u00a0? \"Bureaucracy\"\u00a0:\\\n \"The Aftermath\")\n \n#define date( x ) ((x)%73 == 0\u00a0? 73\u00a0: (x)%73)\n \n#define leap_year( x ) ((x)\u00a0% 400 == 0 || (((x)\u00a0% 4) == 0 && (x)\u00a0% 100))\n \nchar * ddate( int y, int d ){\n int dyear = 1166 + y;\n char * result = malloc( 100 * sizeof( char ) );\n \n if( leap_year( y ) ){\n if( d == 60 ){\n sprintf( result, \"St. Tib's Day, YOLD %d\", dyear );\n return result;\n } else if( d >= 60 ){\n -- d;\n }\n }\n \n sprintf( result, \"%s, %s %d, YOLD %d\",\n day_of_week(d%5), season(((d%73)==0?d-1:d)\/73 ), date( d ), dyear );\n \n return result;\n}\n \n \nint day_of_year( int y, int m, int d ){\n int month_lengths[ 12 ] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };\n \n for( ; m > 1; m -- ){\n d += month_lengths[ m - 2 ];\n if( m == 3 && leap_year( y ) ){\n ++ d;\n }\n }\n return d;\n}\n \n \nint main( int argc, char * argv[] ){\n time_t now;\n struct tm * now_time;\n int year, doy;\n \n if( argc == 1 ){\n now = time( NULL );\n now_time = localtime( &now );\n year = now_time->tm_year + 1900; doy = now_time->tm_yday + 1;\n } else if( argc == 4 ){\n year = atoi( argv[ 1 ] ); doy = day_of_year( atoi( argv[ 1 ] ), atoi( argv[ 2 ] ), atoi( argv[ 3 ] ) );\n }\n \n char * result = ddate( year, doy );\n puts( result );\n free( result );\n \n return 0;\n}\n","Rust":"extern crate chrono;\n\nuse chrono::NaiveDate;\nuse std::str::FromStr;\n\nfn main() {\n let date = std::env::args().nth(1).expect(\"Please provide a YYYY-MM-DD date.\");\n println!(\"{} is {}\", date, NaiveDate::from_str(&date).unwrap().to_poee());\n}\n\n\nconst APOSTLES: [&str; 5] = [\"Mungday\", \"Mojoday\", \"Syaday\", \"Zaraday\", \"Maladay\"];\nconst HOLYDAYS: [&str; 5] = [\"Chaoflux\", \"Discoflux\", \"Confuflux\", \"Bureflux\", \"Afflux\"];\nconst SEASONS: [&str; 5] = [\"Chaos\", \"Discord\", \"Confusion\", \"Bureaucracy\", \"The Aftermath\"];\nconst WEEKDAYS: [&str; 5] = [\"Sweetmorn\", \"Boomtime\", \"Pungenday\", \"Prickle-Prickle\", \"Setting Orange\"];\n\n\nconst APOSTLE_HOLYDAY: usize = 5;\nconst CURSE_OF_GREYFACE: i32 = 1166;\nconst SEASON_DAYS: usize = 73;\nconst SEASON_HOLYDAY: usize = 50;\nconst ST_TIBS_DAY: usize = 59;\nconst WEEK_DAYS: usize = 5;\n\n\n\nimpl DiscordianDate for T {}\npub trait DiscordianDate: Datelike {\n fn to_poee(&self) -> String {\n let day = self.ordinal0() as usize;\n let leap = self.year() % 4 == 0 && self.year() % 100 != 0 || self.year() % 400 == 0;\n let year = self.year() + CURSE_OF_GREYFACE;\n\n if leap && day == ST_TIBS_DAY { return format!(\"St. Tib's Day, in the YOLD {}\", year); }\n\n let day_offset = if leap && day > ST_TIBS_DAY { day - 1 } else { day };\n\n let day_of_season = day_offset % SEASON_DAYS + 1;\n\n let season = SEASONS[day_offset \/ SEASON_DAYS];\n let weekday = WEEKDAYS[day_offset % WEEK_DAYS];\n\n let holiday = if day_of_season == APOSTLE_HOLYDAY {\n format!(\"\\nCelebrate {}\", APOSTLES[day_offset \/ SEASON_DAYS])\n } else if day_of_season == SEASON_HOLYDAY {\n format!(\"\\nCelebrate {}\", HOLYDAYS[day_offset \/ SEASON_DAYS])\n } else {\n String::with_capacity(0)\n };\n\n format!(\"{}, the {} day of {} in the YOLD {}{}\",\n weekday, ordinalize(day_of_season), season, year, holiday)\n }\n}\n\n\nfn ordinalize(num: usize) -> String {\n let s = format!(\"{}\", num);\n\n let suffix = if s.ends_with('1') && !s.ends_with(\"11\") {\n \"st\"\n } else if s.ends_with('2') && !s.ends_with(\"12\") {\n \"nd\"\n } else if s.ends_with('3') && !s.ends_with(\"13\") {\n \"rd\"\n } else {\n \"th\"\n };\n\n format!(\"{}{}\", s, suffix)\n}\n"} {"name":"Display a linear combination","C":"#include\n#include\n#include \n\nint main(int argC, char* argV[])\n{\n\t\n\tint i,zeroCount= 0,firstNonZero = -1;\n\tdouble* vector;\n\t\n\tif(argC == 1){\n\t\tprintf(\"Usage\u00a0: %s \",argV[0]);\n\t}\n\t\n\telse{\n\t\t\n\t\tprintf(\"Vector for [\");\n\t\tfor(i=1;i \");\n\t\t\n\t\t\n\t\tvector = (double*)malloc((argC-1)*sizeof(double));\n\t\t\n\t\tfor(i=1;i<=argC;i++){\n\t\t\tvector[i-1] = atof(argV[i]);\n\t\t\tif(vector[i-1]==0.0)\n\t\t\t\tzeroCount++;\n\t\t\tif(vector[i-1]!=0.0 && firstNonZero==-1)\n\t\t\t\tfirstNonZero = i-1;\n\t\t}\n\n\t\tif(zeroCount == argC){\n\t\t\tprintf(\"0\");\n\t\t}\n\t\t\n\t\telse{\n\t\t\tfor(i=0;i0.0)\n\t\t\t\t\tprintf(\"- %lf e%d \",fabs(vector[i]),i+1);\n\t\t\t\telse if(i==firstNonZero && vector[i]<0 && fabs(vector[i])-abs(vector[i])==0.0)\n\t\t\t\t\tprintf(\"- %ld e%d \",labs(vector[i]),i+1);\n\t\t\t\telse if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])>0.0)\n\t\t\t\t\tprintf(\"%lf e%d \",vector[i],i+1);\n\t\t\t\telse if(i==firstNonZero && vector[i]>0 && fabs(vector[i])-abs(vector[i])==0.0)\n\t\t\t\t\tprintf(\"%ld e%d \",vector[i],i+1);\n\t\t\t\telse if(fabs(vector[i])==1.0 && i!=0)\n\t\t\t\t\tprintf(\"%c e%d \",(vector[i]==-1)?'-':'+',i+1);\n\t\t\t\telse if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])>0.0)\n\t\t\t\t\tprintf(\"%c %lf e%d \",(vector[i]<0)?'-':'+',fabs(vector[i]),i+1);\n\t\t\t\telse if(i!=0 && vector[i]!=0 && fabs(vector[i])-abs(vector[i])==0.0)\n\t\t\t\t\tprintf(\"%c %ld e%d \",(vector[i]<0)?'-':'+',labs(vector[i]),i+1);\t\t\t\t\n\t\t\t}\n\t\t}\n\t}\n\t\n\tfree(vector);\n\t\n\treturn 0;\n}\n","Rust":"use std::fmt::{Display, Formatter, Result};\nuse std::process::exit;\n\nstruct Coefficient(usize, f64);\n\nimpl Display for Coefficient {\n fn fmt(&self, f: &mut Formatter<'_>) -> Result {\n let i = self.0;\n let c = self.1;\n\n if c == 0. {\n return Ok(());\n }\n\n write!(\n f,\n \" {} {}e({})\",\n if c < 0. {\n \"-\"\n } else if f.alternate() {\n \" \"\n } else {\n \"+\"\n },\n if (c.abs() - 1.).abs() < f64::EPSILON {\n \"\".to_string()\n } else {\n c.abs().to_string() + \"*\"\n },\n i + 1\n )\n }\n}\n\nfn usage() {\n println!(\"Usage: display-linear-combination a1 [a2 a3 ...]\");\n}\n\nfn linear_combination(coefficients: &[f64]) -> String {\n let mut string = String::new();\n\n let mut iter = coefficients.iter().enumerate();\n\n \n loop {\n match iter.next() {\n Some((_, &c)) if c == 0. => {\n continue;\n }\n Some((i, &c)) => {\n string.push_str(format!(\"{:#}\", Coefficient(i, c)).as_str());\n break;\n }\n None => {\n string.push('0');\n return string;\n }\n }\n }\n\n \n for (i, &c) in iter {\n string.push_str(format!(\"{}\", Coefficient(i, c)).as_str());\n }\n\n string\n}\n\nfn main() {\n let mut coefficients = Vec::new();\n let mut args = std::env::args();\n\n args.next(); \n\n \n for arg in args {\n let c = arg.parse::().unwrap_or_else(|e| {\n eprintln!(\"Failed to parse argument \\\"{}\\\": {}\", arg, e);\n exit(-1);\n });\n coefficients.push(c);\n }\n\n \n if coefficients.is_empty() {\n usage();\n return;\n }\n\n println!(\"{}\", linear_combination(&coefficients));\n}\n"} {"name":"Documentation","C":"\nint add(int a, int b) {\n return a + b;\n}\n","Rust":"\n\n\n\n\n\n\n#![doc(html_favicon_url = \"https:\n#![doc(html_logo_url = \"https:\n\n\npub const THINGY: u32 = 42;\n\n\npub enum Whatsit {\n \n Yo(Whatchamabob),\n \n HoHo,\n}\n\n\npub struct Whatchamabob {\n \n pub doodad: f64,\n \n pub thingamabob: bool\n}\n\n\npub trait Frobnify {\n \n fn frob(&self);\n}\n\n\nimpl Frobnify for Whatchamabob {\n \n fn frob(&self) {\n println!(\"Frobbed: {}\", self.doodad);\n }\n}\n\n\n\n\n\n\n\n\n\n\n\npub fn main() {\n let foo = Whatchamabob{ doodad: 1.2, thingamabob: false };\n foo.frob();\n}\n"} {"name":"Dot product","C":"#include \n#include \n\nint dot_product(int *, int *, size_t);\n\nint\nmain(void)\n{\n int a[3] = {1, 3, -5};\n int b[3] = {4, -2, -1};\n\n printf(\"%d\\n\", dot_product(a, b, sizeof(a) \/ sizeof(a[0])));\n\n return EXIT_SUCCESS;\n}\n\nint\ndot_product(int *a, int *b, size_t n)\n{\n int sum = 0;\n size_t i;\n\n for (i = 0; i < n; i++) {\n sum += a[i] * b[i];\n }\n\n return sum;\n}\n","Rust":"\n\nfn dot_product(a: &[i32], b: &[i32]) -> Option {\n if a.len() != b.len() { return None }\n Some(\n a.iter()\n .zip( b.iter() )\n .fold(0, |sum, (el_a, el_b)| sum + el_a*el_b)\n )\n}\n\n\nfn main() {\n let v1 = vec![1, 3, -5];\n let v2 = vec![4, -2, -1];\n\n println!(\"{}\", dot_product(&v1, &v2).unwrap());\n}\n"} {"name":"Doubly-linked list_Element definition","C":"struct Node \n{\n struct Node *next;\n struct Node *prev;\n void *data;\n};\n","Rust":"use std::collections::LinkedList;\nfn main() {\n \n let list = LinkedList::::new();\n}\n"} {"name":"Doubly-linked list_Element insertion","C":"void insert(link* anchor, link* newlink) {\n newlink->next = anchor->next;\n newlink->prev = anchor;\n (newlink->next)->prev = newlink;\n anchor->next = newlink;\n}\n","Rust":"use std::collections::LinkedList;\nfn main() {\n let mut list = LinkedList::new();\n list.push_front(8);\n}\n"} {"name":"Dragon curve","C":"#include \n#include \n#include \n#include \n\n\nlong long x, y, dx, dy, scale, clen;\ntypedef struct { double r, g, b; } rgb;\nrgb ** pix;\n\n\nvoid sc_up()\n{\n\tlong long tmp = dx - dy; dy = dx + dy; dx = tmp;\n\tscale *= 2; x *= 2; y *= 2;\n}\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 \/ scale;\n\tdouble VAL = 1 - (cos(3.141592653579 * 64 * clen \/ scale) - 1) \/ 4;\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\n\nvoid iter_string(const char * str, int d)\n{\n\tlong tmp;\n#\tdefine LEFT tmp = -dy; dy = dx; dx = tmp\n#\tdefine RIGHT tmp = dy; dy = -dx; dx = tmp\n\twhile (*str != '\\0') {\n\t\tswitch(*(str++)) {\n\t\tcase 'X':\tif (d) iter_string(\"X+YF+\", d - 1); continue;\n\t\tcase 'Y':\tif (d) iter_string(\"-FX-Y\", d - 1); continue;\n\t\tcase '+':\tRIGHT; continue;\n\t\tcase '-':\tLEFT; continue;\n\t\tcase 'F':\n \n\t\t\t\tclen ++;\n\t\t\t\th_rgb(x\/scale, y\/scale);\n\t\t\t\tx += dx; y += dy;\n\t\t\t\tcontinue;\n\t\t}\n\t}\n}\n\nvoid dragon(long leng, int depth)\n{\n\tlong i, d = leng \/ 3 + 1;\n\tlong h = leng + 3, w = leng + d * 3 \/ 2 + 2;\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 = d; dx = leng; dy = 0; scale = 1; clen = 0;\n\tfor (i = 0; i < depth; i++) sc_up();\n\titer_string(\"FX\", depth);\n\n\t\n\tunsigned char *fpix = malloc(w * h * 3);\n\tdouble maxv = 0, *dbuf = (double*)buf;\n\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\tdragon(size, depth * 2);\n\n\treturn 0;\n}\n","Rust":"use ggez::{\n conf::{WindowMode, WindowSetup},\n error::GameResult,\n event,\n graphics::{clear, draw, present, Color, MeshBuilder},\n nalgebra::Point2,\n Context,\n};\nuse std::time::Duration;\n\n\n\n\n\nfn l_system_next_generation(current_generation: &str) -> String {\n let f_rule = \"f-h\";\n let h_rule = \"f+h\";\n let mut next_gen = String::new();\n for char in current_generation.chars() {\n match char {\n 'f' => next_gen.push_str(f_rule),\n 'h' => next_gen.push_str(h_rule),\n '-' | '+' => next_gen.push(char),\n _ => panic!(\"Unknown char {}\", char),\n }\n }\n next_gen\n}\n\n\n\n\nconst WINDOW_WIDTH: f32 = 700.0;\nconst WINDOW_HEIGHT: f32 = 700.0;\nconst START_X: f32 = WINDOW_WIDTH \/ 6.0;\nconst START_Y: f32 = WINDOW_HEIGHT \/ 6.0;\nconst MAX_DEPTH: i32 = 15;\nconst LINE_LENGTH: f32 = 20.0;\n\nstruct MainState {\n start_gen: String,\n next_gen: String,\n line_length: f32,\n max_depth: i32,\n current_depth: i32,\n}\n\nimpl MainState {\n fn new() -> GameResult {\n let start_gen = \"f\";\n let next_gen = String::new();\n let line_length = LINE_LENGTH;\n let max_depth = MAX_DEPTH;\n let current_depth = 0;\n Ok(MainState {\n start_gen: start_gen.to_string(),\n next_gen,\n line_length,\n max_depth,\n current_depth,\n })\n }\n}\n\nimpl event::EventHandler for MainState {\n \n \n \n \n \n \n fn update(&mut self, _ctx: &mut Context) -> GameResult {\n if self.current_depth < self.max_depth {\n self.next_gen = l_system_next_generation(&self.start_gen);\n self.start_gen = self.next_gen.clone();\n self.line_length -= (self.line_length \/ self.max_depth as f32) * 1.9;\n self.current_depth += 1;\n }\n ggez::timer::sleep(Duration::from_millis(500));\n Ok(())\n }\n\n fn draw(&mut self, ctx: &mut Context) -> GameResult {\n let grey = Color::from_rgb(77, 77, 77);\n let blue = Color::from_rgb(51, 153, 255);\n let initial_point_blue = Point2::new(START_X, START_Y);\n clear(ctx, grey);\n draw_lines(\n &self.next_gen,\n ctx,\n self.line_length,\n blue,\n initial_point_blue,\n )?;\n present(ctx)?;\n Ok(())\n }\n}\n\nfn next_point(current_point: Point2, heading: f32, line_length: f32) -> Point2 {\n let next_point = (\n (current_point.x + (line_length * heading.to_radians().cos().trunc() as f32)),\n (current_point.y + (line_length * heading.to_radians().sin().trunc() as f32)),\n );\n Point2::new(next_point.0, next_point.1)\n}\n\nfn draw_lines(\n instructions: &str,\n ctx: &mut Context,\n line_length: f32,\n colour: Color,\n initial_point: Point2,\n) -> GameResult {\n let line_width = 2.0;\n let mut heading = 0.0;\n let turn_angle = 90.0;\n let mut start_point = initial_point;\n let mut line_builder = MeshBuilder::new();\n for char in instructions.chars() {\n let end_point = next_point(start_point, heading, line_length);\n match char {\n 'f' | 'h' => {\n line_builder.line(&[start_point, end_point], line_width, colour)?;\n start_point = end_point;\n }\n '+' => heading += turn_angle,\n '-' => heading -= turn_angle,\n _ => panic!(\"Unknown char {}\", char),\n }\n }\n let lines = line_builder.build(ctx)?;\n draw(ctx, &lines, (initial_point,))?;\n Ok(())\n}\n\nfn main() -> GameResult {\n let cb = ggez::ContextBuilder::new(\"dragon curve\", \"huw\")\n .window_setup(WindowSetup::default().title(\"Dragon curve\"))\n .window_mode(WindowMode::default().dimensions(WINDOW_WIDTH, WINDOW_HEIGHT));\n let (ctx, event_loop) = &mut cb.build()?;\n let state = &mut MainState::new()?;\n event::run(ctx, event_loop, state)\n}\n"} {"name":"Draw a clock","C":"#include \n#include \n#include \n#include \n#include \n \n#define PI 3.14159265\nconst char * shades = \" .:-*ca&#%@\";\n \n\ndouble dist(double x, double y, double x0, double y0) {\n\tdouble l = (x * x0 + y * y0) \/ (x0 * x0 + y0 * y0);\n \n\tif (l > 1) {\n\t\tx -= x0;\n\t\ty -= y0;\n\t} else if (l >= 0) {\n\t\tx -= l * x0;\n\t\ty -= l * y0;\n\t}\n\treturn sqrt(x * x + y * y);\n}\n \nenum { sec = 0, min, hur }; \n \nvoid draw(int size)\n{\n#\tdefine for_i for(int i = 0; i < size; i++)\n#\tdefine for_j for(int j = 0; j < size * 2; j++)\n \n\tdouble angle, cx = size \/ 2.;\n\tdouble sx[3], sy[3], sw[3];\n\tdouble fade[] = { 1, .35, .35 }; \n\tstruct timeval tv;\n\tstruct tm *t;\n \n\t\n\tsw[sec] = size * .02;\n\tsw[min] = size * .03;\n\tsw[hur] = size * .05;\n \nevery_second:\n\tgettimeofday(&tv, 0);\n\tt = localtime(&tv.tv_sec);\n \n\tangle = t->tm_sec * PI \/ 30;\n\tsy[sec] = -cx * cos(angle);\n\tsx[sec] = cx * sin(angle);\n \n\tangle = (t->tm_min + t->tm_sec \/ 60.) \/ 30 * PI;\n\tsy[min] = -cx * cos(angle) * .8;\n\tsx[min] = cx * sin(angle) * .8;\n \n\tangle = (t->tm_hour + t->tm_min \/ 60.) \/ 6 * PI;\n\tsy[hur] = -cx * cos(angle) * .6;\n\tsx[hur] = cx * sin(angle) * .6;\n \n\tprintf(\"\\033[s\"); \n\tfor_i {\n\t\tprintf(\"\\033[%d;0H\", i); \n\t\tdouble y = i - cx;\n\t\tfor_j {\n\t\t\tdouble x = (j - 2 * cx) \/ 2;\n \n\t\t\tint pix = 0;\n\t\t\t\n\t\t\tfor (int k = hur; k >= sec; k--) {\n\t\t\t\tdouble d = dist(x, y, sx[k], sy[k]);\n\t\t\t\tif (d < sw[k] - .5)\n\t\t\t\t\tpix = 10 * fade[k];\n\t\t\t\telse if (d < sw[k] + .5)\n\t\t\t\t\tpix = (5 + (sw[k] - d) * 10) * fade[k];\n\t\t\t}\n\t\t\tputchar(shades[pix]);\n\t\t}\n\t}\n\tprintf(\"\\033[u\"); \n \n\tfflush(stdout);\n\tsleep(1); \n\tgoto every_second;\n}\n \nint main(int argc, char *argv[])\n{\n\tint s;\n\tif (argc <= 1 || (s = atoi(argv[1])) <= 0) s = 20;\n\tdraw(s);\n\treturn 0;\n}\n","Rust":"\nextern crate time;\n\nuse std::thread;\nuse std::time::Duration;\n\nconst TOP: &str = \" \u284e\u2889\u28b5 \u2800\u28ba\u2800 \u280a\u2809\u2871 \u280a\u28c9\u2871 \u2880\u2814\u2847 \u28cf\u28c9\u2849 \u28ce\u28c9\u2841 \u280a\u2889\u281d \u288e\u28c9\u2871 \u284e\u2809\u28b1 \u2800\u2836\u2800\";\nconst BOT: &str = \" \u2897\u28c1\u2878 \u2880\u28f8\u28c0 \u28d4\u28c9\u28c0 \u2884\u28c0\u2878 \u2809\u2809\u284f \u2884\u28c0\u2878 \u2887\u28c0\u2878 \u28b0\u2801\u2800 \u2887\u28c0\u2878 \u2888\u28c9\u2879 \u2800\u2836\u2800\";\n\nfn main() {\n let top: Vec<&str> = TOP.split_whitespace().collect();\n let bot: Vec<&str> = BOT.split_whitespace().collect();\n\n loop {\n let tm = &time::now().rfc822().to_string()[17..25];\n let top_str: String = tm.chars().map(|x| top[x as usize - '0' as usize]).collect();\n let bot_str: String = tm.chars().map(|x| bot[x as usize - '0' as usize]).collect();\n\n clear_screen();\n println!(\"{}\", top_str);\n println!(\"{}\", bot_str);\n\n thread::sleep(Duration::from_secs(1));\n }\n}\n\nfn clear_screen() {\n println!(\"{}[H{}[J\", 27 as char, 27 as char);\n}\n"} {"name":"Dutch national flag problem","C":"#include \n#include \n#include \n#include \n\n#define NUMBALLS 5 \n\nint compar(const void *a, const void *b){\n\tchar c1=*(const char*)a, c2=*(const char*)b; \n\treturn c1-c2;\n}\n\n_Bool issorted(char *balls){\n\tint i,state;\n\tstate=0;\n\tfor(i=0;istate)state=balls[i];\n\t}\n\treturn true;\n}\n\nvoid printout(char *balls){\n\tint i;\n\tchar str[NUMBALLS+1];\n\tfor(i=0;i) -> bool {\n let mut state = &Color::Red;\n for current in list.iter() {\n if current < state { return false; }\n if current > state { state = current; }\n }\n true\n}\n\n\nfn main() {\n let mut rng = rand::thread_rng();\n let mut colors: Vec = Vec::new();\n\n for _ in 1..10 {\n let r = rng.gen_range(0, 3);\n if r == 0 { colors.push(Color::Red); }\n else if r == 1 { colors.push(Color::White); }\n else if r == 2 { colors.push(Color::Blue); }\n }\n\n while is_sorted(&colors) {\n rng.shuffle(&mut colors);\n }\n\n println!(\"Before: {:?}\", colors);\n colors.sort();\n println!(\"After: {:?}\", colors);\n if !is_sorted(&colors) {\n println!(\"Oops, did not sort colors correctly!\");\n }\n}\n"} {"name":"Echo server","C":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define MAX_ENQUEUED 20\n#define BUF_LEN 256\n#define PORT_STR \"12321\"\n\n\n\n\n\nvoid wait_for_zombie(int s)\n{\n while(waitpid(-1, NULL, WNOHANG) > 0) ;\n}\n\n\n\n\n\nvoid echo_lines(int csock)\n{\n char buf[BUF_LEN];\n int r;\n\n while( (r = read(csock, buf, BUF_LEN)) > 0 ) {\n (void)write(csock, buf, r);\n }\n exit(EXIT_SUCCESS);\n}\n\n\n\n\n\nvoid take_connections_forever(int ssock)\n{\n for(;;) {\n struct sockaddr addr;\n socklen_t addr_size = sizeof(addr);\n int csock;\n\n \n csock = accept(ssock, &addr, &addr_size);\n\n \n if ( csock == -1 ) {\n perror(\"accept\");\n } else if ( fork() == 0 ) {\n close(ssock);\n echo_lines(csock);\n } else {\n close(csock);\n }\n }\n}\n\n\n\n\n\nint main()\n{\n struct addrinfo hints, *res;\n struct sigaction sa;\n int sock;\n\n \n memset(&hints, 0, sizeof(struct addrinfo));\n hints.ai_family = AF_UNSPEC;\n hints.ai_socktype = SOCK_STREAM;\n hints.ai_flags = AI_PASSIVE;\n if ( getaddrinfo(NULL, PORT_STR, &hints, &res) != 0 ) {\n perror(\"getaddrinfo\");\n exit(EXIT_FAILURE);\n }\n\n \n if ( (sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1 ) {\n perror(\"socket\");\n exit(EXIT_FAILURE);\n }\n\n \n sa.sa_handler = wait_for_zombie;\n sigemptyset(&sa.sa_mask);\n sa.sa_flags = SA_RESTART;\n if ( sigaction(SIGCHLD, &sa, NULL) == -1 ) {\n perror(\"sigaction\");\n exit(EXIT_FAILURE);\n }\n\n \n if ( bind(sock, res->ai_addr, res->ai_addrlen) != 0 ) {\n perror(\"bind\");\n exit(EXIT_FAILURE);\n }\n\n freeaddrinfo(res);\n\n \n if ( listen(sock, MAX_ENQUEUED) != 0 ) {\n perror(\"listen\");\n exit(EXIT_FAILURE);\n }\n\n \n take_connections_forever(sock);\n return EXIT_SUCCESS;\n}\n","Rust":"use std::net::{TcpListener, TcpStream};\nuse std::io::{BufReader, BufRead, Write};\nuse std::thread;\n\nfn main() {\n let listener = TcpListener::bind(\"127.0.0.1:12321\").unwrap();\n println!(\"server is running on 127.0.0.1:12321 ...\");\n \n for stream in listener.incoming() {\n let stream = stream.unwrap();\n thread::spawn(move || handle_client(stream));\n }\n}\n\nfn handle_client(stream: TcpStream) {\n let mut stream = BufReader::new(stream);\n loop {\n let mut buf = String::new();\n if stream.read_line(&mut buf).is_err() {\n break;\n }\n stream\n .get_ref()\n .write(buf.as_bytes())\n .unwrap();\n }\n}\n"} {"name":"Egyptian division","C":"'---Ported from the c code example to BaCon by bigbass \n\n'==================================================================================\nFUNCTION EGYPTIAN_DIVISION(long dividend, long divisor, long remainder) TYPE long \n'==================================================================================\n'--- remainder is the third parameter, pass 0 if you do not need the remainder\n \nDECLARE powers[64] TYPE long \nDECLARE doublings[64] TYPE long \n\n\tLOCAL i TYPE long\n \n\tFOR i = 0 TO 63 STEP 1 \n\t\tpowers[i] = 1 << i\n\t\tdoublings[i] = divisor << i\n\t\tIF (doublings[i] > dividend) THEN\n\t\t\tBREAK\n\t\tENDIF\n\tNEXT\n\n\tLOCAL answer TYPE long\n\tLOCAL accumulator TYPE long\n\tanswer = 0\n\taccumulator = 0\n \n\tWHILE i >= 0\n\t\t'--- If the current value of the accumulator added to the\n\t\t'--- doublings cell would be less than or equal to the\n\t\t'--- dividend then add it to the accumulator\n\t\tIF (accumulator + doublings[i] <= dividend) THEN\n\t\t\taccumulator = accumulator + doublings[i]\n\t\t\tanswer = answer + powers[i]\n\t\tENDIF\n\t\tDECR i\n\tWEND\n \n\tIF remainder THEN\n\t\tremainder = dividend - accumulator\n\t\tPRINT dividend ,\" \/ \", divisor, \" = \" , answer ,\" remainder \" , remainder\n\n PRINT \"Decoded the answer to a standard fraction\"\n PRINT (remainder + 0.0 )\/ (divisor + 0.0) + answer\n PRINT\n\n\tELSE \n\t\tPRINT dividend ,\" \/ \", divisor , \" = \" , answer \n\tENDIF\n\t\n\tRETURN answer\n\nENDFUNCTION\n\n \n\t'--- the large number divided by the smaller number \n\t'--- the third argument is 1 if you want to have a remainder\n\t'--- and 0 if you dont want to have a remainder \n\t\n\tEGYPTIAN_DIVISION(580,34,1)\n\tEGYPTIAN_DIVISION(580,34,0)\n\nEGYPTIAN_DIVISION(580,34,1)\n","Rust":"fn egyptian_divide(dividend: u32, divisor: u32) -> (u32, u32) {\n let dividend = dividend as u64;\n let divisor = divisor as u64;\n \n let pows = (0..32).map(|p| 1 << p);\n let doublings = (0..32).map(|p| divisor << p);\n \n let (answer, sum) = doublings\n .zip(pows)\n .rev()\n .skip_while(|(i, _)| i > ÷nd )\n .fold((0, 0), |(answer, sum), (double, power)| {\n if sum + double < dividend {\n (answer + power, sum + double)\n } else {\n (answer, sum)\n }\n });\n \n (answer as u32, (dividend - sum) as u32)\n}\n\nfn main() {\n let (div, rem) = egyptian_divide(580, 34);\n println!(\"580 divided by 34 is {} remainder {}\", div, rem);\n}\n"} {"name":"Element-wise operations","C":"#include \n\n#define for_i for(i = 0; i < h; i++)\n#define for_j for(j = 0; j < w; j++)\n#define _M double**\n#define OPM(name, _op_) \\\n\tvoid eop_##name(_M a, _M b, _M c, int w, int h){int i,j;\\\n\t\tfor_i for_j c[i][j] = a[i][j] _op_ b[i][j];}\nOPM(add, +);OPM(sub, -);OPM(mul, *);OPM(div, \/);\n\n#define OPS(name, res) \\\n\tvoid eop_s_##name(_M a, double s, _M b, int w, int h) {double x;int i,j;\\\n\t\tfor_i for_j {x = a[i][j]; b[i][j] = res;}}\nOPS(mul, x*s);OPS(div, x\/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s));\n","Rust":"struct Matrix {\n elements: Vec,\n pub height: u32,\n pub width: u32,\n}\n\nimpl Matrix {\n fn new(elements: Vec, height: u32, width: u32) -> Matrix {\n \n Matrix {\n elements: elements,\n height: height,\n width: width,\n }\n }\n\n fn get(&self, row: u32, col: u32) -> f32 {\n let row = row as usize;\n let col = col as usize;\n self.elements[col + row * (self.width as usize)]\n }\n\n fn set(&mut self, row: u32, col: u32, value: f32) {\n let row = row as usize;\n let col = col as usize;\n self.elements[col + row * (self.width as usize)] = value;\n }\n\n fn print(&self) {\n for row in 0..self.height {\n for col in 0..self.width {\n print!(\"{:3.0}\", self.get(row, col));\n }\n println!(\"\");\n }\n println!(\"\");\n }\n}\n\n\nfn matrix_addition(first: &Matrix, second: &Matrix) -> Result {\n if first.width == second.width && first.height == second.height {\n let mut result = Matrix::new(vec![0.0f32; (first.height * first.width) as usize],\n first.height,\n first.width);\n for row in 0..first.height {\n for col in 0..first.width {\n let first_value = first.get(row, col);\n let second_value = second.get(row, col);\n result.set(row, col, first_value + second_value);\n }\n }\n Ok(result)\n } else {\n Err(\"Dimensions don't match\".to_owned())\n }\n}\n\nfn scalar_multiplication(scalar: f32, matrix: &Matrix) -> Matrix {\n let mut result = Matrix::new(vec![0.0f32; (matrix.height * matrix.width) as usize],\n matrix.height,\n matrix.width);\n for row in 0..matrix.height {\n for col in 0..matrix.width {\n let value = matrix.get(row, col);\n result.set(row, col, scalar * value);\n }\n }\n result\n}\n\n\nfn matrix_subtraction(first: &Matrix, second: &Matrix) -> Result {\n if first.width == second.width && first.height == second.height {\n let negative_matrix = scalar_multiplication(-1.0, second);\n let result = matrix_addition(first, &negative_matrix).unwrap();\n Ok(result)\n } else {\n Err(\"Dimensions don't match\".to_owned())\n }\n}\n\n\nfn matrix_multiplication(first: &Matrix, second: &Matrix) -> Result {\n if first.width == second.height {\n let mut result = Matrix::new(vec![0.0f32; (first.height * second.width) as usize],\n first.height,\n second.width);\n for row in 0..result.height {\n for col in 0..result.width {\n let mut value = 0.0;\n for it in 0..first.width {\n value += first.get(row, it) * second.get(it, col);\n }\n result.set(row, col, value);\n }\n }\n Ok(result)\n } else {\n Err(\"Dimensions don't match. Width of first must equal height of second\".to_owned())\n }\n}\n\n\nfn main() {\n let height = 2;\n let width = 3;\n \n \n \n let matrix1 = Matrix::new(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], height, width);\n\n \n \n \n let matrix2 = Matrix::new(vec![6.0, 5.0, 4.0, 3.0, 2.0, 1.0], height, width);\n\n \n \n matrix_addition(&matrix1, &matrix2).unwrap().print();\n \n \n scalar_multiplication(2.0, &matrix1).print();\n \n \n matrix_subtraction(&matrix1, &matrix2).unwrap().print();\n\n \n \n \n let matrix3 = Matrix::new(vec![1.0, 1.0, 1.0], width, 1);\n \n \n matrix_multiplication(&matrix1, &matrix3).unwrap().print();\n}\n"} {"name":"Elementary cellular automaton","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;\n\tull st;\n\n\tprintf(\"Rule %d:\\n\", rule);\n\tdo {\n\t\tst = state;\n\t\tfor (i = N; i--; ) putchar(st & B(i) ? '#' : '.');\n\t\tputchar('\\n');\n\n\t\tfor (state = i = 0; i < N; i++)\n\t\t\tif (rule & B(7 & (st>>(i-1) | st<<(N+1-i))))\n\t\t\t\tstate |= B(i);\n\t} while (st != state);\n}\n\nint main(int argc, char **argv)\n{\n\tevolve(B(N\/2), 90);\n\tevolve(B(N\/4)|B(N - N\/4), 30); \n\n\treturn 0;\n}\n","Rust":"fn main() {\n struct ElementaryCA {\n rule: u8,\n state: u64,\n }\n impl ElementaryCA {\n fn new(rule: u8) -> (u64, ElementaryCA) {\n let out = ElementaryCA {\n rule,\n state: 1,\n };\n (out.state, out)\n }\n fn next(&mut self) -> u64 {\n let mut next_state = 0u64;\n let state = self.state;\n for i in 0..64 {\n next_state |= (((self.rule as u64)>>(7 & (state.rotate_left(1).rotate_right(i as u32)))) & 1)< String {\n let mut out = String::new();\n for i in (0..64).rev() {\n if 1<\n#include \n#include \n\nint dir_empty(const char *path)\n{\n\tstruct dirent *ent;\n\tint ret = 1;\n\n\tDIR *d = opendir(path);\n\tif (!d) {\n\t\tfprintf(stderr, \"%s: \", path);\n\t\tperror(\"\");\n\t\treturn -1;\n\t}\n\n\twhile ((ent = readdir(d))) {\n\t\tif (!strcmp(ent->d_name, \".\") || !(strcmp(ent->d_name, \"..\")))\n\t\t\tcontinue;\n\t\tret = 0;\n\t\tbreak;\n\t}\n\n\tclosedir(d);\n\treturn ret;\n}\n\nint main(int c, char **v)\n{\n\tint ret = 0, i;\n\tif (c < 2) return -1;\n\n\tfor (i = 1; i < c; i++) {\n\t\tret = dir_empty(v[i]);\n\t\tif (ret >= 0)\n\t\t\tprintf(\"%s: %sempty\\n\", v[i], ret ? \"\" : \"not \");\n\t}\n\n\treturn 0;\n}\n","Rust":"use std::fs::read_dir;\nuse std::error::Error;\n\nfn main() {\n for path in std::env::args().skip(1) { \n match read_dir(path.as_str()) { \n Ok(contents) => {\n let len = contents.collect::>().len(); \n if len == 0 {\n println!(\"{} is empty\", path);\n } else {\n println!(\"{} is not empty\", path);\n }\n },\n Err(e) => { \n println!(\"Failed to read directory \\\"{}\\\": {}\", path, e.description());\n }\n }\n }\n}\n"} {"name":"Empty string","C":"#include \n\n\n\n\nconst char *str = \"\";\n\n\nif (str) { ... }\n\n\nif (str[0] == '\\0') { ... }\n\n\nif ( (str == NULL) || (strlen(str) == 0)) { ... }\n\n\nif (strcmp(str, \"\") == 0) { ... }\n","Rust":"let s = \"\";\nprintln!(\"is empty: {}\", s.is_empty());\nlet t = \"x\";\nprintln!(\"is empty: {}\", t.is_empty());\nlet a = String::new();\nprintln!(\"is empty: {}\", a.is_empty());\nlet b = \"x\".to_string();\nprintln!(\"is empty: {}\", b.is_empty());\nprintln!(\"is not empty: {}\", !b.is_empty());\n"} {"name":"Entropy","C":"#include \n#include \n#include \n#include \n#include \n \n#define MAXLEN 100 \n \nint makehist(unsigned 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 f32 {\n let mut histogram = [0u64; 256];\n\n for &b in s {\n histogram[b as usize] += 1;\n }\n\n histogram\n .iter()\n .cloned()\n .filter(|&h| h != 0)\n .map(|h| h as f32 \/ s.len() as f32)\n .map(|ratio| -ratio * ratio.log2())\n .sum()\n}\n\nfn main() {\n let arg = std::env::args().nth(1).expect(\"Need a string.\");\n println!(\"Entropy of {} is {}.\", arg, entropy(arg.as_bytes()));\n}\n"} {"name":"Enumerations","C":"enum fruits { apple, banana, cherry };\n\nenum fruits { apple = 0, banana = 1, cherry = 2 };\n","Rust":"enum Fruits {\n Apple,\n Banana,\n Cherry\n}\n\nenum FruitsWithNumbers {\n Strawberry = 0,\n Pear = 27,\n}\n\nfn main() {\n \n println!(\"{}\", FruitsWithNumbers::Pear as u8);\n}\n"} {"name":"Environment variables","C":"#include \n#include \n \nint main() {\n puts(getenv(\"HOME\"));\n puts(getenv(\"PATH\"));\n puts(getenv(\"USER\"));\n return 0;\n}\n","Rust":"use std::env;\n\nfn main() {\n println!(\"{:?}\", env::var(\"HOME\"));\n println!();\n for (k, v) in env::vars().filter(|(k, _)| k.starts_with('P')) {\n println!(\"{}: {}\", k, v);\n }\n}\n"} {"name":"Equilibrium index","C":"#include \n#include \n\nint list[] = {-7, 1, 5, 2, -4, 3, 0};\n\nint eq_idx(int *a, int len, int **ret)\n{\n\tint i, sum, s, cnt;\n\t\n cnt = s = sum = 0;\n\t*ret = malloc(sizeof(int) * len);\n\n\tfor (i = 0; i < len; i++)\n sum += a[i];\n\n\tfor (i = 0; i < len; i++) {\n\t\tif (s * 2 + a[i] == sum) {\n\t\t\t(*ret)[cnt] = i;\n cnt++;\n }\n\t\ts += a[i];\n\t}\n\n \n\t*ret = realloc(*ret, cnt * sizeof(int));\n\n\treturn cnt;\n}\n\nint main()\n{\n\tint i, cnt, *idx;\n\tcnt = eq_idx(list, sizeof(list) \/ sizeof(int), &idx);\n\n\tprintf(\"Found:\");\n\tfor (i = 0; i < cnt; i++)\n printf(\" %d\", idx[i]);\n\tprintf(\"\\n\");\n\n\treturn 0;\n}\n","Rust":"extern crate num;\n\nuse num::traits::Zero;\n\nfn equilibrium_indices(v: &[i32]) -> Vec {\n let mut right = v.iter().sum();\n let mut left = i32::zero();\n\n v.iter().enumerate().fold(vec![], |mut out, (i, &el)| {\n right -= el;\n if left == right {\n out.push(i);\n }\n left += el;\n\n out\n })\n}\n\nfn main() {\n let v = [-7i32, 1, 5, 2, -4, 3, 0];\n let indices = equilibrium_indices(&v);\n println!(\"Equilibrium indices for {:?} are: {:?}\", v, indices);\n}\n"} {"name":"Ethiopian multiplication","C":"#include \n#include \n\nvoid halve(int *x) { *x >>= 1; }\nvoid doublit(int *x) { *x <<= 1; }\nbool iseven(const int x) { return (x & 1) == 0; }\n\nint ethiopian(int plier,\n\t int plicand, const bool tutor)\n{\n int result=0;\n\n if (tutor)\n printf(\"ethiopian multiplication of %d by %d\\n\", plier, plicand);\n \n while(plier >= 1) {\n if ( iseven(plier) ) {\n if (tutor) printf(\"%4d %6d struck\\n\", plier, plicand);\n } else {\n if (tutor) printf(\"%4d %6d kept\\n\", plier, plicand);\n result += plicand;\n }\n halve(&plier); doublit(&plicand);\n }\n return result;\n}\n\nint main()\n{\n printf(\"%d\\n\", ethiopian(17, 34, true));\n return 0;\n}\n","Rust":"fn double(a: i32) -> i32 {\n 2*a\n}\n\nfn halve(a: i32) -> i32 {\n a\/2\n}\n\nfn is_even(a: i32) -> bool {\n a % 2 == 0\n}\n\nfn ethiopian_multiplication(mut x: i32, mut y: i32) -> i32 {\n let mut sum = 0;\n\n while x >= 1 {\n print!(\"{} \\t {}\", x, y);\n match is_even(x) {\n true => println!(\"\\t Not Kept\"),\n false => {\n println!(\"\\t Kept\");\n sum += y;\n }\n }\n x = halve(x);\n y = double(y);\n }\n sum\n}\n\nfn main() {\n let output = ethiopian_multiplication(17, 34);\n println!(\"---------------------------------\");\n println!(\"\\t {}\", output);\n}\n"} {"name":"Euler method","C":"#include \n#include \n\ntypedef double (*deriv_f)(double, double);\n#define FMT \" %7.3f\"\n\nvoid ivp_euler(deriv_f f, double y, int step, int end_t)\n{\n\tint t = 0;\n\n\tprintf(\" Step %2d: \", (int)step);\n\tdo {\n\t\tif (t % 10 == 0) printf(FMT, y);\n\t\ty += step * f(t, y);\n\t} while ((t += step) <= end_t);\n\tprintf(\"\\n\");\n}\n\nvoid analytic()\n{\n\tdouble t;\n\tprintf(\" Time: \");\n\tfor (t = 0; t <= 100; t += 10) printf(\" %7g\", t);\n\tprintf(\"\\nAnalytic: \");\n\n\tfor (t = 0; t <= 100; t += 10)\n\t\tprintf(FMT, 20 + 80 * exp(-0.07 * t));\n\tprintf(\"\\n\");\n}\n\ndouble cooling(double t, double temp)\n{\n\treturn -0.07 * (temp - 20);\n}\n\nint main()\n{\n\tanalytic();\n\tivp_euler(cooling, 100, 2, 100);\n\tivp_euler(cooling, 100, 5, 100);\n\tivp_euler(cooling, 100, 10, 100);\n\n\treturn 0;\n}\n","Rust":"fn header() {\n print!(\" Time: \");\n for t in (0..100).step_by(10) {\n print!(\" {:7}\", t);\n }\n println!();\n}\n\nfn analytic() {\n print!(\"Analytic: \");\n for t in (0..=100).step_by(10) {\n print!(\" {:7.3}\", 20.0 + 80.0 * (-0.07 * f64::from(t)).exp());\n }\n println!();\n}\n\nfn euler f64>(f: F, mut y: f64, step: usize, end: usize) {\n print!(\" Step {:2}: \", step);\n for t in (0..=end).step_by(step) {\n if t % 10 == 0 {\n print!(\" {:7.3}\", y);\n }\n y += step as f64 * f(y);\n }\n println!();\n}\n\nfn main() {\n header();\n analytic();\n for &i in &[2, 5, 10] {\n euler(|temp| -0.07 * (temp - 20.0), 100.0, i, 100);\n }\n}\n"} {"name":"Euler's identity","C":"#include \n#include \n#include \n#include \n#include \n\nint main() {\n wchar_t pi = L'\\u03c0'; \n wchar_t ae = L'\\u2245'; \n double complex e = cexp(M_PI * I) + 1.0;\n setlocale(LC_CTYPE, \"\");\n printf(\"e ^ %lci + 1 = [%.16f,\u00a0%.16f] %lc 0\\n\", pi, creal(e), cimag(e), ae);\n return 0;\n}\n","Rust":"use std::f64::consts::PI;\n\nextern crate num_complex;\nuse num_complex::Complex;\n\nfn main() {\n println!(\"{:e}\", Complex::new(0.0, PI).exp() + 1.0);\n}\n"} {"name":"Euler's sum of powers conjecture","C":"\n#include \n#include \ntypedef long long mylong;\n\nvoid compute(int N, char find_only_one_solution)\n{\tconst int M = 30; \n\tint a, b, c, d, e;\n\tmylong s, t, max, *p5 = (mylong*)malloc(sizeof(mylong)*(N+M));\n \n\tfor(s=0; s < N; ++s)\n\t\tp5[s] = s * s, p5[s] *= p5[s] * s;\n\tfor(max = p5[N - 1]; s < (N + M); p5[s++] = max + 1);\n \n\tfor(a = 1; a < N; ++a)\n\tfor(b = a + 1; b < N; ++b)\n\tfor(c = b + 1; c < N; ++c)\n\tfor(d = c + 1, e = d + ((t = p5[a] + p5[b] + p5[c]) % M); ((s = t + p5[d]) <= max); ++d, ++e)\n\t{\tfor(e -= M; p5[e + M] <= s; e += M); \n\t\tif(p5[e] == s)\n\t\t{\tprintf(\"%d %d %d %d %d\\r\\n\", a, b, c, d, e);\n\t\t\tif(find_only_one_solution) goto onexit;\n\t\t}\n\t}\nonexit:\n\tfree(p5);\n}\n\nint main(void)\n{\n\tint tm = clock();\n\tcompute(250, 0);\n\tprintf(\"time=%d milliseconds\\r\\n\", (int)((clock() - tm) * 1000 \/ CLOCKS_PER_SEC));\n\treturn 0;\n}\n","Rust":"const MAX_N : u64 = 250;\n\nfn eulers_sum_of_powers() -> (usize, usize, usize, usize, usize) {\n let pow5: Vec = (0..MAX_N).map(|i| i.pow(5)).collect();\n let pow5_to_n = |pow| pow5.binary_search(&pow);\n\n for x0 in 1..MAX_N as usize {\n for x1 in 1..x0 {\n for x2 in 1..x1 {\n for x3 in 1..x2 {\n let pow_sum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3];\n if let Ok(n) = pow5_to_n(pow_sum) {\n return (x0, x1, x2, x3, n)\n }\n }\n }\n }\n }\n\n panic!();\n}\n\nfn main() {\n\tlet (x0, x1, x2, x3, y) = eulers_sum_of_powers();\n\tprintln!(\"{}^5 + {}^5 + {}^5 + {}^5 == {}^5\", x0, x1, x2, x3, y)\n}\n"} {"name":"Evaluate binomial coefficients","C":"#include \n#include \n\n\n\nstatic unsigned long gcd_ui(unsigned long x, unsigned long y) {\n unsigned long t;\n if (y < x) { t = x; x = y; y = t; }\n while (y > 0) {\n t = y; y = x % y; x = t; \n }\n return x;\n}\n\nunsigned long binomial(unsigned long n, unsigned long k) {\n unsigned long d, g, r = 1;\n if (k == 0) return 1;\n if (k == 1) return n;\n if (k >= n) return (k == n);\n if (k > n\/2) k = n-k;\n for (d = 1; d <= k; d++) {\n if (r >= ULONG_MAX\/n) { \n unsigned long nr, dr; \n g = gcd_ui(n, d); nr = n\/g; dr = d\/g;\n g = gcd_ui(r, dr); r = r\/g; dr = dr\/g;\n if (r >= ULONG_MAX\/nr) return 0; \n r *= nr;\n r \/= dr;\n n--;\n } else {\n r *= n--;\n r \/= d;\n }\n }\n return r;\n}\n\nint main() {\n printf(\"%lu\\n\", binomial(5, 3));\n printf(\"%lu\\n\", binomial(40, 19));\n printf(\"%lu\\n\", binomial(67, 31));\n return 0;\n}\n","Rust":"fn fact(n:u32) -> u64 {\n let mut f:u64 = n as u64;\n for i in 2..n {\n f *= i as u64;\n }\n return f;\n}\n\nfn choose(n: u32, k: u32) -> u64 {\n let mut num:u64 = n as u64;\n for i in 1..k {\n num *= (n-i) as u64;\n }\n return num \/ fact(k);\n}\n\nfn main() {\n println!(\"{}\", choose(5,3));\n}\n"} {"name":"Even or odd","C":"if (x & 1) {\n \n} else {\n \n}\n","Rust":"let is_odd = |x: i32| x & 1 == 1;\nlet is_even = |x: i32| x & 1 == 0;\n"} {"name":"Events","C":"#include \n#include \n\nint main()\n{\n\tint p[2];\n\tpipe(p);\n\tif (fork()) {\n\t\tclose(p[0]);\n\t\tsleep(1);\n\t\twrite(p[1], p, 1);\n\t\twait(0);\n\t} else {\n\t\tclose(p[1]);\n\t\tread(p[0], p + 1, 1);\n\t\tputs(\"received signal from pipe\");\n\t}\n\treturn 0;\n}\n","Rust":"use std::{sync::mpsc, thread, time::Duration};\n\nfn main() -> Result<(), Box> {\n println!(\"[1] Starting\");\n let (tx, rx) = mpsc::channel();\n thread::spawn(move || {\n println!(\"[2] Waiting for event\");\n rx.recv();\n println!(\"[2] Received event\");\n });\n thread::sleep(Duration::from_secs(1));\n println!(\"[1] Sending event\");\n tx.send(())?;\n thread::sleep(Duration::from_secs(1));\n\n Ok(())\n}\n"} {"name":"Evolutionary algorithm","C":"#include \n#include \n#include \n\nconst char target[] = \"METHINKS IT IS LIKE A WEASEL\";\nconst char tbl[] = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ \";\n\n#define CHOICE (sizeof(tbl) - 1)\n#define MUTATE 15\n#define COPIES 30\n\n\nint irand(int n)\n{\n\tint r, rand_max = RAND_MAX - (RAND_MAX % n);\n\twhile((r = rand()) >= rand_max);\n\treturn r \/ (rand_max \/ n);\n}\n\n\nint unfitness(const char *a, const char *b)\n{\n\tint i, sum = 0;\n\tfor (i = 0; a[i]; i++)\n\t\tsum += (a[i] != b[i]);\n\treturn sum;\n}\n\n\nvoid mutate(const char *a, char *b)\n{\n\tint i;\n\tfor (i = 0; a[i]; i++)\n\t\tb[i] = irand(MUTATE) ? a[i] : tbl[irand(CHOICE)];\n\n\tb[i] = '\\0';\n}\n\nint main()\n{\n\tint i, best_i, unfit, best, iters = 0;\n\tchar specimen[COPIES][sizeof(target) \/ sizeof(char)];\n\n\t\n\tfor (i = 0; target[i]; i++)\n\t\tspecimen[0][i] = tbl[irand(CHOICE)];\n\tspecimen[0][i] = 0;\n\n\tdo {\n\t\tfor (i = 1; i < COPIES; i++)\n\t\t\tmutate(specimen[0], specimen[i]);\n\n\t\t\n\t\tfor (best_i = i = 0; i < COPIES; i++) {\n\t\t\tunfit = unfitness(target, specimen[i]);\n\t\t\tif(unfit < best || !i) {\n\t\t\t\tbest = unfit;\n\t\t\t\tbest_i = i;\n\t\t\t}\n\t\t}\n\n\t\tif (best_i) strcpy(specimen[0], specimen[best_i]);\n\t\tprintf(\"iter %d, score %d: %s\\n\", iters++, best, specimen[0]);\n\t} while (best);\n\n\treturn 0;\n}\n","Rust":"\n\n\n\nextern crate rand;\n\nuse rand::Rng;\n\nfn main() {\n let target = \"METHINKS IT IS LIKE A WEASEL\";\n let copies = 100;\n let mutation_rate = 20; \n\n let mut rng = rand::weak_rng();\n\n \n let start = mutate(&mut rng, target, 1); \n\n println!(\"{}\", target);\n println!(\"{}\", start);\n\n evolve(&mut rng, target, start, copies, mutation_rate);\n}\n\n\n\n\nfn evolve(\n rng: &mut R,\n target: &str,\n mut parent: String,\n copies: usize,\n mutation_rate: u32,\n) -> usize {\n let mut counter = 0;\n let mut parent_fitness = target.len() + 1;\n\n loop {\n counter += 1;\n\n let (best_fitness, best_sentence) = (0..copies)\n .map(|_| {\n \n let sentence = mutate(rng, &parent, mutation_rate);\n \n (fitness(target, &sentence), sentence)\n })\n .min_by_key(|&(f, _)| f) \n .unwrap(); \n\n \n \n if best_fitness < parent_fitness {\n parent = best_sentence;\n parent_fitness = best_fitness;\n println!(\n \"{}\u00a0: generation {} with fitness {}\",\n parent, counter, best_fitness\n );\n\n if best_fitness == 0 {\n return counter;\n }\n }\n }\n}\n\n\n\nfn fitness(target: &str, sentence: &str) -> usize {\n sentence\n .chars()\n .zip(target.chars())\n .filter(|&(c1, c2)| c1 != c2)\n .count()\n}\n\n\n\n\nfn mutate(rng: &mut R, sentence: &str, mutation_rate: u32) -> String {\n let maybe_mutate = |c| {\n if rng.gen_weighted_bool(mutation_rate) {\n random_char(rng)\n } else {\n c\n }\n };\n sentence.chars().map(maybe_mutate).collect()\n}\n\n\nfn random_char(rng: &mut R) -> char {\n \n \n \n match rng.gen_range(b'A', b'Z' + 2) {\n c if c == b'Z' + 1 => ' ', \n c => c as char,\n }\n}\n"} {"name":"Exceptions_Catch an exception thrown in a nested call","C":"#include \n#include \n\ntypedef struct exception {\n int extype;\n char what[128];\n} exception;\n\ntypedef struct exception_ctx {\n exception * exs;\n int size;\n int pos;\n} exception_ctx;\n\nexception_ctx * Create_Ex_Ctx(int length) {\n const int safety = 8; \n char * tmp = (char*) malloc(safety+sizeof(exception_ctx)+sizeof(exception)*length);\n if (! tmp) return NULL;\n exception_ctx * ctx = (exception_ctx*)tmp;\n ctx->size = length;\n ctx->pos = -1;\n ctx->exs = (exception*) (tmp + sizeof(exception_ctx));\n return ctx;\n}\n\nvoid Free_Ex_Ctx(exception_ctx * ctx) {\n free(ctx);\n}\n\nint Has_Ex(exception_ctx * ctx) {\n return (ctx->pos >= 0) ? 1 : 0;\n}\n\nint Is_Ex_Type(exception_ctx * exctx, int extype) {\n return (exctx->pos >= 0 && exctx->exs[exctx->pos].extype == extype) ? 1 : 0;\n}\n\nvoid Pop_Ex(exception_ctx * ctx) {\n if (ctx->pos >= 0) --ctx->pos;\n}\n\nconst char * Get_What(exception_ctx * ctx) {\n if (ctx->pos >= 0) return ctx->exs[ctx->pos].what;\n return NULL;\n}\n\nint Push_Ex(exception_ctx * exctx, int extype, const char * msg) {\n if (++exctx->pos == exctx->size) {\n \n --exctx->pos;\n fprintf(stderr, \"*** Error: Overflow in exception context.\\n\");\n }\n snprintf(exctx->exs[exctx->pos].what, sizeof(exctx->exs[0].what), \"%s\", msg);\n exctx->exs[exctx->pos].extype = extype;\n return -1;\n}\n\n\n\nexception_ctx * GLOBALEX = NULL;\nenum { U0_DRINK_ERROR = 10, U1_ANGRYBARTENDER_ERROR };\n\nvoid baz(int n) {\n if (! n) {\n Push_Ex(GLOBALEX, U0_DRINK_ERROR , \"U0 Drink Error. Insufficient drinks in bar Baz.\");\n return;\n }\n else {\n Push_Ex(GLOBALEX, U1_ANGRYBARTENDER_ERROR , \"U1 Bartender Error. Bartender kicked customer out of bar Baz.\");\n return;\n }\n}\n\nvoid bar(int n) {\n fprintf(stdout, \"Bar door is open.\\n\");\n baz(n);\n if (Has_Ex(GLOBALEX)) goto bar_cleanup;\n fprintf(stdout, \"Baz has been called without errors.\\n\");\nbar_cleanup:\n fprintf(stdout, \"Bar door is closed.\\n\");\n}\n\nvoid foo() {\n fprintf(stdout, \"Foo entering bar.\\n\");\n bar(0);\n while (Is_Ex_Type(GLOBALEX, U0_DRINK_ERROR)) {\n fprintf(stderr, \"I am foo() and I deaall wrth U0 DriNk Errors with my own bottle... GOT oNE! [%s]\\n\", Get_What(GLOBALEX));\n Pop_Ex(GLOBALEX);\n }\n if (Has_Ex(GLOBALEX)) return;\n fprintf(stdout, \"Foo left the bar.\\n\");\n fprintf(stdout, \"Foo entering bar again.\\n\");\n bar(1);\n while (Is_Ex_Type(GLOBALEX, U0_DRINK_ERROR)) {\n fprintf(stderr, \"I am foo() and I deaall wrth U0 DriNk Errors with my own bottle... GOT oNE! [%s]\\n\", Get_What(GLOBALEX));\n Pop_Ex(GLOBALEX);\n }\n if (Has_Ex(GLOBALEX)) return;\n fprintf(stdout, \"Foo left the bar.\\n\");\n}\n\n\nint main(int argc, char ** argv) {\n exception_ctx * ctx = Create_Ex_Ctx(5);\n GLOBALEX = ctx;\n\n foo();\n if (Has_Ex(ctx)) goto main_ex;\n\n fprintf(stdout, \"No errors encountered.\\n\");\n\nmain_ex:\n while (Has_Ex(ctx)) {\n fprintf(stderr, \"*** Error: %s\\n\", Get_What(ctx));\n Pop_Ex(ctx);\n }\n Free_Ex_Ctx(ctx);\n return 0;\n}\n","Rust":"#[derive(Debug)]\nenum U {\n U0(i32),\n U1(String),\n}\n\nfn baz(i: u8) -> Result<(), U> {\n match i {\n 0 => Err(U::U0(42)),\n 1 => Err(U::U1(\"This will be returned from main\".into())),\n _ => Ok(()),\n }\n}\n\nfn bar(i: u8) -> Result<(), U> {\n baz(i)\n}\n\nfn foo() -> Result<(), U> {\n for i in 0..2 {\n match bar(i) {\n Ok(()) => {},\n Err(U::U0(n)) => eprintln!(\"Caught U0 in foo: {}\", n),\n Err(e) => return Err(e),\n }\n }\n Ok(())\n}\n\nfn main() -> Result<(), U> {\n foo()\n}\n"} {"name":"Execute a system command","C":"#include \n\nint main()\n{\n system(\"ls\");\n return 0;\n}\n","Rust":"use std::process::Command;\nfn main() {\n let output = Command::new(\"ls\").output().unwrap_or_else(|e| {\n panic!(\"failed to execute process: {}\", e)\n });\n println!(\"{}\", String::from_utf8_lossy(&output.stdout));\n}\n"} {"name":"Exponentiation operator","C":"#include \n#include \n\nint ipow(int base, int exp)\n{\n int pow = base;\n int v = 1;\n if (exp < 0) {\n assert (base != 0); \n return (base*base != 1)? 0: (exp&1)? base : 1;\n }\n \n while(exp > 0 )\n {\n if (exp & 1) v *= pow;\n pow *= pow;\n exp >>= 1;\n }\n return v;\n}\n\ndouble dpow(double base, int exp)\n{\n double v=1.0;\n double pow = (exp <0)? 1.0\/base : base;\n if (exp < 0) exp = - exp;\n\n while(exp > 0 )\n {\n if (exp & 1) v *= pow;\n pow *= pow;\n exp >>= 1;\n }\n return v;\n}\n\nint main()\n{\n printf(\"2^6 = %d\\n\", ipow(2,6));\n printf(\"2^-6 = %d\\n\", ipow(2,-6));\n printf(\"2.71^6 = %lf\\n\", dpow(2.71,6));\n printf(\"2.71^-6 = %lf\\n\", dpow(2.71,-6));\n}\n","Rust":"extern crate num;\nuse num::traits::One;\nuse std::ops::Mul;\n\nfn pow(mut base: T, mut exp: usize) -> T \n where T: Clone + One + Mul\n{\n if exp == 0 { return T::one() }\n while exp & 1 == 0 {\n base = base.clone() * base;\n exp >>= 1;\n }\n if exp == 1 { return base }\n let mut acc = base.clone();\n\n while exp > 1 {\n exp >>= 1;\n base = base.clone() * base;\n if exp & 1 == 1 {\n acc = acc * base.clone();\n }\n }\n acc\n}\n"} {"name":"Exponentiation order","C":"#include\n#include\n\nint main()\n{\n printf(\"(5 ^ 3) ^ 2 =\u00a0%.0f\",pow(pow(5,3),2));\n printf(\"\\n5 ^ (3 ^ 2) =\u00a0%.0f\",pow(5,pow(3,2)));\n\t\n return 0;\n}\n","Rust":"fn main() {\n println!(\"5**3**2 = {:7}\", 5u32.pow(3).pow(2));\n println!(\"(5**3)**2 = {:7}\", (5u32.pow(3)).pow(2));\n println!(\"5**(3**2) = {:7}\", 5u32.pow(3u32.pow(2)));\n}\n"} {"name":"Extend your language","C":"\n#define if2(firsttest,secondtest,bothtrue,firsttrue,secondtrue,bothfalse)\\\n\tswitch(((firsttest)?0:2)+((secondtest)?0:1)) {\\\n\t\tcase 0: bothtrue; break;\\\n\t\tcase 1: firsttrue; break;\\\n\t\tcase 2: secondtrue; break;\\\n\t\tcase 3: bothfalse; break;\\\n\t}\n","Rust":"#![allow(unused_variables)]\nmacro_rules! if2 {\n ($cond1: expr, $cond2: expr \n => $both:expr \n => $first: expr \n => $second:expr \n => $none:expr) \n => {\n match ($cond1, $cond2) {\n (true, true) => $both,\n (true, _ ) => $first,\n (_ , true) => $second,\n _ => $none\n }\n }\n}\n\nfn main() {\n let i = 1;\n let j = 2;\n if2!(i > j, i + j >= 3\n => {\n \n let k = i + j;\n println!(\"both were true\")\n }\n => println!(\"the first was true\")\n => println!(\"the second was true\")\n => println!(\"neither were true\")\n )\n}\n"} {"name":"Factorial","C":"int factorial(int n) {\n int result = 1;\n for (int i = 1; i <= n; ++i)\n result *= i;\n return result;\n}\n","Rust":"fn factorial_recursive (n: u64) -> u64 {\n match n {\n 0 => 1,\n _ => n * factorial_recursive(n-1)\n }\n}\n\nfn factorial_iterative(n: u64) -> u64 {\n (1..=n).product()\n}\n\nfn main () {\n for i in 1..10 {\n println!(\"{}\", factorial_recursive(i))\n }\n for i in 1..10 {\n println!(\"{}\", factorial_iterative(i))\n }\n}\n"} {"name":"Factors of a Mersenne number","C":"int isPrime(int n){\n\tif (n%2==0) return n==2;\n\tif (n%3==0) return n==3;\n\tint d=5;\n\twhile(d*d<=n){\n\t\tif(n%d==0) return 0;\n\t\td+=2;\n\t\tif(n%d==0) return 0;\n\t\td+=4;}\n\treturn 1;}\n\nmain() {int i,d,p,r,q=929;\n\tif (!isPrime(q)) return 1; \n\tr=q;\n\twhile(r>0) r<<=1;\n\td=2*q+1;\n\tdo { \tfor(p=r, i= 1; p; p<<= 1){\n\t\t\ti=((long long)i * i) % d;\n\t\t\tif (p < 0) i *= 2;\n\t\t\tif (i > d) i -= d;}\n\t\tif (i != 1) d += 2*q;\n\t\telse break;\n\t} while(1);\n\tprintf(\"2^%d - 1 = 0 (mod %d)\\n\", q, d);}\n","Rust":"fn bit_count(mut n: usize) -> usize {\n let mut count = 0;\n while n > 0 {\n n >>= 1;\n count += 1;\n }\n count\n}\n\nfn mod_pow(p: usize, n: usize) -> usize {\n let mut square = 1;\n let mut bits = bit_count(p);\n while bits > 0 {\n square = square * square;\n bits -= 1;\n if (p & (1 << bits)) != 0 {\n square <<= 1;\n }\n square %= n;\n }\n return square;\n}\n\nfn is_prime(n: usize) -> 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_mersenne_factor(p: usize) -> usize {\n let mut k = 0;\n loop {\n k += 1;\n let q = 2 * k * p + 1;\n if q % 8 == 1 || q % 8 == 7 {\n if mod_pow(p, q) == 1 && is_prime(p) {\n return q;\n }\n }\n }\n}\n\nfn main() {\n println!(\"{}\", find_mersenne_factor(929));\n}\n"} {"name":"Factors of an integer","C":"#include \n#include \n\ntypedef struct {\n int *list;\n short count; \n} Factors;\n\nvoid xferFactors( Factors *fctrs, int *flist, int flix ) \n{\n int ix, ij;\n int newSize = fctrs->count + flix;\n if (newSize > flix) {\n fctrs->list = realloc( fctrs->list, newSize * sizeof(int));\n }\n else {\n fctrs->list = malloc( newSize * sizeof(int));\n }\n for (ij=0,ix=fctrs->count; ixlist[ix] = flist[ij];\n }\n fctrs->count = newSize;\n}\n\nFactors *factor( int num, Factors *fctrs)\n{\n int flist[301], flix;\n int dvsr;\n flix = 0;\n fctrs->count = 0;\n free(fctrs->list);\n fctrs->list = NULL;\n for (dvsr=1; dvsr*dvsr < num; dvsr++) {\n if (num % dvsr != 0) continue;\n if ( flix == 300) {\n xferFactors( fctrs, flist, flix );\n flix = 0;\n }\n flist[flix++] = dvsr;\n flist[flix++] = num\/dvsr;\n }\n if (dvsr*dvsr == num) \n flist[flix++] = dvsr;\n if (flix > 0)\n xferFactors( fctrs, flist, flix );\n\n return fctrs;\n}\n \nint main(int argc, char*argv[])\n{\n int nums2factor[] = { 2059, 223092870, 3135, 45 };\n Factors ftors = { NULL, 0};\n char sep;\n int i,j;\n\n for (i=0; i<4; i++) {\n factor( nums2factor[i], &ftors );\n printf(\"\\nfactors of %d are:\\n \", nums2factor[i]);\n sep = ' ';\n for (j=0; j Vec {\n let mut factors: Vec = Vec::new(); \n\n for i in 1..((num as f32).sqrt() as i32 + 1) { \n if num % i == 0 {\n factors.push(i); \n factors.push(num\/i); \n }\n }\n factors.sort(); \n factors \n}\n"} {"name":"Fast Fourier transform","C":"#include \n#include \n#include \n \ndouble PI;\ntypedef double complex cplx;\n \nvoid _fft(cplx buf[], cplx out[], int n, int step)\n{\n\tif (step < n) {\n\t\t_fft(out, buf, n, step * 2);\n\t\t_fft(out + step, buf + step, n, step * 2);\n \n\t\tfor (int i = 0; i < n; i += 2 * step) {\n\t\t\tcplx t = cexp(-I * PI * i \/ n) * out[i + step];\n\t\t\tbuf[i \/ 2] = out[i] + t;\n\t\t\tbuf[(i + n)\/2] = out[i] - t;\n\t\t}\n\t}\n}\n \nvoid fft(cplx buf[], int n)\n{\n\tcplx out[n];\n\tfor (int i = 0; i < n; i++) out[i] = buf[i];\n \n\t_fft(buf, out, n, 1);\n}\n \n \nvoid show(const char * s, cplx buf[]) {\n\tprintf(\"%s\", s);\n\tfor (int i = 0; i < 8; i++)\n\t\tif (!cimag(buf[i]))\n\t\t\tprintf(\"%g \", creal(buf[i]));\n\t\telse\n\t\t\tprintf(\"(%g, %g) \", creal(buf[i]), cimag(buf[i]));\n}\n\nint main()\n{\n\tPI = atan2(1, 1) * 4;\n\tcplx buf[] = {1, 1, 1, 1, 0, 0, 0, 0};\n \n\tshow(\"Data: \", buf);\n\tfft(buf, 8);\n\tshow(\"\\nFFT\u00a0: \", buf);\n \n\treturn 0;\n}\n","Rust":"extern crate num;\nuse num::complex::Complex;\nuse std::f64::consts::PI;\n\nconst I: Complex = Complex { re: 0.0, im: 1.0 };\n\npub fn fft(input: &[Complex]) -> Vec> {\n fn fft_inner(\n buf_a: &mut [Complex],\n buf_b: &mut [Complex],\n n: usize, \n step: usize, \n ) {\n if step >= n {\n return;\n }\n\n fft_inner(buf_b, buf_a, n, step * 2);\n fft_inner(&mut buf_b[step..], &mut buf_a[step..], n, step * 2);\n \n let (left, right) = buf_a.split_at_mut(n \/ 2);\n\n for i in (0..n).step_by(step * 2) {\n let t = (-I * PI * (i as f64) \/ (n as f64)).exp() * buf_b[i + step];\n left[i \/ 2] = buf_b[i] + t;\n right[i \/ 2] = buf_b[i] - t;\n }\n }\n\n \n let n_orig = input.len();\n let n = n_orig.next_power_of_two();\n \n let mut buf_a = input.to_vec();\n \n buf_a.append(&mut vec![Complex { re: 0.0, im: 0.0 }; n - n_orig]);\n \n let mut buf_b = buf_a.clone();\n fft_inner(&mut buf_a, &mut buf_b, n, 1);\n buf_a\n}\n\nfn show(label: &str, buf: &[Complex]) {\n println!(\"{}\", label);\n let string = buf\n .into_iter()\n .map(|x| format!(\"{:.4}{:+.4}i\", x.re, x.im))\n .collect::>()\n .join(\", \");\n println!(\"{}\", string);\n}\n\nfn main() {\n let input: Vec<_> = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]\n .into_iter()\n .map(|x| Complex::from(x))\n .collect();\n show(\"input:\", &input);\n let output = fft(&input);\n show(\"output:\", &output);\n}\n"} {"name":"Fibonacci n-step number sequences","C":"\n\n#include\n#include\n\nint *\nanynacci (int *seedArray, int howMany)\n{\n int *result = malloc (howMany * sizeof (int));\n int i, j, initialCardinality;\n\n for (i = 0; seedArray[i] != 0; i++);\n initialCardinality = i;\n\n for (i = 0; i < initialCardinality; i++)\n result[i] = seedArray[i];\n\n for (i = initialCardinality; i < howMany; i++)\n {\n result[i] = 0;\n for (j = i - initialCardinality; j < i; j++)\n result[i] += result[j];\n }\n return result;\n}\n\nint\nmain ()\n{\n int fibo[] = { 1, 1, 0 }, tribo[] = { 1, 1, 2, 0 }, tetra[] = { 1, 1, 2, 4, 0 }, luca[] = { 2, 1, 0 };\n int *fibonacci = anynacci (fibo, 10), *tribonacci = anynacci (tribo, 10), *tetranacci = anynacci (tetra, 10), \n *lucas = anynacci(luca, 10);\n int i;\n\n printf (\"\\nFibonacci\\tTribonacci\\tTetranacci\\tLucas\\n\");\n\n for (i = 0; i < 10; i++)\n printf (\"\\n%d\\t\\t%d\\t\\t%d\\t\\t%d\", fibonacci[i], tribonacci[i],\n tetranacci[i], lucas[i]);\n\n return 0;\n}\n","Rust":" \nstruct GenFibonacci {\n buf: Vec,\n sum: u64,\n idx: usize,\n}\n\nimpl Iterator for GenFibonacci {\n type Item = u64;\n fn next(&mut self) -> Option {\n let result = Some(self.sum);\n self.sum -= self.buf[self.idx];\n self.buf[self.idx] += self.sum;\n self.sum += self.buf[self.idx];\n self.idx = (self.idx + 1) % self.buf.len();\n result\n }\n}\n\nfn print(buf: Vec, len: usize) {\n let mut sum = 0;\n for &elt in buf.iter() { sum += elt; print!(\"\\t{}\", elt); }\n let iter = GenFibonacci { buf: buf, sum: sum, idx: 0 };\n for x in iter.take(len) {\n print!(\"\\t{}\", x);\n }\n}\n\n\nfn main() {\n print!(\"Fib2:\");\n print(vec![1,1], 10 - 2);\n \n print!(\"\\nFib3:\");\n print(vec![1,1,2], 10 - 3);\n \n print!(\"\\nFib4:\");\n print(vec![1,1,2,4], 10 - 4);\n \n print!(\"\\nLucas:\");\n print(vec![2,1], 10 - 2);\n}\n"} {"name":"Fibonacci sequence","C":"\nfun fibb\n loop\n a = funparam[0]\n break (a < 2)\n\n a--\n\n \n a -> stack\n\n \n funparam[0] = a\n call fibb\n\n \n b = funparam[0]\n stack -> a\n\n \n b -> stack\n\n a--\n\n \n funparam[0] = a\n call fibb\n\n \n c = funparam[0]\n stack -> b\n\n \n b += c\n a = b\n\n funparam[0] = a\n\n break\n end\nend\n\n\n","Rust":"fn main() {\n let mut prev = 0;\n \n let mut curr = 1usize;\n\n while let Some(n) = curr.checked_add(prev) {\n prev = curr;\n curr = n;\n println!(\"{}\", n);\n }\n}\n"} {"name":"File input_output","C":"#include \n\nint main(int argc, char **argv) {\n FILE *in, *out;\n int c;\n\n in = fopen(\"input.txt\", \"r\");\n if (!in) {\n fprintf(stderr, \"Error opening input.txt for reading.\\n\");\n return 1;\n }\n\n out = fopen(\"output.txt\", \"w\");\n if (!out) {\n fprintf(stderr, \"Error opening output.txt for writing.\\n\");\n fclose(in);\n return 1;\n }\n\n while ((c = fgetc(in)) != EOF) {\n fputc(c, out);\n }\n\n fclose(out);\n fclose(in);\n return 0;\n}\n","Rust":"use std::fs::File;\nuse std::io::{Read, Write};\n\nfn main() {\n let mut file = File::open(\"input.txt\").unwrap();\n let mut data = Vec::new();\n file.read_to_end(&mut data).unwrap();\n let mut file = File::create(\"output.txt\").unwrap();\n file.write_all(&data).unwrap();\n}\n"} {"name":"File modification time","C":"#include \n#include \n#include \n#include \n\nconst char *filename = \"input.txt\";\n\nint main() {\n struct stat foo;\n time_t mtime;\n struct utimbuf new_times;\n\n if (stat(filename, &foo) < 0) {\n perror(filename);\n return 1;\n }\n mtime = foo.st_mtime; \n\n new_times.actime = foo.st_atime; \n new_times.modtime = time(NULL); \n if (utime(filename, &new_times) < 0) {\n perror(filename);\n return 1;\n }\n\n return 0;\n}\n","Rust":"use std::fs;\n\nfn main() -> std::io::Result<()> {\n let metadata = fs::metadata(\"foo.txt\")?;\n\n if let Ok(time) = metadata.accessed() {\n println!(\"{:?}\", time);\n } else {\n println!(\"Not supported on this platform\");\n }\n Ok(())\n}\n"} {"name":"File size","C":"#include \n#include \n\nlong getFileSize(const char *filename)\n{\n long result;\n FILE *fh = fopen(filename, \"rb\");\n fseek(fh, 0, SEEK_END);\n result = ftell(fh);\n fclose(fh);\n return result;\n}\n\nint main(void)\n{\n printf(\"%ld\\n\", getFileSize(\"input.txt\"));\n printf(\"%ld\\n\", getFileSize(\"\/input.txt\"));\n return 0;\n}\n","Rust":"use std::{env, fs, process};\nuse std::io::{self, Write};\nuse std::fmt::Display;\n\nfn main() {\n let file_name = env::args().nth(1).unwrap_or_else(|| exit_err(\"No file name supplied\", 1));\n let metadata = fs::metadata(file_name).unwrap_or_else(|e| exit_err(e, 2));\n\n println!(\"Size of file.txt is {} bytes\", metadata.len());\n}\n\n#[inline]\nfn exit_err(msg: T, code: i32) -> ! {\n writeln!(&mut io::stderr(), \"Error: {}\", msg).expect(\"Could not write to stdout\");\n process::exit(code)\n}\n\n}\n"} {"name":"Filter","C":"#include \n#include \n\nint even_sel(int x) { return !(x & 1); }\nint tri_sel(int x) { return x % 3; }\n\n\nint* grep(int *in, int len, int *outlen, int (*sel)(int), int inplace)\n{\n\tint i, j, *out;\n\n\tif (inplace)\tout = in;\n\telse\t\tout = malloc(sizeof(int) * len);\n\n\tfor (i = j = 0; i < len; i++)\n\t\tif (sel(in[i]))\n\t\t\tout[j++] = in[i];\n\n\tif (!inplace && j < len)\n\t\tout = realloc(out, sizeof(int) * j);\n\n\t*outlen = j;\n\treturn out;\n}\n\nint main()\n{\n\tint in[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };\n\tint i, len;\n\n\tint *even = grep(in, 10, &len, even_sel, 0);\n\tprintf(\"Filtered even:\");\n\tfor (i = 0; i < len; i++) printf(\" %d\", even[i]);\n\tprintf(\"\\n\");\n\n\tgrep(in, 8, &len, tri_sel, 1);\n\tprintf(\"In-place filtered not multiple of 3:\");\n\tfor (i = 0; i < len; i++) printf(\" %d\", in[i]);\n\n\tprintf(\"\\n\");\n\n\treturn 0;\n}\n","Rust":"fn main() {\n println!(\"new vec filtered: \");\n let nums: Vec = (1..20).collect();\n let evens: Vec = nums.iter().cloned().filter(|x| x % 2 == 0).collect();\n println!(\"{:?}\", evens);\n\n \n println!(\"original vec filtered: \");\n let mut nums: Vec = (1..20).collect();\n nums.retain(|x| x % 2 == 0);\n println!(\"{:?}\", nums);\n}\n"} {"name":"Find common directory path","C":"#include \n\nint common_len(const char *const *names, int n, char sep)\n{\n\tint i, pos;\n\tfor (pos = 0; ; pos++) {\n\t\tfor (i = 0; i < n; i++) {\n\t\t\tif (names[i][pos] != '\\0' &&\n\t\t\t\t\tnames[i][pos] == names[0][pos])\n\t\t\t\tcontinue;\n\n\t\t\t\n\t\t\twhile (pos > 0 && names[0][--pos] != sep);\n\t\t\treturn pos;\n\t\t}\n\t}\n\n\treturn 0;\n}\n\nint main()\n{\n\tconst char *names[] = {\n\t\t\"\/home\/user1\/tmp\/coverage\/test\",\n\t\t\"\/home\/user1\/tmp\/covert\/operator\",\n\t\t\"\/home\/user1\/tmp\/coven\/members\",\n\t};\n\tint len = common_len(names, sizeof(names) \/ sizeof(const char*), '\/');\n\n\tif (!len) printf(\"No common path\\n\");\n\telse printf(\"Common path:\u00a0%.*s\\n\", len, names[0]);\n\n\treturn 0;\n}\n","Rust":"use std::path::{Path, PathBuf};\n\nfn main() {\n let paths = [\n Path::new(\"\/home\/user1\/tmp\/coverage\/test\"),\n Path::new(\"\/home\/user1\/tmp\/covert\/operator\"),\n Path::new(\"\/home\/user1\/tmp\/coven\/members\"),\n ];\n match common_path(&paths) {\n Some(p) => println!(\"The common path is: {:#?}\", p),\n None => println!(\"No common paths found\"),\n }\n}\n\nfn common_path(paths: I) -> Option\nwhere\n I: IntoIterator,\n P: AsRef,\n{\n let mut iter = paths.into_iter();\n let mut ret = iter.next()?.as_ref().to_path_buf();\n for path in iter {\n if let Some(r) = common(ret, path.as_ref()) {\n ret = r;\n } else {\n return None;\n }\n }\n Some(ret)\n}\n\nfn common, B: AsRef>(a: A, b: B) -> Option {\n let a = a.as_ref().components();\n let b = b.as_ref().components();\n let mut ret = PathBuf::new();\n let mut found = false;\n for (one, two) in a.zip(b) {\n if one == two {\n ret.push(one);\n found = true;\n } else {\n break;\n }\n }\n if found {\n Some(ret)\n } else {\n None\n }\n}\n"} {"name":"Find limit of recursion","C":"#include \n\nvoid recurse(unsigned int i)\n{\n printf(\"%d\\n\", i);\n recurse(i+1); \n}\n\nint main()\n{\n recurse(0);\n return 0;\n}\n","Rust":"fn recurse(n: i32) {\n println!(\"depth: {}\", n);\n recurse(n + 1)\n}\n\nfn main() {\n recurse(0);\n}\n"} {"name":"Find the intersection of a line with a plane","C":"#include\n\ntypedef struct{\n\tdouble x,y,z;\n}vector;\n\nvector addVectors(vector a,vector b){\n\treturn (vector){a.x+b.x,a.y+b.y,a.z+b.z};\n}\n\nvector subVectors(vector a,vector b){\n\treturn (vector){a.x-b.x,a.y-b.y,a.z-b.z};\n}\n\ndouble dotProduct(vector a,vector b){\n\treturn a.x*b.x + a.y*b.y + a.z*b.z;\n}\n\nvector scaleVector(double l,vector a){\n\treturn (vector){l*a.x,l*a.y,l*a.z};\n}\n\nvector intersectionPoint(vector lineVector, vector linePoint, vector planeNormal, vector planePoint){\n\tvector diff = subVectors(linePoint,planePoint);\n\t\n\treturn addVectors(addVectors(diff,planePoint),scaleVector(-dotProduct(diff,planeNormal)\/dotProduct(lineVector,planeNormal),lineVector));\n}\n\nint main(int argC,char* argV[])\n{\n\tvector lV,lP,pN,pP,iP;\n\t\n\tif(argC!=5)\n\t\tprintf(\"Usage\u00a0: %s \");\n\telse{\n\t\tsscanf(argV[1],\"(%lf,%lf,%lf)\",&lV.x,&lV.y,&lV.z);\n\t\tsscanf(argV[3],\"(%lf,%lf,%lf)\",&pN.x,&pN.y,&pN.z);\n\t\t\n\t\tif(dotProduct(lV,pN)==0)\n\t\t\tprintf(\"Line and Plane do not intersect, either parallel or line is on the plane\");\n\t\telse{\n\t\t\tsscanf(argV[2],\"(%lf,%lf,%lf)\",&lP.x,&lP.y,&lP.z);\n\t\t\tsscanf(argV[4],\"(%lf,%lf,%lf)\",&pP.x,&pP.y,&pP.z);\n\t\t\t\n\t\t\tiP = intersectionPoint(lV,lP,pN,pP);\n\t\t\t\n\t\t\tprintf(\"Intersection point is (%lf,%lf,%lf)\",iP.x,iP.y,iP.z);\n\t\t}\n\t}\n\t\t\n\treturn 0;\n}\n","Rust":"use std::ops::{Add, Div, Mul, Sub};\n\n#[derive(Copy, Clone, Debug, PartialEq)]\nstruct V3 {\n x: T,\n y: T,\n z: T,\n}\n\nimpl V3 {\n fn new(x: T, y: T, z: T) -> Self {\n V3 { x, y, z }\n }\n}\n\nfn zip_with(f: F, a: V3, b: V3) -> V3\nwhere\n F: Fn(T, T) -> U,\n{\n V3 {\n x: f(a.x, b.x),\n y: f(a.y, b.y),\n z: f(a.z, b.z),\n }\n}\n\nimpl Add for V3\nwhere\n T: Add,\n{\n type Output = Self;\n\n fn add(self, other: Self) -> Self {\n zip_with(::add, self, other)\n }\n}\n\nimpl Sub for V3\nwhere\n T: Sub,\n{\n type Output = Self;\n\n fn sub(self, other: Self) -> Self {\n zip_with(::sub, self, other)\n }\n}\n\nimpl Mul for V3\nwhere\n T: Mul,\n{\n type Output = Self;\n\n fn mul(self, other: Self) -> Self {\n zip_with(::mul, self, other)\n }\n}\n\nimpl V3\nwhere\n T: Mul + Add,\n{\n fn dot(self, other: Self) -> T {\n let V3 { x, y, z } = self * other;\n x + y + z\n }\n}\n\nimpl V3\nwhere\n T: Mul + Copy,\n{\n fn scale(self, scalar: T) -> Self {\n self * V3 {\n x: scalar,\n y: scalar,\n z: scalar,\n }\n }\n}\n\nfn intersect(\n ray_vector: V3,\n ray_point: V3,\n plane_normal: V3,\n plane_point: V3,\n) -> V3\nwhere\n T: Add + Sub + Mul + Div + Copy,\n{\n let diff = ray_point - plane_point;\n let prod1 = diff.dot(plane_normal);\n let prod2 = ray_vector.dot(plane_normal);\n let prod3 = prod1 \/ prod2;\n ray_point - ray_vector.scale(prod3)\n}\n\nfn main() {\n let rv = V3::new(0.0, -1.0, -1.0);\n let rp = V3::new(0.0, 0.0, 10.0);\n let pn = V3::new(0.0, 0.0, 1.0);\n let pp = V3::new(0.0, 0.0, 5.0);\n println!(\"{:?}\", intersect(rv, rp, pn, pp));\n}\n"} {"name":"Find the intersection of two lines","C":"#include\n#include\n#include\n\ntypedef struct{\n\tdouble x,y;\n}point;\n\ndouble lineSlope(point a,point b){\n\t\n\tif(a.x-b.x == 0.0)\n\t\treturn NAN;\n\telse\n\t\treturn (a.y-b.y)\/(a.x-b.x);\n}\n\npoint extractPoint(char* str){\n\tint i,j,start,end,length;\n\tchar* holder;\n\tpoint c;\n\t\n\tfor(i=0;str[i]!=00;i++){\n\t\tif(str[i]=='(')\n\t\t\tstart = i;\n\t\tif(str[i]==','||str[i]==')')\n\t\t{\n\t\t\tend = i;\n\t\t\t\n\t\t\tlength = end - start;\n\t\t\t\n\t\t\tholder = (char*)malloc(length*sizeof(char));\n\t\t\t\n\t\t\tfor(j=0;j\",argV[0]);\n\telse{\n\t\tc = intersectionPoint(extractPoint(argV[1]),extractPoint(argV[2]),extractPoint(argV[3]),extractPoint(argV[4]));\n\t\t\n\t\tif(isnan(c.x))\n\t\t\tprintf(\"The lines do not intersect, they are either parallel or co-incident.\");\n\t\telse\n\t\t\tprintf(\"Point of intersection\u00a0: (%lf,%lf)\",c.x,c.y);\n\t}\n\t\n\treturn 0;\n}\n","Rust":"#[derive(Copy, Clone, Debug)]\nstruct Point {\n x: f64,\n y: f64,\n}\n\nimpl Point {\n pub fn new(x: f64, y: f64) -> Self {\n Point { x, y }\n }\n}\n\n#[derive(Copy, Clone, Debug)]\nstruct Line(Point, Point);\n\nimpl Line {\n pub fn intersect(self, other: Self) -> Option {\n let a1 = self.1.y - self.0.y;\n let b1 = self.0.x - self.1.x;\n let c1 = a1 * self.0.x + b1 * self.0.y;\n\n let a2 = other.1.y - other.0.y;\n let b2 = other.0.x - other.1.x;\n let c2 = a2 * other.0.x + b2 * other.0.y;\n\n let delta = a1 * b2 - a2 * b1;\n\n if delta == 0.0 {\n return None;\n }\n\n Some(Point {\n x: (b2 * c1 - b1 * c2) \/ delta,\n y: (a1 * c2 - a2 * c1) \/ delta,\n })\n }\n}\n\nfn main() {\n let l1 = Line(Point::new(4.0, 0.0), Point::new(6.0, 10.0));\n let l2 = Line(Point::new(0.0, 3.0), Point::new(10.0, 7.0));\n println!(\"{:?}\", l1.intersect(l2));\n\n let l1 = Line(Point::new(0.0, 0.0), Point::new(1.0, 1.0));\n let l2 = Line(Point::new(1.0, 2.0), Point::new(4.0, 5.0));\n println!(\"{:?}\", l1.intersect(l2));\n}\n"} {"name":"Find the missing permutation","C":"#include \n\n#define N 4\nconst char *perms[] = {\n\t\"ABCD\", \"CABD\", \"ACDB\", \"DACB\", \"BCDA\", \"ACBD\", \"ADCB\", \"CDAB\",\n\t\"DABC\", \"BCAD\", \"CADB\", \"CDBA\", \"CBAD\", \"ABDC\", \"ADBC\", \"BDCA\",\n\t\"DCBA\", \"BACD\", \"BADC\", \"BDAC\", \"CBDA\", \"DBCA\", \"DCAB\",\n};\n\nint main()\n{\n\tint i, j, n, cnt[N];\n\tchar miss[N];\n\n\tfor (n = i = 1; i < N; i++) n *= i; \n\n\tfor (i = 0; i < N; i++) {\n\t\tfor (j = 0; j < N; j++) cnt[j] = 0;\n\n\t\t\n\t\tfor (j = 0; j < sizeof(perms)\/sizeof(const char*); j++)\n\t\t\tcnt[perms[j][i] - 'A']++;\n\n\t\t\n\t\tfor (j = 0; j < N && cnt[j] == n; j++);\n\n\t\tmiss[i] = j + 'A';\n\t}\n\tprintf(\"Missing:\u00a0%.*s\\n\", N, miss);\n\n\treturn 0;\n\t\t\n}\n","Rust":"const GIVEN_PERMUTATIONS: [&str; 23] = [\n \"ABCD\",\n \"CABD\",\n \"ACDB\",\n \"DACB\",\n \"BCDA\",\n \"ACBD\",\n \"ADCB\",\n \"CDAB\",\n \"DABC\",\n \"BCAD\",\n \"CADB\",\n \"CDBA\",\n \"CBAD\",\n \"ABDC\",\n \"ADBC\",\n \"BDCA\",\n \"DCBA\",\n \"BACD\",\n \"BADC\",\n \"BDAC\",\n \"CBDA\",\n \"DBCA\",\n \"DCAB\"\n];\n\nfn main() {\n\n const PERMUTATION_LEN: usize = GIVEN_PERMUTATIONS[0].len();\n let mut bytes_result: [u8; PERMUTATION_LEN] = [0; PERMUTATION_LEN];\n\n for permutation in &GIVEN_PERMUTATIONS {\n for (i, val) in permutation.bytes().enumerate() {\n bytes_result[i] ^= val;\n }\n }\n println!(\"{}\", std::str::from_utf8(&bytes_result).unwrap());\n}\n"} {"name":"First-class functions","C":"#include \n#include \n#include \n \n\ntypedef double (*Class2Func)(double);\n \n\ndouble functionA( double v)\n{\n return v*v*v;\n}\ndouble functionB(double v)\n{\n return exp(log(v)\/3);\n}\n \n\ndouble Function1( Class2Func f2, double val )\n{\n return f2(val);\n}\n \n\nClass2Func WhichFunc( int idx)\n{\n return (idx < 4) ? &functionA : &functionB;\n}\n \n\nClass2Func funcListA[] = {&functionA, &sin, &cos, &tan };\nClass2Func funcListB[] = {&functionB, &asin, &acos, &atan };\n \n\ndouble InvokeComposed( Class2Func f1, Class2Func f2, double val )\n{\n return f1(f2(val));\n}\n \ntypedef struct sComposition {\n Class2Func f1;\n Class2Func f2;\n} *Composition;\n \nComposition Compose( Class2Func f1, Class2Func f2)\n{\n Composition comp = malloc(sizeof(struct sComposition));\n comp->f1 = f1;\n comp->f2 = f2;\n return comp;\n}\n \ndouble CallComposed( Composition comp, double val )\n{\n return comp->f1( comp->f2(val) );\n}\n\n \nint main(int argc, char *argv[])\n{\n int ix;\n Composition c;\n \n printf(\"Function1(functionA, 3.0) = %f\\n\", Function1(WhichFunc(0), 3.0));\n \n for (ix=0; ix<4; ix++) {\n c = Compose(funcListA[ix], funcListB[ix]);\n printf(\"Compostion %d(0.9) = %f\\n\", ix, CallComposed(c, 0.9));\n }\n \n return 0;\n}\n","Rust":"#![feature(conservative_impl_trait)]\nfn main() {\n let cube = |x: f64| x.powi(3);\n let cube_root = |x: f64| x.powf(1.0 \/ 3.0);\n\n let flist : [&Fn(f64) -> f64; 3] = [&cube , &f64::sin , &f64::cos ];\n let invlist: [&Fn(f64) -> f64; 3] = [&cube_root, &f64::asin, &f64::acos];\n\n let result = flist.iter()\n .zip(&invlist)\n .map(|(f,i)| compose(f,i)(0.5))\n .collect::>();\n\n println!(\"{:?}\", result);\n\n}\n\nfn compose<'a, F, G, T, U, V>(f: F, g: G) -> impl 'a + Fn(T) -> V\n where F: 'a + Fn(T) -> U,\n G: 'a + Fn(U) -> V,\n{\n move |x| g(f(x))\n\n}\n"} {"name":"Five weekends","C":"#include \n#include \n\nstatic const char *months[] = {\"January\", \"February\", \"March\", \"April\", \"May\",\n \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"};\nstatic int long_months[] = {0, 2, 4, 6, 7, 9, 11};\n\nint main() {\n int n = 0, y, i, m;\n struct tm t = {0};\n printf(\"Months with five weekends:\\n\");\n for (y = 1900; y <= 2100; y++) {\n for (i = 0; i < 7; i++) {\n m = long_months[i];\n t.tm_year = y-1900;\n\t t.tm_mon = m;\n\t t.tm_mday = 1;\n if (mktime(&t) == -1) { \n printf(\"Error: %d %s\\n\", y, months[m]);\n continue;\n }\n if (t.tm_wday == 5) { \n printf(\" %d %s\\n\", y, months[m]);\n n++;\n }\n }\n }\n printf(\"%d total\\n\", n);\n return 0;\n}\n","Rust":"extern crate chrono;\nuse chrono::prelude::*;\n\n\nconst LONGMONTHS: [u32; 7] = [1, 3, 5, 7, 8, 10, 12];\n\n\n\nfn five_weekends(start: i32, end: i32) -> Vec<(i32, u32)> {\n let mut out = vec![];\n\n for year in start..=end {\n for month in LONGMONTHS.iter() {\n \n if Local.ymd(year, *month, 1).weekday() == Weekday::Fri {\n out.push((year, *month));\n }\n }\n }\n\n out\n}\n\nfn main() {\n let out = five_weekends(1900, 2100);\n\n let len = out.len();\n println!(\n \"There are {} months of which the first and last five are:\",\n len\n );\n for (y, m) in &out[..5] {\n println!(\"\\t{} \/ {}\", y, m);\n }\n println!(\"...\");\n for (y, m) in &out[(len - 5..)] {\n println!(\"\\t{} \/ {}\", y, m);\n }\n}\n\n#[test]\nfn test() {\n let out = five_weekends(1900, 2100);\n assert_eq!(out.len(), 201);\n}\n"} {"name":"Fivenum","C":"#include \n#include \n\ndouble median(double *x, int start, int end_inclusive) {\n int size = end_inclusive - start + 1;\n if (size <= 0) {\n printf(\"Array slice cannot be empty\\n\");\n exit(1);\n }\n int m = start + size \/ 2;\n if (size % 2) return x[m];\n return (x[m - 1] + x[m]) \/ 2.0;\n}\n\nint compare (const void *a, const void *b) {\n double aa = *(double*)a; \n double bb = *(double*)b;\n if (aa > bb) return 1;\n if (aa < bb) return -1;\n return 0;\n}\n\nint fivenum(double *x, double *result, int x_len) {\n int i, m, lower_end;\n for (i = 0; i < x_len; i++) {\n if (x[i] != x[i]) {\n printf(\"Unable to deal with arrays containing NaN\\n\\n\");\n return 1;\n }\n } \n qsort(x, x_len, sizeof(double), compare);\n result[0] = x[0];\n result[2] = median(x, 0, x_len - 1);\n result[4] = x[x_len - 1];\n m = x_len \/ 2;\n lower_end = (x_len % 2) ? m : m - 1;\n result[1] = median(x, 0, lower_end);\n result[3] = median(x, m, x_len - 1);\n return 0;\n}\n\nint show(double *result, int places) {\n int i;\n char f[7];\n sprintf(f, \"%%.%dlf\", places);\n printf(\"[\");\n for (i = 0; i < 5; i++) { \n printf(f, result[i]);\n if (i < 4) printf(\", \");\n }\n printf(\"]\\n\\n\");\n}\n\nint main() {\n double result[5];\n\n double x1[11] = {15.0, 6.0, 42.0, 41.0, 7.0, 36.0, 49.0, 40.0, 39.0, 47.0, 43.0};\n if (!fivenum(x1, result, 11)) show(result, 1);\n\n double x2[6] = {36.0, 40.0, 7.0, 39.0, 41.0, 15.0};\n if (!fivenum(x2, result, 6)) show(result, 1);\n\n double x3[20] = {\n 0.14082834, 0.09748790, 1.73131507, 0.87636009, -1.95059594, 0.73438555,\n -0.03035726, 1.46675970, -0.74621349, -0.72588772, 0.63905160, 0.61501527,\n -0.98983780, -1.00447874, -0.62759469, 0.66206163, 1.04312009, -0.10305385,\n 0.75775634, 0.32566578\n };\n if (!fivenum(x3, result, 20)) show(result, 9);\n\n return 0;\n}\n","Rust":"#[derive(Debug)]\nstruct FiveNum {\n minimum: f64,\n lower_quartile: f64,\n median: f64,\n upper_quartile: f64,\n maximum: f64,\n}\n\nfn median(samples: &[f64]) -> f64 {\n \n let n = samples.len();\n let m = n \/ 2;\n if n % 2 == 0 {\n (samples[m] + samples[m - 1]) \/ 2.0\n } else {\n samples[m]\n }\n}\n\nfn fivenum(samples: &[f64]) -> FiveNum {\n let mut xs = samples.to_vec();\n xs.sort_by(|x, y| x.partial_cmp(y).unwrap());\n\n let m = xs.len() \/ 2;\n\n FiveNum {\n minimum: xs[0],\n lower_quartile: median(&xs[0..(m + (xs.len() % 2))]),\n median: median(&xs),\n upper_quartile: median(&xs[m..]),\n maximum: xs[xs.len() - 1],\n }\n}\nfn main() {\n let inputs = vec![\n vec![15., 6., 42., 41., 7., 36., 49., 40., 39., 47., 43.],\n vec![36., 40., 7., 39., 41., 15.],\n vec![\n 0.14082834,\n 0.09748790,\n 1.73131507,\n 0.87636009,\n -1.95059594,\n 0.73438555,\n -0.03035726,\n 1.46675970,\n -0.74621349,\n -0.72588772,\n 0.63905160,\n 0.61501527,\n -0.98983780,\n -1.00447874,\n -0.62759469,\n 0.66206163,\n 1.04312009,\n -0.10305385,\n 0.75775634,\n 0.32566578,\n ],\n ];\n\n for input in inputs {\n let result = fivenum(&input);\n println!(\"Fivenum\",);\n println!(\" Minumum: {}\", result.minimum);\n println!(\" Lower quartile: {}\", result.lower_quartile);\n println!(\" Median: {}\", result.median);\n println!(\" Upper quartile: {}\", result.upper_quartile);\n println!(\" Maximum: {}\", result.maximum);\n }\n}\n"} {"name":"FizzBuzz","C":" int i = 0 ; char B[88] ;\n while ( i++ < 100 )\n !sprintf( B, \"%s%s\", i%3 ? \"\":\"Fizz\", i%5 ? \"\":\"Buzz\" )\n ? sprintf( B, \"%d\", i ):0, printf( \", %s\", B );\n","Rust":"fn main() {\n for i in 1..=100 {\n match (i % 3, i % 5) {\n (0, 0) => println!(\"fizzbuzz\"),\n (0, _) => println!(\"fizz\"),\n (_, 0) => println!(\"buzz\"),\n (_, _) => println!(\"{}\", i),\n }\n }\n}\n"} {"name":"Flatten a list","C":"#include \n#include \n#include \n\ntypedef struct list_t list_t, *list;\nstruct list_t{\n\tint is_list, ival; \n\tlist *lst;\n};\n\nlist new_list()\n{\n\tlist x = malloc(sizeof(list_t));\n\tx->ival = 0;\n\tx->is_list = 1;\n\tx->lst = 0;\n\treturn x;\n}\n\nvoid append(list parent, list child)\n{\n\tparent->lst = realloc(parent->lst, sizeof(list) * (parent->ival + 1));\n\tparent->lst[parent->ival++] = child;\n}\n\nlist from_string(char *s, char **e, list parent)\n{\n\tlist ret = 0;\n\tif (!parent) parent = new_list();\n\n\twhile (*s != '\\0') {\n\t\tif (*s == ']') {\n\t\t\tif (e) *e = s + 1;\n\t\t\treturn parent;\n\t\t}\n\t\tif (*s == '[') {\n\t\t\tret = new_list();\n\t\t\tret->is_list = 1;\n\t\t\tret->ival = 0;\n\t\t\tappend(parent, ret);\n\t\t\tfrom_string(s + 1, &s, ret);\n\t\t\tcontinue;\n\t\t}\n\t\tif (*s >= '0' && *s <= '9') {\n\t\t\tret = new_list();\n\t\t\tret->is_list = 0;\n\t\t\tret->ival = strtol(s, &s, 10);\n\t\t\tappend(parent, ret);\n\t\t\tcontinue;\n\t\t}\n\t\ts++;\n\t}\n\n\tif (e) *e = s;\n\treturn parent;\n}\n\nvoid show_list(list l)\n{\n\tint i;\n\tif (!l) return;\n\tif (!l->is_list) {\n\t\tprintf(\"%d\", l->ival);\n\t\treturn;\n\t}\n\n\tprintf(\"[\");\n\tfor (i = 0; i < l->ival; i++) {\n\t\tshow_list(l->lst[i]);\n\t\tif (i < l->ival - 1) printf(\", \");\n\t}\n\tprintf(\"]\");\n}\n\nlist flatten(list from, list to)\n{\n\tint i;\n\tlist t;\n\n\tif (!to) to = new_list();\n\tif (!from->is_list) {\n\t\tt = new_list();\n\t\t*t = *from;\n\t\tappend(to, t);\n\t} else\n\t\tfor (i = 0; i < from->ival; i++)\n\t\t\tflatten(from->lst[i], to);\n\treturn to;\n}\n\nvoid delete_list(list l)\n{\n\tint i;\n\tif (!l) return;\n\tif (l->is_list && l->ival) {\n\t\tfor (i = 0; i < l->ival; i++)\n\t\t\tdelete_list(l->lst[i]);\n\t\tfree(l->lst);\n\t}\n\n\tfree(l);\n}\n\nint main()\n{\n\tlist l = from_string(\"[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []\", 0, 0);\n\n\tprintf(\"Nested: \");\n\tshow_list(l);\n\tprintf(\"\\n\");\n\n\tlist flat = flatten(l, 0);\n\tprintf(\"Flattened: \");\n\tshow_list(flat);\n\n\t\n\treturn 0;\n}\n","Rust":"use std::{vec, mem, iter};\n\nenum List {\n Node(Vec>),\n Leaf(T),\n}\n\nimpl IntoIterator for List {\n type Item = List;\n type IntoIter = ListIter;\n fn into_iter(self) -> Self::IntoIter {\n match self {\n List::Node(vec) => ListIter::NodeIter(vec.into_iter()),\n leaf @ List::Leaf(_) => ListIter::LeafIter(iter::once(leaf)),\n }\n }\n}\n\nenum ListIter {\n NodeIter(vec::IntoIter>),\n LeafIter(iter::Once>),\n}\n\nimpl ListIter {\n fn flatten(self) -> Flatten {\n Flatten {\n stack: Vec::new(),\n curr: self,\n }\n }\n}\n\nimpl Iterator for ListIter {\n type Item = List;\n fn next(&mut self) -> Option {\n match *self {\n ListIter::NodeIter(ref mut v_iter) => v_iter.next(),\n ListIter::LeafIter(ref mut o_iter) => o_iter.next(),\n }\n }\n}\n\nstruct Flatten {\n stack: Vec>,\n curr: ListIter,\n}\n\n\nimpl Iterator for Flatten {\n type Item = T;\n fn next(&mut self) -> Option {\n loop {\n match self.curr.next() {\n Some(list) => {\n match list {\n node @ List::Node(_) => {\n self.stack.push(node.into_iter());\n let len = self.stack.len();\n mem::swap(&mut self.stack[len - 1], &mut self.curr);\n }\n List::Leaf(item) => return Some(item),\n }\n }\n None => {\n if let Some(next) = self.stack.pop() {\n self.curr = next;\n } else {\n return None;\n }\n }\n }\n }\n }\n}\n\nuse List::*;\nfn main() {\n let list = Node(vec![Node(vec![Leaf(1)]),\n Leaf(2),\n Node(vec![Node(vec![Leaf(3), Leaf(4)]), Leaf(5)]),\n Node(vec![Node(vec![Node(vec![])])]),\n Node(vec![Node(vec![Node(vec![Leaf(6)])])]),\n Leaf(7),\n Leaf(8),\n Node(vec![])]);\n\n for elem in list.into_iter().flatten() {\n print!(\"{} \", elem);\n }\n println!();\n\n}\n"} {"name":"Floyd's triangle","C":"#include \n\nvoid t(int n)\n{\n\tint i, j, c, len;\n\n\ti = n * (n - 1) \/ 2;\n\tfor (len = c = 1; c < i; c *= 10, len++);\n\tc -= i; \n\n#define SPEED_MATTERS 0\n#if SPEED_MATTERS\t\n\tchar tmp[32], s[4096], *p;\n\n\tsprintf(tmp, \"%*d\", len, 0);\n\n\tinline void inc_numstr(void) {\n\t\tint k = len;\n\n\tredo:\tif (!k--) return;\n\n\t\tif (tmp[k] == '9') {\n\t\t\ttmp[k] = '0';\n\t\t\tgoto redo;\n\t\t}\n\n\t\tif (++tmp[k] == '!')\n\t\t\ttmp[k] = '1';\n\t}\n\n\tfor (p = s, i = 1; i <= n; i++) {\n\t\tfor (j = 1; j <= i; j++) {\n\t\t\tinc_numstr();\n\t\t\t__builtin_memcpy(p, tmp + 1 - (j >= c), len - (j < c));\n\t\t\tp += len - (j < c);\n\n\t\t\t*(p++) = (i - j)? ' ' : '\\n';\n\n\t\t\tif (p - s + len >= 4096) {\n\t\t\t\tfwrite(s, 1, p - s, stdout);\n\t\t\t\tp = s;\n\t\t\t}\n\t\t}\n\t}\n\n\tfwrite(s, 1, p - s, stdout);\n#else \n\tint num;\n\tfor (num = i = 1; i <= n; i++)\n\t\tfor (j = 1; j <= i; j++)\n\t\t\tprintf(\"%*d%c\",\tlen - (j < c), num++, i - j ? ' ':'\\n');\n#endif\n}\n\nint main(void)\n{\n\tt(5), t(14);\n\n\t\n\t\n\treturn 0;\n}\n","Rust":"fn main() {\n floyds_triangle(5);\n floyds_triangle(14);\n}\n\nfn floyds_triangle(n: u32) {\n let mut triangle: Vec> = Vec::new();\n let mut current = 0;\n for i in 1..=n {\n let mut v = Vec::new();\n for _ in 0..i {\n current += 1;\n v.push(current);\n }\n let row = v.iter().map(|x| x.to_string()).collect::>();\n triangle.push(row);\n }\n\n for row in &triangle {\n let arranged_row: Vec<_> = row\n .iter()\n .enumerate()\n .map(|(i, number)| {\n let space_len = triangle.last().unwrap()[i].len() - number.len() + 1;\n let spaces = \" \".repeat(space_len);\n let mut padded_number = spaces;\n padded_number.push_str(&number);\n padded_number\n })\n .collect();\n println!(\"{}\", arranged_row.join(\"\"))\n }\n}\n"} {"name":"Floyd-Warshall algorithm","C":"#include\n#include\n#include\n\ntypedef struct{\n int sourceVertex, destVertex;\n int edgeWeight;\n}edge;\n\ntypedef struct{\n int vertices, edges;\n edge* edgeMatrix;\n}graph;\n\ngraph loadGraph(char* fileName){\n FILE* fp = fopen(fileName,\"r\");\n \n graph G;\n int i;\n \n fscanf(fp,\"%d%d\",&G.vertices,&G.edges);\n \n G.edgeMatrix = (edge*)malloc(G.edges*sizeof(edge));\n \n for(i=0;i %d %3d %5d\",i+1,j+1,processWeights[i][j],i+1);\n k = i+1;\n do{\n k = processedVertices[k-1][j];\n printf(\"->%d\",k);\n }while(k!=j+1);\n }\n }\n}\n\nint main(int argC,char* argV[]){\n if(argC!=2)\n printf(\"Usage\u00a0: %s \");\n else\n floydWarshall(loadGraph(argV[1]));\n return 0;\n}\n","Rust":"pub type Edge = (usize, usize);\n\n#[derive(Clone, Debug, PartialEq, Eq, Hash)]\npub struct Graph {\n size: usize,\n edges: Vec>,\n}\n\nimpl Graph {\n pub fn new(size: usize) -> Self {\n Self {\n size,\n edges: std::iter::repeat_with(|| None).take(size * size).collect(),\n }\n }\n\n pub fn new_with(size: usize, f: impl FnMut(Edge) -> Option) -> Self {\n let edges = (0..size)\n .flat_map(|i| (0..size).map(move |j| (i, j)))\n .map(f)\n .collect();\n\n Self { size, edges }\n }\n\n pub fn with_diagonal(mut self, mut f: impl FnMut(usize) -> Option) -> Self {\n self.edges\n .iter_mut()\n .step_by(self.size + 1)\n .enumerate()\n .for_each(move |(vertex, edge)| *edge = f(vertex));\n\n self\n }\n\n pub fn size(&self) -> usize {\n self.size\n }\n\n pub fn edge(&self, edge: Edge) -> &Option {\n let index = self.edge_index(edge);\n &self.edges[index]\n }\n\n pub fn edge_mut(&mut self, edge: Edge) -> &mut Option {\n let index = self.edge_index(edge);\n &mut self.edges[index]\n }\n\n fn edge_index(&self, (row, col): Edge) -> usize {\n assert!(row < self.size && col < self.size);\n row * self.size() + col\n }\n}\n\nimpl std::ops::Index for Graph {\n type Output = Option;\n\n fn index(&self, index: Edge) -> &Self::Output {\n self.edge(index)\n }\n}\n\nimpl std::ops::IndexMut for Graph {\n fn index_mut(&mut self, index: Edge) -> &mut Self::Output {\n self.edge_mut(index)\n }\n}\n\n#[derive(Clone, Debug, PartialEq, Eq)]\npub struct Paths(Graph);\n\nimpl Paths {\n pub fn new(graph: &Graph) -> Self {\n Self(Graph::new_with(graph.size(), |(i, j)| {\n graph[(i, j)].as_ref().map(|_| j)\n }))\n }\n\n pub fn vertices(&self, from: usize, to: usize) -> Path<'_> {\n assert!(from < self.0.size() && to < self.0.size());\n\n Path {\n graph: &self.0,\n from: Some(from),\n to,\n }\n }\n\n fn update(&mut self, from: usize, to: usize, via: usize) {\n self.0[(from, to)] = self.0[(from, via)];\n }\n}\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub struct Path<'a> {\n graph: &'a Graph,\n from: Option,\n to: usize,\n}\n\nimpl<'a> Iterator for Path<'a> {\n type Item = usize;\n\n fn next(&mut self) -> Option {\n self.from.map(|from| {\n let result = from;\n\n self.from = if result != self.to {\n self.graph[(result, self.to)]\n } else {\n None\n };\n\n result\n })\n }\n}\n\npub fn floyd_warshall(mut result: Graph) -> (Graph, Option)\nwhere\n W: Copy + std::ops::Add + std::cmp::Ord + Default,\n{\n let mut without_negative_cycles = true;\n let mut paths = Paths::new(&result);\n let n = result.size();\n\n for k in 0..n {\n for i in 0..n {\n for j in 0..n {\n \n if i == j && result[(i, j)].filter(|&it| it < W::default()).is_some() {\n without_negative_cycles = false;\n continue;\n }\n\n if let (Some(ik_weight), Some(kj_weight)) = (result[(i, k)], result[(k, j)]) {\n let ij_edge = result.edge_mut((i, j));\n let ij_weight = ik_weight + kj_weight;\n\n if ij_edge.is_none() {\n *ij_edge = Some(ij_weight);\n paths.update(i, j, k);\n } else {\n ij_edge\n .as_mut()\n .filter(|it| ij_weight < **it)\n .map_or((), |it| {\n *it = ij_weight;\n paths.update(i, j, k);\n });\n }\n }\n }\n }\n }\n\n (result, Some(paths).filter(|_| without_negative_cycles)) \n}\n\nfn format_path(path: impl Iterator) -> String {\n path.fold(String::new(), |mut acc, x| {\n if !acc.is_empty() {\n acc.push_str(\" -> \");\n }\n\n acc.push_str(&x.to_string());\n acc\n })\n}\n\nfn print_results(weights: &Graph, paths: Option<&Paths>, vertex: impl Fn(usize) -> V)\nwhere\n W: std::fmt::Display + Default + Eq,\n V: std::fmt::Display,\n{\n let n = weights.size();\n\n for from in 0..n {\n for to in 0..n {\n if let Some(weight) = &weights[(from, to)] {\n \n if from == to && *weight == W::default() {\n continue;\n }\n\n println!(\n \"{} -> {}: {} \\t{}\",\n vertex(from),\n vertex(to),\n weight,\n format_path(paths.iter().flat_map(|p| p.vertices(from, to)).map(&vertex))\n );\n }\n }\n }\n}\n\nfn main() {\n let graph = {\n let mut g = Graph::new(4).with_diagonal(|_| Some(0));\n g[(0, 2)] = Some(-2);\n g[(1, 0)] = Some(4);\n g[(1, 2)] = Some(3);\n g[(2, 3)] = Some(2);\n g[(3, 1)] = Some(-1);\n g\n };\n\n let (weights, paths) = floyd_warshall(graph);\n \n print_results(&weights, paths.as_ref(), |index| index + 1);\n}\n"} {"name":"Forest fire","C":"#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n\n#define PROB_TREE 0.55\n#define PROB_F 0.00001\n#define PROB_P 0.001\n\n#define TIMERFREQ 100\n\n#ifndef WIDTH\n# define WIDTH 640\n#endif\n#ifndef HEIGHT\n# define HEIGHT 480\n#endif\n#ifndef BPP\n# define BPP 32\n#endif\n\n#if BPP\u00a0!= 32\n #warning This program could not work with BPP different from 32\n#endif\n\nuint8_t *field[2], swapu;\ndouble prob_f = PROB_F, prob_p = PROB_P, prob_tree = PROB_TREE; \n\nenum cell_state { \n VOID, TREE, BURNING\n};\n\n\ndouble prand()\n{\n return (double)rand() \/ (RAND_MAX + 1.0);\n}\n\n\nvoid init_field(void)\n{\n int i, j;\n swapu = 0;\n for(i = 0; i < WIDTH; i++)\n {\n for(j = 0; j < HEIGHT; j++)\n {\n *(field[0] + j*WIDTH + i) = prand() > prob_tree ? VOID : TREE;\n }\n }\n}\n\n\nbool burning_neighbor(int, int);\npthread_mutex_t synclock = PTHREAD_MUTEX_INITIALIZER;\nstatic uint32_t simulate(uint32_t iv, void *p)\n{\n int i, j;\n\n \n pthread_mutex_lock(&synclock);\n\n for(i = 0; i < WIDTH; i++) {\n for(j = 0; j < HEIGHT; j++) {\n enum cell_state s = *(field[swapu] + j*WIDTH + i);\n switch(s)\n {\n case BURNING:\n\t*(field[swapu^1] + j*WIDTH + i) = VOID;\n\tbreak;\n case VOID:\n\t*(field[swapu^1] + j*WIDTH + i) = prand() > prob_p ? VOID : TREE;\n\tbreak;\n case TREE:\n\tif (burning_neighbor(i, j))\n\t *(field[swapu^1] + j*WIDTH + i) = BURNING;\n\telse\n\t *(field[swapu^1] + j*WIDTH + i) = prand() > prob_f ? TREE : BURNING;\n\tbreak;\n default:\n\tfprintf(stderr, \"corrupted field\\n\");\n\tbreak;\n }\n }\n }\n swapu ^= 1;\n pthread_mutex_unlock(&synclock);\n return iv;\n}\n\n\n#define NB(I,J) (((I)=0)&&((J)=0) \\\n\t\t\u00a0? (*(field[swapu] + (J)*WIDTH + (I)) == BURNING)\u00a0: false)\nbool burning_neighbor(int i, int j)\n{\n return NB(i-1,j-1) || NB(i-1, j) || NB(i-1, j+1) ||\n NB(i, j-1) || NB(i, j+1) ||\n NB(i+1, j-1) || NB(i+1, j) || NB(i+1, j+1);\n}\n\n\n\n\n\n\nvoid show(SDL_Surface *s)\n{\n int i, j;\n uint8_t *pixels = (uint8_t *)s->pixels;\n uint32_t color;\n SDL_PixelFormat *f = s->format;\n\n pthread_mutex_lock(&synclock);\n for(i = 0; i < WIDTH; i++) {\n for(j = 0; j < HEIGHT; j++) {\n switch(*(field[swapu] + j*WIDTH + i)) {\n case VOID:\n\tcolor = SDL_MapRGBA(f, 0,0,0,255);\n\tbreak;\n case TREE:\n\tcolor = SDL_MapRGBA(f, 0,255,0,255);\n\tbreak;\n case BURNING:\n\tcolor = SDL_MapRGBA(f, 255,0,0,255);\n\tbreak;\n }\n *(uint32_t*)(pixels + j*s->pitch + i*(BPP>>3)) = color;\n }\n }\n pthread_mutex_unlock(&synclock);\n}\n\nint main(int argc, char **argv)\n{\n SDL_Surface *scr = NULL;\n SDL_Event event[1];\n bool quit = false, running = false;\n SDL_TimerID tid;\n\n \n srand(time(NULL));\n\n \n \n \n double *p;\n for(argv++, argc--; argc > 0; argc--, argv++)\n {\n if ( strcmp(*argv, \"prob_f\") == 0 && argc > 1 )\n {\n p = &prob_f;\n } else if ( strcmp(*argv, \"prob_p\") == 0 && argc > 1 ) {\n p = &prob_p;\n } else if ( strcmp(*argv, \"prob_tree\") == 0 && argc > 1 ) {\n p = &prob_tree;\n } else continue;\n\n\n argv++; argc--;\n char *s = NULL;\n double t = strtod(*argv, &s);\n if (s != *argv) *p = t;\n }\n\n printf(\"prob_f %lf\\nprob_p %lf\\nratio %lf\\nprob_tree %lf\\n\", \n\t prob_f, prob_p, prob_p\/prob_f,\n\t prob_tree);\n\n if ( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) != 0 ) return EXIT_FAILURE;\n atexit(SDL_Quit);\n\n field[0] = malloc(WIDTH*HEIGHT);\n if (field[0] == NULL) exit(EXIT_FAILURE);\n field[1] = malloc(WIDTH*HEIGHT);\n if (field[1] == NULL) { free(field[0]); exit(EXIT_FAILURE); }\n\n scr = SDL_SetVideoMode(WIDTH, HEIGHT, BPP, SDL_HWSURFACE|SDL_DOUBLEBUF);\n if (scr == NULL) {\n fprintf(stderr, \"SDL_SetVideoMode: %s\\n\", SDL_GetError());\n free(field[0]); free(field[1]);\n exit(EXIT_FAILURE);\n }\n\n init_field();\n\n tid = SDL_AddTimer(TIMERFREQ, simulate, NULL); \n running = true;\n\n event->type = SDL_VIDEOEXPOSE;\n SDL_PushEvent(event);\n\n while(SDL_WaitEvent(event) && !quit)\n {\n switch(event->type)\n {\n case SDL_VIDEOEXPOSE:\n while(SDL_LockSurface(scr) != 0) SDL_Delay(1);\n show(scr);\n SDL_UnlockSurface(scr);\n SDL_Flip(scr);\n event->type = SDL_VIDEOEXPOSE;\n SDL_PushEvent(event);\n break;\n case SDL_KEYDOWN:\n switch(event->key.keysym.sym)\n {\n case SDLK_q:\n\tquit = true;\n\tbreak;\n case SDLK_p:\n\tif (running)\n\t{\n\t running = false;\n\t pthread_mutex_lock(&synclock);\n\t SDL_RemoveTimer(tid); \n\t pthread_mutex_unlock(&synclock);\n\t} else {\n\t running = true;\n\t tid = SDL_AddTimer(TIMERFREQ, simulate, NULL);\n\t \n\t}\n\tbreak;\n }\n case SDL_QUIT:\n quit = true;\n break;\n }\n }\n\n if (running) {\n pthread_mutex_lock(&synclock);\n SDL_RemoveTimer(tid);\n pthread_mutex_unlock(&synclock);\n }\n free(field[0]); free(field[1]);\n exit(EXIT_SUCCESS);\n}\n","Rust":"extern crate rand;\nextern crate ansi_term;\n\n#[derive(Copy, Clone, PartialEq)]\nenum Tile {\n Empty,\n Tree,\n Burning,\n Heating,\n}\n\nimpl fmt::Display for Tile {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n let output = match *self {\n Empty => Black.paint(\" \"),\n Tree => Green.bold().paint(\"T\"),\n Burning => Red.bold().paint(\"B\"),\n Heating => Yellow.bold().paint(\"T\"),\n };\n write!(f, \"{}\", output)\n }\n}\n\n\n\ntrait Contains {\n fn contains(&self, T) -> bool;\n}\n\nimpl Contains for std::ops::Range {\n fn contains(&self, elt: T) -> bool {\n self.start <= elt && elt < self.end\n }\n}\n\nconst NEW_TREE_PROB: f32 = 0.01;\nconst INITIAL_TREE_PROB: f32 = 0.5;\nconst FIRE_PROB: f32 = 0.001;\n\nconst FOREST_WIDTH: usize = 60;\nconst FOREST_HEIGHT: usize = 30;\n\nconst SLEEP_MILLIS: u64 = 25;\n\nuse std::fmt;\nuse std::io;\nuse std::io::prelude::*;\nuse std::io::BufWriter;\nuse std::io::Stdout;\nuse std::process::Command;\nuse std::time::Duration;\nuse rand::Rng;\nuse ansi_term::Colour::*;\n\nuse Tile::{Empty, Tree, Burning, Heating};\n\nfn main() {\n let sleep_duration = Duration::from_millis(SLEEP_MILLIS);\n let mut forest = [[Tile::Empty; FOREST_WIDTH]; FOREST_HEIGHT];\n\n prepopulate_forest(&mut forest);\n print_forest(forest, 0);\n\n std::thread::sleep(sleep_duration);\n\n for generation in 1.. {\n\n for row in forest.iter_mut() {\n for tile in row.iter_mut() {\n update_tile(tile);\n }\n }\n\n for y in 0..FOREST_HEIGHT {\n for x in 0..FOREST_WIDTH {\n if forest[y][x] == Burning {\n heat_neighbors(&mut forest, y, x);\n }\n }\n }\n\n print_forest(forest, generation);\n\n std::thread::sleep(sleep_duration);\n }\n}\n\nfn prepopulate_forest(forest: &mut [[Tile; FOREST_WIDTH]; FOREST_HEIGHT]) {\n for row in forest.iter_mut() {\n for tile in row.iter_mut() {\n *tile = if prob_check(INITIAL_TREE_PROB) {\n Tree\n } else {\n Empty\n };\n }\n }\n}\n\nfn update_tile(tile: &mut Tile) {\n *tile = match *tile {\n Empty => {\n if prob_check(NEW_TREE_PROB) == true {\n Tree\n } else {\n Empty\n }\n }\n Tree => {\n if prob_check(FIRE_PROB) == true {\n Burning\n } else {\n Tree\n }\n }\n Burning => Empty,\n Heating => Burning,\n }\n}\n\nfn heat_neighbors(forest: &mut [[Tile; FOREST_WIDTH]; FOREST_HEIGHT], y: usize, x: usize) {\n let neighbors = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)];\n\n for &(xoff, yoff) in neighbors.iter() {\n let nx: i32 = (x as i32) + xoff;\n let ny: i32 = (y as i32) + yoff;\n if (0..FOREST_WIDTH as i32).contains(nx) && (0..FOREST_HEIGHT as i32).contains(ny) &&\n forest[ny as usize][nx as usize] == Tree {\n forest[ny as usize][nx as usize] = Heating\n }\n }\n}\n\nfn prob_check(chance: f32) -> bool {\n let roll = rand::thread_rng().gen::();\n if chance - roll > 0.0 {\n true\n } else {\n false\n }\n}\n\nfn print_forest(forest: [[Tile; FOREST_WIDTH]; FOREST_HEIGHT], generation: u32) {\n let mut writer = BufWriter::new(io::stdout());\n clear_screen(&mut writer);\n writeln!(writer, \"Generation: {}\", generation + 1).unwrap();\n for row in forest.iter() {\n for tree in row.iter() {\n write!(writer, \"{}\", tree).unwrap();\n }\n writer.write(b\"\\n\").unwrap();\n }\n}\n\nfn clear_screen(writer: &mut BufWriter) {\n let output = Command::new(\"clear\").output().unwrap();\n write!(writer, \"{}\", String::from_utf8_lossy(&output.stdout)).unwrap();\n}\n"} {"name":"Fork","C":"#include \n#include \n#include \n#include \n#include \n\nint main()\n{\n\tpid_t pid;\n\n\tif (!(pid = fork())) {\n\t\tusleep(10000);\n\t\tprintf(\"\\tchild process: done\\n\");\n\t} else if (pid < 0) {\n\t\terr(1, \"fork error\");\n\t} else {\n\t\tprintf(\"waiting for child %d...\\n\", (int)pid);\n\t\tprintf(\"child %d finished\\n\", (int)wait(0));\n\t}\n\n\treturn 0;\n}\n","Rust":"use nix::unistd::{fork, ForkResult};\nuse std::process::id;\n\nfn main() {\n match fork() {\n Ok(ForkResult::Parent { child, .. }) => {\n println!(\n \"This is the original process(pid: {}). New child has pid: {}\",\n id(),\n child\n );\n }\n Ok(ForkResult::Child) => println!(\"This is the new process(pid: {}).\", id()),\n Err(_) => println!(\"Something went wrong.\"),\n }\n}\n"} {"name":"Formatted numeric output","C":"#include \nmain(){\n float r=7.125;\n printf(\" %9.3f\\n\",-r);\n printf(\" %9.3f\\n\",r);\n printf(\"\u00a0%-9.3f\\n\",r);\n printf(\" %09.3f\\n\",-r);\n printf(\" %09.3f\\n\",r);\n printf(\"\u00a0%-09.3f\\n\",r);\n return 0;\n}\n","Rust":"fn main() {\n let x = 7.125;\n\n println!(\"{:9}\", x);\n println!(\"{:09}\", x);\n println!(\"{:9}\", -x);\n println!(\"{:09}\", -x);\n}\n"} {"name":"Forward difference","C":"#include \n#include \n#include \n\ndouble* fwd_diff(double* x, unsigned int len, unsigned int order)\n{\n\tunsigned int i, j;\n\tdouble* y;\n\n\t\n\tif (order >= len) return 0;\n\n\ty = malloc(sizeof(double) * len);\n\tif (!order) {\n\t\tmemcpy(y, x, sizeof(double) * len);\n\t\treturn y;\n\t}\n\n\t\n\tfor (j = 0; j < order; j++, x = y)\n\t\tfor (i = 0, len--; i < len; i++)\n\t\t\ty[i] = x[i + 1] - x[i];\n\n\ty = realloc(y, sizeof(double) * len);\n\treturn y;\n}\n\nint main(void)\n{\n\tdouble *y, x[] = {90, 47, 58, 29, 22, 32, 55, 5, 55, 73};\n\tint i, len = sizeof(x) \/ sizeof(x[0]);\n\n\ty = fwd_diff(x, len, 1);\n\tfor (i = 0; i < len - 1; i++)\n\t\tprintf(\"%g \", y[i]);\n\tputchar('\\n');\n\n\treturn 0;\n}\n","Rust":"fn forward_difference(input_seq: Vec, order: u32) -> Vec {\n match order {\n 0 => input_seq,\n 1 => {\n let input_seq_iter = input_seq.into_iter();\n let clone_of_input_seq_iter = input_seq_iter.clone();\n input_seq_iter.zip(clone_of_input_seq_iter.skip(1)).map(|(current, next)| next - current).collect()\n },\n _ => forward_difference(forward_difference(input_seq, order - 1), 1),\n }\n}\n\nfn main() {\n let mut sequence = vec![90, 47, 58, 29, 22, 32, 55, 5, 55, 73];\n loop {\n println!(\"{:?}\", sequence);\n sequence = forward_difference(sequence, 1);\n if sequence.is_empty() {\n break;\n }\n }\n}\n"} {"name":"Four bit adder","C":"#include \n\ntypedef char pin_t;\n#define IN const pin_t *\n#define OUT pin_t *\n#define PIN(X) pin_t _##X; pin_t *X = & _##X;\n#define V(X) (*(X))\n\n\n#define NOT(X) (~(X)&1)\n\n\n#define XOR(X,Y) ((NOT(X)&(Y)) | ((X)&NOT(Y)))\n\nvoid halfadder(IN a, IN b, OUT s, OUT c)\n{\n V(s) = XOR(V(a), V(b));\n V(c) = V(a) & V(b);\n}\n\nvoid fulladder(IN a, IN b, IN ic, OUT s, OUT oc)\n{\n PIN(ps); PIN(pc); PIN(tc);\n\n halfadder(a, b, ps, pc);\n halfadder(ps, ic, s, tc);\n V(oc) = V(tc) | V(pc);\n}\n\nvoid fourbitsadder(IN a0, IN a1, IN a2, IN a3,\n\t\t IN b0, IN b1, IN b2, IN b3,\n\t\t OUT o0, OUT o1, OUT o2, OUT o3,\n\t\t OUT overflow)\n{\n PIN(zero); V(zero) = 0;\n PIN(tc0); PIN(tc1); PIN(tc2);\n\n fulladder(a0, b0, zero, o0, tc0);\n fulladder(a1, b1, tc0, o1, tc1);\n fulladder(a2, b2, tc1, o2, tc2);\n fulladder(a3, b3, tc2, o3, overflow);\n}\n\n\nint main()\n{\n PIN(a0); PIN(a1); PIN(a2); PIN(a3);\n PIN(b0); PIN(b1); PIN(b2); PIN(b3);\n PIN(s0); PIN(s1); PIN(s2); PIN(s3);\n PIN(overflow);\n\n V(a3) = 0; V(b3) = 1;\n V(a2) = 0; V(b2) = 1;\n V(a1) = 1; V(b1) = 1;\n V(a0) = 0; V(b0) = 0;\n\n fourbitsadder(a0, a1, a2, a3, \n\t\tb0, b1, b2, b3,\n\t\ts0, s1, s2, s3, \n\t\toverflow);\n\n printf(\"%d%d%d%d + %d%d%d%d = %d%d%d%d, overflow = %d\\n\",\n\t V(a3), V(a2), V(a1), V(a0),\n\t V(b3), V(b2), V(b1), V(b0),\n\t V(s3), V(s2), V(s1), V(s0),\n\t V(overflow));\n \n return 0;\n}\n","Rust":"\n\n\nfn half_adder(a: usize, b: usize) -> (usize, usize) {\n return (a ^ b, a & b);\n}\n\n\n\n\nfn full_adder(a: usize, b: usize, c_in: usize) -> (usize, usize) {\n let (s0, c0) = half_adder(a, b);\n let (s1, c1) = half_adder(s0, c_in);\n return (s1, c0 | c1);\n}\n\n\n\n\nfn four_bit_adder (\n a: (usize, usize, usize, usize),\n b: (usize, usize, usize, usize)\n)\n ->\n \n (usize, usize, usize, usize)\n{\n \n let a = a.reverse();\n let b = b.reverse();\n\n \n \n let (sum, carry) = half_adder(a.0, b.0);\n let out0 = sum;\n let (sum, carry) = full_adder(a.1, b.1, carry);\n let out1 = sum;\n let (sum, carry) = full_adder(a.2, b.2, carry);\n let out2 = sum;\n let (sum, _) = full_adder(a.3, b.3, carry);\n let out3 = sum;\n return (out3, out2, out1, out0);\n}\n\nfn main() {\n let a: (usize, usize, usize, usize) = (0, 1, 1, 0);\n let b: (usize, usize, usize, usize) = (0, 1, 1, 0);\n assert_eq!(four_bit_adder(a, b), (1, 1, 0, 0));\n \n \n}\n\n\ntrait Reverse {\n fn reverse(self) -> (D, C, B, A);\n}\n\n\nimpl Reverse for (A, B, C, D) {\n fn reverse(self) -> (D, C, B, A){\n return (self.3, self.2, self.1, self.0)\n }\n}\n"} {"name":"Function composition","C":"#include \n\n\ntypedef struct double_to_double {\n double (*fn)(struct double_to_double *, double);\n} double_to_double;\n\n#define CALL(f, x) f->fn(f, x)\n\n\n\ntypedef struct compose_functor {\n double (*fn)(struct compose_functor *, double);\n double_to_double *f;\n double_to_double *g;\n} compose_functor;\n\ndouble compose_call(compose_functor *this, double x) {\n return CALL(this->f, CALL(this->g, x));\n}\n\ndouble_to_double *compose(double_to_double *f,\n double_to_double *g) {\n compose_functor *result = malloc(sizeof(compose_functor));\n result->fn = &compose_call;\n result->f = f;\n result->g = g;\n return (double_to_double *)result;\n}\n\n\n\n#include \n\n\ndouble sin_call(double_to_double *this, double x) {\n return sin(x);\n}\ndouble asin_call(double_to_double *this, double x) {\n return asin(x);\n}\n\n\n\n#include \n\nint main() {\n double_to_double *my_sin = malloc(sizeof(double_to_double));\n my_sin->fn = &sin_call;\n double_to_double *my_asin = malloc(sizeof(double_to_double));\n my_asin->fn = &asin_call;\n\n double_to_double *sin_asin = compose(my_sin, my_asin);\n\n printf(\"%f\\n\", CALL(sin_asin, 0.5)); \n\n free(sin_asin);\n free(my_sin);\n free(my_asin);\n\n return 0;\n}\n","Rust":"fn compose<'a,F,G,T,U,V>(f: F, g: G) -> Box V + 'a>\n where F: Fn(U) -> V + 'a,\n G: Fn(T) -> U + 'a,\n{\n Box::new(move |x| f(g(x)))\n}\n"} {"name":"Fusc sequence","C":"#include\n#include\n\nint fusc(int n){\n if(n==0||n==1)\n return n;\n else if(n%2==0)\n return fusc(n\/2);\n else\n return fusc((n-1)\/2) + fusc((n+1)\/2);\n}\n\nint numLen(int n){\n int sum = 1;\n\n while(n>9){\n n = n\/10;\n sum++;\n }\n\n return sum;\n}\n\nvoid printLargeFuscs(int limit){\n int i,f,len,maxLen = 1;\n\n printf(\"\\n\\nPrinting all largest Fusc numbers upto %d \\nIndex-------Value\",limit);\n\n for(i=0;i<=limit;i++){\n f = fusc(i);\n len = numLen(f);\n\n if(len>maxLen){\n maxLen = len;\n printf(\"\\n%5d%12d\",i,f);\n }\n }\n}\n\n\nint main()\n{\n int i;\n\n printf(\"Index-------Value\");\n for(i=0;i<61;i++)\n printf(\"\\n%5d%12d\",i,fusc(i));\n printLargeFuscs(INT_MAX);\n return 0;\n}\n","Rust":"fn fusc_sequence() -> impl std::iter::Iterator {\n let mut sequence = vec![0, 1];\n let mut n = 0;\n std::iter::from_fn(move || {\n if n > 1 {\n sequence.push(match n % 2 {\n 0 => sequence[n \/ 2],\n _ => sequence[(n - 1) \/ 2] + sequence[(n + 1) \/ 2],\n });\n }\n let result = sequence[n];\n n += 1;\n Some(result)\n })\n}\n\nfn main() {\n println!(\"First 61 fusc numbers:\");\n for n in fusc_sequence().take(61) {\n print!(\"{} \", n)\n }\n println!();\n\n let limit = 1000000000;\n println!(\n \"Fusc numbers up to {} that are longer than any previous one:\",\n limit\n );\n let mut max = 0;\n for (index, n) in fusc_sequence().take(limit).enumerate() {\n if n >= max {\n max = std::cmp::max(10, max * 10);\n println!(\"index = {}, fusc number = {}\", index, n);\n }\n }\n}\n"} {"name":"Gaussian elimination","C":"#include \n#include \n#include \n\n#define mat_elem(a, y, x, n) (a + ((y) * (n) + (x)))\n\nvoid swap_row(double *a, double *b, int r1, int r2, int n)\n{\n\tdouble tmp, *p1, *p2;\n\tint i;\n\n\tif (r1 == r2) return;\n\tfor (i = 0; i < n; i++) {\n\t\tp1 = mat_elem(a, r1, i, n);\n\t\tp2 = mat_elem(a, r2, i, n);\n\t\ttmp = *p1, *p1 = *p2, *p2 = tmp;\n\t}\n\ttmp = b[r1], b[r1] = b[r2], b[r2] = tmp;\n}\n\nvoid gauss_eliminate(double *a, double *b, double *x, int n)\n{\n#define A(y, x) (*mat_elem(a, y, x, n))\n\tint i, j, col, row, max_row,dia;\n\tdouble max, tmp;\n\n\tfor (dia = 0; dia < n; dia++) {\n\t\tmax_row = dia, max = A(dia, dia);\n\n\t\tfor (row = dia + 1; row < n; row++)\n\t\t\tif ((tmp = fabs(A(row, dia))) > max)\n\t\t\t\tmax_row = row, max = tmp;\n\n\t\tswap_row(a, b, dia, max_row, n);\n\n\t\tfor (row = dia + 1; row < n; row++) {\n\t\t\ttmp = A(row, dia) \/ A(dia, dia);\n\t\t\tfor (col = dia+1; col < n; col++)\n\t\t\t\tA(row, col) -= tmp * A(dia, col);\n\t\t\tA(row, dia) = 0;\n\t\t\tb[row] -= tmp * b[dia];\n\t\t}\n\t}\n\tfor (row = n - 1; row >= 0; row--) {\n\t\ttmp = b[row];\n\t\tfor (j = n - 1; j > row; j--)\n\t\t\ttmp -= x[j] * A(row, j);\n\t\tx[row] = tmp \/ A(row, row);\n\t}\n#undef A\n}\n\nint main(void)\n{\n\tdouble a[] = {\n\t\t1.00, 0.00, 0.00, 0.00, 0.00, 0.00,\n\t\t1.00, 0.63, 0.39, 0.25, 0.16, 0.10,\n\t\t1.00, 1.26, 1.58, 1.98, 2.49, 3.13,\n\t\t1.00, 1.88, 3.55, 6.70, 12.62, 23.80,\n\t\t1.00, 2.51, 6.32, 15.88, 39.90, 100.28,\n\t\t1.00, 3.14, 9.87, 31.01, 97.41, 306.02\n\t};\n\tdouble b[] = { -0.01, 0.61, 0.91, 0.99, 0.60, 0.02 };\n\tdouble x[6];\n\tint i;\n\n\tgauss_eliminate(a, b, x, 6);\n\n\tfor (i = 0; i < 6; i++)\n\t\tprintf(\"%g\\n\", x[i]);\n\n\treturn 0;\n}\n","Rust":"\n\n\nconst SIZE: usize = 6;\n\npub fn eliminate(mut system: [[f32; SIZE+1]; SIZE]) -> Option> {\n \n \n \n for i in 0..SIZE-1 {\n \n for j in i..SIZE-1 {\n if system[i][i] == 0f32 {\n continue;\n } else {\n \n let factor = system[j + 1][i] as f32 \/ system[i][i] as f32;\n for k in i..SIZE+1 {\n \n \n system[j + 1][k] -= factor * system[i][k] as f32;\n }\n }\n }\n }\n\n \n \n \n \n \n for i in (1..SIZE).rev() {\n if system[i][i] == 0f32 {\n continue;\n } else {\n for j in (1..i+1).rev() {\n let factor = system[j - 1][i] as f32 \/ system[i][i] as f32;\n for k in (0..SIZE+1).rev() {\n system[j - 1][k] -= factor * system[i][k] as f32;\n }\n }\n }\n }\n\n \n let mut solutions: Vec = vec![];\n for i in 0..SIZE {\n if system[i][i] == 0f32 {\n return None;\n }\n else {\n system[i][SIZE] \/= system[i][i] as f32;\n system[i][i] = 1f32;\n println!(\"X{} = {}\", i + 1, system[i][SIZE]);\n solutions.push(system[i][SIZE])\n }\n }\n return Some(solutions);\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n \n #[test]\n fn eliminate_seven_by_six() {\n let system: [[f32; SIZE +1]; SIZE] = [\n [1.00 , 0.00 , 0.00 , 0.00 , 0.00 , 0.00 , -0.01 ] ,\n [1.00 , 0.63 , 0.39 , 0.25 , 0.16 , 0.10 , 0.61 ] ,\n [1.00 , 1.26 , 1.58 , 1.98 , 2.49 , 3.13 , 0.91 ] ,\n [1.00 , 1.88 , 3.55 , 6.70 , 12.62 , 23.80 , 0.99 ] ,\n [1.00 , 2.51 , 6.32 , 15.88 , 39.90 , 100.28 , 0.60 ] ,\n [1.00 , 3.14 , 9.87 , 31.01 , 97.41 , 306.02 , 0.02 ]\n ] ;\n let solutions = eliminate(system).unwrap();\n assert_eq!(6, solutions.len());\n let assert_solns = vec![-0.01, 1.60278, -1.61320, 1.24549, -0.49098, 0.06576];\n for (ans, key) in solutions.iter().zip(assert_solns.iter()) {\n if (ans - key).abs() > 1E-4 { panic!(\"Test Failed!\") }\n }\n }\n}\n"} {"name":"General FizzBuzz","C":"#include \n#include \n\nstruct replace_info {\n int n;\n char *text;\n};\n\nint compare(const void *a, const void *b)\n{\n struct replace_info *x = (struct replace_info *) a;\n struct replace_info *y = (struct replace_info *) b;\n return x->n - y->n;\n}\n\nvoid generic_fizz_buzz(int max, struct replace_info *info, int info_length)\n{\n int i, it;\n int found_word;\n\n for (i = 1; i < max; ++i) {\n found_word = 0;\n\n \n for (it = 0; it < info_length; ++it) {\n if (0 == i % info[it].n) {\n printf(\"%s\", info[it].text);\n found_word = 1;\n }\n }\n\n if (0 == found_word)\n printf(\"%d\", i);\n\n printf(\"\\n\");\n }\n}\n\nint main(void)\n{\n struct replace_info info[3] = {\n {5, \"Buzz\"},\n {7, \"Baxx\"},\n {3, \"Fizz\"}\n };\n\n \n qsort(info, 3, sizeof(struct replace_info), compare);\n\n \n generic_fizz_buzz(20, info, 3);\n return 0;\n}\n","Rust":"use std::io;\nuse std::io::BufRead;\n\nfn parse_entry(l: &str) -> (i32, String) {\n let params: Vec<&str> = l.split(' ').collect();\n\n let divisor = params[0].parse::().unwrap();\n let word = params[1].to_string();\n (divisor, word)\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines().map(|l| l.unwrap());\n\n let l = lines.next().unwrap();\n let high = l.parse::().unwrap();\n\n let mut entries = Vec::new();\n for l in lines {\n if &l == \"\" { break }\n let entry = parse_entry(&l);\n entries.push(entry);\n }\n\n for i in 1..(high + 1) {\n let mut line = String::new();\n for &(divisor, ref word) in &entries {\n if i % divisor == 0 {\n line = line + &word;\n }\n }\n if line == \"\" {\n println!(\"{}\", i);\n } else {\n println!(\"{}\", line);\n }\n }\n}\n"} {"name":"Generate lower case ASCII alphabet","C":"#include \n\n#define N 26\n\nint main() {\n unsigned char lower[N];\n\n for (size_t i = 0; i < N; i++) {\n lower[i] = i + 'a';\n }\n\n return EXIT_SUCCESS;\n}\n","Rust":"fn main() {\n \n let ascii_iter = (0..26)\n .map(|x| (x + b'a') as char);\n \n println!(\"{:?}\", ascii_iter.collect::>());\n}\n"} {"name":"Generator_Exponential","C":"#include \t\n#include \t\n#include \t\n\n#include \t\n\n\n\n\nstruct gen64 {\n\tcothread_t giver;\t\n\tcothread_t taker;\t\n\tint64_t given;\n\tvoid (*free)(struct gen64 *);\n\tvoid *garbage;\n};\n\n\ninline void\nyield64(struct gen64 *gen, int64_t value)\n{\n\tgen->given = value;\n\tco_switch(gen->taker);\n}\n\n\ninline int64_t\nnext64(struct gen64 *gen)\n{\n\tgen->taker = co_active();\n\tco_switch(gen->giver);\n\treturn gen->given;\n}\n\nstatic void\ngen64_free(struct gen64 *gen)\n{\n\tco_delete(gen->giver);\n}\n\nstruct gen64 *entry64;\n\n\ninline void\ngen64_init(struct gen64 *gen, void (*entry)(void))\n{\n\tif ((gen->giver = co_create(4096, entry)) == NULL) {\n\t\t\n\t\tfputs(\"co_create: Cannot create cothread\\n\", stderr);\n\t\texit(1);\n\t}\n\tgen->free = gen64_free;\n\tentry64 = gen;\n}\n\n\n\n\nvoid\npowers(struct gen64 *gen, int64_t m)\n{\n\tint64_t base, exponent, n, result;\n\n\tfor (n = 0;; n++) {\n\t\t\n\t\tbase = n;\n\t\texponent = m;\n\t\tfor (result = 1; exponent != 0; exponent >>= 1) {\n\t\t\tif (exponent & 1) result *= base;\n\t\t\tbase *= base;\n\t\t}\n\t\tyield64(gen, result);\n\t}\n\t\n}\n\n\n#define ENTRY(name, code) static void name(void) { code; }\nENTRY(enter_squares, powers(entry64, 2))\nENTRY(enter_cubes, powers(entry64, 3))\n\nstruct swc {\n\tstruct gen64 cubes;\n\tstruct gen64 squares;\n\tvoid (*old_free)(struct gen64 *);\n};\n\nstatic void\nswc_free(struct gen64 *gen)\n{\n\tstruct swc *f = gen->garbage;\n\tf->cubes.free(&f->cubes);\n\tf->squares.free(&f->squares);\n\tf->old_free(gen);\n}\n\n\nvoid\nsquares_without_cubes(struct gen64 *gen)\n{\n\tstruct swc f;\n\tint64_t c, s;\n\n\tgen64_init(&f.cubes, enter_cubes);\n\tc = next64(&f.cubes);\n\n\tgen64_init(&f.squares, enter_squares);\n\ts = next64(&f.squares);\n\n\t\n\tf.old_free = gen->free;\n\tgen->garbage = &f;\n\tgen->free = swc_free;\n\n\tfor (;;) {\n\t\twhile (c < s)\n\t\t\tc = next64(&f.cubes);\n\t\tif (c != s)\n\t\t\tyield64(gen, s);\n\t\ts = next64(&f.squares);\n\t}\n\t\n}\n\nENTRY(enter_squares_without_cubes, squares_without_cubes(entry64))\n\n\nint\nmain()\n{\n\tstruct gen64 gen;\n\tint i;\n\n\tgen64_init(&gen, enter_squares_without_cubes);\n\n\tfor (i = 0; i < 20; i++)\n\t\tnext64(&gen);\n\tfor (i = 0; i < 9; i++)\n\t\tprintf(\"%\" PRId64 \", \", next64(&gen));\n\tprintf(\"%\" PRId64 \"\\n\", next64(&gen));\n\n\tgen.free(&gen); \n\treturn 0;\n}\n","Rust":"use std::cmp::Ordering;\nuse std::iter::Peekable;\n\nfn powers(m: u32) -> impl Iterator {\n (0u64..).map(move |x| x.pow(m))\n}\n\nfn noncubic_squares() -> impl Iterator {\n NoncubicSquares {\n squares: powers(2).peekable(),\n cubes: powers(3).peekable(),\n }\n}\n\nstruct NoncubicSquares, U: Iterator> {\n squares: Peekable,\n cubes: Peekable,\n}\n\nimpl, U: Iterator> Iterator for NoncubicSquares {\n type Item = u64;\n fn next(&mut self) -> Option {\n loop {\n match self.squares.peek()?.cmp(self.cubes.peek()?) {\n Ordering::Equal => self.squares.next(),\n Ordering::Greater => self.cubes.next(),\n Ordering::Less => return self.squares.next(),\n };\n }\n }\n}\n\nfn main() {\n noncubic_squares()\n .skip(20)\n .take(10)\n .for_each(|x| print!(\"{} \", x));\n println!();\n}\n"} {"name":"Generic swap","C":"void swap(void *va, void *vb, size_t s)\n{\n char t, *a = (char*)va, *b = (char*)vb;\n while(s--)\n t = a[s], a[s] = b[s], b[s] = t;\n}\n","Rust":"fn generic_swap<'a, T>(var1: &'a mut T, var2: &'a mut T) {\n std::mem::swap(var1, var2)\n}\n"} {"name":"Get system command output","C":"#include \n#include \n#include \n\nint main(int argc, char **argv)\n{\n if (argc < 2) return 1;\n\n FILE *fd;\n fd = popen(argv[1], \"r\");\n if (!fd) return 1;\n\n char buffer[256];\n size_t chread;\n \n size_t comalloc = 256;\n size_t comlen = 0;\n char *comout = malloc(comalloc);\n\n \n while ((chread = fread(buffer, 1, sizeof(buffer), fd)) != 0) {\n if (comlen + chread >= comalloc) {\n comalloc *= 2;\n comout = realloc(comout, comalloc);\n }\n memmove(comout + comlen, buffer, chread);\n comlen += chread;\n }\n\n \n fwrite(comout, 1, comlen, stdout);\n free(comout);\n pclose(fd);\n return 0;\n}\n","Rust":"use std::process::Command;\nuse std::io::{Write, self};\n\nfn main() {\n let output = Command::new(\"\/bin\/cat\")\n .arg(\"\/etc\/fstab\")\n .output()\n .expect(\"failed to execute process\");\n\n io::stdout().write(&output.stdout);\n}\n"} {"name":"Globally replace text in several files","C":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nchar * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)\n{\n\tptrdiff_t i;\n\tchar *start = buf;\n\twhile (start + len < buf_end) {\n\t\tfor (i = 0; i < len; i++)\n\t\t\tif (start[i] != pat[i]) break;\n\n\t\tif (i == len) return (char *)start;\n\t\tstart++;\n\t}\n\treturn 0;\n}\n\nint replace(const char *from, const char *to, const char *fname)\n{\n#define bail(msg) { warn(msg\" '%s'\", fname); goto done; }\n\tstruct stat st;\n\tint ret = 0;\n\tchar *buf = 0, *start, *end;\n\tsize_t len = strlen(from), nlen = strlen(to);\n\tint fd = open(fname, O_RDWR);\n\n\tif (fd == -1) bail(\"Can't open\");\n\tif (fstat(fd, &st) == -1) bail(\"Can't stat\");\n\tif (!(buf = malloc(st.st_size))) bail(\"Can't alloc\");\n\tif (read(fd, buf, st.st_size) != st.st_size) bail(\"Bad read\");\n\n\tstart = buf;\n\tend = find_match(start, buf + st.st_size, from, len);\n\tif (!end) goto done; \n\n\tftruncate(fd, 0);\n\tlseek(fd, 0, 0);\n\tdo {\n\t\twrite(fd, start, end - start);\t\n\t\twrite(fd, to, nlen);\t\t\n\t\tstart = end + len;\t\t\n\t\t\t\t\t\t\n\t\tend = find_match(start, buf + st.st_size, from, len);\n\t} while (end);\n\n\t\n\tif (start < buf + st.st_size)\n\t\twrite(fd, start, buf + st.st_size - start);\n\ndone:\n\tif (fd != -1) close(fd);\n\tif (buf) free(buf);\n\treturn ret;\n}\n\nint main()\n{\n\tconst char *from = \"Goodbye, London!\";\n\tconst char *to = \"Hello, New York!\";\n\tconst char * files[] = { \"test1.txt\", \"test2.txt\", \"test3.txt\" };\n\tint i;\n\n\tfor (i = 0; i < sizeof(files)\/sizeof(char*); i++)\n\t\treplace(from, to, files[i]);\n\n\treturn 0;\n}\n","Rust":"\n\n\nuse std::fs::File;\nuse std::fs::OpenOptions;\nuse std::io::BufRead;\nuse std::io::BufReader;\nuse std::io::BufWriter;\nuse std::io::Write;\n\nfn main() {\n \n let out_fd = OpenOptions::new()\n .write(true)\n .create(true)\n .open(\"resources\/output.txt\");\n\n \n let write_line = |line: &str| match out_fd {\n Ok(ref v) => {\n let mut writer = BufWriter::new(v);\n writer.write_all(line.as_bytes()).unwrap();\n }\n Err(ref e) => {\n println!(\"Error:{}\", e);\n }\n };\n \n match File::open(\"resources\/paragraph.txt\") {\n Ok(handle) => {\n let mut reader = BufReader::new(handle);\n let mut line = String::new();\n \n reader.read_line(&mut line).unwrap();\n \n while line.trim() != \"\" {\n let mut replaced_line = line.trim().replace(\"Goodbye London!\", \"Hello New York!\");\n replaced_line += \"\\n\";\n write_line(&replaced_line[..]);\n line.clear();\n reader.read_line(&mut line).unwrap();\n }\n }\n Err(e) => println!(\"Error:{}\", e),\n }\n}\n"} {"name":"Greatest common divisor","C":"int\ngcd_iter(int u, int v) {\n if (u < 0) u = -u;\n if (v < 0) v = -v;\n if (v) while ((u %= v) && (v %= u));\n return (u + v);\n}\n","Rust":"extern crate num;\nuse num::integer::gcd;\n"} {"name":"Greatest element of a list","C":"#include \n\nfloat max(unsigned int count, float values[]) {\n assert(count > 0);\n size_t idx;\n float themax = values[0];\n for(idx = 1; idx < count; ++idx) {\n themax = values[idx] > themax ? values[idx] : themax;\n }\n return themax;\n}\n","Rust":"fn main() {\n let nums = [1,2,39,34,20];\n println!(\"{:?}\", nums.iter().max());\n println!(\"{}\", nums.iter().max().unwrap());\n}\n"} {"name":"Greatest subsequential sum","C":"#include \"stdio.h\"\n\ntypedef struct Range {\n int start, end, sum;\n} Range;\n\nRange maxSubseq(const int sequence[], const int len) {\n int maxSum = 0, thisSum = 0, i = 0;\n int start = 0, end = -1, j;\n\n for (j = 0; j < len; j++) {\n thisSum += sequence[j];\n if (thisSum < 0) {\n i = j + 1;\n thisSum = 0;\n } else if (thisSum > maxSum) {\n maxSum = thisSum;\n start = i;\n end = j;\n }\n }\n\n Range r;\n if (start <= end && start >= 0 && end >= 0) {\n r.start = start;\n r.end = end + 1;\n r.sum = maxSum;\n } else {\n r.start = 0;\n r.end = 0;\n r.sum = 0;\n }\n return r;\n}\n\nint main(int argc, char **argv) {\n int a[] = {-1 , -2 , 3 , 5 , 6 , -2 , -1 , 4 , -4 , 2 , -1};\n int alength = sizeof(a)\/sizeof(a[0]);\n\n Range r = maxSubseq(a, alength);\n printf(\"Max sum = %d\\n\", r.sum);\n int i;\n for (i = r.start; i < r.end; i++)\n printf(\"%d \", a[i]);\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"fn main() {\n let nums = [1,2,39,34,20, -20, -16, 35, 0];\n\n let mut max = 0;\n let mut boundaries = 0..0;\n\n for length in 0..nums.len() {\n for start in 0..nums.len()-length {\n let sum = (&nums[start..start+length]).iter()\n .fold(0, |sum, elem| sum+elem);\n if sum > max {\n max = sum;\n boundaries = start..start+length;\n }\n }\n }\n\n println!(\"Max subsequence sum: {} for {:?}\", max, &nums[boundaries]);;\n}\n"} {"name":"Guess the number","C":"#include \n#include \n#include \n\nint main(void)\n{\n int n;\n int g;\n char c;\n\n srand(time(NULL));\n n = 1 + (rand() % 10);\n\n puts(\"I'm thinking of a number between 1 and 10.\");\n puts(\"Try to guess it:\");\n\n while (1) {\n if (scanf(\"%d\", &g) != 1) {\n\t\t\n\t\tscanf(\"%c\", &c);\n\t\tcontinue;\n\t}\n\n if (g == n) {\n\t puts(\"Correct!\");\n\t return 0;\n\t}\n puts(\"That's not my number. Try another guess:\");\n }\n}\n","Rust":"extern crate rand;\n\nfn main() {\n println!(\"Type in an integer between 1 and 10 and press enter.\");\n\n let n = rand::random::() % 10 + 1;\n loop {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let option: Result = line.trim().parse();\n match option {\n Ok(guess) => {\n if guess < 1 || guess > 10 {\n println!(\"Guess is out of bounds; try again.\");\n } else if guess == n {\n println!(\"Well guessed!\");\n break;\n } else {\n println!(\"Wrong! Try again.\");\n }\n },\n Err(_) => println!(\"Invalid input; try again.\")\n }\n }\n}\n"} {"name":"Guess the number_With feedback","C":"#include \n#include \n#include \n\n#define lower_limit 0\n#define upper_limit 100\n\nint main(){\n int number, guess;\n\n srand( time( 0 ) );\n number = lower_limit + rand() % (upper_limit - lower_limit + 1);\n\n printf( \"Guess the number between %d and %d: \", lower_limit, upper_limit );\n\n while( scanf( \"%d\", &guess ) == 1 ){\n if( number == guess ){\n printf( \"You guessed correctly!\\n\" );\n break;\n }\n printf( \"Your guess was too %s.\\nTry again: \", number < guess ? \"high\" : \"low\" );\n }\n\n return 0;\n}\n","Rust":"use rand::Rng;\nuse std::cmp::Ordering;\nuse std::io;\n\nconst LOWEST: u32 = 1;\nconst HIGHEST: u32 = 100;\n\nfn main() {\n let secret_number = rand::thread_rng().gen_range(1..101);\n\n println!(\"I have chosen my number between {} and {}. Guess the number!\", LOWEST, HIGHEST);\n\n loop {\n println!(\"Please input your guess.\");\n\n let mut guess = String::new();\n\n io::stdin()\n .read_line(&mut guess)\n .expect(\"Failed to read line\");\n\n let guess: u32 = match guess.trim().parse() {\n Ok(num) => num,\n Err(_) => continue,\n };\n\n println!(\"You guessed: {}\", guess);\n\n match guess.cmp(&secret_number) {\n Ordering::Less => println!(\"Too small!\"),\n Ordering::Greater => println!(\"Too big!\"),\n Ordering::Equal => {\n println!(\"You win!\");\n break;\n }\n }\n }\n}\n"} {"name":"Guess the number_With feedback (player)","C":"#include \n\nint main(){\n int bounds[ 2 ] = {1, 100};\n char input[ 2 ] = \" \";\n \n int choice = (bounds[ 0 ] + bounds[ 1 ]) \/ 2;\n \n\n printf( \"Choose a number between %d and %d.\\n\", bounds[ 0 ], bounds[ 1 ] );\n\n do{\n switch( input[ 0 ] ){\n case 'H':\n bounds[ 1 ] = choice;\n break;\n case 'L':\n bounds[ 0 ] = choice;\n break;\n case 'Y':\n printf( \"\\nAwwwright\\n\" );\n return 0;\n }\n choice = (bounds[ 0 ] + bounds[ 1 ]) \/ 2;\n\n printf( \"Is the number %d? (Y\/H\/L) \", choice );\n }while( scanf( \"%1s\", input ) == 1 );\n\n return 0;\n}\n","Rust":"use std::io::stdin;\n\nconst MIN: isize = 1;\nconst MAX: isize = 100;\n\nfn main() {\n loop {\n let mut min = MIN;\n let mut max = MAX;\n let mut num_guesses = 1;\n println!(\"Please think of a number between {} and {}\", min, max);\n loop {\n let guess = (min + max) \/ 2;\n println!(\"Is it {}?\", guess);\n println!(\"(type h if my guess is too high, l if too low, e if equal and q to quit)\");\n\n let mut line = String::new();\n stdin().read_line(&mut line).unwrap();\n match Some(line.chars().next().unwrap().to_uppercase().next().unwrap()) {\n Some('H') => {\n max = guess - 1;\n num_guesses += 1;\n },\n Some('L')=> {\n min = guess + 1;\n num_guesses += 1;\n },\n Some('E') => {\n if num_guesses == 1 {\n println!(\"\\n*** That was easy! Got it in one guess! ***\\n\");\n } else {\n println!(\"\\n*** I knew it! Got it in only {} guesses! ***\\n\", num_guesses);\n }\n break;\n },\n Some('Q') => return,\n _ => println!(\"Sorry, I didn't quite get that. Please try again.\")\n }\n }\n }\n}\n"} {"name":"HTTP","C":"#include \n#include \n#include \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, \"http:\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":"\n\nextern crate hyper;\n\nuse std::io::Read;\nuse hyper::client::Client;\n\nfn main() {\n let client = Client::new();\n let mut resp = client.get(\"http:\n let mut body = String::new();\n resp.read_to_string(&mut body).unwrap();\n println!(\"{}\", body);\n}\n"} {"name":"HTTPS","C":"#include \n#include \n#include \nCURL *curl;\nchar buffer[CURL_ERROR_SIZE];\nint main(void) {\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\nfn main() {\n let response = match reqwest::blocking::get(\"https:\n Ok(response) => response,\n Err(e) => panic!(\"error encountered while making request: {:?}\", e),\n };\n\n println!(\"{}\", response.text().unwrap());\n}\n"} {"name":"Hailstone sequence","C":"#include \n#include \n\nint hailstone(int n, int *arry)\n{\n int hs = 1;\n\n while (n!=1) {\n hs++;\n if (arry) *arry++ = n;\n n = (n&1) ? (3*n+1) : (n\/2);\n }\n if (arry) *arry++ = n;\n return hs;\n}\n\nint main()\n{\n int j, hmax = 0;\n int jatmax, n;\n int *arry;\n\n for (j=1; j<100000; j++) {\n n = hailstone(j, NULL);\n if (hmax < n) {\n hmax = n;\n jatmax = j;\n }\n }\n n = hailstone(27, NULL);\n arry = malloc(n*sizeof(int));\n n = hailstone(27, arry);\n\n printf(\"[ %d, %d, %d, %d, ...., %d, %d, %d, %d] len=%d\\n\",\n arry[0],arry[1],arry[2],arry[3],\n arry[n-4], arry[n-3], arry[n-2], arry[n-1], n);\n printf(\"Max %d at j= %d\\n\", hmax, jatmax);\n free(arry);\n\n return 0;\n}\n","Rust":"fn hailstone(start : u32) -> Vec {\n let mut res = Vec::new();\n let mut next = start;\n\n res.push(start);\n\n while next != 1 {\n next = if next % 2 == 0 { next\/2 } else { 3*next+1 };\n res.push(next);\n }\n res\n}\n\n \nfn main() {\n let test_num = 27;\n let test_hailseq = hailstone(test_num);\n\n println!(\"For {} number of elements is {} \", test_num, test_hailseq.len());\n\n let fst_slice = test_hailseq[0..4].iter()\n .fold(\"\".to_owned(), |acc, i| { acc + &*(i.to_string()).to_owned() + \", \" });\n let last_slice = test_hailseq[test_hailseq.len()-4..].iter()\n .fold(\"\".to_owned(), |acc, i| { acc + &*(i.to_string()).to_owned() + \", \" });\n \n println!(\" hailstone starting with {} ending with {} \", fst_slice, last_slice);\n\n let max_range = 100000;\n let mut max_len = 0;\n let mut max_seed = 0;\n for i_seed in 1..max_range {\n let i_len = hailstone(i_seed).len();\n\n if i_len > max_len {\n max_len = i_len;\n max_seed = i_seed;\n }\n }\n println!(\"Longest sequence is {} element long for seed {}\", max_len, max_seed);\n}\n"} {"name":"Halt and catch fire","C":"int main(){int a=0, b=0, c=a\/b;}\n","Rust":"fn main(){panic!(\"\");}\n"} {"name":"Hamming numbers","C":"#include \n#include \n\ntypedef unsigned long long ham;\n\nsize_t alloc = 0, n = 1;\nham *q = 0;\n\nvoid qpush(ham h)\n{\n\tint i, j;\n\tif (alloc <= n) {\n\t\talloc = alloc ? alloc * 2 : 16;\n\t\tq = realloc(q, sizeof(ham) * alloc);\n\t}\n\n\tfor (i = n++; (j = i\/2) && q[j] > h; q[i] = q[j], i = j);\n\tq[i] = h;\n}\n\nham qpop()\n{\n\tint i, j;\n\tham r, t;\n\t\n\tfor (r = q[1]; n > 1 && r == q[1]; q[i] = t) {\n\t\t\n\t\tfor (i = 1, t = q[--n]; (j = i * 2) < n;) {\n\t\t\tif (j + 1 < n && q[j] > q[j+1]) j++;\n\t\t\tif (t <= q[j]) break;\n\t\t\tq[i] = q[j], i = j;\n\t\t}\n\t}\n\n\treturn r;\n}\n\nint main()\n{\n\tint i;\n\tham h;\n\n\tfor (qpush(i = 1); i <= 1691; i++) {\n\t\t\n\t\th = qpop();\n\t\tqpush(h * 2);\n\t\tqpush(h * 3);\n\t\tqpush(h * 5);\n\n\t\tif (i <= 20 || i == 1691)\n\t\t\tprintf(\"%6d: %llu\\n\", i, h);\n\t}\n\n\t\n\treturn 0;\n}\n","Rust":"extern crate num;\nnum::bigint::BigUint;\n\nuse std::time::Instant;\n\nfn basic_hamming(n: usize) -> BigUint {\n let two = BigUint::from(2u8);\n let three = BigUint::from(3u8);\n let five = BigUint::from(5u8);\n let mut h = vec![BigUint::from(0u8); n];\n h[0] = BigUint::from(1u8);\n let mut x2 = BigUint::from(2u8);\n let mut x3 = BigUint::from(3u8);\n let mut x5 = BigUint::from(5u8);\n let mut i = 0usize; let mut j = 0usize; let mut k = 0usize;\n\n \n fn min3(x: &BigUint, y: &BigUint, z: &BigUint) -> (usize, BigUint) {\n let (cs, r1) = if y == z { (0x6, y) } \n else if y < z { (2, y) } else { (4, z) };\n if x == r1 { (cs | 1, x.clone()) }\n else if x < r1 { (1, x.clone()) } else { (cs, r1.clone()) }\n }\n\n let mut c = 1;\n while c < n { \n let (cs, e1) = { min3(&x2, &x3, &x5) };\n h[c] = e1; \n if (cs & 1) != 0 { i += 1; x2 = &two * &h[i] }\n if (cs & 2) != 0 { j += 1; x3 = &three * &h[j] }\t\n if (cs & 4) != 0 { k += 1; x5 = &five * &h[k] }\n c += 1;\n }\n\n match h.pop() {\n Some(v) => v,\n _ => panic!(\"basic_hamming: arg is zero; no elements\")\n }\n}\n\nfn main() {\n print!(\"[\");\n for (i, h) in (1..21).map(basic_hamming).enumerate() {\n if i != 0 { print!(\",\") }\n print!(\" {}\", h)\n }\n println!(\" ]\");\n println!(\"{}\", basic_hamming(1691));\n\n let strt = Instant::now();\n\n let rslt = basic_hamming(1000000);\n\n let elpsd = strt.elapsed();\n let secs = elpsd.as_secs();\n let millis = (elpsd.subsec_nanos() \/ 1000000)as u64;\n let dur = secs * 1000 + millis;\n\n let rs = rslt.to_str_radix(10);\n let mut s = rs.as_str();\n println!(\"{} digits:\", s.len());\n while s.len() > 100 {\n let (f, r) = s.split_at(100);\n s = r;\n println!(\"{}\", f);\n }\n println!(\"{}\", s);\n\n println!(\"This last took {} milliseconds\", dur);\n}\n"} {"name":"Handle a signal","C":"#include \n#include \t\n#include \n#include \t\n#include \t\n\nvolatile sig_atomic_t gotint = 0;\n\nvoid handleSigint() {\n \n gotint = 1;\n}\n \nint main() {\n clock_t startTime = clock();\n signal(SIGINT, handleSigint);\n int i=0;\n for (;;) {\n if (gotint)\n break;\n usleep(500000);\n if (gotint)\n break;\n\tprintf(\"%d\\n\", ++i);\n }\n clock_t endTime = clock();\n double td = (endTime - startTime) \/ (double)CLOCKS_PER_SEC;\n printf(\"Program has run for %5.3f seconds\\n\", td);\n return 0;\n}\n","Rust":"#[cfg(unix)]\nfn main() {\n use std::sync::atomic::{AtomicBool, Ordering};\n use std::thread;\n use std::time::{Duration, Instant};\n\n use libc::{sighandler_t, SIGINT};\n\n \n let duration = Duration::from_secs(1) \/ 2;\n\n \n static mut GOT_SIGINT: AtomicBool = AtomicBool::new(false);\n\n unsafe {\n \n GOT_SIGINT.store(false, Ordering::Release);\n \n unsafe fn handle_sigint() {\n \n \n GOT_SIGINT.store(true, Ordering::Release);\n }\n \n libc::signal(SIGINT, handle_sigint as sighandler_t);\n }\n\n \n let start = Instant::now();\n\n \n let mut i = 0u32;\n\n \n loop {\n thread::sleep(duration);\n\n \n if unsafe { GOT_SIGINT.load(Ordering::Acquire) } {\n break;\n }\n\n \n i += 1;\n println!(\"{}\", i);\n }\n\n \n let elapsed = start.elapsed();\n\n \n println!(\"Program has run for {} seconds\", elapsed.as_secs());\n}\n\n#[cfg(not(unix))]\nfn main() {\n println!(\"Not supported on this platform\");\n}\n"} {"name":"Happy numbers","C":"#include \n\n#define CACHE 256\nenum { h_unknown = 0, h_yes, h_no };\nunsigned char buf[CACHE] = {0, h_yes, 0};\n\nint happy(int n)\n{\n\tint sum = 0, x, nn;\n\tif (n < CACHE) {\n\t\tif (buf[n]) return 2 - buf[n];\n\t\tbuf[n] = h_no;\n\t}\n\n\tfor (nn = n; nn; nn \/= 10) x = nn % 10, sum += x * x;\n\n\tx = happy(sum);\n\tif (n < CACHE) buf[n] = 2 - x;\n\treturn x;\n}\n\nint main()\n{\n\tint i, cnt = 8;\n\tfor (i = 1; cnt || !printf(\"\\n\"); i++)\n\t\tif (happy(i)) --cnt, printf(\"%d \", i);\n\n\tprintf(\"The %dth happy number: \", cnt = 1000000);\n\tfor (i = 1; cnt; i++)\n\t\tif (happy(i)) --cnt || printf(\"%d\\n\", i);\n\n\treturn 0;\n}\n","Rust":"#![feature(core)]\n\nfn sumsqd(mut n: i32) -> i32 {\n let mut sq = 0;\n while n > 0 {\n let d = n % 10;\n sq += d*d;\n n \/= 10\n }\n sq\n}\n\nuse std::num::Int;\nfn cycle(a: T, f: fn(T) -> T) -> T {\n let mut t = a;\n let mut h = f(a);\n\n while t != h {\n t = f(t);\n h = f(f(h))\n }\n t\n}\n\nfn ishappy(n: i32) -> bool {\n cycle(n, sumsqd) == 1\n}\n\nfn main() {\n let happy = std::iter::count(1, 1)\n .filter(|&n| ishappy(n))\n .take(8)\n .collect::>();\n\n println!(\"{:?}\", happy)\n}\n"} {"name":"Harshad or Niven series","C":"#include \n\nstatic int digsum(int n)\n{\n int sum = 0;\n do { sum += n % 10; } while (n \/= 10);\n return sum;\n}\n\nint main(void)\n{\n int n, done, found;\n\n for (n = 1, done = found = 0; !done; ++n) {\n if (n % digsum(n) == 0) {\n if (found++ < 20) printf(\"%d \", n);\n if (n > 1000) done = printf(\"\\n%d\\n\", n);\n }\n }\n\n return 0;\n}\n","Rust":"fn is_harshad (n : u32) -> bool {\n let sum_digits = n.to_string()\n .chars()\n .map(|c| c.to_digit(10).unwrap())\n .fold(0, |a, b| a+b);\n n % sum_digits == 0\n}\n\nfn main() {\n for i in (1u32..).filter(|num| is_harshad(*num)).take(20) {\n println!(\"Harshad\u00a0: {}\", i);\n }\n for i in (1_001u32..).filter(|num| is_harshad(*num)).take(1) {\n println!(\"First Harshad bigger than 1_000\u00a0: {}\", i);\n }\n}\n"} {"name":"Hash from two arrays","C":"#include \n#include \n#include \n\n#define KeyType const char *\n#define ValType int\n\n#define HASH_SIZE 4096\n\n\nunsigned strhashkey( const char * key, int max)\n{\n unsigned h=0;\n unsigned hl, hr;\n\n while(*key) {\n h += *key;\n hl= 0x5C5 ^ (h&0xfff00000 )>>18;\n hr =(h&0x000fffff );\n h = hl ^ hr ^ *key++;\n }\n return h % max;\n}\n\ntypedef struct sHme {\n KeyType key;\n ValType value;\n struct sHme *link;\n} *MapEntry;\n\ntypedef struct he {\n MapEntry first, last;\n} HashElement;\n\nHashElement hash[HASH_SIZE];\n \ntypedef void (*KeyCopyF)(KeyType *kdest, KeyType ksrc);\ntypedef void (*ValCopyF)(ValType *vdest, ValType vsrc);\ntypedef unsigned (*KeyHashF)( KeyType key, int upperBound );\ntypedef int (*KeyCmprF)(KeyType key1, KeyType key2);\n\nvoid HashAddH( KeyType key, ValType value,\n KeyCopyF copyKey, ValCopyF copyVal, KeyHashF hashKey, KeyCmprF keySame )\n{\n unsigned hix = (*hashKey)(key, HASH_SIZE);\n MapEntry m_ent;\n\n for (m_ent= hash[hix].first;\n m_ent && !(*keySame)(m_ent->key,key); m_ent=m_ent->link);\n if (m_ent) {\n (*copyVal)(&m_ent->value, value);\n }\n else {\n MapEntry last;\n MapEntry hme = malloc(sizeof(struct sHme));\n (*copyKey)(&hme->key, key);\n (*copyVal)(&hme->value, value);\n hme->link = NULL;\n last = hash[hix].last;\n if (last) {\n\n last->link = hme;\n }\n else\n hash[hix].first = hme;\n hash[hix].last = hme;\n }\n}\n\nint HashGetH(ValType *val, KeyType key, KeyHashF hashKey, KeyCmprF keySame )\n{\n unsigned hix = (*hashKey)(key, HASH_SIZE);\n MapEntry m_ent;\n for (m_ent= hash[hix].first;\n m_ent && !(*keySame)(m_ent->key,key); m_ent=m_ent->link);\n if (m_ent) {\n *val = m_ent->value;\n }\n return (m_ent != NULL);\n}\n\nvoid copyStr(const char**dest, const char *src)\n{\n *dest = strdup(src);\n}\nvoid copyInt( int *dest, int src)\n{\n *dest = src;\n}\nint strCompare( const char *key1, const char *key2)\n{\n return strcmp(key1, key2) == 0;\n}\n \nvoid HashAdd( KeyType key, ValType value )\n{\n HashAddH( key, value, ©Str, ©Int, &strhashkey, &strCompare);\n}\n\nint HashGet(ValType *val, KeyType key)\n{\n return HashGetH( val, key, &strhashkey, &strCompare);\n}\n\nint main() \n{\n static const char * keyList[] = {\"red\",\"orange\",\"yellow\",\"green\", \"blue\", \"violet\" };\n static int valuList[] = {1,43,640, 747, 42, 42};\n int ix;\n\n for (ix=0; ix<6; ix++) {\n HashAdd(keyList[ix], valuList[ix]);\n }\n return 0;\n}\n","Rust":"use std::collections::HashMap;\n\nfn main() {\n let keys = [\"a\", \"b\", \"c\"];\n let values = [1, 2, 3];\n\n let hash = keys.iter().zip(values.iter()).collect::>();\n println!(\"{:?}\", hash);\n}\n"} {"name":"Haversine formula","C":"#include \n#include \n#include \n\n#define R 6371\n#define TO_RAD (3.1415926536 \/ 180)\ndouble dist(double th1, double ph1, double th2, double ph2)\n{\n\tdouble dx, dy, dz;\n\tph1 -= ph2;\n\tph1 *= TO_RAD, th1 *= TO_RAD, th2 *= TO_RAD;\n\n\tdz = sin(th1) - sin(th2);\n\tdx = cos(ph1) * cos(th1) - cos(th2);\n\tdy = sin(ph1) * cos(th1);\n\treturn asin(sqrt(dx * dx + dy * dy + dz * dz) \/ 2) * 2 * R;\n}\n\nint main()\n{\n\tdouble d = dist(36.12, -86.67, 33.94, -118.4);\n\t\n\tprintf(\"dist:\u00a0%.1f km (%.1f mi.)\\n\", d, d \/ 1.609344);\n\n\treturn 0;\n}\n","Rust":"struct Point {\n lat: f64,\n lon: f64,\n}\n\nfn haversine(origin: Point, destination: Point) -> f64 {\n const R: f64 = 6372.8;\n\n let lat1 = origin.lat.to_radians();\n let lat2 = destination.lat.to_radians();\n let d_lat = lat2 - lat1;\n let d_lon = (destination.lon - origin.lon).to_radians();\n\n let a = (d_lat \/ 2.0).sin().powi(2) + (d_lon \/ 2.0).sin().powi(2) * lat1.cos() * lat2.cos();\n let c = 2.0 * a.sqrt().asin();\n R * c\n}\n\n#[cfg(test)]\nmod test {\n use super::{Point, haversine};\n\n #[test]\n fn test_haversine() {\n let origin: Point = Point {\n lat: 36.12,\n lon: -86.67\n };\n let destination: Point = Point {\n lat: 33.94,\n lon: -118.4\n };\n let d: f64 = haversine(origin, destination);\n println!(\"Distance: {} km ({} mi)\", d, d \/ 1.609344);\n assert_eq!(d, 2887.2599506071106);\n }\n\n}\n"} {"name":"Hello world_Graphical","C":"#include \n\nint main (int argc, char **argv) {\n GtkWidget *window;\n gtk_init(&argc, &argv);\n\n window = gtk_window_new (GTK_WINDOW_TOPLEVEL);\n gtk_window_set_title (GTK_WINDOW (window), \"Goodbye, World\");\n g_signal_connect (G_OBJECT (window), \"delete-event\", gtk_main_quit, NULL);\n gtk_widget_show_all (window);\n\n gtk_main();\n return 0;\n}\n","Rust":"\nextern crate gtk;\nuse gtk::traits::*;\nuse gtk::{Window, WindowType, WindowPosition};\nuse gtk::signal::Inhibit;\n\nfn main() {\n gtk::init().unwrap();\n let window = Window::new(WindowType::Toplevel).unwrap();\n\n window.set_title(\"Goodbye, World!\");\n window.set_border_width(10);\n window.set_window_position(WindowPosition::Center);\n window.set_default_size(350, 70);\n window.connect_delete_event(|_,_| {\n gtk::main_quit();\n Inhibit(false)\n });\n\n window.show_all();\n gtk::main();\n}\n"} {"name":"Hello world_Newline omission","C":"#include \n#include \n\nint main(int argc, char *argv[]) {\n (void) printf(\"Goodbye, World!\"); \n return EXIT_SUCCESS;\n}\n","Rust":"fn main () {\n print!(\"Goodbye, World!\");\n}\n"} {"name":"Hello world_Standard error","C":"#include \n\nint main()\n{\n\tfprintf(stderr, \"Goodbye, \");\n\tfputs(\"World!\\n\", stderr);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n eprintln!(\"Hello, {}!\", \"world\");\n}\n"} {"name":"Hello world_Text","C":"const hello = \"Hello world!\\n\"\n\nprint(hello)\n","Rust":"fn main() {\n print!(\"Hello world!\");\n}\n"} {"name":"Hello world_Web server","C":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nchar response[] = \"HTTP\/1.1 200 OK\\r\\n\"\n\"Content-Type: text\/html; charset=UTF-8\\r\\n\\r\\n\"\n\"Bye-bye baby bye-bye<\/title>\"\n\"<style>body { background-color: #111 }\"\n\"h1 { font-size:4cm; text-align: center; color: black;\"\n\" text-shadow: 0 0 2mm red}<\/style><\/head>\"\n\"<body><h1>Goodbye, world!<\/h1><\/body><\/html>\\r\\n\";\n\nint main()\n{\n int one = 1, client_fd;\n struct sockaddr_in svr_addr, cli_addr;\n socklen_t sin_len = sizeof(cli_addr);\n\n int sock = socket(AF_INET, SOCK_STREAM, 0);\n if (sock < 0)\n err(1, \"can't open socket\");\n\n setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int));\n\n int port = 8080;\n svr_addr.sin_family = AF_INET;\n svr_addr.sin_addr.s_addr = INADDR_ANY;\n svr_addr.sin_port = htons(port);\n\n if (bind(sock, (struct sockaddr *) &svr_addr, sizeof(svr_addr)) == -1) {\n close(sock);\n err(1, \"Can't bind\");\n }\n\n listen(sock, 5);\n while (1) {\n client_fd = accept(sock, (struct sockaddr *) &cli_addr, &sin_len);\n printf(\"got connection\\n\");\n\n if (client_fd == -1) {\n perror(\"Can't accept\");\n continue;\n }\n\n write(client_fd, response, sizeof(response) - 1); \n close(client_fd);\n }\n}\n","Rust":"use std::net::{Shutdown, TcpListener};\nuse std::thread;\nuse std::io::Write;\n\nconst RESPONSE: &'static [u8] = b\"HTTP\/1.1 200 OK\\r\nContent-Type: text\/html; charset=UTF-8\\r\\n\\r\n<!DOCTYPE html><html><head><title>Bye-bye baby bye-bye<\/title>\n<style>body { background-color: #111 }\nh1 { font-size:4cm; text-align: center; color: black;\ntext-shadow: 0 0 2mm red}<\/style><\/head>\n<body><h1>Goodbye, world!<\/h1><\/body><\/html>\\r\";\n\n\nfn main() {\n let listener = TcpListener::bind(\"127.0.0.1:8080\").unwrap();\n\n for stream in listener.incoming() {\n thread::spawn(move || {\n let mut stream = stream.unwrap();\n match stream.write(RESPONSE) {\n Ok(_) => println!(\"Response sent!\"),\n Err(e) => println!(\"Failed sending response: {}!\", e),\n }\n stream.shutdown(Shutdown::Write).unwrap();\n });\n }\n}\n"} {"name":"Heronian triangles","C":"#include<stdlib.h>\n#include<stdio.h>\n#include<math.h>\n\ntypedef struct{\n\tint a,b,c;\n\tint perimeter;\n\tdouble area;\n}triangle;\n\ntypedef struct elem{\n\ttriangle t;\n\tstruct elem* next;\n}cell;\n\ntypedef cell* list;\n\nvoid addAndOrderList(list *a,triangle t){\n\tlist iter,temp;\n\tint flag = 0;\n\t\n\tif(*a==NULL){\n\t\t*a = (list)malloc(sizeof(cell));\n\t\t(*a)->t = t;\n\t\t(*a)->next = NULL;\n\t}\n\t\n\telse{\n\t\ttemp = (list)malloc(sizeof(cell));\n\n\t\t\titer = *a;\n\t\t\twhile(iter->next!=NULL){\n\t\t\t\tif(((iter->t.area<t.area)||(iter->t.area==t.area && iter->t.perimeter<t.perimeter)||(iter->t.area==t.area && iter->t.perimeter==t.perimeter && iter->t.a<=t.a))\n\t\t\t\t&&\n\t\t\t\t(iter->next==NULL||(t.area<iter->next->t.area || t.perimeter<iter->next->t.perimeter || t.a<iter->next->t.a))){\n\t\t\t\t\ttemp->t = t;\n\t\t\t\t\ttemp->next = iter->next;\n\t\t\t\t\titer->next = temp;\n\t\t\t\t\tflag = 1;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\titer = iter->next;\n\t\t\t}\n\t\t\t\n\t\t\tif(flag!=1){\n\t\t\t\ttemp->t = t;\n\t\t\t\ttemp->next = NULL;\n\t\t\t\titer->next = temp;\n\t\t\t}\n\t}\n}\n\nint gcd(int a,int b){\n\tif(b!=0)\n\t\treturn gcd(b,a%b);\n\treturn a;\n}\n\nvoid calculateArea(triangle *t){\n\t(*t).perimeter = (*t).a + (*t).b + (*t).c;\n\t(*t).area = sqrt(0.5*(*t).perimeter*(0.5*(*t).perimeter - (*t).a)*(0.5*(*t).perimeter - (*t).b)*(0.5*(*t).perimeter - (*t).c));\n}\n\nlist generateTriangleList(int maxSide,int *count){\n\tint a,b,c;\n\ttriangle t;\n\tlist herons = NULL;\n\t\n\t*count = 0;\n\t\n\tfor(a=1;a<=maxSide;a++){\n\t\tfor(b=1;b<=a;b++){\n\t\t\tfor(c=1;c<=b;c++){\n\t\t\t\tif(c+b > a && gcd(gcd(a,b),c)==1){\n\t\t\t\t\tt = (triangle){a,b,c};\n\t\t\t\t\tcalculateArea(&t);\n\t\t\t\t\tif(t.area\/(int)t.area == 1){\n\t\t\t\t\t\taddAndOrderList(&herons,t);\n\t\t\t\t\t\t(*count)++;\n\t\t\t\t\t}\t\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\treturn herons;\n}\n\nvoid printList(list a,int limit,int area){\n\tlist iter = a;\n\tint count = 1;\n\t\n\tprintf(\"\\nDimensions\\tPerimeter\\tArea\");\n\t\n\twhile(iter!=NULL && count!=limit+1){\n\t\tif(area==-1 ||(area==iter->t.area)){\n\t\t\tprintf(\"\\n%d x %d x %d\\t%d\\t\\t%d\",iter->t.a,iter->t.b,iter->t.c,iter->t.perimeter,(int)iter->t.area);\n\t\t\tcount++;\n\t\t}\n\t\titer = iter->next;\n\t}\n}\n\nint main(int argC,char* argV[])\n{\n\tint count;\n\tlist herons = NULL;\n\t\n\tif(argC!=4)\n\t\tprintf(\"Usage\u00a0: %s <Max side, max triangles to print and area, -1 for area to ignore>\",argV[0]);\n\telse{\n\t\therons = generateTriangleList(atoi(argV[1]),&count);\n\t\tprintf(\"Triangles found\u00a0: %d\",count);\n\t\t(atoi(argV[3])==-1)?printf(\"\\nPrinting first %s triangles.\",argV[2]):printf(\"\\nPrinting triangles with area %s square units.\",argV[3]);\n\t\tprintList(herons,atoi(argV[2]),atoi(argV[3]));\n\t\tfree(herons);\n\t}\n\treturn 0;\n}\n","Rust":"use num_integer::Integer;\nuse std::{f64, usize};\n\nconst MAXSIZE: usize = 200;\n\n#[derive(Debug)]\nstruct HerionanTriangle {\n a: usize,\n b: usize,\n c: usize,\n area: usize,\n perimeter: usize,\n}\n\nfn get_area(a: &usize, b: &usize, c: &usize) -> f64 {\n let s = (a + b + c) as f64 \/ 2.;\n (s * (s - *a as f64) * (s - *b as f64) * (s - *c as f64)).sqrt()\n}\n\nfn is_heronian(a: &usize, b: &usize, c: &usize) -> bool {\n let area = get_area(a, b, c);\n \n area != 0. && area.fract() == 0.\n}\n\nfn main() {\n let mut heronians: Vec<HerionanTriangle> = vec![];\n\n (1..=MAXSIZE).into_iter().for_each(|a| {\n (a..=MAXSIZE).into_iter().for_each(|b| {\n (b..=MAXSIZE).into_iter().for_each(|c| {\n if a + b > c && a.gcd(&b).gcd(&c) == 1 && is_heronian(&a, &b, &c) {\n heronians.push(HerionanTriangle {\n a,\n b,\n c,\n perimeter: a + b + c,\n area: get_area(&a, &b, &c) as usize,\n })\n }\n })\n })\n });\n\n \n heronians.sort_unstable_by(|x, y| {\n x.area\n .cmp(&y.area)\n .then(x.perimeter.cmp(&y.perimeter))\n .then((x.a.max(x.b).max(x.c)).cmp(&y.a.max(y.b).max(y.c)))\n });\n\n println!(\n \"Primitive Heronian triangles with sides up to 200: {}\",\n heronians.len()\n );\n\n println!(\"\\nFirst ten when ordered by increasing area, then perimeter,then maximum sides:\");\n heronians.iter().take(10).for_each(|h| println!(\"{:?}\", h));\n\n println!(\"\\nAll with area 210 subject to the previous ordering:\");\n heronians\n .iter()\n .filter(|h| h.area == 210)\n .for_each(|h| println!(\"{:?}\", h));\n}\n"} {"name":"Higher-order functions","C":"void myFuncSimple( void (*funcParameter)(void) )\n{\n \n \n (*funcParameter)(); \n funcParameter(); \n\n \n}\n","Rust":"fn execute_with_10<F: Fn(u64) -> u64> (f: F) -> u64 {\n\tf(10)\n}\n\nfn square(n: u64) -> u64 {\n\tn*n\n}\n\nfn main() {\n\tprintln!(\"{}\", execute_with_10(|n| n*n )); \n\tprintln!(\"{}\", execute_with_10(square)); \n}\n"} {"name":"Hilbert curve","C":"#include <stdio.h>\n\n#define N 32\n#define K 3\n#define MAX N * K\n\ntypedef struct { int x; int y; } point;\n\nvoid rot(int n, point *p, int rx, int ry) {\n int t;\n if (!ry) {\n if (rx == 1) {\n p->x = n - 1 - p->x;\n p->y = n - 1 - p->y;\n }\n t = p->x;\n p->x = p->y;\n p->y = t;\n }\n}\n\nvoid d2pt(int n, int d, point *p) {\n int s = 1, t = d, rx, ry;\n p->x = 0;\n p->y = 0;\n while (s < n) {\n rx = 1 & (t \/ 2);\n ry = 1 & (t ^ rx);\n rot(s, p, rx, ry);\n p->x += s * rx;\n p->y += s * ry;\n t \/= 4;\n s *= 2;\n }\n}\n\nint main() {\n int d, x, y, cx, cy, px, py;\n char pts[MAX][MAX];\n point curr, prev;\n for (x = 0; x < MAX; ++x)\n for (y = 0; y < MAX; ++y) pts[x][y] = ' ';\n prev.x = prev.y = 0;\n pts[0][0] = '.';\n for (d = 1; d < N * N; ++d) {\n d2pt(N, d, &curr);\n cx = curr.x * K;\n cy = curr.y * K;\n px = prev.x * K;\n py = prev.y * K;\n pts[cx][cy] = '.';\n if (cx == px ) {\n if (py < cy)\n for (y = py + 1; y < cy; ++y) pts[cx][y] = '|';\n else\n for (y = cy + 1; y < py; ++y) pts[cx][y] = '|';\n }\n else {\n if (px < cx)\n for (x = px + 1; x < cx; ++x) pts[x][cy] = '_';\n else\n for (x = cx + 1; x < px; ++x) pts[x][cy] = '_';\n }\n prev = curr;\n }\n for (x = 0; x < MAX; ++x) {\n for (y = 0; y < MAX; ++y) printf(\"%c\", pts[y][x]);\n printf(\"\\n\");\n }\n return 0;\n}\n","Rust":"\n\n\nuse svg::node::element::path::Data;\nuse svg::node::element::Path;\n\nstruct HilbertCurve {\n current_x: f64,\n current_y: f64,\n current_angle: i32,\n line_length: f64,\n}\n\nimpl HilbertCurve {\n fn new(x: f64, y: f64, length: f64, angle: i32) -> HilbertCurve {\n HilbertCurve {\n current_x: x,\n current_y: y,\n current_angle: angle,\n line_length: length,\n }\n }\n fn rewrite(order: usize) -> String {\n let mut str = String::from(\"A\");\n for _ in 0..order {\n let mut tmp = String::new();\n for ch in str.chars() {\n match ch {\n 'A' => tmp.push_str(\"-BF+AFA+FB-\"),\n 'B' => tmp.push_str(\"+AF-BFB-FA+\"),\n _ => tmp.push(ch),\n }\n }\n str = tmp;\n }\n str\n }\n fn execute(&mut self, order: usize) -> Path {\n let mut data = Data::new().move_to((self.current_x, self.current_y));\n for ch in HilbertCurve::rewrite(order).chars() {\n match ch {\n 'F' => data = self.draw_line(data),\n '+' => self.turn(90),\n '-' => self.turn(-90),\n _ => {}\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 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, size: usize, order: usize) -> std::io::Result<()> {\n use svg::node::element::Rectangle;\n let x = 10.0;\n let y = 10.0;\n let rect = Rectangle::new()\n .set(\"width\", \"100%\")\n .set(\"height\", \"100%\")\n .set(\"fill\", \"white\");\n let mut hilbert = HilbertCurve::new(x, y, 10.0, 0);\n let document = svg::Document::new()\n .set(\"width\", size)\n .set(\"height\", size)\n .add(rect)\n .add(hilbert.execute(order));\n svg::save(file, &document)\n }\n}\n\nfn main() {\n HilbertCurve::save(\"hilbert_curve.svg\", 650, 6).unwrap();\n}\n"} {"name":"Hofstadter Figure-Figure sequences","C":"#include <stdio.h>\n#include <stdlib.h>\n\n\ntypedef unsigned long long xint;\n\ntypedef struct {\n\tsize_t len, alloc;\n\txint *buf;\n} xarray;\n\nxarray rs, ss;\n\nvoid setsize(xarray *a, size_t size)\n{\n\tsize_t n = a->alloc;\n\tif (!n) n = 1;\n\n\twhile (n < size) n <<= 1;\n\tif (a->alloc < n) {\n\t\ta->buf = realloc(a->buf, sizeof(xint) * n);\n\t\tif (!a->buf) abort();\n\t\ta->alloc = n;\n\t}\n}\n\nvoid push(xarray *a, xint v)\n{\n\twhile (a->alloc <= a->len)\n\t\tsetsize(a, a->alloc * 2);\n\n\ta->buf[a->len++] = v;\n}\n\n\n\nvoid RS_append(void);\n\nxint R(int n)\n{\n\twhile (n > rs.len) RS_append();\n\treturn rs.buf[n - 1];\n}\n\nxint S(int n)\n{\n\twhile (n > ss.len) RS_append();\n\treturn ss.buf[n - 1];\n}\n\nvoid RS_append()\n{\n\tint n = rs.len;\n\txint r = R(n) + S(n);\n\txint s = S(ss.len);\n\n\tpush(&rs, r);\n\twhile (++s < r) push(&ss, s);\n\tpush(&ss, r + 1); \n}\n\nint main(void)\n{\n\tpush(&rs, 1);\n\tpush(&ss, 2);\n\n\tint i;\n\tprintf(\"R(1 .. 10):\");\n\tfor (i = 1; i <= 10; i++)\n\t\tprintf(\" %llu\", R(i));\n\n\tchar seen[1001] = { 0 };\n\tfor (i = 1; i <= 40; i++) seen[ R(i) ] = 1;\n\tfor (i = 1; i <= 960; i++) seen[ S(i) ] = 1;\n\tfor (i = 1; i <= 1000 && seen[i]; i++);\n\n\tif (i <= 1000) {\n\t\tfprintf(stderr, \"%d not seen\\n\", i);\n\t\tabort();\n\t}\n\n\tputs(\"\\nfirst 1000 ok\");\n\treturn 0;\n}\n","Rust":"use std::collections::HashMap;\n\nstruct Hffs {\n sequence_r: HashMap<usize, usize>,\n sequence_s: HashMap<usize, usize>,\n}\n\nimpl Hffs {\n fn new() -> Hffs {\n Hffs {\n sequence_r: HashMap::new(),\n sequence_s: HashMap::new(),\n }\n }\n fn ffr(&mut self, n: usize) -> usize {\n \n let new_r = if let Some(result) = self.sequence_r.get(&n) {\n *result\n } else if n == 0 {\n 1\n } else {\n \n self.ffr(n - 1) + self.ffs(n - 1)\n };\n\n \n *self.sequence_r.entry(n).or_insert(new_r)\n }\n\n fn ffs(&mut self, n: usize) -> usize {\n \n let new_s = if let Some(result) = self.sequence_s.get(&n) {\n *result\n } else if n == 0 {\n 2\n } else {\n let lower = self.ffs(n - 1) + 1_usize;\n let upper = self.ffr(n) + 1_usize;\n let mut min_s: usize = 0;\n \n for i in lower..=upper {\n if !self.sequence_r.values().any(|&val| val == i) {\n min_s = i;\n break;\n }\n }\n min_s\n };\n\n \n *self.sequence_s.entry(n).or_insert(new_s)\n }\n}\n\nimpl Default for Hffs {\n fn default() -> Self {\n Self::new()\n }\n}\nfn main() {\n let mut hof = Hffs::new();\n\n for i in 0..10 {\n println!(\"H:{} -> R: {}, S: {}\", i, hof.ffr(i), hof.ffs(i));\n }\n\n let r40 = (0..40).map(|i| hof.ffr(i)).collect::<Vec<_>>();\n let mut s960 = (0..960).map(|i| hof.ffs(i)).collect::<Vec<_>>();\n\n s960.extend(&r40);\n s960.sort_unstable();\n let f1000 = (1_usize..=1000).collect::<Vec<_>>();\n\n assert_eq!(f1000, s960, \"Does NOT match\");\n}\n"} {"name":"Hofstadter-Conway $10,000 sequence","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint a_list[1<<20 + 1];\n\nint doSqnc( int m)\n{\n int max_df = 0;\n int p2_max = 2;\n int v, n;\n int k1 = 2;\n int lg2 = 1;\n double amax = 0;\n a_list[0] = -50000;\n a_list[1] = a_list[2] = 1;\n v = a_list[2];\n\n for (n=3; n <= m; n++) {\n v = a_list[n] = a_list[v] + a_list[n-v];\n if ( amax < v*1.0\/n) amax = v*1.0\/n;\n if ( 0 == (k1&n)) {\n printf(\"Maximum between 2^%d and 2^%d was %f\\n\", lg2,lg2+1, amax);\n amax = 0;\n lg2++;\n }\n k1 = n;\n }\n return 1;\n}\n","Rust":"struct HofstadterConway {\n current: usize,\n sequence: Vec<usize>,\n}\n\nimpl HofstadterConway {\n \n fn new() -> HofstadterConway {\n HofstadterConway {\n current: 0,\n sequence: vec![1, 1],\n }\n }\n}\n\nimpl Default for HofstadterConway {\n fn default() -> Self {\n Self::new()\n }\n}\n\n\nimpl Iterator for HofstadterConway {\n type Item = usize;\n\n \n fn next(&mut self) -> Option<usize> {\n let max_index = self.sequence.len() - 1;\n let last_value = self.sequence[max_index];\n\n if self.current > max_index {\n let new_x = self.sequence[last_value - 1] + self.sequence[max_index - last_value + 1];\n self.sequence.push(new_x);\n }\n self.current += 1;\n Some(self.sequence[self.current - 1])\n }\n}\n\n#[allow(clippy::cast_precision_loss)]\nfn main() {\n let mut hof = HofstadterConway::new();\n let mut winning_num = 0_usize;\n\n for p in 0..20 {\n let max_hof = (2_usize.pow(p)..2_usize.pow(p + 1))\n .map(|n| (n, hof.next().unwrap() as f64 \/ n as f64))\n .fold(f64::NAN, |a, (n, b)| {\n if b >= 0.55 {\n winning_num = n;\n }\n a.max(b)\n });\n\n println!(\"2^{:>2}-2^{:>2}, {:>.8}\", p, p + 1, max_hof);\n }\n\n println!(\"Winning number: {}\", winning_num);\n}\n"} {"name":"Holidays related to Easter","C":"#include <stdio.h>\n\ntypedef int year_t, month_t, week_t, day_t;\n\ntypedef struct{\n year_t year; \n month_t month; day_t month_day; day_t week_day; } date_t;\n\nconst char *mon_fmt[] = {0, \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\",\n \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\"};\nconst char *week_day_fmt[] = {0, \"Sat\", \"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\"};\n\nday_t month_days(year_t year, month_t month)\n { day_t days[]={0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};\n return (month==2) ? 28 + (( year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0) : days[month];\n }\n\nday_t year_days(year_t year) \n { return (month_days(year, 2) == 28) ? 365 : 366; }\n\nmonth_t year_months = 12;\nweek_t week_days = 7; \n\ndate_t plusab(date_t *date, day_t days)\n { \n \n while(days < 0){\n date->year -= 1;\n days += year_days(date->year);\n };\n while(days > year_days(date->year)){\n days -= year_days(date->year);\n date->year += 1;\n };\n date->month_day += days;\n \n while(date->month_day > month_days(date->year, date->month)){\n date->month_day -= month_days(date->year, date->month);\n date->month += 1;\n if(date->month > year_months){\n date->month -= year_months;\n date->year += 1;\n }\n }\n date->week_day = week_day(*date);\n return *date;\n }\n\ndate_t easter (year_t year)\n {\n \n date_t date; date.year = year;\n int c = year \/ 100, n = year % 19; \n int i = (c - c \/ 4 - (c - (c - 17) \/ 25) \/ 3 + 19 * n + 15) % 30;\n i -= (i \/ 28) * (1 - (i \/ 28) * (29 \/ (i + 1)) * ((21 - n) \/ 11));\n int l = i - (year + year \/ 4 + i + 2 - c + c \/ 4) % 7;\n date.month = 3 + (l + 40) \/ 44;\n date.month_day = l + 28 - 31 * (date.month \/ 4);\n date.week_day = week_day(date);\n return date;\n }\n\nday_t week_day (date_t date)\n \n {\n int year = date.year, month = date.month, month_day = date.month_day, c;\n if(month <= 2){month += 12; year -= 1;}\n c = year \/ 100;\n year %= 100;\n return 1 + ((month_day + ((month + 1) * 26) \/ 10\n + year + year \/ 4 + c \/ 4 - 2 * c) % 7 + 7) % 7;\n }\n\n#define wdmdm_fmt \"%s %2d %s\"\n\ntypedef struct{date_t easter, ascension, pentecost, trinity, corpus_christi;}easter_related_t; \n\neaster_related_t easter_related_init (year_t year)\n{\n date_t date;\n easter_related_t holidays;\n\n holidays.easter = date = easter(year);\n\n holidays.ascension = plusab(&date, 39);\n\n holidays.pentecost = plusab(&date, 10);\n\n holidays.trinity = plusab(&date, 7);\n\n holidays.corpus_christi = plusab(&date, 4);\n return holidays;\n}\n\n\n#define easter_related_fmt \"%4d Easter: \"wdmdm_fmt\", Ascension: \"wdmdm_fmt\\\n \", Pentecost: \"wdmdm_fmt\", Trinity: \"wdmdm_fmt\", Corpus: \"wdmdm_fmt\"\\n\"\n\nvoid easter_related_print(year_t year)\n{\n easter_related_t holidays = easter_related_init(year);\n#define wdmdm(date) week_day_fmt[date.week_day], date.month_day, mon_fmt[date.month]\n printf(easter_related_fmt, year,\n wdmdm(holidays.easter), wdmdm(holidays.ascension), wdmdm(holidays.pentecost),\n wdmdm(holidays.trinity), wdmdm(holidays.corpus_christi));\n}\n\nint main(){\n year_t year;\n\n printf (\"Christian holidays, related to Easter, for each centennial from 400 to 2100 CE:\\n\");\n for(year=400; year<=2100; year+=100){ easter_related_print(year); }\n\n printf (\"\\nChristian holidays, related to Easter, for years from 2010 to 2020 CE:\\n\");\n for(year=2010; year<=2020; year++){ easter_related_print(year); }\n return 0;\n}\n","Rust":"use std::ops::Add;\n\nuse chrono::{prelude::*, Duration};\n\n#[allow(clippy::cast_possible_truncation)]\n#[allow(clippy::cast_sign_loss)]\n#[allow(clippy::cast_possible_wrap)]\nfn get_easter_day(year: u32) -> chrono::NaiveDate {\n let k = (f64::from(year) \/ 100.).floor();\n let d = (19 * (year % 19)\n + ((15 - ((13. + 8. * k) \/ 25.).floor() as u32 + k as u32 - (k \/ 4.).floor() as u32) % 30))\n % 30;\n let e =\n (2 * (year % 4) + 4 * (year % 7) + 6 * d + ((4 + k as u32 - (k \/ 4.).floor() as u32) % 7))\n % 7;\n\n let (month, day) = match d {\n 29 if e == 6 => (4, 19),\n 28 if e == 6 => (4, 18),\n _ if d + e < 10 => (3, 22 + d + e),\n _ => (4, d + e - 9),\n };\n\n NaiveDate::from_ymd(year as i32, month, day)\n}\nfn main() {\n let holidays = vec![\n (\"Easter\", Duration::days(0)),\n (\"Ascension\", Duration::days(39)),\n (\"Pentecost\", Duration::days(49)),\n (\"Trinity\", Duration::days(56)),\n (\"Corpus Christi\", Duration::days(60)),\n ];\n for year in (400..=2100).step_by(100).chain(2010..=2020) {\n print!(\"{}: \", year);\n for (name, offset) in &holidays {\n print!(\n \"{}: {}, \",\n name,\n get_easter_day(year).add(*offset).format(\"%a %d %h\")\n );\n }\n println!();\n }\n}\n"} {"name":"Horizontal sundial calculations","C":"#include <stdio.h>\n#include <math.h>\n\n#define PICKVALUE(TXT, VM) do {\t\t\t\\\n printf(\"%s: \", TXT);\t\t\t\\\n scanf(\"%lf\", &VM);\t\t\t\t\\\n } while(0);\n\n#if !defined(M_PI)\n#define M_PI 3.14159265358979323846\n#endif\n\n#define DR(X) ((X)*M_PI\/180.0)\n#define RD(X) ((X)*180.0\/M_PI)\n\nint main()\n{\n double lat, slat, lng, ref;\n int h;\n \n PICKVALUE(\"Enter latitude\", lat);\n PICKVALUE(\"Enter longitude\", lng);\n PICKVALUE(\"Enter legal meridian\", ref);\n printf(\"\\n\");\n\n slat = sin(DR(lat));\n printf(\"sine of latitude:\u00a0%.3f\\n\", slat);\n printf(\"diff longitude:\u00a0%.3f\\n\\n\", lng - ref);\n \n printf(\"Hour, sun hour angle, dial hour line angle from 6am to 6pm\\n\");\n \n for(h = -6; h <= 6; h++)\n {\n double hla, hra;\n hra = 15.0*h;\n hra = hra - lng + ref;\n hla = RD(atan(slat * tan(DR(hra))));\n printf(\"HR= %3d; \\t HRA=%7.3f; \\t HLA= %7.3f\\n\",\n\t h, hra, hla);\n }\n\n return 0;\n}\n","Rust":"use std::io;\nstruct SundialCalculation {\n hour_angle: f64,\n hour_line_angle: f64,\n}\n\nfn get_input(prompt: &str) -> Result<f64, Box<dyn std::error::Error>> {\n println!(\"{}\", prompt);\n let mut input = String::new();\n let stdin = io::stdin();\n stdin.read_line(&mut input)?;\n Ok(input.trim().parse::<f64>()?)\n}\n\nfn calculate_sundial(hour: i8, lat: f64, lng: f64, meridian: f64) -> SundialCalculation {\n let diff = lng - meridian;\n let hour_angle = f64::from(hour) * 15. - diff;\n let hour_line_angle = (hour_angle.to_radians().tan() * lat.to_radians().sin())\n .atan()\n .to_degrees();\n\n SundialCalculation {\n hour_angle,\n hour_line_angle,\n }\n}\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n let lat = get_input(\"Enter latitude => \")?;\n let lng = get_input(\"Enter longitude => \")?;\n let meridian = get_input(\"Enter legal meridian => \")?;\n let diff = lng - meridian;\n\n let sine_lat = lat.to_radians().sin();\n println!(\"Sine of latitude: {:.5}\", sine_lat);\n println!(\"Diff longitude: {}\", diff);\n\n println!(\" Hrs Angle Hour Line Angle\");\n (-6..=6).for_each(|hour| {\n let sd = calculate_sundial(hour, lat, lng, meridian);\n println!(\n \"{:>3}{} {:>5} {:>+15.5}\",\n if hour == 0 { 12 } else { (hour + 12) % 12 },\n if hour <= 6 { \"pm\" } else { \"am\" },\n sd.hour_angle,\n sd.hour_line_angle\n );\n });\n Ok(())\n}\n"} {"name":"Horner's rule for polynomial evaluation","C":"#include <stdio.h>\n\ndouble horner(double *coeffs, int s, double x)\n{\n int i;\n double res = 0.0;\n \n for(i=s-1; i >= 0; i--)\n {\n res = res * x + coeffs[i];\n }\n return res;\n}\n\n\nint main()\n{\n double coeffs[] = { -19.0, 7.0, -4.0, 6.0 };\n \n printf(\"%5.1f\\n\", horner(coeffs, sizeof(coeffs)\/sizeof(double), 3.0));\n return 0;\n}\n","Rust":"fn horner(v: &[f64], x: f64) -> f64 {\n v.iter().rev().fold(0.0, |acc, coeff| acc*x + coeff)\n}\n\nfn main() {\n let v = [-19., 7., -4., 6.];\n println!(\"result: {}\", horner(&v, 3.0));\n}\n"} {"name":"Host introspection","C":"#include <stdio.h>\n#include <stddef.h> \n#include <limits.h> \n\nint main() {\n int one = 1;\n\n \n printf(\"word size = %d bits\\n\", (int)(CHAR_BIT * sizeof(size_t)));\n\n \n if (*(char *)&one)\n printf(\"little endian\\n\");\n else\n printf(\"big endian\\n\");\n return 0;\n}\n","Rust":"#[derive(Copy, Clone, Debug)]\nenum Endianness {\n Big, Little,\n}\n\nimpl Endianness {\n fn target() -> Self {\n #[cfg(target_endian = \"big\")]\n {\n Endianness::Big\n }\n #[cfg(not(target_endian = \"big\"))]\n {\n Endianness::Little\n }\n }\n}\n\nfn main() {\n println!(\"Word size: {} bytes\", std::mem::size_of::<usize>());\n println!(\"Endianness: {:?}\", Endianness::target());\n}\n"} {"name":"Hostname","C":"#include <stdlib.h>\n#include <stdio.h>\n#include <limits.h>\n#include <unistd.h>\n \nint main(void)\n{\n char name[_POSIX_HOST_NAME_MAX + 1];\n return gethostname(name, sizeof name) == -1 || printf(\"%s\\n\", name) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;\n}\n","Rust":"fn main() {\n match hostname::get_hostname() {\n Some(host) => println!(\"hostname: {}\", host),\n None => eprintln!(\"Could not get hostname!\"),\n }\n}\n"} {"name":"Huffman coding","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#define BYTES 256\n\nstruct huffcode {\n int nbits;\n int code;\n};\ntypedef struct huffcode huffcode_t;\n\nstruct huffheap {\n int *h;\n int n, s, cs;\n long *f;\n};\ntypedef struct huffheap heap_t;\n\n\nstatic heap_t *_heap_create(int s, long *f)\n{\n heap_t *h;\n h = malloc(sizeof(heap_t));\n h->h = malloc(sizeof(int)*s);\n h->s = h->cs = s;\n h->n = 0;\n h->f = f;\n return h;\n}\n\nstatic void _heap_destroy(heap_t *heap)\n{\n free(heap->h);\n free(heap);\n}\n\n#define swap_(I,J) do { int t_; t_ = a[(I)];\t\\\n a[(I)] = a[(J)]; a[(J)] = t_; } while(0)\nstatic void _heap_sort(heap_t *heap)\n{\n int i=1, j=2; \n int *a = heap->h;\n\n while(i < heap->n) { \n if ( heap->f[a[i-1]] >= heap->f[a[i]] ) {\n i = j; j++;\n } else {\n swap_(i-1, i);\n i--;\n i = (i==0) ? j++ : i;\n }\n }\n}\n#undef swap_\n\nstatic void _heap_add(heap_t *heap, int c)\n{\n if ( (heap->n + 1) > heap->s ) {\n heap->h = realloc(heap->h, heap->s + heap->cs);\n heap->s += heap->cs;\n }\n heap->h[heap->n] = c;\n heap->n++;\n _heap_sort(heap);\n}\n\nstatic int _heap_remove(heap_t *heap)\n{\n if ( heap->n > 0 ) {\n heap->n--;\n return heap->h[heap->n];\n }\n return -1;\n}\n\n\nhuffcode_t **create_huffman_codes(long *freqs)\n{\n huffcode_t **codes;\n heap_t *heap;\n long efreqs[BYTES*2];\n int preds[BYTES*2];\n int i, extf=BYTES;\n int r1, r2;\n\n memcpy(efreqs, freqs, sizeof(long)*BYTES);\n memset(&efreqs[BYTES], 0, sizeof(long)*BYTES);\n\n heap = _heap_create(BYTES*2, efreqs);\n if ( heap == NULL ) return NULL;\n\n for(i=0; i < BYTES; i++) if ( efreqs[i] > 0 ) _heap_add(heap, i);\n\n while( heap->n > 1 )\n {\n r1 = _heap_remove(heap);\n r2 = _heap_remove(heap);\n efreqs[extf] = efreqs[r1] + efreqs[r2];\n _heap_add(heap, extf);\n preds[r1] = extf;\n preds[r2] = -extf;\n extf++;\n }\n r1 = _heap_remove(heap);\n preds[r1] = r1;\n _heap_destroy(heap);\n\n codes = malloc(sizeof(huffcode_t *)*BYTES);\n\n int bc, bn, ix;\n for(i=0; i < BYTES; i++) {\n bc=0; bn=0;\n if ( efreqs[i] == 0 ) { codes[i] = NULL; continue; }\n ix = i;\n while( abs(preds[ix]) != ix ) {\n bc |= ((preds[ix] >= 0) ? 1 : 0 ) << bn;\n ix = abs(preds[ix]);\n bn++;\n }\n codes[i] = malloc(sizeof(huffcode_t));\n codes[i]->nbits = bn;\n codes[i]->code = bc;\n }\n return codes;\n}\n\nvoid free_huffman_codes(huffcode_t **c)\n{\n int i;\n\n for(i=0; i < BYTES; i++) free(c[i]);\n free(c);\n}\n\n#define MAXBITSPERCODE 100\n\nvoid inttobits(int c, int n, char *s)\n{\n s[n] = 0;\n while(n > 0) {\n s[n-1] = (c%2) + '0';\n c >>= 1; n--;\n }\n}\n\nconst char *test = \"this is an example for huffman encoding\";\n\nint main()\n{\n huffcode_t **r;\n int i;\n char strbit[MAXBITSPERCODE];\n const char *p;\n long freqs[BYTES];\n\n memset(freqs, 0, sizeof freqs);\n\n p = test;\n while(*p != '\\0') freqs[*p++]++;\n\n r = create_huffman_codes(freqs);\n\n for(i=0; i < BYTES; i++) {\n if ( r[i] != NULL ) {\n inttobits(r[i]->code, r[i]->nbits, strbit);\n printf(\"%c (%d) %s\\n\", i, r[i]->code, strbit);\n }\n }\n\n free_huffman_codes(r);\n\n return 0;\n}\n","Rust":"use std::collections::BTreeMap;\nuse std::collections::binary_heap::BinaryHeap;\n\n#[derive(Debug, Eq, PartialEq)]\nenum NodeKind {\n Internal(Box<Node>, Box<Node>),\n Leaf(char),\n}\n\n#[derive(Debug, Eq, PartialEq)]\nstruct Node {\n frequency: usize,\n kind: NodeKind,\n}\n\nimpl Ord for Node {\n fn cmp(&self, rhs: &Self) -> std::cmp::Ordering {\n rhs.frequency.cmp(&self.frequency)\n }\n}\n\nimpl PartialOrd for Node {\n fn partial_cmp(&self, rhs: &Self) -> Option<std::cmp::Ordering> {\n Some(self.cmp(&rhs))\n }\n}\n\ntype HuffmanCodeMap = BTreeMap<char, Vec<u8>>;\n\nfn main() {\n let text = \"this is an example for huffman encoding\";\n\n let mut frequencies = BTreeMap::new();\n for ch in text.chars() {\n *frequencies.entry(ch).or_insert(0) += 1;\n }\n\n let mut prioritized_frequencies = BinaryHeap::new();\n for counted_char in frequencies {\n prioritized_frequencies.push(Node {\n frequency: counted_char.1,\n kind: NodeKind::Leaf(counted_char.0),\n });\n }\n\n while prioritized_frequencies.len() > 1 {\n let left_child = prioritized_frequencies.pop().unwrap();\n let right_child = prioritized_frequencies.pop().unwrap();\n prioritized_frequencies.push(Node {\n frequency: right_child.frequency + left_child.frequency,\n kind: NodeKind::Internal(Box::new(left_child), Box::new(right_child)),\n });\n }\n\n let mut codes = HuffmanCodeMap::new();\n generate_codes(\n prioritized_frequencies.peek().unwrap(),\n vec![0u8; 0],\n &mut codes,\n );\n\n for item in codes {\n print!(\"{}: \", item.0);\n for bit in item.1 {\n print!(\"{}\", bit);\n }\n println!();\n }\n}\n\nfn generate_codes(node: &Node, prefix: Vec<u8>, out_codes: &mut HuffmanCodeMap) {\n match node.kind {\n NodeKind::Internal(ref left_child, ref right_child) => {\n let mut left_prefix = prefix.clone();\n left_prefix.push(0);\n generate_codes(&left_child, left_prefix, out_codes);\n\n let mut right_prefix = prefix;\n right_prefix.push(1);\n generate_codes(&right_child, right_prefix, out_codes);\n }\n NodeKind::Leaf(ch) => {\n out_codes.insert(ch, prefix);\n }\n }\n}\n"} {"name":"IBAN","C":"#include <alloca.h>\n#include <ctype.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#define V(cc, exp) if (!strncmp(iban, cc, 2)) return len == exp\n\n\nint valid_cc(const char *iban, int len)\n{\n V(\"AL\", 28); V(\"AD\", 24); V(\"AT\", 20); V(\"AZ\", 28); V(\"BE\", 16); V(\"BH\", 22); V(\"BA\", 20); V(\"BR\", 29);\n V(\"BG\", 22); V(\"CR\", 21); V(\"HR\", 21); V(\"CY\", 28); V(\"CZ\", 24); V(\"DK\", 18); V(\"DO\", 28); V(\"EE\", 20);\n V(\"FO\", 18); V(\"FI\", 18); V(\"FR\", 27); V(\"GE\", 22); V(\"DE\", 22); V(\"GI\", 23); V(\"GR\", 27); V(\"GL\", 18);\n V(\"GT\", 28); V(\"HU\", 28); V(\"IS\", 26); V(\"IE\", 22); V(\"IL\", 23); V(\"IT\", 27); V(\"KZ\", 20); V(\"KW\", 30);\n V(\"LV\", 21); V(\"LB\", 28); V(\"LI\", 21); V(\"LT\", 20); V(\"LU\", 20); V(\"MK\", 19); V(\"MT\", 31); V(\"MR\", 27);\n V(\"MU\", 30); V(\"MC\", 27); V(\"MD\", 24); V(\"ME\", 22); V(\"NL\", 18); V(\"NO\", 15); V(\"PK\", 24); V(\"PS\", 29);\n V(\"PL\", 28); V(\"PT\", 25); V(\"RO\", 24); V(\"SM\", 27); V(\"SA\", 24); V(\"RS\", 22); V(\"SK\", 24); V(\"SI\", 19);\n V(\"ES\", 24); V(\"SE\", 24); V(\"CH\", 21); V(\"TN\", 24); V(\"TR\", 26); V(\"AE\", 23); V(\"GB\", 22); V(\"VG\", 24);\n\n return 0;\n}\n\n\nint strip(char *s)\n{\n int i = -1, m = 0;\n\n while(s[++i]) {\n s[i - m] = s[i];\n m += s[i] <= 32;\n }\n\n s[i - m] = 0;\n return i - m;\n}\n\n\nint mod97(const char *s, int len)\n{\n int i, j, parts = len \/ 7;\n char rem[10] = \"00\";\n\n for (i = 1; i <= parts + (len % 7 != 0); ++i) {\n strncpy(rem + 2, s + (i - 1) * 7, 7);\n j = atoi(rem) % 97;\n rem[0] = j \/ 10 + '0';\n rem[1] = j % 10 + '0';\n }\n\n return atoi(rem) % 97;\n}\n\nint valid_iban(char *iban)\n{\n int i, j, l = 0, sz = strip(iban);\n char *rot, *trans;\n\n \n for (i = 0; i < sz; ++i) {\n if (!isdigit(iban[i]) && !isupper(iban[i]))\n return 0;\n l += !!isupper(iban[i]);\n }\n\n if (!valid_cc(iban, sz))\n return 0;\n\n \n rot = alloca(sz);\n strcpy(rot, iban + 4);\n strncpy(rot + sz - 4, iban, 4);\n\n \n trans = alloca(sz + l + 1);\n trans[sz + l] = 0;\n\n \n for (i = j = 0; i < sz; ++i, ++j) {\n if (isdigit(rot[i]))\n trans[j] = rot[i];\n else {\n trans[j] = (rot[i] - 55) \/ 10 + '0';\n trans[++j] = (rot[i] - 55) % 10 + '0';\n }\n }\n\n return mod97(trans, sz + l) == 1;\n}\n\nint main(int _, char **argv)\n{\n while (--_, *++argv)\n printf(\"%s is %svalid.\\n\", *argv, valid_iban(*argv) ? \"\" : \"in\");\n\n return 0;\n}\n","Rust":"fn main() {\n for iban in [\n \"\",\n \"x\",\n \"QQ82\",\n \"QQ82W\",\n \"GB82 TEST 1234 5698 7654 322\",\n \"gb82 WEST 1234 5698 7654 32\",\n \"GB82 WEST 1234 5698 7654 32\",\n \"GB82 TEST 1234 5698 7654 32\",\n \"GB81 WEST 1234 5698 7654 32\",\n \"SA03 8000 0000 6080 1016 7519\",\n \"CH93 0076 2011 6238 5295 7\",\n ].iter()\n {\n println!(\n \"'{}' is {}valid\",\n iban,\n if validate_iban(iban) { \"\" } else { \"NOT \" }\n );\n }\n}\n\nfn validate_iban(iban: &str) -> bool {\n let iso_len = [\n (\"AL\", 28), (\"AD\", 24), (\"AT\", 20), (\"AZ\", 28), (\"BE\", 16), (\"BH\", 22),\n (\"BA\", 20), (\"BR\", 29), (\"BG\", 22), (\"HR\", 21), (\"CY\", 28), (\"CZ\", 24),\n (\"DK\", 18), (\"DO\", 28), (\"EE\", 20), (\"FO\", 18), (\"FI\", 18), (\"FR\", 27),\n (\"GE\", 22), (\"DE\", 22), (\"GI\", 23), (\"GL\", 18), (\"GT\", 28), (\"HU\", 28),\n (\"IS\", 26), (\"IE\", 22), (\"IL\", 23), (\"IT\", 27), (\"KZ\", 20), (\"KW\", 30),\n (\"LV\", 21), (\"LB\", 28), (\"LI\", 21), (\"LT\", 20), (\"LU\", 20), (\"MK\", 19),\n (\"MT\", 31), (\"MR\", 27), (\"MU\", 30), (\"MC\", 27), (\"MD\", 24), (\"ME\", 22),\n (\"NL\", 18), (\"NO\", 15), (\"PK\", 24), (\"PS\", 29), (\"PL\", 28), (\"PT\", 25),\n (\"RO\", 24), (\"SM\", 27), (\"SA\", 24), (\"RS\", 22), (\"SK\", 24), (\"SI\", 19),\n (\"ES\", 24), (\"SE\", 24), (\"CH\", 21), (\"TN\", 24), (\"TR\", 26), (\"AE\", 23),\n (\"GB\", 22), (\"VG\", 24), (\"GR\", 27), (\"CR\", 21),\n ];\n let trimmed_iban = iban.chars()\n .filter(|&ch| ch != ' ')\n .collect::<String>()\n .to_uppercase();\n if trimmed_iban.len() < 4 {\n return false;\n }\n let prefix = &trimmed_iban[0..2];\n if let Some(pair) = iso_len.iter().find(|&&(code, _)| code == prefix) {\n if pair.1 != trimmed_iban.len() {\n return false;\n }\n } else {\n return false;\n }\n let reversed_iban = format!(\"{}{}\", &trimmed_iban[4..], &trimmed_iban[0..4]);\n let mut expanded_iban = String::new();\n for ch in reversed_iban.chars() {\n expanded_iban.push_str(&if ch.is_numeric() {\n format!(\"{}\", ch)\n } else {\n format!(\"{}\", ch as u8 - 'A' as u8 + 10u8)\n });\n }\n expanded_iban.bytes().fold(0, |acc, ch| {\n (acc * 10 + ch as u32 - '0' as u32) % 97\n }) == 1\n}\n"} {"name":"ISBN13 check digit","C":"#include <stdio.h>\n\nint check_isbn13(const char *isbn) {\n int ch = *isbn, count = 0, sum = 0;\n \n for ( ; ch != 0; ch = *++isbn, ++count) {\n \n if (ch == ' ' || ch == '-') {\n --count;\n continue;\n }\n if (ch < '0' || ch > '9') {\n return 0;\n }\n if (count & 1) {\n sum += 3 * (ch - '0');\n } else {\n sum += ch - '0';\n }\n }\n if (count != 13) return 0;\n return !(sum%10);\n}\n\nint main() {\n int i;\n const char* isbns[] = {\"978-1734314502\", \"978-1734314509\", \"978-1788399081\", \"978-1788399083\"};\n for (i = 0; i < 4; ++i) {\n printf(\"%s: %s\\n\", isbns[i], check_isbn13(isbns[i]) ? \"good\" : \"bad\");\n }\n return 0;\n}\n","Rust":"fn main() {\n let isbns = [\"978-1734314502\", \"978-1734314509\", \"978-1788399081\", \"978-1788399083\"];\n isbns.iter().for_each(|isbn| println!(\"{}: {}\", isbn, check_isbn(isbn)));\n}\n\nfn check_isbn(isbn: &str) -> bool {\n if isbn.chars().filter(|c| c.is_digit(10)).count() != 13 {\n return false;\n } \n let checksum = isbn.chars().filter_map(|c| c.to_digit(10))\n .zip([1, 3].iter().cycle())\n .fold(0, |acc, (val, fac)| acc + val * fac);\n checksum % 10 == 0\n}\n"} {"name":"Identity matrix","C":"#include <stdlib.h>\n#include <stdio.h>\nint main(int argc, char** argv) {\n if (argc < 2) {\n printf(\"usage: identitymatrix <number of rows>\\n\");\n exit(EXIT_FAILURE);\n }\n int rowsize = atoi(argv[1]);\n if (rowsize < 0) {\n printf(\"Dimensions of matrix cannot be negative\\n\");\n exit(EXIT_FAILURE);\n }\n int numElements = rowsize * rowsize;\n if (numElements < rowsize) {\n printf(\"Squaring %d caused result to overflow to %d.\\n\", rowsize, numElements);\n abort();\n }\n int** matrix = calloc(numElements, sizeof(int*));\n if (!matrix) {\n printf(\"Failed to allocate %d elements of %ld bytes each\\n\", numElements, sizeof(int*));\n abort();\n }\n for (unsigned int row = 0;row < rowsize;row++) {\n matrix[row] = calloc(numElements, sizeof(int));\n if (!matrix[row]) {\n printf(\"Failed to allocate %d elements of %ld bytes each\\n\", numElements, sizeof(int));\n abort();\n }\n matrix[row][row] = 1;\n }\n printf(\"Matrix is: \\n\");\n for (unsigned int row = 0;row < rowsize;row++) {\n for (unsigned int column = 0;column < rowsize;column++) {\n printf(\"%d \", matrix[row][column]);\n }\n printf(\"\\n\");\n }\n}\n","Rust":"extern crate num;\nstruct Matrix<T> {\n data: Vec<T>,\n size: usize,\n}\n\nimpl<T> Matrix<T>\nwhere\n T: num::Num + Clone + Copy,\n{\n fn new(size: usize) -> Self {\n Self {\n data: vec![T::zero(); size * size],\n size: size,\n }\n }\n fn get(&mut self, x: usize, y: usize) -> T {\n self.data[x + self.size * y]\n }\n fn identity(&mut self) {\n for (i, item) in self.data.iter_mut().enumerate() {\n *item = if i % (self.size + 1) == 0 {\n T::one()\n } else {\n T::zero()\n }\n }\n }\n}\n\nfn main() {\n let size = std::env::args().nth(1).unwrap().parse().unwrap();\n let mut matrix = Matrix::<i32>::new(size);\n matrix.identity();\n for y in 0..size {\n for x in 0..size {\n print!(\"{} \", matrix.get(x, y));\n }\n println!();\n }\n}\n"} {"name":"Increment a numerical string","C":"#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\n\nchar * incr(char *s)\n{\n\tint i, begin, tail, len;\n\tint neg = (*s == '-');\n\tchar tgt = neg ? '0' : '9';\n\n\t\n\tif (!strcmp(s, \"-1\")) {\n\t\ts[0] = '0', s[1] = '\\0';\n\t\treturn s;\n\t}\n\n\tlen = strlen(s);\n\tbegin = (*s == '-' || *s == '+') ? 1 : 0;\n\n\t\n\tfor (tail = len - 1; tail >= begin && s[tail] == tgt; tail--);\n\n\tif (tail < begin && !neg) {\n\t\t\n\t\tif (!begin) s = realloc(s, len + 2);\n\t\ts[0] = '1';\n\t\tfor (i = 1; i <= len - begin; i++) s[i] = '0';\n\t\ts[len + 1] = '\\0';\n\t} else if (tail == begin && neg && s[1] == '1') {\n\t\t\n\t\tfor (i = 1; i < len - begin; i++) s[i] = '9';\n\t\ts[len - 1] = '\\0';\n\t} else { \n\t\tfor (i = len - 1; i > tail; i--)\n\t\t\ts[i] = neg ? '9' : '0';\n\t\ts[tail] += neg ? -1 : 1;\n\t}\n\n\treturn s;\n}\n\nvoid string_test(const char *s)\n{\n\tchar *ret = malloc(strlen(s));\n\tstrcpy(ret, s);\n\n\tprintf(\"text: %s\\n\", ret);\n\tprintf(\" ->: %s\\n\", ret = incr(ret));\n\tfree(ret);\n}\n\nint main()\n{\n\tstring_test(\"+0\");\n\tstring_test(\"-1\");\n\tstring_test(\"-41\");\n\tstring_test(\"+41\");\n\tstring_test(\"999\");\n\tstring_test(\"+999\");\n\tstring_test(\"109999999999999999999999999999999999999999\");\n\tstring_test(\"-100000000000000000000000000000000000000000000\");\n\n\treturn 0;\n}\n","Rust":"fn next_string(input: &str) -> String {\n (input.parse::<i64>().unwrap() + 1).to_string()\n}\n\nfn main() {\n let s = \"-1\";\n let s2 = next_string(s);\n println!(\"{:?}\", s2);\n}\n"} {"name":"Infinity","C":"#include <math.h>\t\n#include <stdio.h>\t\n\ndouble inf(void) {\n return HUGE_VAL;\n}\n\nint main() {\n printf(\"%g\\n\", inf());\n return 0;\n}\n","Rust":"fn main() {\n let inf = f32::INFINITY;\n println!(\"{}\", inf);\n}\n"} {"name":"Inheritance_Multiple","C":"typedef struct{\n\tdouble focalLength;\n\tdouble resolution;\n\tdouble memory;\n}Camera;\n\ntypedef struct{\n\tdouble balance;\n\tdouble batteryLevel;\n\tchar** contacts;\n}Phone;\n\ntypedef struct{\n\tCamera cameraSample;\n\tPhone phoneSample;\n}CameraPhone;\n","Rust":"trait Camera {}\ntrait MobilePhone {}\ntrait CameraPhone: Camera + MobilePhone {}\n"} {"name":"Input loop","C":"#include <stdlib.h>\n#include <stdio.h>\n\nchar *get_line(FILE* fp)\n{\n\tint len = 0, got = 0, c;\n\tchar *buf = 0;\n\n\twhile ((c = fgetc(fp)) != EOF) {\n\t\tif (got + 1 >= len) {\n\t\t\tlen *= 2;\n\t\t\tif (len < 4) len = 4;\n\t\t\tbuf = realloc(buf, len);\n\t\t}\n\t\tbuf[got++] = c;\n\t\tif (c == '\\n') break;\n\t}\n\tif (c == EOF && !got) return 0;\n\n\tbuf[got++] = '\\0';\n\treturn buf;\n}\n\nint main()\n{\n\tchar *s;\n\twhile ((s = get_line(stdin))) {\n\t\tprintf(\"%s\",s);\n\t\tfree(s);\n\t}\n\treturn 0;\n}\n","Rust":" use std::io::{self, BufReader, Read, BufRead};\nuse std::fs::File;\n\nfn main() {\n print_by_line(io::stdin())\n .expect(\"Could not read from stdin\");\n\n File::open(\"\/etc\/fstab\")\n .and_then(print_by_line)\n .expect(\"Could not read from file\");\n}\n\nfn print_by_line<T: Read>(reader: T) -> io::Result<()> {\n let buffer = BufReader::new(reader);\n for line in buffer.lines() {\n println!(\"{}\", line?)\n }\n Ok(())\n}\n"} {"name":"Integer comparison","C":"#include <stdio.h>\n\nint main()\n{\n int a, b;\n scanf(\"%d %d\", &a, &b);\n\n if (a < b)\n printf(\"%d is less than %d\\n\", a, b);\n\n if (a == b)\n printf(\"%d is equal to %d\\n\", a, b);\n\n if (a > b)\n printf(\"%d is greater than %d\\n\", a, b);\n\n return 0;\n}\n","Rust":"use std::io::{self, BufRead};\n\nfn main() {\n let mut reader = io::stdin();\n let mut buffer = String::new();\n let mut lines = reader.lock().lines().take(2);\n let nums: Vec<i32>= lines.map(|string|\n string.unwrap().trim().parse().unwrap()\n ).collect();\n let a: i32 = nums[0];\n let b: i32 = nums[1];\n if a < b {\n println!(\"{} is less than {}\" , a , b)\n } else if a == b {\n println!(\"{} equals {}\" , a , b)\n } else if a > b {\n println!(\"{} is greater than {}\" , a , b)\n };\n}\n"} {"name":"Integer overflow","C":"#include <stdio.h>\n\nint main (int argc, char *argv[])\n{\n printf(\"Signed 32-bit:\\n\");\n printf(\"%d\\n\", -(-2147483647-1));\n printf(\"%d\\n\", 2000000000 + 2000000000);\n printf(\"%d\\n\", -2147483647 - 2147483647);\n printf(\"%d\\n\", 46341 * 46341);\n printf(\"%d\\n\", (-2147483647-1) \/ -1);\n printf(\"Signed 64-bit:\\n\");\n printf(\"%ld\\n\", -(-9223372036854775807-1));\n printf(\"%ld\\n\", 5000000000000000000+5000000000000000000);\n printf(\"%ld\\n\", -9223372036854775807 - 9223372036854775807);\n printf(\"%ld\\n\", 3037000500 * 3037000500);\n printf(\"%ld\\n\", (-9223372036854775807-1) \/ -1);\n printf(\"Unsigned 32-bit:\\n\");\n printf(\"%u\\n\", -4294967295U);\n printf(\"%u\\n\", 3000000000U + 3000000000U);\n printf(\"%u\\n\", 2147483647U - 4294967295U);\n printf(\"%u\\n\", 65537U * 65537U);\n printf(\"Unsigned 64-bit:\\n\");\n printf(\"%lu\\n\", -18446744073709551615LU);\n printf(\"%lu\\n\", 10000000000000000000LU + 10000000000000000000LU);\n printf(\"%lu\\n\", 9223372036854775807LU - 18446744073709551615LU);\n printf(\"%lu\\n\", 4294967296LU * 4294967296LU);\n return 0;\n}\n","Rust":" \n let i32_1 : i32 = -(-2_147_483_647 - 1);\n let i32_2 : i32 = 2_000_000_000 + 2_000_000_000;\n let i32_3 : i32 = -2_147_483_647 - 2_147_483_647;\n let i32_4 : i32 = 46341 * 46341;\n let i32_5 : i32 = (-2_147_483_647 - 1) \/ -1;\n\n \n let i64_1 : i64 = -(-9_223_372_036_854_775_807 - 1);\n let i64_2 : i64 = 5_000_000_000_000_000_000 + 5_000_000_000_000_000_000;\n let i64_3 : i64 = -9_223_372_036_854_775_807 - 9_223_372_036_854_775_807;\n let i64_4 : i64 = 3_037_000_500 * 3_037_000_500;\n let i64_5 : i64 = (-9_223_372_036_854_775_807 - 1) \/ -1;\n"} {"name":"Integer sequence","C":"#include <stdio.h>\n\nint main()\n{\n\tunsigned int i = 0;\n\twhile (++i) printf(\"%u\\n\", i);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n for i in 0.. {\n println!(\"{}\", i);\n }\n}\n"} {"name":"Inverted index","C":"#include <stdio.h>\n#include <stdlib.h>\n\nchar chr_legal[] = \"abcdefghijklmnopqrstuvwxyz0123456789_-.\/\";\nint chr_idx[256] = {0};\nchar idx_chr[256] = {0};\n\n#define FNAME 0\ntypedef struct trie_t *trie, trie_t;\nstruct trie_t {\n trie next[sizeof(chr_legal)]; \n int eow;\n};\n\ntrie trie_new() { return calloc(sizeof(trie_t), 1); }\n\n#define find_word(r, w) trie_trav(r, w, 1)\n\ntrie trie_trav(trie root, const char * str, int no_create)\n{\n int c;\n while (root) {\n if ((c = str[0]) == '\\0') {\n if (!root->eow && no_create) return 0;\n break;\n }\n if (! (c = chr_idx[c]) ) {\n str++;\n continue;\n }\n\n if (!root->next[c]) {\n if (no_create) return 0;\n root->next[c] = trie_new();\n }\n root = root->next[c];\n str++;\n }\n return root;\n}\n\n\nint trie_all(trie root, char path[], int depth, int (*callback)(char *))\n{\n int i;\n if (root->eow && !callback(path)) return 0;\n\n for (i = 1; i < sizeof(chr_legal); i++) {\n if (!root->next[i]) continue;\n\n path[depth] = idx_chr[i];\n path[depth + 1] = '\\0';\n if (!trie_all(root->next[i], path, depth + 1, callback))\n return 0;\n }\n return 1;\n}\n\nvoid add_index(trie root, const char *word, const char *fname)\n{\n trie x = trie_trav(root, word, 0);\n x->eow = 1;\n\n if (!x->next[FNAME])\n x->next[FNAME] = trie_new();\n x = trie_trav(x->next[FNAME], fname, 0);\n x->eow = 1;\n}\n\nint print_path(char *path)\n{\n printf(\" %s\", path);\n return 1;\n}\n\n\nconst char *files[] = { \"f1.txt\", \"source\/f2.txt\", \"other_file\" };\nconst char *text[][5] ={{ \"it\", \"is\", \"what\", \"it\", \"is\" },\n { \"what\", \"is\", \"it\", 0 },\n { \"it\", \"is\", \"a\", \"banana\", 0 }};\n\ntrie init_tables()\n{\n int i, j;\n trie root = trie_new();\n for (i = 0; i < sizeof(chr_legal); i++) {\n chr_idx[(int)chr_legal[i]] = i + 1;\n idx_chr[i + 1] = chr_legal[i];\n }\n\n\n#define USE_ADVANCED_FILE_HANDLING 0\n#if USE_ADVANCED_FILE_HANDLING\n void read_file(const char * fname) {\n char cmd[1024];\n char word[1024];\n sprintf(cmd, \"perl -p -e 'while(\/(\\\\w+)\/g) {print lc($1),\\\"\\\\n\\\"}' %s\", fname);\n FILE *in = popen(cmd, \"r\");\n while (!feof(in)) {\n fscanf(in, \"%1000s\", word);\n add_index(root, word, fname);\n }\n pclose(in);\n };\n\n read_file(\"f1.txt\");\n read_file(\"source\/f2.txt\");\n read_file(\"other_file\");\n#else\n for (i = 0; i < 3; i++) {\n for (j = 0; j < 5; j++) {\n if (!text[i][j]) break;\n add_index(root, text[i][j], files[i]);\n }\n }\n#endif \n\n return root;\n}\n\nvoid search_index(trie root, const char *word)\n{\n char path[1024];\n printf(\"Search for \\\"%s\\\": \", word);\n trie found = find_word(root, word);\n\n if (!found) printf(\"not found\\n\");\n else {\n trie_all(found->next[FNAME], path, 0, print_path);\n printf(\"\\n\");\n }\n}\n\nint main()\n{\n trie root = init_tables();\n\n search_index(root, \"what\");\n search_index(root, \"is\");\n search_index(root, \"banana\");\n search_index(root, \"boo\");\n return 0;\n}\n","Rust":"\n\nuse std::{\n borrow::Borrow,\n collections::{BTreeMap, BTreeSet},\n};\n\n#[derive(Debug, Default)]\npub struct InvertedIndex<T> {\n indexed: BTreeMap<String, BTreeSet<usize>>,\n sources: Vec<T>,\n}\n\nimpl<T> InvertedIndex<T> {\n pub fn add<I, V>(&mut self, source: T, tokens: I)\n where\n I: IntoIterator<Item = V>,\n V: Into<String>,\n {\n let source_id = self.sources.len();\n self.sources.push(source);\n for token in tokens {\n self.indexed\n .entry(token.into())\n .or_insert_with(BTreeSet::new)\n .insert(source_id);\n }\n }\n\n pub fn search<'a, I, K>(&self, tokens: I) -> impl Iterator<Item = &T>\n where\n String: Borrow<K>,\n K: Ord + ?Sized + 'a,\n I: IntoIterator<Item = &'a K>,\n {\n let mut tokens = tokens.into_iter();\n\n tokens\n .next()\n .and_then(|token| self.indexed.get(token).cloned())\n .and_then(|first| {\n tokens.try_fold(first, |found, token| {\n self.indexed\n .get(token)\n .map(|sources| {\n found\n .intersection(sources)\n .cloned()\n .collect::<BTreeSet<_>>()\n })\n .filter(|update| !update.is_empty())\n })\n })\n .unwrap_or_else(BTreeSet::new)\n .into_iter()\n .map(move |source| &self.sources[source])\n }\n\n pub fn tokens(&self) -> impl Iterator<Item = &str> {\n self.indexed.keys().map(|it| it.as_str())\n }\n\n pub fn sources(&self) -> &[T] {\n &self.sources\n }\n}\n\n\n\nuse std::{\n ffi::OsString,\n fmt::{Debug, Display},\n fs::{read_dir, DirEntry, File, ReadDir},\n io::{self, stdin, Read},\n path::{Path, PathBuf},\n};\n\n#[derive(Debug)]\npub struct Files {\n dirs: Vec<ReadDir>,\n}\n\nimpl Files {\n pub fn walk<P: AsRef<Path>>(path: P) -> io::Result<Self> {\n Ok(Files {\n dirs: vec![read_dir(path)?],\n })\n }\n}\n\nimpl Iterator for Files {\n type Item = DirEntry;\n\n fn next(&mut self) -> Option<Self::Item> {\n 'outer: while let Some(mut current) = self.dirs.pop() {\n while let Some(entry) = current.next() {\n if let Ok(entry) = entry {\n let path = entry.path();\n if !path.is_dir() {\n self.dirs.push(current);\n return Some(entry);\n } else if let Ok(dir) = read_dir(path) {\n self.dirs.push(current);\n self.dirs.push(dir);\n continue 'outer;\n }\n }\n }\n }\n\n None \n }\n}\n\nfn tokenize<'a>(input: &'a str) -> impl Iterator<Item = String> + 'a {\n input\n .split(|c: char| !c.is_alphanumeric())\n .filter(|token| !token.is_empty())\n .map(|token| token.to_lowercase())\n}\n\nfn tokenize_file<P: AsRef<Path>>(path: P) -> io::Result<BTreeSet<String>> {\n let mut buffer = Vec::new();\n File::open(path)?.read_to_end(&mut buffer)?;\n let text = String::from_utf8_lossy(&buffer);\n Ok(tokenize(&text).collect::<BTreeSet<_>>())\n}\n\nfn tokenize_query(input: &str) -> Vec<String> {\n let result = tokenize(input).collect::<BTreeSet<_>>();\n \n \n let mut result = result.into_iter().collect::<Vec<_>>();\n result.sort_by_key(|item| usize::MAX - item.len());\n result\n}\n\n\n\nfn args() -> io::Result<(OsString, BTreeSet<OsString>)> {\n let mut args = std::env::args_os().skip(1); \n\n let path = args\n .next()\n .ok_or_else(|| io::Error::new(io::ErrorKind::Other, \"missing path\"))?;\n\n let extensions = args.collect::<BTreeSet<_>>();\n\n Ok((path, extensions))\n}\n\nfn print_hits<'a, T>(hits: impl Iterator<Item = T>)\nwhere\n T: Display,\n{\n let mut found_none = true;\n for (number, hit) in hits.enumerate() {\n println!(\" [{}] {}\", number + 1, hit);\n found_none = false;\n }\n\n if found_none {\n println!(\"(none)\")\n }\n}\n\nfn main() -> io::Result<()> {\n let (path, extensions) = args()?;\n let mut files = InvertedIndex::<PathBuf>::default();\n let mut content = InvertedIndex::<PathBuf>::default();\n\n println!(\n \"Indexing {:?} files in '{}'\",\n extensions,\n path.to_string_lossy()\n );\n\n for path in Files::walk(path)?.map(|file| file.path()).filter(|path| {\n path.extension()\n .filter(|&ext| extensions.is_empty() || extensions.contains(ext))\n .is_some()\n }) {\n files.add(path.clone(), tokenize(&path.to_string_lossy()));\n\n match tokenize_file(&path) {\n Ok(tokens) => content.add(path, tokens),\n Err(e) => eprintln!(\"Skipping a file {}: {}\", path.display(), e),\n }\n }\n\n println!(\n \"Indexed {} tokens in {} files.\",\n content.tokens().count(),\n content.sources.len()\n );\n\n \n let mut query = String::new();\n\n loop {\n query.clear();\n println!(\"Enter search query:\");\n if stdin().read_line(&mut query).is_err() || query.trim().is_empty() {\n break;\n }\n\n match query.trim() {\n \"\/exit\" | \"\/quit\" | \"\" => break,\n\n \"\/tokens\" => {\n println!(\"Tokens:\");\n for token in content.tokens() {\n println!(\"{}\", token);\n }\n\n println!();\n }\n\n \"\/files\" => {\n println!(\"Sources:\");\n for source in content.sources() {\n println!(\"{}\", source.display());\n }\n\n println!();\n }\n\n _ => {\n let query = tokenize_query(&query);\n println!();\n println!(\"Found hits:\");\n print_hits(content.search(query.iter()).map(|it| it.display()));\n println!(\"Found file names:\");\n print_hits(files.search(query.iter()).map(|it| it.display()));\n println!();\n }\n }\n }\n\n Ok(())\n}\n"} {"name":"Isqrt (integer square root) of X","C":"#include <stdint.h>\n#include <stdio.h>\n\nint64_t isqrt(int64_t x) {\n int64_t q = 1, r = 0;\n while (q <= x) {\n q <<= 2;\n }\n while (q > 1) {\n int64_t t;\n q >>= 2;\n t = x - r - q;\n r >>= 1;\n if (t >= 0) {\n x = t;\n r += q;\n }\n }\n return r;\n}\n\nint main() {\n int64_t p;\n int n;\n\n printf(\"Integer square root for numbers 0 to 65:\\n\");\n for (n = 0; n <= 65; n++) {\n printf(\"%lld \", isqrt(n));\n }\n printf(\"\\n\\n\");\n\n printf(\"Integer square roots of odd powers of 7 from 1 to 21:\\n\");\n printf(\" n | 7 ^ n | isqrt(7 ^ n)\\n\");\n p = 7;\n for (n = 1; n <= 21; n += 2, p *= 49) {\n printf(\"%2d | %18lld | %12lld\\n\", n, p, isqrt(p));\n }\n}\n","Rust":"use num::BigUint;\nuse num::CheckedSub;\nuse num_traits::{One, Zero};\n\nfn isqrt(number: &BigUint) -> BigUint {\n let mut q: BigUint = One::one();\n while q <= *number {\n q <<= &2;\n }\n\n let mut z = number.clone();\n let mut result: BigUint = Zero::zero();\n\n while q > One::one() {\n q >>= &2;\n let t = z.checked_sub(&result).and_then(|diff| diff.checked_sub(&q));\n result >>= &1;\n\n if let Some(t) = t {\n z = t;\n result += &q;\n }\n }\n\n result\n}\n\nfn with_thousand_separator(s: &str) -> String {\n let digits: Vec<_> = s.chars().rev().collect();\n let chunks: Vec<_> = digits\n .chunks(3)\n .map(|chunk| chunk.iter().collect::<String>())\n .collect();\n\n chunks.join(\",\").chars().rev().collect::<String>()\n}\n\nfn main() {\n println!(\"The integer square roots of integers from 0 to 65 are:\");\n (0_u32..=65).for_each(|n| print!(\"{} \", isqrt(&n.into())));\n\n println!(\"\\nThe integer square roots of odd powers of 7 from 7^1 up to 7^74 are:\");\n (1_u32..75).step_by(2).for_each(|exp| {\n println!(\n \"7^{:>2}={:>83} ISQRT: {:>42} \",\n exp,\n with_thousand_separator(&BigUint::from(7_u8).pow(exp).to_string()),\n with_thousand_separator(&isqrt(&BigUint::from(7_u8).pow(exp)).to_string())\n )\n });\n}\n"} {"name":"Iterated digits squaring","C":"#include <stdio.h>\n\ntypedef unsigned long long ull;\n\nint is89(int x)\n{\n\twhile (1) {\n\t\tint s = 0;\n\t\tdo s += (x%10)*(x%10); while ((x \/= 10));\n\n\t\tif (s == 89) return 1;\n\t\tif (s == 1) return 0;\n\t\tx = s;\n\t}\n}\n\n\nint main(void)\n{\n\t\n\tull sums[32*81 + 1] = {1, 0};\n\n\tfor (int n = 1; ; n++) {\n\t\tfor (int i = n*81; i; i--) {\n\t\t\tfor (int j = 1; j < 10; j++) {\n\t\t\t\tint s = j*j;\n\t\t\t\tif (s > i) break;\n\t\t\t\tsums[i] += sums[i-s];\n\t\t\t}\n\t\t}\n\n\t\tull count89 = 0;\n\t\tfor (int i = 1; i < n*81 + 1; i++) {\n\t\t\tif (!is89(i)) continue;\n\n\t\t\tif (sums[i] > ~0ULL - count89) {\n\t\t\t\tprintf(\"counter overflow for 10^%d\\n\", n);\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t\tcount89 += sums[i];\n\t\t}\n\n\t\tprintf(\"1->10^%d: %llu\\n\", n, count89);\n\t}\n\n\treturn 0;\n}\n","Rust":"fn digit_square_sum(mut num: usize) -> usize {\n let mut sum = 0;\n while num != 0 {\n sum += (num % 10).pow(2);\n num \/= 10;\n }\n sum\n}\n\nfn last_in_chain(num: usize) -> usize {\n match num {\n 1 | 89 => num,\n _ => last_in_chain(digit_square_sum(num)),\n }\n}\n\nfn main() {\n let count = (1..100_000_000).filter(|&n| last_in_chain(n) == 89).count();\n println!(\"{}\", count);\n}\n"} {"name":"JSON","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <yajl\/yajl_tree.h>\n#include <yajl\/yajl_gen.h>\n\nstatic void print_callback (void *ctx, const char *str, size_t len)\n{\n FILE *f = (FILE *) ctx;\n fwrite (str, 1, len, f);\n}\n\nstatic void check_status (yajl_gen_status status)\n{\n if (status != yajl_gen_status_ok)\n {\n fprintf (stderr, \"yajl_gen_status was %d\\n\", (int) status);\n exit (EXIT_FAILURE);\n }\n}\n\nstatic void serialize_value (yajl_gen gen, yajl_val val, int parse_numbers)\n{\n size_t i;\n\n switch (val->type)\n {\n case yajl_t_string:\n check_status (yajl_gen_string (gen,\n (const unsigned char *) val->u.string,\n strlen (val->u.string)));\n break;\n case yajl_t_number:\n if (parse_numbers && YAJL_IS_INTEGER (val))\n check_status (yajl_gen_integer (gen, YAJL_GET_INTEGER (val)));\n else if (parse_numbers && YAJL_IS_DOUBLE (val))\n check_status (yajl_gen_double (gen, YAJL_GET_DOUBLE (val)));\n else\n check_status (yajl_gen_number (gen, YAJL_GET_NUMBER (val),\n strlen (YAJL_GET_NUMBER (val))));\n break;\n case yajl_t_object:\n check_status (yajl_gen_map_open (gen));\n for (i = 0 ; i < val->u.object.len ; i++)\n {\n check_status (yajl_gen_string (gen,\n (const unsigned char *) val->u.object.keys[i],\n strlen (val->u.object.keys[i])));\n serialize_value (gen, val->u.object.values[i], parse_numbers);\n }\n check_status (yajl_gen_map_close (gen));\n break;\n case yajl_t_array:\n check_status (yajl_gen_array_open (gen));\n for (i = 0 ; i < val->u.array.len ; i++)\n serialize_value (gen, val->u.array.values[i], parse_numbers);\n check_status (yajl_gen_array_close (gen));\n break;\n case yajl_t_true:\n check_status (yajl_gen_bool (gen, 1));\n break;\n case yajl_t_false:\n check_status (yajl_gen_bool (gen, 0));\n break;\n case yajl_t_null:\n check_status (yajl_gen_null (gen));\n break;\n default:\n fprintf (stderr, \"unexpectedly got type %d\\n\", (int) val->type);\n exit (EXIT_FAILURE);\n }\n}\n\nstatic void print_tree (FILE *f, yajl_val tree, int parse_numbers)\n{\n yajl_gen gen;\n\n gen = yajl_gen_alloc (NULL);\n if (! gen)\n {\n fprintf (stderr, \"yajl_gen_alloc failed\\n\");\n exit (EXIT_FAILURE);\n }\n\n if (0 == yajl_gen_config (gen, yajl_gen_beautify, 1) ||\n 0 == yajl_gen_config (gen, yajl_gen_validate_utf8, 1) ||\n 0 == yajl_gen_config (gen, yajl_gen_print_callback, print_callback, f))\n {\n fprintf (stderr, \"yajl_gen_config failed\\n\");\n exit (EXIT_FAILURE);\n }\n\n serialize_value (gen, tree, parse_numbers);\n yajl_gen_free (gen);\n}\n\nint main (int argc, char **argv)\n{\n char err_buf[200];\n const char *json =\n \"{\\\"pi\\\": 3.14, \\\"large number\\\": 123456789123456789123456789, \"\n \"\\\"an array\\\": [-1, true, false, null, \\\"foo\\\"]}\";\n yajl_val tree;\n\n tree = yajl_tree_parse (json, err_buf, sizeof (err_buf));\n if (! tree)\n {\n fprintf (stderr, \"parsing failed because: %s\\n\", err_buf);\n return EXIT_FAILURE;\n }\n\n printf (\"Treating numbers as strings...\\n\");\n print_tree (stdout, tree, 0);\n printf (\"Parsing numbers to long long or double...\\n\");\n print_tree (stdout, tree, 1);\n\n yajl_tree_free (tree);\n\n return EXIT_SUCCESS;\n}\n","Rust":"use serde::{Serialize, Deserialize};\n\n#[derive(Serialize, Deserialize, Debug)]\nstruct Point {\n x: i32,\n y: i32,\n}\n"} {"name":"Jensen's Device","C":"#include <stdio.h>\n\nint i;\ndouble sum(int *i, int lo, int hi, double (*term)()) {\n double temp = 0;\n for (*i = lo; *i <= hi; (*i)++)\n temp += term();\n return temp;\n}\n\ndouble term_func() { return 1.0 \/ i; }\n\nint main () {\n printf(\"%f\\n\", sum(&i, 1, 100, term_func));\n return 0;\n}\n","Rust":"use std::f32;\n\nfn harmonic_sum<F>(lo: usize, hi: usize, term: F) -> f32\nwhere\n F: Fn(f32) -> f32,\n{\n (lo..hi + 1).fold(0.0, |acc, item| acc + term(item as f32))\n}\n\nfn main() {\n println!(\"{}\", harmonic_sum(1, 100, |i| 1.0 \/ i));\n}\n"} {"name":"Jewels and stones","C":"#include <stdio.h>\n#include <string.h>\n\nint count_jewels(const char *s, const char *j) {\n int count = 0;\n for ( ; *s; ++s) if (strchr(j, *s)) ++count;\n return count;\n}\n\nint main() {\n printf(\"%d\\n\", count_jewels(\"aAAbbbb\", \"aA\"));\n printf(\"%d\\n\", count_jewels(\"ZZ\", \"z\"));\n return 0;\n}\n","Rust":"fn count_jewels(stones: &str, jewels: &str) -> u8 {\n let mut count: u8 = 0;\n for cur_char in stones.chars() {\n if jewels.contains(cur_char) {\n count += 1;\n }\n }\n count\n}\nfn main() {\n println!(\"{}\", count_jewels(\"aAAbbbb\", \"aA\"));\n println!(\"{}\", count_jewels(\"ZZ\", \"z\"));\n}\n"} {"name":"JortSort","C":"#include <stdio.h>\n#include <stdlib.h>\n\n\n\nint number_of_digits(int x){\n int NumberOfDigits;\n for(NumberOfDigits=0;x!=0;NumberOfDigits++){\n x=x\/10;\n }\n return NumberOfDigits;\n}\n\nint* convert_array(char array[], int NumberOfElements) \n{\n int *convertedArray=malloc(NumberOfElements*sizeof(int));\n int originalElement, convertedElement;\n\n for(convertedElement=0, originalElement=0; convertedElement<NumberOfElements; convertedElement++)\n {\n convertedArray[convertedElement]=atoi(&array[originalElement]);\n originalElement+=number_of_digits(convertedArray[convertedElement])+1; \n\n }\n return convertedArray;\n}\n\n\n\nint isSorted(int array[], int numberOfElements){\n int sorted=1;\n for(int counter=0;counter<numberOfElements;counter++){\n if(counter!=0 && array[counter-1]>array[counter]) sorted--;\n\n }\n return sorted;\n}\nint main(int argc, char* argv[])\n{\n int* convertedArray;\n\n\n convertedArray=convert_array(*(argv+1), argc-1);\n\n\n\n if(isSorted(convertedArray, argc-1)==1) printf(\"Did you forgot to turn on your brain?! This array is already sorted!\\n\");\n else if(argc-1<=10) printf(\"Am I really supposed to sort this? Sort it by yourself!\\n\");\n else printf(\"Am I really supposed to sort this? Bhahahaha!\\n\");\n free(convertedArray);\n return 0;\n\n\n\n}\n","Rust":"use std::cmp::{Ord, Eq};\n\nfn jort_sort<T: Ord + Eq + Clone>(array: Vec<T>) -> bool {\n \n let mut sorted_array = array.to_vec();\n sorted_array.sort();\n \n \n for i in 0..array.len() {\n if array[i] != sorted_array[i] {\n return false;\n }\n }\n\n return true;\n}\n"} {"name":"Josephus problem","C":"#include <stdio.h>\n\n\nint jos(int n, int k, int m) {\n\tint a;\n\tfor (a = m + 1; a <= n; a++)\n\t\tm = (m + k) % a;\n\treturn m;\n}\n\ntypedef unsigned long long xint;\n\n\nxint jos_large(xint n, xint k, xint m) {\n\tif (k <= 1) return n - m - 1;\n\n\txint a = m;\n\twhile (a < n) {\n\t\txint q = (a - m + k - 2) \/ (k - 1);\n\n\t\tif (a + q > n)\tq = n - a;\n\t\telse if (!q)\tq = 1;\n\n\t\tm = (m + q * k) % (a += q);\n\t}\n\n\treturn m;\n}\n\nint main(void) {\n\txint n, k, i;\n\n\tn = 41;\n\tk = 3;\n\tprintf(\"n = %llu, k = %llu, final survivor: %d\\n\", n, k, jos(n, k, 0));\n\n\tn = 9876543210987654321ULL;\n\tk = 12031;\n\tprintf(\"n = %llu, k = %llu, three survivors:\", n, k);\n\n\tfor (i = 3; i--; )\n\t\tprintf(\" %llu\", jos_large(n, k, i));\n\tputchar('\\n');\n\n\treturn 0;\n}\n","Rust":"const N: usize = 41;\nconst K: usize = 3;\nconst M: usize = 3;\nconst POSITION: usize = 5;\n\nfn main() {\n let mut prisoners: Vec<usize> = Vec::new();\n let mut executed: Vec<usize> = Vec::new();\n for pos in 0..N {\n prisoners.push(pos);\n }\n\n let mut to_kill: usize = 0;\n let mut len: usize = prisoners.len();\n\n while len > M {\n to_kill = (to_kill + K - 1) % len;\n executed.push(prisoners.remove(to_kill));\n len -= 1;\n }\n\n println!(\"JOSEPHUS n={}, k={}, m={}\", N, K, M);\n println!(\"Executed: {:?}\", executed);\n println!(\"Executed position number {}: {}\", POSITION, executed[POSITION - 1]);\n println!(\"Survivors: {:?}\", prisoners);\n}\n"} {"name":"Julia set","C":"#include<graphics.h>\n#include<stdlib.h>\n#include<math.h>\n\ntypedef struct{\n\tdouble x,y;\n}complex;\n\ncomplex add(complex a,complex b){\n\tcomplex c;\n\tc.x = a.x + b.x;\n\tc.y = a.y + b.y;\n\treturn c;\n}\n\ncomplex sqr(complex a){\n\tcomplex c;\n\tc.x = a.x*a.x - a.y*a.y;\n\tc.y = 2*a.x*a.y;\n\treturn c;\n}\n\ndouble mod(complex a){\n\treturn sqrt(a.x*a.x + a.y*a.y);\n}\n\ncomplex mapPoint(int width,int height,double radius,int x,int y){\n\tcomplex c;\n\tint l = (width<height)?width:height;\n\t\n\tc.x = 2*radius*(x - width\/2.0)\/l;\n\tc.y = 2*radius*(y - height\/2.0)\/l;\n\t\n\treturn c;\n}\n\nvoid juliaSet(int width,int height,complex c,double radius,int n){\n\tint x,y,i;\n\tcomplex z0,z1;\n\t\n\tfor(x=0;x<=width;x++)\n\t\tfor(y=0;y<=height;y++){\n\t\t\tz0 = mapPoint(width,height,radius,x,y);\n\t\t\tfor(i=1;i<=n;i++){\n\t\t\t\tz1 = add(sqr(z0),c);\n\t\t\t\tif(mod(z1)>radius){\n\t\t\t\t\tputpixel(x,y,i%15+1);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tz0 = z1;\n\t\t\t}\n\t\t\tif(i>n)\n\t\t\t\tputpixel(x,y,0);\n\t\t}\n}\n\nint main(int argC, char* argV[])\n{\n\tint width, height;\n\tcomplex c;\n\t\n\tif(argC != 7)\n\t\tprintf(\"Usage\u00a0: %s <width and height of screen, real and imaginary parts of c, limit radius and iterations>\");\n\telse{\n\t\twidth = atoi(argV[1]);\n\t\theight = atoi(argV[2]);\n\t\t\n\t\tc.x = atof(argV[3]);\n\t\tc.y = atof(argV[4]);\n\t\t\n\t\tinitwindow(width,height,\"Julia Set\");\n\t\tjuliaSet(width,height,c,atof(argV[5]),atoi(argV[6]));\n\t\t\n\t\tgetch();\n\t}\n\t\n\treturn 0;\n}\n","Rust":"extern crate image;\n\nuse image::{ImageBuffer, Pixel, Rgb};\n\nfn main() {\n \n let width = 8000;\n let height = 6000;\n\n let mut img = ImageBuffer::new(width as u32, height as u32);\n\n \n let cx = -0.9;\n let cy = 0.27015;\n let iterations = 110;\n\n for x in 0..width {\n for y in 0..height {\n let inner_height = height as f32;\n let inner_width = width as f32;\n let inner_y = y as f32;\n let inner_x = x as f32;\n\n let mut zx = 3.0 * (inner_x - 0.5 * inner_width) \/ (inner_width);\n let mut zy = 2.0 * (inner_y - 0.5 * inner_height) \/ (inner_height);\n\n let mut i = iterations;\n\n while zx * zx + zy * zy < 4.0 && i > 1 {\n let tmp = zx * zx - zy * zy + cx;\n zy = 2.0 * zx * zy + cy;\n zx = tmp;\n i -= 1;\n }\n\n \n let r = (i << 3) as u8;\n let g = (i << 5) as u8;\n let b = (i << 4) as u8;\n let pixel = Rgb::from_channels(r, g, b, 0);\n img.put_pixel(x as u32, y as u32, pixel);\n }\n }\n\n let _ = img.save(\"output.png\");\n\n}\n"} {"name":"Kernighans large earthquake problem","C":"#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\nint main() {\n FILE *fp;\n char *line = NULL;\n size_t len = 0;\n ssize_t read;\n char *lw, *lt;\n fp = fopen(\"data.txt\", \"r\");\n if (fp == NULL) {\n printf(\"Unable to open file\\n\");\n exit(1);\n }\n printf(\"Those earthquakes with a magnitude > 6.0 are:\\n\\n\");\n while ((read = getline(&line, &len, fp)) != EOF) {\n if (read < 2) continue; \n lw = strrchr(line, ' '); \n lt = strrchr(line, '\\t'); \n if (!lw && !lt) continue; \n if (lt > lw) lw = lt; \n if (atof(lw + 1) > 6.0) printf(\"%s\", line);\n }\n fclose(fp);\n if (line) free(line);\n return 0;\n}\n","Rust":"fn main() -> Result<(), Box<dyn std::error::Error>> {\n use std::io::{BufRead, BufReader};\n\n for line in BufReader::new(std::fs::OpenOptions::new().read(true).open(\"data.txt\")?).lines() {\n let line = line?;\n\n let magnitude = line\n .split_whitespace()\n .nth(2)\n .and_then(|it| it.parse::<f32>().ok())\n .ok_or_else(|| format!(\"Could not parse scale: {}\", line))?;\n\n if magnitude > 6.0 {\n println!(\"{}\", line);\n }\n }\n\n Ok(())\n}\n"} {"name":"Knapsack problem_0-1","C":"#include <stdio.h>\n#include <stdlib.h>\n\ntypedef struct {\n char *name;\n int weight;\n int value;\n} item_t;\n\nitem_t items[] = {\n {\"map\", 9, 150},\n {\"compass\", 13, 35},\n {\"water\", 153, 200},\n {\"sandwich\", 50, 160},\n {\"glucose\", 15, 60},\n {\"tin\", 68, 45},\n {\"banana\", 27, 60},\n {\"apple\", 39, 40},\n {\"cheese\", 23, 30},\n {\"beer\", 52, 10},\n {\"suntan cream\", 11, 70},\n {\"camera\", 32, 30},\n {\"T-shirt\", 24, 15},\n {\"trousers\", 48, 10},\n {\"umbrella\", 73, 40},\n {\"waterproof trousers\", 42, 70},\n {\"waterproof overclothes\", 43, 75},\n {\"note-case\", 22, 80},\n {\"sunglasses\", 7, 20},\n {\"towel\", 18, 12},\n {\"socks\", 4, 50},\n {\"book\", 30, 10},\n};\n\nint *knapsack (item_t *items, int n, int w) {\n int i, j, a, b, *mm, **m, *s;\n mm = calloc((n + 1) * (w + 1), sizeof (int));\n m = malloc((n + 1) * sizeof (int *));\n m[0] = mm;\n for (i = 1; i <= n; i++) {\n m[i] = &mm[i * (w + 1)];\n for (j = 0; j <= w; j++) {\n if (items[i - 1].weight > j) {\n m[i][j] = m[i - 1][j];\n }\n else {\n a = m[i - 1][j];\n b = m[i - 1][j - items[i - 1].weight] + items[i - 1].value;\n m[i][j] = a > b ? a : b;\n }\n }\n }\n s = calloc(n, sizeof (int));\n for (i = n, j = w; i > 0; i--) {\n if (m[i][j] > m[i - 1][j]) {\n s[i - 1] = 1;\n j -= items[i - 1].weight;\n }\n }\n free(mm);\n free(m);\n return s;\n}\n\nint main () {\n int i, n, tw = 0, tv = 0, *s;\n n = sizeof (items) \/ sizeof (item_t);\n s = knapsack(items, n, 400);\n for (i = 0; i < n; i++) {\n if (s[i]) {\n printf(\"%-22s %5d %5d\\n\", items[i].name, items[i].weight, items[i].value);\n tw += items[i].weight;\n tv += items[i].value;\n }\n }\n printf(\"%-22s %5d %5d\\n\", \"totals:\", tw, tv);\n return 0;\n}\n","Rust":"use std::cmp;\n\nstruct Item {\n name: &'static str,\n weight: usize,\n value: usize\n}\n\nfn knapsack01_dyn(items: &[Item], max_weight: usize) -> Vec<&Item> {\n let mut best_value = vec![vec![0; max_weight + 1]; items.len() + 1];\n for (i, it) in items.iter().enumerate() {\n for w in 1 .. max_weight + 1 {\n best_value[i + 1][w] =\n if it.weight > w {\n best_value[i][w]\n } else {\n cmp::max(best_value[i][w], best_value[i][w - it.weight] + it.value)\n }\n }\n }\n\n let mut result = Vec::with_capacity(items.len());\n let mut left_weight = max_weight;\n\n for (i, it) in items.iter().enumerate().rev() {\n if best_value[i + 1][left_weight] != best_value[i][left_weight] {\n result.push(it);\n left_weight -= it.weight;\n }\n }\n\n result\n}\n\n\nfn main () {\n const MAX_WEIGHT: usize = 400;\n\n const ITEMS: &[Item] = &[\n Item { name: \"map\", weight: 9, value: 150 },\n Item { name: \"compass\", weight: 13, value: 35 },\n Item { name: \"water\", weight: 153, value: 200 },\n Item { name: \"sandwich\", weight: 50, value: 160 },\n Item { name: \"glucose\", weight: 15, value: 60 },\n Item { name: \"tin\", weight: 68, value: 45 },\n Item { name: \"banana\", weight: 27, value: 60 },\n Item { name: \"apple\", weight: 39, value: 40 },\n Item { name: \"cheese\", weight: 23, value: 30 },\n Item { name: \"beer\", weight: 52, value: 10 },\n Item { name: \"suntancream\", weight: 11, value: 70 },\n Item { name: \"camera\", weight: 32, value: 30 },\n Item { name: \"T-shirt\", weight: 24, value: 15 },\n Item { name: \"trousers\", weight: 48, value: 10 },\n Item { name: \"umbrella\", weight: 73, value: 40 },\n Item { name: \"waterproof trousers\", weight: 42, value: 70 },\n Item { name: \"waterproof overclothes\", weight: 43, value: 75 },\n Item { name: \"note-case\", weight: 22, value: 80 },\n Item { name: \"sunglasses\", weight: 7, value: 20 },\n Item { name: \"towel\", weight: 18, value: 12 },\n Item { name: \"socks\", weight: 4, value: 50 },\n Item { name: \"book\", weight: 30, value: 10 }\n ];\n\n let items = knapsack01_dyn(ITEMS, MAX_WEIGHT);\n\n \n for it in items.iter().rev() {\n println!(\"{}\", it.name);\n }\n\n println!(\"Total weight: {}\", items.iter().map(|w| w.weight).sum::<usize>());\n println!(\"Total value: {}\", items.iter().map(|w| w.value).sum::<usize>());\n}\n"} {"name":"Knapsack problem_Continuous","C":"#include <stdio.h>\n#include <stdlib.h>\n\nstruct item { double w, v; const char *name; } items[] = {\n\t{ 3.8, 36, \"beef\" },\n\t{ 5.4, 43, \"pork\" },\n\t{ 3.6, 90, \"ham\" },\n\t{ 2.4, 45, \"greaves\" },\n\t{ 4.0, 30, \"flitch\" },\n\t{ 2.5, 56, \"brawn\" },\n\t{ 3.7, 67, \"welt\" },\n\t{ 3.0, 95, \"salami\" },\n\t{ 5.9, 98, \"sausage\" },\n};\n\nint item_cmp(const void *aa, const void *bb)\n{\n\tconst struct item *a = aa, *b = bb;\n\tdouble ua = a->v \/ a->w, ub = b->v \/ b->w;\n\treturn ua < ub ? -1 : ua > ub;\n}\n\nint main()\n{\n\tstruct item *it;\n\tdouble space = 15;\n\n\tqsort(items, 9, sizeof(struct item), item_cmp);\n\tfor (it = items + 9; it---items && space > 0; space -= it->w)\n\t\tif (space >= it->w)\n\t\t\tprintf(\"take all %s\\n\", it->name);\n\t\telse\n\t\t\tprintf(\"take %gkg of %g kg of %s\\n\",\n\t\t\t\tspace, it->w, it->name);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n let items: [(&str, f32, u8); 9] = [\n (\"beef\", 3.8, 36),\n (\"pork\", 5.4, 43),\n (\"ham\", 3.6, 90),\n (\"greaves\", 2.4, 45),\n (\"flitch\", 4.0, 30),\n (\"brawn\", 2.5, 56),\n (\"welt\", 3.7, 67),\n (\"salami\", 3.0, 95),\n (\"sausage\", 5.9, 98),\n ];\n let mut weight: f32 = 15.0;\n let mut values: Vec<(&str, f32, f32)> = Vec::new();\n for item in &items {\n values.push((item.0, f32::from(item.2) \/ item.1, item.1));\n }\n\n values.sort_by(|a, b| (a.1).partial_cmp(&b.1).unwrap());\n values.reverse();\n\n for choice in values {\n if choice.2 <= weight {\n println!(\"Grab {:.1} kgs of {}\", choice.2, choice.0);\n weight -= choice.2;\n if (choice.2 - weight).abs() < std::f32::EPSILON {\n return;\n }\n } else {\n println!(\"Grab {:.1} kgs of {}\", weight, choice.0);\n return;\n }\n }\n}\n"} {"name":"Knight's tour","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <unistd.h>\n\ntypedef unsigned char cell;\nint dx[] = { -2, -2, -1, 1, 2, 2, 1, -1 };\nint dy[] = { -1, 1, 2, 2, 1, -1, -2, -2 };\n\nvoid init_board(int w, int h, cell **a, cell **b)\n{\n\tint i, j, k, x, y, p = w + 4, q = h + 4;\n\t\n\ta[0] = (cell*)(a + q);\n\tb[0] = a[0] + 2;\n\n\tfor (i = 1; i < q; i++) {\n\t\ta[i] = a[i-1] + p;\n\t\tb[i] = a[i] + 2;\n\t}\n\n\tmemset(a[0], 255, p * q);\n\tfor (i = 0; i < h; i++) {\n\t\tfor (j = 0; j < w; j++) {\n\t\t\tfor (k = 0; k < 8; k++) {\n\t\t\t\tx = j + dx[k], y = i + dy[k];\n\t\t\t\tif (b[i+2][j] == 255) b[i+2][j] = 0;\n\t\t\t\tb[i+2][j] += x >= 0 && x < w && y >= 0 && y < h;\n\t\t\t}\n\t\t}\n\t}\n}\n\n#define E \"\\033[\"\nint walk_board(int w, int h, int x, int y, cell **b)\n{\n\tint i, nx, ny, least;\n\tint steps = 0;\n\tprintf(E\"H\"E\"J\"E\"%d;%dH\"E\"32m[]\"E\"m\", y + 1, 1 + 2 * x);\n\n\twhile (1) {\n\t\t\n\t\tb[y][x] = 255;\n\n\t\t\n\t\tfor (i = 0; i < 8; i++)\n\t\t\tb[ y + dy[i] ][ x + dx[i] ]--;\n\n\t\t\n\t\tleast = 255;\n\t\tfor (i = 0; i < 8; i++) {\n\t\t\tif (b[ y + dy[i] ][ x + dx[i] ] < least) {\n\t\t\t\tnx = x + dx[i];\n\t\t\t\tny = y + dy[i];\n\t\t\t\tleast = b[ny][nx];\n\t\t\t}\n\t\t}\n\n\t\tif (least > 7) {\n\t\t\tprintf(E\"%dH\", h + 2);\n\t\t\treturn steps == w * h - 1;\n\t\t}\n\n\t\tif (steps++) printf(E\"%d;%dH[]\", y + 1, 1 + 2 * x);\n\t\tx = nx, y = ny;\n\t\tprintf(E\"%d;%dH\"E\"31m[]\"E\"m\", y + 1, 1 + 2 * x);\n\t\tfflush(stdout);\n\t\tusleep(120000);\n\t}\n}\n\nint solve(int w, int h)\n{\n\tint x = 0, y = 0;\n\tcell **a, **b;\n\ta = malloc((w + 4) * (h + 4) + sizeof(cell*) * (h + 4));\n\tb = malloc((h + 4) * sizeof(cell*));\n\n\twhile (1) {\n\t\tinit_board(w, h, a, b);\n\t\tif (walk_board(w, h, x, y, b + 2)) {\n\t\t\tprintf(\"Success!\\n\");\n\t\t\treturn 1;\n\t\t}\n\t\tif (++x >= w) x = 0, y++;\n\t\tif (y >= h) {\n\t\t\tprintf(\"Failed to find a solution\\n\");\n\t\t\treturn 0;\n\t\t}\n\t\tprintf(\"Any key to try next start position\");\n\t\tgetchar();\n\t}\n}\n\nint main(int c, char **v)\n{\n\tint w, h;\n\tif (c < 2 || (w = atoi(v[1])) <= 0) w = 8;\n\tif (c < 3 || (h = atoi(v[2])) <= 0) h = w;\n\tsolve(w, h);\n\n\treturn 0;\n}\n","Rust":"use std::fmt;\n\nconst SIZE: usize = 8;\nconst MOVES: [(i32, i32); 8] = [\n (2, 1),\n (1, 2),\n (-1, 2),\n (-2, 1),\n (-2, -1),\n (-1, -2),\n (1, -2),\n (2, -1),\n];\n\n#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]\nstruct Point {\n x: i32,\n y: i32,\n}\n\nimpl Point {\n fn mov(&self, &(dx, dy): &(i32, i32)) -> Self {\n Self {\n x: self.x + dx,\n y: self.y + dy,\n }\n }\n}\n\nstruct Board {\n field: [[i32; SIZE]; SIZE],\n}\n\nimpl Board {\n fn new() -> Self {\n Self {\n field: [[0; SIZE]; SIZE],\n }\n }\n\n fn available(&self, p: Point) -> bool {\n 0 <= p.x\n && p.x < SIZE as i32\n && 0 <= p.y\n && p.y < SIZE as i32\n && self.field[p.x as usize][p.y as usize] == 0\n }\n\n \n fn count_degree(&self, p: Point) -> i32 {\n let mut count = 0;\n for dir in MOVES.iter() {\n let next = p.mov(dir);\n if self.available(next) {\n count += 1;\n }\n }\n count\n }\n}\n\nimpl fmt::Display for Board {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n for row in self.field.iter() {\n for x in row.iter() {\n write!(f, \"{:3} \", x)?;\n }\n write!(f, \"\\n\")?;\n }\n Ok(())\n }\n}\n\nfn knights_tour(x: i32, y: i32) -> Option<Board> {\n let mut board = Board::new();\n let mut p = Point { x: x, y: y };\n let mut step = 1;\n board.field[p.x as usize][p.y as usize] = step;\n step += 1;\n\n while step <= (SIZE * SIZE) as i32 {\n \n let mut candidates = vec![];\n for dir in MOVES.iter() {\n let adj = p.mov(dir);\n if board.available(adj) {\n let degree = board.count_degree(adj);\n candidates.push((degree, adj));\n }\n }\n match candidates.iter().min() {\n \n Some(&(_, adj)) => p = adj,\n \n None => return None,\n };\n board.field[p.x as usize][p.y as usize] = step;\n step += 1;\n }\n Some(board)\n}\n\nfn main() {\n let (x, y) = (3, 1);\n println!(\"Board size: {}\", SIZE);\n println!(\"Starting position: ({}, {})\", x, y);\n match knights_tour(x, y) {\n Some(b) => print!(\"{}\", b),\n None => println!(\"Fail!\"),\n }\n}\n"} {"name":"Knuth shuffle","C":"#include <stdlib.h>\n#include <string.h>\n\nint rrand(int m)\n{\n return (int)((double)m * ( rand() \/ (RAND_MAX+1.0) ));\n}\n\n#define BYTE(X) ((unsigned char *)(X)) \nvoid shuffle(void *obj, size_t nmemb, size_t size)\n{\n void *temp = malloc(size);\n size_t n = nmemb;\n while ( n > 1 ) {\n size_t k = rrand(n--);\n memcpy(temp, BYTE(obj) + n*size, size);\n memcpy(BYTE(obj) + n*size, BYTE(obj) + k*size, size);\n memcpy(BYTE(obj) + k*size, temp, size);\n }\n free(temp);\n}\n","Rust":"use rand::Rng;\n\nextern crate rand;\n\nfn knuth_shuffle<T>(v: &mut [T]) {\n let mut rng = rand::thread_rng();\n let l = v.len();\n\n for n in 0..l {\n let i = rng.gen_range(0, l - n);\n v.swap(i, l - n - 1);\n }\n}\n\nfn main() {\n let mut v: Vec<_> = (0..10).collect();\n\n println!(\"before: {:?}\", v);\n knuth_shuffle(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Kronecker product","C":"#include<stdlib.h>\n#include<stdio.h>\n\nint main(){\n\t\n\tchar input[100],output[100];\n\tint i,j,k,l,rowA,colA,rowB,colB,rowC,colC,startRow,startCol;\n\tdouble **matrixA,**matrixB,**matrixC;\n\t\n\tprintf(\"Enter full path of input file\u00a0: \");\n\tfscanf(stdin,\"%s\",input);\n\t\n\tprintf(\"Enter full path of output file\u00a0: \");\n\tfscanf(stdin,\"%s\",output);\n\t\n\tFILE* inputFile = fopen(input,\"r\");\n\t\n\tfscanf(inputFile,\"%d%d\",&rowA,&colA);\n\t\n\tmatrixA = (double**)malloc(rowA * sizeof(double*));\n\t\n\tfor(i=0;i<rowA;i++){\n\t\tmatrixA[i] = (double*)malloc(colA*sizeof(double));\n\t\tfor(j=0;j<colA;j++){\n\t\t\tfscanf(inputFile,\"%lf\",&matrixA[i][j]);\n\t\t}\n\t}\n\t\n\tfscanf(inputFile,\"%d%d\",&rowB,&colB);\n\t\n\tmatrixB = (double**)malloc(rowB * sizeof(double*));\n\t\n\tfor(i=0;i<rowB;i++){\n\t\tmatrixB[i] = (double*)malloc(colB*sizeof(double));\n\t\tfor(j=0;j<colB;j++){\n\t\t\tfscanf(inputFile,\"%lf\",&matrixB[i][j]);\n\t\t}\n\t}\n\t\n\tfclose(inputFile);\n\t\n\trowC = rowA*rowB;\n\tcolC = colA*colB;\n\t\n\tmatrixC = (double**)malloc(rowC*sizeof(double*));\n\t\n\tfor(i=0;i<rowA*rowB;i++){\n\t\tmatrixC[i] = (double*)malloc(colA*colB*sizeof(double));\n\t}\n\t\n\tfor(i=0;i<rowA;i++){\n\t\tfor(j=0;j<colA;j++){\n\t\t\tstartRow = i*rowB;\n\t\t\tstartCol = j*colB;\n\t\t\tfor(k=0;k<rowB;k++){\n\t\t\t\tfor(l=0;l<colB;l++){\n\t\t\t\t\tmatrixC[startRow+k][startCol+l] = matrixA[i][j]*matrixB[k][l];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tFILE* outputFile = fopen(output,\"w\");\n\t\n\tfor(i=0;i<rowC;i++){\n\t\tfor(j=0;j<colC;j++){\n\t\t\tfprintf(outputFile,\"%lf\\t\",matrixC[i][j]);\n\t\t}\n\t\tfprintf(outputFile,\"\\n\");\n\t}\n\t\n\tfclose(outputFile);\n\t\n\tprintf(\"\\n\\n\\nKronecker product of the two matrices written to %s.\",output);\n}\n","Rust":"fn main() {\n\n let mut a = vec![vec![1., 2.], vec![3., 4.]];\n let mut b = vec![vec![0., 5.], vec![6., 7.]];\n\n let mut a_ref = &mut a;\n let a_rref = &mut a_ref;\n\n let mut b_ref = &mut b;\n let b_rref = &mut b_ref;\n\n let ab = kronecker_product(a_rref, b_rref);\n\n println!(\"Kronecker product of\\n\");\n for i in a {\n println!(\"{:?}\", i);\n }\n println!(\"\\nand\\n\");\n for i in b {\n println!(\"{:?}\", i);\n }\n println!(\"\\nis\\n\");\n for i in ab {\n println!(\"{:?}\", i);\n }\n\n println!(\"\\n\\n\");\n\n let mut a = vec![vec![0., 1., 0.],\n vec![1., 1., 1.],\n vec![0., 1., 0.]];\n let mut b = vec![vec![1., 1., 1., 1.],\n vec![1., 0., 0., 1.],\n vec![1., 1., 1., 1.]];\n\n let mut a_ref = &mut a;\n let a_rref = &mut a_ref;\n\n let mut b_ref = &mut b;\n let b_rref = &mut b_ref;\n\n let ab = kronecker_product(a_rref, b_rref);\n\n println!(\"Kronecker product of\\n\");\n for i in a {\n println!(\"{:?}\", i);\n }\n println!(\"\\nand\\n\");\n for i in b {\n println!(\"{:?}\", i);\n }\n println!(\"\\nis\\n\");\n for i in ab {\n println!(\"{:?}\", i);\n }\n\n println!(\"\\n\\n\");\n\n}\n\nfn kronecker_product(a: &mut Vec<Vec<f64>>, b: &mut Vec<Vec<f64>>) -> Vec<Vec<f64>> {\n let m = a.len();\n let n = a[0].len();\n let p = b.len();\n let q = b[0].len();\n let rtn = m * p;\n let ctn = n * q;\n\n let mut r = zero_matrix(rtn, ctn);\n\n for i in 0..m {\n for j in 0..n {\n for k in 0..p {\n for l in 0..q {\n r[p * i + k][q * j + l] = a[i][j] * b[k][l];\n }\n }\n }\n }\n r\n}\n\nfn zero_matrix(rows: usize, cols: usize) -> Vec<Vec<f64>> {\n let mut matrix = Vec::with_capacity(cols);\n for _ in 0..rows {\n let mut col: Vec<f64> = Vec::with_capacity(rows);\n for _ in 0..cols {\n col.push(0.0);\n }\n matrix.push(col);\n }\n matrix\n}\n"} {"name":"Langton's ant","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <unistd.h>\n\nint w = 0, h = 0;\nunsigned char *pix;\n\nvoid refresh(int x, int y)\n{\n\tint i, j, k;\n\tprintf(\"\\033[H\");\n\tfor (i = k = 0; i < h; putchar('\\n'), i++)\n\t\tfor (j = 0; j < w; j++, k++)\n\t\t\tputchar(pix[k] ? '#' : ' ');\n}\n\nvoid walk()\n{\n\tint dx = 0, dy = 1, i, k;\n\tint x = w \/ 2, y = h \/ 2;\n\n\tpix = calloc(1, w * h);\n\tprintf(\"\\033[H\\033[J\");\n\n\twhile (1) {\n\t\ti = (y * w + x);\n\t\tif (pix[i]) k = dx, dx = -dy, dy = k;\n\t\telse\t k = dy, dy = -dx, dx = k;\n\n\t\tpix[i] = !pix[i];\n\t\tprintf(\"\\033[%d;%dH%c\", y + 1, x + 1, pix[i] ? '#' : ' ');\n\n\t\tx += dx, y += dy;\n\n\t\tk = 0;\n\t\tif (x < 0) {\n\t\t\tmemmove(pix + 1, pix, w * h - 1);\n\t\t\tfor (i = 0; i < w * h; i += w) pix[i] = 0;\n\t\t\tx++, k = 1;\n\t\t}\n\t\telse if (x >= w) {\n\t\t\tmemmove(pix, pix + 1, w * h - 1);\n\t\t\tfor (i = w-1; i < w * h; i += w) pix[i] = 0;\n\t\t\tx--, k = 1;\n\t\t}\n\n\t\tif (y >= h) {\n\t\t\tmemmove(pix, pix + w, w * (h - 1));\n\t\t\tmemset(pix + w * (h - 1), 0, w);\n\t\t\ty--, k = 1;\n\t\t}\n\t\telse if (y < 0) {\n\t\t\tmemmove(pix + w, pix, w * (h - 1));\n\t\t\tmemset(pix, 0, w);\n\t\t\ty++, k = 1;\n\t\t}\n\t\tif (k) refresh(x, y);\n\t\tprintf(\"\\033[%d;%dH\\033[31m@\\033[m\", y + 1, x + 1);\n\n\t\tfflush(stdout);\n\t\tusleep(10000);\n\t}\n}\n\nint main(int c, char **v)\n{\n\tif (c > 1) w = atoi(v[1]);\n\tif (c > 2) h = atoi(v[2]);\n\tif (w < 40) w = 40;\n\tif (h < 25) h = 25;\n\n\twalk();\n\treturn 0;\n}\n","Rust":"struct Ant {\n x: usize,\n y: usize,\n dir: Direction\n}\n\n#[derive(Clone,Copy)]\nenum Direction {\n North,\n East,\n South,\n West\n}\n\nuse Direction::*;\n\nimpl Ant {\n fn mv(&mut self, vec: &mut Vec<Vec<u8>>) {\n let pointer = &mut vec[self.y][self.x];\n \n match *pointer {\n 0 => self.dir = self.dir.right(),\n 1 => self.dir = self.dir.left(),\n _ => panic!(\"Unexpected colour in grid\")\n }\n \n \n \n *pointer ^= 1;\n\n \n match self.dir {\n North => self.y -= 1,\n South => self.y += 1,\n East => self.x += 1,\n West => self.x -= 1,\n }\n\n }\n}\n\nimpl Direction {\n fn right(self) -> Direction {\n match self {\n North => East,\n East => South,\n South => West,\n West => North,\n }\n }\n\n fn left(self) -> Direction {\n \n self.right().right().right()\n }\n}\n\nfn main(){\n \n let mut grid: Vec<Vec<u8>> = vec![vec![0; 100]; 100];\n let mut ant = Ant {\n x: 50, y: 50, dir: Direction::North\n };\n\n while ant.x < 100 && ant.y < 100 {\n ant.mv(&mut grid);\n }\n for each in grid.iter() {\n \n \n \n let string = each.iter()\n .map(|&x| if x == 0 { \" \" } else { \"#\" })\n .fold(String::new(), |x, y| x+y);\n println!(\"{}\", string);\n }\n}\n"} {"name":"Largest int from concatenated ints","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nint catcmp(const void *a, const void *b)\n{\n\tchar ab[32], ba[32];\n\tsprintf(ab, \"%d%d\", *(int*)a, *(int*)b);\n\tsprintf(ba, \"%d%d\", *(int*)b, *(int*)a);\n\treturn strcmp(ba, ab);\n}\n\nvoid maxcat(int *a, int len)\n{\n\tint i;\n\tqsort(a, len, sizeof(int), catcmp);\n\tfor (i = 0; i < len; i++)\n\t\tprintf(\"%d\", a[i]);\n\tputchar('\\n');\n}\n\nint main(void)\n{\n\tint x[] = {1, 34, 3, 98, 9, 76, 45, 4};\n\tint y[] = {54, 546, 548, 60};\n\n\tmaxcat(x, sizeof(x)\/sizeof(x[0]));\n\tmaxcat(y, sizeof(y)\/sizeof(y[0]));\n\n\treturn 0;\n}\n","Rust":"fn maxcat(a: &mut [u32]) {\n a.sort_by(|x, y| {\n let xy = format!(\"{}{}\", x, y);\n let yx = format!(\"{}{}\", y, x);\n xy.cmp(&yx).reverse()\n });\n for x in a {\n print!(\"{}\", x);\n }\n println!();\n}\n \nfn main() {\n maxcat(&mut [1, 34, 3, 98, 9, 76, 45, 4]);\n maxcat(&mut [54, 546, 548, 60]);\n}\n"} {"name":"Last Friday of each month","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint main(int c, char *v[])\n{\n\tint days[] = {31,29,31,30,31,30,31,31,30,31,30,31};\n\tint m, y, w;\n\n\tif (c < 2 || (y = atoi(v[1])) <= 1700) return 1;\n \tdays[1] -= (y % 4) || (!(y % 100) && (y % 400));\n\tw = y * 365 + (y - 1) \/ 4 - (y - 1) \/ 100 + (y - 1) \/ 400 + 6;\n\n\tfor(m = 0; m < 12; m++) {\n\t\tw = (w + days[m]) % 7;\n\t\tprintf(\"%d-%02d-%d\\n\", y, m + 1,\n\t\t\tdays[m] + (w < 5 ? -2 : 5) - w);\n\t}\n\n\treturn 0;\n}\n","Rust":"use std::env::args;\nuse time::{Date, Duration};\n\nfn main() {\n let year = args().nth(1).unwrap().parse::<i32>().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) % 7) + 1);\n println!(\"{}\", date - days_back);\n });\n}\n"} {"name":"Last letter-first letter","C":"#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#include <inttypes.h>\n\ntypedef struct {\n uint16_t index;\n char last_char, first_char;\n} Ref;\n\nRef* longest_path_refs;\nsize_t longest_path_refs_len;\n\nRef* refs;\nsize_t refs_len;\n\nsize_t n_solutions;\n\nconst char** longest_path;\nsize_t longest_path_len;\n\n\n\nvoid search(size_t curr_len) {\n if (curr_len == longest_path_refs_len) {\n n_solutions++;\n } else if (curr_len > longest_path_refs_len) {\n n_solutions = 1;\n longest_path_refs_len = curr_len;\n memcpy(longest_path_refs, refs, curr_len * sizeof(Ref));\n }\n\n \n intptr_t last_char = refs[curr_len - 1].last_char;\n for (size_t i = curr_len; i < refs_len; i++)\n if (refs[i].first_char == last_char) {\n Ref aux = refs[curr_len];\n refs[curr_len] = refs[i];\n refs[i] = aux;\n search(curr_len + 1);\n refs[i] = refs[curr_len];\n refs[curr_len] = aux;\n }\n}\n\nvoid find_longest_chain(const char* items[],\n size_t items_len) {\n refs_len = items_len;\n refs = calloc(refs_len, sizeof(Ref));\n\n \n longest_path_refs_len = 0;\n longest_path_refs = calloc(refs_len, sizeof(Ref));\n\n for (size_t i = 0; i < items_len; i++) {\n size_t itemsi_len = strlen(items[i]);\n if (itemsi_len <= 1)\n exit(1);\n refs[i].index = (uint16_t)i;\n refs[i].last_char = items[i][itemsi_len - 1];\n refs[i].first_char = items[i][0];\n }\n\n \n for (size_t i = 0; i < items_len; i++) {\n Ref aux = refs[0];\n refs[0] = refs[i];\n refs[i] = aux;\n search(1);\n refs[i] = refs[0];\n refs[0] = aux;\n }\n\n longest_path_len = longest_path_refs_len;\n longest_path = calloc(longest_path_len, sizeof(const char*));\n for (size_t i = 0; i < longest_path_len; i++)\n longest_path[i] = items[longest_path_refs[i].index];\n\n free(longest_path_refs);\n free(refs);\n}\n\nint main() {\n const char* pokemon[] = {\"audino\", \"bagon\", \"baltoy\", \"banette\",\n \"bidoof\", \"braviary\", \"bronzor\", \"carracosta\", \"charmeleon\",\n \"cresselia\", \"croagunk\", \"darmanitan\", \"deino\", \"emboar\",\n \"emolga\", \"exeggcute\", \"gabite\", \"girafarig\", \"gulpin\",\n \"haxorus\", \"heatmor\", \"heatran\", \"ivysaur\", \"jellicent\",\n \"jumpluff\", \"kangaskhan\", \"kricketune\", \"landorus\", \"ledyba\",\n \"loudred\", \"lumineon\", \"lunatone\", \"machamp\", \"magnezone\",\n \"mamoswine\", \"nosepass\", \"petilil\", \"pidgeotto\", \"pikachu\",\n \"pinsir\", \"poliwrath\", \"poochyena\", \"porygon2\", \"porygonz\",\n \"registeel\", \"relicanth\", \"remoraid\", \"rufflet\", \"sableye\",\n \"scolipede\", \"scrafty\", \"seaking\", \"sealeo\", \"silcoon\",\n \"simisear\", \"snivy\", \"snorlax\", \"spoink\", \"starly\", \"tirtouga\",\n \"trapinch\", \"treecko\", \"tyrogue\", \"vigoroth\", \"vulpix\",\n \"wailord\", \"wartortle\", \"whismur\", \"wingull\", \"yamask\"};\n size_t pokemon_len = sizeof(pokemon) \/ sizeof(pokemon[0]);\n\n find_longest_chain(pokemon, pokemon_len);\n printf(\"Maximum path length: %u\\n\", longest_path_len);\n printf(\"Paths of that length: %u\\n\", n_solutions);\n printf(\"Example path of that length:\\n\");\n for (size_t i = 0; i < longest_path_len; i += 7) {\n printf(\" \");\n for (size_t j = i; j < (i+7) && j < longest_path_len; j++)\n printf(\"%s \", longest_path[j]);\n printf(\"\\n\");\n }\n\n free(longest_path);\n\n return 0;\n}\n","Rust":"\n\n\nfn first_char(string: &str) -> char {\n string.chars().next().unwrap()\n}\n\n\n\n\nfn first_and_last_char(string: &str) -> (char, char) {\n (\n first_char(string),\n first_char(string.rmatches(|_: char| true).next().unwrap()),\n )\n}\n\nstruct Pokemon {\n name: &'static str,\n first: char,\n last: char,\n}\n\nimpl Pokemon {\n fn new(name: &'static str) -> Pokemon {\n let (first, last) = first_and_last_char(name);\n Pokemon { name, first, last }\n }\n}\n\n#[derive(Default)]\nstruct App {\n max_path_length: usize,\n max_path_length_count: usize,\n max_path_example: Vec<&'static str>,\n pokemon: Vec<Pokemon>,\n}\n\nimpl App {\n fn search(&mut self, offset: usize) {\n if offset > self.max_path_length {\n self.max_path_length = offset;\n self.max_path_length_count = 1;\n } else if offset == self.max_path_length {\n self.max_path_length_count += 1;\n self.max_path_example.clear();\n self.max_path_example.extend(\n self.pokemon[0..offset]\n .iter()\n .map(|Pokemon { name, .. }| *name),\n );\n }\n\n let last_char = self.pokemon[offset - 1].last;\n for i in offset..self.pokemon.len() {\n if self.pokemon[i].first == last_char {\n self.pokemon.swap(offset, i);\n self.search(offset + 1);\n self.pokemon.swap(offset, i);\n }\n }\n }\n}\n\nfn main() {\n let pokemon_names = [\n \"audino\",\n \"bagon\",\n \"baltoy\",\n \"banette\",\n \"bidoof\",\n \"braviary\",\n \"bronzor\",\n \"carracosta\",\n \"charmeleon\",\n \"cresselia\",\n \"croagunk\",\n \"darmanitan\",\n \"deino\",\n \"emboar\",\n \"emolga\",\n \"exeggcute\",\n \"gabite\",\n \"girafarig\",\n \"gulpin\",\n \"haxorus\",\n \"heatmor\",\n \"heatran\",\n \"ivysaur\",\n \"jellicent\",\n \"jumpluff\",\n \"kangaskhan\",\n \"kricketune\",\n \"landorus\",\n \"ledyba\",\n \"loudred\",\n \"lumineon\",\n \"lunatone\",\n \"machamp\",\n \"magnezone\",\n \"mamoswine\",\n \"nosepass\",\n \"petilil\",\n \"pidgeotto\",\n \"pikachu\",\n \"pinsir\",\n \"poliwrath\",\n \"poochyena\",\n \"porygon2\",\n \"porygonz\",\n \"registeel\",\n \"relicanth\",\n \"remoraid\",\n \"rufflet\",\n \"sableye\",\n \"scolipede\",\n \"scrafty\",\n \"seaking\",\n \"sealeo\",\n \"silcoon\",\n \"simisear\",\n \"snivy\",\n \"snorlax\",\n \"spoink\",\n \"starly\",\n \"tirtouga\",\n \"trapinch\",\n \"treecko\",\n \"tyrogue\",\n \"vigoroth\",\n \"vulpix\",\n \"wailord\",\n \"wartortle\",\n \"whismur\",\n \"wingull\",\n \"yamask\",\n ];\n\n let mut app = App {\n pokemon: pokemon_names\n .iter()\n .map(|name| Pokemon::new(name))\n .collect(),\n ..App::default()\n };\n\n for i in 0..app.pokemon.len() {\n app.pokemon.swap(0, i);\n app.search(1);\n app.pokemon.swap(0, i);\n }\n\n println!(\"Maximum path length: {}\", app.max_path_length);\n println!(\"Paths of that length: {}\", app.max_path_length_count);\n println!(\n \"Example path of that length: {}\",\n app.max_path_example.join(\" \"),\n );\n}\n"} {"name":"Leap year","C":"#include <stdio.h>\n\nint is_leap_year(unsigned year)\n{\n return !(year & (year % 100 ? 3 : 15));\n}\n\nint main(void)\n{\n const unsigned test_case[] = {\n 1900, 1994, 1996, 1997, 2000, 2024, 2025, 2026, 2100\n };\n const unsigned n = sizeof test_case \/ sizeof test_case[0];\n\n for (unsigned i = 0; i != n; ++i) {\n unsigned year = test_case[i];\n printf(\"%u is %sa leap year.\\n\", year, is_leap_year(year) ? \"\" : \"not \");\n }\n return 0;\n}\n","Rust":"fn is_leap(year: i32) -> bool {\n let factor = |x| year % x == 0;\n factor(4) && (!factor(100) || factor(400))\n}\n"} {"name":"Least common multiple","C":"#include <stdio.h>\n\nint gcd(int m, int n)\n{\n int tmp;\n while(m) { tmp = m; m = n % m; n = tmp; } \n return n;\n}\n\nint lcm(int m, int n)\n{\n return m \/ gcd(m, n) * n;\n}\n\nint main()\n{\n printf(\"lcm(35, 21) = %d\\n\", lcm(21,35));\n return 0;\n}\n","Rust":"use std::cmp::{max, min};\n\nfn gcd(a: usize, b: usize) -> usize {\n match ((a, b), (a & 1, b & 1)) {\n ((x, y), _) if x == y => y,\n ((0, x), _) | ((x, 0), _) => x,\n ((x, y), (0, 1)) | ((y, x), (1, 0)) => gcd(x >> 1, y),\n ((x, y), (0, 0)) => gcd(x >> 1, y >> 1) << 1,\n ((x, y), (1, 1)) => {\n let (x, y) = (min(x, y), max(x, y));\n gcd((y - x) >> 1, x)\n }\n _ => unreachable!(),\n }\n}\n\nfn lcm(a: usize, b: usize) -> usize {\n a * b \/ gcd(a, b)\n}\n\nfn main() {\n println!(\"{}\", lcm(6324, 234))\n}\n"} {"name":"Leonardo numbers","C":"#include<stdio.h>\n\nvoid leonardo(int a,int b,int step,int num){\n\t\n\tint i,temp;\n\t\n\tprintf(\"First 25 Leonardo numbers\u00a0: \\n\");\n\t\n\tfor(i=1;i<=num;i++){\n\t\tif(i==1)\n\t\t\tprintf(\" %d\",a);\n\t\telse if(i==2)\n\t\t\tprintf(\" %d\",b);\n\t\telse{\n\t\t\tprintf(\" %d\",a+b+step);\n\t\t\ttemp = a;\n\t\t\ta = b;\n\t\t\tb = temp+b+step;\n\t\t}\n\t}\n}\n\nint main()\n{\n\tint a,b,step;\n\t\n\tprintf(\"Enter first two Leonardo numbers and increment step\u00a0: \");\n\t\n\tscanf(\"%d%d%d\",&a,&b,&step);\n\t\n\tleonardo(a,b,step,25);\n\t\n\treturn 0;\n}\n","Rust":"fn leonardo(mut n0: u32, mut n1: u32, add: u32) -> impl std::iter::Iterator<Item = u32> {\n std::iter::from_fn(move || {\n let n = n0;\n n0 = n1;\n n1 += n + add;\n Some(n)\n })\n}\n\nfn main() {\n println!(\"First 25 Leonardo numbers:\");\n for i in leonardo(1, 1, 1).take(25) {\n print!(\"{} \", i);\n }\n println!();\n println!(\"First 25 Fibonacci numbers:\");\n for i in leonardo(0, 1, 0).take(25) {\n print!(\"{} \", i);\n }\n println!();\n}\n"} {"name":"Letter frequency","C":"\nint frequency[26];\nint ch;\nFILE* txt_file = fopen (\"a_text_file.txt\", \"rt\");\n\n\nfor (ch = 0; ch < 26; ch++)\n frequency[ch] = 0;\n\nwhile (1) {\n ch = fgetc(txt_file);\n if (ch == EOF) break; \n\n \n if ('a' <= ch && ch <= 'z') \n frequency[ch-'a']++;\n else if ('A' <= ch && ch <= 'Z') \n frequency[ch-'A']++;\n}\n","Rust":"use std::collections::btree_map::BTreeMap;\nuse std::{env, process};\nuse std::io::{self, Read, Write};\nuse std::fmt::Display;\nuse std::fs::File;\n\nfn main() {\n let filename = env::args().nth(1)\n .ok_or(\"Please supply a file name\")\n .unwrap_or_else(|e| exit_err(e, 1));\n\n let mut buf = String::new();\n let mut count = BTreeMap::new();\n\n File::open(&filename)\n .unwrap_or_else(|e| exit_err(e, 2))\n .read_to_string(&mut buf)\n .unwrap_or_else(|e| exit_err(e, 3));\n\n\n for c in buf.chars() {\n *count.entry(c).or_insert(0) += 1;\n }\n\n println!(\"Number of occurences per character\");\n for (ch, count) in &count {\n println!(\"{:?}: {}\", ch, count);\n }\n}\n\n#[inline]\nfn exit_err<T>(msg: T, code: i32) -> ! where T: Display {\n writeln!(&mut io::stderr(), \"{}\", msg).expect(\"Could not write to stderr\");\n process::exit(code)\n}\n"} {"name":"Levenshtein distance","C":"#include <stdio.h>\n#include <string.h>\n\n\nint levenshtein(const char *s, int ls, const char *t, int lt)\n{\n int a, b, c;\n\n \n if (!ls) return lt;\n if (!lt) return ls;\n\n \n if (s[ls - 1] == t[lt - 1])\n return levenshtein(s, ls - 1, t, lt - 1);\n\n \n a = levenshtein(s, ls - 1, t, lt - 1);\n b = levenshtein(s, ls, t, lt - 1);\n c = levenshtein(s, ls - 1, t, lt );\n\n if (a > b) a = b;\n if (a > c) a = c;\n\n return a + 1;\n}\n\nint main()\n{\n const char *s1 = \"rosettacode\";\n const char *s2 = \"raisethysword\";\n printf(\"distance between `%s' and `%s': %d\\n\", s1, s2,\n levenshtein(s1, strlen(s1), s2, strlen(s2)));\n\n return 0;\n}\n","Rust":"fn main() {\n println!(\"{}\", levenshtein_distance(\"kitten\", \"sitting\"));\n println!(\"{}\", levenshtein_distance(\"saturday\", \"sunday\"));\n println!(\"{}\", levenshtein_distance(\"rosettacode\", \"raisethysword\"));\n}\n \nfn levenshtein_distance(word1: &str, word2: &str) -> usize {\n let w1 = word1.chars().collect::<Vec<_>>();\n let w2 = word2.chars().collect::<Vec<_>>();\n \n let word1_length = w1.len() + 1;\n let word2_length = w2.len() + 1;\n \n let mut matrix = vec![vec![0; word1_length]; word2_length];\n \n for i in 1..word1_length { matrix[0][i] = i; }\n for j in 1..word2_length { matrix[j][0] = j; }\n \n for j in 1..word2_length {\n for i in 1..word1_length {\n let x: usize = if w1[i-1] == w2[j-1] {\n matrix[j-1][i-1]\n } else {\n 1 + std::cmp::min(\n std::cmp::min(matrix[j][i-1], matrix[j-1][i])\n , matrix[j-1][i-1])\n };\n matrix[j][i] = x;\n }\n }\n matrix[word2_length-1][word1_length-1]\n}\n"} {"name":"Linear congruential generator","C":"#include <stdio.h>\n\n\nint rand();\nint rseed = 0;\n\ninline void srand(int x)\n{\n\trseed = x;\n}\n\n#ifndef MS_RAND\n#define RAND_MAX ((1U << 31) - 1)\n\ninline int rand()\n{\n\treturn rseed = (rseed * 1103515245 + 12345) & RAND_MAX;\n}\n\n#else \n\n#define RAND_MAX_32 ((1U << 31) - 1)\n#define RAND_MAX ((1U << 15) - 1)\n\ninline int rand()\n{\n\treturn (rseed = (rseed * 214013 + 2531011) & RAND_MAX_32) >> 16;\n}\n\n#endif\n\nint main()\n{\n\tint i;\n\tprintf(\"rand max is %d\\n\", RAND_MAX);\n\n\tfor (i = 0; i < 100; i++)\n\t\tprintf(\"%d\\n\", rand());\n\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\npub use rand::{Rng, SeedableRng};\n\npub struct BsdLcg {\n state: u32,\n}\n\nimpl Rng for BsdLcg {\n \n \n \n \n fn next_u32(&mut self) -> u32 {\n self.state = self.state.wrapping_mul(1_103_515_245).wrapping_add(12_345);\n self.state %= 1 << 31;\n self.state\n }\n}\n\nimpl SeedableRng<u32> for BsdLcg {\n fn from_seed(seed: u32) -> Self {\n Self { state: seed }\n }\n fn reseed(&mut self, seed: u32) {\n self.state = seed;\n }\n}\n\npub struct MsLcg {\n state: u32,\n}\n\nimpl Rng for MsLcg {\n \n \n fn next_u32(&mut self) -> u32 {\n self.state = self.state.wrapping_mul(214_013).wrapping_add(2_531_011);\n self.state %= 1 << 31;\n self.state >> 16 \n }\n}\n\nimpl SeedableRng<u32> for MsLcg {\n fn from_seed(seed: u32) -> Self {\n Self { state: seed }\n }\n fn reseed(&mut self, seed: u32) {\n self.state = seed;\n }\n}\n\nfn main() {\n println!(\"~~~ BSD ~~~\");\n let mut bsd = BsdLcg::from_seed(0);\n for _ in 0..10 {\n println!(\"{}\", bsd.next_u32());\n }\n\n println!(\"~~~ MS ~~~\");\n let mut ms = MsLcg::from_seed(0);\n for _ in 0..10 {\n println!(\"{}\", ms.next_u32());\n }\n\n \n println!(\"~~~ Others ~~~\");\n println!(\"{:?}\", ms.gen::<[u32; 5]>());\n println!(\"{}\", ms.gen::<bool>());\n println!(\"{}\", ms.gen_ascii_chars().take(15).collect::<String>());\n}\n"} {"name":"List comprehensions","C":"for (int i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); }\n","Rust":"fn pyth(n: u32) -> impl Iterator<Item = [u32; 3]> {\n (1..=n).flat_map(move |x| {\n (x..=n).flat_map(move |y| {\n (y..=n).filter_map(move |z| {\n if x.pow(2) + y.pow(2) == z.pow(2) {\n Some([x, y, z])\n } else {\n None\n }\n })\n })\n })\n}\n"} {"name":"Literals_Integer","C":"#include <stdio.h>\n\nint main(void)\n{\n printf(\"%s\\n\",\n ( (727 == 0x2d7) && \n (727 == 01327) ) ? \"true\" : \"false\");\n\n return 0;\n}\n","Rust":"10 \n0b10 \n0x10 \n0o10 \n1_000 \n10_i32 \n10i32 \n"} {"name":"Literals_String","C":"char ch = 'z';\n","Rust":"let char01: char = 'a';\nlet char02: char = '\\u{25A0}'; \nlet char03: char = '\u2764'; \n"} {"name":"Logical operations","C":"if(myValue == 3 && myOtherValue == 5){\nmyResult = true;\n}\n","Rust":"fn boolean_ops(a: bool, b: bool) {\n println!(\"{} and {} -> {}\", a, b, a && b);\n println!(\"{} or {} -> {}\", a, b, a || b);\n println!(\"{} xor {} -> {}\", a, b, a ^ b);\n println!(\"not {} -> {}\\n\", a, !a);\n}\n\nfn main() {\n boolean_ops(true, true);\n boolean_ops(true, false);\n boolean_ops(false, true);\n boolean_ops(false, false)\n}\n"} {"name":"Longest common prefix","C":"#include<stdarg.h>\n#include<string.h>\n#include<stdlib.h>\n#include<stdio.h>\n\nchar* lcp(int num,...){\n\tva_list vaList,vaList2;\n\tint i,j,len,min;\n\tchar* dest;\n\tchar** strings = (char**)malloc(num*sizeof(char*));\n\t\n\tva_start(vaList,num);\n\tva_start(vaList2,num);\n\t\n\tfor(i=0;i<num;i++){\n\t\tlen = strlen(va_arg(vaList,char*));\n\t\tstrings[i] = (char*)malloc((len + 1)*sizeof(char));\n\t\t\n\t\tstrcpy(strings[i],va_arg(vaList2,char*));\n\t\t\n\t\tif(i==0)\n\t\t\tmin = len;\n\t\telse if(len<min)\n\t\t\tmin = len;\n\t}\n\t\n\tif(min==0)\n\t\treturn \"\";\n\t\n\tfor(i=0;i<min;i++){\n\t\tfor(j=1;j<num;j++){\n\t\t\tif(strings[j][i]!=strings[0][i]){\n\t\t\t\tif(i==0)\n\t\t\t\t\treturn \"\";\n\t\t\t\telse{\n\t\t\t\t\tdest = (char*)malloc(i*sizeof(char));\n\t\t\t\t\tstrncpy(dest,strings[0],i-1);\n\t\t\t\t\treturn dest;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\tdest = (char*)malloc((min+1)*sizeof(char));\n\tstrncpy(dest,strings[0],min);\n\treturn dest;\n}\n\nint main(){\n\n\tprintf(\"\\nLongest common prefix\u00a0: %s\",lcp(3,\"interspecies\",\"interstellar\",\"interstate\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(2,\"throne\",\"throne\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(2,\"throne\",\"dungeon\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(3,\"throne\",\"\",\"throne\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(1,\"cheese\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(1,\"\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(0,NULL));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(2,\"prefix\",\"suffix\"));\n printf(\"\\nLongest common prefix\u00a0: %s\",lcp(2,\"foo\",\"foobar\"));\n\treturn 0;\n}\n","Rust":"fn main() {\n let strs: [&[&[u8]]; 7] = [\n &[b\"interspecies\", b\"interstellar\", b\"interstate\"],\n &[b\"throne\", b\"throne\"],\n &[b\"throne\", b\"dungeon\"],\n &[b\"cheese\"],\n &[b\"\"],\n &[b\"prefix\", b\"suffix\"],\n &[b\"foo\", b\"foobar\"],\n ];\n strs.iter().for_each(|list| match lcp(list) {\n Some(prefix) => println!(\"{}\", String::from_utf8_lossy(&prefix)),\n None => println!(),\n });\n}\n\nfn lcp(list: &[&[u8]]) -> Option<Vec<u8>> {\n if list.is_empty() {\n return None;\n }\n let mut ret = Vec::new();\n let mut i = 0;\n loop {\n let mut c = None;\n for word in list {\n if i == word.len() {\n return Some(ret);\n }\n match c {\n None => {\n c = Some(word[i]);\n }\n Some(letter) if letter != word[i] => return Some(ret),\n _ => continue,\n }\n }\n if let Some(letter) = c {\n ret.push(letter);\n }\n i += 1;\n }\n}\n"} {"name":"Longest common subsequence","C":"#include <stdio.h>\n#include <stdlib.h>\n\n#define MAX(a, b) (a > b\u00a0? a\u00a0: b)\n\nint lcs (char *a, int n, char *b, int m, char **s) {\n int i, j, k, t;\n int *z = calloc((n + 1) * (m + 1), sizeof (int));\n int **c = calloc((n + 1), sizeof (int *));\n for (i = 0; i <= n; i++) {\n c[i] = &z[i * (m + 1)];\n }\n for (i = 1; i <= n; i++) {\n for (j = 1; j <= m; j++) {\n if (a[i - 1] == b[j - 1]) {\n c[i][j] = c[i - 1][j - 1] + 1;\n }\n else {\n c[i][j] = MAX(c[i - 1][j], c[i][j - 1]);\n }\n }\n }\n t = c[n][m];\n *s = malloc(t);\n for (i = n, j = m, k = t - 1; k >= 0;) {\n if (a[i - 1] == b[j - 1])\n (*s)[k] = a[i - 1], i--, j--, k--;\n else if (c[i][j - 1] > c[i - 1][j])\n j--;\n else\n i--;\n }\n free(c);\n free(z);\n return t;\n}\n","Rust":"use std::cmp;\n\nfn lcs(string1: String, string2: String) -> (usize, String){\n let total_rows = string1.len() + 1;\n let total_columns = string2.len() + 1;\n \n let string1_chars = string1.as_bytes();\n let string2_chars = string2.as_bytes();\n\n let mut table = vec![vec![0; total_columns]; total_rows];\n\n for row in 1..total_rows{\n for col in 1..total_columns {\n if string1_chars[row - 1] == string2_chars[col - 1]{\n table[row][col] = table[row - 1][col - 1] + 1;\n } else {\n table[row][col] = cmp::max(table[row][col-1], table[row-1][col]);\n }\n }\n }\n\n let mut common_seq = Vec::new();\n let mut x = total_rows - 1;\n let mut y = total_columns - 1;\n\n while x != 0 && y != 0 {\n \n if table[x][y] == table[x - 1][y] {\n x = x - 1;\n }\n \n else if table[x][y] == table[x][y - 1] {\n y = y - 1;\n }\n else {\n \n assert_eq!(string1_chars[x-1], string2_chars[y-1]);\n let char = string1_chars[x - 1];\n common_seq.push(char);\n x = x - 1;\n y = y - 1;\n }\n }\n common_seq.reverse();\n (table[total_rows - 1][total_columns - 1], String::from_utf8(common_seq).unwrap())\n}\n\nfn main() {\n let res = lcs(\"abcdaf\".to_string(), \"acbcf\".to_string());\n assert_eq!((4 as usize, \"abcf\".to_string()), res);\n let res = lcs(\"thisisatest\".to_string(), \"testing123testing\".to_string());\n assert_eq!((7 as usize, \"tsitest\".to_string()), res);\n \n let res = lcs(\"AGGTAB\".to_string(), \"GXTXAYB\".to_string());\n assert_eq!((4 as usize, \"GTAB\".to_string()), res);\n}\n"} {"name":"Longest common substring","C":"#include <stdio.h>\n\nvoid lcs(const char * const sa, const char * const sb, char ** const beg, char ** const end) {\n size_t apos, bpos;\n ptrdiff_t len;\n\n *beg = 0;\n *end = 0;\n len = 0;\n\n for (apos = 0; sa[apos] != 0; ++apos) {\n for (bpos = 0; sb[bpos] != 0; ++bpos) {\n if (sa[apos] == sb[bpos]) {\n len = 1;\n while (sa[apos + len] != 0 && sb[bpos + len] != 0 && sa[apos + len] == sb[bpos + len]) {\n len++;\n }\n }\n\n if (len > *end - *beg) {\n *beg = sa + apos;\n *end = *beg + len;\n len = 0;\n }\n }\n }\n}\n\nint main() {\n char *s1 = \"thisisatest\";\n char *s2 = \"testing123testing\";\n char *beg, *end, *it;\n\n lcs(s1, s2, &beg, &end);\n\n for (it = beg; it != end; it++) {\n putchar(*it);\n }\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"fn longest_common_substring(s1: &str, s2: &str) -> String {\n let s1_chars: Vec<char> = s1.chars().collect();\n let s2_chars: Vec<char> = s2.chars().collect();\n let mut lcs = \"\".to_string();\n\n for i in 0..s1_chars.len() {\n for j in 0..s2_chars.len() {\n if s1_chars[i] == s2_chars[j] {\n let mut tmp_lcs = s2_chars[j].to_string();\n let mut tmp_i = i + 1;\n let mut tmp_j = j + 1;\n\n while tmp_i < s1_chars.len() && tmp_j < s2_chars.len() && s1_chars[tmp_i] == s2_chars[tmp_j] {\n tmp_lcs = format!(\"{}{}\", tmp_lcs, s1_chars[tmp_i]);\n tmp_i += 1;\n tmp_j += 1;\n }\n\n if tmp_lcs.len() > lcs.len() {\n lcs = tmp_lcs;\n }\n }\n }\n }\n\n lcs\n}\n\nfn main() {\n let s1 = \"thisisatest\";\n let s2 = \"testing123testing\";\n let lcs = longest_common_substring(s1, s2);\n println!(\"{}\", lcs);\n}\n"} {"name":"Look-and-say sequence","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint main()\n{\n\tchar *a = malloc(2), *b = 0, *x, c;\n\tint cnt, len = 1;\n\n\tfor (sprintf(a, \"1\"); (b = realloc(b, len * 2 + 1)); a = b, b = x) {\n\t\tputs(x = a);\n\t\tfor (len = 0, cnt = 1; (c = *a); ) {\n\t\t\tif (c == *++a)\n\t\t\t\tcnt++;\n\t\t\telse if (c) {\n\t\t\t\tlen += sprintf(b + len, \"%d%c\", cnt, c);\n\t\t\t\tcnt = 1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn 0;\n}\n","Rust":"fn next_sequence(in_seq: &[i8]) -> Vec<i8> {\n assert!(!in_seq.is_empty());\n\n let mut result = Vec::new();\n let mut current_number = in_seq[0];\n let mut current_runlength = 1;\n\n for i in &in_seq[1..] {\n if current_number == *i {\n current_runlength += 1;\n } else {\n result.push(current_runlength);\n result.push(current_number);\n current_runlength = 1;\n current_number = *i;\n }\n }\n result.push(current_runlength);\n result.push(current_number);\n result\n}\n\nfn main() {\n let mut seq = vec![1];\n\n for i in 0..10 {\n println!(\"Sequence {}: {:?}\", i, seq);\n seq = next_sequence(&seq);\n }\n}\n"} {"name":"Loop over multiple arrays simultaneously","C":"#include <stdio.h>\n\nchar a1[] = {'a','b','c'};\nchar a2[] = {'A','B','C'};\nint a3[] = {1,2,3};\n\nint main(void) {\n for (int i = 0; i < 3; i++) {\n printf(\"%c%c%i\\n\", a1[i], a2[i], a3[i]);\n }\n}\n","Rust":"fn main() {\n let a1 = [\"a\", \"b\", \"c\"];\n let a2 = [\"A\", \"B\", \"C\"];\n let a3 = [1, 2, 3];\n\n for ((&x, &y), &z) in a1.iter().zip(a2.iter()).zip(a3.iter()) {\n println!(\"{}{}{}\", x, y, z);\n }\n}\n"} {"name":"Loops_Break","C":"int main(){\n\ttime_t t;\n\tint a, b;\n\tsrand((unsigned)time(&t));\n\tfor(;;){\n\t\ta = rand() % 20;\n\t\tprintf(\"%d\\n\", a);\n\t\tif(a == 10)\n\t\t\tbreak;\n\t\tb = rand() % 20;\n\t\tprintf(\"%d\\n\", b);\n\t}\n\treturn 0;\n}\n","Rust":"\n\nextern crate rand;\nuse rand::{thread_rng, Rng};\n \nfn main() {\n let mut rng = thread_rng();\n loop {\n let num = rng.gen_range(0, 20);\n if num == 10 {\n println!(\"{}\", num);\n break;\n }\n println!(\"{}\", rng.gen_range(0, 20));\n }\n}\n"} {"name":"Loops_Continue","C":"for(int i = 1;i <= 10; i++){\n printf(\"%d\", i);\n if(i % 5 == 0){\n printf(\"\\n\");\n continue;\n }\n printf(\", \");\n}\n","Rust":"fn main() {\n for i in 1..=10 {\n print!(\"{}\", i);\n if i % 5 == 0 {\n println!();\n continue;\n }\n print!(\", \");\n }\n}\n"} {"name":"Loops_Do-while","C":"int val = 0;\ndo{\n val++;\n printf(\"%d\\n\",val);\n}while(val % 6 != 0);\n","Rust":"let mut x = 0;\n\nloop {\n x += 1;\n println!(\"{}\", x);\n\n if x % 6 == 0 { break; }\n}\n"} {"name":"Loops_Downward for","C":"int i;\nfor(i = 10; i >= 0; --i)\n printf(\"%d\\n\",i);\n","Rust":"fn main() {\n for i in (0..=10).rev() {\n println!(\"{}\", i);\n }\n}\n"} {"name":"Loops_For","C":"int i, j;\nfor (i = 1; i <= 5; i++) {\n for (j = 1; j <= i; j++)\n putchar('*');\n puts(\"\");\n}\n","Rust":"fn main() {\n for i in 0..5 {\n for _ in 0..=i {\n print!(\"*\");\n }\n\n println!();\n }\n}\n"} {"name":"Loops_For with a specified step","C":"int i;\nfor(i = 1; i < 10; i += 2)\n printf(\"%d\\n\", i);\n","Rust":"fn main() {\n for i in (2..=8).step_by(2) {\n print!(\"{}\", i);\n }\n println!(\"who do we appreciate?!\");\n}\n"} {"name":"Loops_Foreach","C":"#include <stdio.h>\n...\n\nconst char *list[] = {\"Red\",\"Green\",\"Blue\",\"Black\",\"White\"};\n#define LIST_SIZE (sizeof(list)\/sizeof(list[0]))\n\nint ix;\nfor(ix=0; ix<LIST_SIZE; ix++) {\n printf(\"%s\\n\", list[ix]);\n}\n","Rust":"let collection = vec![1,2,3,4,5];\nfor elem in collection {\n println!(\"{}\", elem);\n}\n"} {"name":"Loops_N plus one half","C":"#include <stdio.h>\n\nint main()\n{\n int i;\n for (i = 1; i <= 10; i++) {\n printf(\"%d\", i);\n printf(i == 10 ? \"\\n\" : \", \");\n }\n return 0;\n}\n","Rust":"fn main() {\n for i in 1..=10 {\n print!(\"{}{}\", i, if i < 10 { \", \" } else { \"\\n\" });\n }\n}\n"} {"name":"Loops_Nested","C":"#include <stdlib.h>\n#include <time.h>\n#include <stdio.h>\n\nint main() {\n int a[10][10], i, j;\n\n srand(time(NULL));\n for (i = 0; i < 10; i++)\n for (j = 0; j < 10; j++)\n a[i][j] = rand() % 20 + 1;\n\n for (i = 0; i < 10; i++) {\n for (j = 0; j < 10; j++) {\n printf(\" %d\", a[i][j]);\n if (a[i][j] == 20)\n goto Done;\n }\n printf(\"\\n\");\n }\nDone:\n printf(\"\\n\");\n return 0;\n}\n","Rust":"use rand::Rng;\n\nextern crate rand;\n\nfn main() {\n let mut matrix = [[0u8; 10]; 10];\n let mut rng = rand::thread_rng();\n\n for row in matrix.iter_mut() {\n for item in row.iter_mut() {\n *item = rng.gen_range(0, 21);\n }\n }\n\n 'outer: for row in matrix.iter() {\n for &item in row.iter() {\n print!(\"{:2} \", item);\n if item == 20 { break 'outer }\n }\n println!();\n }\n}\n"} {"name":"Loops_While","C":"int i = 1024;\nwhile(i > 0) {\n printf(\"%d\\n\", i);\n i \/= 2;\n}\n","Rust":"fn main() {\n let mut n: i32 = 1024;\n while n > 0 {\n println!(\"{}\", n);\n n \/= 2;\n }\n}\n"} {"name":"Lucas-Lehmer test","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <limits.h>\n#include <gmp.h>\n\nint lucas_lehmer(unsigned long p)\n{\n mpz_t V, mp, t;\n unsigned long k, tlim;\n int res;\n\n if (p == 2) return 1;\n if (!(p&1)) return 0;\n\n mpz_init_set_ui(t, p);\n if (!mpz_probab_prime_p(t, 25)) \n { mpz_clear(t); return 0; }\n\n if (p < 23) \n { mpz_clear(t); return (p != 11); }\n\n mpz_init(mp);\n mpz_setbit(mp, p);\n mpz_sub_ui(mp, mp, 1);\n\n \n if (p > 3 && p % 4 == 3) {\n mpz_mul_ui(t, t, 2);\n mpz_add_ui(t, t, 1);\n if (mpz_probab_prime_p(t,25) && mpz_divisible_p(mp, t))\n { mpz_clear(mp); mpz_clear(t); return 0; }\n }\n\n \n tlim = p\/2;\n if (tlim > (ULONG_MAX\/(2*p)))\n tlim = ULONG_MAX\/(2*p);\n for (k = 1; k < tlim; k++) {\n unsigned long q = 2*p*k+1;\n \n if ( (q%8==1 || q%8==7) &&\n q % 3 && q % 5 && q % 7 &&\n mpz_divisible_ui_p(mp, q) )\n { mpz_clear(mp); mpz_clear(t); return 0; }\n }\n\n mpz_init_set_ui(V, 4);\n for (k = 3; k <= p; k++) {\n mpz_mul(V, V, V);\n mpz_sub_ui(V, V, 2);\n \n if (mpz_sgn(V) < 0) mpz_add(V, V, mp);\n \n \n mpz_tdiv_r_2exp(t, V, p);\n mpz_tdiv_q_2exp(V, V, p);\n mpz_add(V, V, t);\n while (mpz_cmp(V, mp) >= 0) mpz_sub(V, V, mp);\n }\n res = !mpz_sgn(V);\n mpz_clear(t); mpz_clear(mp); mpz_clear(V);\n return res;\n}\n\nint main(int argc, char* argv[]) {\n unsigned long i, n = 43112609;\n if (argc >= 2) n = strtoul(argv[1], 0, 10);\n for (i = 1; i <= n; i++) {\n if (lucas_lehmer(i)) {\n printf(\"M%lu \", i);\n fflush(stdout);\n }\n }\n printf(\"\\n\");\n return 0;\n}\n","Rust":"extern crate rug;\nextern crate primal;\n\nuse rug::Integer;\nuse rug::ops::Pow;\nuse std::thread::spawn;\n\nfn is_mersenne (p : usize) {\n let p = p as u32;\n let mut m = Integer::from(1);\n m = m << p; \n m = Integer::from(&m - 1);\n let mut flag1 = false;\n for k in 1..10_000 {\n let mut flag2 = false;\n let mut div : u32 = 2*k*p + 1;\n if &div >= &m {break; }\n for j in [3,5,7,11,13,17,19,23,29,31,37].iter() {\n if div % j == 0 {\n flag2 = true;\n break;\n } \n }\n if flag2 == true {continue;}\n if div % 8 != 1 && div % 8 != 7 { continue; }\n if m.is_divisible_u(div) { \n flag1 = true;\n break;\n }\n }\n if flag1 == true {return ()}\n let mut s = Integer::from(4);\n let two = Integer::from(2);\n for _i in 2..p {\n\t\tlet mut sqr = s.pow(2);\n\t\ts = Integer::from(&Integer::from(&sqr & &m) + &Integer::from(&sqr >> p));\n\t\tif &s >= &m {s = s - &m}\n\t\ts = Integer::from(&s - &two);\n }\n\tif s == 0 {println!(\"Mersenne\u00a0: {}\",p);} \n}\n\nfn main () {\n println!(\"Mersenne\u00a0: 2\");\n let limit = 11_214;\n let mut thread_handles = vec![];\n for p in primal::Primes::all().take_while(|p| *p < limit) {\n thread_handles.push(spawn(move || is_mersenne(p))); \n }\n for handle in thread_handles {\n handle.join().unwrap();\n }\n}\n"} {"name":"Ludic numbers","C":"#include <stdio.h>\n#include <stdlib.h>\n\ntypedef unsigned uint;\ntypedef struct { uint i, v; } filt_t;\n\n\nuint* ludic(uint min_len, uint min_val, uint *len)\n{\n\tuint cap, i, v, active = 1, nf = 0;\n\tfilt_t *f = calloc(cap = 2, sizeof(*f));\n\tf[1].i = 4;\n\n\tfor (v = 1; ; ++v) {\n\t\tfor (i = 1; i < active && --f[i].i; i++);\n\n\t\tif (i < active)\n\t\t\tf[i].i = f[i].v;\n\t\telse if (nf == f[i].i)\n\t\t\tf[i].i = f[i].v, ++active; \n\t\telse {\n\t\t\tif (nf >= cap)\n\t\t\t\tf = realloc(f, sizeof(*f) * (cap*=2));\n\t\t\tf[nf] = (filt_t){ v + nf, v };\n\t\t\tif (++nf >= min_len && v >= min_val) break;\n\t\t}\n\t}\n\n\t\n\t\n\tuint *x = (void*) f;\n\tfor (i = 0; i < nf; i++) x[i] = f[i].v;\n\tx = realloc(x, sizeof(*x) * nf);\n\n\t*len = nf;\n\treturn x;\n}\n\nint find(uint *a, uint v)\n{\n\tuint i;\n\tfor (i = 0; a[i] <= v; i++)\n\t\tif (v == a[i]) return 1;\n\treturn 0;\n}\n\nint main(void)\n{\n\tuint len, i, *x = ludic(2005, 1000, &len);\n\n\tprintf(\"First 25:\");\n\tfor (i = 0; i < 25; i++) printf(\" %u\", x[i]);\n\tputchar('\\n');\n\n\tfor (i = 0; x[i] <= 1000; i++);\n\tprintf(\"Ludics below 1000: %u\\n\", i);\n\n\tprintf(\"Ludic 2000 to 2005:\");\n\tfor (i = 2000; i <= 2005; i++) printf(\" %u\", x[i - 1]);\n\tputchar('\\n');\n\n\tprintf(\"Triples below 250:\");\n\tfor (i = 0; x[i] + 6 <= 250; i++)\n\t\tif (find(x, x[i] + 2) && find(x, x[i] + 6))\n\t\t\tprintf(\" (%u %u %u)\", x[i], x[i] + 2, x[i] + 6);\n\n\tputchar('\\n');\n\n\tfree(x);\n\treturn 0;\n}\n","Rust":"const ARRAY_MAX: usize = 25_000;\nconst LUDIC_MAX: usize = 2100;\n\n\n\n\nfn ludic_numbers() -> Vec<usize> {\n \n let mut numbers = vec![1, 2];\n \n \n numbers.extend((3..ARRAY_MAX).step_by(2));\n\n \n for ludic_idx in 2..LUDIC_MAX {\n let next_ludic = numbers[ludic_idx];\n\n \n \n \n let mut idx = 0;\n numbers.retain(|_| {\n let keep = idx <= ludic_idx || (idx - ludic_idx) % next_ludic != 0;\n idx += 1;\n keep\n });\n }\n\n numbers\n}\n\nfn main() {\n let ludic_numbers = ludic_numbers();\n\n print!(\"First 25: \");\n print_n_ludics(&ludic_numbers, 25);\n println!();\n print!(\"Number of Ludics below 1000: \");\n print_num_ludics_upto(&ludic_numbers, 1000);\n println!();\n print!(\"Ludics from 2000 to 2005: \");\n print_ludics_from_to(&ludic_numbers, 2000, 2005);\n println!();\n println!(\"Triplets below 250: \");\n print_triplets_until(&ludic_numbers, 250);\n}\n\n\nfn print_n_ludics(x: &[usize], n: usize) {\n println!(\"{:?}\", &x[..n]);\n}\n\n\nfn print_num_ludics_upto(x: &[usize], max_num: usize) {\n let num = x.iter().take_while(|&&i| i < max_num).count();\n println!(\"{}\", num);\n}\n\n\nfn print_ludics_from_to(x: &[usize], from: usize, to: usize) {\n println!(\"{:?}\", &x[from - 1..to - 1]);\n}\n\n\nfn triplets_below(ludics: &[usize], limit: usize) -> Vec<(usize, usize, usize)> {\n ludics\n .iter()\n .enumerate()\n .take_while(|&(_, &num)| num < limit)\n .filter_map(|(idx, &number)| {\n let triplet_2 = number + 2;\n let triplet_3 = number + 6;\n\n \n \n \n \n \n \n let is_triplet = ludics[idx + 1..idx + 3].binary_search(&triplet_2).is_ok()\n && ludics[idx + 2..idx + 5].binary_search(&triplet_3).is_ok();\n\n if is_triplet {\n Some((number, triplet_2, triplet_3))\n } else {\n None\n }\n })\n .collect()\n}\n\n\nfn print_triplets_until(ludics: &[usize], limit: usize) {\n for (number, triplet_2, triplet_3) in triplets_below(ludics, limit) {\n println!(\"{} {} {}\", number, triplet_2, triplet_3);\n }\n}\n"} {"name":"Luhn test of credit card numbers","C":"#include <string.h>\n#include <stdio.h>\n\nint luhn(const char* cc)\n{\n\tconst int m[] = {0,2,4,6,8,1,3,5,7,9}; \n\tint i, odd = 1, sum = 0;\n\n\tfor (i = strlen(cc); i--; odd = !odd) {\n\t\tint digit = cc[i] - '0';\n\t\tsum += odd ? digit : m[digit];\n\t}\n\n\treturn sum % 10 == 0;\n}\n\nint main()\n{\n\tconst char* cc[] = {\n\t\t\"49927398716\",\n\t\t\"49927398717\",\n\t\t\"1234567812345678\",\n\t\t\"1234567812345670\",\n\t\t0\n\t};\n\tint i;\n\n\tfor (i = 0; cc[i]; i++)\n\t\tprintf(\"%16s\\t%s\\n\", cc[i], luhn(cc[i]) ? \"ok\" : \"not ok\");\n\n\treturn 0;\n}\n","Rust":"extern crate luhn_test_of_credit_card_numbers;\n\nuse luhn_test_of_credit_card_numbers::luhn_test;\n\nfn validate_isin(isin: &str) -> bool {\n if !isin.chars().all(|x| x.is_alphanumeric()) || isin.len() != 12 {\n return false;\n }\n if !isin[..2].chars().all(|x| x.is_alphabetic())\n || !isin[2..12].chars().all(|x| x.is_alphanumeric())\n || !isin.chars().last().unwrap().is_numeric()\n {\n return false;\n }\n\n let bytes = isin.as_bytes();\n\n let s2 = bytes\n .iter()\n .flat_map(|&c| {\n if c.is_ascii_digit() {\n vec![c]\n } else {\n (c + 10 - ('A' as u8)).to_string().into_bytes()\n }\n })\n .collect::<Vec<u8>>();\n\n let string = std::str::from_utf8(&s2).unwrap();\n let number = string.parse::<u64>().unwrap();\n\n return luhn_test(number as u64);\n}\n\n#[cfg(test)]\nmod tests {\n use super::validate_isin;\n\n #[test]\n fn test_validate_isin() {\n assert_eq!(validate_isin(\"US0378331005\"), true);\n assert_eq!(validate_isin(\"US0373831005\"), false);\n assert_eq!(validate_isin(\"U50378331005\"), false);\n assert_eq!(validate_isin(\"US03378331005\"), false);\n assert_eq!(validate_isin(\"AU0000XVGZA3\"), true);\n assert_eq!(validate_isin(\"AU0000VXGZA3\"), true);\n assert_eq!(validate_isin(\"FR0000988040\"), true);\n }\n}\n"} {"name":"MD4","C":"\n\n\n#include <stdlib.h>\n#include <string.h>\n#include <stdint.h>\n\nchar *MD4(char *str, int len); \n\ntypedef struct string{\n char *c;\n int len;\n char sign;\n}string;\n\nstatic uint32_t *MD4Digest(uint32_t *w, int len);\nstatic void setMD4Registers(uint32_t AA, uint32_t BB, uint32_t CC, uint32_t DD);\nstatic uint32_t changeEndianness(uint32_t x);\nstatic void resetMD4Registers(void);\nstatic string stringCat(string first, string second);\nstatic string uint32ToString(uint32_t l);\nstatic uint32_t stringToUint32(string s);\n\nstatic const char *BASE16 = \"0123456789abcdef=\";\n\n#define F(X,Y,Z) (((X)&(Y))|((~(X))&(Z)))\n#define G(X,Y,Z) (((X)&(Y))|((X)&(Z))|((Y)&(Z)))\n#define H(X,Y,Z) ((X)^(Y)^(Z))\n\n#define LEFTROTATE(A,N) ((A)<<(N))|((A)>>(32-(N)))\n\n#define MD4ROUND1(a,b,c,d,x,s) a += F(b,c,d) + x; a = LEFTROTATE(a, s);\n#define MD4ROUND2(a,b,c,d,x,s) a += G(b,c,d) + x + (uint32_t)0x5A827999; a = LEFTROTATE(a, s);\n#define MD4ROUND3(a,b,c,d,x,s) a += H(b,c,d) + x + (uint32_t)0x6ED9EBA1; a = LEFTROTATE(a, s);\n\nstatic uint32_t A = 0x67452301;\nstatic uint32_t B = 0xefcdab89;\nstatic uint32_t C = 0x98badcfe;\nstatic uint32_t D = 0x10325476;\n\nstring newString(char * c, int t){\n\tstring r;\n\tint i;\n\tif(c!=NULL){\n\t\tr.len = (t<=0)?strlen(c):t;\n\t\tr.c=(char *)malloc(sizeof(char)*(r.len+1));\n\t\tfor(i=0; i<r.len; i++) r.c[i]=c[i];\n\t\tr.c[r.len]='\\0';\n\t\treturn r;\n\t}\n\tr.len=t;\n\tr.c=(char *)malloc(sizeof(char)*(r.len+1));\n\tmemset(r.c,(char)0,sizeof(char)*(t+1));\n\tr.sign = 1;\n\treturn r;\n}\n\nstring stringCat(string first, string second){\n\tstring str=newString(NULL, first.len+second.len);\n\tint i;\n\n\tfor(i=0; i<first.len; i++){\n\t\tstr.c[i]=first.c[i];\n\t}\n\tfor(i=first.len; i<str.len; i++){\n\t\tstr.c[i]=second.c[i-first.len];\n\t}\n\treturn str;\n}\n\nstring base16Encode(string in){\n\tstring out=newString(NULL, in.len*2);\n\tint i,j;\n\n\tj=0;\n\tfor(i=0; i<in.len; i++){\n\t\tout.c[j++]=BASE16[((in.c[i] & 0xF0)>>4)];\n\t\tout.c[j++]=BASE16[(in.c[i] & 0x0F)];\n\t}\n\tout.c[j]='\\0';\n\treturn out;\n}\n\n\nstring uint32ToString(uint32_t l){\n\tstring s = newString(NULL,4);\n\tint i;\n\tfor(i=0; i<4; i++){\n\t\ts.c[i] = (l >> (8*(3-i))) & 0xFF;\n\t}\n\treturn s;\n}\n\nuint32_t stringToUint32(string s){\n\tuint32_t l;\n\tint i;\n\tl=0;\n\tfor(i=0; i<4; i++){\n\t\tl = l|(((uint32_t)((unsigned char)s.c[i]))<<(8*(3-i)));\n\t}\n\treturn l;\n}\n\nchar *MD4(char *str, int len){\n\tstring m=newString(str, len);\n\tstring digest;\n\tuint32_t *w;\n\tuint32_t *hash;\n\tuint64_t mlen=m.len;\n\tunsigned char oneBit = 0x80;\n\tint i, wlen;\n\n\n\tm=stringCat(m, newString((char *)&oneBit,1));\n\n\t\n\t\n\ti=((56-m.len)%64);\n\tif(i<0) i+=64;\n\tm=stringCat(m,newString(NULL, i));\n\n\tw = malloc(sizeof(uint32_t)*(m.len\/4+2));\n\n\t\n\tfor(i=0; i<m.len\/4; i++){\n\t\tw[i]=stringToUint32(newString(&(m.c[4*i]), 4));\n\t}\n\tw[i++] = (mlen<<3) & 0xFFFFFFFF;\n\tw[i++] = (mlen>>29) & 0xFFFFFFFF;\n\n\twlen=i;\n\n\n\t\n\tfor(i=0; i<wlen-2; i++){\n\t\tw[i]=changeEndianness(w[i]);\n\t}\n\n\thash = MD4Digest(w,wlen);\n\n\tdigest=newString(NULL,0);\n\tfor(i=0; i<4; i++){\n\t\thash[i]=changeEndianness(hash[i]);\n\t\tdigest=stringCat(digest,uint32ToString(hash[i]));\n\t}\n\n\treturn base16Encode(digest).c;\n}\n\nuint32_t *MD4Digest(uint32_t *w, int len){\n\t\n\tint i,j;\n\tuint32_t X[16];\n\tuint32_t *digest = malloc(sizeof(uint32_t)*4);\n\tuint32_t AA, BB, CC, DD;\n\n\tfor(i=0; i<len\/16; i++){\n\t\tfor(j=0; j<16; j++){\n\t\t\tX[j]=w[i*16+j];\n\t\t}\n\n\t\tAA=A;\n\t\tBB=B;\n\t\tCC=C;\n\t\tDD=D;\n\n\t\tMD4ROUND1(A,B,C,D,X[0],3);\n\t\tMD4ROUND1(D,A,B,C,X[1],7);\n\t\tMD4ROUND1(C,D,A,B,X[2],11);\n\t\tMD4ROUND1(B,C,D,A,X[3],19);\n\t\tMD4ROUND1(A,B,C,D,X[4],3);\n\t\tMD4ROUND1(D,A,B,C,X[5],7);\n\t\tMD4ROUND1(C,D,A,B,X[6],11);\n\t\tMD4ROUND1(B,C,D,A,X[7],19);\n\t\tMD4ROUND1(A,B,C,D,X[8],3);\n\t\tMD4ROUND1(D,A,B,C,X[9],7);\n\t\tMD4ROUND1(C,D,A,B,X[10],11);\n\t\tMD4ROUND1(B,C,D,A,X[11],19);\n\t\tMD4ROUND1(A,B,C,D,X[12],3);\n\t\tMD4ROUND1(D,A,B,C,X[13],7);\n\t\tMD4ROUND1(C,D,A,B,X[14],11);\n\t\tMD4ROUND1(B,C,D,A,X[15],19);\n\n\t\tMD4ROUND2(A,B,C,D,X[0],3);\n\t\tMD4ROUND2(D,A,B,C,X[4],5);\n\t\tMD4ROUND2(C,D,A,B,X[8],9);\n\t\tMD4ROUND2(B,C,D,A,X[12],13);\n\t\tMD4ROUND2(A,B,C,D,X[1],3);\n\t\tMD4ROUND2(D,A,B,C,X[5],5);\n\t\tMD4ROUND2(C,D,A,B,X[9],9);\n\t\tMD4ROUND2(B,C,D,A,X[13],13);\n\t\tMD4ROUND2(A,B,C,D,X[2],3);\n\t\tMD4ROUND2(D,A,B,C,X[6],5);\n\t\tMD4ROUND2(C,D,A,B,X[10],9);\n\t\tMD4ROUND2(B,C,D,A,X[14],13);\n\t\tMD4ROUND2(A,B,C,D,X[3],3);\n\t\tMD4ROUND2(D,A,B,C,X[7],5);\n\t\tMD4ROUND2(C,D,A,B,X[11],9);\n\t\tMD4ROUND2(B,C,D,A,X[15],13);\n\n\t\tMD4ROUND3(A,B,C,D,X[0],3);\n\t\tMD4ROUND3(D,A,B,C,X[8],9);\n\t\tMD4ROUND3(C,D,A,B,X[4],11);\n\t\tMD4ROUND3(B,C,D,A,X[12],15);\n\t\tMD4ROUND3(A,B,C,D,X[2],3);\n\t\tMD4ROUND3(D,A,B,C,X[10],9);\n\t\tMD4ROUND3(C,D,A,B,X[6],11);\n\t\tMD4ROUND3(B,C,D,A,X[14],15);\n\t\tMD4ROUND3(A,B,C,D,X[1],3);\n\t\tMD4ROUND3(D,A,B,C,X[9],9);\n\t\tMD4ROUND3(C,D,A,B,X[5],11);\n\t\tMD4ROUND3(B,C,D,A,X[13],15);\n\t\tMD4ROUND3(A,B,C,D,X[3],3);\n\t\tMD4ROUND3(D,A,B,C,X[11],9);\n\t\tMD4ROUND3(C,D,A,B,X[7],11);\n\t\tMD4ROUND3(B,C,D,A,X[15],15);\n\n\t\tA+=AA;\n\t\tB+=BB;\n\t\tC+=CC;\n\t\tD+=DD;\n\t}\n\n\tdigest[0]=A;\n\tdigest[1]=B;\n\tdigest[2]=C;\n\tdigest[3]=D;\n\tresetMD4Registers();\n\treturn digest;\n}\n\nuint32_t changeEndianness(uint32_t x){\n\treturn ((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24);\n}\n\nvoid setMD4Registers(uint32_t AA, uint32_t BB, uint32_t CC, uint32_t DD){\n\tA=AA;\n\tB=BB;\n\tC=CC;\n\tD=DD;\n}\n\nvoid resetMD4Registers(void){\n\tsetMD4Registers(0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476);\n}\n","Rust":"\n\n\n\n\n\nuse std::fmt::Write;\nuse std::mem;\n\n\n\n\n\n\n\nfn f(x: u32, y: u32, z: u32) -> u32 {\n (x & y) | (!x & z)\n}\n\n\nfn g(x: u32, y: u32, z: u32) -> u32 {\n (x & y) | (x & z) | (y & z)\n}\n\n\nfn h(x: u32, y: u32, z: u32) -> u32 {\n x ^ y ^ z\n}\n\n\n\n\nmacro_rules! md4round1 {\n ( $a:expr, $b:expr, $c:expr, $d:expr, $i:expr, $s:expr, $x:expr) => {\n {\n \n $a = ($a.wrapping_add( f($b, $c, $d) ).wrapping_add( $x[$i] ) ).rotate_left($s);\n }\n };\n}\n\n\n\n\nmacro_rules! md4round2 {\n ( $a:expr, $b:expr, $c:expr, $d:expr, $i:expr, $s:expr, $x:expr) => {\n {\n $a = ($a.wrapping_add( g($b, $c, $d)).wrapping_add($x[$i]).wrapping_add(0x5a827999_u32)).rotate_left($s);\n }\n };\n}\n\n\n\n\nmacro_rules! md4round3 {\n ( $a:expr, $b:expr, $c:expr, $d:expr, $i:expr, $s:expr, $x:expr) => {\n {\n $a = ($a.wrapping_add(h($b, $c, $d)).wrapping_add($x[$i]).wrapping_add(0x6ed9eba1_u32)).rotate_left($s);\n }\n };\n}\n\nfn convert_byte_vec_to_u32(mut bytes: Vec<u8>) -> Vec<u32> {\n\n bytes.shrink_to_fit();\n let num_bytes = bytes.len();\n let num_words = num_bytes \/ 4;\n unsafe {\n let words = Vec::from_raw_parts(bytes.as_mut_ptr() as *mut u32, num_words, num_words);\n mem::forget(bytes);\n words\n }\n}\n\n\n\nfn md4<T: Into<Vec<u8>>>(input: T) -> [u32; 4] {\n\n let mut bytes = input.into().to_vec();\n let initial_bit_len = (bytes.len() << 3) as u64;\n\n \n \n \n \n \n\n \n \n bytes.push(0x80_u8);\n while (bytes.len() % 64) != 56 {\n bytes.push(0_u8);\n }\n\n \n let mut w = convert_byte_vec_to_u32(bytes);\n\n \n \n \n w.push(initial_bit_len as u32); \n w.push((initial_bit_len >> 32) as u32);\n\n \n let mut a = 0x67452301_u32;\n let mut b = 0xefcdab89_u32;\n let mut c = 0x98badcfe_u32;\n let mut d = 0x10325476_u32;\n\n \n let n = w.len();\n for i in 0..n \/ 16 {\n\n \n let x = &w[i * 16..i * 16 + 16];\n\n let aa = a;\n let bb = b;\n let cc = c;\n let dd = d;\n\n \n md4round1!(a, b, c, d, 0, 3, x); \n md4round1!(d, a, b, c, 1, 7, x); \n md4round1!(c, d, a, b, 2, 11, x); \n md4round1!(b, c, d, a, 3, 19, x); \n md4round1!(a, b, c, d, 4, 3, x); \n md4round1!(d, a, b, c, 5, 7, x); \n md4round1!(c, d, a, b, 6, 11, x); \n md4round1!(b, c, d, a, 7, 19, x); \n md4round1!(a, b, c, d, 8, 3, x); \n md4round1!(d, a, b, c, 9, 7, x); \n md4round1!(c, d, a, b, 10, 11, x);\n md4round1!(b, c, d, a, 11, 19, x);\n md4round1!(a, b, c, d, 12, 3, x); \n md4round1!(d, a, b, c, 13, 7, x); \n md4round1!(c, d, a, b, 14, 11, x);\n md4round1!(b, c, d, a, 15, 19, x);\n\n \n md4round2!(a, b, c, d, 0, 3, x); \n md4round2!(d, a, b, c, 4, 5, x); \n md4round2!(c, d, a, b, 8, 9, x); \n md4round2!(b, c, d, a, 12, 13, x);\n md4round2!(a, b, c, d, 1, 3, x); \n md4round2!(d, a, b, c, 5, 5, x); \n md4round2!(c, d, a, b, 9, 9, x); \n md4round2!(b, c, d, a, 13, 13, x);\n md4round2!(a, b, c, d, 2, 3, x); \n md4round2!(d, a, b, c, 6, 5, x); \n md4round2!(c, d, a, b, 10, 9, x); \n md4round2!(b, c, d, a, 14, 13, x);\n md4round2!(a, b, c, d, 3, 3, x); \n md4round2!(d, a, b, c, 7, 5, x); \n md4round2!(c, d, a, b, 11, 9, x); \n md4round2!(b, c, d, a, 15, 13, x);\n\n \n md4round3!(a, b, c, d, 0, 3, x); \n md4round3!(d, a, b, c, 8, 9, x); \n md4round3!(c, d, a, b, 4, 11, x); \n md4round3!(b, c, d, a, 12, 15, x);\n md4round3!(a, b, c, d, 2, 3, x); \n md4round3!(d, a, b, c, 10, 9, x); \n md4round3!(c, d, a, b, 6, 11, x); \n md4round3!(b, c, d, a, 14, 15, x);\n md4round3!(a, b, c, d, 1, 3, x); \n md4round3!(d, a, b, c, 9, 9, x); \n md4round3!(c, d, a, b, 5, 11, x); \n md4round3!(b, c, d, a, 13, 15, x);\n md4round3!(a, b, c, d, 3, 3, x); \n md4round3!(d, a, b, c, 11, 9, x); \n md4round3!(c, d, a, b, 7, 11, x); \n md4round3!(b, c, d, a, 15, 15, x);\n\n a = a.wrapping_add(aa);\n b = b.wrapping_add(bb);\n c = c.wrapping_add(cc);\n d = d.wrapping_add(dd);\n }\n\n \n \n \n [u32::from_be(a), u32::from_be(b), u32::from_be(c), u32::from_be(d)]\n}\n\nfn digest_to_str(digest: &[u32]) -> String {\n let mut s = String::new();\n for &word in digest {\n write!(&mut s, \"{:08x}\", word).unwrap();\n }\n s\n}\n\nfn main() {\n let val = \"Rosetta Code\";\n println!(\"md4(\\\"{}\\\") = {}\", val, digest_to_str(&md4(val)));\n}\n"} {"name":"MD5","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <openssl\/md5.h>\n\nconst char *string = \"The quick brown fox jumped over the lazy dog's back\";\n\nint main()\n{\n int i;\n unsigned char result[MD5_DIGEST_LENGTH];\n\n MD5(string, strlen(string), result);\n\n \n for(i = 0; i < MD5_DIGEST_LENGTH; i++)\n printf(\"%02x\", result[i]);\n printf(\"\\n\");\n\n return EXIT_SUCCESS;\n}\n","Rust":"extern crate crypto;\n\nuse crypto::digest::Digest;\nuse crypto::md5::Md5;\n\nfn main() {\n let mut sh = Md5::new();\n sh.input_str(\"The quick brown fox jumped over the lazy dog's back\");\n println!(\"{}\", sh.result_str());\n}\n"} {"name":"Make directory path","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <libgen.h>\n#include <string.h>\n#include <sys\/stat.h>\n#include <sys\/types.h>\n\nint main (int argc, char **argv) {\n char *str, *s;\n struct stat statBuf;\n\n if (argc != 2) {\n fprintf (stderr, \"usage: %s <path>\\n\", basename (argv[0]));\n exit (1);\n }\n s = argv[1];\n while ((str = strtok (s, \"\/\")) != NULL) {\n if (str != s) {\n str[-1] = '\/';\n }\n if (stat (argv[1], &statBuf) == -1) {\n mkdir (argv[1], 0);\n } else {\n if (! S_ISDIR (statBuf.st_mode)) {\n fprintf (stderr, \"couldn't create directory %s\\n\", argv[1]);\n exit (1);\n }\n }\n s = NULL;\n }\n return 0;\n}\n","Rust":"use std::fs;\n\nfn main() {\n fs::create_dir_all(\".\/path\/to\/dir\").expect(\"An Error Occured!\")\n}\n"} {"name":"Man or boy test","C":"\n#include <stdio.h>\n#include <stdlib.h>\n\n\ntypedef struct arg\n{\n int (*fn)(struct arg*);\n int *k;\n struct arg *x1, *x2, *x3, *x4, *x5;\n} ARG;\n\n\nint f_1 (ARG* _) { return -1; }\nint f0 (ARG* _) { return 0; }\nint f1 (ARG* _) { return 1; }\n\n\nint eval(ARG* a) { return a->fn(a); }\n#define MAKE_ARG(...) (&(ARG){__VA_ARGS__})\n#define FUN(...) MAKE_ARG(B, &k, __VA_ARGS__)\n\nint A(ARG*);\n\n\nint B(ARG* a)\n{\n int k = *a->k -= 1;\n return A(FUN(a, a->x1, a->x2, a->x3, a->x4));\n}\n\nint A(ARG* a)\n{\n return *a->k <= 0 ? eval(a->x4) + eval(a->x5) : B(a);\n}\n\nint main(int argc, char **argv)\n{\n int k = argc == 2 ? strtol(argv[1], 0, 0) : 10;\n printf(\"%d\\n\", A(FUN(MAKE_ARG(f1), MAKE_ARG(f_1), MAKE_ARG(f_1),\n MAKE_ARG(f1), MAKE_ARG(f0))));\n return 0;\n}\n","Rust":"use std::cell::Cell;\n\ntrait Arg {\n fn run(&self) -> i32;\n}\n\nimpl Arg for i32 {\n fn run(&self) -> i32 { *self }\n}\n\nstruct B<'a> {\n k: &'a Cell<i32>,\n x1: &'a Arg,\n x2: &'a Arg,\n x3: &'a Arg,\n x4: &'a Arg,\n}\n\nimpl<'a> Arg for B<'a> {\n fn run(&self) -> i32 {\n self.k.set(self.k.get() - 1);\n a(self.k.get(), self, self.x1, self.x2, self.x3, self.x4)\n }\n}\n\nfn a(k: i32, x1: &Arg, x2: &Arg, x3: &Arg, x4: &Arg, x5: &Arg) -> i32 {\n if k <= 0 {\n x4.run() + x5.run()\n } else {\n B{\n k: &Cell::new(k),\n x1, x2, x3, x4\n }.run()\n }\n}\n\npub fn main() {\n println!(\"{}\", a(10, &1, &-1, &-1, &1, &0));\n}\n"} {"name":"Mandelbrot set","C":" \n #include <stdio.h>\n #include <math.h>\n int main()\n {\n \n int iX,iY;\n const int iXmax = 800; \n const int iYmax = 800;\n \n double Cx,Cy;\n const double CxMin=-2.5;\n const double CxMax=1.5;\n const double CyMin=-2.0;\n const double CyMax=2.0;\n \n double PixelWidth=(CxMax-CxMin)\/iXmax;\n double PixelHeight=(CyMax-CyMin)\/iYmax;\n \n \n const int MaxColorComponentValue=255; \n FILE * fp;\n char *filename=\"new1.ppm\";\n char *comment=\"# \";\n static unsigned char color[3];\n \n double Zx, Zy;\n double Zx2, Zy2; \n \n int Iteration;\n const int IterationMax=200;\n \n const double EscapeRadius=2;\n double ER2=EscapeRadius*EscapeRadius;\n \n fp= fopen(filename,\"wb\"); \n \n fprintf(fp,\"P6\\n %s\\n %d\\n %d\\n %d\\n\",comment,iXmax,iYmax,MaxColorComponentValue);\n \n for(iY=0;iY<iYmax;iY++)\n {\n Cy=CyMin + iY*PixelHeight;\n if (fabs(Cy)< PixelHeight\/2) Cy=0.0; \n for(iX=0;iX<iXmax;iX++)\n { \n Cx=CxMin + iX*PixelWidth;\n \n Zx=0.0;\n Zy=0.0;\n Zx2=Zx*Zx;\n Zy2=Zy*Zy;\n \n for (Iteration=0;Iteration<IterationMax && ((Zx2+Zy2)<ER2);Iteration++)\n {\n Zy=2*Zx*Zy + Cy;\n Zx=Zx2-Zy2 +Cx;\n Zx2=Zx*Zx;\n Zy2=Zy*Zy;\n };\n \n if (Iteration==IterationMax)\n { \n color[0]=0;\n color[1]=0;\n color[2]=0; \n }\n else \n { \n color[0]=255; \n color[1]=255; \n color[2]=255;\n };\n \n fwrite(color,1,3,fp);\n }\n }\n fclose(fp);\n return 0;\n }\n","Rust":"extern crate image;\nextern crate num_complex;\n\nuse num_complex::Complex;\n\nfn main() {\n let max_iterations = 256u16;\n let img_side = 800u32;\n let cxmin = -2f32;\n let cxmax = 1f32;\n let cymin = -1.5f32;\n let cymax = 1.5f32;\n let scalex = (cxmax - cxmin) \/ img_side as f32;\n let scaley = (cymax - cymin) \/ img_side as f32;\n\n \n let mut imgbuf = image::ImageBuffer::new(img_side, img_side);\n\n \n for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {\n let cx = cxmin + x as f32 * scalex;\n let cy = cymin + y as f32 * scaley;\n\n let c = Complex::new(cx, cy);\n let mut z = Complex::new(0f32, 0f32);\n\n let mut i = 0;\n for t in 0..max_iterations {\n if z.norm() > 2.0 {\n break;\n }\n z = z * z + c;\n i = t;\n }\n\n *pixel = image::Luma([i as u8]);\n }\n\n \n imgbuf.save(\"fractal.png\").unwrap();\n}\n"} {"name":"Map range","C":"double inc = (nHasta - nDesde) \/ ( nTotal - 1);\nlista[0] = nDesde;\nlista[nTotal] = nHasta;\nfor( n=1; n<nTotal; n++){\n lista[n] = lista[n-1] + inc;\n}\n","Rust":"use std::ops::{Add, Sub, Mul, Div};\n\nfn map_range<T: Copy>(from_range: (T, T), to_range: (T, T), s: T) -> T \n where T: Add<T, Output=T> +\n Sub<T, Output=T> +\n Mul<T, Output=T> +\n Div<T, Output=T>\n{\n to_range.0 + (s - from_range.0) * (to_range.1 - to_range.0) \/ (from_range.1 - from_range.0)\n}\n\nfn main() {\n let input: Vec<f64> = vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];\n let result = input.into_iter()\n .map(|x| map_range((0.0, 10.0), (-1.0, 0.0), x))\n .collect::<Vec<f64>>();\n print!(\"{:?}\", result);\n}\n"} {"name":"Matrix chain multiplication","C":"#include <stdio.h>\n#include <limits.h>\n#include <stdlib.h>\n\nint **m;\nint **s;\n\nvoid optimal_matrix_chain_order(int *dims, int n) {\n int len, i, j, k, temp, cost;\n n--;\n m = (int **)malloc(n * sizeof(int *));\n for (i = 0; i < n; ++i) {\n m[i] = (int *)calloc(n, sizeof(int));\n }\n\n s = (int **)malloc(n * sizeof(int *));\n for (i = 0; i < n; ++i) {\n s[i] = (int *)calloc(n, sizeof(int));\n }\n\n for (len = 1; len < n; ++len) {\n for (i = 0; i < n - len; ++i) {\n j = i + len;\n m[i][j] = INT_MAX;\n for (k = i; k < j; ++k) {\n temp = dims[i] * dims[k + 1] * dims[j + 1];\n cost = m[i][k] + m[k + 1][j] + temp;\n if (cost < m[i][j]) {\n m[i][j] = cost;\n s[i][j] = k;\n }\n }\n }\n }\n}\n\nvoid print_optimal_chain_order(int i, int j) {\n if (i == j)\n printf(\"%c\", i + 65);\n else {\n printf(\"(\");\n print_optimal_chain_order(i, s[i][j]);\n print_optimal_chain_order(s[i][j] + 1, j);\n printf(\")\");\n }\n}\n\nint main() {\n int i, j, n;\n int a1[4] = {5, 6, 3, 1};\n int a2[13] = {1, 5, 25, 30, 100, 70, 2, 1, 100, 250, 1, 1000, 2};\n int a3[12] = {1000, 1, 500, 12, 1, 700, 2500, 3, 2, 5, 14, 10};\n int *dims_list[3] = {a1, a2, a3};\n int sizes[3] = {4, 13, 12};\n for (i = 0; i < 3; ++i) {\n printf(\"Dims \u00a0: [\");\n n = sizes[i];\n for (j = 0; j < n; ++j) {\n printf(\"%d\", dims_list[i][j]);\n if (j < n - 1) printf(\", \"); else printf(\"]\\n\");\n } \n optimal_matrix_chain_order(dims_list[i], n);\n printf(\"Order\u00a0: \");\n print_optimal_chain_order(0, n - 2);\n printf(\"\\nCost \u00a0: %d\\n\\n\", m[0][n - 2]);\n for (j = 0; j <= n - 2; ++j) free(m[j]);\n free(m);\n for (j = 0; j <= n - 2; ++j) free(s[j]);\n free(s);\n }\n return 0;\n}\n","Rust":"use std::collections::HashMap;\n\nfn main() {\n println!(\"{}\\n\", mcm_display(vec![5, 6, 3, 1]));\n println!(\n \"{}\\n\",\n mcm_display(vec![1, 5, 25, 30, 100, 70, 2, 1, 100, 250, 1, 1000, 2])\n );\n println!(\n \"{}\\n\",\n mcm_display(vec![1000, 1, 500, 12, 1, 700, 2500, 3, 2, 5, 14, 10])\n );\n}\n\nfn mcm_display(dims: Vec<i32>) -> String {\n let mut costs: HashMap<Vec<i32>, (i32, Vec<usize>)> = HashMap::new();\n let mut line = format!(\"Dims\u00a0: {:?}\\n\", dims);\n let ans = mcm(dims, &mut costs);\n let mut mats = (1..=ans.1.len() + 1)\n .map(|x| x.to_string())\n .collect::<Vec<String>>();\n for i in 0..ans.1.len() {\n let mat_taken = mats[ans.1[i]].clone();\n mats.remove(ans.1[i]);\n mats[ans.1[i]] = \"(\".to_string() + &mat_taken + \"*\" + &mats[ans.1[i]] + \")\";\n }\n line += &format!(\"Order: {}\\n\", mats[0]);\n line += &format!(\"Cost\u00a0: {}\", ans.0);\n line\n}\n\nfn mcm(dims: Vec<i32>, costs: &mut HashMap<Vec<i32>, (i32, Vec<usize>)>) -> (i32, Vec<usize>) {\n match costs.get(&dims) {\n Some(c) => c.clone(),\n None => {\n let ans = if dims.len() == 3 {\n (dims[0] * dims[1] * dims[2], vec![0])\n } else {\n let mut min_cost = std::i32::MAX;\n let mut min_path = Vec::new();\n for i in 1..dims.len() - 1 {\n let taken = dims[(i - 1)..(i + 2)].to_vec();\n let mut rest = dims[..i].to_vec();\n rest.extend_from_slice(&dims[(i + 1)..]);\n let a1 = mcm(taken, costs);\n let a2 = mcm(rest, costs);\n if a1.0 + a2.0 < min_cost {\n min_cost = a1.0 + a2.0;\n min_path = vec![i - 1];\n min_path.extend_from_slice(&a2.1);\n }\n }\n (min_cost, min_path)\n };\n costs.insert(dims, ans.clone());\n ans\n }\n }\n}\n"} {"name":"Matrix multiplication","C":"#include <stdio.h>\n\n#define MAT_ELEM(rows,cols,r,c) (r*cols+c)\n\n\n\n#ifdef __cplusplus\n typedef double * const __restrict MAT_OUT_t;\n#else\n typedef double * const restrict MAT_OUT_t;\n#endif\ntypedef const double * const MAT_IN_t;\n\nstatic inline void mat_mult(\n const int m,\n const int n,\n const int p, \n MAT_IN_t a,\n MAT_IN_t b,\n MAT_OUT_t c)\n{\n for (int row=0; row<m; row++) {\n for (int col=0; col<p; col++) {\n c[MAT_ELEM(m,p,row,col)] = 0;\n for (int i=0; i<n; i++) {\n c[MAT_ELEM(m,p,row,col)] += a[MAT_ELEM(m,n,row,i)]*b[MAT_ELEM(n,p,i,col)];\n }\n }\n }\n}\n\nstatic inline void mat_show(\n const int m,\n const int p,\n MAT_IN_t a)\n{\n for (int row=0; row<m;row++) {\n for (int col=0; col<p;col++) {\n printf(\"\\t%7.3f\", a[MAT_ELEM(m,p,row,col)]);\n }\n putchar('\\n');\n }\n}\n\nint main(void)\n{\n double a[4*4] = {1, 1, 1, 1,\n 2, 4, 8, 16,\n 3, 9, 27, 81,\n 4, 16, 64, 256};\n\n double b[4*3] = { 4.0, -3.0, 4.0\/3,\n -13.0\/3, 19.0\/4, -7.0\/3,\n 3.0\/2, -2.0, 7.0\/6,\n -1.0\/6, 1.0\/4, -1.0\/6};\n\n double c[4*3] = {0};\n \n mat_mult(4,4,3,a,b,c);\n mat_show(4,3,c);\n return 0;\n}\n","Rust":"struct Matrix {\n dat: [[f32; 3]; 3]\n}\n\nimpl Matrix {\n pub fn mult_m(a: Matrix, b: Matrix) -> Matrix\n {\n let mut out = Matrix {\n dat: [[0., 0., 0.],\n [0., 0., 0.],\n [0., 0., 0.]\n ]\n };\n\n for i in 0..3{\n for j in 0..3 {\n for k in 0..3 {\n out.dat[i][j] += a.dat[i][k] * b.dat[k][j];\n }\n }\n }\n\n out\n }\n\n pub fn print(self)\n {\n for i in 0..3 {\n for j in 0..3 {\n print!(\"{} \", self.dat[i][j]);\n }\n print!(\"\\n\");\n }\n }\n}\n\nfn main()\n{\n let a = Matrix {\n dat: [[1., 2., 3.],\n [4., 5., 6.],\n [7., 8., 9.]\n ]\n };\n\n let b = Matrix {\n dat: [[1., 0., 0.],\n [0., 1., 0.],\n [0., 0., 1.]]\n };\n\t\n\n \n let c = Matrix::mult_m(a, b);\n \n\n c.print();\n}\n"} {"name":"Matrix transposition","C":"#include <stdio.h>\n\nvoid transpose(void *dest, void *src, int src_h, int src_w)\n{\n\tint i, j;\n\tdouble (*d)[src_h] = dest, (*s)[src_w] = src;\n\tfor (i = 0; i < src_h; i++)\n\t\tfor (j = 0; j < src_w; j++)\n\t\t\td[j][i] = s[i][j];\n}\n\nint main()\n{\n\tint i, j;\n\tdouble a[3][5] = {{ 0, 1, 2, 3, 4 },\n\t\t\t { 5, 6, 7, 8, 9 },\n\t\t\t { 1, 0, 0, 0, 42}};\n\tdouble b[5][3];\n\ttranspose(b, a, 3, 5);\n\n\tfor (i = 0; i < 5; i++)\n\t\tfor (j = 0; j < 3; j++)\n\t\t\tprintf(\"%g%c\", b[i][j], j == 2 ? '\\n' : ' ');\n\treturn 0;\n}\n","Rust":"struct Matrix {\n dat: [[i32; 3]; 3]\n}\n \n\n \nimpl Matrix {\n pub fn transpose_m(a: Matrix) -> Matrix\n {\n let mut out = Matrix {\n dat: [[0, 0, 0],\n [0, 0, 0],\n [0, 0, 0]\n ]\n };\n \n for i in 0..3{\n for j in 0..3{\n \n out.dat[i][j] = a.dat[j][i];\n }\n }\n \n out\n }\n \n pub fn print(self)\n {\n for i in 0..3 {\n for j in 0..3 {\n print!(\"{} \", self.dat[i][j]);\n }\n print!(\"\\n\");\n }\n }\n}\n \nfn main()\n{\n let a = Matrix {\n dat: [[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9] ]\n };\n\nlet c = Matrix::transpose_m(a);\n c.print();\n}\n"} {"name":"Matrix-exponentiation operator","C":"#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n\ntypedef struct squareMtxStruct {\n int dim;\n double *cells;\n double **m;\n} *SquareMtx;\n\n\ntypedef void (*FillFunc)( double *cells, int r, int dim, void *ff_data);\n\nSquareMtx NewSquareMtx( int dim, FillFunc fillFunc, void *ff_data ) \n{\n SquareMtx sm = malloc(sizeof(struct squareMtxStruct));\n if (sm) {\n int rw;\n sm->dim = dim;\n sm->cells = malloc(dim*dim * sizeof(double));\n sm->m = malloc( dim * sizeof(double *));\n if ((sm->cells != NULL) && (sm->m != NULL)) {\n for (rw=0; rw<dim; rw++) {\n sm->m[rw] = sm->cells + dim*rw;\n fillFunc( sm->m[rw], rw, dim, ff_data );\n }\n }\n else {\n free(sm->m);\n free(sm->cells);\n free(sm);\n printf(\"Square Matrix allocation failure\\n\");\n return NULL;\n }\n }\n else {\n printf(\"Malloc failed for square matrix\\n\");\n }\n return sm;\n}\n\nvoid ffMatxSquare( double *cells, int rw, int dim, SquareMtx m0 )\n{\n int col, ix;\n double sum;\n double *m0rw = m0->m[rw];\n \n for (col = 0; col < dim; col++) {\n sum = 0.0;\n for (ix=0; ix<dim; ix++)\n sum += m0rw[ix] * m0->m[ix][col];\n cells[col] = sum;\n }\n}\n\nvoid ffMatxMulply( double *cells, int rw, int dim, SquareMtx mplcnds[] )\n{\n SquareMtx mleft = mplcnds[0];\n SquareMtx mrigt = mplcnds[1];\n double sum;\n double *m0rw = mleft->m[rw];\n int col, ix;\n\n for (col = 0; col < dim; col++) {\n sum = 0.0;\n for (ix=0; ix<dim; ix++)\n sum += m0rw[ix] * mrigt->m[ix][col];\n cells[col] = sum;\n }\n}\n\nvoid MatxMul( SquareMtx mr, SquareMtx left, SquareMtx rigt)\n{\n int rw;\n SquareMtx mplcnds[2];\n mplcnds[0] = left; mplcnds[1] = rigt;\n\n for (rw = 0; rw < left->dim; rw++) \n ffMatxMulply( mr->m[rw], rw, left->dim, mplcnds);\n}\n\nvoid ffIdentity( double *cells, int rw, int dim, void *v )\n{\n int col;\n for (col=0; col<dim; col++) cells[col] = 0.0;\n cells[rw] = 1.0;\n}\nvoid ffCopy(double *cells, int rw, int dim, SquareMtx m1)\n{\n int col;\n for (col=0; col<dim; col++) cells[col] = m1->m[rw][col];\n}\n\nvoid FreeSquareMtx( SquareMtx m ) \n{\n free(m->m);\n free(m->cells);\n free(m);\n}\n\nSquareMtx SquareMtxPow( SquareMtx m0, int exp )\n{\n SquareMtx v0 = NewSquareMtx(m0->dim, ffIdentity, NULL);\n SquareMtx v1 = NULL;\n SquareMtx base0 = NewSquareMtx( m0->dim, ffCopy, m0);\n SquareMtx base1 = NULL;\n SquareMtx mplcnds[2], t;\n\n while (exp) {\n if (exp % 2) {\n if (v1)\n MatxMul( v1, v0, base0);\n else {\n mplcnds[0] = v0; mplcnds[1] = base0;\n v1 = NewSquareMtx(m0->dim, ffMatxMulply, mplcnds); \n }\n {t = v0; v0=v1; v1 = t;}\n }\n if (base1)\n MatxMul( base1, base0, base0);\n else \n base1 = NewSquareMtx( m0->dim, ffMatxSquare, base0);\n t = base0; base0 = base1; base1 = t;\n exp = exp\/2;\n }\n if (base0) FreeSquareMtx(base0);\n if (base1) FreeSquareMtx(base1);\n if (v1) FreeSquareMtx(v1);\n return v0;\n}\n\nFILE *fout;\nvoid SquareMtxPrint( SquareMtx mtx, const char *mn ) \n{\n int rw, col;\n int d = mtx->dim;\n\n fprintf(fout, \"%s dim:%d =\\n\", mn, mtx->dim);\n\n for (rw=0; rw<d; rw++) {\n fprintf(fout, \" |\");\n for(col=0; col<d; col++) \n fprintf(fout, \"%8.5f \",mtx->m[rw][col] );\n fprintf(fout, \" |\\n\");\n }\n fprintf(fout, \"\\n\");\n}\n\nvoid fillInit( double *cells, int rw, int dim, void *data)\n{\n double theta = 3.1415926536\/6.0;\n double c1 = cos( theta);\n double s1 = sin( theta);\n\n switch(rw) {\n case 0:\n cells[0]=c1; cells[1]=s1; cells[2]=0.0;\n break;\n case 1:\n cells[0]=-s1; cells[1]=c1; cells[2]=0;\n break;\n case 2:\n cells[0]=0.0; cells[1]=0.0; cells[2]=1.0;\n break;\n }\n}\n\nint main()\n{\n SquareMtx m0 = NewSquareMtx( 3, fillInit, NULL);\n SquareMtx m1 = SquareMtxPow( m0, 5);\n SquareMtx m2 = SquareMtxPow( m0, 9);\n SquareMtx m3 = SquareMtxPow( m0, 2);\n\n\n fout = fopen(\"matrx_exp.txt\", \"w\");\n SquareMtxPrint(m0, \"m0\"); FreeSquareMtx(m0);\n SquareMtxPrint(m1, \"m0^5\"); FreeSquareMtx(m1);\n SquareMtxPrint(m2, \"m0^9\"); FreeSquareMtx(m2);\n SquareMtxPrint(m3, \"m0^2\"); FreeSquareMtx(m3);\n fclose(fout);\n\n return 0;\n}\n","Rust":"use std::fmt;\nuse std::ops;\nconst WIDTH: usize = 6;\n\n#[derive(Clone)]\nstruct SqMat {\n data: Vec<Vec<i64>>,\n}\n\nimpl fmt::Debug for SqMat {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n let mut row = \"\".to_string();\n for i in &self.data {\n for j in i {\n row += &format!(\"{:>w$} \", j, w = WIDTH);\n }\n row += &\"\\n\";\n }\n write!(f, \"{}\", row)\n }\n}\n\nimpl ops::BitXor<u32> for SqMat {\n type Output = Self;\n\n fn bitxor(self, n: u32) -> Self::Output {\n let mut aux = self.data.clone();\n let mut ans: SqMat = SqMat {\n data: vec![vec![0; aux.len()]; aux.len()],\n };\n for i in 0..aux.len() {\n ans.data[i][i] = 1;\n }\n let mut b = n;\n while b > 0 {\n if b & 1 > 0 {\n \n let mut tmp = aux.clone();\n for i in 0..aux.len() {\n for j in 0..aux.len() {\n tmp[i][j] = 0;\n for k in 0..aux.len() {\n tmp[i][j] += ans.data[i][k] * aux[k][j];\n }\n }\n }\n ans.data = tmp;\n }\n b >>= 1;\n if b > 0 {\n \n let mut tmp = aux.clone();\n for i in 0..aux.len() {\n for j in 0..aux.len() {\n tmp[i][j] = 0;\n for k in 0..aux.len() {\n tmp[i][j] += aux[i][k] * aux[k][j];\n }\n }\n }\n aux = tmp;\n }\n }\n ans\n }\n}\n\nfn main() {\n let sm: SqMat = SqMat {\n data: vec![vec![1, 2, 0], vec![0, 3, 1], vec![1, 0, 0]],\n };\n for i in 0..11 {\n println!(\"Power of {}:\\n{:?}\", i, sm.clone() ^ i);\n }\n}\n"} {"name":"Maximum triangle path sum","C":"#include <stdio.h>\n#include <math.h>\n\n#define max(x,y) ((x) > (y)\u00a0? (x)\u00a0: (y))\n\nint tri[] = {\n 55,\n\t94, 48,\n\t95, 30, 96,\n\t77, 71, 26, 67,\n\t97, 13, 76, 38, 45,\n\t7, 36, 79, 16, 37, 68,\n\t48, 7, 9, 18, 70, 26, 6,\n\t18, 72, 79, 46, 59, 79, 29, 90,\n\t20, 76, 87, 11, 32, 7, 7, 49, 18,\n\t27, 83, 58, 35, 71, 11, 25, 57, 29, 85,\n\t14, 64, 36, 96, 27, 11, 58, 56, 92, 18, 55,\n\t2, 90, 3, 60, 48, 49, 41, 46, 33, 36, 47, 23,\n\t92, 50, 48, 2, 36, 59, 42, 79, 72, 20, 82, 77, 42,\n\t56, 78, 38, 80, 39, 75, 2, 71, 66, 66, 1, 3, 55, 72,\n\t44, 25, 67, 84, 71, 67, 11, 61, 40, 57, 58, 89, 40, 56, 36,\n\t85, 32, 25, 85, 57, 48, 84, 35, 47, 62, 17, 1, 1, 99, 89, 52,\n\t6, 71, 28, 75, 94, 48, 37, 10, 23, 51, 6, 48, 53, 18, 74, 98, 15,\n\t27, 2, 92, 23, 8, 71, 76, 84, 15, 52, 92, 63, 81, 10, 44, 10, 69, 93\n};\n\nint main(void)\n{\n const int len = sizeof(tri) \/ sizeof(tri[0]);\n const int base = (sqrt(8*len + 1) - 1) \/ 2;\n int step = base - 1;\n int stepc = 0;\n\n int i;\n for (i = len - base - 1; i >= 0; --i) {\n tri[i] += max(tri[i + step], tri[i + step + 1]);\n if (++stepc == step) {\n step--;\n stepc = 0;\n }\n }\n\n printf(\"%d\\n\", tri[0]);\n return 0;\n}\n","Rust":"use std::cmp::max;\n\nfn max_path(vector: &mut Vec<Vec<u32>>) -> u32 {\n \n while vector.len() > 1 {\n \n let last = vector.pop().unwrap();\n let ante = vector.pop().unwrap();\n \n let mut new: Vec<u32> = Vec::new();\n \n for (i, value) in ante.iter().enumerate() {\n new.push(max(last[i], last[i+1]) + value);\n };\n \n vector.push(new);\n };\n \n vector[0][0]\n}\n\nfn main() {\n let mut data = \"55\n94 48\n95 30 96\n77 71 26 67\n97 13 76 38 45\n07 36 79 16 37 68\n48 07 09 18 70 26 06\n18 72 79 46 59 79 29 90\n20 76 87 11 32 07 07 49 18\n27 83 58 35 71 11 25 57 29 85\n14 64 36 96 27 11 58 56 92 18 55\n02 90 03 60 48 49 41 46 33 36 47 23\n92 50 48 02 36 59 42 79 72 20 82 77 42\n56 78 38 80 39 75 02 71 66 66 01 03 55 72\n44 25 67 84 71 67 11 61 40 57 58 89 40 56 36\n85 32 25 85 57 48 84 35 47 62 17 01 01 99 89 52\n06 71 28 75 94 48 37 10 23 51 06 48 53 18 74 98 15\n27 02 92 23 08 71 76 84 15 52 92 63 81 10 44 10 69 93\";\n\n let mut vector = data.split(\"\\n\").map(|x| x.split(\" \").map(|s: &str| s.parse::<u32>().unwrap())\n .collect::<Vec<u32>>()).collect::<Vec<Vec<u32>>>();\n \n let max_value = max_path(&mut vector);\n \n println!(\"{}\", max_value);\n \n}\n"} {"name":"Maze generation","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <locale.h>\n\n#define DOUBLE_SPACE 1\n\n#if DOUBLE_SPACE\n#\tdefine SPC \"\u3000\"\n#else\n#\tdefine SPC \" \"\n#endif\n\nwchar_t glyph[] = L\"\"SPC\"\u2502\u2502\u2502\u2500\u2518\u2510\u2524\u2500\u2514\u250c\u251c\u2500\u2534\u252c\u253c\"SPC\"\u2506\u2506\u2506\u2504\u256f\u256e \u2504\u2570\u256d \u2504\";\n\ntypedef unsigned char byte;\nenum { N = 1, S = 2, W = 4, E = 8, V = 16 };\n\nbyte **cell;\nint w, h, avail;\n#define each(i, x, y) for (i = x; i <= y; i++)\n\nint irand(int n)\n{\n\tint r, rmax = n * (RAND_MAX \/ n);\n\twhile ((r = rand()) >= rmax);\n\treturn r \/ (RAND_MAX\/n);\n}\n\nvoid show()\n{\n\tint i, j, c;\n\teach(i, 0, 2 * h) {\n\t\teach(j, 0, 2 * w) {\n\t\t\tc = cell[i][j];\n\t\t\tif (c > V) printf(\"\\033[31m\");\n\t\t\tprintf(\"%lc\", glyph[c]);\n\t\t\tif (c > V) printf(\"\\033[m\");\n\t\t}\n\t\tputchar('\\n');\n\t}\n}\n\ninline int max(int a, int b) { return a >= b ? a : b; }\ninline int min(int a, int b) { return b >= a ? a : b; }\n\nstatic int dirs[4][2] = {{-2, 0}, {0, 2}, {2, 0}, {0, -2}};\nvoid walk(int x, int y)\n{\n\tint i, t, x1, y1, d[4] = { 0, 1, 2, 3 };\n\n\tcell[y][x] |= V;\n\tavail--;\n\n\tfor (x1 = 3; x1; x1--)\n\t\tif (x1 != (y1 = irand(x1 + 1)))\n\t\t\ti = d[x1], d[x1] = d[y1], d[y1] = i;\n\n\tfor (i = 0; avail && i < 4; i++) {\n\t\tx1 = x + dirs[ d[i] ][0], y1 = y + dirs[ d[i] ][1];\n\n\t\tif (cell[y1][x1] & V) continue;\n\n\t\t\n\t\tif (x1 == x) {\n\t\t\tt = (y + y1) \/ 2;\n\t\t\tcell[t][x+1] &= ~W, cell[t][x] &= ~(E|W), cell[t][x-1] &= ~E;\n\t\t} else if (y1 == y) {\n\t\t\tt = (x + x1)\/2;\n\t\t\tcell[y-1][t] &= ~S, cell[y][t] &= ~(N|S), cell[y+1][t] &= ~N;\n\t\t}\n\t\twalk(x1, y1);\n\t}\n}\n\nint solve(int x, int y, int tox, int toy)\n{\n\tint i, t, x1, y1;\n\n\tcell[y][x] |= V;\n\tif (x == tox && y == toy) return 1;\n\n\teach(i, 0, 3) {\n\t\tx1 = x + dirs[i][0], y1 = y + dirs[i][1];\n\t\tif (cell[y1][x1]) continue;\n\n\t\t\n\t\tif (x1 == x) {\n\t\t\tt = (y + y1)\/2;\n\t\t\tif (cell[t][x] || !solve(x1, y1, tox, toy)) continue;\n\n\t\t\tcell[t-1][x] |= S, cell[t][x] |= V|N|S, cell[t+1][x] |= N;\n\t\t} else if (y1 == y) {\n\t\t\tt = (x + x1)\/2;\n\t\t\tif (cell[y][t] || !solve(x1, y1, tox, toy)) continue;\n\n\t\t\tcell[y][t-1] |= E, cell[y][t] |= V|E|W, cell[y][t+1] |= W;\n\t\t}\n\t\treturn 1;\n\t}\n\n\t\n\tcell[y][x] &= ~V;\n\treturn 0;\n}\n\nvoid make_maze()\n{\n\tint i, j;\n\tint h2 = 2 * h + 2, w2 = 2 * w + 2;\n\tbyte **p;\n\n\tp = calloc(sizeof(byte*) * (h2 + 2) + w2 * h2 + 1, 1);\n\n\tp[1] = (byte*)(p + h2 + 2) + 1;\n\teach(i, 2, h2) p[i] = p[i-1] + w2;\n\tp[0] = p[h2];\n\tcell = &p[1];\n\n\teach(i, -1, 2 * h + 1) cell[i][-1] = cell[i][w2 - 1] = V;\n\teach(j, 0, 2 * w) cell[-1][j] = cell[h2 - 1][j] = V;\n\teach(i, 0, h) each(j, 0, 2 * w) cell[2*i][j] |= E|W;\n\teach(i, 0, 2 * h) each(j, 0, w) cell[i][2*j] |= N|S;\n\teach(j, 0, 2 * w) cell[0][j] &= ~N, cell[2*h][j] &= ~S;\n\teach(i, 0, 2 * h) cell[i][0] &= ~W, cell[i][2*w] &= ~E;\n\n\tavail = w * h;\n\twalk(irand(2) * 2 + 1, irand(h) * 2 + 1);\n\n\t\n\teach(i, 0, 2 * h) each(j, 0, 2 * w) cell[i][j] &= ~V;\n\tsolve(1, 1, 2 * w - 1, 2 * h - 1);\n\n\tshow();\n}\n\nint main(int c, char **v)\n{\n\tsetlocale(LC_ALL, \"\");\n\tif (c < 2 || (w = atoi(v[1])) <= 0) w = 16;\n\tif (c < 3 || (h = atoi(v[2])) <= 0) h = 8;\n\n\tmake_maze();\n\n\treturn 0;\n}\n","Rust":"use rand::{thread_rng, Rng, rngs::ThreadRng};\n\nconst WIDTH: usize = 16;\nconst HEIGHT: usize = 16;\n\n#[derive(Clone, Copy)]\nstruct Cell {\n col: usize,\n row: usize,\n}\n\nimpl Cell {\n fn from(col: usize, row: usize) -> Cell {\n Cell {col, row}\n }\n}\n\nstruct Maze {\n cells: [[bool; HEIGHT]; WIDTH], \n walls_h: [[bool; WIDTH]; HEIGHT + 1], \n walls_v: [[bool; WIDTH + 1]; HEIGHT], \n thread_rng: ThreadRng, \n}\n\nimpl Maze {\n\n \n fn new() -> Maze {\n Maze { \n cells: [[true; HEIGHT]; WIDTH], \n walls_h: [[true; WIDTH]; HEIGHT + 1],\n walls_v: [[true; WIDTH + 1]; HEIGHT],\n thread_rng: thread_rng(),\n }\n }\n\n \n fn first(&mut self) -> Cell {\n Cell::from(self.thread_rng.gen_range(0, WIDTH), self.thread_rng.gen_range(0, HEIGHT))\n }\n\n \n fn open_doors(&mut self) {\n let from_top: bool = self.thread_rng.gen();\n let limit = if from_top { WIDTH } else { HEIGHT };\n let door = self.thread_rng.gen_range(0, limit);\n let exit = self.thread_rng.gen_range(0, limit);\n if from_top { \n self.walls_h[0][door] = false;\n self.walls_h[HEIGHT][exit] = false;\n } else {\n self.walls_v[door][0] = false;\n self.walls_v[exit][WIDTH] = false;\n }\n }\n\n \n fn remove_wall(&mut self, cell1: &Cell, cell2: &Cell) {\n if cell1.row == cell2.row {\n self.walls_v[cell1.row][if cell1.col > cell2.col { cell1.col } else { cell2.col }] = false;\n } else { \n self.walls_h[if cell1.row > cell2.row { cell1.row } else { cell2.row }][cell1.col] = false;\n };\n }\n\n \n fn neighbor(&mut self, cell: &Cell) -> Option<Cell> {\n self.cells[cell.col][cell.row] = false;\n let mut neighbors = Vec::new();\n if cell.col > 0 && self.cells[cell.col - 1][cell.row] { neighbors.push(Cell::from(cell.col - 1, cell.row)); }\n if cell.row > 0 && self.cells[cell.col][cell.row - 1] { neighbors.push(Cell::from(cell.col, cell.row - 1)); }\n if cell.col < WIDTH - 1 && self.cells[cell.col + 1][cell.row] { neighbors.push(Cell::from(cell.col + 1, cell.row)); }\n if cell.row < HEIGHT - 1 && self.cells[cell.col][cell.row + 1] { neighbors.push(Cell::from(cell.col, cell.row + 1)); }\n if neighbors.is_empty() {\n None\n } else {\n let next = neighbors.get(self.thread_rng.gen_range(0, neighbors.len())).unwrap();\n self.remove_wall(cell, next);\n Some(*next)\n }\n }\n\n \n fn build(&mut self) {\n let mut cell_stack: Vec<Cell> = Vec::new();\n let mut next = self.first();\n loop {\n while let Some(cell) = self.neighbor(&next) {\n cell_stack.push(cell);\n next = cell;\n }\n match cell_stack.pop() {\n Some(cell) => next = cell,\n None => break,\n }\n }\n }\n\n \n fn paint_wall(h_wall: bool, active: bool) {\n if h_wall {\n print!(\"{}\", if active { \"+---\" } else { \"+ \" });\n } else {\n print!(\"{}\", if active { \"| \" } else { \" \" });\n }\n }\n\n \n fn paint_close_wall(h_wall: bool) {\n if h_wall { println!(\"+\") } else { println!() }\n }\n\n \n fn paint_row(&self, h_walls: bool, index: usize) {\n let iter = if h_walls { self.walls_h[index].iter() } else { self.walls_v[index].iter() };\n for &wall in iter {\n Maze::paint_wall(h_walls, wall);\n }\n Maze::paint_close_wall(h_walls);\n } \n\n \n fn paint(&self) {\n for i in 0 .. HEIGHT {\n self.paint_row(true, i);\n self.paint_row(false, i);\n }\n self.paint_row(true, HEIGHT);\n }\n}\n\nfn main() {\n let mut maze = Maze::new();\n maze.build();\n maze.open_doors();\n maze.paint();\n}\n"} {"name":"Memory allocation","C":"#include <stdlib.h>\n\n\n#define SIZEOF_MEMB (sizeof(int))\n#define NMEMB 100\n\nint main()\n{\n int *ints = malloc(SIZEOF_MEMB*NMEMB);\n \n ints = realloc(ints, sizeof(int)*(NMEMB+1));\n \n int *int2 = calloc(NMEMB, SIZEOF_MEMB);\n \n free(ints); free(int2);\n return 0;\n}\n","Rust":"\n\nunsafe {\n use std::alloc::{Layout, alloc, dealloc};\n \n let int_layout = Layout::new::<i32>();\n\n \n let ptr = alloc(int_layout);\n\n \n *ptr = 123;\n assert_eq!(*ptr, 123);\n\n \n dealloc(ptr, int_layout);\n}\n"} {"name":"Menu","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nconst char *menu_select(const char *const *items, const char *prompt);\n\nint\nmain(void)\n{\n\tconst char *items[] = {\"fee fie\", \"huff and puff\", \"mirror mirror\", \"tick tock\", NULL};\n\tconst char *prompt = \"Which is from the three pigs?\";\n\n\tprintf(\"You chose %s.\\n\", menu_select(items, prompt));\n\n\treturn EXIT_SUCCESS;\n}\n\nconst char *\nmenu_select(const char *const *items, const char *prompt)\n{\n\tchar buf[BUFSIZ];\n\tint i;\n\tint choice;\n\tint choice_max;\n\n\tif (items == NULL)\n\t\treturn NULL;\n\n\tdo {\n\t\tfor (i = 0; items[i] != NULL; i++) {\n\t\t\tprintf(\"%d) %s\\n\", i + 1, items[i]);\n\t\t}\n\t\tchoice_max = i;\n\t\tif (prompt != NULL)\n\t\t\tprintf(\"%s \", prompt);\n\t\telse\n\t\t\tprintf(\"Choice? \");\n\t\tif (fgets(buf, sizeof(buf), stdin) != NULL) {\n\t\t\tchoice = atoi(buf);\n\t\t}\n\t} while (1 > choice || choice > choice_max);\n\n\treturn items[choice - 1];\n}\n","Rust":"fn menu_select<'a>(items: &'a [&'a str]) -> &'a str {\n if items.len() == 0 {\n return \"\";\n }\n\n let stdin = std::io::stdin();\n let mut buffer = String::new();\n\n loop {\n for (i, item) in items.iter().enumerate() {\n println!(\"{}) {}\", i + 1, item);\n }\n print!(\"Pick a number from 1 to {}: \", items.len());\n\n \n stdin.read_line(&mut buffer).unwrap();\n println!();\n\n if let Ok(selected_index) = buffer.trim().parse::<usize>() {\n if 0 < selected_index {\n if let Some(selected_item) = items.get(selected_index - 1) {\n return selected_item;\n }\n }\n }\n\n \n buffer.clear();\n }\n}\n\nfn main() {\n \n let selection = menu_select(&[]);\n println!(\"No choice: {:?}\", selection);\n\n \n let items = [\n \"fee fie\",\n \"huff and puff\",\n \"mirror mirror\",\n \"tick tock\",\n ];\n\n let selection = menu_select(&items);\n println!(\"You chose: {}\", selection);\n}\n"} {"name":"Metered concurrency","C":"#include <semaphore.h>\n#include <pthread.h>\n#include <stdlib.h>\n#include <stdio.h>\n#include <unistd.h>\n\nsem_t sem;\nint count = 3;\n\n\n#define getcount() count\nvoid acquire()\n{\n\tsem_wait(&sem);\n\tcount--;\n}\n\nvoid release()\n{\n\tcount++;\n\tsem_post(&sem);\n}\n\nvoid* work(void * id)\n{\n\tint i = 10;\n\twhile (i--) {\n\t\tacquire();\n\t\tprintf(\"#%d acquired sema at %d\\n\", *(int*)id, getcount());\n\t\tusleep(rand() % 4000000); \n\t\trelease();\n\t\tusleep(0); \n\t}\n\treturn 0;\n}\n\nint main()\n{\n\tpthread_t th[4];\n\tint i, ids[] = {1, 2, 3, 4};\n\n\tsem_init(&sem, 0, count);\n\n\tfor (i = 4; i--;) pthread_create(th + i, 0, work, ids + i);\n\tfor (i = 4; i--;) pthread_join(th[i], 0);\n\tprintf(\"all workers done\\n\");\n\n\treturn sem_destroy(&sem);\n}\n","Rust":"\n\n\nuse std::sync::atomic::AtomicUsize;\nuse std::sync::atomic::Ordering::SeqCst;\nuse std::sync::mpsc::channel;\nuse std::sync::Arc;\nuse std::thread::{self, spawn};\nuse std::time::Duration;\n\npub struct CountingSemaphore {\n \n count: AtomicUsize,\n\n \n backoff: Duration,\n}\n\npub struct CountingSemaphoreGuard<'a> {\n \n sem: &'a CountingSemaphore,\n}\n\nimpl CountingSemaphore {\n \n \n pub fn new(max: usize, backoff: Duration) -> CountingSemaphore {\n CountingSemaphore {\n count: AtomicUsize::new(max),\n backoff,\n }\n }\n\n \n pub fn acquire(&self) -> CountingSemaphoreGuard {\n \n let mut backoff = self.backoff;\n loop {\n \n let count = self.count.load(SeqCst);\n \n \n if count == 0\n || self\n .count\n .compare_exchange(count, count - 1, SeqCst, SeqCst)\n .is_err()\n {\n \n thread::sleep(backoff);\n backoff += self.backoff;\n } else {\n \n break;\n }\n }\n CountingSemaphoreGuard { sem: self }\n }\n\n \n pub fn count(&self) -> usize {\n self.count.load(SeqCst)\n }\n}\n\nimpl<'a> Drop for CountingSemaphoreGuard<'a> {\n \n fn drop(&mut self) {\n self.sem.count.fetch_add(1, SeqCst);\n }\n}\n\nfn metered(duration: Duration) {\n static MAX_COUNT: usize = 4; \n static NUM_WORKERS: u8 = 10; \n let backoff = Duration::from_millis(1); \n \n let sem = Arc::new(CountingSemaphore::new(MAX_COUNT, backoff));\n \n let (tx, rx) = channel();\n for i in 0..NUM_WORKERS {\n let sem = Arc::clone(&sem);\n let tx = tx.clone();\n spawn(move || {\n \n let guard = sem.acquire();\n let count = sem.count();\n \n assert!(count < MAX_COUNT);\n println!(\"Worker {} after acquire: count = {}\", i, count);\n \n thread::sleep(duration);\n \n drop(guard);\n \n let count = sem.count();\n assert!(count <= MAX_COUNT);\n println!(\"Worker {} after release: count = {}\", i, count);\n \n tx.send(()).unwrap();\n });\n }\n drop(tx);\n \n for _ in 0..NUM_WORKERS {\n rx.recv().unwrap();\n }\n}\n\nfn main() {\n \n metered(Duration::from_secs(2));\n}\n"} {"name":"Middle three digits","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n\nchar * mid3(int n)\n{\n\tstatic char buf[32];\n\tint l;\n\tsprintf(buf, \"%d\", n > 0 ? n : -n);\n\tl = strlen(buf);\n\tif (l < 3 || !(l & 1)) return 0;\n\tl = l \/ 2 - 1;\n\tbuf[l + 3] = 0;\n\treturn buf + l;\n}\n\nint main(void)\n{\n\tint x[] = {123, 12345, 1234567, 987654321, 10001, -10001,\n\t\t-123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0,\n\t\t1234567890};\n\n\tint i;\n\tchar *m;\n\tfor (i = 0; i < sizeof(x)\/sizeof(x[0]); i++) {\n\t\tif (!(m = mid3(x[i])))\n\t\t\tm = \"error\";\n\t\tprintf(\"%d: %s\\n\", x[i], m);\n\t}\n\treturn 0;\n}\n","Rust":"fn middle_three_digits(x: i32) -> Result<String, String> {\n let s: String = x.abs().to_string();\n let len = s.len();\n if len < 3 {\n Err(\"Too short\".into())\n } else if len % 2 == 0 {\n Err(\"Even number of digits\".into())\n } else {\n Ok(s[len\/2 - 1 .. len\/2 + 2].to_owned())\n }\n}\n\nfn print_result(x: i32) {\n print!(\"middle_three_digits({}) returned: \", x);\n match middle_three_digits(x) {\n Ok(s) => println!(\"Success, {}\", s),\n Err(s) => println!(\"Failure, {}\", s)\n }\n}\n\nfn main() {\n let passing = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345];\n let failing = [1, 2, -1, -10, 2002, -2002, 0];\n for i in passing.iter() {\n print_result(*i);\n }\n for i in failing.iter() {\n print_result(*i);\n }\n}\n"} {"name":"Miller\u2013Rabin primality test","C":"#ifndef _MILLER_RABIN_H_\n#define _MILLER_RABIN_H\n#include <gmp.h>\nbool miller_rabin_test(mpz_t n, int j);\n#endif\n","Rust":"\n \nuse num::bigint::BigInt;\nuse num::bigint::ToBigInt;\n \n \n\n\nfn modular_exponentiation<T: ToBigInt>(n: &T, e: &T, m: &T) -> BigInt {\n \n let n = n.to_bigint().unwrap();\n let e = e.to_bigint().unwrap();\n let m = m.to_bigint().unwrap();\n \n \n assert!(e >= Zero::zero());\n \n use num::traits::{Zero, One};\n \n \n if e == Zero::zero() {\n return One::one()\n }\n \n \n let mut result: BigInt = One::one();\n let mut base = n % &m;\n let mut exp = e;\n \n loop { \n if &exp % 2 == One::one() {\n result *= &base;\n result %= &m;\n }\n \n if exp == One::one() {\n return result\n }\n \n exp \/= 2;\n base *= base.clone();\n base %= &m;\n }\n}\n \n \n\n\n\nfn is_prime<T: ToBigInt>(n: &T) -> bool {\n let n = n.to_bigint().unwrap();\n if n.clone() < 2.to_bigint().unwrap() {\n return false\n }\n \n let small_primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,\n 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,\n 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,\n 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,\n 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,\n 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,\n 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,\n 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,\n 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,\n 509, 521, 523, 541, 547, 557, 563, 569, 571, 577,\n 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,\n 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,\n 709, 719, 727, 733, 739, 743, 751, 757, 761, 769,\n 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,\n 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,\n 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,\n 991, 997, 1009, 1013];\n \n use num::traits::Zero; \n \n \n \n for sp in small_primes {\n let sp = sp.to_bigint().unwrap();\n \n if n.clone() == sp {\n return true\n } else if n.clone() % sp == Zero::zero() {\n return false\n }\n }\n \n is_rabin_miller_prime(&n, None)\n}\n \n \n\n\n\nfn get_random_bigint(low: &BigInt, high: &BigInt) -> BigInt {\n if low == high { \n return low.clone()\n }\n \n let middle = (low.clone() + high) \/ 2.to_bigint().unwrap();\n \n let go_low: bool = rand::random();\n \n if go_low {\n return get_random_bigint(low, &middle)\n } else {\n return get_random_bigint(&middle, high)\n }\n}\n \n \n\nfn is_rabin_miller_prime<T: ToBigInt>(n: &T, k: Option<usize>) -> bool {\n let n = n.to_bigint().unwrap();\n let k = k.unwrap_or(10); \n \n use num::traits::{Zero, One}; \n let zero: BigInt = Zero::zero();\n let one: BigInt = One::one();\n let two: BigInt = 2.to_bigint().unwrap();\n \n \n \n if n <= one {\n return false\n } else if n == two {\n return true \n } else if n.clone() % &two == Zero::zero() {\n return false \n }\n\n let mut t: BigInt = zero.clone();\n let n_minus_one: BigInt = n.clone() - &one;\n let mut s = n_minus_one.clone();\n while &s % &two == one {\n s \/= &two;\n t += &one;\n }\n \n \n 'outer: for _ in 0..k {\n let a = get_random_bigint(&two, &n_minus_one);\n let mut v = modular_exponentiation(&a, &s, &n);\n if v == one {\n continue 'outer;\n }\n let mut i: BigInt = zero.clone();\n 'inner: while &i < &t {\n v = (v.clone() * &v) % &n;\n if &v == &n_minus_one {\n continue 'outer;\n }\n i += &one;\n }\n return false;\n }\n \n \n true\n}\n"} {"name":"Modular exponentiation","C":"#include <gmp.h>\n\nint main()\n{\n\tmpz_t a, b, m, r;\n\n\tmpz_init_set_str(a,\t\"2988348162058574136915891421498819466320\"\n\t\t\t\t\"163312926952423791023078876139\", 0);\n\tmpz_init_set_str(b,\t\"2351399303373464486466122544523690094744\"\n\t\t\t\t\"975233415544072992656881240319\", 0);\n\tmpz_init(m);\n\tmpz_ui_pow_ui(m, 10, 40);\n\n\tmpz_init(r);\n\tmpz_powm(r, a, b, m);\n\n\tgmp_printf(\"%Zd\\n\", r); \n\n\tmpz_clear(a);\n\tmpz_clear(b);\n\tmpz_clear(m);\n\tmpz_clear(r);\n\n\treturn 0;\n}\n","Rust":"\n\n\nuse num::bigint::BigInt;\nuse num::bigint::ToBigInt;\n\n\n\n\nfn modular_exponentiation<T: ToBigInt>(n: &T, e: &T, m: &T) -> BigInt {\n \n let n = n.to_bigint().unwrap();\n let e = e.to_bigint().unwrap();\n let m = m.to_bigint().unwrap();\n\n \n assert!(e >= Zero::zero());\n\n use num::traits::{Zero, One};\n\n \n if e == Zero::zero() {\n return One::one()\n }\n\n \n let mut result: BigInt = One::one();\n let mut base = n % &m;\n let mut exp = e;\n\n \n loop {\n if &exp % 2 == One::one() {\n result *= &base;\n result %= &m;\n }\n\n if exp == One::one() {\n return result\n }\n\n exp \/= 2;\n base *= base.clone();\n base %= &m;\n }\n}\n"} {"name":"Modular inverse","C":"#include <stdio.h>\n\nint mul_inv(int a, int b)\n{\n\tint b0 = b, t, q;\n\tint x0 = 0, x1 = 1;\n\tif (b == 1) return 1;\n\twhile (a > 1) {\n\t\tq = a \/ b;\n\t\tt = b, b = a % b, a = t;\n\t\tt = x0, x0 = x1 - q * x0, x1 = t;\n\t}\n\tif (x1 < 0) x1 += b0;\n\treturn x1;\n}\n\nint main(void) {\n\tprintf(\"%d\\n\", mul_inv(42, 2017));\n\treturn 0;\n}\n","Rust":"fn mod_inv(a: isize, module: isize) -> isize {\n let mut mn = (module, a);\n let mut xy = (0, 1);\n \n while mn.1 != 0 {\n xy = (xy.1, xy.0 - (mn.0 \/ mn.1) * xy.1);\n mn = (mn.1, mn.0 % mn.1);\n }\n \n while xy.0 < 0 {\n xy.0 += module;\n }\n xy.0\n}\n\nfn main() {\n println!(\"{}\", mod_inv(42, 2017))\n}\n"} {"name":"Monte Carlo methods","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n \ndouble pi(double tolerance)\n{\n\tdouble x, y, val, error;\n\tunsigned long sampled = 0, hit = 0, i;\n\n\tdo {\n\t\t\n\t\tfor (i = 1000000; i; i--, sampled++) {\n\t\t\tx = rand() \/ (RAND_MAX + 1.0);\n\t\t\ty = rand() \/ (RAND_MAX + 1.0);\n\t\t\tif (x * x + y * y < 1) hit ++;\n\t\t}\n\n\t\tval = (double) hit \/ sampled;\n\t\terror = sqrt(val * (1 - val) \/ sampled) * 4;\n\t\tval *= 4;\n\n\t\t\n\t\tfprintf(stderr, \"Pi = %f +\/- %5.3e at %ldM samples.\\r\",\n\t\t\tval, error, sampled\/1000000);\n\t} while (!hit || error > tolerance);\n \n\n\treturn val;\n}\n\nint main()\n{\n\tprintf(\"Pi is %f\\n\", pi(3e-4)); \n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::Rng;\nuse std::f64::consts::PI;\n\n\n\n\nfn is_inside_circle((x, y): (f64, f64)) -> bool {\n x * x + y * y <= 1.0\n}\n\nfn simulate<R: Rng>(rng: &mut R, samples: usize) -> f64 {\n let mut count = 0;\n for _ in 0..samples {\n if is_inside_circle(rng.gen()) {\n count += 1;\n }\n }\n (count as f64) \/ (samples as f64)\n}\n\nfn main() {\n let mut rng = rand::weak_rng();\n\n println!(\"Real pi: {}\", PI);\n\n for samples in (3..9).map(|e| 10_usize.pow(e)) {\n let estimate = 4.0 * simulate(&mut rng, samples);\n let deviation = 100.0 * (1.0 - estimate \/ PI).abs();\n println!(\"{:9}: {:<11} dev: {:.5}%\", samples, estimate, deviation);\n }\n}\n"} {"name":"Monty Hall problem","C":"\n\n#include <stdlib.h>\n#include <stdio.h>\n#include <stdbool.h>\n#include <time.h>\n#include <math.h>\n#define NumSim 1000000000 \n\nvoid main() {\n unsigned long int i,stay=0;\n int ChosenDoor,WinningDoor;\n bool door[3]={0,0,0}; \n \n srand(time(NULL)); \n\t \n\t for(i=0;i<=NumSim;i++){\n\t \n\t WinningDoor=rand() % 3; \n\t \n\t ChosenDoor=rand() % 3; \n\t \n\t if(door[WinningDoor]=true,door[ChosenDoor])stay++;\n\t \n\t door[WinningDoor]=false;\n\t \n } \n\t \n printf(\"\\nAfter %lu games, I won %u by staying. That is %f%%. and I won by switching %lu That is %f%%\",NumSim, stay, (float)stay*100.0\/(float)i,abs(NumSim-stay),100-(float)stay*100.0\/(float)i);\n\t\n }\n","Rust":"extern crate rand;\nuse rand::Rng;\nuse rand::seq::SliceRandom;\n\n#[derive(Clone, Copy, PartialEq)]\nenum Prize {Goat , Car}\n\nconst GAMES: usize = 3_000_000;\nfn main() {\n let mut switch_wins = 0;\n let mut rng = rand::thread_rng();\n \n for _ in 0..GAMES {\n let mut doors = [Prize::Goat; 3];\n *doors.choose_mut(&mut rng).unwrap() = Prize::Car;\n\n \n if doors.choose(&mut rng).unwrap() != &Prize::Car {\n switch_wins += 1;\n }\n }\n println!(\"I played the game {total} times and won {wins} times ({percent}%).\", \n total = GAMES, \n wins = switch_wins, \n percent = switch_wins as f64 \/ GAMES as f64 * 100.0\n );\n}\n"} {"name":"Morse code","C":"\n\n#include <ctype.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#define BIND(A,L,H) ((L)<(A)?(A)<(H)?(A):(H):(L))\n\n\nchar\n \n \n dih[50],dah[50],medium[30],word[30],\n *dd[2] = {dih,dah};\nconst char\n *ascii = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,?'!\/()&:;=+-_\\\"$@\",\n *itu[] = {\n \"13\",\"3111\",\"3131\",\"311\",\"1\",\"1131\",\"331\",\"1111\",\"11\",\"1333\",\"313\",\"1311\",\"33\",\"31\",\"333\",\"1331\",\"3313\",\"131\",\"111\",\"3\",\"113\",\"1113\",\"133\",\"3113\",\"3133\",\"3311\",\"33333\",\"13333\",\"11333\",\"11133\",\"11113\",\"11111\",\"31111\",\"33111\",\"33311\",\"33331\",\"131313\",\"331133\",\"113311\",\"133331\",\"313133\",\"31131\",\"31331\",\"313313\",\"13111\",\"333111\",\"313131\",\"31113\",\"13131\",\"311113\",\"113313\",\"131131\",\"1113113\",\"133131\"\n };\n\nvoid append(char*s,const char*morse) {\n for (; *morse; ++morse)\n strcat(s,dd['3'==*morse]);\n strcat(s,medium);\n}\n\nchar*translate(const char*i,char*o) {\n const char*pc;\n sprintf(o,\"beep\");\n for (; *i; ++i)\n if (NULL == (pc = strchr(ascii,toupper(*i))))\n strcat(o,word);\n else\n append(o,itu[pc-ascii]);\n strcat(o,word);\n return o;\n}\n\nint main(int ac,char*av[]) {\n char\n sin[73],sout[100000];\n int\n dit = 100;\n if (1 < ac) {\n if (strlen(av[1]) != strspn(av[1],\"0123456789\"))\n return 0*fprintf(stderr,\"use: %s [duration] dit in ms, default %d\\n\",*av,dit);\n dit = BIND(atoi(av[1]),1,1000);\n }\n sprintf(dah,\" -n -f 440 -l %d -D %d\",3*dit,dit);\n sprintf(dih,\" -n -f 440 -l %d -D %d\",dit,dit);\n sprintf(medium,\" -n -D %d\",(3-1)*dit);\n sprintf(word,\" -n -D %d\",(7-(3-1)-1)*dit);\n while (NULL != fgets(sin,72,stdin))\n puts(translate(sin,sout));\n return 0;\n}\n","Rust":"\n\n\n\n\n\n\n\n\nuse std::process;\nuse structopt::StructOpt;\nuse morse_code::{Config, Opt, run};\n\n\n\n\n\n\nfn main() {\n let opts = Opt::from_args();\n let mut config = Config::new(opts).unwrap_or_else(|err| {\n eprintln!(\"Problem parsing arguments: {}\", err);\n process::exit(1);\n });\n if let Err(err) = run(&mut config) {\n eprintln!(\"Application error: {}\", err);\n process::exit(2);\n }\n}\n"} {"name":"Mouse position","C":"#include <stdio.h>\n#include <X11\/Xlib.h>\n\nint main()\n{\n Display *d;\n Window inwin; \n Window inchildwin; \n int rootx, rooty; \n int childx, childy; \n Atom atom_type_prop; \n int actual_format; \n unsigned int mask; \n unsigned long n_items, bytes_after_ret;\n Window *props; \n\n \n d = XOpenDisplay(NULL); \n\n \n (void)XGetWindowProperty(d, DefaultRootWindow(d),\n\t\t\t XInternAtom(d, \"_NET_ACTIVE_WINDOW\", True),\n\t\t\t 0, 1, False, AnyPropertyType,\n\t\t\t &atom_type_prop, &actual_format,\n\t\t\t &n_items, &bytes_after_ret, (unsigned char**)&props);\n\t\t\t \n XQueryPointer(d, props[0], &inwin, &inchildwin,\n\t\t&rootx, &rooty, &childx, &childy, &mask);\n printf(\"relative to active window: %d,%d\\n\", childx, childy);\n\n XFree(props); \n (void)XCloseDisplay(d); \n return 0;\n}\n","Rust":"\n\nuse std::libc::{BOOL, HANDLE, LONG};\nuse std::ptr::mut_null;\n\ntype HWND = HANDLE;\n\n#[deriving(Eq)]\nstruct POINT {\n x: LONG,\n y: LONG\n}\n\n#[link_name = \"user32\"]\nextern \"system\" {\n fn GetCursorPos(lpPoint:&mut POINT) -> BOOL;\n fn GetForegroundWindow() -> HWND;\n fn ScreenToClient(hWnd:HWND, lpPoint:&mut POINT);\n}\n\nfn main() {\n let mut pt = POINT{x:0, y:0};\n loop {\n std::io::timer::sleep(100); \n\n let pt_prev = pt;\n unsafe { GetCursorPos(&mut pt) };\n if pt != pt_prev {\n let h = unsafe { GetForegroundWindow() };\n if h == mut_null() { continue }\n\n let mut pt_client = pt;\n unsafe { ScreenToClient(h, &mut pt_client) };\n println!(\"x: {}, y: {}\", pt_client.x, pt_client.y);\n }\n }\n}\n"} {"name":"Move-to-front algorithm","C":"#include<stdio.h>\n#include<stdlib.h>\n#include<string.h>\n\n#define MAX_SIZE 100\n\nint move_to_front(char *str,char c)\n{\n char *q,*p;\n int shift=0;\n p=(char *)malloc(strlen(str)+1);\n strcpy(p,str);\n q=strchr(p,c); \n shift=q-p; \n strncpy(str+1,p,shift);\n str[0]=c;\n free(p);\n \n return shift;\n}\n\nvoid decode(int* pass,int size,char *sym)\n{\n int i,index;\n char c;\n char table[]=\"abcdefghijklmnopqrstuvwxyz\";\n for(i=0;i<size;i++)\n {\n c=table[pass[i]];\n index=move_to_front(table,c);\n if(pass[i]!=index) printf(\"there is an error\");\n sym[i]=c;\n }\n sym[size]='\\0';\n}\n\nvoid encode(char *sym,int size,int *pass)\n{\n int i=0;\n char c;\n char table[]=\"abcdefghijklmnopqrstuvwxyz\";\n for(i=0;i<size;i++)\n {\n c=sym[i];\n pass[i]=move_to_front(table,c);\n }\n}\n\nint check(char *sym,int size,int *pass)\n{\n int *pass2=malloc(sizeof(int)*size);\n char *sym2=malloc(sizeof(char)*size);\n int i,val=1;\n\n encode(sym,size,pass2);\n i=0;\n while(i<size && pass[i]==pass2[i])i++;\n if(i!=size)val=0;\n\n decode(pass,size,sym2);\n if(strcmp(sym,sym2)!=0)val=0;\n\n free(sym2);\n free(pass2);\n\n return val;\n}\n\nint main()\n{\n char sym[3][MAX_SIZE]={\"broood\",\"bananaaa\",\"hiphophiphop\"};\n int pass[MAX_SIZE]={0};\n int i,len,j;\n for(i=0;i<3;i++)\n {\n len=strlen(sym[i]);\n encode(sym[i],len,pass);\n printf(\"%s\u00a0: [\",sym[i]);\n for(j=0;j<len;j++)\n printf(\"%d \",pass[j]);\n printf(\"]\\n\");\n if(check(sym[i],len,pass))\n printf(\"Correct\u00a0:)\\n\");\n else\n printf(\"Incorrect\u00a0:(\\n\");\n }\n return 0;\n}\n","Rust":"fn main() {\n let examples = vec![\"broood\", \"bananaaa\", \"hiphophiphop\"];\n for example in examples {\n let encoded = encode(example);\n let decoded = decode(&encoded);\n println!(\n \"{} encodes to {:?} decodes to {}\",\n example, encoded, decoded\n );\n }\n}\n\nfn get_symbols() -> Vec<u8> {\n (b'a'..b'z').collect()\n}\n\nfn encode(input: &str) -> Vec<usize> {\n input\n .as_bytes()\n .iter()\n .fold((Vec::new(), get_symbols()), |(mut o, mut s), x| {\n let i = s.iter().position(|c| c == x).unwrap();\n let c = s.remove(i);\n s.insert(0, c);\n o.push(i);\n (o, s)\n })\n .0\n}\n\nfn decode(input: &[usize]) -> String {\n input\n .iter()\n .fold((Vec::new(), get_symbols()), |(mut o, mut s), x| {\n o.push(s[*x]);\n let c = s.remove(*x);\n s.insert(0, c);\n (o, s)\n })\n .0\n .into_iter()\n .map(|c| c as char)\n .collect()\n}\n"} {"name":"Multifactorial","C":"\n#include <stdio.h>\n#define HIGHEST_DEGREE 5\n#define LARGEST_NUMBER 10\n\n\nint multifact(int n, int deg){\n return n <= deg ? n : n * multifact(n - deg, deg);\n}\n\n\nint multifact_i(int n, int deg){\n int result = n;\n while (n >= deg + 1){\n result *= (n - deg);\n n -= deg;\n }\n return result;\n}\n\n\nint main(void){\n int i, j;\n for (i = 1; i <= HIGHEST_DEGREE; i++){\n printf(\"\\nDegree %d: \", i);\n for (j = 1; j <= LARGEST_NUMBER; j++){\n printf(\"%d \", multifact(j, i));\n }\n }\n}\n","Rust":"fn multifactorial(n: i32, deg: i32) -> i32 {\n\tif n < 1 {\n\t\t1\n\t} else {\n\t\tn * multifactorial(n - deg, deg)\n\t}\n}\n\nfn main() {\n\tfor i in 1..6 {\n\t\tfor j in 1..11 {\n\t\t\tprint!(\"{} \", multifactorial(j, i));\n\t\t}\n\tprintln!(\"\");\n\t}\n}\n"} {"name":"Multiple distinct objects","C":"foo *foos = malloc(n * sizeof(*foos));\nfor (int i = 0; i < n; i++)\n init_foo(&foos[i]);\n","Rust":"use std::rc::Rc;\nuse std::cell::RefCell;\n\nfn main() {\n let size = 3;\n \n \n let mut v: Vec<String> = vec![String::new(); size];\n v[0].push('a');\n println!(\"{:?}\", v);\n \n \n let mut v: Vec<String> = (0..size).map(|i| i.to_string()).collect();\n v[0].push('a');\n println!(\"{:?}\", v);\n \n \n let v: Vec<Rc<RefCell<String>>> = vec![Rc::new(RefCell::new(String::new())); size];\n v[0].borrow_mut().push('a');\n println!(\"{:?}\", v);\n}\n"} {"name":"Multiplication tables","C":"#include <stdio.h>\n\nint main(void)\n{\n\tint i, j, n = 12;\n \n\tfor (j = 1; j <= n; j++) printf(\"%3d%c\", j, j != n ? ' ' : '\\n');\n\tfor (j = 0; j <= n; j++) printf(j != n ? \"----\" : \"+\\n\");\n\n\tfor (i = 1; i <= n; i++) {\n\t\tfor (j = 1; j <= n; j++)\n\t\t\tprintf(j < i ? \" \" : \"%3d \", i * j);\n printf(\"| %d\\n\", i);\n }\n \n\treturn 0;\n}\n","Rust":"const LIMIT: i32 = 12;\n\nfn main() {\n for i in 1..LIMIT+1 {\n print!(\"{:3}{}\", i, if LIMIT - i == 0 {'\\n'} else {' '})\n }\n for i in 0..LIMIT+1 {\n print!(\"{}\", if LIMIT - i == 0 {\"+\\n\"} else {\"----\"});\n }\n\n for i in 1..LIMIT+1 {\n for j in 1..LIMIT+1 {\n if j < i {\n print!(\" \")\n } else { \n print!(\"{:3} \", j * i)\n }\n }\n println!(\"| {}\", i);\n }\n}\n"} {"name":"Munchausen numbers","C":"#include <stdio.h>\n#include <math.h>\n\nint main() {\n for (int i = 1; i < 5000; i++) {\n \n \n int sum = 0;\n for (int number = i; number > 0; number \/= 10) {\n int digit = number % 10;\n \n \n sum += pow(digit, digit);\n }\n if (sum == i) {\n \n \n \n printf(\"%i\\n\", i);\n } \n }\n return 0;\n}\n","Rust":"fn main() {\n let mut solutions = Vec::new();\n\n for num in 1..5_000 {\n let power_sum = num.to_string()\n .chars()\n .map(|c| {\n let digit = c.to_digit(10).unwrap();\n (digit as f64).powi(digit as i32) as usize\n })\n .sum::<usize>();\n\n if power_sum == num {\n solutions.push(num);\n }\n }\n\n println!(\"Munchausen numbers below 5_000\u00a0: {:?}\", solutions);\n}\n"} {"name":"Munching squares","C":"#include <stdlib.h>\n#include <stdio.h>\n#include <math.h>\n#include <string.h>\n\nvoid hue_to_rgb(double hue, double sat, unsigned char *p)\n{\n\tdouble x;\n\tint c = 255 * sat;\n\thue \/= 60;\n\tx = (1 - fabs(fmod(hue, 2) - 1)) * 255;\n\n\tswitch((int)hue) {\n\tcase 0:\tp[0] = c; p[1] = x; p[2] = 0; return;\n\tcase 1:\tp[0] = x; p[1] = c; p[2] = 0; return;\n\tcase 2:\tp[0] = 0; p[1] = c; p[2] = x; return;\n\tcase 3:\tp[0] = 0; p[1] = x; p[2] = c; return;\n\tcase 4:\tp[0] = x; p[1] = 0; p[2] = c; return;\n\tcase 5:\tp[0] = c; p[1] = 0; p[2] = x; return;\n\t}\n}\n\nint main(void)\n{\n\tconst int size = 512;\n\tint i, j;\n\tunsigned char *colors = malloc(size * 3);\n\tunsigned char *pix = malloc(size * size * 3), *p;\n\tFILE *fp;\n\n\tfor (i = 0; i < size; i++)\n\t\thue_to_rgb(i * 240. \/ size, i * 1. \/ size, colors + 3 * i);\n\n\tfor (i = 0, p = pix; i < size; i++)\n\t\tfor (j = 0; j < size; j++, p += 3)\n\t\t\tmemcpy(p, colors + (i ^ j) * 3, 3);\n\n\tfp = fopen(\"xor.ppm\", \"wb\");\n\tfprintf(fp, \"P6\\n%d %d\\n255\\n\", size, size);\n\tfwrite(pix, size * size * 3, 1, fp);\n\tfclose(fp);\n\n\treturn 0;\n}\n","Rust":"extern crate image;\n\nuse image::{ImageBuffer, Pixel, Rgb};\n\nfn main() {\n let mut img = ImageBuffer::new(256, 256);\n\n for x in 0..256 {\n for y in 0..256 {\n let pixel = Rgb::from_channels(0, x as u8 ^ y as u8, 0, 0);\n img.put_pixel(x, y, pixel);\n }\n }\n\n let _ = img.save(\"output.png\");\n}\n"} {"name":"Mutual recursion","C":"#include <stdio.h>\n#include <stdlib.h>\n\n\nint F(const int n);\nint M(const int n);\n\nint F(const int n)\n{\n return (n == 0) ? 1 : n - M(F(n - 1));\n}\n\nint M(const int n)\n{\n return (n == 0) ? 0 : n - F(M(n - 1));\n}\n\nint main(void)\n{\n int i;\n for (i = 0; i < 20; i++)\n printf(\"%2d \", F(i));\n printf(\"\\n\");\n for (i = 0; i < 20; i++)\n printf(\"%2d \", M(i));\n printf(\"\\n\");\n return EXIT_SUCCESS;\n}\n","Rust":"fn f(n: u32) -> u32 {\n match n {\n 0 => 1,\n _ => n - m(f(n - 1))\n }\n}\n\nfn m(n: u32) -> u32 {\n match n {\n 0 => 0,\n _ => n - f(m(n - 1))\n }\n}\n\nfn main() {\n for i in (0..20).map(f) {\n print!(\"{} \", i);\n }\n println!(\"\");\n\n for i in (0..20).map(m) {\n print!(\"{} \", i);\n }\n println!(\"\")\n}\n"} {"name":"N'th","C":"#include <stdio.h>\n \nchar* addSuffix(int num, char* buf, size_t len)\n{\n char *suffixes[4] = { \"th\", \"st\", \"nd\", \"rd\" };\n int i;\n\n switch (num % 10)\n {\n case 1 : i = (num % 100 == 11) ? 0 : 1;\n\t break;\n case 2 : i = (num % 100 == 12) ? 0 : 2;\n break;\n case 3 : i = (num % 100 == 13) ? 0 : 3;\n break;\n default: i = 0;\n };\n \n snprintf(buf, len, \"%d%s\", num, suffixes[i]);\n return buf;\n}\n\nint main(void)\n{\n int i;\n\n printf(\"Set [0,25]:\\n\");\n for (i = 0; i < 26; i++)\n {\n char s[5];\n printf(\"%s \", addSuffix(i, s, 5));\n }\n putchar('\\n'); \n\n printf(\"Set [250,265]:\\n\");\n for (i = 250; i < 266; i++)\n {\n char s[6];\n printf(\"%s \", addSuffix(i, s, 6));\n }\n putchar('\\n'); \n\n printf(\"Set [1000,1025]:\\n\");\n for (i = 1000; i < 1026; i++)\n {\n char s[7];\n printf(\"%s \", addSuffix(i, s, 7));\n }\n putchar('\\n');\n\n return 0;\n}\n","Rust":"fn nth(num: isize) -> String {\n format!(\"{}{}\", num, match (num % 10, num % 100) {\n (1, 11) | (2, 12) | (3, 13) => \"th\",\n (1, _) => \"st\",\n (2, _) => \"nd\",\n (3, _) => \"rd\",\n _ => \"th\",\n })\n}\n\nfn main() {\n let ranges = [(0, 26), (250, 266), (1000, 1026)];\n for &(s, e) in &ranges {\n println!(\"[{}, {})\u00a0:\", s, e);\n for i in s..e {\n print!(\"{}, \", nth(i));\n }\n println!();\n }\n}\n"} {"name":"N-queens problem","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint count = 0;\nvoid solve(int n, int col, int *hist)\n{\n\tif (col == n) {\n\t\tprintf(\"\\nNo. %d\\n-----\\n\", ++count);\n\t\tfor (int i = 0; i < n; i++, putchar('\\n'))\n\t\t\tfor (int j = 0; j < n; j++)\n\t\t\t\tputchar(j == hist[i] ? 'Q' : ((i + j) & 1) ? ' ' : '.');\n\n\t\treturn;\n\t}\n\n#\tdefine attack(i, j) (hist[j] == i || abs(hist[j] - i) == col - j)\n\tfor (int i = 0, j = 0; i < n; i++) {\n\t\tfor (j = 0; j < col && !attack(i, j); j++);\n\t\tif (j < col) continue;\n\n\t\thist[col] = i;\n\t\tsolve(n, col + 1, hist);\n\t}\n}\n\nint main(int n, char **argv)\n{\n\tif (n <= 1 || (n = atoi(argv[1])) <= 0) n = 8;\n\tint hist[n];\n\tsolve(n, 0, hist);\n}\n","Rust":"const N: usize = 8;\n\nfn try(mut board: &mut [[bool; N]; N], row: usize, mut count: &mut i64) {\n if row == N {\n *count += 1;\n for r in board.iter() {\n println!(\"{}\", r.iter().map(|&x| if x {\"x\"} else {\".\"}.to_string()).collect::<Vec<String>>().join(\" \"))\n }\n println!(\"\");\n return\n }\n for i in 0..N {\n let mut ok: bool = true;\n for j in 0..row {\n if board[j][i]\n || i+j >= row && board[j][i+j-row]\n || i+row < N+j && board[j][i+row-j]\n { ok = false }\n }\n if ok {\n board[row][i] = true;\n try(&mut board, row+1, &mut count);\n board[row][i] = false;\n }\n }\n}\n\nfn main() {\n let mut board: [[bool; N]; N] = [[false; N]; N];\n let mut count: i64 = 0;\n try (&mut board, 0, &mut count);\n println!(\"Found {} solutions\", count)\n}\n"} {"name":"Narcissist","C":"extern void*stdin;main(){ char*p = \"extern void*stdin;main(){ char*p = %c%s%c,a[300],b[300];sprintf(a,p,34,p,34);fgets(b,300,stdin);putchar(48+!strcmp(a,b)); }\",a[300],b[300];sprintf(a,p,34,p,34);fgets(b,300,stdin);putchar(48+!strcmp(a,b)); }\n","Rust":"use std::io::{stdin, prelude::*};\nfn main() {\n let src = include_str!(\"main.rs\");\n let mut input = String::new();\n stdin()\n .lock()\n .read_to_string(&mut input)\n .expect(\"Could not read from STDIN\");\n println!(\"{}\", src == input);\n}\n"} {"name":"Narcissistic decimal number","C":"#include <stdio.h>\n#include <gmp.h>\n\n#define MAX_LEN 81\n\nmpz_t power[10];\nmpz_t dsum[MAX_LEN + 1];\nint cnt[10], len;\n\nvoid check_perm(void)\n{\n\tchar s[MAX_LEN + 1];\n\tint i, c, out[10] = { 0 };\n\n\tmpz_get_str(s, 10, dsum[0]);\n\tfor (i = 0; s[i]; i++) {\n\t\tc = s[i]-'0';\n\t\tif (++out[c] > cnt[c]) return;\n\t}\n\n\tif (i == len)\n\t\tgmp_printf(\" %Zd\", dsum[0]);\n}\n\nvoid narc_(int pos, int d)\n{\n\tif (!pos) {\n\t\tcheck_perm();\n\t\treturn;\n\t}\n\n\tdo {\n\t\tmpz_add(dsum[pos-1], dsum[pos], power[d]);\n\t\t++cnt[d];\n\t\tnarc_(pos - 1, d);\n\t\t--cnt[d];\n\t} while (d--);\n}\n\nvoid narc(int n)\n{\n\tint i;\n\tlen = n;\n\tfor (i = 0; i < 10; i++)\n\t\tmpz_ui_pow_ui(power[i], i, n);\n\n\tmpz_init_set_ui(dsum[n], 0);\n\n\tprintf(\"length %d:\", n);\n\tnarc_(n, 9);\n\tputchar('\\n');\n}\n\nint main(void)\n{\n\tint i;\n\n\tfor (i = 0; i <= 10; i++)\n\t\tmpz_init(power[i]);\n\tfor (i = 1; i <= MAX_LEN; i++) narc(i);\n\n\treturn 0;\n}\n","Rust":"fn is_narcissistic(x: u32) -> bool {\n let digits: Vec<u32> = x\n .to_string()\n .chars()\n .map(|c| c.to_digit(10).unwrap())\n .collect();\n\n digits\n .iter()\n .map(|d| d.pow(digits.len() as u32))\n .sum::<u32>()\n == x\n}\n\nfn main() {\n let mut counter = 0;\n let mut i = 0;\n while counter < 25 {\n if is_narcissistic(i) {\n println!(\"{}\", i);\n counter += 1;\n }\n i += 1;\n }\n}\n"} {"name":"Negative base numbers","C":"#include <stdio.h>\n\nconst char DIGITS[] = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\nconst int DIGITS_LEN = 64;\n\nvoid encodeNegativeBase(long n, long base, char *out) {\n char *ptr = out;\n\n if (base > -1 || base < -62) {\n \n out = \"\";\n return;\n }\n if (n == 0) {\n \n out = \"0\";\n return;\n }\n\n \n while (n != 0) {\n long rem = n % base;\n n = n \/ base;\n if (rem < 0) {\n n++;\n rem = rem - base;\n }\n *ptr = DIGITS[rem];\n ptr++;\n }\n *ptr = 0;\n\n \n ptr--;\n while (out < ptr) {\n char t = *out;\n *out = *ptr;\n *ptr = t;\n out++;\n ptr--;\n }\n return;\n}\n\nlong decodeNegativeBase(const char* ns, long base) {\n long value, bb;\n int i;\n const char *ptr;\n\n if (base < -62 || base > -1) {\n \n return 0;\n }\n if (ns[0] == 0 || (ns[0] == '0' && ns[1] == 0)) {\n \n return 0;\n }\n\n \n ptr = ns;\n while (*ptr != 0) {\n ptr++;\n }\n\n \n value = 0;\n bb = 1;\n ptr--;\n while (ptr >= ns) {\n for (i = 0; i < DIGITS_LEN; i++) {\n if (*ptr == DIGITS[i]) {\n value = value + i * bb;\n bb = bb * base;\n break;\n }\n }\n ptr--;\n }\n\n return value;\n}\n\nvoid driver(long n, long b) {\n char buf[64];\n long value;\n\n encodeNegativeBase(n, b, buf);\n printf(\"%12d encoded in base %3d = %12s\\n\", n, b, buf);\n\n value = decodeNegativeBase(buf, b);\n printf(\"%12s decoded in base %3d = %12d\\n\", buf, b, value);\n\n printf(\"\\n\");\n}\n\nint main() {\n driver(10, -2);\n driver(146, -3);\n driver(15, -10);\n driver(12, -62);\n\n return 0;\n}\n","Rust":"const DIGITS: [char;62] = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];\n \n\nfn main() {\n let nums_and_bases: [(i64,i64);5] = [(10,-2),(146,-3),(15,-10),(-6222885,-62),(1488588316238,-62)];\n\n for (n,b) in nums_and_bases.iter() {\n let ns = encode_neg_base(*n, *b);\n println!(\"{} encoded in base {} = {}\", *n, *b, &ns);\n let nn = decode_neg_base(&ns, *b);\n println!(\"{} decoded in base {} = {}\\n\", &ns, *b, nn);\n }\n}\n\nfn decode_neg_base(ns: &str, b: i64) -> i64 {\n if b < -62 || b > -1 {\n panic!(\"base must be between -62 and -1 inclusive\")\n }\n if ns == \"0\" {\n return 0\n }\n let mut total: i64 = 0;\n let mut bb: i64 = 1;\n for c in ns.chars().rev() {\n total += (DIGITS.iter().position(|&d| d==c).unwrap() as i64) * bb;\n bb *= b;\n }\n return total;\n}\n\nfn encode_neg_base(mut n: i64, b: i64) -> String {\n if b < -62 || b > -1 {\n panic!(\"base must be between -62 and -1 inclusive\");\n }\n if n == 0 {\n return \"0\".to_string();\n }\n let mut out = String::new();\n while n != 0 {\n let mut rem = n % b;\n n \/= b;\n if rem < 0 {\n n+=1;\n rem -= b;\n }\n out.push(DIGITS[rem as usize]);\n }\n return out.chars().rev().collect();\n}\n"} {"name":"Nested function","C":"#include<stdlib.h>\n#include<stdio.h>\n\ntypedef struct{\n\tchar str[30];\n}item;\n\nitem* makeList(char* separator){\n\tint counter = 0,i;\n\titem* list = (item*)malloc(3*sizeof(item));\n\t\n\titem makeItem(){\n\t\titem holder;\n\t\t\n\t\tchar names[5][10] = {\"first\",\"second\",\"third\",\"fourth\",\"fifth\"};\n\t\t\n\t\tsprintf(holder.str,\"%d%s%s\",++counter,separator,names[counter]);\n\t\t\n\t\treturn holder;\n\t}\n\t\n\tfor(i=0;i<3;i++)\n\t\tlist[i] = makeItem();\n\t\n\treturn list;\n}\n\nint main()\n{\n\tint i;\n\titem* list = makeList(\". \");\n\t\n\tfor(i=0;i<3;i++)\n\t\tprintf(\"\\n%s\",list[i].str);\n\t\n\treturn 0;\n}\n","Rust":"fn make_list(sep: &str) -> String {\n let mut counter = 0;\n let mut make_item = |label| {\n counter += 1;\n format!(\"{}{}{}\", counter, sep, label)\n };\n format!(\n \"{}\\n{}\\n{}\",\n make_item(\"First\"),\n make_item(\"Second\"),\n make_item(\"Third\")\n )\n}\n\nfn main() {\n println!(\"{}\", make_list(\". \"))\n}\n"} {"name":"Nim game","C":"#include <stdio.h>\n\nint playerTurn(int numTokens, int take);\nint computerTurn(int numTokens);\n\nint main(void)\n{\n\tprintf(\"Nim Game\\n\\n\");\n\t\n\tint Tokens = 12;\n\t\n\twhile(Tokens > 0)\n\t{\n\t\tprintf(\"How many tokens would you like to take?: \");\n\t\t\n\t\tint uin;\n\t\tscanf(\"%i\", &uin);\n\t\t\n\t\tint nextTokens = playerTurn(Tokens, uin);\n\t\t\n\t\tif (nextTokens == Tokens)\n\t\t{\n\t\t\tcontinue;\n\t\t}\n\t\t\n\t\tTokens = nextTokens;\n\t\t\n\t\tTokens = computerTurn(Tokens);\n\t}\n\tprintf(\"Computer wins.\");\n\t\n\treturn 0;\n}\n\nint playerTurn(int numTokens, int take)\n{\n\tif (take < 1 || take > 3)\n\t{\n\t\tprintf(\"\\nTake must be between 1 and 3.\\n\\n\");\n\t\treturn numTokens;\n\t}\n\tint remainingTokens = numTokens - take;\n\t\n\tprintf(\"\\nPlayer takes %i tokens.\\n\", take);\n\tprintf(\"%i tokens remaining.\\n\\n\", remainingTokens);\n\t\n\treturn remainingTokens;\n}\n\nint computerTurn(int numTokens)\n{\n\tint take = numTokens % 4;\n\tint remainingTokens = numTokens - take;\n\t\n\tprintf(\"Computer takes %u tokens.\\n\", take);\n\tprintf(\"%i tokens remaining.\\n\\n\", remainingTokens);\n\t\n\treturn remainingTokens;\n}\n","Rust":"fn main() {\n let mut tokens = 12;\n println!(\"Nim game\");\n println!(\"Starting with {} tokens.\", tokens);\n println!(\"\");\n \n loop {\n tokens = p_turn(&tokens);\n print_remaining(&tokens);\n tokens = c_turn(&tokens);\n print_remaining(&tokens);\n \n if tokens == 0 {\n println!(\"Computer wins!\");\n break;\n }\n }\n}\n\nfn p_turn(tokens: &i32) -> i32 {\n loop { \n println!(\"How many tokens would you like to take?\");\n \n let mut take = String::new();\n io::stdin().read_line(&mut take)\n .expect(\"Sorry, I didn't understand that.\");\n \n let take: i32 = match take.trim().parse() {\n Ok(num) => num,\n Err(_) => {\n println!(\"Invalid input\");\n println!(\"\");\n continue;\n }\n };\n \n if take > 3 || take < 1 {\n println!(\"Take must be between 1 and 3.\");\n println!(\"\");\n continue;\n }\n \n return tokens - take;\n }\n}\n\nfn c_turn(tokens: &i32) -> i32 {\n let take = tokens % 4;\n \n println!(\"Computer takes {} tokens.\", take);\n \n return tokens - take;\n}\n\nfn print_remaining(tokens: &i32) {\n println!(\"{} tokens remaining.\", tokens);\n println!(\"\");\n}\n"} {"name":"Non-decimal radices_Convert","C":"#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#include <stdint.h>\n\nchar *to_base(int64_t num, int base)\n{\n char *tbl = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n char buf[66] = {'\\0'};\n char *out;\n uint64_t n;\n int i, len = 0, neg = 0;\n if (base > 36) {\n fprintf(stderr, \"base %d too large\\n\", base);\n return 0;\n }\n\n \n n = ((neg = num < 0)) ? (~num) + 1 : num;\n\n do { buf[len++] = tbl[n % base]; } while(n \/= base);\n\n out = malloc(len + neg + 1);\n for (i = neg; len > 0; i++) out[i] = buf[--len];\n if (neg) out[0] = '-';\n\n return out;\n}\n\nlong from_base(const char *num_str, int base)\n{\n char *endptr;\n \n \n int result = strtol(num_str, &endptr, base);\n return result;\n}\n\nint main()\n{\n int64_t x;\n x = ~(1LL << 63) + 1;\n printf(\"%lld in base 2: %s\\n\", x, to_base(x, 2));\n x = 383;\n printf(\"%lld in base 16: %s\\n\", x, to_base(x, 16));\n return 0;\n}\n","Rust":"fn format_with_radix(mut n: u32, radix: u32) -> String {\n assert!(2 <= radix && radix <= 36);\n\n let mut result = String::new();\n\n loop {\n result.push(std::char::from_digit(n % radix, radix).unwrap());\n n \/= radix;\n if n == 0 {\n break;\n }\n }\n\n result.chars().rev().collect()\n}\n\n#[cfg(test)]\n#[test]\nfn test() {\n for value in 0..100u32 {\n for radix in 2..=36 {\n let s = format_with_radix(value, radix);\n let v = u32::from_str_radix(s.as_str(), radix).unwrap();\n assert_eq!(value, v);\n }\n }\n}\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n println!(\"{}\", format_with_radix(0xdeadbeef, 2));\n println!(\"{}\", format_with_radix(0xdeadbeef, 36));\n println!(\"{}\", format_with_radix(0xdeadbeef, 16));\n println!(\"{}\", u32::from_str_radix(\"DeadBeef\", 16)?);\n Ok(())\n}\n"} {"name":"Non-decimal radices_Input","C":"#include <stdio.h>\n\nint main()\n{\n int num;\n\n sscanf(\"0123459\", \"%d\", &num);\n printf(\"%d\\n\", num); \n\n sscanf(\"abcf123\", \"%x\", &num);\n printf(\"%d\\n\", num); \n\n sscanf(\"7651\", \"%o\", &num);\n printf(\"%d\\n\", num); \n\n \n\n return 0;\n}\n","Rust":"fn main() {\n println!(\n \"Parse from plain decimal: {}\",\n \"123\".parse::<u32>().unwrap()\n );\n\n println!(\n \"Parse with a given radix (2-36 supported): {}\",\n u32::from_str_radix(\"deadbeef\", 16).unwrap()\n );\n}\n"} {"name":"Non-decimal radices_Output","C":"#include <stdio.h>\n\nint main()\n{\n int i;\n\n for(i=1; i <= 33; i++)\n printf(\"%6d %6x %6o\\n\", i, i, i);\n\n return 0;\n}\n","Rust":"fn main() {\n \n println!(\"Binary: {:b}\", 0xdeadbeefu32);\n println!(\"Binary with 0b prefix: {:#b}\", 0xdeadbeefu32);\n println!(\"Octal: {:o}\", 0xdeadbeefu32);\n println!(\"Octal with 0o prefix: {:#o}\", 0xdeadbeefu32);\n println!(\"Decimal: {}\", 0xdeadbeefu32);\n println!(\"Lowercase hexadecimal: {:x}\", 0xdeadbeefu32);\n println!(\"Lowercase hexadecimal with 0x prefix: {:#x}\", 0xdeadbeefu32);\n println!(\"Uppercase hexadecimal: {:X}\", 0xdeadbeefu32);\n println!(\"Uppercase hexadecimal with 0x prefix: {:#X}\", 0xdeadbeefu32);\n}\n"} {"name":"Nth root","C":"#include <stdio.h>\n#include <float.h>\n\ndouble pow_ (double x, int e) {\n int i;\n double r = 1;\n for (i = 0; i < e; i++) {\n r *= x;\n }\n return r;\n}\n\ndouble root (int n, double x) {\n double d, r = 1;\n if (!x) {\n return 0;\n }\n if (n < 1 || (x < 0 && !(n&1))) {\n return 0.0 \/ 0.0; \n }\n do {\n d = (x \/ pow_(r, n - 1) - r) \/ n;\n r += d;\n }\n while (d >= DBL_EPSILON * 10 || d <= -DBL_EPSILON * 10);\n return r;\n}\n\nint main () {\n int n = 15;\n double x = pow_(-3.14159, 15);\n printf(\"root(%d, %g) = %g\\n\", n, x, root(n, x));\n return 0;\n}\n","Rust":"\n\nfn nthRoot(n: f64, A: f64) -> f64 {\n\n let p = 1e-9_f64 ;\n let mut x0 = A \/ n ;\n\n loop {\n let mut x1 = ( (n-1.0) * x0 + A \/ f64::powf(x0, n-1.0) ) \/ n;\n if (x1-x0).abs() < (x0*p).abs() { return x1 };\n x0 = x1\n }\n}\n\nfn main() {\n println!(\"{}\", nthRoot(3. , 8. ));\n}\n"} {"name":"Null object","C":"#include <stdio.h>\n\nint main()\n{\n\tchar *object = 0;\n\n\tif (object == NULL) {\n\t\tputs(\"object is null\");\n\t}\n\treturn 0;\n}\n","Rust":"\n\n\n\n\nfn check_number(num: &Option<u8>) {\n if num.is_none() {\n println!(\"Number is: None\");\n } else {\n println!(\"Number is: {}\", num.unwrap());\n }\n}\n\nfn main() {\n let mut possible_number: Option<u8> = None;\n check_number(&possible_number);\n\n possible_number = Some(31);\n check_number(&possible_number);\n}\n"} {"name":"Number names","C":"#include <stdio.h>\n#include <string.h>\n\nconst char *ones[] = { 0, \"one\", \"two\", \"three\", \"four\",\n\t\"five\", \"six\", \"seven\", \"eight\", \"nine\", \n\t\"ten\", \"eleven\", \"twelve\", \"thirteen\", \"fourteen\",\n\t\"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\" };\nconst char *tens[] = { 0, \"ten\", \"twenty\", \"thirty\", \"forty\",\n\t\"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\" };\nconst char *llions[] = { 0, \"thousand\", \"million\", \"billion\", \"trillion\",\n\n\n\t};\nconst int maxillion = sizeof(llions) \/ sizeof(llions[0]) * 3 - 3;\n\nint say_hundred(const char *s, int len, int depth, int has_lead)\n{\n\tint c[3], i;\n\tfor (i = -3; i < 0; i++) {\n\t\tif (len + i >= 0) c[i + 3] = s[len + i] - '0';\n\t\telse c[i + 3] = 0;\n\t}\n\tif (!(c[0] + c[1] + c[2])) return 0;\n\n\tif (c[0]) {\n\t\tprintf(\"%s hundred\", ones[c[0]]);\n\t\thas_lead = 1;\n\t}\n\n\tif (has_lead && (c[1] || c[2]))\n\t\tprintf((!depth || c[0]) && (!c[0] || !c[1]) ? \"and \" :\n\t\t\tc[0] ? \" \" : \"\");\n\n\tif (c[1] < 2) {\n\t\tif (c[1] || c[2]) printf(\"%s\", ones[c[1] * 10 + c[2]]);\n\t} else {\n\t\tif (c[1]) {\n\t\t\tprintf(\"%s\", tens[c[1]]);\n\t\t\tif (c[2]) putchar('-');\n\t\t}\n\t\tif (c[2]) printf(\"%s\", ones[c[2]]);\n\t}\n\n\treturn 1;\n}\n\nint say_maxillion(const char *s, int len, int depth, int has_lead)\n{\n\tint n = len \/ 3, r = len % 3;\n\tif (!r) {\n\t\tn--;\n\t\tr = 3;\n\t}\n\tconst char *e = s + r;\n\tdo {\n\t\tif (say_hundred(s, r, n, has_lead) && n) {\n\t\t\thas_lead = 1;\n\t\t\tprintf(\" %s\", llions[n]);\n\t\t\tif (!depth) printf(\", \");\n\t\t\telse printf(\" \");\n\t\t}\n\t\ts = e; e += 3;\n\t} while (r = 3, n--);\n\n\treturn 1;\n}\n\nvoid say_number(const char *s)\n{\n\tint len, i, got_sign = 0;\n\n\twhile (*s == ' ') s++;\n\tif (*s < '0' || *s > '9') {\n\t\tif (*s == '-') got_sign = -1;\n\t\telse if (*s == '+') got_sign = 1;\n\t\telse goto nan;\n\t\ts++;\n\t} else\n\t\tgot_sign = 1;\n\n\twhile (*s == '0') {\n\t\ts++;\n\t\tif (*s == '\\0') {\n\t\t\tprintf(\"zero\\n\");\n\t\t\treturn;\n\t\t}\n\t}\n\n\tlen = strlen(s);\n\tif (!len) goto nan;\n\n\tfor (i = 0; i < len; i++) {\n\t\tif (s[i] < '0' || s[i] > '9') {\n\t\t\tprintf(\"(not a number)\");\n\t\t\treturn;\n\t\t}\n\t}\n\tif (got_sign == -1) printf(\"minus \");\n\n\tint n = len \/ maxillion;\n\tint r = len % maxillion;\n\tif (!r) {\n\t\tr = maxillion;\n\t\tn--;\n\t}\n\n\tconst char *end = s + len - n * maxillion;\n\tint has_lead = 0;\n\tdo {\n\t\tif ((has_lead = say_maxillion(s, r, n, has_lead))) {\n\t\t\tfor (i = 0; i < n; i++)\n\t\t\t\tprintf(\" %s\", llions[maxillion \/ 3]);\n\t\t\tif (n) printf(\", \");\n\t\t}\n\t\tn--;\n\t\tr = maxillion;\n\t\ts = end;\n\t\tend += r;\n\t} while (n >= 0);\n\n\tprintf(\"\\n\");\n\treturn;\n\nnan:\tprintf(\"not a number\\n\");\n\treturn;\n}\n\nint main()\n{\n\tsay_number(\"-42\");\n\tsay_number(\"1984\");\n\tsay_number(\"10000\");\n\tsay_number(\"1024\");\n\tsay_number(\"1001001001001\");\n\tsay_number(\"123456789012345678901234567890123456789012345678900000001\");\n\treturn 0;\n}\n","Rust":"use std::io::{self, Write, stdout};\n\nconst SMALL: &[&str] = &[\n \"zero\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\", \"ten\",\n \"eleven\", \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\",\n \"nineteen\",\n];\n\nconst TENS: &[&str] = &[\n \"PANIC\", \"PANIC\", \"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\",\n];\n\nconst MAGNITUDE: &[&str] = &[\n \"PANIC\", \"thousand\", \"million\", \"billion\", \"trillion\", \"quadrillion\", \"quintillion\",\n];\n\nfn wordify<W: Write>(w: &mut W, mut number: i64) -> Result<(), io::Error> {\n if number == 0 {\n return write!(w, \"zero\");\n }\n if number < 0 {\n write!(w, \"negative \")?;\n number = -number;\n }\n while number != 0 {\n if number < 20 {\n write!(w, \"{}\", SMALL[number as usize])?;\n break;\n } else if number < 100 {\n write!(w, \"{}\", TENS[number as usize \/ 10])?;\n number %= 10;\n if number != 0 {\n write!(w, \"-\")?;\n }\n } else if number < 1_000 {\n write!(w, \"{} hundred\", SMALL[number as usize \/ 100])?;\n number %= 100;\n if number != 0 {\n write!(w, \" and \")?;\n }\n } else {\n let mut top = number;\n let mut magnitude = 0i64;\n let mut magnitude_pow = 1i64;\n while top >= 1_000 {\n top \/= 1_000;\n magnitude += 1;\n magnitude_pow *= 1_000;\n }\n wordify(w, top)?;\n number %= magnitude_pow;\n if number == 0 {\n write!(w, \" {}\", MAGNITUDE[magnitude as usize])?;\n } else if number > 100 {\n write!(w, \" {}, \", MAGNITUDE[magnitude as usize])?;\n } else {\n write!(w, \" {} and \", MAGNITUDE[magnitude as usize])?;\n }\n }\n }\n Ok(())\n}\n\nfn main() {\n let stdout = stdout();\n let mut stdout = stdout.lock();\n for &n in &[12, 1048576, 9_000_000_000_000_000_000, -2, 0, 5_000_000_000_000_000_001, -555_555_555_555] {\n wordify(&mut stdout, n).unwrap();\n write!(&mut stdout, \"\\n\").unwrap();\n }\n}\n"} {"name":"Number reversal game","C":"void number_reversal_game()\n{\n printf(\"Number Reversal Game. Type a number to flip the first n numbers.\");\n printf(\"Win by sorting the numbers in ascending order.\\n\");\n printf(\"Anything besides numbers are ignored.\\n\");\n printf(\"\\t |1__2__3__4__5__6__7__8__9|\\n\");\n int list[9] = {1,2,3,4,5,6,7,8,9};\n shuffle_list(list,9);\n\n int tries=0;\n unsigned int i;\n int input;\n\n while(!check_array(list, 9))\n {\n ((tries<10) ? printf(\"Round %d\u00a0: \", tries) : printf(\"Round %d\u00a0: \", tries));\n for(i=0;i<9;i++)printf(\"%d \",list[i]);\n printf(\" Gimme that number:\");\n while(1)\n {\n \n scanf(\"%d\", &input);\n if(input>1&&input<10)\n break;\n\n printf(\"\\n%d - Please enter a number between 2 and 9:\", (int)input);\n }\n tries++;\n do_flip(list, 9, input);\n }\n printf(\"Hurray! You solved it in %d moves!\\n\", tries);\n}\n","Rust":"use rand::prelude::*;\nuse std::io::stdin;\n\nfn is_sorted(seq: &[impl PartialOrd]) -> bool {\n if seq.len() < 2 {\n return true;\n }\n \n !seq.iter()\n .zip(seq[1..].iter())\n .any(|(prev, foll)| prev > foll)\n}\n\nfn main() {\n println!(\n \"Number reversal game:\n Given a jumbled list of the numbers 1 to 9, put the numbers in order.\n Each attempt you can reverse up to n digits starting from the left.\n The score is the count of the reversals needed to attain the ascending order.\"\n );\n let mut rng = thread_rng();\n\n let mut sequence: Vec<u8> = (1..10).collect();\n while is_sorted(&sequence) {\n sequence.shuffle(&mut rng);\n }\n\n let mut attempt = 1;\n while !is_sorted(&sequence) {\n println!(\n \"Attempt {}: {:?} - How many numbers do you want to flip?\",\n attempt, sequence\n );\n let flip = {\n let mut input = String::new();\n stdin().read_line(&mut input).unwrap();\n input.trim().parse().unwrap()\n };\n sequence[..flip].reverse();\n attempt += 1;\n }\n println!(\n \"Congrats! It took you {} attempts to sort the sequence.\",\n attempt - 1 \n );\n}\n"} {"name":"Numerical integration","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\ndouble int_leftrect(double from, double to, double n, double (*func)())\n{\n double h = (to-from)\/n;\n double sum = 0.0, x;\n for(x=from; x <= (to-h); x += h)\n sum += func(x);\n return h*sum;\n}\n\ndouble int_rightrect(double from, double to, double n, double (*func)())\n{\n double h = (to-from)\/n;\n double sum = 0.0, x;\n for(x=from; x <= (to-h); x += h)\n sum += func(x+h);\n return h*sum;\n}\n\ndouble int_midrect(double from, double to, double n, double (*func)())\n{\n double h = (to-from)\/n;\n double sum = 0.0, x;\n for(x=from; x <= (to-h); x += h)\n sum += func(x+h\/2.0);\n return h*sum;\n}\n\ndouble int_trapezium(double from, double to, double n, double (*func)())\n{\n double h = (to - from) \/ n;\n double sum = func(from) + func(to);\n int i;\n for(i = 1;i < n;i++)\n sum += 2.0*func(from + i * h);\n return h * sum \/ 2.0;\n}\n\ndouble int_simpson(double from, double to, double n, double (*func)())\n{\n double h = (to - from) \/ n;\n double sum1 = 0.0;\n double sum2 = 0.0;\n int i;\n\n double x;\n \n for(i = 0;i < n;i++)\n sum1 += func(from + h * i + h \/ 2.0);\n\n for(i = 1;i < n;i++)\n sum2 += func(from + h * i);\n\n return h \/ 6.0 * (func(from) + func(to) + 4.0 * sum1 + 2.0 * sum2);\n}\n","Rust":"fn integral<F>(f: F, range: std::ops::Range<f64>, n_steps: u32) -> f64\n where F: Fn(f64) -> f64\n{\n let step_size = (range.end - range.start)\/n_steps as f64;\n\n let mut integral = (f(range.start) + f(range.end))\/2.;\n let mut pos = range.start + step_size;\n while pos < range.end {\n integral += f(pos);\n pos += step_size;\n }\n integral * step_size\n}\n\nfn main() {\n println!(\"{}\", integral(|x| x.powi(3), 0.0..1.0, 100));\n println!(\"{}\", integral(|x| 1.0\/x, 1.0..100.0, 1000));\n println!(\"{}\", integral(|x| x, 0.0..5000.0, 5_000_000));\n println!(\"{}\", integral(|x| x, 0.0..6000.0, 6_000_000));\n}\n"} {"name":"Old lady swallowed a fly","C":"#include <stdio.h>\nstatic char const *animals[] = {\n \"fly\", \n \"spider\", \n \"bird\", \n \"cat\", \n \"dog\", \n \"goat\", \n \"cow\", \n \"horse\"\n};\nstatic char const *verses[] = {\n \"I don't know why she swallowed that fly.\\nPerhaps she'll die\\n\",\n \"That wiggled and jiggled and tickled inside her\",\n \"How absurd, to swallow a bird\",\n \"Imagine that. She swallowed a cat\",\n \"What a hog to swallow a dog\",\n \"She just opened her throat and swallowed that goat\",\n \"I don't know how she swallowed that cow\",\n \"She's dead of course\"\n};\n\n#define LEN(ARR) (sizeof ARR \/ sizeof *ARR)\n\nint main(void)\n{\n for (size_t i = 0; i < LEN(animals); i++) {\n printf(\"There was an old lady who swallowed a %s\\n%s\\n\", animals[i], verses[i]);\n for (size_t j = i; j > 0 && i < LEN(animals) - 1; j--) {\n printf(\"She swallowed the %s to catch the %s\\n\", animals[j], animals[j-1]);\n if (j == 1) {\n printf(\"%s\\n\", verses[0]);\n }\n }\n }\n}\n","Rust":"enum Action {Once, Every, Die}\nuse Action::*;\n\nfn main() {\n let animals = [ (\"horse\" , Die , \"She's dead, of course!\")\n , (\"donkey\", Once , \"It was rather wonky. To swallow a donkey.\")\n , (\"cow\" , Once , \"I don't know how. To swallow a cow.\")\n , (\"goat\" , Once , \"She just opened her throat. To swallow a goat.\")\n , (\"pig\" , Once , \"Her mouth was so big. To swallow a pig.\")\n , (\"dog\" , Once , \"What a hog. To swallow a dog.\")\n , (\"cat\" , Once , \"Fancy that. To swallow a cat.\")\n , (\"bird\" , Once , \"Quite absurd. To swallow a bird.\")\n , (\"spider\", Once , \"That wriggled and jiggled and tickled inside her.\")\n , (\"fly\" , Every, \"I don't know why she swallowed the fly.\")\n ];\n\n for (i, a) in animals.iter().enumerate().rev() {\n println!(\"There was an old lady who swallowed a {}\\n{}\", a.0, a.2);\n\n if let Die = a.1 {break}\n\n for (swallowed, to_catch) in animals[i..].iter().zip(&animals[i+1..]) {\n println!(\"She swallowed the {} to catch the {}.\", swallowed.0, to_catch.0);\n\n if let Every = to_catch.1 {\n println!(\"{}\", to_catch.2);\n }\n }\n\n println!(\"Perhaps she'll die.\\n\");\n }\n}\n"} {"name":"One of n lines in a file","C":"#include <stdio.h>\n#include <stdlib.h>\n\ninline int irand(int n)\n{\n\tint r, randmax = RAND_MAX\/n * n;\n\twhile ((r = rand()) >= randmax);\n\treturn r \/ (randmax \/ n);\n}\n\ninline int one_of_n(int n)\n{\n\tint i, r = 0;\n\tfor (i = 1; i < n; i++) if (!irand(i + 1)) r = i;\n\treturn r;\n}\n\nint main(void)\n{\n\tint i, r[10] = {0};\n\n\tfor (i = 0; i < 1000000; i++, r[one_of_n(10)]++);\n\tfor (i = 0; i < 10; i++)\n\t\tprintf(\"%d%c\", r[i], i == 9 ? '\\n':' ');\n\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::{Rng, thread_rng};\n\nfn one_of_n<R: Rng>(rng: &mut R, n: usize) -> usize {\n (1..n).fold(0, |keep, cand| {\n \n if rng.gen_weighted_bool(cand as u32 + 1) {\n cand\n } else {\n keep\n }\n })\n}\n\nfn main() {\n const LINES: usize = 10;\n\n let mut dist = [0; LINES];\n let mut rng = thread_rng();\n\n for _ in 0..1_000_000 {\n let num = one_of_n(&mut rng, LINES);\n dist[num] += 1;\n }\n\n println!(\"{:?}\", dist);\n}\n"} {"name":"One-dimensional cellular automata","C":"#include <stdio.h>\n#include <string.h>\n\nchar trans[] = \"___#_##_\";\n\n#define v(i) (cell[i]\u00a0!= '_')\nint evolve(char cell[], char backup[], int len)\n{\n\tint i, diff = 0;\n\n\tfor (i = 0; i < len; i++) {\n\t\t\n\t\tbackup[i] = trans[ v(i-1) * 4 + v(i) * 2 + v(i + 1) ];\n\t\tdiff += (backup[i] != cell[i]);\n\t}\n\n\tstrcpy(cell, backup);\n\treturn diff;\n}\n\nint main()\n{\n\tchar\tc[] = \"_###_##_#_#_#_#__#__\\n\",\n\t\tb[] = \"____________________\\n\";\n\n\tdo { printf(c + 1); } while (evolve(c + 1, b + 1, sizeof(c) - 3));\n\treturn 0;\n}\n","Rust":"fn get_new_state(windowed: &[bool]) -> bool {\n match windowed {\n [false, true, true] | [true, true, false] => true,\n _ => false\n }\n}\n\nfn next_gen(cell: &mut [bool]) {\n let mut v = Vec::with_capacity(cell.len());\n v.push(cell[0]);\n for i in cell.windows(3) {\n v.push(get_new_state(i));\n }\n v.push(cell[cell.len() - 1]);\n cell.copy_from_slice(&v);\n}\n\nfn print_cell(cell: &[bool]) {\n for v in cell {\n print!(\"{} \", if *v {'#'} else {' '});\n }\n println!();\n}\n\nfn main() {\n\n const MAX_GENERATION: usize = 10;\n const CELLS_LENGTH: usize = 30;\n\n let mut cell: [bool; CELLS_LENGTH] = rand::random();\n\n for i in 1..=MAX_GENERATION {\n print!(\"Gen {:2}: \", i);\n print_cell(&cell);\n next_gen(&mut cell);\n }\n}\n"} {"name":"OpenGL","C":"#include <stdlib.h>\n#include <GL\/gl.h>\n#include <GL\/glut.h>\n\nvoid paint(void)\n{\n glClearColor(0.3,0.3,0.3,0.0);\n glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);\n\n glShadeModel(GL_SMOOTH);\n\n glLoadIdentity();\n glTranslatef(-15.0, -15.0, 0.0);\n\n glBegin(GL_TRIANGLES);\n glColor3f(1.0, 0.0, 0.0);\n glVertex2f(0.0, 0.0);\n glColor3f(0.0, 1.0, 0.0);\n glVertex2f(30.0, 0.0);\n glColor3f(0.0, 0.0, 1.0);\n glVertex2f(0.0, 30.0);\n glEnd();\n\n glFlush();\n}\n\nvoid reshape(int width, int height)\n{\n glViewport(0, 0, width, height);\n glMatrixMode(GL_PROJECTION);\n glLoadIdentity();\n glOrtho(-30.0, 30.0, -30.0, 30.0, -30.0, 30.0);\n glMatrixMode(GL_MODELVIEW);\n}\n\nint main(int argc, char *argv[])\n{\n glutInit(&argc, argv);\n glutInitWindowSize(640, 480);\n glutCreateWindow(\"Triangle\");\n\n glutDisplayFunc(paint);\n glutReshapeFunc(reshape);\n\n glutMainLoop();\n\n return EXIT_SUCCESS;\n}\n","Rust":"use glow::*;\nuse glutin::event::*;\nuse glutin::event_loop::{ControlFlow, EventLoop};\nuse std::os::raw::c_uint;\n\nconst VERTEX: &str = \"#version 410\nconst vec2 verts[3] = vec2[3](\n vec2(0.5f, 1.0f),\n vec2(0.0f, 0.0f),\n vec2(1.0f, 0.0f)\n);\nout vec2 vert;\nvoid main() {\n vert = verts[gl_VertexID];\n gl_Position = vec4(vert - 0.5, 0.0, 1.0);\n}\";\n\nconst FRAGMENT: &str = \"#version 410\nprecision mediump float;\nin vec2 vert;\nout vec4 color;\nvoid main() {\n color = vec4(vert, 0.5, 1.0);\n}\";\n\nunsafe fn create_program(gl: &Context, vert: &str, frag: &str) -> c_uint {\n let program = gl.create_program().expect(\"Cannot create program\");\n let shader_sources = [(glow::VERTEX_SHADER, vert), (glow::FRAGMENT_SHADER, frag)];\n\n let mut shaders = Vec::new();\n for (shader_type, shader_source) in shader_sources.iter() {\n let shader = gl\n .create_shader(*shader_type)\n .expect(\"Cannot create shader\");\n gl.shader_source(shader, shader_source);\n gl.compile_shader(shader);\n if !gl.get_shader_compile_status(shader) {\n panic!(gl.get_shader_info_log(shader));\n }\n gl.attach_shader(program, shader);\n shaders.push(shader);\n }\n\n gl.link_program(program);\n if !gl.get_program_link_status(program) {\n panic!(gl.get_program_info_log(program));\n }\n\n for shader in shaders {\n gl.detach_shader(program, shader);\n gl.delete_shader(shader);\n }\n program\n}\n\nfn main() {\n let (gl, event_loop, window) = unsafe {\n let el = EventLoop::new();\n let wb = glutin::window::WindowBuilder::new()\n .with_title(\"Hello triangle!\")\n .with_inner_size(glutin::dpi::LogicalSize::new(1024.0, 768.0));\n let windowed_context = glutin::ContextBuilder::new()\n .with_vsync(true)\n .build_windowed(wb, &el)\n .unwrap();\n let windowed_context = windowed_context.make_current().unwrap();\n let context = glow::Context::from_loader_function(|s| {\n windowed_context.get_proc_address(s) as *const _\n });\n (context, el, windowed_context)\n };\n\n let (program, vab) = unsafe {\n let vertex_array = gl\n .create_vertex_array()\n .expect(\"Cannot create vertex array\");\n gl.bind_vertex_array(Some(vertex_array));\n\n let program = create_program(&gl, VERTEX, FRAGMENT);\n gl.use_program(Some(program));\n\n (program, vertex_array)\n };\n\n event_loop.run(move |ev, _, flow| match ev {\n Event::WindowEvent {\n event: WindowEvent::CloseRequested, ..\n } => {\n unsafe {\n gl.delete_program(program);\n gl.delete_vertex_array(vab);\n }\n *flow = ControlFlow::Exit;\n }\n Event::WindowEvent {\n event: WindowEvent::Resized(size), ..\n } => {\n unsafe {\n gl.viewport(0, 0, size.width as i32, size.height as i32);\n }\n window.resize(size);\n }\n Event::RedrawRequested(_) => unsafe {\n gl.clear_color(0.1, 0.2, 0.3, 1.0);\n gl.clear(glow::COLOR_BUFFER_BIT);\n gl.draw_arrays(glow::TRIANGLES, 0, 3);\n window.swap_buffers().unwrap();\n },\n _ => {}\n });\n}\n"} {"name":"Order two numerical lists","C":"int list_cmp(int *a, int la, int *b, int lb)\n{\n\tint i, l = la;\n\tif (l > lb) l = lb;\n\tfor (i = 0; i < l; i++) {\n\t\tif (a[i] == b[i]) continue;\n\t\treturn (a[i] > b[i]) ? 1 : -1;\n\t}\n\tif (la == lb) return 0;\n\treturn la > lb ? 1 : -1;\n}\n","Rust":"vec![1, 2, 1, 3, 2] < vec![1, 2, 0, 4, 4, 0, 0, 0]\n"} {"name":"Ordered partitions","C":"#include <stdio.h>\n\nint next_perm(int size, int * nums)\n{\n int *l, *k, tmp;\n\n for (k = nums + size - 2; k >= nums && k[0] >= k[1]; k--) {};\n if (k < nums) return 0;\n\n for (l = nums + size - 1; *l <= *k; l--) {};\n tmp = *k; *k = *l; *l = tmp;\n\n for (l = nums + size - 1, k++; k < l; k++, l--) {\n tmp = *k; *k = *l; *l = tmp;\n }\n\n return 1;\n}\n\nvoid make_part(int n, int * sizes)\n{\n int x[1024], i, j, *ptr, len = 0;\n\n for (ptr = x, i = 0; i < n; i++)\n for (j = 0, len += sizes[i]; j < sizes[i]; j++, *(ptr++) = i);\n\n do {\n for (i = 0; i < n; i++) {\n printf(\" { \");\n for (j = 0; j < len; j++)\n if (x[j] == i) printf(\"%d \", j);\n\n printf(\"}\");\n }\n printf(\"\\n\");\n } while (next_perm(len, x));\n}\n\nint main()\n{\n int s1[] = {2, 0, 2};\n int s2[] = {1, 2, 3, 4};\n\n printf(\"Part 2 0 2:\\n\");\n make_part(3, s1);\n\n printf(\"\\nPart 1 2 3 4:\\n\");\n make_part(4, s2);\n\n return 1;\n}\n","Rust":"use itertools::Itertools;\n\ntype NArray = Vec<Vec<Vec<usize>>>;\n\nfn generate_partitions(args: &[usize]) -> NArray {\n \n let max = args.iter().sum();\n\n \n \n let c = args.iter().fold(vec![], |mut acc, arg| {\n acc.push((1..=max).combinations(*arg).collect::<Vec<_>>());\n acc\n });\n\n \n \n c.iter()\n .map(|i| i.iter().cloned())\n .multi_cartesian_product()\n .unique()\n .filter(|x| x.iter().cloned().flatten().unique().count() == max)\n .collect::<Vec<_>>()\n}\n\n#[allow(clippy::clippy::ptr_arg)]\nfn print_partitions(result: &NArray) {\n println!(\"Partitions:\");\n for partition in result {\n println!(\"{:?}\", partition);\n }\n}\nfn main() {\n print_partitions(generate_partitions(&[2, 0, 2]).as_ref());\n print_partitions(generate_partitions(&[1, 1, 1]).as_ref());\n print_partitions(generate_partitions(&[2, 3]).as_ref());\n print_partitions(generate_partitions(&[0]).as_ref());\n}\n"} {"name":"Ordered words","C":"#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#include <assert.h>\n\n\n#define MAXLEN 100\ntypedef char TWord[MAXLEN];\n\n\ntypedef struct Node {\n TWord word;\n struct Node *next;\n} Node;\n\n\nint is_ordered_word(const TWord word) {\n assert(word != NULL);\n int i;\n\n for (i = 0; word[i] != '\\0'; i++)\n if (word[i] > word[i + 1] && word[i + 1] != '\\0')\n return 0;\n\n return 1;\n}\n\n\nNode* list_prepend(Node* words_list, const TWord new_word) {\n assert(new_word != NULL);\n Node *new_node = malloc(sizeof(Node));\n if (new_node == NULL)\n exit(EXIT_FAILURE);\n\n strcpy(new_node->word, new_word);\n new_node->next = words_list;\n return new_node;\n}\n\n\nNode* list_destroy(Node *words_list) {\n while (words_list != NULL) {\n Node *temp = words_list;\n words_list = words_list->next;\n free(temp);\n }\n\n return words_list;\n}\n\n\nvoid list_print(Node *words_list) {\n while (words_list != NULL) {\n printf(\"\\n%s\", words_list->word);\n words_list = words_list->next;\n }\n}\n\n\nint main() {\n FILE *fp = fopen(\"unixdict.txt\", \"r\");\n if (fp == NULL)\n return EXIT_FAILURE;\n\n Node *words = NULL;\n TWord line;\n unsigned int max_len = 0;\n\n while (fscanf(fp, \"%99s\\n\", line) != EOF) {\n if (strlen(line) > max_len && is_ordered_word(line)) {\n max_len = strlen(line);\n words = list_destroy(words);\n words = list_prepend(words, line);\n } else if (strlen(line) == max_len && is_ordered_word(line)) {\n words = list_prepend(words, line);\n }\n }\n\n fclose(fp);\n list_print(words);\n\n return EXIT_SUCCESS;\n}\n","Rust":"const FILE: &'static str = include_str!(\".\/unixdict.txt\");\n\nfn is_ordered(s: &str) -> bool {\n let mut prev = '\\x00';\n for c in s.to_lowercase().chars() {\n if c < prev {\n return false;\n }\n prev = c;\n }\n\n return true;\n}\n\nfn find_longest_ordered_words(dict: Vec<&str>) -> Vec<&str> {\n let mut result = Vec::new();\n let mut longest_length = 0;\n\n for s in dict.into_iter() {\n if is_ordered(&s) {\n let n = s.len();\n if n > longest_length {\n longest_length = n;\n result.truncate(0);\n }\n if n == longest_length {\n result.push(s);\n }\n }\n }\n\n return result;\n}\n\nfn main() {\n let lines = FILE.lines().collect();\n\n let longest_ordered = find_longest_ordered_words(lines);\n\n for s in longest_ordered.iter() {\n println!(\"{}\", s.to_string());\n }\n}\n"} {"name":"Palindrome dates","C":"#include <stdbool.h>\n#include <stdio.h>\n#include <string.h>\n#include <time.h>\n\nbool is_palindrome(const char* str) {\n size_t n = strlen(str);\n for (size_t i = 0; i + 1 < n; ++i, --n) {\n if (str[i] != str[n - 1])\n return false;\n }\n return true;\n}\n\nint main() {\n time_t timestamp = time(0);\n const int seconds_per_day = 24*60*60;\n int count = 15;\n char str[32];\n printf(\"Next %d palindrome dates:\\n\", count);\n for (; count > 0; timestamp += seconds_per_day) {\n struct tm* ptr = gmtime(×tamp);\n strftime(str, sizeof(str), \"%Y%m%d\", ptr);\n if (is_palindrome(str)) {\n strftime(str, sizeof(str), \"%F\", ptr);\n printf(\"%s\\n\", str);\n --count;\n }\n }\n return 0;\n}\n","Rust":"\n\n\nfn is_palindrome(s: &str) -> bool {\n s.chars().rev().eq(s.chars())\n}\n\nfn main() {\n let mut date = chrono::Utc::today();\n let mut count = 0;\n while count < 15 {\n if is_palindrome(&date.format(\"%Y%m%d\").to_string()) {\n println!(\"{}\", date.format(\"%F\"));\n count += 1;\n }\n date = date.succ();\n }\n}\n"} {"name":"Palindrome detection","C":"#include <string.h>\n\nint palindrome(const char *s)\n{\n int i,l;\n l = strlen(s);\n for(i=0; i<l\/2; i++)\n {\n if ( s[i] != s[l-i-1] ) return 0; \n }\n return 1;\n}\n","Rust":"fn is_palindrome(string: &str) -> bool {\n let half_len = string.len() \/ 2;\n string\n .chars()\n .take(half_len)\n .eq(string.chars().rev().take(half_len))\n}\n\nmacro_rules! test {\n ( $( $x:tt ),* ) => { $( println!(\"'{}': {}\", $x, is_palindrome($x)); )* };\n}\n\nfn main() {\n test!(\n \"\",\n \"a\",\n \"ada\",\n \"adad\",\n \"ingirumimusnocteetconsumimurigni\",\n \"\u4eba\u4eba\u70ba\u6211,\u6211\u70ba\u4eba\u4eba\",\n \"\u042f \u0438\u0434\u0443 \u0441 \u043c\u0435\u0447\u0435\u043c, \u0441\u0443\u0434\u0438\u044f\",\n \"\uc544\ub4e4\ub538\ub4e4\uc544\",\n \"The quick brown fox\"\n );\n}\n"} {"name":"Pangram checker","C":"#include <stdio.h>\n\nint is_pangram(const char *s)\n{\n\tconst char *alpha = \"\"\n\t\t\"abcdefghjiklmnopqrstuvwxyz\"\n\t\t\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n\tchar ch, wasused[26] = {0};\n\tint total = 0;\n\n\twhile ((ch = *s++) != '\\0') {\n\t\tconst char *p;\n\t\tint idx;\n\n\t\tif ((p = strchr(alpha, ch)) == NULL)\n\t\t\tcontinue;\n\n\t\tidx = (p - alpha) % 26;\n\n\t\ttotal += !wasused[idx];\n\t\twasused[idx] = 1;\n\t\tif (total == 26)\n\t\t\treturn 1;\n\t}\n\treturn 0;\n}\n\nint main(void)\n{\n\tint i;\n\tconst char *tests[] = {\n\t\t\"The quick brown fox jumps over the lazy dog.\",\n\t\t\"The qu1ck brown fox jumps over the lazy d0g.\"\n\t};\n\n\tfor (i = 0; i < 2; i++)\n\t\tprintf(\"\\\"%s\\\" is %sa pangram\\n\",\n\t\t\ttests[i], is_pangram(tests[i])?\"\":\"not \");\n\treturn 0;\n}\n","Rust":"#![feature(test)]\n\nextern crate test;\n\nuse std::collections::HashSet;\n\npub fn is_pangram_via_bitmask(s: &str) -> bool {\n\n \n let mut mask = (1 << 26) - 1;\n\n for chr in s.chars() {\n let val = chr as u32 & !0x20; \n if val <= 'Z' as u32 && val >= 'A' as u32 {\n mask = mask & !(1 << (val - 'A' as u32));\n }\n }\n\n mask == 0\n}\n\npub fn is_pangram_via_hashset(s: &str) -> bool {\n\n \n let letters = s.chars()\n .flat_map(|chr| chr.to_lowercase())\n .filter(|&chr| chr >= 'a' && chr <= 'z')\n .fold(HashSet::new(), |mut letters, chr| {\n letters.insert(chr);\n letters\n });\n\n letters.len() == 26\n}\n\npub fn is_pangram_via_sort(s: &str) -> bool {\n\n \n let mut chars: Vec<char> = s.chars()\n .flat_map(|chr| chr.to_lowercase())\n .filter(|&chr| chr >= 'a' && chr <= 'z')\n .collect();\n\n chars.sort();\n chars.dedup();\n\n chars.len() == 26\n}\n\nfn main() {\n\n let examples = [\"The quick brown fox jumps over the lazy dog\",\n \"The quick white cat jumps over the lazy dog\"];\n\n for &text in examples.iter() {\n let is_pangram_sort = is_pangram_via_sort(text);\n println!(\"Is \\\"{}\\\" a pangram via sort? - {}\", text, is_pangram_sort);\n\n let is_pangram_bitmask = is_pangram_via_bitmask(text);\n println!(\"Is \\\"{}\\\" a pangram via bitmask? - {}\",\n text,\n is_pangram_bitmask);\n\n let is_pangram_hashset = is_pangram_via_hashset(text);\n println!(\"Is \\\"{}\\\" a pangram via bitmask? - {}\",\n text,\n is_pangram_hashset);\n }\n}\n"} {"name":"Parallel calculations","C":"#include <stdio.h>\n#include <omp.h>\n\nint main()\n{\n int data[] = {12757923, 12878611, 12878893, 12757923, 15808973, 15780709, 197622519};\n int largest, largest_factor = 0;\n\n omp_set_num_threads(4);\n \n #pragma omp parallel for shared(largest_factor, largest)\n for (int i = 0; i < 7; i++) {\n int p, n = data[i];\n\n for (p = 3; p * p <= n && n % p; p += 2);\n if (p * p > n) p = n;\n if (p > largest_factor) {\n largest_factor = p;\n largest = n;\n printf(\"thread %d: found larger: %d of %d\\n\",\n omp_get_thread_num(), p, n);\n } else {\n printf(\"thread %d: not larger: %d of %d\\n\",\n omp_get_thread_num(), p, n);\n }\n }\n\n printf(\"Largest factor: %d of %d\\n\", largest_factor, largest);\n return 0;\n}\n","Rust":"\n\n\n\nextern crate rayon;\n\nextern crate prime_decomposition;\n\nuse rayon::prelude::*;\n\n\npub fn largest_min_factor(numbers: &[usize]) -> usize {\n numbers\n .par_iter()\n .map(|n| {\n \n prime_decomposition::factor(*n)[0]\n })\n .max()\n .unwrap()\n}\n\nfn main() {\n let numbers = &[\n 1_122_725, 1_125_827, 1_122_725, 1_152_800, 1_157_978, 1_099_726,\n ];\n let max = largest_min_factor(numbers);\n println!(\"The largest minimal factor is {}\", max);\n}\n"} {"name":"Parametric polymorphism","C":"#include <stdio.h>\n#include <stdlib.h>\n\n#define decl_tree_type(T) \\\n typedef struct node_##T##_t node_##T##_t, *node_##T; \\\n struct node_##T##_t { node_##T left, right; T value; }; \\\n \\\n node_##T node_##T##_new(T v) { \\\n node_##T node = malloc(sizeof(node_##T##_t)); \\\n node->value = v; \\\n node->left = node->right = 0; \\\n return node; \\\n } \\\n node_##T node_##T##_insert(node_##T root, T v) { \\\n node_##T n = node_##T##_new(v); \\\n while (root) { \\\n if (root->value < n->value) \\\n if (!root->left) return root->left = n; \\\n else root = root->left; \\\n else \\\n if (!root->right) return root->right = n; \\\n else root = root->right; \\\n } \\\n return 0; \\\n }\n\n#define tree_node(T) node_##T\n#define node_insert(T, r, x) node_##T##_insert(r, x)\n#define node_new(T, x) node_##T##_new(x)\n\ndecl_tree_type(double);\ndecl_tree_type(int);\n\nint main()\n{\n int i;\n tree_node(double) root_d = node_new(double, (double)rand() \/ RAND_MAX);\n\n for (i = 0; i < 10000; i++)\n node_insert(double, root_d, (double)rand() \/ RAND_MAX);\n\n tree_node(int) root_i = node_new(int, rand());\n for (i = 0; i < 10000; i++)\n node_insert(int, root_i, rand());\n\n return 0;\n}\n","Rust":"struct TreeNode<T> {\n value: T,\n left: Option<Box<TreeNode<T>>>,\n right: Option<Box<TreeNode<T>>>,\n}\n\nimpl <T> TreeNode<T> {\n fn my_map<U,F>(&self, f: &F) -> TreeNode<U> where\n F: Fn(&T) -> U {\n TreeNode {\n value: f(&self.value),\n left: match self.left {\n None => None,\n Some(ref n) => Some(Box::new(n.my_map(f))),\n },\n right: match self.right {\n None => None,\n Some(ref n) => Some(Box::new(n.my_map(f))),\n },\n }\n }\n}\n\nfn main() {\n let root = TreeNode {\n value: 3,\n left: Some(Box::new(TreeNode {\n value: 55,\n left: None,\n right: None,\n })),\n right: Some(Box::new(TreeNode {\n value: 234,\n left: Some(Box::new(TreeNode {\n value: 0,\n left: None,\n right: None,\n })),\n right: None,\n })),\n };\n root.my_map(&|x| { println!(\"{}\" , x)});\n println!(\"---------------\");\n let new_root = root.my_map(&|x| *x as f64 * 333.333f64);\n new_root.my_map(&|x| { println!(\"{}\" , x) });\n}\n"} {"name":"Parsing_RPN calculator algorithm","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <math.h>\n\nvoid die(const char *msg)\n{\n\tfprintf(stderr, \"%s\", msg);\n\tabort();\n}\n\n#define MAX_D 256\ndouble stack[MAX_D];\nint depth;\n\nvoid push(double v)\n{\n\tif (depth >= MAX_D) die(\"stack overflow\\n\");\n\tstack[depth++] = v;\n}\n\ndouble pop()\n{\n\tif (!depth) die(\"stack underflow\\n\");\n\treturn stack[--depth];\n}\n\ndouble rpn(char *s)\n{\n\tdouble a, b;\n\tint i;\n\tchar *e, *w = \" \\t\\n\\r\\f\";\n\n\tfor (s = strtok(s, w); s; s = strtok(0, w)) {\n\t\ta = strtod(s, &e);\n\t\tif (e > s)\t\tprintf(\"\u00a0:\"), push(a);\n#define binop(x) printf(\"%c:\", *s), b = pop(), a = pop(), push(x)\n\t\telse if (*s == '+')\tbinop(a + b);\n\t\telse if (*s == '-')\tbinop(a - b);\n\t\telse if (*s == '*')\tbinop(a * b);\n\t\telse if (*s == '\/')\tbinop(a \/ b);\n\t\telse if (*s == '^')\tbinop(pow(a, b));\n#undef binop\n\t\telse {\n\t\t\tfprintf(stderr, \"'%c': \", *s);\n\t\t\tdie(\"unknown oeprator\\n\");\n\t\t}\n\t\tfor (i = depth; i-- || 0 * putchar('\\n'); )\n\t\t\tprintf(\" %g\", stack[i]);\n\t}\n\n\tif (depth != 1) die(\"stack leftover\\n\");\n\n\treturn pop();\n}\n\nint main(void)\n{\n\tchar s[] = \" 3 4 2 * 1 5 - 2 3 ^ ^ \/ + \";\n\tprintf(\"%g\\n\", rpn(s));\n\treturn 0;\n}\n","Rust":"fn rpn(text: &str) -> f64 {\n let tokens = text.split_whitespace();\n let mut stack: Vec<f64> = vec![];\n println!(\"input operation stack\");\n\n for token in tokens {\n print!(\"{:^5} \", token);\n match token.parse() {\n Ok(num) => {\n stack.push(num);\n println!(\"push {:?}\", stack);\n }\n Err(_) => {\n match token {\n \"+\" => {\n let b = stack.pop().expect(\"missing first operand\");\n let a = stack.pop().expect(\"missing second operand\");\n stack.push(a + b);\n }\n \"-\" => {\n let b = stack.pop().expect(\"missing first operand\");\n let a = stack.pop().expect(\"missing second operand\");\n stack.push(a - b);\n }\n \"*\" => {\n let b = stack.pop().expect(\"missing first operand\");\n let a = stack.pop().expect(\"missing second operand\");\n stack.push(a * b);\n }\n \"\/\" => {\n let b = stack.pop().expect(\"missing first operand\");\n let a = stack.pop().expect(\"missing second operand\");\n stack.push(a \/ b);\n }\n \"^\" => {\n let b = stack.pop().expect(\"missing first operand\");\n let a = stack.pop().expect(\"missing second operand\");\n stack.push(a.powf(b));\n }\n _ => panic!(\"unknown operator {}\", token),\n }\n println!(\"calculate {:?}\", stack);\n }\n }\n }\n\n stack.pop().unwrap_or(0.0)\n}\n\nfn main() {\n let text = \"3 4 2 * 1 5 - 2 3 ^ ^ \/ +\";\n\n println!(\"\\nresult: {}\", rpn(text));\n}\n"} {"name":"Pascal's triangle","C":"#include <stdio.h>\n\nvoid pascaltriangle(unsigned int n)\n{\n unsigned int c, i, j, k;\n\n for(i=0; i < n; i++) {\n c = 1;\n for(j=1; j <= 2*(n-1-i); j++) printf(\" \");\n for(k=0; k <= i; k++) {\n printf(\"%3d \", c);\n c = c * (i-k)\/(k+1);\n }\n printf(\"\\n\");\n }\n}\n\nint main()\n{\n pascaltriangle(8);\n return 0;\n}\n","Rust":"fn pascal_triangle(n: u64)\n{\n\n for i in 0..n {\n let mut c = 1;\n for _j in 1..2*(n-1-i)+1 {\n print!(\" \");\n }\n for k in 0..i+1 {\n print!(\"{:2} \", c);\n c = c * (i-k)\/(k+1);\n }\n println!();\n }\n}\n"} {"name":"Password generator","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <time.h>\n\n#define DEFAULT_LENGTH 4\n#define DEFAULT_COUNT 1\n\nchar* symbols[] = {\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\", \"abcdefghijklmnopqrstuvwxyz\", \"0123456789\", \"!\\\"#$%&'()*+,-.\/:;<=>?@[]^_{|}~\"};\nint length = DEFAULT_LENGTH;\nint count = DEFAULT_COUNT;\nunsigned seed;\nchar exSymbols = 0;\n\nvoid GetPassword () {\n \n int lengths[4] = {1, 1, 1, 1};\n int count = 4;\n while (count < length) {\n lengths[rand()%4]++;\n count++;\n } \n\n \n char password[length + 1];\n for (int i = 0; i < length; ) { \n \n int str = rand()%4;\n if (!lengths[str])continue; \n\n char c;\n switch (str) {\n case 2:\n c = symbols[str][rand()%10];\n while (exSymbols && (c == 'I' || c == 'l' || c == '1' || c == 'O' || c == '0' || c == '5' || c == 'S' || c == '2' || c == 'Z'))\n c = symbols[str][rand()%10];\n password[i] = c;\n break;\n\n case 3:\n c = symbols[str][rand()%30];\n while (exSymbols && (c == 'I' || c == 'l' || c == '1' || c == 'O' || c == '0' || c == '5' || c == 'S' || c == '2' || c == 'Z'))\n c = symbols[str][rand()%30];\n password[i] = c;\n break;\n\n default:\n c = symbols[str][rand()%26];\n while (exSymbols && (c == 'I' || c == 'l' || c == '1' || c == 'O' || c == '0' || c == '5' || c == 'S' || c == '2' || c == 'Z')) \n c = symbols[str][rand()%26];\n password[i] = c;\n break;\n }\n\n i++;\n lengths[str]--;\n }\n\n password [length] = '\\0';\n printf (\"%s\\n\", password);\n}\n\nint main (int argc, char* argv[]) {\n seed = (unsigned)time(NULL);\n\n \n for (int i = 1; i < argc; i++) {\n switch (argv[i][1]) {\n case 'l':\n if (sscanf (argv[i+1], \"%d\", &length) != 1) {\n puts (\"Unrecognized input. Syntax: -l [integer]\");\n return -1;\n }\n \n if (length < 4) {\n puts (\"Password length must be at least 4 characters.\");\n return -1;\n }\n i++; \n break;\n\n case 'c':\n if (sscanf (argv[i+1], \"%d\", &count) != 1) {\n puts (\"Unrecognized input. Syntax: -c [integer]\");\n return -1;\n }\n\n if (count <= 0) {\n puts (\"Count must be at least 1.\");\n return -1;\n }\n i++;\n break;\n\n case 's':\n if (sscanf (argv[i+1], \"%d\", &seed) != 1) {\n puts (\"Unrecognized input. Syntax: -s [integer]\");\n return -1;\n }\n i++;\n break;\n\n case 'e':\n exSymbols = 1;\n break;\n\n default:\n help:\n printf (\"Help:\\nThis program generates a random password.\\n\"\n \"Commands:\"\n \"Set password length: -l [integer]\\n\"\n \"Set password count: -c [integer]\\n\"\n \"Set seed: -s [integer]\\n\"\n \"Exclude similiar characters: -e\\n\"\n \"Display help: -h\");\n return 0;\n break;\n } \n }\n\n srand (seed);\n\n for (int i = 0; i < count; i++)\n GetPassword();\n \n return 0;\n}\n","Rust":"use rand::distributions::Alphanumeric;\nuse rand::prelude::IteratorRandom;\nuse rand::{thread_rng, Rng};\nuse std::iter;\nuse std::process;\nuse structopt::StructOpt;\nconst OTHER_VALUES: &str = \"!\\\"#$%&'()*+,-.\/:;<=>?@[]^_{|}~\";\n\n\nfn generate_password(length: u8) -> String {\n \n let mut rng = thread_rng();\n \n \n \n let mut base_password: Vec<char> = iter::repeat(())\n .map(|()| rng.sample(Alphanumeric))\n .take(length as usize)\n .collect();\n let mut end_range = 10;\n \n \n if length < end_range {\n end_range = length;\n }\n \n let mut to_add = rng.gen_range(1, end_range as usize);\n loop {\n \n let special = OTHER_VALUES.chars().choose(&mut rng).unwrap();\n to_add -= 1;\n base_password[to_add] = special;\n if to_add == 0 {\n break;\n }\n }\n base_password.iter().collect()\n}\n\n#[derive(StructOpt, Debug)]\n#[structopt(name = \"password-generator\", about = \"A simple password generator.\")]\nstruct Opt {\n \n \n \n #[structopt(default_value = \"160\")]\n length: u8,\n \n #[structopt(default_value = \"1\")]\n count: u8,\n}\n\nfn main() {\n \n \n let opt = Opt::from_args();\n const MINIMUM_LENGTH: u8 = 30;\n if opt.length < MINIMUM_LENGTH {\n eprintln!(\n \"Please provide a password length greater than or equal to {}\",\n MINIMUM_LENGTH\n );\n process::exit(1);\n }\n for index in 0..opt.count {\n let password = generate_password(opt.length);\n \n match index + 1 == opt.count {\n true => print!(\"{}\", password),\n _ => println!(\"{}\", password),\n };\n }\n}\n"} {"name":"Pell's equation","C":"#include <math.h>\n#include <stdbool.h>\n#include <stdint.h>\n#include <stdio.h>\n\nstruct Pair {\n uint64_t v1, v2;\n};\n\nstruct Pair makePair(uint64_t a, uint64_t b) {\n struct Pair r;\n r.v1 = a;\n r.v2 = b;\n return r;\n}\n\nstruct Pair solvePell(int n) {\n int x = (int) sqrt(n);\n\n if (x * x == n) {\n \n return makePair(1, 0);\n } else {\n \n int y = x;\n int z = 1;\n int r = 2 * x;\n struct Pair e = makePair(1, 0);\n struct Pair f = makePair(0, 1);\n uint64_t a = 0;\n uint64_t b = 0;\n\n while (true) {\n y = r * z - y;\n z = (n - y * y) \/ z;\n r = (x + y) \/ z;\n e = makePair(e.v2, r * e.v2 + e.v1);\n f = makePair(f.v2, r * f.v2 + f.v1);\n a = e.v2 + x * f.v2;\n b = f.v2;\n if (a * a - n * b * b == 1) {\n break;\n }\n }\n\n return makePair(a, b);\n }\n}\n\nvoid test(int n) {\n struct Pair r = solvePell(n);\n printf(\"x^2 - %3d * y^2 = 1 for x = %21llu and y = %21llu\\n\", n, r.v1, r.v2);\n}\n\nint main() {\n test(61);\n test(109);\n test(181);\n test(277);\n\n return 0;\n}\n","Rust":"use num_bigint::{ToBigInt, BigInt};\nuse num_traits::{Zero, One};\n\n\nfn main() {\n test(61u64);\n test(109u64);\n test(181u64);\n test(277u64);\n}\n\nstruct Pair {\n v1: BigInt,\n v2: BigInt,\n}\n\nimpl Pair {\n pub fn make_pair(a: &BigInt, b: &BigInt) -> Pair {\n Pair {\n v1: a.clone(),\n v2: b.clone(),\n }\n }\n\n}\n\nfn solve_pell(n: u64) -> Pair{\n let x: BigInt = ((n as f64).sqrt()).to_bigint().unwrap();\n if x.clone() * x.clone() == n.to_bigint().unwrap() {\n Pair::make_pair(&One::one(), &Zero::zero())\n } else {\n let mut y: BigInt = x.clone();\n let mut z: BigInt = One::one();\n let mut r: BigInt = ( &z + &z) * x.clone();\n let mut e: Pair = Pair::make_pair(&One::one(), &Zero::zero());\n let mut f: Pair = Pair::make_pair(&Zero::zero() ,&One::one());\n let mut a: BigInt = Zero::zero();\n let mut b: BigInt = Zero::zero();\n while &a * &a - n * &b * &b != One::one() {\n \n y = &r * &z - &y;\n z = (n - &y * &y) \/ &z;\n r = (&x + &y) \/ &z;\n\n e = Pair::make_pair(&e.v2, &(&r * &e.v2 + &e.v1));\n f = Pair::make_pair(&f.v2, &(&r * &f.v2 + &f.v1));\n a = &e.v2 + &x * &f.v2;\n b = f.v2.clone();\n }\n let pa = &a;\n let pb = &b;\n Pair::make_pair(&pa.clone(), &pb.clone())\n }\n}\n\nfn test(n: u64) {\n let r: Pair = solve_pell(n);\n println!(\"x^2 - {} * y^2 = 1 for x = {} and y = {}\", n, r.v1, r.v2);\n}\n"} {"name":"Percentage difference between images","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\n\n#define RED_C 0\n#define GREEN_C 1\n#define BLUE_C 2\n#define GET_PIXEL(IMG, X, Y) ((IMG)->buf[ (Y) * (IMG)->width + (X) ])\n\nint main(int argc, char **argv)\n{\n image im1, im2;\n double totalDiff = 0.0;\n unsigned int x, y;\n \n if ( argc < 3 )\n {\n fprintf(stderr, \"usage:\\n%s FILE1 FILE2\\n\", argv[0]);\n exit(1);\n }\n im1 = read_image(argv[1]);\n if ( im1 == NULL ) exit(1);\n im2 = read_image(argv[2]);\n if ( im2 == NULL ) { free_img(im1); exit(1); }\n if ( (im1->width != im2->width) || (im1->height != im2->height) )\n {\n fprintf(stderr, \"width\/height of the images must match!\\n\");\n } else {\n \n for(x=0; x < im1->width; x++)\n {\n for(y=0; y < im1->width; y++)\n {\n totalDiff += fabs( GET_PIXEL(im1, x, y)[RED_C] - GET_PIXEL(im2, x, y)[RED_C] ) \/ 255.0;\n totalDiff += fabs( GET_PIXEL(im1, x, y)[GREEN_C] - GET_PIXEL(im2, x, y)[GREEN_C] ) \/ 255.0;\n totalDiff += fabs( GET_PIXEL(im1, x, y)[BLUE_C] - GET_PIXEL(im2, x, y)[BLUE_C] ) \/ 255.0;\n }\n }\n printf(\"%lf\\n\", 100.0 * totalDiff \/ (double)(im1->width * im1->height * 3) );\n \n }\n free_img(im1);\n free_img(im2);\n}\n","Rust":"extern crate image;\n\nuse image::{GenericImageView, Rgba};\n\nfn diff_rgba3(rgba1 : Rgba<u8>, rgba2 : Rgba<u8>) -> i32 {\n (rgba1[0] as i32 - rgba2[0] as i32).abs()\n + (rgba1[1] as i32 - rgba2[1] as i32).abs()\n + (rgba1[2] as i32 - rgba2[2] as i32).abs()\n}\n\nfn main() {\n let img1 = image::open(\"Lenna100.jpg\").unwrap();\n let img2 = image::open(\"Lenna50.jpg\").unwrap();\n let mut accum = 0;\n let zipper = img1.pixels().zip(img2.pixels());\n for (pixel1, pixel2) in zipper {\n accum += diff_rgba3(pixel1.2, pixel2.2);\n }\n println!(\"Percent difference {}\", accum as f64 * 100.0\/ (255.0 * 3.0 * (img1.width() * img1.height()) as f64));\n}\n"} {"name":"Perfect numbers","C":"#include \"stdio.h\"\n#include \"math.h\"\n\nint perfect(int n) {\n int max = (int)sqrt((double)n) + 1;\n int tot = 1;\n int i;\n\n for (i = 2; i < max; i++)\n if ( (n % i) == 0 ) {\n tot += i;\n int q = n \/ i;\n if (q > i)\n tot += q;\n }\n\n return tot == n;\n}\n\nint main() {\n int n;\n for (n = 2; n < 33550337; n++)\n if (perfect(n))\n printf(\"%d\\n\", n);\n\n return 0;\n}\n","Rust":"fn main ( ) {\n\tfn factor_sum(n: i32) -> i32 {\n\t let mut v = Vec::new(); \n\t for x in 1..n-1 { \n\t \tif n%x == 0 { \n\t \t\tv.push(x); \n\t \t}\n\t }\n let mut sum = v.iter().sum(); \n return sum;\n }\n \n fn perfect_nums(n: i32) {\n \tfor x in 2..n { \n \t\tif factor_sum(x) == x {\n \t\t\tprintln!(\"{} is a perfect number.\", x); \n \t\t}\n \t}\n }\n perfect_nums(10000);\n}\n"} {"name":"Perfect shuffle","C":"\n#include <stdlib.h>\n#include <stdio.h>\n#include <string.h>\n\n\n#define N_DECKS 7\nconst int kDecks[N_DECKS] = { 8, 24, 52, 100, 1020, 1024, 10000 };\n\n\nint CreateDeck( int **deck, int nCards );\nvoid InitDeck( int *deck, int nCards );\nint DuplicateDeck( int **dest, const int *orig, int nCards );\nint InitedDeck( int *deck, int nCards );\nint ShuffleDeck( int *deck, int nCards );\nvoid FreeDeck( int **deck );\n\n\n\nint main() {\n int i, nCards, nShuffles;\n int *deck = NULL;\n\n for( i=0; i<N_DECKS; ++i ) {\n nCards = kDecks[i];\n\n if( !CreateDeck(&deck,nCards) ) {\n fprintf( stderr, \"Error: malloc() failed!\\n\" );\n return 1;\n }\n\n InitDeck( deck, nCards );\n nShuffles = 0;\n\n do {\n ShuffleDeck( deck, nCards );\n ++nShuffles;\n } while( !InitedDeck(deck,nCards) );\n\n printf( \"Cards count: %d, shuffles required: %d.\\n\", nCards, nShuffles );\n\n FreeDeck( &deck );\n }\n\n return 0;\n}\n\nint CreateDeck( int **deck, int nCards ) {\n int *tmp = NULL;\n\n if( deck != NULL )\n tmp = malloc( nCards*sizeof(*tmp) );\n\n return tmp!=NULL ? (*deck=tmp)!=NULL : 0; \n}\n\nvoid InitDeck( int *deck, int nCards ) {\n if( deck != NULL ) {\n int i;\n\n for( i=0; i<nCards; ++i )\n deck[i] = i;\n }\n}\n\nint DuplicateDeck( int **dest, const int *orig, int nCards ) {\n if( orig != NULL && CreateDeck(dest,nCards) ) {\n memcpy( *dest, orig, nCards*sizeof(*orig) );\n return 1; \n }\n else {\n return 0; \n }\n}\n\nint InitedDeck( int *deck, int nCards ) {\n int i;\n\n for( i=0; i<nCards; ++i )\n if( deck[i] != i )\n return 0; \n\n return 1; \n}\n\nint ShuffleDeck( int *deck, int nCards ) {\n int *copy = NULL;\n\n if( DuplicateDeck(©,deck,nCards) ) {\n int i, j;\n\n for( i=j=0; i<nCards\/2; ++i, j+=2 ) {\n deck[j] = copy[i];\n deck[j+1] = copy[i+nCards\/2];\n }\n\n FreeDeck( © );\n return 1; \n }\n else {\n return 0; \n }\n}\n\nvoid FreeDeck( int **deck ) {\n if( *deck != NULL ) {\n free( *deck );\n *deck = NULL;\n }\n}\n","Rust":"extern crate itertools;\n\nfn shuffle<T>(mut deck: Vec<T>) -> Vec<T> {\n let index = deck.len() \/ 2;\n let right_half = deck.split_off(index);\n itertools::interleave(deck, right_half).collect()\n}\n\nfn main() {\n for &size in &[8, 24, 52, 100, 1020, 1024, 10_000] {\n let original_deck: Vec<_> = (0..size).collect();\n let mut deck = original_deck.clone();\n let mut iterations = 0;\n loop {\n deck = shuffle(deck);\n iterations += 1;\n if deck == original_deck {\n break;\n }\n }\n println!(\"{: >5}: {: >4}\", size, iterations);\n }\n}\n"} {"name":"Permutations","C":"#include <stdio.h>\nint main (int argc, char *argv[]) {\n\n\tif (argc < 2) {\n printf(\"Enter an argument. Example 1234 or dcba:\\n\");\n return 0;\n\t}\n\n int x;\n for (x = 0; argv[1][x] != '\\0'; x++);\n\n\tint f, v, m;\n\t for(f=0; f < x; f++) {\n \t for(v = x-1; v > f; v-- ) {\n \t if (argv[1][v-1] > argv[1][v]) {\n\tm=argv[1][v-1];\n\targv[1][v-1]=argv[1][v];\n\targv[1][v]=m;\n }\n }\n}\n\n\n char a[x];\n\tint k=0;\n\tint fact=k+1;\n while (k!=x) {\n a[k]=argv[1][k];\n \t k++;\n\t\t fact = k*fact;\n }\n a[k]='\\0';\n\n int i, j;\n int y=0;\n char c;\n while (y != fact) {\n printf(\"%s\\n\", a);\n i=x-2;\n while(a[i] > a[i+1] ) i--;\n j=x-1;\n while(a[j] < a[i] ) j--;\n c=a[j];\n a[j]=a[i];\n a[i]=c;\ni++;\nfor (j = x-1; j > i; i++, j--) {\n c = a[i];\n a[i] = a[j];\n a[j] = c;\n }\ny++;\n }\n}\n","Rust":"pub fn permutations(size: usize) -> Permutations {\n Permutations { idxs: (0..size).collect(), swaps: vec![0; size], i: 0 }\n}\n\npub struct Permutations {\n idxs: Vec<usize>,\n swaps: Vec<usize>,\n i: usize,\n}\n\nimpl Iterator for Permutations {\n type Item = Vec<usize>;\n\n fn next(&mut self) -> Option<Self::Item> {\n if self.i > 0 {\n loop {\n if self.i >= self.swaps.len() { return None; }\n if self.swaps[self.i] < self.i { break; }\n self.swaps[self.i] = 0;\n self.i += 1;\n }\n self.idxs.swap(self.i, (self.i & 1) * self.swaps[self.i]);\n self.swaps[self.i] += 1;\n }\n self.i = 1;\n Some(self.idxs.clone())\n }\n}\n\nfn main() {\n let perms = permutations(3).collect::<Vec<_>>();\n assert_eq!(perms, vec![\n vec![0, 1, 2],\n vec![1, 0, 2],\n vec![2, 0, 1],\n vec![0, 2, 1],\n vec![1, 2, 0],\n vec![2, 1, 0],\n ]);\n}\n"} {"name":"Pernicious numbers","C":"#include <stdio.h>\n \ntypedef unsigned uint;\nuint is_pern(uint n)\n{\n uint c = 2693408940u; \n while (n) c >>= 1, n &= (n - 1); \n return c & 1;\n}\n \nint main(void)\n{\n uint i, c;\n for (i = c = 0; c < 25; i++)\n if (is_pern(i))\n printf(\"%u \", i), ++c;\n putchar('\\n');\n \n for (i = 888888877u; i <= 888888888u; i++)\n if (is_pern(i))\n printf(\"%u \", i);\n putchar('\\n');\n \n return 0;\n}\n","Rust":"extern crate aks_test_for_primes;\n\nuse std::iter::Filter;\nuse std::ops::RangeFrom;\n\nuse aks_test_for_primes::is_prime;\n\nfn main() {\n for i in pernicious().take(25) {\n print!(\"{} \", i);\n }\n println!();\n for i in (888_888_877u64..888_888_888).filter(is_pernicious) {\n print!(\"{} \", i);\n }\n}\n\nfn pernicious() -> Filter<RangeFrom<u64>, fn(&u64) -> bool> {\n (0u64..).filter(is_pernicious as fn(&u64) -> bool)\n}\n\nfn is_pernicious(n: &u64) -> bool {\n is_prime(n.count_ones())\n}\n"} {"name":"Phrase reversals","C":"#include <stdio.h>\n#include <string.h>\n\n\n\nchar* reverse_section(char *s, size_t length)\n{\n if (length == 0) return s;\n\n size_t i; char temp;\n for (i = 0; i < length \/ 2 + 1; ++i)\n temp = s[i], s[i] = s[length - i], s[length - i] = temp;\n return s;\n}\n\nchar* reverse_words_in_order(char *s, char delim)\n{\n if (!strlen(s)) return s;\n\n size_t i, j;\n for (i = 0; i < strlen(s) - 1; ++i) {\n for (j = 0; s[i + j] != 0 && s[i + j] != delim; ++j)\n ;\n reverse_section(s + i, j - 1);\n s += j;\n }\n return s;\n}\n\nchar* reverse_string(char *s)\n{\n return strlen(s) ? reverse_section(s, strlen(s) - 1) : s;\n}\n\nchar* reverse_order_of_words(char *s, char delim)\n{\n reverse_string(s);\n reverse_words_in_order(s, delim);\n return s;\n}\n\nint main(void)\n{\n char str[] = \"rosetta code phrase reversal\";\n size_t lenstr = sizeof(str) \/ sizeof(str[0]);\n char scopy[lenstr];\n char delim = ' ';\n\n \n printf(\"Original: \\\"%s\\\"\\n\", str);\n\n \n strncpy(scopy, str, lenstr);\n reverse_string(scopy);\n printf(\"Reversed: \\\"%s\\\"\\n\", scopy);\n\n \n strncpy(scopy, str, lenstr);\n reverse_words_in_order(scopy, delim);\n printf(\"Reversed words: \\\"%s\\\"\\n\", scopy);\n\n \n strncpy(scopy, str, lenstr);\n reverse_order_of_words(scopy, delim);\n printf(\"Reversed order: \\\"%s\\\"\\n\", scopy);\n\n return 0;\n}\n","Rust":"fn reverse_string(string: &str) -> String {\n string.chars().rev().collect::<String>()\n}\n\nfn reverse_words(string: &str) -> String {\n string\n .split_whitespace()\n .map(|x| x.chars().rev().collect::<String>())\n .collect::<Vec<String>>()\n .join(\" \")\n}\n\nfn reverse_word_order(string: &str) -> String {\n string\n .split_whitespace()\n .rev()\n .collect::<Vec<&str>>()\n .join(\" \")\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_reverse_string() {\n let string = \"rosetta code phrase reversal\";\n assert_eq!(\n reverse_string(string.clone()),\n \"lasrever esarhp edoc attesor\"\n );\n }\n\n #[test]\n fn test_reverse_words() {\n let string = \"rosetta code phrase reversal\";\n assert_eq!(\n reverse_words(string.clone()),\n \"attesor edoc esarhp lasrever\"\n );\n }\n\n #[test]\n fn test_reverse_word_order() {\n let string = \"rosetta code phrase reversal\";\n assert_eq!(\n reverse_word_order(string.clone()),\n \"reversal phrase code rosetta\"\n );\n }\n}\n"} {"name":"Pi","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <gmp.h>\n\nmpz_t tmp1, tmp2, t5, t239, pows;\nvoid actan(mpz_t res, unsigned long base, mpz_t pows)\n{\n\tint i, neg = 1;\n\tmpz_tdiv_q_ui(res, pows, base);\n\tmpz_set(tmp1, res);\n\tfor (i = 3; ; i += 2) {\n\t\tmpz_tdiv_q_ui(tmp1, tmp1, base * base);\n\t\tmpz_tdiv_q_ui(tmp2, tmp1, i);\n\t\tif (mpz_cmp_ui(tmp2, 0) == 0) break;\n\t\tif (neg) mpz_sub(res, res, tmp2);\n\t\telse\t mpz_add(res, res, tmp2);\n\t\tneg = !neg;\n\t}\n}\n\nchar * get_digits(int n, size_t* len)\n{\n\tmpz_ui_pow_ui(pows, 10, n + 20);\n\n\tactan(t5, 5, pows);\n\tmpz_mul_ui(t5, t5, 16);\n\n\tactan(t239, 239, pows);\n\tmpz_mul_ui(t239, t239, 4);\n\n\tmpz_sub(t5, t5, t239);\n\tmpz_ui_pow_ui(pows, 10, 20);\n\tmpz_tdiv_q(t5, t5, pows);\n\n\t*len = mpz_sizeinbase(t5, 10);\n\treturn mpz_get_str(0, 0, t5);\n}\n\nint main(int c, char **v)\n{\n\tunsigned long accu = 16384, done = 0;\n\tsize_t got;\n\tchar *s;\n\n\tmpz_init(tmp1);\n\tmpz_init(tmp2);\n\tmpz_init(t5);\n\tmpz_init(t239);\n\tmpz_init(pows);\n\n\twhile (1) {\n\t\ts = get_digits(accu, &got);\n\n\t\t\n\t\tgot -= 2; \n\t\twhile (s[got] == '0' || s[got] == '9') got--;\n\n\t\tprintf(\"%.*s\", (int)(got - done), s + done);\n\t\tfree(s);\n\n\t\tdone = got;\n\n\t\t\n\t\taccu *= 2;\n\t}\n\n\treturn 0;\n}\n","Rust":"use num_bigint::BigInt;\n\nfn main() {\n calc_pi();\n}\n\nfn calc_pi() {\n let mut q = BigInt::from(1);\n let mut r = BigInt::from(0);\n let mut t = BigInt::from(1);\n let mut k = BigInt::from(1);\n let mut n = BigInt::from(3);\n let mut l = BigInt::from(3);\n let mut first = true;\n loop {\n if &q * 4 + &r - &t < &n * &t {\n print!(\"{}\", n);\n if first {\n print!(\".\");\n first = false;\n }\n let nr = (&r - &n * &t) * 10;\n n = (&q * 3 + &r) * 10 \/ &t - &n * 10;\n q *= 10;\n r = nr;\n } else {\n let nr = (&q * 2 + &r) * &l;\n let nn = (&q * &k * 7 + 2 + &r * &l) \/ (&t * &l);\n q *= &k;\n t *= &l;\n l += 2;\n k += 1;\n n = nn;\n r = nr;\n }\n }\n}\n"} {"name":"Pick random element","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <time.h>\n \nint main(){\n char array[] = { 'a', 'b', 'c','d','e','f','g','h','i','j' };\n int i;\n time_t t;\n srand((unsigned)time(&t));\n \n for(i=0;i<30;i++){\n\t\tprintf(\"%c\\n\", array[rand()%10]);\n }\n \n return 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::Rng;\n\nfn main() {\n let array = [5,1,2,5,6,7,8,1,2,4,5];\n let mut rng = rand::thread_rng();\n \n println!(\"{}\", rng.choose(&array).unwrap());\n}\n"} {"name":"Pig the dice game","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <time.h>\n\n\nconst int NUM_PLAYERS = 2;\nconst int MAX_POINTS = 100;\n\n\n\nint randrange(int min, int max){\n return (rand() % (max - min + 1)) + min;\n}\n\n\n\nvoid ResetScores(int *scores){\n for(int i = 0; i < NUM_PLAYERS; i++){\n scores[i] = 0;\n }\n}\n\n\nvoid Play(int *scores){\n int scoredPoints = 0;\n int diceResult;\n int choice;\n\n for(int i = 0; i < NUM_PLAYERS; i++){\n while(1){\n printf(\"Player %d - You have %d total points and %d points this turn \\nWhat do you want to do (1)roll or (2)hold: \", i + 1, scores[i], scoredPoints);\n scanf(\"%d\", &choice);\n\n if(choice == 1){\n diceResult = randrange(1, 6);\n printf(\"\\nYou rolled a %d\\n\", diceResult);\n\n if(diceResult != 1){\n scoredPoints += diceResult;\n }\n else{\n printf(\"You loose all your points from this turn\\n\\n\");\n scoredPoints = 0;\n break;\n }\n }\n else if(choice == 2){\n scores[i] += scoredPoints;\n printf(\"\\nYou holded, you have %d points\\n\\n\", scores[i]);\n\n break;\n }\n }\n\n scoredPoints = 0;\n CheckForWin(scores[i], i + 1);\n\n }\n}\n\n\nvoid CheckForWin(int playerScore, int playerNum){\n if(playerScore >= MAX_POINTS){\n printf(\"\\n\\nCONGRATULATIONS PLAYER %d, YOU WIN\\n\\n!\", playerNum);\n\n exit(EXIT_SUCCESS);\n }\n}\n\n\nint main()\n{\n srand(time(0));\n\n int scores[NUM_PLAYERS];\n ResetScores(scores);\n\n while(1){\n Play(scores);\n }\n\n return 0;\n}\n","Rust":"use rand::prelude::*;\n\nfn main() {\n println!(\"Beginning game of Pig...\");\n\n let mut players = vec![\n Player::new(String::from(\"PLAYER (1) ONE\")),\n Player::new(String::from(\"PLAYER (2) TWO\")),\n ];\n\n 'game: loop {\n for player in players.iter_mut() {\n if player.cont() {\n println!(\"\\n# {} has {:?} Score\", player.name, player.score);\n player.resolve();\n } else {\n println!(\"\\n{} wins!\", player.name);\n break 'game;\n }\n }\n }\n\n println!(\"Thanks for playing!\");\n}\n\ntype DiceRoll = u32;\ntype Score = u32;\ntype Name = String;\n\nenum Action {\n Roll,\n Hold,\n}\n\n#[derive(PartialEq)]\nenum TurnStatus {\n Continue,\n End,\n}\n\nstruct Player {\n name: Name,\n score: Score,\n status: TurnStatus,\n}\n\nimpl Player {\n fn new(name: Name) -> Player {\n Player {\n name,\n score: 0,\n status: TurnStatus::Continue,\n }\n }\n\n fn roll() -> DiceRoll {\n \n let sides = rand::distributions::Uniform::new(1, 6);\n rand::thread_rng().sample(sides)\n }\n\n fn action() -> Action {\n \n let command = || -> Option<char> {\n let mut cmd: String = String::new();\n match std::io::stdin().read_line(&mut cmd) {\n Ok(c) => c.to_string(),\n Err(err) => panic!(\"Error: {}\", err),\n };\n\n cmd.to_lowercase().trim().chars().next()\n };\n\n 'user_in: loop {\n match command() {\n Some('r') => break 'user_in Action::Roll,\n Some('h') => break 'user_in Action::Hold,\n Some(invalid) => println!(\"{} is not a valid command!\", invalid),\n None => println!(\"Please input a command!\"),\n }\n }\n }\n\n fn turn(&mut self) -> Score {\n let one = |die: DiceRoll| {\n println!(\"[DICE] Dice result is: {:3}!\", die);\n println!(\"[DUMP] Dumping Score! Sorry!\");\n println!(\"###### ENDING TURN ######\");\n };\n\n let two_to_six = |die: DiceRoll, score: Score, player_score: Score| {\n println!(\"[DICE] Dice result is: {:3}!\", die);\n println!(\"[ROLL] Total Score: {:3}!\", (score + die));\n println!(\"[HOLD] Possible Score: {:3}!\", (score + die + player_score));\n };\n\n let mut score: Score = 0;\n 'player: loop {\n println!(\"# {}'s Turn\", self.name);\n println!(\"###### [R]oll ######\\n###### --OR-- ######\\n###### [H]old ######\");\n\n match Player::action() {\n Action::Roll => match Player::roll() {\n 0 | 7..=u32::MAX => panic!(\"outside dice bounds!\"),\n die @ 1 => {\n one(die);\n self.status = TurnStatus::End;\n break 'player 0;\n }\n die @ 2..=6 => {\n two_to_six(die, score, self.score);\n self.status = TurnStatus::Continue;\n score += die\n }\n },\n Action::Hold => {\n self.status = TurnStatus::End;\n break 'player score;\n }\n }\n }\n }\n\n fn resolve(&mut self) {\n self.score += self.turn()\n }\n\n fn cont(&self) -> bool {\n self.score <= 100 || self.status == TurnStatus::Continue\n }\n}\n"} {"name":"Population count","C":"#include <stdio.h>\n\nint main() {\n {\n unsigned long long n = 1;\n for (int i = 0; i < 30; i++) {\n \n \n \n printf(\"%d \", __builtin_popcountll(n));\n n *= 3;\n }\n printf(\"\\n\");\n }\n\n int od[30];\n int ne = 0, no = 0;\n printf(\"evil \u00a0: \");\n for (int n = 0; ne+no < 60; n++) {\n if ((__builtin_popcount(n) & 1) == 0) {\n if (ne < 30) {\n\tprintf(\"%d \", n);\n\tne++;\n }\n } else {\n if (no < 30) {\n\tod[no++] = n;\n }\n }\n }\n printf(\"\\n\");\n printf(\"odious: \");\n for (int i = 0; i < 30; i++) {\n printf(\"%d \", od[i]);\n }\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"fn main() {\n let mut num = 1u64;\n let mut vec = Vec::new();\n for _ in 0..30 {\n vec.push(num.count_ones());\n num *= 3;\n }\n println!(\"pop count of 3^0, 3^1 ... 3^29:\\n{:?}\",vec);\n let mut even = Vec::new();\n let mut odd = Vec::new();\n num = 1;\n while even.len() < 30 || odd.len() < 30 {\n match 0 == num.count_ones()%2 {\n true if even.len() < 30 => even.push(num),\n false if odd.len() < 30 => odd.push(num),\n _ => {}\n }\n num += 1;\n }\n println!(\"\\nFirst 30 even pop count:\\n{:?}\",even);\n println!(\"\\nFirst 30 odd pop count:\\n{:?}\",odd);\n}\n"} {"name":"Power set","C":"#include <stdio.h>\n\nstruct node {\n\tchar *s;\n\tstruct node* prev;\n};\n\nvoid powerset(char **v, int n, struct node *up)\n{\n\tstruct node me;\n\n\tif (!n) {\n\t\tputchar('[');\n\t\twhile (up) {\n\t\t\tprintf(\" %s\", up->s);\n\t\t\tup = up->prev;\n\t\t}\n\t\tputs(\" ]\");\n\t} else {\n\t\tme.s = *v;\n\t\tme.prev = up;\n\t\tpowerset(v + 1, n - 1, up);\n\t\tpowerset(v + 1, n - 1, &me);\n\t}\n}\n\nint main(int argc, char **argv)\n{\n\tpowerset(argv + 1, argc - 1, 0);\n\treturn 0;\n}\n","Rust":"use std::collections::BTreeSet;\n\nfn powerset<T: Ord + Clone>(mut set: BTreeSet<T>) -> BTreeSet<BTreeSet<T>> {\n if set.is_empty() {\n let mut powerset = BTreeSet::new();\n powerset.insert(set);\n return powerset;\n }\n \n \n let entry = set.iter().nth(0).unwrap().clone(); \n set.remove(&entry);\n let mut powerset = powerset(set);\n for mut set in powerset.clone().into_iter() {\n set.insert(entry.clone());\n powerset.insert(set);\n }\n powerset\n}\n\nfn main() {\n let set = (1..5).collect();\n let set = powerset(set);\n println!(\"{:?}\", set);\n\n let set = [\"a\", \"b\", \"c\", \"d\"].iter().collect();\n let set = powerset(set);\n println!(\"{:?}\", set);\n}\n"} {"name":"Primality by Wilson's theorem","C":"#include <stdbool.h>\n#include <stdint.h>\n#include <stdio.h>\n\nuint64_t factorial(uint64_t n) {\n uint64_t product = 1;\n\n if (n < 2) {\n return 1;\n }\n\n for (; n > 0; n--) {\n uint64_t prev = product;\n product *= n;\n if (product < prev) {\n fprintf(stderr, \"Overflowed\\n\");\n return product;\n }\n }\n\n return product;\n}\n\n\nbool isPrime(uint64_t n) {\n uint64_t large = factorial(n - 1) + 1;\n return (large % n) == 0;\n}\n\nint main() {\n uint64_t n;\n\n \n for (n = 2; n < 22; n++) {\n printf(\"Is %llu prime: %d\\n\", n, isPrime(n));\n }\n\n return 0;\n}\n","Rust":"fn factorial_mod(mut n: u32, p: u32) -> u32 {\n let mut f = 1;\n while n != 0 && f != 0 {\n f = (f * n) % p;\n n -= 1;\n }\n f\n}\n\nfn is_prime(p: u32) -> bool {\n p > 1 && factorial_mod(p - 1, p) == p - 1\n}\n\nfn main() {\n println!(\" n | prime?\\n------------\");\n for p in vec![2, 3, 9, 15, 29, 37, 47, 57, 67, 77, 87, 97, 237, 409, 659] {\n println!(\"{:>3} | {}\", p, is_prime(p));\n }\n println!(\"\\nFirst 120 primes by Wilson's theorem:\");\n let mut n = 0;\n let mut p = 1;\n while n < 120 {\n if is_prime(p) {\n n += 1;\n print!(\"{:>3}{}\", p, if n % 20 == 0 { '\\n' } else { ' ' });\n }\n p += 1;\n }\n println!(\"\\n1000th through 1015th primes:\");\n let mut i = 0;\n while n < 1015 {\n if is_prime(p) {\n n += 1;\n if n >= 1000 {\n i += 1;\n print!(\"{:>3}{}\", p, if i % 16 == 0 { '\\n' } else { ' ' });\n }\n }\n p += 1;\n }\n}\n"} {"name":"Primality by trial division","C":"int is_prime(unsigned int n)\n{\n\tunsigned int p;\n\tif (!(n & 1) || n < 2 ) return n == 2;\n\n\t\n\tfor (p = 3; p <= n\/p; p += 2)\n\t\tif (!(n % p)) return 0;\n\treturn 1;\n}\n","Rust":"fn is_prime(n: u64) -> bool {\n match n {\n 0 | 1 => false,\n 2 => true,\n _even if n % 2 == 0 => false,\n _ => {\n let sqrt_limit = (n as f64).sqrt() as u64;\n (3..=sqrt_limit).step_by(2).find(|i| n % i == 0).is_none()\n }\n }\n}\n\nfn main() {\n for i in (1..30).filter(|i| is_prime(*i)) {\n println!(\"{} \", i);\n }\n}\n"} {"name":"Prime decomposition","C":"#include <inttypes.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <assert.h>\n\ntypedef uint32_t pint;\ntypedef uint64_t xint;\ntypedef unsigned int uint;\n#define PRIuPINT PRIu32 \n#define PRIuXINT PRIu64 \n#define MAX_FACTORS 63 \n\nuint8_t *pbits;\n\n#define MAX_PRIME (~(pint)0)\n#define MAX_PRIME_SQ 65535U\n#define PBITS (MAX_PRIME \/ 30 + 1)\n\npint next_prime(pint);\nint is_prime(xint);\nvoid sieve(pint);\n\nuint8_t bit_pos[30] = {\n 0, 1<<0, 0, 0, 0, 0,\n 0, 1<<1, 0, 0, 0, 1<<2,\n 0, 1<<3, 0, 0, 0, 1<<4,\n 0, 1<<5, 0, 0, 0, 1<<6,\n 0, 0, 0, 0, 0, 1<<7,\n};\n\nuint8_t rem_num[] = { 1, 7, 11, 13, 17, 19, 23, 29 };\n\nvoid init_primes()\n{\n FILE *fp;\n pint s, tgt = 4;\n\n if (!(pbits = malloc(PBITS))) {\n perror(\"malloc\");\n exit(1);\n }\n\n if ((fp = fopen(\"primebits\", \"r\"))) {\n fread(pbits, 1, PBITS, fp);\n fclose(fp);\n return;\n }\n\n memset(pbits, 255, PBITS);\n for (s = 7; s <= MAX_PRIME_SQ; s = next_prime(s)) {\n if (s > tgt) {\n tgt *= 2;\n fprintf(stderr, \"sieve\u00a0%\"PRIuPINT\"\\n\", s);\n }\n sieve(s);\n }\n fp = fopen(\"primebits\", \"w\");\n fwrite(pbits, 1, PBITS, fp);\n fclose(fp);\n}\n\nint is_prime(xint x)\n{\n pint p;\n if (x > 5) {\n if (x < MAX_PRIME)\n return pbits[x\/30] & bit_pos[x % 30];\n\n for (p = 2; p && (xint)p * p <= x; p = next_prime(p))\n if (x % p == 0) return 0;\n\n return 1;\n }\n return x == 2 || x == 3 || x == 5;\n}\n\nvoid sieve(pint p)\n{\n unsigned char b[8];\n off_t ofs[8];\n int i, q;\n\n for (i = 0; i < 8; i++) {\n q = rem_num[i] * p;\n b[i] = ~bit_pos[q % 30];\n ofs[i] = q \/ 30;\n }\n\n for (q = ofs[1], i = 7; i; i--)\n ofs[i] -= ofs[i-1];\n\n for (ofs[0] = p, i = 1; i < 8; i++)\n ofs[0] -= ofs[i];\n\n for (i = 1; q < PBITS; q += ofs[i = (i + 1) & 7])\n pbits[q] &= b[i];\n}\n\npint next_prime(pint p)\n{\n off_t addr;\n uint8_t bits, rem;\n\n if (p > 5) {\n addr = p \/ 30;\n bits = bit_pos[ p % 30 ] << 1;\n for (rem = 0; (1 << rem) < bits; rem++);\n while (pbits[addr] < bits || !bits) {\n if (++addr >= PBITS) return 0;\n bits = 1;\n rem = 0;\n }\n if (addr >= PBITS) return 0;\n while (!(pbits[addr] & bits)) {\n rem++;\n bits <<= 1;\n }\n return p = addr * 30 + rem_num[rem];\n }\n\n switch(p) {\n case 2: return 3;\n case 3: return 5;\n case 5: return 7;\n }\n return 2;\n}\n\nint decompose(xint n, xint *f)\n{\n pint p = 0;\n int i = 0;\n\n \n if (n <= MAX_PRIME && is_prime(n)) {\n f[0] = n;\n return 1;\n }\n\n while (n >= (xint)p * p) {\n if (!(p = next_prime(p))) break;\n while (n % p == 0) {\n n \/= p;\n f[i++] = p;\n }\n }\n if (n > 1) f[i++] = n;\n return i;\n}\n\nint main()\n{\n int i, len;\n pint p = 0;\n xint f[MAX_FACTORS], po;\n\n init_primes();\n\n for (p = 1; p < 64; p++) {\n po = (1LLU << p) - 1;\n printf(\"2^%\"PRIuPINT\" - 1 =\u00a0%\"PRIuXINT, p, po);\n fflush(stdout);\n if ((len = decompose(po, f)) > 1)\n for (i = 0; i < len; i++)\n printf(\" %c\u00a0%\"PRIuXINT, i?'x':'=', f[i]);\n putchar('\\n');\n }\n\n return 0;\n}\n","Rust":"use num_bigint::BigUint;\nuse num_traits::{One, Zero};\nuse std::fmt::{Display, Formatter};\n\n#[derive(Clone, Debug)]\npub struct Factors {\n pub number: BigUint,\n pub result: Vec<BigUint>,\n}\n\nimpl Factors {\n pub fn of(number: BigUint) -> Factors {\n let mut factors = Self {\n number: number.clone(),\n result: Vec::new(),\n };\n\n let big_2 = BigUint::from(2u8);\n let big_4 = BigUint::from(4u8);\n\n factors.check(&big_2);\n factors.check(&BigUint::from(3u8));\n\n let mut divisor = BigUint::from(5u8);\n while &divisor * &divisor <= factors.number {\n factors.check(&divisor);\n divisor += &big_2;\n factors.check(&divisor);\n divisor += &big_4;\n }\n\n if factors.number > BigUint::one() {\n factors.result.push(factors.number);\n }\n\n factors.number = number; \n factors\n }\n\n pub fn is_prime(&self) -> bool {\n self.result.len() == 1\n }\n\n fn check(&mut self, divisor: &BigUint) {\n while (&self.number % divisor).is_zero() {\n self.result.push(divisor.clone());\n self.number \/= divisor;\n }\n }\n}\n\nimpl Display for Factors {\n fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {\n let mut iter = self.result.iter();\n\n match iter.next() {\n None => write!(f, \"[]\"),\n\n Some(first) => {\n write!(f, \"[{}\", first)?;\n for next in iter {\n write!(f, \", {}\", next)?;\n }\n\n write!(f, \"]\")\n }\n }\n }\n}\n\nfn print_factors(number: BigUint) {\n let factors = Factors::of(number);\n\n if factors.is_prime() {\n println!(\"{} -> {} (prime)\", factors.number, factors);\n } else {\n println!(\"{} -> {}\", factors.number, factors);\n }\n}\n\nfn main() {\n print_factors(24u32.into());\n print_factors(32u32.into());\n print_factors(37u32.into());\n\n \n\n for n in 2..70 {\n print!(\"2**{} - 1: \", n);\n print_factors((BigUint::from(2u8) << n) - BigUint::one());\n }\n}\n"} {"name":"Priority queue","C":"#include <stdio.h>\n#include <stdlib.h>\n\ntypedef struct {\n int priority;\n char *data;\n} node_t;\n\ntypedef struct {\n node_t *nodes;\n int len;\n int size;\n} heap_t;\n\nvoid push (heap_t *h, int priority, char *data) {\n if (h->len + 1 >= h->size) {\n h->size = h->size ? h->size * 2 : 4;\n h->nodes = (node_t *)realloc(h->nodes, h->size * sizeof (node_t));\n }\n int i = h->len + 1;\n int j = i \/ 2;\n while (i > 1 && h->nodes[j].priority > priority) {\n h->nodes[i] = h->nodes[j];\n i = j;\n j = j \/ 2;\n }\n h->nodes[i].priority = priority;\n h->nodes[i].data = data;\n h->len++;\n}\n\nchar *pop (heap_t *h) {\n int i, j, k;\n if (!h->len) {\n return NULL;\n }\n char *data = h->nodes[1].data;\n \n h->nodes[1] = h->nodes[h->len];\n \n h->len--;\n \n i = 1;\n while (i!=h->len+1) {\n k = h->len+1;\n j = 2 * i;\n if (j <= h->len && h->nodes[j].priority < h->nodes[k].priority) {\n k = j;\n }\n if (j + 1 <= h->len && h->nodes[j + 1].priority < h->nodes[k].priority) {\n k = j + 1;\n }\n h->nodes[i] = h->nodes[k];\n i = k;\n }\n return data;\n}\n\nint main () {\n heap_t *h = (heap_t *)calloc(1, sizeof (heap_t));\n push(h, 3, \"Clear drains\");\n push(h, 4, \"Feed cat\");\n push(h, 5, \"Make tea\");\n push(h, 1, \"Solve RC tasks\");\n push(h, 2, \"Tax return\");\n int i;\n for (i = 0; i < 5; i++) {\n printf(\"%s\\n\", pop(h));\n }\n return 0;\n}\n","Rust":"use std::collections::BinaryHeap;\nuse std::cmp::Ordering;\nuse std::borrow::Cow;\n\n#[derive(Eq, PartialEq)]\nstruct Item<'a> {\n priority: usize,\n task: Cow<'a, str>, \n}\n\nimpl<'a> Item<'a> {\n fn new<T>(p: usize, t: T) -> Self\n where T: Into<Cow<'a, str>>\n {\n Item {\n priority: p,\n task: t.into(),\n }\n }\n}\n\n\nimpl<'a> Ord for Item<'a> {\n fn cmp(&self, other: &Self) -> Ordering {\n other.priority.cmp(&self.priority)\n }\n}\n\n\nimpl<'a> PartialOrd for Item<'a> {\n fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n Some(self.cmp(other))\n }\n}\n\n\nfn main() {\n let mut queue = BinaryHeap::with_capacity(5);\n queue.push(Item::new(3, \"Clear drains\"));\n queue.push(Item::new(4, \"Feed cat\"));\n queue.push(Item::new(5, \"Make tea\"));\n queue.push(Item::new(1, \"Solve RC tasks\"));\n queue.push(Item::new(2, \"Tax return\"));\n\n for item in queue {\n println!(\"{}\", item.task);\n }\n}\n"} {"name":"Probabilistic choice","C":"#include <stdio.h>\n#include <stdlib.h>\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\n#define LEN 8\n#define N 1000000\nint main()\n{\n\tconst char *names[LEN] = { \"aleph\", \"beth\", \"gimel\", \"daleth\",\n\t\t\t \"he\", \"waw\", \"zayin\", \"heth\" };\n\tdouble s, p[LEN] = { 1.\/5, 1.\/6, 1.\/7, 1.\/8, 1.\/9, 1.\/10, 1.\/11, 1e300 };\n\tint i, count[LEN] = {0};\n\n\tfor (i = 0; i < N; i++) count[rand_idx(p, LEN)] ++;\n\n\tprintf(\" Name Count Ratio Expected\\n\");\n\tfor (i = 0, s = 1; i < LEN; s -= p[i++])\n\t\tprintf(\"%6s%7d %7.4f%% %7.4f%%\\n\",\n\t\t\tnames[i], count[i],\n\t\t\t(double)count[i] \/ N * 100,\n\t\t\t((i < LEN - 1) ? p[i] : s) * 100);\n\n\treturn 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::distributions::{IndependentSample, Sample, Weighted, WeightedChoice};\nuse rand::{weak_rng, Rng};\n\nconst DATA: [(&str, f64); 8] = [\n (\"aleph\", 1.0 \/ 5.0),\n (\"beth\", 1.0 \/ 6.0),\n (\"gimel\", 1.0 \/ 7.0),\n (\"daleth\", 1.0 \/ 8.0),\n (\"he\", 1.0 \/ 9.0),\n (\"waw\", 1.0 \/ 10.0),\n (\"zayin\", 1.0 \/ 11.0),\n (\"heth\", 1759.0 \/ 27720.0),\n];\n\nconst SAMPLES: usize = 1_000_000;\n\n\nfn gen_mapping() -> Vec<Weighted<usize>> {\n DATA.iter()\n .enumerate()\n .map(|(i, &(_, p))| Weighted {\n \n \n \n \n \n weight: (p * 1_000_000_000.0) as u32,\n item: i,\n })\n .collect()\n}\n\n\nfn gen_mapping_float() -> Vec<f64> {\n \n \n let mut running_total = 0.0;\n DATA.iter()\n .map(|&(_, p)| {\n running_total += p;\n running_total\n })\n .collect()\n}\n\n\n\nstruct WcFloat {\n mapping: Vec<f64>,\n}\n\nimpl WcFloat {\n fn new(mapping: &[f64]) -> Self {\n Self {\n mapping: mapping.to_vec(),\n }\n }\n\n \n fn search(&self, sample_prob: f64) -> usize {\n let idx = self.mapping\n .binary_search_by(|p| p.partial_cmp(&sample_prob).unwrap());\n match idx {\n Ok(i) | Err(i) => i,\n }\n }\n}\n\nimpl IndependentSample<usize> for WcFloat {\n fn ind_sample<R: Rng>(&self, rng: &mut R) -> usize {\n \n \n \n let sample_prob = rng.next_f64();\n self.search(sample_prob)\n }\n}\n\nimpl Sample<usize> for WcFloat {\n fn sample<R: Rng>(&mut self, rng: &mut R) -> usize {\n self.ind_sample(rng)\n }\n}\n\nfn take_samples<R: Rng, T>(rng: &mut R, wc: &T) -> [usize; 8]\nwhere\n T: IndependentSample<usize>,\n{\n let mut counts = [0; 8];\n for _ in 0..SAMPLES {\n let sample = wc.ind_sample(rng);\n counts[sample] += 1;\n }\n counts\n}\n\nfn print_mapping(counts: &[usize]) {\n println!(\"Item | Expected | Actual \");\n println!(\"-------+----------+----------\");\n for (&(name, expected), &count) in DATA.iter().zip(counts.iter()) {\n let real = count as f64 \/ SAMPLES as f64;\n println!(\"{:6} | {:.6} | {:.6}\", name, expected, real);\n }\n}\n\nfn main() {\n let mut rng = weak_rng();\n\n println!(\" ~~~ U32 METHOD ~~~\");\n let mut mapping = gen_mapping();\n let wc = WeightedChoice::new(&mut mapping);\n\n let counts = take_samples(&mut rng, &wc);\n print_mapping(&counts);\n\n println!();\n\n println!(\" ~~~ FLOAT METHOD ~~~\");\n \n let mapping = gen_mapping_float();\n let wc = WcFloat::new(&mapping);\n\n let counts = take_samples(&mut rng, &wc);\n print_mapping(&counts);\n}\n"} {"name":"Program name","C":"#include <stdio.h>\n\nint main(int argc, char **argv) {\n\tprintf(\"Executable: %s\\n\", argv[0]);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n println!(\"Program: {}\", std::env::args().next().unwrap());\n}\n"} {"name":"Program termination","C":"#include <stdlib.h>\n\nint main(int argc, char **argv)\n{\n \n ...\n return 0; \n}\n\nif(problem){\n exit(exit_code);\n \n}\n","Rust":"fn main() {\n println!(\"The program is running\");\n return;\n println!(\"This line won't be printed\");\n}\n"} {"name":"Proper divisors","C":"#include <stdio.h>\n#include <stdbool.h>\n\nint proper_divisors(const int n, bool print_flag)\n{\n int count = 0;\n\n for (int i = 1; i < n; ++i) {\n if (n % i == 0) {\n count++;\n if (print_flag)\n printf(\"%d \", i);\n }\n }\n\n if (print_flag)\n printf(\"\\n\");\n\n return count;\n}\n\nint main(void)\n{\n for (int i = 1; i <= 10; ++i) {\n printf(\"%d: \", i);\n proper_divisors(i, true);\n }\n\n int max = 0;\n int max_i = 1;\n\n for (int i = 1; i <= 20000; ++i) {\n int v = proper_divisors(i, false);\n if (v >= max) {\n max = v;\n max_i = i;\n }\n }\n\n printf(\"%d with %d divisors\\n\", max_i, max);\n return 0;\n}\n","Rust":"trait ProperDivisors {\n fn proper_divisors(&self) -> Option<Vec<u64>>;\n}\n\nimpl ProperDivisors for u64 {\n fn proper_divisors(&self) -> Option<Vec<u64>> {\n if self.le(&1) {\n return None;\n }\n let mut divisors: Vec<u64> = Vec::new();\n\n for i in 1..*self {\n if *self % i == 0 {\n divisors.push(i);\n }\n }\n Option::from(divisors)\n }\n}\n\nfn main() {\n for i in 1..11 {\n println!(\"Proper divisors of {:2}: {:?}\", i,\n i.proper_divisors().unwrap_or(vec![]));\n }\n\n let mut most_idx: u64 = 0;\n let mut most_divisors: Vec<u64> = Vec::new();\n for i in 1..20_001 {\n let divs = i.proper_divisors().unwrap_or(vec![]);\n if divs.len() > most_divisors.len() {\n most_divisors = divs;\n most_idx = i;\n }\n }\n println!(\"In 1 to 20000, {} has the most proper divisors at {}\", most_idx,\n most_divisors.len());\n}\n"} {"name":"Quaternion type","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n#include <math.h>\n\ntypedef struct quaternion\n{\n double q[4];\n} quaternion_t;\n\n\nquaternion_t *quaternion_new(void)\n{\n return malloc(sizeof(quaternion_t));\n}\n\nquaternion_t *quaternion_new_set(double q1,\n\t\t\t\t double q2,\n\t\t\t\t double q3,\n\t\t\t\t double q4)\n{\n quaternion_t *q = malloc(sizeof(quaternion_t));\n if (q != NULL) {\n q->q[0] = q1; q->q[1] = q2; q->q[2] = q3; q->q[3] = q4;\n }\n return q;\n}\n\n\nvoid quaternion_copy(quaternion_t *r, quaternion_t *q)\n{\n size_t i;\n\n if (r == NULL || q == NULL) return;\n for(i = 0; i < 4; i++) r->q[i] = q->q[i];\n}\n\n\ndouble quaternion_norm(quaternion_t *q)\n{\n size_t i;\n double r = 0.0;\n \n if (q == NULL) {\n fprintf(stderr, \"NULL quaternion in norm\\n\");\n return 0.0;\n }\n\n for(i = 0; i < 4; i++) r += q->q[i] * q->q[i];\n return sqrt(r);\n}\n\n\nvoid quaternion_neg(quaternion_t *r, quaternion_t *q)\n{\n size_t i;\n\n if (q == NULL || r == NULL) return;\n for(i = 0; i < 4; i++) r->q[i] = -q->q[i];\n}\n\n\nvoid quaternion_conj(quaternion_t *r, quaternion_t *q)\n{\n size_t i;\n\n if (q == NULL || r == NULL) return;\n r->q[0] = q->q[0];\n for(i = 1; i < 4; i++) r->q[i] = -q->q[i];\n}\n\n\nvoid quaternion_add_d(quaternion_t *r, quaternion_t *q, double d)\n{\n if (q == NULL || r == NULL) return;\n quaternion_copy(r, q);\n r->q[0] += d;\n}\n\n\nvoid quaternion_add(quaternion_t *r, quaternion_t *a, quaternion_t *b)\n{\n size_t i;\n\n if (r == NULL || a == NULL || b == NULL) return;\n for(i = 0; i < 4; i++) r->q[i] = a->q[i] + b->q[i];\n}\n\n\nvoid quaternion_mul_d(quaternion_t *r, quaternion_t *q, double d)\n{\n size_t i;\n\n if (r == NULL || q == NULL) return;\n for(i = 0; i < 4; i++) r->q[i] = q->q[i] * d;\n}\n\nbool quaternion_equal(quaternion_t *a, quaternion_t *b)\n{\n size_t i;\n \n for(i = 0; i < 4; i++) if (a->q[i] != b->q[i]) return false;\n return true;\n}\n\n\n#define A(N) (a->q[(N)])\n#define B(N) (b->q[(N)])\n#define R(N) (r->q[(N)])\nvoid quaternion_mul(quaternion_t *r, quaternion_t *a, quaternion_t *b)\n{\n size_t i;\n double ri = 0.0;\n\n if (r == NULL || a == NULL || b == NULL) return;\n R(0) = A(0)*B(0) - A(1)*B(1) - A(2)*B(2) - A(3)*B(3);\n R(1) = A(0)*B(1) + A(1)*B(0) + A(2)*B(3) - A(3)*B(2);\n R(2) = A(0)*B(2) - A(1)*B(3) + A(2)*B(0) + A(3)*B(1);\n R(3) = A(0)*B(3) + A(1)*B(2) - A(2)*B(1) + A(3)*B(0);\n}\n#undef A\n#undef B\n#undef R\n\n\nvoid quaternion_print(quaternion_t *q)\n{\n if (q == NULL) return;\n printf(\"(%lf, %lf, %lf, %lf)\\n\", \n\t q->q[0], q->q[1], q->q[2], q->q[3]);\n}\n","Rust":"use std::fmt::{Display, Error, Formatter};\nuse std::ops::{Add, Mul, Neg};\n\n#[derive(Clone,Copy,Debug)]\nstruct Quaternion {\n a: f64,\n b: f64,\n c: f64,\n d: f64\n}\n\nimpl Quaternion {\n pub fn new(a: f64, b: f64, c: f64, d: f64) -> Quaternion {\n Quaternion {\n a: a,\n b: b,\n c: c,\n d: d\n }\n }\n\n pub fn norm(&self) -> f64 {\n (self.a.powi(2) + self.b.powi(2) + self.c.powi(2) + self.d.powi(2)).sqrt()\n }\n\n pub fn conjugate(&self) -> Quaternion {\n Quaternion {\n a: self.a,\n b: -self.b,\n c: -self.c,\n d: -self.d\n }\n }\n}\n\nimpl Add for Quaternion {\n type Output = Quaternion;\n\n #[inline]\n fn add(self, other: Quaternion) -> Self::Output {\n Quaternion {\n a: self.a + other.a,\n b: self.b + other.b,\n c: self.c + other.c,\n d: self.d + other.d\n }\n }\n}\n\nimpl Add<f64> for Quaternion {\n type Output = Quaternion;\n\n #[inline]\n fn add(self, other: f64) -> Self::Output {\n Quaternion {\n a: self.a + other,\n b: self.b,\n c: self.c,\n d: self.d\n }\n }\n}\n\nimpl Add<Quaternion> for f64 {\n type Output = Quaternion;\n\n #[inline]\n fn add(self, other: Quaternion) -> Self::Output {\n Quaternion {\n a: other.a + self,\n b: other.b,\n c: other.c,\n d: other.d\n }\n }\n}\n\nimpl Display for Quaternion {\n fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {\n write!(f, \"({} + {}i + {}j + {}k)\", self.a, self.b, self.c, self.d)\n }\n}\n\nimpl Mul for Quaternion {\n type Output = Quaternion;\n\n #[inline]\n fn mul(self, rhs: Quaternion) -> Self::Output {\n Quaternion {\n a: self.a * rhs.a - self.b * rhs.b - self.c * rhs.c - self.d * rhs.d,\n b: self.a * rhs.b + self.b * rhs.a + self.c * rhs.d - self.d * rhs.c,\n c: self.a * rhs.c - self.b * rhs.d + self.c * rhs.a + self.d * rhs.b,\n d: self.a * rhs.d + self.b * rhs.c - self.c * rhs.b + self.d * rhs.a,\n }\n }\n}\n\nimpl Mul<f64> for Quaternion {\n type Output = Quaternion;\n\n #[inline]\n fn mul(self, other: f64) -> Self::Output {\n Quaternion {\n a: self.a * other,\n b: self.b * other,\n c: self.c * other,\n d: self.d * other\n }\n }\n}\n\nimpl Mul<Quaternion> for f64 {\n type Output = Quaternion;\n\n #[inline]\n fn mul(self, other: Quaternion) -> Self::Output {\n Quaternion {\n a: other.a * self,\n b: other.b * self,\n c: other.c * self,\n d: other.d * self\n }\n }\n}\n\nimpl Neg for Quaternion {\n type Output = Quaternion;\n\n #[inline]\n fn neg(self) -> Self::Output {\n Quaternion {\n a: -self.a,\n b: -self.b,\n c: -self.c,\n d: -self.d\n }\n }\n}\n\nfn main() {\n let q0 = Quaternion { a: 1., b: 2., c: 3., d: 4. };\n let q1 = Quaternion::new(2., 3., 4., 5.);\n let q2 = Quaternion::new(3., 4., 5., 6.);\n let r: f64 = 7.;\n\n println!(\"q0 = {}\", q0);\n println!(\"q1 = {}\", q1);\n println!(\"q2 = {}\", q2);\n println!(\"r = {}\", r);\n println!();\n println!(\"-q0 = {}\", -q0);\n println!(\"conjugate of q0 = {}\", q0.conjugate());\n println!();\n println!(\"r + q0 = {}\", r + q0);\n println!(\"q0 + r = {}\", q0 + r);\n println!();\n println!(\"r * q0 = {}\", r * q0);\n println!(\"q0 * r = {}\", q0 * r);\n println!();\n println!(\"q0 + q1 = {}\", q0 + q1);\n println!(\"q0 * q1 = {}\", q0 * q1);\n println!();\n println!(\"q0 * (conjugate of q0) = {}\", q0 * q0.conjugate());\n println!();\n println!(\" q0 + q1 * q2 = {}\", q0 + q1 * q2);\n println!(\"(q0 + q1) * q2 = {}\", (q0 + q1) * q2);\n println!();\n println!(\" q0 * q1 * q2 = {}\", q0 *q1 * q2);\n println!(\"(q0 * q1) * q2 = {}\", (q0 * q1) * q2);\n println!(\" q0 * (q1 * q2) = {}\", q0 * (q1 * q2));\n println!();\n println!(\"normal of q0 = {}\", q0.norm());\n}\n"} {"name":"Queue_Definition","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef int DATA; \ntypedef struct {\n DATA *buf;\n size_t head, tail, alloc;\n} queue_t, *queue;\n\nqueue q_new()\n{\n queue q = malloc(sizeof(queue_t));\n q->buf = malloc(sizeof(DATA) * (q->alloc = 4));\n q->head = q->tail = 0;\n return q;\n}\n\nint empty(queue q)\n{\n return q->tail == q->head;\n}\n\nvoid enqueue(queue q, DATA n)\n{\n if (q->tail >= q->alloc) q->tail = 0;\n q->buf[q->tail++] = n;\n \n \n if (q->tail == q->alloc) { \n q->buf = realloc(q->buf, sizeof(DATA) * q->alloc * 2);\n if (q->head) {\n memcpy(q->buf + q->head + q->alloc, q->buf + q->head,\n sizeof(DATA) * (q->alloc - q->head));\n q->head += q->alloc;\n } else\n q->tail = q->alloc;\n q->alloc *= 2;\n }\n}\n\nint dequeue(queue q, DATA *n)\n{\n if (q->head == q->tail) return 0;\n *n = q->buf[q->head++];\n if (q->head >= q->alloc) { \n q->head = 0;\n if (q->alloc >= 512 && q->tail < q->alloc \/ 2)\n q->buf = realloc(q->buf, sizeof(DATA) * (q->alloc\/=2));\n }\n return 1;\n}\n","Rust":"use std::collections::VecDeque;\nfn main() {\n let mut stack = VecDeque::new();\n stack.push_back(\"Element1\");\n stack.push_back(\"Element2\");\n stack.push_back(\"Element3\");\n\n assert_eq!(Some(&\"Element1\"), stack.front());\n assert_eq!(Some(\"Element1\"), stack.pop_front());\n assert_eq!(Some(\"Element2\"), stack.pop_front());\n assert_eq!(Some(\"Element3\"), stack.pop_front());\n assert_eq!(None, stack.pop_front());\n}\n"} {"name":"Queue_Usage","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n \n#include <sys\/queue.h>\n\n\n\nint main()\n{\n int i;\n FIFOList head;\n\n TAILQ_INIT(&head);\n\n \n for(i=0; i < 20; i++) {\n m_enqueue(i, &head);\n }\n\n \n while( m_dequeue(&i, &head) )\n printf(\"%d\\n\", i);\n\n fprintf(stderr, \"FIFO list %s\\n\",\n ( m_dequeue(&i, &head) ) ? \n \"had still an element\" :\n \"is void!\");\n\n exit(0);\n}\n","Rust":"use std::collections::VecDeque;\n\nfn main() {\n let mut queue = VecDeque::new();\n queue.push_back(\"Hello\");\n queue.push_back(\"World\");\n while let Some(item) = queue.pop_front() {\n println!(\"{}\", item);\n }\n\n if queue.is_empty() {\n println!(\"Yes, it is empty!\");\n }\n}\n"} {"name":"Quickselect algorithm","C":"#include <stdio.h>\n#include <string.h>\n\nint qselect(int *v, int len, int k)\n{\n#\tdefine SWAP(a, b) { tmp = v[a]; v[a] = v[b]; v[b] = tmp; }\n\tint i, st, tmp;\n\n\tfor (st = i = 0; i < len - 1; i++) {\n\t\tif (v[i] > v[len-1]) continue;\n\t\tSWAP(i, st);\n\t\tst++;\n\t}\n\n\tSWAP(len-1, st);\n\n\treturn k == st\t?v[st]\n\t\t\t:st > k\t? qselect(v, st, k)\n\t\t\t\t: qselect(v + st, len - st, k - st);\n}\n\nint main(void)\n{\n#\tdefine N (sizeof(x)\/sizeof(x[0]))\n\tint x[] = {9, 8, 7, 6, 5, 0, 1, 2, 3, 4};\n\tint y[N];\n\n\tint i;\n\tfor (i = 0; i < 10; i++) {\n\t\tmemcpy(y, x, sizeof(x)); \n\t\tprintf(\"%d: %d\\n\", i, qselect(y, 10, i));\n\t}\n\n\treturn 0;\n}\n","Rust":"\n\nfn partition<T: PartialOrd>(a: &mut [T], left: usize, right: usize, pivot: usize) -> usize {\n a.swap(pivot, right);\n let mut store_index = left;\n for i in left..right {\n if a[i] < a[right] {\n a.swap(store_index, i);\n store_index += 1;\n }\n }\n a.swap(right, store_index);\n store_index\n}\n\nfn pivot_index(left: usize, right: usize) -> usize {\n return left + (right - left) \/ 2;\n}\n\nfn select<T: PartialOrd>(a: &mut [T], mut left: usize, mut right: usize, n: usize) {\n loop {\n if left == right {\n break;\n }\n let mut pivot = pivot_index(left, right);\n pivot = partition(a, left, right, pivot);\n if n == pivot {\n break;\n } else if n < pivot {\n right = pivot - 1;\n } else {\n left = pivot + 1;\n }\n }\n}\n\n\n\n\nfn nth_element<T: PartialOrd>(a: &mut [T], n: usize) {\n select(a, 0, a.len() - 1, n);\n}\n\nfn main() {\n let a = vec![9, 8, 7, 6, 5, 0, 1, 2, 3, 4];\n for n in 0..a.len() {\n let mut b = a.clone();\n nth_element(&mut b, n);\n println!(\"n = {}, nth element = {}\", n + 1, b[n]);\n }\n}\n"} {"name":"Quine","C":"#include <stdio.h>\n\nstatic char sym[] = \"\\n\\t\\\\\\\"\";\n\nint main(void) {\n\tconst char *code = \"#include <stdio.h>%c%cstatic char sym[] = %c%cn%ct%c%c%c%c%c;%c%cint main(void) {%c%cconst char *code = %c%s%c;%c%cprintf(code, sym[0], sym[0], sym[3], sym[2], sym[2], sym[2], sym[2], sym[2], sym[3], sym[3], sym[0], sym[0], sym[0], sym[1], sym[3], code, sym[3], sym[0], sym[1], sym[0], sym[0], sym[1], sym[0], sym[0]);%c%c%creturn 0;%c}%c\";\n\tprintf(code, sym[0], sym[0], sym[3], sym[2], sym[2], sym[2], sym[2], sym[2], sym[3], sym[3], sym[0], sym[0], sym[0], sym[1], sym[3], code, sym[3], sym[0], sym[1], sym[0], sym[0], sym[1], sym[0], sym[0]);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n let x = \"fn main() {\\n let x = \";\n let y = \"print!(\\\"{}{:?};\\n let y = {:?};\\n {}\\\", x, x, y, y)\\n}\\n\";\n print!(\"{}{:?};\n let y = {:?};\n {}\", x, x, y, y)\n}\n"} {"name":"RIPEMD-160","C":"#ifndef RMDsize\n#define RMDsize 160\n#endif\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <time.h>\n#include <string.h>\n#if RMDsize == 128\n#include \"rmd128.h\"\n#include \"rmd128.c\" \n#elif RMDsize == 160\n#include \"rmd160.h\"\n#include \"rmd160.c\" \n#endif\n","Rust":"use ripemd160::{Digest, Ripemd160};\n\n\n\nfn ripemd160(text: &str) -> String {\n \n \n \n format!(\"{:x}\", Ripemd160::digest(text.as_bytes()))\n}\n\nfn main() {\n println!(\"{}\", ripemd160(\"Rosetta Code\"));\n}\n"} {"name":"RSA code","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <gmp.h>\n\nint main(void)\n{\n mpz_t n, d, e, pt, ct;\n\n mpz_init(pt);\n mpz_init(ct);\n mpz_init_set_str(n, \"9516311845790656153499716760847001433441357\", 10);\n mpz_init_set_str(e, \"65537\", 10);\n mpz_init_set_str(d, \"5617843187844953170308463622230283376298685\", 10);\n\n const char *plaintext = \"Rossetta Code\";\n mpz_import(pt, strlen(plaintext), 1, 1, 0, 0, plaintext);\n\n if (mpz_cmp(pt, n) > 0)\n abort();\n\n mpz_powm(ct, pt, e, n);\n gmp_printf(\"Encoded: %Zd\\n\", ct);\n\n mpz_powm(pt, ct, d, n);\n gmp_printf(\"Decoded: %Zd\\n\", pt);\n\n char buffer[64];\n mpz_export(buffer, NULL, 1, 1, 0, 0, pt);\n printf(\"As String: %s\\n\", buffer);\n\n mpz_clears(pt, ct, n, e, d, NULL);\n return 0;\n}\n","Rust":"extern crate num;\n\nuse num::bigint::BigUint;\nuse num::integer::Integer;\nuse num::traits::{One, Zero};\n\nfn mod_exp(b: &BigUint, e: &BigUint, n: &BigUint) -> Result<BigUint, &'static str> {\n if n.is_zero() {\n return Err(\"modulus is zero\");\n }\n if b >= n {\n \n return Err(\"base is >= modulus\");\n }\n if b.gcd(n) != BigUint::one() {\n return Err(\"base and modulus are not relatively prime\");\n }\n\n let mut bb = b.clone();\n let mut ee = e.clone();\n let mut result = BigUint::one();\n while !ee.is_zero() {\n if ee.is_odd() {\n result = (result * &bb) % n;\n }\n ee >>= 1;\n bb = (&bb * &bb) % n;\n }\n Ok(result)\n}\n\nfn main() {\n let msg = \"Rosetta Code\";\n\n let n = \"9516311845790656153499716760847001433441357\"\n .parse()\n .unwrap();\n let e = \"65537\".parse().unwrap();\n let d = \"5617843187844953170308463622230283376298685\"\n .parse()\n .unwrap();\n\n let msg_int = BigUint::from_bytes_be(msg.as_bytes());\n let enc = mod_exp(&msg_int, &e, &n).unwrap();\n let dec = mod_exp(&enc, &d, &n).unwrap();\n let msg_dec = String::from_utf8(dec.to_bytes_be()).unwrap();\n\n println!(\"msg as txt: {}\", msg);\n println!(\"msg as num: {}\", msg_int);\n println!(\"enc as num: {}\", enc);\n println!(\"dec as num: {}\", dec);\n println!(\"dec as txt: {}\", msg_dec);\n}\n"} {"name":"Random number generator (device)","C":"#include <stdio.h>\n#include <stdlib.h>\n\n#define RANDOM_PATH \"\/dev\/urandom\"\n\nint main(void)\n{\n unsigned char buf[4];\n unsigned long v;\n FILE *fin;\n\n if ((fin = fopen(RANDOM_PATH, \"r\")) == NULL) {\n fprintf(stderr, \"%s: unable to open file\\n\", RANDOM_PATH);\n return EXIT_FAILURE;\n }\n if (fread(buf, 1, sizeof buf, fin) != sizeof buf) {\n fprintf(stderr, \"%s: not enough bytes (expected %u)\\n\",\n RANDOM_PATH, (unsigned) sizeof buf);\n return EXIT_FAILURE;\n }\n fclose(fin);\n v = buf[0] | buf[1] << 8UL | buf[2] << 16UL | buf[3] << 24UL;\n printf(\"%lu\\n\", v);\n return 0;\n}\n","Rust":"extern crate rand;\n\nuse rand::{OsRng, Rng};\n\nfn main() {\n \n let mut rng = match OsRng::new() {\n Ok(v) => v,\n Err(e) => panic!(\"Failed to obtain OS RNG: {}\", e)\n };\n\n let rand_num: u32 = rng.gen();\n println!(\"{}\", rand_num);\n}\n"} {"name":"Random numbers","C":"#include <stdlib.h>\n#include <math.h>\n#ifndef M_PI\n#define M_PI 3.14159265358979323846\n#endif\n\ndouble drand() \n{\n return (rand()+1.0)\/(RAND_MAX+1.0);\n}\ndouble random_normal() \n{\n return sqrt(-2*log(drand())) * cos(2*M_PI*drand());\n}\nint main()\n{\n int i;\n double rands[1000];\n for (i=0; i<1000; i++)\n rands[i] = 1.0 + 0.5*random_normal();\n return 0;\n}\n","Rust":"extern crate rand;\nuse rand::distributions::{Normal, IndependentSample};\n\nfn main() {\n let mut rands = [0.0; 1000];\n let normal = Normal::new(1.0, 0.5);\n let mut rng = rand::thread_rng();\n for num in rands.iter_mut() {\n *num = normal.ind_sample(&mut rng);\n }\n}\n"} {"name":"Range expansion","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <ctype.h>\n\n\n\nint get_list(const char *, char **);\nint get_rnge(const char *, char **);\n\n\nvoid add_number(int x);\nint add_range(int x, int y);\n\n#define skip_space while(isspace(*s)) s++\n#define get_number(x, s, e) (x = strtol(s, e, 10), *e\u00a0!= s)\nint get_list(const char *s, char **e)\n{\n\tint x;\n\twhile (1) {\n\t\tskip_space;\n\t\tif (!get_rnge(s, e) && !get_number(x, s, e)) break;\n\t\ts = *e;\n\n\t\tskip_space;\n\t\tif ((*s) == '\\0') { putchar('\\n'); return 1; }\n\t\tif ((*s) == ',') { s++; continue; }\n\t\tbreak;\n\t}\n\t*(const char **)e = s;\n\tprintf(\"\\nSyntax error at %s\\n\", s);\n\treturn 0;\n}\n\nint get_rnge(const char *s, char **e)\n{\n\tint x, y;\n\tchar *ee;\n\tif (!get_number(x, s, &ee)) return 0;\n\ts = ee;\n\n\tskip_space;\n\tif (*s != '-') {\n\t\t*(const char **)e = s;\n\t\treturn 0;\n\t}\n\ts++;\n\tif(!get_number(y, s, e)) return 0;\n\treturn add_range(x, y);\n}\n\nvoid add_number(int x)\n{\n\tprintf(\"%d \", x);\n}\n\nint add_range(int x, int y)\n{\n\tif (y <= x) return 0;\n\twhile (x <= y) printf(\"%d \", x++);\n\treturn 1;\n}\n\nint main()\n{\n\tchar *end;\n\n\t\n\tif (get_list(\"-6,-3--1,3-5,7-11,14,15,17-20\", &end)) puts(\"Ok\");\n\n\t\n\tget_list(\"-6 -3--1,3-5,7-11,14,15,17-20\", &end);\n\n\treturn 0;\n}\n","Rust":"use std::str::FromStr;\n\n\nfn range_expand(range : &str) -> Vec<i32> {\n range.split(',').flat_map(|item| {\n match i32::from_str(item) {\n Ok(n) => n..n+1,\n _ => {\n let dashpos=\n match item.rfind(\"--\") {\n Some(p) => p,\n None => item.rfind('-').unwrap(),\n };\n let rstart=i32::from_str(\n unsafe{ item.slice_unchecked(0,dashpos)} ).unwrap();\n let rend=i32::from_str(\n unsafe{ item.slice_unchecked(dashpos+1,item.len()) } ).unwrap();\n rstart..rend+1\n },\n }\n }).collect()\n}\n\nfn main() {\n println!(\"{:?}\", range_expand(\"-6,-3--1,3-5,7-11,14,15,17-20\"));\n}\n"} {"name":"Range extraction","C":"#include <stdio.h>\n#include <stdlib.h>\n\nsize_t rprint(char *s, int *x, int len)\n{\n#define sep (a > s\u00a0? \",\"\u00a0: \"\") \n#define ol (s\u00a0? 100\u00a0: 0) \n\tint i, j;\n\tchar *a = s;\n\tfor (i = j = 0; i < len; i = ++j) {\n\t\tfor (; j < len - 1 && x[j + 1] == x[j] + 1; j++);\n\n\t\tif (i + 1 < j)\n\t\t\ta += snprintf(s?a:s, ol, \"%s%d-%d\", sep, x[i], x[j]);\n\t\telse\n\t\t\twhile (i <= j)\n\t\t\t\ta += snprintf(s?a:s, ol, \"%s%d\", sep, x[i++]);\n\t}\n\treturn a - s;\n#undef sep\n#undef ol\n}\n\nint main()\n{\n\tint x[] = {\t0, 1, 2, 4, 6, 7, 8, 11, 12, 14,\n\t\t\t15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n\t\t\t25, 27, 28, 29, 30, 31, 32, 33, 35, 36,\n\t\t\t37, 38, 39 };\n\n\tchar *s = malloc(rprint(0, x, sizeof(x) \/ sizeof(int)) + 1);\n\trprint(s, x, sizeof(x) \/ sizeof(int));\n\tprintf(\"%s\\n\", s);\n\n\treturn 0;\n}\n","Rust":"use std::ops::Add;\n \nstruct RangeFinder<'a, T: 'a> {\n index: usize,\n length: usize,\n arr: &'a [T],\n}\n \nimpl<'a, T> Iterator for RangeFinder<'a, T> where T: PartialEq + Add<i8, Output=T> + Copy {\n type Item = (T, Option<T>);\n fn next(&mut self) -> Option<Self::Item> {\n if self.index == self.length {\n return None;\n }\n let lo = self.index;\n while self.index < self.length - 1 && self.arr[self.index + 1] == self.arr[self.index] + 1 {\n self.index += 1\n }\n let hi = self.index;\n self.index += 1;\n if hi - lo > 1 {\n Some((self.arr[lo], Some(self.arr[hi])))\n } else {\n if hi - lo == 1 {\n self.index -= 1\n }\n Some((self.arr[lo], None))\n }\n }\n}\n \nimpl<'a, T> RangeFinder<'a, T> {\n fn new(a: &'a [T]) -> Self {\n RangeFinder {\n index: 0,\n arr: a,\n length: a.len(),\n }\n }\n}\n\nfn main() {\n let input_numbers : &[i8] = &[0, 1, 2, 4, 6, 7, 8, 11, 12, 14,\n 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 27, 28, 29, 30, 31, 32, 33, 35, 36,\n 37, 38, 39];\n for (i, (lo, hi)) in RangeFinder::new(&input_numbers).enumerate() {\n if i > 0 {print!(\",\")}\n print!(\"{}\", lo);\n if hi.is_some() {print!(\"-{}\", hi.unwrap())}\n }\n println!(\"\");\n}\n"} {"name":"Read a file line by line","C":"\n\n#include <conio.h>\n#include <stdio.h>\n\nint main()\n{\n int n1, n2, n3;\n\n printf( \"\\n Introduzca el primer n%cmero (entero): \", 163 );\n scanf( \"%d\", &n1 );\n printf( \"\\n Introduzca el segundo n%cmero (entero): \", 163 );\n scanf( \"%d\", &n2 );\n printf( \"\\n Introduzca el tercer n%cmero (entero): \", 163 );\n scanf( \"%d\", &n3 );\n\n if ( n1 >= n2 && n1 >= n3 )\n printf( \"\\n %d es el mayor.\", n1 );\n else\n\n if ( n2 > n3 )\n printf( \"\\n %d es el mayor.\", n2 );\n else\n printf( \"\\n %d es el mayor.\", n3 );\n \n getch(); \n\n return 0;\n}\n","Rust":"use std::io::{BufReader,BufRead};\nuse std::fs::File;\n\nfn main() {\n let file = File::open(\"file.txt\").unwrap();\n for line in BufReader::new(file).lines() {\n println!(\"{}\", line.unwrap());\n }\n}\n"} {"name":"Read entire file","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint main()\n{\n char *buffer;\n FILE *fh = fopen(\"readentirefile.c\", \"rb\");\n if ( fh != NULL )\n {\n fseek(fh, 0L, SEEK_END);\n long s = ftell(fh);\n rewind(fh);\n buffer = malloc(s);\n if ( buffer != NULL )\n {\n fread(buffer, s, 1, fh);\n \n fclose(fh); fh = NULL;\n \n \n fwrite(buffer, s, 1, stdout);\n\n free(buffer);\n }\n if (fh != NULL) fclose(fh);\n }\n return EXIT_SUCCESS;\n}\n","Rust":"use std::fs::File;\nuse std::io::Read;\n\nfn main() {\n let mut file = File::open(\"somefile.txt\").unwrap();\n\n let mut contents: Vec<u8> = Vec::new();\n \n let result = file.read_to_end(&mut contents).unwrap();\n println!(\"Read {} bytes\", result);\n\n \n let filestr = String::from_utf8(contents).unwrap();\n println!(\"{}\", filestr);\n}\n"} {"name":"Real constants and functions","C":"#include <math.h>\n\nM_E; \nM_PI; \nsqrt(x); \nlog(x); \nexp(x); \nabs(x); \nfabs(x); \nfloor(x); \nceil(x); \npow(x,y); \n","Rust":"use std::f64::consts::*;\n\nfn main() {\n \n let mut x = E;\n \n x += PI;\n \n x = x.sqrt();\n \n x = x.ln();\n \n x = x.ceil();\n \n x = x.exp();\n \n x = x.abs();\n \n x = x.floor();\n \n x = x.powf(x);\n\n assert_eq!(x, 4.0);\n}\n"} {"name":"Reduced row echelon form","C":"#include <stdio.h>\n#define TALLOC(n,typ) malloc(n*sizeof(typ))\n\n#define EL_Type int\n\ntypedef struct sMtx {\n int dim_x, dim_y;\n EL_Type *m_stor;\n EL_Type **mtx;\n} *Matrix, sMatrix;\n\ntypedef struct sRvec {\n int dim_x;\n EL_Type *m_stor;\n} *RowVec, sRowVec;\n\nMatrix NewMatrix( int x_dim, int y_dim )\n{\n int n;\n Matrix m;\n m = TALLOC( 1, sMatrix);\n n = x_dim * y_dim;\n m->dim_x = x_dim;\n m->dim_y = y_dim;\n m->m_stor = TALLOC(n, EL_Type);\n m->mtx = TALLOC(m->dim_y, EL_Type *);\n for(n=0; n<y_dim; n++) {\n m->mtx[n] = m->m_stor+n*x_dim;\n }\n return m;\n}\n\nvoid MtxSetRow(Matrix m, int irow, EL_Type *v)\n{\n int ix;\n EL_Type *mr;\n mr = m->mtx[irow];\n for(ix=0; ix<m->dim_x; ix++)\n mr[ix] = v[ix];\n}\n\nMatrix InitMatrix( int x_dim, int y_dim, EL_Type **v)\n{\n Matrix m;\n int iy;\n m = NewMatrix(x_dim, y_dim);\n for (iy=0; iy<y_dim; iy++) \n MtxSetRow(m, iy, v[iy]);\n return m;\n}\n\nvoid MtxDisplay( Matrix m )\n{\n int iy, ix;\n const char *sc;\n for (iy=0; iy<m->dim_y; iy++) {\n printf(\" \");\n sc = \" \";\n for (ix=0; ix<m->dim_x; ix++) {\n printf(\"%s %3d\", sc, m->mtx[iy][ix]);\n sc = \",\";\n }\n printf(\"\\n\");\n }\n printf(\"\\n\");\n}\n\nvoid MtxMulAndAddRows(Matrix m, int ixrdest, int ixrsrc, EL_Type mplr)\n{\n int ix;\n EL_Type *drow, *srow;\n drow = m->mtx[ixrdest];\n srow = m->mtx[ixrsrc];\n for (ix=0; ix<m->dim_x; ix++) \n drow[ix] += mplr * srow[ix];\n\n\n}\n\nvoid MtxSwapRows( Matrix m, int rix1, int rix2)\n{\n EL_Type *r1, *r2, temp;\n int ix;\n if (rix1 == rix2) return;\n r1 = m->mtx[rix1];\n r2 = m->mtx[rix2];\n for (ix=0; ix<m->dim_x; ix++)\n temp = r1[ix]; r1[ix]=r2[ix]; r2[ix]=temp;\n\n\n}\n\nvoid MtxNormalizeRow( Matrix m, int rix, int lead)\n{\n int ix;\n EL_Type *drow;\n EL_Type lv;\n drow = m->mtx[rix];\n lv = drow[lead];\n for (ix=0; ix<m->dim_x; ix++)\n drow[ix] \/= lv;\n\n\n}\n\n#define MtxGet( m, rix, cix ) m->mtx[rix][cix]\n\nvoid MtxToReducedREForm(Matrix m)\n{\n int lead;\n int rix, iix;\n EL_Type lv;\n int rowCount = m->dim_y;\n\n lead = 0;\n for (rix=0; rix<rowCount; rix++) {\n if (lead >= m->dim_x)\n return;\n iix = rix;\n while (0 == MtxGet(m, iix,lead)) {\n iix++;\n if (iix == rowCount) {\n iix = rix;\n lead++;\n if (lead == m->dim_x)\n return;\n }\n }\n MtxSwapRows(m, iix, rix );\n MtxNormalizeRow(m, rix, lead );\n for (iix=0; iix<rowCount; iix++) {\n if ( iix != rix ) {\n lv = MtxGet(m, iix, lead );\n MtxMulAndAddRows(m,iix, rix, -lv) ;\n }\n }\n lead++;\n }\n}\n\nint main()\n{\n Matrix m1;\n static EL_Type r1[] = {1,2,-1,-4};\n static EL_Type r2[] = {2,3,-1,-11};\n static EL_Type r3[] = {-2,0,-3,22};\n static EL_Type *im[] = { r1, r2, r3 };\n\n m1 = InitMatrix( 4,3, im );\n printf(\"Initial\\n\");\n MtxDisplay(m1);\n MtxToReducedREForm(m1);\n printf(\"Reduced R-E form\\n\");\n MtxDisplay(m1);\n return 0;\n}\n","Rust":"fn main() {\n let mut matrix_to_reduce: Vec<Vec<f64>> = vec![vec![1.0, 2.0 , -1.0, -4.0], \n vec![2.0, 3.0, -1.0, -11.0],\n vec![-2.0, 0.0, -3.0, 22.0]];\n let mut r_mat_to_red = &mut matrix_to_reduce;\n let rr_mat_to_red = &mut r_mat_to_red;\n\n println!(\"Matrix to reduce:\\n{:?}\", rr_mat_to_red);\n let reduced_matrix = reduced_row_echelon_form(rr_mat_to_red);\n println!(\"Reduced matrix:\\n{:?}\", reduced_matrix);\n}\n\nfn reduced_row_echelon_form(matrix: &mut Vec<Vec<f64>>) -> Vec<Vec<f64>> {\n let mut matrix_out: Vec<Vec<f64>> = matrix.to_vec();\n let mut pivot = 0;\n let row_count = matrix_out.len();\n let column_count = matrix_out[0].len();\n \n 'outer: for r in 0..row_count {\n if column_count <= pivot {\n break;\n }\n let mut i = r;\n while matrix_out[i][pivot] == 0.0 {\n i = i+1;\n if i == row_count {\n i = r;\n pivot = pivot + 1;\n if column_count == pivot {\n pivot = pivot - 1;\n break 'outer;\n }\n }\n }\n for j in 0..row_count {\n let temp = matrix_out[r][j];\n matrix_out[r][j] = matrix_out[i][j];\n matrix_out[i][j] = temp;\n }\n let divisor = matrix_out[r][pivot];\n if divisor != 0.0 {\n for j in 0..column_count {\n matrix_out[r][j] = matrix_out[r][j] \/ divisor;\n }\n }\n for j in 0..row_count {\n if j != r {\n let hold = matrix_out[j][pivot];\n for k in 0..column_count {\n matrix_out[j][k] = matrix_out[j][k] - ( hold * matrix_out[r][k]);\n }\n }\n }\n pivot = pivot + 1;\n }\n matrix_out\n}\n"} {"name":"Regular expressions","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <sys\/types.h>\n#include <regex.h>\n#include <string.h>\n\nint main()\n{\n regex_t preg;\n regmatch_t substmatch[1];\n const char *tp = \"string$\";\n const char *t1 = \"this is a matching string\";\n const char *t2 = \"this is not a matching string!\";\n const char *ss = \"istyfied\";\n \n regcomp(&preg, \"string$\", REG_EXTENDED);\n printf(\"'%s' %smatched with '%s'\\n\", t1,\n (regexec(&preg, t1, 0, NULL, 0)==0) ? \"\" : \"did not \", tp);\n printf(\"'%s' %smatched with '%s'\\n\", t2,\n (regexec(&preg, t2, 0, NULL, 0)==0) ? \"\" : \"did not \", tp);\n regfree(&preg);\n \n regcomp(&preg, \"a[a-z]+\", REG_EXTENDED);\n if ( regexec(&preg, t1, 1, substmatch, 0) == 0 )\n {\n \n char *ns = malloc(substmatch[0].rm_so + 1 + strlen(ss) +\n (strlen(t1) - substmatch[0].rm_eo) + 2);\n memcpy(ns, t1, substmatch[0].rm_so+1);\n memcpy(&ns[substmatch[0].rm_so], ss, strlen(ss));\n memcpy(&ns[substmatch[0].rm_so+strlen(ss)], &t1[substmatch[0].rm_eo],\n strlen(&t1[substmatch[0].rm_eo]));\n ns[ substmatch[0].rm_so + strlen(ss) +\n strlen(&t1[substmatch[0].rm_eo]) ] = 0;\n printf(\"mod string: '%s'\\n\", ns);\n free(ns); \n } else {\n printf(\"the string '%s' is the same: no matching!\\n\", t1);\n }\n regfree(&preg);\n \n return 0;\n}\n","Rust":"use regex::Regex;\n\nfn main() {\n let s = \"I am a string\";\n\n if Regex::new(\"string$\").unwrap().is_match(s) {\n println!(\"Ends with string.\");\n }\n\n println!(\"{}\", Regex::new(\" a \").unwrap().replace(s, \" another \"));\n}\n"} {"name":"Remove duplicate elements","C":"#include <stdio.h>\n#include <stdlib.h>\n\nstruct list_node {int x; struct list_node *next;};\ntypedef struct list_node node;\n\nnode * uniq(int *a, unsigned alen)\n {if (alen == 0) return NULL;\n node *start = malloc(sizeof(node));\n if (start == NULL) exit(EXIT_FAILURE);\n start->x = a[0];\n start->next = NULL;\n\n for (int i = 1 ; i < alen ; ++i)\n {node *n = start;\n for (;; n = n->next)\n {if (a[i] == n->x) break;\n if (n->next == NULL)\n {n->next = malloc(sizeof(node));\n n = n->next;\n if (n == NULL) exit(EXIT_FAILURE);\n n->x = a[i];\n n->next = NULL;\n break;}}}\n\n return start;}\n\nint main(void)\n {int a[] = {1, 2, 1, 4, 5, 2, 15, 1, 3, 4};\n for (node *n = uniq(a, 10) ; n != NULL ; n = n->next)\n printf(\"%d \", n->x);\n puts(\"\");\n return 0;}\n","Rust":"use std::collections::HashSet;\nuse std::hash::Hash;\n\nfn remove_duplicate_elements_hashing<T: Hash + Eq>(elements: &mut Vec<T>) {\n let set: HashSet<_> = elements.drain(..).collect();\n elements.extend(set.into_iter());\n}\n\nfn remove_duplicate_elements_sorting<T: Ord>(elements: &mut Vec<T>) {\n elements.sort_unstable(); \n elements.dedup();\n}\n\nfn main() {\n let mut sample_elements = vec![0, 0, 1, 1, 2, 3, 2];\n println!(\"Before removal of duplicates\u00a0: {:?}\", sample_elements);\n remove_duplicate_elements_sorting(&mut sample_elements);\n println!(\"After removal of duplicates\u00a0: {:?}\", sample_elements);\n}\n"} {"name":"Remove lines from a file","C":"#include <stdio.h>\n#include <stdlib.h> \n#include <string.h> \n\n\n#define ERROR(fmt, arg) return fprintf(stderr, fmt \"\\n\", arg)\n\nint main(int argc, char **argv)\n{\n FILE *fp;\n char *buf;\n size_t sz;\n int start, count, lines = 1;\n int dest = 0, src = 0, pos = -1;\n\n \n if (argc != 4)\n ERROR(\"Usage: %s <file> <start> <count>\", argv[0]);\n\n if ((count = atoi(argv[3])) < 1) \n return 0;\n\n if ((start = atoi(argv[2])) < 1)\n ERROR(\"Error: <start> (%d) must be positive\", start);\n\n if ((fp = fopen(argv[1], \"r\")) == NULL)\n ERROR(\"No such file: %s\", argv[1]);\n\n \n fseek(fp, 0, SEEK_END);\n sz = ftell(fp);\n buf = malloc(sz + 1);\n rewind(fp);\n\n \n while ((buf[++pos] = fgetc(fp)) != EOF) {\n if (buf[pos] == '\\n') {\n ++lines;\n if (lines == start) dest = pos + 1;\n if (lines == start + count) src = pos + 1;\n }\n }\n\n \n if (start + count > lines) {\n free(buf);\n fclose(fp);\n ERROR(\"Error: invalid parameters for file with %d lines\", --lines);\n }\n\n \n memmove(buf + dest, buf + src, pos - src);\n\n \n freopen(argv[1], \"w\", fp);\n fwrite(buf, pos - src + dest, 1, fp);\n\n free(buf);\n fclose(fp);\n return 0;\n}\n","Rust":"extern crate rustc_serialize;\nextern crate docopt;\n\nuse docopt::Docopt;\n\nuse std::io::{BufReader,BufRead};\nuse std::fs::File;\n\nconst USAGE: &'static str = \"\nUsage: rosetta <start> <count> <file>\n\";\n\n#[derive(Debug, RustcDecodable)]\nstruct Args {\n arg_start: usize,\n arg_count: usize,\n arg_file: String,\n}\n\nfn main() {\n let args: Args = Docopt::new(USAGE)\n .and_then(|d| d.decode())\n .unwrap_or_else(|e| e.exit());\n\n let file = BufReader::new(File::open(args.arg_file).unwrap());\n\n for (i, line) in file.lines().enumerate() {\n let cur = i + 1;\n\n if cur < args.arg_start || cur >= (args.arg_start + args.arg_count) {\n println!(\"{}\", line.unwrap());\n }\n }\n}\n"} {"name":"Remove vowels from a string","C":"#include <stdio.h>\n\nvoid print_no_vowels(const char *s) {\n for (; *s != 0; s++) {\n switch (*s) {\n case 'A':\n case 'E':\n case 'I':\n case 'O':\n case 'U':\n case 'a':\n case 'e':\n case 'i':\n case 'o':\n case 'u':\n break;\n default:\n putchar(*s);\n break;\n }\n }\n}\n\nvoid test(const char *const s) {\n printf(\"Input \u00a0: %s\\n\", s);\n\n printf(\"Output\u00a0: \");\n print_no_vowels(s);\n printf(\"\\n\");\n}\n\nint main() {\n test(\"C Programming Language\");\n return 0;\n}\n","Rust":"fn remove_vowels(str: String) -> String {\n let vowels = \"aeiouAEIOU\";\n let mut devowelled_string = String::from(\"\");\n\n for i in str.chars() {\n if vowels.contains(i) {\n continue;\n } else {\n devowelled_string.push(i);\n }\n }\n return devowelled_string;\n}\n\nfn main() {\n let intro =\n String::from(\"Ferris, the crab, is the unofficial mascot of the Rust Programming Language\");\n println!(\"{}\", intro);\n println!(\"{}\", remove_vowels(intro));\n}\n"} {"name":"Rename a file","C":"#include <stdio.h>\n\nint main()\n{\n rename(\"input.txt\", \"output.txt\");\n rename(\"docs\", \"mydocs\");\n rename(\"\/input.txt\", \"\/output.txt\");\n rename(\"\/docs\", \"\/mydocs\");\n return 0;\n}\n","Rust":"use std::fs;\n\nfn main() {\n let err = \"File move error\";\n fs::rename(\"input.txt\", \"output.txt\").ok().expect(err);\n fs::rename(\"docs\", \"mydocs\").ok().expect(err);\n fs::rename(\"\/input.txt\", \"\/output.txt\").ok().expect(err);\n fs::rename(\"\/docs\", \"\/mydocs\").ok().expect(err);\n}\n"} {"name":"Repeat","C":"#include <stdio.h>\n\nvoid repeat(void (*f)(void), unsigned int n) {\n while (n-->0)\n (*f)(); \n}\n\nvoid example() {\n printf(\"Example\\n\");\n}\n\nint main(int argc, char *argv[]) {\n repeat(example, 4);\n return 0;\n}\n","Rust":"fn repeat(f: impl FnMut(usize), n: usize) {\n (0..n).for_each(f);\n}\n"} {"name":"Repeat a string","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nchar * string_repeat( int n, const char * s ) {\n size_t slen = strlen(s);\n char * dest = malloc(n*slen+1);\n\n int i; char * p;\n for ( i=0, p = dest; i < n; ++i, p += slen ) {\n memcpy(p, s, slen);\n }\n *p = '\\0';\n return dest;\n}\n\nint main() {\n char * result = string_repeat(5, \"ha\");\n puts(result);\n free(result);\n return 0;\n}\n","Rust":"std::iter::repeat(\"ha\").take(5).collect::<String>(); \n"} {"name":"Reverse a string","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <locale.h>\n#include <wchar.h>\n\nconst char *sa = \"abcdef\";\nconst char *su = \"as\u20dddf\u0305\"; \n\nint is_comb(wchar_t c)\n{\n\tif (c >= 0x300 && c <= 0x36f) return 1;\n\tif (c >= 0x1dc0 && c <= 0x1dff) return 1;\n\tif (c >= 0x20d0 && c <= 0x20ff) return 1;\n\tif (c >= 0xfe20 && c <= 0xfe2f) return 1;\n\treturn 0;\n}\n\nwchar_t* mb_to_wchar(const char *s)\n{\n\twchar_t *u;\n\tsize_t len = mbstowcs(0, s, 0) + 1;\n\tif (!len) return 0;\n\n\tu = malloc(sizeof(wchar_t) * len);\n\tmbstowcs(u, s, len);\n\treturn u;\n}\n\nwchar_t* ws_reverse(const wchar_t* u)\n{\n\tsize_t len, i, j;\n\twchar_t *out;\n\tfor (len = 0; u[len]; len++);\n\tout = malloc(sizeof(wchar_t) * (len + 1));\n\tout[len] = 0;\n\tj = 0;\n\twhile (len) {\n\t\tfor (i = len - 1; i && is_comb(u[i]); i--);\n\t\twcsncpy(out + j, u + i, len - i);\n\t\tj += len - i;\n\t\tlen = i;\n\t}\n\treturn out;\n}\n\nchar *mb_reverse(const char *in)\n{\n\tsize_t len;\n\tchar *out;\n\twchar_t *u = mb_to_wchar(in);\n\twchar_t *r = ws_reverse(u);\n\tlen = wcstombs(0, r, 0) + 1;\n\tout = malloc(len);\n\twcstombs(out, r, len);\n\tfree(u);\n\tfree(r);\n\treturn out;\n}\n\nint main(void)\n{\n\tsetlocale(LC_CTYPE, \"\");\n\n\tprintf(\"%s => %s\\n\", sa, mb_reverse(sa));\n\tprintf(\"%s => %s\\n\", su, mb_reverse(su));\n\treturn 0;\n}\n","Rust":"let mut buffer = b\"abcdef\".to_vec();\nbuffer.reverse();\nassert_eq!(buffer, b\"fedcba\");\n"} {"name":"Reverse words in a string","C":"#include <stdio.h>\n#include <ctype.h>\n\nvoid rev_print(char *s, int n)\n{\n for (; *s && isspace(*s); s++);\n if (*s) {\n char *e;\n for (e = s; *e && !isspace(*e); e++);\n rev_print(e, 0);\n printf(\"%.*s%s\", (int)(e - s), s, \" \" + n);\n }\n if (n) putchar('\\n');\n}\n\nint main(void)\n{\n char *s[] = {\n \"---------- Ice and Fire ------------\",\n \" \",\n \"fire, in end will world the say Some\",\n \"ice. in say Some \",\n \"desire of tasted I've what From \",\n \"fire. favor who those with hold I \",\n \" \",\n \"... elided paragraph last ... \",\n \" \",\n \"Frost Robert -----------------------\",\n 0\n };\n int i;\n for (i = 0; s[i]; i++) rev_print(s[i], 1);\n\n return 0;\n}\n","Rust":"const TEXT: &'static str = \n\"---------- Ice and Fire ------------\n \nfire, in end will world the say Some\nice. in say Some\ndesire of tasted I've what From\nfire. favor who those with hold I\n \n... elided paragraph last ...\n \nFrost Robert -----------------------\";\n \nfn main() {\n println!(\"{}\", \n TEXT.lines() \n .map(|line| \n line.split_whitespace() \n .rev() \n .collect::<Vec<_>>() \n .join(\" \")) \n .collect::<Vec<_>>() \n .join(\"\\n\")); \n}\n"} {"name":"Roman numerals_Decode","C":"#include <stdio.h>\n\nint digits[26] = { 0, 0, 100, 500, 0, 0, 0, 0, 1, 1, 0, 50, 1000, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 10, 0, 0 };\n\n\n#define VALUE(x) digits[(~0x20 & (x)) - 'A']\n\nint decode(const char * roman)\n{\n const char *bigger;\n int current;\n int arabic = 0;\n while (*roman != '\\0') {\n current = VALUE(*roman);\n \n bigger = roman;\n\n \n while (VALUE(*bigger) <= current && *++bigger != '\\0');\n\n if (*bigger == '\\0')\n arabic += current;\n else {\n arabic += VALUE(*bigger);\n while (roman < bigger)\n arabic -= VALUE(* (roman++) );\n }\n\n roman ++;\n }\n return arabic;\n}\n\nint main()\n{\n const char * romans[] = { \"MCmxC\", \"MMVIII\", \"MDClXVI\", \"MCXLUJ\" };\n int i;\n\n for (i = 0; i < 4; i++)\n printf(\"%s\\t%d\\n\", romans[i], decode(romans[i]));\n\n return 0;\n}\n","Rust":"struct RomanNumeral {\n symbol: &'static str,\n value: u32\n}\n\nconst NUMERALS: [RomanNumeral; 13] = [\n RomanNumeral {symbol: \"M\", value: 1000},\n RomanNumeral {symbol: \"CM\", value: 900},\n RomanNumeral {symbol: \"D\", value: 500},\n RomanNumeral {symbol: \"CD\", value: 400},\n RomanNumeral {symbol: \"C\", value: 100},\n RomanNumeral {symbol: \"XC\", value: 90},\n RomanNumeral {symbol: \"L\", value: 50},\n RomanNumeral {symbol: \"XL\", value: 40},\n RomanNumeral {symbol: \"X\", value: 10},\n RomanNumeral {symbol: \"IX\", value: 9},\n RomanNumeral {symbol: \"V\", value: 5},\n RomanNumeral {symbol: \"IV\", value: 4},\n RomanNumeral {symbol: \"I\", value: 1}\n];\n\nfn to_hindu(roman: &str) -> u32 {\n match NUMERALS.iter().find(|num| roman.starts_with(num.symbol)) {\n Some(num) => num.value + to_hindu(&roman[num.symbol.len()..]),\n None => 0, \n }\n}\n\nfn main() {\n let roms = [\"MMXIV\", \"MCMXCIX\", \"XXV\", \"MDCLXVI\", \"MMMDCCCLXXXVIII\"];\n for &r in &roms {\n \n println!(\"{:2$} = {}\", r, to_hindu(r), 15);\n }\n}\n"} {"name":"Roman numerals_Encode","C":"#include <stdio.h>\n\n\nint main() {\n int arabic[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};\n\n \n \n \n char roman[13][3] = {\"M\\0\", \"CM\\0\", \"D\\0\", \"CD\\0\", \"C\\0\", \"XC\\0\", \"L\\0\", \"XL\\0\", \"X\\0\", \"IX\\0\", \"V\\0\", \"IV\\0\", \"I\\0\"};\n int N;\n\n printf(\"Enter arabic number:\\n\");\n scanf(\"%d\", &N);\n printf(\"\\nRoman number:\\n\");\n\n for (int i = 0; i < 13; i++) {\n while (N >= arabic[i]) {\n printf(\"%s\", roman[i]);\n N -= arabic[i];\n }\n }\n return 0;\n}\n","Rust":"struct RomanNumeral {\n symbol: &'static str,\n value: u32\n}\n\nconst NUMERALS: [RomanNumeral; 13] = [\n RomanNumeral {symbol: \"M\", value: 1000},\n RomanNumeral {symbol: \"CM\", value: 900},\n RomanNumeral {symbol: \"D\", value: 500},\n RomanNumeral {symbol: \"CD\", value: 400},\n RomanNumeral {symbol: \"C\", value: 100},\n RomanNumeral {symbol: \"XC\", value: 90},\n RomanNumeral {symbol: \"L\", value: 50},\n RomanNumeral {symbol: \"XL\", value: 40},\n RomanNumeral {symbol: \"X\", value: 10},\n RomanNumeral {symbol: \"IX\", value: 9},\n RomanNumeral {symbol: \"V\", value: 5},\n RomanNumeral {symbol: \"IV\", value: 4},\n RomanNumeral {symbol: \"I\", value: 1}\n];\n\nfn to_roman(mut number: u32) -> String {\n let mut min_numeral = String::new();\n for numeral in NUMERALS.iter() {\n while numeral.value <= number {\n min_numeral = min_numeral + numeral.symbol;\n number -= numeral.value;\n }\n }\n min_numeral\n}\n\nfn main() {\n let nums = [2014, 1999, 25, 1666, 3888];\n for &n in nums.iter() {\n \n println!(\"{:2$} = {}\", n, to_roman(n), 4);\n }\n}\n"} {"name":"Roots of a function","C":"#include <math.h>\n#include <stdio.h>\n\ndouble f(double x)\n{\n return x*x*x-3.0*x*x +2.0*x;\n}\n\ndouble secant( double xA, double xB, double(*f)(double) )\n{\n double e = 1.0e-12;\n double fA, fB;\n double d;\n int i;\n int limit = 50;\n\n fA=(*f)(xA);\n for (i=0; i<limit; i++) {\n fB=(*f)(xB);\n d = (xB - xA) \/ (fB - fA) * fB;\n if (fabs(d) < e) \n break;\n xA = xB;\n fA = fB;\n xB -= d;\n }\n if (i==limit) {\n printf(\"Function is not converging near (%7.4f,%7.4f).\\n\", xA,xB);\n return -99.0;\n }\n return xB;\n}\n\nint main(int argc, char *argv[])\n{\n double step = 1.0e-2;\n double e = 1.0e-12;\n double x = -1.032;\t\t\n double xx, value;\n\n int s = (f(x)> 0.0);\n\n while (x < 3.0) {\n value = f(x);\n if (fabs(value) < e) {\n printf(\"Root found at x= %12.9f\\n\", x);\n s = (f(x+.0001)>0.0);\n }\n else if ((value > 0.0) != s) {\n xx = secant(x-step, x,&f);\n if (xx != -99.0) \n printf(\"Root found at x= %12.9f\\n\", xx);\n else\n printf(\"Root found near x= %7.4f\\n\", x);\n s = (f(x+.0001)>0.0);\n }\n x += step;\n }\n return 0;\n}\n","Rust":"\n\nuse roots::find_roots_cubic;\n\nfn main() {\n\n let roots = find_roots_cubic(1f32, -3f32, 2f32, 0f32);\n\n println!(\"Result\u00a0: {:?}\", roots);\n}\n"} {"name":"Roots of unity","C":"#include <stdio.h>\n#include <math.h>\n\nint main()\n{\n\tdouble a, c, s, PI2 = atan2(1, 1) * 8;\n\tint n, i;\n\n\tfor (n = 1; n < 10; n++) for (i = 0; i < n; i++) {\n\t\tc = s = 0;\n\t\tif (!i )\t\tc = 1;\n\t\telse if(n == 4 * i)\ts = 1;\n\t\telse if(n == 2 * i)\tc = -1;\n\t\telse if(3 * n == 4 * i)\ts = -1;\n\t\telse\n\t\t\ta = i * PI2 \/ n, c = cos(a), s = sin(a);\n\n\t\tif (c) printf(\"%.2g\", c);\n\t\tprintf(s == 1 ? \"i\" : s == -1 ? \"-i\" : s ? \"%+.2gi\" : \"\", s);\n\t\tprintf(i == n - 1 ?\"\\n\":\", \");\n\t}\n\n\treturn 0;\n}\n","Rust":"use num::Complex;\nfn main() {\n let n = 8;\n let z = Complex::from_polar(&1.0,&(1.0*std::f64::consts::PI\/n as f64));\n for k in 0..=n-1 {\n println!(\"e^{:2}\u03c0i\/{} \u2248 {:>14.3}\",2*k,n,z.powf(2.0*k as f64));\n }\n}\n"} {"name":"Rosetta Code_Count examples","C":"\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <curl\/curl.h>\n#include \"wren.h\"\n\nstruct MemoryStruct {\n char *memory;\n size_t size;\n};\n\n\n\nstatic size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {\n size_t realsize = size * nmemb;\n struct MemoryStruct *mem = (struct MemoryStruct *)userp;\n \n char *ptr = realloc(mem->memory, mem->size + realsize + 1);\n if(!ptr) {\n \n printf(\"not enough memory (realloc returned NULL)\\n\");\n return 0;\n }\n\n mem->memory = ptr;\n memcpy(&(mem->memory[mem->size]), contents, realsize);\n mem->size += realsize;\n mem->memory[mem->size] = 0;\n return realsize;\n}\n\nvoid C_bufferAllocate(WrenVM* vm) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct MemoryStruct));\n ms->memory = malloc(1);\n ms->size = 0;\n}\n\nvoid C_bufferFinalize(void* data) {\n struct MemoryStruct *ms = (struct MemoryStruct *)data;\n free(ms->memory);\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_value(WrenVM* vm) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenGetSlotForeign(vm, 0);\n wrenSetSlotString(vm, 0, ms->memory);\n}\n\nvoid C_easyPerform(WrenVM* vm) {\n CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);\n curl_easy_perform(curl);\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 if (opt < 10000) {\n long lparam = (long)wrenGetSlotDouble(vm, 2);\n curl_easy_setopt(curl, opt, lparam);\n } else if (opt < 20000) {\n if (opt == CURLOPT_WRITEDATA) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenGetSlotForeign(vm, 2);\n curl_easy_setopt(curl, opt, (void *)ms);\n } else if (opt == CURLOPT_URL) {\n const char *url = wrenGetSlotString(vm, 2);\n curl_easy_setopt(curl, opt, url);\n }\n } else if (opt < 30000) {\n if (opt == CURLOPT_WRITEFUNCTION) {\n curl_easy_setopt(curl, opt, &WriteMemoryCallback);\n }\n }\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, \"Buffer\") == 0) {\n methods.allocate = C_bufferAllocate;\n methods.finalize = C_bufferFinalize;\n } else 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, \"Buffer\") == 0) {\n if (!isStatic && strcmp(signature, \"value\") == 0) return C_value;\n } else 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\nstatic void loadModuleComplete(WrenVM* vm, const char* module, WrenLoadModuleResult result) {\n if( result.source) free((void*)result.source);\n}\n\nWrenLoadModuleResult loadModule(WrenVM* vm, const char* name) {\n WrenLoadModuleResult result = {0};\n if (strcmp(name, \"random\") != 0 && strcmp(name, \"meta\") != 0) {\n result.onComplete = loadModuleComplete;\n char fullName[strlen(name) + 6];\n strcpy(fullName, name);\n strcat(fullName, \".wren\");\n result.source = readFile(fullName);\n }\n return result;\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 config.loadModuleFn = &loadModule;\n WrenVM* vm = wrenNewVM(&config);\n const char* module = \"main\";\n const char* fileName = \"rc_count_examples.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":"extern crate reqwest;\nextern crate url;\nextern crate rustc_serialize;\n\nuse std::io::Read;\nuse self::url::Url;\nuse rustc_serialize::json::{self, Json};\n\npub struct Task {\n page_id: u64,\n pub title: String,\n}\n\n#[derive(Debug)]\nenum ParseError {\n \n Http(reqwest::Error),\n\n \n Json(json::ParserError),\n\n \n UnexpectedFormat,\n}\nimpl From<json::ParserError> for ParseError {\n fn from(error: json::ParserError) -> Self {\n ParseError::Json(error)\n }\n}\n\nimpl From<reqwest::Error> for ParseError {\n fn from(error: reqwest::Error) -> Self {\n ParseError::Http(error)\n }\n}\n\n\nfn construct_query_category(category: &str) -> Url {\n let mut base_url = Url::parse(\"http:\n let cat = format!(\"Category:{}\", category);\n let query_pairs = vec![(\"action\", \"query\"),\n (\"format\", \"json\"),\n (\"list\", \"categorymembers\"),\n (\"cmlimit\", \"500\"),\n (\"cmtitle\", &cat),\n (\"continue\", \"\")];\n base_url.query_pairs_mut().extend_pairs(query_pairs.into_iter());\n base_url\n}\n\nfn construct_query_task_content(task_id: &str) -> Url {\n let mut base_url = Url::parse(\"http:\n let mut query_pairs =\n vec![(\"action\", \"query\"), (\"format\", \"json\"), (\"prop\", \"revisions\"), (\"rvprop\", \"content\")];\n query_pairs.push((\"pageids\", task_id));\n base_url.query_pairs_mut().extend_pairs(query_pairs.into_iter());\n base_url\n}\n\nfn query_api(url: Url) -> Result<Json, ParseError> {\n let mut response = try!(reqwest::get(url.as_str()));\n \n let mut body = String::new();\n response.read_to_string(&mut body).unwrap();\n\n Ok(try!(Json::from_str(&body)))\n}\n\nfn parse_all_tasks(reply: &Json) -> Result<Vec<Task>, ParseError> {\n let json_to_task = |json: &Json| -> Result<Task, ParseError> {\n let page_id: u64 = try!(json.find(\"pageid\")\n .and_then(|id| id.as_u64())\n .ok_or(ParseError::UnexpectedFormat));\n let title: &str = try!(json.find(\"title\")\n .and_then(|title| title.as_string())\n .ok_or(ParseError::UnexpectedFormat));\n\n Ok(Task {\n page_id: page_id,\n title: title.to_owned(),\n })\n };\n let tasks_json = try!(reply.find_path(&[\"query\", \"categorymembers\"])\n .and_then(|tasks| tasks.as_array())\n .ok_or(ParseError::UnexpectedFormat));\n\n \n tasks_json.iter().map(json_to_task).collect()\n}\nfn count_number_examples(task: &Json, task_id: u64) -> Result<u32, ParseError> {\n let revisions =\n try!(task.find_path(&[\"query\", \"pages\", task_id.to_string().as_str(), \"revisions\"])\n .and_then(|content| content.as_array())\n .ok_or(ParseError::UnexpectedFormat));\n let content = try!(revisions[0]\n .find(\"*\")\n .and_then(|content| content.as_string())\n .ok_or(ParseError::UnexpectedFormat));\n Ok(content.split(\"=={{header\").count() as u32)\n}\n\npub fn query_all_tasks() -> Vec<Task> {\n let query = construct_query_category(\"Programming_Tasks\");\n let json: Json = query_api(query).unwrap();\n parse_all_tasks(&json).unwrap()\n}\n\npub fn query_a_task(task: &Task) -> u32 {\n let query = construct_query_task_content(&task.page_id.to_string());\n let json: Json = query_api(query).unwrap();\n count_number_examples(&json, task.page_id).unwrap()\n}\n"} {"name":"Rosetta Code_Find unimplemented tasks","C":"\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <curl\/curl.h>\n#include \"wren.h\"\n\nstruct MemoryStruct {\n char *memory;\n size_t size;\n};\n\n\n\nstatic size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {\n size_t realsize = size * nmemb;\n struct MemoryStruct *mem = (struct MemoryStruct *)userp;\n \n char *ptr = realloc(mem->memory, mem->size + realsize + 1);\n if(!ptr) {\n \n printf(\"not enough memory (realloc returned NULL)\\n\");\n return 0;\n }\n\n mem->memory = ptr;\n memcpy(&(mem->memory[mem->size]), contents, realsize);\n mem->size += realsize;\n mem->memory[mem->size] = 0;\n return realsize;\n}\n\nvoid C_bufferAllocate(WrenVM* vm) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenSetSlotNewForeign(vm, 0, 0, sizeof(struct MemoryStruct));\n ms->memory = malloc(1);\n ms->size = 0;\n}\n\nvoid C_bufferFinalize(void* data) {\n struct MemoryStruct *ms = (struct MemoryStruct *)data;\n free(ms->memory);\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_value(WrenVM* vm) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenGetSlotForeign(vm, 0);\n wrenSetSlotString(vm, 0, ms->memory);\n}\n\nvoid C_easyPerform(WrenVM* vm) {\n CURL* curl = *(CURL**)wrenGetSlotForeign(vm, 0);\n curl_easy_perform(curl);\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 if (opt < 10000) {\n long lparam = (long)wrenGetSlotDouble(vm, 2);\n curl_easy_setopt(curl, opt, lparam);\n } else if (opt < 20000) {\n if (opt == CURLOPT_WRITEDATA) {\n struct MemoryStruct *ms = (struct MemoryStruct *)wrenGetSlotForeign(vm, 2);\n curl_easy_setopt(curl, opt, (void *)ms);\n } else if (opt == CURLOPT_URL) {\n const char *url = wrenGetSlotString(vm, 2);\n curl_easy_setopt(curl, opt, url);\n }\n } else if (opt < 30000) {\n if (opt == CURLOPT_WRITEFUNCTION) {\n curl_easy_setopt(curl, opt, &WriteMemoryCallback);\n }\n }\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, \"Buffer\") == 0) {\n methods.allocate = C_bufferAllocate;\n methods.finalize = C_bufferFinalize;\n } else 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, \"Buffer\") == 0) {\n if (!isStatic && strcmp(signature, \"value\") == 0) return C_value;\n } else 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\nstatic void loadModuleComplete(WrenVM* vm, const char* module, WrenLoadModuleResult result) {\n if( result.source) free((void*)result.source);\n}\n\nWrenLoadModuleResult loadModule(WrenVM* vm, const char* name) {\n WrenLoadModuleResult result = {0};\n if (strcmp(name, \"random\") != 0 && strcmp(name, \"meta\") != 0) {\n result.onComplete = loadModuleComplete;\n char fullName[strlen(name) + 6];\n strcpy(fullName, name);\n strcat(fullName, \".wren\");\n result.source = readFile(fullName);\n }\n return result;\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 config.loadModuleFn = &loadModule;\n WrenVM* vm = wrenNewVM(&config);\n const char* module = \"main\";\n const char* fileName = \"rc_find_unimplemented_tasks.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::collections::{BTreeMap, HashSet};\n\nuse reqwest::Url;\nuse serde::Deserialize;\nuse serde_json::Value;\n\n\n#[derive(Clone, PartialEq, Eq, Hash, Debug, Deserialize)]\npub struct Task {\n \n #[serde(rename = \"pageid\")]\n pub id: u64,\n\n \n pub title: String,\n}\n\n\n#[derive(Debug)]\nenum TaskParseError {\n \n Http(reqwest::Error),\n\n \n Json(serde_json::Error),\n\n \n UnexpectedFormat,\n}\n\nimpl From<serde_json::Error> for TaskParseError {\n fn from(err: serde_json::Error) -> Self {\n TaskParseError::Json(err)\n }\n}\n\nimpl From<reqwest::Error> for TaskParseError {\n fn from(err: reqwest::Error) -> Self {\n TaskParseError::Http(err)\n }\n}\n\n\nstruct Category {\n name: String,\n continue_params: Option<BTreeMap<String, String>>,\n}\n\nimpl Category {\n fn new(name: &str) -> Category {\n let mut continue_params = BTreeMap::new();\n continue_params.insert(\"continue\".to_owned(), \"\".to_owned());\n\n Category {\n name: name.to_owned(),\n continue_params: Some(continue_params),\n }\n }\n}\n\n\n\nfn query_api(\n category_name: &str,\n continue_params: &BTreeMap<String, String>,\n) -> Result<Value, TaskParseError> {\n let mut url = Url::parse(\"http:\n url.query_pairs_mut()\n .append_pair(\"action\", \"query\")\n .append_pair(\"list\", \"categorymembers\")\n .append_pair(\"cmtitle\", &format!(\"Category:{}\", category_name))\n .append_pair(\"cmlimit\", \"500\")\n .append_pair(\"format\", \"json\")\n .extend_pairs(continue_params);\n\n Ok(reqwest::blocking::get(url)?.json()?)\n}\n\n\nfn parse_tasks(json: &Value) -> Result<Vec<Task>, TaskParseError> {\n let tasks_json = json\n .pointer(\"\/query\/categorymembers\")\n .and_then(Value::as_array)\n .ok_or(TaskParseError::UnexpectedFormat)?;\n\n tasks_json\n .iter()\n .map(|json| Task::deserialize(json).map_err(From::from))\n .collect()\n}\n\nimpl Iterator for Category {\n type Item = Vec<Task>;\n\n fn next(&mut self) -> Option<Self::Item> {\n self.continue_params.as_ref()?;\n\n query_api(&self.name, self.continue_params.as_ref()?)\n .and_then(|result| {\n \n self.continue_params =\n result\n .get(\"continue\")\n .and_then(Value::as_object)\n .map(|continue_params| {\n continue_params\n .iter()\n .map(|(key, value)| {\n (key.to_owned(), value.as_str().unwrap().to_owned())\n })\n .collect()\n });\n\n parse_tasks(&result)\n })\n .map_err(|err| println!(\"Error parsing response: {:?}\", err))\n .ok()\n }\n}\n\npub fn all_tasks() -> Vec<Task> {\n Category::new(\"Programming Tasks\").flatten().collect()\n}\n\npub fn unimplemented_tasks(lang: &str) -> Vec<Task> {\n let all_tasks = all_tasks().iter().cloned().collect::<HashSet<_>>();\n let implemented_tasks = Category::new(lang).flatten().collect::<HashSet<_>>();\n let mut unimplemented_tasks = all_tasks\n .difference(&implemented_tasks)\n .cloned()\n .collect::<Vec<Task>>();\n unimplemented_tasks.sort_by(|a, b| a.title.cmp(&b.title));\n unimplemented_tasks\n}\n\n\nfn main() {\n for task in find_unimplemented_tasks::unimplemented_tasks(\"Rust\") {\n println!(\"{:6} {}\", task.id, task.title);\n }\n}\n"} {"name":"Rot-13","C":"#include <ctype.h>\n#include <limits.h>\n#include <stdio.h>\n#include <stdlib.h>\n\nstatic char rot13_table[UCHAR_MAX + 1];\n\nstatic void init_rot13_table(void) {\n\tstatic const unsigned char upper[] = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\tstatic const unsigned char lower[] = \"abcdefghijklmnopqrstuvwxyz\";\n\n\tfor (int ch = '\\0'; ch <= UCHAR_MAX; ch++) {\n\t\trot13_table[ch] = ch;\n\t}\n\tfor (const unsigned char *p = upper; p[13] != '\\0'; p++) {\n\t\trot13_table[p[0]] = p[13];\n\t\trot13_table[p[13]] = p[0];\n\t}\n\tfor (const unsigned char *p = lower; p[13] != '\\0'; p++) {\n\t\trot13_table[p[0]] = p[13];\n\t\trot13_table[p[13]] = p[0];\n\t}\n}\n\nstatic void rot13_file(FILE *fp)\n{\n\tint ch;\n\twhile ((ch = fgetc(fp)) != EOF) {\n\t\tfputc(rot13_table[ch], stdout); \n\t}\n}\n\nint main(int argc, char *argv[])\n{\n\tinit_rot13_table();\n\n\tif (argc > 1) {\n\t\tfor (int i = 1; i < argc; i++) {\n\t\t\tFILE *fp = fopen(argv[i], \"r\");\n\t\t\tif (fp == NULL) {\n\t\t\t\tperror(argv[i]);\n\t\t\t\treturn EXIT_FAILURE;\n\t\t\t}\n\t\t\trot13_file(fp);\n\t\t\tfclose(fp);\n\t\t}\n\t} else {\n\t\trot13_file(stdin);\n\t}\n\treturn EXIT_SUCCESS;\n}\n","Rust":"fn rot13(string: &str) -> String {\n string.chars().map(|c| {\n match c {\n 'a'..='m' | 'A'..='M' => ((c as u8) + 13) as char,\n 'n'..='z' | 'N'..='Z' => ((c as u8) - 13) as char,\n _ => c\n }\n }).collect()\n}\n\nfn main () {\n assert_eq!(rot13(\"abc\"), \"nop\");\n}\n"} {"name":"Run-length encoding","C":"#include <stdio.h>\n#include <stdlib.h>\n\ntypedef struct stream_t stream_t, *stream;\nstruct stream_t {\n\t\n\tint (*get)(stream);\n\t\n\tint (*put)(stream, int);\n};\n\n\ntypedef struct {\n\tint (*get)(stream);\n\tint (*put)(stream, int);\n\tchar *string;\n\tint pos;\n} string_stream;\n\ntypedef struct {\n\tint (*get)(stream);\n\tint (*put)(stream, int);\n\tFILE *fp;\n} file_stream;\n\n\nint sget(stream in)\n{\n\tint c;\n\tstring_stream* s = (string_stream*) in;\n\tc = (unsigned char)(s->string[s->pos]);\n\tif (c == '\\0') return -1;\n\ts->pos++;\n\treturn c;\n}\n\nint sput(stream out, int c)\n{\n\tstring_stream* s = (string_stream*) out;\n\ts->string[s->pos++] = (c == -1) ? '\\0' : c;\n\tif (c == -1) s->pos = 0;\n\treturn 0;\n}\n\nint file_put(stream out, int c)\n{\n\tfile_stream *f = (file_stream*) out;\n\treturn fputc(c, f->fp);\n}\n\n\nvoid output(stream out, unsigned char* buf, int len)\n{\n\tint i;\n\tout->put(out, 128 + len);\n\tfor (i = 0; i < len; i++)\n\t\tout->put(out, buf[i]);\n}\n\n\nvoid encode(stream in, stream out)\n{\n\tunsigned char buf[256];\n\tint len = 0, repeat = 0, end = 0, c;\n\tint (*get)(stream) = in->get;\n\tint (*put)(stream, int) = out->put;\n\n\twhile (!end) {\n\t\tend = ((c = get(in)) == -1);\n\t\tif (!end) {\n\t\t\tbuf[len++] = c;\n\t\t\tif (len <= 1) continue;\n\t\t}\n\n\t\tif (repeat) {\n\t\t\tif (buf[len - 1] != buf[len - 2])\n\t\t\t\trepeat = 0;\n\t\t\tif (!repeat || len == 129 || end) {\n\t\t\t\t\n\t\t\t\tput(out, end ? len : len - 1);\n\t\t\t\tput(out, buf[0]);\n\t\t\t\tbuf[0] = buf[len - 1];\n\t\t\t\tlen = 1;\n\t\t\t}\n\t\t} else {\n\t\t\tif (buf[len - 1] == buf[len - 2]) {\n\t\t\t\trepeat = 1;\n\t\t\t\tif (len > 2) {\n\t\t\t\t\toutput(out, buf, len - 2);\n\t\t\t\t\tbuf[0] = buf[1] = buf[len - 1];\n\t\t\t\t\tlen = 2;\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (len == 128 || end) {\n\t\t\t\toutput(out, buf, len);\n\t\t\t\tlen = 0;\n\t\t\t\trepeat = 0;\n\t\t\t}\n\t\t}\n\t}\n\tput(out, -1);\n}\n\nvoid decode(stream in, stream out)\n{\n\tint c, i, cnt;\n\twhile (1) {\n\t\tc = in->get(in);\n\t\tif (c == -1) return;\n\t\tif (c > 128) {\n\t\t\tcnt = c - 128;\n\t\t\tfor (i = 0; i < cnt; i++)\n\t\t\t\tout->put(out, in->get(in));\n\t\t} else {\n\t\t\tcnt = c;\n\t\t\tc = in->get(in);\n\t\t\tfor (i = 0; i < cnt; i++)\n\t\t\t\tout->put(out, c);\n\t\t}\n\t}\n}\n\nint main()\n{\n\tchar buf[256];\n\tstring_stream str_in = { sget, 0,\n\t\t\"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW\", 0};\n\tstring_stream str_out = { sget, sput, buf, 0 };\n\tfile_stream file = { 0, file_put, stdout };\n\n\t\n\tencode((stream)&str_in, (stream)&str_out);\n\n\t\n\tdecode((stream)&str_out, (stream)&file);\n\n\treturn 0;\n}\n","Rust":"fn encode(s: &str) -> String {\n s.chars()\n \n .map(Some)\n \n .chain(std::iter::once(None))\n .scan((0usize, '\\0'), |(n, c), elem| match elem {\n Some(elem) if *n == 0 || *c == elem => {\n \n *n += 1;\n *c = elem;\n \n Some(String::new())\n }\n Some(elem) => {\n \n let run = format!(\"{}{}\", n, c);\n *n = 1;\n *c = elem;\n Some(run)\n }\n None => {\n \n Some(format!(\"{}{}\", n, c))\n }\n })\n \n .collect()\n}\n\nfn decode(s: &str) -> String {\n s.chars()\n .fold((0usize, String::new()), |(n, text), c| {\n if c.is_ascii_digit() {\n \n (\n n * 10 + c.to_digit(10).expect(\"invalid encoding\") as usize,\n text,\n )\n } else {\n \n (0, text + &format!(\"{}\", c.to_string().repeat(n)))\n }\n })\n .1\n}\n\nfn main() {\n let text = \"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW\";\n let encoded = encode(text);\n let decoded = decode(&encoded);\n\n println!(\"original: {}\\n encoded: {}\\n decoded: {}\", text, encoded, decoded);\n assert_eq!(text, decoded);\n}\n"} {"name":"Runge-Kutta method","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\ndouble rk4(double(*f)(double, double), double dx, double x, double y)\n{\n\tdouble\tk1 = dx * f(x, y),\n\t\tk2 = dx * f(x + dx \/ 2, y + k1 \/ 2),\n\t\tk3 = dx * f(x + dx \/ 2, y + k2 \/ 2),\n\t\tk4 = dx * f(x + dx, y + k3);\n\treturn y + (k1 + 2 * k2 + 2 * k3 + k4) \/ 6;\n}\n\ndouble rate(double x, double y)\n{\n\treturn x * sqrt(y);\n}\n\nint main(void)\n{\n\tdouble *y, x, y2;\n\tdouble x0 = 0, x1 = 10, dx = .1;\n\tint i, n = 1 + (x1 - x0)\/dx;\n\ty = (double *)malloc(sizeof(double) * n);\n\n\tfor (y[0] = 1, i = 1; i < n; i++)\n\t\ty[i] = rk4(rate, dx, x0 + dx * (i - 1), y[i-1]);\n\n\tprintf(\"x\\ty\\trel. err.\\n------------\\n\");\n\tfor (i = 0; i < n; i += 10) {\n\t\tx = x0 + dx * i;\n\t\ty2 = pow(x * x \/ 4 + 1, 2);\n\t\tprintf(\"%g\\t%g\\t%g\\n\", x, y[i], y[i]\/y2 - 1);\n\t}\n\n\treturn 0;\n}\n","Rust":"fn runge_kutta4(fx: &dyn Fn(f64, f64) -> f64, x: f64, y: f64, dx: f64) -> f64 {\n let k1 = dx * fx(x, y);\n let k2 = dx * fx(x + dx \/ 2.0, y + k1 \/ 2.0);\n let k3 = dx * fx(x + dx \/ 2.0, y + k2 \/ 2.0);\n let k4 = dx * fx(x + dx, y + k3);\n\n y + (k1 + 2.0 * k2 + 2.0 * k3 + k4) \/ 6.0\n}\n\nfn f(x: f64, y: f64) -> f64 {\n x * y.sqrt()\n}\n\nfn actual(x: f64) -> f64 {\n (1.0 \/ 16.0) * (x * x + 4.0).powi(2)\n}\n\nfn main() {\n let mut y = 1.0;\n let mut x = 0.0;\n let step = 0.1;\n let max_steps = 101;\n let sample_every_n = 10;\n\n for steps in 0..max_steps {\n if steps % sample_every_n == 0 {\n println!(\"y({}):\\t{:.10}\\t\\t {:E}\", x, y, actual(x) - y)\n }\n\n y = runge_kutta4(&f, x, y, step);\n\n x = ((x * 10.0) + (step * 10.0)) \/ 10.0;\n }\n}\n"} {"name":"S-expressions","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <ctype.h>\n#include <string.h>\n\nenum { S_NONE, S_LIST, S_STRING, S_SYMBOL };\n\ntypedef struct {\n\tint type;\n\tsize_t len;\n\tvoid *buf;\n} s_expr, *expr;\n\nvoid whine(const char *s)\n{\n\tfprintf(stderr, \"parse error before ==>%.10s\\n\", s);\n}\n\nexpr parse_string(const char *s, char **e)\n{\n\texpr ex = calloc(sizeof(s_expr), 1);\n\tchar buf[256] = {0};\n\tint i = 0;\n\n\twhile (*s) {\n\t\tif (i >= 256) {\n\t\t\tfprintf(stderr, \"string too long:\\n\");\n\t\t\twhine(s);\n\t\t\tgoto fail;\n\t\t}\n\t\tswitch (*s) {\n\t\tcase '\\\\':\n\t\t\tswitch (*++s) {\n\t\t\tcase '\\\\':\n\t\t\tcase '\"':\tbuf[i++] = *s++;\n\t\t\t\t\tcontinue;\n\n\t\t\tdefault:\twhine(s);\n\t\t\t\t\tgoto fail;\n\t\t\t}\n\t\tcase '\"':\tgoto success;\n\t\tdefault:\tbuf[i++] = *s++;\n\t\t}\n\t}\nfail:\n\tfree(ex);\n\treturn 0;\n\nsuccess:\n\t*(const char **)e = s + 1;\n\tex->type = S_STRING;\n\tex->buf = strdup(buf);\n\tex->len = strlen(buf);\n\treturn ex;\n}\n\nexpr parse_symbol(const char *s, char **e)\n{\n\texpr ex = calloc(sizeof(s_expr), 1);\n\tchar buf[256] = {0};\n\tint i = 0;\n\n\twhile (*s) {\n\t\tif (i >= 256) {\n\t\t\tfprintf(stderr, \"symbol too long:\\n\");\n\t\t\twhine(s);\n\t\t\tgoto fail;\n\t\t}\n\t\tif (isspace(*s)) goto success;\n\t\tif (*s == ')' || *s == '(') {\n\t\t\ts--;\n\t\t\tgoto success;\n\t\t}\n\n\t\tswitch (*s) {\n\t\tcase '\\\\':\n\t\t\tswitch (*++s) {\n\t\t\tcase '\\\\': case '\"': case '(': case ')':\n\t\t\t\t\tbuf[i++] = *s++;\n\t\t\t\t\tcontinue;\n\t\t\tdefault:\twhine(s);\n\t\t\t\t\tgoto fail;\n\t\t\t}\n\t\tcase '\"':\twhine(s);\n\t\t\t\tgoto success;\n\t\tdefault:\tbuf[i++] = *s++;\n\t\t}\n\t}\nfail:\n\tfree(ex);\n\treturn 0;\n\nsuccess:\n\t*(const char **)e = s + 1;\n\tex->type = S_SYMBOL;\n\tex->buf = strdup(buf);\n\tex->len = strlen(buf);\n\treturn ex;\n}\n\nvoid append(expr list, expr ele)\n{\n\tlist->buf = realloc(list->buf, sizeof(expr) * ++list->len);\n\t((expr*)(list->buf))[list->len - 1] = ele;\n}\n\nexpr parse_list(const char *s, char **e)\n{\n\texpr ex = calloc(sizeof(s_expr), 1), chld;\n\tchar *next;\n\n\tex->len = 0;\n\n\twhile (*s) {\n\t\tif (isspace(*s)) {\n\t\t\ts++;\n\t\t\tcontinue;\n\t\t}\n\n\t\tswitch (*s) {\n\t\tcase '\"':\n\t\t\tchld = parse_string(s+1, &next);\n\t\t\tif (!chld) goto fail;\n\t\t\tappend(ex, chld);\n\t\t\ts = next;\n\t\t\tcontinue;\n\t\tcase '(':\n\t\t\tchld = parse_list(s+1, &next);\n\t\t\tif (!chld) goto fail;\n\t\t\tappend(ex, chld);\n\t\t\ts = next;\n\t\t\tcontinue;\n\t\tcase ')':\n\t\t\tgoto success;\n\n\t\tdefault:\n\t\t\tchld = parse_symbol(s, &next);\n\t\t\tif (!chld) goto fail;\n\t\t\tappend(ex, chld);\n\t\t\ts = next;\n\t\t\tcontinue;\n\t\t}\n\t}\n\nfail:\n\twhine(s);\n\tfree(ex);\n\treturn 0;\n\nsuccess:\n\t*(const char **)e = s+1;\n\tex->type = S_LIST;\n\treturn ex;\n}\n\nexpr parse_term(const char *s, char **e)\n{\n\twhile (*s) {\n\t\tif (isspace(*s)) {\n\t\t\ts++;\n\t\t\tcontinue;\n\t\t}\n\t\tswitch(*s) {\n\t\tcase '(':\n\t\t\treturn parse_list(s+1, e);\n\t\tcase '\"':\n\t\t\treturn parse_string(s+1, e);\n\t\tdefault:\n\t\t\treturn parse_symbol(s+1, e);\n\t\t}\n\t}\n\treturn 0;\n}\n\nvoid print_expr(expr e, int depth)\n{\n#define sep() for(i = 0; i < depth; i++) printf(\" \")\n\tint i;\n\tif (!e) return;\n\n\n\tswitch(e->type) {\n\tcase S_LIST:\n\t\tsep();\n\t\tputs(\"(\");\n\t\tfor (i = 0; i < e->len; i++)\n\t\t\tprint_expr(((expr*)e->buf)[i], depth + 1);\n\t\tsep();\n\t\tputs(\")\");\n\t\treturn;\n\tcase S_SYMBOL:\n\tcase S_STRING:\n\t\tsep();\n\t\tif (e->type == S_STRING) putchar('\"');\n\t\tfor (i = 0; i < e->len; i++) {\n\t\t\tswitch(((char*)e->buf)[i]) {\n\t\t\tcase '\"':\n\t\t\tcase '\\\\':\n\t\t\t\tputchar('\\\\');\n\t\t\t\tbreak;\n\t\t\tcase ')': case '(':\n\t\t\t\tif (e->type == S_SYMBOL)\n\t\t\t\t\tputchar('\\\\');\n\t\t\t}\n\n\t\t\tputchar(((char*)e->buf)[i]);\n\t\t}\n\t\tif (e->type == S_STRING) putchar('\"');\n\t\tputchar('\\n');\n\t\treturn;\n\t}\n}\n\nint main()\n{\n\tchar *next;\n\tconst char *in = \"((data da\\\\(\\\\)ta \\\"quot\\\\\\\\ed data\\\" 123 4.5)\\n\"\n\t\t\t\" (\\\"data\\\" (!@# (4.5) \\\"(mo\\\\\\\"re\\\" \\\"data)\\\")))\";\n\n\texpr x = parse_term(in, &next);\n\n\tprintf(\"input is:\\n%s\\n\", in);\n\tprintf(\"parsed as:\\n\");\n\tprint_expr(x, 0);\n\treturn 0;\n}\n","Rust":"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nextern crate typed_arena;\n\nuse typed_arena::Arena;\n\nuse self::Error::*;\nuse self::SExp::*;\nuse self::Token::*;\nuse std::io;\nuse std::num::FpCategory;\nuse std::str::FromStr;\n\n\n\n\n\n#[derive(PartialEq, Debug)]\npub enum SExp<'a> {\n \n F64(f64),\n\n \n List(&'a [SExp<'a>]),\n\n \n Str(&'a str),\n}\n\n\n#[derive(PartialEq, Debug)]\npub enum Error {\n \n NoReprForFloat,\n\n \n UnterminatedStringLiteral,\n\n \n Io,\n\n \n IncorrectCloseDelimiter,\n\n \n UnexpectedEOF,\n\n \n ExpectedEOF,\n}\n\nimpl From<io::Error> for Error {\n fn from(_err: io::Error) -> Error {\n Error::Io\n }\n}\n\n\n#[derive(PartialEq, Debug)]\nenum Token<'a> {\n \n ListStart,\n\n \n ListEnd,\n\n \n Literal(SExp<'a>),\n\n \n Eof,\n}\n\n\n\n\n\n#[derive(Copy, Clone, Debug)]\nstruct Tokens<'a> {\n \n string: &'a str,\n\n \n first: Option<char>,\n\n \n rest: &'a str,\n}\n\nimpl<'a> Tokens<'a> {\n \n fn new(string: &str) -> Tokens {\n let mut chars = string.chars();\n\n match chars.next() {\n Some(ch) => Tokens {\n string,\n first: Some(ch),\n rest: chars.as_str(),\n },\n None => Tokens {\n string,\n first: None,\n rest: string,\n },\n }\n }\n\n \n \n \n \n fn update(&mut self, string: &'a str) {\n self.string = string;\n let mut chars = self.string.chars();\n\n if let Some(ch) = chars.next() {\n self.first = Some(ch);\n self.rest = chars.as_str();\n } else {\n self.first = None;\n };\n }\n\n \n fn next_token(&mut self) -> Result<Token<'a>, Error> {\n loop {\n match self.first {\n \n Some('(') => {\n self.update(self.rest);\n return Ok(ListStart);\n }\n \n Some(')') => {\n self.update(self.rest);\n return Ok(ListEnd);\n }\n \n Some('\"') => {\n \n \n \n let mut iter = self.rest.splitn(2, '\"');\n \n let str = iter.next().unwrap();\n match iter.next() {\n \n \n Some(s) => {\n self.update(s);\n return Ok(Literal(Str(str)));\n }\n None => return Err(UnterminatedStringLiteral),\n }\n }\n \n Some(c) => {\n \n if c.is_whitespace() {\n self.update(self.rest);\n continue;\n }\n \n \n let mut end_ch = None;\n let str = {\n let mut iter = self.string.splitn(2, |ch: char| {\n let term = ch == ')' || ch == '(';\n if term {\n end_ch = Some(ch)\n }\n term || ch.is_whitespace()\n });\n \n let str = iter.next().unwrap();\n self.rest = iter.next().unwrap_or(\"\");\n str\n };\n match end_ch {\n \n \n \n \n \n Some(_) => self.first = end_ch,\n None => self.update(self.rest),\n }\n return Ok(Literal(parse_literal(str)));\n }\n None => return Ok(Eof),\n }\n }\n }\n}\n\n\n\nfn parse_literal(literal: &str) -> SExp {\n match literal.bytes().next() {\n Some(b'0'..=b'9') | Some(b'-') => match f64::from_str(literal) {\n Ok(f) => F64(f),\n Err(_) => Str(literal),\n },\n _ => Str(literal),\n }\n}\n\n\npub struct ParseContext<'a> {\n \n string: &'a str,\n\n \n arena: Option<Arena<Vec<SExp<'a>>>>,\n\n \n stack: Vec<Vec<SExp<'a>>>,\n}\n\nimpl<'a> ParseContext<'a> {\n \n pub fn new(string: &'a str) -> ParseContext<'a> {\n ParseContext {\n string,\n arena: None,\n stack: Vec::new(),\n }\n }\n}\n\nimpl<'a> SExp<'a> {\n \n fn encode<T: io::Write>(&self, writer: &mut T) -> Result<(), Error> {\n match *self {\n F64(f) => {\n match f.classify() {\n \n FpCategory::Normal | FpCategory::Zero => {\n write!(writer, \"{}\", f)?;\n Ok(())\n }\n _ => Err(Error::NoReprForFloat),\n }\n }\n List(l) => {\n \n \n \n \n write!(writer, \"(\")?;\n let mut iter = l.iter();\n if let Some(sexp) = iter.next() {\n sexp.encode(writer)?;\n for sexp in iter {\n write!(writer, \" \")?;\n sexp.encode(writer)?;\n }\n }\n write!(writer, \")\")?;\n Ok(())\n }\n Str(s) => {\n write!(writer, \"\\\"{}\\\"\", s)?;\n Ok(())\n }\n }\n }\n\n \n pub fn parse(ctx: &'a mut ParseContext<'a>) -> Result<SExp<'a>, Error> {\n ctx.arena = Some(Arena::new());\n \n \n let arena = match ctx.arena {\n Some(ref mut arena) => arena,\n None => unreachable!(),\n };\n let ParseContext {\n string,\n ref mut stack,\n ..\n } = *ctx;\n \n \n \n stack.clear();\n let mut tokens = Tokens::new(string);\n \n \n let next = tokens.next_token();\n let mut list = match next? {\n ListStart => Vec::new(),\n Literal(s) => {\n return if tokens.next_token()? == Eof {\n Ok(s)\n } else {\n Err(ExpectedEOF)\n };\n }\n ListEnd => return Err(IncorrectCloseDelimiter),\n Eof => return Err(UnexpectedEOF),\n };\n\n \n loop {\n let tok = tokens.next_token();\n match tok? {\n ListStart => {\n \n stack.push(list);\n list = Vec::new()\n }\n Literal(s) => list.push(s), \n ListEnd => {\n match stack.pop() {\n \n Some(mut l) => {\n \n \n l.push(List(&*arena.alloc(list)));\n \n list = l;\n }\n \n \n \n None => {\n return match tokens.next_token()? {\n Eof => Ok(List(&*arena.alloc(list))),\n _ => Err(ExpectedEOF),\n };\n }\n }\n }\n \n Eof => return Err(UnexpectedEOF),\n }\n }\n }\n\n \n pub fn buffer_encode(&self) -> Result<String, Error> {\n let mut m = Vec::new();\n self.encode(&mut m)?;\n \n \n \n unsafe { Ok(String::from_utf8_unchecked(m)) }\n }\n}\n\npub const SEXP_STRUCT: SExp<'static> = List(&[\n List(&[Str(\"data\"), Str(\"quoted data\"), F64(123.), F64(4.5)]),\n List(&[\n Str(\"data\"),\n List(&[Str(\"!@#\"), List(&[F64(4.5)]), Str(\"(more\"), Str(\"data)\")]),\n ]),\n]);\n\npub const SEXP_STRING_IN: &str = r#\"((data \"quoted data\" 123 4.5)\n(data (!@# (4.5) \"(more\" \"data)\")))\"#;\n\n\nand main.rs:\n\nuse s_expressions::{ParseContext, SExp, SEXP_STRING_IN, SEXP_STRUCT};\n\nfn main() {\n println!(\"{:?}\", SEXP_STRUCT.buffer_encode());\n let ctx = &mut ParseContext::new(SEXP_STRING_IN);\n println!(\"{:?}\", SExp::parse(ctx));\n}\n"} {"name":"SEDOLs","C":"#include <stdio.h>\n#include <ctype.h>\n#include <string.h>\n\nint sedol_weights[] = {1, 3, 1, 7, 3, 9}; \nconst char *reject = \"AEIOUaeiou\";\n\nint sedol_checksum(const char *sedol6)\n{\n int len = strlen(sedol6);\n int sum = 0, i;\n\n if ( len == 7 ) {\n fprintf(stderr, \"SEDOL code already checksummed? (%s)\\n\", sedol6);\n return sedol6[6] & 0x7f;\n }\n if ( (len > 7) || (len < 6) || ( strcspn(sedol6, reject) != 6 )) {\n fprintf(stderr, \"not a SEDOL code? (%s)\\n\", sedol6);\n return -1;\n }\n for(i=0; i < 6; i++) {\n if ( isdigit(sedol6[i]) ) {\n sum += (sedol6[i]-'0')*sedol_weights[i];\n } else if ( isalpha(sedol6[i]) ) {\n sum += ((toupper(sedol6[i])-'A') + 10)*sedol_weights[i];\n } else {\n fprintf(stderr, \"SEDOL with not alphanumeric digit\\n\");\n return -1;\n }\n }\n return (10 - (sum%10))%10 + '0'; \n}\n\n\n#define MAXLINELEN 10\nint main()\n{\n char line[MAXLINELEN];\n int sr, len;\n while( fgets(line, MAXLINELEN, stdin) != NULL ) {\n len = strlen(line);\n if ( line[len-1] == '\\n' ) line[len-1]='\\0';\n sr = sedol_checksum(line);\n if ( sr > 0 )\n printf(\"%s%c\\n\", line, sr);\n }\n return 0;\n}\n","Rust":"fn sedol(input: &str) -> Option<String> {\n let weights = vec![1, 3, 1, 7, 3, 9, 1];\n let valid_chars = \"0123456789BCDFGHJKLMNPQRSTVWXYZ\";\n\n if input.len() != 6 {\n return None;\n }\n\n \n for c in input.chars() {\n if !valid_chars.contains(c) {\n return None;\n }\n }\n\n let mut result: u32 = input\n .chars()\n .map(|c| {\n if c.is_digit(10) {\n c as u32 - 48\n } else {\n c as u32 - 55\n }\n })\n .zip(weights)\n .map(|(cnum, w)| w * cnum)\n .collect::<Vec<u32>>()\n .iter()\n .sum();\n\n result = (10 - result % 10) % 10;\n\n Some(input.to_owned() + &result.to_string())\n}\n\nfn main() {\n let inputs = vec![\n \"710889\", \"B0YBKJ\", \"406566\", \"B0YBLH\", \"228276\", \"B0YBKL\", \"557910\", \"B0YBKR\", \"585284\",\n \"B0YBKT\", \"B00030\",\n ];\n\n for input in inputs {\n println!(\"{} SEDOL: {:?}\", &input, sedol(&input).unwrap());\n }\n}\n"} {"name":"SHA-1","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <openssl\/sha.h>\n\nint main()\n{\n int i;\n unsigned char result[SHA_DIGEST_LENGTH];\n const char *string = \"Rosetta Code\";\n \n SHA1(string, strlen(string), result);\n \n for(i = 0; i < SHA_DIGEST_LENGTH; i++)\n printf(\"%02x%c\", result[i], i < (SHA_DIGEST_LENGTH-1) ? ' ' : '\\n');\n \n return EXIT_SUCCESS;\n}\n","Rust":"use sha1::Sha1;\n\nfn main() {\n let mut hash_msg = Sha1::new();\n hash_msg.update(b\"Rosetta Code\");\n println!(\"{}\", hash_msg.digest().to_string());\n}\n"} {"name":"SHA-256","C":"#include <stdio.h>\n#include <string.h>\n#include <openssl\/sha.h>\n\nint main (void) {\n\tconst char *s = \"Rosetta code\";\n\tunsigned char *d = SHA256(s, strlen(s), 0);\n\n\tint i;\n\tfor (i = 0; i < SHA256_DIGEST_LENGTH; i++)\n\t\tprintf(\"%02x\", d[i]);\n\tputchar('\\n');\n\n\treturn 0;\n}\n","Rust":"use sha2::{Digest, Sha256};\n\nfn hex_string(input: &[u8]) -> String {\n input.as_ref().iter().map(|b| format!(\"{:x}\", b)).collect()\n}\n\nfn main() {\n \n let mut hasher = Sha256::new();\n\n \n hasher.update(b\"Rosetta code\");\n\n \n let result = hasher.finalize();\n\n let hex = hex_string(&result);\n\n assert_eq!(\n hex,\n \"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf\"\n );\n \n println!(\"{}\", hex);\n}\n"} {"name":"Search a list","C":"#include <stdio.h>\n#include <string.h>\n\nconst char *haystack[] = {\n \"Zig\", \"Zag\", \"Wally\", \"Ronald\", \"Bush\", \"Krusty\", \"Charlie\",\n \"Bush\", \"Boz\", \"Zag\", NULL\n};\n\nint search_needle(const char *needle, const char **hs)\n{\n int i = 0;\n while( hs[i] != NULL ) {\n if ( strcmp(hs[i], needle) == 0 ) return i;\n i++;\n }\n return -1;\n}\n\nint search_last_needle(const char *needle, const char **hs)\n{\n int i, last=0;\n i = last = search_needle(needle, hs);\n if ( last < 0 ) return -1;\n while( hs[++i] != NULL ) {\n if ( strcmp(needle, hs[i]) == 0 ) {\n last = i;\n }\n }\n return last;\n}\n\nint main()\n{\n printf(\"Bush is at %d\\n\", search_needle(\"Bush\", haystack));\n if ( search_needle(\"Washington\", haystack) == -1 )\n printf(\"Washington is not in the haystack\\n\");\n printf(\"First index for Zag: %d\\n\", search_needle(\"Zag\", haystack));\n printf(\"Last index for Zag: %d\\n\", search_last_needle(\"Zag\", haystack));\n return 0;\n}\n","Rust":"fn main() {\n let haystack=vec![\"Zig\", \"Zag\", \"Wally\", \"Ronald\", \"Bush\", \"Krusty\", \"Charlie\", \n \"Bush\", \"Boz\", \"Zag\"];\n\n println!(\"First occurence of 'Bush' at {:?}\",haystack.iter().position(|s| *s==\"Bush\"));\n println!(\"Last occurence of 'Bush' at {:?}\",haystack.iter().rposition(|s| *s==\"Bush\"));\n println!(\"First occurence of 'Rob' at {:?}\",haystack.iter().position(|s| *s==\"Rob\"));\n}\n"} {"name":"Secure temporary file","C":"#include <stdlib.h>\n#include <stdio.h>\n\nint main(void)\n{\n FILE *fh = tmpfile(); \n \n fclose(fh);\n \n return 0;\n}\n","Rust":"\n\nuse tempfile::tempfile;\n\nfn main() {\n\n let fh = tempfile();\n\n println!(\"{:?}\", fh);\n}\n"} {"name":"Semiprime","C":"#include <stdio.h>\n\nint semiprime(int n)\n{\n\tint p, f = 0;\n\tfor (p = 2; f < 2 && p*p <= n; p++)\n\t\twhile (0 == n % p)\n\t\t\tn \/= p, f++;\n\n\treturn f + (n > 1) == 2;\n}\n\nint main(void)\n{\n\tint i;\n\tfor (i = 2; i < 100; i++)\n\t\tif (semiprime(i)) printf(\" %d\", i);\n\tputchar('\\n');\n\n\treturn 0;\n}\n","Rust":"extern crate primal;\n\nfn isqrt(n: usize) -> usize {\n (n as f64).sqrt() as usize\n}\n\nfn is_semiprime(mut n: usize) -> bool {\n let root = isqrt(n) + 1;\n let primes1 = primal::Sieve::new(root);\n let mut count = 0;\n\n for i in primes1.primes_from(2).take_while(|&x| x < root) {\n while n % i == 0 {\n n \/= i;\n count += 1;\n }\n if n == 1 {\n break;\n }\n }\n\n if n != 1 {\n count += 1;\n }\n count == 2\n}\n\n#[test]\nfn test1() {\n assert_eq!((2..10).filter(|&n| is_semiprime(n)).count(), 3);\n}\n\n#[test]\nfn test2() {\n assert_eq!((2..100).filter(|&n| is_semiprime(n)).count(), 34);\n}\n\n#[test]\nfn test3() {\n assert_eq!((2..1_000).filter(|&n| is_semiprime(n)).count(), 299);\n}\n\n#[test]\nfn test4() {\n assert_eq!((2..10_000).filter(|&n| is_semiprime(n)).count(), 2_625);\n}\n\n#[test]\nfn test5() {\n assert_eq!((2..100_000).filter(|&n| is_semiprime(n)).count(), 23_378);\n}\n\n#[test]\nfn test6() {\n assert_eq!((2..1_000_000).filter(|&n| is_semiprime(n)).count(), 210_035);\n}\n"} {"name":"Semordnilap","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <alloca.h> \n#include <string.h>\n\nstatic void reverse(char *s, int len)\n{\n int i, j;\n char tmp;\n\n for (i = 0, j = len - 1; i < len \/ 2; ++i, --j)\n tmp = s[i], s[i] = s[j], s[j] = tmp;\n}\n\n\nstatic int strsort(const void *s1, const void *s2)\n{\n return strcmp(*(char *const *) s1, *(char *const *) s2);\n}\n\nint main(void)\n{\n int i, c, ct = 0, len, sem = 0;\n char **words, **drows, tmp[24];\n FILE *dict = fopen(\"unixdict.txt\", \"r\");\n\n \n while ((c = fgetc(dict)) != EOF)\n ct += c == '\\n';\n rewind(dict);\n\n \n words = alloca(ct * sizeof words);\n drows = alloca(ct * sizeof drows);\n\n for (i = 0; fscanf(dict, \"%s%n\", tmp, &len) != EOF; ++i) {\n \n strcpy(words[i] = alloca(len), tmp);\n\n \n strcpy(drows[i] = alloca(len), tmp);\n reverse(drows[i], len - 1);\n }\n\n fclose(dict);\n qsort(drows, ct, sizeof drows, strsort);\n\n \n for (c = i = 0; i < ct; ++i) {\n while (strcmp(drows[i], words[c]) > 0 && c < ct - 1)\n c++;\n \n if (!strcmp(drows[i], words[c])) {\n strcpy(tmp, drows[i]);\n reverse(tmp, strlen(tmp));\n \n if (strcmp(drows[i], tmp) > 0 && sem++ < 5)\n printf(\"%s\\t%s\\n\", drows[i], tmp);\n }\n }\n\n printf(\"Semordnilap pairs: %d\\n\", sem);\n return 0;\n}\n","Rust":"use std::collections::HashSet;\nuse std::fs::File;\nuse std::io::{self, BufRead};\nuse std::iter::FromIterator;\n\nfn semordnilap(filename: &str) -> std::io::Result<()> {\n let file = File::open(filename)?;\n let mut seen = HashSet::new();\n let mut count = 0;\n for line in io::BufReader::new(file).lines() {\n let mut word = line?;\n word.make_ascii_lowercase();\n let rev = String::from_iter(word.chars().rev());\n if seen.contains(&rev) {\n if count < 5 {\n println!(\"{}\\t{}\", word, rev);\n }\n count += 1;\n } else {\n seen.insert(word);\n }\n }\n println!(\"\\nSemordnilap pairs found: {}\", count);\n Ok(())\n}\n\nfn main() {\n match semordnilap(\"unixdict.txt\") {\n Ok(()) => {}\n Err(error) => eprintln!(\"{}\", error),\n }\n}\n"} {"name":"Sequence of non-squares","C":"#include <math.h>\n#include <stdio.h>\n#include <assert.h>\n\nint nonsqr(int n) {\n return n + (int)(0.5 + sqrt(n));\n \n}\n\nint main() {\n int i;\n \n \n for (i = 1; i < 23; i++)\n printf(\"%d \", nonsqr(i));\n printf(\"\\n\");\n \n \n for (i = 1; i < 1000000; i++) {\n double j = sqrt(nonsqr(i));\n assert(j != floor(j));\n }\n return 0;\n}\n","Rust":"fn f(n: i64) -> i64 {\n n + (0.5 + (n as f64).sqrt()) as i64\n}\n\nfn is_sqr(n: i64) -> bool {\n let a = (n as f64).sqrt() as i64;\n n == a * a || n == (a+1) * (a+1) || n == (a-1) * (a-1) \n}\n\nfn main() {\n println!( \"{:?}\", (1..23).map(|n| f(n)).collect::<Vec<i64>>() );\n let count = (1..1_000_000).map(|n| f(n)).filter(|&n| is_sqr(n)).count();\n println!(\"{} unexpected squares found\", count);\n}\n"} {"name":"Sequence of primes by trial division","C":"#include<stdio.h>\n\nint isPrime(unsigned int n)\n{\n\tunsigned int num;\n\t\n\tif ( n < 2||!(n & 1)) \n\t\treturn n == 2;\n\n\tfor (num = 3; num <= n\/num; num += 2)\n\t\tif (!(n % num)) \n\t\t\treturn 0;\n\treturn 1;\n}\n\nint main()\n{\n\tunsigned int l,u,i,sum=0;\n\t\n\tprintf(\"Enter lower and upper bounds: \");\n\tscanf(\"%ld%ld\",&l,&u);\n\t\n\tfor(i=l;i<=u;i++){\n\t\tif(isPrime(i)==1)\n\t\t\t{\n\t\t\t\tprintf(\"\\n%ld\",i);\n\t\t\t\tsum++;\n\t\t\t}\n\t}\n\t\n\tprintf(\"\\n\\nPrime numbers found in [%ld,%ld]\u00a0: %ld\",l,u,sum);\n\t\n\treturn 0;\n}\n","Rust":"fn is_prime(number: u32) -> bool {\n #[allow(clippy::cast_precision_loss)]\n let limit = (number as f32).sqrt() as u32 + 1;\n\n \n !(number < 2 || (2..limit).any(|x| number % x == 0))\n}\n\nfn main() {\n println!(\n \"Primes below 100:\\n{:?}\",\n (0_u32..100).fold(vec![], |mut acc, number| {\n if is_prime(number) {\n acc.push(number)\n };\n acc\n })\n );\n}\n"} {"name":"Set","C":"#include <stdio.h>\n\ntypedef unsigned int set_t; \n\nvoid show_set(set_t x, const char *name)\n{\n\tint i;\n\tprintf(\"%s is:\", name);\n\tfor (i = 0; (1U << i) <= x; i++)\n\t\tif (x & (1U << i))\n\t\t\tprintf(\" %d\", i);\n\tputchar('\\n');\n}\n\nint main(void)\n{\n\tint i;\n\tset_t a, b, c;\n\t\n\ta = 0; \n\tfor (i = 0; i < 10; i += 3) \n\t\ta |= (1U << i);\n\tshow_set(a, \"a\");\n\n\tfor (i = 0; i < 5; i++)\n\t\tprintf(\"\\t%d%s in set a\\n\", i, (a & (1U << i)) ? \"\":\" not\");\n\n\tb = a;\n\tb |= (1U << 5); b |= (1U << 10); \n\tb &= ~(1U << 0);\t\n\tshow_set(b, \"b\");\n\n\tshow_set(a | b, \"union(a, b)\");\n\tshow_set(c = a & b, \"c = common(a, b)\");\n\tshow_set(a & ~b, \"a - b\"); \n\tshow_set(b & ~a, \"b - a\");\n\tprintf(\"b is%s a subset of a\\n\", !(b & ~a) ? \"\" : \" not\");\n\tprintf(\"c is%s a subset of a\\n\", !(c & ~a) ? \"\" : \" not\");\n\n\tprintf(\"union(a, b) - common(a, b) %s union(a - b, b - a)\\n\",\n\t\t((a | b) & ~(a & b)) == ((a & ~b) | (b & ~a))\n\t\t\t? \"equals\" : \"does not equal\");\n\n\treturn 0;\n}\n","Rust":"use std::collections::HashSet;\n\nfn main() {\n let a = vec![1, 3, 4].into_iter().collect::<HashSet<i32>>();\n let b = vec![3, 5, 6].into_iter().collect::<HashSet<i32>>();\n\n println!(\"Set A: {:?}\", a.iter().collect::<Vec<_>>());\n println!(\"Set B: {:?}\", b.iter().collect::<Vec<_>>());\n println!(\"Does A contain 4? {}\", a.contains(&4));\n println!(\"Union: {:?}\", a.union(&b).collect::<Vec<_>>());\n println!(\"Intersection: {:?}\", a.intersection(&b).collect::<Vec<_>>());\n println!(\"Difference: {:?}\", a.difference(&b).collect::<Vec<_>>());\n println!(\"Is A a subset of B? {}\", a.is_subset(&b));\n println!(\"Is A equal to B? {}\", a == b);\n}\n"} {"name":"Set puzzle","C":"#include <stdio.h>\n#include <stdlib.h>\n\nchar *names[4][3] = {\n\t{ \"red\", \"green\", \"purple\" },\n\t{ \"oval\", \"squiggle\", \"diamond\" },\n\t{ \"one\", \"two\", \"three\" },\n\t{ \"solid\", \"open\", \"striped\" }\n};\n\nint set[81][81];\n\nvoid init_sets(void)\n{\n\tint i, j, t, a, b;\n\tfor (i = 0; i < 81; i++) {\n\t\tfor (j = 0; j < 81; j++) {\n\t\t\tfor (t = 27; t; t \/= 3) {\n\t\t\t\ta = (i \/ t) % 3;\n\t\t\t\tb = (j \/ t) % 3;\n\t\t\t\tset[i][j] += t * (a == b ? a : 3 - a - b);\n\t\t\t}\n\t\t}\n\t}\n}\n\nvoid deal(int *out, int n)\n{\n\tint i, j, t, c[81];\n\tfor (i = 0; i < 81; i++) c[i] = i;\n\tfor (i = 0; i < n; i++) {\n\t\tj = i + (rand() % (81 - i));\n\t\tt = c[i], c[i] = out[i] = c[j], c[j] = t;\n\t}\n}\n\nint get_sets(int *cards, int n, int sets[][3])\n{\n\tint i, j, k, s = 0;\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = i + 1; j < n; j++) {\n\t\t\tfor (k = j + 1; k < n; k++) {\n\t\t\t\tif (set[cards[i]][cards[j]] == cards[k])\n\t\t\t\t\tsets[s][0] = i,\n\t\t\t\t\tsets[s][1] = j,\n\t\t\t\t\tsets[s][2] = k,\n\t\t\t\t\ts++;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn s;\n}\n\nvoid show_card(int c)\n{\n\tint i, t;\n\tfor (i = 0, t = 27; t; i++, t \/= 3)\n\t\tprintf(\"%9s\", names[i][(c\/t)%3]);\n\tputchar('\\n');\n}\n\nvoid deal_sets(int ncard, int nset)\n{\n\tint c[81];\n\tint csets[81][3]; \n\tint i, j, s;\n\n\tdo deal(c, ncard); while ((s = get_sets(c, ncard, csets)) != nset);\n\n\tprintf(\"dealt %d cards\\n\", ncard);\n\tfor (i = 0; i < ncard; i++) {\n\t\tprintf(\"%2d:\", i);\n\t\tshow_card(c[i]);\n\t}\n\tprintf(\"\\nsets:\\n\");\n\n\tfor (i = 0; i < s; i++) {\n\t\tfor (j = 0; j < 3; j++) {\n\t\t\tprintf(\"%2d:\", csets[i][j]);\n\t\t\tshow_card(c[csets[i][j]]);\n\t\t}\n\t\tputchar('\\n');\n\t}\n}\n\nint main(void)\n{\n\tinit_sets();\n\tdeal_sets(9, 4);\n\n\twhile (1) deal_sets(12, 6);\n\n\treturn 0;\n}\n","Rust":"use itertools::Itertools;\nuse rand::Rng;\n\nconst DECK_SIZE: usize = 81;\nconst NUM_ATTRIBUTES: usize = 4;\nconst ATTRIBUTES: [&[&str]; NUM_ATTRIBUTES] = [\n &[\"red\", \"green\", \"purple\"],\n &[\"one\", \"two\", \"three\"],\n &[\"oval\", \"squiggle\", \"diamond\"],\n &[\"solid\", \"open\", \"striped\"],\n];\n\nfn get_random_card_indexes(num_of_cards: usize) -> Vec<usize> {\n let mut selected_cards: Vec<usize> = Vec::with_capacity(num_of_cards);\n let mut rng = rand::thread_rng();\n loop {\n let idx = rng.gen_range(0..DECK_SIZE);\n if !selected_cards.contains(&idx) {\n selected_cards.push(idx);\n }\n if selected_cards.len() == num_of_cards {\n break;\n }\n }\n\n selected_cards\n}\n\nfn run_game(num_of_cards: usize, minimum_number_of_sets: usize) {\n println!(\n \"\\nGAME: # of cards: {} # of sets: {}\",\n num_of_cards, minimum_number_of_sets\n );\n\n \n let deck = (0..NUM_ATTRIBUTES)\n .map(|_| (0..=2_usize))\n .multi_cartesian_product()\n .collect::<Vec<_>>();\n\n \n let valid_attribute =\n |a: usize, b: usize, c: usize| -> bool { a == b && b == c || (a != b && b != c && a != c) };\n\n \n let valid_set = |t: &Vec<&Vec<usize>>| -> bool {\n for attr in 0..NUM_ATTRIBUTES {\n if !valid_attribute(t[0][attr], t[1][attr], t[2][attr]) {\n return false;\n }\n }\n true\n };\n\n loop {\n \n let selected_cards = get_random_card_indexes(num_of_cards)\n .iter()\n .map(|idx| deck[*idx].clone())\n .collect::<Vec<_>>();\n\n \n let valid_sets = selected_cards\n .iter()\n .combinations(3)\n .filter(|triplet| valid_set(triplet))\n .collect::<Vec<_>>();\n\n \n if valid_sets.len() == minimum_number_of_sets {\n print!(\"SELECTED CARDS:\");\n for card in &selected_cards {\n print!(\"\\ncard: \");\n for attr in 0..NUM_ATTRIBUTES {\n print!(\"{}, \", ATTRIBUTES[attr][card[attr]]);\n }\n }\n\n print!(\"\\nSets:\");\n for triplet in &valid_sets {\n print!(\"\\nSet: \");\n for card in triplet {\n for attr in 0..NUM_ATTRIBUTES {\n print!(\"{}, \", ATTRIBUTES[attr][card[attr]]);\n }\n print!(\" | \");\n }\n }\n\n break;\n }\n\n \n }\n}\nfn main() {\n run_game(9, 4);\n run_game(12, 6);\n}\n"} {"name":"Short-circuit evaluation","C":"#include <stdio.h>\n#include <stdbool.h>\n\nbool a(bool in)\n{\n printf(\"I am a\\n\");\n return in;\n}\n\nbool b(bool in)\n{\n printf(\"I am b\\n\");\n return in;\n}\n\n#define TEST(X,Y,O)\t\t\t\t\t\t\\\n do {\t\t\t\t\t\t\t\t\\\n x = a(X) O b(Y);\t\t\t\t\t\t\\\n printf(#X \" \" #O \" \" #Y \" = %s\\n\\n\", x\u00a0? \"true\"\u00a0: \"false\");\t\\\n } while(false);\n\nint main()\n{\n bool x;\n\n TEST(false, true, &&); \n TEST(true, false, ||); \n TEST(true, false, &&); \n TEST(false, false, ||); \n\n return 0;\n}\n","Rust":"fn a(foo: bool) -> bool {\n println!(\"a\");\n foo\n}\n\nfn b(foo: bool) -> bool {\n println!(\"b\");\n foo\n}\n\nfn main() {\n for i in vec![true, false] {\n for j in vec![true, false] {\n println!(\"{} and {} == {}\", i, j, a(i) && b(j));\n println!(\"{} or {} == {}\", i, j, a(i) || b(j));\n println!();\n }\n }\n}\n"} {"name":"Show ASCII table","C":"#include <stdio.h>\n\nint main() {\n int i, j;\n char k[4];\n for (i = 0; i < 16; ++i) {\n for (j = 32 + i; j < 128; j += 16) {\n switch (j) {\n default: sprintf(k, \"%c\", j); break;\n case 32: sprintf(k, \"Spc\"); break;\n case 127: sprintf(k, \"Del\"); break;\n }\n printf(\"%3d\u00a0:\u00a0%-3s \", j, k);\n }\n printf(\"\\n\");\n }\n return 0;\n}\n","Rust":"fn main() {\n for i in 0u8..16 {\n for j in ((32+i)..128).step_by(16) {\n let k = (j as char).to_string();\n print!(\"{:3}\u00a0: {:<3} \", j, match j {\n 32 => \"Spc\",\n 127 => \"Del\",\n _ => &k,\n });\n }\n println!();\n }\n}\n"} {"name":"Show the (decimal) value of a number of 1s appended with a 3, then squared","C":"#include <stdio.h>\n#include <stdint.h>\n\nuint64_t ones_plus_three(uint64_t ones) {\n uint64_t r = 0;\n while (ones--) r = r*10 + 1;\n return r*10 + 3;\n}\n\nint main() {\n uint64_t n;\n for (n=0; n<8; n++) {\n uint64_t x = ones_plus_three(n);\n printf(\"%8lu^2 = %15lu\\n\", x, x*x);\n }\n return 0;\n}\n","Rust":"fn main() {\n let mut big_squares : Vec<u64> = Vec::new( ) ;\n let mut numberstrings : Vec<String> = Vec::new( ) ;\n for n in 0..8 {\n let mut numberstring : String = String::new( ) ;\n for i in 0..=n {\n if i != 0 {\n numberstring.push( '1' ) ;\n }\n }\n numberstring.push('3') ;\n let number : u64 = numberstring.parse::<u64>().unwrap( ) ;\n numberstrings.push( numberstring ) ;\n big_squares.push( number.pow( 2 )) ;\n }\n for i in 0..numberstrings.len( ) {\n print!(\"{} ^ 2 =\" , numberstrings[ i ] ) ;\n let width = 30 - (7 + i ) ;\n println!(\"{:>width$}\" , big_squares[ i ] ) ;\n }\n}\n"} {"name":"Show the epoch","C":"#include <time.h>\n#include <stdio.h>\n\nint main() {\n time_t t = 0;\n printf(\"%s\", asctime(gmtime(&t)));\n return 0;\n}\n","Rust":"extern crate time;\n\nuse time::{at_utc, Timespec};\n\nfn main() {\n let epoch = at_utc(Timespec::new(0, 0)); \n println!(\"{}\", epoch.asctime());\n}\n"} {"name":"Sierpinski carpet","C":"#include <stdio.h>\n\nint main()\n{\n\tint i, j, dim, d;\n\tint depth = 3;\n\n\tfor (i = 0, dim = 1; i < depth; i++, dim *= 3);\n\n\tfor (i = 0; i < dim; i++) {\n\t\tfor (j = 0; j < dim; j++) {\n\t\t\tfor (d = dim \/ 3; d; d \/= 3)\n\t\t\t\tif ((i % (d * 3)) \/ d == 1 && (j % (d * 3)) \/ d == 1)\n\t\t\t\t\tbreak;\n\t\t\tprintf(d ? \" \" : \"##\");\n\t\t}\n\t\tprintf(\"\\n\");\n\t}\n\n\treturn 0;\n}\n","Rust":"fn main() {\n for i in 0..4 {\n println!(\"\\nN={}\", i);\n println!(\"{}\", sierpinski_carpet(i));\n }\n}\n\nfn sierpinski_carpet(n: u32) -> String {\n let mut carpet = vec![\"#\".to_string()];\n for _ in 0..n {\n let mut top: Vec<_> = carpet.iter().map(|x| x.repeat(3)).collect();\n let middle: Vec<_> = carpet\n .iter()\n .map(|x| x.to_string() + &x.replace(\"#\", \" \") + x)\n .collect();\n let bottom = top.clone();\n\n top.extend(middle);\n top.extend(bottom);\n carpet = top;\n }\n carpet.join(\"\\n\")\n}\n"} {"name":"Sierpinski triangle","C":"#include <stdio.h>\n\n#define SIZE (1 << 4)\nint main()\n{\n\tint x, y, i;\n\tfor (y = SIZE - 1; y >= 0; y--, putchar('\\n')) {\n\t\tfor (i = 0; i < y; i++) putchar(' ');\n\t\tfor (x = 0; x + y < SIZE; x++)\n\t\t\tprintf((x & y) ? \" \" : \"* \");\n\t}\n\treturn 0;\n}\n","Rust":"use std::iter::repeat;\n\nfn sierpinski(order: usize) {\n let mut triangle = vec![\"*\".to_string()];\n for i in 0..order {\n let space = repeat(' ').take(2_usize.pow(i as u32)).collect::<String>();\n\n \n let mut d = triangle.clone();\n\n \n d.iter_mut().for_each(|r| {\n let new_row = format!(\"{}{}{}\", space, r, space);\n *r = new_row;\n });\n\n \n triangle.iter().for_each(|r| {\n let new_row = format!(\"{}{}{}\", r, \" \", r);\n d.push(new_row);\n });\n\n triangle = d;\n }\n\n triangle.iter().for_each(|r| println!(\"{}\", r));\n}\nfn main() {\n let order = std::env::args()\n .nth(1)\n .unwrap_or_else(|| \"4\".to_string())\n .parse::<usize>()\n .unwrap();\n\n sierpinski(order);\n}\n"} {"name":"Sieve of Eratosthenes","C":"#include <stdlib.h>\n#include <math.h>\n\nchar*\neratosthenes(int n, int *c)\n{\n\tchar* sieve;\n\tint i, j, m;\n\n\tif(n < 2)\n\t\treturn NULL;\n\n\t*c = n-1; \n\tm = (int) sqrt((double) n);\n\n\t\n\tsieve = calloc(n+1,sizeof(char));\n\tsieve[0] = 1;\n\tsieve[1] = 1;\n\tfor(i = 2; i <= m; i++)\n\t\tif(!sieve[i])\n\t\t\tfor (j = i*i; j <= n; j += i)\n\t\t\t\tif(!sieve[j]){\n\t\t\t\t\tsieve[j] = 1; \n\t\t\t\t\t--(*c);\n\t\t\t\t}\n \treturn sieve;\n}\n","Rust":"fn primes(n: usize) -> impl Iterator<Item = usize> {\n const START: usize = 2;\n if n < START {\n Vec::new()\n } else {\n let mut is_prime = vec![true; n + 1 - START];\n let limit = (n as f64).sqrt() as usize;\n for i in START..limit + 1 {\n let mut it = is_prime[i - START..].iter_mut().step_by(i);\n if let Some(true) = it.next() {\n it.for_each(|x| *x = false);\n }\n }\n is_prime\n }\n .into_iter()\n .enumerate()\n .filter_map(|(e, b)| if b { Some(e + START) } else { None })\n}\n"} {"name":"Simple windowed application","C":"#include <stdio.h>\n#include <gtk\/gtk.h>\n\nconst gchar *clickme = \"Click Me\";\nguint counter = 0;\n\n#define MAXLEN 64\nvoid clickedme(GtkButton *o, gpointer d)\n{\n GtkLabel *l = GTK_LABEL(d);\n char nt[MAXLEN];\n \n counter++;\n snprintf(nt, MAXLEN, \"You clicked me %d times\", counter);\n gtk_label_set_text(l, nt);\n}\n\nint main(int argc, char **argv)\n{\n GtkWindow *win;\n GtkButton *button;\n GtkLabel *label;\n GtkVBox *vbox;\n\n gtk_init(&argc, &argv);\n win = (GtkWindow*)gtk_window_new(GTK_WINDOW_TOPLEVEL);\n gtk_window_set_title(win, clickme);\n button = (GtkButton*)gtk_button_new_with_label(clickme);\n label = (GtkLabel*)gtk_label_new(\"There have been no clicks yet\");\n gtk_label_set_single_line_mode(label, TRUE);\n vbox = (GtkVBox*)gtk_vbox_new(TRUE, 1);\n gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(label));\n gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(button));\n gtk_container_add(GTK_CONTAINER(win), GTK_WIDGET(vbox));\n g_signal_connect(G_OBJECT(win), \"delete-event\", (GCallback)gtk_main_quit, NULL);\n g_signal_connect(G_OBJECT(button), \"clicked\", (GCallback)clickedme, label);\n gtk_widget_show_all(GTK_WIDGET(win));\n gtk_main();\n return 0;\n}\n","Rust":"use iced::{ \n button, Button, Column, Element, Length,\n Text, Sandbox, Settings, Space,\n};\n\n#[derive(Debug, Copy, Clone)]\nstruct Pressed;\nstruct Simple {\n value: i32,\n button: button::State,\n}\n\nimpl Sandbox for Simple {\n type Message = Pressed;\n\n fn new() -> Simple {\n Simple {\n value: 0,\n button: button::State::new(),\n }\n }\n\n fn title(&self) -> String {\n \"Simple Windowed Application\".into()\n }\n\n fn view(&mut self) -> Element<Self::Message> {\n Column::new()\n .padding(20)\n .push({\n let text = match self.value {\n 0 => \"there have been no clicks yet\".into(),\n 1 => \"there has been 1 click\".into(),\n n => format!(\"there have been {} clicks\", n),\n };\n Text::new(text).size(24)\n }).push(\n Space::with_height(Length::Fill)\n ).push(\n Button::new(&mut self.button, Text::new(\"Click Me!\"))\n .on_press(Pressed)\n ).into()\n }\n\n fn update(&mut self, _: Self::Message) {\n self.value += 1;\n }\n}\n\nfn main() {\n let mut settings = Settings::default();\n settings.window.size = (600, 400);\n Simple::run(settings).unwrap();\n}\n"} {"name":"Singly-linked list_Element definition","C":"struct link {\n struct link *next;\n int data;\n};\n","Rust":" struct Node<T> {\n elem: T,\n next: Option<Box<Node<T>>>,\n}\n"} {"name":"Singly-linked list_Element insertion","C":"void insert_append (struct link *anchor, struct link *newlink) {\n newlink->next = anchor->next;\n anchor->next = newlink;\n}\n","Rust":"impl<T> List<T> {\n pub fn new() -> Self {\n List { head: None }\n }\n\n pub fn push(&mut self, elem: T) {\n let new_node = Box::new(Node {\n elem: elem,\n next: self.head.take(),\n });\n self.head = Some(new_node);\n}\n"} {"name":"Singly-linked list_Traversal","C":"struct link *first;\n\nstruct link *iter;\nfor(iter = first; iter != NULL; iter = iter->next) {\n \n}\n","Rust":"\n\n\n\n\npub struct IntoIter<T>(List<T>);\n\nimpl<T> Iterator for IntoIter<T> {\n type Item = T;\n fn next(&mut self) -> Option<Self::Item> {\n self.0.head.take().map(|node| { \n let node = *node;\n self.0.head = node.next;\n node.elem\n })\n }\n}\n\n\n\n\n\n\n\npub struct Iter<'a, T: 'a> {\n next: Option<&'a Node<T>>,\n}\n\nimpl<'a, T> Iterator for Iter<'a, T> {\n type Item = &'a T;\n fn next(&mut self) -> Option<Self::Item> {\n self.next.take().map(|node| {\n self.next = node.next.as_ref().map(|node| &**node);\n &node.elem\n })\n }\n}\n\n\n\n\n\n\n\npub struct IterMut<'a, T: 'a> {\n next: Option<&'a mut Node<T>>,\n}\n\nimpl<'a, T> Iterator for IterMut<'a, T> {\n type Item = &'a mut T;\n fn next(&mut self) -> Option<Self::Item> {\n self.next.take().map(|node| {\n self.next = node.next.as_mut().map(|node| &mut **node);\n &mut node.elem\n })\n }\n}\n\n\n\n\n\n\n\nimpl<T> List<T> {\n pub fn into_iter(self) -> IntoIter<T> {\n IntoIter(self)\n }\n\n pub fn iter<'a>(&'a self) -> Iter<'a,T> {\n Iter { next: self.head.as_ref().map(|node| &**node) }\n }\n\n pub fn iter_mut(&mut self) -> IterMut<T> {\n IterMut { next: self.head.as_mut().map(|node| &mut **node) }\n }\n\n}\n"} {"name":"Sleep","C":"#include <stdio.h>\n#include <unistd.h>\n\nint main()\n{\n unsigned int seconds;\n scanf(\"%u\", &seconds);\n printf(\"Sleeping...\\n\");\n sleep(seconds);\n printf(\"Awake!\\n\");\n return 0;\n}\n","Rust":"use std::{io, time, thread};\n\nfn main() {\n println!(\"How long should we sleep in milliseconds?\");\n \n let mut sleep_string = String::new();\n\n io::stdin().read_line(&mut sleep_string)\n .expect(\"Failed to read line\");\n\n let sleep_timer: u64 = sleep_string.trim()\n .parse()\n .expect(\"Not an integer\");\n let sleep_duration = time::Duration::from_millis(sleep_timer);\n \n println!(\"Sleeping...\");\n thread::sleep(sleep_duration);\n println!(\"Awake!\");\n}\n"} {"name":"Smith numbers","C":"#include <stdlib.h>\n#include <stdio.h>\n#include <stdbool.h>\n\nint numPrimeFactors(unsigned x) {\n unsigned p = 2;\n int pf = 0;\n if (x == 1)\n return 1;\n else {\n while (true) {\n if (!(x % p)) {\n pf++;\n x \/= p;\n if (x == 1)\n return pf;\n }\n else\n ++p;\n }\n }\n}\n\nvoid primeFactors(unsigned x, unsigned* arr) {\n unsigned p = 2;\n int pf = 0;\n if (x == 1)\n arr[pf] = 1;\n else {\n while (true) {\n if (!(x % p)) {\n arr[pf++] = p;\n x \/= p;\n if (x == 1)\n return;\n }\n else\n p++;\n }\n }\n}\n\nunsigned sumDigits(unsigned x) {\n unsigned sum = 0, y;\n while (x) {\n y = x % 10;\n sum += y;\n x \/= 10;\n }\n return sum;\n}\n\nunsigned sumFactors(unsigned* arr, int size) {\n unsigned sum = 0;\n for (int a = 0; a < size; a++)\n sum += sumDigits(arr[a]);\n return sum;\n}\n\nvoid listAllSmithNumbers(unsigned x) {\n unsigned *arr;\n for (unsigned a = 4; a < x; a++) {\n int numfactors = numPrimeFactors(a);\n arr = (unsigned*)malloc(numfactors * sizeof(unsigned));\n if (numfactors < 2)\n continue;\t\n primeFactors(a, arr);\t\n if (sumDigits(a) == sumFactors(arr,numfactors))\n printf(\"%4u \",a);\n free(arr);\n }\n}\n\nint main(int argc, char* argv[]) {\n printf(\"All the Smith Numbers < 10000 are:\\n\");\n listAllSmithNumbers(10000);\n return 0;\n}\n","Rust":"fn main () {\n \n let primes = vec![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 let mut solution = Vec::new();\n let mut number;\n for i in 4..10000 {\n \n let mut prime_factors = Vec::new();\n number = i;\n for j in &primes {\n while number % j == 0 {\n number = number \/ j;\n prime_factors.push(j);\n }\n if number == 1 { break; }\n }\n \n if number != 1 { prime_factors.push(&number); }\n \n if prime_factors.len() < 2 { continue; }\n \n if prime_factors.iter().fold(0, |n,x| n + x.to_string().chars().map(|d| d.to_digit(10).unwrap()).fold(0, |n,x| n + x)) \n == i.to_string().chars().map(|d| d.to_digit(10).unwrap()).fold(0, |n,x| n + x) {\n solution.push(i);\n }\n }\n println!(\"Smith numbers below 10000 ({})\u00a0: {:?}\",solution.len(), solution);\n}\n"} {"name":"Sockets","C":"#include <stdio.h>\n#include <string.h>\n#include <sys\/types.h>\n#include <sys\/socket.h>\n#include <netdb.h>\n\nconst char *msg = \"hello socket world\";\n\nint main()\n{\n int i, sock, len, slen;\n\n struct addrinfo hints, *addrs; \n memset(&hints, 0, sizeof(struct addrinfo));\n hints.ai_family = AF_UNSPEC;\n hints.ai_socktype = SOCK_STREAM;\n \n if (0 == getaddrinfo(\"localhost\", \"256\", &hints, &addrs))\n {\n sock = socket(addrs->ai_family, addrs->ai_socktype, addrs->ai_protocol);\n if ( sock >= 0 )\n {\n if ( connect(sock, addrs->ai_addr, addrs->ai_addrlen) >= 0 )\n {\n const char *pm = msg;\n do\n {\n len = strlen(pm);\n slen = send(sock, pm, len, 0);\n pm += slen;\n } while ((0 <= slen) && (slen < len));\n }\n close(sock);\n }\n freeaddrinfo(addrs);\n }\n}\n","Rust":"use std::io::prelude::*;\nuse std::net::TcpStream;\n\nfn main() {\n \n let mut my_stream = TcpStream::connect(\"127.0.0.1:256\").unwrap();\n\n \n let _ = my_stream.write(b\"hello socket world\");\n\n} \n"} {"name":"Soloway's recurring rainfall","C":"#include <stdio.h>\n\nint main(int argc, char **argv)\n{\n\t\n\t(void)argc;\n\t(void)argv;\n\t\n\tfloat currentAverage = 0;\n\tunsigned int currentEntryNumber = 0;\n\t\n\tfor (;;)\n\t{\n\t\tint ret, entry;\n\t\t\n\t\tprintf(\"Enter rainfall int, 99999 to quit: \");\n\t\tret = scanf(\"%d\", &entry);\n\t\t\n\t\tif (ret)\n\t\t{\n\t\t\tif (entry == 99999)\n\t\t\t{\n\t\t\t\tprintf(\"User requested quit.\\n\");\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcurrentEntryNumber++;\n\t\t\t\tcurrentAverage = currentAverage + (1.0f\/currentEntryNumber)*entry - (1.0f\/currentEntryNumber)*currentAverage;\n\t\t\t\t\n\t\t\t\tprintf(\"New Average: %f\\n\", currentAverage);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tprintf(\"Invalid input\\n\");\n\t\t\twhile (getchar() != '\\n');\t\n\t\t}\n\t}\n\t\n\treturn 0;\n}\n","Rust":"fn main() {\n\t\n\tlet mut current_average:f32 = 0.0;\n\tlet mut current_entry_number:u32 = 0;\n\t\n\tloop\n\t{\n\t\tlet current_entry;\n\n\t\tprintln!(\"Enter rainfall int, 99999 to quit: \"); \n\t\tlet mut input_text = String::new();\n\t\tstd::io::stdin().read_line(&mut input_text).expect(\"Failed to read from stdin\");\n\t\tlet trimmed = input_text.trim();\n\t\tmatch trimmed.parse::<u32>() {\n\t\t\tOk(new_entry) => current_entry = new_entry,\n\t\t\tErr(..) => { println!(\"Invalid input\"); continue; }\n\t\t};\n\n\t\tif current_entry == 99999\n\t\t{\n\t\t\tprintln!(\"User requested quit.\");\n\t\t\tbreak;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tcurrent_entry_number = current_entry_number + 1;\n\t\t\tcurrent_average = current_average + (1.0 \/ current_entry_number as f32)*(current_entry as f32) - (1.0 \/ current_entry_number as f32)*current_average;\n\n\t\t\tprintln!(\"New Average: {}\", current_average);\n\t\t}\n\t}\n}\n"} {"name":"Sort a list of object identifiers","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct oid_tag {\n char* str_;\n int* numbers_;\n int length_;\n} oid;\n\n\nvoid oid_destroy(oid* p) {\n if (p != 0) {\n free(p->str_);\n free(p->numbers_);\n free(p);\n }\n}\n\nint char_count(const char* str, char ch) {\n int count = 0;\n for (const char* p = str; *p; ++p) {\n if (*p == ch)\n ++count;\n }\n return count;\n}\n\n\n\noid* oid_create(const char* str) {\n oid* ptr = calloc(1, sizeof(oid));\n if (ptr == 0)\n return 0;\n ptr->str_ = strdup(str);\n if (ptr->str_ == 0) {\n oid_destroy(ptr);\n return 0;\n }\n int dots = char_count(str, '.');\n ptr->numbers_ = malloc(sizeof(int) * (dots + 1));\n if (ptr->numbers_ == 0) {\n oid_destroy(ptr);\n return 0;\n }\n ptr->length_ = dots + 1;\n const char* p = str;\n for (int i = 0; i <= dots && *p;) {\n char* eptr = 0;\n int num = strtol(p, &eptr, 10);\n if (*eptr != 0 && *eptr != '.') {\n \n oid_destroy(ptr);\n return 0;\n }\n ptr->numbers_[i++] = num;\n p = eptr;\n if (*p)\n ++p;\n }\n return ptr;\n}\n\n\nint oid_compare(const void* p1, const void* p2) {\n const oid* o1 = *(oid* const*)p1;\n const oid* o2 = *(oid* const*)p2;\n int i1 = 0, i2 = 0;\n for (; i1 < o1->length_ && i2 < o2->length_; ++i1, ++i2) {\n if (o1->numbers_[i1] < o2->numbers_[i2])\n return -1;\n if (o1->numbers_[i1] > o2->numbers_[i2])\n return 1;\n }\n if (o1->length_ < o2->length_)\n return -1;\n if (o1->length_ > o2->length_)\n return 1;\n return 0;\n}\n\nint main() {\n const char* input[] = {\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.10\",\n \"1.3.6.1.4.1.11.2.17.5.2.0.79\",\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.4\",\n \"1.3.6.1.4.1.11150.3.4.0.1\",\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.1\",\n \"1.3.6.1.4.1.11150.3.4.0\"\n };\n const int len = sizeof(input)\/sizeof(input[0]);\n oid* oids[len];\n memset(oids, 0, sizeof(oids));\n int i;\n for (i = 0; i < len; ++i) {\n oids[i] = oid_create(input[i]);\n if (oids[i] == 0)\n {\n fprintf(stderr, \"Out of memory\\n\");\n goto cleanup;\n }\n }\n qsort(oids, len, sizeof(oid*), oid_compare);\n for (i = 0; i < len; ++i)\n puts(oids[i]->str_);\ncleanup:\n for (i = 0; i < len; ++i)\n oid_destroy(oids[i]);\n return 0;\n}\n","Rust":"fn split(s: &str) -> impl Iterator<Item = u64> + '_ {\n s.split('.').map(|x| x.parse().unwrap())\n}\n\nfn main() {\n let mut oids = vec![\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.10\",\n \"1.3.6.1.4.1.11.2.17.5.2.0.79\",\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.4\",\n \"1.3.6.1.4.1.11150.3.4.0.1\",\n \"1.3.6.1.4.1.11.2.17.19.3.4.0.1\",\n \"1.3.6.1.4.1.11150.3.4.0\",\n ];\n\n oids.sort_by(|a, b| Iterator::cmp(split(a), split(b)));\n \n println!(\"{:#?}\", oids);\n}\n"} {"name":"Sort an array of composite structures","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <ctype.h>\n\ntypedef struct twoStringsStruct {\n char * key, *value;\n} sTwoStrings;\n \nint ord( char v )\n{\n static char *dgts = \"012345679\";\n char *cp;\n for (cp=dgts; v != *cp; cp++);\n return (cp-dgts);\n}\n\nint cmprStrgs(const sTwoStrings *s1,const sTwoStrings *s2)\n{\n char *p1 = s1->key; \n char *p2 = s2->key;\n char *mrk1, *mrk2;\n while ((tolower(*p1) == tolower(*p2)) && *p1) { p1++; p2++;}\n if (isdigit(*p1) && isdigit(*p2)) {\n long v1, v2;\n if ((*p1 == '0') ||(*p2 == '0')) {\n while (p1 > s1->key) {\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->key, p2=s2->key; (*p1 == *p2) && *p1; p1++, p2++);\n return (*p1 -*p2);\n}\n\nint maxstrlen( char *a, char *b)\n{\n\tint la = strlen(a);\n\tint lb = strlen(b);\n\treturn (la>lb)? la : lb;\n}\n\nint main()\n{\n sTwoStrings toBsorted[] = {\n { \"Beta11a\", \"many\" },\n { \"alpha1\", \"This\" },\n { \"Betamax\", \"sorted.\" },\n { \"beta3\", \"order\" },\n { \"beta11a\", \"strings\" },\n { \"beta001\", \"is\" },\n { \"beta11\", \"which\" },\n { \"beta041\", \"be\" },\n { \"beta05\", \"in\" },\n { \"beta1\", \"the\" },\n { \"beta40\", \"should\" },\n };\n#define ASIZE (sizeof(toBsorted)\/sizeof(sTwoStrings))\n int k, maxlens[ASIZE];\n char format[12];\n sTwoStrings *cp;\n\n qsort( (void*)toBsorted, ASIZE, sizeof(sTwoStrings),cmprStrgs); \n\n for (k=0,cp=toBsorted; k < ASIZE; k++,cp++) {\n maxlens[k] = maxstrlen(cp->key, cp->value); \n sprintf(format,\"\u00a0%%-%ds\", maxlens[k]);\n printf(format, toBsorted[k].value);\n\t}\n printf(\"\\n\");\n for (k=0; k < ASIZE; k++) {\n sprintf(format,\"\u00a0%%-%ds\", maxlens[k]);\n printf(format, toBsorted[k].key);\n\t}\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"use std::cmp::Ordering;\n\n#[derive(Debug)]\nstruct Employee {\n name: String,\n category: String,\n}\n\nimpl Employee {\n fn new(name: &str, category: &str) -> Self {\n Employee {\n name: name.into(),\n category: category.into(),\n }\n }\n}\n\nimpl PartialEq for Employee {\n fn eq(&self, other: &Self) -> bool {\n self.name == other.name\n }\n}\n\nimpl Eq for Employee {}\n\nimpl PartialOrd for Employee {\n fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n Some(self.cmp(other))\n }\n}\n\nimpl Ord for Employee {\n fn cmp(&self, other: &Self) -> Ordering {\n self.name.cmp(&other.name)\n }\n}\n\nfn main() {\n let mut employees = vec![\n Employee::new(\"David\", \"Manager\"),\n Employee::new(\"Alice\", \"Sales\"),\n Employee::new(\"Joanna\", \"Director\"),\n Employee::new(\"Henry\", \"Admin\"),\n Employee::new(\"Tim\", \"Sales\"),\n Employee::new(\"Juan\", \"Admin\"),\n ];\n employees.sort();\n for e in employees {\n println!(\"{:<6}\u00a0: {}\", e.name, e.category);\n }\n}\n"} {"name":"Sort an integer array","C":"#include <stdlib.h> \n#include <stdio.h> \n\nint intcmp(const void *aa, const void *bb)\n{\n const int *a = aa, *b = bb;\n return (*a < *b) ? -1 : (*a > *b);\n}\n\nint main()\n{\n int nums[5] = {2,4,3,1,2};\n qsort(nums, 5, sizeof(int), intcmp);\n printf(\"result: %d %d %d %d %d\\n\",\n nums[0], nums[1], nums[2], nums[3], nums[4]);\n return 0;\n}\n","Rust":"fn main() {\n let mut a = vec!(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);\n\n a.sort();\n println!(\"{:?}\", a);\n}\n"} {"name":"Sort disjoint sublist","C":"#include <stdio.h>\n\n\nvoid bubble_sort(int *idx, int n_idx, int *buf)\n{\n int i, j, tmp;\n#define for_ij for (i = 0; i < n_idx; i++) for (j = i + 1; j < n_idx; j++)\n#define sort(a, b) if (a < b) { tmp = a; a = b; b = tmp;}\n for_ij { sort(idx[j], idx[i]); }\n for_ij { sort(buf[idx[j]], buf[idx[i]]);}\n#undef for_ij\n#undef sort\n}\n\nint main()\n{\n int values[] = {7, 6, 5, 4, 3, 2, 1, 0};\n int idx[] = {6, 1, 7};\n int i;\n\n printf(\"before sort:\\n\");\n for (i = 0; i < 8; i++)\n printf(\"%d \", values[i]);\n\n printf(\"\\n\\nafter sort:\\n\");\n bubble_sort(idx, 3, values);\n\n for (i = 0; i < 8; i++)\n printf(\"%d \", values[i]);\n printf(\"\\n\");\n\n return 0;\n}\n","Rust":"use std::collections::BTreeSet;\n\nfn disjoint_sort(array: &mut [impl Ord], indices: &[usize]) {\n let mut sorted = indices.to_owned();\n sorted.sort_unstable_by_key(|k| &array[*k]);\n indices\n .iter()\n .zip(sorted.iter())\n .map(|(&a, &b)| if a > b { (b, a) } else { (a, b) })\n .collect::<BTreeSet<_>>()\n .iter()\n .for_each(|(a, b)| array.swap(*a, *b))\n}\n\nfn main() {\n let mut array = [7, 6, 5, 4, 3, 2, 1, 0];\n let indices = [6, 1, 7];\n disjoint_sort(&mut array, &indices);\n println!(\"{:?}\", array);\n}\n"} {"name":"Sort numbers lexicographically","C":"#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nint compareStrings(const void *a, const void *b) {\n const char **aa = (const char **)a;\n const char **bb = (const char **)b;\n return strcmp(*aa, *bb);\n}\n\nvoid lexOrder(int n, int *ints) {\n char **strs;\n int i, first = 1, last = n, k = n, len;\n if (n < 1) {\n first = n; last = 1; k = 2 - n;\n } \n strs = malloc(k * sizeof(char *));\n for (i = first; i <= last; ++i) {\n if (i >= 1) len = (int)log10(i) + 2;\n else if (i == 0) len = 2;\n else len = (int)log10(-i) + 3; \n strs[i-first] = malloc(len);\n sprintf(strs[i-first], \"%d\", i);\n }\n qsort(strs, k, sizeof(char *), compareStrings);\n for (i = 0; i < k; ++i) {\n ints[i] = atoi(strs[i]);\n free(strs[i]);\n }\n free(strs);\n}\n\nint main() {\n int i, j, k, n, *ints;\n int numbers[5] = {0, 5, 13, 21, -22};\n printf(\"In lexicographical order:\\n\\n\");\n for (i = 0; i < 5; ++i) {\n k = n = numbers[i];\n if (k < 1) k = 2 - k;\n ints = malloc(k * sizeof(int));\n lexOrder(n, ints);\n printf(\"%3d: [\", n);\n for (j = 0; j < k; ++j) {\n printf(\"%d \", ints[j]);\n }\n printf(\"\\b]\\n\");\n free(ints);\n }\n return 0;\n}\n","Rust":"fn lex_sorted_vector(num: i32) -> Vec<i32> {\n let (min, max) = if num >= 1 { (1, num) } else { (num, 1) };\n let mut str: Vec<String> = (min..=max).map(|i| i.to_string()).collect();\n str.sort();\n str.iter().map(|s| s.parse::<i32>().unwrap()).collect()\n}\n\nfn main() {\n for n in &[0, 5, 13, 21, -22] {\n println!(\"{}: {:?}\", n, lex_sorted_vector(*n));\n }\n}\n"} {"name":"Sort three variables","C":"#include<string.h>\n#include<stdlib.h>\n#include<stdio.h>\n\n#define MAX 3\n\nint main()\n{\n char values[MAX][100],tempStr[100];\n int i,j,isString=0;\n double val[MAX],temp;\n \n for(i=0;i<MAX;i++){\n printf(\"Enter %d%s value\u00a0: \",i+1,(i==0)?\"st\":((i==1)?\"nd\":\"rd\"));\n fgets(values[i],100,stdin);\n \n for(j=0;values[i][j]!=00;j++){\n if(((values[i][j]<'0' || values[i][j]>'9') && (values[i][j]!='.' ||values[i][j]!='-'||values[i][j]!='+'))\n ||((values[i][j]=='.' ||values[i][j]=='-'||values[i][j]=='+')&&(values[i][j+1]<'0' || values[i][j+1]>'9')))\n isString = 1;\n }\n }\n \n if(isString==0){\n for(i=0;i<MAX;i++)\n val[i] = atof(values[i]);\n }\n \n for(i=0;i<MAX-1;i++){\n for(j=i+1;j<MAX;j++){\n if(isString==0 && val[i]>val[j]){\n temp = val[j];\n val[j] = val[i];\n val[i] = temp;\n }\n \n else if(values[i][0]>values[j][0]){\n strcpy(tempStr,values[j]);\n strcpy(values[j],values[i]);\n strcpy(values[i],tempStr);\n }\n }\n }\n \n for(i=0;i<MAX;i++)\n isString==1?printf(\"%c = %s\",'X'+i,values[i]):printf(\"%c = %lf\",'X'+i,val[i]);\n \n return 0;\n}\n","Rust":"fn main() {\n let mut array = [5, 1, 3];\n array.sort();\n println!(\"Sorted: {:?}\", array);\n array.sort_by(|a, b| b.cmp(a));\n println!(\"Reverse sorted: {:?}\", array);\n}\n"} {"name":"Sort using a custom comparator","C":"#include <stdlib.h> \n#include <string.h> \n#include <strings.h> \n\nint mycmp(const void *s1, const void *s2)\n{\n const char *l = *(const char **)s1, *r = *(const char **)s2;\n size_t ll = strlen(l), lr = strlen(r);\n\n if (ll > lr) return -1;\n if (ll < lr) return 1;\n return strcasecmp(l, r);\n}\n\nint main()\n{\n const char *strings[] = {\n \"Here\", \"are\", \"some\", \"sample\", \"strings\", \"to\", \"be\", \"sorted\" };\n\n qsort(strings, sizeof(strings)\/sizeof(*strings), sizeof(*strings), mycmp);\n return 0;\n}\n","Rust":"fn main() {\n let mut words = [\"Here\", \"are\", \"some\", \"sample\", \"strings\", \"to\", \"be\", \"sorted\"];\n words.sort_by(|l, r| Ord::cmp(&r.len(), &l.len()).then(Ord::cmp(l, r)));\n println!(\"{:?}\", words);\n}\n"} {"name":"Sorting algorithms_Bogosort","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n\nbool is_sorted(int *a, int n)\n{\n while ( --n >= 1 ) {\n if ( a[n] < a[n-1] ) return false;\n }\n return true;\n}\n\nvoid shuffle(int *a, int n)\n{\n int i, t, r;\n for(i=0; i < n; i++) {\n t = a[i];\n r = rand() % n;\n a[i] = a[r];\n a[r] = t;\n }\n}\n\nvoid bogosort(int *a, int n)\n{\n while ( !is_sorted(a, n) ) shuffle(a, n);\n}\n\nint main()\n{\n int numbers[] = { 1, 10, 9, 7, 3, 0 };\n int i;\n\n bogosort(numbers, 6);\n for (i=0; i < 6; i++) printf(\"%d \", numbers[i]);\n printf(\"\\n\");\n}\n","Rust":"extern crate rand;\nuse rand::Rng;\n\nfn bogosort_by<T,F>(order: F, coll: &mut [T])\n where F: Fn(&T, &T) -> bool\n{\n let mut rng = rand::thread_rng();\n while !is_sorted_by(&order, coll) {\n rng.shuffle(coll);\n }\n}\n\n#[inline]\nfn is_sorted_by<T,F>(order: F, coll: &[T]) -> bool\n where F: Fn(&T,&T) -> bool,\n{\n coll[..].iter().zip(&coll[1..]).all(|(x,y)| order(x,y))\n}\n\n \nfn main() {\n let mut testlist = [1,55,88,24,990876,312,67,0,854,13,4,7];\n bogosort_by(|x,y| x < y, &mut testlist);\n println!(\"{:?}\", testlist);\n bogosort_by(|x,y| x > y, &mut testlist);\n println!(\"{:?}\", testlist);\n}\n"} {"name":"Sorting algorithms_Bubble sort","C":"#include <stdio.h>\n\nvoid bubble_sort (int *a, int n) {\n int i, t, j = n, s = 1;\n while (s) {\n s = 0;\n for (i = 1; i < j; i++) {\n if (a[i] < a[i - 1]) {\n t = a[i];\n a[i] = a[i - 1];\n a[i - 1] = t;\n s = 1;\n }\n }\n j--;\n }\n}\n\nint main () {\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 bubble_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 bubble_sort<T: Ord>(values: &mut[T]) {\n let mut n = values.len();\n let mut swapped = true;\n\n while swapped {\n swapped = false;\n\n for i in 1..n {\n if values[i - 1] > values[i] {\n values.swap(i - 1, i);\n swapped = true;\n }\n }\n\n n = n - 1;\n }\n}\n\nfn main() {\n \n let mut numbers = [8, 7, 1, 2, 9, 3, 4, 5, 0, 6];\n println!(\"Before: {:?}\", numbers);\n\n bubble_sort(&mut numbers);\n println!(\"After: {:?}\", numbers);\n\n \n let mut strings = [\"empty\", \"beach\", \"art\", \"car\", \"deal\"];\n println!(\"Before: {:?}\", strings);\n\n bubble_sort(&mut strings);\n println!(\"After: {:?}\", strings);\n}\n"} {"name":"Sorting algorithms_Cocktail sort","C":"#include <stdio.h>\n\n\nvoid swap(int *x, int *y) {\n\tif(x == y)\n\t\treturn;\n\t*x ^= *y;\n\t*y ^= *x;\n\t*x ^= *y;\n}\nvoid cocktailsort(int *a, size_t n) {\n\twhile(1) {\n\t\t\n\t\tchar flag;\n\t\tsize_t start[2] = {1, n - 1},\n\t\t\t end[2] = {n, 0},\n\t\t\t inc[2] = {1, -1};\n\t\tfor(int it = 0; it < 2; ++it) {\n\t\t\tflag = 1;\n\t\t\tfor(int i = start[it]; i != end[it]; i += inc[it])\n\t\t\t\tif(a[i - 1] > a[i]) {\n\t\t\t\t\tswap(a + i - 1, a + i);\n\t\t\t\t\tflag = 0;\n\t\t\t\t}\n\t\t\tif(flag)\n\t\t\t\treturn;\n\t\t}\n\t}\n}\n\nint main(void) {\n\tint a[] = { 5, -1, 101, -4, 0, 1, 8, 6, 2, 3 };\n\tsize_t n = sizeof(a)\/sizeof(a[0]);\n\n\tcocktailsort(a, n);\n\tfor (size_t i = 0; i < n; ++i)\n\t\tprintf(\"%d \", a[i]);\n\treturn 0;\n}\n","Rust":"fn cocktail_sort<T: PartialOrd>(a: &mut [T]) {\n let len = a.len();\n loop {\n let mut swapped = false;\n let mut i = 0;\n while i + 1 < len {\n if a[i] > a[i + 1] {\n a.swap(i, i + 1);\n swapped = true;\n }\n i += 1;\n }\n if swapped {\n swapped = false;\n i = len - 1;\n while i > 0 {\n if a[i - 1] > a[i] {\n a.swap(i - 1, i);\n swapped = true;\n }\n i -= 1;\n }\n }\n if !swapped {\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 cocktail_sort(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Sorting algorithms_Comb sort","C":"void Combsort11(double a[], int nElements)\n{\n int i, j, gap, swapped = 1;\n double temp;\n\n gap = nElements;\n while (gap > 1 || swapped == 1)\n {\n gap = gap * 10 \/ 13;\n if (gap == 9 || gap == 10) gap = 11;\n if (gap < 1) gap = 1;\n swapped = 0;\n for (i = 0, j = gap; j < nElements; i++, j++)\n {\n if (a[i] > a[j])\n {\n temp = a[i];\n a[i] = a[j];\n a[j] = temp;\n swapped = 1;\n }\n }\n }\n}\n","Rust":"fn comb_sort<T: PartialOrd>(a: &mut [T]) {\n let len = a.len();\n let mut gap = len;\n let mut swapped = true;\n while gap > 1 || swapped {\n gap = (4 * gap) \/ 5;\n if gap < 1 {\n gap = 1;\n }\n let mut i = 0;\n swapped = false;\n while i + gap < len {\n if a[i] > a[i + gap] {\n a.swap(i, i + gap);\n swapped = true;\n }\n i += 1;\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 comb_sort(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Sorting algorithms_Counting sort","C":"#include <stdio.h>\n#include <stdlib.h>\n\nvoid counting_sort_mm(int *array, int n, int min, int max)\n{\n int i, j, z;\n\n int range = max - min + 1;\n int *count = malloc(range * sizeof(*array));\n\n for(i = 0; i < range; i++) count[i] = 0;\n for(i = 0; i < n; i++) count[ array[i] - min ]++;\n\n for(i = min, z = 0; i <= max; i++) {\n for(j = 0; j < count[i - min]; j++) {\n array[z++] = i;\n }\n } \n\n free(count);\n}\n\nvoid min_max(int *array, int n, int *min, int *max)\n{\n int i;\n \n *min = *max = array[0];\n for(i=1; i < n; i++) {\n if ( array[i] < *min ) {\n *min = array[i];\n } else if ( array[i] > *max ) {\n *max = array[i];\n }\n }\n}\n","Rust":"fn counting_sort(\n mut data: Vec<usize>,\n min: usize,\n max: usize,\n) -> Vec<usize> {\n \n let mut count: Vec<usize> = Vec::with_capacity(data.len());\n count.resize(data.len(), 0);\n\n for num in &data {\n count[num - min] = count[num - min] + 1;\n }\n let mut z: usize = 0;\n for i in min..max+1 {\n while count[i - min] > 0 {\n data[z] = i;\n z += 1;\n count[i - min] = count[i - min] - 1;\n }\n }\n\n data\n}\n\nfn main() {\n let arr1 = vec![1, 0, 2, 9, 3, 8, 4, 7, 5, 6];\n println!(\"{:?}\", counting_sort(arr1, 0, 9));\n\n let arr2 = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n println!(\"{:?}\", counting_sort(arr2, 0, 9));\n\n let arr3 = vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0];\n println!(\"{:?}\", counting_sort(arr3, 0, 10));\n}\n"} {"name":"Sorting algorithms_Gnome sort","C":"void gnome_sort(int *a, int n)\n{\n int i=1, j=2, t;\n# define swap(i, j) { t = a[i]; a[i] = a[j]; a[j] = t; } \n while(i < n) {\n if (a[i - 1] > a[i]) {\n swap(i - 1, i);\n if (--i) continue;\n }\n i = j++;\n }\n# undef swap\n}\n","Rust":"fn gnome_sort<T: PartialOrd>(a: &mut [T]) {\n let len = a.len();\n let mut i: usize = 1;\n let mut j: usize = 2;\n while i < len {\n if a[i - 1] <= a[i] {\n \n i = j;\n j += 1;\n } else {\n a.swap(i - 1, i);\n i -= 1;\n if i == 0 {\n i = j;\n j += 1;\n }\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 gnome_sort(&mut v);\n println!(\"after: {:?}\", v);\n}\n"} {"name":"Sorting algorithms_Heapsort","C":"#include <stdio.h>\n\nint max (int *a, int n, int i, int j, int k) {\n int m = i;\n if (j < n && a[j] > a[m]) {\n m = j;\n }\n if (k < n && a[k] > a[m]) {\n m = k;\n }\n return m;\n}\n\nvoid downheap (int *a, int n, int i) {\n while (1) {\n int j = max(a, n, i, 2 * i + 1, 2 * i + 2);\n if (j == i) {\n break;\n }\n int t = a[i];\n a[i] = a[j];\n a[j] = t;\n i = j;\n }\n}\n\nvoid heapsort (int *a, int n) {\n int i;\n for (i = (n - 2) \/ 2; i >= 0; i--) {\n downheap(a, n, i);\n }\n for (i = 0; i < n; i++) {\n int t = a[n - i - 1];\n a[n - i - 1] = a[0];\n a[0] = t;\n downheap(a, n - i - 1, 0);\n }\n}\n\nint main () {\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 heapsort(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 main() {\n let mut v = [4, 6, 8, 1, 0, 3, 2, 2, 9, 5];\n heap_sort(&mut v, |x, y| x < y);\n println!(\"{:?}\", v);\n}\n\nfn heap_sort<T, F>(array: &mut [T], order: F)\nwhere\n F: Fn(&T, &T) -> bool,\n{\n let len = array.len();\n \n for start in (0..len \/ 2).rev() {\n shift_down(array, &order, start, len - 1)\n }\n\n for end in (1..len).rev() {\n array.swap(0, end);\n shift_down(array, &order, 0, end - 1)\n }\n}\n\nfn shift_down<T, F>(array: &mut [T], order: &F, start: usize, end: usize)\nwhere\n F: Fn(&T, &T) -> bool,\n{\n let mut root = start;\n loop {\n let mut child = root * 2 + 1;\n if child > end {\n break;\n }\n if child + 1 <= end && order(&array[child], &array[child + 1]) {\n child += 1;\n }\n if order(&array[root], &array[child]) {\n array.swap(root, child);\n root = child\n } else {\n break;\n }\n }\n}\n"} {"name":"Sorting algorithms_Insertion sort","C":"#include <stdio.h>\n\nvoid insertion_sort(int*, const size_t); \n\nvoid insertion_sort(int *a, const size_t n) {\n\tfor(size_t i = 1; i < n; ++i) {\n\t\tint key = a[i];\n\t\tsize_t j = i;\n\t\twhile( (j > 0) && (key < a[j - 1]) ) {\n\t\t\ta[j] = a[j - 1];\n\t\t\t--j;\n\t\t}\n\t\ta[j] = key;\n\t}\n}\n\nint main (int argc, char** argv) {\n\n int a[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1};\n\n const size_t n = sizeof(a) \/ sizeof(a[0]) ; \n\n for (size_t i = 0; i < n; i++)\n printf(\"%d%s\", a[i], (i == (n - 1))? \"\\n\" : \" \");\n\n insertion_sort(a, n);\n\n for (size_t i = 0; i < n; i++)\n printf(\"%d%s\", a[i], (i == (n - 1))? \"\\n\" : \" \");\n\n return 0;\n}\n","Rust":"fn insertion_sort<T: std::cmp::Ord>(arr: &mut [T]) {\n for i in 1..arr.len() {\n let mut j = i;\n while j > 0 && arr[j] < arr[j-1] {\n arr.swap(j, j-1);\n j = j-1;\n }\n }\n}\n"} {"name":"Sorting algorithms_Merge sort","C":"#include <stdio.h>\n#include <stdlib.h>\n\nvoid merge (int *a, int n, int m) {\n int i, j, k;\n int *x = malloc(n * sizeof (int));\n for (i = 0, j = m, k = 0; k < n; k++) {\n x[k] = j == n ? a[i++]\n : i == m ? a[j++]\n : a[j] < a[i] ? a[j++]\n : a[i++];\n }\n for (i = 0; i < n; i++) {\n a[i] = x[i];\n }\n free(x);\n}\n\nvoid merge_sort (int *a, int n) {\n if (n < 2)\n return;\n int m = n \/ 2;\n merge_sort(a, m);\n merge_sort(a + m, n - m);\n merge(a, n, m);\n}\n\nint main () {\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 merge_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":"pub fn merge_sort1<T: Copy + Ord>(v: &mut [T]) {\n sort(v, &mut Vec::new());\n\n fn sort<T: Copy + Ord>(v: &mut [T], t: &mut Vec<T>) {\n match v.len() {\n 0 | 1 => (),\n \n n => {\n if t.is_empty() {\n t.reserve_exact(n);\n t.resize(n, v[0]);\n }\n let m = n \/ 2;\n sort(&mut v[..m], t);\n sort(&mut v[m..], t);\n if v[m - 1] <= v[m] {\n return;\n }\n copy(v, t);\n merge(&t[..m], &t[m..n], v);\n }\n }\n }\n\n \n #[inline(always)]\n fn merge<T: Copy + Ord>(a: &[T], b: &[T], c: &mut [T]) {\n let (mut i, mut j) = (0, 0);\n for k in 0..c.len() {\n if i < a.len() && (j >= b.len() || a[i] <= b[j]) {\n c[k] = a[i];\n i += 1;\n } else {\n c[k] = b[j];\n j += 1;\n }\n }\n }\n\n #[inline(always)]\n fn copy<T: Copy>(src: &[T], dst: &mut [T]) {\n for i in 0..src.len() {\n dst[i] = src[i];\n }\n }\n\n #[inline(always)]\n fn insertion_sort<T: Ord>(v: &mut [T]) {\n for i in 1..v.len() {\n let mut j = i;\n while j > 0 && v[j] < v[j - 1] {\n v.swap(j, j - 1);\n j -= 1;\n }\n }\n }\n}\n"} {"name":"Sorting algorithms_Quicksort","C":"#include <stdio.h>\n\nvoid quicksort(int *A, int len);\n\nint main (void) {\n int a[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1};\n int n = sizeof a \/ sizeof a[0];\n\n int i;\n for (i = 0; i < n; i++) {\n printf(\"%d \", a[i]);\n }\n printf(\"\\n\");\n\n quicksort(a, n);\n\n for (i = 0; i < n; i++) {\n printf(\"%d \", a[i]);\n }\n printf(\"\\n\");\n\n return 0;\n}\n\nvoid quicksort(int *A, int len) {\n if (len < 2) return;\n\n int pivot = A[len \/ 2];\n\n int i, j;\n for (i = 0, j = len - 1; ; i++, j--) {\n while (A[i] < pivot) i++;\n while (A[j] > pivot) j--;\n\n if (i >= j) break;\n\n int temp = A[i];\n A[i] = A[j];\n A[j] = temp;\n }\n\n quicksort(A, i);\n quicksort(A + i, len - i);\n}\n","Rust":"fn main() {\n println!(\"Sort numbers in descending order\");\n let mut numbers = [4, 65, 2, -31, 0, 99, 2, 83, 782, 1];\n println!(\"Before: {:?}\", numbers);\n\n quick_sort(&mut numbers, &|x,y| x > y);\n println!(\"After: {:?}\\n\", numbers);\n\n println!(\"Sort strings alphabetically\");\n let mut strings = [\"beach\", \"hotel\", \"airplane\", \"car\", \"house\", \"art\"];\n println!(\"Before: {:?}\", strings);\n\n quick_sort(&mut strings, &|x,y| x < y);\n println!(\"After: {:?}\\n\", strings);\n \n println!(\"Sort strings by length\");\n println!(\"Before: {:?}\", strings);\n\n quick_sort(&mut strings, &|x,y| x.len() < y.len());\n println!(\"After: {:?}\", strings); \n}\n\nfn quick_sort<T,F>(v: &mut [T], f: &F) \n where F: Fn(&T,&T) -> bool\n{\n let len = v.len();\n if len >= 2 {\n let pivot_index = partition(v, f);\n quick_sort(&mut v[0..pivot_index], f);\n quick_sort(&mut v[pivot_index + 1..len], f);\n }\n}\n\nfn partition<T,F>(v: &mut [T], f: &F) -> usize \n where F: Fn(&T,&T) -> bool\n{\n let len = v.len();\n let pivot_index = len \/ 2;\n let last_index = len - 1;\n\n v.swap(pivot_index, last_index);\n\n let mut store_index = 0;\n for i in 0..last_index {\n if f(&v[i], &v[last_index]) {\n v.swap(i, store_index);\n store_index += 1;\n }\n }\n\n v.swap(store_index, len - 1);\n store_index\n}\n"} {"name":"Sorting algorithms_Radix sort","C":"#include <stdio.h>\n#include <limits.h>\n#include <stdlib.h>\n#include <time.h>\n\n\n#define ARR_LEN(ARR) (sizeof ARR \/ sizeof *ARR)\n\n#define RAND_RNG(M,N) (M + rand() \/ (RAND_MAX \/ (N - M + 1) + 1));\n\nstatic void swap(unsigned *a, unsigned *b) {\n unsigned tmp = *a;\n *a = *b;\n *b = tmp;\n}\n\n\nstatic void rad_sort_u(unsigned *from, unsigned *to, unsigned bit)\n{\n\tif (!bit || to < from + 1) return;\n\n\tunsigned *ll = from, *rr = to - 1;\n\tfor (;;) {\n\t\t\n\t\twhile (ll < rr && !(*ll & bit)) ll++;\n\t\twhile (ll < rr && (*rr & bit)) rr--;\n\t\tif (ll >= rr) break;\n\t\tswap(ll, rr);\n\t}\n\n\tif (!(bit & *ll) && ll < to) ll++;\n\tbit >>= 1;\n\n\trad_sort_u(from, ll, bit);\n\trad_sort_u(ll, to, bit);\n}\n\n\nstatic void radix_sort(int *a, const size_t len)\n{\n\tsize_t i;\n\tunsigned *x = (unsigned*) a;\n\n\tfor (i = 0; i < len; i++) \n x[i] ^= INT_MIN;\n\n rad_sort_u(x, x + len, INT_MIN);\n\n for (i = 0; i < len; i++) \n x[i] ^= INT_MIN;\n}\n\nint main(void)\n{\n \n srand(time(NULL));\n int x[16];\n\n for (size_t i = 0; i < ARR_LEN(x); i++) \n x[i] = RAND_RNG(-128,127)\n\n radix_sort(x, ARR_LEN(x));\n\n for (size_t i = 0; i < ARR_LEN(x); i++) \n printf(\"%d%c\", x[i], i + 1 < ARR_LEN(x) ? ' ' : '\\n');\n}\n","Rust":"fn merge(in1: &[i32], in2: &[i32], out: &mut [i32]) {\n let (left, right) = out.split_at_mut(in1.len());\n left.clone_from_slice(in1);\n right.clone_from_slice(in2);\n}\n\n\nfn radix_sort(data: &mut [i32]) {\n for bit in 0..31 {\n \n \n let (small, big): (Vec<_>, Vec<_>) = data.iter().partition(|&&x| (x >> bit) & 1 == 0);\n merge(&small, &big, data);\n }\n \n let (negative, positive): (Vec<_>, Vec<_>) = data.iter().partition(|&&x| x < 0);\n merge(&negative, &positive, data);\n}\n\nfn main() {\n let mut data = [170, 45, 75, -90, -802, 24, 2, 66, -17, 2];\n println!(\"Before: {:?}\", data);\n radix_sort(&mut data);\n println!(\"After: {:?}\", data);\n}\n"} {"name":"Sorting algorithms_Selection sort","C":"#include <stdio.h>\n\nvoid selection_sort (int *a, int n) {\n int i, j, m, t;\n for (i = 0; i < n; i++) {\n for (j = i, m = i; j < n; j++) {\n if (a[j] < a[m]) {\n m = j;\n }\n }\n t = a[i];\n a[i] = a[m];\n a[m] = t;\n }\n}\n\nint main () {\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 selection_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 selection_sort(array: &mut [i32]) {\n\n let mut min;\n\n for i in 0..array.len() {\n\n min = i;\n\n for j in (i+1)..array.len() {\n\n if array[j] < array[min] {\n min = j;\n }\n }\n\n let tmp = array[i];\n array[i] = array[min];\n array[min] = tmp;\n }\n}\n\nfn main() {\n\n let mut array = [ 9, 4, 8, 3, -5, 2, 1, 6 ];\n println!(\"The initial array is {:?}\", array);\n\n selection_sort(&mut array);\n println!(\" The sorted array is {:?}\", array);\n}\n"} {"name":"Sorting algorithms_Sleep sort","C":">>>>>,----------[++++++++\n++[->+>+<<]>+>[-<<+>>]+++\n+++++[-<------>]>>+>,----\n------<<+[->>>>>+<<<<<]>>\n]>>>[<<<<[<<<[->>+<<[->+>\n[-]<<]]>[-<+>]>[-<<<.>>>>\n->>>>>[>>>>>]<-<<<<[<<<<<\n]+<]<<<<]>>>>>[>>>>>]<]\n","Rust":"use std::thread;\n\nfn sleepsort<I: Iterator<Item=u32>>(nums: I) {\n let threads: Vec<_> = nums.map(|n|\n thread::spawn(move || {\n thread::sleep_ms(n);\n println!(\"{}\", n); })).collect();\n for t in threads { t.join(); }\n}\n\nfn main() {\n sleepsort(std::env::args().skip(1).map(|s| s.parse().unwrap()));\n}\n"} {"name":"Spiral matrix","C":"#include <stdio.h>\n#include <stdlib.h>\n \n#define valid(i, j) 0 <= i && i < m && 0 <= j && j < n && !s[i][j]\nint main(int c, char **v)\n{\n\tint i, j, m = 0, n = 0;\n \n\t\n\tif (c >= 2) m = atoi(v[1]);\n\tif (c >= 3) n = atoi(v[2]);\n\tif (m <= 0) m = 5;\n\tif (n <= 0) n = m;\n \n\tint **s = calloc(1, sizeof(int *) * m + sizeof(int) * m * n);\n\ts[0] = (int*)(s + m);\n\tfor (i = 1; i < m; i++) s[i] = s[i - 1] + n;\n \n\tint dx = 1, dy = 0, val = 0, t;\n\tfor (i = j = 0; valid(i, j); i += dy, j += dx ) {\n\t\tfor (; valid(i, j); j += dx, i += dy)\n\t\t\ts[i][j] = ++val;\n \n\t\tj -= dx; i -= dy;\n\t\tt = dy; dy = dx; dx = -t;\n\t}\n\n\tfor (t = 2; val \/= 10; t++);\n\n\tfor(i = 0; i < m; i++)\n\t\tfor(j = 0; j < n || !putchar('\\n'); j++)\n\t\t\tprintf(\"%*d\", t, s[i][j]);\n\n\treturn 0;\n}\n","Rust":"const VECTORS: [(isize, isize); 4] = [(1, 0), (0, 1), (-1, 0), (0, -1)];\n\npub fn spiral_matrix(size: usize) -> Vec<Vec<u32>> {\n let mut matrix = vec![vec![0; size]; size];\n let mut movement = VECTORS.iter().cycle();\n let (mut x, mut y, mut n) = (-1, 0, 1..);\n\n for (move_x, move_y) in std::iter::once(size)\n .chain((1..size).rev().flat_map(|n| std::iter::repeat(n).take(2)))\n .flat_map(|steps| std::iter::repeat(movement.next().unwrap()).take(steps))\n {\n x += move_x;\n y += move_y;\n matrix[y as usize][x as usize] = n.next().unwrap();\n }\n\n matrix\n}\n\nfn main() {\n for i in spiral_matrix(4).iter() {\n for j in i.iter() {\n print!(\"{:>2} \", j);\n }\n println!();\n }\n}\n"} {"name":"Split a character string based on change of character","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\nchar *split(char *str);\nint main(int argc,char **argv)\n{\n\tchar input[13]=\"gHHH5YY++\n\tprintf(\"%s\\n\",split(input));\n}\nchar *split(char *str)\n{\n\tchar last=*str,*result=malloc(3*strlen(str)),*counter=result;\n\tfor (char *c=str;*c;c++) {\n\t\tif (*c!=last) {\n\t\t\tstrcpy(counter,\", \");\n\t\t\tcounter+=2;\n\t\t\tlast=*c;\n\t\t}\n\t\t*counter=*c;\n\t\tcounter++;\n\t}\n\t*(counter--)='\\0';\n\treturn realloc(result,strlen(result));\n}\n","Rust":"fn splitter(string: &str) -> String {\n let chars: Vec<_> = string.chars().collect();\n let mut result = Vec::new();\n let mut last_mismatch = 0;\n for i in 0..chars.len() {\n if chars.len() == 1 {\n return chars[0..1].iter().collect();\n }\n if i > 0 && chars[i-1] != chars[i] {\n let temp_result: String = chars[last_mismatch..i].iter().collect();\n result.push(temp_result);\n last_mismatch = i;\n }\n if i == chars.len() - 1 {\n let temp_result: String = chars[last_mismatch..chars.len()].iter().collect();\n result.push(temp_result);\n }\n }\n result.join(\", \")\n}\n\nfn main() {\n let test_string = \"g\";\n println!(\"input string: {}\", test_string);\n println!(\"output string: {}\", splitter(test_string));\n\n let test_string = \"\";\n println!(\"input string: {}\", test_string);\n println!(\"output string: {}\", splitter(test_string));\n\n let test_string = \"gHHH5YY++\n println!(\"input string: {}\", test_string);\n println!(\"output string: {}\", splitter(test_string));\n}\n"} {"name":"Square but not cube","C":"#include <stdio.h>\n#include <math.h>\n\nint main() {\n int n = 1, count = 0, sq, cr;\n for ( ; count < 30; ++n) {\n sq = n * n;\n cr = (int)cbrt((double)sq);\n if (cr * cr * cr != sq) {\n count++;\n printf(\"%d\\n\", sq);\n }\n else {\n printf(\"%d is square and cube\\n\", sq);\n }\n }\n return 0;\n}\n","Rust":"fn main() {\n let mut s = 1;\n let mut c = 1;\n let mut cube = 1;\n let mut n = 0;\n while n < 30 {\n let square = s * s;\n while cube < square {\n c += 1;\n cube = c * c * c;\n }\n if cube == square {\n println!(\"{} is a square and a cube.\", square);\n } else {\n println!(\"{}\", square);\n n += 1;\n }\n s += 1;\n }\n}\n"} {"name":"Stack","C":"#include <stdio.h>\n#include <stdlib.h>\n\n\n#define DECL_STACK_TYPE(type, name)\t\t\t\t\t\\\ntypedef struct stk_##name##_t{type *buf; size_t alloc,len;}*stk_##name;\t\\\nstk_##name stk_##name##_create(size_t init_size) {\t\t\t\\\n\tstk_##name s; if (!init_size) init_size = 4;\t\t\t\\\n\ts = malloc(sizeof(struct stk_##name##_t));\t\t\t\\\n\tif (!s) return 0;\t\t\t\t\t\t\\\n\ts->buf = malloc(sizeof(type) * init_size);\t\t\t\\\n\tif (!s->buf) { free(s); return 0; }\t\t\t\t\\\n\ts->len = 0, s->alloc = init_size;\t\t\t\t\\\n\treturn s; }\t\t\t\t\t\t\t\\\nint stk_##name##_push(stk_##name s, type item) {\t\t\t\\\n\ttype *tmp;\t\t\t\t\t\t\t\\\n\tif (s->len >= s->alloc) {\t\t\t\t\t\\\n\t\ttmp = realloc(s->buf, s->alloc*2*sizeof(type));\t\t\\\n\t\tif (!tmp) return -1; s->buf = tmp;\t\t\t\\\n\t\ts->alloc *= 2; }\t\t\t\t\t\\\n\ts->buf[s->len++] = item;\t\t\t\t\t\\\n\treturn s->len; }\t\t\t\t\t\t\\\ntype stk_##name##_pop(stk_##name s) {\t\t\t\t\t\\\n\ttype tmp;\t\t\t\t\t\t\t\\\n\tif (!s->len) abort();\t\t\t\t\t\t\\\n\ttmp = s->buf[--s->len];\t\t\t\t\t\t\\\n\tif (s->len * 2 <= s->alloc && s->alloc >= 8) {\t\t\t\\\n\t\ts->alloc \/= 2;\t\t\t\t\t\t\\\n\t\ts->buf = realloc(s->buf, s->alloc * sizeof(type));}\t\\\n\treturn tmp; }\t\t\t\t\t\t\t\\\nvoid stk_##name##_delete(stk_##name s) {\t\t\t\t\\\n\tfree(s->buf); free(s); }\n\n#define stk_empty(s) (!(s)->len)\n#define stk_size(s) ((s)->len)\n\nDECL_STACK_TYPE(int, int)\n\nint main(void)\n{\n\tint i;\n\tstk_int stk = stk_int_create(0);\n\n\tprintf(\"pushing: \");\n\tfor (i = 'a'; i <= 'z'; i++) {\n\t\tprintf(\" %c\", i);\n\t\tstk_int_push(stk, i);\n\t}\n\n\tprintf(\"\\nsize now: %d\", stk_size(stk));\n\tprintf(\"\\nstack is%s empty\\n\", stk_empty(stk) ? \"\" : \" not\");\n\n\tprintf(\"\\npoppoing:\");\n\twhile (stk_size(stk))\n\t\tprintf(\" %c\", stk_int_pop(stk));\n\tprintf(\"\\nsize now: %d\", stk_size(stk));\n\tprintf(\"\\nstack is%s empty\\n\", stk_empty(stk) ? \"\" : \" not\");\n\n\t\n\tstk_int_delete(stk);\n\treturn 0;\n}\n","Rust":"fn main() {\n let mut stack = Vec::new();\n stack.push(\"Element1\");\n stack.push(\"Element2\");\n stack.push(\"Element3\");\n\n assert_eq!(Some(&\"Element3\"), stack.last());\n assert_eq!(Some(\"Element3\"), stack.pop());\n assert_eq!(Some(\"Element2\"), stack.pop());\n assert_eq!(Some(\"Element1\"), stack.pop());\n assert_eq!(None, stack.pop());\n}\n"} {"name":"Stair-climbing puzzle","C":"void step_up(void)\n{\n while (!step()) {\n step_up();\n }\n}\n","Rust":"fn step_up() {\n\twhile !step() {\n\t\tstep_up();\n\t}\n}\n"} {"name":"Statistics_Basic","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n#include <stdint.h>\n\n#define n_bins 10\n\ndouble rand01() { return rand() \/ (RAND_MAX + 1.0); }\n\ndouble avg(int count, double *stddev, int *hist)\n{\n\tdouble x[count];\n\tdouble m = 0, s = 0;\n\n\tfor (int i = 0; i < n_bins; i++) hist[i] = 0;\n\tfor (int i = 0; i < count; i++) {\n\t\tm += (x[i] = rand01());\n\t\thist[(int)(x[i] * n_bins)] ++;\n\t}\n\n\tm \/= count;\n\tfor (int i = 0; i < count; i++)\n\t\ts += x[i] * x[i];\n\t*stddev = sqrt(s \/ count - m * m);\n\treturn m;\n}\n\nvoid hist_plot(int *hist)\n{\n\tint max = 0, step = 1;\n\tdouble inc = 1.0 \/ n_bins;\n\n\tfor (int i = 0; i < n_bins; i++)\n\t\tif (hist[i] > max) max = hist[i];\n\n\t\n\tif (max >= 60) step = (max + 59) \/ 60;\n\n\tfor (int i = 0; i < n_bins; i++) {\n\t\tprintf(\"[%5.2g,%5.2g]%5d \", i * inc, (i + 1) * inc, hist[i]);\n\t\tfor (int j = 0; j < hist[i]; j += step)\n\t\t\tprintf(\"#\");\n\t\tprintf(\"\\n\");\n\t}\n}\n\n\ntypedef struct {\n\tuint64_t size;\n\tdouble sum, x2;\n\tuint64_t hist[n_bins];\n} moving_rec;\n\nvoid moving_avg(moving_rec *rec, double *data, int count)\n{\n\tdouble sum = 0, x2 = 0;\n\t\n\tfor (int i = 0; i < count; i++) {\n\t\tsum += data[i];\n\t\tx2 += data[i] * data[i];\n\t\trec->hist[(int)(data[i] * n_bins)]++;\n\t}\n\n\trec->sum += sum;\n\trec->x2 += x2;\n\trec->size += count;\n}\n\nint main()\n{\n\tdouble m, stddev;\n\tint hist[n_bins], samples = 10;\n\n\twhile (samples <= 10000) {\n\t\tm = avg(samples, &stddev, hist);\n\t\tprintf(\"size %5d: %g %g\\n\", samples, m, stddev);\n\t\tsamples *= 10;\n\t}\n\n\tprintf(\"\\nHistograph:\\n\");\n\thist_plot(hist);\n\n\tprintf(\"\\nMoving average:\\n N Mean Sigma\\n\");\n\tmoving_rec rec = { 0, 0, 0, {0} };\n\tdouble data[100];\n\tfor (int i = 0; i < 10000; i++) {\n\t\tfor (int j = 0; j < 100; j++) data[j] = rand01();\n\n\t\tmoving_avg(&rec, data, 100);\n\n\t\tif ((i % 1000) == 999) {\n\t\t\tprintf(\"%4lluk %f %f\\n\",\n\t\t\t\trec.size\/1000,\n\t\t\t\trec.sum \/ rec.size,\n\t\t\t\tsqrt(rec.x2 * rec.size - rec.sum * rec.sum)\/rec.size\n\t\t\t);\n\t\t}\n\t}\n}\n","Rust":"#![feature(iter_arith)]\nextern crate rand;\n\nuse rand::distributions::{IndependentSample, Range};\n\npub fn mean(data: &[f32]) -> Option<f32> {\n if data.is_empty() {\n None\n } else {\n let sum: f32 = data.iter().sum();\n Some(sum \/ data.len() as f32)\n }\n}\n\npub fn variance(data: &[f32]) -> Option<f32> {\n if data.is_empty() {\n None\n } else {\n let mean = mean(data).unwrap();\n let mut sum = 0f32;\n for &x in data {\n sum += (x - mean).powi(2);\n }\n Some(sum \/ data.len() as f32)\n }\n}\n\npub fn standard_deviation(data: &[f32]) -> Option<f32> {\n if data.is_empty() {\n None\n } else {\n let variance = variance(data).unwrap();\n Some(variance.sqrt())\n }\n}\n\nfn print_histogram(width: u32, data: &[f32]) {\n let mut histogram = [0; 10];\n let len = histogram.len() as f32;\n for &x in data {\n histogram[(x * len) as usize] += 1;\n }\n let max_frequency = *histogram.iter().max().unwrap() as f32;\n for (i, &frequency) in histogram.iter().enumerate() {\n let bar_width = frequency as f32 * width as f32 \/ max_frequency;\n print!(\"{:3.1}: \", i as f32 \/ len);\n for _ in 0..bar_width as usize {\n print!(\"*\");\n }\n println!(\"\");\n }\n}\n\nfn main() {\n let range = Range::new(0f32, 1f32);\n let mut rng = rand::thread_rng();\n\n for &number_of_samples in [1000, 10_000, 1_000_000].iter() {\n let mut data = vec![];\n for _ in 0..number_of_samples {\n let x = range.ind_sample(&mut rng);\n data.push(x);\n }\n println!(\" Statistics for sample size {}\", number_of_samples);\n println!(\"Mean: {:?}\", mean(&data));\n println!(\"Variance: {:?}\", variance(&data));\n println!(\"Standard deviation: {:?}\", standard_deviation(&data));\n print_histogram(40, &data);\n }\n}\n"} {"name":"String append","C":"#include<stdio.h>\n#include<string.h>\n\nint main()\n{\n char str[24]=\"Good Morning\";\n char *cstr=\" to all\";\n char *cstr2=\"\u00a0!!!\";\n int x=0;\n \n\n if(sizeof(str)>strlen(str)+strlen(cstr)+strlen(cstr2))\n {\n \n strcat(str,cstr);\n\n \n x=strlen(str);\n sprintf(&str[x],\"%s\",cstr2);\n\n printf(\"%s\\n\",str);\n\n }\n return 0;\n}\n","Rust":"use std::ops::Add;\n\nfn main(){\n let hello = String::from(\"Hello world\");\n println!(\"{}\", hello.add(\"!!!!\"));\n}\n"} {"name":"String case","C":"\n#include <ctype.h>\n#include <stdio.h>\n\n\nvoid str_toupper(char *s)\n{\n while(*s)\n {\n *s=toupper(*s);\n s++;\n }\n}\n\n\n\nvoid str_tolower(char *s)\n{\n while(*s)\n {\n *s=tolower(*s);\n s++;\n }\n}\n\nint main(int argc, char *argv[])\n{\n char t[255]=\"alphaBETA\";\n str_toupper(t);\n printf(\"uppercase: %s\\n\", t);\n str_tolower(t);\n printf(\"lowercase: %s\\n\", t);\n return 0;\n}\n","Rust":"fn main() {\n println!(\"{}\", \"jalape\u00f1o\".to_uppercase()); \n println!(\"{}\", \"JALAPE\u00d1O\".to_lowercase()); \n}\n"} {"name":"String concatenation","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nchar *sconcat(const char *s1, const char *s2)\n{\n char *s0 = malloc(strlen(s1)+strlen(s2)+1);\n strcpy(s0, s1);\n strcat(s0, s2);\n return s0;\n}\n\nint main()\n{\n const char *s = \"hello\";\n char *s2;\n \n printf(\"%s literal\\n\", s);\n \n printf(\"%s%s\\n\", s, \" literal\");\n \n s2 = sconcat(s, \" literal\");\n puts(s2);\n free(s2);\n}\n","Rust":"fn main() {\n let s = \"hello\".to_owned();\n println!(\"{}\", s);\n \n let s1 = s + \" world\";\n println!(\"{}\", s1);\n}\n"} {"name":"String interpolation (included)","C":"#include <stdio.h>\n\nint main() {\n const char *extra = \"little\";\n printf(\"Mary had a %s lamb.\\n\", extra);\n return 0;\n}\n","Rust":"fn main() {\n println!(\"Mary had a {} lamb\", \"little\");\n \n println!(\"{1} had a {0} lamb\", \"little\", \"Mary\");\n \n println!(\"{name} had a {adj} lamb\", adj=\"little\", name=\"Mary\");\n}\n"} {"name":"String length","C":"#include <string.h>\n\nint main(void) \n{\n const char *string = \"Hello, world!\";\n size_t length = strlen(string);\n \n return 0;\n}\n","Rust":"fn main() {\n let s = \"\u6587\u5b57\u5316\u3051\"; \n println!(\"Character length: {}\", s.chars().count());\n}\n"} {"name":"String matching","C":"#include <string.h>\n#include <stdio.h>\n\nint startsWith(const char* container, const char* target)\n{\n size_t clen = strlen(container), tlen = strlen(target);\n if (clen < tlen)\n return 0;\n return strncmp(container, target, tlen) == 0;\n}\n\nint endsWith(const char* container, const char* target)\n{\n size_t clen = strlen(container), tlen = strlen(target);\n if (clen < tlen)\n return 0;\n return strncmp(container + clen - tlen, target, tlen) == 0;\n}\n\nint doesContain(const char* container, const char* target)\n{\n return strstr(container, target) != 0;\n}\n\nint main(void)\n{\n printf(\"Starts with Test ( Hello,Hell )\u00a0: %d\\n\", startsWith(\"Hello\",\"Hell\"));\n printf(\"Ends with Test ( Code,ode )\u00a0: %d\\n\", endsWith(\"Code\",\"ode\"));\n printf(\"Contains Test ( Google,msn )\u00a0: %d\\n\", doesContain(\"Google\",\"msn\"));\n\n return 0;\n}\n","Rust":"fn print_match(possible_match: Option<usize>) {\n match possible_match {\n Some(match_pos) => println!(\"Found match at pos {}\", match_pos),\n None => println!(\"Did not find any matches\")\n }\n}\n\nfn main() {\n let s1 = \"abcd\";\n let s2 = \"abab\";\n let s3 = \"ab\";\n \n \n assert!(s1.starts_with(s3));\n \n assert!(s1.contains(s3));\n \n print_match(s1.find(s3)); \n print_match(s1.find(s2)); \n \n assert!(s2.ends_with(s3));\n}\n"} {"name":"String prepend","C":"#include<stdio.h>\n#include<string.h>\n#include<stdlib.h>\n\nint main()\n{\n char str[100]=\"my String\";\n char *cstr=\"Changed \";\n char *dup;\n sprintf(str,\"%s%s\",cstr,(dup=strdup(str)));\n free(dup);\n printf(\"%s\\n\",str);\n return 0;\n}\n","Rust":"let mut s = \"World\".to_string();\ns.insert_str(0, \"Hello \");\nprintln!(\"{}\", s);\n"} {"name":"Strip a set of characters from a string","C":"#include <string.h>\n#include <stdio.h>\n#include <stdlib.h>\n\n \nchar *strip_chars(const char *string, const char *chars)\n{\n char * newstr = malloc(strlen(string) + 1);\n int counter = 0;\n\n for ( ; *string; string++) {\n if (!strchr(chars, *string)) {\n newstr[ counter ] = *string;\n ++ counter;\n }\n }\n\n newstr[counter] = 0;\n return newstr;\n}\n\nint main(void)\n{\n char *new = strip_chars(\"She was a soul stripper. She took my heart!\", \"aei\");\n printf(\"%s\\n\", new);\n\n free(new);\n return 0;\n}\n","Rust":"fn strip_characters(original : &str, to_strip : &str) -> String {\n let mut result = String::new();\n for c in original.chars() {\n if !to_strip.contains(c) {\n result.push(c);\n }\n }\n result\n}\n"} {"name":"Strip comments from a string","C":"#include<stdio.h>\n\nint main()\n{\n\tchar ch, str[100];\n\tint i;\n\t\n\tdo{\n\t\tprintf(\"\\nEnter the string\u00a0:\");\n\t\tfgets(str,100,stdin);\n\t\tfor(i=0;str[i]!=00;i++)\n\t\t{\n\t\t\tif(str[i]=='#'||str[i]==';')\n\t\t\t{\n\t\t\t\tstr[i]=00;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tprintf(\"\\nThe modified string is\u00a0: %s\",str);\n\t\tprintf(\"\\nDo you want to repeat (y\/n): \");\n\t\tscanf(\"%c\",&ch);\n\t\tfflush(stdin);\n\t}while(ch=='y'||ch=='Y');\n\t\n\treturn 0;\n}\n","Rust":"fn strip_comment<'a>(input: &'a str, markers: &[char]) -> &'a str {\n input\n .find(markers)\n .map(|idx| &input[..idx])\n .unwrap_or(input)\n .trim()\n}\n\nfn main() {\n println!(\"{:?}\", strip_comment(\"apples, pears # and bananas\", &['#', ';']));\n println!(\"{:?}\", strip_comment(\"apples, pears\u00a0; and bananas\", &['#', ';']));\n println!(\"{:?}\", strip_comment(\"apples, pears and bananas \", &['#', ';']));\n}\n"} {"name":"Strip whitespace from a string_Top and tail","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <ctype.h>\n\nchar *rtrim(const char *s)\n{\n while( isspace(*s) || !isprint(*s) ) ++s;\n return strdup(s);\n}\n\nchar *ltrim(const char *s)\n{\n char *r = strdup(s);\n if (r != NULL)\n {\n char *fr = r + strlen(s) - 1;\n while( (isspace(*fr) || !isprint(*fr) || *fr == 0) && fr >= r) --fr;\n *++fr = 0;\n }\n return r;\n}\n\nchar *trim(const char *s)\n{\n char *r = rtrim(s);\n char *f = ltrim(r);\n free(r);\n return f;\n}\n\nconst char *a = \" this is a string \";\n\nint main()\n{\n char *b = rtrim(a);\n char *c = ltrim(a);\n char *d = trim(a);\n\n printf(\"'%s'\\n'%s'\\n'%s'\\n\", b, c, d);\n \n free(b);\n free(c);\n free(d);\n return 0;\n}\n","Rust":"fn main() {\n let spaces = \" \\t\\n\\x0B\\x0C\\r \\u{A0} \\u{2000}\\u{3000}\";\n let string_with_spaces = spaces.to_owned() + \"String without spaces\" + spaces;\n\n assert_eq!(string_with_spaces.trim(), \"String without spaces\");\n assert_eq!(string_with_spaces.trim_left(), \"String without spaces\".to_owned() + spaces);\n assert_eq!(string_with_spaces.trim_right(), spaces.to_owned() + \"String without spaces\");\n}\n"} {"name":"Substring","C":"\n#define _CRT_SECURE_NO_WARNINGS \n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n\nvoid putm(char* string, size_t m)\n{\n while(*string && m--)\n putchar(*string++);\n}\n\nint main(void)\n{\n\n char string[] = \n \"Programs for other encodings (such as 8-bit ASCII, or EUC-JP).\"\n\n int n = 3;\n int m = 4;\n char knownCharacter = '(';\n char knownSubstring[] = \"encodings\";\n\n putm(string+n-1, m ); putchar('\\n');\n puts(string+n+1); putchar('\\n');\n putm(string, strlen(string)-1); putchar('\\n');\n putm(strchr(string, knownCharacter), m ); putchar('\\n');\n putm(strstr(string, knownSubstring), m ); putchar('\\n');\n\n return EXIT_SUCCESS;\n}\n","Rust":"let s = \"abc\u6587\u5b57\u5316\u3051def\";\nlet n = 2;\nlet m = 3;\n\n \nprintln!(\"{}\", s.chars().skip(n).take(m).collect::<String>());\n\n \nprintln!(\"{}\", s.chars().skip(n).collect::<String>());\n\n \nprintln!(\"{}\", s.chars().rev().skip(1).collect::<String>());\n\n \nlet cpos = s.find('b').unwrap();\nprintln!(\"{}\", s[cpos..].chars().take(m).collect::<String>());\n\n \nlet spos = s.find(\"\u3051d\").unwrap();\nprintln!(\"{}\", s[spos..].chars().take(m).collect::<String>());\n"} {"name":"Subtractive generator","C":"#include<stdio.h>\n\n#define MOD 1000000000\nint state[55], si = 0, sj = 0;\n\nint subrand();\n\nvoid subrand_seed(int p1)\n{\n\tint i, j, p2 = 1;\n\n\tstate[0] = p1 % MOD;\n\tfor (i = 1, j = 21; i < 55; i++, j += 21) {\n\t\tif (j >= 55) j -= 55;\n\t\tstate[j] = p2;\n\t\tif ((p2 = p1 - p2) < 0) p2 += MOD;\n\t\tp1 = state[j];\n\t}\n\tsi = 0;\n\tsj = 24;\n\tfor (i = 0; i < 165; i++) subrand();\n}\n\nint subrand()\n{\n\tint x;\n\tif (si == sj) subrand_seed(0);\n\n\tif (!si--) si = 54;\n\tif (!sj--) sj = 54;\n\tif ((x = state[si] - state[sj]) < 0) x += MOD;\n\n\treturn state[si] = x;\n}\n\nint main()\n{\n\tsubrand_seed(292929);\n\tint i;\n\tfor (i = 0; i < 10; i++) printf(\"%d\\n\", subrand());\n\n\treturn 0;\n}\n","Rust":"struct SubtractiveGenerator {\n \n modulo: i32,\n \n offsets: (u32, u32),\n \n state: Vec<i32>,\n \n position: usize,\n}\n\nimpl SubtractiveGenerator {\n fn new(modulo: i32, first_offset: u32, second_offset: u32) -> Self {\n \n \n let state_size: usize = first_offset.try_into().unwrap();\n\n \n \n assert!(first_offset <= i32::MAX as u32);\n assert!(first_offset > second_offset);\n SubtractiveGenerator {\n modulo,\n offsets: (first_offset, second_offset),\n state: Vec::with_capacity(state_size),\n position: 0,\n }\n }\n}\n\nimpl Iterator for SubtractiveGenerator {\n type Item = i32;\n\n fn next(&mut self) -> Option<<Self as Iterator>::Item> {\n let state_size = self.offsets.0 as usize;\n\n assert_eq!(self.state.len(), state_size);\n\n self.position = (self.position + 1) % self.offsets.0 as usize;\n\n let i1 = (self.position as i32 - self.offsets.0 as i32).rem_euclid(state_size as i32);\n let i2 = (self.position as i32 - self.offsets.1 as i32).rem_euclid(state_size as i32);\n\n let p1 = self.state[i1 as usize];\n let p2 = self.state[i2 as usize];\n\n self.state[self.position] = (p1 - p2).rem_euclid(self.modulo);\n\n Some(self.state[self.position])\n }\n}\n\n\n\nfn get_seeded_xpat2_gen(seed: i32) -> SubtractiveGenerator {\n let mut gen = SubtractiveGenerator::new(1_000_000_000, 55, 24);\n\n let state_size = gen.offsets.0 as usize;\n\n let mut pre_state = Vec::with_capacity(state_size);\n pre_state.push(seed);\n pre_state.push(1);\n for i in 2..state_size {\n pre_state.push((pre_state[i - 2] - pre_state[i - 1]).rem_euclid(gen.modulo));\n }\n\n for i in 0..state_size {\n gen.state.push(pre_state[(34 * (i + 1)) % 55]);\n }\n\n gen.position = 54;\n for _ in 0..165 {\n gen.next();\n }\n\n gen\n}\n\nfn main() {\n let gen = get_seeded_xpat2_gen(292929);\n\n for n in gen.take(5) {\n println!(\"{}\", n);\n }\n}\n"} {"name":"Sudoku","C":"#include <stdio.h>\n\nvoid show(int *x)\n{\n\tint i, j;\n\tfor (i = 0; i < 9; i++) {\n\t\tif (!(i % 3)) putchar('\\n');\n\t\tfor (j = 0; j < 9; j++)\n\t\t\tprintf(j % 3 ? \"%2d\" : \"%3d\", *x++);\n\t\tputchar('\\n');\n\t}\n}\n\nint trycell(int *x, int pos)\n{\n\tint row = pos \/ 9;\n\tint col = pos % 9;\n\tint i, j, used = 0;\n\n\tif (pos == 81) return 1;\n\tif (x[pos]) return trycell(x, pos + 1);\n\n\tfor (i = 0; i < 9; i++)\n\t\tused |= 1 << (x[i * 9 + col] - 1);\n\n\tfor (j = 0; j < 9; j++)\n\t\tused |= 1 << (x[row * 9 + j] - 1);\n\n\trow = row \/ 3 * 3;\n\tcol = col \/ 3 * 3;\n\tfor (i = row; i < row + 3; i++)\n\t\tfor (j = col; j < col + 3; j++)\n\t\t\tused |= 1 << (x[i * 9 + j] - 1);\n\n\tfor (x[pos] = 1; x[pos] <= 9; x[pos]++, used >>= 1)\n\t\tif (!(used & 1) && trycell(x, pos + 1)) return 1;\n\n\tx[pos] = 0;\n\treturn 0;\n}\n\nvoid solve(const char *s)\n{\n\tint i, x[81];\n\tfor (i = 0; i < 81; i++)\n\t\tx[i] = s[i] >= '1' && s[i] <= '9' ? s[i] - '0' : 0;\n\n\tif (trycell(x, 0))\n\t\tshow(x);\n\telse\n\t\tputs(\"no solution\");\n}\n\nint main(void)\n{\n\tsolve(\t\"5x..7....\"\n\t\t\"6..195...\"\n\t\t\".98....6.\"\n\t\t\"8...6...3\"\n\t\t\"4..8.3..1\"\n\t\t\"7...2...6\"\n\t\t\".6....28.\"\n\t\t\"...419..5\"\n\t\t\"....8..79\"\t);\n\n\treturn 0;\n}\n","Rust":"type Sudoku = [u8; 81];\n\nfn is_valid(val: u8, x: usize, y: usize, sudoku_ar: &mut Sudoku) -> bool {\n (0..9).all(|i| sudoku_ar[y * 9 + i] != val && sudoku_ar[i * 9 + x] != val) && {\n let (start_x, start_y) = ((x \/ 3) * 3, (y \/ 3) * 3);\n (start_y..start_y + 3).all(|i| (start_x..start_x + 3).all(|j| sudoku_ar[i * 9 + j] != val))\n }\n}\n\nfn place_number(pos: usize, sudoku_ar: &mut Sudoku) -> bool {\n (pos..81).find(|&p| sudoku_ar[p] == 0).map_or(true, |pos| {\n let (x, y) = (pos % 9, pos \/ 9);\n for n in 1..10 {\n if is_valid(n, x, y, sudoku_ar) {\n sudoku_ar[pos] = n;\n if place_number(pos + 1, sudoku_ar) {\n return true;\n }\n sudoku_ar[pos] = 0;\n }\n }\n false\n })\n}\n\nfn pretty_print(sudoku_ar: Sudoku) {\n let line_sep = \"------+-------+------\";\n println!(\"{}\", line_sep);\n for (i, e) in sudoku_ar.iter().enumerate() {\n print!(\"{} \", e);\n if (i + 1) % 3 == 0 && (i + 1) % 9 != 0 {\n print!(\"| \");\n }\n if (i + 1) % 9 == 0 {\n println!(\" \");\n }\n if (i + 1) % 27 == 0 {\n println!(\"{}\", line_sep);\n }\n }\n}\n\nfn solve(sudoku_ar: &mut Sudoku) -> bool {\n place_number(0, sudoku_ar)\n}\n\nfn main() {\n let mut sudoku_ar: Sudoku = [\n 8, 5, 0, 0, 0, 2, 4, 0, 0,\n 7, 2, 0, 0, 0, 0, 0, 0, 9,\n 0, 0, 4, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 1, 0, 7, 0, 0, 2,\n 3, 0, 5, 0, 0, 0, 9, 0, 0,\n 0, 4, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 8, 0, 0, 7, 0,\n 0, 1, 7, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 3, 6, 0, 4, 0\n ];\n if solve(&mut sudoku_ar) {\n pretty_print(sudoku_ar);\n } else {\n println!(\"Unsolvable\");\n }\n}\n"} {"name":"Sum and product of an array","C":"\nint arg[] = { 1,2,3,4,5 };\nint arg_length = sizeof(arg)\/sizeof(arg[0]);\nint *end = arg+arg_length;\nint sum = 0, prod = 1;\nint *p;\n\nfor (p = arg; p!=end; ++p) {\n sum += *p;\n prod *= *p;\n}\n","Rust":"fn main() {\n let arr = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];\n\n \n let sum = arr.iter().fold(0i32, |a, &b| a + b);\n let product = arr.iter().fold(1i32, |a, &b| a * b);\n println!(\"the sum is {} and the product is {}\", sum, product);\n\n \n let sum = arr.iter().sum::<i32>();\n let product = arr.iter().product::<i32>();\n println!(\"the sum is {} and the product is {}\", sum, product);\n}\n"} {"name":"Sum digits of an integer","C":"#include <stdio.h>\n\nint SumDigits(unsigned long long n, const int base) {\n int sum = 0;\n for (; n; n \/= base)\n \tsum += n % base;\n return sum;\n}\n \nint main() {\n printf(\"%d %d %d %d %d\\n\",\n SumDigits(1, 10),\n SumDigits(12345, 10),\n SumDigits(123045, 10),\n SumDigits(0xfe, 16),\n SumDigits(0xf0e, 16) );\n return 0;\n}\n","Rust":"struct DigitIter(usize, usize);\n\nimpl Iterator for DigitIter {\n type Item = usize;\n fn next(&mut self) -> Option<Self::Item> {\n if self.0 == 0 {\n None\n } else {\n let ret = self.0 % self.1;\n self.0 \/= self.1;\n Some(ret)\n }\n }\n}\n\nfn main() {\n println!(\"{}\", DigitIter(1234,10).sum::<usize>());\n}\n"} {"name":"Sum multiples of 3 and 5","C":"#include <stdio.h>\n#include <stdlib.h>\n\nunsigned long long sum35(unsigned long long limit)\n{\n unsigned long long sum = 0;\n for (unsigned long long i = 0; i < limit; i++)\n if (!(i % 3) || !(i % 5))\n sum += i;\n return sum;\n}\n\nint main(int argc, char **argv)\n{\n unsigned long long limit;\n\n if (argc == 2)\n limit = strtoull(argv[1], NULL, 10);\n else\n limit = 1000;\n\n printf(\"%lld\\n\", sum35(limit));\n return 0;\n}\n","Rust":"extern crate rug;\n\nuse rug::Integer;\nuse rug::ops::Pow;\n\nfn main() {\n for i in [3, 20, 100, 1_000].iter() {\n let ten = Integer::from(10);\n let mut limit = Integer::from(Integer::from(&ten.pow(*i as u32)) - 1);\n let mut aux_3_1 = &limit.mod_u(3u32);\n let mut aux_3_2 = Integer::from(&limit - aux_3_1);\n let mut aux_3_3 = Integer::from(&aux_3_2\/3);\n let mut aux_3_4 = Integer::from(3 + aux_3_2);\n let mut aux_3_5 = Integer::from(&aux_3_3*&aux_3_4);\n let mut aux_3_6 = Integer::from(&aux_3_5\/2);\n \n let mut aux_5_1 = &limit.mod_u(5u32);\n let mut aux_5_2 = Integer::from(&limit - aux_5_1); \n let mut aux_5_3 = Integer::from(&aux_5_2\/5);\n let mut aux_5_4 = Integer::from(5 + aux_5_2); \n let mut aux_5_5 = Integer::from(&aux_5_3*&aux_5_4);\n let mut aux_5_6 = Integer::from(&aux_5_5\/2); \n\n let mut aux_15_1 = &limit.mod_u(15u32);\n let mut aux_15_2 = Integer::from(&limit - aux_15_1); \n let mut aux_15_3 = Integer::from(&aux_15_2\/15);\n let mut aux_15_4 = Integer::from(15 + aux_15_2);\n let mut aux_15_5 = Integer::from(&aux_15_3*&aux_15_4);\n let mut aux_15_6 = Integer::from(&aux_15_5\/2); \n\n let mut result_aux_1 = Integer::from(&aux_3_6 + &aux_5_6); \n let mut result = Integer::from(&result_aux_1 - &aux_15_6);\n \n println!(\"Sum for 10^{}\u00a0: {}\",i,result);\n }\n}\n"} {"name":"Sum of a series","C":"#include <stdio.h>\n\ndouble Invsqr(double n)\n{\n\treturn 1 \/ (n*n);\n}\n\nint main (int argc, char *argv[])\n{\n\tint i, start = 1, end = 1000;\n\tdouble sum = 0.0;\n\t\n\tfor( i = start; i <= end; i++)\n\t\tsum += Invsqr((double)i); \n\t\n\tprintf(\"%16.14f\\n\", sum);\n\t\n\treturn 0;\n}\n","Rust":"const LOWER: i32 = 1;\nconst UPPER: i32 = 1000;\n\n\n\nconst NUMBER_OF_TERMS: i32 = (UPPER + 1) - LOWER;\nfn main() {\n \n println!(\"{}\", (NUMBER_OF_TERMS * (LOWER + UPPER)) \/ 2);\n \n println!(\"{}\", (LOWER..UPPER + 1).fold(0, |sum, x| sum + x));\n}\n"} {"name":"Sum of squares","C":"#include <stdio.h>\n\ndouble squaredsum(double *l, int e)\n{\n int i; double sum = 0.0;\n for(i = 0 ; i < e ; i++) sum += l[i]*l[i];\n return sum;\n}\n\nint main()\n{\n double list[6] = {3.0, 1.0, 4.0, 1.0, 5.0, 9.0};\n \n printf(\"%lf\\n\", squaredsum(list, 6));\n printf(\"%lf\\n\", squaredsum(list, 0));\n \n printf(\"%lf\\n\", squaredsum(NULL, 0));\n return 0;\n}\n","Rust":"fn sq_sum(v: &[f64]) -> f64 {\n v.iter().fold(0., |sum, &num| sum + num*num)\n}\n\nfn main() {\n let v = vec![3.0, 1.0, 4.0, 1.0, 5.5, 9.7];\n println!(\"{}\", sq_sum(&v));\n\n let u : Vec<f64> = vec![];\n println!(\"{}\", sq_sum(&u));\n}\n"} {"name":"Symmetric difference","C":"#include <stdio.h>\n#include <string.h>\n\nconst char *A[] = { \"John\", \"Serena\", \"Bob\", \"Mary\", \"Serena\" };\nconst char *B[] = { \"Jim\", \"Mary\", \"John\", \"Jim\", \"Bob\" };\n\n#define LEN(x) sizeof(x)\/sizeof(x[0])\n\n\nvoid uniq(const char *x[], int len)\n{\n\tint i, j;\n\tfor (i = 0; i < len; i++)\n\t\tfor (j = i + 1; j < len; j++)\n\t\t\tif (x[j] && x[i] && !strcmp(x[i], x[j])) x[j] = 0;\n}\n\nint in_set(const char *const x[], int len, const char *match)\n{\n\tint i;\n\tfor (i = 0; i < len; i++)\n\t\tif (x[i] && !strcmp(x[i], match))\n\t\t\treturn 1;\n\treturn 0;\n}\n\n\nvoid show_diff(const char *const x[], int lenx, const char *const y[], int leny)\n{\n\tint i;\n\tfor (i = 0; i < lenx; i++)\n\t\tif (x[i] && !in_set(y, leny, x[i]))\n\t\t\tprintf(\" %s\\n\", x[i]);\n}\n\n\nvoid show_sym_diff(const char *const x[], int lenx, const char *const y[], int leny)\n{\n\tshow_diff(x, lenx, y, leny);\n\tshow_diff(y, leny, x, lenx);\n}\n\nint main()\n{\n\tuniq(A, LEN(A));\n\tuniq(B, LEN(B));\n\tprintf(\"A \\\\ B:\\n\"); show_diff(A, LEN(A), B, LEN(B));\n\tprintf(\"\\nB \\\\ A:\\n\"); show_diff(B, LEN(B), A, LEN(A));\n\tprintf(\"\\nA ^ B:\\n\"); show_sym_diff(A, LEN(A), B, LEN(B));\n\n\treturn 0;\n}\n","Rust":"use std::collections::HashSet;\n\nfn main() {\n let a: HashSet<_> = [\"John\", \"Bob\", \"Mary\", \"Serena\"]\n .iter()\n .collect();\n let b = [\"Jim\", \"Mary\", \"John\", \"Bob\"]\n .iter()\n .collect();\n\n let diff = a.symmetric_difference(&b);\n println!(\"{:?}\", diff);\n}\n"} {"name":"Synchronous concurrency","C":"#include <stdlib.h>\t\n#include <stdio.h>\t\n\n#include <libco.h>\t\n\nvoid\nfail(const char *message) {\n\tperror(message);\n\texit(1);\n}\n\n\ncothread_t reader;\ncothread_t printer;\nstruct {\n\tchar\t*buf;\t\n\tsize_t\tlen;\t\n\tsize_t\tcap;\t\n} line;\nsize_t count;\t\t\n\n\nvoid\nreader_entry(void)\n{\n\tFILE *input;\n\tsize_t newcap;\n\tint c, eof, eol;\n\tchar *newbuf;\n\n\tinput = fopen(\"input.txt\", \"r\");\n\tif (input == NULL)\n\t\tfail(\"fopen\");\n\n\tline.buf = malloc(line.cap = 4096); \n\tif (line.buf == NULL)\n\t\tfail(\"malloc\");\n\tline.len = 0; \n\n\tdo {\n\t\tc = fgetc(input); \n\t\tif (ferror(input))\n\t\t\tfail(\"fgetc\");\n\n\t\teof = (c == EOF);\n\t\tif (eof) {\n\t\t\t\n\t\t\teol = (line.len > 0);\n\t\t} else {\n\t\t\t\n\t\t\tif (line.len == line.cap) {\n\t\t\t\t\n\t\t\t\tnewcap = line.cap * 2;\n\t\t\t\tnewbuf = realloc(line.buf, newcap);\n\t\t\t\tif (newbuf == NULL)\n\t\t\t\t\tfail(\"realloc\");\n\t\t\t\tline.buf = newbuf;\n\t\t\t\tline.cap = newcap;\n\t\t\t}\n\t\t\tline.buf[line.len++] = c;\n\n\t\t\t\n\t\t\teol = (c == '\\n');\n\t\t}\n\n\t\tif (eol) {\n\t\t\t\n\t\t\tco_switch(printer);\n\t\t\tline.len = 0; \n\t\t}\n\t} while (!eof);\n\n\tfree(line.buf);\n\tline.buf = NULL; \n\n\tprintf(\"Printed %zu lines.\\n\", count);\n\tco_switch(printer);\n}\n\n\nint\nmain()\n{\n\treader = co_create(4096, reader_entry);\n\tprinter = co_active();\n\tcount = 0;\n\n\tfor (;;) {\n\t\tco_switch(reader);\n\t\tif (line.buf == NULL)\n\t\t\tbreak;\n\n\t\t\n\t\tfwrite(line.buf, 1, line.len, stdout);\n\t\tcount++;\n\t}\n\n\tco_delete(reader);\n\treturn 0;\n}\n","Rust":"use std::fs::File;\nuse std::io::BufRead;\nuse std::io::BufReader;\n\nuse std::sync::mpsc::{channel, sync_channel};\nuse std::thread;\n\nfn main() {\n \n let (reader_send, writer_recv) = channel();\n\n \n \n let (writer_send, reader_recv) = sync_channel(0);\n\n \n let reader_work = move || {\n let file = File::open(\"input.txt\").expect(\"Failed to open input.txt\");\n let reader = BufReader::new(file);\n\n for line in reader.lines() {\n match line {\n Ok(msg) => reader_send\n .send(msg)\n .expect(\"Failed to send via the channel\"),\n Err(e) => println!(\"{}\", e),\n }\n }\n\n \n drop(reader_send);\n\n \n \n let count = reader_recv\n .recv()\n .expect(\"Failed to receive count from printer.\");\n\n println!(\"{}\", count);\n };\n\n \n let writer_work = move || {\n let mut line_count = 0;\n\n loop {\n match writer_recv.recv() {\n Ok(msg) => {\n println!(\"{}\", msg);\n line_count += 1;\n }\n Err(_) => break, \n }\n }\n\n \n writer_send\n .send(line_count)\n .expect(\"Failed to send line count from writer.\");\n\n drop(writer_send);\n };\n\n \n let reader_handle = thread::spawn(reader_work);\n thread::spawn(writer_work);\n\n reader_handle\n .join()\n .expect(\"Failed to join the reader thread.\");\n}\n"} {"name":"System time","C":"#include<time.h>\n#include<stdio.h>\n#include<stdlib.h>\nint main(){\n time_t my_time = time(NULL);\n printf(\"%s\", ctime(&my_time));\n return 0;\n}\n","Rust":"\n\nextern crate chrono;\nuse chrono::prelude::*;\n\nfn main() {\n let utc: DateTime<Utc> = Utc::now();\n println!(\"{}\", utc.format(\"%d\/%m\/%Y %T\"));\n}\n"} {"name":"Take notes on the command line","C":"#include <stdio.h>\n#include <time.h>\n\n#define note_file \"NOTES.TXT\"\n\nint main(int argc, char**argv)\n{\n\tFILE *note = 0;\n\ttime_t tm;\n\tint i;\n\tchar *p;\n\n\tif (argc < 2) {\n\t\tif ((note = fopen(note_file, \"r\")))\n\t\t\twhile ((i = fgetc(note)) != EOF)\n\t\t\t\tputchar(i);\n\n\t} else if ((note = fopen(note_file, \"a\"))) {\n\t\ttm = time(0);\n\t\tp = ctime(&tm);\n\n\t\t\n\t\twhile (*p) fputc(*p != '\\n'?*p:'\\t', note), p++;\n\n\t\tfor (i = 1; i < argc; i++)\n\t\t\tfprintf(note, \"%s%c\", argv[i], 1 + i - argc ? ' ' : '\\n');\n\t}\n\n\tif (note) fclose(note);\n\treturn 0;\n}\n","Rust":"extern crate chrono;\n\nuse std::fs::OpenOptions;\nuse std::io::{self, BufReader, BufWriter};\nuse std::io::prelude::*;\nuse std::env;\n\nconst FILENAME: &str = \"NOTES.TXT\";\n\nfn show_notes() -> Result<(), io::Error> {\n let file = OpenOptions::new()\n .read(true)\n .create(true) \n .write(true) \n .open(FILENAME)?;\n let mut buf_reader = BufReader::new(file);\n let mut contents = String::new();\n buf_reader.read_to_string(&mut contents)?;\n println!(\"{}\", contents);\n Ok(())\n}\n\nfn add_to_notes(note: &str) -> Result<(), io::Error> {\n let file = OpenOptions::new()\n .append(true) \n .create(true)\n .open(FILENAME)?;\n let mut buf_writer = BufWriter::new(file);\n\n let date_and_time = chrono::Local::now();\n writeln!(buf_writer, \"{}\", date_and_time)?;\n\n writeln!(buf_writer, \"\\t{}\", note)\n}\n\nfn main() {\n let note = env::args().skip(1).collect::<Vec<_>>();\n\n if note.is_empty() {\n show_notes().expect(\"failed to print NOTES.TXT\");\n } else {\n add_to_notes(¬e.join(\" \")).expect(\"failed to write to NOTES.TXT\");\n }\n}\n"} {"name":"Temperature conversion","C":"#include <stdio.h>\n#include <stdlib.h>\n\ndouble kelvinToCelsius(double k){\n return k - 273.15;\n}\n\ndouble kelvinToFahrenheit(double k){\n return k * 1.8 - 459.67;\n}\n\ndouble kelvinToRankine(double k){\n return k * 1.8;\n}\nvoid convertKelvin(double kelvin) {\n printf(\"K\u00a0%.2f\\n\", kelvin);\n printf(\"C\u00a0%.2f\\n\", kelvinToCelsius(kelvin));\n printf(\"F\u00a0%.2f\\n\", kelvinToFahrenheit(kelvin));\n printf(\"R\u00a0%.2f\", kelvinToRankine(kelvin));\n}\n\nint main(int argc, const char * argv[])\n{\n if (argc > 1) {\n double kelvin = atof(argv[1]);\n convertKelvin(kelvin);\n }\n return 0;\n}\n","Rust":"fn main() -> std::io::Result<()> {\n print!(\"Enter temperature in Kelvin to convert: \");\n let mut input = String::new();\n std::io::stdin().read_line(&mut input)?;\n match input.trim().parse::<f32>() {\n Ok(kelvin) => {\n if kelvin < 0.0 {\n println!(\"Negative Kelvin values are not acceptable.\");\n } else {\n println!(\"{} K\", kelvin);\n println!(\"{} \u00b0C\", kelvin - 273.15);\n println!(\"{} \u00b0F\", kelvin * 1.8 - 459.67);\n println!(\"{} \u00b0R\", kelvin * 1.8);\n }\n }\n\n _ => println!(\"Could not parse the input to a number.\"),\n }\n\n Ok(())\n}\n"} {"name":"Terminal control_Clear the screen","C":"void cls(void) {\n printf(\"\\33[2J\");\n}\n","Rust":"print!(\"\\x1B[2J\");\n"} {"name":"Terminal control_Coloured text","C":"#include <stdio.h>\n\nvoid table(const char *title, const char *mode)\n{\n\tint f, b;\n\tprintf(\"\\n\\033[1m%s\\033[m\\n bg\\t fg\\n\", title);\n\tfor (b = 40; b <= 107; b++) {\n\t\tif (b == 48) b = 100;\n\t\tprintf(\"%3d\\t\\033[%s%dm\", b, mode, b);\n\t\tfor (f = 30; f <= 97; f++) {\n\t\t\tif (f == 38) f = 90;\n\t\t\tprintf(\"\\033[%dm%3d \", f, f);\n\t\t}\n\t\tputs(\"\\033[m\");\n\t}\n}\n\nint main(void)\n{\n\tint fg, bg, blink, inverse;\n\n\ttable(\"normal ( ESC[22m or ESC[m )\", \"22;\");\n\ttable(\"bold ( ESC[1m )\", \"1;\");\n\ttable(\"faint ( ESC[2m ), not well supported\", \"2;\");\n\ttable(\"italic ( ESC[3m ), not well supported\", \"3;\");\n\ttable(\"underline ( ESC[4m ), support varies\", \"4;\");\n\ttable(\"blink ( ESC[5m )\", \"5;\");\n\ttable(\"inverted ( ESC[7m )\", \"7;\");\n\treturn 0;\n}\n","Rust":"const ESC: &str = \"\\x1B[\";\nconst RESET: &str = \"\\x1B[0m\";\n\nfn main() {\n println!(\"Foreground\u00a6Background--------------------------------------------------------------\");\n print!(\" \u00a6\");\n for i in 40..48 {\n print!(\" ESC[{}m \", i);\n }\n println!(\"\\n----------\u00a6------------------------------------------------------------------------\");\n for i in 30..38 {\n print!(\"{}ESC[{}m \u00a6{}{1}m\", RESET, i, ESC);\n for j in 40..48 {\n print!(\"{}{}m Rosetta \", ESC, j);\n }\n println!(\"{}\", RESET);\n print!(\"{}ESC[{};1m \u00a6{}{1};1m\", RESET, i, ESC);\n for j in 40..48 {\n print!(\"{}{}m Rosetta \", ESC, j);\n }\n println!(\"{}\", RESET);\n }\n}\n"} {"name":"Terminal control_Ringing the terminal bell","C":"#include <stdio.h>\nint main() {\n printf(\"\\a\");\n return 0;\n}\n","Rust":"fn main() {\n print!(\"\\x07\");\n}\n"} {"name":"Ternary logic","C":"#include <stdio.h>\n \ntypedef enum {\n TRITTRUE, \n TRITMAYBE, \n TRITFALSE \n} trit;\n \n\ntrit tritNot[3] = {TRITFALSE , TRITMAYBE, TRITTRUE};\ntrit tritAnd[3][3] = { {TRITTRUE, TRITMAYBE, TRITFALSE},\n {TRITMAYBE, TRITMAYBE, TRITFALSE},\n {TRITFALSE, TRITFALSE, TRITFALSE} };\n \ntrit tritOr[3][3] = { {TRITTRUE, TRITTRUE, TRITTRUE},\n {TRITTRUE, TRITMAYBE, TRITMAYBE},\n {TRITTRUE, TRITMAYBE, TRITFALSE} };\n \ntrit tritThen[3][3] = { { TRITTRUE, TRITMAYBE, TRITFALSE},\n { TRITTRUE, TRITMAYBE, TRITMAYBE},\n { TRITTRUE, TRITTRUE, TRITTRUE } };\n \ntrit tritEquiv[3][3] = { { TRITTRUE, TRITMAYBE, TRITFALSE},\n { TRITMAYBE, TRITMAYBE, TRITMAYBE},\n { TRITFALSE, TRITMAYBE, TRITTRUE } };\n\n\n\nconst char* tritString[3] = {\"T\", \"?\", \"F\"};\n\nvoid demo_binary_op(trit operator[3][3], const char* name)\n{\n trit operand1 = TRITTRUE; \n trit operand2 = TRITTRUE; \n\n \n printf(\"\\n\");\n\n \n for( operand1 = TRITTRUE; operand1 <= TRITFALSE; ++operand1 )\n {\n for( operand2 = TRITTRUE; operand2 <= TRITFALSE; ++operand2 )\n {\n printf(\"%s %s %s: %s\\n\", tritString[operand1],\n name,\n tritString[operand2],\n tritString[operator[operand1][operand2]]);\n }\n }\n\n}\n\nint main()\n{\n trit op1 = TRITTRUE; \n trit op2 = TRITTRUE; \n \n \n for( op1 = TRITTRUE; op1 <= TRITFALSE; ++op1 )\n {\n printf(\"Not %s: %s\\n\", tritString[op1], tritString[tritNot[op1]]);\n }\n demo_binary_op(tritAnd, \"And\");\n demo_binary_op(tritOr, \"Or\");\n demo_binary_op(tritThen, \"Then\");\n demo_binary_op(tritEquiv, \"Equiv\");\n\n \n return 0;\n}\n","Rust":"use std::{ops, fmt};\n\n#[derive(Copy, Clone, Debug)]\nenum Trit {\n True,\n Maybe,\n False,\n}\n\nimpl ops::Not for Trit {\n type Output = Self;\n fn not(self) -> Self {\n match self {\n Trit::True => Trit::False,\n Trit::Maybe => Trit::Maybe,\n Trit::False => Trit::True,\n }\n }\n}\n\nimpl ops::BitAnd for Trit {\n type Output = Self;\n fn bitand(self, other: Self) -> Self {\n match (self, other) {\n (Trit::True, Trit::True) => Trit::True,\n (Trit::False, _) | (_, Trit::False) => Trit::False,\n _ => Trit::Maybe,\n }\n }\n}\n\nimpl ops::BitOr for Trit {\n type Output = Self;\n fn bitor(self, other: Self) -> Self {\n match (self, other) {\n (Trit::True, _) | (_, Trit::True) => Trit::True,\n (Trit::False, Trit::False) => Trit::False,\n _ => Trit::Maybe,\n }\n }\n}\n\nimpl Trit {\n fn imp(self, other: Self) -> Self {\n match self {\n Trit::True => other,\n Trit::Maybe => {\n if let Trit::True = other {\n Trit::True\n } else {\n Trit::Maybe\n }\n }\n Trit::False => Trit::True,\n }\n }\n\n fn eqv(self, other: Self) -> Self {\n match self {\n Trit::True => other,\n Trit::Maybe => Trit::Maybe,\n Trit::False => !other,\n }\n }\n}\n\nimpl fmt::Display for Trit {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(\n f,\n \"{}\",\n match self {\n Trit::True => 'T',\n Trit::Maybe => 'M',\n Trit::False => 'F',\n }\n )\n }\n}\n\nstatic TRITS: [Trit; 3] = [Trit::True, Trit::Maybe, Trit::False];\n\nfn main() {\n println!(\"not\");\n println!(\"-------\");\n for &t in &TRITS {\n println!(\" {} | {}\", t, !t);\n }\n \n table(\"and\", |a, b| a & b);\n table(\"or\", |a, b| a | b);\n table(\"imp\", |a, b| a.imp(b));\n table(\"eqv\", |a, b| a.eqv(b));\n}\n\nfn table(title: &str, f: impl Fn(Trit, Trit) -> Trit) {\n println!();\n println!(\"{:3} | T M F\", title);\n println!(\"-------------\");\n for &t1 in &TRITS {\n print!(\" {} | \", t1);\n for &t2 in &TRITS {\n print!(\"{} \", f(t1, t2));\n }\n println!();\n }\n}\n"} {"name":"Test a function","C":"#include <assert.h>\nint IsPalindrome(char *Str);\n\nint main()\n{\n assert(IsPalindrome(\"racecar\"));\n assert(IsPalindrome(\"alice\"));\n}\n","Rust":"\n\n\n\n\n\n\n\n\n\npub fn is_palindrome(s: &str) -> bool {\n let half = s.len();\n s.chars().take(half).eq(s.chars().rev().take(half))\n}\n\n#[cfg(test)]\nmod tests {\n\n use super::is_palindrome;\n\n #[test]\n fn test_is_palindrome() {\n assert!(is_palindrome(\"abba\"));\n }\n}\n"} {"name":"Text processing_Max licenses in use","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <sys\/types.h>\n\n#define INOUT_LEN 4\n#define TIME_LEN 20\n#define MAX_MAXOUT 1000\n\nchar inout[INOUT_LEN];\nchar time[TIME_LEN];\nuint jobnum;\n\nchar maxtime[MAX_MAXOUT][TIME_LEN];\n\nint main(int argc, char **argv)\n{\n FILE *in = NULL;\n int l_out = 0, maxout=-1, maxcount=0;\n\n if ( argc > 1 ) {\n in = fopen(argv[1], \"r\");\n if ( in == NULL ) {\n fprintf(stderr, \"cannot read %s\\n\", argv[1]);\n exit(1);\n }\n } else {\n in = stdin;\n }\n\n while( fscanf(in, \"License %s @ %s for job %u\\n\", inout, time, &jobnum) != EOF ) {\n\n if ( strcmp(inout, \"OUT\") == 0 )\n l_out++;\n else\n l_out--;\n\n if ( l_out > maxout ) {\n maxout = l_out;\n maxcount=0; maxtime[0][0] = '\\0';\n }\n if ( l_out == maxout ) {\n if ( maxcount < MAX_MAXOUT ) {\n strncpy(maxtime[maxcount], time, TIME_LEN);\n maxcount++;\n } else {\n fprintf(stderr, \"increase MAX_MAXOUT (now it is %u)\\n\", MAX_MAXOUT);\n exit(1);\n }\n }\n }\n\n printf(\"Maximum simultaneous license use is %d at the following times:\\n\", maxout);\n for(l_out=0; l_out < maxcount; l_out++) {\n printf(\"%s\\n\", maxtime[l_out]);\n }\n\n if ( in != stdin ) fclose(in);\n exit(0);\n}\n","Rust":"type Timestamp = String;\n\nfn compute_usage<R, S, E>(lines: R) -> Result<(u32, Vec<Timestamp>), E>\nwhere\n S: AsRef<str>,\n R: Iterator<Item = Result<S, E>>,\n{\n let mut timestamps = Vec::new();\n let mut current = 0;\n let mut maximum = 0;\n\n for line in lines {\n let line = line?;\n let line = line.as_ref();\n\n if line.starts_with(\"License IN\") {\n current -= 1;\n } else if line.starts_with(\"License OUT\") {\n current += 1;\n\n if maximum <= current {\n let date = line.split_whitespace().nth(3).unwrap().to_string();\n\n if maximum < current {\n maximum = current;\n timestamps.clear();\n }\n\n timestamps.push(date);\n }\n }\n }\n\n Ok((maximum, timestamps))\n}\n\nfn main() -> std::io::Result<()> {\n use std::io::{BufRead, BufReader};\n let file = std::fs::OpenOptions::new().read(true).open(\"mlijobs.txt\")?;\n let (max, timestamps) = compute_usage(BufReader::new(file).lines())?;\n println!(\"Maximum licenses out: {}\", max);\n println!(\"At time(s): {:?}\", timestamps);\n Ok(())\n}\n"} {"name":"The Twelve Days of Christmas","C":"#include<stdio.h>\n \nint main()\n{\n int i,j;\n \n char days[12][10] = \n {\n \"First\",\n \"Second\",\n \"Third\",\n \"Fourth\",\n \"Fifth\",\n \"Sixth\",\n \"Seventh\",\n \"Eighth\",\n \"Ninth\",\n \"Tenth\",\n \"Eleventh\",\n \"Twelfth\"\n };\n\n char gifts[12][33] =\n {\n \"Twelve drummers drumming\",\n \"Eleven pipers piping\",\n \"Ten lords a-leaping\",\n \"Nine ladies dancing\",\n \"Eight maids a-milking\",\n \"Seven swans a-swimming\",\n \"Six geese a-laying\",\n \"Five golden rings\",\n \"Four calling birds\",\n \"Three french hens\", \n \"Two turtle doves\", \n \"And a partridge in a pear tree.\"\n };\n \n for(i=0;i<12;i++)\n {\n printf(\"\\n\\nOn the %s day of Christmas\\nMy true love gave to me:\",days[i]);\n \n for(j=i;j>=0;j--)\n {\n (i==0)?printf(\"\\nA partridge in a pear tree.\"):printf(\"\\n%s%c\",gifts[11-j],(j!=0)?',':' ');\n }\n }\n \n return 0;\n}\n","Rust":"fn main() {\n let days = [\"first\", \"second\", \"third\", \"fourth\", \"fifth\", \"sixth\", \"seventh\", \"eighth\",\n \"ninth\", \"tenth\", \"eleventh\", \"twelfth\"];\n\n let gifts = [\"A Partridge in a Pear Tree\",\n \"Two Turtle Doves and\",\n \"Three French Hens\",\n \"Four Calling Birds\",\n \"Five Golden Rings\",\n \"Six Geese a Laying\",\n \"Seven Swans a Swimming\",\n \"Eight Maids a Milking\",\n \"Nine Ladies Dancing\",\n \"Ten Lords a Leaping\",\n \"Eleven Pipers Piping\",\n \"Twelve Drummers Drumming\"];\n\n for i in 0..12 {\n println!(\"On the {} day of Christmas,\", days[i]);\n println!(\"My true love gave to me:\");\n\n for j in (0..i + 1).rev() {\n println!(\"{}\", gifts[j]);\n }\n println!()\n }\n}\n"} {"name":"Thue-Morse","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nint main(int argc, char *argv[]){\n\tchar sequence[256+1] = \"0\";\n\tchar inverse[256+1] = \"1\";\n\tchar buffer[256+1];\n\tint i;\n\t\n\tfor(i = 0; i < 8; i++){\n\t\tstrcpy(buffer, sequence);\n\t\tstrcat(sequence, inverse);\n\t\tstrcat(inverse, buffer);\n\t}\n\t\n\tputs(sequence);\n\treturn 0;\n}\n","Rust":"const ITERATIONS: usize = 8;\n\nfn neg(sequence: &String) -> String {\n sequence.chars()\n .map(|ch| {\n (1 - ch.to_digit(2).unwrap()).to_string()\n })\n .collect::<String>()\n}\n\nfn main() {\n let mut sequence: String = String::from(\"0\");\n for i in 0..ITERATIONS {\n println!(\"{}: {}\", i + 1, sequence);\n sequence = format!(\"{}{}\", sequence, neg(&sequence));\n }\n}\n"} {"name":"Tic-tac-toe","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint b[3][3]; \n\nint check_winner()\n{\n\tint i;\n\tfor (i = 0; i < 3; i++) {\n\t\tif (b[i][0] && b[i][1] == b[i][0] && b[i][2] == b[i][0])\n\t\t\treturn b[i][0];\n\t\tif (b[0][i] && b[1][i] == b[0][i] && b[2][i] == b[0][i])\n\t\t\treturn b[0][i];\n\t}\n\tif (!b[1][1]) return 0;\n\n\tif (b[1][1] == b[0][0] && b[2][2] == b[0][0]) return b[0][0];\n\tif (b[1][1] == b[2][0] && b[0][2] == b[1][1]) return b[1][1];\n\n\treturn 0;\n}\n\nvoid showboard()\n{\n\tconst char *t = \"X O\";\n\tint i, j;\n\tfor (i = 0; i < 3; i++, putchar('\\n'))\n\t\tfor (j = 0; j < 3; j++)\n\t\t\tprintf(\"%c \", t[ b[i][j] + 1 ]);\n\tprintf(\"-----\\n\");\n}\n\n#define for_ij for (i = 0; i < 3; i++) for (j = 0; j < 3; j++)\nint best_i, best_j;\nint test_move(int val, int depth)\n{\n\tint i, j, score;\n\tint best = -1, changed = 0;\n\n\tif ((score = check_winner())) return (score == val) ? 1 : -1;\n\n\tfor_ij {\n\t\tif (b[i][j]) continue;\n\n\t\tchanged = b[i][j] = val;\n\t\tscore = -test_move(-val, depth + 1);\n\t\tb[i][j] = 0;\n\n\t\tif (score <= best) continue;\n\t\tif (!depth) {\n\t\t\tbest_i = i;\n\t\t\tbest_j = j;\n\t\t}\n\t\tbest = score;\n\t}\n\n\treturn changed ? best : 0;\n}\n\nconst char* game(int user)\n{\n\tint i, j, k, move, win = 0;\n\tfor_ij b[i][j] = 0;\n\n\tprintf(\"Board postions are numbered so:\\n1 2 3\\n4 5 6\\n7 8 9\\n\");\n\tprintf(\"You have O, I have X.\\n\\n\");\n\tfor (k = 0; k < 9; k++, user = !user) {\n\t\twhile(user) {\n\t\t\tprintf(\"your move: \");\n\t\t\tif (!scanf(\"%d\", &move)) {\n\t\t\t\tscanf(\"%*s\");\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (--move < 0 || move >= 9) continue;\n\t\t\tif (b[i = move \/ 3][j = move % 3]) continue;\n\n\t\t\tb[i][j] = 1;\n\t\t\tbreak;\n\t\t}\n\t\tif (!user) {\n\t\t\tif (!k) { \n\t\t\t\tbest_i = rand() % 3;\n\t\t\t\tbest_j = rand() % 3;\n\t\t\t} else\n\t\t\t\ttest_move(-1, 0);\n\n\t\t\tb[best_i][best_j] = -1;\n\t\t\tprintf(\"My move: %d\\n\", best_i * 3 + best_j + 1);\n\t\t}\n\n\t\tshowboard();\n\t\tif ((win = check_winner())) \n\t\t\treturn win == 1 ? \"You win.\\n\\n\": \"I win.\\n\\n\";\n\t}\n\treturn \"A draw.\\n\\n\";\n}\n\nint main()\n{\n\tint first = 0;\n\twhile (1) printf(\"%s\", game(first = !first));\n\treturn 0;\n}\n","Rust":"use GameState::{ComputerWin, Draw, PlayerWin, Playing};\n\nuse rand::prelude::*;\n\n#[derive(PartialEq, Debug)]\nenum GameState {\n PlayerWin,\n ComputerWin,\n Draw,\n Playing,\n}\n\ntype Board = [[char; 3]; 3];\n\nfn main() {\n let mut rng = StdRng::from_entropy();\n\n let mut board: Board = [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']];\n\n draw_board(board);\n loop {\n player_turn(&mut board);\n if check_win(board) != Playing {\n break;\n }\n computer_turn(&mut rng, &mut board);\n if check_win(board) != Playing {\n break;\n }\n draw_board(board);\n }\n\n draw_board(board);\n let announcement = match check_win(board) {\n PlayerWin => \"The Player has won!\",\n ComputerWin => \"The Computer has won!\",\n Draw => \"Draw!\",\n Playing => unreachable!(),\n };\n println!(\"{}\", announcement);\n}\n\nfn is_empty(cell: &char) -> bool {\n *cell != 'X' && *cell != 'O'\n}\n\nfn check_win(board: Board) -> GameState {\n \n for (i, row) in board.iter().enumerate() {\n if row[0] == row[1] && row[0] == row[2] {\n return which_win(row[0]);\n } else if board[0][i] == board[1][i] && board[0][i] == board[2][i] {\n return which_win(board[0][i]);\n }\n }\n if board[0][0] == board[1][1] && board[0][0] == board[2][2] {\n return which_win(board[0][0]);\n } else if board[0][2] == board[1][1] && board[0][2] == board[2][0] {\n return which_win(board[0][2]);\n }\n\n \n let is_draw = board.iter().flatten().any(is_empty);\n if is_draw {\n Playing\n } else {\n Draw\n }\n}\n\nfn which_win(s: char) -> GameState {\n match s {\n 'X' => PlayerWin,\n 'O' => ComputerWin,\n _ => unreachable!(),\n }\n}\n\nfn player_turn(board: &mut Board) {\n use std::io;\n\n println!(\"Player, enter your field of choice!: \");\n let mut ln = String::new();\n io::stdin()\n .read_line(&mut ln)\n .expect(\"Failed to read stdin\");\n let choice = ln.trim().parse::<usize>().expect(\"Failed to parse input\");\n let row = (choice - 1) \/ 3;\n let col = (choice - 1) % 3;\n\n if board[row][col] == 'X' || board[row][col] == 'O' {\n println!(\"Someone already took this field!\");\n player_turn(board);\n } else {\n board[row][col] = 'X';\n }\n}\n\nfn computer_turn<R: Rng>(rng: &mut R, board: &mut Board) {\n let possible_choices: Vec<_> = board\n .iter()\n .flatten()\n .enumerate()\n .filter(|&(_, c)| is_empty(c))\n .map(|(i, _)| i)\n .collect();\n\n let choice = possible_choices.choose(rng).unwrap();\n println!(\"Computer chose: {}\", choice);\n let row = choice \/ 3;\n let col = choice % 3;\n board[row][col] = 'O';\n}\n\nfn draw_board(board: Board) {\n for row in &board {\n println!(\"{} {} {}\", row[0], row[1], row[2]);\n }\n}\n"} {"name":"Time a function","C":"#include <stdio.h>\n#include <time.h>\n\nint identity(int x) { return x; }\n\nint sum(int s)\n{\n int i;\n for(i=0; i < 1000000; i++) s += i;\n return s;\n}\n\n#ifdef CLOCK_PROCESS_CPUTIME_ID\n\n#define CLOCKTYPE CLOCK_PROCESS_CPUTIME_ID\n#else\n\n#define CLOCKTYPE CLOCK_MONOTONIC\n#endif\n\ndouble time_it(int (*action)(int), int arg)\n{\n struct timespec tsi, tsf;\n\n clock_gettime(CLOCKTYPE, &tsi);\n action(arg);\n clock_gettime(CLOCKTYPE, &tsf);\n\n double elaps_s = difftime(tsf.tv_sec, tsi.tv_sec);\n long elaps_ns = tsf.tv_nsec - tsi.tv_nsec;\n return elaps_s + ((double)elaps_ns) \/ 1.0e9;\n}\n\nint main()\n{\n printf(\"identity (4) takes %lf s\\n\", time_it(identity, 4));\n printf(\"sum (4) takes %lf s\\n\", time_it(sum, 4));\n return 0;\n}\n","Rust":"\n\nuse rand::Rng;\nuse std::time::{Instant};\n\nfn custom_function() {\n \n let mut i = 0;\n let mut rng = rand::thread_rng();\n let n1: f32 = rng.gen();\n\n while i < ( 1000000 + 1000000 * ( n1.log10() as i32 ) ) {\n i = i + 1;\n }\n}\n\nfn main() {\n\n let start = Instant::now();\n custom_function();\n let duration = start.elapsed();\n\n println!(\"Time elapsed in the custom_function() is\u00a0: {:?}\", duration);\n}\n"} {"name":"Tokenize a string","C":"#include<string.h>\n#include<stdio.h>\n#include<stdlib.h>\n\nint main(void)\n{\n\tchar *a[5];\n\tconst char *s=\"Hello,How,Are,You,Today\";\n\tint n=0, nn;\n\n\tchar *ds=strdup(s);\n\n\ta[n]=strtok(ds, \",\");\n\twhile(a[n] && n<4) a[++n]=strtok(NULL, \",\");\n\n\tfor(nn=0; nn<=n; ++nn) printf(\"%s.\", a[nn]);\n\tputchar('\\n');\n\n\tfree(ds);\n\n\treturn 0;\n}\n","Rust":"fn main() {\n let s = \"Hello,How,Are,You,Today\";\n let tokens: Vec<&str> = s.split(\",\").collect();\n println!(\"{}\", tokens.join(\".\"));\n}\n"} {"name":"Tokenize a string with escaping","C":"#include <stdlib.h>\n#include <stdio.h>\n\n#define STR_DEMO \"one^|uno||three^^^^|four^^^|^cuatro|\"\n#define SEP '|'\n#define ESC '^'\n\ntypedef char* Str; \n\n\nunsigned int ElQ( const char *s, char sep, char esc );\nStr *Tokenize( char *s, char sep, char esc, unsigned int *q );\n\n\n\nint main() {\n char s[] = STR_DEMO;\n unsigned int i, q;\n\n Str *list = Tokenize( s, SEP, ESC, &q );\n\n if( list != NULL ) {\n printf( \"\\n Original string: %s\\n\\n\", STR_DEMO );\n printf( \" %d tokens:\\n\\n\", q );\n\n for( i=0; i<q; ++i )\n printf( \" %4d. %s\\n\", i+1, list[i] );\n\n free( list );\n }\n\n return 0;\n}\n\n\n\nunsigned int ElQ( const char *s, char sep, char esc ) {\n unsigned int q, e;\n const char *p;\n\n for( e=0, q=1, p=s; *p; ++p ) {\n if( *p == esc )\n e = !e;\n else if( *p == sep )\n q += !e;\n else e = 0;\n }\n\n return q;\n}\n\n\n\nStr *Tokenize( char *s, char sep, char esc, unsigned int *q ) {\n Str *list = NULL;\n\n *q = ElQ( s, sep, esc );\n list = malloc( *q * sizeof(Str) );\n\n if( list != NULL ) {\n unsigned int e, i;\n char *p;\n\n i = 0;\n list[i++] = s;\n\n for( e=0, p=s; *p; ++p ) {\n if( *p == esc ) {\n e = !e;\n }\n else if( *p == sep && !e ) {\n list[i++] = p+1;\n *p = '\\0';\n }\n else {\n e = 0;\n }\n }\n }\n\n return list;\n}\n","Rust":"const SEPARATOR: char = '|';\nconst ESCAPE: char = '^';\nconst STRING: &str = \"one^|uno||three^^^^|four^^^|^cuatro|\";\n\nfn tokenize(string: &str) -> Vec<String> {\n let mut token = String::new();\n let mut tokens: Vec<String> = Vec::new();\n let mut chars = string.chars();\n while let Some(ch) = chars.next() {\n match ch {\n SEPARATOR => {\n tokens.push(token);\n token = String::new();\n },\n ESCAPE => {\n if let Some(next) = chars.next() {\n token.push(next);\n }\n },\n _ => token.push(ch),\n }\n }\n tokens.push(token);\n tokens\n}\n\nfn main() {\n println!(\"{:#?}\", tokenize(STRING));\n}\n"} {"name":"Top rank per group","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct {\n const char *name, *id, *dept;\n int sal;\n} person;\n\nperson ppl[] = {\n {\"Tyler Bennett\", \"E10297\", \"D101\", 32000},\n {\"John Rappl\", \"E21437\", \"D050\", 47000},\n {\"George Woltman\", \"E00127\", \"D101\", 53500},\n {\"Adam Smith\", \"E63535\", \"D202\", 18000},\n {\"Claire Buckman\", \"E39876\", \"D202\", 27800},\n {\"David McClellan\", \"E04242\", \"D101\", 41500},\n {\"Rich Holcomb\", \"E01234\", \"D202\", 49500},\n {\"Nathan Adams\", \"E41298\", \"D050\", 21900},\n {\"Richard Potter\", \"E43128\", \"D101\", 15900},\n {\"David Motsinger\", \"E27002\", \"D202\", 19250},\n {\"Tim Sampair\", \"E03033\", \"D101\", 27000},\n {\"Kim Arlich\", \"E10001\", \"D190\", 57000},\n {\"Timothy Grove\", \"E16398\", \"D190\", 29900},\n};\n\nint pcmp(const void *a, const void *b)\n{\n const person *aa = a, *bb = b;\n int x = strcmp(aa->dept, bb->dept);\n if (x) return x;\n return aa->sal > bb->sal ? -1 : aa->sal < bb->sal;\n}\n\n#define N sizeof(ppl)\/sizeof(person)\nvoid top(int n)\n{\n int i, rank;\n qsort(ppl, N, sizeof(person), pcmp);\n\n for (i = rank = 0; i < N; i++) {\n if (i && strcmp(ppl[i].dept, ppl[i - 1].dept)) {\n rank = 0;\n printf(\"\\n\");\n }\n\n if (rank++ < n)\n printf(\"%s %d: %s\\n\", ppl[i].dept, ppl[i].sal, ppl[i].name);\n }\n}\n\nint main()\n{\n top(2);\n return 0;\n}\n","Rust":"#[derive(Debug)]\nstruct Employee<S> {\n \n id: S,\n name: S,\n department: S,\n salary: u32,\n}\n\nimpl<S> Employee<S> {\n fn new(name: S, id: S, salary: u32, department: S) -> Self {\n Self {\n id,\n name,\n department,\n salary,\n }\n }\n}\n\n#[rustfmt::skip]\nfn load_data() -> Vec<Employee<&'static str>> {\n vec![\n Employee::new(\"Tyler Bennett\", \"E10297\", 32000, \"D101\"),\n Employee::new(\"John Rappl\", \"E21437\", 47000, \"D050\"),\n Employee::new(\"George Woltman\", \"E00127\", 53500, \"D101\"),\n Employee::new(\"Adam Smith\", \"E63535\", 18000, \"D202\"),\n Employee::new(\"Claire Buckman\", \"E39876\", 27800, \"D202\"),\n Employee::new(\"David McClellan\", \"E04242\", 41500, \"D101\"),\n Employee::new(\"Rich Holcomb\", \"E01234\", 49500, \"D202\"),\n Employee::new(\"Nathan Adams\", \"E41298\", 21900, \"D050\"),\n Employee::new(\"Richard Potter\", \"E43128\", 15900, \"D101\"),\n Employee::new(\"David Motsinger\", \"E27002\", 19250, \"D202\"),\n Employee::new(\"Tim Sampair\", \"E03033\", 27000, \"D101\"),\n Employee::new(\"Kim Arlich\", \"E10001\", 57000, \"D190\"),\n Employee::new(\"Timothy Grove\", \"E16398\", 29900, \"D190\"),\n \n Employee::new(\"Kim Tie\", \"E16400\", 57000, \"D190\"),\n Employee::new(\"Timothy Tie\", \"E16401\", 29900, \"D190\"),\n Employee::new(\"Timothy Kim\", \"E16401\", 19900, \"D190\"),\n ]\n}\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n let n = {\n println!(\"How many top salaries to list? \");\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf)?;\n buf.trim().parse::<u32>()?\n };\n\n let mut employees = load_data();\n\n \n employees.sort_by(|a, b| b.salary.cmp(&a.salary));\n\n let sorted = employees\n .into_iter()\n .fold(std::collections::BTreeMap::new(), |mut acc, next| {\n \n \n let mut bucket = acc\n .entry(next.department)\n .or_insert_with(|| (0, Vec::<Employee<_>>::new()));\n\n match bucket.1.last().map(|e| e.salary) {\n Some(last_salary) if last_salary == next.salary => {\n if bucket.0 <= n {\n bucket.1.push(next);\n }\n }\n\n _ => {\n if bucket.0 < n {\n bucket.0 += 1; \n bucket.1.push(next);\n }\n }\n }\n\n acc\n });\n\n for (department, (_, employees)) in sorted {\n println!(\"{}\", department);\n\n employees\n .iter()\n .for_each(|employee| println!(\" {:?}\", employee));\n }\n\n Ok(())\n}\n"} {"name":"Topological sort","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <ctype.h>\n\nchar input[] =\n\t\"des_system_lib std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee\\n\"\n\t\"dw01 ieee dw01 dware gtech\\n\"\n\t\"dw02 ieee dw02 dware\\n\"\n\t\"dw03 std synopsys dware dw03 dw02 dw01 ieee gtech\\n\"\n\t\"dw04 dw04 ieee dw01 dware gtech\\n\"\n\t\"dw05 dw05 ieee dware\\n\"\n\t\"dw06 dw06 ieee dware\\n\"\n\t\"dw07 ieee dware\\n\"\n\t\"dware ieee dware\\n\"\n\t\"gtech ieee gtech\\n\"\n\t\"ramlib std ieee\\n\"\n\t\"std_cell_lib ieee std_cell_lib\\n\"\n\t\"synopsys\\n\"\n\t\"cycle_11\t cycle_12\\n\"\n\t\"cycle_12\t cycle_11\\n\"\n\t\"cycle_21\t dw01 cycle_22 dw02 dw03\\n\"\n\t\"cycle_22\t cycle_21 dw01 dw04\";\n\ntypedef struct item_t item_t, *item;\nstruct item_t { const char *name; int *deps, n_deps, idx, depth; };\n\nint get_item(item *list, int *len, const char *name)\n{\n\tint i;\n\titem lst = *list;\n\n\tfor (i = 0; i < *len; i++)\n\t\tif (!strcmp(lst[i].name, name)) return i;\n\n\tlst = *list = realloc(lst, ++*len * sizeof(item_t));\n\ti = *len - 1;\n\tmemset(lst + i, 0, sizeof(item_t));\n\tlst[i].idx = i;\n\tlst[i].name = name;\n\treturn i;\n}\n\nvoid add_dep(item it, int i)\n{\n\tif (it->idx == i) return;\n\tit->deps = realloc(it->deps, (it->n_deps + 1) * sizeof(int));\n\tit->deps[it->n_deps++] = i;\n}\n\nint parse_input(item *ret)\n{\n\tint n_items = 0;\n\tint i, parent, idx;\n\titem list = 0;\n\n\tchar *s, *e, *word, *we;\n\tfor (s = input; ; s = 0) {\n\t\tif (!(s = strtok_r(s, \"\\n\", &e))) break;\n\n\t\tfor (i = 0, word = s; ; i++, word = 0) {\n\t\t\tif (!(word = strtok_r(word, \" \\t\", &we))) break;\n\t\t\tidx = get_item(&list, &n_items, word);\n\n\t\t\tif (!i) parent = idx;\n\t\t\telse add_dep(list + parent, idx);\n\t\t}\n\t}\n\n\t*ret = list;\n\treturn n_items;\n}\n\n\nint get_depth(item list, int idx, int bad)\n{\n\tint max, i, t;\n\n\tif (!list[idx].deps)\n\t\treturn list[idx].depth = 1;\n\n\tif ((t = list[idx].depth) < 0) return t;\n\n\tlist[idx].depth = bad;\n\tfor (max = i = 0; i < list[idx].n_deps; i++) {\n\t\tif ((t = get_depth(list, list[idx].deps[i], bad)) < 0) {\n\t\t\tmax = t;\n\t\t\tbreak;\n\t\t}\n\t\tif (max < t + 1) max = t + 1;\n\t}\n\treturn list[idx].depth = max;\n}\n\nint main()\n{\n\tint i, j, n, bad = -1, max, min;\n\titem items;\n\tn = parse_input(&items);\n\n\tfor (i = 0; i < n; i++)\n\t\tif (!items[i].depth && get_depth(items, i, bad) < 0) bad--;\n\n\tfor (i = 0, max = min = 0; i < n; i++) {\n\t\tif (items[i].depth > max) max = items[i].depth;\n\t\tif (items[i].depth < min) min = items[i].depth;\n\t}\n\n\tprintf(\"Compile order:\\n\");\n\tfor (i = min; i <= max; i++) {\n\t\tif (!i) continue;\n\n\t\tif (i < 0) printf(\" [unorderable]\");\n\t\telse\t printf(\"%d:\", i);\n\n\t\tfor (j = 0; j < n || !putchar('\\n'); j++)\n\t\t\tif (items[j].depth == i)\n\t\t\t\tprintf(\" %s\", items[j].name);\n\t}\n\n\treturn 0;\n}\n","Rust":"use std::boxed::Box;\nuse std::collections::{HashMap, HashSet};\n\n#[derive(Debug, PartialEq, Eq, Hash)]\nstruct Library<'a> {\n name: &'a str,\n children: Vec<&'a str>,\n num_parents: usize,\n}\n\nfn build_libraries(input: Vec<&str>) -> HashMap<&str, Box<Library>> {\n let mut libraries: HashMap<&str, Box<Library>> = HashMap::new();\n\n for input_line in input {\n let line_split = input_line.split_whitespace().collect::<Vec<&str>>();\n let name = line_split.get(0).unwrap();\n let mut num_parents: usize = 0;\n for parent in line_split.iter().skip(1) {\n if parent == name {\n continue;\n }\n if !libraries.contains_key(parent) {\n libraries.insert(\n parent,\n Box::new(Library {\n name: parent,\n children: vec![name],\n num_parents: 0,\n }),\n );\n } else {\n libraries.get_mut(parent).unwrap().children.push(name);\n }\n num_parents += 1;\n }\n\n if !libraries.contains_key(name) {\n libraries.insert(\n name,\n Box::new(Library {\n name,\n children: Vec::new(),\n num_parents,\n }),\n );\n } else {\n libraries.get_mut(name).unwrap().num_parents = num_parents;\n }\n }\n libraries\n}\n\nfn topological_sort<'a>(\n mut libraries: HashMap<&'a str, Box<Library<'a>>>,\n) -> Result<Vec<&'a str>, String> {\n let mut needs_processing = libraries\n .iter()\n .map(|(k, _v)| k.clone())\n .collect::<HashSet<&str>>();\n let mut options: Vec<&str> = libraries\n .iter()\n .filter(|(_k, v)| v.num_parents == 0)\n .map(|(k, _v)| *k)\n .collect();\n let mut sorted: Vec<&str> = Vec::new();\n while !options.is_empty() {\n let cur = options.pop().unwrap();\n for children in libraries\n .get_mut(cur)\n .unwrap()\n .children\n .drain(0..)\n .collect::<Vec<&str>>()\n {\n let child = libraries.get_mut(children).unwrap();\n child.num_parents -= 1;\n if child.num_parents == 0 {\n options.push(child.name)\n }\n }\n sorted.push(cur);\n needs_processing.remove(cur);\n }\n match needs_processing.is_empty() {\n true => Ok(sorted),\n false => Err(format!(\"Cycle detected among {:?}\", needs_processing)),\n }\n}\n\nfn main() {\n let input: Vec<&str> = vec![\n \"des_system_lib std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee\\n\",\n \"dw01 ieee dw01 dware gtech dw04\\n\",\n \"dw02 ieee dw02 dware\\n\",\n \"dw03 std synopsys dware dw03 dw02 dw01 ieee gtech\\n\",\n \"dw04 dw04 ieee dw01 dware gtech\\n\",\n \"dw05 dw05 ieee dware\\n\",\n \"dw06 dw06 ieee dware\\n\",\n \"dw07 ieee dware\\n\",\n \"dware ieee dware\\n\",\n \"gtech ieee gtech\\n\",\n \"ramlib std ieee\\n\",\n \"std_cell_lib ieee std_cell_lib\\n\",\n \"synopsys\\n\",\n ];\n\n let libraries = build_libraries(input);\n match topological_sort(libraries) {\n Ok(sorted) => println!(\"{:?}\", sorted),\n Err(msg) => println!(\"{:?}\", msg),\n }\n}\n"} {"name":"Totient function","C":"\n\n#include<stdio.h>\n\nint totient(int n){\n\tint 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\nint main()\n{\n\tint count = 0,n,tot;\n\t\n\tprintf(\" n %c prime\",237);\n printf(\"\\n---------------\\n\");\n\t\n\tfor(n=1;n<=25;n++){\n\t\ttot = totient(n);\n\t\t\n\t\tif(n-1 == tot)\n\t\t\tcount++;\n\t\t\n\t\tprintf(\"%2d %2d %s\\n\", n, tot, n-1 == tot?\"True\":\"False\");\n\t}\n\t\n\tprintf(\"\\nNumber of primes up to %6d =%4d\\n\", 25,count);\n\t\n\tfor(n = 26; n <= 100000; n++){\n tot = totient(n);\n if(tot == n-1)\n\t\t\tcount++;\n \n if(n == 100 || n == 1000 || n%10000 == 0){\n printf(\"\\nNumber of primes up to %6d = %4d\\n\", n, count);\n }\n }\n\t\n\treturn 0;\n}\n","Rust":"use num::integer::gcd;\n\nfn main() {\n \n println!(\"N\\t phi(n)\\t Prime\");\n for n in 1..26 {\n let phi_n = phi(n);\n println!(\"{}\\t {}\\t {:?}\", n, phi_n, phi_n == n - 1);\n }\n\n \n [1, 100, 1000, 10000, 100000]\n .windows(2)\n .scan(0, |acc, tuple| {\n *acc += (tuple[0]..=tuple[1]).filter(is_prime).count();\n Some((tuple[1], *acc))\n })\n .for_each(|x| println!(\"Until {}: {} prime numbers\", x.0, x.1));\n}\n\nfn is_prime(n: &usize) -> bool {\n phi(*n) == *n - 1\n}\n\nfn phi(n: usize) -> usize {\n (1..=n).filter(|&x| gcd(n, x) == 1).count()\n}\n"} {"name":"Towers of Hanoi","C":"#include <stdio.h>\n\nvoid move(int n, int from, int via, int to)\n{\n if (n > 1) {\n move(n - 1, from, to, via);\n printf(\"Move disk from pole %d to pole %d\\n\", from, to);\n move(n - 1, via, from, to);\n } else {\n printf(\"Move disk from pole %d to pole %d\\n\", from, to);\n }\n}\nint main()\n{\n move(4, 1,2,3);\n return 0;\n}\n","Rust":"fn move_(n: i32, from: i32, to: i32, via: i32) {\n if n > 0 {\n move_(n - 1, from, via, to);\n println!(\"Move disk from pole {} to pole {}\", from, to);\n move_(n - 1, via, to, from);\n }\n}\n\nfn main() {\n move_(4, 1,2,3);\n}\n"} {"name":"Tree traversal","C":"#include <stdlib.h>\n#include <stdio.h>\n\ntypedef struct node_s\n{\n int value;\n struct node_s* left;\n struct node_s* right;\n} *node;\n\nnode tree(int v, node l, node r)\n{\n node n = malloc(sizeof(struct node_s));\n n->value = v;\n n->left = l;\n n->right = r;\n return n;\n}\n\nvoid destroy_tree(node n)\n{\n if (n->left)\n destroy_tree(n->left);\n if (n->right)\n destroy_tree(n->right);\n free(n);\n}\n\nvoid preorder(node n, void (*f)(int))\n{\n f(n->value);\n if (n->left)\n preorder(n->left, f);\n if (n->right)\n preorder(n->right, f);\n}\n\nvoid inorder(node n, void (*f)(int))\n{\n if (n->left)\n inorder(n->left, f);\n f(n->value);\n if (n->right)\n inorder(n->right, f);\n}\n\nvoid postorder(node n, void (*f)(int))\n{\n if (n->left)\n postorder(n->left, f);\n if (n->right)\n postorder(n->right, f);\n f(n->value);\n}\n\n\ntypedef struct qnode_s\n{\n struct qnode_s* next;\n node value;\n} *qnode;\n\ntypedef struct { qnode begin, end; } queue;\n\nvoid enqueue(queue* q, node n)\n{\n qnode node = malloc(sizeof(struct qnode_s));\n node->value = n;\n node->next = 0;\n if (q->end)\n q->end->next = node;\n else\n q->begin = node;\n q->end = node;\n}\n\nnode dequeue(queue* q)\n{\n node tmp = q->begin->value;\n qnode second = q->begin->next;\n free(q->begin);\n q->begin = second;\n if (!q->begin)\n q->end = 0;\n return tmp;\n}\n\nint queue_empty(queue* q)\n{\n return !q->begin;\n}\n\nvoid levelorder(node n, void(*f)(int))\n{\n queue nodequeue = {};\n enqueue(&nodequeue, n);\n while (!queue_empty(&nodequeue))\n {\n node next = dequeue(&nodequeue);\n f(next->value);\n if (next->left)\n enqueue(&nodequeue, next->left);\n if (next->right)\n enqueue(&nodequeue, next->right);\n }\n}\n\nvoid print(int n)\n{\n printf(\"%d \", n);\n}\n\nint main()\n{\n node n = tree(1,\n tree(2,\n tree(4,\n tree(7, 0, 0),\n 0),\n tree(5, 0, 0)),\n tree(3,\n tree(6,\n tree(8, 0, 0),\n tree(9, 0, 0)),\n 0));\n\n printf(\"preorder: \");\n preorder(n, print);\n printf(\"\\n\");\n\n printf(\"inorder: \");\n inorder(n, print);\n printf(\"\\n\");\n\n printf(\"postorder: \");\n postorder(n, print);\n printf(\"\\n\");\n\n printf(\"level-order: \");\n levelorder(n, print);\n printf(\"\\n\");\n\n destroy_tree(n);\n\n return 0;\n}\n","Rust":"#![feature(box_syntax, box_patterns)]\n\nuse std::collections::VecDeque;\n\n#[derive(Debug)]\nstruct TreeNode<T> {\n value: T,\n left: Option<Box<TreeNode<T>>>,\n right: Option<Box<TreeNode<T>>>,\n}\n\nenum TraversalMethod {\n PreOrder,\n InOrder,\n PostOrder,\n LevelOrder,\n}\n\nimpl<T> TreeNode<T> {\n pub fn new(arr: &[[i8; 3]]) -> TreeNode<i8> {\n\n let l = match arr[0][1] {\n -1 => None,\n i @ _ => Some(Box::new(TreeNode::<i8>::new(&arr[(i - arr[0][0]) as usize..]))),\n };\n let r = match arr[0][2] {\n -1 => None,\n i @ _ => Some(Box::new(TreeNode::<i8>::new(&arr[(i - arr[0][0]) as usize..]))),\n };\n\n TreeNode {\n value: arr[0][0],\n left: l,\n right: r,\n }\n }\n\n pub fn traverse(&self, tr: &TraversalMethod) -> Vec<&TreeNode<T>> {\n match tr {\n &TraversalMethod::PreOrder => self.iterative_preorder(),\n &TraversalMethod::InOrder => self.iterative_inorder(),\n &TraversalMethod::PostOrder => self.iterative_postorder(),\n &TraversalMethod::LevelOrder => self.iterative_levelorder(),\n }\n }\n\n fn iterative_preorder(&self) -> Vec<&TreeNode<T>> {\n let mut stack: Vec<&TreeNode<T>> = Vec::new();\n let mut res: Vec<&TreeNode<T>> = Vec::new();\n\n stack.push(self);\n while !stack.is_empty() {\n let node = stack.pop().unwrap();\n res.push(node);\n match node.right {\n None => {}\n Some(box ref n) => stack.push(n),\n }\n match node.left {\n None => {}\n Some(box ref n) => stack.push(n),\n }\n }\n res\n }\n\n \n fn iterative_inorder(&self) -> Vec<&TreeNode<T>> {\n let mut stack: Vec<&TreeNode<T>> = Vec::new();\n let mut res: Vec<&TreeNode<T>> = Vec::new();\n let mut p = self;\n\n loop {\n \n loop {\n match p.right {\n None => {}\n Some(box ref n) => stack.push(n),\n }\n stack.push(p);\n match p.left {\n None => break,\n Some(box ref n) => p = n,\n }\n }\n \n p = stack.pop().unwrap();\n while !stack.is_empty() && p.right.is_none() {\n res.push(p);\n p = stack.pop().unwrap();\n }\n \n res.push(p);\n if stack.is_empty() {\n break;\n } else {\n p = stack.pop().unwrap();\n }\n }\n res\n }\n\n \n fn iterative_postorder(&self) -> Vec<&TreeNode<T>> {\n let mut stack: Vec<&TreeNode<T>> = Vec::new();\n let mut res: Vec<&TreeNode<T>> = Vec::new();\n\n stack.push(self);\n while !stack.is_empty() {\n let node = stack.pop().unwrap();\n res.push(node);\n match node.left {\n None => {}\n Some(box ref n) => stack.push(n),\n }\n match node.right {\n None => {}\n Some(box ref n) => stack.push(n),\n }\n }\n let rev_iter = res.iter().rev();\n let mut rev: Vec<&TreeNode<T>> = Vec::new();\n for elem in rev_iter {\n rev.push(elem);\n }\n rev\n }\n\n fn iterative_levelorder(&self) -> Vec<&TreeNode<T>> {\n let mut queue: VecDeque<&TreeNode<T>> = VecDeque::new();\n let mut res: Vec<&TreeNode<T>> = Vec::new();\n\n queue.push_back(self);\n while !queue.is_empty() {\n let node = queue.pop_front().unwrap();\n res.push(node);\n match node.left {\n None => {}\n Some(box ref n) => queue.push_back(n),\n }\n match node.right {\n None => {}\n Some(box ref n) => queue.push_back(n),\n }\n }\n res\n }\n}\n\nfn main() {\n \n let arr_tree = [[1, 2, 3],\n [2, 4, 5],\n [3, 6, -1],\n [4, 7, -1],\n [5, -1, -1],\n [6, 8, 9],\n [7, -1, -1],\n [8, -1, -1],\n [9, -1, -1]];\n\n let root = TreeNode::<i8>::new(&arr_tree);\n\n for method_label in [(TraversalMethod::PreOrder, \"pre-order:\"),\n (TraversalMethod::InOrder, \"in-order:\"),\n (TraversalMethod::PostOrder, \"post-order:\"),\n (TraversalMethod::LevelOrder, \"level-order:\")]\n .iter() {\n print!(\"{}\\t\", method_label.1);\n for n in root.traverse(&method_label.0) {\n print!(\" {}\", n.value);\n }\n print!(\"\\n\");\n }\n}\n"} {"name":"Trigonometric functions","C":"#include <math.h>\n#include <stdio.h>\n\nint main() {\n double pi = 4 * atan(1);\n \n double radians = pi \/ 4;\n double degrees = 45.0;\n double temp;\n \n printf(\"%f %f\\n\", sin(radians), sin(degrees * pi \/ 180));\n \n printf(\"%f %f\\n\", cos(radians), cos(degrees * pi \/ 180));\n \n printf(\"%f %f\\n\", tan(radians), tan(degrees * pi \/ 180));\n \n temp = asin(sin(radians));\n printf(\"%f %f\\n\", temp, temp * 180 \/ pi);\n \n temp = acos(cos(radians));\n printf(\"%f %f\\n\", temp, temp * 180 \/ pi);\n \n temp = atan(tan(radians));\n printf(\"%f %f\\n\", temp, temp * 180 \/ pi);\n\n return 0;\n}\n","Rust":"\n\nuse std::f64::consts::PI;\n\nfn main() {\n let angle_radians: f64 = PI\/4.0;\n let angle_degrees: f64 = 45.0;\n\n println!(\"{} {}\", angle_radians.sin(), angle_degrees.to_radians().sin());\n println!(\"{} {}\", angle_radians.cos(), angle_degrees.to_radians().cos());\n println!(\"{} {}\", angle_radians.tan(), angle_degrees.to_radians().tan());\n\n let asin = angle_radians.sin().asin();\n println!(\"{} {}\", asin, asin.to_degrees());\n let acos = angle_radians.cos().acos();\n println!(\"{} {}\", acos, acos.to_degrees());\n let atan = angle_radians.tan().atan();\n println!(\"{} {}\", atan, atan.to_degrees());\n}\n"} {"name":"Truncatable primes","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#define MAX_PRIME 1000000\nchar *primes;\nint n_primes;\n\n\nvoid init_primes()\n{\n\tint j;\n\tprimes = malloc(sizeof(char) * MAX_PRIME);\n\tmemset(primes, 1, MAX_PRIME);\n\tprimes[0] = primes[1] = 0;\n\tint i = 2;\n\twhile (i * i < MAX_PRIME) {\n\t\tfor (j = i * 2; j < MAX_PRIME; j += i)\n\t\t\tprimes[j] = 0;\n\t\twhile (++i < MAX_PRIME && !primes[i]);\n\t}\n}\n\nint left_trunc(int n)\n{\n\tint tens = 1;\n\twhile (tens < n) tens *= 10;\n\n\twhile (n) {\n\t\tif (!primes[n]) return 0;\n\t\ttens \/= 10;\n\t\tif (n < tens) return 0;\n\t\tn %= tens;\n\t}\n\treturn 1;\n}\n\nint right_trunc(int n)\n{\n\twhile (n) {\n\t\tif (!primes[n]) return 0;\n\t\tn \/= 10;\n\t}\n\treturn 1;\n}\n\nint main()\n{\n\tint n;\n\tint max_left = 0, max_right = 0;\n\tinit_primes();\n\n\tfor (n = MAX_PRIME - 1; !max_left; n -= 2)\n\t\tif (left_trunc(n)) max_left = n;\n\n\tfor (n = MAX_PRIME - 1; !max_right; n -= 2)\n\t\tif (right_trunc(n)) max_right = n;\n\n\tprintf(\"Left: %d; right: %d\\n\", max_left, max_right);\n\treturn 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_left_truncatable(p: u32) -> bool {\n let mut n = 10;\n let mut q = p;\n while p > n {\n if !is_prime(p % n) || q == p % n {\n return false;\n }\n q = p % n;\n n *= 10;\n }\n true\n}\n\nfn is_right_truncatable(p: u32) -> bool {\n let mut q = p \/ 10;\n while q > 0 {\n if !is_prime(q) {\n return false;\n }\n q \/= 10;\n }\n true\n}\n\nfn main() {\n let limit = 1000000;\n let mut largest_left = 0;\n let mut largest_right = 0;\n let mut p = limit;\n while p >= 2 {\n if is_prime(p) && is_left_truncatable(p) {\n largest_left = p;\n break;\n }\n p -= 1;\n }\n println!(\"Largest left truncatable prime is {}\", largest_left);\n p = limit;\n while p >= 2 {\n if is_prime(p) && is_right_truncatable(p) {\n largest_right = p;\n break;\n }\n p -= 1;\n }\n println!(\"Largest right truncatable prime is {}\", largest_right);\n}\n"} {"name":"URL decoding","C":"#include <stdio.h>\n#include <string.h>\n\ninline int ishex(int x)\n{\n\treturn\t(x >= '0' && x <= '9')\t||\n\t\t(x >= 'a' && x <= 'f')\t||\n\t\t(x >= 'A' && x <= 'F');\n}\n\nint decode(const char *s, char *dec)\n{\n\tchar *o;\n\tconst char *end = s + strlen(s);\n\tint c;\n\n\tfor (o = dec; s <= end; o++) {\n\t\tc = *s++;\n\t\tif (c == '+') c = ' ';\n\t\telse if (c == '%' && (\t!ishex(*s++)\t||\n\t\t\t\t\t!ishex(*s++)\t||\n\t\t\t\t\t!sscanf(s - 2, \"%2x\", &c)))\n\t\t\treturn -1;\n\n\t\tif (dec) *o = c;\n\t}\n\n\treturn o - dec;\n}\n\nint main()\n{\n\tconst char *url = \"http%3A%2F%2ffoo+bar%2fabcd\";\n\tchar out[strlen(url) + 1];\n\n\tprintf(\"length: %d\\n\", decode(url, 0));\n\tputs(decode(url, out) < 0 ? \"bad string\" : out);\n\n\treturn 0;\n}\n","Rust":"const INPUT1: &str = \"http%3A%2F%2Ffoo%20bar%2F\";\nconst INPUT2: &str = \"google.com\/search?q=%60Abdu%27l-Bah%C3%A1\";\n\nfn append_frag(text: &mut String, frag: &mut String) {\n if !frag.is_empty() {\n let encoded = frag.chars()\n .collect::<Vec<char>>()\n .chunks(2)\n .map(|ch| {\n u8::from_str_radix(&ch.iter().collect::<String>(), 16).unwrap()\n }).collect::<Vec<u8>>();\n text.push_str(&std::str::from_utf8(&encoded).unwrap());\n frag.clear();\n }\n}\n\nfn decode(text: &str) -> String {\n let mut output = String::new();\n let mut encoded_ch = String::new();\n let mut iter = text.chars();\n while let Some(ch) = iter.next() {\n if ch == '%' {\n encoded_ch.push_str(&format!(\"{}{}\", iter.next().unwrap(), iter.next().unwrap()));\n } else {\n append_frag(&mut output, &mut encoded_ch);\n output.push(ch);\n }\n }\n append_frag(&mut output, &mut encoded_ch);\n output\n}\n\nfn main() {\n println!(\"{}\", decode(INPUT1));\n println!(\"{}\", decode(INPUT2));\n}\n"} {"name":"UTF-8 encode and decode","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <inttypes.h>\n\ntypedef struct {\n\tchar mask; \n\tchar lead; \n\tuint32_t beg; \n\tuint32_t end; \n\tint bits_stored; \n}utf_t;\n\nutf_t * utf[] = {\n\t\n\t[0] = &(utf_t){0b00111111, 0b10000000, 0, 0, 6 },\n\t[1] = &(utf_t){0b01111111, 0b00000000, 0000, 0177, 7 },\n\t[2] = &(utf_t){0b00011111, 0b11000000, 0200, 03777, 5 },\n\t[3] = &(utf_t){0b00001111, 0b11100000, 04000, 0177777, 4 },\n\t[4] = &(utf_t){0b00000111, 0b11110000, 0200000, 04177777, 3 },\n\t &(utf_t){0},\n};\n\n\nint codepoint_len(const uint32_t cp); \nint utf8_len(const char ch); \n\nchar *to_utf8(const uint32_t cp);\nuint32_t to_cp(const char chr[4]);\n\nint codepoint_len(const uint32_t cp)\n{\n\tint len = 0;\n\tfor(utf_t **u = utf; *u; ++u) {\n\t\tif((cp >= (*u)->beg) && (cp <= (*u)->end)) {\n\t\t\tbreak;\n\t\t}\n\t\t++len;\n\t}\n\tif(len > 4) \n\t\texit(1);\n\n\treturn len;\n}\n\nint utf8_len(const char ch)\n{\n\tint len = 0;\n\tfor(utf_t **u = utf; *u; ++u) {\n\t\tif((ch & ~(*u)->mask) == (*u)->lead) {\n\t\t\tbreak;\n\t\t}\n\t\t++len;\n\t}\n\tif(len > 4) { \n\t\texit(1);\n\t}\n\treturn len;\n}\n\nchar *to_utf8(const uint32_t cp)\n{\n\tstatic char ret[5];\n\tconst int bytes = codepoint_len(cp);\n\n\tint shift = utf[0]->bits_stored * (bytes - 1);\n\tret[0] = (cp >> shift & utf[bytes]->mask) | utf[bytes]->lead;\n\tshift -= utf[0]->bits_stored;\n\tfor(int i = 1; i < bytes; ++i) {\n\t\tret[i] = (cp >> shift & utf[0]->mask) | utf[0]->lead;\n\t\tshift -= utf[0]->bits_stored;\n\t}\n\tret[bytes] = '\\0';\n\treturn ret;\n}\n\nuint32_t to_cp(const char chr[4])\n{\n\tint bytes = utf8_len(*chr);\n\tint shift = utf[0]->bits_stored * (bytes - 1);\n\tuint32_t codep = (*chr++ & utf[bytes]->mask) << shift;\n\n\tfor(int i = 1; i < bytes; ++i, ++chr) {\n\t\tshift -= utf[0]->bits_stored;\n\t\tcodep |= ((char)*chr & utf[0]->mask) << shift;\n\t}\n\n\treturn codep;\n}\n\nint main(void)\n{\n\tconst uint32_t *in, input[] = {0x0041, 0x00f6, 0x0416, 0x20ac, 0x1d11e, 0x0};\n\n\tprintf(\"Character Unicode UTF-8 encoding (hex)\\n\");\n\tprintf(\"----------------------------------------\\n\");\n\n\tchar *utf8;\n\tuint32_t codepoint;\n\tfor(in = input; *in; ++in) {\n\t\tutf8 = to_utf8(*in);\n\t\tcodepoint = to_cp(utf8);\n\t\tprintf(\"%s U+%-7.4x\", utf8, codepoint);\n\n\t\tfor(int i = 0; utf8[i] && i < 4; ++i) {\n\t\t\tprintf(\"%hhx \", utf8[i]);\n\t\t}\n\t\tprintf(\"\\n\");\n\t}\n\treturn 0;\n}\n","Rust":"fn main() {\n let chars = vec!('A', '\u00f6', '\u0416', '\u20ac', '\ud834\udd1e');\n chars.iter().for_each(|c| {\n let mut encoded = vec![0; c.len_utf8()];\n c.encode_utf8(&mut encoded);\n let decoded = String::from_utf8(encoded.to_vec()).unwrap();\n let encoded_string = encoded.iter().fold(String::new(), |acc, val| format!(\"{}{:X}\", acc, val));\n println!(\"Character: {}, Unicode:{}, UTF-8 encoded:{}, Decoded: {}\", c, c.escape_unicode(), encoded_string , decoded);\n });\n}\n"} {"name":"Unbias a random generator","C":"#include <stdio.h>\n#include <stdlib.h>\n \nint biased(int bias)\n{\n\t\n\tint r, rand_max = RAND_MAX - (RAND_MAX % bias);\n\twhile ((r = rand()) > rand_max);\n\treturn r < rand_max \/ bias;\n}\n\nint unbiased(int bias)\n{\n\tint a;\n\twhile ((a = biased(bias)) == biased(bias));\n\treturn a;\n}\n\nint main()\n{\n\tint b, n = 10000, cb, cu, i;\n\tfor (b = 3; b <= 6; b++) {\n\t\tfor (i = cb = cu = 0; i < n; i++) {\n\t\t\tcb += biased(b);\n\t\t\tcu += unbiased(b);\n\t\t}\n\t\tprintf(\"bias %d: %5.3f%% vs %5.3f%%\\n\", b,\n\t\t\t100. * cb \/ n, 100. * cu \/ n);\n\t}\n\n\treturn 0;\n}\n","Rust":"#![feature(inclusive_range_syntax)]\n\nextern crate rand;\n\nuse rand::Rng;\n\nfn rand_n<R: Rng>(rng: &mut R, n: u32) -> usize {\n rng.gen_weighted_bool(n) as usize \n}\n\nfn unbiased<R: Rng>(rng: &mut R, n: u32) -> usize {\n let mut bit = rand_n(rng, n);\n while bit == rand_n(rng, n) {\n bit = rand_n(rng, n);\n }\n bit\n}\n\nfn main() {\n const SAMPLES: usize = 100_000;\n let mut rng = rand::weak_rng();\n\n println!(\" Bias rand_n unbiased\");\n for n in 3..=6 {\n let mut count_biased = 0;\n let mut count_unbiased = 0;\n for _ in 0..SAMPLES {\n count_biased += rand_n(&mut rng, n);\n count_unbiased += unbiased(&mut rng, n);\n }\n\n let b_percentage = 100.0 * count_biased as f64 \/ SAMPLES as f64;\n let ub_percentage = 100.0 * count_unbiased as f64 \/ SAMPLES as f64;\n println!(\n \"bias {}: {:0.2}% {:0.2}%\",\n n, b_percentage, ub_percentage\n );\n }\n}\n"} {"name":"Undefined values","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint main()\n{\n int junk, *junkp;\n\n \n printf(\"junk: %d\\n\", junk);\n\n \n junkp = malloc(sizeof *junkp);\n if (junkp)\n printf(\"*junkp: %d\\n\", *junkp);\n return 0;\n}\n","Rust":"use std::ptr;\n\nlet p: *const i32 = ptr::null();\nassert!(p.is_null());\n"} {"name":"Universal Turing machine","C":"#include <stdio.h>\n#include <stdarg.h>\n#include <stdlib.h>\n#include <string.h>\n\nenum {\n LEFT,\n RIGHT,\n STAY\n};\n\ntypedef struct {\n int state1;\n int symbol1;\n int symbol2;\n int dir;\n int state2;\n} transition_t;\n\ntypedef struct tape_t tape_t;\nstruct tape_t {\n int symbol;\n tape_t *left;\n tape_t *right;\n};\n\ntypedef struct {\n int states_len;\n char **states;\n int final_states_len;\n int *final_states;\n int symbols_len;\n char *symbols;\n int blank;\n int state;\n int tape_len;\n tape_t *tape;\n int transitions_len;\n transition_t ***transitions;\n} turing_t;\n\nint state_index (turing_t *t, char *state) {\n int i;\n for (i = 0; i < t->states_len; i++) {\n if (!strcmp(t->states[i], state)) {\n return i;\n }\n }\n return 0;\n}\n\nint symbol_index (turing_t *t, char symbol) {\n int i;\n for (i = 0; i < t->symbols_len; i++) {\n if (t->symbols[i] == symbol) {\n return i;\n }\n }\n return 0;\n}\n\nvoid move (turing_t *t, int dir) {\n tape_t *orig = t->tape;\n if (dir == RIGHT) {\n if (orig && orig->right) {\n t->tape = orig->right;\n }\n else {\n t->tape = calloc(1, sizeof (tape_t));\n t->tape->symbol = t->blank;\n if (orig) {\n t->tape->left = orig;\n orig->right = t->tape;\n }\n }\n }\n else if (dir == LEFT) {\n if (orig && orig->left) {\n t->tape = orig->left;\n }\n else {\n t->tape = calloc(1, sizeof (tape_t));\n t->tape->symbol = t->blank;\n if (orig) {\n t->tape->right = orig;\n orig->left = t->tape;\n }\n }\n }\n}\n\nturing_t *create (int states_len, ...) {\n va_list args;\n va_start(args, states_len);\n turing_t *t = malloc(sizeof (turing_t));\n t->states_len = states_len;\n t->states = malloc(states_len * sizeof (char *));\n int i;\n for (i = 0; i < states_len; i++) {\n t->states[i] = va_arg(args, char *);\n }\n t->final_states_len = va_arg(args, int);\n t->final_states = malloc(t->final_states_len * sizeof (int));\n for (i = 0; i < t->final_states_len; i++) {\n t->final_states[i] = state_index(t, va_arg(args, char *));\n }\n t->symbols_len = va_arg(args, int);\n t->symbols = malloc(t->symbols_len);\n for (i = 0; i < t->symbols_len; i++) {\n t->symbols[i] = va_arg(args, int);\n }\n t->blank = symbol_index(t, va_arg(args, int));\n t->state = state_index(t, va_arg(args, char *));\n t->tape_len = va_arg(args, int);\n t->tape = NULL;\n for (i = 0; i < t->tape_len; i++) {\n move(t, RIGHT);\n t->tape->symbol = symbol_index(t, va_arg(args, int));\n }\n if (!t->tape_len) {\n move(t, RIGHT);\n }\n while (t->tape->left) {\n t->tape = t->tape->left;\n }\n t->transitions_len = va_arg(args, int);\n t->transitions = malloc(t->states_len * sizeof (transition_t **));\n for (i = 0; i < t->states_len; i++) {\n t->transitions[i] = malloc(t->symbols_len * sizeof (transition_t *));\n }\n for (i = 0; i < t->transitions_len; i++) {\n transition_t *tran = malloc(sizeof (transition_t));\n tran->state1 = state_index(t, va_arg(args, char *));\n tran->symbol1 = symbol_index(t, va_arg(args, int));\n tran->symbol2 = symbol_index(t, va_arg(args, int));\n tran->dir = va_arg(args, int);\n tran->state2 = state_index(t, va_arg(args, char *));\n t->transitions[tran->state1][tran->symbol1] = tran;\n }\n va_end(args);\n return t;\n}\n\nvoid print_state (turing_t *t) {\n printf(\"%-10s \", t->states[t->state]);\n tape_t *tape = t->tape;\n while (tape->left) {\n tape = tape->left;\n }\n while (tape) {\n if (tape == t->tape) {\n printf(\"[%c]\", t->symbols[tape->symbol]);\n }\n else {\n printf(\" %c \", t->symbols[tape->symbol]);\n }\n tape = tape->right;\n }\n printf(\"\\n\");\n}\n\nvoid run (turing_t *t) {\n int i;\n while (1) {\n print_state(t);\n for (i = 0; i < t->final_states_len; i++) {\n if (t->final_states[i] == t->state) {\n return;\n }\n }\n transition_t *tran = t->transitions[t->state][t->tape->symbol];\n t->tape->symbol = tran->symbol2;\n move(t, tran->dir);\n t->state = tran->state2;\n }\n}\n\nint main () {\n printf(\"Simple incrementer\\n\");\n turing_t *t = create(\n 2, \"q0\", \"qf\",\n 1, \"qf\",\n 2, 'B', '1',\n 'B',\n \"q0\",\n 3, '1', '1', '1',\n 2,\n \"q0\", '1', '1', RIGHT, \"q0\",\n \"q0\", 'B', '1', STAY, \"qf\"\n );\n run(t);\n printf(\"\\nThree-state busy beaver\\n\");\n t = create(\n 4, \"a\", \"b\", \"c\", \"halt\",\n 1, \"halt\",\n 2, '0', '1',\n '0',\n \"a\",\n 0,\n 6,\n \"a\", '0', '1', RIGHT, \"b\",\n \"a\", '1', '1', LEFT, \"c\",\n \"b\", '0', '1', LEFT, \"a\",\n \"b\", '1', '1', RIGHT, \"b\",\n \"c\", '0', '1', LEFT, \"b\",\n \"c\", '1', '1', STAY, \"halt\"\n );\n run(t);\n return 0;\n printf(\"\\nFive-state two-symbol probable busy beaver\\n\");\n t = create(\n 6, \"A\", \"B\", \"C\", \"D\", \"E\", \"H\",\n 1, \"H\",\n 2, '0', '1',\n '0',\n \"A\",\n 0,\n 10,\n \"A\", '0', '1', RIGHT, \"B\",\n \"A\", '1', '1', LEFT, \"C\",\n \"B\", '0', '1', RIGHT, \"C\",\n \"B\", '1', '1', RIGHT, \"B\",\n \"C\", '0', '1', RIGHT, \"D\",\n \"C\", '1', '0', LEFT, \"E\",\n \"D\", '0', '1', LEFT, \"A\",\n \"D\", '1', '1', LEFT, \"D\",\n \"E\", '0', '1', STAY, \"H\",\n \"E\", '1', '0', LEFT, \"A\"\n );\n run(t);\n}\n","Rust":"use std::collections::VecDeque;\nuse std::fmt::{Display, Formatter, Result};\n\nfn main() {\n println!(\"Simple incrementer\");\n let rules_si = vec!(\n Rule::new(\"q0\", '1', '1', Direction::Right, \"q0\"),\n Rule::new(\"q0\", 'B', '1', Direction::Stay, \"qf\")\n );\n let states_si = vec!(\"q0\", \"qf\");\n let terminating_states_si = vec!(\"qf\");\n let permissible_symbols_si = vec!('B', '1');\n let mut tm_si = TM::new(states_si, \"q0\", terminating_states_si, permissible_symbols_si, 'B', rules_si, \"111\");\n while !tm_si.is_done() {\n println!(\"{}\", tm_si);\n tm_si.step();\n }\n\n println!(\"___________________\");\n println!(\"Three-state busy beaver\");\n let rules_bb3 = vec!(\n Rule::new(\"a\", '0', '1', Direction::Right, \"b\"), \n Rule::new(\"a\", '1', '1', Direction::Left, \"c\"),\n Rule::new(\"b\", '0', '1', Direction::Left, \"a\"),\n Rule::new(\"b\", '1', '1', Direction::Right, \"b\"),\n Rule::new(\"c\", '0', '1', Direction::Left, \"b\"),\n Rule::new(\"c\", '1', '1', Direction::Stay, \"halt\"),\n );\n let states_bb3 = vec!(\"a\", \"b\", \"c\", \"halt\");\n let terminating_states_bb3 = vec!(\"halt\");\n let permissible_symbols_bb3 = vec!('0', '1');\n let mut tm_bb3 = TM::new(states_bb3 ,\"a\", terminating_states_bb3, permissible_symbols_bb3, '0', rules_bb3, \"0\");\n while !tm_bb3.is_done() {\n println!(\"{}\", tm_bb3);\n tm_bb3.step();\n }\n println!(\"{}\", tm_bb3);\n\n println!(\"___________________\");\n println!(\"Five-state busy beaver\");\n let rules_bb5 = vec!(\n Rule::new(\"A\", '0', '1', Direction::Right, \"B\"), \n Rule::new(\"A\", '1', '1', Direction::Left, \"C\"),\n Rule::new(\"B\", '0', '1', Direction::Right, \"C\"),\n Rule::new(\"B\", '1', '1', Direction::Right, \"B\"),\n Rule::new(\"C\", '0', '1', Direction::Right, \"D\"),\n Rule::new(\"C\", '1', '0', Direction::Left, \"E\"),\n Rule::new(\"D\", '0', '1', Direction::Left, \"A\"),\n Rule::new(\"D\", '1', '1', Direction::Left, \"D\"),\n Rule::new(\"E\", '0', '1', Direction::Stay, \"H\"),\n Rule::new(\"E\", '1', '0', Direction::Left, \"A\"),\n );\n let states_bb5 = vec!(\"A\", \"B\", \"C\", \"D\", \"E\", \"H\");\n let terminating_states_bb5 = vec!(\"H\");\n let permissible_symbols_bb5 = vec!('0', '1');\n let mut tm_bb5 = TM::new(states_bb5 ,\"A\", terminating_states_bb5, permissible_symbols_bb5, '0', rules_bb5, \"0\");\n let mut steps = 0;\n while !tm_bb5.is_done() {\n tm_bb5.step();\n steps += 1;\n }\n println!(\"Steps: {}\", steps);\n println!(\"Band lenght: {}\", tm_bb5.band.len());\n}\n\nstruct TM<'a> {\n state: &'a str,\n terminating_states: Vec<&'a str>,\n rules: Vec<Rule<'a>>,\n band: VecDeque<char>,\n head: usize,\n blank: char,\n}\n\nstruct Rule<'a> {\n state: &'a str,\n read: char,\n write: char,\n dir: Direction,\n new_state: &'a str,\n}\n\nenum Direction{\n Left,\n Right,\n Stay,\n}\n\nimpl<'a> TM<'a> {\n\n fn new(_states: Vec<&'a str>, initial_state: &'a str, terminating_states: Vec<&'a str>, _permissible_symbols: Vec<char>, blank: char, rules: Vec<Rule<'a>>, input: &str) -> Self {\n Self { state: initial_state, terminating_states, rules, band: input.chars().collect::<VecDeque<_>>(), head: 0, blank }\n }\n\n fn is_done(&self) -> bool {\n self.terminating_states.contains(&self.state)\n }\n \n fn step(&mut self) {\n let field = self.band.get(self.head).unwrap();\n let rule = self.rules.iter().find(|rule| rule.state == self.state && &rule.read == field).unwrap();\n let field = self.band.get_mut(self.head).unwrap();\n *field = rule.write;\n self.state = rule.new_state;\n match rule.dir {\n Direction::Left => {\n if self.head == 0 {\n self.band.push_front(self.blank)\n } else {\n self.head -= 1;\n }\n },\n Direction::Right => {\n if self.head == self.band.len() - 1 {\n self.band.push_back(self.blank)\n }\n self.head += 1;\n },\n Direction::Stay => {},\n }\n }\n}\n\nimpl<'a> Display for TM<'a> {\n fn fmt(&self, f: &mut Formatter<'_>) -> Result {\n let band = self.band.iter().enumerate().map(|(i, c)| { \n if i == self.head {\n format!(\"[{}]\", c)\n } else {\n format!(\" {} \", c)\n }\n }).fold(String::new(), |acc, val| acc + &val);\n write!(f, \"{}\\t{}\", self.state, band)\n }\n}\n\n\nimpl<'a> Rule<'a> {\n fn new(state: &'a str, read: char, write: char, dir: Direction, new_state: &'a str) -> Self {\n Self { state, read, write, dir, new_state }\n }\n}\n"} {"name":"Unix_ls","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <limits.h>\n#include <sys\/types.h>\n#include <dirent.h>\n#include <unistd.h>\n\nint cmpstr(const void *a, const void *b)\n{\n return strcmp(*(const char**)a, *(const char**)b);\n}\n\nint main(void)\n{\n DIR *basedir;\n char path[PATH_MAX];\n struct dirent *entry;\n char **dirnames;\n int diralloc = 128;\n int dirsize = 0;\n \n if (!(dirnames = malloc(diralloc * sizeof(char*)))) {\n perror(\"malloc error:\");\n return 1;\n }\n\n if (!getcwd(path, PATH_MAX)) {\n perror(\"getcwd error:\");\n return 1;\n }\n\n if (!(basedir = opendir(path))) {\n perror(\"opendir error:\");\n return 1;\n }\n\n while ((entry = readdir(basedir))) {\n if (dirsize >= diralloc) {\n diralloc *= 2;\n if (!(dirnames = realloc(dirnames, diralloc * sizeof(char*)))) {\n perror(\"realloc error:\");\n return 1;\n }\n }\n dirnames[dirsize++] = strdup(entry->d_name);\n }\n\n qsort(dirnames, dirsize, sizeof(char*), cmpstr);\n\n int i;\n for (i = 0; i < dirsize; ++i) {\n if (dirnames[i][0] != '.') {\n printf(\"%s\\n\", dirnames[i]);\n }\n }\n\n for (i = 0; i < dirsize; ++i)\n free(dirnames[i]);\n free(dirnames);\n closedir(basedir);\n return 0;\n}\n","Rust":"use std::{env, fmt, fs, process};\nuse std::io::{self, Write};\nuse std::path::Path;\n\nfn main() {\n let cur = env::current_dir().unwrap_or_else(|e| exit_err(e, 1));\n let arg = env::args().nth(1);\n print_files(arg.as_ref().map_or(cur.as_path(), |p| Path::new(p)))\n .unwrap_or_else(|e| exit_err(e, 2));\n}\n\n#[inline]\nfn print_files(path: &Path) -> io::Result<()> {\n for x in try!(fs::read_dir(path)) {\n println!(\"{}\", try!(x).file_name().to_string_lossy());\n }\n Ok(())\n}\n\n#[inline]\nfn exit_err<T>(msg: T, code: i32) -> ! where T: fmt::Display {\n writeln!(&mut io::stderr(), \"{}\", msg).expect(\"Could not write to stderr\");\n process::exit(code)\n}\n"} {"name":"User input_Text","C":"#include <stdio.h>\n#include <stdlib.h>\n\nint main(void)\n{\n \n char str[BUFSIZ];\n puts(\"Enter a string: \");\n fgets(str, sizeof(str), stdin);\n\n \n long num;\n char buf[BUFSIZ];\n do\n {\n puts(\"Enter 75000: \");\n fgets(buf, sizeof(buf), stdin);\n num = strtol(buf, NULL, 10);\n } while (num != 75000);\n\n return EXIT_SUCCESS;\n}\n","Rust":"use std::io::{self, Write};\nuse std::fmt::Display;\nuse std::process;\n\nfn main() {\n let s = grab_input(\"Give me a string\")\n .unwrap_or_else(|e| exit_err(&e, e.raw_os_error().unwrap_or(-1)));\n\n println!(\"You entered: {}\", s.trim());\n\n let n: i32 = grab_input(\"Give me an integer\")\n .unwrap_or_else(|e| exit_err(&e, e.raw_os_error().unwrap_or(-1)))\n .trim()\n .parse()\n .unwrap_or_else(|e| exit_err(&e, 2));\n\n println!(\"You entered: {}\", n);\n}\n\nfn grab_input(msg: &str) -> io::Result<String> {\n let mut buf = String::new();\n print!(\"{}: \", msg);\n try!(io::stdout().flush());\n\n try!(io::stdin().read_line(&mut buf));\n Ok(buf)\n}\n\nfn exit_err<T: Display>(msg: T, code: i32) -> ! {\n let _ = writeln!(&mut io::stderr(), \"Error: {}\", msg);\n process::exit(code)\n}\n"} {"name":"Van Eck sequence","C":"#include <stdlib.h>\n#include <stdio.h>\n\nint main(int argc, const char *argv[]) {\n const int max = 1000;\n int *a = malloc(max * sizeof(int));\n for (int n = 0; n < max - 1; n ++) {\n for (int m = n - 1; m >= 0; m --) {\n if (a[m] == a[n]) {\n a[n+1] = n - m;\n break;\n }\n }\n }\n\n printf(\"The first ten terms of the Van Eck sequence are:\\n\");\n for (int i = 0; i < 10; i ++) printf(\"%d \", a[i]);\n printf(\"\\n\\nTerms 991 to 1000 of the sequence are:\\n\");\n for (int i = 990; i < 1000; i ++) printf(\"%d \", a[i]);\n putchar('\\n');\n\n return 0;\n}\n","Rust":"fn van_eck_sequence() -> impl std::iter::Iterator<Item = i32> {\n let mut index = 0;\n let mut last_term = 0;\n let mut last_pos = std::collections::HashMap::new();\n std::iter::from_fn(move || {\n let result = last_term;\n let mut next_term = 0;\n if let Some(v) = last_pos.get_mut(&last_term) {\n next_term = index - *v;\n *v = index;\n } else {\n last_pos.insert(last_term, index);\n }\n last_term = next_term;\n index += 1;\n Some(result)\n })\n}\n\nfn main() {\n let mut v = van_eck_sequence().take(1000);\n println!(\"First 10 terms of the Van Eck sequence:\");\n for n in v.by_ref().take(10) {\n print!(\"{} \", n);\n }\n println!(\"\\nTerms 991 to 1000 of the Van Eck sequence:\");\n for n in v.skip(980) {\n print!(\"{} \", n);\n }\n println!();\n}\n"} {"name":"Van der Corput sequence","C":"#include <stdio.h>\n\nvoid vc(int n, int base, int *num, int *denom)\n{\n int p = 0, q = 1;\n\n while (n) {\n p = p * base + (n % base);\n q *= base;\n n \/= base;\n }\n\n *num = p; \n *denom = q;\n\n while (p) { n = p; p = q % p; q = n; }\n *num \/= q;\n *denom \/= q;\n}\n\nint main()\n{\n int d, n, i, b;\n for (b = 2; b < 6; b++) {\n printf(\"base %d:\", b);\n for (i = 0; i < 10; i++) {\n vc(i, b, &n, &d);\n if (n) printf(\" %d\/%d\", n, d);\n else printf(\" 0\");\n }\n printf(\"\\n\");\n }\n\n return 0;\n}\n","Rust":"\npub fn corput(nth: usize, base: usize) -> f64 {\n let mut n = nth;\n let mut q: f64 = 0.0;\n let mut bk: f64 = 1.0 \/ (base as f64);\n\n while n > 0_usize {\n q += ((n % base) as f64)*bk;\n n \/= base;\n bk \/= base as f64;\n }\n q\n}\n\nfn main() {\n for base in 2_usize..=5_usize {\n print!(\"Base {}:\", base);\n for i in 1_usize..=10_usize {\n let c = corput(i, base);\n print!(\" {:.6}\", c)\n }\n println!(\"\");\n }\n}\n"} {"name":"Variables","C":"int j;\n","Rust":"let var01; \nlet var02: u32; \nlet var03 = 5; \nlet var04 = 5u8; \nlet var05: i8 = 5; \nlet var06: u8 = 5u8; \nvar01 = var05; \nvar02 = 9u32; \n"} {"name":"Variadic function","C":"#include <stdio.h>\n#include <stdarg.h>\n\nvoid varstrings(int count, ...) \n{\n va_list args;\n va_start(args, count);\n while (count--)\n puts(va_arg(args, const char *));\n va_end(args);\n}\n\nvarstrings(5, \"Mary\", \"had\", \"a\", \"little\", \"lamb\");\n","Rust":"\n\nmacro_rules! print_all {\n ($($args:expr),*) => { $( println!(\"{}\", $args); )* } \n}\n\nfn main() {\n print_all!(\"Rosetta\", \"Code\", \"Is\", \"Awesome!\");\n}\n"} {"name":"Vector products","C":"#include<stdio.h>\n\ntypedef struct{\n\tfloat i,j,k;\n\t}Vector;\n\nVector a = {3, 4, 5},b = {4, 3, 5},c = {-5, -12, -13};\n\nfloat dotProduct(Vector a, Vector b)\n{\n\treturn a.i*b.i+a.j*b.j+a.k*b.k;\n}\n\nVector crossProduct(Vector a,Vector b)\n{\n\tVector c = {a.j*b.k - a.k*b.j, a.k*b.i - a.i*b.k, a.i*b.j - a.j*b.i};\n\t\n\treturn c;\n}\n\nfloat scalarTripleProduct(Vector a,Vector b,Vector c)\n{\n\treturn dotProduct(a,crossProduct(b,c));\n}\n\nVector vectorTripleProduct(Vector a,Vector b,Vector c)\n{\n\treturn crossProduct(a,crossProduct(b,c));\n}\n\nvoid printVector(Vector a)\n{\n\tprintf(\"( %f, %f, %f)\",a.i,a.j,a.k);\n}\n\nint main()\n{\n\tprintf(\"\\n a = \"); printVector(a);\n\tprintf(\"\\n b = \"); printVector(b);\n\tprintf(\"\\n c = \"); printVector(c);\n\tprintf(\"\\n a . b = %f\",dotProduct(a,b));\n\tprintf(\"\\n a x b = \"); printVector(crossProduct(a,b));\n\tprintf(\"\\n a . (b x c) = %f\",scalarTripleProduct(a,b,c));\n\tprintf(\"\\n a x (b x c) = \"); printVector(vectorTripleProduct(a,b,c));\n\t\n\treturn 0;\n}\n","Rust":"#[derive(Debug)]\nstruct Vector {\n x: f64,\n y: f64,\n z: f64,\n}\n\nimpl Vector {\n fn new(x: f64, y: f64, z: f64) -> Self {\n Vector {\n x: x,\n y: y,\n z: z,\n }\n }\n\n fn dot_product(&self, other: &Vector) -> f64 {\n (self.x * other.x) + (self.y * other.y) + (self.z * other.z)\n }\n\n fn cross_product(&self, other: &Vector) -> Vector {\n Vector::new(self.y * other.z - self.z * other.y,\n self.z * other.x - self.x * other.z,\n self.x * other.y - self.y * other.x)\n }\n\n fn scalar_triple_product(&self, b: &Vector, c: &Vector) -> f64 {\n self.dot_product(&b.cross_product(&c))\n }\n\n fn vector_triple_product(&self, b: &Vector, c: &Vector) -> Vector {\n self.cross_product(&b.cross_product(&c))\n }\n}\n\nfn main(){\n let a = Vector::new(3.0, 4.0, 5.0);\n let b = Vector::new(4.0, 3.0, 5.0);\n let c = Vector::new(-5.0, -12.0, -13.0);\n\n println!(\"a . b = {}\", a.dot_product(&b));\n println!(\"a x b = {:?}\", a.cross_product(&b));\n println!(\"a . (b x c) = {}\", a.scalar_triple_product(&b, &c));\n println!(\"a x (b x c) = {:?}\", a.vector_triple_product(&b, &c));\n}\n"} {"name":"Vigen\u00e8re cipher","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <stdbool.h>\n#include <ctype.h>\n#include <getopt.h>\n\n#define NUMLETTERS 26\n#define BUFSIZE 4096\n\nchar *get_input(void);\n\nint main(int argc, char *argv[])\n{\n char const usage[] = \"Usage: vinigere [-d] key\";\n char sign = 1; \n char const plainmsg[] = \"Plain text: \";\n char const cryptmsg[] = \"Cipher text: \";\n bool encrypt = true;\n int opt;\n\n while ((opt = getopt(argc, argv, \"d\")) != -1) {\n switch (opt) {\n case 'd': \n sign = -1;\n encrypt = false;\n break;\n default: \n fprintf(stderr, \"Unrecogized command line argument:'-%i'\\n\", opt);\n fprintf(stderr, \"\\n%s\\n\", usage);\n return 1;\n }\n }\n\n if (argc - optind != 1) {\n fprintf(stderr, \"%s requires one argument and one only\\n\", argv[0]);\n fprintf(stderr, \"\\n%s\\n\", usage);\n return 1;\n }\n\n\n \n char const *const restrict key = argv[optind];\n size_t const keylen = strlen(key);\n char shifts[keylen];\n\n char const *restrict plaintext = NULL; \n for (size_t i = 0; i < keylen; i++) {\n if (!(isalpha(key[i]))) {\n fprintf(stderr, \"Invalid key\\n\");\n return 2;\n }\n char const charcase = (isupper(key[i])) ? 'A' : 'a';\n \n \n shifts[i] = (key[i] - charcase) * sign;\n }\n\n do {\n fflush(stdout);\n \n \n printf(\"%s\", (encrypt) ? plainmsg : cryptmsg);\n plaintext = get_input();\n if (plaintext == NULL) {\n fprintf(stderr, \"Error getting input\\n\");\n return 4;\n }\n } while (strcmp(plaintext, \"\") == 0); \n\n size_t const plainlen = strlen(plaintext);\n\n char* const restrict ciphertext = calloc(plainlen + 1, sizeof *ciphertext);\n if (ciphertext == NULL) {\n fprintf(stderr, \"Memory error\\n\");\n return 5;\n }\n\n for (size_t i = 0, j = 0; i < plainlen; i++) {\n \n if (!(isalpha(plaintext[i]))) {\n ciphertext[i] = plaintext[i];\n continue;\n }\n \n char const charcase = (isupper(plaintext[i])) ? 'A' : 'a';\n \n ciphertext[i] = ((plaintext[i] + shifts[j] - charcase + NUMLETTERS) % NUMLETTERS) + charcase;\n j = (j+1) % keylen;\n }\n ciphertext[plainlen] = '\\0';\n printf(\"%s%s\\n\", (encrypt) ? cryptmsg : plainmsg, ciphertext);\n\n free(ciphertext);\n \n free((char*) plaintext);\n return 0;\n}\nchar *get_input(void) {\n\n char *const restrict buf = malloc(BUFSIZE * sizeof (char));\n if (buf == NULL) {\n return NULL;\n }\n\n fgets(buf, BUFSIZE, stdin);\n\n \n size_t const len = strlen(buf);\n if (buf[len - 1] == '\\n') buf[len - 1] = '\\0';\n\n return buf;\n}\n","Rust":"use std::ascii::AsciiExt;\n\nstatic A: u8 = 'A' as u8;\n\nfn uppercase_and_filter(input: &str) -> Vec<u8> {\n let alphabet = b\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n let mut result = Vec::new();\n\n for c in input.chars() {\n \n if alphabet.iter().any(|&x| x as char == c) {\n result.push(c.to_ascii_uppercase() as u8);\n }\n }\n\n return result;\n}\n\nfn vigenere(key: &str, text: &str, is_encoding: bool) -> String {\n\n let key_bytes = uppercase_and_filter(key);\n let text_bytes = uppercase_and_filter(text);\n\n let mut result_bytes = Vec::new();\n\n for (i, c) in text_bytes.iter().enumerate() {\n let c2 = if is_encoding {\n (c + key_bytes[i % key_bytes.len()] - 2 * A) % 26 + A\n } else {\n (c + 26 - key_bytes[i % key_bytes.len()]) % 26 + A\n };\n result_bytes.push(c2);\n }\n\n String::from_utf8(result_bytes).unwrap()\n}\n\nfn main() {\n let text = \"Beware the Jabberwock, my son! The jaws that bite, the claws that catch!\";\n let key = \"VIGENERECIPHER\";\n\n println!(\"Text: {}\", text);\n println!(\"Key: {}\", key);\n\n let encoded = vigenere(key, text, true);\n println!(\"Code: {}\", encoded);\n let decoded = vigenere(key, &encoded, false);\n println!(\"Back: {}\", decoded);\n}\n"} {"name":"Visualize a tree","C":"#include <stdio.h>\n#include <stdlib.h>\n\ntypedef struct stem_t *stem;\nstruct stem_t { const char *str; stem next; };\n\nvoid tree(int root, stem head)\n{\n\tstatic const char *sdown = \" |\", *slast = \" `\", *snone = \" \";\n\tstruct stem_t col = {0, 0}, *tail;\n\n\tfor (tail = head; tail; tail = tail->next) {\n\t\tprintf(\"%s\", tail->str);\n\t\tif (!tail->next) break;\n\t}\n\n\tprintf(\"--%d\\n\", root);\n\n\tif (root <= 1) return;\n\n\tif (tail && tail->str == slast)\n\t\ttail->str = snone;\n\n\tif (!tail)\ttail = head = &col;\n\telse\t\ttail->next = &col;\n\n\twhile (root) { \n\t\tint r = 1 + (rand() % root);\n\t\troot -= r;\n\t\tcol.str = root ? sdown : slast;\n\n\t\ttree(r, head);\n\t}\n\n\ttail->next = 0;\n}\n\nint main(int c, char**v)\n{\n\tint n;\n\tif (c < 2 || (n = atoi(v[1])) < 0) n = 8;\n\n\ttree(n, 0);\n\treturn 0;\n}\n","Rust":"extern crate rustc_serialize;\nextern crate term_painter;\n\nuse rustc_serialize::json;\nuse std::fmt::{Debug, Display, Formatter, Result};\nuse term_painter::ToStyle;\nuse term_painter::Color::*;\n\ntype NodePtr = Option<usize>;\n\n#[derive(Debug, PartialEq, Clone, Copy)]\nenum Side {\n Left,\n Right,\n Up,\n}\n\n#[derive(Debug, PartialEq, Clone, Copy)]\nenum DisplayElement {\n TrunkSpace,\n SpaceLeft,\n SpaceRight,\n SpaceSpace,\n Root,\n}\n\nimpl DisplayElement {\n fn string(&self) -> String {\n match *self {\n DisplayElement::TrunkSpace => \" \u2502 \".to_string(),\n DisplayElement::SpaceRight => \" \u250c\u2500\u2500\u2500\".to_string(),\n DisplayElement::SpaceLeft => \" \u2514\u2500\u2500\u2500\".to_string(),\n DisplayElement::SpaceSpace => \" \".to_string(),\n DisplayElement::Root => \"\u251c\u2500\u2500\".to_string(),\n }\n }\n}\n\n#[derive(Debug, Clone, Copy, RustcDecodable, RustcEncodable)]\nstruct Node<K, V> {\n key: K,\n value: V,\n left: NodePtr,\n right: NodePtr,\n up: NodePtr,\n}\n\nimpl<K: Ord + Copy, V: Copy> Node<K, V> {\n pub fn get_ptr(&self, side: Side) -> NodePtr {\n match side {\n Side::Up => self.up,\n Side::Left => self.left,\n _ => self.right,\n }\n }\n}\n\n#[derive(Debug, RustcDecodable, RustcEncodable)]\nstruct Tree<K, V> {\n root: NodePtr,\n store: Vec<Node<K, V>>,\n}\n\nimpl<K: Ord + Copy + Debug + Display, V: Debug + Copy + Display> Tree<K, V> {\n pub fn get_node(&self, np: NodePtr) -> Node<K, V> {\n assert!(np.is_some());\n self.store[np.unwrap()]\n }\n\n pub fn get_pointer(&self, np: NodePtr, side: Side) -> NodePtr {\n assert!(np.is_some());\n self.store[np.unwrap()].get_ptr(side)\n }\n\n \n \n \n \n \n \n fn display(&self, p: NodePtr, side: Side, e: &Vec<DisplayElement>, f: &mut Formatter) {\n if p.is_none() {\n return;\n }\n\n let mut elems = e.clone();\n let node = self.get_node(p);\n let mut tail = DisplayElement::SpaceSpace;\n if node.up != self.root {\n \n \n if side == Side::Left && node.right.is_some() {\n elems.push(DisplayElement::TrunkSpace);\n } else {\n elems.push(DisplayElement::SpaceSpace);\n }\n }\n let hindex = elems.len() - 1;\n self.display(node.right, Side::Right, &elems, f);\n\n if p == self.root {\n elems[hindex] = DisplayElement::Root;\n tail = DisplayElement::TrunkSpace;\n } else if side == Side::Right {\n \n elems[hindex] = DisplayElement::SpaceRight;\n \n tail = DisplayElement::TrunkSpace;\n } else if side == Side::Left {\n elems[hindex] = DisplayElement::SpaceLeft;\n let parent = self.get_node(node.up);\n if parent.up.is_some() && self.get_pointer(parent.up, Side::Right) == node.up {\n \n elems[hindex - 1] = DisplayElement::TrunkSpace;\n }\n }\n\n \n \n for e in elems.clone() {\n let _ = write!(f, \"{}\", e.string());\n }\n let _ = write!(f,\n \"{key:>width$} \",\n key = Green.bold().paint(node.key),\n width = 2);\n let _ = write!(f,\n \"{value:>width$}\\n\",\n value = Blue.bold().paint(format!(\"{:.*}\", 2, node.value)),\n width = 4);\n\n \n elems[hindex] = tail;\n\n self.display(node.left, Side::Left, &elems, f);\n }\n}\n\nimpl<K: Ord + Copy + Debug + Display, V: Debug + Copy + Display> Display for Tree<K, V> {\n fn fmt(&self, f: &mut Formatter) -> Result {\n if self.root.is_none() {\n write!(f, \"[empty]\")\n } else {\n let mut v: Vec<DisplayElement> = Vec::new();\n self.display(self.root, Side::Up, &mut v, f);\n Ok(())\n }\n }\n}\n\n\nfn main() {\n let encoded = r#\"{\"root\":0,\"store\":[{\"key\":0,\"value\":0.45,\"left\":1,\"right\":3,\n \"up\":null},{\"key\":-8,\"value\":-0.94,\"left\":7,\"right\":2,\"up\":0}, {\"key\":-1,\n \"value\":0.15,\"left\":8,\"right\":null,\"up\":1},{\"key\":7, \"value\":-0.29,\"left\":4,\n \"right\":9,\"up\":0},{\"key\":5,\"value\":0.80,\"left\":5,\"right\":null,\"up\":3},\n {\"key\":4,\"value\":-0.85,\"left\":6,\"right\":null,\"up\":4},{\"key\":3,\"value\":-0.46,\n \"left\":null,\"right\":null,\"up\":5},{\"key\":-10,\"value\":-0.85,\"left\":null,\n \"right\":13,\"up\":1},{\"key\":-6,\"value\":-0.42,\"left\":null,\"right\":10,\"up\":2},\n {\"key\":9,\"value\":0.63,\"left\":12,\"right\":null,\"up\":3},{\"key\":-3,\"value\":-0.83,\n \"left\":null,\"right\":11,\"up\":8},{\"key\":-2,\"value\":0.75,\"left\":null,\"right\":null,\n \"up\":10},{\"key\":8,\"value\":-0.48,\"left\":null,\"right\":null,\"up\":9},{\"key\":-9,\n \"value\":0.53,\"left\":null,\"right\":null,\"up\":7}]}\"#;\n let tree: Tree<i32, f32> = json::decode(&encoded).unwrap();\n println!(\"{}\", tree);\n}\n"} {"name":"Walk a directory_Non-recursively","C":"#include <sys\/types.h>\n#include <dirent.h>\n#include <regex.h>\n#include <stdio.h>\n\nenum {\n WALK_OK = 0,\n WALK_BADPATTERN,\n WALK_BADOPEN,\n};\n\nint walker(const char *dir, const char *pattern)\n{\n struct dirent *entry;\n regex_t reg;\n DIR *d; \n\n if (regcomp(®, pattern, REG_EXTENDED | REG_NOSUB))\n return WALK_BADPATTERN;\n if (!(d = opendir(dir)))\n return WALK_BADOPEN;\n while (entry = readdir(d))\n if (!regexec(®, entry->d_name, 0, NULL, 0))\n puts(entry->d_name);\n closedir(d);\n regfree(®);\n return WALK_OK;\n}\n\nint main()\n{\n walker(\".\", \".\\\\.c$\");\n return 0;\n}\n","Rust":"extern crate docopt;\nextern crate regex;\nextern crate rustc_serialize;\n\nuse docopt::Docopt;\nuse regex::Regex;\n\nconst USAGE: &'static str = \"\nUsage: rosetta <pattern>\n\nWalks the directory tree starting with the current working directory and\nprint filenames matching <pattern>.\n\";\n\n#[derive(Debug, RustcDecodable)]\nstruct Args {\n arg_pattern: String,\n}\n\nfn main() {\n let args: Args = Docopt::new(USAGE)\n .and_then(|d| d.decode())\n .unwrap_or_else(|e| e.exit());\n\n let re = Regex::new(&args.arg_pattern).unwrap();\n let paths = std::fs::read_dir(\".\").unwrap();\n\n for path in paths {\n let path = path.unwrap().path();\n let path = path.to_str().unwrap();\n\n if re.is_match(path) {\n println!(\"{}\", path);\n }\n }\n}\n"} {"name":"Walk a directory_Recursively","C":"#include <sys\/types.h>\n#include <sys\/stat.h>\n#include <unistd.h>\n#include <dirent.h>\n#include <regex.h>\n#include <stdio.h>\n#include <string.h>\n#include <errno.h>\n#include <err.h>\n\nenum {\n\tWALK_OK = 0,\n\tWALK_BADPATTERN,\n\tWALK_NAMETOOLONG,\n\tWALK_BADIO,\n};\n\n#define WS_NONE\t\t0\n#define WS_RECURSIVE\t(1 << 0)\n#define WS_DEFAULT\tWS_RECURSIVE\n#define WS_FOLLOWLINK\t(1 << 1)\t\n#define WS_DOTFILES\t(1 << 2)\t\n#define WS_MATCHDIRS\t(1 << 3)\t\n\nint walk_recur(char *dname, regex_t *reg, int spec)\n{\n\tstruct dirent *dent;\n\tDIR *dir;\n\tstruct stat st;\n\tchar fn[FILENAME_MAX];\n\tint res = WALK_OK;\n\tint len = strlen(dname);\n\tif (len >= FILENAME_MAX - 1)\n\t\treturn WALK_NAMETOOLONG;\n\n\tstrcpy(fn, dname);\n\tfn[len++] = '\/';\n\n\tif (!(dir = opendir(dname))) {\n\t\twarn(\"can't open %s\", dname);\n\t\treturn WALK_BADIO;\n\t}\n\n\terrno = 0;\n\twhile ((dent = readdir(dir))) {\n\t\tif (!(spec & WS_DOTFILES) && dent->d_name[0] == '.')\n\t\t\tcontinue;\n\t\tif (!strcmp(dent->d_name, \".\") || !strcmp(dent->d_name, \"..\"))\n\t\t\tcontinue;\n\n\t\tstrncpy(fn + len, dent->d_name, FILENAME_MAX - len);\n\t\tif (lstat(fn, &st) == -1) {\n\t\t\twarn(\"Can't stat %s\", fn);\n\t\t\tres = WALK_BADIO;\n\t\t\tcontinue;\n\t\t}\n\n\t\t\n\t\tif (S_ISLNK(st.st_mode) && !(spec & WS_FOLLOWLINK))\n\t\t\tcontinue;\n\n\t\t\n\t\tif (S_ISDIR(st.st_mode)) {\n\t\t\t\n\t\t\tif ((spec & WS_RECURSIVE))\n\t\t\t\twalk_recur(fn, reg, spec);\n\n\t\t\tif (!(spec & WS_MATCHDIRS)) continue;\n\t\t}\n\n\t\t\n\t\tif (!regexec(reg, fn, 0, 0, 0)) puts(fn);\n\t}\n\n\tif (dir) closedir(dir);\n\treturn res ? res : errno ? WALK_BADIO : WALK_OK;\n}\n\nint walk_dir(char *dname, char *pattern, int spec)\n{\n\tregex_t r;\n\tint res;\n\tif (regcomp(&r, pattern, REG_EXTENDED | REG_NOSUB))\n\t\treturn WALK_BADPATTERN;\n\tres = walk_recur(dname, &r, spec);\n\tregfree(&r);\n\n\treturn res;\n}\n\nint main()\n{\n\tint r = walk_dir(\".\", \".\\\\.c$\", WS_DEFAULT|WS_MATCHDIRS);\n\tswitch(r) {\n\tcase WALK_OK:\t\tbreak;\n\tcase WALK_BADIO:\terr(1, \"IO error\");\n\tcase WALK_BADPATTERN:\terr(1, \"Bad pattern\");\n\tcase WALK_NAMETOOLONG:\terr(1, \"Filename too long\");\n\tdefault:\n\t\terr(1, \"Unknown error?\");\n\t}\n\treturn 0;\n}\n","Rust":"#![feature(fs_walk)]\n\nuse std::fs;\nuse std::path::Path;\n\nfn main() {\n for f in fs::walk_dir(&Path::new(\"\/home\/pavel\/Music\")).unwrap() {\n let p = f.unwrap().path();\n if p.extension().unwrap_or(\"\".as_ref()) == \"mp3\" {\n println!(\"{:?}\", p);\n }\n }\n}\n"} {"name":"Web scraping","C":"#include <stdio.h>\n#include <string.h>\n#include <curl\/curl.h>\n#include <sys\/types.h>\n#include <regex.h>\n\n#define BUFSIZE 16384\n\nsize_t lr = 0;\n\nsize_t filterit(void *ptr, size_t size, size_t nmemb, void *stream)\n{\n if ( (lr + size*nmemb) > BUFSIZE ) return BUFSIZE;\n memcpy(stream+lr, ptr, size*nmemb);\n lr += size*nmemb;\n return size*nmemb;\n}\n\nint main()\n{\n CURL *curlHandle;\n char buffer[BUFSIZE];\n regmatch_t amatch;\n regex_t cregex;\n\n curlHandle = curl_easy_init();\n curl_easy_setopt(curlHandle, CURLOPT_URL, \"http:\n curl_easy_setopt(curlHandle, CURLOPT_FOLLOWLOCATION, 1);\n curl_easy_setopt(curlHandle, CURLOPT_WRITEFUNCTION, filterit);\n curl_easy_setopt(curlHandle, CURLOPT_WRITEDATA, buffer);\n int success = curl_easy_perform(curlHandle);\n curl_easy_cleanup(curlHandle);\n\n buffer[lr] = 0;\n \n regcomp(&cregex, \" UTC\", REG_NEWLINE);\n regexec(&cregex, buffer, 1, &amatch, 0);\n int bi = amatch.rm_so;\n while ( bi-- > 0 )\n if ( memcmp(&buffer[bi], \"<BR>\", 4) == 0 ) break;\n\n buffer[amatch.rm_eo] = 0;\n\n printf(\"%s\\n\", &buffer[bi+4]);\n\n regfree(&cregex);\n return 0;\n}\n","Rust":"\n\nuse std::io::Read;\nuse regex::Regex;\n\nfn main() {\n\n let client = reqwest::blocking::Client::new();\n let site = \"https:\n let mut res = client.get(site).send().unwrap();\n let mut body = String::new();\n\n res.read_to_string(&mut body).unwrap();\n\n let re = Regex::new(r#\"<td>UTC<\/td><td>(.*Z)<\/td>\"#).unwrap();\n let caps = re.captures(&body).unwrap();\n\n println!(\"Result\u00a0: {:?}\", caps.get(1).unwrap().as_str());\n}\n"} {"name":"Wieferich primes","C":"#include <stdbool.h>\n#include <stdio.h>\n#include <stdint.h>\n\n#define LIMIT 5000\nstatic bool PRIMES[LIMIT];\n\nstatic void prime_sieve() {\n uint64_t p;\n int i;\n\n PRIMES[0] = false;\n PRIMES[1] = false;\n for (i = 2; i < LIMIT; i++) {\n PRIMES[i] = true;\n }\n\n for (i = 4; i < LIMIT; i += 2) {\n PRIMES[i] = false;\n }\n\n for (p = 3;; p += 2) {\n uint64_t q = p * p;\n if (q >= LIMIT) {\n break;\n }\n if (PRIMES[p]) {\n uint64_t inc = 2 * p;\n for (; q < LIMIT; q += inc) {\n PRIMES[q] = false;\n }\n }\n }\n}\n\nuint64_t modpow(uint64_t base, uint64_t exp, uint64_t mod) {\n uint64_t result = 1;\n\n if (mod == 1) {\n return 0;\n }\n\n base %= mod;\n for (; exp > 0; exp >>= 1) {\n if ((exp & 1) == 1) {\n result = (result * base) % mod;\n }\n base = (base * base) % mod;\n }\n return result;\n}\n\nvoid wieferich_primes() {\n uint64_t p;\n\n for (p = 2; p < LIMIT; ++p) {\n if (PRIMES[p] && modpow(2, p - 1, p * p) == 1) {\n printf(\"%lld\\n\", p);\n }\n }\n}\n\nint main() {\n prime_sieve();\n\n printf(\"Wieferich primes less than %d:\\n\", LIMIT);\n wieferich_primes();\n\n return 0;\n}\n","Rust":"\n\n\n\nfn wieferich_primes(limit: usize) -> impl std::iter::Iterator<Item = usize> {\n primal::Primes::all()\n .take_while(move |x| *x < limit)\n .filter(|x| mod_exp::mod_exp(2, *x - 1, *x * *x) == 1)\n}\n\nfn main() {\n let limit = 5000;\n println!(\"Wieferich primes less than {}:\", limit);\n for p in wieferich_primes(limit) {\n println!(\"{}\", p);\n }\n}\n"} {"name":"Window creation","C":"\n\n#include <stdio.h>\n#include <stdlib.h>\n#include \"SDL.h\"\n\nint main()\n{\n SDL_Surface *screen;\n \n if (SDL_Init(SDL_INIT_VIDEO) != 0) {\n fprintf(stderr, \"Unable to initialize SDL: %s\\n\", SDL_GetError());\n return 1;\n }\n atexit(SDL_Quit);\n screen = SDL_SetVideoMode( 800, 600, 16, SDL_SWSURFACE | SDL_HWPALETTE );\n \n return 0;\n}\n","Rust":"use winit::event::{Event, WindowEvent}; \nuse winit::event_loop::{ControlFlow, EventLoop};\nuse winit::window::WindowBuilder;\n\nfn main() {\n let event_loop = EventLoop::new();\n let _win = WindowBuilder::new()\n .with_title(\"Window\")\n .build(&event_loop).unwrap();\n\n event_loop.run(move |ev, _, flow| {\n match ev {\n Event::WindowEvent {\n event: WindowEvent::CloseRequested, ..\n } => {\n *flow = ControlFlow::Exit;\n }\n _ => {}\n }\n });\n}\n"} {"name":"Word frequency","C":"#include <stdbool.h>\n#include <stdio.h>\n#include <glib.h>\n\ntypedef struct word_count_tag {\n const char* word;\n size_t count;\n} word_count;\n\nint compare_word_count(const void* p1, const void* p2) {\n const word_count* w1 = p1;\n const word_count* w2 = p2;\n if (w1->count > w2->count)\n return -1;\n if (w1->count < w2->count)\n return 1;\n return 0;\n}\n\nbool get_top_words(const char* filename, size_t count) {\n GError* error = NULL;\n GMappedFile* mapped_file = g_mapped_file_new(filename, FALSE, &error);\n if (mapped_file == NULL) {\n fprintf(stderr, \"%s\\n\", error->message);\n g_error_free(error);\n return false;\n }\n const char* text = g_mapped_file_get_contents(mapped_file);\n if (text == NULL) {\n fprintf(stderr, \"File %s is empty\\n\", filename);\n g_mapped_file_unref(mapped_file);\n return false;\n }\n gsize file_size = g_mapped_file_get_length(mapped_file);\n \n GHashTable* ht = g_hash_table_new_full(g_str_hash, g_str_equal,\n g_free, g_free);\n GRegex* regex = g_regex_new(\"\\\\w+\", 0, 0, NULL);\n GMatchInfo* match_info;\n g_regex_match_full(regex, text, file_size, 0, 0, &match_info, NULL);\n while (g_match_info_matches(match_info)) {\n char* word = g_match_info_fetch(match_info, 0);\n char* lower = g_utf8_strdown(word, -1);\n g_free(word);\n size_t* count = g_hash_table_lookup(ht, lower);\n if (count != NULL) {\n ++*count;\n g_free(lower);\n } else {\n count = g_new(size_t, 1);\n *count = 1;\n g_hash_table_insert(ht, lower, count);\n }\n g_match_info_next(match_info, NULL);\n }\n g_match_info_free(match_info);\n g_regex_unref(regex);\n g_mapped_file_unref(mapped_file);\n\n \n size_t size = g_hash_table_size(ht);\n word_count* words = g_new(word_count, size);\n GHashTableIter iter;\n gpointer key, value;\n g_hash_table_iter_init(&iter, ht);\n for (size_t i = 0; g_hash_table_iter_next(&iter, &key, &value); ++i) {\n words[i].word = key;\n words[i].count = *(size_t*)value;\n }\n qsort(words, size, sizeof(word_count), compare_word_count);\n\n \n if (count > size)\n count = size;\n printf(\"Top %lu words\\n\", count);\n printf(\"Rank\\tCount\\tWord\\n\");\n for (size_t i = 0; i < count; ++i)\n printf(\"%lu\\t%lu\\t%s\\n\", i + 1, words[i].count, words[i].word);\n g_free(words);\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 file\\n\", argv[0]);\n return EXIT_FAILURE;\n }\n if (!get_top_words(argv[1], 10))\n return EXIT_FAILURE;\n return EXIT_SUCCESS;\n}\n","Rust":"use std::cmp::Reverse;\nuse std::collections::HashMap;\nuse std::fs::File;\nuse std::io::{BufRead, BufReader};\n\nextern crate regex;\nuse regex::Regex;\n\nfn word_count(file: File, n: usize) {\n let word_regex = Regex::new(\"(?i)[a-z']+\").unwrap();\n\n let mut words = HashMap::new();\n for line in BufReader::new(file).lines() {\n word_regex\n .find_iter(&line.expect(\"Read error\"))\n .map(|m| m.as_str())\n .for_each(|word| {\n *words.entry(word.to_lowercase()).or_insert(0) += 1;\n });\n }\n\n let mut words: Vec<_> = words.iter().collect();\n words.sort_unstable_by_key(|&(word, count)| (Reverse(count), word));\n\n for (word, count) in words.iter().take(n) {\n println!(\"{:8} {:>8}\", word, count);\n }\n}\n\nfn main() {\n word_count(File::open(\"135-0.txt\").expect(\"File open error\"), 10)\n}\n"} {"name":"Word wrap","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <ctype.h>\n\n\nconst char *string = \"In olden times when wishing still helped one, there lived a king \"\n \"whose daughters were all beautiful, but the youngest was so beautiful \"\n \"that the sun itself, which has seen so much, was astonished whenever \"\n \"it shone-in-her-face. Close-by-the-king's castle lay a great dark \"\n \"forest, and under an old lime-tree in the forest was a well, and when \"\n \"the day was very warm, the king's child went out into the forest and \"\n \"sat down by the side of the cool-fountain, and when she was bored she \"\n \"took a golden ball, and threw it up on high and caught it, and this \"\n \"ball was her favorite plaything.\";\n\n\n\n#define PENALTY_LONG 100\n#define PENALTY_SHORT 1\n\ntypedef struct word_t {\n const char *s;\n int len;\n} *word;\n\nword make_word_list(const char *s, int *n)\n{\n int max_n = 0;\n word words = 0;\n\n *n = 0;\n while (1) {\n while (*s && isspace(*s)) s++;\n if (!*s) break;\n\n if (*n >= max_n) {\n if (!(max_n *= 2)) max_n = 2;\n words = realloc(words, max_n * sizeof(*words));\n }\n words[*n].s = s;\n while (*s && !isspace(*s)) s++;\n words[*n].len = s - words[*n].s;\n (*n) ++;\n }\n\n return words;\n}\n\nint greedy_wrap(word words, int count, int cols, int *breaks)\n{\n int score = 0, line, i, j, d;\n\n i = j = line = 0;\n while (1) {\n if (i == count) {\n breaks[j++] = i;\n break;\n }\n\n if (!line) {\n line = words[i++].len;\n continue;\n }\n\n if (line + words[i].len < cols) {\n line += words[i++].len + 1;\n continue;\n }\n\n breaks[j++] = i;\n if (i < count) {\n d = cols - line;\n if (d > 0) score += PENALTY_SHORT * d * d;\n else if (d < 0) score += PENALTY_LONG * d * d;\n }\n\n line = 0;\n }\n breaks[j++] = 0;\n\n return score;\n}\n\n\nint balanced_wrap(word words, int count, int cols, int *breaks)\n{\n int *best = malloc(sizeof(int) * (count + 1));\n\n \n int best_score = greedy_wrap(words, count, cols, breaks);\n\n void test_wrap(int line_no, int start, int score) {\n int line = 0, current_score = -1, d;\n\n while (start <= count) {\n if (line) line ++;\n line += words[start++].len;\n d = cols - line;\n if (start < count || d < 0) {\n if (d > 0)\n current_score = score + PENALTY_SHORT * d * d;\n else\n current_score = score + PENALTY_LONG * d * d;\n } else {\n current_score = score;\n }\n\n if (current_score >= best_score) {\n if (d <= 0) return;\n continue;\n }\n\n best[line_no] = start;\n test_wrap(line_no + 1, start, current_score);\n }\n if (current_score >= 0 && current_score < best_score) {\n best_score = current_score;\n memcpy(breaks, best, sizeof(int) * (line_no));\n }\n }\n test_wrap(0, 0, 0);\n free(best);\n\n return best_score;\n}\n\nvoid show_wrap(word list, int count, int *breaks)\n{\n int i, j;\n for (i = j = 0; i < count && breaks[i]; i++) {\n while (j < breaks[i]) {\n printf(\"%.*s\", list[j].len, list[j].s);\n if (j < breaks[i] - 1)\n putchar(' ');\n j++;\n }\n if (breaks[i]) putchar('\\n');\n }\n}\n\nint main(void)\n{\n int len, score, cols;\n word list = make_word_list(string, &len);\n int *breaks = malloc(sizeof(int) * (len + 1));\n\n cols = 80;\n score = greedy_wrap(list, len, cols, breaks);\n printf(\"\\n== greedy wrap at %d (score %d) ==\\n\\n\", cols, score);\n show_wrap(list, len, breaks);\n\n score = balanced_wrap(list, len, cols, breaks);\n printf(\"\\n== balanced wrap at %d (score %d) ==\\n\\n\", cols, score);\n show_wrap(list, len, breaks);\n\n\n cols = 32;\n score = greedy_wrap(list, len, cols, breaks);\n printf(\"\\n== greedy wrap at %d (score %d) ==\\n\\n\", cols, score);\n show_wrap(list, len, breaks);\n\n score = balanced_wrap(list, len, cols, breaks);\n printf(\"\\n== balanced wrap at %d (score %d) ==\\n\\n\", cols, score);\n show_wrap(list, len, breaks);\n\n return 0;\n}\n","Rust":"#[derive(Clone, Debug)]\npub struct LineComposer<I> {\n words: I,\n width: usize,\n current: Option<String>,\n}\n\nimpl<I> LineComposer<I> {\n pub(crate) fn new<S>(words: I, width: usize) -> Self\n where\n I: Iterator<Item = S>,\n S: AsRef<str>,\n {\n LineComposer {\n words,\n width,\n current: None,\n }\n }\n}\n\nimpl<I, S> Iterator for LineComposer<I>\nwhere\n I: Iterator<Item = S>,\n S: AsRef<str>,\n{\n type Item = String;\n\n fn next(&mut self) -> Option<Self::Item> {\n let mut next = match self.words.next() {\n None => return self.current.take(),\n Some(value) => value,\n };\n\n let mut current = self.current.take().unwrap_or_else(String::new);\n\n loop {\n let word = next.as_ref();\n if self.width <= current.len() + word.len() {\n self.current = Some(String::from(word));\n \n \n if !current.is_empty() {\n return Some(current);\n }\n }\n\n if !current.is_empty() {\n current.push_str(\" \")\n }\n\n current.push_str(word);\n\n match self.words.next() {\n None => return Some(current), \n Some(word) => next = word,\n }\n }\n }\n}\n\n\n\npub trait ComposeLines: Iterator {\n fn compose_lines(self, width: usize) -> LineComposer<Self>\n where\n Self: Sized,\n Self::Item: AsRef<str>,\n {\n LineComposer::new(self, width)\n }\n}\n\nimpl<T, S> ComposeLines for T\nwhere\n T: Iterator<Item = S>,\n S: AsRef<str>,\n{\n}\n\nfn main() {\n let text = r\"\n In olden times when wishing still helped one, there lived a king whose\n daughters were all beautiful, but the youngest was so beautiful that the\n sun itself, which has seen so much, was astonished whenever it shone in\n her face. Close by the king's castle lay a great dark forest, and under\n an old lime tree in the forest was a well, and when the day was very\n warm, the king's child went out into the forest and sat down by the side\n of the cool fountain, and when she was bored she took a golden ball, and\n threw it up on high and caught it, and this ball was her favorite\n plaything.\";\n\n text.split_whitespace()\n .compose_lines(80)\n .for_each(|line| println!(\"{}\", line));\n}\n"} {"name":"Write entire file","C":"\n#define _CRT_SECURE_NO_WARNINGS \n#include <stdio.h>\n\nint main(void)\n{\n return 0 >= fputs(\"ANY STRING TO WRITE TO A FILE AT ONCE.\", \n freopen(\"sample.txt\",\"wb\",stdout));\n}\n","Rust":"use std::fs::File;\nuse std::io::Write;\n\nfn main() -> std::io::Result<()> {\n let data = \"Sample text.\";\n let mut file = File::create(\"filename.txt\")?;\n write!(file, \"{}\", data)?;\n Ok(())\n}\n"} {"name":"Write language name in 3D ASCII","C":"#include <stdio.h>\nconst char*s = \" _____\\n \/____\/\\\\\\n\/ ___\\\\\/\\n\\\\ \\\\\/__\/\\n \\\\____\/\";\nint main(){ puts(s); return 0; }\n","Rust":"pub fn char_from_id(id: u8) -> char {\n [' ', '#', '\/', '_', 'L', '|', '\\n'][id as usize]\n}\n\nconst ID_BITS: u8 = 3;\n\npub fn decode(code: &[u8]) -> String {\n let mut ret = String::new();\n let mut carry = 0;\n let mut carry_bits = 0;\n for &b in code {\n let mut bit_pos = ID_BITS - carry_bits;\n let mut cur = b >> bit_pos;\n let mask = (1 << bit_pos) - 1;\n let id = carry | (b & mask) << carry_bits;\n ret.push(char_from_id(id));\n while bit_pos + ID_BITS < 8 {\n ret.push(char_from_id(cur & ((1 << ID_BITS) - 1)));\n cur >>= ID_BITS;\n bit_pos += ID_BITS;\n }\n carry = cur;\n carry_bits = 8 - bit_pos;\n }\n ret\n}\n\nfn main() {\n let code = [\n 72, 146, 36, 0, 0, 0, 0, 0, 0, 0, 128, 196, 74, 182, 41, 1, 0, 0, 0, 0, 0, 0, 160, 196, 77, 0,\n 52, 1, 18, 0, 9, 144, 36, 9, 146, 36, 113, 147, 36, 9, 160, 4, 80, 130, 100, 155, 160, 41, 145,\n 155, 108, 74, 128, 38, 64, 19, 41, 73, 2, 160, 137, 155, 0, 84, 130, 38, 64, 19, 112, 155, 18,\n 160, 137, 155, 0, 160, 18, 42, 73, 18, 36, 73, 2, 128, 74, 76, 1, 0, 40, 128, 219, 38, 104, 219,\n 4, 0, 160, 0\n ];\n\n println!(\"{}\", decode(&code));\n}\n"} {"name":"XML_Input","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <libxml\/parser.h>\n#include <libxml\/tree.h>\n\nstatic void print_names(xmlNode *node)\n{\n xmlNode *cur_node = NULL;\n for (cur_node = node; cur_node; cur_node = cur_node->next) {\n if (cur_node->type == XML_ELEMENT_NODE) {\n if ( strcmp(cur_node->name, \"Student\") == 0 ) {\n\txmlAttr *prop = NULL;\n\tif ( (prop = xmlHasProp(cur_node, \"Name\")) != NULL ) {\n\t printf(\"%s\\n\", prop->children->content);\n\t \n\t}\n }\n }\n print_names(cur_node->children);\n }\n}\n\nconst char *buffer =\n \"<Students>\\n\"\n \" <Student Name=\\\"April\\\" Gender=\\\"F\\\" DateOfBirth=\\\"1989-01-02\\\" \/>\\n\"\n \" <Student Name=\\\"Bob\\\" Gender=\\\"M\\\" DateOfBirth=\\\"1990-03-04\\\" \/>\\n\"\n \" <Student Name=\\\"Chad\\\" Gender=\\\"M\\\" DateOfBirth=\\\"1991-05-06\\\" \/>\\n\"\n \" <Student Name=\\\"Dave\\\" Gender=\\\"M\\\" DateOfBirth=\\\"1992-07-08\\\">\\n\"\n \" <Pet Type=\\\"dog\\\" Name=\\\"Rover\\\" \/>\\n\"\n \" <\/Student>\\n\"\n \" <Student DateOfBirth=\\\"1993-09-10\\\" Gender=\\\"F\\\" Name=\\\"Émily\\\" \/>\\n\"\n \"<\/Students>\\n\";\n\nint main()\n{\n xmlDoc *doc = NULL;\n xmlNode *root = NULL;\n\n doc = xmlReadMemory(buffer, strlen(buffer), NULL, NULL, 0);\n if ( doc != NULL ) {\n root = xmlDocGetRootElement(doc);\n print_names(root);\n xmlFreeDoc(doc);\n }\n xmlCleanupParser();\n return 0;\n}\n","Rust":"extern crate xml; \nuse xml::{name::OwnedName, reader::EventReader, reader::XmlEvent};\n\nconst DOCUMENT: &str = r#\"\n<Students>\n <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" \/>\n <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" \/>\n <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" \/>\n <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n <Pet Type=\"dog\" Name=\"Rover\" \/>\n <\/Student>\n <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" \/>\n<\/Students>\n\"#;\n\nfn main() -> Result<(), xml::reader::Error> {\n let parser = EventReader::new(DOCUMENT.as_bytes());\n\n let tag_name = OwnedName::local(\"Student\");\n let attribute_name = OwnedName::local(\"Name\");\n\n for event in parser {\n match event? {\n XmlEvent::StartElement {\n name,\n attributes,\n ..\n } if name == tag_name => {\n if let Some(attribute) = attributes.iter().find(|&attr| attr.name == attribute_name) {\n println!(\"{}\", attribute.value);\n }\n }\n _ => (),\n }\n }\n Ok(())\n}\n"} {"name":"XML_Output","C":"#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <libxml\/parser.h>\n#include <libxml\/tree.h>\n\nconst char *names[] = {\n \"April\", \"Tam O'Shanter\", \"Emily\", NULL\n};\nconst char *remarks[] = {\n \"Bubbly: I'm > Tam and <= Emily\",\n \"Burns: \\\"When chapman billies leave the street ...\\\"\",\n \"Short & shrift\", NULL\n};\n\nint main()\n{\n xmlDoc *doc = NULL;\n xmlNode *root = NULL, *node;\n const char **next;\n int a;\n\n doc = xmlNewDoc(\"1.0\");\n root = xmlNewNode(NULL, \"CharacterRemarks\");\n xmlDocSetRootElement(doc, root);\n\n for(next = names, a = 0; *next != NULL; next++, a++) {\n node = xmlNewNode(NULL, \"Character\");\n (void)xmlNewProp(node, \"name\", *next);\n xmlAddChild(node, xmlNewText(remarks[a]));\n xmlAddChild(root, node);\n }\n\n xmlElemDump(stdout, doc, root);\n\n xmlFreeDoc(doc);\n xmlCleanupParser();\n \n return EXIT_SUCCESS;\n}\n","Rust":"extern crate xml;\n\nuse std::collections::HashMap;\nuse std::str;\n\nuse xml::writer::{EmitterConfig, XmlEvent};\n\nfn characters_to_xml(characters: HashMap<String, String>) -> String {\n let mut output: Vec<u8> = Vec::new();\n let mut writer = EmitterConfig::new()\n .perform_indent(true)\n .create_writer(&mut output);\n\n writer\n .write(XmlEvent::start_element(\"CharacterRemarks\"))\n .unwrap();\n\n for (character, line) in &characters {\n let element = XmlEvent::start_element(\"Character\").attr(\"name\", character);\n writer.write(element).unwrap();\n writer.write(XmlEvent::characters(line)).unwrap();\n writer.write(XmlEvent::end_element()).unwrap();\n }\n\n writer.write(XmlEvent::end_element()).unwrap();\n str::from_utf8(&output).unwrap().to_string()\n}\n\n#[cfg(test)]\nmod tests {\n use super::characters_to_xml;\n use std::collections::HashMap;\n\n #[test]\n fn test_xml_output() {\n let mut input = HashMap::new();\n input.insert(\n \"April\".to_string(),\n \"Bubbly: I'm > Tam and <= Emily\".to_string(),\n );\n input.insert(\n \"Tam O'Shanter\".to_string(),\n \"Burns: \\\"When chapman billies leave the street ...\\\"\".to_string(),\n );\n input.insert(\"Emily\".to_string(), \"Short & shrift\".to_string());\n\n let output = characters_to_xml(input);\n\n println!(\"{}\", output);\n assert!(output.contains(\n \"<Character name=\\\"Tam O'Shanter\\\">Burns: \\\"When chapman \\\n billies leave the street ...\\\"<\/Character>\"\n ));\n assert!(output\n .contains(\"<Character name=\\\"April\\\">Bubbly: I'm > Tam and <= Emily<\/Character>\"));\n assert!(output.contains(\"<Character name=\\\"Emily\\\">Short & shrift<\/Character>\"));\n }\n}\n"} {"name":"Yin and yang","C":"#include <stdio.h>\n\nvoid draw_yinyang(int trans, double scale)\n{\n\tprintf(\"<use xlink:href='#y' transform='translate(%d,%d) scale(%g)'\/>\",\n\t\ttrans, trans, scale);\n}\n\nint main()\n{\tprintf(\n\t\"<?xml version='1.0' encoding='UTF-8' standalone='no'?>\\n\"\n\t\"<!DOCTYPE svg PUBLIC '-\n\t\"\t'http:\n\t\"<svg xmlns='http:\n\t\"\txmlns:xlink='http:\n\t\"\t\twidth='30' height='30'>\\n\"\n\t\"\t<defs><g id='y'>\\n\"\n\t\"\t\t<circle cx='0' cy='0' r='200' stroke='black'\\n\"\n\t\"\t\t\tfill='white' stroke-width='1'\/>\\n\"\n\t\"\t\t<path d='M0 -200 A 200 200 0 0 0 0 200\\n\"\n\t\"\t\t\t100 100 0 0 0 0 0 100 100 0 0 1 0 -200\\n\"\n\t\"\t\t\tz' fill='black'\/>\\n\"\n\t\"\t\t<circle cx='0' cy='100' r='33' fill='white'\/>\\n\"\n\t\"\t\t<circle cx='0' cy='-100' r='33' fill='black'\/>\\n\"\n\t\"\t<\/g><\/defs>\\n\");\n\tdraw_yinyang(20, .05);\n\tdraw_yinyang(8, .02);\n\tprintf(\"<\/svg>\");\n\treturn 0;\n}\n","Rust":"use svg::node::element::Path;\n\nfn main() {\n let doc = svg::Document::new()\n .add(yin_yang(15.0, 1.0).set(\"transform\", \"translate(20,20)\"))\n .add(yin_yang(6.0, 1.0).set(\"transform\", \"translate(50,11)\"));\n svg::save(\"yin_yang.svg\", &doc).unwrap();\n}\n\nfn yin_yang(r: f32, th: f32) -> Path {\n let (cr, cw, ccw) = (\",0,1,1,.1,0z\", \",0,0,1,0,\", \",0,0,0,0,\");\n let d = format!(\"M0,{0} a{0},{0}{cr} M0,{1} \", r + th, -r \/ 3.0) \n + &format!(\"a{0},{0}{cr} m0,{r} a{0},{0}{cr} M0,0 \", r \/ 6.0) \n + &format!(\"A{0},{0}{ccw}{r} A{r},{r}{cw}-{r} A{0},{0}{cw}0\", r \/ 2.0); \n Path::new().set(\"d\", d).set(\"fill-rule\", \"evenodd\")\n}\n"} {"name":"Zero to the zero power","C":"#include <stdio.h>\n#include <math.h>\n#include <complex.h>\n\nint main()\n{\n\tprintf(\"0 ^ 0 = %f\\n\", pow(0,0));\n double complex c = cpow(0,0);\n\tprintf(\"0+0i ^ 0+0i = %f+%fi\\n\", creal(c), cimag(c));\n\treturn 0;\n}\n","Rust":"fn main() {\n println!(\"{}\",0u32.pow(0));\n}\n"} {"name":"Zig-zag matrix","C":"#include <stdio.h>\n#include <stdlib.h>\n \nint main(int c, char **v)\n{\n\tint i, j, m, n, *s;\n \n\t\n\tif (c < 2 || ((m = atoi(v[1]))) <= 0) m = 5;\n \n\t\n\ts = malloc(sizeof(int) * m * m);\n \n\tfor (i = n = 0; i < m * 2; i++)\n\t\tfor (j = (i < m) ? 0 : i-m+1; j <= i && j < m; j++)\n\t\t\ts[(i&1)? j*(m-1)+i : (i-j)*m+j ] = n++;\n \n\tfor (i = 0; i < m * m; putchar((++i % m) ? ' ':'\\n'))\n\t\tprintf(\"%3d\", s[i]);\n\n\t\n\treturn 0;\n}\n","Rust":"use std::cmp::Ordering;\nuse std::cmp::Ordering::{Equal, Greater, Less};\nuse std::iter::repeat;\n\n#[derive(Debug, PartialEq, Eq)]\nstruct SortIndex {\n x: usize,\n y: usize,\n}\n\nimpl SortIndex {\n fn new(x: usize, y: usize) -> SortIndex {\n SortIndex { x, y }\n }\n}\n\nimpl PartialOrd for SortIndex {\n fn partial_cmp(&self, other: &SortIndex) -> Option<Ordering> {\n Some(self.cmp(other))\n }\n}\n\nimpl Ord for SortIndex {\n fn cmp(&self, other: &SortIndex) -> Ordering {\n let lower = if self.x + self.y == other.x + other.y {\n if (self.x + self.y) % 2 == 0 {\n self.x < other.x\n } else {\n self.y < other.y\n }\n } else {\n (self.x + self.y) < (other.x + other.y)\n };\n\n if lower {\n Less\n } else if self == other {\n Equal\n } else {\n Greater\n }\n }\n}\n\nfn zigzag(n: usize) -> Vec<Vec<usize>> {\n let mut l: Vec<SortIndex> = (0..n * n).map(|i| SortIndex::new(i % n, i \/ n)).collect();\n l.sort();\n\n let init_vec = vec![0; n];\n let mut result: Vec<Vec<usize>> = repeat(init_vec).take(n).collect();\n for (i, &SortIndex { x, y }) in l.iter().enumerate() {\n result[y][x] = i\n }\n result\n}\n\nfn main() {\n println!(\"{:?}\", zigzag(5));\n}\n"}