• Python

a, b = zip(*sorted(zip(a, b)))

• Python

temp = list(zip(a, b))
temp.sort(key=operator.itemgetter(0))
a, b = zip(*work)

• Clojure

(->> (map vector a b)
     (sort-by first)
     (apply (partial mapv vector)))

• Go

type sorter struct {
	k []K
	t []T
}

func (s *sorter) Len() int {
	return len(s.k)
}

func (s *sorter) Swap(i, j int) {
	s.k[i], s.k[j] = s.k[j], s.k[i]
	s.t[i], s.t[j] = s.t[j], s.t[i]
}

func (s *sorter) Less(i, j int) bool {
	return s.k[i] < s.k[j]
}

sort.Sort(&sorter{
	k: a,
	t: b,
})

• Haskell

let (outA,outB) = unzip $ sort $ zip a b

• Java

record QuickSort<T extends Comparable<T>>(List<T> a, List<?> b) {
    void sort(int x, int y) {
        if (x >= y || x < 0) return;
        int p = f(x, y);
        sort(x, p - 1);
        sort(p + 1, y);
    }
    int f(int x, int y) {
        T t = a.get(y);
        int i, j = i = x;
        do if (a.get(j).compareTo(t) < 1) {
            swap(a, i, j);
            swap(b, i++, j);
        } while (++j < y);
        swap(a, i, y);
        swap(b, i, y);
        return i;
    }
}

• Pascal

type
  TPairedList = class(TStringList)
  private
    FBuddy: TStrings;
  protected
    procedure ExchangeItems(Id1, Id2: Integer); override;
  public
    procedure Sort(Buddy: TStrings); overload;
  end;

procedure TPairedList.ExchangeItems(Id1, Id2: Integer);
begin
  inherited Exchange(Id1, Id2);
  if Assigned(FBuddy) then
    FBuddy.Exchange(Id1, Id2);
end;

procedure TPairedList.Sort(Buddy: TStrings);
begin
  FBuddy := Buddy;
  Sort;
end;

begin
  ...
  a.sort(b);
end.

• Perl

@keys = qw(x y a f e n);
@vals = qw(1 2 3 4 5 6);

pairmap { push @new_keys, $a; push @new_vals, $b }
    unpairs 
        sort { $a->[0] cmp $b->[0] } 
            zip \@keys, \@vals;

• Ruby

a, b = a.zip(b).sort.transpose

• Rust

let mut tmp: Vec<_> = a.iter().zip(b).collect();
tmp.as_mut_slice().sort_by_key(|(&x, _y)| x);
let (aa, bb): (Vec<i32>, Vec<i32>) = tmp.into_iter().unzip();