One logic,
three dialects.

sub sum_to_n {
    my $n = shift;
    return $n * ($n + 1) / 2;      # the closed form beats any loop
}

function s = sum_to_n(n)
  s = n * (n + 1) / 2;             % closed form, constant time
end

sub linear_search {
    my ($a, $target) = @_;         # array ref, value
    for my $i (0 .. $#$a) {        # 0 .. last index
        return $i if $a->[$i] == $target;
    }
    return -1;                     # not found
}

function idx = linear_search(A, target)
  idx = -1;                        % sentinel: not found
  for i = 1:numel(A)               % Octave is 1-based
    if A(i) == target
      idx = i; return;             % first match wins
    end
  end
end

sub binary_search {
    my ($a, $target) = @_;
    my ($lo, $hi) = (0, $#$a);
    while ($lo <= $hi) {
        my $mid = int(($lo + $hi) / 2);
        if    ($a->[$mid] == $target) { return $mid; }
        elsif ($a->[$mid] <  $target) { $lo = $mid + 1; }
        else                          { $hi = $mid - 1; }
    }
    return -1;
}

function idx = binary_search(A, target)
  % PRECONDITION: A is sorted ascending.
  lo = 1; hi = numel(A); idx = -1;
  while lo <= hi
    mid = floor((lo + hi) / 2);
    if A(mid) == target
      idx = mid; return;
    elseif A(mid) < target
      lo = mid + 1;                % answer is to the right
    else
      hi = mid - 1;                % answer is to the left
    end
  end
end

sub insertion_sort {
    my @a = @{ $_[0] };            # copy the array
    for my $i (1 .. $#a) {
        my $key = $a[$i];
        my $j = $i - 1;
        while ($j >= 0 && $a[$j] > $key) {
            $a[$j + 1] = $a[$j];   # shift right
            $j--;
        }
        $a[$j + 1] = $key;
    }
    return \@a;
}

function A = insertion_sort(A)
  for i = 2:numel(A)
    key = A(i); j = i - 1;
    while j >= 1 && A(j) > key
      A(j + 1) = A(j);             % shift larger elements right
      j = j - 1;
    end
    A(j + 1) = key;                % drop key into the gap
  end
end

sub merge_sort {
    my @a = @{ $_[0] };
    return [@a] if @a <= 1;
    my $mid = int(@a / 2);
    my $L = merge_sort([ @a[0 .. $mid - 1] ]);
    my $R = merge_sort([ @a[$mid .. $#a] ]);
    my @out;
    my ($i, $j) = (0, 0);
    while ($i < @$L && $j < @$R) {
        if ($L->[$i] <= $R->[$j]) { push @out, $L->[$i++]; }
        else                      { push @out, $R->[$j++]; }
    }
    push @out, @{$L}[$i .. $#$L] if $i <= $#$L;
    push @out, @{$R}[$j .. $#$R] if $j <= $#$R;
    return \@out;
}

function A = merge_sort(A)
  if numel(A) <= 1, return; end
  mid = floor(numel(A) / 2);
  L = merge_sort(A(1:mid));
  R = merge_sort(A(mid+1:end));
  A = merge(L, R);
end

function out = merge(L, R)
  out = zeros(1, numel(L) + numel(R));
  i = 1; j = 1; k = 1;
  while i <= numel(L) && j <= numel(R)
    if L(i) <= R(j)
      out(k) = L(i); i = i + 1;
    else
      out(k) = R(j); j = j + 1;
    end
    k = k + 1;
  end
  while i <= numel(L), out(k) = L(i); i = i + 1; k = k + 1; end
  while j <= numel(R), out(k) = R(j); j = j + 1; k = k + 1; end
end

sub quick_sort {
    my @a = @{ $_[0] };
    return [@a] if @a <= 1;
    my $pivot = $a[int(@a / 2)];
    my @less = grep { $_ <  $pivot } @a;
    my @eq   = grep { $_ == $pivot } @a;
    my @gre  = grep { $_ >  $pivot } @a;
    return [ @{ quick_sort(\@less) }, @eq, @{ quick_sort(\@gre) } ];
}

function A = quick_sort(A)
  if numel(A) <= 1, return; end
  pivot = A(floor(numel(A) / 2));
  less = A(A <  pivot);            % logical indexing does the partition
  eq   = A(A == pivot);
  gre  = A(A >  pivot);
  A = [quick_sort(less), eq, quick_sort(gre)];
end

my @words = qw(fig ant fig cat ant fig);
my %freq;
$freq{$_}++ for @words;            # autovivify + increment, O(1) expected
print "$freq{fig}\n";              # -> 3

words = {"fig", "ant", "fig", "cat", "ant", "fig"};
freq = containers.Map("KeyType", "char", "ValueType", "double");
for i = 1:numel(words)
  w = words{i};
  if isKey(freq, w)
    freq(w) = freq(w) + 1;
  else
    freq(w) = 1;
  end
end
disp(freq("fig"))                  % -> 3

{
    my %memo;                       # closure: a private cache
    sub fib {
        my $n = shift;
        return $n if $n < 2;
        return $memo{$n} if exists $memo{$n};
        $memo{$n} = fib($n - 1) + fib($n - 2);
        return $memo{$n};
    }
}

function f = fib(n)             % bottom-up tabulation
  if n < 2, f = n; return; end
  t = zeros(1, n + 1);             % t(k) holds fib(k-1)
  t(2) = 1;
  for k = 3:n+1
    t(k) = t(k-1) + t(k-2);
  end
  f = t(n + 1);
end

sub knapsack {
    my ($w, $v, $W) = @_;
    my $n = scalar @$w;
    my @dp;
    for my $i (0 .. $n) { $dp[$i][$_] = 0 for 0 .. $W; }
    for my $i (1 .. $n) {
        for my $cap (0 .. $W) {
            $dp[$i][$cap] = $dp[$i - 1][$cap];   # skip item i
            if ($w->[$i - 1] <= $cap) {          # or take it
                my $take = $dp[$i - 1][$cap - $w->[$i - 1]] + $v->[$i - 1];
                $dp[$i][$cap] = $take if $take > $dp[$i][$cap];
            }
        }
    }
    return $dp[$n][$W];
}

function best = knapsack(weights, values, W)
  n = numel(weights);
  dp = zeros(n + 1, W + 1);        % dp(i+1,c+1): best value, first i items, cap c
  for i = 1:n
    for c = 0:W
      dp(i+1, c+1) = dp(i, c+1);                 % skip item i
      if weights(i) <= c                         % or take it
        take = dp(i, c - weights(i) + 1) + values(i);
        if take > dp(i+1, c+1)
          dp(i+1, c+1) = take;
        end
      end
    end
  end
  best = dp(n + 1, W + 1);
end

sub activity_select {
    my $acts = shift;             # arrayref of [start, finish]
    my @sorted = sort { $a->[1] <=> $b->[1] } @$acts;   # by finish time
    my @chosen;
    my $last = -1e15;
    for my $p (@sorted) {
        my ($s, $f) = @$p;
        if ($s >= $last) {        # compatible with the last pick
            push @chosen, $p;
            $last = $f;
        }
    }
    return \@chosen;
}

function chosen = activity_select(acts)   % acts: rows of [start, finish]
  [~, idx] = sort(acts(:, 2));    % sort by finish time
  acts = acts(idx, :);
  chosen = []; last = -inf;
  for i = 1:rows(acts)
    if acts(i, 1) >= last          % compatible with the last pick
      chosen(end+1, :) = acts(i, :);
      last = acts(i, 2);
    end
  end
end

sub bfs {
    my ($adj, $s) = @_;            # adj: hashref node -> arrayref of neighbors
    my %seen = ($s => 1);
    my @order;
    my @q = ($s);
    while (@q) {
        my $u = shift @q;          # FIFO queue
        push @order, $u;
        for my $v (@{ $adj->{$u} }) {
            unless ($seen{$v}) {
                $seen{$v} = 1;
                push @q, $v;
            }
        }
    }
    return \@order;
}

function order = bfs(adj, s)    % adj: cell array, adj{u} = neighbor vector
  n = numel(adj);
  seen = false(1, n); seen(s) = true;
  queue = [s]; order = [];
  while ~isempty(queue)
    u = queue(1); queue(1) = [];   % dequeue front (FIFO)
    order(end+1) = u;
    for v = adj{u}
      if ~seen(v)
        seen(v) = true;
        queue(end+1) = v;          % enqueue
      end
    end
  end
end

sub dijkstra {
    my ($adj, $s) = @_;           # adj: hashref u -> arrayref of [v, w]
    my %dist = map { $_ => 1e15 } keys %$adj;
    $dist{$s} = 0;
    my %done;
    while (1) {
        my ($u, $best) = (undef, 1e15);
        for my $node (keys %$adj) {           # pick closest unfinished node
            next if $done{$node};
            ($u, $best) = ($node, $dist{$node}) if $dist{$node} < $best;
        }
        last unless defined $u;
        $done{$u} = 1;
        for my $e (@{ $adj->{$u} }) {
            my ($v, $w) = @$e;
            $dist{$v} = $dist{$u} + $w if $dist{$u} + $w < $dist{$v};   # relax
        }
    }
    return \%dist;
}

function dist = dijkstra(adj, s)   % adj{u} = rows of [neighbor, weight]
  n = numel(adj);
  dist = inf(1, n); dist(s) = 0;
  done = false(1, n);
  for it = 1:n
    u = -1; best = inf;
    for k = 1:n                          % pick closest unfinished node
      if ~done(k) && dist(k) < best
        best = dist(k); u = k;
      end
    end
    if u == -1, break; end
    done(u) = true;
    E = adj{u};
    for r = 1:rows(E)
      v = E(r, 1); w = E(r, 2);
      if dist(u) + w < dist(v)           % relax the edge
        dist(v) = dist(u) + w;
      end
    end
  end
end