Comparing languages for rollouts

(* Read input from stdin *)
let read_int () = Scanf.scanf "%d" (fun x -> x)
let read_int_list () = Scanf.Scanner.scan_string "%d " >> fun s -> List.map int_of_string (Str.split (Str.regexp " ") s) |> List.filter (fun x -> x <> 0)

(* Main function *)
let rec solve n scores =
  if n = 1 then scores.(n - 1) else
    let sum = List.fold_left (fun acc x -> acc + x) 0 scores in
    let avg = sum / (n - 1) in
    avg +. (solve (n - 1) scores)

(* Read input and print result *)
let () =
  let n = read_int () in
  let scores = read_int_list () in
  let result = solve n scores in
  Printf.printf "%+.0f\n" result

File "Main.ml", line 3, characters 55-57:
3 | let read_int_list () = Scanf.Scanner.scan_string "%d " >> fun s -> List.map int_of_string (Str.split (Str.regexp " ") s) |> List.filter (fun x -> x <> 0)
                                                           ^^
Error: Unbound value (>>)

(* Problem: Move the K-th 1-block from the beginning in S to immediately after the (K-1)-th 1-block *)

(* Read input from standard input *)
let () =
  let _ = Scanf.scanf "%d %d\n" (fun n k -> ()) in
  let s = Scanf.scanf "%s\n" (fun s -> s) () in
  let n = String.length s in

  (* Find all 1-blocks in the string *)
  let rec find_1_blocks i acc =
    if i = n then acc
    else if s.[i] = '1' && (i = 0 || s.[i-1] = '0') then
      find_1_blocks (i + 1) ((i, i) :: acc)
    else find_1_blocks (i + 1) acc
  in

  let blocks = find_1_blocks 0 [] in

  (* Move the K-th 1-block to immediately after the (K-1)-th 1-block *)
  let rec move_block blocks k =
    match blocks with
    | [] -> []
    | _ when k = 1 -> blocks
    | (l1, r1) :: (l2, r2) :: tl ->
       if k = 2 then (l1, r1) :: (l2, r2 + (r2 - l2) + 1) :: tl
       else (l1, r1) :: move_block ((l2, r2) :: tl) (k - 1)
  in

  let new_blocks = move_block blocks 3 in

  (* Create the resulting string *)
  let rec create_string i acc =
    match new_blocks with
    | [] -> acc
    | (l, r) :: tl ->
       let len = r - l + 1 in
       let prefix = String.sub s 0 l in
       let block = String.make len '1' in
       let suffix = String.sub s (l + len) (n - l - len) in
       create_string (l + len) (prefix ^ block ^ suffix ^ acc)
  in

  let result = create_string 0 "" in
  Printf.printf "%s\n" result

File "Main.ml", line 6, characters 39-40:
6 |   let s = Scanf.scanf "%s\n" (fun s -> s) () in
                                           ^
Error: The value s has type string but an expression was expected of type

(* Problem: Given two lists of integers P and Q of length N, 
   find the number written on the bib of the person that the person wearing 
   the bib with number i is staring at. *)
(* Input: N, P, Q *)
(* Output: S where S_i is the number written on the bib of the person 
   that the person wearing the bib with number i is staring at. *)

(* Read input from standard input *)
let read_int () = Scanf.scanf "%d" (fun x -> x)
let read_int_list n = List.init n read_int
let () = Scanf scanf "%d" read_int_list
let n = read_int ()
let p = read_int_list n
let q = read_int_list n

(* Create a list of pairs (i, P_i) *)
let p_list = List.mapi (fun i x -> (x, i)) p

(* Create a map from P_i to i *)
let p_map = List.fold_left (fun acc (x, i) -> Map.put acc x i) Map.empty p_list

(* Create a list of S_i *)
let s = List.map (fun x -> Map.find x (p_map)) q

(* Print the list of S_i *)
let () = List.iter (fun x -> Printf.printf "%d " x) s; 
        Printf.printf "\n"

File "Main.ml", line 11, characters 21-25:
11 | let () = Scanf scanf "%d" read_int_list
                          ^^^^
Error: Syntax error

(* Problem: Find the maximum length of a strictly increasing subsequence of a given sequence
   with elements at most X_i, for Q queries. *)

