mcmillhj

fun inverse_captcha_2 input = let
  val digits = List.map (fn c => (Char.ord c) - 48) (explode input)

  fun halve [] = ([], [])
    | halve xs = let
        val length = (List.length xs) div 2
        val firstHalf = List.take(xs, length)
        val secondHalf = List.drop(xs, length)
      in
        (xs, secondHalf @ firstHalf)

mcmillhj

module Accumulate

export
accumulate : (a -> b) -> List a -> List b
accumulate f [] = []
accumulate f (x::xs) = f x :: accumulate f xs

mcmillhj

(* foldl type
   fn: ('a * 'b -> 'b) -> 'b -> 'a list -> 'b
*)

fun fromBase base = let
  fun f (x, NONE  ) = NONE
    | f (x, SOME n) =
      if x >= 0 andalso x < base then SOME(n * base + x)
      else NONE
in

mcmillhj

fun run_tests _ [] = []
  | run_tests f (x :: xs) =
      let
        fun aux { description, is_correct } =
          let
            val expl = description ^ ": " ^
              (if is_correct then "PASSED" else "FAILED") ^ "\n"
          in
            (print (expl); is_correct)
          end

mcmillhj

(* fn: ('a -> 'b) -> 'a list -> 'b list *)
fun accumulate  _ []     = []
  | accumulate f (x::xs) = f x :: accumulate f xs
  
(* fn: ('a -> 'b) * 'a -> 'b list *)
fun accumulate (f: ('a -> 'b), xs: 'a list): 'b list =
  raise Fail "'accumulate' has not been implemented"

mcmillhj

#!/usr/bin/perl                                                                 

use strict;                                                                     
use warnings;                                                                   

exit(0) unless @ARGV;                                                           

open(my $fh, '>>', 'mutlti-top.out') or die "$!";                               
foreach my $server ( @ARGV ) {                                                  
    print {$fh} `ssh ${server} top -bn 1`;                                       

mcmillhj

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;
use English qw(-no_match_vars);
use JSON qw(decode_json);
use LWP::UserAgent;