Find columns where all characters are the same I came across this question on SO and thought it'd make a nice golf challenge.  So here it is:

Challenge:

Write a program that reads a sequence of character strings, one per line, and outputs a list of all positions where each string has the same character.

Input and output:

The input consists of one or more lines of printable non-whitespace ASCII characters, each followed by a newline.  You may assume that all input lines have the same length.  The newline is not to be considered part of the input (i.e. you should not output it as a matching character).

Example input (shamelessly stolen from the SO question):

abcdefg
avcddeg
acbdeeg


After reading the input, your program should print the positions of each matching column and the characters they contain.  (Your program may, but need not, stop reading further input if it can determine early that there are no matching columns.)  Any reasonable output format is permitted; in particular, you may use either 0-based or 1-based indexing for the positions.

Example output for the above input (using 0-based indexing):

0: a
3: d
6: g


Scoring:

This is code golf, so shortest answer wins.  In the event of a tie, fractional tie-breaker chars may be awarded for additional features:


&minus;&frac12; chars for correctly handling input lines of unequal length.  (Output should not contain positions past the end of the shortest input line.)
&minus;&frac14; chars for correctly handling input consisting of arbitrary UTF-8 encoded Unicode characters.


For inspiration, you may find some ungolfed solutions at the SO question (see above).

Clarifications:


Simply concatenating the positions and characters, as in 0a3d6g, does not count as "reasonable output".  You should provide some kind of separator (such as a space) between each element of the output so that it can be parsed unambiguously.
The input will be provided on the standard input stream (stdin), or using whatever text file input mechanism is most natural to your language of choice.  (If your chosen language doesn't have a natural mechanism for file input, do whatever seems closest in spirit.)
The input ends when there is no more data to be read (i.e. when an end-of-file condition occurs).  If you wish, you may require that the input be terminated by a blank line (which you then should not count as part of the input, obviously).  If you do so, please mention it in your answer so that others can provide correct input for testing.
Every input line, including the last one, ends with a newline character.  Your answer must not report this newline as a matching column.  (It's fine if your solution can also handle input where the last line doesn't end in a newline, but that's not required.)
APL, 25 characters

∩/{0=⍴⍵:⍬⋄(⊂⍵,⍨¨⍳⍴⍵),∇⍞}⍞


I used Dyalog APL (version 13) as my interpreter. It handles both inputs of unequal length and Unicode (UTF-8) characters.

Examples:

      ∩/{0=⍴⍵:⍬⋄(⊂⍵,⍨¨⍳⍴⍵),∇⍞}⍞
abcdefg
avcddeg
acbdeeg

  1 a  4 d  7 g  

      ∩/{0=⍴⍵:⍬⋄(⊂⍵,⍨¨⍳⍴⍵),∇⍞}⍞
test日本
blat日本国foo

  4 t  5 日  6 本 


Explanation, somewhat from right to left:


The main chunk of this answer is the direct function (basically, anonymous function), defined within the curly braces. Its right argument is specified by ⍵.

0=⍴⍵:⍬ is our first expression, and it checks if we've gotten an empty line (i.e., we are done). It uses a guard (a familiar construct to many functional programmers) to conditionally execute the expression to the right of the colon. In this case, if 0 is equal to the shape/length (⍴) of the right argument, we return the empty set (⍬).
⋄ separates the two expressions within the function. If the previous expression didn't get evaluated (and thus didn't return anything), we move to the next expression.
We recursively call the function using the self-reference function (∇). The argument to the function is a line of non-evaluated user input, given by quote-quad (⍞).
⊂⍵,⍨¨⍳⍴⍵ creates pairs for each character in the string, where each pair's first element is its position in the string, and its second element is the character.
⍳⍴⍵ gives a vector from 1 to ⍴⍵, or the length of the input string.
⍵,⍨¨ applies the commuted concatenation function (,⍨) to each (¨) element to its left (⍵, in this case the user's input) and right. Commuting the concatenation function causes its left and right arguments to be swapped.
Finally, we enclose the result using ⊂, so that we can differentiate between lines of input.

We initially feed our function with user input (⍞).
Finally, we reduce (/) our resulting vector of vectors of pairs using the intersection function (∩), yielding the pairs that are found in all of the sub-vectors.