encode(Source) ->
frompoints(makecolumns(flattenrows(topoints(Source)))).

decode(Source) ->
frompoints(unflattenrows(flattencolumns(topoints(Source)))).

% flattenrows(PointsList)
% flattens a list of two-integer tuples [{X1, Y1}, {X2, Y2} ... ]
% into a list of ints [X1, X2, ... Y1, Y2, ...]
flattenrows(Points) ->
[X || {X,_} <- Points] ++ [Y || {_,Y}
makepoints(lists:split(length(List) div 2, List), []).

% makepoints({IntsList1, IntsList2}, AccumulatorList)
% Helper function for makepoints, that does most of the work
% Joins corresponding items of the two input lists to two-integer
% tuples and ads the result to accumulator list
% at the end the accumulator list is reversed to get the right order
makepoints({[], _}, Acc) -> lists:reverse(Acc);
makepoints({[X | Xlist], [Y | Ylist]}, Acc) ->
makepoints({Xlist, Ylist}, [{X, Y} | Acc]).

% flattencolumns(PointsList)
% flattens a list of two-integer tuples [{X1, Y1}, {X2, Y2} ... ]
% into a list of ints [X1, Y1, X2, Y2, ...]
flattencolumns(List) -> flattencolumns(List, []).
flattencolumns([], Acc) -> lists:reverse(Acc);
flattencolumns([{X, Y} | Tail], Acc) ->
flattencolumns(Tail, [Y | [X | Acc]]). % will be reversed

% makecolumns(IntegersList)
% does the inverse operation of flattencolumns
makecolumns(List) -> makecolumns(List, []).

makecolumns([], Acc) -> lists:reverse(Acc);
makecolumns([X | [Y | Tail]], Acc) ->
makecolumns(Tail, [{X, Y} | Acc]).

% topoints(String, Encoding)
% calculates the two-integer tuple that represents a character
% in the given encoding
topoints(Source, {Key, Period}) ->
[divrem( indexof(Char, Key), Period) || Char
frompoints(Source, Key, Period, []).
frompoints([], _Key, _Period, Accumulator) -> lists:reverse(Accumulator);
frompoints([{X, Y} | Tail], Key, Period, Accumulator) ->
Index = (X-1) * Period + (Y),
Char = lists:nth(Index, Key),
frompoints(Tail, Key, Period, [Char | Accumulator]);
frompoints(Any, _, _, Acc) ->
io:format(“Error: ~p, ~p~n”, [Any, Acc]),
Acc.

% divrem(X, Y)
% function to X div Y and X rem Y and return both as a tuple {Div, Rem}
% both values are offset by 1 for convenience
divrem(X, Y) -> divrem(X, Y, 0).
divrem(X, Y, Acc) when X {Acc+1, X+1};
divrem(X, Y, Acc) -> divrem(X – Y, Y, Acc + 1).

% indexof(List, Item)
% As Erlang has no array data type we have to use linked lists.
% The lists module does not have a function to calculate the index
% of an item so here is my implementation.
indexof(Item, List) -> indexof(Item, List, 0).
indexof(_Item, [], Start) -> Start;
indexof(Item, [Head | Tail], Start) ->
if Item =:= Head -> Start;
true -> indexof(Item, Tail, Start + 1)
end.

% encoding()
% convenience method for testing
encoding() -> {“ABCDEFGHIKLMNOPQRSTUVWXYZ”, 5}.

% topoints(List)
% convenience method for testing
topoints(Source) -> topoints(Source, encoding()).

% frompoints(Source)
% convenience method for testing
frompoints(Source) -> frompoints(Source, encoding()).

In the erlang shell you can then enter:
1> c(bifid).
{ok,bifid}
2> bifid:encode(“PROGRAMMINGPRAXIS”).
“OMQNHHQWUIGBIMWCS”
3> E = bifid:encode(“PROGRAMMINGPRAXIS”).
“OMQNHHQWUIGBIMWCS”
4> bifid:decode(E).
“PROGRAMMINGPRAXIS”

pre=:(]->&9)@-&65@(a.&i.@toupper)
enc=:|:@((%&2@#,2:)$[)@(<.@%&5,5&|)
dec=:((2:,%&2@#)$[)@(<.@%&5,@,.5&|)
pst=:{&a.@(]-<&75)@(5&*@[/+66&+@]/)

encode=:pst@enc@pre
decode=:pst@dec@pre

public class Bifid
{
string[,] KeyMatrix = new string[5,5];

public Bifid()
{
BuildKeyMatrix();
}

private void BuildKeyMatrix()
{
int k = 65;
for(int i = 0; i <5; i++)
{
for(int j = 0; j<5; j++)
{
if(k==74) {k++;} // Dont take j (j ascii = 64)
KeyMatrix[i,j] = ((char)k).ToString();
k++;
}
}
}

public string EncryptDecrypt(string Text, bool Encrypt)
{
int k = 0;
string CharofMessage = string.Empty;
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder();
StringBuilder sbOut = new StringBuilder();
bool HasGotChar = false;

while(k < Text.Length)
{
CharofMessage = Text.Substring(k,1);
for(int i = 0; i <5; i++)
{
for(int j = 0; j<5; j++)
{
if(string.Compare(KeyMatrix[i,j],CharofMessage, true) == 0)
{
sb1.Append(i.ToString());
if(Encrypt)
sb2.Append(j.ToString()); //Use separate string builder for encrypt – ease of coding :-)
else
sb1.Append(j.ToString());
HasGotChar = true;
break;
}
}
if(HasGotChar) // exit the loop if we hit the character
{
HasGotChar = false;
break;
}
}
k++;
}

k = 0;

if(Encrypt)
{
sb1.Append(sb2.ToString()); // combine both
while(k < sb1.Length)
{
sbOut.Append( KeyMatrix[Convert.ToInt32(sb1[k].ToString()),Convert.ToInt32(sb1[k+1].ToString())]);
k += 2;
}
}
else
{
int SplitNum = (sb1.Length) / 2;
while(k < SplitNum)
{
sbOut.Append( KeyMatrix[Convert.ToInt32(sb1[k].ToString()),Convert.ToInt32(sb1[k + SplitNum].ToString())]);
k ++;
}
}

return sbOut.ToString();
}
}

(ns bifid
  (:gen-class))

(defn polybius-square
  "Polybius square by the given charset and size"
  [charset square-size]
  (map #(vector %1 [%2 %3]) charset
    (for [x (range 1 (+ 1 square-size)), y (range 1 (+ 1 square-size))] x)
    (take (count charset) (cycle (range 1 (+ 1 square-size))))))

(defn- letter-2-code
  "Produce a mapping between letters and their codes"
  [square]
  (letfn [(helper [the-square the-map]
          (if (empty? the-square)
            the-map
            (let [the-item (first the-square)
                  the-key (first the-item)
                  the-number (second the-item)]
              (recur (rest the-square) (assoc the-map the-key the-number)))))]
    (helper square (empty hash-map))))

(defn- transposed-2-letter
  "Produce a mapping between the transposed codes to letter"
  [square]
  (letfn [(helper [the-square the-map]
            (if (empty? the-square)
              the-map
              (let [the-item (first the-square)
                    the-key (second the-item)
                    the-letter (first the-item)]
                (recur (rest the-square) (assoc the-map the-key the-letter)))))]
    (helper square (empty hash-map))))

(defn encode
  "Return the message encoded by the specified polybius-square"
  [message polybius-square]
  (let [l2c (letter-2-code polybius-square)
        tr2l (transposed-2-letter polybius-square)]
    (apply str
      (map #(get tr2l % %) (partition 2 (apply interleave (map #(get l2c % %) message)))))))

(defn decode
  "Return the decoded message using the specified polybius-square"
  [encoded polybius-square]
  (let [l2c (letter-2-code polybius-square)
        c2l (transposed-2-letter polybius-square)
        codes (apply concat (map #(get l2c % %) encoded))
        len (count codes)
        parts (partition (/ len 2) codes)]
    (apply str (map #(get c2l %1 %1) (map #(vector %1 %2) (first parts) (second parts))))))

(defn -main
  "A simple test case entry point"
  []
  (let [square (polybius-square "ABCDEFGHIKLMNOPQRSTUVWXYZ" 5)]
    (do
        (println (encode "PROGRAMMINGPRAXIS" square))
        (println (decode "OMQNHHQWUIGBIMWCS" square)))))

http://pastebin.com/f44f6043c

class String
def bifid_encipher
self.gsub!(/[^A-Za-z]/,”)
stringify coordinates.transpose.flatten.each_slice(2)
end

def bifid_decipher
stringify coordinates.flatten.each_slice(self.size).to_a.transpose
end

protected
def coordinates
self.upcase.split(//).inject([]) do |a, char|
polybius_square.each_with_index do |array, i|
a << [i, $_] if $_ = array =~ /#{char}/
end

a
end
end

def stringify(message)
message.map { |k,v| "%c" % polybius_square[k][v] }.to_s
end

def polybius_square
@square ||= (('A'..'Z').to_a – %w(J)).each_slice(5).map { |a| a.join }
end
end

http://vpaste.net/nksKf?

public static string Bifid(string entrada) {
var filas = “1111122222333334444455555″;
var cols = “1234512345123451234512345″;
var alfa = “abcdefghiklmnopqrstuvwxyz”;

entrada = entrada.ToLower();

var arr1 = new char[entrada.Length];
var arr2 = new char[entrada.Length];

for (int i = 0; i < entrada.Length; i++) {
var ind = alfa.IndexOf(entrada[i]);
arr1[i] = filas[ind];
arr2[i] = cols[ind];
}
var arr3 = new char[entrada.Length * 2];
Array.ConstrainedCopy(arr1, 0, arr3, 0, arr1.Length);
Array.ConstrainedCopy(arr2, 0, arr3, arr1.Length, arr2.Length);
var sb = new StringBuilder();
for (int i = 0; i < arr3.Length; i += 2) {
var sf = filas.IndexOf(arr3[i]);
var sc = cols.IndexOf(arr3[i + 1], sf);
sb.Append(alfa[sc]);
}

return sb.ToString();
}

Here’s the code: http://pastie.org/658185