(* Read input from standard input *)
let () =
  let n, q = Scanf.scanf "%d %d\n" (fun n q -> n, q) in
  let a = Array.init n (fun _ -> Scanf.scanf "%d" (fun x -> x)) in
  let queries = Array.init q (fun _ ->
      let r, x = Scanf.scanf "%d %d\n" (fun r x -> r, x) in
      r - 1, x
    ) in

  (* Process queries *)
  let results = Array.init q (fun i ->
      let r, x = queries.(i) in
      let rec find_max_length r x acc =
        if r < 0 then acc
        else
          let ai = a.(r) in
          if ai > x then find_max_length (r - 1) x acc
          else
            let new_acc = if ai <= acc then acc + 1 else acc in
            find_max_length (r - 1) x new_acc
      in
      find_max_length r x 0
    ) in

  (* Print results *)
  List.iter (fun x -> Printf.printf "%d\n" x) (Array.to_list results)

Fatal error: exception Stdlib.Scanf.Scan_failure("scanf: bad input at char number 5: character ' ' is not a decimal digit")

(* Problem: Check if two strings are equal, if not print the position of the first difference *)
(* Input: Two strings S and T *)
(* Output: If S and T are equal, print 0; otherwise, print the position of the first character where they differ *)

(* Read two strings from the input *)
let () =
  let s = read_line () in
  let t = read_line () in

  (* Compare the strings *)
  let rec compare_strings s t pos =
    if pos > min (String.length s) (String.length t) then
      (* If one string is a prefix of the other, print the position of the first differing character *)
      if String.length s < String.length t then
        Printf.printf "%d\n" (String.length s + 1)
      else if String.length s > String.length t then
        Printf.printf "%d\n" (String.length t + 1)
      else
        Printf.printf "0\n"
    else if s.[pos] <> t.[pos] then
      (* If the characters at the current position are different, print the position *)
      Printf.printf "%d\n" (pos + 1)
    else
      (* If the characters are the same, continue comparing the rest of the strings *)
      compare_strings s t (pos + 1)
  in

  (* Start comparing the strings from the first position *)
  compare_strings s t 0

Fatal error: exception Invalid_argument("index out of bounds")

(* This program prints all triples of non-negative integers (x,y,z) such that x+y+z <= N in ascending lexicographical order. *)

(* Read an integer from standard input *)
let read_int () =
  Scanf.scanf "%d" (fun n -> n)

(* Generate all triples (x, y, z) such that x + y + z <= N *)
let generate_triples n =
  let rec generate x y =
    if x + y > n then []
    else
      (x, y, n - x - y) :: generate x (y + 1) @ generate (x + 1) y
  in
  generate 0 0

(* Print the triples in ascending lexicographical order *)
let print_triples triples =
  List.iter (fun (x, y, z) ->
    Printf.printf "%d %d %d\n" x y z)
    triples

(* Main function *)
let () =
  let n = read_int () in
  let triples = generate_triples n in
  print_triples triples

(* Problem: Takahashi's Ticket Gate Records *)
(* Author: [Your Name] *)
(* Date: [Today's Date] *)

(* Function to calculate the minimum number of characters to be inserted *)
let rec min_insertions s =
  let rec loop i count =
    if i >= String.length s then
      count
    else if i mod 2 = 0 then
      (* If the current character is at an even position, check the next character *)
      if i + 1 < String.length s && s.[i] = 'o' && s.[i + 1] = 'i' then
        loop (i + 2) count
      else
        loop (i + 1) (count + 1)
    else
      (* If the current character is at an odd position, check the previous character *)
      if i - 1 >= 0 && s.[i] = 'i' && s.[i - 1] = 'o' then
        loop (i - 2) count
      else
        loop (i - 1) (count + 1)
  in
  loop 0 0

(* Main function *)
let () =
  (* Read the input string from standard input *)
  let s = Scanf.scanf "%s" (fun s -> s) in
  (* Calculate and print the minimum number of characters to be inserted *)
  Printf.printf "%d\n" (min_insertions s)

[<class 'subprocess.TimeoutExpired'>][Command '['/scratch/tmp.5294624.skiegeland/tmpj7pwtd53/Main.exe']' timed out after 8 seconds]

empty or unparsed code